@planu/cli 4.10.11 → 4.11.0

package/dist/engine/project-graph/builder.js

@@ -1,15 +1,24 @@
-import { collectProjectGraphSources, diffSourceHashes, hashText, loadProjectGraphPolicy, projectGraphCachePath, projectGraphPath, readProjectGraph, readProjectGraphSourceHashes, writeProjectGraph, writeProjectGraphSourceHashes, } from './cache.js';
+import { randomUUID } from 'node:crypto';
+import { collectProjectGraphSources, diffSourceHashes, hashText, hydrateProjectGraphSource, loadProjectGraphPolicy, projectGraphCachePath, projectGraphExtractorVersion, projectGraphPath, readProjectGraphArtifact, readProjectGraphCache, withProjectGraphBuildLock, writeProjectGraphArtifacts, } from './cache.js';
 import { extractGitGraph, extractReleaseGraph } from './extractors/git-extractor.js';
 import { extractHandoffGraph } from './extractors/handoff-extractor.js';
 import { extractDecisionStoreGraph } from './extractors/decision-store-extractor.js';
 import { extractSpecGraph } from './extractors/spec-extractor.js';
 import { extractValidationGraph } from './extractors/validation-extractor.js';
+import { createNativeProjectGraphRuntime } from './native.js';
+const NATIVE_PROJECT_GRAPH_IMPLEMENTATION_VERSION = 'native-project-graph-v2';
 function uniqueNodes(nodes) {
     return [...new Map(nodes.map((node) => [node.id, node])).values()];
 }
 function uniqueEdges(edges) {
     return [...new Map(edges.map((edge) => [edge.id, edge])).values()];
 }
+function sameSourceHashes(graphHashes, cacheHashes) {
+    const graphEntries = Object.entries(graphHashes);
+    const cacheEntries = Object.entries(cacheHashes);
+    return (graphEntries.length === cacheEntries.length &&
+        graphEntries.every(([sourceId, hash]) => cacheHashes[sourceId] === hash));
+}
 function validateAgainstPolicy(result, policy) {
     const nodes = result.nodes.filter((node) => policy.nodeTypes.includes(node.type));
     const edges = result.edges.filter((edge) => policy.edgeTypes.includes(edge.type) &&
@@ -17,61 +26,271 @@ function validateAgainstPolicy(result, policy) {
         policy.classifications.includes(edge.classification));
     return { nodes, edges };
 }
-export async function buildProjectKnowledgeGraph(args) {
-    const policy = args.policy ?? (await loadProjectGraphPolicy());
-    const sources = await collectProjectGraphSources({
+function codeNode(args) {
+    return {
+        id: args.id,
+        type: args.type,
+        label: args.label,
+        source: 'project-code-graph',
+        evidence: [{ path: args.path }],
+        metadata: args.metadata,
+        updatedAt: args.updatedAt,
+    };
+}
+function relationTargetNode(args) {
+    if (args.id.startsWith('module:')) {
+        const specifier = args.id.slice('module:'.length);
+        return codeNode({
+            id: args.id,
+            type: 'module',
+            label: specifier,
+            path: args.sourceFile,
+            updatedAt: args.updatedAt,
+            metadata: { specifier },
+        });
+    }
+    if (args.id.startsWith('scenario:')) {
+        const name = args.id.split('#').slice(1).join('#') || args.id;
+        return codeNode({
+            id: args.id,
+            type: 'scenario',
+            label: name,
+            path: args.sourceFile,
+            updatedAt: args.updatedAt,
+            metadata: { path: args.sourceFile, name },
+        });
+    }
+    const name = args.id.split('#').slice(1).join('#') || args.id;
+    const type = args.sourceFile.startsWith('src/tools/') && /^handle[A-Z]/.test(name)
+        ? 'tool_handler'
+        : 'symbol';
+    return codeNode({
+        id: args.id,
+        type,
+        label: name,
+        path: args.sourceFile,
+        updatedAt: args.updatedAt,
+        metadata: { path: args.sourceFile, name },
+    });
+}
+function extractNativeCodeFragment(args) {
+    const updatedAt = new Date().toISOString();
+    const relations = args.runtime.extractTypeScriptRelations(args.projectPath, [args.source.path], args.policy.limits.operational.maxFiles);
+    const fileType = args.source.path.includes('.test.') || args.source.path.endsWith('.test.ts') ? 'test' : 'file';
+    const nodes = [
+        codeNode({
+            id: `${fileType}:${args.source.path}`,
+            type: fileType,
+            label: args.source.path,
+            path: args.source.path,
+            updatedAt,
+            metadata: {
+                path: args.source.path,
+                hash: args.source.hash,
+                ...(args.source.size === undefined ? {} : { size: args.source.size }),
+                native: args.runtime.nativeActive,
+            },
+        }),
+    ];
+    nodes.push(...relations.flatMap((relation) => [
+        relationTargetNode({ id: relation.to, sourceFile: relation.sourceFile, updatedAt }),
+        relation.from.startsWith('test:')
+            ? codeNode({
+                id: relation.from,
+                type: 'test',
+                label: relation.sourceFile,
+                path: relation.sourceFile,
+                updatedAt,
+                metadata: { path: relation.sourceFile },
+            })
+            : codeNode({
+                id: relation.from,
+                type: 'file',
+                label: relation.sourceFile,
+                path: relation.sourceFile,
+                updatedAt,
+                metadata: { path: relation.sourceFile },
+            }),
+    ]));
+    const edges = relations.map((relation) => ({
+        id: `code:${relation.sourceFile}:${relation.relation}:${relation.from}->${relation.to}`,
+        from: relation.from,
+        to: relation.to,
+        type: relation.relation,
+        source: 'project-code-graph',
+        confidence: relation.confidence === 'low' || relation.confidence === 'medium'
+            ? relation.confidence
+            : 'high',
+        evidence: { path: relation.sourceFile },
+        classification: relation.classification === 'ambiguous' || relation.classification === 'inferred'
+            ? relation.classification
+            : 'extracted',
+        updatedAt,
+    }));
+    return validateAgainstPolicy({ nodes, edges }, args.policy);
+}
+function nativeCoreCacheVersion(runtime) {
+    const mode = runtime.nativeActive
+        ? `native:${process.platform}-${process.arch}`
+        : 'typescript-fallback';
+    return `${NATIVE_PROJECT_GRAPH_IMPLEMENTATION_VERSION}:${mode}`;
+}
+async function collectGitSource(projectPath) {
+    try {
+        const { execFile } = await import('node:child_process');
+        const stdout = await new Promise((resolveOutput, reject) => {
+            execFile('git', ['rev-parse', 'HEAD'], { cwd: projectPath }, (error, output) => {
+                if (error) {
+                    reject(new Error('git rev-parse failed', { cause: error }));
+                    return;
+                }
+                resolveOutput(output);
+            });
+        });
+        const head = stdout.trim();
+        if (head.length === 0) {
+            return null;
+        }
+        return {
+            id: 'project-git',
+            kind: 'project-git',
+            path: '.git/log',
+            content: head,
+            hash: hashText(head),
+            size: Buffer.byteLength(head),
+            mtimeMs: 0,
+            contentLoaded: true,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function extractSourceFragment(args) {
+    if (args.source.kind === 'spec') {
+        return extractSpecGraph(args.source, args.policy);
+    }
+    if (args.source.kind === 'validation') {
+        return extractValidationGraph(args.source, args.policy);
+    }
+    if (args.source.kind === 'handoff') {
+        return extractHandoffGraph(args.source, args.policy);
+    }
+    if (args.source.kind === 'decisions') {
+        return extractDecisionStoreGraph(args.source, args.policy);
+    }
+    if (args.source.kind === 'release-events') {
+        return extractReleaseGraph(args.source, args.policy);
+    }
+    if (args.source.kind === 'project-code') {
+        return extractNativeCodeFragment(args);
+    }
+    if (args.source.kind === 'project-git') {
+        return extractGitGraph({ projectPath: args.projectPath, policy: args.policy });
+    }
+    return { nodes: [], edges: [] };
+}
+function createFragment(args) {
+    return {
+        version: 1,
+        sourceId: args.source.id,
+        kind: args.source.kind,
+        contentHash: args.source.hash,
+        extractorVersion: projectGraphExtractorVersion(args.source.kind),
+        nativeCoreVersion: args.source.kind === 'project-code' ? args.nativeCoreVersion : 'not-applicable',
+        nodes: args.result.nodes,
+        edges: args.result.edges,
+    };
+}
+// eslint-disable-next-line max-lines-per-function -- the lock owner keeps one coherent snapshot transaction.
+async function buildProjectKnowledgeGraphUnlocked(args) {
+    const runtime = createNativeProjectGraphRuntime(args.policy.limits);
+    const nativeCoreVersion = nativeCoreCacheVersion(runtime);
+    const cacheResult = await readProjectGraphCache(args.projectId, args.policy);
+    const previousCache = cacheResult.cache;
+    const previousRecords = previousCache?.records ?? {};
+    const collected = await collectProjectGraphSources({
         projectId: args.projectId,
         projectPath: args.projectPath,
-        policy,
+        policy: args.policy,
+        previous: previousRecords,
+        nativeCoreVersion,
+    });
+    const gitSource = await collectGitSource(args.projectPath);
+    let sources = gitSource === null ? collected : [...collected, gitSource];
+    sources.sort((a, b) => a.id.localeCompare(b.id));
+    let diff = diffSourceHashes(sources, previousRecords, nativeCoreVersion, {
+        fragments: previousCache?.fragments,
+        knownSourceIds: cacheResult.knownSourceIds,
     });
-    const previousHashes = await readProjectGraphSourceHashes(args.projectId, policy);
-    const diff = diffSourceHashes(sources, previousHashes);
-    const existingGraph = await readProjectGraph(args.projectId, policy);
-    if (existingGraph !== null && diff.changed.length === 0) {
+    const changed = new Set(diff.changed);
+    const hydrated = await Promise.all(sources.map(async (source) => changed.has(source.id) && source.contentLoaded === false
+        ? await hydrateProjectGraphSource(source, args.policy.limits.operational.maxFileBytes)
+        : source));
+    sources = hydrated.filter((source) => source !== null);
+    diff = diffSourceHashes(sources, previousRecords, nativeCoreVersion, {
+        fragments: previousCache?.fragments,
+        knownSourceIds: cacheResult.knownSourceIds,
+    });
+    const existingGraph = await readProjectGraphArtifact(args.projectId, args.policy);
+    const hasConsistentExistingGraph = existingGraph !== null &&
+        typeof existingGraph.generation === 'string' &&
+        existingGraph.generation.length > 0 &&
+        existingGraph.generation === previousCache?.generation &&
+        sameSourceHashes(existingGraph.sourceHashes, diff.next) &&
+        Array.isArray(existingGraph.nodes) &&
+        Array.isArray(existingGraph.edges);
+    if (hasConsistentExistingGraph && diff.changed.length === 0 && diff.removed.length === 0) {
         return {
             graph: existingGraph,
-            graphPath: projectGraphPath(args.projectId, policy),
-            cachePath: projectGraphCachePath(args.projectId, policy),
+            generation: existingGraph.generation,
+            graphPath: projectGraphPath(args.projectId, args.policy),
+            cachePath: projectGraphCachePath(args.projectId, args.policy),
             reprocessedSources: [],
+            removedSources: [],
             skippedSources: diff.skipped,
             usedCache: true,
         };
     }
-    const extracted = [];
+    const changedIds = new Set(diff.changed);
+    const fragments = {};
     for (const source of sources) {
-        if (source.kind === 'spec') {
-            extracted.push(extractSpecGraph(source, policy));
-        }
-        else if (source.kind === 'validation') {
-            extracted.push(extractValidationGraph(source, policy));
-        }
-        else if (source.kind === 'handoff') {
-            extracted.push(extractHandoffGraph(source, policy));
-        }
-        else if (source.kind === 'decisions') {
-            extracted.push(extractDecisionStoreGraph(source, policy));
-        }
-        else if (source.kind === 'release-events') {
-            extracted.push(extractReleaseGraph(source, policy));
+        if (!changedIds.has(source.id)) {
+            const cached = previousCache?.fragments[source.id];
+            if (cached !== undefined) {
+                fragments[source.id] = cached;
+                continue;
+            }
         }
+        const extracted = await extractSourceFragment({
+            source,
+            projectPath: args.projectPath,
+            policy: args.policy,
+            runtime,
+        });
+        fragments[source.id] = createFragment({
+            source,
+            result: validateAgainstPolicy(extracted, args.policy),
+            nativeCoreVersion,
+        });
     }
-    extracted.push(await extractGitGraph({ projectPath: args.projectPath, policy }));
-    const validated = extracted.map((result) => validateAgainstPolicy(result, policy));
+    const validated = Object.values(fragments).map((fragment) => validateAgainstPolicy(fragment, args.policy));
     const nodes = uniqueNodes(validated.flatMap((result) => result.nodes));
     const nodeIds = new Set(nodes.map((node) => node.id));
     const edges = uniqueEdges(validated
         .flatMap((result) => result.edges)
         .filter((edge) => nodeIds.has(edge.from) && nodeIds.has(edge.to)));
-    const sourceHashes = diff.next;
-    const sourceHash = hashText(JSON.stringify(sourceHashes));
+    const generation = randomUUID();
+    const sourceHash = hashText(JSON.stringify(diff.next));
     const graph = {
         version: 1,
-        graphVersion: policy.graphVersion,
+        graphVersion: args.policy.graphVersion,
+        generation,
         projectId: args.projectId,
         projectPath: args.projectPath,
         generatedAt: new Date().toISOString(),
         sourceHash,
-        sourceHashes,
+        sourceHashes: diff.next,
         metadata: {
             nodeCount: nodes.length,
             edgeCount: edges.length,
@@ -82,15 +301,31 @@ export async function buildProjectKnowledgeGraph(args) {
         nodes,
         edges,
     };
-    await writeProjectGraph(args.projectId, policy, graph);
-    await writeProjectGraphSourceHashes(args.projectId, policy, sourceHashes);
+    const cache = {
+        version: 2,
+        generation,
+        records: diff.records,
+        fragments,
+    };
+    await writeProjectGraphArtifacts({
+        projectId: args.projectId,
+        policy: args.policy,
+        graph,
+        cache,
+    });
     return {
         graph,
-        graphPath: projectGraphPath(args.projectId, policy),
-        cachePath: projectGraphCachePath(args.projectId, policy),
+        generation,
+        graphPath: projectGraphPath(args.projectId, args.policy),
+        cachePath: projectGraphCachePath(args.projectId, args.policy),
         reprocessedSources: diff.changed,
+        removedSources: diff.removed,
         skippedSources: diff.skipped,
         usedCache: false,
     };
 }
+export async function buildProjectKnowledgeGraph(args) {
+    const policy = args.policy ?? (await loadProjectGraphPolicy());
+    return withProjectGraphBuildLock(args.projectId, policy, () => buildProjectKnowledgeGraphUnlocked({ ...args, policy }));
+}
 //# sourceMappingURL=builder.js.map

package/dist/engine/project-graph/cache.d.ts

@@ -1,22 +1,40 @@
-import type { ProjectGraphFreshness, ProjectGraphPolicy, ProjectGraphSource, ProjectKnowledgeGraph } from '../../types/project-knowledge-graph.js';
+import type { ProjectGraphCacheEnvelope, ProjectGraphCacheReadResult, ProjectGraphFreshness, ProjectGraphPolicy, ProjectGraphSource, ProjectGraphSourceCacheRecord, ProjectGraphSourceFragment, ProjectKnowledgeGraph } from '../../types/project-knowledge-graph.js';
 export declare function loadProjectGraphPolicy(): Promise<ProjectGraphPolicy>;
 export declare function hashText(text: string): string;
+export declare function projectGraphExtractorVersion(kind: string): string;
 export declare function projectGraphDir(projectId: string, policy: ProjectGraphPolicy): string;
 export declare function projectGraphPath(projectId: string, policy: ProjectGraphPolicy): string;
 export declare function projectGraphCachePath(projectId: string, policy: ProjectGraphPolicy): string;
+export declare function readProjectGraphCache(projectId: string, policy: ProjectGraphPolicy): Promise<ProjectGraphCacheReadResult>;
+export declare function readProjectGraphArtifact(projectId: string, policy: ProjectGraphPolicy): Promise<ProjectKnowledgeGraph | null>;
 export declare function readProjectGraph(projectId: string, policy: ProjectGraphPolicy): Promise<ProjectKnowledgeGraph | null>;
 export declare function writeProjectGraph(projectId: string, policy: ProjectGraphPolicy, graph: ProjectKnowledgeGraph): Promise<void>;
-export declare function readProjectGraphSourceHashes(projectId: string, policy: ProjectGraphPolicy): Promise<Record<string, string>>;
-export declare function writeProjectGraphSourceHashes(projectId: string, policy: ProjectGraphPolicy, hashes: Record<string, string>): Promise<void>;
-export declare function diffSourceHashes(sources: ProjectGraphSource[], previous: Record<string, string>): {
+export declare function readProjectGraphSourceHashes(projectId: string, policy: ProjectGraphPolicy): Promise<Record<string, ProjectGraphSourceCacheRecord>>;
+export declare function writeProjectGraphSourceHashes(projectId: string, policy: ProjectGraphPolicy, hashes: Record<string, ProjectGraphSourceCacheRecord>): Promise<void>;
+export declare function writeProjectGraphArtifacts(args: {
+    projectId: string;
+    policy: ProjectGraphPolicy;
+    graph: ProjectKnowledgeGraph;
+    cache: ProjectGraphCacheEnvelope;
+}): Promise<void>;
+export declare function withProjectGraphBuildLock<T>(projectId: string, policy: ProjectGraphPolicy, task: () => Promise<T>): Promise<T>;
+export declare function diffSourceHashes(sources: ProjectGraphSource[], previous: Record<string, ProjectGraphSourceCacheRecord>, nativeCoreVersion?: string, options?: {
+    fragments?: Record<string, ProjectGraphSourceFragment>;
+    knownSourceIds?: string[];
+}): {
     changed: string[];
+    removed: string[];
     skipped: string[];
     next: Record<string, string>;
+    records: Record<string, ProjectGraphSourceCacheRecord>;
 };
+export declare function hydrateProjectGraphSource(source: ProjectGraphSource, maxFileBytes: number): Promise<ProjectGraphSource | null>;
 export declare function collectProjectGraphSources(args: {
     projectId: string;
     projectPath: string;
     policy: ProjectGraphPolicy;
+    previous?: Record<string, ProjectGraphSourceCacheRecord>;
+    nativeCoreVersion?: string;
 }): Promise<ProjectGraphSource[]>;
 export declare function getProjectGraphFreshness(args: {
     projectId: string;