@deftai/directive 0.126.2 → 0.128.0

package/dist/triage-evaluate.js

@@ -1,153 +0,0 @@
-#!/usr/bin/env node
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { DEFAULT_CONCURRENCY, EvaluateError, evaluateIssues, renderEvaluateText, } from "@deftai/directive-core/dist/triage/evaluate/index.js";
-import { interceptHelp } from "@deftai/directive-core/dist/triage/help/index.js";
-import { resolveRepo } from "@deftai/directive-core/dist/triage/queue/repo.js";
-export function parseArgs(argv) {
-    const parsed = {
-        projectRoot: process.env.DEFT_PROJECT_ROOT ?? process.cwd(),
-        repo: process.env.DEFT_TRIAGE_REPO ?? null,
-        issues: [],
-        concurrency: DEFAULT_CONCURRENCY,
-        json: false,
-    };
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        if (arg === undefined || arg === "--") {
-            continue;
-        }
-        if (arg === "--project-root") {
-            if (i + 1 >= argv.length) {
-                return { ...parsed, error: "--project-root requires a path" };
-            }
-            i += 1;
-            const value = argv[i];
-            if (value === undefined) {
-                return { ...parsed, error: "--project-root requires a path" };
-            }
-            parsed.projectRoot = value;
-        }
-        else if (arg.startsWith("--project-root=")) {
-            parsed.projectRoot = arg.slice("--project-root=".length);
-        }
-        else if (arg === "--repo") {
-            if (i + 1 >= argv.length) {
-                return { ...parsed, error: "--repo requires owner/name" };
-            }
-            i += 1;
-            const value = argv[i];
-            if (value === undefined) {
-                return { ...parsed, error: "--repo requires owner/name" };
-            }
-            parsed.repo = value;
-        }
-        else if (arg.startsWith("--repo=")) {
-            parsed.repo = arg.slice("--repo=".length);
-        }
-        else if (arg === "--issue") {
-            if (i + 1 >= argv.length) {
-                return { ...parsed, error: "--issue requires a number" };
-            }
-            i += 1;
-            const value = argv[i];
-            if (value === undefined) {
-                return { ...parsed, error: "--issue requires a number" };
-            }
-            const n = Number.parseInt(value, 10);
-            if (!Number.isInteger(n) || n < 1) {
-                return { ...parsed, error: `--issue invalid: ${value}` };
-            }
-            parsed.issues.push(n);
-        }
-        else if (arg.startsWith("--issue=")) {
-            const n = Number.parseInt(arg.slice("--issue=".length), 10);
-            if (!Number.isInteger(n) || n < 1) {
-                return { ...parsed, error: `--issue invalid: ${arg}` };
-            }
-            parsed.issues.push(n);
-        }
-        else if (arg === "--concurrency") {
-            if (i + 1 >= argv.length) {
-                return { ...parsed, error: "--concurrency requires a positive integer" };
-            }
-            i += 1;
-            const value = argv[i];
-            if (value === undefined) {
-                return { ...parsed, error: "--concurrency requires a positive integer" };
-            }
-            const n = Number.parseInt(value, 10);
-            if (!Number.isInteger(n) || n < 1) {
-                return { ...parsed, error: `--concurrency invalid: ${value}` };
-            }
-            parsed.concurrency = n;
-        }
-        else if (arg.startsWith("--concurrency=")) {
-            const n = Number.parseInt(arg.slice("--concurrency=".length), 10);
-            if (!Number.isInteger(n) || n < 1) {
-                return { ...parsed, error: `--concurrency invalid: ${arg}` };
-            }
-            parsed.concurrency = n;
-        }
-        else if (arg === "--json") {
-            parsed.json = true;
-        }
-        else if (arg.startsWith("-")) {
-            return { ...parsed, error: `unrecognized argument: ${arg}` };
-        }
-        else {
-            const n = Number.parseInt(arg.replace(/^#/u, ""), 10);
-            if (!Number.isInteger(n) || n < 1) {
-                return { ...parsed, error: `invalid issue number: ${arg}` };
-            }
-            parsed.issues.push(n);
-        }
-    }
-    return parsed;
-}
-export async function run(argv) {
-    const help = interceptHelp("triage_evaluate", argv);
-    if (help !== null) {
-        return help;
-    }
-    const parsed = parseArgs(argv);
-    if (parsed.error !== undefined) {
-        process.stderr.write(`triage:evaluate: ${parsed.error}\n`);
-        return 2;
-    }
-    const projectRoot = resolve(parsed.projectRoot);
-    const repo = resolveRepo(parsed.repo, projectRoot);
-    if (repo === null) {
-        process.stderr.write("triage:evaluate: --repo owner/name is required\n");
-        return 2;
-    }
-    try {
-        const result = await evaluateIssues({
-            projectRoot,
-            repo,
-            issues: parsed.issues,
-            concurrency: parsed.concurrency,
-        });
-        if (parsed.json) {
-            process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-        }
-        else {
-            process.stdout.write(renderEvaluateText(result));
-        }
-        return result.verdicts.some((v) => v.error !== null) ? 1 : 0;
-    }
-    catch (err) {
-        const message = err instanceof EvaluateError ? err.message : String(err);
-        process.stderr.write(`triage:evaluate: ${message}\n`);
-        return err instanceof EvaluateError ? 2 : 1;
-    }
-}
-export async function main(argv) {
-    return run(argv);
-}
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-    void run(process.argv.slice(2)).then((code) => {
-        process.exit(code);
-    });
-}
-//# sourceMappingURL=triage-evaluate.js.map

package/dist/triage-help.d.ts

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

package/dist/triage-help.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-import { fileURLToPath } from "node:url";
-import { runHelp } from "@deftai/directive-core/dist/triage/help/index.js";
-export function run(argv) {
-    return runHelp(argv);
-}
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-    process.exit(run(process.argv.slice(2)));
-}
-//# sourceMappingURL=triage-help.js.map

package/dist/triage-queue-fixtures.d.ts

@@ -1,59 +0,0 @@
-export interface CommandCapture {
-    readonly exitCode: number;
-    readonly stdout: string;
-    readonly stderr: string;
-}
-export interface QueueFixtureIssue {
-    readonly number: number;
-    readonly title?: string;
-    readonly state?: string;
-    readonly labels?: readonly string[];
-    readonly updatedAt?: string;
-    readonly createdAt?: string;
-    /** Cache author.login for --author filter tests (#3129). */
-    readonly author?: string;
-}
-export interface QueueAuditEntry {
-    readonly issueNumber: number;
-    readonly decision: string;
-    readonly timestamp?: string;
-}
-export interface QueueFixtureOptions {
-    readonly repo?: string;
-    readonly issues?: readonly QueueFixtureIssue[];
-    readonly auditEntries?: readonly QueueAuditEntry[];
-    readonly rankingLabels?: readonly string[];
-    readonly activeIssueNumbers?: readonly number[];
-    readonly sliceRecords?: readonly Record<string, unknown>[];
-    readonly blockedIssueNumbers?: readonly number[];
-}
-export interface ParityCase {
-    readonly name: string;
-    readonly argv: readonly string[];
-    readonly fixture?: QueueFixtureOptions;
-    readonly skipFixture?: boolean;
-}
-export interface ParityDiff {
-    readonly caseName: string;
-    readonly exitMismatch: boolean;
-    readonly stdoutMismatch: boolean;
-    readonly stderrMismatch: boolean;
-    readonly pythonExit: number;
-    readonly tsExit: number;
-}
-export interface ParityResult {
-    readonly ok: boolean;
-    readonly diffs: readonly ParityDiff[];
-}
-/** Strip volatile absolute paths before compare. */
-export declare function normalizeOutput(text: string): string;
-/** Build a throwaway project root with optional queue fixtures. */
-export declare function buildFixtureRepo(options?: QueueFixtureOptions): string;
-/** Diff one parity case between Python oracle and TS CLI. */
-export declare function diffCase(python: CommandCapture, ts: CommandCapture, caseName: string): ParityDiff;
-export declare const PARITY_CASES: readonly ParityCase[];
-/** Augment argv with fixture audit/slices hooks when present. */
-export declare function augmentParityArgv(testCase: ParityCase, root: string): readonly string[];
-/** Run all parity cases; returns aggregate result. */
-export declare function renderReport(result: ParityResult): string;
-//# sourceMappingURL=triage-queue-fixtures.d.ts.map

package/dist/triage-queue-fixtures.js

@@ -1,284 +0,0 @@
-/** Test fixtures extracted from legacy parity harness (#2083). */
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-const DEFAULT_REPO = "owner/repo";
-/** Strip volatile absolute paths before compare. */
-export function normalizeOutput(text) {
-    return text
-        .replace(/^WARN [^\n]*\n/gm, "")
-        .replace(/project_root=[^\s)]+/g, "project_root=<ROOT>");
-}
-function writeCachedIssue(root, repo, issue) {
-    const parts = repo.split("/", 2);
-    const owner = parts[0];
-    const name = parts[1];
-    if (owner === undefined || name === undefined) {
-        throw new Error(`invalid repo slug: ${repo}`);
-    }
-    const dir = join(root, ".deft-cache", "github-issue", owner, name, String(issue.number));
-    mkdirSync(dir, { recursive: true });
-    const raw = {
-        number: issue.number,
-        title: issue.title ?? `Issue ${issue.number}`,
-        state: issue.state ?? "open",
-        labels: (issue.labels ?? []).map((label) => ({ name: label })),
-        updated_at: issue.updatedAt ?? "2026-05-17T20:00:00Z",
-        ...(issue.createdAt !== undefined ? { created_at: issue.createdAt } : {}),
-        ...(issue.author !== undefined ? { author: { login: issue.author } } : {}),
-    };
-    writeFileSync(join(dir, "raw.json"), `${JSON.stringify(raw)}\n`, { encoding: "utf8" });
-}
-function writeAuditLog(root, repo, entries) {
-    const dir = join(root, "xbrief", ".triage-cache");
-    mkdirSync(dir, { recursive: true });
-    const lines = entries.map((entry) => JSON.stringify({
-        decision_id: `id-${entry.issueNumber}-${entry.decision}`,
-        timestamp: entry.timestamp ?? "2026-05-17T20:00:00Z",
-        repo,
-        issue_number: entry.issueNumber,
-        decision: entry.decision,
-        actor: "parity",
-    }));
-    writeFileSync(join(dir, "candidates.jsonl"), `${lines.join("\n")}\n`, { encoding: "utf8" });
-}
-function writeProjectDefinition(root, rankingLabels) {
-    const dir = join(root, "xbrief");
-    mkdirSync(dir, { recursive: true });
-    const plan = { title: "T", status: "running", items: [] };
-    if (rankingLabels !== undefined && rankingLabels.length > 0) {
-        plan.policy = { triageRankingLabels: [...rankingLabels] };
-    }
-    writeFileSync(join(dir, "PROJECT-DEFINITION.xbrief.json"), `${JSON.stringify({ xBRIEFInfo: { version: "0.8" }, plan }, null, 2)}\n`, { encoding: "utf8" });
-}
-function writeActiveScope(root, repo, issueNumber, filename) {
-    const dir = join(root, "xbrief", "active");
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, filename), `${JSON.stringify({
-        xBRIEFInfo: { version: "0.8" },
-        plan: {
-            title: "Active scope",
-            status: "running",
-            references: [
-                {
-                    uri: `https://github.com/${repo}/issues/${issueNumber}`,
-                    type: "x-vbrief/github-issue",
-                    title: `Issue #${issueNumber}`,
-                },
-            ],
-        },
-    })}\n`, { encoding: "utf8" });
-}
-function writeBlockedScope(root, repo, issueNumber, filename) {
-    const dir = join(root, "xbrief", "active");
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, filename), `${JSON.stringify({
-        xBRIEFInfo: { version: "0.8" },
-        plan: {
-            title: "Blocked scope",
-            status: "blocked",
-            references: [
-                {
-                    uri: `https://github.com/${repo}/issues/${issueNumber}`,
-                    type: "x-vbrief/github-issue",
-                    title: `Issue #${issueNumber}`,
-                },
-            ],
-        },
-    })}\n`, { encoding: "utf8" });
-}
-function writeSliceRecords(root, records) {
-    const dir = join(root, "xbrief", ".triage-cache");
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, "slices.jsonl"), `${records.map((record) => JSON.stringify(record)).join("\n")}\n`, { encoding: "utf8" });
-}
-/** Build a throwaway project root with optional queue fixtures. */
-export function buildFixtureRepo(options = {}) {
-    const root = mkdtempSync(join(tmpdir(), "deft-triage-queue-parity-"));
-    const repo = options.repo ?? DEFAULT_REPO;
-    mkdirSync(join(root, "xbrief"), { recursive: true });
-    writeProjectDefinition(root, options.rankingLabels);
-    for (const issue of options.issues ?? []) {
-        writeCachedIssue(root, repo, issue);
-    }
-    if (options.auditEntries !== undefined && options.auditEntries.length > 0) {
-        writeAuditLog(root, repo, options.auditEntries);
-    }
-    for (const issueNumber of options.activeIssueNumbers ?? []) {
-        writeActiveScope(root, repo, issueNumber, `active-${issueNumber}.xbrief.json`);
-    }
-    for (const issueNumber of options.blockedIssueNumbers ?? []) {
-        writeBlockedScope(root, repo, issueNumber, `blocked-${issueNumber}.xbrief.json`);
-    }
-    if (options.sliceRecords !== undefined && options.sliceRecords.length > 0) {
-        writeSliceRecords(root, options.sliceRecords);
-    }
-    return root;
-}
-/** Diff one parity case between Python oracle and TS CLI. */
-export function diffCase(python, ts, caseName) {
-    const pyOut = normalizeOutput(python.stdout);
-    const tsOut = normalizeOutput(ts.stdout);
-    const pyErr = normalizeOutput(python.stderr);
-    const tsErr = normalizeOutput(ts.stderr);
-    return {
-        caseName,
-        exitMismatch: python.exitCode !== ts.exitCode,
-        stdoutMismatch: pyOut !== tsOut,
-        stderrMismatch: pyErr !== tsErr,
-        pythonExit: python.exitCode,
-        tsExit: ts.exitCode,
-    };
-}
-export const PARITY_CASES = [
-    {
-        name: "missing-repo",
-        argv: ["--project-root", "<ROOT>"],
-        skipFixture: true,
-    },
-    {
-        name: "empty-cache",
-        argv: ["--project-root", "<ROOT>", "--repo", DEFAULT_REPO, "--limit", "0"],
-        fixture: {},
-    },
-    {
-        name: "group-order",
-        argv: ["--project-root", "<ROOT>", "--repo", DEFAULT_REPO, "--limit", "0"],
-        fixture: {
-            issues: [
-                { number: 1, title: "Untriaged", updatedAt: "2026-05-17T12:00:00Z" },
-                { number: 2, title: "Resume", updatedAt: "2026-05-17T11:00:00Z" },
-                { number: 3, title: "Urgent", updatedAt: "2026-05-15T10:00:00Z" },
-                { number: 4, title: "Other", updatedAt: "2026-05-14T10:00:00Z" },
-            ],
-            auditEntries: [
-                { issueNumber: 3, decision: "needs-ac", timestamp: "2026-05-15T11:00:00Z" },
-                { issueNumber: 4, decision: "defer", timestamp: "2026-05-14T11:00:00Z" },
-            ],
-            activeIssueNumbers: [2],
-        },
-    },
-    {
-        name: "orphan-above-resume",
-        argv: ["--project-root", "<ROOT>", "--repo", DEFAULT_REPO, "--limit", "0"],
-        fixture: {
-            issues: [
-                { number: 10, title: "Umbrella closed", state: "closed" },
-                { number: 11, title: "Orphan child", state: "open", updatedAt: "2026-05-16T10:00:00Z" },
-                { number: 12, title: "Resume child", state: "open", updatedAt: "2026-05-17T10:00:00Z" },
-            ],
-            activeIssueNumbers: [12],
-            sliceRecords: [
-                {
-                    slice_id: "slice-1",
-                    umbrella: 10,
-                    umbrella_url: "https://github.com/owner/repo/issues/10",
-                    children: [
-                        { n: 11, url: "https://github.com/owner/repo/issues/11", wave: 1, role: "child" },
-                    ],
-                },
-            ],
-        },
-    },
-    {
-        name: "resume-eligible",
-        argv: ["--project-root", "<ROOT>", "--repo", DEFAULT_REPO, "--limit", "0"],
-        fixture: {
-            issues: [
-                { number: 20, title: "Resume eligible", updatedAt: "2026-05-17T10:00:00Z" },
-                { number: 21, title: "Untriaged", updatedAt: "2026-05-17T11:00:00Z" },
-            ],
-            auditEntries: [
-                { issueNumber: 20, decision: "resume-eligible", timestamp: "2026-05-17T09:00:00Z" },
-            ],
-        },
-    },
-    {
-        name: "ranking-labels",
-        argv: ["--project-root", "<ROOT>", "--repo", DEFAULT_REPO, "--limit", "0"],
-        fixture: {
-            rankingLabels: ["urgent", "breaking-change"],
-            issues: [
-                { number: 30, title: "Unranked", updatedAt: "2026-05-17T10:00:00Z" },
-                {
-                    number: 31,
-                    title: "Breaking",
-                    labels: ["breaking-change"],
-                    updatedAt: "2026-05-15T10:00:00Z",
-                },
-                { number: 32, title: "Urgent", labels: ["urgent"], updatedAt: "2026-05-16T10:00:00Z" },
-            ],
-        },
-    },
-    {
-        name: "limit-cap",
-        argv: ["--project-root", "<ROOT>", "--repo", DEFAULT_REPO, "--limit", "2"],
-        fixture: {
-            issues: [
-                { number: 40, updatedAt: "2026-05-17T10:00:00Z" },
-                { number: 41, updatedAt: "2026-05-16T10:00:00Z" },
-                { number: 42, updatedAt: "2026-05-15T10:00:00Z" },
-            ],
-        },
-    },
-    {
-        name: "blocked-demoted",
-        argv: ["--project-root", "<ROOT>", "--repo", DEFAULT_REPO, "--limit", "0"],
-        fixture: {
-            issues: [
-                { number: 50, title: "Blocked", updatedAt: "2026-05-17T10:00:00Z" },
-                { number: 51, title: "Open", updatedAt: "2026-05-16T10:00:00Z" },
-            ],
-            blockedIssueNumbers: [50],
-        },
-    },
-    {
-        name: "include-blocked",
-        argv: ["--project-root", "<ROOT>", "--repo", DEFAULT_REPO, "--limit", "0", "--include-blocked"],
-        fixture: {
-            issues: [
-                { number: 60, title: "Blocked", updatedAt: "2026-05-17T10:00:00Z" },
-                { number: 61, title: "Open", updatedAt: "2026-05-16T10:00:00Z" },
-            ],
-            blockedIssueNumbers: [60],
-        },
-    },
-];
-/** Augment argv with fixture audit/slices hooks when present. */
-export function augmentParityArgv(testCase, root) {
-    const argv = testCase.argv.map((arg) => (arg === "<ROOT>" ? root : arg));
-    if (testCase.skipFixture || testCase.fixture === undefined) {
-        return argv;
-    }
-    const extras = [];
-    if (testCase.fixture.auditEntries !== undefined && testCase.fixture.auditEntries.length > 0) {
-        extras.push("--audit-log", join(root, "xbrief", ".triage-cache", "candidates.jsonl"));
-    }
-    if (testCase.fixture.sliceRecords !== undefined && testCase.fixture.sliceRecords.length > 0) {
-        extras.push("--slices-log", join(root, "xbrief", ".triage-cache", "slices.jsonl"));
-    }
-    return [...argv, ...extras];
-}
-/** Run all parity cases; returns aggregate result. */
-export function renderReport(result) {
-    if (result.ok) {
-        return `triage:queue parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} cases.`;
-    }
-    const lines = ["triage:queue parity: DIVERGENCE"];
-    for (const diff of result.diffs) {
-        if (diff.exitMismatch || diff.stdoutMismatch || diff.stderrMismatch) {
-            lines.push(`  case: ${diff.caseName}`);
-            if (diff.exitMismatch) {
-                lines.push(`    exit: python=${diff.pythonExit} ts=${diff.tsExit}`);
-            }
-            if (diff.stdoutMismatch) {
-                lines.push("    stdout mismatch");
-            }
-            if (diff.stderrMismatch) {
-                lines.push("    stderr mismatch");
-            }
-        }
-    }
-    return lines.join("\n");
-}
-//# sourceMappingURL=triage-queue-fixtures.js.map

package/dist/triage-queue.d.ts

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-import { type LiveOpenIssuesReader, type ResolveAuthenticatedLogin } from "@deftai/directive-core/dist/triage/queue/index.js";
-export type ShowFormat = "default" | "operator";
-interface CommonArgs {
-    projectRoot: string;
-    repo: string | null;
-    cacheRoot: string | null;
-    auditLog: string | null;
-    error?: string;
-}
-interface QueueArgs extends CommonArgs {
-    cmd: "queue";
-    limit: number;
-    includeBlocked: boolean;
-    reconcile: boolean;
-    slicesLog: string | null;
-    /** Raw --author value (LOGIN, @me, or comma allow-list); null = no filter (#3129). */
-    author: string | null;
-}
-interface ShowArgs extends CommonArgs {
-    cmd: "show";
-    number: number | null;
-    format: ShowFormat;
-}
-/** Parse triage-queue CLI args (queue subcommand — default). */
-export declare function parseArgs(argv: string[]): QueueArgs;
-/** Parse show subcommand args. */
-export declare function parseShowArgs(argv: string[]): ShowArgs;
-/** Optional injection seams for `run` (tests supply stubs). */
-export interface RunOptions {
-    readonly liveOpenReader?: LiveOpenIssuesReader;
-    /** Override `@me` resolution for hermetic tests (#3129). */
-    readonly resolveAuthenticatedLogin?: ResolveAuthenticatedLogin;
-}
-/** Run triage:queue or triage:show and return process exit code. */
-export declare function run(argv: string[], options?: RunOptions): number;
-export {};
-//# sourceMappingURL=triage-queue.d.ts.map