@veewo/gitnexus 1.5.0-rc.4 → 1.5.1

package/dist/cli/sync-manifest.js

@@ -0,0 +1,200 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { parseScopeManifestConfig } from './scope-manifest-config.js';
+import { normalizeRepoAlias, parseExtensionList } from './analyze-options.js';
+export function resolveDefaultSyncManifestPath(repoPath) {
+    return path.join(repoPath, '.gitnexus', 'sync-manifest.txt');
+}
+export function shouldAutoUseSyncManifest(options) {
+    if (options?.scopeManifest)
+        return false;
+    return parseScopePrefixCount(options?.scopePrefix) === 0;
+}
+export async function resolveScopeManifestForAnalyze(repoPath, options, pathExists = fileExists) {
+    if (options?.scopeManifest) {
+        return options.scopeManifest;
+    }
+    if (!shouldAutoUseSyncManifest(options)) {
+        return undefined;
+    }
+    const defaultManifestPath = resolveDefaultSyncManifestPath(repoPath);
+    if (await pathExists(defaultManifestPath)) {
+        return defaultManifestPath;
+    }
+    return undefined;
+}
+export async function enforceSyncManifestConsistency(input) {
+    if (!input.manifestPath) {
+        return { decision: 'none', diff: [] };
+    }
+    ensureConcreteManifestPath(input.manifestPath);
+    const raw = await fs.readFile(input.manifestPath, 'utf-8');
+    const parsed = parseScopeManifestConfig(raw);
+    const normalizedDirectives = normalizeManifestDirectives(parsed.directives);
+    const diff = computeDiff(normalizedDirectives, input);
+    const policy = normalizePolicy(input.policy);
+    if (diff.length === 0) {
+        if (policy === 'update') {
+            throw new Error('Sync manifest rewrite requires non-empty diff entries.');
+        }
+        return { decision: 'none', diff };
+    }
+    const decision = await resolveDecision(policy, input.manifestPath, diff, input.stdinIsTTY, input.prompt);
+    if (decision === 'update') {
+        const nextDirectives = mergeDirectivesForUpdate(normalizedDirectives, input);
+        const rewritten = renderSyncManifest(parsed.scopeRules, nextDirectives);
+        await fs.writeFile(input.manifestPath, rewritten, 'utf-8');
+    }
+    return {
+        decision,
+        diff,
+    };
+}
+function parseScopePrefixCount(scopePrefix) {
+    if (Array.isArray(scopePrefix))
+        return scopePrefix.length;
+    if (typeof scopePrefix === 'string')
+        return scopePrefix.trim() ? 1 : 0;
+    return 0;
+}
+async function fileExists(candidatePath) {
+    try {
+        await fs.stat(candidatePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizePolicy(raw) {
+    if (!raw)
+        return 'ask';
+    if (raw === 'ask' || raw === 'update' || raw === 'keep' || raw === 'error')
+        return raw;
+    throw new Error(`Invalid --sync-manifest-policy value: ${raw}. Use ask|update|keep|error.`);
+}
+function normalizeManifestDirectives(directives) {
+    return {
+        extensions: normalizeExtensions(directives.extensions),
+        repoAlias: normalizeAlias(directives.repoAlias),
+        embeddings: normalizeEmbeddings(directives.embeddings),
+    };
+}
+function computeDiff(manifest, input) {
+    const diff = [];
+    if (input.extensions !== undefined) {
+        const cliValue = normalizeExtensions(input.extensions);
+        if (cliValue !== manifest.extensions) {
+            diff.push({ directive: 'extensions', manifestValue: manifest.extensions, cliValue: cliValue || '' });
+        }
+    }
+    if (input.repoAlias !== undefined) {
+        const cliValue = normalizeAlias(input.repoAlias);
+        if (cliValue !== manifest.repoAlias) {
+            diff.push({ directive: 'repoAlias', manifestValue: manifest.repoAlias, cliValue: cliValue || '' });
+        }
+    }
+    if (input.embeddings !== undefined) {
+        const cliValue = input.embeddings ? 'true' : 'false';
+        if (cliValue !== manifest.embeddings) {
+            diff.push({ directive: 'embeddings', manifestValue: manifest.embeddings, cliValue });
+        }
+    }
+    return diff;
+}
+async function resolveDecision(policy, manifestPath, diff, stdinIsTTY, prompt) {
+    if (policy === 'update' || policy === 'keep')
+        return policy;
+    if (policy === 'error') {
+        throw new Error(`${formatMismatchHeader(manifestPath)}\n${formatDiff(diff)}`);
+    }
+    if (stdinIsTTY === undefined) {
+        throw new Error('TTY prompt branch requires concrete stdin.isTTY evidence.');
+    }
+    const interactive = stdinIsTTY;
+    if (!interactive) {
+        throw new Error(`${formatMismatchHeader(manifestPath)}\n${formatDiff(diff)}\n` +
+            'Non-interactive mode requires --sync-manifest-policy ask|update|keep|error.');
+    }
+    const promptFn = prompt || defaultPrompt;
+    return promptFn([
+        formatMismatchHeader(manifestPath),
+        formatDiff(diff),
+        'Choose: update (rewrite sync-manifest) or keep (continue without rewrite).',
+    ].join('\n'));
+}
+function mergeDirectivesForUpdate(manifest, input) {
+    const merged = { ...manifest };
+    if (input.extensions !== undefined) {
+        merged.extensions = normalizeExtensions(input.extensions);
+    }
+    if (input.repoAlias !== undefined) {
+        merged.repoAlias = normalizeAlias(input.repoAlias);
+    }
+    if (input.embeddings !== undefined) {
+        merged.embeddings = input.embeddings ? 'true' : 'false';
+    }
+    return merged;
+}
+function renderSyncManifest(scopeRules, directives) {
+    const lines = [...scopeRules];
+    if (directives.extensions)
+        lines.push(`@extensions=${directives.extensions}`);
+    if (directives.repoAlias)
+        lines.push(`@repoAlias=${directives.repoAlias}`);
+    if (directives.embeddings)
+        lines.push(`@embeddings=${directives.embeddings}`);
+    return `${lines.join('\n')}\n`;
+}
+function normalizeExtensions(raw) {
+    if (raw === undefined)
+        return undefined;
+    const parsed = parseExtensionList(raw);
+    return parsed.length > 0 ? parsed.join(',') : undefined;
+}
+function normalizeAlias(raw) {
+    if (raw === undefined)
+        return undefined;
+    return normalizeRepoAlias(raw);
+}
+function normalizeEmbeddings(raw) {
+    if (raw === undefined)
+        return undefined;
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'true')
+        return 'true';
+    if (normalized === 'false')
+        return 'false';
+    throw new Error(`Invalid @embeddings directive value: ${raw}. Expected true or false.`);
+}
+function formatMismatchHeader(manifestPath) {
+    return `Explicit analyze options differ from sync manifest directives: ${manifestPath}`;
+}
+function formatDiff(diff) {
+    return diff
+        .map((entry) => `- @${entry.directive}: ${entry.manifestValue ?? '<unset>'} -> ${entry.cliValue}`)
+        .join('\n');
+}
+async function defaultPrompt(message) {
+    const rl = readline.createInterface({ input, output });
+    try {
+        const answer = await rl.question(`${message}\nUpdate sync-manifest now? [y/N] `);
+        return /^y(es)?$/i.test(answer.trim()) ? 'update' : 'keep';
+    }
+    finally {
+        rl.close();
+    }
+}
+function ensureConcreteManifestPath(manifestPath) {
+    const normalized = manifestPath.trim();
+    if (!normalized) {
+        throw new Error('Invalid placeholder manifest path: empty value.');
+    }
+    if (/placeholder/i.test(normalized) ||
+        /<\s*path\s*>/i.test(normalized) ||
+        /todo/i.test(normalized)) {
+        throw new Error(`Invalid placeholder manifest path: ${manifestPath}`);
+    }
+}

package/dist/cli/sync-manifest.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/sync-manifest.test.js

@@ -0,0 +1,88 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { enforceSyncManifestConsistency } from './sync-manifest.js';
+async function writeManifest(filePath, content) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf-8');
+}
+test('when explicit CLI values differ from manifest, TTY mode asks whether to update manifest', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-'));
+    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
+    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
+    let promptMessage = '';
+    const result = await enforceSyncManifestConsistency({
+        manifestPath,
+        extensions: '.ts',
+        policy: 'ask',
+        stdinIsTTY: true,
+        prompt: async (message) => {
+            promptMessage = message;
+            return 'keep';
+        },
+    });
+    assert.equal(result.decision, 'keep');
+    assert.match(promptMessage, /@extensions/i);
+    assert.match(promptMessage, /sync-manifest\.txt/i);
+    assert.match(promptMessage, /update/i);
+    assert.match(promptMessage, /keep/i);
+});
+test('non-TTY without explicit policy exits with actionable error', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-'));
+    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
+    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
+    await assert.rejects(enforceSyncManifestConsistency({
+        manifestPath,
+        extensions: '.ts',
+        stdinIsTTY: false,
+    }), /--sync-manifest-policy/i);
+});
+test('policy=update rewrites manifest with normalized directives', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-'));
+    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
+    await writeManifest(manifestPath, ['Assets/', 'Packages/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
+    const result = await enforceSyncManifestConsistency({
+        manifestPath,
+        extensions: '.ts,.tsx',
+        embeddings: true,
+        policy: 'update',
+    });
+    const rewritten = await fs.readFile(manifestPath, 'utf-8');
+    assert.equal(result.decision, 'update');
+    assert.equal(rewritten, ['Assets', 'Packages', '@extensions=.ts,.tsx', '@repoAlias=demo-repo', '@embeddings=true', ''].join('\n'));
+});
+test('rejects placeholder manifest path values', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-placeholder-'));
+    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest-placeholder.txt');
+    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
+    await assert.rejects(enforceSyncManifestConsistency({
+        manifestPath,
+        extensions: '.ts',
+        policy: 'keep',
+    }), /placeholder manifest path/i);
+});
+test('TTY prompt branch requires concrete stdin.isTTY evidence', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-tty-evidence-'));
+    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
+    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
+    await assert.rejects(enforceSyncManifestConsistency({
+        manifestPath,
+        extensions: '.ts',
+        policy: 'ask',
+        prompt: async () => 'keep',
+    }), /stdin\.isTTY evidence/i);
+});
+test('manifest rewrite requires non-empty diff entries', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-noop-'));
+    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
+    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
+    await assert.rejects(enforceSyncManifestConsistency({
+        manifestPath,
+        extensions: '.cs,.meta',
+        repoAlias: 'demo-repo',
+        embeddings: false,
+        policy: 'update',
+    }), /non-empty diff/i);
+});

package/dist/cli/tool.d.ts

@@ -21,6 +21,7 @@ export declare function queryCommand(queryText: string, options?: {
     goal?: string;
     limit?: string;
     content?: boolean;
+    responseProfile?: 'slim' | 'full';
     scopePreset?: 'unity-gameplay' | 'unity-all';
     unityResources?: UnityResourcesMode;
     unityHydration?: UnityHydrationMode;
@@ -34,6 +35,7 @@ export declare function contextCommand(name: string, options?: {
     file?: string;
     uid?: string;
     content?: boolean;
+    responseProfile?: 'slim' | 'full';
     unityResources?: UnityResourcesMode;
     unityHydration?: UnityHydrationMode;
     unityEvidence?: UnityEvidenceMode;

package/dist/cli/tool.js

@@ -91,6 +91,7 @@ export async function queryCommand(queryText, options) {
         goal: options?.goal,
         limit: options?.limit ? parseInt(options.limit) : undefined,
         include_content: options?.content ?? false,
+        response_profile: options?.responseProfile,
         scope_preset: options?.scopePreset,
         unity_resources: options?.unityResources,
         unity_hydration_mode: options?.unityHydration,
@@ -114,6 +115,7 @@ export async function contextCommand(name, options) {
         uid: options?.uid,
         file_path: options?.file,
         include_content: options?.content ?? false,
+        response_profile: options?.responseProfile,
         unity_resources: options?.unityResources,
         unity_hydration_mode: options?.unityHydration,
         unity_evidence_mode: options?.unityEvidence,

package/dist/core/config/unity-config.d.ts

@@ -1,11 +1,11 @@
 export interface UnityConfig {
     maxSyntheticEdgesPerClass: number;
     maxSyntheticEdgesTotal: number;
+    enableContainerNodes: boolean;
     lazyMaxPaths: number;
     lazyBatchSize: number;
     lazyMaxMs: number;
     payloadMode: 'compact' | 'full';
-    persistLifecycleProcessMetadata: boolean;
     parityWarmup: boolean;
     parityWarmupMaxParallel: number;
     paritySeedCacheIdleMs: number;

package/dist/core/config/unity-config.js

@@ -3,11 +3,11 @@ import { join } from 'node:path';
 const DEFAULTS = {
     maxSyntheticEdgesPerClass: 12,
     maxSyntheticEdgesTotal: 256,
+    enableContainerNodes: false,
     lazyMaxPaths: 120,
     lazyBatchSize: 30,
     lazyMaxMs: 5000,
     payloadMode: 'compact',
-    persistLifecycleProcessMetadata: false,
     parityWarmup: false,
     parityWarmupMaxParallel: 4,
     paritySeedCacheIdleMs: 60000,

package/dist/core/ingestion/call-processor.d.ts

@@ -5,7 +5,8 @@ import type { ExtractedCall, ExtractedHeritage, ExtractedRoute, FileConstructorB
 export declare const processCalls: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
-}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<ExtractedHeritage[]>;
+    rawContent?: string;
+}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, onRawFallbackParse?: (count: number) => void) => Promise<ExtractedHeritage[]>;
 /**
  * Fast path: resolve pre-extracted call sites from workers.
  * No AST parsing — workers already extracted calledName + sourceId.

package/dist/core/ingestion/call-processor.js

@@ -1,11 +1,10 @@
 import Parser from 'tree-sitter';
 import { TIER_CONFIDENCE } from './resolution-context.js';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { isLanguageAvailable, loadParser, loadLanguage, parseContent } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, findEnclosingClassId, CALL_EXPRESSION_TYPES, extractCallChain, } from './utils.js';
 import { buildTypeEnv } from './type-env.js';
-import { getTreeSitterBufferSize } from './constants.js';
 import { callRouters } from './call-routing.js';
 import { extractReturnTypeName } from './type-extractors/shared.js';
 /**
@@ -86,7 +85,7 @@ const verifyConstructorBindings = (bindings, filePath, ctx, graph) => {
     }
     return verified;
 };
-export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
+export const processCalls = async (graph, files, astCache, ctx, onProgress, onRawFallbackParse) => {
     const parser = await loadParser();
     const collectedHeritage = [];
     const logSkipped = isVerboseIngestionEnabled();
@@ -112,10 +111,33 @@ export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
         let tree = astCache.get(file.path);
         if (!tree) {
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+                tree = parseContent(file.content);
             }
-            catch (parseError) {
-                continue;
+            catch {
+                if (file.rawContent && file.rawContent !== file.content) {
+                    try {
+                        tree = parseContent(file.rawContent);
+                        onRawFallbackParse?.(1);
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                else {
+                    continue;
+                }
+            }
+            if (file.rawContent && file.rawContent !== file.content && tree.rootNode?.hasError) {
+                try {
+                    const rawTree = parseContent(file.rawContent);
+                    if (!rawTree.rootNode?.hasError) {
+                        tree = rawTree;
+                        onRawFallbackParse?.(1);
+                    }
+                }
+                catch {
+                    // Keep normalized parse result when raw fallback fails
+                }
             }
             astCache.set(file.path, tree);
         }

package/dist/core/ingestion/heritage-processor.d.ts

@@ -20,7 +20,8 @@ import type { ResolutionContext } from './resolution-context.js';
 export declare const processHeritage: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
-}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<void>;
+    rawContent?: string;
+}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, onRawFallbackParse?: (count: number) => void) => Promise<void>;
 /**
  * Fast path: resolve pre-extracted heritage from workers.
  * No AST parsing — workers already extracted className + parentName + kind.

package/dist/core/ingestion/heritage-processor.js

@@ -14,12 +14,11 @@
  *   - All other languages: default to EXTENDS
  */
 import Parser from 'tree-sitter';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { isLanguageAvailable, loadParser, loadLanguage, parseContent } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop } from './utils.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
-import { getTreeSitterBufferSize } from './constants.js';
 /** C#/Java convention: interfaces start with I followed by an uppercase letter */
 const INTERFACE_NAME_RE = /^I[A-Z]/;
 /**
@@ -65,7 +64,7 @@ const resolveHeritageId = (name, filePath, ctx, fallbackLabel, fallbackKey) => {
     }
     return generateId(fallbackLabel, fallbackKey ?? name);
 };
-export const processHeritage = async (graph, files, astCache, ctx, onProgress) => {
+export const processHeritage = async (graph, files, astCache, ctx, onProgress, onRawFallbackParse) => {
     const parser = await loadParser();
     const logSkipped = isVerboseIngestionEnabled();
     const skippedByLang = logSkipped ? new Map() : null;
@@ -94,11 +93,35 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
         if (!tree) {
             // Use larger bufferSize for files > 32KB
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+                tree = parseContent(file.content);
             }
-            catch (parseError) {
-                // Skip files that can't be parsed
-                continue;
+            catch {
+                if (file.rawContent && file.rawContent !== file.content) {
+                    try {
+                        tree = parseContent(file.rawContent);
+                        onRawFallbackParse?.(1);
+                    }
+                    catch {
+                        // Skip files that can't be parsed
+                        continue;
+                    }
+                }
+                else {
+                    // Skip files that can't be parsed
+                    continue;
+                }
+            }
+            if (file.rawContent && file.rawContent !== file.content && tree.rootNode?.hasError) {
+                try {
+                    const rawTree = parseContent(file.rawContent);
+                    if (!rawTree.rootNode?.hasError) {
+                        tree = rawTree;
+                        onRawFallbackParse?.(1);
+                    }
+                }
+                catch {
+                    // Keep normalized parse result when raw fallback fails
+                }
             }
             // Cache re-parsed tree for potential future use
             astCache.set(file.path, tree);

package/dist/core/ingestion/import-processor.d.ts

@@ -28,7 +28,8 @@ export declare function buildImportResolutionContext(allPaths: string[]): Import
 export declare const processImports: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
-}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, repoRoot?: string, allPaths?: string[]) => Promise<void>;
+    rawContent?: string;
+}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, repoRoot?: string, allPaths?: string[], onRawFallbackParse?: (count: number) => void) => Promise<void>;
 export declare const processImportsFromExtracted: (graph: KnowledgeGraph, files: {
     path: string;
 }[], extractedImports: ExtractedImport[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, repoRoot?: string, prebuiltCtx?: ImportResolutionContext) => Promise<void>;

package/dist/core/ingestion/import-processor.js

@@ -1,11 +1,10 @@
 import Parser from 'tree-sitter';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { isLanguageAvailable, loadParser, loadLanguage, parseContent } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop } from './utils.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 import { extractNamedBindings } from './named-binding-extraction.js';
-import { getTreeSitterBufferSize } from './constants.js';
 import { loadTsconfigPaths, loadGoModulePath, loadComposerConfig, loadCSharpProjectConfig, loadSwiftPackageConfig, } from './language-config.js';
 import { buildSuffixIndex, resolveImportPath, appendKotlinWildcard, KOTLIN_EXTENSIONS, resolveJvmWildcard, resolveJvmMemberImport, resolveGoPackageDir, resolveGoPackage, resolveCSharpImport, resolveCSharpNamespaceDir, resolvePhpImport, resolveRustImport, resolveRubyImport, resolvePythonImport, } from './resolvers/index.js';
 import { callRouters } from './call-routing.js';
@@ -173,7 +172,7 @@ function applyImportResult(result, filePath, importMap, packageMap, addImportEdg
 // ============================================================================
 // MAIN IMPORT PROCESSOR
 // ============================================================================
-export const processImports = async (graph, files, astCache, ctx, onProgress, repoRoot, allPaths) => {
+export const processImports = async (graph, files, astCache, ctx, onProgress, repoRoot, allPaths, onRawFallbackParse) => {
     const importMap = ctx.importMap;
     const packageMap = ctx.packageMap;
     const namedImportMap = ctx.namedImportMap;
@@ -249,10 +248,33 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
         let wasReparsed = false;
         if (!tree) {
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+                tree = parseContent(file.content);
             }
-            catch (parseError) {
-                continue;
+            catch {
+                if (file.rawContent && file.rawContent !== file.content) {
+                    try {
+                        tree = parseContent(file.rawContent);
+                        onRawFallbackParse?.(1);
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                else {
+                    continue;
+                }
+            }
+            if (file.rawContent && file.rawContent !== file.content && tree.rootNode?.hasError) {
+                try {
+                    const rawTree = parseContent(file.rawContent);
+                    if (!rawTree.rootNode?.hasError) {
+                        tree = rawTree;
+                        onRawFallbackParse?.(1);
+                    }
+                }
+                catch {
+                    // Keep normalized parse result when raw fallback fails
+                }
             }
             wasReparsed = true;
             // Cache re-parsed tree so call/heritage phases get hits

package/dist/core/ingestion/parsing-processor.d.ts

@@ -11,8 +11,10 @@ export interface WorkerExtractedData {
     routes: ExtractedRoute[];
     constructorBindings: FileConstructorBindings[];
 }
-export { isNodeExported } from './export-detection.js';
-export declare const processParsing: (graph: KnowledgeGraph, files: {
+export interface ParsingFileInput {
     path: string;
     content: string;
-}[], symbolTable: SymbolTable, astCache: ASTCache, onFileProgress?: FileProgressCallback, workerPool?: WorkerPool) => Promise<WorkerExtractedData | null>;
+    rawContent?: string;
+}
+export { isNodeExported } from './export-detection.js';
+export declare const processParsing: (graph: KnowledgeGraph, files: ParsingFileInput[], symbolTable: SymbolTable, astCache: ASTCache, onFileProgress?: FileProgressCallback, workerPool?: WorkerPool, onRawFallbackParse?: (count: number) => void) => Promise<WorkerExtractedData | null>;