pome-sh 0.6.6

package/dist/src/scenario/seed-compiler.js

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Compile a prose seed description into a JSON seed object matching
+ * `seedStateSchema`. Uses the Anthropic Messages API with structured
+ * output (`output_config` + `zodOutputFormat`).
+ *
+ * See `docs/agents/scenario-prose-seed.md` for the prose convention.
+ *
+ * Why Messages API and not the Agent SDK: this is a pure prose-to-JSON
+ * transform with no tools needed during generation, so the agent loop
+ * adds only cost and variance. The bundled Claude Code system prompt
+ * also pushes per-call cost up ~3-10×.
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import { zodOutputFormat } from "@anthropic-ai/sdk/helpers/zod";
+import { seedStateSchema } from "../twin/github/domain/seed.js";
+export const COMPILER_MODEL = "claude-opus-4-7";
+const SYSTEM_PROMPT = `You convert natural-language descriptions of a GitHub twin's seed state into JSON matching the provided schema.
+
+Rules:
+1. Anything marked "(exact)" or "exact text" or shown inside an inline code block as a value must be copied character-for-character. Do NOT rephrase, normalize whitespace, or fix typos.
+2. For values described semantically (e.g. "GitHub-conventional colors", "a reasonable description"), pick realistic GitHub-style values.
+3. When the prose says "exactly N" or "and no others", do not add extras.
+4. When a field is not mentioned, omit it — schema defaults will fill in.
+5. Do not invent entities not mentioned. If the prose describes one issue, output exactly one issue.
+6. Issue \`number\` is required and must be set (use #N if the prose says so, otherwise start at 1).
+7. PR \`number\` is optional; set it when the prose says "#N".
+8. Issue \`assignee\` is a single string or null — not an array.
+9. Use fenced code blocks in the prose to indicate the exact content of \`files[].content\`. Preserve trailing newlines verbatim.`;
+export async function compileSeed(prose, opts = {}) {
+    if (!process.env.ANTHROPIC_API_KEY) {
+        throw new Error("ANTHROPIC_API_KEY is not set. Export your Anthropic API key before running `pome compile-seeds`.");
+    }
+    const model = opts.model ?? COMPILER_MODEL;
+    const client = new Anthropic();
+    const t0 = Date.now();
+    const response = await client.messages.parse({
+        model,
+        max_tokens: 8192,
+        system: SYSTEM_PROMPT,
+        messages: [{ role: "user", content: prose }],
+        output_config: { format: zodOutputFormat(seedStateSchema) }
+    });
+    const durationMs = Date.now() - t0;
+    if (!response.parsed_output) {
+        throw new Error(`Compiler returned no parsed_output (stop_reason=${response.stop_reason}). ` +
+            `This usually means the model produced output that failed schema validation.`);
+    }
+    // Re-validate locally to be safe — `parse()` already ran the schema, but
+    // running it again here gives us a stable error site for tests + ensures
+    // downstream code holds a `ParsedSeedState`-shaped value, not `unknown`.
+    const seed = seedStateSchema.parse(response.parsed_output);
+    return {
+        seed,
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        model,
+        durationMs
+    };
+}

package/dist/src/scenario/seed-verifier.d.ts

@@ -0,0 +1 @@
+export declare function verifySeedWithTwin(seed: unknown): void;

package/dist/src/scenario/seed-verifier.js

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Layer-3 defense for compile-seeds: boot an in-memory twin and load the
+ * generated seed through its real `GitHubDomain.seed()` path. Catches the
+ * cross-reference and domain-invariant errors that schema validation alone
+ * cannot — e.g. issue.labels referencing a label not in repo.labels, PR head
+ * referencing a branch with no files.
+ *
+ * Throws if the twin rejects the seed; otherwise returns silently.
+ */
+import { GitHubDomain, openGitHubCloneDatabase } from "@pome-sh/twin-github";
+export function verifySeedWithTwin(seed) {
+    // `:memory:` SQLite — torn down when this function returns and `db`
+    // goes out of scope. No filesystem side-effects, no cleanup needed.
+    const db = openGitHubCloneDatabase(":memory:");
+    try {
+        new GitHubDomain(db).seed(seed);
+    }
+    catch (err) {
+        throw new Error(`Seed verification failed: the in-memory twin rejected the compiled seed. ` +
+            `Adjust the prose to fix the underlying problem.\n  ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/src/score/view.d.ts

@@ -0,0 +1,38 @@
+import type { z } from "zod";
+import type { criterionSchema } from "../types/shared.js";
+type WireCriterion = z.infer<typeof criterionSchema>;
+export type CriterionOutcome = "passed" | "failed" | "skipped" | "errored";
+export type CriterionResult = {
+    criterion: WireCriterion;
+    outcome?: CriterionOutcome;
+    passed: boolean;
+    skipped: boolean;
+    reason: string;
+    confidence?: number;
+    judge_model?: string;
+    judge_tokens_in?: number;
+    judge_tokens_out?: number;
+    judge_has_usage?: boolean;
+};
+export type Score = {
+    satisfaction: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    errored: number;
+    total_required: number;
+    evaluated: boolean;
+    can_pass: boolean;
+    results: CriterionResult[];
+    judge_model: string | null;
+    judge_tokens_in: number | null;
+    judge_tokens_out: number | null;
+};
+export declare function outcomeOf(result: CriterionResult): CriterionOutcome;
+export type ScoreStatus = "pass" | "fail" | "unevaluated";
+export declare function scoreStatus(score: Score, passThreshold: number): ScoreStatus;
+export declare function scenarioPassed(score: Score, passThreshold: number): boolean;
+export declare function markerFor(outcome: CriterionOutcome): string;
+export declare function scoreCountsSummary(score: Score): string;
+export declare function runScoreLine(score: Score, passThreshold: number, unevaluatedNumericLabel: string): string;
+export {};

package/dist/src/score/view.js

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Cloud-verdict DISPLAY model + pure label/render helpers (FDRS-656/657).
+//
+// The OSS CLI is CAPTURE-ONLY: it never computes a score, never runs a judge,
+// and never correlates locally. Every helper here operates on a score object
+// that ORIGINATES FROM THE CLOUD (a hosted `pome run` /finalize response, or a
+// `pome eval` upload verdict — see `scoreFromFinalizeResponse`). Nothing in
+// this module derives a verdict from twin state, events, or a judge call.
+//
+// This is the relocation of the former `src/evaluator/score.ts` + the
+// verdict-rendering half of `src/cli/render.ts`. The local scoring engine
+// (`scoreResults`, the deterministic matchers, the BYOK LLM judge) was deleted
+// under FDRS-657; only the pure display model survives, moved out of the
+// `evaluator/` tree so the `no-eval-in-oss` gate can assert that tree is gone.
+// Derive the four-state outcome from a cloud result. Prefers the explicit
+// `outcome` field; falls back to the legacy passed/skipped booleans. PURE.
+export function outcomeOf(result) {
+    if (result.outcome)
+        return result.outcome;
+    if (result.skipped)
+        return "skipped";
+    return result.passed ? "passed" : "failed";
+}
+// Single source of truth for "did this run pass?", applied to a CLOUD score.
+// Encodes the A5 guard: a run is only a PASS when it was evaluated, every
+// required criterion was evaluated (can_pass), AND satisfaction cleared the
+// threshold. PURE — no computation of the score itself.
+export function scoreStatus(score, passThreshold) {
+    if (!score.evaluated || !score.can_pass)
+        return "unevaluated";
+    return score.satisfaction >= passThreshold ? "pass" : "fail";
+}
+export function scenarioPassed(score, passThreshold) {
+    return scoreStatus(score, passThreshold) === "pass";
+}
+// FDRS-591/611 per-criterion marker: ✓ passed, ✗ failed, - skipped, ! errored.
+export function markerFor(outcome) {
+    switch (outcome) {
+        case "passed":
+            return "✓";
+        case "failed":
+            return "✗";
+        case "errored":
+            return "!";
+        default:
+            return "-";
+    }
+}
+export function scoreCountsSummary(score) {
+    return `${score.passed ?? 0} passed, ${score.failed ?? 0} failed, ${score.skipped ?? 0} skipped, ${score.errored ?? 0} errored`;
+}
+export function runScoreLine(score, passThreshold, unevaluatedNumericLabel) {
+    const status = scoreStatus(score, passThreshold);
+    if (status === "unevaluated") {
+        return `score: un-evaluated (cannot pass) — ${scoreCountsSummary(score)}; ${unevaluatedNumericLabel}: ${score.satisfaction}/100`;
+    }
+    return `score: ${score.satisfaction}/100`;
+}

package/dist/src/twin/github/app.d.ts

@@ -0,0 +1,10 @@
+import { Hono } from "hono";
+import type { GitHubTwinDatabase, Recorder, SeedState } from "./types.js";
+type AppOptions = {
+    db?: GitHubTwinDatabase;
+    seed?: SeedState;
+    recorder?: Recorder;
+    runId?: string;
+};
+export declare function createGitHubTwinApp(options?: AppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export {};

package/dist/src/twin/github/app.js

@@ -0,0 +1,316 @@
+// SPDX-License-Identifier: Apache-2.0
+import { Hono } from "hono";
+import { z } from "zod";
+import { createRequestId } from "../../recorder/recorder.js";
+import { openGitHubTwinDatabase } from "./db/openDatabase.js";
+import { addIssueLabel, createComment, createLabel, deleteIssueLabel, exportState, getIssue, getLabel, getRepo, hasCollaborator, listCollaborators, listIssueLabels, listIssues, listLabels, seedDatabase, updateIssue } from "./db/queries.js";
+import { defaultSeedState } from "./domain/seed.js";
+import { collaboratorJson, commentJson, issueJson, labelJson, repoJson } from "./domain/serializers.js";
+const issuePatchSchema = z.object({
+    title: z.string().min(1).optional(),
+    body: z.string().optional(),
+    state: z.enum(["open", "closed"]).optional(),
+    assignee: z.string().nullable().optional(),
+    assignees: z.array(z.string().min(1)).optional()
+});
+const createCommentSchema = z.object({
+    body: z.string().min(1)
+});
+const createLabelSchema = z.object({
+    name: z.string().min(1),
+    color: z.string().default("ededed"),
+    description: z.string().default("")
+});
+const addLabelsSchema = z.object({
+    labels: z.array(z.string().min(1)).min(1)
+});
+const addAssigneesSchema = z.object({
+    assignees: z.array(z.string().min(1)).min(1)
+});
+export function createGitHubTwinApp(options = {}) {
+    const db = options.db ?? openGitHubTwinDatabase();
+    if (!options.db) {
+        seedDatabase(db, options.seed ?? defaultSeedState());
+    }
+    const recorder = options.recorder;
+    const runId = options.runId ?? "local";
+    const app = new Hono();
+    app.get("/_pome/health", (c) => c.json({
+        ok: true,
+        twin: "github",
+        fidelity: "semantic"
+    }));
+    app.get("/_pome/state", (c) => c.json(exportState(db)));
+    app.get("/_pome/events", (c) => c.json(recorder?.events() ?? []));
+    app.get("/repos/:owner/:repo", (c) => {
+        const started = Date.now();
+        const repo = getRepoForRequest(c, db);
+        if (!repo) {
+            return respond(c, recorder, runId, started, null, 404, githubError("Not Found", 404), false);
+        }
+        return respond(c, recorder, runId, started, null, 200, repoJson(repo), false);
+    });
+    app.get("/repos/:owner/:repo/issues", (c) => {
+        const started = Date.now();
+        const repo = getRepoForRequest(c, db);
+        if (!repo) {
+            return respond(c, recorder, runId, started, null, 404, githubError("Not Found", 404), false);
+        }
+        const issues = listIssues(db, repo.id).map((issue) => issueJson(issue, listIssueLabels(db, repo.id, issue.number), repo));
+        return respond(c, recorder, runId, started, null, 200, issues, false);
+    });
+    app.get("/repos/:owner/:repo/issues/:number", (c) => {
+        const started = Date.now();
+        const found = getIssueForRequest(c, db);
+        if (!found.repo) {
+            return respond(c, recorder, runId, started, null, 404, githubError("Not Found", 404), false);
+        }
+        if (!found.issue) {
+            return respond(c, recorder, runId, started, null, 404, githubError("Issue not found", 404), false);
+        }
+        const body = issueJson(found.issue, listIssueLabels(db, found.repo.id, found.issue.number), found.repo);
+        return respond(c, recorder, runId, started, null, 200, body, false);
+    });
+    app.patch("/repos/:owner/:repo/issues/:number", async (c) => {
+        const started = Date.now();
+        const parsed = await parseBody(c, issuePatchSchema);
+        if (!parsed.ok) {
+            return respond(c, recorder, runId, started, parsed.raw, parsed.status, parsed.body, false);
+        }
+        const found = getIssueForRequest(c, db);
+        if (!found.repo) {
+            return respond(c, recorder, runId, started, parsed.raw, 404, githubError("Not Found", 404), false);
+        }
+        if (!found.issue) {
+            return respond(c, recorder, runId, started, parsed.raw, 404, githubError("Issue not found", 404), false);
+        }
+        const requestedAssignee = parsed.data.assignee ?? parsed.data.assignees?.[0];
+        if (requestedAssignee && !hasCollaborator(db, found.repo.id, requestedAssignee)) {
+            return respond(c, recorder, runId, started, parsed.raw, 422, githubError("Validation Failed", 422, [
+                { resource: "Issue", field: "assignees", code: "invalid" }
+            ]), false);
+        }
+        const issue = updateIssue(db, found.repo.id, found.issue.number, {
+            title: parsed.data.title,
+            body: parsed.data.body,
+            state: parsed.data.state,
+            assignee_login: requestedAssignee
+        });
+        const body = issueJson(issue, listIssueLabels(db, found.repo.id, found.issue.number), found.repo);
+        return respond(c, recorder, runId, started, parsed.raw, 200, body, true);
+    });
+    app.post("/repos/:owner/:repo/issues/:number/comments", async (c) => {
+        const started = Date.now();
+        const parsed = await parseBody(c, createCommentSchema);
+        if (!parsed.ok) {
+            return respond(c, recorder, runId, started, parsed.raw, parsed.status, parsed.body, false);
+        }
+        const found = getIssueForRequest(c, db);
+        if (!found.repo) {
+            return respond(c, recorder, runId, started, parsed.raw, 404, githubError("Not Found", 404), false);
+        }
+        if (!found.issue) {
+            return respond(c, recorder, runId, started, parsed.raw, 404, githubError("Issue not found", 404), false);
+        }
+        const comment = createComment(db, found.repo.id, found.issue.number, parsed.data.body);
+        return respond(c, recorder, runId, started, parsed.raw, 201, commentJson(comment, found.repo, found.issue.number), true);
+    });
+    app.get("/repos/:owner/:repo/labels", (c) => {
+        const started = Date.now();
+        const repo = getRepoForRequest(c, db);
+        if (!repo) {
+            return respond(c, recorder, runId, started, null, 404, githubError("Not Found", 404), false);
+        }
+        return respond(c, recorder, runId, started, null, 200, listLabels(db, repo.id).map(labelJson), false);
+    });
+    app.post("/repos/:owner/:repo/labels", async (c) => {
+        const started = Date.now();
+        const parsed = await parseBody(c, createLabelSchema);
+        if (!parsed.ok) {
+            return respond(c, recorder, runId, started, parsed.raw, parsed.status, parsed.body, false);
+        }
+        const repo = getRepoForRequest(c, db);
+        if (!repo) {
+            return respond(c, recorder, runId, started, parsed.raw, 404, githubError("Not Found", 404), false);
+        }
+        if (getLabel(db, repo.id, parsed.data.name)) {
+            return respond(c, recorder, runId, started, parsed.raw, 422, githubError("Validation Failed", 422, [
+                { resource: "Label", field: "name", code: "already_exists" }
+            ]), false);
+        }
+        const label = createLabel(db, repo.id, parsed.data.name, parsed.data.color, parsed.data.description);
+        return respond(c, recorder, runId, started, parsed.raw, 201, labelJson(label), true);
+    });
+    app.get("/repos/:owner/:repo/issues/:number/labels", (c) => {
+        const started = Date.now();
+        const found = getIssueForRequest(c, db);
+        if (!found.repo) {
+            return respond(c, recorder, runId, started, null, 404, githubError("Not Found", 404), false);
+        }
+        if (!found.issue) {
+            return respond(c, recorder, runId, started, null, 404, githubError("Issue not found", 404), false);
+        }
+        return respond(c, recorder, runId, started, null, 200, listIssueLabels(db, found.repo.id, found.issue.number).map(labelJson), false);
+    });
+    app.post("/repos/:owner/:repo/issues/:number/labels", async (c) => {
+        const started = Date.now();
+        const parsed = await parseBody(c, addLabelsSchema);
+        if (!parsed.ok) {
+            return respond(c, recorder, runId, started, parsed.raw, parsed.status, parsed.body, false);
+        }
+        const found = getIssueForRequest(c, db);
+        if (!found.repo) {
+            return respond(c, recorder, runId, started, parsed.raw, 404, githubError("Not Found", 404), false);
+        }
+        if (!found.issue) {
+            return respond(c, recorder, runId, started, parsed.raw, 404, githubError("Issue not found", 404), false);
+        }
+        for (const labelName of parsed.data.labels) {
+            if (!getLabel(db, found.repo.id, labelName)) {
+                return respond(c, recorder, runId, started, parsed.raw, 422, githubError("Validation Failed", 422, [
+                    { resource: "Label", field: "name", code: "missing", value: labelName }
+                ]), false);
+            }
+        }
+        for (const labelName of parsed.data.labels) {
+            addIssueLabel(db, found.repo.id, found.issue.number, labelName);
+        }
+        return respond(c, recorder, runId, started, parsed.raw, 200, listIssueLabels(db, found.repo.id, found.issue.number).map(labelJson), true);
+    });
+    app.delete("/repos/:owner/:repo/issues/:number/labels/:name", (c) => {
+        const started = Date.now();
+        const found = getIssueForRequest(c, db);
+        if (!found.repo) {
+            return respond(c, recorder, runId, started, null, 404, githubError("Not Found", 404), false);
+        }
+        if (!found.issue) {
+            return respond(c, recorder, runId, started, null, 404, githubError("Issue not found", 404), false);
+        }
+        const changes = deleteIssueLabel(db, found.repo.id, found.issue.number, c.req.param("name"));
+        if (!changes) {
+            return respond(c, recorder, runId, started, null, 404, githubError("Label not found", 404), false);
+        }
+        return respond(c, recorder, runId, started, null, 200, listIssueLabels(db, found.repo.id, found.issue.number).map(labelJson), true);
+    });
+    app.get("/repos/:owner/:repo/collaborators", (c) => {
+        const started = Date.now();
+        const repo = getRepoForRequest(c, db);
+        if (!repo) {
+            return respond(c, recorder, runId, started, null, 404, githubError("Not Found", 404), false);
+        }
+        return respond(c, recorder, runId, started, null, 200, listCollaborators(db, repo.id).map(collaboratorJson), false);
+    });
+    app.post("/repos/:owner/:repo/issues/:number/assignees", async (c) => {
+        const started = Date.now();
+        const parsed = await parseBody(c, addAssigneesSchema);
+        if (!parsed.ok) {
+            return respond(c, recorder, runId, started, parsed.raw, parsed.status, parsed.body, false);
+        }
+        const found = getIssueForRequest(c, db);
+        if (!found.repo) {
+            return respond(c, recorder, runId, started, parsed.raw, 404, githubError("Not Found", 404), false);
+        }
+        if (!found.issue) {
+            return respond(c, recorder, runId, started, parsed.raw, 404, githubError("Issue not found", 404), false);
+        }
+        const assignee = parsed.data.assignees[0];
+        if (!hasCollaborator(db, found.repo.id, assignee)) {
+            return respond(c, recorder, runId, started, parsed.raw, 422, githubError("Validation Failed", 422, [
+                { resource: "Issue", field: "assignees", code: "invalid", value: assignee }
+            ]), false);
+        }
+        const issue = updateIssue(db, found.repo.id, found.issue.number, { assignee_login: assignee });
+        return respond(c, recorder, runId, started, parsed.raw, 201, issueJson(issue, listIssueLabels(db, found.repo.id, issue.number), found.repo), true);
+    });
+    app.all("*", (c) => {
+        const started = Date.now();
+        return respond(c, recorder, runId, started, null, 404, {
+            message: "This endpoint is not supported by this twin.",
+            fidelity: "unsupported",
+            supported_endpoints: [
+                "GET /repos/:owner/:repo",
+                "GET /repos/:owner/:repo/issues",
+                "GET /repos/:owner/:repo/issues/:number",
+                "PATCH /repos/:owner/:repo/issues/:number",
+                "POST /repos/:owner/:repo/issues/:number/comments",
+                "GET /repos/:owner/:repo/labels",
+                "POST /repos/:owner/:repo/labels",
+                "GET /repos/:owner/:repo/issues/:number/labels",
+                "POST /repos/:owner/:repo/issues/:number/labels",
+                "DELETE /repos/:owner/:repo/issues/:number/labels/:name",
+                "GET /repos/:owner/:repo/collaborators",
+                "POST /repos/:owner/:repo/issues/:number/assignees"
+            ]
+        }, false, "unsupported");
+    });
+    return app;
+}
+function getRepoForRequest(c, db) {
+    const owner = c.req.param("owner");
+    const repo = c.req.param("repo");
+    if (!owner || !repo)
+        return undefined;
+    return getRepo(db, owner, repo);
+}
+function getIssueForRequest(c, db) {
+    const repo = getRepoForRequest(c, db);
+    const issueNumber = Number(c.req.param("number"));
+    return {
+        repo,
+        issue: repo && Number.isInteger(issueNumber) ? getIssue(db, repo.id, issueNumber) : undefined
+    };
+}
+function githubError(message, status, errors) {
+    return {
+        message,
+        documentation_url: "https://docs.github.com/rest",
+        status,
+        ...(errors ? { errors } : {})
+    };
+}
+async function parseBody(c, schema) {
+    let raw;
+    try {
+        raw = await c.req.json();
+    }
+    catch {
+        return {
+            ok: false,
+            status: 400,
+            body: githubError("Problems parsing JSON", 400),
+            raw: null
+        };
+    }
+    const parsed = schema.safeParse(raw);
+    if (!parsed.success) {
+        return {
+            ok: false,
+            status: 422,
+            body: githubError("Validation Failed", 422, parsed.error.issues.map((issue) => ({
+                resource: "Request",
+                field: issue.path.join("."),
+                code: issue.code
+            }))),
+            raw
+        };
+    }
+    return { ok: true, data: parsed.data, raw };
+}
+function respond(c, recorder, runId, started, requestBody, status, responseBody, stateMutation, fidelity = "semantic") {
+    recorder?.record({
+        ts: new Date().toISOString(),
+        run_id: runId,
+        twin: "github",
+        request_id: createRequestId(),
+        method: c.req.method,
+        path: new URL(c.req.url).pathname,
+        request_body: requestBody,
+        status,
+        response_body: responseBody,
+        latency_ms: Date.now() - started,
+        fidelity,
+        state_mutation: stateMutation,
+        error: status >= 400 ? responseBody.message ?? "request failed" : null
+    });
+    return c.json(responseBody, status);
+}

package/dist/src/twin/github/db/migrations.d.ts

@@ -0,0 +1,2 @@
+import type { GitHubTwinDatabase } from "../types.js";
+export declare function migrate(db: GitHubTwinDatabase): void;

package/dist/src/twin/github/db/migrations.js

@@ -0,0 +1,64 @@
+const MIGRATION_SQL = `
+CREATE TABLE IF NOT EXISTS repositories (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  owner TEXT NOT NULL,
+  name TEXT NOT NULL,
+  full_name TEXT NOT NULL UNIQUE,
+  description TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS labels (
+  repo_id INTEGER NOT NULL,
+  name TEXT NOT NULL,
+  color TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  PRIMARY KEY (repo_id, name),
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS collaborators (
+  repo_id INTEGER NOT NULL,
+  login TEXT NOT NULL,
+  PRIMARY KEY (repo_id, login),
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS issues (
+  repo_id INTEGER NOT NULL,
+  number INTEGER NOT NULL,
+  title TEXT NOT NULL,
+  body TEXT NOT NULL DEFAULT '',
+  state TEXT NOT NULL,
+  assignee_login TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (repo_id, number),
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE,
+  FOREIGN KEY (repo_id, assignee_login) REFERENCES collaborators(repo_id, login)
+);
+
+CREATE TABLE IF NOT EXISTS issue_labels (
+  repo_id INTEGER NOT NULL,
+  issue_number INTEGER NOT NULL,
+  label_name TEXT NOT NULL,
+  PRIMARY KEY (repo_id, issue_number, label_name),
+  FOREIGN KEY (repo_id, issue_number) REFERENCES issues(repo_id, number) ON DELETE CASCADE,
+  FOREIGN KEY (repo_id, label_name) REFERENCES labels(repo_id, name) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS comments (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER NOT NULL,
+  issue_number INTEGER NOT NULL,
+  body TEXT NOT NULL,
+  user_login TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (repo_id, issue_number) REFERENCES issues(repo_id, number) ON DELETE CASCADE
+);
+`;
+export function migrate(db) {
+    db.exec("PRAGMA foreign_keys = ON;");
+    db.exec(MIGRATION_SQL);
+}

package/dist/src/twin/github/db/openDatabase.d.ts

@@ -0,0 +1,2 @@
+import type { GitHubTwinDatabase } from "../types.js";
+export declare function openGitHubTwinDatabase(path?: string): GitHubTwinDatabase;

package/dist/src/twin/github/db/openDatabase.js

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+import Database from "better-sqlite3";
+import { dirname } from "node:path";
+import { mkdirSync } from "node:fs";
+import { migrate } from "./migrations.js";
+export function openGitHubTwinDatabase(path = ":memory:") {
+    if (path !== ":memory:") {
+        mkdirSync(dirname(path), { recursive: true });
+    }
+    const db = new Database(path);
+    migrate(db);
+    return db;
+}