@kentwynn/kgraph 0.1.25 → 0.1.26

package/README.md

@@ -100,13 +100,18 @@ 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. Run the normal workflow for a topic
+# 3. Optional: configure deep language extractors for non-TS repos
+kgraph extractor add jvm python
+
+# 4. Run the normal workflow for a topic
 kgraph "auth token refresh"
 
-# 4. Check health if something feels off
+# 5. 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.
+
 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 +143,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
@@ -258,6 +263,18 @@ 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/extractor.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerExtractorCommand(program: Command): void;

package/dist/cli/commands/extractor.js

@@ -0,0 +1,50 @@
+import { installCommandForExtractors, normalizeExtractorNames, } from '../../extractors/extractor-registry.js';
+import { addExtractors, listExtractors, removeExtractors, } from '../../extractors/extractor-store.js';
+import { assertWorkspace } from '../../storage/kgraph-paths.js';
+import { KGraphError, runCommand } from '../errors.js';
+export function registerExtractorCommand(program) {
+    const extractor = program
+        .command('extractor')
+        .description('Manage optional deep language extractors');
+    extractor
+        .command('list')
+        .description('List configured optional extractors')
+        .action(() => runCommand(async () => {
+        const workspace = await assertWorkspace(process.cwd());
+        const extractors = await listExtractors(workspace);
+        if (extractors.length === 0) {
+            console.log('No extractors configured.');
+            return;
+        }
+        for (const item of extractors) {
+            console.log(`${item.name} ${item.enabled ? 'enabled' : 'disabled'} ${item.packageName} ${item.packageInstalled ? 'present' : 'missing'}`);
+        }
+    }));
+    extractor
+        .command('add')
+        .description('Configure optional deep extractors')
+        .argument('<names...>')
+        .action((names) => runCommand(async () => {
+        const workspace = await assertWorkspace(process.cwd());
+        const normalized = normalizeExtractorNames(names);
+        if (normalized.length === 0) {
+            throw new KGraphError('Provide at least one extractor name.');
+        }
+        const changed = await addExtractors(workspace, normalized);
+        console.log(`Configured extractors: ${changed.map((item) => item.name).join(', ')}`);
+        console.log(`Install packages: ${installCommandForExtractors(changed.map((item) => item.packageName))}`);
+    }));
+    extractor
+        .command('remove')
+        .description('Remove optional deep extractors')
+        .argument('<names...>')
+        .action((names) => runCommand(async () => {
+        const workspace = await assertWorkspace(process.cwd());
+        const normalized = normalizeExtractorNames(names);
+        if (normalized.length === 0) {
+            throw new KGraphError('Provide at least one extractor name.');
+        }
+        const removed = await removeExtractors(workspace, normalized);
+        console.log(`Removed extractors: ${removed.join(', ')}`);
+    }));
+}

package/dist/cli/commands/init.js

@@ -1,10 +1,15 @@
 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 { renderInitSummary } from '../init-summary.js';
 export function registerInitCommand(program) {
     program
         .command('init')
@@ -27,7 +32,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 +43,53 @@ 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,
+        });
+        let recommendedExtractors = recommendedExtractorsForInit({
+            files: result.files,
+            configuredExtractors: config.extractors,
+        });
+        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,
+                });
+            }
+        }
+        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,
+        }));
     }));
 }
 function collectOption(value, previous) {

package/dist/cli/help.js

@@ -47,6 +47,11 @@ 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,6 +5,7 @@ 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';
@@ -43,6 +44,7 @@ export function createProgram() {
     registerUpdateCommand(program);
     registerContextCommand(program);
     registerImpactCommand(program);
+    registerExtractorCommand(program);
     registerIntegrateCommand(program);
     registerVisualizeCommand(program);
     registerHistoryCommand(program);

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

@@ -0,0 +1,13 @@
+import type { ExtractorConfig, ExtractorName, IntegrationConfig, IntegrationName } from '../types/config.js';
+import type { InitExtractorRecommendation, 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

@@ -0,0 +1,124 @@
+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) {
+    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;
+}
+// --- 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

@@ -0,0 +1,31 @@
+import type { ExtractorConfig, ExtractorName, IntegrationConfig, IntegrationName } from '../types/config.js';
+import type { RepositoryFile } from '../types/maps.js';
+export interface InitIntegrationRecommendation {
+    name: IntegrationName;
+    reason: string;
+}
+export interface InitExtractorRecommendation {
+    name: ExtractorName;
+    packageName: string;
+    languages: 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 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

@@ -0,0 +1,163 @@
+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;
+    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 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;
+    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,19 @@
+import type { ExtractorConfig, IntegrationConfig } from '../types/config.js';
+import type { RepositoryFile } from '../types/maps.js';
+import { type InitExtractorRecommendation, 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[];
+    extractors: Pick<ExtractorConfig, 'name' | 'enabled' | 'packageName'>[];
+    recommendedExtractors: InitExtractorRecommendation[];
+}): string;
+export {};

package/dist/cli/init-summary.js

@@ -0,0 +1,147 @@
+import { extractorSetupCommands, 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' },
+    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 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) {
+        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) {
+            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('');
+    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');
+    }
+    for (const command of extractorSetupCommands(options.recommendedExtractors)) {
+        lines.push(`  ${command}`);
+    }
+    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/config/config.js

@@ -71,6 +71,7 @@ export const DEFAULT_CONFIG = {
     maxContextItems: 8,
     domainHints: {},
     integrations: [],
+    extractors: [],
 };
 export async function writeDefaultConfig(workspace) {
     if (await pathExists(workspace.configPath)) {
@@ -114,6 +115,7 @@ export function normalizeConfig(config) {
             ? config.domainHints
             : {},
         integrations: normalizeIntegrations(config.integrations),
+        extractors: normalizeExtractors(config.extractors),
     };
 }
 function mergeUnique(base, extra) {
@@ -161,3 +163,34 @@ 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/extractors/extractor-registry.d.ts

@@ -0,0 +1,11 @@
+import type { ExtractorName } from '../types/config.js';
+export interface ExtractorAdapter {
+    name: ExtractorName;
+    label: string;
+    packageName: string;
+    languages: string[];
+}
+export declare function listExtractorAdapters(): ExtractorAdapter[];
+export declare function getExtractorAdapter(name: string): ExtractorAdapter;
+export declare function normalizeExtractorNames(values: string[] | undefined): ExtractorName[];
+export declare function installCommandForExtractors(packageNames: string[]): string;

package/dist/extractors/extractor-registry.js

@@ -0,0 +1,70 @@
+const ADAPTERS = [
+    {
+        name: 'python',
+        label: 'Python deep extractor',
+        packageName: '@kentwynn/kgraph-extractor-python',
+        languages: ['python'],
+    },
+    {
+        name: 'jvm',
+        label: 'JVM deep extractor',
+        packageName: '@kentwynn/kgraph-extractor-jvm',
+        languages: ['java', 'kotlin'],
+    },
+    {
+        name: 'go',
+        label: 'Go deep extractor',
+        packageName: '@kentwynn/kgraph-extractor-go',
+        languages: ['go'],
+    },
+    {
+        name: 'rust',
+        label: 'Rust deep extractor',
+        packageName: '@kentwynn/kgraph-extractor-rust',
+        languages: ['rust'],
+    },
+    {
+        name: 'c-family',
+        label: 'C/C++ deep extractor',
+        packageName: '@kentwynn/kgraph-extractor-c-family',
+        languages: ['c', 'cpp'],
+    },
+    {
+        name: 'csharp',
+        label: 'C# deep extractor',
+        packageName: '@kentwynn/kgraph-extractor-csharp',
+        languages: ['csharp'],
+    },
+].sort((left, right) => left.name.localeCompare(right.name));
+export function listExtractorAdapters() {
+    return ADAPTERS;
+}
+export function getExtractorAdapter(name) {
+    const adapter = ADAPTERS.find((item) => item.name === name);
+    if (!adapter) {
+        throw new Error(`Unsupported extractor "${name}". Supported extractors: ${ADAPTERS.map((item) => item.name).join(', ')}`);
+    }
+    return adapter;
+}
+export function normalizeExtractorNames(values) {
+    if (!values || values.length === 0) {
+        return [];
+    }
+    const names = [];
+    const seen = new Set();
+    for (const value of values) {
+        for (const raw of value.split(/[\s,]+/)) {
+            const name = raw.trim();
+            if (!name || seen.has(name)) {
+                continue;
+            }
+            const adapter = getExtractorAdapter(name);
+            seen.add(adapter.name);
+            names.push(adapter.name);
+        }
+    }
+    return names;
+}
+export function installCommandForExtractors(packageNames) {
+    return `npm install -D ${packageNames.join(' ')}`;
+}

package/dist/extractors/extractor-store.d.ts

@@ -0,0 +1,10 @@
+import type { ExtractorConfig, ExtractorName, KGraphWorkspace } from '../types/config.js';
+export interface ExtractorStatus {
+    name: ExtractorName;
+    enabled: boolean;
+    packageName: string;
+    packageInstalled: boolean;
+}
+export declare function listExtractors(workspace: KGraphWorkspace): Promise<ExtractorStatus[]>;
+export declare function addExtractors(workspace: KGraphWorkspace, names: ExtractorName[]): Promise<ExtractorConfig[]>;
+export declare function removeExtractors(workspace: KGraphWorkspace, names: ExtractorName[]): Promise<ExtractorName[]>;

package/dist/extractors/extractor-store.js

@@ -0,0 +1,58 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { loadConfig, saveConfig } from '../config/config.js';
+import { pathExists } from '../storage/kgraph-paths.js';
+import { getExtractorAdapter } from './extractor-registry.js';
+export async function listExtractors(workspace) {
+    const config = await loadConfig(workspace);
+    const statuses = await Promise.all(config.extractors.map(async (extractor) => ({
+        name: extractor.name,
+        enabled: extractor.enabled,
+        packageName: extractor.packageName,
+        packageInstalled: await isExtractorInstalled(workspace.rootPath, extractor.packageName),
+    })));
+    return statuses.sort((left, right) => left.name.localeCompare(right.name));
+}
+export async function addExtractors(workspace, names) {
+    const config = await loadConfig(workspace);
+    const byName = new Map(config.extractors.map((extractor) => [extractor.name, extractor]));
+    const changed = [];
+    for (const name of names) {
+        const adapter = getExtractorAdapter(name);
+        const next = {
+            name: adapter.name,
+            enabled: true,
+            packageName: adapter.packageName,
+        };
+        byName.set(adapter.name, next);
+        changed.push(next);
+    }
+    config.extractors = [...byName.values()].sort((left, right) => left.name.localeCompare(right.name));
+    await saveConfig(workspace, config);
+    return changed;
+}
+export async function removeExtractors(workspace, names) {
+    const config = await loadConfig(workspace);
+    const removeNames = new Set(names);
+    config.extractors = config.extractors.filter((extractor) => !removeNames.has(extractor.name));
+    await saveConfig(workspace, config);
+    return [...removeNames].sort((left, right) => left.localeCompare(right));
+}
+async function isExtractorInstalled(rootPath, packageName) {
+    const packageJsonPath = path.join(rootPath, 'package.json');
+    if (await pathExists(packageJsonPath)) {
+        try {
+            const raw = await readFile(packageJsonPath, 'utf8');
+            const pkg = JSON.parse(raw);
+            if (pkg.dependencies?.[packageName] ||
+                pkg.devDependencies?.[packageName] ||
+                pkg.optionalDependencies?.[packageName]) {
+                return true;
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    return pathExists(path.join(rootPath, 'node_modules', ...packageName.split('/'), 'package.json'));
+}

package/dist/types/config.d.ts

@@ -7,19 +7,26 @@ export interface KGraphConfig {
     maxContextItems: number;
     domainHints: Record<string, DomainHint>;
     integrations: IntegrationConfig[];
+    extractors: ExtractorConfig[];
 }
 export interface DomainHint {
     paths?: string[];
     tags?: string[];
 }
-export type IntegrationName = "claude-code" | "cline" | "codex" | "copilot" | "cursor" | "gemini" | "windsurf";
-export type IntegrationMode = "smart" | "always" | "manual" | "off";
+export type IntegrationName = 'claude-code' | 'cline' | 'codex' | 'copilot' | 'cursor' | 'gemini' | 'windsurf';
+export type IntegrationMode = 'smart' | 'always' | 'manual' | 'off';
+export type ExtractorName = 'c-family' | 'csharp' | 'go' | 'jvm' | 'python' | 'rust';
 export interface IntegrationConfig {
     name: IntegrationName;
     enabled: boolean;
     mode: IntegrationMode;
     targetPath: string;
 }
+export interface ExtractorConfig {
+    name: ExtractorName;
+    enabled: boolean;
+    packageName: string;
+}
 export interface KGraphWorkspace {
     rootPath: string;
     kgraphPath: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kentwynn/kgraph",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "Persistent repo intelligence for AI coding assistants.",
   "type": "module",
   "bin": {
@@ -39,6 +39,7 @@
   },
   "homepage": "https://github.com/kentwynn/KGraph#readme",
   "dependencies": {
+    "@clack/prompts": "^1.3.0",
     "chalk": "^5.6.2",
     "commander": "^12.1.0",
     "fast-glob": "^3.3.2",