@deftai/directive 0.126.0-beta.2 → 0.126.0

package/dist/triage-scope-fixtures.js

@@ -0,0 +1,131 @@
+/** 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";
+/** Strip volatile absolute paths before compare. */
+export function normalizeOutput(text) {
+    return text
+        .replace(/--project-root [^\s]+/g, "--project-root <ROOT>")
+        .replace(/--cache-root [^\s]+/g, "--cache-root <ROOT>")
+        .replace(/path=[^\s\n]+coverage\.json/g, "path=<ROOT>/coverage.json");
+}
+function writeProjectDefinition(root, policy = {}) {
+    const dir = join(root, "xbrief");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "PROJECT-DEFINITION.xbrief.json"), `${JSON.stringify({
+        xBRIEFInfo: { version: "0.8" },
+        plan: { title: "T", status: "running", items: [], policy },
+    }, null, 2)}\n`, "utf8");
+}
+export function buildFixtureRepo(options = {}) {
+    const root = mkdtempSync(join(tmpdir(), "deft-triage-scope-parity-"));
+    mkdirSync(join(root, "xbrief"), { recursive: true });
+    writeProjectDefinition(root, options.policy ?? {});
+    return root;
+}
+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",
+        argv: ["--list"],
+    },
+    {
+        name: "list-custom-scope-ignores",
+        argv: ["--list"],
+        fixture: {
+            policy: {
+                triageScope: [{ rule: "labels", "any-of": ["bug"] }],
+                triageScopeIgnores: [
+                    { label: "wontfix" },
+                    { rule: "author", "any-of": ["dependabot[bot]"] },
+                ],
+            },
+        },
+    },
+    {
+        name: "add-label",
+        argv: ["--add-label=priority:p0"],
+    },
+    {
+        name: "add-milestone",
+        argv: ["--add-milestone=v2.0-blocker"],
+    },
+    {
+        name: "ignore-label",
+        argv: ["--ignore-label=wontfix"],
+    },
+    {
+        name: "mutations-mutually-exclusive",
+        argv: ["--add-label=bug", "--ignore-label=wontfix"],
+    },
+    {
+        name: "diff-from-upstream-missing-repo",
+        argv: ["--diff-from-upstream"],
+        fixture: { policy: {} },
+    },
+    {
+        name: "refresh-denominator-missing-repo",
+        argv: ["--refresh-denominator", "--count", "10"],
+    },
+    {
+        name: "invalid-project-root",
+        argv: ["--list"],
+        fixture: undefined,
+    },
+    {
+        name: "schema-error",
+        argv: ["--list"],
+        fixture: {
+            policy: {
+                triageScope: [{ rule: "bogus-type" }],
+            },
+        },
+    },
+    {
+        name: "refresh-denominator-success",
+        argv: [
+            "--refresh-denominator",
+            "--repo",
+            "deftai/directive",
+            "--count",
+            "247",
+            "--source",
+            "github-issue",
+        ],
+        fixture: {
+            policy: { triageScope: [{ rule: "all-open" }] },
+        },
+    },
+];
+export function renderReport(result) {
+    if (result.ok) {
+        return `triage:scope parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} cases.`;
+    }
+    const lines = ["triage:scope 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");
+}
+//# sourceMappingURL=triage-scope-fixtures.js.map

package/dist/triage-scope.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+/** Run triage:scope with argv; returns process exit code. */
+export declare function run(argv: string[]): number;
+//# sourceMappingURL=triage-scope.d.ts.map

package/dist/triage-scope.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * Thin CLI entry for triage:scope (#1725).
+ * Delegates to the core implementation at packages/core/dist/triage/scope/cli.js.
+ */
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+const require = createRequire(import.meta.url);
+// Resolve the core CLI by its published package name so it works both in the
+// source monorepo and under a flattened npm install (#1993). The bare specifier
+// resolves via @deftai/directive-core's "./dist/*.js" export map; a hand-built
+// relative path would point at the non-existent "@deftai/core" once published.
+function coreCliPath() {
+    return require.resolve("@deftai/directive-core/dist/triage/scope/cli.js");
+}
+/** Run triage:scope with argv; returns process exit code. */
+export function run(argv) {
+    const result = spawnSync(process.execPath, [coreCliPath(), ...argv], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (typeof result.stdout === "string" && result.stdout.length > 0) {
+        process.stdout.write(result.stdout);
+    }
+    if (typeof result.stderr === "string" && result.stderr.length > 0) {
+        process.stderr.write(result.stderr);
+    }
+    return result.status ?? 2;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-scope.js.map

package/dist/triage-smoketest.d.ts

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

package/dist/triage-smoketest.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import { existsSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { interceptHelp } from "@deftai/directive-core/dist/triage/help/index.js";
+import { DEFAULT_FIXTURE_REL, parseSmoketestArgs, runSmoketest, } from "@deftai/directive-core/dist/triage/smoketest/index.js";
+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)), "..", "..", "..");
+}
+export function run(argv) {
+    const helpRc = interceptHelp("triage_smoketest", argv);
+    if (helpRc !== null) {
+        return helpRc;
+    }
+    const args = parseSmoketestArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`${args.error}\n`);
+        return 2;
+    }
+    if (args.showHelp) {
+        return 0;
+    }
+    const deftRoot = resolveDeftRoot();
+    const fixtureRoot = resolve(args.fixture !== "" ? args.fixture : join(deftRoot, DEFAULT_FIXTURE_REL));
+    if (!existsSync(fixtureRoot) || !statSync(fixtureRoot).isDirectory()) {
+        process.stderr.write(`[triage:smoketest] FAIL: fixture root ${fixtureRoot} does not exist ` +
+            "or is not a directory.\n");
+        return 1;
+    }
+    return runSmoketest(fixtureRoot, {
+        verbose: args.verbose,
+        keepTempdir: args.keepTempdir,
+        cacheOnly: args.cacheOnly,
+        deftRoot,
+    });
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-smoketest.js.map

package/dist/triage-strip-withdrawn.d.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { type ListWithdrawnChipIssues } from "@deftai/directive-core/dist/triage/classify/withdraw.js";
+import type { LabelClient } from "@deftai/directive-core/dist/vbrief-reconcile/types.js";
+export interface StripParsedArgs {
+    projectRoot: string;
+    apply: boolean;
+    json: boolean;
+    emitDigest: boolean;
+    repo: string | null;
+    error?: string;
+}
+export declare function parseStripArgs(argv: string[]): StripParsedArgs;
+export interface StripRunOptions {
+    readonly labelClient?: LabelClient;
+    readonly resolveDefaultRepo?: () => string | null;
+    readonly listIssues?: ListWithdrawnChipIssues;
+}
+export declare function runStripWithdrawn(argv: string[], options?: StripRunOptions): number;
+/** Dispatch handler name (`CLI_MODULE_VERBS` looks for `run`). */
+export declare const run: typeof runStripWithdrawn;
+//# sourceMappingURL=triage-strip-withdrawn.d.ts.map

package/dist/triage-strip-withdrawn.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { resolveRepoFromGitOrigin } from "@deftai/directive-core/dist/scm/design-critique-chip.js";
+import { classifyIssue, resolveClassifyRules, resolveHoldMarkers, } from "@deftai/directive-core/dist/triage/classify/index.js";
+import { CLASSIFY_MIRROR_WITHDRAWN_MESSAGE, stripWithdrawnChips, } from "@deftai/directive-core/dist/triage/classify/withdraw.js";
+export function parseStripArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        apply: false,
+        json: false,
+        emitDigest: false,
+        repo: null,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--apply") {
+            parsed.apply = true;
+        }
+        else if (arg === "--json") {
+            parsed.json = true;
+        }
+        else if (arg === "--emit-digest") {
+            parsed.emitDigest = 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 === "--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 === "--help" || arg === "-h") {
+            return parsed;
+        }
+        else if (arg === "--") {
+        }
+        else if (arg?.startsWith("-")) {
+            return { ...parsed, error: `unrecognized arguments: ${arg}` };
+        }
+    }
+    return parsed;
+}
+export function runStripWithdrawn(argv, options = {}) {
+    const args = parseStripArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`ERR: ${args.error}\n`);
+        return 2;
+    }
+    const repo = args.repo ?? (options.resolveDefaultRepo ?? resolveRepoFromGitOrigin)();
+    if (repo === null || repo.length === 0) {
+        process.stderr.write("ERR: missing --repo OWNER/NAME (could not resolve from git origin)\n");
+        return 2;
+    }
+    const rules = resolveClassifyRules({ projectRoot: args.projectRoot });
+    const holdMarkers = resolveHoldMarkers({ projectRoot: args.projectRoot });
+    const [code, outcome] = stripWithdrawnChips({
+        repo,
+        dryRun: !args.apply,
+        emitDigest: args.emitDigest,
+        classify: args.emitDigest
+            ? (issue, opts) => classifyIssue(issue, {
+                rules: opts?.rules ?? rules,
+                holdMarkers: opts?.holdMarkers ?? holdMarkers,
+            })
+            : undefined,
+        rules,
+        holdMarkers,
+        ...(options.labelClient !== undefined ? { client: options.labelClient } : {}),
+        ...(options.listIssues !== undefined ? { listIssues: options.listIssues } : {}),
+    });
+    if (args.json) {
+        process.stdout.write(`${JSON.stringify(outcome, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(`strip-withdrawn-chips repo=${outcome.repo} dry-run=${outcome.dry_run} ` +
+            `scanned=${outcome.scanned} planned=${outcome.planned} applied=${outcome.applied} ` +
+            `unchanged=${outcome.unchanged} errors=${outcome.errors}\n`);
+        process.stdout.write(`${CLASSIFY_MIRROR_WITHDRAWN_MESSAGE}\n`);
+    }
+    return code;
+}
+/** Dispatch handler name (`CLI_MODULE_VERBS` looks for `run`). */
+export const run = runStripWithdrawn;
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(runStripWithdrawn(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-strip-withdrawn.js.map

package/dist/triage-subscribe.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    op: string;
+    projectRoot: string;
+    label: string | null;
+    milestone: string | null;
+    issue: number | null;
+    issueNote: string;
+    actor: string | null;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=triage-subscribe.d.ts.map

package/dist/triage-subscribe.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+import { existsSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { interceptHelp } from "@deftai/directive-core/dist/triage/help/index.js";
+import { RECONCILE_HINT, subscribe, unsubscribe, } from "@deftai/directive-core/dist/triage/subscribe/index.js";
+export function parseArgs(argv) {
+    const parsed = {
+        op: "",
+        projectRoot: process.env.DEFT_PROJECT_ROOT ?? ".",
+        label: null,
+        milestone: null,
+        issue: null,
+        issueNote: "added via task triage:subscribe",
+        actor: null,
+    };
+    const positional = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        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 === "--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 === "--milestone") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --milestone: expected one argument" };
+            }
+            parsed.milestone = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--milestone=")) {
+            parsed.milestone = arg.slice("--milestone=".length);
+        }
+        else if (arg === "--issue") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --issue: expected one argument" };
+            }
+            parsed.issue = Number.parseInt(value, 10);
+            i += 1;
+        }
+        else if (arg.startsWith("--issue=")) {
+            parsed.issue = Number.parseInt(arg.slice("--issue=".length), 10);
+        }
+        else if (arg === "--issue-note") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --issue-note: expected one argument" };
+            }
+            parsed.issueNote = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--issue-note=")) {
+            parsed.issueNote = arg.slice("--issue-note=".length);
+        }
+        else if (arg === "--actor") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --actor: expected one argument" };
+            }
+            parsed.actor = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--actor=")) {
+            parsed.actor = arg.slice("--actor=".length);
+        }
+        else if (arg.startsWith("-")) {
+            return { ...parsed, error: `unrecognized arguments: ${arg}` };
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    if (positional.length > 0 && positional[0] !== undefined) {
+        parsed.op = positional[0];
+    }
+    return parsed;
+}
+export function run(argv) {
+    const helpRc = interceptHelp("triage_subscribe", argv);
+    if (helpRc !== null) {
+        return helpRc;
+    }
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`${args.error}\n`);
+        return 2;
+    }
+    if (args.op !== "subscribe" && args.op !== "unsubscribe") {
+        process.stderr.write("triage:subscribe: first positional arg must be 'subscribe' or " +
+            "'unsubscribe'; e.g. task triage:subscribe -- --label=bug\n");
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    if (!existsSync(projectRoot) || !statSync(projectRoot).isDirectory()) {
+        process.stderr.write(`triage:${args.op}: --project-root ${projectRoot} does not exist ` +
+            "or is not a directory.\n");
+        return 2;
+    }
+    const chosen = [args.label, args.milestone, args.issue].filter((v) => v !== null).length;
+    if (chosen !== 1) {
+        process.stderr.write(`triage:${args.op}: exactly one of --label / --milestone / --issue is required.\n`);
+        return 2;
+    }
+    try {
+        const [changed, message] = args.op === "subscribe"
+            ? subscribe(projectRoot, {
+                label: args.label,
+                milestone: args.milestone,
+                issue: args.issue,
+                issueNote: args.issueNote,
+                actor: args.actor,
+            })
+            : unsubscribe(projectRoot, {
+                label: args.label,
+                milestone: args.milestone,
+                issue: args.issue,
+                actor: args.actor,
+            });
+        if (!changed) {
+            process.stderr.write(`triage:${args.op}: ${message} (no-op).\n`);
+            return 0;
+        }
+        process.stdout.write(`triage:${args.op}: ${message}.\n`);
+        process.stderr.write(`${RECONCILE_HINT}\n`);
+        return 0;
+    }
+    catch (exc) {
+        process.stderr.write(`triage:${args.op}: ${String(exc)}\n`);
+        return 1;
+    }
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-subscribe.js.map

package/dist/triage-summary.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    cacheRoot: string | null;
+    noHistory: boolean;
+    json: boolean;
+    error?: string;
+}
+/** Parse triage-summary CLI args, mirroring the Python argparse surface. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the triage:summary CLI — always returns exit code 0. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=triage-summary.d.ts.map

package/dist/triage-summary.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ensureTriageCacheHydrated } from "@deftai/directive-core/dist/cache/empty-populate.js";
+import { resolveTriageCachePath } from "@deftai/directive-core/dist/triage/cache-path.js";
+import { appendHistory, computeSummary, formatSummary, pythonStyleStringify, summaryResultToRecord, utcIso, } from "@deftai/directive-core/dist/triage/summary/index.js";
+/** Parse triage-summary CLI args, mirroring the Python argparse surface. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        cacheRoot: null,
+        noHistory: false,
+        json: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--no-history") {
+            parsed.noHistory = true;
+        }
+        else if (arg === "--json") {
+            parsed.json = 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 === "--cache-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --cache-root: expected one argument" };
+            }
+            parsed.cacheRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--cache-root=")) {
+            parsed.cacheRoot = arg.slice("--cache-root=".length);
+        }
+        else if (arg !== undefined && arg.length > 0) {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Run the triage:summary CLI — always returns exit code 0. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`triage_summary: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const cacheRoot = args.cacheRoot !== null ? resolve(args.cacheRoot) : undefined;
+    ensureTriageCacheHydrated(projectRoot, {
+        cacheRoot,
+        repo: process.env.DEFT_TRIAGE_REPO ?? null,
+    });
+    const result = computeSummary(projectRoot, { cacheRoot });
+    const line = formatSummary(result);
+    const emittedAt = utcIso();
+    if (args.json) {
+        const record = summaryResultToRecord(result, { emittedAt, line });
+        process.stdout.write(`${pythonStyleStringify(record)}\n`);
+    }
+    else {
+        process.stdout.write(`${line}\n`);
+    }
+    if (!args.noHistory) {
+        const historyPath = resolveTriageCachePath(projectRoot, "summary-history.jsonl");
+        appendHistory(historyPath, result, line, { emittedAt });
+    }
+    return 0;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=triage-summary.js.map

package/dist/triage-welcome.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    onboard: boolean;
+    noHistory: boolean;
+    taskPrefix: string;
+    preset: string | null;
+    wipCap: number | null;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=triage-welcome.d.ts.map