@pome-sh/cli 0.1.0 → 0.2.0

package/dist/src/recorder/verdictArtifact.js

@@ -1,207 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// FDRS-644 — the per-trial CLOUD verdict artifact.
-//
-// Hosted `pome run` persists each finalized trial's cloud verdict payload
-// (what /finalize returned and the terminal rendered) as `verdict.json`
-// next to the trial's raw trace. This is a provenance-labeled CACHE of the
-// cloud judge's output — NOT a local score: the OSS CLI still has no
-// scoring engine (FDRS-657 / no-eval-in-oss), score.json is still never
-// written, and deleting verdict.json loses nothing the dashboard doesn't
-// hold. `pome fix-prompt` reads these to hand grouped failure signatures
-// to the user's coding agent without a credentialed cloud round-trip —
-// the F0-3 / L5 intent recorded in uploadAndFinalize.ts ("so the CLI can
-// render per-criterion verdicts … without a follow-up cloud round-trip").
-//
-// Artifact-layout knowledge lives HERE and only here:
-//   <artifacts-root>/<task-slug>/<session-id>/verdict.json
-// (runDir shape from recorder/artifacts.ts `writeRunArtifactsCore`).
-import { existsSync } from "node:fs";
-import { readdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-export const VERDICT_ARTIFACT_VERSION = 1;
-export const VERDICT_FILENAME = "verdict.json";
-export async function writeVerdictArtifact(runDir, verdict) {
-    await writeFile(join(runDir, VERDICT_FILENAME), `${JSON.stringify(verdict, null, 2)}\n`, "utf8");
-}
-/** Read one trial's verdict.json. Returns null when absent or when the file
- *  isn't a recognizable verdict artifact (foreign/corrupt files are skipped,
- *  never thrown on — fix-prompt discovery must survive a messy runs/). */
-/** Every field the fix-prompt pipeline dereferences must hold its declared
- *  shape, or the FILE is rejected — discovery treats a half-recognizable
- *  verdict.json as foreign rather than crashing downstream on it. */
-function isVerdictArtifact(parsed) {
-    if (typeof parsed !== "object" || parsed === null)
-        return false;
-    const v = parsed;
-    if (v.source !== "cloud-finalize")
-        return false;
-    if (typeof v.session_id !== "string")
-        return false;
-    if (typeof v.task_name !== "string")
-        return false;
-    if (typeof v.scenario_path !== "string")
-        return false;
-    if (v.group_id !== null && typeof v.group_id !== "string")
-        return false;
-    if (typeof v.finalized_at !== "string")
-        return false;
-    if (typeof v.passed !== "boolean")
-        return false;
-    if (typeof v.score !== "number")
-        return false;
-    if (!Array.isArray(v.criteria_results))
-        return false;
-    return v.criteria_results.every((r) => {
-        if (typeof r !== "object" || r === null)
-            return false;
-        const result = r;
-        const criterion = result.criterion;
-        return (typeof criterion === "object" &&
-            criterion !== null &&
-            typeof criterion.text === "string" &&
-            typeof result.reason === "string" &&
-            typeof result.passed === "boolean" &&
-            typeof result.skipped === "boolean");
-    });
-}
-export async function readVerdictArtifact(runDir) {
-    const path = join(runDir, VERDICT_FILENAME);
-    let raw;
-    try {
-        raw = await readFile(path, "utf8");
-    }
-    catch {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (!isVerdictArtifact(parsed))
-            return null;
-        return { runDir, verdict: parsed };
-    }
-    catch {
-        return null;
-    }
-}
-/** Scan an artifacts root for finalized trials — exactly the two-level
- *  layout `<root>/<task-slug>/<session-id>/verdict.json`. Anything
- *  unreadable is skipped. */
-export async function scanVerdictArtifacts(artifactsRoot) {
-    const found = [];
-    let slugs;
-    try {
-        slugs = await readdir(artifactsRoot);
-    }
-    catch {
-        return found;
-    }
-    for (const slug of slugs) {
-        const slugDir = join(artifactsRoot, slug);
-        let runIds;
-        try {
-            runIds = await readdir(slugDir);
-        }
-        catch {
-            continue;
-        }
-        for (const runId of runIds) {
-            const trial = await readVerdictArtifact(join(slugDir, runId));
-            if (trial)
-                found.push(trial);
-        }
-    }
-    return found;
-}
-/** Group trials into run sets: trials sharing a group_id form one set; a
- *  null group_id is its own single-run set. */
-export function groupRunSets(trials) {
-    const byKey = new Map();
-    for (const trial of trials) {
-        const key = trial.verdict.group_id ?? `solo:${trial.verdict.session_id}`;
-        const bucket = byKey.get(key);
-        if (bucket)
-            bucket.push(trial);
-        else
-            byKey.set(key, [trial]);
-    }
-    const sets = [];
-    for (const bucket of byKey.values()) {
-        bucket.sort((a, b) => a.verdict.finalized_at.localeCompare(b.verdict.finalized_at));
-        const last = bucket[bucket.length - 1];
-        sets.push({
-            groupId: bucket[0].verdict.group_id,
-            taskName: bucket[0].verdict.task_name,
-            scenarioPath: bucket[0].verdict.scenario_path,
-            trials: bucket,
-            latestFinalizedAt: last.verdict.finalized_at,
-            anyFailed: bucket.some((t) => !t.verdict.passed),
-        });
-    }
-    sets.sort((a, b) => a.latestFinalizedAt.localeCompare(b.latestFinalizedAt));
-    return sets;
-}
-/** The newest run set with at least one failed (completed) trial. */
-export function latestFailedRunSet(sets) {
-    for (let i = sets.length - 1; i >= 0; i -= 1) {
-        if (sets[i].anyFailed)
-            return sets[i];
-    }
-    return null;
-}
-/**
- * Resolve what `pome fix-prompt [target]` should read.
- * - `target` = a trial run dir (has verdict.json): that trial's whole set —
- *   the user pointed at it, outcome doesn't matter.
- * - `target` = an artifacts root: the latest failed set under it.
- */
-export async function discoverRunSet(target) {
-    const anchor = await readVerdictArtifact(target);
-    if (anchor) {
-        // Trial dir → its set. Layout is <root>/<slug>/<runId>, so the root is
-        // two levels up; a moved/isolated dir degrades to a set of one.
-        const root = join(target, "..", "..");
-        const sets = groupRunSets(await scanVerdictArtifacts(root));
-        const own = sets.find((s) => (anchor.verdict.group_id !== null &&
-            s.groupId === anchor.verdict.group_id) ||
-            (anchor.verdict.group_id === null &&
-                s.trials.length === 1 &&
-                s.trials[0].verdict.session_id === anchor.verdict.session_id)) ?? groupRunSets([anchor])[0];
-        return { kind: "trial-dir", set: own, totalSets: Math.max(sets.length, 1) };
-    }
-    if (!existsSync(target))
-        return { kind: "root", set: null, totalSets: 0 };
-    const sets = groupRunSets(await scanVerdictArtifacts(target));
-    return {
-        kind: "root",
-        set: latestFailedRunSet(sets),
-        totalSets: sets.length,
-    };
-}
-/** Load a trial's captured events.jsonl (raw trace) for prompt assembly.
- *  Missing/corrupt lines are skipped — the prompt degrades, never throws. */
-export async function loadTrialEvents(runDir) {
-    let raw;
-    try {
-        raw = await readFile(join(runDir, "events.jsonl"), "utf8");
-    }
-    catch {
-        return [];
-    }
-    const events = [];
-    for (const line of raw.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        try {
-            const parsed = JSON.parse(trimmed);
-            // Valid JSON but not an event object (`null`, `3`, `"x"`) is corrupt
-            // for our purposes — renderEvent dereferences fields on it.
-            if (typeof parsed === "object" && parsed !== null)
-                events.push(parsed);
-        }
-        catch {
-            // skip corrupt row
-        }
-    }
-    return events;
-}

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

@@ -1,38 +0,0 @@
-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

@@ -1,59 +0,0 @@
-// 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

@@ -1,10 +0,0 @@
-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

@@ -1,316 +0,0 @@
-// 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

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