@deftai/directive 0.55.0

package/dist/triage-bootstrap.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+import { statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+async function loadBootstrapModule() {
+    const corePath = join(dirname(fileURLToPath(import.meta.url)), "../../core/dist/triage/bootstrap/index.js");
+    return import(pathToFileURL(corePath).href);
+}
+/** Parse triage-bootstrap CLI args, mirroring the Python argparse surface. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: process.env.DEFT_PROJECT_ROOT ?? ".",
+        repo: process.env.DEFT_TRIAGE_REPO ?? null,
+        labels: [],
+        fetchTimeoutS: Number.NaN,
+        quiet: false,
+        emitJson: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--quiet") {
+            parsed.quiet = true;
+        }
+        else if (arg === "--json") {
+            parsed.emitJson = true;
+        }
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --repo: expected one argument" };
+            }
+            parsed.repo = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--repo=")) {
+            parsed.repo = arg.slice("--repo=".length);
+        }
+        else if (arg === "--limit") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --limit: expected one argument" };
+            }
+            parsed.limit = Number.parseInt(value, 10);
+            i += 1;
+        }
+        else if (arg === "--state") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --state: expected one argument" };
+            }
+            if (value !== "open" && value !== "closed" && value !== "all") {
+                return {
+                    ...parsed,
+                    error: `invalid choice: '${value}' (choose from 'open', 'closed', 'all')`,
+                };
+            }
+            parsed.state = value;
+            i += 1;
+        }
+        else if (arg === "--label") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --label: expected one argument" };
+            }
+            parsed.labels.push(value);
+            i += 1;
+        }
+        else if (arg === "--author") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --author: expected one argument" };
+            }
+            parsed.author = value;
+            i += 1;
+        }
+        else if (arg === "--batch-size") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --batch-size: expected one argument" };
+            }
+            parsed.batchSize = Number.parseInt(value, 10);
+            i += 1;
+        }
+        else if (arg === "--delay-ms") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --delay-ms: expected one argument" };
+            }
+            parsed.delayMs = Number.parseInt(value, 10);
+            i += 1;
+        }
+        else if (arg === "--fetch-timeout-s") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --fetch-timeout-s: expected one argument" };
+            }
+            parsed.fetchTimeoutS = Number.parseFloat(value);
+            i += 1;
+        }
+        else {
+            return { ...parsed, error: `unrecognized arguments: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Run triage:bootstrap with an injected core module (test seam). */
+export async function runWithModule(mod, argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`triage_bootstrap: ${args.error}\n`);
+        return 2;
+    }
+    const fetchTimeoutS = Number.isNaN(args.fetchTimeoutS)
+        ? mod.defaultFetchTimeoutFromEnv()
+        : args.fetchTimeoutS;
+    const projectRoot = resolve(args.projectRoot);
+    let isDir = false;
+    try {
+        isDir = statSync(projectRoot).isDirectory();
+    }
+    catch {
+        isDir = false;
+    }
+    if (!isDir) {
+        process.stderr.write(`❌ triage:bootstrap: --project-root ${projectRoot} does not exist or is not a directory.\n`);
+        return 2;
+    }
+    const labels = mod.normaliseLabelFilter(args.labels);
+    const result = await mod.runBootstrap(projectRoot, args.repo, {
+        batchSize: args.batchSize,
+        delayMs: args.delayMs,
+        state: args.state,
+        limit: args.limit,
+        labels,
+        author: args.author,
+        fetchTimeoutS,
+        progress: args.quiet ? null : mod.PROGRESS_DEFAULT,
+    });
+    if (args.emitJson) {
+        process.stdout.write(`${mod.formatJson(result)}\n`);
+    }
+    else {
+        process.stdout.write(`${mod.formatSummary(result)}\n`);
+    }
+    return result.exitCode;
+}
+/** Run triage:bootstrap and return the process exit code. */
+export async function run(argv) {
+    return runWithModule(await loadBootstrapModule(), argv);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    run(process.argv.slice(2))
+        .then((code) => {
+        process.exit(code);
+    })
+        .catch((err) => {
+        process.stderr.write(`triage_bootstrap: ${String(err)}\n`);
+        process.exit(2);
+    });
+}
+//# sourceMappingURL=triage-bootstrap.js.map

package/dist/triage-bulk.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    action: string;
+    repo: string;
+    label: string | null;
+    author: string | null;
+    ageDays: number | null;
+    cluster: string | null;
+    reason: string | null;
+    reAction: boolean;
+    showHelp: boolean;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=triage-bulk.d.ts.map

package/dist/triage-bulk.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { bulkActionWithDefaults, CacheEmptyError } from "../../core/dist/triage/bulk/index.js";
+import { interceptHelp } from "../../core/dist/triage/help/index.js";
+export function parseArgs(argv) {
+    const parsed = {
+        action: "",
+        repo: "",
+        label: null,
+        author: null,
+        ageDays: null,
+        cluster: null,
+        reason: null,
+        reAction: false,
+        showHelp: false,
+    };
+    const positional = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        if (arg === "--help" || arg === "-h") {
+            parsed.showHelp = true;
+        }
+        else if (arg === "--re-action") {
+            parsed.reAction = true;
+        }
+        else if (arg === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --repo: expected one argument" };
+            }
+            parsed.repo = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--repo=")) {
+            parsed.repo = arg.slice("--repo=".length);
+        }
+        else if (arg === "--label") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --label: expected one argument" };
+            }
+            parsed.label = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--label=")) {
+            parsed.label = arg.slice("--label=".length);
+        }
+        else if (arg === "--author") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --author: expected one argument" };
+            }
+            parsed.author = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--author=")) {
+            parsed.author = arg.slice("--author=".length);
+        }
+        else if (arg === "--age-days") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --age-days: expected one argument" };
+            }
+            parsed.ageDays = Number.parseInt(value, 10);
+            i += 1;
+        }
+        else if (arg.startsWith("--age-days=")) {
+            parsed.ageDays = Number.parseInt(arg.slice("--age-days=".length), 10);
+        }
+        else if (arg === "--cluster") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --cluster: expected one argument" };
+            }
+            parsed.cluster = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--cluster=")) {
+            parsed.cluster = arg.slice("--cluster=".length);
+        }
+        else if (arg === "--reason") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --reason: expected one argument" };
+            }
+            parsed.reason = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--reason=")) {
+            parsed.reason = arg.slice("--reason=".length);
+        }
+        else if (arg.startsWith("-")) {
+            return { ...parsed, error: `unrecognized arguments: ${arg}` };
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    if (positional.length > 0 && positional[0] !== undefined) {
+        parsed.action = positional[0];
+    }
+    return parsed;
+}
+export function run(argv) {
+    const helpRc = interceptHelp("triage_bulk", argv);
+    if (helpRc !== null) {
+        return helpRc;
+    }
+    const args = parseArgs(argv);
+    if (args.showHelp && args.action === "") {
+        return 0;
+    }
+    if (args.error !== undefined) {
+        process.stderr.write(`${args.error}\n`);
+        return 2;
+    }
+    if (!["accept", "reject", "defer", "needs-ac"].includes(args.action)) {
+        process.stderr.write("triage_bulk: action required (accept|reject|defer|needs-ac)\n");
+        return 2;
+    }
+    if (args.repo === "") {
+        process.stderr.write("triage_bulk: --repo is required\n");
+        return 2;
+    }
+    const projectRoot = process.cwd();
+    const frameworkRoot = resolve(process.env.DEFT_ROOT ?? projectRoot);
+    try {
+        bulkActionWithDefaults(args.action, args.repo, {
+            label: args.label,
+            author: args.author,
+            ageDays: args.ageDays,
+            cluster: args.cluster,
+            reason: args.reason,
+            reAction: args.reAction,
+            deftRoot: projectRoot,
+            scriptsDir: join(frameworkRoot, "scripts"),
+        });
+    }
+    catch (exc) {
+        if (exc instanceof CacheEmptyError) {
+            process.stderr.write(`${exc.message}\n`);
+            return 2;
+        }
+        throw exc;
+    }
+    return 0;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-bulk.js.map

package/dist/triage-classify-parity.d.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+export interface CommandCapture {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface FixtureOptions {
+    readonly plan?: Record<string, unknown>;
+    readonly omitProjectDefinition?: boolean;
+    readonly rawProjectDefinition?: Record<string, unknown>;
+}
+export interface ParityCase {
+    readonly name: string;
+    readonly argv: readonly string[];
+    readonly fixture?: FixtureOptions;
+    readonly useRepoRoot?: 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: ParityDiff[];
+}
+/** Strip volatile absolute paths before compare. */
+export declare function normalizeOutput(text: string): string;
+/** Build a throwaway project root with optional PROJECT-DEFINITION. */
+export declare function buildFixtureRepo(options?: FixtureOptions): 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[];
+/** Run all parity cases; returns aggregate result. */
+export declare function runParity(): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=triage-classify-parity.d.ts.map

package/dist/triage-classify-parity.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1725): runs BOTH the Python oracle
+ * (`scripts/triage_classify.py`) and the ported TS triage-classify CLI with
+ * identical argv, then diffs exit codes and normalised stdout/stderr.
+ *
+ * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
+ */
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Strip volatile absolute paths before compare. */
+export function normalizeOutput(text) {
+    return (text
+        .replace(/project_root=[^\s)]+/g, "project_root=<ROOT>")
+        // Match the parity temp root regardless of platform tmpdir prefix
+        // (/tmp on Linux, /var/folders/... on macOS, etc.).
+        .replace(/\S*deft-triage-classify-parity-[^\s/]+/g, "<TMPROOT>"));
+}
+function runCapture(cmd, args, cwd, env = {}) {
+    const merged = { ...process.env, ...env };
+    for (const key of Object.keys(merged)) {
+        if (merged[key] === undefined)
+            delete merged[key];
+    }
+    const result = spawnSync(cmd, args, {
+        cwd,
+        encoding: "utf8",
+        env: merged,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return {
+        status: result.status ?? 2,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr: typeof result.stderr === "string" ? result.stderr : "",
+    };
+}
+function writeProjectDefinition(root, plan) {
+    const dir = join(root, "vbrief");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "PROJECT-DEFINITION.vbrief.json"), `${JSON.stringify({
+        vBRIEFInfo: { version: "0.6" },
+        plan: { title: "T", status: "running", items: [], ...plan },
+    }, null, 2)}\n`, { encoding: "utf8" });
+}
+/** Build a throwaway project root with optional PROJECT-DEFINITION. */
+export function buildFixtureRepo(options = {}) {
+    const root = mkdtempSync(join(tmpdir(), "deft-triage-classify-parity-"));
+    mkdirSync(join(root, "vbrief"), { recursive: true });
+    if (options.rawProjectDefinition !== undefined) {
+        writeFileSync(join(root, "vbrief", "PROJECT-DEFINITION.vbrief.json"), `${JSON.stringify(options.rawProjectDefinition, null, 2)}\n`, { encoding: "utf8" });
+    }
+    else if (!options.omitProjectDefinition && options.plan !== undefined) {
+        writeProjectDefinition(root, options.plan);
+    }
+    else if (!options.omitProjectDefinition) {
+        writeProjectDefinition(root, {});
+    }
+    return root;
+}
+function resolveDeftRoot() {
+    if (process.env.DEFT_ROOT !== undefined && process.env.DEFT_ROOT.length > 0) {
+        return resolve(process.env.DEFT_ROOT);
+    }
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+}
+function runPythonClassify(deftRoot, repo, argv) {
+    const cap = runCapture("uv", [
+        "run",
+        "python",
+        join(deftRoot, "scripts", "triage_classify.py"),
+        ...argv,
+        "--project-root",
+        repo,
+    ], deftRoot);
+    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+}
+function runTsClassify(deftRoot, repo, argv) {
+    const cap = runCapture("node", [
+        join(deftRoot, "packages", "cli", "dist", "triage-classify.js"),
+        ...argv,
+        "--project-root",
+        repo,
+    ], deftRoot);
+    return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+}
+/** 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: "list-default-repo-root",
+        argv: ["--list"],
+        useRepoRoot: true,
+    },
+    {
+        name: "list-no-project-definition",
+        argv: ["--list"],
+        fixture: { omitProjectDefinition: true },
+    },
+    {
+        name: "validate-no-project-definition",
+        argv: ["--validate"],
+        fixture: { omitProjectDefinition: true },
+    },
+    {
+        name: "validate-valid-consumer-rules",
+        argv: ["--validate"],
+        fixture: {
+            plan: {
+                policy: {
+                    triageAutoClassify: [
+                        {
+                            match: { labels: { "any-of": ["bug"] } },
+                            action: "escalate",
+                            reason: "p0 bug",
+                        },
+                    ],
+                    triageHoldMarkers: ["BLOCKED", "WONTFIX"],
+                },
+            },
+        },
+    },
+    {
+        name: "validate-invalid-empty-match",
+        argv: ["--validate"],
+        fixture: {
+            plan: {
+                policy: {
+                    triageAutoClassify: [{ match: {}, action: "defer", reason: "??" }],
+                },
+            },
+        },
+    },
+    {
+        name: "validate-invalid-hold-markers",
+        argv: ["--validate"],
+        fixture: {
+            plan: {
+                policy: {
+                    triageHoldMarkers: "",
+                },
+            },
+        },
+    },
+    {
+        name: "validate-malformed-plan",
+        argv: ["--validate"],
+        fixture: {
+            rawProjectDefinition: {
+                vBRIEFInfo: { version: "0.6" },
+                plan: null,
+            },
+        },
+    },
+];
+/** Run all parity cases; returns aggregate result. */
+export function runParity() {
+    const deftRoot = resolveDeftRoot();
+    const diffs = [];
+    for (const testCase of PARITY_CASES) {
+        const pyRepo = testCase.useRepoRoot === true ? deftRoot : buildFixtureRepo(testCase.fixture ?? {});
+        const tsRepo = testCase.useRepoRoot === true ? deftRoot : buildFixtureRepo(testCase.fixture ?? {});
+        const ownsFixture = testCase.useRepoRoot !== true;
+        try {
+            const python = runPythonClassify(deftRoot, pyRepo, testCase.argv);
+            const ts = runTsClassify(deftRoot, tsRepo, testCase.argv);
+            diffs.push(diffCase(python, ts, testCase.name));
+        }
+        finally {
+            if (ownsFixture) {
+                rmSync(pyRepo, { recursive: true, force: true });
+                rmSync(tsRepo, { recursive: true, force: true });
+            }
+        }
+    }
+    const ok = diffs.every((d) => !d.exitMismatch && !d.stdoutMismatch && !d.stderrMismatch);
+    return { ok, diffs };
+}
+export function renderReport(result) {
+    if (result.ok) {
+        return `triage:classify parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} cases.`;
+    }
+    const lines = ["triage:classify parity: DIVERGENCE"];
+    for (const d of result.diffs) {
+        if (d.exitMismatch || d.stdoutMismatch || d.stderrMismatch) {
+            lines.push(`  case: ${d.caseName}`);
+            if (d.exitMismatch)
+                lines.push(`    exit: python=${d.pythonExit} ts=${d.tsExit}`);
+            if (d.stdoutMismatch)
+                lines.push("    stdout mismatch");
+            if (d.stderrMismatch)
+                lines.push("    stderr mismatch");
+        }
+    }
+    return lines.join("\n");
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    try {
+        const result = runParity();
+        if (result.ok) {
+            process.stdout.write(`${renderReport(result)}\n`);
+            process.exit(0);
+        }
+        process.stderr.write(`${renderReport(result)}\n`);
+        process.exit(1);
+    }
+    catch (err) {
+        process.stderr.write(`triage:classify parity: harness error -- ${String(err)}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=triage-classify-parity.js.map

package/dist/triage-classify.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    doList: boolean;
+    doValidate: boolean;
+    error?: string;
+}
+/** Parse triage-classify CLI args, mirroring the Python argparse surface. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the CLI and return the process exit code. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=triage-classify.d.ts.map