@anirudh242/contextbridge 0.1.0

package/README.md

@@ -0,0 +1,62 @@
+# ContextBridge
+
+Git-style version control for your AI session context. Works across every coding tool you use.
+
+[![npm version](https://img.shields.io/npm/v/contextbridge.svg)](https://npmjs.org/package/contextbridge) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## The Problem
+
+Working with AI assistants involves constantly running into context limits or losing the thread when switching between tools. Every time you start a new conversation, you have to painstakingly rebuild the project's current state and goals.
+
+## The Solution
+
+ContextBridge captures your exact working state (git diffs, active tasks, blockers) and compresses it into an LLM-generated summary. You can then instantly inject that context into any agent or browser-based AI tool.
+
+```bash
+cb init          # set up once per project
+cb capture       # after any AI session — auto-reads your git diff
+cb inject        # before starting a new session — injects context everywhere
+```
+
+## Installation
+
+**Prerequisite:** Node.js >= 18
+
+```bash
+npm install -g contextbridge
+# or run without installing:
+npx contextbridge init
+```
+
+## Core Commands
+
+- `cb capture` - Analyzes your `git diff` and summarizes the current session context. Add `-m "note"` to manually steer the summary, or `--paste` to include clipboard content.
+- `cb inject` - Injects the latest trusted context into your AI tools.
+- `cb log` - View the version history of your project's captured sessions.
+- `cb status` - Show the current ContextBridge status and configuration for this project.
+
+## Provider Setup
+
+ContextBridge works best with an LLM for summarisation. `cb init` will walk you through the initial setup.
+
+| Provider    | Model used                  | Note                                                |
+| ----------- | --------------------------- | --------------------------------------------------- |
+| `anthropic` | `claude-haiku-4-5-20251001` | Recommended. Fast and highly accurate.              |
+| `openai`    | `gpt-4o-mini`               | Good alternative.                                   |
+| `gemini`    | `gemini-2.0-flash`          | Google's high-speed option.                         |
+| `ollama`    | `qwen2.5-coder:7b`          | Free and completely private. Requires local Ollama. |
+
+_You can change your active provider at any time by running `cb provider`._
+_If you are using Ollama, you can configure the timeout limit by running `cb timeout <ms>`._
+
+## Tool-Specific Injection
+
+What happens when you run `cb inject`:
+
+- **Antigravity:** `AGENTS.md` is written automatically to your project root. Antigravity reads it on every agent task. Nothing else needed.
+- **Codex:** `cb inject --codex | codex exec -` pipes context directly into a new session.
+- **Browser tools (Claude, ChatGPT, Gemini):** Context is copied to your clipboard automatically. Paste it at the start of your conversation.
+
+## Privacy & Storage
+
+All context and configuration are stored locally in `~/.contextbridge/` on your machine. When using a cloud provider, only the LLM summary request is sent — not your raw git diff or clipboard content. When using Ollama, no data leaves your machine.

package/dist/commands/capture.js

@@ -0,0 +1,160 @@
+import clipboard from 'clipboardy';
+import { randomUUID } from 'node:crypto';
+import ora from 'ora';
+import { loadConfig } from '../lib/config.js';
+import { addEntryToProjectStore, ensureProjectStore } from '../lib/store.js';
+import { getCurrentBranch, getGitContext } from '../lib/git.js';
+import { summariseContent } from '../lib/llm.js';
+import { buildProjectGrounding } from '../lib/project.js';
+import { formatSummaryLines, printSuccess, printWarning } from '../utils/display.js';
+function hasContent(value) {
+    return value.trim().length > 0;
+}
+function buildRawContent(raw) {
+    const parts = [];
+    if (hasContent(raw.note)) {
+        parts.push(`Manual note:\n${raw.note}`);
+    }
+    if (hasContent(raw.clipboard)) {
+        parts.push(`Clipboard:\n${raw.clipboard}`);
+    }
+    if (hasContent(raw.repoGrounding)) {
+        parts.push(raw.repoGrounding);
+    }
+    if (hasContent(raw.gitLog)) {
+        parts.push(`Git log:\n${raw.gitLog}`);
+    }
+    if (hasContent(raw.gitStatus)) {
+        parts.push(`Git status:\n${raw.gitStatus}`);
+    }
+    if (hasContent(raw.gitDiff)) {
+        parts.push(`Git diff:\n${raw.gitDiff}`);
+    }
+    return parts.join('\n\n');
+}
+function extractStackHint(repoGrounding) {
+    const match = repoGrounding.match(/dependencies:\s*(.+)/i);
+    return match?.[1]?.trim() || 'Unknown';
+}
+function extractLabeledValue(note, label, stopLabels) {
+    const escapedLabel = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedStops = stopLabels.map((item) => item.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    const pattern = new RegExp(`${escapedLabel}\\s*:\\s*([\\s\\S]*?)(?=\\s+(?:${escapedStops.join('|')})\\s*:|$)`, 'i');
+    return note.match(pattern)?.[1]?.trim() ?? '';
+}
+function splitList(value) {
+    return value
+        .split(/;|\n/)
+        .map((item) => item.replace(/^[-*]\s*/, '').trim())
+        .filter(Boolean)
+        .slice(0, 3);
+}
+function buildManualSummary(note, repoGrounding) {
+    const labels = ['Project goal', 'Current direction', 'Current focus', 'Decisions', 'Blockers', 'Next steps'];
+    const projectGoal = extractLabeledValue(note, 'Project goal', labels)
+        || note.split(/current direction:/i)[0]?.trim()
+        || 'Unknown';
+    const currentDirection = extractLabeledValue(note, 'Current direction', labels)
+        || note.split(/current direction:/i)[1]?.trim()
+        || note.trim();
+    const currentFocus = extractLabeledValue(note, 'Current focus', labels) || currentDirection;
+    const decisions = splitList(extractLabeledValue(note, 'Decisions', labels));
+    const blockers = splitList(extractLabeledValue(note, 'Blockers', labels));
+    const nextSteps = splitList(extractLabeledValue(note, 'Next steps', labels));
+    return {
+        projectGoal,
+        currentDirection,
+        currentFocus,
+        decisions,
+        blockers: blockers.length > 0 ? blockers : ['None'],
+        stack: extractStackHint(repoGrounding),
+        nextSteps,
+    };
+}
+function shouldUseManualSummary(raw) {
+    return hasContent(raw.note) && !hasContent(raw.clipboard);
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function registerCaptureCommand(program) {
+    program
+        .command('capture')
+        .description('Capture the latest session context')
+        .option('--paste', 'Read clipboard content as an additional capture source')
+        .option('-m, --message <text>', 'Add a quick manual note')
+        .action(async (options) => {
+        const spinner = ora('Capturing session...').start();
+        const projectPath = process.cwd();
+        try {
+            const config = await loadConfig();
+            await ensureProjectStore(projectPath);
+            const gitContext = await getGitContext(projectPath);
+            const repoGrounding = await buildProjectGrounding(projectPath);
+            const raw = {
+                gitDiff: gitContext.diff ?? '',
+                gitLog: gitContext.log ?? '',
+                gitStatus: gitContext.status ?? '',
+                repoGrounding,
+                clipboard: '',
+                note: options.message ?? '',
+            };
+            if (options.paste) {
+                try {
+                    raw.clipboard = await clipboard.read();
+                }
+                catch {
+                    spinner.warn('Clipboard read failed. Continuing without clipboard content.');
+                    spinner.start('Capturing session...');
+                }
+            }
+            const warnings = [...gitContext.warnings];
+            const content = buildRawContent(raw);
+            const sources = [raw.gitDiff, raw.gitLog, raw.gitStatus, raw.repoGrounding, raw.clipboard, raw.note].filter(hasContent);
+            if (sources.length === 0) {
+                spinner.fail('Nothing to capture. Add a note, copy context, or make code changes first.');
+                return;
+            }
+            let summary = null;
+            if (shouldUseManualSummary(raw)) {
+                summary = buildManualSummary(raw.note, raw.repoGrounding);
+                spinner.succeed('Captured manual note as the primary direction signal.');
+            }
+            else {
+                try {
+                    summary = await summariseContent(content, config);
+                    spinner.succeed('Session captured and summarised.');
+                }
+                catch (error) {
+                    const message = getErrorMessage(error);
+                    spinner.warn(`Summarisation failed: ${message}`);
+                    warnings.push(`Summarisation failed: ${message}`);
+                    if (shouldUseManualSummary(raw)) {
+                        summary = buildManualSummary(raw.note, raw.repoGrounding);
+                        warnings.push('Fell back to the manual note because summarisation was not trustworthy.');
+                    }
+                }
+            }
+            const entry = {
+                id: randomUUID(),
+                timestamp: new Date().toISOString(),
+                branch: (await getCurrentBranch(projectPath)) ?? 'unknown',
+                summary,
+            };
+            await addEntryToProjectStore(projectPath, entry, raw);
+            if (summary) {
+                printSuccess('Context saved', formatSummaryLines(summary));
+            }
+            else {
+                printWarning('Raw context saved without summary.');
+            }
+            for (const warning of warnings) {
+                printWarning(warning);
+            }
+        }
+        catch (error) {
+            spinner.fail(`Capture failed: ${getErrorMessage(error)}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/init.js

@@ -0,0 +1,83 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { ensureConfig, getConfigPath, registerProjectInConfig, setProvider, } from '../lib/config.js';
+import { ensureProjectStore, getStorePath } from '../lib/store.js';
+import { isGitRepository } from '../lib/git.js';
+import { printInfo, printSuccess, printWarning } from '../utils/display.js';
+function getErrorCode(error) {
+    return error instanceof Error && 'code' in error
+        ? String(error.code)
+        : undefined;
+}
+async function ensureAgentsGitignore(projectPath) {
+    const gitignorePath = path.join(projectPath, '.gitignore');
+    try {
+        const existing = await fs.readFile(gitignorePath, 'utf8');
+        if (!existing.split('\n').map((line) => line.trim()).includes('AGENTS.md')) {
+            const prefix = existing.endsWith('\n') || existing.length === 0 ? '' : '\n';
+            await fs.writeFile(gitignorePath, `${existing}${prefix}AGENTS.md\n`, 'utf8');
+        }
+        return true;
+    }
+    catch (error) {
+        if (getErrorCode(error) === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+export function registerInitCommand(program) {
+    program
+        .command('init')
+        .description('Initialise ContextBridge for the current project')
+        .action(async () => {
+        const projectPath = process.cwd();
+        const projectName = path.basename(projectPath);
+        const gitRepo = await isGitRepository(projectPath);
+        if (!gitRepo) {
+            printWarning('No git repository detected in the current directory. Git capture will degrade gracefully.');
+        }
+        console.log('\nContextBridge works best with an LLM for summarisation.\n');
+        console.log('  [1] Anthropic (Claude Haiku) — recommended, fast, accurate');
+        console.log('  [2] OpenAI (GPT-4o Mini) — good alternative');
+        console.log('  [3] Gemini (Gemini Flash) — Google\'s option');
+        console.log('  [4] Ollama (local) — private, no API key needed, requires Ollama installed\n');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const choice = await rl.question('Choose a provider [1-4, default: 4]: ');
+        let providerName = 'ollama';
+        let apiKey;
+        if (choice.trim() === '1') {
+            providerName = 'anthropic';
+            apiKey = await rl.question('Enter your Anthropic API key: ');
+        }
+        else if (choice.trim() === '2') {
+            providerName = 'openai';
+            apiKey = await rl.question('Enter your OpenAI API key: ');
+        }
+        else if (choice.trim() === '3') {
+            providerName = 'gemini';
+            apiKey = await rl.question('Enter your Gemini API key: ');
+        }
+        rl.close();
+        await setProvider({ provider: providerName, apiKey: apiKey?.trim() || undefined });
+        const config = await ensureConfig();
+        await registerProjectInConfig(projectName, projectPath);
+        await ensureProjectStore(projectPath, projectName);
+        const gitignoreUpdated = await ensureAgentsGitignore(projectPath);
+        printSuccess('ContextBridge initialised', [
+            `Project: ${projectName}`,
+            `Config: ${getConfigPath()}`,
+            `Store: ${getStorePath()}`,
+            `Provider: ${config.provider}`,
+            'Next: cb capture, then cb inject',
+            `AGENTS.md gitignored: ${gitignoreUpdated ? 'yes' : 'no .gitignore found'}`,
+        ]);
+        if (config.provider === 'ollama') {
+            printInfo('Make sure Ollama is running before you use `cb capture`. Start it with: ollama serve');
+        }
+    });
+}

package/dist/commands/inject.js

@@ -0,0 +1,63 @@
+import clipboard from 'clipboardy';
+import path from 'node:path';
+import { getHeadEntry, getProjectStore } from '../lib/store.js';
+import { formatContextForInjection, writeAgentsFile } from '../lib/inject.js';
+import { printSuccess, printWarning } from '../utils/display.js';
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function registerInjectCommand(program) {
+    program
+        .command('inject')
+        .description('Inject the latest captured context into your next AI tool')
+        .option('--codex', 'Output raw context to stdout for piping into codex exec -')
+        .option('--no-agents-md', 'Skip writing AGENTS.md')
+        .option('--clip-only', 'Only copy to clipboard')
+        .action(async (options) => {
+        try {
+            const projectPath = process.cwd();
+            const projectName = path.basename(projectPath);
+            const project = await getProjectStore(projectPath);
+            const entry = await getHeadEntry(projectPath);
+            if (!entry) {
+                printWarning('No captured context found for this project. Run `cb capture` first.');
+                return;
+            }
+            const output = await formatContextForInjection({
+                projectName,
+                entry,
+                entries: project?.entries,
+            });
+            const actions = [];
+            const shouldWriteAgents = !options.clipOnly && options.agentsMd !== false;
+            if (shouldWriteAgents) {
+                const agentsPath = await writeAgentsFile(projectPath, output);
+                actions.push(`AGENTS.md written: ${agentsPath}`);
+            }
+            try {
+                await clipboard.write(output);
+                actions.push('Clipboard updated');
+            }
+            catch (error) {
+                actions.push(`Clipboard skipped: ${getErrorMessage(error)}`);
+            }
+            if (options.codex) {
+                process.stdout.write(output);
+            }
+            const confirmation = [
+                ...actions,
+                'Paste the copied context into browser-based tools as needed.',
+            ];
+            if (options.codex) {
+                console.error(confirmation.join('\n'));
+            }
+            else {
+                printSuccess('Context injected', confirmation);
+            }
+        }
+        catch (error) {
+            printWarning(`Inject failed: ${getErrorMessage(error)}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/log.js

@@ -0,0 +1,38 @@
+import { getProjectStore } from '../lib/store.js';
+import { formatRelativeTime, printPanel, printWarning } from '../utils/display.js';
+export function registerLogCommand(program) {
+    program
+        .command('log')
+        .description('Show version history for captured sessions')
+        .option('--limit <number>', 'Show the last N entries', '10')
+        .option('--branch <name>', 'Filter entries by git branch')
+        .action(async (options) => {
+        const projectPath = process.cwd();
+        const project = await getProjectStore(projectPath);
+        if (!project || project.entries.length === 0) {
+            printWarning('No captured sessions found for this project.');
+            return;
+        }
+        const limit = Number.parseInt(options.limit ?? '10', 10);
+        const filtered = project.entries
+            .filter((entry) => !options.branch || entry.branch === options.branch)
+            .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
+            .slice(0, Number.isNaN(limit) ? 10 : limit);
+        if (filtered.length === 0) {
+            printWarning('No captured sessions match the selected filters.');
+            return;
+        }
+        filtered.forEach((entry, index) => {
+            const summary = entry.summary;
+            const task = summary?.currentFocus ?? 'Unknown';
+            const lines = [
+                `#${index + 1}  ${entry.branch ?? 'unknown'}  ${formatRelativeTime(entry.timestamp)}`,
+                `Focus: ${task}`,
+                `Direction: ${summary?.currentDirection || 'Unknown'}`,
+                `Decisions: ${summary?.decisions.slice(0, 3).join(' | ') || 'Unknown'}`,
+                `Next steps: ${summary?.nextSteps.slice(0, 3).join(' | ') || 'Unknown'}`,
+            ];
+            printPanel(lines.join('\n'));
+        });
+    });
+}

package/dist/commands/provider.js

@@ -0,0 +1,49 @@
+import readline from 'node:readline/promises';
+import { setProvider } from '../lib/config.js';
+import { printSuccess, printWarning } from '../utils/display.js';
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function registerProviderCommand(program) {
+    program
+        .command('provider')
+        .description('Change the LLM provider for summarisation')
+        .action(async () => {
+        try {
+            console.log('\nContextBridge works best with an LLM for summarisation.\n');
+            console.log('  [1] Anthropic (Claude Haiku) — recommended, fast, accurate');
+            console.log('  [2] OpenAI (GPT-4o Mini) — good alternative');
+            console.log("  [3] Gemini (Gemini Flash) — Google's option");
+            console.log('  [4] Ollama (local) — private, no API key needed, requires Ollama installed\n');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const choice = await rl.question('Choose a provider [1-4, default: 4]: ');
+            let providerName = 'ollama';
+            let apiKey;
+            if (choice.trim() === '1') {
+                providerName = 'anthropic';
+                apiKey = await rl.question('Enter your Anthropic API key: ');
+            }
+            else if (choice.trim() === '2') {
+                providerName = 'openai';
+                apiKey = await rl.question('Enter your OpenAI API key: ');
+            }
+            else if (choice.trim() === '3') {
+                providerName = 'gemini';
+                apiKey = await rl.question('Enter your Gemini API key: ');
+            }
+            rl.close();
+            const config = await setProvider({
+                provider: providerName,
+                apiKey: apiKey?.trim() || undefined,
+            });
+            printSuccess('Provider updated', [`New provider: ${config.provider}`]);
+        }
+        catch (error) {
+            printWarning(`Provider update failed: ${getErrorMessage(error)}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/status.js

@@ -0,0 +1,44 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { loadConfig } from '../lib/config.js';
+import { getCurrentBranch } from '../lib/git.js';
+import { getHeadEntry, getProjectStore } from '../lib/store.js';
+import { formatRelativeTime, printInfoPanel } from '../utils/display.js';
+function formatTimeout(timeoutMs) {
+    return timeoutMs === null ? 'none' : `${timeoutMs}ms`;
+}
+export function registerStatusCommand(program) {
+    program
+        .command('status')
+        .description('Show the current ContextBridge status for this project')
+        .action(async () => {
+        const projectPath = process.cwd();
+        const projectName = path.basename(projectPath);
+        const config = await loadConfig();
+        const project = await getProjectStore(projectPath);
+        const entry = await getHeadEntry(projectPath);
+        const branch = await getCurrentBranch(projectPath);
+        let agentsPresent = false;
+        try {
+            await fs.access(path.join(projectPath, 'AGENTS.md'));
+            agentsPresent = true;
+        }
+        catch {
+            agentsPresent = false;
+        }
+        printInfoPanel('ContextBridge Status', [
+            `Project: ${projectName}`,
+            `Branch: ${branch ?? 'unknown'}`,
+            `Current focus: ${entry?.summary?.currentFocus ?? 'Unknown'}`,
+            `Last captured: ${entry ? formatRelativeTime(entry.timestamp) : 'Never'}`,
+            `Total sessions: ${project?.entries.length ?? 0}`,
+            `AGENTS.md: ${agentsPresent ? 'present' : 'missing'}`,
+            `LLM provider: ${config.provider}`,
+            `Model: ${config.model ?? 'default'}`,
+            ...(config.provider === 'ollama' ? [
+                `Ollama URL: ${config.baseUrl ?? 'http://127.0.0.1:11434'}`,
+                `Ollama timeout: ${formatTimeout(config.ollamaTimeoutMs)}`,
+            ] : []),
+        ]);
+    });
+}

package/dist/commands/timeout.js

@@ -0,0 +1,50 @@
+import { loadConfig, setTimeout } from '../lib/config.js';
+import { printInfoPanel, printSuccess, printWarning } from '../utils/display.js';
+function formatTimeout(timeoutMs) {
+    return timeoutMs === null ? 'none' : `${timeoutMs}ms`;
+}
+function parseTimeout(input) {
+    const normalised = input.trim().toLowerCase();
+    if (normalised === 'none' || normalised === 'off' || normalised === 'disabled') {
+        return null;
+    }
+    const parsed = Number.parseInt(normalised, 10);
+    if (Number.isNaN(parsed) || parsed <= 0) {
+        throw new Error('Timeout must be a positive number of milliseconds or `none`.');
+    }
+    return parsed;
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function registerTimeoutCommand(program) {
+    program
+        .command('timeout')
+        .description('Show or set the Ollama summarisation timeout (Ollama provider only)')
+        .argument('[value]', 'Timeout in milliseconds, or `none` to disable the timeout entirely')
+        .action(async (value) => {
+        try {
+            const config = await loadConfig();
+            if (config.provider !== 'ollama') {
+                printWarning('Timeout settings only apply when the Ollama provider is active.');
+                return;
+            }
+            if (!value) {
+                printInfoPanel('Ollama Timeout', [
+                    `Current timeout: ${formatTimeout(config.ollamaTimeoutMs)}`,
+                    'Set a new value with `cb timeout <milliseconds>` or disable it with `cb timeout none`.',
+                ]);
+                return;
+            }
+            const timeoutMs = parseTimeout(value);
+            const updatedConfig = await setTimeout(timeoutMs);
+            printSuccess('Timeout updated', [
+                `Ollama timeout: ${formatTimeout(updatedConfig.ollamaTimeoutMs)}`,
+            ]);
+        }
+        catch (error) {
+            printWarning(`Timeout update failed: ${getErrorMessage(error)}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerInitCommand } from './commands/init.js';
+import { registerCaptureCommand } from './commands/capture.js';
+import { registerInjectCommand } from './commands/inject.js';
+import { registerLogCommand } from './commands/log.js';
+import { registerStatusCommand } from './commands/status.js';
+import { registerTimeoutCommand } from './commands/timeout.js';
+import { registerProviderCommand } from './commands/provider.js';
+const program = new Command();
+program
+    .name('cb')
+    .description('Persistent, versioned AI project context for every coding tool you use.')
+    .version('0.1.0');
+registerInitCommand(program);
+registerCaptureCommand(program);
+registerInjectCommand(program);
+registerLogCommand(program);
+registerStatusCommand(program);
+registerTimeoutCommand(program);
+registerProviderCommand(program);
+program.parseAsync(process.argv).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`ContextBridge failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/lib/config.js

@@ -0,0 +1,75 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+const CONFIG_DIR = path.join(os.homedir(), '.contextbridge');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+const DEFAULT_CONFIG = {
+    provider: 'ollama',
+    ollamaTimeoutMs: 120000,
+    projects: {},
+};
+function getErrorCode(error) {
+    return error instanceof Error && 'code' in error
+        ? String(error.code)
+        : undefined;
+}
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+export function getConfigPath() {
+    return CONFIG_PATH;
+}
+export async function saveConfig(config) {
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+    await fs.writeFile(CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+}
+export async function ensureConfig() {
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+    try {
+        const existing = await fs.readFile(CONFIG_PATH, 'utf8');
+        const parsed = JSON.parse(existing);
+        const merged = {
+            ...DEFAULT_CONFIG,
+            ...parsed,
+            projects: {
+                ...DEFAULT_CONFIG.projects,
+                ...(parsed.projects ?? {}),
+            },
+        };
+        if (JSON.stringify(merged) !== JSON.stringify(parsed)) {
+            await saveConfig(merged);
+        }
+        return merged;
+    }
+    catch (error) {
+        if (getErrorCode(error) !== 'ENOENT') {
+            throw error;
+        }
+        await saveConfig(DEFAULT_CONFIG);
+        return DEFAULT_CONFIG;
+    }
+}
+export async function loadConfig() {
+    return ensureConfig();
+}
+export async function registerProjectInConfig(projectName, projectPath) {
+    const config = await ensureConfig();
+    config.projects[projectName] = projectPath;
+    await saveConfig(config);
+    return config;
+}
+export async function setProvider(providerConfig) {
+    const config = await ensureConfig();
+    config.provider = providerConfig.provider;
+    config.apiKey = providerConfig.apiKey;
+    config.model = providerConfig.model;
+    config.baseUrl = providerConfig.baseUrl;
+    await saveConfig(config);
+    return config;
+}
+export async function setTimeout(timeoutMs) {
+    const config = await ensureConfig();
+    config.ollamaTimeoutMs = timeoutMs;
+    await saveConfig(config);
+    return config;
+}