c0de-agent 0.0.0 → 1.0.0

package/dist/plugins/types.d.ts

@@ -0,0 +1,113 @@
+import type { AgentConfig } from '../shared/types/agent.js';
+import type { Config } from '../shared/types/config.js';
+import type { ChatMessage, ChatRequest, ProviderConfig, StreamChunk } from '../shared/types/llm.js';
+import type { Message, Session } from '../shared/types/message.js';
+import type { ToolContext, ToolDef, ToolResult } from '../shared/types/tool.js';
+type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+type Logger = {
+    debug: (msg: string, ...args: unknown[]) => void;
+    info: (msg: string, ...args: unknown[]) => void;
+    warn: (msg: string, ...args: unknown[]) => void;
+    error: (msg: string, ...args: unknown[]) => void;
+};
+/** Unified event map. `domain:before` = chain (can modify/abort); `domain:after` = broadcast. */
+type HookMap = {
+    'agent:start': {
+        config: AgentConfig;
+    };
+    'agent:end': Record<string, never>;
+    'tool:before': {
+        tool: string;
+        input: unknown;
+        ctx: ToolContext;
+    };
+    'tool:after': {
+        tool: string;
+        input: unknown;
+        result: ToolResult;
+        ctx: ToolContext;
+    };
+    'provider:before': {
+        request: ChatRequest;
+    };
+    'provider:after': {
+        request: ChatRequest;
+        chunks: StreamChunk[];
+    };
+    'message:before': {
+        messages: ChatMessage[];
+    };
+    'message:after': {
+        message: Message;
+    };
+    'session:create': {
+        session: Session;
+    };
+    'session:fork': {
+        source: Session;
+        fork: Session;
+    };
+    'session:compact': {
+        before: number;
+        after: number;
+    };
+    'config:resolve': {
+        config: Config;
+    };
+};
+/** Hook handler. Returns T (possibly modified) or false (abort). void = passthrough. */
+type HookHandler<T> = (data: T) => T | false | void | Promise<T | false | void>;
+/** Options for createHookRunner. */
+type HookRunnerOptions = {
+    /** Per-handler timeout in ms. Default 5000. */
+    timeout?: number;
+    /** Logger for error/timeout warnings. Default: console. */
+    logger?: Logger;
+};
+/** Mutable event registry. Functions are context-first (runner as hidden state). */
+type HookRunner = {
+    on: <K extends keyof HookMap>(event: K, handler: HookHandler<HookMap[K]>, priority?: number) => void;
+    off: <K extends keyof HookMap>(event: K, handler: HookHandler<HookMap[K]>) => void;
+    runHooks: <K extends keyof HookMap>(event: K, data: HookMap[K]) => Promise<HookMap[K] | false>;
+    fireHooks: <K extends keyof HookMap>(event: K, data: HookMap[K]) => Promise<void>;
+    dispose: () => void;
+};
+/** A process-level plugin. `setup` is called during activation; `dispose` during deactivation. */
+type Plugin = {
+    name: string;
+    version: string;
+    description?: string;
+    setup: (ctx: PluginContext) => void | Promise<void>;
+    dispose?: () => void | Promise<void>;
+};
+/** Context passed to plugin.setup(). Delegates to real registries. */
+type PluginContext = {
+    registerTool: (tool: ToolDef) => void;
+    registerProvider: (provider: ProviderConfig) => void;
+    on: HookRunner['on'];
+    off: HookRunner['off'];
+    getConfig: () => Config;
+    getLogger: (name: string) => Logger;
+    onDispose: (handler: () => void | Promise<void>) => void;
+};
+/** Runtime status of a loaded plugin. */
+type PluginStatus = 'loaded' | 'active' | 'error' | 'inactive';
+/** Internal record stored in PluginRegistry. */
+type PluginRecord = {
+    plugin: Plugin;
+    status: PluginStatus;
+    error?: string;
+    disposeHandlers: (() => void | Promise<void>)[];
+};
+/** Mutable plugin registry. */
+type PluginRegistry = {
+    plugins: Map<string, PluginRecord>;
+    hookRunner: HookRunner;
+};
+/** Services needed to create PluginContext during activation. */
+type PluginServices = {
+    config: Config;
+    toolRegistry: unknown;
+    llmRegistry: unknown;
+};
+export type { AgentConfig, ChatMessage, ChatRequest, Config, HookHandler, HookMap, HookRunner, HookRunnerOptions, Logger, LogLevel, Message, Plugin, PluginContext, PluginRecord, PluginRegistry, PluginServices, PluginStatus, ProviderConfig, Session, StreamChunk, ToolContext, ToolDef, ToolResult, };

package/dist/plugins/types.js

@@ -0,0 +1 @@
+export {};

package/dist/project/detect.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectInfo } from '../core/types.js';
+/** 探测项目信息：name/language/framework/gitBranch，全部失败回退安全默认值。 */
+declare function detectProjectInfo(cwd: string): ProjectInfo;
+export { detectProjectInfo };

package/dist/project/detect.js

@@ -0,0 +1,131 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveProject } from './resolve.js';
+/** 框架推断映射：依赖名 → 框架名（按常见前端/后端框架）。 */
+const FRAMEWORK_MAP = {
+    react: 'react',
+    'react-dom': 'react',
+    vue: 'vue',
+    svelte: 'svelte',
+    '@angular/core': 'angular',
+    next: 'next.js',
+    nuxt: 'nuxt',
+    '@nestjs/core': 'nest',
+    '@hono/node-server': 'hono',
+    hono: 'hono',
+    express: 'express',
+    fastify: 'fastify',
+};
+/** 语言推断映射：文件后缀 → 语言名。 */
+const EXT_LANGUAGE_MAP = {
+    '.ts': 'TypeScript',
+    '.tsx': 'TypeScript',
+    '.js': 'JavaScript',
+    '.jsx': 'JavaScript',
+    '.mjs': 'JavaScript',
+    '.py': 'Python',
+    '.go': 'Go',
+    '.rs': 'Rust',
+    '.java': 'Java',
+    '.kt': 'Kotlin',
+    '.rb': 'Ruby',
+    '.php': 'PHP',
+    '.cs': 'C#',
+    '.swift': 'Swift',
+};
+/** 安全读 package.json，失败返回 null。 */
+function readPackageJson(cwd) {
+    const pkgPath = join(cwd, 'package.json');
+    if (!existsSync(pkgPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** 从 package.json 的 deps 推断主框架。 */
+function inferFramework(pkg) {
+    const deps = {
+        ...(pkg.dependencies ?? {}),
+        ...(pkg.devDependencies ?? {}),
+    };
+    if (!deps)
+        return undefined;
+    for (const depName of Object.keys(deps)) {
+        const mapped = FRAMEWORK_MAP[depName];
+        if (mapped)
+            return mapped;
+    }
+    return undefined;
+}
+/** 递归扫描源文件后缀统计，推断主语言（浅层，避免深扫 node_modules）。 */
+function inferLanguage(cwd) {
+    const counts = {};
+    const queue = [join(cwd, 'src')];
+    let scanned = 0;
+    const MAX_SCAN = 500; // 防御性上限
+    while (queue.length > 0 && scanned < MAX_SCAN) {
+        const current = queue.shift();
+        scanned++;
+        let entries;
+        try {
+            entries = readdirSync(current);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = join(current, entry);
+            let st;
+            try {
+                st = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                if (entry === 'node_modules' || entry === '.git' || entry === 'dist')
+                    continue;
+                queue.push(full);
+            }
+            else if (st.isFile()) {
+                const dot = entry.lastIndexOf('.');
+                if (dot < 0)
+                    continue;
+                const ext = entry.slice(dot).toLowerCase();
+                const lang = EXT_LANGUAGE_MAP[ext];
+                if (lang)
+                    counts[lang] = (counts[lang] ?? 0) + 1;
+            }
+        }
+    }
+    const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]);
+    return sorted[0]?.[0] ?? 'unknown';
+}
+/** 探测项目信息：name/language/framework/gitBranch，全部失败回退安全默认值。 */
+function detectProjectInfo(cwd) {
+    const pkg = readPackageJson(cwd);
+    const name = ((pkg && typeof pkg.name === 'string' && pkg.name) || 'project');
+    const framework = pkg ? inferFramework(pkg) : undefined;
+    let language = 'unknown';
+    if (existsSync(join(cwd, 'src'))) {
+        language = inferLanguage(cwd);
+    }
+    else if (pkg) {
+        language = 'JavaScript';
+    }
+    // 复用已有 git 探测（resolveProject），不重复造轮子
+    const resolved = resolveProject(cwd);
+    // resolveProject.gitBranch 为 string | null，ProjectInfo.gitBranch 为 string | undefined
+    const gitBranch = resolved.vcs === 'git' ? (resolved.gitBranch ?? undefined) : undefined;
+    return {
+        name,
+        language,
+        framework,
+        rootDir: cwd,
+        gitBranch,
+    };
+}
+export { detectProjectInfo };

package/dist/project/index.d.ts

@@ -0,0 +1,4 @@
+export type { Project } from './project.js';
+export { fromDirectory, getByDirectory, getProject, listProjects, updateProjectName, } from './project.js';
+export type { ResolvedProject } from './resolve.js';
+export { resolveProject } from './resolve.js';

package/dist/project/index.js

@@ -0,0 +1,2 @@
+export { fromDirectory, getByDirectory, getProject, listProjects, updateProjectName, } from './project.js';
+export { resolveProject } from './resolve.js';

package/dist/project/project.d.ts

@@ -0,0 +1,23 @@
+import type { DB } from '../db/client.js';
+export type Project = {
+    id: string;
+    worktree: string;
+    vcs: 'git' | null;
+    name: string | null;
+    gitRemote: string | null;
+    createdAt: number;
+    updatedAt: number;
+};
+/**
+ * 解析目录 + upsert 项目记录。返回 Project。
+ *
+ * 历史缺陷修复：旧版 resolveProject 曾用 git remote 作 id，remote 变更（先无后加）
+ * 会导致同一目录分裂成多个项目记录，挂在旧 id 的会话随之「消失」。这里在 upsert 后
+ * 合并同 worktree 的重复项目：把孤儿 id 名下的会话迁回规范 id，再删除孤儿记录。
+ * 幂等——无重复时为 no-op。
+ */
+export declare function fromDirectory(handle: DB, directory: string): Promise<Project>;
+export declare function listProjects(handle: DB): Promise<Project[]>;
+export declare function getProject(handle: DB, id: string): Promise<Project | null>;
+export declare function getByDirectory(handle: DB, directory: string): Promise<Project | null>;
+export declare function updateProjectName(handle: DB, id: string, name: string): Promise<Project | null>;

package/dist/project/project.js

@@ -0,0 +1,87 @@
+import { basename } from 'node:path';
+import { eq } from 'drizzle-orm';
+import { projects, sessions } from '../db/schema.js';
+import { resolveProject } from './resolve.js';
+function rowToProject(row) {
+    return {
+        id: row.id,
+        worktree: row.worktree,
+        vcs: row.vcs ?? null,
+        name: row.name,
+        gitRemote: row.gitRemote,
+        createdAt: row.createdAt instanceof Date ? row.createdAt.getTime() : new Date(row.createdAt).getTime(),
+        updatedAt: row.updatedAt instanceof Date ? row.updatedAt.getTime() : new Date(row.updatedAt).getTime(),
+    };
+}
+/**
+ * 解析目录 + upsert 项目记录。返回 Project。
+ *
+ * 历史缺陷修复：旧版 resolveProject 曾用 git remote 作 id，remote 变更（先无后加）
+ * 会导致同一目录分裂成多个项目记录，挂在旧 id 的会话随之「消失」。这里在 upsert 后
+ * 合并同 worktree 的重复项目：把孤儿 id 名下的会话迁回规范 id，再删除孤儿记录。
+ * 幂等——无重复时为 no-op。
+ */
+export async function fromDirectory(handle, directory) {
+    const resolved = resolveProject(directory);
+    const name = basename(resolved.worktree) || resolved.worktree;
+    await handle.db
+        .insert(projects)
+        .values({
+        id: resolved.id,
+        worktree: resolved.worktree,
+        vcs: resolved.vcs,
+        name,
+        gitRemote: resolved.gitRemote,
+    })
+        .onConflictDoUpdate({
+        target: projects.id,
+        set: {
+            worktree: resolved.worktree,
+            vcs: resolved.vcs,
+            gitRemote: resolved.gitRemote,
+            updatedAt: new Date(),
+        },
+    });
+    await mergeDuplicateProjects(handle, resolved.id, resolved.worktree);
+    const result = await getProject(handle, resolved.id);
+    if (!result)
+        throw new Error(`Project upsert failed for ${directory}`);
+    return result;
+}
+/**
+ * 合并同 worktree 下 id ≠ canonicalId 的项目记录：迁移其会话到 canonicalId 后删除。
+ * 清理因 id 漂移（remote 变更）产生的历史重复项目，使列表不再出现同名重复项，
+ * 也让挂在漂移 id 上的会话重新归属规范项目。
+ */
+async function mergeDuplicateProjects(handle, canonicalId, worktree) {
+    const dups = await handle.db.select().from(projects).where(eq(projects.worktree, worktree));
+    for (const dup of dups) {
+        if (dup.id === canonicalId)
+            continue;
+        await handle.db
+            .update(sessions)
+            .set({ projectId: canonicalId })
+            .where(eq(sessions.projectId, dup.id));
+        await handle.db.delete(projects).where(eq(projects.id, dup.id));
+    }
+}
+export async function listProjects(handle) {
+    const rows = await handle.db.select().from(projects);
+    return rows.map(rowToProject);
+}
+export async function getProject(handle, id) {
+    const [row] = await handle.db.select().from(projects).where(eq(projects.id, id));
+    return row ? rowToProject(row) : null;
+}
+export async function getByDirectory(handle, directory) {
+    const resolved = resolveProject(directory);
+    return getProject(handle, resolved.id);
+}
+export async function updateProjectName(handle, id, name) {
+    const [row] = await handle.db
+        .update(projects)
+        .set({ name, updatedAt: new Date() })
+        .where(eq(projects.id, id))
+        .returning();
+    return row ? rowToProject(row) : null;
+}

package/dist/project/resolve.d.ts

@@ -0,0 +1,8 @@
+export type ResolvedProject = {
+    id: string;
+    worktree: string;
+    vcs: 'git' | null;
+    gitRemote: string | null;
+    gitBranch: string | null;
+};
+export declare function resolveProject(directory: string): ResolvedProject;

package/dist/project/resolve.js

@@ -0,0 +1,81 @@
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+/** 运行 git 命令，失败返回空字符串（不抛错）。 */
+function git(args, cwd) {
+    try {
+        const result = spawnSync('git', args, {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        if (result.status !== 0 || result.error)
+            return '';
+        return (result.stdout ?? '').trim();
+    }
+    catch {
+        return '';
+    }
+}
+/** 从 directory 向上查找 .git，返回仓库根；非 git 返回 null。 */
+function findGitRoot(directory) {
+    let current = resolve(directory);
+    // 防御性上限，避免无限向上
+    for (let i = 0; i < 64; i++) {
+        const dotGit = join(current, '.git');
+        if (existsSync(dotGit)) {
+            try {
+                statSync(dotGit);
+                return current;
+            }
+            catch {
+                // ignore
+            }
+        }
+        const parent = resolve(current, '..');
+        if (parent === current)
+            break; // 到达根
+        current = parent;
+    }
+    return null;
+}
+/** 取第一个 remote 的 URL（origin 无果时的回退）。 */
+function firstRemoteUrl(cwd) {
+    const names = git(['remote'], cwd);
+    const first = names
+        .split('\n')
+        .map((s) => s.trim())
+        .filter(Boolean)[0];
+    if (!first)
+        return '';
+    return git(['remote', 'get-url', first], cwd);
+}
+function hash16(input) {
+    return createHash('sha256').update(input).digest('hex').slice(0, 16);
+}
+export function resolveProject(directory) {
+    const absolute = resolve(directory);
+    const gitRoot = findGitRoot(absolute);
+    if (gitRoot) {
+        const remote = git(['remote', 'get-url', 'origin'], gitRoot) || firstRemoteUrl(gitRoot);
+        const branch = git(['rev-parse', '--abbrev-ref', 'HEAD'], gitRoot) || null;
+        // 身份恒用 worktree（本地路径稳定）；remote 是可变元数据，曾用 remote 作 id 会在
+        // 「先无 remote 注册、后加 remote」时导致 id 漂移——同一目录分裂成两个项目，
+        // 历史会话挂在旧 id 上从列表消失。remote 仅记录到 gitRemote 字段。
+        return {
+            id: hash16(gitRoot),
+            worktree: gitRoot,
+            vcs: 'git',
+            gitRemote: remote || null,
+            gitBranch: branch,
+        };
+    }
+    return {
+        id: hash16(absolute),
+        worktree: absolute,
+        vcs: null,
+        gitRemote: null,
+        gitBranch: null,
+    };
+}

package/dist/server/agent-manager.d.ts

@@ -0,0 +1,32 @@
+import type { AgentDependencies } from '../core/types.js';
+import type { AgentState } from '../shared/types/agent.js';
+/** 一个活跃的 agent run。 */
+type ActiveRun = {
+    sessionId: string;
+    state: AgentState;
+    deps: AgentDependencies;
+    /** 若为子 agent run：记录父 sessionId（恢复时重建树）。 */
+    parentSessionId?: string;
+    /** 子 agent 类型名（调试/展示用）。 */
+    agentType?: string;
+    /** 后台任务 jobId（后台 subagent）。 */
+    jobId?: string;
+};
+/** Agent run 跟踪器 + 控制操作。 */
+type AgentManager = {
+    register(run: ActiveRun): void;
+    get(sessionId: string): ActiveRun | undefined;
+    unregister(sessionId: string): void;
+    size(): number;
+    abort(sessionId: string): boolean;
+    pause(sessionId: string): boolean;
+    resume(sessionId: string): boolean;
+    steer(sessionId: string, message: string): boolean;
+    /** 查询某 session 的所有子 agent run（恢复/展示用）。 */
+    children(parentSessionId: string): ActiveRun[];
+    /** 查询所有后台任务（jobId 非空的 run）。 */
+    backgroundJobs(): ActiveRun[];
+};
+declare function createAgentManager(): AgentManager;
+export type { ActiveRun, AgentManager };
+export { createAgentManager };

package/dist/server/agent-manager.js

@@ -0,0 +1,54 @@
+// src/server/agent-manager.ts
+import { abortAgent, injectSteering, pauseAgent, resumeAgent } from '../core/index.js';
+function createAgentManager() {
+    const runs = new Map();
+    return {
+        register(run) {
+            runs.set(run.sessionId, run);
+        },
+        get(sessionId) {
+            return runs.get(sessionId);
+        },
+        unregister(sessionId) {
+            runs.delete(sessionId);
+        },
+        size() {
+            return runs.size;
+        },
+        abort(sessionId) {
+            const run = runs.get(sessionId);
+            if (!run)
+                return false;
+            abortAgent(run.state);
+            return true;
+        },
+        pause(sessionId) {
+            const run = runs.get(sessionId);
+            if (!run)
+                return false;
+            pauseAgent(run.state);
+            return true;
+        },
+        resume(sessionId) {
+            const run = runs.get(sessionId);
+            if (!run)
+                return false;
+            resumeAgent(run.state);
+            return true;
+        },
+        steer(sessionId, message) {
+            const run = runs.get(sessionId);
+            if (!run)
+                return false;
+            injectSteering(run.state, message);
+            return true;
+        },
+        children(parentSessionId) {
+            return Array.from(runs.values()).filter((r) => r.parentSessionId === parentSessionId);
+        },
+        backgroundJobs() {
+            return Array.from(runs.values()).filter((r) => r.jobId !== undefined);
+        },
+    };
+}
+export { createAgentManager };

package/dist/server/app.d.ts

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import type { ServerContext } from './types.js';
+/** 创建完整的 Hono 应用，挂载所有路由 + 中间件。 */
+declare function createApp(ctx: ServerContext): Hono;
+export { createApp };

package/dist/server/app.js

@@ -0,0 +1,75 @@
+// src/server/app.ts
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { Hono } from 'hono';
+import { createAuthMiddleware } from './middleware/auth.js';
+import { createCORSMiddleware } from './middleware/cors.js';
+import { errorHandler } from './middleware/error.js';
+import { createAgentRoute } from './routes/agent.js';
+import { createCatalogRoute } from './routes/catalog.js';
+import { createChatRoute } from './routes/chat.js';
+import { createCommandsRoute } from './routes/commands.js';
+import { createConfigRoute } from './routes/config.js';
+import { createFilesRoute } from './routes/files.js';
+import { createFilesystemRoute } from './routes/filesystem.js';
+import { createHealthRoute } from './routes/health.js';
+import { createPermissionsRoute } from './routes/permissions.js';
+import { createProjectRoute } from './routes/project.js';
+import { createProviderRoute } from './routes/provider.js';
+import { createSessionRoute } from './routes/session.js';
+import { createToolRoute } from './routes/tool.js';
+import { createUpdateRoute } from './routes/update.js';
+/** 创建完整的 Hono 应用，挂载所有路由 + 中间件。 */
+function createApp(ctx) {
+    const app = new Hono();
+    // 中间件
+    app.onError(errorHandler);
+    // spec §24.2：仅允许本地/可信 origin 跨域读，拒绝外部网页。
+    app.use('*', createCORSMiddleware({ allowedOrigins: ctx.config.security.allowedOrigins }));
+    // spec §24.2：Bearer token 认证（配置了 token 时生效；/api/health 探活放行）。
+    app.use('/api/*', createAuthMiddleware(ctx.config.security.authEnabled ? ctx.config.security.token : undefined));
+    // 路由
+    app.route('/api/health', createHealthRoute());
+    app.route('/api/agents', createAgentRoute(ctx));
+    app.route('/api/sessions', createSessionRoute(ctx));
+    app.route('/api/projects', createProjectRoute(ctx));
+    app.route('/api/providers', createProviderRoute(ctx));
+    app.route('/api/catalog', createCatalogRoute(ctx));
+    app.route('/api/filesystem', createFilesystemRoute(ctx));
+    app.route('/api/chat', createChatRoute(ctx));
+    app.route('/api/commands', createCommandsRoute(ctx));
+    app.route('/api/tools', createToolRoute(ctx));
+    app.route('/api/update', createUpdateRoute(ctx));
+    app.route('/api/config', createConfigRoute(ctx));
+    app.route('/api/permissions', createPermissionsRoute(ctx));
+    app.route('/api/files', createFilesRoute(ctx));
+    // 根路径
+    app.get('/', (c) => c.json({
+        name: 'c0de-agent',
+        version: '0.1.0',
+        endpoints: [
+            '/api/health',
+            '/api/agents',
+            '/api/sessions',
+            '/api/projects',
+            '/api/providers',
+            '/api/catalog',
+            '/api/filesystem',
+            '/api/chat',
+            '/api/commands',
+            '/api/tools',
+            '/api/update',
+            '/api/config',
+            '/api/permissions',
+            '/api/files',
+        ],
+    }));
+    // 静态文件服务（生产环境 dist-web/ 存在时启用）
+    if (existsSync(path.resolve(ctx.cwd, 'dist-web'))) {
+        app.use('/*', serveStatic({ root: './dist-web' }));
+        app.get('/*', (c) => c.body(null)); // SPA fallback
+    }
+    return app;
+}
+export { createApp };

package/dist/server/context.d.ts

@@ -0,0 +1,20 @@
+import type { AgentRegistry } from '../core/agents/types.js';
+import { DEFAULT_CONFIG } from '../core/config.js';
+import type { DB } from '../db/client.js';
+import type { Registry } from '../llm/registry.js';
+import type { Config } from '../shared/types/config.js';
+import type { ToolRegistry } from '../tools/types.js';
+import type { ServerContext } from './types.js';
+type CreateServerContextOptions = {
+    db: DB;
+    config?: Config;
+    toolRegistry?: ToolRegistry;
+    llmRegistry: Registry;
+    cwd?: string;
+    chatStream?: ServerContext['chatStream'];
+    /** 测试注入：覆盖默认（内置 agent）注册表。 */
+    agentRegistry?: AgentRegistry;
+};
+declare function createServerContext(opts: CreateServerContextOptions): ServerContext;
+export type { CreateServerContextOptions };
+export { createServerContext, DEFAULT_CONFIG };