@kentwynn/kgraph 0.1.26 → 0.2.0

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/context.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "commander";
-import type { ContextResponse } from "../../types/cognition.js";
+import type { Command } from 'commander';
+import type { ContextResponse } from '../../types/cognition.js';
 export declare function registerContextCommand(program: Command): void;
 export declare function renderContextMarkdown(response: ContextResponse): string;

package/dist/cli/commands/context.js

@@ -1,43 +1,102 @@
-import { loadConfig } from "../../config/config.js";
-import { queryContext } from "../../context/context-query.js";
-import { assertWorkspace } from "../../storage/kgraph-paths.js";
-import { mapsExist, readMaps } from "../../storage/map-store.js";
-import { KGraphError, runCommand } from "../errors.js";
+import { loadConfig } from '../../config/config.js';
+import { queryContext } from '../../context/context-query.js';
+import { assertWorkspace } from '../../storage/kgraph-paths.js';
+import { mapsExist, readMaps } from '../../storage/map-store.js';
+import { KGraphError, runCommand } from '../errors.js';
 export function registerContextCommand(program) {
     program
-        .command("context <query>")
-        .description("Return compact repo context for a query")
-        .option("--json", "Print JSON output")
+        .command('context <query>')
+        .description('Return compact repo context for a query')
+        .option('--json', 'Print JSON output')
         .action((query, options) => runCommand(async () => {
         if (!query.trim()) {
-            throw new KGraphError("Query cannot be empty.");
+            throw new KGraphError('Query cannot be empty.');
         }
         const workspace = await assertWorkspace(process.cwd());
         if (!(await mapsExist(workspace))) {
-            throw new KGraphError("KGraph maps are missing. Run `kgraph scan` first.");
+            throw new KGraphError('KGraph maps are missing. Run `kgraph scan` first.');
         }
         const config = await loadConfig(workspace);
         const maps = await readMaps(workspace);
         const response = await queryContext(workspace, config, maps, query);
-        console.log(options.json ? JSON.stringify(response, null, 2) : renderContextMarkdown(response));
+        console.log(options.json
+            ? JSON.stringify(response, null, 2)
+            : renderContextMarkdown(response));
     }));
 }
 export function renderContextMarkdown(response) {
     const lines = [`# KGraph Context`, ``, `Query: ${response.query}`, ``];
-    lines.push("## Matched Domains", "");
-    lines.push(...formatList(response.matchedDomains.map((item) => `- ${item.item.name} (${item.reasons.join(", ")})`)));
-    lines.push("", "## Relevant Files", "");
-    lines.push(...formatList(response.relevantFiles.map((item) => `- ${item.item.path} (${item.reasons.join(", ")})`)));
-    lines.push("", "## Relevant Symbols", "");
-    lines.push(...formatList(response.relevantSymbols.map((item) => `- ${item.item.name} in ${item.item.filePath}`)));
-    lines.push("", "## Relevant Cognition", "");
+    lines.push('## Matched Domains', '');
+    lines.push(...formatList(response.matchedDomains.map((item) => `- ${item.item.name} (${item.reasons.join(', ')})`)));
+    lines.push('', '## Relevant Files', '');
+    lines.push(...formatList(response.relevantFiles.map((item) => {
+        const f = item.item;
+        const meta = [
+            f.language,
+            f.tokenEstimate ? `~${f.tokenEstimate} tokens` : '',
+        ]
+            .filter(Boolean)
+            .join(', ');
+        return `- ${f.path}${meta ? ` [${meta}]` : ''}`;
+    })));
+    lines.push('', '## Relevant Symbols', '');
+    lines.push(...formatList(response.relevantSymbols.map((item) => {
+        const s = item.item;
+        const kindInfo = [s.kind, s.parentName].filter(Boolean).join(', ');
+        const lineRange = s.startLine != null && s.endLine != null
+            ? `:${s.startLine}-${s.endLine}`
+            : '';
+        return `- ${s.name} (${kindInfo}) in ${s.filePath}${lineRange}`;
+    })));
+    lines.push('', '## Relevant Cognition', '');
     lines.push(...formatList(response.relevantCognition.map((item) => `- ${item.item.title} [${item.item.referencesStatus}]`)));
-    lines.push("", "## Relationships", "");
-    lines.push(...formatList(response.relationships.map((relationship) => `- ${relationship.sourceId} ${relationship.relationshipType} ${relationship.targetId} (${relationship.confidence})`)));
-    lines.push("", "## Stale References", "");
+    lines.push('', '## Relationships', '');
+    lines.push(...formatGroupedRelationships(response.relationships));
+    lines.push('', '## Nearby Symbols (1-hop imports)', '');
+    lines.push(...formatList((response.nearbySymbols ?? []).map((s) => {
+        const kindInfo = [s.kind, s.parentName].filter(Boolean).join(', ');
+        const lineRange = s.startLine != null && s.endLine != null
+            ? `:${s.startLine}-${s.endLine}`
+            : '';
+        return `- ${s.name} (${kindInfo}) in ${s.filePath}${lineRange}`;
+    })));
+    lines.push('', '## Stale References', '');
     lines.push(...formatList(response.staleReferences.map((ref) => `- ${ref}`)));
-    return lines.join("\n");
+    return lines.join('\n');
+}
+function formatGroupedRelationships(relationships) {
+    const imports = relationships.filter((r) => r.relationshipType === 'import');
+    const calls = relationships.filter((r) => r.relationshipType === 'calls');
+    const contains = relationships.filter((r) => r.relationshipType === 'symbol-contains');
+    const other = relationships.filter((r) => r.relationshipType !== 'import' &&
+        r.relationshipType !== 'calls' &&
+        r.relationshipType !== 'symbol-contains' &&
+        r.relationshipType !== 'mentions' &&
+        r.relationshipType !== 'belongs-to-domain' &&
+        r.relationshipType !== 'stale-reference');
+    const lines = [];
+    if (imports.length > 0) {
+        lines.push('Imports:');
+        for (const r of imports)
+            lines.push(`  ${r.sourceId} → ${r.targetId}`);
+    }
+    if (calls.length > 0) {
+        lines.push('Calls:');
+        for (const r of calls)
+            lines.push(`  ${r.sourceId} → ${r.targetId}`);
+    }
+    if (contains.length > 0) {
+        lines.push('Contains:');
+        for (const r of contains)
+            lines.push(`  ${r.sourceId} contains ${r.targetId}`);
+    }
+    if (other.length > 0) {
+        lines.push('Other:');
+        for (const r of other)
+            lines.push(`  ${r.sourceId} ${r.relationshipType} ${r.targetId}`);
+    }
+    return lines.length > 0 ? lines : ['- None'];
 }
 function formatList(items) {
-    return items.length > 0 ? items : ["- None"];
+    return items.length > 0 ? items : ['- None'];
 }

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/commands/workflow.js

@@ -1,5 +1,4 @@
-import { updateCognition } from '../../cognition/cognition-updater.js';
-import { refreshCognitionReferenceStatuses } from '../../cognition/cognition-updater.js';
+import { refreshCognitionReferenceStatuses, updateCognition, } from '../../cognition/cognition-updater.js';
 import { loadConfig } from '../../config/config.js';
 import { queryContext } from '../../context/context-query.js';
 import { scanRepository } from '../../scanner/repo-scanner.js';
@@ -35,6 +34,7 @@ export async function runDefaultWorkflow(query) {
         console.log(renderWorkflowBanner({
             files: scan.files.length,
             symbols: scan.symbols.length,
+            skippedFiles: scan.skippedFiles,
             cognitionNotes: update.processed.length,
             integrations: config.integrations.map((integration) => ({
                 name: integration.name,

package/dist/cli/help.d.ts

@@ -3,6 +3,7 @@ interface WorkflowBannerStats {
     files: number;
     symbols: number;
     cognitionNotes: number;
+    skippedFiles?: number;
     integrations?: WorkflowBannerIntegration[];
 }
 interface WorkflowBannerIntegration {

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'),
@@ -82,7 +77,10 @@ export function renderWorkflowBanner(stats, useColor = supportsColor()) {
         `  ${theme.bold('KGraph')} ${theme.dim('repo intelligence refreshed')}`,
         '',
         theme.bold('Refresh Complete'),
-        command('files', String(stats.files)),
+        command('files', String(stats.files) +
+            (stats.skippedFiles
+                ? ` (${stats.skippedFiles} unchanged, skipped)`
+                : '')),
         command('symbols', String(stats.symbols)),
         command('cognition notes processed', String(stats.cognitionNotes)),
         command('integration modes', integrationLine),

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/context/context-query.js

@@ -73,6 +73,28 @@ export async function queryContext(workspace, config, maps, query) {
             .filter((s) => !symbolNames.has(s))
             .map((ref) => `${note.title}: ${ref}`),
     ]);
+    // Collect nearby symbols: exported symbols from files 1-hop imported by matched files
+    const matchedFilePaths = new Set([
+        ...relevantFiles.map((f) => f.item.path),
+        ...relevantSymbols.map((s) => s.item.filePath),
+    ]);
+    const matchedSymbolIds = new Set(relevantSymbols.map((s) => s.item.id));
+    const importedFilePaths = new Set();
+    for (const dep of maps.dependencyMap.dependencies) {
+        if (dep.kind === 'local' &&
+            dep.resolvedFile &&
+            matchedFilePaths.has(dep.fromFile)) {
+            importedFilePaths.add(dep.resolvedFile);
+        }
+    }
+    // Remove files already in the matched set
+    for (const p of matchedFilePaths)
+        importedFilePaths.delete(p);
+    const nearbySymbols = maps.symbolMap.symbols
+        .filter((s) => s.exported &&
+        importedFilePaths.has(s.filePath) &&
+        !matchedSymbolIds.has(s.id))
+        .slice(0, max);
     return {
         query,
         matchedDomains,
@@ -80,6 +102,7 @@ export async function queryContext(workspace, config, maps, query) {
         relevantSymbols,
         relevantCognition,
         relationships: relationships.slice(0, max),
+        nearbySymbols,
         staleReferences,
         warnings: [],
     };

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