@kentwynn/kgraph 0.1.24 → 0.1.26

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/cognition/markdown-note-parser.js

@@ -1,8 +1,9 @@
 import YAML from 'yaml';
 const PATH_REF = /(?:^|\s|`?)([\w./-]+\.(?:ts|tsx|js|jsx|json|md|yaml|yml))(?:\s|$|[),.;`])/g;
 export function parseMarkdownNote(markdown) {
+    const normalized = markdown.replace(/\r\n/g, '\n');
     const warnings = [];
-    const { frontmatter, body } = splitFrontmatter(markdown, warnings);
+    const { frontmatter, body } = splitFrontmatter(normalized, warnings);
     const sections = parseSections(body);
     const frontmatterTitle = typeof frontmatter.title === 'string' ? frontmatter.title : undefined;
     const title = extractTitle(body) ?? frontmatterTitle ?? 'Untitled Cognition Note';

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/integrations/instruction-blocks.d.ts

@@ -1,4 +1,4 @@
-import type { IntegrationMode } from "../types/config.js";
+import type { IntegrationMode } from '../types/config.js';
 export declare const KGRAPH_CONTEXT_POLICY_PLACEHOLDER = "{{KGRAPH_CONTEXT_POLICY}}";
 export declare const KGRAPH_CAPTURE_POLICY_PLACEHOLDER = "{{KGRAPH_CAPTURE_POLICY}}";
 export declare function upsertManagedBlock(content: string, integrationName: string, instructions: string): string;

package/dist/integrations/instruction-blocks.js

@@ -1,7 +1,7 @@
-const MARKER_PREFIX = "<!--";
-const MARKER_SUFFIX = "-->";
-export const KGRAPH_CONTEXT_POLICY_PLACEHOLDER = "{{KGRAPH_CONTEXT_POLICY}}";
-export const KGRAPH_CAPTURE_POLICY_PLACEHOLDER = "{{KGRAPH_CAPTURE_POLICY}}";
+const MARKER_PREFIX = '<!--';
+const MARKER_SUFFIX = '-->';
+export const KGRAPH_CONTEXT_POLICY_PLACEHOLDER = '{{KGRAPH_CONTEXT_POLICY}}';
+export const KGRAPH_CAPTURE_POLICY_PLACEHOLDER = '{{KGRAPH_CAPTURE_POLICY}}';
 export function upsertManagedBlock(content, integrationName, instructions) {
     const normalized = content.trimEnd();
     const block = renderManagedBlock(integrationName, instructions);
@@ -9,23 +9,26 @@ export function upsertManagedBlock(content, integrationName, instructions) {
     if (pattern.test(content)) {
         return content.replace(pattern, block);
     }
-    return `${normalized}${normalized ? "\n\n" : ""}${block}\n`;
+    return normalized ? `${block}\n\n${normalized}\n` : `${block}\n`;
 }
 export function removeManagedBlock(content, integrationName) {
-    return content.replace(managedBlockPattern(integrationName), "").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+    return (content
+        .replace(managedBlockPattern(integrationName), '')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim() + '\n');
 }
 function renderManagedBlock(integrationName, instructions) {
     return [
         `${MARKER_PREFIX} BEGIN KGRAPH ${integrationName} ${MARKER_SUFFIX}`,
         instructions.trim(),
-        `${MARKER_PREFIX} END KGRAPH ${integrationName} ${MARKER_SUFFIX}`
-    ].join("\n");
+        `${MARKER_PREFIX} END KGRAPH ${integrationName} ${MARKER_SUFFIX}`,
+    ].join('\n');
 }
 function managedBlockPattern(integrationName) {
-    return new RegExp(`${escapeRegExp(MARKER_PREFIX)} BEGIN KGRAPH ${escapeRegExp(integrationName)} ${escapeRegExp(MARKER_SUFFIX)}[\\s\\S]*?${escapeRegExp(MARKER_PREFIX)} END KGRAPH ${escapeRegExp(integrationName)} ${escapeRegExp(MARKER_SUFFIX)}\\n?`, "m");
+    return new RegExp(`${escapeRegExp(MARKER_PREFIX)} BEGIN KGRAPH ${escapeRegExp(integrationName)} ${escapeRegExp(MARKER_SUFFIX)}[\\s\\S]*?${escapeRegExp(MARKER_PREFIX)} END KGRAPH ${escapeRegExp(integrationName)} ${escapeRegExp(MARKER_SUFFIX)}\\n?`, 'm');
 }
 function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 export function applyContextPolicy(content, mode) {
     return content
@@ -34,13 +37,13 @@ export function applyContextPolicy(content, mode) {
 }
 export function renderContextPolicy(mode) {
     switch (mode) {
-        case "always":
+        case 'always':
             return 'Every chat in this repository must start by running `kgraph "<topic>"` before answering or exploring files. Infer the topic from the user\'s message; no exceptions, including simple or conversational requests.';
-        case "manual":
+        case 'manual':
             return 'Do not run KGraph automatically. Run `kgraph "<topic>"` only when the user explicitly asks for KGraph context or invokes the KGraph command.';
-        case "off":
-            return "KGraph is disabled for this integration.";
-        case "smart":
+        case 'off':
+            return 'KGraph is disabled for this integration.';
+        case 'smart':
         default:
             return 'For repo-specific coding, debugging, architecture, refactor, review, or file-exploration requests, run `kgraph "<topic>"` before broad repository exploration. Infer the topic from the user\'s message. Skip KGraph for simple conversational requests that do not depend on repo knowledge.';
     }

package/dist/integrations/integration-registry.d.ts

@@ -1,4 +1,4 @@
-import type { IntegrationName } from "../types/config.js";
+import type { IntegrationName } from '../types/config.js';
 export interface IntegrationAdapter {
     name: IntegrationName;
     label: string;

package/dist/integrations/integration-registry.js

@@ -1,10 +1,10 @@
-import { claudeCodeAdapter } from "./adapters/claude-code.js";
-import { clineAdapter } from "./adapters/cline.js";
-import { codexAdapter } from "./adapters/codex.js";
-import { copilotAdapter } from "./adapters/copilot.js";
-import { cursorAdapter } from "./adapters/cursor.js";
-import { geminiAdapter } from "./adapters/gemini.js";
-import { windsurfAdapter } from "./adapters/windsurf.js";
+import { claudeCodeAdapter } from './adapters/claude-code.js';
+import { clineAdapter } from './adapters/cline.js';
+import { codexAdapter } from './adapters/codex.js';
+import { copilotAdapter } from './adapters/copilot.js';
+import { cursorAdapter } from './adapters/cursor.js';
+import { geminiAdapter } from './adapters/gemini.js';
+import { windsurfAdapter } from './adapters/windsurf.js';
 const ADAPTERS = [
     claudeCodeAdapter,
     clineAdapter,
@@ -12,7 +12,7 @@ const ADAPTERS = [
     copilotAdapter,
     cursorAdapter,
     geminiAdapter,
-    windsurfAdapter
+    windsurfAdapter,
 ].sort((left, right) => left.name.localeCompare(right.name));
 export function listIntegrationAdapters() {
     return ADAPTERS;
@@ -20,7 +20,7 @@ export function listIntegrationAdapters() {
 export function getIntegrationAdapter(name) {
     const adapter = ADAPTERS.find((item) => item.name === name);
     if (!adapter) {
-        throw new Error(`Unsupported integration "${name}". Supported integrations: ${ADAPTERS.map((item) => item.name).join(", ")}`);
+        throw new Error(`Unsupported integration "${name}". Supported integrations: ${ADAPTERS.map((item) => item.name).join(', ')}`);
     }
     return adapter;
 }
@@ -31,7 +31,7 @@ export function normalizeIntegrationNames(values) {
     const names = [];
     const seen = new Set();
     for (const value of values) {
-        for (const raw of value.split(",")) {
+        for (const raw of value.split(/[\s,]+/)) {
             const name = raw.trim();
             if (!name || seen.has(name)) {
                 continue;