@kentwynn/kgraph 0.1.25 → 0.1.27

package/README.md

@@ -107,6 +107,8 @@ kgraph "auth token refresh"
 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.
+
 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`.
 
 Normal agent flow is intentionally small:
@@ -138,7 +140,7 @@ This is optional. Claude Code can use generated hook scripts for automatic captu
 kgraph init
 ```
 
-Required once per repo. Creates `.kgraph/` and the local config.
+Required once per repo. Creates `.kgraph/`, writes the local config, runs the first scan, and prints suggested next actions based on the detected repo languages and likely local AI tools.
 
 ```bash
 kgraph init --integrations codex,copilot,cursor,claude-code,gemini,windsurf,cline

package/dist/cli/commands/init.js

@@ -5,6 +5,9 @@ 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 { promptForInitIntegrations, shouldPromptForInitIntegrations, } from '../init-prompt.js';
+import { detectMachineIntegrationRecommendations, recommendedIntegrationsForInit, } from '../init-recommendations.js';
+import { renderInitSummary } from '../init-summary.js';
 export function registerInitCommand(program) {
     program
         .command('init')
@@ -27,7 +30,7 @@ export function registerInitCommand(program) {
             const changed = await addIntegrations(workspace, names, mode);
             console.log(`Configured integrations: ${changed.map((item) => `${item.name}:${item.mode}`).join(', ')}`);
         }
-        const config = await loadConfig(workspace);
+        let config = await loadConfig(workspace);
         const previousMaps = await readMaps(workspace);
         const result = await scanRepository(workspace.rootPath, config, {
             files: previousMaps.fileMap.files,
@@ -38,6 +41,32 @@ export function registerInitCommand(program) {
         });
         await writeMaps(workspace, result);
         console.log(`Scanned ${result.files.length} files and ${result.symbols.length} symbols.`);
+        const detectedMachineIntegrations = await detectMachineIntegrationRecommendations();
+        let recommendedIntegrations = recommendedIntegrationsForInit({
+            configuredIntegrations: config.integrations,
+            detectedIntegrations: detectedMachineIntegrations,
+        });
+        if (shouldPromptForInitIntegrations({
+            explicitIntegrationsRequested: names.length > 0,
+            configuredIntegrations: config.integrations,
+        })) {
+            const selected = await promptForInitIntegrations(recommendedIntegrations);
+            if (selected.length > 0) {
+                const changed = await addIntegrations(workspace, selected, 'always');
+                console.log(`Configured integrations: ${changed.map((item) => `${item.name}:${item.mode}`).join(', ')}`);
+                config = await loadConfig(workspace);
+                recommendedIntegrations = recommendedIntegrationsForInit({
+                    configuredIntegrations: config.integrations,
+                    detectedIntegrations: detectedMachineIntegrations,
+                });
+            }
+        }
+        console.log('');
+        console.log(renderInitSummary({
+            files: result.files,
+            integrations: config.integrations,
+            recommendedIntegrations,
+        }));
     }));
 }
 function collectOption(value, previous) {

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

@@ -0,0 +1,8 @@
+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[]>;

package/dist/cli/init-prompt.js

@@ -0,0 +1,61 @@
+import * as clack from '@clack/prompts';
+import { listIntegrationAdapters } from '../integrations/integration-registry.js';
+// --- Integration prompt ---
+export function shouldPromptForInitIntegrations(options) {
+    const interactive = options.interactive ?? isInteractiveTerminal();
+    return (interactive &&
+        !options.explicitIntegrationsRequested &&
+        options.configuredIntegrations.length === 0);
+}
+export async function promptForInitIntegrations(recommendations) {
+    const recNames = recommendations.map((item) => item.name);
+    const action = await clack.select({
+        message: 'AI tool integrations',
+        options: [
+            ...(recommendations.length > 0
+                ? [
+                    {
+                        value: 'recommended',
+                        label: `Use recommended (${recNames.join(', ')})`,
+                        hint: recommendations
+                            .map((item) => `${item.name} — ${item.reason}`)
+                            .join('; '),
+                    },
+                ]
+                : []),
+            { value: 'custom', label: 'Custom selection' },
+            { value: 'skip', label: 'Skip' },
+        ],
+    });
+    if (clack.isCancel(action) || action === 'skip') {
+        return [];
+    }
+    if (action === 'recommended') {
+        return recNames;
+    }
+    const recommendedNames = new Set(recNames);
+    const otherAdapters = listIntegrationAdapters().filter((adapter) => !recommendedNames.has(adapter.name));
+    const allOptions = [
+        ...recommendations.map((rec) => ({
+            value: rec.name,
+            label: rec.name,
+            hint: rec.reason,
+        })),
+        ...otherAdapters.map((adapter) => ({
+            value: adapter.name,
+            label: adapter.name,
+        })),
+    ];
+    const selected = await clack.multiselect({
+        message: 'Select integrations (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

@@ -0,0 +1,20 @@
+import type { IntegrationConfig, IntegrationName } from '../types/config.js';
+export interface InitIntegrationRecommendation {
+    name: IntegrationName;
+    reason: string;
+}
+interface MachineDetectionContext {
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    platform?: NodeJS.Platform;
+    exists?: (targetPath: string) => Promise<boolean>;
+    readDir?: (targetPath: string) => Promise<string[]>;
+    localAppData?: string;
+}
+export declare function detectMachineIntegrationRecommendations(context?: MachineDetectionContext): Promise<InitIntegrationRecommendation[]>;
+export declare function recommendedIntegrationsForInit(options: {
+    configuredIntegrations: Pick<IntegrationConfig, 'name'>[];
+    detectedIntegrations: InitIntegrationRecommendation[];
+}): InitIntegrationRecommendation[];
+export declare function integrationSetupCommand(recommendations: InitIntegrationRecommendation[]): string | undefined;
+export {};

package/dist/cli/init-recommendations.js

@@ -0,0 +1,140 @@
+import { readdir } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { pathExists } from '../storage/kgraph-paths.js';
+export async function detectMachineIntegrationRecommendations(context = {}) {
+    const env = context.env ?? process.env;
+    if (env.KGRAPH_DISABLE_MACHINE_DETECTION === '1') {
+        return [];
+    }
+    const recommendations = [];
+    if ((await hasVsCodeExtension(['github.copilot-', 'github.copilot-chat-'], context)) ||
+        (await hasVsCodeBundledCopilot(context))) {
+        recommendations.push({
+            name: 'copilot',
+            reason: 'VS Code Copilot detected',
+        });
+    }
+    if (await hasExecutable('codex', context)) {
+        recommendations.push({
+            name: 'codex',
+            reason: 'codex executable detected on PATH',
+        });
+    }
+    if (await hasExecutable('claude', context)) {
+        recommendations.push({
+            name: 'claude-code',
+            reason: 'claude executable detected on PATH',
+        });
+    }
+    if (await hasExecutable('gemini', context)) {
+        recommendations.push({
+            name: 'gemini',
+            reason: 'gemini executable detected on PATH',
+        });
+    }
+    return recommendations.sort((left, right) => left.name.localeCompare(right.name));
+}
+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 integrationSetupCommand(recommendations) {
+    if (recommendations.length === 0) {
+        return undefined;
+    }
+    return `kgraph integrate add ${recommendations.map((item) => item.name).join(' ')}`;
+}
+async function hasVsCodeExtension(prefixes, context) {
+    const exists = context.exists ?? pathExists;
+    const readDir = context.readDir ?? defaultReadDir;
+    const homeDir = context.homeDir ?? os.homedir();
+    const candidates = [
+        path.join(homeDir, '.vscode', 'extensions'),
+        path.join(homeDir, '.vscode-insiders', 'extensions'),
+    ];
+    for (const candidate of candidates) {
+        if (!(await exists(candidate))) {
+            continue;
+        }
+        const entries = await readDir(candidate);
+        if (entries.some((entry) => prefixes.some((prefix) => entry.toLowerCase().startsWith(prefix)))) {
+            return true;
+        }
+    }
+    return false;
+}
+async function hasVsCodeBundledCopilot(context) {
+    const exists = context.exists ?? pathExists;
+    const readDir = context.readDir ?? defaultReadDir;
+    const platform = context.platform ?? process.platform;
+    const env = context.env ?? process.env;
+    const dirs = await resolveVsCodeBundledExtensionDirs(platform, env, context.localAppData, exists, readDir);
+    for (const dir of dirs) {
+        if (await exists(path.join(dir, 'copilot'))) {
+            return true;
+        }
+    }
+    return false;
+}
+async function resolveVsCodeBundledExtensionDirs(platform, env, overrideLocalAppData, exists, readDir) {
+    const dirs = [];
+    if (platform === 'win32') {
+        const localAppData = overrideLocalAppData ?? env.LOCALAPPDATA ?? '';
+        if (localAppData) {
+            const vsCodeRoot = path.join(localAppData, 'Programs', 'Microsoft VS Code');
+            if (await exists(vsCodeRoot)) {
+                const entries = await readDir(vsCodeRoot);
+                for (const entry of entries) {
+                    dirs.push(path.join(vsCodeRoot, entry, 'resources', 'app', 'extensions'));
+                }
+            }
+        }
+    }
+    else if (platform === 'darwin') {
+        dirs.push('/Applications/Visual Studio Code.app/Contents/Resources/app/extensions');
+        dirs.push('/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/extensions');
+    }
+    else {
+        dirs.push('/usr/share/code/resources/app/extensions');
+        dirs.push('/usr/lib/code/resources/app/extensions');
+    }
+    return dirs;
+}
+async function hasExecutable(commandName, context) {
+    const env = context.env ?? process.env;
+    const exists = context.exists ?? pathExists;
+    const platform = context.platform ?? process.platform;
+    const pathValue = env.PATH ?? '';
+    const directories = pathValue
+        .split(path.delimiter)
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (directories.length === 0) {
+        return false;
+    }
+    const candidates = platform === 'win32'
+        ? buildWindowsExecutableCandidates(commandName, env.PATHEXT)
+        : [commandName];
+    for (const directory of directories) {
+        for (const candidate of candidates) {
+            if (await exists(path.join(directory, candidate))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function buildWindowsExecutableCandidates(commandName, pathExt) {
+    const extensions = (pathExt ?? '.EXE;.CMD;.BAT;.COM')
+        .split(';')
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return [
+        commandName,
+        ...extensions.map((extension) => `${commandName}${extension}`),
+    ];
+}
+async function defaultReadDir(targetPath) {
+    return readdir(targetPath);
+}

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

@@ -0,0 +1,17 @@
+import type { IntegrationConfig } from '../types/config.js';
+import type { RepositoryFile } from '../types/maps.js';
+import { type InitIntegrationRecommendation } from './init-recommendations.js';
+type CoverageLevel = 'deep' | 'basic' | 'generic';
+export interface InitLanguageSummary {
+    language: string;
+    label: string;
+    fileCount: number;
+    coverage: CoverageLevel;
+}
+export declare function summarizeInitLanguages(files: RepositoryFile[]): InitLanguageSummary[];
+export declare function renderInitSummary(options: {
+    files: RepositoryFile[];
+    integrations: Pick<IntegrationConfig, 'name' | 'enabled' | 'mode'>[];
+    recommendedIntegrations: InitIntegrationRecommendation[];
+}): string;
+export {};

package/dist/cli/init-summary.js

@@ -0,0 +1,122 @@
+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: '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' },
+    xml: { label: 'XML', coverage: 'generic' },
+    graphql: { label: 'GraphQL', coverage: 'generic' },
+    sql: { label: 'SQL', coverage: 'generic' },
+    shell: { label: 'Shell', coverage: 'generic' },
+};
+const EXCLUDED_LANGUAGES = new Set(['unknown', 'markdown', 'restructuredtext']);
+export function summarizeInitLanguages(files) {
+    const byLabel = new Map();
+    for (const file of files) {
+        if (EXCLUDED_LANGUAGES.has(file.language)) {
+            continue;
+        }
+        const descriptor = describeLanguage(file.language);
+        const existing = byLabel.get(descriptor.label);
+        if (existing) {
+            existing.fileCount += 1;
+            existing.coverage = moreDetailedCoverage(existing.coverage, descriptor.coverage);
+            continue;
+        }
+        byLabel.set(descriptor.label, {
+            language: file.language,
+            label: descriptor.label,
+            fileCount: 1,
+            coverage: descriptor.coverage,
+        });
+    }
+    return [...byLabel.values()].sort((left, right) => {
+        if (right.fileCount !== left.fileCount) {
+            return right.fileCount - left.fileCount;
+        }
+        return left.label.localeCompare(right.label);
+    });
+}
+export function renderInitSummary(options) {
+    const languages = summarizeInitLanguages(options.files);
+    const lines = ['KGraph Init Summary', ''];
+    lines.push('AI integrations');
+    if (options.recommendedIntegrations.length > 0) {
+        lines.push(`  recommended: ${options.recommendedIntegrations.map((item) => `${item.name} (${item.reason})`).join('; ')}`);
+    }
+    if (options.integrations.length === 0) {
+        lines.push('  configured: none');
+    }
+    else {
+        for (const integration of options.integrations) {
+            lines.push(`  configured: ${integration.name}: ${integration.enabled ? integration.mode : 'off'}`);
+        }
+    }
+    lines.push('');
+    lines.push('Repo languages');
+    if (languages.length === 0) {
+        lines.push('  none detected yet');
+    }
+    else {
+        for (const language of languages) {
+            lines.push(`  ${language.label}: ${formatFileCount(language.fileCount)}, ${coverageDescription(language.coverage)}`);
+        }
+    }
+    lines.push('');
+    lines.push('Next');
+    lines.push('  kgraph "topic"  Run the normal refresh and context workflow');
+    const integrationCommand = integrationSetupCommand(options.recommendedIntegrations);
+    if (integrationCommand) {
+        lines.push(`  ${integrationCommand}  Optional: connect detected AI tools`);
+    }
+    else if (options.integrations.length === 0) {
+        lines.push('  kgraph integrate add <agent>  Optional: connect an AI tool');
+    }
+    lines.push('  kgraph doctor  Check workspace health');
+    return lines.join('\n');
+}
+function describeLanguage(language) {
+    return (LANGUAGE_PRESENTATION[language] ?? {
+        label: humanizeLanguage(language),
+        coverage: 'generic',
+    });
+}
+function humanizeLanguage(language) {
+    return language
+        .split(/[-_\s]+/)
+        .filter(Boolean)
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join(' ');
+}
+function moreDetailedCoverage(left, right) {
+    const rank = {
+        deep: 3,
+        basic: 2,
+        generic: 1,
+    };
+    return rank[left] >= rank[right] ? left : right;
+}
+function coverageDescription(coverage) {
+    switch (coverage) {
+        case 'deep':
+            return 'deep built-in extraction';
+        case 'basic':
+            return 'basic built-in extraction';
+        default:
+            return 'generic file coverage';
+    }
+}
+function formatFileCount(fileCount) {
+    return fileCount === 1 ? '1 file' : `${fileCount} files`;
+}

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>;