icopilot 2.2.0

package/dist/hooks/precommit.js

@@ -0,0 +1,463 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import simpleGit from 'simple-git';
+import { activeProvider, client } from '../api/github-models.js';
+import { detectLinters } from '../commands/lint-cmd.js';
+import { scanFilesForSecrets } from '../commands/security-cmd.js';
+import { detectTestFrameworks } from '../commands/test-cmd.js';
+import { config } from '../config.js';
+import { theme } from '../ui/theme.js';
+const HOOK_MARKER = '# managed by icopilot pre-commit hook';
+const PRECOMMIT_USAGE = [
+    theme.brand('Hook command'),
+    `  ${theme.hl('/hook install')}               ${theme.dim('install the git pre-commit hook')}`,
+    `  ${theme.hl('/hook uninstall')}             ${theme.dim('remove the git pre-commit hook')}`,
+    `  ${theme.hl('/hook run')}                   ${theme.dim('run configured checks now')}`,
+    `  ${theme.hl('/hook config')}                ${theme.dim('show current hook config')}`,
+    `  ${theme.hl('/hook config enable|disable')} ${theme.dim('toggle the hook')}`,
+    `  ${theme.hl('/hook config fail-on <mode>')} ${theme.dim('set error, warning, or never')}`,
+    `  ${theme.hl('/hook config checks <list>')}  ${theme.dim('replace checks (comma-separated)')}`,
+    `  ${theme.hl('/hook config add <check>')}    ${theme.dim('add review, security, lint, or test')}`,
+    `  ${theme.hl('/hook config remove <check>')} ${theme.dim('remove a configured check')}`,
+    `  ${theme.hl('/hook config reset')}          ${theme.dim('restore defaults')}`,
+].join('\n');
+const PRECOMMIT_CONFIG_FILE = path.join('.icopilot', 'precommit.json');
+const REVIEW_PROMPT = `You are doing a fast pre-commit code review.
+Return "LGTM" if the staged diff is clean.
+Otherwise return a compact bullet list of concrete issues only. Focus on bugs, regressions, security problems, and missing tests.`;
+const VALID_CHECKS = ['review', 'security', 'lint', 'test'];
+const DEFAULT_PRECOMMIT_CONFIG = {
+    enabled: true,
+    checks: ['review', 'security'],
+    failOn: 'error',
+};
+const MAX_FINDINGS = 20;
+export function installHook(gitDir) {
+    const hooksDir = path.join(gitDir, 'hooks');
+    const hookPath = path.join(hooksDir, 'pre-commit');
+    fs.mkdirSync(hooksDir, { recursive: true });
+    fs.writeFileSync(hookPath, buildHookScript(), 'utf8');
+    try {
+        fs.chmodSync(hookPath, 0o755);
+    }
+    catch {
+        /* best effort on Windows */
+    }
+}
+export function uninstallHook(gitDir) {
+    fs.rmSync(path.join(gitDir, 'hooks', 'pre-commit'), { force: true });
+}
+export async function runPrecommitChecks(precommitConfig) {
+    return toPublicResult(await runPrecommitChecksInternal(normalizePrecommitConfig(precommitConfig), process.cwd()));
+}
+export function loadPrecommitConfig(cwd = config.cwd) {
+    const filePath = getPrecommitConfigPath(cwd);
+    try {
+        if (!fs.existsSync(filePath))
+            return { ...DEFAULT_PRECOMMIT_CONFIG, checks: [...DEFAULT_PRECOMMIT_CONFIG.checks] };
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        return normalizePrecommitConfig(parsed);
+    }
+    catch {
+        return { ...DEFAULT_PRECOMMIT_CONFIG, checks: [...DEFAULT_PRECOMMIT_CONFIG.checks] };
+    }
+}
+export function savePrecommitConfig(next, cwd = config.cwd) {
+    const normalized = normalizePrecommitConfig(next);
+    const filePath = getPrecommitConfigPath(cwd);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(normalized, null, 2)}\n`, 'utf8');
+    return normalized;
+}
+export async function hookCommand(args, cwd = config.cwd) {
+    const [subcommand, ...rest] = args;
+    const normalizedSubcommand = subcommand?.toLowerCase();
+    if (!normalizedSubcommand) {
+        return { output: `${PRECOMMIT_USAGE}\n`, exitCode: 0 };
+    }
+    switch (normalizedSubcommand) {
+        case 'install': {
+            const gitDir = await resolveGitDir(cwd);
+            installHook(gitDir);
+            const current = savePrecommitConfig(loadPrecommitConfig(cwd), cwd);
+            return {
+                output: `${theme.ok('✔ pre-commit hook installed')}\n` +
+                    `${theme.dim(path.join(gitDir, 'hooks', 'pre-commit'))}\n` +
+                    `${formatPrecommitConfig(current, cwd)}`,
+                exitCode: 0,
+            };
+        }
+        case 'uninstall': {
+            const gitDir = await resolveGitDir(cwd);
+            uninstallHook(gitDir);
+            return {
+                output: `${theme.ok('✔ pre-commit hook removed')}\n${theme.dim(path.join(gitDir, 'hooks', 'pre-commit'))}\n`,
+                exitCode: 0,
+            };
+        }
+        case 'run': {
+            const current = loadPrecommitConfig(cwd);
+            const result = await runPrecommitChecksInternal({ ...current, enabled: true }, cwd);
+            return {
+                output: formatPrecommitResult(result, current, cwd),
+                exitCode: result.passed ? 0 : 1,
+            };
+        }
+        case 'pre-commit': {
+            const current = loadPrecommitConfig(cwd);
+            if (!current.enabled) {
+                return {
+                    output: `${theme.dim(`pre-commit hook disabled (${getPrecommitConfigPath(cwd)})`)}\n`,
+                    exitCode: 0,
+                };
+            }
+            const result = await runPrecommitChecksInternal(current, cwd);
+            return {
+                output: formatPrecommitResult(result, current, cwd),
+                exitCode: result.passed ? 0 : 1,
+            };
+        }
+        case 'config':
+            return handleConfigCommand(rest, cwd);
+        default:
+            return {
+                output: `${theme.warn(`unknown hook subcommand: ${subcommand}`)}\n${PRECOMMIT_USAGE}\n`,
+                exitCode: 1,
+            };
+    }
+}
+function buildHookScript() {
+    return `#!/bin/sh
+${HOOK_MARKER}
+if command -v icopilot >/dev/null 2>&1; then
+  exec icopilot hook pre-commit "$@"
+fi
+
+if command -v icli >/dev/null 2>&1; then
+  exec icli hook pre-commit "$@"
+fi
+
+echo "icopilot is not installed on PATH." >&2
+exit 1
+`;
+}
+function getPrecommitConfigPath(cwd) {
+    return path.join(cwd, PRECOMMIT_CONFIG_FILE);
+}
+function normalizePrecommitConfig(input) {
+    const candidate = input && typeof input === 'object' ? input : {};
+    const enabled = typeof candidate.enabled === 'boolean' ? candidate.enabled : DEFAULT_PRECOMMIT_CONFIG.enabled;
+    const failOn = candidate.failOn === 'error' || candidate.failOn === 'warning' || candidate.failOn === 'never'
+        ? candidate.failOn
+        : DEFAULT_PRECOMMIT_CONFIG.failOn;
+    const checks = Array.isArray(candidate.checks)
+        ? dedupeChecks(candidate.checks.filter(isCheckName))
+        : [...DEFAULT_PRECOMMIT_CONFIG.checks];
+    return {
+        enabled,
+        checks: checks.length ? checks : [...DEFAULT_PRECOMMIT_CONFIG.checks],
+        failOn,
+    };
+}
+function dedupeChecks(checks) {
+    return [...new Set(checks)];
+}
+function isCheckName(value) {
+    return typeof value === 'string' && VALID_CHECKS.includes(value);
+}
+async function handleConfigCommand(args, cwd) {
+    const current = loadPrecommitConfig(cwd);
+    const [action, ...rest] = args;
+    if (!action || action === 'show') {
+        return { output: formatPrecommitConfig(current, cwd), exitCode: 0 };
+    }
+    switch (action.toLowerCase()) {
+        case 'enable':
+            return {
+                output: `${theme.ok('✔ hook enabled')}\n${formatPrecommitConfig(savePrecommitConfig({ ...current, enabled: true }, cwd), cwd)}`,
+                exitCode: 0,
+            };
+        case 'disable':
+            return {
+                output: `${theme.ok('✔ hook disabled')}\n${formatPrecommitConfig(savePrecommitConfig({ ...current, enabled: false }, cwd), cwd)}`,
+                exitCode: 0,
+            };
+        case 'fail-on': {
+            const value = rest[0];
+            if (value !== 'error' && value !== 'warning' && value !== 'never') {
+                return {
+                    output: `${theme.warn('usage: /hook config fail-on <error|warning|never>')}\n`,
+                    exitCode: 1,
+                };
+            }
+            return {
+                output: `${theme.ok(`✔ failOn → ${value}`)}\n${formatPrecommitConfig(savePrecommitConfig({ ...current, failOn: value }, cwd), cwd)}`,
+                exitCode: 0,
+            };
+        }
+        case 'checks': {
+            const list = parseCheckList(rest.join(' '));
+            if (!list.length) {
+                return {
+                    output: `${theme.warn('usage: /hook config checks <review,security,lint,test>')}\n`,
+                    exitCode: 1,
+                };
+            }
+            return {
+                output: `${theme.ok(`✔ checks → ${list.join(', ')}`)}\n${formatPrecommitConfig(savePrecommitConfig({ ...current, checks: list }, cwd), cwd)}`,
+                exitCode: 0,
+            };
+        }
+        case 'add': {
+            const check = rest[0];
+            if (!isCheckName(check)) {
+                return {
+                    output: `${theme.warn('usage: /hook config add <review|security|lint|test>')}\n`,
+                    exitCode: 1,
+                };
+            }
+            return {
+                output: `${theme.ok(`✔ added ${check}`)}\n${formatPrecommitConfig(savePrecommitConfig({ ...current, checks: dedupeChecks([...current.checks, check]) }, cwd), cwd)}`,
+                exitCode: 0,
+            };
+        }
+        case 'remove': {
+            const check = rest[0];
+            if (!isCheckName(check)) {
+                return {
+                    output: `${theme.warn('usage: /hook config remove <review|security|lint|test>')}\n`,
+                    exitCode: 1,
+                };
+            }
+            return {
+                output: `${theme.ok(`✔ removed ${check}`)}\n${formatPrecommitConfig(savePrecommitConfig({ ...current, checks: current.checks.filter((entry) => entry !== check) }, cwd), cwd)}`,
+                exitCode: 0,
+            };
+        }
+        case 'reset':
+            return {
+                output: `${theme.ok('✔ hook config reset')}\n${formatPrecommitConfig(savePrecommitConfig(DEFAULT_PRECOMMIT_CONFIG, cwd), cwd)}`,
+                exitCode: 0,
+            };
+        default:
+            return {
+                output: `${theme.warn(`unknown config action: ${action}`)}\n${PRECOMMIT_USAGE}\n`,
+                exitCode: 1,
+            };
+    }
+}
+function parseCheckList(value) {
+    const items = value
+        .split(',')
+        .map((entry) => entry.trim().toLowerCase())
+        .filter(Boolean);
+    return dedupeChecks(items.filter(isCheckName));
+}
+async function runPrecommitChecksInternal(precommitConfig, cwd) {
+    if (!precommitConfig.enabled) {
+        return { passed: true, checks: [] };
+    }
+    const staged = await getStagedContext(cwd);
+    const checks = [];
+    for (const name of precommitConfig.checks) {
+        checks.push(await runCheck(name, staged));
+    }
+    return {
+        passed: evaluateOverallPass(checks, precommitConfig.failOn),
+        checks,
+    };
+}
+async function getStagedContext(cwd) {
+    const git = simpleGit({ baseDir: cwd });
+    const filesRaw = await git.diff(['--cached', '--name-only', '--diff-filter=ACMR']);
+    const files = filesRaw
+        .split(/\r?\n/)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    const diff = files.length ? await git.diff(['--cached', '--unified=0', '--no-color']) : '';
+    return { cwd, files, diff };
+}
+async function runCheck(name, staged) {
+    switch (name) {
+        case 'review':
+            return runReviewCheck(staged);
+        case 'security':
+            return runSecurityCheck(staged);
+        case 'lint':
+            return runLintCheck(staged);
+        case 'test':
+            return runTestCheck(staged);
+    }
+}
+async function runReviewCheck(staged) {
+    const startedAt = Date.now();
+    if (!staged.diff.trim()) {
+        return finalizeCheck('review', true, [], startedAt, 'none');
+    }
+    try {
+        const provider = activeProvider();
+        const messages = [
+            { role: 'system', content: REVIEW_PROMPT },
+            {
+                role: 'user',
+                content: `Review this staged diff:\n\n${staged.diff.slice(0, 80_000)}`,
+            },
+        ];
+        const response = await client().chat.completions.create({
+            model: config.defaultModel,
+            messages,
+            temperature: 0.1,
+            ...(provider?.maxTokens ? { max_tokens: provider.maxTokens } : {}),
+        });
+        const content = response.choices[0]?.message?.content?.trim() ?? '';
+        if (!content || isCleanReview(content)) {
+            return finalizeCheck('review', true, [], startedAt, 'none');
+        }
+        return finalizeCheck('review', false, summarizeText(content), startedAt, 'warning');
+    }
+    catch (error) {
+        return finalizeCheck('review', false, [`review failed: ${String(error?.message || error)}`], startedAt, 'error');
+    }
+}
+function runSecurityCheck(staged) {
+    const startedAt = Date.now();
+    const findings = scanFilesForSecrets(staged.cwd, staged.files).map((finding) => `${finding.file}:${finding.line} ${finding.pattern} (${finding.severity})`);
+    return Promise.resolve(finalizeCheck('security', findings.length === 0, findings, startedAt, findings.length ? 'error' : 'none'));
+}
+async function runLintCheck(staged) {
+    const startedAt = Date.now();
+    const linters = detectLinters(staged.cwd);
+    if (!linters.length) {
+        return finalizeCheck('lint', false, ['No configured linter detected.'], startedAt, 'error');
+    }
+    const selection = buildLintCommand(linters, staged.files);
+    const result = await executeCommand(selection.command, staged.cwd);
+    const findings = result.code === 0 ? [] : summarizeText(result.output || 'Lint command failed.');
+    return finalizeCheck('lint', result.code === 0, findings, startedAt, result.code === 0 ? 'none' : 'error');
+}
+async function runTestCheck(staged) {
+    const startedAt = Date.now();
+    const frameworks = detectTestFrameworks(staged.cwd);
+    if (!frameworks.length) {
+        return finalizeCheck('test', false, ['No configured test runner detected.'], startedAt, 'error');
+    }
+    const selection = buildTestCommand(frameworks, staged.files);
+    const result = await executeCommand(selection.command, staged.cwd);
+    const findings = result.code === 0 ? [] : summarizeText(result.output || 'Test command failed.');
+    return finalizeCheck('test', result.code === 0, findings, startedAt, result.code === 0 ? 'none' : 'error');
+}
+function buildLintCommand(linters, stagedFiles) {
+    const preferred = linters.find((entry) => entry.name === 'npm-lint') ?? linters[0];
+    const lintableFiles = stagedFiles.filter((file) => /\.(?:[cm]?[jt]sx?|py|go|java|cs|php|rb)$/i.test(file));
+    if ((preferred.name === 'eslint' || preferred.name === 'eslint-config') && lintableFiles.length) {
+        return { command: ['npx', 'eslint', ...lintableFiles].map(quoteArg).join(' ') };
+    }
+    return { command: preferred.command };
+}
+function buildTestCommand(frameworks, stagedFiles) {
+    const testFiles = stagedFiles.filter((file) => /\.(?:test|spec)\.[cm]?[jt]sx?$/i.test(file));
+    const preferred = frameworks.find((entry) => entry.name === 'vitest') ??
+        frameworks.find((entry) => entry.name === 'jest') ??
+        frameworks[0];
+    if (preferred.name === 'vitest' && testFiles.length) {
+        return { command: ['npx', 'vitest', 'run', ...testFiles].map(quoteArg).join(' ') };
+    }
+    if (preferred.name === 'jest' && testFiles.length) {
+        return { command: ['npx', 'jest', ...testFiles].map(quoteArg).join(' ') };
+    }
+    return { command: preferred.command };
+}
+function executeCommand(command, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, [], {
+            cwd,
+            shell: true,
+            windowsHide: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let output = '';
+        child.stdout.on('data', (chunk) => {
+            output += String(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            output += String(chunk);
+        });
+        child.on('error', reject);
+        child.on('exit', (code) => {
+            resolve({ code: code ?? 1, output });
+        });
+    });
+}
+function summarizeText(text) {
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.replace(/^\s*[-*]\s*/, '').trim())
+        .filter(Boolean)
+        .slice(0, MAX_FINDINGS);
+}
+function isCleanReview(content) {
+    return /^(?:lgtm|no issues found|looks good\b)/i.test(content.trim());
+}
+function evaluateOverallPass(checks, failOn) {
+    if (failOn === 'never')
+        return true;
+    if (failOn === 'warning')
+        return checks.every((check) => check.failureLevel === 'none');
+    return checks.every((check) => check.failureLevel !== 'error');
+}
+function finalizeCheck(name, passed, findings, startedAt, failureLevel) {
+    return {
+        name,
+        passed,
+        findings,
+        duration: Date.now() - startedAt,
+        failureLevel,
+    };
+}
+function toPublicResult(result) {
+    return {
+        passed: result.passed,
+        checks: result.checks.map(({ failureLevel: _failureLevel, ...check }) => check),
+    };
+}
+function formatPrecommitConfig(precommitConfig, cwd) {
+    const configPath = getPrecommitConfigPath(cwd);
+    return [
+        theme.brand('Pre-commit config'),
+        `  file:    ${theme.hl(configPath)}`,
+        `  enabled: ${theme.hl(String(precommitConfig.enabled))}`,
+        `  failOn:  ${theme.hl(precommitConfig.failOn)}`,
+        `  checks:  ${theme.hl(precommitConfig.checks.join(', '))}`,
+        '',
+    ].join('\n');
+}
+function formatPrecommitResult(result, precommitConfig, cwd) {
+    const header = result.passed
+        ? theme.ok('✔ pre-commit checks passed')
+        : theme.err('✖ pre-commit checks failed');
+    const lines = [
+        header,
+        theme.dim(`config: ${getPrecommitConfigPath(cwd)}  failOn=${precommitConfig.failOn}`),
+        '',
+    ];
+    if (result.checks.length === 0) {
+        lines.push(theme.dim('No checks ran.'));
+    }
+    for (const check of result.checks) {
+        lines.push(`  ${check.passed ? theme.ok('✓') : theme.err('✗')} ${check.name} ${theme.dim(`(${check.duration}ms)`)}`);
+        for (const finding of check.findings) {
+            lines.push(`    - ${finding}`);
+        }
+    }
+    lines.push('');
+    return `${lines.join('\n')}\n`;
+}
+async function resolveGitDir(cwd) {
+    const git = simpleGit({ baseDir: cwd });
+    const gitDir = (await git.raw(['rev-parse', '--git-dir'])).trim();
+    return path.resolve(cwd, gitDir);
+}
+function quoteArg(value) {
+    return `"${value.replace(/(["\\$`])/g, '\\$1')}"`;
+}

package/dist/index/embeddings.js

@@ -0,0 +1,23 @@
+import { client } from '../api/github-models.js';
+const EMBEDDING_MODEL = 'text-embedding-3-small';
+const BATCH_SIZE = 64;
+export async function embed(texts) {
+    if (!texts.length)
+        return [];
+    const vectors = [];
+    for (let i = 0; i < texts.length; i += BATCH_SIZE) {
+        const input = texts.slice(i, i + BATCH_SIZE);
+        try {
+            const response = await client().embeddings.create({
+                model: EMBEDDING_MODEL,
+                input,
+            });
+            vectors.push(...response.data.map((item) => item.embedding));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new Error(`Embedding request failed: ${message}`);
+        }
+    }
+    return vectors;
+}

package/dist/index/indexer.js

@@ -0,0 +1,86 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import fg from 'fast-glob';
+import { embed } from './embeddings.js';
+import { VectorStore } from './store.js';
+const DEFAULT_INCLUDE = ['**/*.{ts,tsx,js,jsx,md,py,go,rs,java,rb,cs,json,yaml,yml,toml}'];
+const DEFAULT_IGNORE = ['node_modules/**', 'dist/**', '.git/**', 'coverage/**'];
+const MAX_FILE_BYTES = 256 * 1024;
+const OVERLAP_CHARS = 200;
+export async function buildIndex(cwd, opts = {}) {
+    const started = Date.now();
+    const outPath = path.join(cwd, '.icopilot', 'index.json');
+    const store = new VectorStore(outPath);
+    const existing = store.load().entries;
+    const existingByFile = new Map();
+    for (const entry of existing) {
+        const bucket = existingByFile.get(entry.file) ?? [];
+        bucket.push(entry);
+        existingByFile.set(entry.file, bucket);
+    }
+    const files = await fg(opts.include ?? DEFAULT_INCLUDE, {
+        cwd,
+        ignore: opts.ignore ?? DEFAULT_IGNORE,
+        onlyFiles: true,
+        dot: false,
+    });
+    const chunkChars = opts.chunkChars ?? 1500;
+    const retained = [];
+    const pending = [];
+    for (const file of files.sort()) {
+        const absolute = path.join(cwd, file);
+        const stat = await fs.stat(absolute);
+        if (stat.size > MAX_FILE_BYTES)
+            continue;
+        const content = await fs.readFile(absolute, 'utf8');
+        const sha = sha1(content);
+        const oldEntries = existingByFile.get(file);
+        if (oldEntries?.length && oldEntries.every((entry) => entry.sha === sha)) {
+            retained.push(...oldEntries);
+            continue;
+        }
+        const chunks = chunkText(content, chunkChars);
+        if (chunks.length)
+            pending.push({ file, sha, chunks });
+    }
+    const texts = pending.flatMap((item) => item.chunks);
+    const vectors = await embed(texts);
+    const fresh = [];
+    let vectorIndex = 0;
+    for (const item of pending) {
+        item.chunks.forEach((text, chunk) => {
+            fresh.push({
+                id: `${item.file}:${item.sha}:${chunk}`,
+                file: item.file,
+                chunk,
+                text,
+                vector: vectors[vectorIndex++],
+                sha: item.sha,
+            });
+        });
+    }
+    store.replaceAll([...retained, ...fresh]);
+    store.save();
+    return {
+        files: files.length,
+        chunks: fresh.length,
+        ms: Date.now() - started,
+        outPath,
+    };
+}
+function chunkText(text, chunkChars) {
+    const chunks = [];
+    const step = Math.max(1, chunkChars - OVERLAP_CHARS);
+    for (let start = 0; start < text.length; start += step) {
+        const chunk = text.slice(start, start + chunkChars).trim();
+        if (chunk)
+            chunks.push(chunk);
+        if (start + chunkChars >= text.length)
+            break;
+    }
+    return chunks;
+}
+function sha1(text) {
+    return crypto.createHash('sha1').update(text).digest('hex');
+}

package/dist/index/retrieve.js

@@ -0,0 +1,20 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { embed } from './embeddings.js';
+import { VectorStore } from './store.js';
+export async function retrieve(cwd, query, topK = 6) {
+    const indexPath = path.join(cwd, '.icopilot', 'index.json');
+    if (!fs.existsSync(indexPath))
+        return [];
+    const store = new VectorStore(indexPath);
+    store.load();
+    const [queryVec] = await embed([query]);
+    if (!queryVec)
+        return [];
+    return store.search(queryVec, topK).map(({ entry, score }) => ({
+        file: entry.file,
+        chunk: entry.chunk,
+        text: entry.text,
+        score,
+    }));
+}

package/dist/index/store.js

@@ -0,0 +1,95 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { embed } from './embeddings.js';
+export class VectorStore {
+    file;
+    data = { model: 'text-embedding-3-small', createdAt: '', entries: [] };
+    norms = new Map();
+    constructor(file) {
+        this.file = file;
+    }
+    get index() {
+        return this.data;
+    }
+    get entries() {
+        return this.data.entries;
+    }
+    load() {
+        if (!fs.existsSync(this.file)) {
+            this.data = { model: 'text-embedding-3-small', createdAt: '', entries: [] };
+            this.rebuildNorms();
+            return this.data;
+        }
+        const raw = fs.readFileSync(this.file, 'utf8');
+        const parsed = JSON.parse(raw);
+        this.data = {
+            model: parsed.model || 'text-embedding-3-small',
+            createdAt: parsed.createdAt || '',
+            entries: Array.isArray(parsed.entries) ? parsed.entries : [],
+        };
+        this.rebuildNorms();
+        return this.data;
+    }
+    save() {
+        fs.mkdirSync(path.dirname(this.file), { recursive: true });
+        this.data.createdAt = new Date().toISOString();
+        fs.writeFileSync(this.file, JSON.stringify(this.data, null, 2), 'utf8');
+    }
+    addAll(entries) {
+        const byId = new Map(this.data.entries.map((entry) => [entry.id, entry]));
+        for (const entry of entries) {
+            byId.set(entry.id, entry);
+            this.norms.set(entry.id, norm(entry.vector));
+        }
+        this.data.entries = [...byId.values()];
+        this.rebuildNorms();
+    }
+    replaceAll(entries) {
+        this.data.entries = [...entries];
+        this.rebuildNorms();
+    }
+    search(queryVec, topK = 8) {
+        const queryNorm = norm(queryVec);
+        return this.data.entries
+            .map((entry) => ({
+            entry,
+            score: cosine(queryVec, queryNorm, entry.vector, this.norms.get(entry.id) ?? norm(entry.vector)),
+        }))
+            .sort((a, b) => b.score - a.score)
+            .slice(0, topK);
+    }
+    rebuildNorms() {
+        this.norms = new Map(this.data.entries.map((entry) => [entry.id, norm(entry.vector)]));
+    }
+}
+function norm(vector) {
+    return Math.sqrt(vector.reduce((sum, value) => sum + value * value, 0));
+}
+function cosine(a, aNorm, b, bNorm) {
+    if (!aNorm || !bNorm)
+        return 0;
+    const len = Math.min(a.length, b.length);
+    let dot = 0;
+    for (let i = 0; i < len; i++)
+        dot += a[i] * b[i];
+    return dot / (aNorm * bNorm);
+}
+export async function searchIndex(cwd, query, topK = 6) {
+    const indexPath = path.join(cwd, '.icopilot', 'index.json');
+    if (!fs.existsSync(indexPath)) {
+        const error = new Error('No index found');
+        error.code = 'ENOENT';
+        throw error;
+    }
+    const store = new VectorStore(indexPath);
+    store.load();
+    const [queryVec] = await embed([query]);
+    if (!queryVec)
+        return [];
+    return store.search(queryVec, topK).map(({ entry, score }) => ({
+        file: entry.file,
+        chunk: entry.chunk,
+        text: entry.text,
+        score,
+    }));
+}