Everything you use, connected in one place. Then build whatever you need on top.

import { defineApp, router } from "apps";
import { github } from "./providers";
import { listBriefs, saveBrief, refreshBrief } from "./tools";
import { refresh } from "./workflows";

export const requirements = {
  user: { accounts: { github } },
};

export default defineApp(requirements, {
  tools: router({ listBriefs, saveBrief, refreshBrief }),
  workflows: { refresh },
});

import { query, mutation, object, string, number, array } from "apps";
import type { QueryContext, MutationContext } from "apps";
import type { requirements } from "./index";

type Read = QueryContext<typeof requirements>;
type Write = MutationContext<typeof requirements>;

export const Repository = object({ owner: string(), name: string() });
export const BriefInput = object({ repository: string(), openIssues: number() });
export const Brief = object({ id: string(), repository: string(), openIssues: number() });

const columns = "id, repository, open_issues AS openIssues";

export const listBriefs = query(
  { input: object({}), output: array(Brief) },
  async ({ sql }: Read) =>
    sql.exec(`SELECT ${columns} FROM briefs ORDER BY created_at DESC LIMIT 10`).toArray(),
);

export const saveBrief = mutation(
  { input: BriefInput, output: Brief },
  async ({ sql }: Write, input) =>
    sql.transaction((tx) =>
      tx.exec(
        `INSERT INTO briefs (id, repository, open_issues, created_at)
         VALUES (?, ?, ?, ?) RETURNING ${columns}`,
        crypto.randomUUID(),
        input.repository,
        input.openIssues,
        Date.now(),
      ).one(),
    ),
);

export const refreshBrief = mutation(
  { input: Repository },
  async (ctx: Write, input) =>
    ctx.workflows.start({ workflow: "refresh", input }),
);

import { defineProvider, oauth2 } from "apps";

export const github = defineProvider({
  name: "GitHub",
  auth: {
    oauth: oauth2({
      authorizationUrl: "https://github.com/login/oauth/authorize",
      tokenUrl: "https://github.com/login/oauth/access_token",
      scopes: ["repo"],
    }),
  },
});

CREATE TABLE briefs (
  id TEXT PRIMARY KEY NOT NULL,
  repository TEXT NOT NULL,
  open_issues INTEGER NOT NULL,
  created_at INTEGER NOT NULL
);

import { workflow, object, number } from "apps";
import type { WorkflowContext } from "apps";
import type { requirements } from "./index";
import { Repository, saveBrief } from "./tools";

type Context = WorkflowContext<typeof requirements>;
const Stats = object({ open_issues_count: number() });

export const refresh = workflow(
  { input: Repository },
  async (ctx: Context, { owner, name }) => {
    const repository = owner + "/" + name;
    const openIssues = await ctx.step.do("Read GitHub", async (step) => {
      const path = encodeURIComponent(owner) + "/" + encodeURIComponent(name);
      const response = await step.fetch("https://api.github.com/repos/" + path, {
        headers: {
          Authorization: "Bearer " + step.user.accounts.github.fields.access_token,
          "User-Agent": "Daily brief",
        },
      });
      if (!response.ok) throw new Error("Could not read the repository");
      return Stats.parse(await response.json()).open_issues_count;
    });

    return ctx.step.runMutation("Save the brief", saveBrief, {
      repository,
      openIssues,
    });
  },
);

---
name: brief
description: Review recent GitHub activity with Daily brief.
---

# Give me a project brief

1. Ask which repository to review if it is not clear.
2. Use refreshBrief with the repository owner and name.
3. Wait for the workflow to finish, then call listBriefs.
4. Summarize the saved open issue count in plain language.

Mention which repository the brief covers.
If the refresh fails, say so instead of presenting old data as new.

Follow the user's instructions and Executor's approval requests.

import { createRoot } from "react-dom/client";
import { array } from "apps";
import { createAppClient, queryReference } from "apps/client";
import { useAppQuery } from "apps/react";
import { Brief, type listBriefs } from "../tools";

const client = createAppClient();
const briefs = client.queryAtom(
  queryReference<typeof listBriefs>("listBriefs"),
  {},
  array(Brief),
);

function DailyBrief() {
  const { data, pending, error } = useAppQuery(briefs);
  if (pending) return <p>Loading your briefs…</p>;
  if (error) return <p>Could not load your briefs.</p>;

  return (
    <main>
      <h1>Your project briefs</h1>
      {data?.map((brief) => (
        <article key={brief.id}>
          <h2>{brief.repository}</h2>
          <p>{brief.openIssues} open issues</p>
        </article>
      ))}
    </main>
  );
}

const root = document.getElementById("root");
if (!root) throw new Error("Missing app root");
createRoot(root).render(<DailyBrief />);

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Daily brief</title>
    <script type="module" src="./main.tsx"></script>
  </head>
  <body>
    <div id="root"></div>
  </body>
</html>

{
  "name": "daily-brief",
  "private": true,
  "type": "module",
  "dependencies": {
    "react": "^19.2.5",
    "react-dom": "^19.2.5"
  }
}