@hongmaple0820/scale-engine 0.43.0 → 0.45.0

package/dist/codegraph/CodeIntelligence.js

@@ -24,6 +24,10 @@ const CODEGRAPH_PROJECT_INIT_HINT = 'codegraph init -i';
 const CODEGRAPH_SERVE_COMMAND = 'codegraph serve --mcp';
 const GRAPHIFY_SOURCE = 'https://github.com/safishamsi/graphify';
 const GRAPHIFY_INSTALL_HINT = 'uv tool install graphify && graphify install --platform codex';
+const CRG_SOURCE = 'https://github.com/tirth8205/code-review-graph';
+const CRG_INSTALL_HINT = 'pip install code-review-graph';
+const CRG_PROJECT_INIT_HINT = 'code-review-graph build';
+const CRG_SERVE_COMMAND = 'code-review-graph serve';
 const DEFAULT_CODEGRAPH_PROVIDER = {
     id: 'codegraph',
     type: 'external-cli',
@@ -44,6 +48,17 @@ const DEFAULT_GRAPHIFY_PROVIDER = {
     source: GRAPHIFY_SOURCE,
     installHint: GRAPHIFY_INSTALL_HINT,
 };
+const DEFAULT_CRG_PROVIDER = {
+    id: 'code-review-graph',
+    type: 'external-cli',
+    enabled: true,
+    command: 'code-review-graph',
+    capabilities: ['symbols', 'callers', 'callees', 'impact', 'context', 'summary', 'module-map'],
+    source: CRG_SOURCE,
+    installHint: CRG_INSTALL_HINT,
+    projectInitHint: CRG_PROJECT_INIT_HINT,
+    serveCommand: CRG_SERVE_COMMAND,
+};
 let execFileSyncImpl = childProcess.execFileSync;
 export function setCodeIntelligenceExecFileSyncForTesting(impl) {
     execFileSyncImpl = impl ?? childProcess.execFileSync;
@@ -54,6 +69,7 @@ export function defaultCodeIntelligenceConfig() {
         providers: [
             { ...DEFAULT_CODEGRAPH_PROVIDER },
             { ...DEFAULT_GRAPHIFY_PROVIDER },
+            { ...DEFAULT_CRG_PROVIDER },
         ],
         fallback: {
             enabled: true,
@@ -225,6 +241,314 @@ export function createCodeGraphRoiReport(options) {
         evidenceLevel: report.fallbackUsed ? 'estimated' : 'measured',
     };
 }
+export function dumpCodeGraphData(options) {
+    const projectDir = resolve(options.projectDir ?? process.cwd());
+    const status = inspectCodeIntelligence({ projectDir, scaleDir: options.scaleDir });
+    const warnings = [];
+    // Priority 1: artifact manifest (graph.json)
+    const artifactProvider = status.providers.find(p => p.available && p.type === 'artifact');
+    if (artifactProvider) {
+        const config = loadCodeIntelligenceConfig(projectDir, options.scaleDir).config;
+        const providerConfig = config.providers.find(p => p.id === artifactProvider.id);
+        if (providerConfig?.manifest) {
+            const result = dumpArtifactManifest(projectDir, providerConfig);
+            if (result.nodes.length > 0)
+                return result;
+        }
+    }
+    // Priority 2: codegraph CLI (full index)
+    const externalProvider = status.providers.find(p => p.available && p.type === 'external-cli' && p.id === 'codegraph');
+    if (externalProvider && status.projectIndexExists) {
+        const result = dumpExternalCodeGraph(projectDir);
+        if (result.nodes.length > 0)
+            return result;
+    }
+    // Priority 3: fallback file walk
+    return dumpFallbackTopology(projectDir);
+}
+function dumpArtifactManifest(projectDir, provider) {
+    if (!provider.manifest)
+        return emptyTopology(projectDir, provider.id);
+    const manifestPath = resolveManifestWithFallback(projectDir, provider.manifest);
+    if (!manifestPath)
+        return emptyTopology(projectDir, provider.id);
+    try {
+        const content = readFileSync(manifestPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        // Graphify format: nodes[] + links[]
+        if (Array.isArray(parsed.nodes) && (Array.isArray(parsed.links) || Array.isArray(parsed.edges))) {
+            return dumpGraphifyManifest(projectDir, provider.id, parsed);
+        }
+        // Traditional format: symbols[] + files[]
+        const symbols = Array.isArray(parsed.symbols) ? parsed.symbols : [];
+        const files = Array.isArray(parsed.files) ? parsed.files : [];
+        return dumpTraditionalManifest(projectDir, provider.id, symbols, files);
+    }
+    catch {
+        return emptyTopology(projectDir, provider.id);
+    }
+}
+function resolveManifestWithFallback(projectDir, manifest) {
+    const primary = resolveProjectPath(projectDir, manifest);
+    if (existsSync(primary))
+        return primary;
+    // Fallback: try graph.json in the same directory
+    const dir = dirname(primary);
+    const fallback = join(dir, 'graph.json');
+    if (existsSync(fallback))
+        return fallback;
+    return undefined;
+}
+function dumpGraphifyManifest(projectDir, provider, manifest) {
+    const nodes = [];
+    const edges = [];
+    for (const node of manifest.nodes) {
+        const filePath = normalizeManifestPath(node.source_file ?? '');
+        nodes.push({
+            id: node.id,
+            kind: mapGraphifyKind(node.metadata?.kind),
+            name: node.label ?? node.id,
+            filePath,
+            line: parseLineNumber(node.source_location),
+        });
+    }
+    const linkSource = manifest.links ?? manifest.edges ?? [];
+    for (const link of linkSource) {
+        edges.push({
+            source: link.source,
+            target: link.target,
+            kind: mapGraphifyRelation(link.relation),
+        });
+    }
+    return {
+        nodes: dedupeTopologyNodes(nodes),
+        edges: dedupeTopologyEdges(edges),
+        generatedAt: new Date().toISOString(),
+        provider,
+        projectDir,
+    };
+}
+function mapGraphifyKind(kind) {
+    switch (kind) {
+        case 'file': return 'file';
+        case 'bash_function':
+        case 'bash_entrypoint': return 'function';
+        case 'code': return 'function';
+        default: return 'file';
+    }
+}
+function mapGraphifyRelation(relation) {
+    switch (relation) {
+        case 'calls': return 'calls';
+        case 'imports':
+        case 'imports_from': return 'imports';
+        case 'extends': return 'extends';
+        case 'implements': return 'implements';
+        case 'contains':
+        case 'defines':
+        case 'method': return 'depends-on';
+        default: return 'depends-on';
+    }
+}
+function parseLineNumber(loc) {
+    if (!loc)
+        return undefined;
+    const match = loc.match(/L(\d+)/);
+    return match ? parseInt(match[1], 10) : undefined;
+}
+function dumpTraditionalManifest(projectDir, provider, symbols, files) {
+    const nodes = [];
+    const edges = [];
+    const nodeIds = new Set();
+    // Symbol nodes
+    for (const sym of symbols) {
+        const name = String(sym.name ?? '');
+        const file = normalizeManifestPath(sym.file ?? sym.path);
+        if (!name)
+            continue;
+        const id = file ? `${file}::${name}` : name;
+        nodeIds.add(id);
+        nodes.push({
+            id,
+            kind: guessSymbolKind(name),
+            name,
+            filePath: file || '',
+        });
+        // Edges from callers/callees/dependencies
+        for (const callee of stringifyArray(sym.callees)) {
+            const target = resolveEdgeTarget(callee, symbols);
+            if (target)
+                edges.push({ source: id, target, kind: 'calls' });
+        }
+        for (const dep of stringifyArray(sym.dependencies)) {
+            const target = resolveEdgeTarget(dep, symbols);
+            if (target)
+                edges.push({ source: id, target, kind: 'depends-on' });
+        }
+        for (const caller of stringifyArray(sym.callers)) {
+            const target = resolveEdgeTarget(caller, symbols);
+            if (target)
+                edges.push({ source: target, target: id, kind: 'calls' });
+        }
+        for (const dependent of stringifyArray(sym.dependents)) {
+            const target = resolveEdgeTarget(dependent, symbols);
+            if (target)
+                edges.push({ source: target, target: id, kind: 'depends-on' });
+        }
+    }
+    // File nodes (for files not yet represented by symbols)
+    for (const file of files) {
+        const path = normalizeManifestPath(file.path ?? file.file);
+        if (!path)
+            continue;
+        const fileId = `file:${path}`;
+        if (!nodeIds.has(fileId)) {
+            nodeIds.add(fileId);
+            nodes.push({ id: fileId, kind: 'file', name: path.split('/').pop() ?? path, filePath: path });
+        }
+        // Import edges
+        for (const imp of stringifyArray(file.imports)) {
+            const targetFile = normalizeManifestPath(imp);
+            if (targetFile) {
+                const targetId = `file:${targetFile}`;
+                edges.push({ source: fileId, target: targetId, kind: 'imports' });
+            }
+        }
+        // dependsOn edges
+        for (const dep of stringifyArray(file.dependsOn)) {
+            const targetFile = normalizeManifestPath(dep);
+            if (targetFile) {
+                const targetId = `file:${targetFile}`;
+                edges.push({ source: fileId, target: targetId, kind: 'depends-on' });
+            }
+        }
+    }
+    return {
+        nodes: dedupeTopologyNodes(nodes),
+        edges: dedupeTopologyEdges(edges),
+        generatedAt: new Date().toISOString(),
+        provider,
+        projectDir,
+    };
+}
+function dumpExternalCodeGraph(projectDir) {
+    try {
+        // Use codegraph CLI to get a broad dump via empty query
+        const output = runExternalCommandSync('codegraph', ['query', '', '-p', projectDir, '--json'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }, {
+            execFileSync: execFileSyncImpl,
+            spawnSync: childProcess.spawnSync,
+        });
+        const parsed = JSON.parse(String(output));
+        const nodes = [];
+        const seen = new Set();
+        for (const entry of parsed) {
+            const file = normalizeManifestPath(entry.node?.filePath);
+            const name = String(entry.node?.qualifiedName ?? entry.node?.name ?? '').trim();
+            if (!file || !name)
+                continue;
+            const id = `${file}::${name}`;
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            nodes.push({
+                id,
+                kind: mapCodeGraphKind(entry.node?.kind),
+                name,
+                filePath: file,
+                line: entry.node?.startLine,
+            });
+        }
+        return {
+            nodes,
+            edges: [], // CLI doesn't return edge data in query mode
+            generatedAt: new Date().toISOString(),
+            provider: 'codegraph',
+            projectDir,
+        };
+    }
+    catch {
+        return emptyTopology(projectDir, 'codegraph');
+    }
+}
+function dumpFallbackTopology(projectDir) {
+    const files = sourceFiles(projectDir);
+    const nodes = files.map(file => {
+        const rel = normalizePath(relative(projectDir, file));
+        return {
+            id: `file:${rel}`,
+            kind: 'file',
+            name: rel.split('/').pop() ?? rel,
+            filePath: rel,
+        };
+    });
+    return {
+        nodes,
+        edges: [],
+        generatedAt: new Date().toISOString(),
+        provider: 'fallback-file-walk',
+        projectDir,
+    };
+}
+function resolveEdgeTarget(ref, symbols) {
+    const asPath = normalizeManifestPath(ref);
+    if (asPath && hasFileExtension(asPath)) {
+        // Reference is a file path — find a symbol in that file
+        const sym = symbols.find(s => normalizeManifestPath(s.file ?? s.path) === asPath);
+        return sym ? `${asPath}::${sym.name}` : `file:${asPath}`;
+    }
+    // Reference is a symbol name
+    const sym = symbols.find(s => String(s.name) === ref);
+    if (sym) {
+        const file = normalizeManifestPath(sym.file ?? sym.path);
+        return file ? `${file}::${ref}` : ref;
+    }
+    return undefined;
+}
+function guessSymbolKind(name) {
+    if (/^[A-Z]/.test(name))
+        return 'class';
+    if (/^[A-Z_][A-Z_0-9]*$/.test(name))
+        return 'constant';
+    return 'function';
+}
+function mapCodeGraphKind(kind) {
+    switch (kind?.toLowerCase()) {
+        case 'class':
+        case 'struct':
+        case 'interface':
+        case 'type': return 'class';
+        case 'function':
+        case 'method':
+        case 'constructor': return 'function';
+        case 'constant':
+        case 'enum': return 'constant';
+        case 'module':
+        case 'namespace':
+        case 'package': return 'module';
+        default: return 'function';
+    }
+}
+function dedupeTopologyNodes(nodes) {
+    const seen = new Set();
+    return nodes.filter(n => { if (seen.has(n.id))
+        return false; seen.add(n.id); return true; });
+}
+function dedupeTopologyEdges(edges) {
+    const seen = new Set();
+    return edges.filter(e => {
+        const key = `${e.source}->${e.target}:${e.kind}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function emptyTopology(projectDir, provider) {
+    return { nodes: [], edges: [], generatedAt: new Date().toISOString(), provider, projectDir };
+}
 function runCodeGraphQuery(options) {
     const projectDir = resolve(options.projectDir ?? process.cwd());
     const query = options.query.trim();
@@ -255,6 +579,16 @@ function runCodeGraphQuery(options) {
                 warnings.push(`Provider ${externalAvailable.id} returned no hits for "${query}".`);
         }
     }
+    else if (externalAvailable?.id === 'code-review-graph' && options.mode === 'query') {
+        const crgQuery = queryExternalCRG({ projectDir, query });
+        if (crgQuery) {
+            hits = crgQuery.hits;
+            provider = externalAvailable.id;
+            warnings.push(...crgQuery.warnings);
+            if (hits.length === 0)
+                warnings.push(`Provider code-review-graph returned no hits for "${query}".`);
+        }
+    }
     else if (externalAvailable) {
         if (externalAvailable.id === 'codegraph' && !status.projectIndexExists) {
             warnings.push('CodeGraph CLI is installed, but this project has no .codegraph/ index yet; run codegraph init -i to enable upstream graph queries.');
@@ -310,15 +644,20 @@ function providerStatus(projectDir) {
             };
         }
         if (provider.type === 'artifact') {
-            const manifest = provider.manifest ? resolveProjectPath(projectDir, provider.manifest) : '';
-            const available = Boolean(manifest && existsSync(manifest));
+            const resolved = provider.manifest ? resolveManifestWithFallback(projectDir, provider.manifest) : undefined;
+            const available = Boolean(resolved);
+            const reason = available
+                ? resolved === resolveProjectPath(projectDir, provider.manifest ?? '')
+                    ? `manifest found at ${provider.manifest}`
+                    : `manifest found via fallback at graph.json (configured: ${provider.manifest})`
+                : `manifest not found: ${provider.manifest ?? '(missing)'}`;
             return {
                 id: provider.id,
                 type: provider.type,
                 enabled,
                 available,
                 capabilities,
-                reason: available ? `manifest found at ${provider.manifest}` : `manifest not found: ${provider.manifest ?? '(missing)'}`,
+                reason,
                 source: provider.source,
                 installHint: provider.installHint,
                 projectInitHint: provider.projectInitHint,
@@ -331,7 +670,9 @@ function providerStatus(projectDir) {
                 ? projectIndexExists
                     ? '; project index found at .codegraph/'
                     : '; project index missing (.codegraph/)'
-                : '';
+                : provider.id === 'code-review-graph'
+                    ? '; run code-review-graph build to index the project'
+                    : '';
             return {
                 id: provider.id,
                 type: provider.type,
@@ -529,6 +870,7 @@ function confidence(hitCount, fallbackUsed) {
 function recommendations(configExists, providers, fallbackAvailable, projectIndexExists) {
     const output = [];
     const codegraph = providers.find(provider => provider.id === 'codegraph');
+    const crg = providers.find(provider => provider.id === 'code-review-graph');
     if (!configExists)
         output.push('Run scale codegraph init to create .scale/code-intelligence.json.');
     if (codegraph && !codegraph.available && codegraph.installHint) {
@@ -537,6 +879,9 @@ function recommendations(configExists, providers, fallbackAvailable, projectInde
     if (codegraph?.available && !projectIndexExists) {
         output.push('Run codegraph init -i in the project root to build the local .codegraph/ index.');
     }
+    if (crg && !crg.available && crg.installHint) {
+        output.push(`Install code-review-graph from ${crg.source ?? CRG_SOURCE}: ${crg.installHint}.`);
+    }
     if (providers.every(provider => !provider.available))
         output.push('No graph provider is available; exploration will use explicit fallback.');
     if (!fallbackAvailable)
@@ -584,7 +929,9 @@ function hydrateProviderConfig(provider) {
         ? DEFAULT_CODEGRAPH_PROVIDER
         : provider.id === 'graphify'
             ? DEFAULT_GRAPHIFY_PROVIDER
-            : undefined;
+            : provider.id === 'code-review-graph'
+                ? DEFAULT_CRG_PROVIDER
+                : undefined;
     return {
         ...(defaults ?? {}),
         ...provider,
@@ -678,4 +1025,109 @@ function queryExternalCodeGraphContext(options) {
         return null;
     }
 }
+function crgCommandExists() {
+    return commandExists('code-review-graph');
+}
+function runCRGCommand(args, projectDir) {
+    try {
+        const result = runExternalCommandSync('code-review-graph', args, {
+            encoding: 'utf8',
+            cwd: projectDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }, {
+            execFileSync: execFileSyncImpl,
+            spawnSync: childProcess.spawnSync,
+        });
+        return typeof result === 'string' ? result : String(result);
+    }
+    catch {
+        return null;
+    }
+}
+export function queryExternalCRG(options) {
+    // code-review-graph exposes search via MCP tools, not CLI query.
+    // Use detect-changes as a proxy for graph availability, and fall through
+    // to the artifact provider (SQLite graph) for actual search.
+    if (!crgCommandExists())
+        return null;
+    // Verify graph exists
+    const output = runCRGCommand(['status'], options.projectDir);
+    if (!output || !output.includes('Nodes:'))
+        return { hits: [], warnings: ['code-review-graph graph not built; run code-review-graph build'] };
+    // CRG search is MCP-only; return empty hits so the caller falls through to artifact or fallback
+    return { hits: [], warnings: ['code-review-graph search is available via MCP tools only; use code-review-graph serve or code-review-graph mcp'] };
+}
+export function detectChangesCRG(options) {
+    if (!crgCommandExists())
+        return null;
+    const args = ['detect-changes'];
+    if (options.baseRef)
+        args.push('--base', options.baseRef);
+    const output = runCRGCommand(args, options.projectDir);
+    if (!output)
+        return null;
+    try {
+        const parsed = JSON.parse(output);
+        const changedFiles = [];
+        const affectedSymbols = [];
+        const affectedTests = [];
+        for (const fn of parsed.changed_functions ?? []) {
+            const file = normalizeManifestPath(fn.file);
+            if (file && !changedFiles.includes(file))
+                changedFiles.push(file);
+            if (fn.name && file)
+                affectedSymbols.push({ symbol: fn.name, file, reason: 'changed function' });
+        }
+        for (const gap of parsed.test_gaps ?? []) {
+            const file = normalizeManifestPath(gap.file);
+            if (file)
+                affectedTests.push(file);
+        }
+        for (const priority of parsed.review_priorities ?? []) {
+            const file = normalizeManifestPath(priority.file);
+            if (file && !changedFiles.includes(file))
+                changedFiles.push(file);
+        }
+        return {
+            changedFiles,
+            affectedSymbols,
+            affectedTests,
+            blastRadiusFiles: changedFiles,
+            provider: 'code-review-graph',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function reviewContextCRG(options) {
+    if (!crgCommandExists())
+        return null;
+    // Use detect-changes for token savings overview
+    const output = runCRGCommand(['detect-changes'], options.projectDir);
+    if (!output)
+        return null;
+    try {
+        const parsed = JSON.parse(output);
+        const files = (parsed.changed_functions ?? [])
+            .map(fn => normalizeManifestPath(fn.file))
+            .filter(Boolean);
+        const savedTokens = parsed.context_savings?.saved_tokens ?? 0;
+        const savedPercent = parsed.context_savings?.saved_percent ?? 0;
+        const naiveCorpus = savedTokens > 0 && savedPercent > 0 && savedPercent < 100
+            ? Math.round(savedTokens / (1 - savedPercent / 100))
+            : savedTokens > 0 ? savedTokens + 70 : 0;
+        const graphQuery = naiveCorpus > savedTokens ? naiveCorpus - savedTokens : 70;
+        const reduction = naiveCorpus > 0 ? Math.round(naiveCorpus / graphQuery) : 1;
+        return {
+            files,
+            blastRadius: [],
+            tokenSavings: { naiveCorpus, graphQuery, reduction },
+            provider: 'code-review-graph',
+        };
+    }
+    catch {
+        return null;
+    }
+}
 //# sourceMappingURL=CodeIntelligence.js.map