@deftai/directive 0.55.0

package/dist/verify-session-ritual.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { emitBypassWarning, emitVerifyJson, verifySessionRitual, } from "@deftai/directive-core/session";
+/** Parse verify-session-ritual CLI args, mirroring scripts/verify_session_ritual.py. */
+export function parseArgs(argv) {
+    const parsed = { projectRoot: ".", tier: "quick", emitJson: false };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        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 === "--tier") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --tier: expected one argument" };
+            }
+            if (value !== "quick" && value !== "gated") {
+                return { ...parsed, error: `argument --tier: invalid choice: '${value}'` };
+            }
+            parsed.tier = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--tier=")) {
+            const value = arg.slice("--tier=".length);
+            if (value !== "quick" && value !== "gated") {
+                return { ...parsed, error: `argument --tier: invalid choice: '${value}'` };
+            }
+            parsed.tier = value;
+        }
+        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_session_ritual: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const result = verifySessionRitual(projectRoot, { tier: args.tier });
+    const warning = emitBypassWarning(result);
+    const warningNeeded = result.bypassed && result.wouldFailCode !== null;
+    if (args.emitJson) {
+        process.stdout.write(`${emitVerifyJson(result)}\n`);
+    }
+    else if (result.code === 0) {
+        if (!warningNeeded) {
+            process.stdout.write(`${result.message}\n`);
+        }
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+    }
+    if (warning.length > 0) {
+        process.stderr.write(`${warning}\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-session-ritual.js.map

package/dist/verify-source-cli/rule-ownership-lint.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    mapPath: string | null;
+    root: string | null;
+    error?: string;
+}
+/** Parse rule-ownership-lint CLI args, mirroring scripts/rule_ownership_lint.py. */
+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=rule-ownership-lint.d.ts.map

package/dist/verify-source-cli/rule-ownership-lint.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateRuleOwnership } from "@deftai/directive-core/verify-source";
+/** Parse rule-ownership-lint CLI args, mirroring scripts/rule_ownership_lint.py. */
+export function parseArgs(argv) {
+    const parsed = { mapPath: null, root: null };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--map") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --map: expected one argument" };
+            }
+            parsed.mapPath = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--map=")) {
+            parsed.mapPath = arg.slice("--map=".length);
+        }
+        else if (arg === "--root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --root: expected one argument" };
+            }
+            parsed.root = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--root=")) {
+            parsed.root = arg.slice("--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(`rule_ownership_lint: ${args.error}\n`);
+        return 2;
+    }
+    const root = resolve(args.root ?? ".");
+    const result = evaluateRuleOwnership(root, {
+        root,
+        mapPath: args.mapPath !== null ? resolve(args.mapPath) : undefined,
+    });
+    if (result.stream === "stdout") {
+        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=rule-ownership-lint.js.map

package/dist/verify-source-cli/verify-content-manifest.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    manifestPath: string | null;
+    projectRoot: string | null;
+    error?: string;
+}
+/** Parse verify-content-manifest CLI args (#1821). */
+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-content-manifest.d.ts.map

package/dist/verify-source-cli/verify-content-manifest.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateContentManifest } from "@deftai/directive-core/verify-source";
+/** Parse verify-content-manifest CLI args (#1821). */
+export function parseArgs(argv) {
+    const parsed = { manifestPath: null, projectRoot: null };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--manifest") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --manifest: expected one argument" };
+            }
+            parsed.manifestPath = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--manifest=")) {
+            parsed.manifestPath = arg.slice("--manifest=".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 {
+            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_content_manifest: ${args.error}\n`);
+        return 2;
+    }
+    const root = resolve(args.projectRoot ?? ".");
+    const result = evaluateContentManifest(root, {
+        root,
+        manifestPath: args.manifestPath !== null ? resolve(args.manifestPath) : undefined,
+    });
+    if (result.stream === "stdout") {
+        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-content-manifest.js.map

package/dist/verify-source-cli/verify-scm-boundary.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    allowList: string | null;
+    quiet: boolean;
+    error?: string;
+}
+/** Parse verify-scm-boundary CLI args, mirroring scripts/verify_scm_boundary.py. */
+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-scm-boundary.d.ts.map

package/dist/verify-source-cli/verify-scm-boundary.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateScmBoundary } from "@deftai/directive-core/verify-source";
+/** Parse verify-scm-boundary CLI args, mirroring scripts/verify_scm_boundary.py. */
+export function parseArgs(argv) {
+    const parsed = { projectRoot: ".", allowList: null, 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 if (arg === "--allow-list") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --allow-list: expected one argument" };
+            }
+            parsed.allowList = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--allow-list=")) {
+            parsed.allowList = arg.slice("--allow-list=".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_scm_boundary: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const result = evaluateScmBoundary(projectRoot, {
+        allowListPath: args.allowList !== null ? resolve(args.allowList) : null,
+        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-scm-boundary.js.map

package/dist/verify-source-cli/verify-stubs.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    error?: string;
+}
+/** Parse verify-stubs CLI args (mirrors scripts/verify-stubs.py -- no flags). */
+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-stubs.d.ts.map

package/dist/verify-source-cli/verify-stubs.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateVerifyStubs } from "@deftai/directive-core/verify-source";
+/** Parse verify-stubs CLI args (mirrors scripts/verify-stubs.py -- no flags). */
+export function parseArgs(argv) {
+    const parsed = { projectRoot: "." };
+    for (const arg of argv) {
+        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-stubs: ${args.error}\n`);
+        return 2;
+    }
+    const result = evaluateVerifyStubs(resolve(args.projectRoot));
+    process.stdout.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-stubs.js.map

package/dist/verify-source-parity.d.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+export interface GateCapture {
+    readonly name: string;
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface GateParity {
+    readonly name: string;
+    readonly exitMismatch: boolean;
+    readonly stdoutMismatch: boolean;
+    readonly stderrMismatch: boolean;
+    readonly pythonExit: number;
+    readonly tsExit: number;
+}
+export interface ParityResult {
+    readonly ok: boolean;
+    readonly gates: readonly GateParity[];
+}
+export declare function captureTsGate(name: string, deftRoot: string): GateCapture;
+export declare function capturePythonGate(name: string, deftRoot: string): GateCapture;
+export declare const PARITY_GATES: readonly ["verify_scm_boundary", "rule_ownership_lint", "code_structure_validate", "verify-stubs"];
+export declare function diffGate(python: GateCapture, ts: GateCapture): GateParity;
+export declare function runParity(deftRoot?: string): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=verify-source-parity.d.ts.map

package/dist/verify-source-parity.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1783 s2): runs BOTH the frozen Python source-tree
+ * scanner gates and the ported TS verify-source module over the repository tree,
+ * then diffs exit codes + byte-identical stdout/stderr (cache-off).
+ *
+ * Exit codes: 0 parity / 1 divergence / 2 harness setup error.
+ */
+import { spawnSync } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateCodeStructure, evaluateRuleOwnership, evaluateScmBoundary, evaluateVerifyStubs, } from "@deftai/directive-core/verify-source";
+function runCapture(cmd, args, cwd, env = {}) {
+    const result = spawnSync(cmd, args, {
+        cwd,
+        encoding: "utf8",
+        env: { ...process.env, ...env },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return {
+        status: result.status ?? 2,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr: typeof result.stderr === "string" ? result.stderr : "",
+    };
+}
+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 normaliseHarnessNoise(text) {
+    return text
+        .split("\n")
+        .filter((line) => !line.startsWith("Using CPython") &&
+        !line.startsWith("Creating virtual environment") &&
+        !line.startsWith("Installed "))
+        .join("\n");
+}
+export function captureTsGate(name, deftRoot) {
+    if (name === "verify_scm_boundary") {
+        const result = evaluateScmBoundary(deftRoot);
+        return {
+            name,
+            exitCode: result.code,
+            stdout: result.stream === "stdout" ? `${result.message}\n` : "",
+            stderr: result.stream === "stderr" ? `${result.message}\n` : "",
+        };
+    }
+    if (name === "rule_ownership_lint") {
+        const result = evaluateRuleOwnership(deftRoot, { root: deftRoot });
+        return {
+            name,
+            exitCode: result.code,
+            stdout: result.stream === "stdout" ? `${result.message}\n` : "",
+            stderr: result.stream === "stderr" ? `${result.message}\n` : "",
+        };
+    }
+    if (name === "code_structure_validate") {
+        const result = evaluateCodeStructure(deftRoot);
+        return {
+            name,
+            exitCode: result.code,
+            stdout: result.stdout,
+            stderr: result.stderr,
+        };
+    }
+    if (name === "verify-stubs") {
+        const result = evaluateVerifyStubs(deftRoot);
+        const msg = result.message.endsWith("\n") ? result.message : `${result.message}\n`;
+        return {
+            name,
+            exitCode: result.code,
+            stdout: msg,
+            stderr: "",
+        };
+    }
+    return { name, exitCode: 2, stdout: "", stderr: `unknown gate: ${name}\n` };
+}
+export function capturePythonGate(name, deftRoot) {
+    const env = { DEFT_CACHE_DISABLE: "1", PYTHONUTF8: "1" };
+    if (name === "verify_scm_boundary") {
+        const cap = runCapture("uv", [
+            "run",
+            "python",
+            join(deftRoot, "scripts", "verify_scm_boundary.py"),
+            "--project-root",
+            deftRoot,
+        ], deftRoot, env);
+        return { name, exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+    }
+    if (name === "rule_ownership_lint") {
+        const cap = runCapture("uv", ["run", "python", join(deftRoot, "scripts", "rule_ownership_lint.py"), "--root", deftRoot], deftRoot, env);
+        return { name, exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+    }
+    if (name === "code_structure_validate") {
+        const cap = runCapture("uv", [
+            "run",
+            "python",
+            join(deftRoot, "scripts", "code_structure_validate.py"),
+            "--project-root",
+            deftRoot,
+        ], deftRoot, env);
+        return { name, exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+    }
+    if (name === "verify-stubs") {
+        const cap = runCapture("uv", ["run", "python", join(deftRoot, "scripts", "verify-stubs.py")], deftRoot, env);
+        return { name, exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
+    }
+    return { name, exitCode: 2, stdout: "", stderr: `unknown gate: ${name}\n` };
+}
+export const PARITY_GATES = [
+    "verify_scm_boundary",
+    "rule_ownership_lint",
+    "code_structure_validate",
+    "verify-stubs",
+];
+export function diffGate(python, ts) {
+    const pyOut = normaliseHarnessNoise(python.stdout);
+    const tsOut = normaliseHarnessNoise(ts.stdout);
+    const pyErr = normaliseHarnessNoise(python.stderr);
+    const tsErr = normaliseHarnessNoise(ts.stderr);
+    return {
+        name: python.name,
+        exitMismatch: python.exitCode !== ts.exitCode,
+        stdoutMismatch: pyOut !== tsOut,
+        stderrMismatch: pyErr !== tsErr,
+        pythonExit: python.exitCode,
+        tsExit: ts.exitCode,
+    };
+}
+export function runParity(deftRoot = resolveDeftRoot()) {
+    const gates = [];
+    for (const name of PARITY_GATES) {
+        const python = capturePythonGate(name, deftRoot);
+        const ts = captureTsGate(name, deftRoot);
+        gates.push(diffGate(python, ts));
+    }
+    const ok = gates.every((g) => !g.exitMismatch && !g.stdoutMismatch && !g.stderrMismatch);
+    return { ok, gates };
+}
+export function renderReport(result) {
+    if (result.ok) {
+        return `verify-source parity: CLEAN -- Python and TS agree on ${PARITY_GATES.length} gate(s).`;
+    }
+    const lines = ["verify-source parity: DIVERGENCE"];
+    for (const g of result.gates) {
+        if (g.exitMismatch || g.stdoutMismatch || g.stderrMismatch) {
+            lines.push(`  gate: ${g.name}`);
+            if (g.exitMismatch) {
+                lines.push(`    exit: python=${g.pythonExit} ts=${g.tsExit}`);
+            }
+            if (g.stdoutMismatch) {
+                lines.push("    stdout mismatch");
+            }
+            if (g.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(`verify-source parity: harness error -- ${String(err)}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=verify-source-parity.js.map

package/dist/verify-story-ready.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    vbriefPath: string | null;
+    projectRoot: string;
+    allocationContext: string | null;
+    allowDirty: boolean;
+    emitJson: boolean;
+    help?: boolean;
+    error?: string;
+}
+/** Parse verify-story-ready CLI args, mirroring the Python argparse surface. */
+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-story-ready.d.ts.map