@deftai/directive-core 0.55.0

package/dist/vbrief-validation/main.js

@@ -0,0 +1,65 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { PARITY_SCENARIO_NAMES, renderScenarioOutput, runParityScenario, } from "./parity-scenarios.js";
+export function usage() {
+    process.stderr.write("usage: vbrief-validation [--scenario NAME | --all] [--fixture-root PATH]\n");
+}
+/** Run one or all parity scenarios; writes JSON payload to stdout. */
+export function run(argv) {
+    let scenario = null;
+    let all = false;
+    let fixtureRoot = null;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--scenario") {
+            scenario = argv[i + 1] ?? null;
+            i += 1;
+        }
+        else if (arg === "--all") {
+            all = true;
+        }
+        else if (arg === "--fixture-root") {
+            fixtureRoot = argv[i + 1] ?? null;
+            i += 1;
+        }
+        else if (arg === "-h" || arg === "--help") {
+            usage();
+            return 0;
+        }
+        else {
+            process.stderr.write(`vbrief-validation: error: unexpected argument: ${arg}\n`);
+            usage();
+            return 2;
+        }
+    }
+    if (!all && !scenario) {
+        usage();
+        return 2;
+    }
+    const ownedFixture = fixtureRoot === null;
+    const root = fixtureRoot ?? mkdtempSync(join(tmpdir(), "deft-vbrief-validation-"));
+    try {
+        const names = all ? [...PARITY_SCENARIO_NAMES] : [scenario];
+        const results = names.map((name) => runParityScenario(name, { fixtureRoot: root }));
+        const payload = all ? results : results[0];
+        process.stdout.write(renderScenarioOutput(payload, root));
+        return 0;
+    }
+    finally {
+        if (ownedFixture) {
+            rmSync(root, { recursive: true, force: true });
+        }
+    }
+}
+export function cmdVbriefValidation(argv) {
+    try {
+        return run(argv);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`vbrief-validation: error: ${msg}\n`);
+        return 2;
+    }
+}
+//# sourceMappingURL=main.js.map

package/dist/vbrief-validation/normalize.d.ts

@@ -0,0 +1,22 @@
+/** Match Python ``str.splitlines()`` (no trailing empty line from final ``\\n``). */
+export declare function splitLines(content: string): string[];
+/** Equivalent of ``value.replace(/\s+$/, "")`` without backtracking. */
+export declare function stripTrailingWhitespace(value: string): string;
+/** Equivalent of ``value.replace(/^\s+/, "")`` without backtracking. */
+export declare function stripLeadingWhitespace(value: string): string;
+/** Equivalent of ``value.replace(/^[chars]+|[chars]+$/g, "")`` without backtracking. */
+export declare function stripEdgeChars(value: string, chars: string): string;
+/** Equivalent of ``value.replace(/[char]+$/, "")`` without backtracking. */
+export declare function stripTrailingChar(value: string, char: string): string;
+/** Replace absolute fixture paths with a stable token for parity payloads. */
+export declare function normalizeFixturePaths(value: unknown, fixtureRoot: string): unknown;
+/** Sort validation diagnostics for deterministic parity payloads. */
+export declare function sortedDiagnostics(errors: readonly string[], warnings: readonly string[]): {
+    errors: string[];
+    warnings: string[];
+};
+/** Sort schema-validation diagnostic lines for deterministic parity payloads. */
+export declare function sortFailureActions(actions: readonly string[]): string[];
+/** Sort stderr validation detail lines for deterministic parity payloads. */
+export declare function sortFailureStderr(stderr: string): string;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/vbrief-validation/normalize.js

@@ -0,0 +1,126 @@
+/** Match Python ``str.splitlines()`` (no trailing empty line from final ``\\n``). */
+export function splitLines(content) {
+    if (content.length === 0) {
+        return [];
+    }
+    const lines = content.split("\n");
+    if (content.endsWith("\n")) {
+        lines.pop();
+    }
+    return lines;
+}
+// Single-character whitespace probe. A regex without a quantifier is constant
+// time, so these helpers replace ReDoS-prone anchored quantifiers like
+// ``/\s+$/`` / ``/X+$/`` with linear character scans (CodeQL js/polynomial-redos).
+const WS_CHAR = /\s/;
+/** Equivalent of ``value.replace(/\s+$/, "")`` without backtracking. */
+export function stripTrailingWhitespace(value) {
+    let end = value.length;
+    while (end > 0 && WS_CHAR.test(value[end - 1])) {
+        end -= 1;
+    }
+    return value.slice(0, end);
+}
+/** Equivalent of ``value.replace(/^\s+/, "")`` without backtracking. */
+export function stripLeadingWhitespace(value) {
+    let start = 0;
+    while (start < value.length && WS_CHAR.test(value[start])) {
+        start += 1;
+    }
+    return value.slice(start);
+}
+/** Equivalent of ``value.replace(/^[chars]+|[chars]+$/g, "")`` without backtracking. */
+export function stripEdgeChars(value, chars) {
+    const set = new Set(chars);
+    let start = 0;
+    let end = value.length;
+    while (start < end && set.has(value[start])) {
+        start += 1;
+    }
+    while (end > start && set.has(value[end - 1])) {
+        end -= 1;
+    }
+    return value.slice(start, end);
+}
+/** Equivalent of ``value.replace(/[char]+$/, "")`` without backtracking. */
+export function stripTrailingChar(value, char) {
+    let end = value.length;
+    while (end > 0 && value[end - 1] === char) {
+        end -= 1;
+    }
+    return value.slice(0, end);
+}
+/** Replace absolute fixture paths with a stable token for parity payloads. */
+export function normalizeFixturePaths(value, fixtureRoot) {
+    const token = "<FIXTURE>";
+    const normalizedRoot = fixtureRoot.replace(/\\/g, "/");
+    const normalizeString = (text) => text.split(normalizedRoot).join(token);
+    const walk = (input) => {
+        if (typeof input === "string") {
+            return normalizeString(input);
+        }
+        if (Array.isArray(input)) {
+            return input.map(walk);
+        }
+        if (input !== null && typeof input === "object") {
+            const out = {};
+            for (const [key, child] of Object.entries(input)) {
+                out[key] = walk(child);
+            }
+            return out;
+        }
+        return input;
+    };
+    return walk(value);
+}
+/** Sort validation diagnostics for deterministic parity payloads. */
+export function sortedDiagnostics(errors, warnings) {
+    return {
+        errors: [...errors].sort(),
+        warnings: [...warnings].sort(),
+    };
+}
+/** Sort schema-validation diagnostic lines for deterministic parity payloads. */
+export function sortFailureActions(actions) {
+    const prefix = [];
+    const errors = [];
+    const suffix = [];
+    let seenErrors = false;
+    for (const line of actions) {
+        if (line.startsWith("  ") && line.includes(".vbrief.json:")) {
+            errors.push(line);
+            seenErrors = true;
+            continue;
+        }
+        if (seenErrors) {
+            suffix.push(line);
+        }
+        else {
+            prefix.push(line);
+        }
+    }
+    return [...prefix, ...errors.sort(), ...suffix];
+}
+/** Sort stderr validation detail lines for deterministic parity payloads. */
+export function sortFailureStderr(stderr) {
+    const lines = stderr.split("\n");
+    const prefix = [];
+    const errors = [];
+    const suffix = [];
+    let seenErrors = false;
+    for (const line of lines) {
+        if (line.startsWith("  ") && line.includes(".vbrief.json:")) {
+            errors.push(line);
+            seenErrors = true;
+            continue;
+        }
+        if (seenErrors) {
+            suffix.push(line);
+        }
+        else {
+            prefix.push(line);
+        }
+    }
+    return [...prefix, ...errors.sort(), ...suffix].join("\n");
+}
+//# sourceMappingURL=normalize.js.map

package/dist/vbrief-validation/parity-scenarios.d.ts

@@ -0,0 +1,14 @@
+export interface ParityScenarioContext {
+    readonly fixtureRoot: string;
+}
+export interface ParityScenarioResult {
+    readonly scenario: string;
+    readonly ok: boolean;
+    readonly payload: unknown;
+}
+/** Execute a named parity scenario and return structured payload. */
+export declare function runParityScenario(name: string, ctx: ParityScenarioContext): ParityScenarioResult;
+export declare const PARITY_SCENARIO_NAMES: readonly ["slugify-basic", "slugify-collision", "slug-fallback-id", "validate-migration-missing-dir", "validate-migration-empty-dir", "validate-migration-valid-pd", "validate-migration-invalid-status", "isolate-invalid-output", "finalize-migration-success", "finalize-migration-failure", "legacy-normalize-title", "legacy-lookup-canonical", "legacy-parse-sections", "legacy-partition-sections", "fidelity-map-spec-status", "fidelity-parse-spec-tasks", "fidelity-requirements", "fidelity-edges-and-narratives", "fidelity-ingest-spec", "story-quality-happy", "story-quality-failures", "safety-premigrate-sibling", "safety-plan-backups", "safety-manifest-roundtrip", "safety-write-backups-dryrun", "regex-edge-cases"];
+/** Render scenario output bytes for parity compare. */
+export declare function renderScenarioOutput(result: ParityScenarioResult, fixtureRoot?: string): string;
+//# sourceMappingURL=parity-scenarios.d.ts.map