@deftai/directive 0.126.0-beta.2 → 0.126.1

package/dist/content-validate-cli/verify-capacity.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { verifyCapacity } from "@deftai/directive-core/validate-content";
+/** Parse verify-capacity CLI args, mirroring scripts/verify_capacity.py. */
+export function parseArgs(argv) {
+    const parsed = { projectRoot: ".", quiet: false };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--quiet") {
+            parsed.quiet = 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 {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Run the gate and return the process exit code. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`verify_capacity: ${args.error}\n`);
+        return 2;
+    }
+    const result = verifyCapacity.evaluate({
+        projectRoot: resolve(args.projectRoot),
+        quiet: args.quiet,
+    });
+    if (result.code === 0) {
+        if (!args.quiet && result.message.length > 0) {
+            process.stdout.write(`${result.message}\n`);
+        }
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+    }
+    return result.code;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-capacity.js.map

package/dist/coverage-hotspots.d.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    coverageDir: string | null;
+    minHeadroomPp: number | null;
+    baseRef: string | null;
+    pathFilter: string[];
+    useDiffPaths: boolean;
+    attemptId: string | null;
+    worktree: string | null;
+    evaluatorId: string | null;
+    json: boolean;
+    quiet: boolean;
+    error?: string;
+}
+/** Parse coverage-hotspots CLI args. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run coverage-hotspots and return the process exit code. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=coverage-hotspots.d.ts.map

package/dist/coverage-hotspots.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateCoverageHotspots, formatJsonReport } from "@deftai/directive-core";
+function parseNumber(raw) {
+    const value = Number.parseFloat(raw);
+    if (!Number.isFinite(value)) {
+        return null;
+    }
+    return value;
+}
+/** Parse coverage-hotspots CLI args. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        coverageDir: null,
+        minHeadroomPp: null,
+        baseRef: null,
+        pathFilter: [],
+        useDiffPaths: true,
+        attemptId: null,
+        worktree: null,
+        evaluatorId: null,
+        json: false,
+        quiet: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--json") {
+            parsed.json = true;
+        }
+        else if (arg === "--quiet") {
+            parsed.quiet = true;
+        }
+        else if (arg === "--no-diff-filter") {
+            parsed.useDiffPaths = false;
+        }
+        else if (arg === "--attempt-id") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --attempt-id: expected one argument" };
+            }
+            parsed.attemptId = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--attempt-id=")) {
+            parsed.attemptId = arg.slice("--attempt-id=".length);
+        }
+        else if (arg === "--worktree") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --worktree: expected one argument" };
+            }
+            parsed.worktree = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--worktree=")) {
+            parsed.worktree = arg.slice("--worktree=".length);
+        }
+        else if (arg === "--evaluator-id") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --evaluator-id: expected one argument" };
+            }
+            parsed.evaluatorId = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--evaluator-id=")) {
+            parsed.evaluatorId = arg.slice("--evaluator-id=".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 === "--coverage-dir") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --coverage-dir: expected one argument" };
+            }
+            parsed.coverageDir = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--coverage-dir=")) {
+            parsed.coverageDir = arg.slice("--coverage-dir=".length);
+        }
+        else if (arg === "--min-headroom-pp") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --min-headroom-pp: expected one argument" };
+            }
+            const num = parseNumber(value);
+            if (num === null) {
+                return { ...parsed, error: "argument --min-headroom-pp: expected a number" };
+            }
+            parsed.minHeadroomPp = num;
+            i += 1;
+        }
+        else if (arg?.startsWith("--min-headroom-pp=")) {
+            const num = parseNumber(arg.slice("--min-headroom-pp=".length));
+            if (num === null) {
+                return { ...parsed, error: "argument --min-headroom-pp: expected a number" };
+            }
+            parsed.minHeadroomPp = num;
+        }
+        else if (arg === "--base-ref") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --base-ref: expected one argument" };
+            }
+            parsed.baseRef = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--base-ref=")) {
+            parsed.baseRef = arg.slice("--base-ref=".length);
+        }
+        else if (arg === "--path" || arg === "--paths") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: `argument ${arg}: expected one argument` };
+            }
+            parsed.pathFilter.push(...value
+                .split(",")
+                .map((part) => part.trim())
+                .filter(Boolean));
+            parsed.useDiffPaths = false;
+            i += 1;
+        }
+        else if (arg?.startsWith("--path=") || arg?.startsWith("--paths=")) {
+            const prefix = arg.startsWith("--path=") ? "--path=" : "--paths=";
+            parsed.pathFilter.push(...arg
+                .slice(prefix.length)
+                .split(",")
+                .map((part) => part.trim())
+                .filter(Boolean));
+            parsed.useDiffPaths = false;
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Run coverage-hotspots and return the process exit code. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`coverage-hotspots: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const result = evaluateCoverageHotspots({
+        projectRoot,
+        coverageDir: args.coverageDir ?? undefined,
+        minHeadroomPp: args.minHeadroomPp ?? undefined,
+        baseRef: args.baseRef,
+        pathFilter: args.pathFilter.length > 0 ? args.pathFilter : null,
+        useDiffPaths: args.useDiffPaths,
+        attemptId: args.attemptId,
+        worktree: args.worktree,
+        evaluatorId: args.evaluatorId,
+    });
+    // Exit 3 = authorized coverage N/A (#5421); exit 4 = gate-override waived (#5674).
+    // Keep machine-readable artifact on stdout for --json. Never map waived to exit 0.
+    if (result.exitCode === 3 || result.exitCode === 4) {
+        if (args.json && result.applicability) {
+            process.stdout.write(`${JSON.stringify(result.applicability, null, 2)}\n`);
+        }
+        else if (!args.quiet) {
+            process.stderr.write(`${result.message}\n`);
+        }
+        return result.exitCode;
+    }
+    if (result.exitCode === 2 || result.report === null) {
+        process.stderr.write(`${result.message}\n`);
+        return result.exitCode;
+    }
+    const payload = args.json ? formatJsonReport(result.report) : result.message;
+    if (result.exitCode === 0) {
+        if (!args.quiet) {
+            process.stdout.write(payload);
+        }
+    }
+    else {
+        process.stderr.write(payload);
+    }
+    return result.exitCode;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=coverage-hotspots.js.map

package/dist/design-critique-spend-resolve.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+export declare const DESIGN_CRITIQUE_SPEND_RESOLVE_HELP = "design-critique:spend-resolve \u2014 record spend-recommend then resolve (#5466)\n\nUsage:\n  deft design-critique:spend-resolve --utterance <text> --recommend N=1|N\u22653 [--project-root PATH] [--session-id ID] [--json]\n  deft design-critique:spend-resolve --open-gate [--utterance <text>] [--project-root PATH] [--session-id ID]\n  deft design-critique:spend-resolve --clear [--project-root PATH] [--session-id ID]\n  deft design-critique:spend-resolve --utterance <text> --unclosable-recommend [--project-root PATH] [--session-id ID]\n\nOptions:\n  --utterance TEXT          Operator chat utterance (required except --open-gate/--clear)\n  --recommend N=1|N\u22653       Closed Dual-stop recommendation (required on bare arc)\n  --unclosable-recommend    Parent-declared unclosable recommend; permit lawful ask\n  --open-gate               Open deny-default session-scoped arc-spend-state at arc start\n  --clear                   Clear session arc-spend-state when the arc ends or is abandoned\n  --session-id ID           Session that owns arc-spend-state (default: DEFT_SESSION_ID / env)\n  --project-root PATH       Project root for arc-spend-state scratch (default: cwd)\n  --json                    Emit structured result\n\nExit codes:\n  0  Resolved / gate opened / cleared\n  1  Refused (missing/invalid recommend, ambiguous, or unclosable ask path)\n  2  Config / usage error\n";
+export interface DesignCritiqueSpendResolveArgs {
+    utterance: string | null;
+    recommend: string | null;
+    projectRoot: string;
+    sessionId: string | null;
+    emitJson: boolean;
+    help: boolean;
+    openGate: boolean;
+    clear: boolean;
+    unclosableRecommend: boolean;
+    error?: string;
+}
+export declare function parseDesignCritiqueSpendResolveArgs(argv: readonly string[]): DesignCritiqueSpendResolveArgs;
+export declare function run(argv: readonly string[]): number;
+export declare function main(argv: readonly string[]): number;
+//# sourceMappingURL=design-critique-spend-resolve.d.ts.map

package/dist/design-critique-spend-resolve.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+/**
+ * design-critique:spend-resolve — callable spend front door (#5466 Prefer-A).
+ * Records closed spend-recommend: + resolved spend:/spend-ask: via
+ * parseOperatorSpend / evaluateSpendRecord. Bare arc requires --recommend;
+ * never asks; never defaults N=1. Does not copy run-posture missing-token
+ * auto-resolve onto spend.
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { clearArcSpendState, openArcSpendGate, resolveDesignCritiqueSpend, } from "@deftai/directive-core/dist/design-critique/spend.js";
+export const DESIGN_CRITIQUE_SPEND_RESOLVE_HELP = `design-critique:spend-resolve — record spend-recommend then resolve (#5466)
+
+Usage:
+  deft design-critique:spend-resolve --utterance <text> --recommend N=1|N≥3 [--project-root PATH] [--session-id ID] [--json]
+  deft design-critique:spend-resolve --open-gate [--utterance <text>] [--project-root PATH] [--session-id ID]
+  deft design-critique:spend-resolve --clear [--project-root PATH] [--session-id ID]
+  deft design-critique:spend-resolve --utterance <text> --unclosable-recommend [--project-root PATH] [--session-id ID]
+
+Options:
+  --utterance TEXT          Operator chat utterance (required except --open-gate/--clear)
+  --recommend N=1|N≥3       Closed Dual-stop recommendation (required on bare arc)
+  --unclosable-recommend    Parent-declared unclosable recommend; permit lawful ask
+  --open-gate               Open deny-default session-scoped arc-spend-state at arc start
+  --clear                   Clear session arc-spend-state when the arc ends or is abandoned
+  --session-id ID           Session that owns arc-spend-state (default: DEFT_SESSION_ID / env)
+  --project-root PATH       Project root for arc-spend-state scratch (default: cwd)
+  --json                    Emit structured result
+
+Exit codes:
+  0  Resolved / gate opened / cleared
+  1  Refused (missing/invalid recommend, ambiguous, or unclosable ask path)
+  2  Config / usage error
+`;
+export function parseDesignCritiqueSpendResolveArgs(argv) {
+    const acc = {
+        utterance: null,
+        recommend: null,
+        projectRoot: ".",
+        sessionId: null,
+        emitJson: false,
+        help: false,
+        openGate: false,
+        clear: false,
+        unclosableRecommend: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        // Accept a lone go-task / deft separator so documented `-- --utterance` forms work.
+        if (arg === "--") {
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            return { ...acc, help: true };
+        }
+        if (arg === "--json") {
+            acc.emitJson = true;
+            continue;
+        }
+        if (arg === "--open-gate") {
+            acc.openGate = true;
+            continue;
+        }
+        if (arg === "--clear") {
+            acc.clear = true;
+            continue;
+        }
+        if (arg === "--unclosable-recommend") {
+            acc.unclosableRecommend = true;
+            continue;
+        }
+        if (arg === "--utterance") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...acc, error: "argument --utterance: expected one argument" };
+            }
+            acc.utterance = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--utterance=")) {
+            acc.utterance = arg.slice("--utterance=".length);
+            continue;
+        }
+        if (arg === "--recommend") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...acc, error: "argument --recommend: expected one argument" };
+            }
+            acc.recommend = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--recommend=")) {
+            acc.recommend = arg.slice("--recommend=".length);
+            continue;
+        }
+        if (arg === "--session-id") {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return { ...acc, error: "argument --session-id: expected one argument" };
+            }
+            acc.sessionId = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--session-id=")) {
+            acc.sessionId = arg.slice("--session-id=".length);
+            continue;
+        }
+        if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...acc, error: "argument --project-root: expected one argument" };
+            }
+            acc.projectRoot = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--project-root=")) {
+            acc.projectRoot = arg.slice("--project-root=".length);
+            continue;
+        }
+        return { ...acc, error: `unknown argument: ${arg}` };
+    }
+    return acc;
+}
+export function run(argv) {
+    const args = parseDesignCritiqueSpendResolveArgs(argv);
+    if (args.help) {
+        process.stdout.write(`${DESIGN_CRITIQUE_SPEND_RESOLVE_HELP}\n`);
+        return 0;
+    }
+    if (args.error !== undefined) {
+        process.stderr.write(`design-critique:spend-resolve: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const sessionId = args.sessionId;
+    if (args.clear) {
+        const removed = clearArcSpendState(projectRoot, { sessionId });
+        if (args.emitJson) {
+            process.stdout.write(`${JSON.stringify({ ok: true, cleared: removed }, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(removed
+                ? "design-critique:spend-resolve: cleared arc-spend-state\n"
+                : "design-critique:spend-resolve: no arc-spend-state to clear\n");
+        }
+        return 0;
+    }
+    if (args.openGate) {
+        const state = openArcSpendGate(projectRoot, { utterance: args.utterance, sessionId });
+        if (args.emitJson) {
+            process.stdout.write(`${JSON.stringify({ ok: true, opened: true, state }, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write("design-critique:spend-resolve: opened arc spend gate (ask denied until --recommend or lawful ask)\n");
+        }
+        return 0;
+    }
+    if (args.utterance === null || args.utterance.trim().length === 0) {
+        process.stderr.write("design-critique:spend-resolve: --utterance is required\n" +
+            "Remediation: deft design-critique:spend-resolve --utterance <text> --recommend N=1|N≥3\n");
+        return 2;
+    }
+    const result = resolveDesignCritiqueSpend({
+        utterance: args.utterance,
+        recommendRaw: args.recommend,
+        unclosableRecommend: args.unclosableRecommend,
+        projectRoot,
+        sessionId,
+    });
+    if (args.emitJson) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    }
+    else if (result.ok) {
+        process.stdout.write(`${result.lines.join("\n")}\n`);
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+    }
+    return result.ok ? 0 : 1;
+}
+export function main(argv) {
+    return run(argv);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=design-critique-spend-resolve.js.map

package/dist/directive-finish-loop.d.ts

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

package/dist/directive-finish-loop.js

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