@deftai/directive-core 0.55.0

package/dist/intake/github-body.js

@@ -0,0 +1,151 @@
+import { readFileSync } from "node:fs";
+import { defaultWhich } from "../scm/binary.js";
+import { call } from "../scm/call.js";
+export const DEFAULT_TIMEOUT_SECONDS = 60;
+export class GitHubBodyError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GitHubBodyError";
+    }
+}
+function splitRepo(repo) {
+    const parts = repo.split("/", 2);
+    if (parts.length !== 2 || parts[0] === "" || parts[1] === "" || parts[1]?.includes("/")) {
+        throw new GitHubBodyError(`repo must be OWNER/NAME; got ${JSON.stringify(repo)}`);
+    }
+    return [parts[0], parts[1]];
+}
+/** Resolve the live GitHub CLI used for writes and mutation read-back. */
+export function resolveLiveGh() {
+    if (defaultWhich("gh") === null) {
+        throw new GitHubBodyError("gh not found on PATH; safe body posting requires live gh, not ghx, so immediate read-back cannot be served from a stale cache");
+    }
+    return "gh";
+}
+export function readBody(bodyFile, stdinText) {
+    if (bodyFile === "-") {
+        return stdinText ?? "";
+    }
+    return readFileSync(bodyFile, "utf8");
+}
+function jsonInput(payload) {
+    return JSON.stringify(payload);
+}
+function runGhApiJson(args, options = {}) {
+    if (options.runFn !== undefined) {
+        return options.runFn(args, {
+            inputText: options.inputText,
+            binary: options.binary ?? undefined,
+        });
+    }
+    const binary = options.binary ?? resolveLiveGh();
+    let result;
+    try {
+        result = call("github-issue", "api", [...args], {
+            binary,
+            timeout: DEFAULT_TIMEOUT_SECONDS,
+            input: options.inputText ?? undefined,
+        });
+    }
+    catch {
+        throw new GitHubBodyError(`${JSON.stringify(binary)} not found on PATH`);
+    }
+    if (result.returncode !== 0) {
+        const stderr = result.stderr.trim() || "(no stderr)";
+        throw new GitHubBodyError(`gh api ${args.join(" ")} failed with exit ${result.returncode}: ${stderr}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout || "{}");
+    }
+    catch {
+        throw new GitHubBodyError(`gh api ${args.join(" ")} returned non-JSON output`);
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new GitHubBodyError(`gh api ${args.join(" ")} returned non-object JSON`);
+    }
+    return parsed;
+}
+function requireIntField(obj, field) {
+    const value = obj[field];
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+        throw new GitHubBodyError(`mutation response did not include integer field ${JSON.stringify(field)}`);
+    }
+    return value;
+}
+function mutateWithReadback(mutationEndpoint, method, payload, readbackEndpoint, options = {}) {
+    const mutation = runGhApiJson([mutationEndpoint, "--method", method, "--input", "-"], {
+        inputText: jsonInput(payload),
+        binary: options.binary,
+        runFn: options.runFn,
+    });
+    const endpoint = typeof readbackEndpoint === "function" ? readbackEndpoint(mutation) : readbackEndpoint;
+    return runGhApiJson([endpoint], { binary: options.binary, runFn: options.runFn });
+}
+export function createIssue(repo, options) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/issues`;
+    return mutateWithReadback(endpoint, "POST", { title: options.title, body: options.body }, (response) => `repos/${owner}/${name}/issues/${requireIntField(response, "number")}`, { binary: options.binary, runFn: options.runFn });
+}
+export function editIssueBody(repo, issue, options) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/issues/${issue}`;
+    return mutateWithReadback(endpoint, "PATCH", { body: options.body }, endpoint, {
+        binary: options.binary,
+        runFn: options.runFn,
+    });
+}
+export function createIssueComment(repo, issue, options) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/issues/${issue}/comments`;
+    return mutateWithReadback(endpoint, "POST", { body: options.body }, (response) => `repos/${owner}/${name}/issues/comments/${requireIntField(response, "id")}`, { binary: options.binary, runFn: options.runFn });
+}
+export function editIssueCommentBody(repo, commentId, options) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/issues/comments/${commentId}`;
+    return mutateWithReadback(endpoint, "PATCH", { body: options.body }, endpoint, {
+        binary: options.binary,
+        runFn: options.runFn,
+    });
+}
+export function editPrBody(repo, pr, options) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/pulls/${pr}`;
+    return mutateWithReadback(endpoint, "PATCH", { body: options.body }, endpoint, {
+        binary: options.binary,
+        runFn: options.runFn,
+    });
+}
+export function githubBodyMain(args) {
+    try {
+        const body = readBody(args.bodyFile ?? "-");
+        let result;
+        switch (args.command) {
+            case "issue-create":
+                result = createIssue(args.repo, { title: args.title, body });
+                break;
+            case "issue-edit":
+                result = editIssueBody(args.repo, args.issue, { body });
+                break;
+            case "comment-create":
+                result = createIssueComment(args.repo, args.issue, { body });
+                break;
+            case "comment-edit":
+                result = editIssueCommentBody(args.repo, args.comment, { body });
+                break;
+            case "pr-edit":
+                result = editPrBody(args.repo, args.pr, { body });
+                break;
+            default:
+                process.stderr.write(`error: unknown command ${JSON.stringify(args.command)}\n`);
+                return 1;
+        }
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        return 0;
+    }
+    catch (exc) {
+        process.stderr.write(`error: ${String(exc)}\n`);
+        return 1;
+    }
+}
+//# sourceMappingURL=github-body.js.map

package/dist/intake/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./candidates-log.js";
+export * from "./github-auth-modes.js";
+export { resultToDict } from "./github-auth-modes.js";
+export * from "./github-body.js";
+export { githubBodyMain } from "./github-body.js";
+export * from "./issue-emit.js";
+export { issueEmitMain } from "./issue-emit.js";
+export * from "./issue-ingest.js";
+export { issueIngestMain } from "./issue-ingest.js";
+export * from "./markdown-scanners.js";
+export * from "./parity-scenarios.js";
+export * from "./platform-capabilities.js";
+export * from "./reconcile-issues.js";
+export { reconcileMain } from "./reconcile-issues.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/intake/index.js

@@ -0,0 +1,15 @@
+export * from "./candidates-log.js";
+export * from "./github-auth-modes.js";
+export { resultToDict } from "./github-auth-modes.js";
+export * from "./github-body.js";
+export { githubBodyMain } from "./github-body.js";
+export * from "./issue-emit.js";
+export { issueEmitMain } from "./issue-emit.js";
+export * from "./issue-ingest.js";
+export { issueIngestMain } from "./issue-ingest.js";
+export * from "./markdown-scanners.js";
+export * from "./parity-scenarios.js";
+export * from "./platform-capabilities.js";
+export * from "./reconcile-issues.js";
+export { reconcileMain } from "./reconcile-issues.js";
+//# sourceMappingURL=index.js.map

package/dist/intake/issue-emit-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function mainEntry(argv?: string[]): number;
+//# sourceMappingURL=issue-emit-cli.d.ts.map

package/dist/intake/issue-emit-cli.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { issueEmitMain } from "./issue-emit.js";
+function parseArgs(argv) {
+    const patterns = [];
+    const out = { patterns };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--umbrella")
+            out.umbrella = true;
+        else if (arg === "--per-vbrief")
+            out.perVbrief = true;
+        else if (arg === "--dry-run")
+            out.dryRun = true;
+        else if (arg === "--json")
+            out.json = true;
+        else if (arg === "--title")
+            out.title = argv[++i];
+        else if (arg === "--repo")
+            out.repo = argv[++i];
+        else if (arg === "--project-root")
+            out.projectRoot = argv[++i];
+        else if (!arg.startsWith("-"))
+            patterns.push(arg);
+    }
+    return out;
+}
+export function mainEntry(argv = process.argv.slice(2)) {
+    return issueEmitMain(parseArgs(argv));
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(mainEntry());
+}
+//# sourceMappingURL=issue-emit-cli.js.map

package/dist/intake/issue-emit.d.ts

@@ -0,0 +1,63 @@
+import type { ScmCallFn } from "./reconcile-issues.js";
+export declare const GITHUB_ISSUE_REF_TYPE = "x-vbrief/github-issue";
+export declare const EXTERNAL_TRUST_LEVEL = "external";
+export declare class IssueEmitError extends Error {
+    constructor(message: string);
+}
+export declare function loadVbrief(path: string): Record<string, unknown>;
+export declare function writeVbrief(path: string, data: Record<string, unknown>): void;
+export declare function vbriefTitle(data: Record<string, unknown>): string;
+export declare function existingGithubIssueRef(data: Record<string, unknown>): string | null | undefined;
+export declare function addGithubIssueReference(data: Record<string, unknown>, url: string): Record<string, unknown>;
+export declare function renderIssueBody(data: Record<string, unknown>): string;
+export declare function renderUmbrellaBody(entries: readonly [string, Record<string, unknown>][], intro?: string | null): string;
+export declare function fileIssue(repo: string, title: string, body: string, scmCall?: ScmCallFn): string;
+export interface EmitAction {
+    result: "created" | "dryrun" | "skipped";
+    vbrief: string;
+    url?: string | null;
+    title?: string;
+}
+export declare function emitSingle(path: string, options: {
+    repo: string;
+    scmCall?: ScmCallFn;
+    noNetwork?: boolean;
+    displayPath?: string | null;
+}): EmitAction;
+export declare function emitPerVbrief(paths: string[], options: {
+    repo: string;
+    scmCall?: ScmCallFn;
+    noNetwork?: boolean;
+    displayPaths?: string[] | null;
+}): EmitAction[];
+export interface UmbrellaAction {
+    result: "created" | "dryrun" | "skipped";
+    url: string | null;
+    title: string;
+    vbriefs: {
+        vbrief: string;
+        result: string;
+    }[];
+}
+export declare function emitUmbrella(paths: string[], options: {
+    repo: string;
+    scmCall?: ScmCallFn;
+    noNetwork?: boolean;
+    title?: string | null;
+    displayPaths?: string[] | null;
+}): UmbrellaAction;
+export declare function expandPatterns(patterns: string[], root?: string | null): string[];
+export declare function isNoNetwork(dryRun: boolean): boolean;
+export declare function displayPath(path: string, projectRoot: string | null): string;
+export interface IssueEmitCliArgs {
+    patterns: string[];
+    umbrella?: boolean;
+    perVbrief?: boolean;
+    title?: string | null;
+    dryRun?: boolean;
+    json?: boolean;
+    repo?: string | null;
+    projectRoot?: string | null;
+}
+export declare function issueEmitMain(args: IssueEmitCliArgs): number;
+//# sourceMappingURL=issue-emit.d.ts.map

package/dist/intake/issue-emit.js

@@ -0,0 +1,351 @@
+import { globSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, relative, resolve } from "node:path";
+import { call } from "../scm/call.js";
+import { resolveProjectRoot } from "../scope/project-context.js";
+import { resolveProjectRepo } from "../slice/project-context.js";
+export const GITHUB_ISSUE_REF_TYPE = "x-vbrief/github-issue";
+export const EXTERNAL_TRUST_LEVEL = "external";
+const ISSUE_URL_PATTERN = /https?:\/\/\S+?\/issues\/\d+/;
+export class IssueEmitError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "IssueEmitError";
+    }
+}
+export function loadVbrief(path) {
+    const data = JSON.parse(readFileSync(path, "utf8"));
+    return data !== null && typeof data === "object" && !Array.isArray(data)
+        ? data
+        : {};
+}
+export function writeVbrief(path, data) {
+    writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+export function vbriefTitle(data) {
+    const plan = (data.plan ?? {});
+    const title = plan.title;
+    if (typeof title === "string" && title.trim().length > 0) {
+        return title.trim();
+    }
+    const info = (data.vBRIEFInfo ?? {});
+    const desc = info.description;
+    if (typeof desc === "string" && desc.trim().length > 0) {
+        return desc.trim();
+    }
+    return "Untitled vBRIEF";
+}
+export function existingGithubIssueRef(data) {
+    const plan = (data.plan ?? {});
+    const refs = plan.references;
+    if (!Array.isArray(refs)) {
+        return undefined;
+    }
+    for (const ref of refs) {
+        if (ref !== null && typeof ref === "object" && !Array.isArray(ref)) {
+            const obj = ref;
+            if (obj.type === GITHUB_ISSUE_REF_TYPE) {
+                const uri = obj.uri ?? obj.url;
+                return typeof uri === "string" && uri.length > 0 ? uri : "";
+            }
+        }
+    }
+    return undefined;
+}
+export function addGithubIssueReference(data, url) {
+    const plan = (data.plan ?? {});
+    data.plan = plan;
+    const refs = Array.isArray(plan.references) ? plan.references : [];
+    refs.push({
+        uri: url,
+        type: GITHUB_ISSUE_REF_TYPE,
+        TrustLevel: EXTERNAL_TRUST_LEVEL,
+    });
+    plan.references = refs;
+    return data;
+}
+export function renderIssueBody(data) {
+    const plan = (data.plan ?? {});
+    const narratives = (plan.narratives ?? {});
+    const parts = [];
+    const desc = narratives.Description;
+    if (typeof desc === "string" && desc.trim().length > 0) {
+        parts.push(`## Description\n\n${desc.trim()}`);
+    }
+    const acceptanceLines = [];
+    const planAcceptance = narratives.Acceptance;
+    if (typeof planAcceptance === "string" && planAcceptance.trim().length > 0) {
+        acceptanceLines.push(planAcceptance.trim());
+    }
+    const items = plan.items;
+    if (Array.isArray(items)) {
+        for (const item of items) {
+            if (item === null || typeof item !== "object" || Array.isArray(item)) {
+                continue;
+            }
+            const itemObj = item;
+            const narrative = (itemObj.narrative ?? {});
+            const acc = narrative.Acceptance;
+            if (typeof acc === "string" && acc.trim().length > 0) {
+                const itemTitle = String(itemObj.title ?? "").trim();
+                if (itemTitle.length > 0) {
+                    acceptanceLines.push(`- **${itemTitle}**: ${acc.trim()}`);
+                }
+                else {
+                    acceptanceLines.push(`- ${acc.trim()}`);
+                }
+            }
+        }
+    }
+    if (acceptanceLines.length > 0) {
+        parts.push(`## Acceptance\n\n${acceptanceLines.join("\n")}`);
+    }
+    const traces = narratives.Traces;
+    if (typeof traces === "string" && traces.trim().length > 0) {
+        parts.push(`## Traces\n\n${traces.trim()}`);
+    }
+    if (parts.length === 0) {
+        return `Scope vBRIEF: ${vbriefTitle(data)}\n`;
+    }
+    return `${parts.join("\n\n")}\n`;
+}
+export function renderUmbrellaBody(entries, intro) {
+    const lines = [];
+    if (intro !== undefined && intro !== null && intro.trim().length > 0) {
+        lines.push(intro.trim(), "");
+    }
+    lines.push("## Tracked vBRIEFs", "");
+    for (const [displayPath, data] of entries) {
+        lines.push(`- [ ] ${vbriefTitle(data)} (\`${displayPath}\`)`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function fileIssue(repo, title, body, scmCall = call) {
+    const tmpDir = mkdtempSync(join(tmpdir(), "deft-issue-emit-"));
+    const bodyPath = join(tmpDir, "body.md");
+    try {
+        writeFileSync(bodyPath, body, "utf8");
+        const result = scmCall("github-issue", "issue", ["create", "--repo", repo, "--title", title, "--body-file", bodyPath], { timeout: 60 });
+        if (result.returncode !== 0) {
+            throw new IssueEmitError(`gh issue create failed (exit ${result.returncode}): ${(result.stderr ?? "").trim()}`);
+        }
+        const stdout = (result.stdout ?? "").trim();
+        const match = ISSUE_URL_PATTERN.exec(stdout);
+        if (match?.[0]) {
+            return match[0];
+        }
+        if (stdout.length > 0) {
+            return stdout;
+        }
+        throw new IssueEmitError("gh issue create succeeded but emitted no issue URL on stdout");
+    }
+    finally {
+        rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+export function emitSingle(path, options) {
+    const shown = options.displayPath ?? path;
+    const data = loadVbrief(path);
+    const existing = existingGithubIssueRef(data);
+    if (existing !== undefined) {
+        return {
+            result: "skipped",
+            vbrief: shown,
+            url: typeof existing === "string" && existing.length > 0 ? existing : null,
+            title: vbriefTitle(data),
+        };
+    }
+    const title = vbriefTitle(data);
+    if (options.noNetwork) {
+        return { result: "dryrun", vbrief: shown, url: null, title };
+    }
+    const body = renderIssueBody(data);
+    const url = fileIssue(options.repo, title, body, options.scmCall);
+    addGithubIssueReference(data, url);
+    writeVbrief(path, data);
+    return { result: "created", vbrief: shown, url, title };
+}
+export function emitPerVbrief(paths, options) {
+    const shown = options.displayPaths ?? paths;
+    const actions = [];
+    for (let i = 0; i < paths.length; i += 1) {
+        actions.push(emitSingle(paths[i], {
+            ...options,
+            displayPath: shown[i],
+        }));
+    }
+    return actions;
+}
+function defaultUmbrellaTitle(count) {
+    const noun = count === 1 ? "vBRIEF" : "vBRIEFs";
+    return `Umbrella: ${count} tracked ${noun}`;
+}
+export function emitUmbrella(paths, options) {
+    const shown = options.displayPaths ?? paths;
+    const loaded = [];
+    for (let i = 0; i < paths.length; i += 1) {
+        loaded.push([paths[i], shown[i], loadVbrief(paths[i])]);
+    }
+    const pending = loaded.filter(([, , data]) => existingGithubIssueRef(data) === undefined);
+    const already = loaded
+        .filter(([, , data]) => existingGithubIssueRef(data) !== undefined)
+        .map(([, disp]) => ({ vbrief: disp, result: "skipped" }));
+    const umbrellaTitle = options.title ?? defaultUmbrellaTitle(loaded.length);
+    if (pending.length === 0) {
+        return { result: "skipped", url: null, title: umbrellaTitle, vbriefs: already };
+    }
+    if (options.noNetwork) {
+        return {
+            result: "dryrun",
+            url: null,
+            title: umbrellaTitle,
+            vbriefs: [...pending.map(([, disp]) => ({ vbrief: disp, result: "dryrun" })), ...already],
+        };
+    }
+    const body = renderUmbrellaBody(pending.map(([, disp, data]) => [disp, data]));
+    const url = fileIssue(options.repo, umbrellaTitle, body, options.scmCall);
+    const written = [];
+    for (const [path, disp, data] of pending) {
+        addGithubIssueReference(data, url);
+        writeVbrief(path, data);
+        written.push({ vbrief: disp, result: "created" });
+    }
+    return { result: "created", url, title: umbrellaTitle, vbriefs: [...written, ...already] };
+}
+export function expandPatterns(patterns, root = null) {
+    const seen = new Set();
+    const out = [];
+    for (const pattern of patterns) {
+        const candidate = root !== null && !pattern.startsWith("/") ? join(root, pattern) : pattern;
+        let matches = globSync(candidate).sort();
+        if (matches.length === 0) {
+            try {
+                readFileSync(candidate);
+                matches = [candidate];
+            }
+            catch {
+                matches = [];
+            }
+        }
+        for (const match of matches) {
+            const resolved = resolve(match);
+            if (seen.has(resolved)) {
+                continue;
+            }
+            seen.add(resolved);
+            out.push(match);
+        }
+    }
+    return out;
+}
+export function isNoNetwork(dryRun) {
+    return dryRun || process.env.DEFT_NO_NETWORK === "1";
+}
+export function displayPath(path, projectRoot) {
+    if (projectRoot !== null) {
+        try {
+            return relative(resolve(projectRoot), resolve(path));
+        }
+        catch {
+            // fall through
+        }
+    }
+    return path;
+}
+export function issueEmitMain(args) {
+    if (args.patterns.length === 0) {
+        process.stderr.write("Error: Provide a vBRIEF path or glob(s) to emit\n");
+        return 2;
+    }
+    if (args.title !== undefined && args.title !== null && !args.umbrella) {
+        process.stderr.write("Error: --title is only valid with --umbrella\n");
+        return 2;
+    }
+    const projectRoot = resolveProjectRoot(args.projectRoot ?? undefined);
+    const paths = expandPatterns(args.patterns, projectRoot);
+    if (paths.length === 0) {
+        process.stderr.write(`Error: no vBRIEF files matched ${JSON.stringify(args.patterns)}.\n`);
+        return 2;
+    }
+    const noNetwork = isNoNetwork(args.dryRun ?? false);
+    let repo = "";
+    if (!noNetwork) {
+        repo = resolveProjectRepo(args.repo ?? undefined, projectRoot) ?? "";
+        if (repo.length === 0) {
+            process.stderr.write("Error: could not detect repo. Pass --repo OWNER/NAME, set $DEFT_PROJECT_REPO, or run from the consumer repo (#538).\n");
+            return 2;
+        }
+    }
+    const display = paths.map((p) => displayPath(p, projectRoot));
+    try {
+        let summary;
+        if (args.umbrella) {
+            const action = emitUmbrella(paths, {
+                repo,
+                noNetwork,
+                title: args.title,
+                displayPaths: display,
+            });
+            summary = { mode: "umbrella", no_network: noNetwork, umbrella: action };
+        }
+        else if (args.perVbrief) {
+            const actions = emitPerVbrief(paths, { repo, noNetwork, displayPaths: display });
+            summary = { mode: "per-vbrief", no_network: noNetwork, actions };
+        }
+        else {
+            if (paths.length !== 1) {
+                process.stderr.write(`Error: single mode expects exactly one vBRIEF; matched ${paths.length}. Use --umbrella or --per-vbrief for globs.\n`);
+                return 2;
+            }
+            const action = emitSingle(paths[0], {
+                repo,
+                noNetwork,
+                displayPath: display[0],
+            });
+            summary = { mode: "single", no_network: noNetwork, actions: [action] };
+        }
+        if (args.json) {
+            process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
+        }
+        else {
+            printSummary(summary);
+        }
+        return 0;
+    }
+    catch (exc) {
+        process.stderr.write(`Error: ${String(exc)}\n`);
+        return 2;
+    }
+}
+function printSummary(summary) {
+    const mode = String(summary.mode);
+    const noNetwork = Boolean(summary.no_network);
+    const banner = noNetwork ? "issue:emit plan (no network)" : "issue:emit";
+    process.stdout.write(`${banner} -- mode: ${mode}\n`);
+    if (mode === "umbrella") {
+        const action = summary.umbrella;
+        const verbs = {
+            created: "FILED umbrella",
+            dryrun: "WOULD FILE umbrella",
+            skipped: "SKIP umbrella (already tracked)",
+        };
+        const url = action.url ? ` -> ${action.url}` : "";
+        process.stdout.write(`  ${verbs[action.result]}: ${action.title}${url}\n`);
+        for (const child of action.vbriefs) {
+            process.stdout.write(`    - ${child.result.toUpperCase().padEnd(8)} ${child.vbrief}\n`);
+        }
+    }
+    else {
+        const actions = summary.actions;
+        const verbs = {
+            created: "FILED",
+            dryrun: "WOULD FILE",
+            skipped: "SKIP (already tracked)",
+        };
+        for (const action of actions) {
+            const url = action.url ? ` -> ${action.url}` : "";
+            process.stdout.write(`  ${verbs[action.result]?.padEnd(22) ?? ""} ${action.vbrief}${url}\n`);
+        }
+    }
+}
+//# sourceMappingURL=issue-emit.js.map

package/dist/intake/issue-ingest-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function mainEntry(argv?: string[]): number;
+//# sourceMappingURL=issue-ingest-cli.d.ts.map

package/dist/intake/issue-ingest-cli.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { issueIngestMain } from "./issue-ingest.js";
+function parseArgs(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--all")
+            out.all = true;
+        else if (arg === "--dry-run")
+            out.dryRun = true;
+        else if (arg === "--label")
+            out.label = argv[++i];
+        else if (arg === "--status")
+            out.status = argv[++i];
+        else if (arg === "--vbrief-dir")
+            out.vbriefDir = argv[++i];
+        else if (arg === "--repo")
+            out.repo = argv[++i];
+        else if (arg === "--project-root")
+            out.projectRoot = argv[++i];
+        else if (/^\d+$/.test(arg))
+            out.number = Number.parseInt(arg, 10);
+    }
+    return out;
+}
+export function mainEntry(argv = process.argv.slice(2)) {
+    return issueIngestMain(parseArgs(argv));
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(mainEntry());
+}
+//# sourceMappingURL=issue-ingest-cli.js.map