hadara 0.3.2 → 0.3.3-rc.0

package/dist/context/document-extractors.js

@@ -0,0 +1,343 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractManagedSections = extractManagedSections;
+exports.extractProjectState = extractProjectState;
+exports.extractDecisions = extractDecisions;
+exports.extractAgentHandoff = extractAgentHandoff;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const extractor_contract_1 = require("./extractor-contract");
+const managed_sections_1 = require("../services/managed-sections");
+const markdown_table_1 = require("../services/markdown-table");
+const task_capsule_1 = require("../task/task-capsule");
+const PROJECT_MANAGED_TARGETS = [
+    'docs/TASK_BOARD.md',
+    'docs/PROJECT_STATE.md',
+    'docs/AGENT_HANDOFF.md',
+    'docs/IMPLEMENTATION_SOP.md',
+    'docs/DOC_REGISTRY.md'
+];
+function extractManagedSections(projectRoot) {
+    const targets = listManagedSectionTargets(projectRoot);
+    const sources = targets.map((target) => readSource(projectRoot, target));
+    const result = (0, extractor_contract_1.createEmptyExtractionResult)('extractManagedSections', sources);
+    for (const target of targets) {
+        const content = readOptionalText(node_path_1.default.join(projectRoot, target));
+        if (content == null)
+            continue;
+        const sourceHash = (0, extractor_contract_1.hashContextGraphText)(content);
+        const parsed = (0, managed_sections_1.parseManagedSections)(content, target);
+        result.issues.push(...parsed.issues.map((issue) => managedSectionIssue(issue)));
+        for (const section of parsed.sections) {
+            const source = (0, extractor_contract_1.createContextGraphSourceRef)({
+                path: target,
+                extractor: 'extractManagedSections',
+                line: section.startLine,
+                hash: sourceHash
+            });
+            result.nodes.push(managedSectionNode(section, source));
+            result.edges.push(edge('BELONGS_TO_DOCUMENT', (0, extractor_contract_1.createManagedSectionNodeId)(section.path, section.id), (0, extractor_contract_1.createDocumentNodeId)(section.path), source, `${section.id} belongs to ${section.path}.`));
+        }
+    }
+    return result;
+}
+function extractProjectState(projectRoot) {
+    const relativePath = 'docs/PROJECT_STATE.md';
+    const content = readOptionalText(node_path_1.default.join(projectRoot, relativePath));
+    const result = (0, extractor_contract_1.createEmptyExtractionResult)('extractProjectState', [{ path: relativePath, content }]);
+    if (content == null) {
+        result.issues.push({
+            severity: 'warning',
+            code: 'CONTEXT_GRAPH_SOURCE_MISSING',
+            path: relativePath,
+            message: 'docs/PROJECT_STATE.md is missing; project-state hints cannot be extracted.',
+            fixHint: 'Restore docs/PROJECT_STATE.md before relying on state projection context routing.'
+        });
+        return result;
+    }
+    const sourceHash = (0, extractor_contract_1.hashContextGraphText)(content);
+    result.stateSources?.push(projectStateSource(relativePath, sourceHash, extractProjectStateHints(content)));
+    return result;
+}
+function extractDecisions(projectRoot) {
+    const targets = listDecisionTargets(projectRoot);
+    const sources = targets.map((target) => readSource(projectRoot, target.path));
+    const result = (0, extractor_contract_1.createEmptyExtractionResult)('extractDecisions', sources);
+    for (const target of targets) {
+        const content = readOptionalText(node_path_1.default.join(projectRoot, target.path));
+        if (content == null)
+            continue;
+        const sourceHash = (0, extractor_contract_1.hashContextGraphText)(content);
+        for (const decision of parseDecisionRecords(content)) {
+            const source = (0, extractor_contract_1.createContextGraphSourceRef)({
+                path: target.path,
+                extractor: 'extractDecisions',
+                line: decision.line,
+                hash: sourceHash
+            });
+            const decisionNodeId = (0, extractor_contract_1.createDecisionNodeId)(target.path, decision.id);
+            result.nodes.push(decisionNode(target.path, decision, source));
+            result.edges.push(edge('BELONGS_TO_DOCUMENT', decisionNodeId, (0, extractor_contract_1.createDocumentNodeId)(target.path), source, `${decision.id} belongs to ${target.path}.`));
+            result.edges.push(edge('HAS_DECISION', decisionOwnerNodeId(target), decisionNodeId, source, `${decisionOwnerNodeId(target)} has decision ${decision.id}.`));
+        }
+    }
+    return result;
+}
+function extractAgentHandoff(projectRoot) {
+    const relativePath = 'docs/AGENT_HANDOFF.md';
+    const content = readOptionalText(node_path_1.default.join(projectRoot, relativePath));
+    const result = (0, extractor_contract_1.createEmptyExtractionResult)('extractAgentHandoff', [{ path: relativePath, content }]);
+    if (content == null) {
+        result.issues.push({
+            severity: 'warning',
+            code: 'CONTEXT_GRAPH_SOURCE_MISSING',
+            path: relativePath,
+            message: 'docs/AGENT_HANDOFF.md is missing; KnownProblem nodes cannot be extracted from current handoff state.',
+            fixHint: 'Restore docs/AGENT_HANDOFF.md before relying on known-problem context routing.'
+        });
+        return result;
+    }
+    const sourceHash = (0, extractor_contract_1.hashContextGraphText)(content);
+    const knownProblems = parseKnownProblems(content);
+    result.stateSources?.push(agentHandoffStateSource(relativePath, sourceHash, extractAgentHandoffHints(content), knownProblems.length));
+    for (const problem of knownProblems) {
+        const source = (0, extractor_contract_1.createContextGraphSourceRef)({
+            path: relativePath,
+            extractor: 'extractAgentHandoff',
+            line: problem.line,
+            hash: sourceHash
+        });
+        const problemNodeId = (0, extractor_contract_1.createKnownProblemNodeId)(relativePath, problem.issue);
+        result.nodes.push(knownProblemNode(relativePath, problem, source));
+        result.edges.push(edge('HAS_KNOWN_PROBLEM', (0, extractor_contract_1.createDocumentNodeId)(relativePath), problemNodeId, source, `docs/AGENT_HANDOFF.md records known problem: ${problem.issue}`));
+    }
+    return result;
+}
+function projectStateSource(relativePath, sourceHash, hints) {
+    return {
+        id: 'state-source:project-state',
+        path: (0, extractor_contract_1.normalizeContextGraphPath)(relativePath),
+        kind: 'project-state',
+        hash: sourceHash,
+        extracted: hints
+    };
+}
+function agentHandoffStateSource(relativePath, sourceHash, hints, knownProblems) {
+    return {
+        id: 'state-source:agent-handoff',
+        path: (0, extractor_contract_1.normalizeContextGraphPath)(relativePath),
+        kind: 'agent-handoff',
+        hash: sourceHash,
+        extracted: {
+            ...hints,
+            knownProblems
+        }
+    };
+}
+function extractProjectStateHints(content) {
+    const rows = (0, markdown_table_1.parseMarkdownRowsUnderHeading)(content, '## Metadata');
+    const latestRaw = (0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'Latest Completed Task')?.[1] ?? findLineValue(content, /latest completed task is\s+([^\n.]+)/i);
+    const activeRaw = (0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'Active Task')?.[1] ?? null;
+    return {
+        latestCompletedTask: normalizeTaskHint(latestRaw),
+        activeTask: normalizeTaskHint(activeRaw),
+        latestCompletedRaw: latestRaw ?? null,
+        activeRaw: activeRaw ?? null
+    };
+}
+function extractAgentHandoffHints(content) {
+    const rows = (0, markdown_table_1.parseMarkdownRowsUnderHeading)(content, '## Current State');
+    const latestRaw = (0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'Latest Completed Task')?.[1] ?? null;
+    const activeRaw = (0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'Active / Next Task')?.[1] ?? (0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'Active Task')?.[1] ?? null;
+    return {
+        latestCompletedTask: normalizeTaskHint(latestRaw),
+        activeTask: normalizeTaskHint(activeRaw),
+        latestCompletedRaw: latestRaw,
+        activeRaw: activeRaw
+    };
+}
+function normalizeTaskHint(value) {
+    if (!value)
+        return null;
+    if (/^(none|n\/a|tbd)\b/i.test(value.trim()))
+        return null;
+    return value.match(/\bT-\d{4}\b/)?.[0] ?? null;
+}
+function findLineValue(content, pattern) {
+    for (const line of content.split(/\r?\n/)) {
+        const match = line.match(pattern);
+        if (match?.[1])
+            return match[1].trim();
+    }
+    return null;
+}
+function managedSectionNode(section, source) {
+    return {
+        id: (0, extractor_contract_1.createManagedSectionNodeId)(section.path, section.id),
+        type: 'ManagedSection',
+        label: section.id,
+        path: (0, extractor_contract_1.normalizeContextGraphPath)(section.path),
+        kind: section.metadata.kind,
+        owner: section.metadata.owner,
+        metadata: {
+            mode: section.metadata.mode,
+            version: section.metadata.version,
+            required: section.metadata.required ?? false,
+            closeSourceRole: section.metadata.closeSourceRole ?? null,
+            startLine: section.startLine,
+            endLine: section.endLine,
+            sectionBeforeHash: section.sectionBeforeHash
+        },
+        source
+    };
+}
+function decisionNode(documentPath, decision, source) {
+    return {
+        id: (0, extractor_contract_1.createDecisionNodeId)(documentPath, decision.id),
+        type: 'Decision',
+        label: `${decision.id} ${decision.decision}`.trim(),
+        path: (0, extractor_contract_1.normalizeContextGraphPath)(documentPath),
+        status: decision.status,
+        kind: 'decision-record',
+        metadata: {
+            decision: decision.decision,
+            rationale: decision.rationale ?? null,
+            evidence: decision.evidence ?? null
+        },
+        source
+    };
+}
+function knownProblemNode(documentPath, problem, source) {
+    return {
+        id: (0, extractor_contract_1.createKnownProblemNodeId)(documentPath, problem.issue),
+        type: 'KnownProblem',
+        label: problem.issue,
+        path: (0, extractor_contract_1.normalizeContextGraphPath)(documentPath),
+        kind: 'current-known-problem',
+        metadata: {
+            impact: problem.impact ?? null,
+            nextStep: problem.nextStep ?? null
+        },
+        source
+    };
+}
+function parseDecisionRecords(content) {
+    const rows = parseDecisionTableRows(content);
+    if (rows.length > 0)
+        return rows;
+    return parseDecisionHeadingRecords(content);
+}
+function parseDecisionTableRows(content) {
+    const decisions = [];
+    content.split(/\r?\n/).forEach((line, index) => {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('|') || !trimmed.endsWith('|') || /^\|\s*:?-+/.test(trimmed))
+            return;
+        const cells = trimmed.slice(1, -1).split('|').map((cell) => cell.trim());
+        if (!/^D-\d+/i.test(cells[0] ?? ''))
+            return;
+        const hasDateColumn = /^\d{4}-\d{2}-\d{2}$/.test(cells[1] ?? '') || cells.length >= 6;
+        decisions.push({
+            id: cells[0],
+            decision: cells[hasDateColumn ? 2 : 1] ?? '',
+            status: cells[hasDateColumn ? 3 : 2] ?? 'recorded',
+            rationale: cells[hasDateColumn ? 4 : 3],
+            evidence: cells[hasDateColumn ? 5 : 4],
+            line: index + 1
+        });
+    });
+    return decisions;
+}
+function parseDecisionHeadingRecords(content) {
+    const lines = content.split(/\r?\n/);
+    const records = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const match = lines[index].match(/^##\s+(D-\d+):?\s*(.*)$/i);
+        if (!match)
+            continue;
+        const body = [];
+        for (let next = index + 1; next < lines.length && !/^##\s+/.test(lines[next]); next += 1) {
+            if (lines[next].trim())
+                body.push(lines[next].trim());
+        }
+        records.push({
+            id: match[1],
+            decision: match[2]?.trim() || match[1],
+            status: 'recorded',
+            rationale: body.join('\n') || undefined,
+            line: index + 1
+        });
+    }
+    return records;
+}
+function parseKnownProblems(content) {
+    const rows = (0, markdown_table_1.parseMarkdownRowsUnderHeading)(content, '## Current Known Problems');
+    return rows
+        .filter((row) => row[0] && row[0] !== 'Issue')
+        .map((row) => ({
+        issue: row[0],
+        impact: row[1],
+        nextStep: row[2],
+        line: findLineContaining(content, row[0])
+    }));
+}
+function listManagedSectionTargets(projectRoot) {
+    const taskTargets = (0, task_capsule_1.listTaskCapsules)(projectRoot).flatMap((task) => [
+        (0, extractor_contract_1.toProjectRelativeContextPath)(projectRoot, node_path_1.default.join(task.dir, 'TASK.md')),
+        (0, extractor_contract_1.toProjectRelativeContextPath)(projectRoot, node_path_1.default.join(task.dir, 'HANDOFF.md'))
+    ]);
+    return uniqueSorted(PROJECT_MANAGED_TARGETS.concat(taskTargets)).filter((target) => node_fs_1.default.existsSync(node_path_1.default.join(projectRoot, target)));
+}
+function listDecisionTargets(projectRoot) {
+    const targets = [];
+    if (node_fs_1.default.existsSync(node_path_1.default.join(projectRoot, 'docs/DECISIONS.md')))
+        targets.push({ path: 'docs/DECISIONS.md' });
+    for (const task of (0, task_capsule_1.listTaskCapsules)(projectRoot)) {
+        const decisionPath = (0, extractor_contract_1.toProjectRelativeContextPath)(projectRoot, node_path_1.default.join(task.dir, 'DECISIONS.md'));
+        if (node_fs_1.default.existsSync(node_path_1.default.join(projectRoot, decisionPath)))
+            targets.push({ path: decisionPath, task });
+    }
+    return targets;
+}
+function decisionOwnerNodeId(target) {
+    return target.task ? (0, extractor_contract_1.createTaskNodeId)(target.task.id) : (0, extractor_contract_1.createDocumentNodeId)(target.path);
+}
+function edge(type, from, to, source, reason) {
+    return {
+        id: (0, extractor_contract_1.createContextGraphEdgeId)({ type, from, to, source, reason }),
+        from,
+        to,
+        type,
+        confidence: 'explicit',
+        reason,
+        source
+    };
+}
+function readSource(projectRoot, relativePath) {
+    return {
+        path: relativePath,
+        content: readOptionalText(node_path_1.default.join(projectRoot, relativePath))
+    };
+}
+function readOptionalText(absolutePath) {
+    return node_fs_1.default.existsSync(absolutePath) ? node_fs_1.default.readFileSync(absolutePath, 'utf8') : null;
+}
+function managedSectionIssue(issue) {
+    return {
+        severity: issue.severity === 'error' ? 'warning' : issue.severity,
+        code: 'CONTEXT_GRAPH_PARSE_FAILED',
+        path: issue.path,
+        message: issue.message,
+        fixHint: issue.sectionId ? `Repair managed section ${issue.sectionId} in ${issue.path}.` : `Repair managed section markers in ${issue.path}.`
+    };
+}
+function findLineContaining(content, needle) {
+    const index = content.split(/\r?\n/).findIndex((line) => line.includes(needle));
+    return index >= 0 ? index + 1 : undefined;
+}
+function uniqueSorted(values) {
+    return Array.from(new Set(values.map(extractor_contract_1.normalizeContextGraphPath))).sort();
+}

package/dist/context/evidence-extractors.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractEvidence = extractEvidence;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const extractor_contract_1 = require("./extractor-contract");
+const normalizer_1 = require("../evidence/normalizer");
+const task_capsule_1 = require("../task/task-capsule");
+function extractEvidence(projectRoot) {
+    const capsules = (0, task_capsule_1.listTaskCapsules)(projectRoot);
+    const sources = capsules.map((task) => readEvidenceSource(projectRoot, task));
+    const result = (0, extractor_contract_1.createEmptyExtractionResult)('extractEvidence', sources);
+    for (const task of capsules) {
+        const evidencePath = node_path_1.default.join(task.dir, 'evidence.jsonl');
+        const relativePath = (0, extractor_contract_1.toProjectRelativeContextPath)(projectRoot, evidencePath);
+        const content = readOptionalText(evidencePath);
+        if (content == null) {
+            result.issues.push(evidenceReadFailedIssue(relativePath, `Task Capsule ${task.id} is missing evidence.jsonl.`));
+            continue;
+        }
+        const sourceHash = (0, extractor_contract_1.hashContextGraphText)(content);
+        const normalizedRecords = parseEvidenceJsonl(content, relativePath, result.issues)
+            .map((entry) => normalizeEntry(entry, task, relativePath, result.issues))
+            .filter((entry) => Boolean(entry));
+        for (const record of normalizedRecords) {
+            const source = (0, extractor_contract_1.createContextGraphSourceRef)({
+                path: relativePath,
+                extractor: 'extractEvidence',
+                line: record.sourceLine,
+                hash: sourceHash
+            });
+            result.nodes.push(evidenceNode(record, source));
+            result.edges.push(...evidenceEdges(task, record, source));
+        }
+        result.stateSources?.push(evidenceStateSource(task, relativePath, sourceHash, normalizedRecords));
+    }
+    return result;
+}
+function evidenceNode(record, source) {
+    return {
+        id: (0, extractor_contract_1.createEvidenceNodeId)(record.id),
+        type: 'Evidence',
+        label: record.summary,
+        status: record.outcome,
+        kind: record.category,
+        metadata: {
+            taskId: record.taskId,
+            time: record.time,
+            idSource: record.idSource,
+            idStability: record.idStability,
+            persistedSchemaVersion: record.persistedSchemaVersion,
+            sourceLine: record.sourceLine ?? null,
+            fingerprint: record.fingerprint,
+            category: record.category,
+            artifactType: record.artifactType,
+            outcome: record.outcome,
+            visibility: record.visibility,
+            artifacts: record.artifacts,
+            tags: record.tags,
+            legacy: record.legacy
+        },
+        source
+    };
+}
+function evidenceEdges(task, record, source) {
+    const taskNodeId = (0, extractor_contract_1.createTaskNodeId)(task.id);
+    const evidenceNodeId = (0, extractor_contract_1.createEvidenceNodeId)(record.id);
+    const edges = [
+        edge('HAS_EVIDENCE', taskNodeId, evidenceNodeId, source, `${task.id} has evidence ${record.id}.`)
+    ];
+    if (record.tags.includes('close-proof')) {
+        edges.push(edge('CLOSES_WITH', taskNodeId, evidenceNodeId, source, `${task.id} closes with evidence ${record.id}.`));
+    }
+    for (const dependencyId of evidenceDependencyIds(record.tags)) {
+        edges.push(edge('DEPENDS_ON_EVIDENCE', evidenceNodeId, (0, extractor_contract_1.createEvidenceNodeId)(dependencyId), source, `${record.id} references evidence ${dependencyId}.`));
+    }
+    return edges;
+}
+function evidenceStateSource(task, relativePath, sourceHash, records) {
+    return {
+        id: `state-source:evidence:${task.id}`,
+        path: relativePath,
+        kind: 'evidence',
+        hash: sourceHash,
+        extracted: {
+            taskId: task.id,
+            records: records.length,
+            durableRecords: records.filter((record) => record.idStability === 'durable').length,
+            legacyRecords: records.filter((record) => record.persistedSchemaVersion === 'hadara.evidence.v1').length,
+            closeProofs: records.filter((record) => record.tags.includes('close-proof')).length,
+            categoryCounts: countBy(records.map((record) => record.category)),
+            outcomeCounts: countBy(records.map((record) => record.outcome))
+        }
+    };
+}
+function parseEvidenceJsonl(content, relativePath, issues) {
+    const entries = [];
+    content.split(/\r?\n/).forEach((line, index) => {
+        const lineNumber = index + 1;
+        if (!line.trim())
+            return;
+        try {
+            entries.push({ record: JSON.parse(line), lineNumber });
+        }
+        catch (error) {
+            issues.push(parseFailedIssue(relativePath, lineNumber, `Could not parse evidence JSONL line ${lineNumber}: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    });
+    return entries;
+}
+function normalizeEntry(entry, task, relativePath, issues) {
+    try {
+        return (0, normalizer_1.normalizeEvidenceRecord)(entry.record, {
+            taskDir: task.dir,
+            lineNumber: entry.lineNumber
+        });
+    }
+    catch (error) {
+        issues.push(parseFailedIssue(relativePath, entry.lineNumber, `Could not normalize evidence JSONL line ${entry.lineNumber}: ${error instanceof Error ? error.message : String(error)}`));
+        return null;
+    }
+}
+function evidenceDependencyIds(tags) {
+    const ids = new Set();
+    for (const tag of tags) {
+        const match = tag.match(/^(?:resolves|supersedes):(.+)$/);
+        if (match?.[1])
+            ids.add(match[1]);
+    }
+    return Array.from(ids).sort();
+}
+function edge(type, from, to, source, reason) {
+    return {
+        id: (0, extractor_contract_1.createContextGraphEdgeId)({ type, from, to, source, reason }),
+        from,
+        to,
+        type,
+        confidence: 'explicit',
+        reason,
+        source
+    };
+}
+function readEvidenceSource(projectRoot, task) {
+    const absolutePath = node_path_1.default.join(task.dir, 'evidence.jsonl');
+    return {
+        path: (0, extractor_contract_1.toProjectRelativeContextPath)(projectRoot, absolutePath),
+        content: readOptionalText(absolutePath)
+    };
+}
+function readOptionalText(absolutePath) {
+    return node_fs_1.default.existsSync(absolutePath) ? node_fs_1.default.readFileSync(absolutePath, 'utf8') : null;
+}
+function evidenceReadFailedIssue(relativePath, message) {
+    return {
+        severity: 'warning',
+        code: 'CONTEXT_GRAPH_EVIDENCE_READ_FAILED',
+        path: relativePath,
+        message,
+        fixHint: `Restore ${relativePath} or run the scoped evidence remediation workflow before relying on evidence context routing.`
+    };
+}
+function parseFailedIssue(relativePath, lineNumber, message) {
+    return {
+        severity: 'warning',
+        code: 'CONTEXT_GRAPH_PARSE_FAILED',
+        path: relativePath,
+        message,
+        fixHint: `Repair line ${lineNumber} in ${relativePath}; context graph extraction will skip malformed evidence records.`
+    };
+}
+function countBy(values) {
+    return values.reduce((counts, value) => {
+        counts[value] = (counts[value] ?? 0) + 1;
+        return counts;
+    }, {});
+}

package/dist/context/extractor-contract.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeContextGraphPath = normalizeContextGraphPath;
+exports.toProjectRelativeContextPath = toProjectRelativeContextPath;
+exports.hashContextGraphText = hashContextGraphText;
+exports.hashContextGraphJson = hashContextGraphJson;
+exports.hashContextGraphSources = hashContextGraphSources;
+exports.createContextGraphSourceRef = createContextGraphSourceRef;
+exports.createTaskNodeId = createTaskNodeId;
+exports.createDocumentNodeId = createDocumentNodeId;
+exports.createManagedSectionNodeId = createManagedSectionNodeId;
+exports.createCommandNodeId = createCommandNodeId;
+exports.createEvidenceNodeId = createEvidenceNodeId;
+exports.createReleaseCheckNodeId = createReleaseCheckNodeId;
+exports.createDecisionNodeId = createDecisionNodeId;
+exports.createKnownProblemNodeId = createKnownProblemNodeId;
+exports.createContextGraphEdgeId = createContextGraphEdgeId;
+exports.createEmptyExtractionResult = createEmptyExtractionResult;
+exports.mergeGraphExtractionResults = mergeGraphExtractionResults;
+exports.summarizeContextGraphExtraction = summarizeContextGraphExtraction;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_path_1 = __importDefault(require("node:path"));
+const context_graph_1 = require("./context-graph");
+function normalizeContextGraphPath(inputPath) {
+    const normalized = inputPath.replace(/\\/g, '/').replace(/^\.\//, '');
+    return normalized.split('/').filter((part) => part.length > 0).join('/');
+}
+function toProjectRelativeContextPath(projectRoot, absoluteOrRelativePath) {
+    const resolvedRoot = node_path_1.default.resolve(projectRoot);
+    const resolvedPath = node_path_1.default.isAbsolute(absoluteOrRelativePath)
+        ? node_path_1.default.resolve(absoluteOrRelativePath)
+        : node_path_1.default.resolve(resolvedRoot, absoluteOrRelativePath);
+    const relative = node_path_1.default.relative(resolvedRoot, resolvedPath);
+    return normalizeContextGraphPath(relative || '.');
+}
+function hashContextGraphText(value) {
+    return `sha256:${node_crypto_1.default.createHash('sha256').update(value, 'utf8').digest('hex')}`;
+}
+function hashContextGraphJson(value) {
+    return hashContextGraphText(stableStringify(value));
+}
+function hashContextGraphSources(sources) {
+    return hashContextGraphJson(sources.map((source) => ({
+        path: normalizeContextGraphPath(source.path),
+        hash: source.hash ?? (source.content == null ? null : hashContextGraphText(source.content))
+    })).sort((a, b) => a.path.localeCompare(b.path)));
+}
+function createContextGraphSourceRef(input) {
+    return {
+        path: normalizeContextGraphPath(input.path),
+        ...(input.line === undefined ? {} : { line: input.line }),
+        ...(input.hash || input.content != null ? { hash: input.hash ?? hashContextGraphText(input.content ?? '') } : {}),
+        extractor: input.extractor
+    };
+}
+function createTaskNodeId(taskId) {
+    return `task:${taskId}`;
+}
+function createDocumentNodeId(documentPath) {
+    return `doc:${normalizeContextGraphPath(documentPath)}`;
+}
+function createManagedSectionNodeId(documentPath, sectionId) {
+    return `section:${normalizeContextGraphPath(documentPath)}#${sectionId}`;
+}
+function createCommandNodeId(commandId) {
+    return `command:${commandId}`;
+}
+function createEvidenceNodeId(evidenceId) {
+    return evidenceId;
+}
+function createReleaseCheckNodeId(name) {
+    return `release-check:${normalizeIdPart(name)}`;
+}
+function createDecisionNodeId(documentPath, decisionId) {
+    return `decision:${normalizeContextGraphPath(documentPath)}#${decisionId}`;
+}
+function createKnownProblemNodeId(documentPath, text) {
+    return `known-problem:${sha256Hex(`${normalizeContextGraphPath(documentPath)}\n${normalizeWhitespace(text)}`)}`;
+}
+function createContextGraphEdgeId(input) {
+    return `edge:${input.type}:${sha256Hex(stableStringify({
+        from: input.from,
+        to: input.to,
+        source: {
+            path: normalizeContextGraphPath(input.source.path),
+            line: input.source.line ?? null,
+            extractor: input.source.extractor
+        },
+        reason: normalizeWhitespace(input.reason)
+    }))}`;
+}
+function createEmptyExtractionResult(extractor, sources = []) {
+    return {
+        source: {
+            extractor,
+            paths: sources.map((source) => normalizeContextGraphPath(source.path)).sort(),
+            sourceHash: hashContextGraphSources(sources)
+        },
+        nodes: [],
+        edges: [],
+        stateSources: [],
+        issues: []
+    };
+}
+function mergeGraphExtractionResults(results) {
+    const sourceInputs = results.flatMap((result) => result.source.paths.map((sourcePath) => ({ path: sourcePath, hash: result.source.sourceHash })));
+    return {
+        source: {
+            extractor: 'mergeGraphExtractionResults',
+            paths: Array.from(new Set(results.flatMap((result) => result.source.paths))).sort(),
+            sourceHash: hashContextGraphSources(sourceInputs)
+        },
+        nodes: dedupeById(results.flatMap((result) => result.nodes)),
+        edges: dedupeById(results.flatMap((result) => result.edges)),
+        stateSources: dedupeStateSources(results.flatMap((result) => result.stateSources ?? [])),
+        issues: results.flatMap((result) => result.issues)
+    };
+}
+function summarizeContextGraphExtraction(nodes, edges, issues) {
+    return {
+        nodeCounts: countByVocabulary(context_graph_1.CONTEXT_GRAPH_NODE_TYPES, nodes.map((node) => node.type)),
+        edgeCounts: countByVocabulary(context_graph_1.CONTEXT_GRAPH_EDGE_TYPES, edges.map((edge) => edge.type)),
+        sourcesRead: new Set(nodes.map((node) => node.source.path).concat(edges.map((edge) => edge.source.path))).size,
+        degraded: issues.some((issue) => issue.severity === 'warning' || issue.severity === 'error')
+    };
+}
+function dedupeById(items) {
+    const seen = new Set();
+    const deduped = [];
+    for (const item of items) {
+        if (seen.has(item.id))
+            continue;
+        seen.add(item.id);
+        deduped.push(item);
+    }
+    return deduped;
+}
+function dedupeStateSources(items) {
+    return dedupeById(items);
+}
+function countByVocabulary(vocabulary, values) {
+    const counts = Object.fromEntries(vocabulary.map((value) => [value, 0]));
+    for (const value of values)
+        counts[value] += 1;
+    return counts;
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(',')}}`;
+}
+function normalizeWhitespace(value) {
+    return value.trim().replace(/\s+/g, ' ');
+}
+function normalizeIdPart(value) {
+    return normalizeWhitespace(value).toLowerCase().replace(/[^a-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '') || 'unknown';
+}
+function sha256Hex(value) {
+    return node_crypto_1.default.createHash('sha256').update(value, 'utf8').digest('hex');
+}