@aakrit512/gatekeep 1.0.0

package/dist/ui/server.js

@@ -0,0 +1,523 @@
+import 'dotenv/config';
+import { execFile, spawn } from 'child_process';
+import * as fs from 'fs';
+import * as http from 'http';
+import * as path from 'path';
+import { pathToFileURL } from 'url';
+import { cleanString, configureApp, DEFAULT_BASE_URL, DEFAULT_MODEL, DEFAULT_PROVIDER, } from '../config.js';
+import { getConfigPath, readUserConfig, resolveConfig, writeUserConfig } from '../cli/configStore.js';
+import { maskSecret, validateConfig, validateNodeRuntime, validateProject } from '../cli/validation.js';
+import { clearChatMessages, deleteProject, getChatMessages, getDatabasePath, getProjectByName, getRecentProjects, saveChatMessage, updateChatMessage, upsertProject, } from './projectDb.js';
+import { initializeProject, resetProjectSession, sendChatMessage } from './webAgent.js';
+const WEB_FEATURES = [
+    { id: 'init', name: 'Initialize project', description: 'Save project metadata in SQLite and create docs/intro.md.' },
+    { id: 'config', name: 'Config', description: 'View and update provider, model, API key, and base URL.' },
+    { id: 'doctor', name: 'Doctor', description: 'Check Node, provider config, and project path readiness.' },
+    { id: 'run', name: 'Chat review loop', description: 'Ask code review and project questions with file, diff, and directory tools.' },
+];
+const CURATED_OPENAI_MODELS = [
+    'gpt-5.5',
+    'gpt-5.4',
+    'gpt-5.4-mini',
+    'gpt-5',
+    'gpt-4.1',
+    'gpt-4o',
+];
+function jsonResponse(res, status, payload) {
+    const body = JSON.stringify(payload);
+    res.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': Buffer.byteLength(body),
+    });
+    res.end(body);
+}
+function htmlResponse(res, body) {
+    res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+    res.end(body);
+}
+function sseResponse(res) {
+    res.writeHead(200, {
+        'content-type': 'text/event-stream; charset=utf-8',
+        'cache-control': 'no-cache, no-transform',
+        connection: 'keep-alive',
+        'x-accel-buffering': 'no',
+    });
+}
+function writeSse(res, event, payload) {
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(payload)}\n\n`);
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let raw = '';
+        req.setEncoding('utf-8');
+        req.on('data', (chunk) => {
+            raw += chunk;
+            if (raw.length > 1_000_000) {
+                req.destroy(new Error('Request body is too large.'));
+            }
+        });
+        req.on('end', () => {
+            if (!raw.trim()) {
+                resolve({});
+                return;
+            }
+            try {
+                const parsed = JSON.parse(raw);
+                resolve(parsed && typeof parsed === 'object' ? parsed : {});
+            }
+            catch {
+                reject(new Error('Request body must be valid JSON.'));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+function getString(body, key) {
+    const value = body[key];
+    return typeof value === 'string' ? value.trim() : '';
+}
+function publicConfig(config) {
+    return {
+        provider: config.provider,
+        apiKey: maskSecret(config.apiKey),
+        hasApiKey: Boolean(config.apiKey),
+        model: config.model,
+        baseUrl: config.baseUrl,
+    };
+}
+function resolveProjectPath(bodyPath, fallbackProject) {
+    return path.resolve(cleanString(bodyPath) || fallbackProject || process.cwd());
+}
+function explicitProjectPath(body) {
+    const projectPath = cleanString(getString(body, 'projectPath'));
+    return projectPath ? path.resolve(projectPath) : undefined;
+}
+function doctor(project, config = resolveConfig({})) {
+    return [
+        ...validateNodeRuntime(),
+        ...validateConfig(config),
+        ...validateProject(project),
+    ];
+}
+function buildConfigFromBody(body) {
+    const stored = readUserConfig();
+    return {
+        provider: DEFAULT_PROVIDER,
+        apiKey: cleanString(getString(body, 'apiKey')) || cleanString(stored.apiKey) || cleanString(process.env.AI_API_KEY) || '',
+        model: cleanString(getString(body, 'model')) || cleanString(stored.model) || cleanString(process.env.MODEL_NAME) || DEFAULT_MODEL,
+        baseUrl: cleanString(getString(body, 'baseUrl')) || cleanString(stored.baseUrl) || cleanString(process.env.AI_BASE_URL) || DEFAULT_BASE_URL,
+    };
+}
+function uniqueStrings(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function modelListUrl(baseUrl) {
+    const normalized = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+    return new URL('models', normalized).toString();
+}
+async function listModels(config) {
+    const fallback = uniqueStrings([config.model, ...CURATED_OPENAI_MODELS]);
+    if (!config.apiKey.trim()) {
+        return { models: fallback, source: 'fallback', warning: 'Add an API key to load account models.' };
+    }
+    const response = await fetch(modelListUrl(config.baseUrl), {
+        headers: {
+            authorization: `Bearer ${config.apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        return {
+            models: fallback,
+            source: 'fallback',
+            warning: `Could not load models (${response.status}).`,
+        };
+    }
+    const body = await response.json();
+    const available = new Set((body.data || []).map((model) => typeof model.id === 'string' ? model.id : '').filter(Boolean));
+    const models = uniqueStrings([
+        config.model,
+        ...CURATED_OPENAI_MODELS.filter((model) => available.has(model)),
+    ]);
+    return { models: models.length ? models : fallback, source: 'api' };
+}
+function pickDirectory() {
+    return new Promise((resolve, reject) => {
+        if (process.platform === 'darwin') {
+            execFile('osascript', [
+                '-e',
+                'POSIX path of (choose folder with prompt "Choose a project directory")',
+            ], { timeout: 120_000 }, (error, stdout) => {
+                if (error) {
+                    reject(new Error('Directory selection was cancelled.'));
+                    return;
+                }
+                resolve(stdout.trim().replace(/\/$/, ''));
+            });
+            return;
+        }
+        reject(new Error('Folder picker is currently available on macOS. Paste the project path instead.'));
+    });
+}
+function projectHref(project) {
+    return `/${encodeURIComponent(project.name)}`;
+}
+function projectPayload(project) {
+    return {
+        ...project,
+        href: projectHref(project),
+    };
+}
+function readIntroMarkdown(projectPath) {
+    const introPath = path.join(projectPath, 'docs', 'intro.md');
+    if (!fs.existsSync(introPath))
+        return '';
+    return fs.readFileSync(introPath, 'utf-8').trim();
+}
+function resolveProjectByRouteName(rawName) {
+    return getProjectByName(decodeURIComponent(rawName));
+}
+function splitProjectRoute(pathname) {
+    const match = pathname.match(/^\/api\/projects\/([^/]+)(?:\/([^/]+))?$/);
+    if (!match)
+        return undefined;
+    return {
+        name: match[1],
+        action: match[2] || '',
+    };
+}
+function estimateCost(model, promptTokens, completionTokens) {
+    const pricing = {
+        'gpt-4o': { input: 2.5, output: 10 },
+        'gpt-4o-mini': { input: 0.15, output: 0.6 },
+        'gpt-4.1': { input: 2, output: 8 },
+        'gpt-4.1-mini': { input: 0.4, output: 1.6 },
+        'gpt-4.1-nano': { input: 0.1, output: 0.4 },
+        'gpt-5': { input: 1.25, output: 10 },
+        'gpt-5.4': { input: 1.25, output: 10 },
+        'gpt-5.4-mini': { input: 0.25, output: 2 },
+        'gpt-5.5': { input: 1.25, output: 10 },
+        'gpt-5-mini': { input: 0.25, output: 2 },
+        'gpt-5-nano': { input: 0.05, output: 0.4 },
+    };
+    const price = pricing[model.toLowerCase()];
+    if (!price)
+        return undefined;
+    return ((promptTokens / 1_000_000) * price.input) + ((completionTokens / 1_000_000) * price.output);
+}
+const UI_TEMPLATE_PATH = new URL('../../ui/app.html', import.meta.url);
+let uiTemplateCache;
+function appHtml() {
+    uiTemplateCache ??= fs.readFileSync(UI_TEMPLATE_PATH, 'utf-8');
+    return uiTemplateCache.replace('__FALLBACK_MODELS__', JSON.stringify(CURATED_OPENAI_MODELS));
+}
+async function streamChat(res, project, body) {
+    const config = buildConfigFromBody(body);
+    const errors = doctor(project.path, config);
+    if (errors.length > 0) {
+        jsonResponse(res, 400, { error: errors.join('\n'), errors });
+        return;
+    }
+    const message = getString(body, 'message');
+    if (!message) {
+        jsonResponse(res, 400, { error: 'Message is required.' });
+        return;
+    }
+    writeUserConfig(config);
+    configureApp(config);
+    upsertProject(project.path, config);
+    saveChatMessage(project.id, 'user', message);
+    const turnUsage = {
+        model: config.model,
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0,
+        estimatedCost: undefined,
+    };
+    const activity = [{
+            type: 'status',
+            label: 'thinking',
+            detail: 'reading project context',
+        }];
+    const assistantMessageId = saveChatMessage(project.id, 'assistant', '', {
+        model: turnUsage.model,
+        activity,
+    });
+    const persistAssistantTurn = (content = assistantMessage) => {
+        updateChatMessage(assistantMessageId, content, {
+            model: turnUsage.model,
+            promptTokens: turnUsage.promptTokens,
+            completionTokens: turnUsage.completionTokens,
+            totalTokens: turnUsage.totalTokens,
+            estimatedCost: turnUsage.estimatedCost,
+            activity,
+        });
+    };
+    sseResponse(res);
+    writeSse(res, 'status', { type: 'status', message: 'reading project context' });
+    let assistantMessage = '';
+    try {
+        const events = await sendChatMessage(project.path, message, (event) => {
+            if (event.type === 'assistant') {
+                assistantMessage = event.message;
+                persistAssistantTurn();
+                return;
+            }
+            if (event.type === 'usage') {
+                const cost = estimateCost(event.model, event.promptTokens, event.completionTokens);
+                turnUsage.model = event.model;
+                turnUsage.promptTokens += event.promptTokens;
+                turnUsage.completionTokens += event.completionTokens;
+                turnUsage.totalTokens += event.totalTokens;
+                if (typeof cost === 'number') {
+                    turnUsage.estimatedCost = (turnUsage.estimatedCost ?? 0) + cost;
+                }
+                activity.push({
+                    type: 'tokens',
+                    label: 'tokens',
+                    detail: [
+                        `${turnUsage.totalTokens} total`,
+                        `${turnUsage.promptTokens} in`,
+                        `${turnUsage.completionTokens} out`,
+                        typeof turnUsage.estimatedCost === 'number' ? `$${turnUsage.estimatedCost.toFixed(4)}` : undefined,
+                    ].filter(Boolean).join(' · '),
+                });
+                persistAssistantTurn();
+                writeSse(res, 'usage', {
+                    type: 'usage',
+                    model: turnUsage.model,
+                    promptTokens: turnUsage.promptTokens,
+                    completionTokens: turnUsage.completionTokens,
+                    totalTokens: turnUsage.totalTokens,
+                    cost: turnUsage.estimatedCost,
+                });
+                return;
+            }
+            if (event.type === 'status') {
+                activity.push({ type: 'status', label: 'thinking', detail: event.message });
+            }
+            else if (event.type === 'tool_call') {
+                const detail = Object.entries(event.args)
+                    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+                    .slice(0, 3)
+                    .map(([key, value]) => {
+                    const text = typeof value === 'string' ? value : JSON.stringify(value);
+                    return `${key}: ${text.slice(0, 90)}`;
+                })
+                    .join(' · ');
+                activity.push({ type: 'tool_call', label: `tool_call ${event.name}`, detail });
+            }
+            else if (event.type === 'tool') {
+                activity.push({
+                    type: 'tool_result',
+                    label: `tool_result ${event.name}`,
+                    detail: event.summary,
+                    preview: event.preview,
+                    full: event.full,
+                    truncated: event.truncated,
+                });
+            }
+            persistAssistantTurn();
+            writeSse(res, event.type, event);
+        });
+        const assistant = assistantMessage || [...events].reverse().find((event) => event.type === 'assistant')?.message || '';
+        for (const chunk of assistant.match(/.{1,96}(?:\s|$)/gs) || [assistant]) {
+            writeSse(res, 'assistant_delta', { delta: chunk });
+        }
+        if (assistant) {
+            updateChatMessage(assistantMessageId, assistant, {
+                model: turnUsage.model,
+                promptTokens: turnUsage.promptTokens,
+                completionTokens: turnUsage.completionTokens,
+                totalTokens: turnUsage.totalTokens,
+                estimatedCost: turnUsage.estimatedCost,
+                activity,
+            });
+        }
+        writeSse(res, 'done', { ok: true });
+        res.end();
+    }
+    catch (error) {
+        writeSse(res, 'error', { error: error instanceof Error ? error.message : String(error) });
+        res.end();
+    }
+}
+export async function startUiServer(options = {}) {
+    const projectPath = path.resolve(options.project || process.cwd());
+    const port = options.port || Number(process.env.MY_CODING_AGENT_PORT) || 9808;
+    const host = options.host || '127.0.0.1';
+    const server = http.createServer(async (req, res) => {
+        try {
+            const url = new URL(req.url || '/', `http://${req.headers.host || `${host}:${port}`}`);
+            if (req.method === 'GET' && !url.pathname.startsWith('/api/')) {
+                htmlResponse(res, appHtml());
+                return;
+            }
+            if (req.method === 'GET' && url.pathname === '/api/projects') {
+                const config = resolveConfig({});
+                const projects = getRecentProjects().map(projectPayload);
+                jsonResponse(res, 200, {
+                    projectPath,
+                    projects,
+                    config: publicConfig(config),
+                    configPath: getConfigPath(),
+                    databasePath: getDatabasePath(),
+                    features: WEB_FEATURES,
+                });
+                return;
+            }
+            if (req.method === 'GET' && url.pathname === '/api/config') {
+                jsonResponse(res, 200, {
+                    config: publicConfig(resolveConfig({})),
+                    configPath: getConfigPath(),
+                });
+                return;
+            }
+            if (req.method === 'POST' && url.pathname === '/api/models') {
+                const body = await readBody(req);
+                const config = buildConfigFromBody(body);
+                const result = await listModels(config);
+                jsonResponse(res, 200, result);
+                return;
+            }
+            if (req.method === 'POST' && url.pathname === '/api/pick-directory') {
+                const directory = await pickDirectory();
+                jsonResponse(res, 200, { path: directory });
+                return;
+            }
+            if (req.method === 'GET') {
+                const route = splitProjectRoute(url.pathname);
+                if (route && !route.action) {
+                    const project = resolveProjectByRouteName(route.name);
+                    if (!project) {
+                        jsonResponse(res, 404, { error: 'Project not found.' });
+                        return;
+                    }
+                    const config = resolveConfig({});
+                    jsonResponse(res, 200, {
+                        project: projectPayload(project),
+                        projects: getRecentProjects().map(projectPayload),
+                        config: publicConfig(config),
+                        configPath: getConfigPath(),
+                        databasePath: getDatabasePath(),
+                        features: WEB_FEATURES,
+                        messages: getChatMessages(project.id),
+                    });
+                    return;
+                }
+            }
+            if (req.method === 'POST' && url.pathname === '/api/init') {
+                const body = await readBody(req);
+                const targetProject = explicitProjectPath(body);
+                if (!targetProject) {
+                    jsonResponse(res, 400, { error: 'Choose a project directory first.', errors: ['Choose a project directory first.'] });
+                    return;
+                }
+                const config = buildConfigFromBody(body);
+                const errors = [...validateConfig(config), ...validateProject(targetProject)];
+                if (errors.length > 0) {
+                    jsonResponse(res, 400, { error: errors.join('\n'), errors });
+                    return;
+                }
+                writeUserConfig(config);
+                configureApp(config);
+                const project = upsertProject(targetProject, config);
+                const events = await initializeProject(targetProject);
+                const existingMessages = getChatMessages(project.id);
+                const introMarkdown = readIntroMarkdown(targetProject);
+                if (introMarkdown && existingMessages.length === 0) {
+                    saveChatMessage(project.id, 'assistant', introMarkdown, {
+                        activity: [
+                            { type: 'status', label: 'Initialized project', detail: 'Loaded docs/intro.md' },
+                        ],
+                    });
+                }
+                else if (existingMessages.length === 0) {
+                    saveChatMessage(project.id, 'system', 'Project initialized.');
+                }
+                jsonResponse(res, 200, { project: projectPayload(project), events });
+                return;
+            }
+            if ((req.method === 'POST' || req.method === 'PATCH') && url.pathname === '/api/config') {
+                const body = await readBody(req);
+                const config = buildConfigFromBody(body);
+                const errors = validateConfig(config);
+                if (errors.length > 0) {
+                    jsonResponse(res, 400, { error: errors.join('\n'), errors });
+                    return;
+                }
+                writeUserConfig(config);
+                configureApp(config);
+                jsonResponse(res, 200, {
+                    config: publicConfig(config),
+                    configPath: getConfigPath(),
+                });
+                return;
+            }
+            if (req.method === 'POST' && url.pathname === '/api/doctor') {
+                const body = await readBody(req);
+                const targetProject = explicitProjectPath(body);
+                if (!targetProject) {
+                    jsonResponse(res, 200, { errors: ['Choose a project directory first.'] });
+                    return;
+                }
+                const config = buildConfigFromBody(body);
+                jsonResponse(res, 200, { errors: doctor(targetProject, config) });
+                return;
+            }
+            if (req.method === 'POST') {
+                const route = splitProjectRoute(url.pathname);
+                if (route) {
+                    const project = resolveProjectByRouteName(route.name);
+                    if (!project) {
+                        jsonResponse(res, 404, { error: 'Project not found.' });
+                        return;
+                    }
+                    if (route.action === 'open-code') {
+                        const child = spawn('code', [project.path], {
+                            detached: true,
+                            stdio: 'ignore',
+                        });
+                        child.unref();
+                        jsonResponse(res, 200, { ok: true });
+                        return;
+                    }
+                    if (route.action === 'chat-stream') {
+                        const body = await readBody(req);
+                        await streamChat(res, project, body);
+                        return;
+                    }
+                    if (route.action === 'clear-chat') {
+                        const deleted = clearChatMessages(project.id);
+                        resetProjectSession(project.path);
+                        jsonResponse(res, 200, { ok: true, deleted });
+                        return;
+                    }
+                    if (route.action === 'delete') {
+                        const deleted = deleteProject(project.id);
+                        resetProjectSession(project.path);
+                        jsonResponse(res, 200, { ok: true, deleted });
+                        return;
+                    }
+                }
+            }
+            jsonResponse(res, 404, { error: 'Not found.' });
+        }
+        catch (error) {
+            jsonResponse(res, 500, { error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, host, () => {
+            server.off('error', reject);
+            resolve();
+        });
+    });
+    const url = `http://${host}:${port}`;
+    console.log(`Gatekeep UI is running at ${url}`);
+    console.log(`Project: ${projectPath}`);
+    console.log(`SQLite: ${getDatabasePath()}`);
+    console.log(`Open ${pathToFileURL(process.cwd()).href} in your editor and use the browser at ${url}.`);
+    return server;
+}

package/dist/ui/webAgent.js

@@ -0,0 +1,170 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createChatCompletion } from '../ai/chat.js';
+import { getModelName } from '../ai/openAiClient.js';
+import { isFunctionToolCall, runToolCall } from '../functions/toolCallHandler.js';
+import { initializationPrompt, missingIntroNudge } from '../prompts/initializationPrompt.js';
+import { systemMessage } from '../prompts/systemPrompt.js';
+const sessions = new Map();
+function countLines(content) {
+    return content ? content.split('\n').length : 0;
+}
+function summarizeToolResult(name, content) {
+    if (content.startsWith('Error executing tool:'))
+        return content;
+    if (name === 'read_file')
+        return `Read ${countLines(content)} lines`;
+    if (name === 'list_directory')
+        return `Listed ${countLines(content)} entries`;
+    if (name === 'write_file')
+        return content;
+    if (name === 'get_git_diff')
+        return content.includes('None.') ? 'Checked git diff' : 'Found repository changes';
+    return `Returned ${countLines(content)} lines`;
+}
+function previewToolResult(content) {
+    const normalized = content.trim();
+    const lines = normalized ? normalized.split('\n') : [];
+    const maxLines = lines.length > 18 ? Math.max(6, Math.floor(lines.length * 0.4)) : lines.length;
+    const linePreview = lines.slice(0, maxLines).join('\n');
+    const limit = 1200;
+    const preview = linePreview.length > limit ? linePreview.slice(0, limit).trimEnd() : linePreview;
+    const truncated = preview.length < normalized.length;
+    if (!truncated) {
+        return {
+            preview: normalized,
+            full: normalized,
+            truncated: false,
+        };
+    }
+    return {
+        preview,
+        full: normalized,
+        truncated: true,
+    };
+}
+function loadProjectSummary(history, projectSummaryPath) {
+    if (!fs.existsSync(projectSummaryPath))
+        return false;
+    const summary = fs.readFileSync(projectSummaryPath, 'utf-8').trim();
+    if (!summary)
+        return false;
+    history.push({
+        role: 'system',
+        content: [
+            'Project summary loaded from ./docs/intro.md.',
+            'Use this as cached repository context. Refresh it only when the user asks or when code changes make it materially stale.',
+            '',
+            summary,
+        ].join('\n'),
+    });
+    return true;
+}
+function getSession(project) {
+    const resolvedProject = path.resolve(project);
+    const existing = sessions.get(resolvedProject);
+    if (existing)
+        return existing;
+    const history = [systemMessage];
+    const initialized = loadProjectSummary(history, path.join(resolvedProject, 'docs', 'intro.md'));
+    const session = { project: resolvedProject, history, initialized };
+    sessions.set(resolvedProject, session);
+    return session;
+}
+export function resetProjectSession(project) {
+    sessions.delete(path.resolve(project));
+}
+async function pushEvent(events, event, onEvent) {
+    events.push(event);
+    await onEvent?.(event);
+}
+async function runToolLoop(session, events, maxSteps = 12, requireAnswer = true, onEvent) {
+    for (let step = 0; step < maxSteps; step++) {
+        await pushEvent(events, { type: 'status', message: step === 0 ? 'thinking through the request' : 'continuing after tool results' }, onEvent);
+        const response = await createChatCompletion(session.history);
+        const usage = response.usage;
+        if (usage) {
+            await pushEvent(events, {
+                type: 'usage',
+                promptTokens: usage.prompt_tokens ?? 0,
+                completionTokens: usage.completion_tokens ?? 0,
+                totalTokens: usage.total_tokens ?? 0,
+                model: getModelName(),
+            }, onEvent);
+        }
+        const message = response.choices[0]?.message;
+        if (!message) {
+            throw new Error('Provider returned no assistant message.');
+        }
+        session.history.push(message);
+        if (message.tool_calls && message.tool_calls.length > 0) {
+            for (const toolCall of message.tool_calls) {
+                if (!isFunctionToolCall(toolCall)) {
+                    session.history.push({
+                        role: 'tool',
+                        tool_call_id: toolCall.id,
+                        content: 'Unsupported custom tool call type.',
+                    });
+                    continue;
+                }
+                const { args, message: toolMessage } = runToolCall(toolCall);
+                const content = String(toolMessage.content || '');
+                await pushEvent(events, {
+                    type: 'tool_call',
+                    name: toolCall.function.name,
+                    args,
+                }, onEvent);
+                session.history.push(toolMessage);
+                const preview = previewToolResult(content);
+                await pushEvent(events, {
+                    type: 'tool',
+                    name: toolCall.function.name,
+                    summary: summarizeToolResult(toolCall.function.name, content),
+                    ...preview,
+                }, onEvent);
+            }
+            continue;
+        }
+        const content = typeof message.content === 'string' ? message.content : '';
+        await pushEvent(events, { type: 'assistant', message: content }, onEvent);
+        return content;
+    }
+    if (requireAnswer) {
+        throw new Error('Agent reached the maximum number of tool steps before answering.');
+    }
+    return '';
+}
+export async function initializeProject(project) {
+    const session = getSession(project);
+    const events = [];
+    process.chdir(session.project);
+    if (session.initialized) {
+        events.push({ type: 'status', message: 'Project summary already exists at docs/intro.md.' });
+        return events;
+    }
+    events.push({ type: 'status', message: 'Scanning project and creating docs/intro.md.' });
+    session.history.push({ role: 'user', content: initializationPrompt });
+    for (let step = 0; step < 15; step++) {
+        const before = session.history.length;
+        await runToolLoop(session, events, 1, false);
+        const wroteIntro = session.history.slice(before).some((message) => (message.role === 'tool' &&
+            typeof message.content === 'string' &&
+            message.content.startsWith('Success: Wrote')));
+        if (wroteIntro || fs.existsSync(path.join(session.project, 'docs', 'intro.md'))) {
+            session.initialized = true;
+            events.push({ type: 'status', message: 'Initialization complete.' });
+            return events;
+        }
+        session.history.push({ role: 'user', content: missingIntroNudge });
+    }
+    events.push({ type: 'status', message: 'Initialization stopped after 15 steps. You can ask the agent to continue.' });
+    return events;
+}
+export async function sendChatMessage(project, content, onEvent) {
+    const session = getSession(project);
+    const events = [];
+    process.chdir(session.project);
+    session.history.push({ role: 'user', content });
+    await runToolLoop(session, events, 12, true, onEvent);
+    return events;
+}