@deftai/directive-core 0.55.0

package/dist/vbrief-reconcile/parity-scenarios.js

@@ -0,0 +1,385 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { pythonJsonPretty } from "../vbrief-build/json.js";
+import { graphOutcomeToJson, reconcileGraph, renderGraphReport } from "./graph.js";
+import { labelsOutcomeToJson, reconcileLabels, renderLabelsReport } from "./labels.js";
+import { buildSpecTaskIndex, formatReconciliationMarkdown, hasDisagreement, parseOverridesYaml, reconcileScopeItems, } from "./reconciliation.js";
+import { parseCurrentShape, reconcileUmbrellas, renderUmbrellasReport } from "./umbrellas.js";
+class MemoryLabelClient {
+    fetchLabels() {
+        return [];
+    }
+    apply() { }
+}
+class MemoryUmbrellaClient {
+    comments = new Map();
+    nextId = 1000;
+    key(repo, issue) {
+        return `${repo}:${issue}`;
+    }
+    fetchComments(repo, issueNumber) {
+        return [...(this.comments.get(this.key(repo, issueNumber)) ?? [])];
+    }
+    editComment(_repo, commentId, body) {
+        for (const bucket of this.comments.values()) {
+            for (const comment of bucket) {
+                if (comment.id === commentId)
+                    comment.body = body;
+            }
+        }
+    }
+    createComment(repo, issueNumber, body) {
+        const key = this.key(repo, issueNumber);
+        const id = this.nextId;
+        this.nextId += 1;
+        const bucket = this.comments.get(key) ?? [];
+        bucket.push({ id, body });
+        this.comments.set(key, bucket);
+        return id;
+    }
+}
+const SHARED_UMBRELLA_CLIENT = new MemoryUmbrellaClient();
+export const PARITY_SCENARIO_NAMES = [
+    "reconcile-overrides",
+    "reconcile-spec-index",
+    "reconcile-scope-clean",
+    "reconcile-scope-orphan",
+    "reconcile-report",
+    "reconcile-parse-shape",
+    "graph-dry-run",
+    "graph-cycle",
+    "graph-missing-proposed",
+    "labels-blocked-dry-run",
+    "labels-utf8-dry-run",
+    "umbrellas-create-dry-run",
+    "umbrellas-unchanged",
+];
+const FIXED_NOW = new Date("2026-06-14T20:00:00Z");
+const FIXED_REPORT_NOW = new Date("2026-06-19T12:00:00Z");
+const OVERRIDES_SAMPLE = "overrides:\n" +
+    "  t2.4.1:\n" +
+    "    status: completed\n" +
+    "    body_source: spec\n" +
+    "  roadmap-9:\n" +
+    "    drop: true\n";
+// Whitespace-edge body for the ReDoS-hardened parse path (#1782 s4): leading
+// runs of spaces/tabs, an all-whitespace tail, and a final line without a
+// trailing newline -- exactly the inputs the `\s*(\S.*|)$` rewrite must parse
+// byte-identically to the Python oracle's `\s*(.*)$`.
+const PARSE_SHAPE_BODY = "## Current shape (as of pass-4)\n" +
+    "Last updated:    2026-06-19T00:00:00Z   \n" +
+    "Last pass type:\tverify\t\n" +
+    "Child-count history:   pass-1: 2, pass-2: 3,  pass-3: 5\n" +
+    "Trailing field with empty value:      \n" +
+    "Child-count history: pass-9: 9";
+function specWith(items) {
+    return {
+        vBRIEFInfo: { version: "0.5", description: "spec" },
+        plan: { title: "Spec", status: "approved", narratives: {}, items },
+    };
+}
+function writeBrief(root, storyId, folder, extra = {}) {
+    const path = join(root, "vbrief", folder, `2026-05-21-${storyId}.vbrief.json`);
+    mkdirSync(join(root, "vbrief", folder), { recursive: true });
+    const statusMap = {
+        proposed: "proposed",
+        pending: "pending",
+        active: "running",
+        completed: "completed",
+        cancelled: "cancelled",
+    };
+    const data = {
+        vBRIEFInfo: { version: "0.6" },
+        plan: {
+            id: storyId,
+            title: storyId,
+            status: statusMap[folder] ?? "pending",
+            narratives: {
+                Description: `${storyId} description.`,
+                ImplementationPlan: `1. Do ${storyId}.`,
+                UserStory: `As a user, I want ${storyId}.`,
+                Traces: "FR-1",
+            },
+            items: [
+                {
+                    id: `${storyId}-a1`,
+                    title: "Acceptance item 1",
+                    status: "pending",
+                    narrative: { Acceptance: `Given X when ${storyId} then Y.` },
+                },
+            ],
+            metadata: {
+                kind: "story",
+                swarm: {
+                    readiness: "ready",
+                    parallel_safe: true,
+                    file_scope: [`src/${storyId}.py`],
+                    verify_commands: [`pytest ${storyId}`],
+                    expected_outputs: ["tests pass"],
+                    depends_on: [],
+                    conflict_group: "reconcile-suite",
+                    size: "small",
+                    file_scope_confidence: "high",
+                    model_tier: "standard",
+                },
+            },
+            references: [],
+            ...extra,
+        },
+    };
+    writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+    return path;
+}
+export function renderScenarioOutput(payload) {
+    return pythonJsonPretty(payload);
+}
+export function runParityScenario(name, options) {
+    const root = options.fixtureRoot;
+    switch (name) {
+        case "reconcile-overrides":
+            return { scenario: name, ok: true, payload: parseOverridesYaml(OVERRIDES_SAMPLE) };
+        case "reconcile-spec-index": {
+            const spec = specWith([
+                { id: "t1.1", title: "One", status: "pending" },
+                {
+                    id: "phase-1",
+                    title: "Phase 1: Foundation",
+                    status: "pending",
+                    subItems: [{ id: "t1.1.1", title: "Deep task", status: "pending" }],
+                },
+            ]);
+            const index = buildSpecTaskIndex(spec);
+            return {
+                scenario: name,
+                ok: true,
+                payload: {
+                    keys: Object.keys(index).sort(),
+                    deepPhase: index["t1.1.1"]?.specPhase ?? "",
+                },
+            };
+        }
+        case "reconcile-scope-clean": {
+            const spec = specWith([{ id: "t1", title: "Task one", status: "pending" }]);
+            const [items, report] = reconcileScopeItems({
+                roadmapActive: [{ number: "", task_id: "t1", title: "Task one", phase: "Phase 1" }],
+                roadmapCompleted: [],
+                specVbrief: spec,
+            });
+            return {
+                scenario: name,
+                ok: true,
+                payload: { items, hasDisagreement: hasDisagreement(report) },
+            };
+        }
+        case "reconcile-scope-orphan": {
+            const spec = specWith([{ id: "t1", title: "One", status: "pending" }]);
+            const [items, report] = reconcileScopeItems({
+                roadmapActive: [
+                    { number: "9", title: "Orphan task", phase: "Phase 1", synthetic_id: "roadmap-9" },
+                ],
+                roadmapCompleted: [],
+                specVbrief: spec,
+            });
+            return {
+                scenario: name,
+                ok: true,
+                payload: { items, orphans: report.orphans },
+            };
+        }
+        case "reconcile-report": {
+            const spec = specWith([{ id: "t2.4.1", title: "Repo indexer", status: "pending" }]);
+            const [, report] = reconcileScopeItems({
+                roadmapActive: [],
+                roadmapCompleted: [
+                    { number: "", task_id: "t2.4.1", title: "Repo indexer", phase: "Completed" },
+                ],
+                specVbrief: spec,
+            });
+            return {
+                scenario: name,
+                ok: true,
+                payload: formatReconciliationMarkdown(report, FIXED_REPORT_NOW),
+            };
+        }
+        case "reconcile-parse-shape": {
+            const parsed = parseCurrentShape(PARSE_SHAPE_BODY);
+            return {
+                scenario: name,
+                ok: true,
+                payload: {
+                    passN: parsed.passN,
+                    history: parsed.history,
+                    lastUpdated: parsed.lastUpdated,
+                    lastPassType: parsed.lastPassType,
+                },
+            };
+        }
+        case "graph-dry-run": {
+            mkdirSync(join(root, "vbrief", "proposed"), { recursive: true });
+            writeBrief(root, "dep-done", "completed");
+            writeBrief(root, "child", "proposed", {
+                metadata: {
+                    kind: "story",
+                    swarm: {
+                        readiness: "ready",
+                        parallel_safe: true,
+                        file_scope: ["src/child.py"],
+                        verify_commands: ["pytest child"],
+                        expected_outputs: ["tests pass"],
+                        depends_on: ["dep-done"],
+                        conflict_group: "reconcile-suite",
+                        size: "small",
+                        file_scope_confidence: "high",
+                        model_tier: "standard",
+                    },
+                },
+            });
+            const [code, outcome] = reconcileGraph(root, { dryRun: true });
+            return {
+                scenario: name,
+                ok: true,
+                payload: {
+                    exitCode: code,
+                    report: renderGraphReport(outcome),
+                    json: graphOutcomeToJson(outcome),
+                },
+            };
+        }
+        case "graph-cycle": {
+            mkdirSync(join(root, "vbrief", "proposed"), { recursive: true });
+            for (const id of ["a", "b"]) {
+                writeBrief(root, id, "proposed", {
+                    metadata: {
+                        kind: "story",
+                        swarm: {
+                            readiness: "ready",
+                            parallel_safe: true,
+                            file_scope: [`src/${id}.py`],
+                            verify_commands: [`pytest ${id}`],
+                            expected_outputs: ["tests pass"],
+                            depends_on: [id === "a" ? "b" : "a"],
+                            conflict_group: "reconcile-suite",
+                            size: "small",
+                            file_scope_confidence: "high",
+                            model_tier: "standard",
+                        },
+                    },
+                });
+            }
+            const [code, outcome] = reconcileGraph(root, { dryRun: true });
+            return {
+                scenario: name,
+                ok: true,
+                payload: { exitCode: code, report: renderGraphReport(outcome) },
+            };
+        }
+        case "graph-missing-proposed": {
+            mkdirSync(join(root, "vbrief"), { recursive: true });
+            const [code] = reconcileGraph(root, { dryRun: true });
+            return { scenario: name, ok: true, payload: { exitCode: code } };
+        }
+        case "labels-blocked-dry-run": {
+            mkdirSync(join(root, "vbrief", "active"), { recursive: true });
+            writeBrief(root, "blk", "active", {
+                status: "blocked",
+                references: [
+                    {
+                        uri: "https://github.com/deftai/directive/issues/10",
+                        type: "x-vbrief/github-issue",
+                        title: "Issue #10",
+                    },
+                ],
+            });
+            const client = options.labelClient ?? new MemoryLabelClient();
+            const [code, outcome] = reconcileLabels(root, { client, dryRun: true });
+            return {
+                scenario: name,
+                ok: true,
+                payload: {
+                    exitCode: code,
+                    report: renderLabelsReport(outcome),
+                    json: labelsOutcomeToJson(outcome),
+                },
+            };
+        }
+        case "labels-utf8-dry-run": {
+            mkdirSync(join(root, "vbrief", "active"), { recursive: true });
+            writeBrief(root, "utf8", "active", {
+                references: [
+                    {
+                        uri: "https://github.com/deftai/directive/issues/11",
+                        type: "x-vbrief/github-issue",
+                        title: "Issue #11 — smart “quotes”",
+                    },
+                ],
+            });
+            const client = options.labelClient ?? new MemoryLabelClient();
+            const [code, outcome] = reconcileLabels(root, { client, dryRun: true });
+            return {
+                scenario: name,
+                ok: true,
+                payload: { exitCode: code, report: renderLabelsReport(outcome) },
+            };
+        }
+        case "umbrellas-create-dry-run": {
+            mkdirSync(join(root, "vbrief", "active"), { recursive: true });
+            writeBrief(root, "child-a", "active", {
+                metadata: { kind: "story", swarm: { depends_on: [] } },
+            });
+            writeBrief(root, "epic-1", "active", {
+                metadata: { kind: "epic", swarm: { depends_on: [] } },
+                references: [
+                    { uri: "active/2026-05-21-child-a.vbrief.json", type: "x-vbrief/plan", title: "child-a" },
+                    {
+                        uri: "https://github.com/deftai/directive/issues/1284",
+                        type: "x-vbrief/github-issue",
+                        title: "Issue #1284",
+                    },
+                ],
+            });
+            const client = options.umbrellaClient ?? SHARED_UMBRELLA_CLIENT;
+            const [code, outcome] = reconcileUmbrellas(root, {
+                client,
+                dryRun: true,
+                now: FIXED_NOW.toISOString().replace(/\.\d{3}Z$/, "Z"),
+            });
+            return {
+                scenario: name,
+                ok: true,
+                payload: { exitCode: code, report: renderUmbrellasReport(outcome) },
+            };
+        }
+        case "umbrellas-unchanged": {
+            mkdirSync(join(root, "vbrief", "active"), { recursive: true });
+            writeBrief(root, "child-b", "active", {
+                metadata: { kind: "story", swarm: { depends_on: [] } },
+            });
+            writeBrief(root, "epic-2", "active", {
+                metadata: { kind: "epic", swarm: { depends_on: [] } },
+                references: [
+                    { uri: "active/2026-05-21-child-b.vbrief.json", type: "x-vbrief/plan", title: "child-b" },
+                    {
+                        uri: "https://github.com/deftai/directive/issues/1285",
+                        type: "x-vbrief/github-issue",
+                        title: "Issue #1285",
+                    },
+                ],
+            });
+            const client = options.umbrellaClient ?? SHARED_UMBRELLA_CLIENT;
+            const now = FIXED_NOW.toISOString().replace(/\.\d{3}Z$/, "Z");
+            reconcileUmbrellas(root, { client, dryRun: false, now });
+            const [code, outcome] = reconcileUmbrellas(root, { client, dryRun: true, now });
+            return {
+                scenario: name,
+                ok: true,
+                payload: { exitCode: code, report: renderUmbrellasReport(outcome) },
+            };
+        }
+        default:
+            throw new Error(`unknown scenario: ${name}`);
+    }
+}
+export function loadFixtureBrief(path) {
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+//# sourceMappingURL=parity-scenarios.js.map

package/dist/vbrief-reconcile/py-repr.d.ts

@@ -0,0 +1,3 @@
+/** Python ``!r`` / ``repr()`` for strings used in conflict messages. */
+export declare function pyRepr(value: string): string;
+//# sourceMappingURL=py-repr.d.ts.map

package/dist/vbrief-reconcile/py-repr.js

@@ -0,0 +1,5 @@
+/** Python ``!r`` / ``repr()`` for strings used in conflict messages. */
+export function pyRepr(value) {
+    return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+//# sourceMappingURL=py-repr.js.map

package/dist/vbrief-reconcile/reconciliation.d.ts

@@ -0,0 +1,20 @@
+import type { ReconciledItem, ReconciliationReport, SpecTaskEntry } from "./types.js";
+export declare const OVERRIDES_FILENAME = "migration-overrides.yaml";
+export declare function detectStatusMarker(text: string): string | null;
+export declare function parseOverridesYaml(text: string): Record<string, Record<string, unknown>>;
+export declare function loadOverrides(vbriefDir: string): Record<string, Record<string, unknown>>;
+export declare function normalizeTaskId(taskId: string): string;
+export declare function buildSpecTaskIndex(specVbrief: Record<string, unknown> | null): Record<string, SpecTaskEntry>;
+export declare function hasDisagreement(report: ReconciliationReport): boolean;
+export declare function folderFromStatus(status: string): string;
+export interface ReconcileScopeOptions {
+    readonly roadmapActive: ReadonlyArray<Record<string, unknown>>;
+    readonly roadmapCompleted: ReadonlyArray<Record<string, unknown>>;
+    readonly specVbrief: Record<string, unknown> | null;
+    readonly phaseDescriptions?: Record<string, string>;
+    readonly overrides?: Record<string, Record<string, unknown>>;
+}
+export declare function reconcileScopeItems(options: ReconcileScopeOptions): [ReconciledItem[], ReconciliationReport];
+export declare function formatReconciliationMarkdown(report: ReconciliationReport, now?: Date): string;
+export declare function writeReconciliationReport(report: ReconciliationReport, vbriefDir: string, now?: Date): string | null;
+//# sourceMappingURL=reconciliation.d.ts.map