@deftai/directive 0.62.0 → 0.64.0

package/dist/doctor-parity.d.ts

@@ -1,42 +0,0 @@
-#!/usr/bin/env node
-export interface ScenarioResult {
-    readonly name: string;
-    readonly exitCode: number;
-    readonly stdout: string;
-    readonly stderr: string;
-}
-export interface ParityScenario {
-    readonly name: string;
-    readonly argv: readonly string[];
-    readonly cwd?: string;
-    readonly env?: Record<string, string | undefined>;
-    readonly setup?: (root: string) => void;
-    /** When true, stdout may diverge (TS-only consumer probes post #2022 Phase 3). */
-    readonly exitCodeOnly?: boolean;
-}
-export interface ParityResult {
-    readonly ok: boolean;
-    readonly scenarios: Array<{
-        readonly name: string;
-        readonly exitMismatch: boolean;
-        readonly pythonExit: number;
-        readonly tsExit: number;
-        readonly stdoutMismatch: boolean;
-        readonly pythonStdout: string;
-        readonly tsStdout: string;
-    }>;
-}
-export declare const PARITY_SCENARIOS: readonly ParityScenario[];
-/** Normalise volatile lines while preserving doctor semantics. */
-export declare function normaliseStdout(text: string): string;
-export declare function diffParity(python: ScenarioResult, ts: ScenarioResult, options?: {
-    exitCodeOnly?: boolean;
-}): {
-    exitMismatch: boolean;
-    stdoutMismatch: boolean;
-    pythonStdout: string;
-    tsStdout: string;
-};
-export declare function runParity(): ParityResult;
-export declare function renderReport(result: ParityResult): string;
-//# sourceMappingURL=doctor-parity.d.ts.map

package/dist/doctor-parity.js

@@ -1,157 +0,0 @@
-#!/usr/bin/env node
-/**
- * Golden-output parity harness (#1728): runs BOTH the Python oracle
- * (`scripts/doctor.py`) and the ported TS doctor CLI with identical argv,
- * then diffs exit codes and stdout. Exit 0 only on byte-identical results.
- *
- * 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";
-export const PARITY_SCENARIOS = [
-    { name: "full-json-deft-root", argv: ["--full", "--json"] },
-    { name: "full-quiet-deft-root", argv: ["--full", "--quiet"] },
-    { name: "unknown-flag", argv: ["--not-a-real-flag"] },
-    {
-        name: "full-json-consumer-fixture",
-        argv: ["--full", "--json"],
-        exitCodeOnly: true,
-        setup(root) {
-            writeFileSync(join(root, "AGENTS.md"), "<!-- deft:managed-section v3 -->\nbody\n<!-- /deft:managed-section -->\n", "utf8");
-            mkdirSync(join(root, ".deft", "core"), { recursive: true });
-            writeFileSync(join(root, ".deft", "core", "VERSION"), "tag: v0.1.0\nsha: abcdef0123456789abcdef0123456789abcdef01\nref: v0.1.0\n", "utf8");
-        },
-    },
-];
-function runCapture(cmd, args, cwd, env = {}) {
-    const merged = {
-        ...process.env,
-        ...env,
-        DEFT_CACHE_DISABLE: "1",
-    };
-    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 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)), "..", "..", "..");
-}
-/** Normalise volatile lines while preserving doctor semantics. */
-export function normaliseStdout(text) {
-    return text
-        .split("\n")
-        .filter((line) => !line.startsWith("Using CPython") &&
-        !line.startsWith("Creating virtual environment") &&
-        !line.startsWith("Installed ") &&
-        // #2022: the TS doctor emits a pre-cutover status line that the Python
-        // oracle (scripts/doctor.py) never had ("without a Python port"). Filter
-        // it so this intentional TS-only addition does not register as parity
-        // divergence. Removed when scripts/doctor.py is purged with the gate.
-        !line.startsWith("Pre-cutover:"))
-        .join("\n");
-}
-function runScenario(deftRoot, scenario) {
-    let cwd = scenario.cwd ?? deftRoot;
-    let tempRoot;
-    const argv = [...scenario.argv];
-    if (scenario.setup) {
-        tempRoot = mkdtempSync(join(tmpdir(), "deft-doctor-parity-"));
-        scenario.setup(tempRoot);
-        cwd = tempRoot;
-    }
-    try {
-        const pyArgs = ["run", "python", join(deftRoot, "scripts", "doctor.py"), ...argv];
-        const tsArgs = [join(deftRoot, "packages", "cli", "dist", "doctor.js"), ...argv];
-        const env = { ...scenario.env, PYTHONUTF8: "1" };
-        const py = runCapture("uv", pyArgs, cwd, env);
-        const ts = runCapture("node", tsArgs, cwd, env);
-        return {
-            python: { name: scenario.name, exitCode: py.status, stdout: py.stdout, stderr: py.stderr },
-            ts: { name: scenario.name, exitCode: ts.status, stdout: ts.stdout, stderr: ts.stderr },
-        };
-    }
-    finally {
-        if (tempRoot) {
-            rmSync(tempRoot, { recursive: true, force: true });
-        }
-    }
-}
-export function diffParity(python, ts, options = {}) {
-    const pythonStdout = normaliseStdout(python.stdout);
-    const tsStdout = normaliseStdout(ts.stdout);
-    return {
-        exitMismatch: python.exitCode !== ts.exitCode,
-        stdoutMismatch: options.exitCodeOnly ? false : pythonStdout !== tsStdout,
-        pythonStdout,
-        tsStdout,
-    };
-}
-export function runParity() {
-    const deftRoot = resolveDeftRoot();
-    const scenarios = [];
-    for (const scenario of PARITY_SCENARIOS) {
-        const ran = runScenario(deftRoot, scenario);
-        scenarios.push({
-            name: scenario.name,
-            pythonExit: ran.python.exitCode,
-            tsExit: ran.ts.exitCode,
-            ...diffParity(ran.python, ran.ts, { exitCodeOnly: scenario.exitCodeOnly }),
-        });
-    }
-    const ok = scenarios.every((s) => !s.exitMismatch && !s.stdoutMismatch);
-    return { ok, scenarios };
-}
-export function renderReport(result) {
-    if (result.ok) {
-        return `doctor parity: CLEAN -- Python and TS agree on ${result.scenarios.length} scenario(s).`;
-    }
-    const lines = ["doctor parity: DIVERGENCE"];
-    for (const s of result.scenarios) {
-        if (s.exitMismatch || s.stdoutMismatch) {
-            lines.push(`  scenario: ${s.name}`);
-            if (s.exitMismatch) {
-                lines.push(`    exit mismatch: python=${s.pythonExit} ts=${s.tsExit}`);
-            }
-            if (s.stdoutMismatch) {
-                lines.push(`    python stdout (${s.pythonStdout.length} bytes)`);
-                lines.push(`    ts stdout (${s.tsStdout.length} bytes)`);
-            }
-        }
-    }
-    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) {
-        const msg = String(err).replace(/\r?\n/g, " ");
-        process.stderr.write(`doctor parity: harness error -- ${msg}\n`);
-        process.exit(2);
-    }
-}
-//# sourceMappingURL=doctor-parity.js.map

package/dist/intake-parity.d.ts

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-import { PARITY_SCENARIO_NAMES, type ParityScenarioName } from "@deftai/directive-core/intake/parity-scenarios";
-export interface Capture {
-    readonly exitCode: number;
-    readonly stdout: string;
-    readonly stderr: string;
-}
-export interface ParityCase {
-    readonly name: ParityScenarioName;
-    readonly runPython: (deftRoot: string) => Capture;
-    readonly runTs: (deftRoot: string) => Capture;
-}
-export declare const PARITY_CASES: readonly ParityCase[];
-export interface ParityDiff {
-    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 diffs: ParityDiff[];
-}
-export declare function diffCase(python: Capture, ts: Capture, name: string): ParityDiff;
-export declare function runParity(deftRoot?: string): ParityResult;
-export declare function renderReport(result: ParityResult): string;
-export { PARITY_SCENARIO_NAMES };
-//# sourceMappingURL=intake-parity.d.ts.map

package/dist/intake-parity.js

@@ -1,203 +0,0 @@
-#!/usr/bin/env node
-/**
- * Golden-output parity harness (#1784): compares TS intake modules vs Python oracle via python -c.
- */
-import { spawnSync } from "node:child_process";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { buildIssueVbrief, CandidatesLogError, extractCrossRefs, IssueState, reconcile, renderIssueBody, resultToDict, validateCandidatesEntry, validateGithubAuth, } from "@deftai/directive-core/intake";
-import { PARITY_SCENARIO_NAMES, SAMPLE_ISSUE, SAMPLE_VBRIEF, } from "@deftai/directive-core/intake/parity-scenarios";
-import { pythonJsonStringify } from "@deftai/directive-core/scm";
-function capture(exitCode, stdout, stderr = "") {
-    return { exitCode, stdout, stderr };
-}
-function sortKeysDeep(value) {
-    if (Array.isArray(value)) {
-        return value.map((item) => sortKeysDeep(item));
-    }
-    if (value !== null && typeof value === "object") {
-        const obj = value;
-        const sorted = {};
-        for (const key of Object.keys(obj).sort()) {
-            sorted[key] = sortKeysDeep(obj[key]);
-        }
-        return sorted;
-    }
-    return value;
-}
-function stableJson(value) {
-    return `${pythonJsonStringify(sortKeysDeep(value))}\n`;
-}
-function runPythonScript(deftRoot, script) {
-    const code = `import importlib.util, json, sys\nfrom pathlib import Path\nroot = Path(${JSON.stringify(deftRoot)})\nsys.path.insert(0, str(root / "scripts"))\n${script}`;
-    const result = spawnSync("uv", ["run", "python", "-c", code], {
-        cwd: deftRoot,
-        encoding: "utf8",
-        env: { ...process.env, DEFT_CACHE_DISABLE: "1", PYTHONUTF8: "1" },
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    return {
-        exitCode: result.status ?? 2,
-        stdout: typeof result.stdout === "string" ? result.stdout : "",
-        stderr: typeof result.stderr === "string" ? result.stderr : "",
-    };
-}
-function loadModule(name, rel) {
-    return `spec = importlib.util.spec_from_file_location(${JSON.stringify(name)}, root / ${JSON.stringify(rel)})
-mod = importlib.util.module_from_spec(spec)
-sys.modules[${JSON.stringify(name)}] = mod
-spec.loader.exec_module(mod)`;
-}
-export const PARITY_CASES = [
-    {
-        name: "issue-ingest-build-vbrief",
-        runPython(deftRoot) {
-            return runPythonScript(deftRoot, `${loadModule("issue_ingest", "scripts/issue_ingest.py")}
-issue = ${JSON.stringify(SAMPLE_ISSUE)}
-vbrief, folder = mod._build_issue_vbrief(issue, "proposed", "https://github.com/owner/repo")
-print(json.dumps({"folder": folder, "vbrief": vbrief}, ensure_ascii=False, sort_keys=True))
-sys.exit(0)`);
-        },
-        runTs() {
-            const [vbrief, folder] = buildIssueVbrief(SAMPLE_ISSUE, "proposed", "https://github.com/owner/repo");
-            return capture(0, stableJson({ folder, vbrief }));
-        },
-    },
-    {
-        name: "issue-ingest-cross-refs",
-        runPython(deftRoot) {
-            return runPythonScript(deftRoot, `${loadModule("issue_ingest", "scripts/issue_ingest.py")}
-body = "Closes #10\\nRefs #11\\nBlocked by #12"
-refs = mod._extract_cross_refs(body, "https://github.com/o/r", exclude={10})
-print(json.dumps(refs, ensure_ascii=False, sort_keys=True))
-sys.exit(0)`);
-        },
-        runTs() {
-            const refs = extractCrossRefs("Closes #10\nRefs #11\nBlocked by #12", "https://github.com/o/r", new Set([10]));
-            return capture(0, stableJson(refs));
-        },
-    },
-    {
-        name: "issue-emit-render-body",
-        runPython(deftRoot) {
-            return runPythonScript(deftRoot, `${loadModule("issue_emit", "scripts/issue_emit.py")}
-data = ${JSON.stringify(SAMPLE_VBRIEF)}
-print(mod.render_issue_body(data), end="")
-sys.exit(0)`);
-        },
-        runTs() {
-            return capture(0, renderIssueBody(SAMPLE_VBRIEF));
-        },
-    },
-    {
-        name: "reconcile-classify",
-        runPython(deftRoot) {
-            return runPythonScript(deftRoot, `${loadModule("reconcile_issues", "scripts/reconcile_issues.py")}
-report = mod.reconcile({1: ["proposed/a.vbrief.json"]}, {1: mod.IssueState("OPEN")})
-print(json.dumps(report, ensure_ascii=False, sort_keys=True))
-sys.exit(0)`);
-        },
-        runTs() {
-            const report = reconcile(new Map([[1, ["proposed/a.vbrief.json"]]]), new Map([[1, new IssueState("OPEN")]]));
-            return capture(0, stableJson(report));
-        },
-    },
-    {
-        name: "candidates-validate-reject",
-        runPython(deftRoot) {
-            return runPythonScript(deftRoot, `${loadModule("candidates_log", "scripts/candidates_log.py")}
-try:
-    mod._validate_entry({"decision": "accept"})
-except mod.CandidatesLogError as exc:
-    print(str(exc))
-    sys.exit(1)
-sys.exit(0)`);
-        },
-        runTs() {
-            try {
-                validateCandidatesEntry({ decision: "accept" });
-                return capture(0, "");
-            }
-            catch (exc) {
-                if (exc instanceof CandidatesLogError) {
-                    return capture(1, `${exc.message}\n`);
-                }
-                throw exc;
-            }
-        },
-    },
-    {
-        name: "github-auth-invalid-mode",
-        runPython(deftRoot) {
-            return runPythonScript(deftRoot, `${loadModule("github_auth_modes", "scripts/github_auth_modes.py")}
-result = mod.validate_github_auth("bogus", environ={})
-print(json.dumps(result.to_dict(), ensure_ascii=False, sort_keys=True))
-sys.exit(0)`);
-        },
-        runTs() {
-            const result = validateGithubAuth("bogus", { environ: {} });
-            return capture(0, stableJson(resultToDict(result)));
-        },
-    },
-];
-function resolveDeftRoot() {
-    if (process.env.DEFT_ROOT) {
-        return resolve(process.env.DEFT_ROOT);
-    }
-    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-}
-export function diffCase(python, ts, name) {
-    return {
-        name,
-        exitMismatch: python.exitCode !== ts.exitCode,
-        stdoutMismatch: python.stdout !== ts.stdout,
-        stderrMismatch: python.stderr !== ts.stderr,
-        pythonExit: python.exitCode,
-        tsExit: ts.exitCode,
-    };
-}
-export function runParity(deftRoot = resolveDeftRoot()) {
-    const diffs = [];
-    for (const testCase of PARITY_CASES) {
-        diffs.push(diffCase(testCase.runPython(deftRoot), testCase.runTs(deftRoot), testCase.name));
-    }
-    return {
-        ok: diffs.every((d) => !d.exitMismatch && !d.stdoutMismatch && !d.stderrMismatch),
-        diffs,
-    };
-}
-export function renderReport(result) {
-    if (result.ok) {
-        return `intake parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} case(s).`;
-    }
-    const lines = ["intake parity: DIVERGENCE"];
-    for (const d of result.diffs) {
-        if (d.exitMismatch || d.stdoutMismatch || d.stderrMismatch) {
-            lines.push(`  case: ${d.name}`);
-            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(`intake parity: harness error -- ${String(err)}\n`);
-        process.exit(2);
-    }
-}
-export { PARITY_SCENARIO_NAMES };
-//# sourceMappingURL=intake-parity.js.map

package/dist/lifecycle-packs-parity.d.ts

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-export interface CommandCapture {
-    readonly exitCode: number;
-    readonly stdout: string;
-    readonly stderr: string;
-}
-export interface ParityCase {
-    readonly name: string;
-    readonly runPython: (deftRoot: string, repo: string) => CommandCapture;
-    readonly runTs: (deftRoot: string, repo: string) => CommandCapture;
-    readonly setup?: (deftRoot: string, repo: string) => void;
-}
-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[];
-}
-export declare const PARITY_CASES: readonly ParityCase[];
-export declare function normalizeOutput(text: string): string;
-export declare function diffCase(python: CommandCapture, ts: CommandCapture, caseName: string): ParityDiff;
-export declare function runParity(): ParityResult;
-export declare function renderReport(result: ParityResult): string;
-//# sourceMappingURL=lifecycle-packs-parity.d.ts.map