Built by your agents. Run by Executor.

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

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

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

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

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

export const Repository = object({
  owner: string(),
  name: string(),
});

export const listBriefs = query(
  { input: object({}), output: array(Brief) },
  async ({ db }: Read) =>
    db.briefs.withIndex("by_creation").order("desc").take(10),
);

export const saveBrief = mutation(
  { input: BriefInput, output: Brief },
  async ({ db }: Write, input) => db.briefs.insert(input),
);

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"],
    }),
  },
});

import { defineDatabase, table, object, string, number } from "apps";

const fields = {
  repository: string(),
  openIssues: number(),
};

export const BriefInput = object(fields);
export const Brief = object({ id: string(), ...fields });

export const database = defineDatabase({
  briefs: table(fields),
});

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.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 type { listBriefs } from "../tools";
import { Brief } from "../database";

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"
  }
}