@kentwynn/kgraph 0.1.26 → 0.1.27

package/README.md

@@ -100,17 +100,14 @@ kgraph init
 # 2. Optional: connect AI tools so they know the KGraph workflow
 kgraph integrate add codex copilot cursor claude-code gemini windsurf cline
 
-# 3. Optional: configure deep language extractors for non-TS repos
-kgraph extractor add jvm python
-
-# 4. Run the normal workflow for a topic
+# 3. Run the normal workflow for a topic
 kgraph "auth token refresh"
 
-# 5. Check health if something feels off
+# 4. Check health if something feels off
 kgraph doctor
 ```
 
-`kgraph init` now scans once, then prints relevant next steps. When KGraph can detect likely AI tools on the machine, it recommends matching integrations. When the repository contains languages that only have basic built-in extraction today, it recommends optional deep extractors and prints the exact install/configure commands.
+`kgraph init` now scans once, then prints relevant next steps. When KGraph can detect likely AI tools on the machine, it recommends matching integrations.
 
 After useful AI work, assistants save durable runtime-capture notes into `.kgraph/inbox/`. These notes are not project documentation; they are KGraph input files that the next `kgraph` run processes automatically. You can also process them directly with `kgraph update`.
 
@@ -263,18 +260,6 @@ New integrations default to `always` mode because coding agents often under-clas
 | Codex | `AGENTS.md`, `.agents/skills/kgraph/SKILL.md` |
 | GitHub Copilot | `.github/copilot-instructions.md`, `.github/prompts/*` |
 | Cursor | `.cursor/rules/kgraph.mdc` |
-
-## Optional Deep Extractors
-
-KGraph ships with built-in extractors for several languages, but TypeScript and JavaScript still have the deepest built-in analysis today. For languages such as Java, Kotlin, Python, Go, Rust, C/C++, and C#, `kgraph init` can recommend optional deep extractors when those languages are detected in the repository.
-
-```bash
-kgraph extractor list
-kgraph extractor add jvm python
-kgraph extractor remove jvm
-```
-
-`extractor add` writes extractor configuration into `.kgraph/config.yaml` and prints the exact `npm install -D ...` command for the matching optional packages. This is explicit on purpose: KGraph recommends install commands by default rather than silently changing package-manager state.
 | Claude Code | `CLAUDE.md`, `.claude/commands/*` |
 | Gemini CLI | `GEMINI.md` |
 | Windsurf | `.windsurf/rules/kgraph.md` |

package/dist/cli/commands/init.js

@@ -1,14 +1,12 @@
 import { loadConfig, writeDefaultConfig } from '../../config/config.js';
-import { installCommandForExtractors } from '../../extractors/extractor-registry.js';
-import { addExtractors } from '../../extractors/extractor-store.js';
 import { normalizeIntegrationNames } from '../../integrations/integration-registry.js';
 import { addIntegrations } from '../../integrations/integration-store.js';
 import { scanRepository } from '../../scanner/repo-scanner.js';
 import { ensureWorkspace } from '../../storage/kgraph-paths.js';
 import { readMaps, writeMaps } from '../../storage/map-store.js';
 import { KGraphError, runCommand } from '../errors.js';
-import { promptForInitExtractors, promptForInitIntegrations, shouldPromptForInitExtractors, shouldPromptForInitIntegrations, } from '../init-prompt.js';
-import { detectMachineIntegrationRecommendations, recommendedExtractorsForInit, recommendedIntegrationsForInit, } from '../init-recommendations.js';
+import { promptForInitIntegrations, shouldPromptForInitIntegrations, } from '../init-prompt.js';
+import { detectMachineIntegrationRecommendations, recommendedIntegrationsForInit, } from '../init-recommendations.js';
 import { renderInitSummary } from '../init-summary.js';
 export function registerInitCommand(program) {
     program
@@ -48,10 +46,6 @@ export function registerInitCommand(program) {
             configuredIntegrations: config.integrations,
             detectedIntegrations: detectedMachineIntegrations,
         });
-        let recommendedExtractors = recommendedExtractorsForInit({
-            files: result.files,
-            configuredExtractors: config.extractors,
-        });
         if (shouldPromptForInitIntegrations({
             explicitIntegrationsRequested: names.length > 0,
             configuredIntegrations: config.integrations,
@@ -67,28 +61,11 @@ export function registerInitCommand(program) {
                 });
             }
         }
-        if (shouldPromptForInitExtractors({
-            configuredExtractors: config.extractors,
-        })) {
-            const selected = await promptForInitExtractors(recommendedExtractors);
-            if (selected.length > 0) {
-                const changed = await addExtractors(workspace, selected);
-                console.log(`Configured extractors: ${changed.map((item) => item.name).join(', ')}`);
-                console.log(`Install packages: ${installCommandForExtractors(changed.map((item) => item.packageName))}`);
-                config = await loadConfig(workspace);
-                recommendedExtractors = recommendedExtractorsForInit({
-                    files: result.files,
-                    configuredExtractors: config.extractors,
-                });
-            }
-        }
         console.log('');
         console.log(renderInitSummary({
             files: result.files,
             integrations: config.integrations,
             recommendedIntegrations,
-            extractors: config.extractors,
-            recommendedExtractors,
         }));
     }));
 }

package/dist/cli/help.js

@@ -47,11 +47,6 @@ export function renderRootHelp(useColor = supportsColor()) {
         command('integrate remove cursor', 'Remove KGraph-managed instruction blocks'),
         command('--mode smart|always|manual|off', 'Control automatic KGraph involvement per integration'),
         '',
-        theme.bold('Extractors'),
-        command('extractor list', 'Show configured optional deep extractors'),
-        command('extractor add jvm python', 'Configure optional deep extractors and print install commands'),
-        command('extractor remove jvm', 'Remove extractor configuration'),
-        '',
         theme.bold('Options'),
         command('-V, --version', 'Show version'),
         command('-h, --help', 'Show this help'),

package/dist/cli/index.js

@@ -5,7 +5,6 @@ import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
 import { registerContextCommand } from './commands/context.js';
 import { registerDoctorCommand } from './commands/doctor.js';
-import { registerExtractorCommand } from './commands/extractor.js';
 import { registerHistoryCommand } from './commands/history.js';
 import { registerImpactCommand } from './commands/impact.js';
 import { registerInitCommand } from './commands/init.js';
@@ -44,7 +43,6 @@ export function createProgram() {
     registerUpdateCommand(program);
     registerContextCommand(program);
     registerImpactCommand(program);
-    registerExtractorCommand(program);
     registerIntegrateCommand(program);
     registerVisualizeCommand(program);
     registerHistoryCommand(program);

package/dist/cli/init-prompt.d.ts

@@ -1,13 +1,8 @@
-import type { ExtractorConfig, ExtractorName, IntegrationConfig, IntegrationName } from '../types/config.js';
-import type { InitExtractorRecommendation, InitIntegrationRecommendation } from './init-recommendations.js';
+import type { IntegrationConfig, IntegrationName } from '../types/config.js';
+import type { InitIntegrationRecommendation } from './init-recommendations.js';
 export declare function shouldPromptForInitIntegrations(options: {
     explicitIntegrationsRequested: boolean;
     configuredIntegrations: Pick<IntegrationConfig, 'name'>[];
     interactive?: boolean;
 }): boolean;
 export declare function promptForInitIntegrations(recommendations: InitIntegrationRecommendation[]): Promise<IntegrationName[]>;
-export declare function shouldPromptForInitExtractors(options: {
-    configuredExtractors: Pick<ExtractorConfig, 'name'>[];
-    interactive?: boolean;
-}): boolean;
-export declare function promptForInitExtractors(recommendations: InitExtractorRecommendation[]): Promise<ExtractorName[]>;

package/dist/cli/init-prompt.js

@@ -1,5 +1,4 @@
 import * as clack from '@clack/prompts';
-import { listExtractorAdapters } from '../extractors/extractor-registry.js';
 import { listIntegrationAdapters } from '../integrations/integration-registry.js';
 // --- Integration prompt ---
 export function shouldPromptForInitIntegrations(options) {
@@ -57,68 +56,6 @@ export async function promptForInitIntegrations(recommendations) {
     }
     return selected;
 }
-// --- Extractor prompt ---
-export function shouldPromptForInitExtractors(options) {
-    const interactive = options.interactive ?? isInteractiveTerminal();
-    return interactive && options.configuredExtractors.length === 0;
-}
-export async function promptForInitExtractors(recommendations) {
-    const recNames = recommendations.map((item) => item.name);
-    const hasRecommendations = recommendations.length > 0;
-    const action = await clack.select({
-        message: 'Optional deep language extractors',
-        options: [
-            ...(hasRecommendations
-                ? [
-                    {
-                        value: 'recommended',
-                        label: `Use recommended (${recNames.join(', ')})`,
-                        hint: recommendations
-                            .map((item) => `${item.name} for ${item.languages.join(', ')}`)
-                            .join('; '),
-                    },
-                ]
-                : []),
-            {
-                value: 'custom',
-                label: 'Custom selection',
-                hint: hasRecommendations
-                    ? undefined
-                    : 'no language-specific extractors detected; pick manually',
-            },
-            { value: 'skip', label: 'Skip' },
-        ],
-    });
-    if (clack.isCancel(action) || action === 'skip') {
-        return [];
-    }
-    if (action === 'recommended') {
-        return recNames;
-    }
-    const recommendedNames = new Set(recNames);
-    const otherAdapters = listExtractorAdapters().filter((adapter) => !recommendedNames.has(adapter.name));
-    const allOptions = [
-        ...recommendations.map((rec) => ({
-            value: rec.name,
-            label: rec.name,
-            hint: `${rec.languages.join(', ')} — ${rec.packageName} (recommended)`,
-        })),
-        ...otherAdapters.map((adapter) => ({
-            value: adapter.name,
-            label: adapter.name,
-            hint: `${adapter.languages.join(', ')} — ${adapter.packageName}`,
-        })),
-    ];
-    const selected = await clack.multiselect({
-        message: 'Select extractors (space to toggle, enter to confirm)',
-        options: allOptions,
-        required: false,
-    });
-    if (clack.isCancel(selected)) {
-        return [];
-    }
-    return selected;
-}
 function isInteractiveTerminal() {
     return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
 }

package/dist/cli/init-recommendations.d.ts

@@ -1,14 +1,8 @@
-import type { ExtractorConfig, ExtractorName, IntegrationConfig, IntegrationName } from '../types/config.js';
-import type { RepositoryFile } from '../types/maps.js';
+import type { IntegrationConfig, IntegrationName } from '../types/config.js';
 export interface InitIntegrationRecommendation {
     name: IntegrationName;
     reason: string;
 }
-export interface InitExtractorRecommendation {
-    name: ExtractorName;
-    packageName: string;
-    languages: string[];
-}
 interface MachineDetectionContext {
     env?: NodeJS.ProcessEnv;
     homeDir?: string;
@@ -22,10 +16,5 @@ export declare function recommendedIntegrationsForInit(options: {
     configuredIntegrations: Pick<IntegrationConfig, 'name'>[];
     detectedIntegrations: InitIntegrationRecommendation[];
 }): InitIntegrationRecommendation[];
-export declare function recommendedExtractorsForInit(options: {
-    files: RepositoryFile[];
-    configuredExtractors: Pick<ExtractorConfig, 'name'>[];
-}): InitExtractorRecommendation[];
 export declare function integrationSetupCommand(recommendations: InitIntegrationRecommendation[]): string | undefined;
-export declare function extractorSetupCommands(recommendations: InitExtractorRecommendation[]): string[];
 export {};

package/dist/cli/init-recommendations.js

@@ -1,7 +1,6 @@
 import { readdir } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { installCommandForExtractors, listExtractorAdapters, } from '../extractors/extractor-registry.js';
 import { pathExists } from '../storage/kgraph-paths.js';
 export async function detectMachineIntegrationRecommendations(context = {}) {
     const env = context.env ?? process.env;
@@ -40,34 +39,12 @@ export function recommendedIntegrationsForInit(options) {
     const configured = new Set(options.configuredIntegrations.map((item) => item.name));
     return options.detectedIntegrations.filter((item) => !configured.has(item.name));
 }
-export function recommendedExtractorsForInit(options) {
-    const configured = new Set(options.configuredExtractors.map((item) => item.name));
-    const detectedLanguages = new Set(options.files.map((file) => file.language));
-    return listExtractorAdapters()
-        .filter((adapter) => !configured.has(adapter.name))
-        .map((adapter) => ({
-        name: adapter.name,
-        packageName: adapter.packageName,
-        languages: adapter.languages.filter((language) => detectedLanguages.has(language)),
-    }))
-        .filter((adapter) => adapter.languages.length > 0)
-        .sort((left, right) => left.name.localeCompare(right.name));
-}
 export function integrationSetupCommand(recommendations) {
     if (recommendations.length === 0) {
         return undefined;
     }
     return `kgraph integrate add ${recommendations.map((item) => item.name).join(' ')}`;
 }
-export function extractorSetupCommands(recommendations) {
-    if (recommendations.length === 0) {
-        return [];
-    }
-    return [
-        `kgraph extractor add ${recommendations.map((item) => item.name).join(' ')}`,
-        installCommandForExtractors(recommendations.map((item) => item.packageName)),
-    ];
-}
 async function hasVsCodeExtension(prefixes, context) {
     const exists = context.exists ?? pathExists;
     const readDir = context.readDir ?? defaultReadDir;

package/dist/cli/init-summary.d.ts

@@ -1,6 +1,6 @@
-import type { ExtractorConfig, IntegrationConfig } from '../types/config.js';
+import type { IntegrationConfig } from '../types/config.js';
 import type { RepositoryFile } from '../types/maps.js';
-import { type InitExtractorRecommendation, type InitIntegrationRecommendation } from './init-recommendations.js';
+import { type InitIntegrationRecommendation } from './init-recommendations.js';
 type CoverageLevel = 'deep' | 'basic' | 'generic';
 export interface InitLanguageSummary {
     language: string;
@@ -13,7 +13,5 @@ export declare function renderInitSummary(options: {
     files: RepositoryFile[];
     integrations: Pick<IntegrationConfig, 'name' | 'enabled' | 'mode'>[];
     recommendedIntegrations: InitIntegrationRecommendation[];
-    extractors: Pick<ExtractorConfig, 'name' | 'enabled' | 'packageName'>[];
-    recommendedExtractors: InitExtractorRecommendation[];
 }): string;
 export {};

package/dist/cli/init-summary.js

@@ -1,17 +1,17 @@
-import { extractorSetupCommands, integrationSetupCommand, } from './init-recommendations.js';
+import { integrationSetupCommand, } from './init-recommendations.js';
 const LANGUAGE_PRESENTATION = {
     javascript: { label: 'JavaScript', coverage: 'deep' },
     javascriptreact: { label: 'JavaScript', coverage: 'deep' },
     typescript: { label: 'TypeScript', coverage: 'deep' },
     typescriptreact: { label: 'TypeScript', coverage: 'deep' },
-    python: { label: 'Python', coverage: 'basic' },
-    go: { label: 'Go', coverage: 'basic' },
-    rust: { label: 'Rust', coverage: 'basic' },
-    java: { label: 'Java', coverage: 'basic' },
-    kotlin: { label: 'Kotlin', coverage: 'basic' },
-    c: { label: 'C', coverage: 'basic' },
-    cpp: { label: 'C++', coverage: 'basic' },
-    csharp: { label: 'C#', coverage: 'basic' },
+    python: { label: 'Python', coverage: 'deep' },
+    go: { label: 'Go', coverage: 'deep' },
+    rust: { label: 'Rust', coverage: 'deep' },
+    java: { label: 'Java', coverage: 'deep' },
+    kotlin: { label: 'Kotlin', coverage: 'deep' },
+    c: { label: 'C', coverage: 'deep' },
+    cpp: { label: 'C++', coverage: 'deep' },
+    csharp: { label: 'C#', coverage: 'deep' },
     yaml: { label: 'YAML', coverage: 'generic' },
     json: { label: 'JSON', coverage: 'generic' },
     toml: { label: 'TOML', coverage: 'generic' },
@@ -50,12 +50,6 @@ export function summarizeInitLanguages(files) {
 }
 export function renderInitSummary(options) {
     const languages = summarizeInitLanguages(options.files);
-    const recommendedExtractorByLanguage = new Map();
-    for (const extractor of options.recommendedExtractors) {
-        for (const language of extractor.languages) {
-            recommendedExtractorByLanguage.set(language, extractor.name);
-        }
-    }
     const lines = ['KGraph Init Summary', ''];
     lines.push('AI integrations');
     if (options.recommendedIntegrations.length > 0) {
@@ -76,23 +70,7 @@ export function renderInitSummary(options) {
     }
     else {
         for (const language of languages) {
-            const recommendedExtractor = recommendedExtractorByLanguage.get(language.language);
-            lines.push(`  ${language.label}: ${formatFileCount(language.fileCount)}, ${coverageDescription(language.coverage)}${recommendedExtractor ? `; recommended extractor: ${recommendedExtractor}` : ''}`);
-        }
-    }
-    lines.push('');
-    lines.push('Optional extractors');
-    if (options.extractors.length === 0) {
-        lines.push('  configured: none');
-    }
-    else {
-        for (const extractor of options.extractors) {
-            lines.push(`  configured: ${extractor.name}: ${extractor.enabled ? extractor.packageName : 'off'}`);
-        }
-    }
-    if (options.recommendedExtractors.length > 0) {
-        for (const extractor of options.recommendedExtractors) {
-            lines.push(`  recommended: ${extractor.name} for ${extractor.languages.map(humanizeLanguage).join(', ')} (${extractor.packageName})`);
+            lines.push(`  ${language.label}: ${formatFileCount(language.fileCount)}, ${coverageDescription(language.coverage)}`);
         }
     }
     lines.push('');
@@ -105,9 +83,6 @@ export function renderInitSummary(options) {
     else if (options.integrations.length === 0) {
         lines.push('  kgraph integrate add <agent>  Optional: connect an AI tool');
     }
-    for (const command of extractorSetupCommands(options.recommendedExtractors)) {
-        lines.push(`  ${command}`);
-    }
     lines.push('  kgraph doctor  Check workspace health');
     return lines.join('\n');
 }

package/dist/config/config.js

@@ -71,7 +71,6 @@ export const DEFAULT_CONFIG = {
     maxContextItems: 8,
     domainHints: {},
     integrations: [],
-    extractors: [],
 };
 export async function writeDefaultConfig(workspace) {
     if (await pathExists(workspace.configPath)) {
@@ -115,7 +114,6 @@ export function normalizeConfig(config) {
             ? config.domainHints
             : {},
         integrations: normalizeIntegrations(config.integrations),
-        extractors: normalizeExtractors(config.extractors),
     };
 }
 function mergeUnique(base, extra) {
@@ -163,34 +161,3 @@ function normalizeIntegrationMode(value) {
         ? value
         : 'smart';
 }
-function normalizeExtractors(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    const seen = new Set();
-    const extractors = [];
-    for (const item of value) {
-        if (!item || typeof item !== 'object') {
-            continue;
-        }
-        const candidate = item;
-        if (typeof candidate.name !== 'string' ||
-            typeof candidate.packageName !== 'string' ||
-            seen.has(candidate.name)) {
-            continue;
-        }
-        if (!isExtractorName(candidate.name)) {
-            continue;
-        }
-        seen.add(candidate.name);
-        extractors.push({
-            name: candidate.name,
-            enabled: candidate.enabled !== false,
-            packageName: candidate.packageName,
-        });
-    }
-    return extractors;
-}
-function isExtractorName(value) {
-    return ['c-family', 'csharp', 'go', 'jvm', 'python', 'rust'].includes(value);
-}

package/dist/scanner/c-symbol-extractor.d.ts

@@ -1,2 +1,2 @@
 import type { SymbolExtractionResult } from './ts-symbol-extractor.js';
-export declare function extractCSymbols(sourceText: string, filePath: string): SymbolExtractionResult;
+export declare function extractCSymbols(sourceText: string, filePath: string): Promise<SymbolExtractionResult>;

package/dist/scanner/c-symbol-extractor.js

@@ -1,14 +1,19 @@
+import { parseSource } from './tree-sitter-parser.js';
+const CPP_EXTS = new Set(['.cpp', '.cc', '.cxx', '.hpp', '.hxx']);
 // Handles C (.c, .h) and C++ (.cpp, .cc, .cxx, .hpp, .hxx)
-export function extractCSymbols(sourceText, filePath) {
-    const lines = sourceText.split('\n');
+export async function extractCSymbols(sourceText, filePath) {
     const symbols = [];
     const dependencies = [];
     const relationships = [];
     const warnings = [];
-    const typeStack = [];
-    let braceDepth = 0;
-    const addSymbol = (name, kind, lineNum, parentName) => {
-        const id = [filePath, kind, parentName, name, lineNum]
+    if (!sourceText.trim()) {
+        return { symbols, dependencies, relationships, warnings };
+    }
+    const ext = filePath.substring(filePath.lastIndexOf('.'));
+    const grammar = CPP_EXTS.has(ext) ? 'cpp' : 'c';
+    const tree = await parseSource(sourceText, grammar);
+    const addSymbol = (name, kind, startLine, endLine, parentName) => {
+        const id = [filePath, kind, parentName, name, startLine]
             .filter(Boolean)
             .join('#');
         symbols.push({
@@ -16,8 +21,8 @@ export function extractCSymbols(sourceText, filePath) {
             name,
             kind,
             filePath,
-            startLine: lineNum,
-            endLine: lineNum,
+            startLine,
+            endLine,
             exported: false,
             parentName,
         });
@@ -30,67 +35,105 @@ export function extractCSymbols(sourceText, filePath) {
             confidence: 'high',
         });
     };
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const lineNum = i + 1;
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('*'))
-            continue;
-        braceDepth +=
-            (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length;
-        while (typeStack.length > 0 &&
-            braceDepth < typeStack[typeStack.length - 1].braceDepth) {
-            typeStack.pop();
-        }
-        // #include <...> or #include "..."
-        const includeMatch = trimmed.match(/^#include\s+[<"]([^>"]+)[>"]/);
-        if (includeMatch) {
-            const specifier = includeMatch[1];
-            const kind = trimmed.includes('"') ? 'local' : 'package';
-            dependencies.push({ fromFile: filePath, specifier, kind });
-            relationships.push({
-                sourceType: 'file',
-                sourceId: filePath,
-                targetType: kind === 'local' ? 'file' : 'package',
-                targetId: specifier,
-                relationshipType: 'import',
-                confidence: 'high',
-            });
-            continue;
+    function getFuncName(node) {
+        // function_definition has a function_declarator child which contains the identifier
+        const declarator = node.childForFieldName('declarator');
+        if (!declarator)
+            return null;
+        if (declarator.type === 'function_declarator') {
+            const nameNode = declarator.childForFieldName('declarator');
+            return nameNode?.text ?? null;
         }
-        // class / struct (C++ with body — has name before {)
-        const classMatch = trimmed.match(/\b(?:class|struct)\s+(\w+)\s*(?::[^{]*)?\s*\{/);
-        if (classMatch) {
-            addSymbol(classMatch[1], 'class', lineNum, typeStack[typeStack.length - 1]?.name);
-            typeStack.push({ name: classMatch[1], braceDepth });
-            continue;
+        // For pointer_declarator wrapping function_declarator
+        const funcDecl = declarator.descendantsOfType('function_declarator')[0];
+        if (funcDecl) {
+            const nameNode = funcDecl.childForFieldName('declarator');
+            return nameNode?.text ?? null;
         }
-        // Function definition: returnType funcName( — must have ( and no ; on same line
-        // Exclude preprocessor, declarations without body
-        if (!trimmed.endsWith(';') && !trimmed.startsWith('#')) {
-            const funcMatch = trimmed.match(/\b(\w+)\s*\((?:[^)]*)?\)\s*(?:const\s*)?(?:noexcept\s*)?(?:override\s*)?(?:final\s*)?\{?$/);
-            // Filter out common false positives: if/for/while/switch/catch/else
-            const CONTROL_FLOW = new Set([
-                'if',
-                'for',
-                'while',
-                'switch',
-                'catch',
-                'else',
-                'return',
-                'sizeof',
-                'typeof',
-            ]);
-            if (funcMatch &&
-                !CONTROL_FLOW.has(funcMatch[1]) &&
-                funcMatch[1] !== 'class' &&
-                funcMatch[1] !== 'struct') {
-                const parent = typeStack[typeStack.length - 1];
-                const kind = parent ? 'method' : 'function';
-                addSymbol(funcMatch[1], kind, lineNum, parent?.name);
-                continue;
+        return null;
+    }
+    function walk(node, parentClassName) {
+        switch (node.type) {
+            case 'preproc_include': {
+                // #include <...> or #include "..."
+                const pathNode = node.namedChildren.find((c) => c.type === 'system_lib_string') ??
+                    node.namedChildren.find((c) => c.type === 'string_literal');
+                if (pathNode) {
+                    let specifier;
+                    let kind;
+                    if (pathNode.type === 'system_lib_string') {
+                        // <iostream> — strip angle brackets
+                        specifier = pathNode.text.replace(/^<|>$/g, '');
+                        kind = 'package';
+                    }
+                    else {
+                        // "myheader.h" — extract string content
+                        const content = pathNode.namedChildren.find((c) => c.type === 'string_content');
+                        specifier = content?.text ?? pathNode.text.replace(/^"|"$/g, '');
+                        kind = 'local';
+                    }
+                    dependencies.push({ fromFile: filePath, specifier, kind });
+                    relationships.push({
+                        sourceType: 'file',
+                        sourceId: filePath,
+                        targetType: kind === 'local' ? 'file' : 'package',
+                        targetId: specifier,
+                        relationshipType: 'import',
+                        confidence: 'high',
+                    });
+                }
+                return;
+            }
+            case 'class_specifier':
+            case 'struct_specifier': {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    addSymbol(nameNode.text, 'class', node.startPosition.row + 1, node.endPosition.row + 1, parentClassName);
+                    // Walk body for methods
+                    const body = node.childForFieldName('body');
+                    if (body) {
+                        for (const child of body.namedChildren) {
+                            walk(child, nameNode.text);
+                        }
+                    }
+                }
+                return;
             }
+            case 'function_definition': {
+                const name = getFuncName(node);
+                if (name) {
+                    const kind = parentClassName
+                        ? 'method'
+                        : 'function';
+                    addSymbol(name, kind, node.startPosition.row + 1, node.endPosition.row + 1, parentClassName);
+                }
+                return;
+            }
+            case 'declaration': {
+                // Could be a function declaration (prototype) inside a class
+                if (parentClassName) {
+                    const declarator = node.childForFieldName('declarator');
+                    if (declarator) {
+                        const funcDecl = declarator.type === 'function_declarator'
+                            ? declarator
+                            : declarator.descendantsOfType('function_declarator')[0];
+                        if (funcDecl) {
+                            const nameNode = funcDecl.childForFieldName('declarator');
+                            if (nameNode) {
+                                addSymbol(nameNode.text, 'method', node.startPosition.row + 1, node.endPosition.row + 1, parentClassName);
+                            }
+                            return;
+                        }
+                    }
+                }
+                break;
+            }
+        }
+        for (const child of node.namedChildren) {
+            walk(child, parentClassName);
         }
     }
+    walk(tree.rootNode);
+    tree.delete();
     return { symbols, dependencies, relationships, warnings };
 }

package/dist/scanner/csharp-symbol-extractor.d.ts

@@ -1,2 +1,2 @@
 import type { SymbolExtractionResult } from './ts-symbol-extractor.js';
-export declare function extractCSharpSymbols(sourceText: string, filePath: string): SymbolExtractionResult;
+export declare function extractCSharpSymbols(sourceText: string, filePath: string): Promise<SymbolExtractionResult>;