@deftai/directive 0.126.0-beta.2 → 0.126.1

package/dist/verify-orphan-active.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluate } from "@deftai/directive-core/orphan-active";
+function parseIssueNumber(raw) {
+    const trimmed = raw.startsWith("#") ? raw.slice(1) : raw;
+    if (!/^\d+$/.test(trimmed)) {
+        return null;
+    }
+    const value = Number(trimmed);
+    return Number.isInteger(value) && value > 0 ? value : null;
+}
+/** Parse verify-orphan-active CLI args. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        repo: null,
+        issue: null,
+        quiet: false,
+        skipGh: false,
+        changedOnly: false,
+        baseRef: null,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--quiet") {
+            parsed.quiet = true;
+        }
+        else if (arg === "--skip-gh") {
+            parsed.skipGh = true;
+        }
+        else if (arg === "--changed-only") {
+            parsed.changedOnly = true;
+        }
+        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 === "--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 === "--issue") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --issue: expected one argument" };
+            }
+            const issue = parseIssueNumber(value);
+            if (issue === null) {
+                return { ...parsed, error: `argument --issue: expected a positive integer, got ${value}` };
+            }
+            parsed.issue = issue;
+            i += 1;
+        }
+        else if (arg?.startsWith("--issue=")) {
+            const value = arg.slice("--issue=".length);
+            const issue = parseIssueNumber(value);
+            if (issue === null) {
+                return { ...parsed, error: `argument --issue: expected a positive integer, got ${value}` };
+            }
+            parsed.issue = issue;
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    // The two scopes answer different questions; silently preferring one would
+    // hide which residue the run actually covered (#3893).
+    if (parsed.changedOnly && parsed.issue !== null) {
+        return {
+            ...parsed,
+            error: "--changed-only and --issue are mutually exclusive: --issue is the after-merge " +
+                "one-origin scan, --changed-only is the merge-gate candidate scan",
+        };
+    }
+    if (parsed.baseRef !== null && !parsed.changedOnly) {
+        return { ...parsed, error: "--base-ref requires --changed-only" };
+    }
+    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_orphan_active: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const result = evaluate(projectRoot, {
+        quiet: args.quiet,
+        repo: args.repo,
+        skipGh: args.skipGh,
+        issue: args.issue,
+        changedOnly: args.changedOnly,
+        baseRef: args.baseRef,
+    });
+    if (result.message.length > 0) {
+        if (result.stream === "stdout") {
+            process.stdout.write(`${result.message}\n`);
+        }
+        else if (result.stream === "stderr") {
+            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-orphan-active.js.map

package/dist/verify-ownership.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+export interface VerifyOwnershipArgs {
+    projectRoot: string;
+    json: boolean;
+    owner: string | null;
+    error?: string;
+}
+export declare function parseArgs(argv: readonly string[]): VerifyOwnershipArgs;
+export declare function run(argv: readonly string[]): number;
+//# sourceMappingURL=verify-ownership.d.ts.map

package/dist/verify-ownership.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * verify:ownership / verify-ownership (#1617)
+ * Fail-closed check for WSL root-runtime ownership mismatch.
+ */
+import { resolve } from "node:path";
+import { assertProtectedMutationOwnership, evaluateWslOwnershipGuard, ownershipGuardToDict, } from "@deftai/directive-core/platform";
+import { isDirectEntrypoint } from "./entrypoint.js";
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        json: false,
+        owner: null,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--") {
+        }
+        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 === "--owner") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --owner: expected uid:gid" };
+            }
+            parsed.owner = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--owner=")) {
+            parsed.owner = arg.slice("--owner=".length);
+        }
+        else if (arg === "--help" || arg === "-h") {
+            return { ...parsed, error: "__help__" };
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+const HELP = "usage: deft verify:ownership [--project-root PATH] [--owner uid:gid] [--json]\n" +
+    "Fail closed when WSL root runtime can create root-owned project files (#1617).\n" +
+    "Native Windows/macOS always pass. Mount-pinned DrvFs/9p without metadata passes.\n";
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error === "__help__") {
+        process.stdout.write(HELP);
+        return 0;
+    }
+    if (args.error !== undefined) {
+        process.stderr.write(`verify:ownership: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const seams = { projectRoot, explicitOwner: args.owner };
+    const gate = assertProtectedMutationOwnership(seams);
+    if (args.json) {
+        process.stdout.write(`${JSON.stringify(ownershipGuardToDict(gate.verdict), null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(`${gate.message}\n`);
+    }
+    if (!gate.ok)
+        return gate.exitCode;
+    // Also surface soft warn / override without failing when not blocked.
+    const soft = evaluateWslOwnershipGuard(seams);
+    if (soft.status === "warn" || soft.status === "exempt-override") {
+        if (!args.json) {
+            for (const line of soft.sessionWarnLines)
+                process.stderr.write(`${line}\n`);
+        }
+    }
+    return 0;
+}
+if (isDirectEntrypoint(import.meta.url)) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-ownership.js.map

package/dist/verify-persisted-planning-narratives.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    checkConjunct: boolean;
+    error?: string;
+}
+/** Parse verify:persisted-planning-narratives CLI args (#5176). */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the Prefer-A first-ship planning-narrative bar. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-persisted-planning-narratives.d.ts.map

package/dist/verify-persisted-planning-narratives.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+/**
+ * CLI for verify:persisted-planning-narratives (#5176 Prefer-A).
+ *
+ * Default mode is the unconditional setup Phase 2 bar. `--check-conjunct`
+ * mirrors the in-process deft check Prefer-A gate (marker present/unreadable +
+ * empty Overview/tech stack → refuse; missing PD / no marker → pass) so
+ * Taskfile aggregates like check:merge / check:consumer cannot bypass it.
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { checkRejectsEmptyPlanningNarratives, evaluateCheckPersistedPlanningNarratives, } from "@deftai/directive-core/check";
+import { evaluatePersistedPlanningNarratives } from "@deftai/directive-core/project";
+/** Parse verify:persisted-planning-narratives CLI args (#5176). */
+export function parseArgs(argv) {
+    const parsed = { projectRoot: ".", checkConjunct: false };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        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 === "--check-conjunct") {
+            parsed.checkConjunct = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            process.stdout.write("usage: verify:persisted-planning-narratives [--project-root PATH] [--check-conjunct]\n\n" +
+                "Fail closed when every tracked PROJECT-DEFINITION planning narrative\n" +
+                "(Overview + tech stack) is empty/whitespace (#5176 Prefer-A).\n" +
+                "Default: unconditional setup Phase 2 bar (missing PD → exit 2).\n" +
+                "--check-conjunct: Taskfile/check Prefer-A mirror (marker + empty →\n" +
+                "refuse; missing PD / no marker → pass). Reuse deft project:write-narratives.\n");
+            return parsed;
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Run the Prefer-A first-ship planning-narrative bar. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`verify:persisted-planning-narratives: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    if (args.checkConjunct) {
+        const planning = evaluateCheckPersistedPlanningNarratives(projectRoot);
+        if (checkRejectsEmptyPlanningNarratives(planning.narratives, planning.productMutation)) {
+            process.stderr.write(`${planning.narratives.message}\n`);
+            return 1;
+        }
+        if (planning.narratives.ok) {
+            process.stdout.write(`${planning.narratives.message}\n`);
+        }
+        else {
+            process.stdout.write("verify:persisted-planning-narratives --check-conjunct: pass " +
+                `(${planning.narratives.cause}; Prefer-A check conjunct does not refuse)\n`);
+        }
+        return 0;
+    }
+    const result = evaluatePersistedPlanningNarratives(projectRoot);
+    if (result.ok) {
+        process.stdout.write(`${result.message}\n`);
+        return 0;
+    }
+    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-persisted-planning-narratives.js.map

package/dist/verify-plan-sequence.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { type PlanTargetKind } from "@deftai/directive-core/plan-sequence";
+export interface Parsed {
+    projectRoot: string;
+    targetKind: PlanTargetKind | null;
+    target: string | null;
+    emitJson: boolean;
+    /** Typed `--help` / `-h` (#4203); main() prints usage on stdout and exits 0. */
+    help?: boolean;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): Parsed;
+export declare function main(argv?: string[]): number;
+//# sourceMappingURL=verify-plan-sequence.d.ts.map

package/dist/verify-plan-sequence.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+/**
+ * verify:plan-sequence (#2402) — fail closed unless target matches current entry.
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { collectTerminalLifecycleOrigins, inspectMissingSequenceKind, missingSequenceKindPayload, readPlanSequence, verifyPlanTarget, } from "@deftai/directive-core/plan-sequence";
+const KINDS = [
+    "pr",
+    "issue",
+    "story",
+    "task",
+    "phase",
+    "checklist",
+    "review",
+];
+const USAGE = "usage: verify:plan-sequence -- --target-kind <kind> --target <id-or-title>";
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        targetKind: null,
+        target: null,
+        emitJson: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined || arg === "--")
+            continue;
+        if (arg === "--help" || arg === "-h") {
+            return { ...parsed, help: true };
+        }
+        if (arg === "--json") {
+            parsed.emitJson = true;
+        }
+        else if (arg === "--project-root") {
+            const value = argv[++i];
+            if (value === undefined || value === "--") {
+                return { ...parsed, error: "--project-root requires a value" };
+            }
+            parsed.projectRoot = value;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--target-kind") {
+            const value = argv[++i];
+            if (value === undefined || value === "--" || !KINDS.includes(value)) {
+                return { ...parsed, error: `--target-kind must be one of ${KINDS.join("|")}` };
+            }
+            parsed.targetKind = value;
+        }
+        else if (arg.startsWith("--target-kind=")) {
+            const value = arg.slice("--target-kind=".length);
+            if (value === "--" || !KINDS.includes(value)) {
+                return { ...parsed, error: `--target-kind must be one of ${KINDS.join("|")}` };
+            }
+            parsed.targetKind = value;
+        }
+        else if (arg === "--target") {
+            const value = argv[++i];
+            if (value === undefined || value === "--") {
+                return { ...parsed, error: "--target requires a value" };
+            }
+            parsed.target = value;
+        }
+        else if (arg.startsWith("--target=")) {
+            const value = arg.slice("--target=".length);
+            if (value.length === 0 || value === "--") {
+                return { ...parsed, error: "--target requires a value" };
+            }
+            parsed.target = value;
+        }
+        else if (arg.startsWith("-")) {
+            return { ...parsed, error: `unknown flag: ${arg}` };
+        }
+    }
+    if (parsed.help)
+        return parsed;
+    if (parsed.targetKind === null || parsed.target === null) {
+        return {
+            ...parsed,
+            error: USAGE,
+        };
+    }
+    return parsed;
+}
+export function main(argv = process.argv.slice(2)) {
+    const parsed = parseArgs(argv);
+    if (parsed.help) {
+        process.stdout.write(`${USAGE}\n`);
+        return 0;
+    }
+    if (parsed.error || parsed.targetKind === null || parsed.target === null) {
+        process.stderr.write(`${parsed.error ?? "usage error"}\n`);
+        return 2;
+    }
+    const root = resolve(parsed.projectRoot);
+    const missingKind = inspectMissingSequenceKind(root);
+    if (missingKind !== null) {
+        if (parsed.emitJson) {
+            process.stdout.write(`${JSON.stringify(missingSequenceKindPayload(missingKind), null, 2)}\n`);
+        }
+        else {
+            process.stderr.write(`${missingKind.message}\n`);
+        }
+        return 1;
+    }
+    const seq = readPlanSequence(root);
+    // No sequence: allow (caller may have explicit operator approval); warn on stderr.
+    if (seq === null) {
+        if (parsed.emitJson) {
+            process.stdout.write(`${JSON.stringify({ ok: true, skipped: true, reason: "no-active-sequence" }, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write("OK verify:plan-sequence skipped (no active ordered-plan sequence)\n");
+        }
+        return 0;
+    }
+    const result = verifyPlanTarget(seq, {
+        targetKind: parsed.targetKind,
+        target: parsed.target,
+        terminalOrigins: collectTerminalLifecycleOrigins(root),
+    });
+    if (parsed.emitJson) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    }
+    else if (result.ok) {
+        process.stdout.write(`OK verify:plan-sequence matched ${result.entry.kind}:${result.entry.id} (index=${result.index})\n`);
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+    }
+    return result.ok ? 0 : 1;
+}
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    process.exit(main());
+}
+//# sourceMappingURL=verify-plan-sequence.js.map

package/dist/verify-pr-closeout-attestable.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    repo: string | null;
+    pr: number | null;
+    quiet: boolean;
+    onePrUnitId: string | null;
+    error?: string;
+}
+/** Parse verify-pr-closeout-attestable CLI args. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the gate and return the process exit code. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-pr-closeout-attestable.d.ts.map

package/dist/verify-pr-closeout-attestable.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluate } from "@deftai/directive-core/pr-closeout-attestable";
+function parsePrNumber(raw) {
+    const trimmed = raw.startsWith("#") ? raw.slice(1) : raw;
+    if (!/^\d+$/.test(trimmed)) {
+        return null;
+    }
+    const value = Number(trimmed);
+    return Number.isInteger(value) && value > 0 ? value : null;
+}
+/** Parse verify-pr-closeout-attestable CLI args. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        repo: null,
+        pr: null,
+        quiet: false,
+        onePrUnitId: null,
+    };
+    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 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 === "--pr") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --pr: expected one argument" };
+            }
+            const pr = parsePrNumber(value);
+            if (pr === null) {
+                return { ...parsed, error: `argument --pr: expected a positive integer, got ${value}` };
+            }
+            parsed.pr = pr;
+            i += 1;
+        }
+        else if (arg?.startsWith("--pr=")) {
+            const value = arg.slice("--pr=".length);
+            const pr = parsePrNumber(value);
+            if (pr === null) {
+                return { ...parsed, error: `argument --pr: expected a positive integer, got ${value}` };
+            }
+            parsed.pr = pr;
+        }
+        else if (arg === "--one-pr-unit") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --one-pr-unit: expected one argument" };
+            }
+            parsed.onePrUnitId = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--one-pr-unit=")) {
+            parsed.onePrUnitId = arg.slice("--one-pr-unit=".length);
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    if (parsed.pr === null) {
+        return { ...parsed, error: "argument --pr is required" };
+    }
+    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_pr_closeout_attestable: ${args.error}\n`);
+        return 2;
+    }
+    const result = evaluate(resolve(args.projectRoot), args.pr, {
+        repo: args.repo,
+        quiet: args.quiet,
+        onePrUnitId: args.onePrUnitId,
+    });
+    if (result.message.length > 0) {
+        if (result.stream === "stdout") {
+            process.stdout.write(`${result.message}\n`);
+        }
+        else if (result.stream === "stderr") {
+            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-pr-closeout-attestable.js.map

package/dist/verify-presentation-ceiling.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    baseRef: string | null;
+    quiet: boolean;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-presentation-ceiling.d.ts.map