c0de-agent 0.0.0 → 1.0.0

package/dist/llm/transport.js

@@ -0,0 +1,165 @@
+import { isContextOverflow } from './provider-error.js';
+import { llmError } from './schema/errors.js';
+/**
+ * Parse a Server-Sent Events byte stream into individual `data:` payloads.
+ * Emits the decoded data string for each event block. Skips empty data and
+ * the `[DONE]` sentinel. Works for both OpenAI (`data: {...}`) and Anthropic
+ * (`event: {type}\ndata: {...}`) framing — only the `data:` lines are emitted.
+ */
+const sseFraming = async function* (stream) {
+    const decoder = new TextDecoder();
+    const reader = stream.getReader();
+    let buffer = '';
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let sepIndex = buffer.indexOf('\n\n');
+            while (sepIndex !== -1) {
+                const block = buffer.slice(0, sepIndex);
+                buffer = buffer.slice(sepIndex + 2);
+                const data = extractData(block);
+                if (data !== null && data.length > 0 && data !== '[DONE]') {
+                    yield data;
+                }
+                sepIndex = buffer.indexOf('\n\n');
+            }
+        }
+        const tailData = extractData(buffer);
+        if (tailData !== null && tailData.length > 0 && tailData !== '[DONE]') {
+            yield tailData;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+};
+/** Join all `data:` lines of an SSE block into one string. */
+const extractData = (block) => {
+    const lines = block.split('\n');
+    const dataLines = [];
+    for (const line of lines) {
+        if (line.startsWith('data:')) {
+            dataLines.push(line.slice(5).trimStart());
+        }
+    }
+    if (dataLines.length === 0)
+        return null;
+    return dataLines.join('\n');
+};
+/**
+ * Eagerly POST a JSON body and return the response body stream for framing.
+ * Throws an LLMError (classified) on non-2xx responses or transport failure.
+ * Used when the connection must be retryable independently of frame consumption.
+ */
+const httpPost = async (options) => {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    let response;
+    try {
+        response = await fetchImpl(options.url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', ...options.headers },
+            body: JSON.stringify(options.body),
+            signal: options.signal,
+        });
+    }
+    catch (cause) {
+        throw llmError('ProviderShared', 'request', {
+            _tag: 'Transport',
+            message: `Failed to send request to ${options.url}: ${cause instanceof Error ? cause.message : String(cause)}`,
+            kind: 'network',
+            url: options.url,
+        });
+    }
+    if (!response.ok || response.body === null) {
+        const text = await response.text().catch(() => '');
+        throw classifyHttpError(response.status, text, options.url, response.headers);
+    }
+    return response.body;
+};
+/**
+ * POST a JSON body and yield SSE data frames from the response.
+ * Throws an LLMError on non-2xx responses, classifying context-overflow.
+ */
+const streamHTTP = async function* (options) {
+    const body = await httpPost(options);
+    yield* sseFraming(body);
+};
+/** Map an HTTP failure status + body to an LLMError. */
+const classifyHttpError = (status, body, url, headers) => {
+    const http = {
+        request: { method: 'POST', url, headers: {} },
+        response: { status, headers: Object.fromEntries(headers.entries()) },
+        body,
+    };
+    if (status === 401 || status === 403) {
+        return llmError('ProviderShared', 'request', {
+            _tag: 'Authentication',
+            message: body || `Authentication failed (${status})`,
+            kind: status === 401 ? 'invalid' : 'insufficient-permissions',
+            http,
+        });
+    }
+    if (status === 429) {
+        const retryAfterMs = parseRetryAfterMs(headers.get('retry-after-ms'), headers.get('retry-after'));
+        return llmError('ProviderShared', 'request', {
+            _tag: 'RateLimit',
+            message: body || 'Rate limited',
+            retryAfterMs,
+            http,
+        });
+    }
+    if (status === 402 || /quota|billing|insufficient.{0,4}quota|exceeded.{0,12}limit/i.test(body)) {
+        return llmError('ProviderShared', 'request', {
+            _tag: 'QuotaExceeded',
+            message: body || `Quota exceeded (${status})`,
+            http,
+        });
+    }
+    if (status >= 500) {
+        return llmError('ProviderShared', 'request', {
+            _tag: 'ProviderInternal',
+            message: body || `Provider error (${status})`,
+            status,
+            http,
+        });
+    }
+    // Bodyless 413/400 (no error text) is a context-window overflow signal.
+    if (status === 413 || (status === 400 && body.length === 0) || isContextOverflow(body)) {
+        return llmError('ProviderShared', 'request', {
+            _tag: 'InvalidRequest',
+            message: body || 'Context overflow',
+            classification: 'context-overflow',
+            http,
+        });
+    }
+    if (/content.{0,4}(filter|policy)|safety/i.test(body)) {
+        return llmError('ProviderShared', 'request', {
+            _tag: 'ContentPolicy',
+            message: body || 'Content policy violation',
+            http,
+        });
+    }
+    return llmError('ProviderShared', 'request', {
+        _tag: 'UnknownProvider',
+        message: body || `Unknown provider error (${status})`,
+        status,
+        http,
+    });
+};
+const parseRetryAfterMs = (retryAfterMs, retryAfter) => {
+    if (retryAfterMs !== null && retryAfterMs !== undefined) {
+        const parsed = Number.parseFloat(retryAfterMs);
+        if (!Number.isNaN(parsed))
+            return Math.ceil(parsed);
+    }
+    if (retryAfter !== null && retryAfter !== undefined) {
+        const parsed = Number.parseFloat(retryAfter);
+        if (!Number.isNaN(parsed))
+            return Math.ceil(parsed * 1000);
+    }
+    return undefined;
+};
+export { classifyHttpError, httpPost, sseFraming, streamHTTP };

package/dist/mcp/index.d.ts

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

package/dist/mcp/index.js

@@ -0,0 +1,3 @@
+// MCP package: MCP protocol client, tool adapter.
+// Implementation in subsequent plan.
+export {};

package/dist/plugins/builtin.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin, PluginRegistry, PluginServices } from './types.js';
+declare function createToolAuditLogger(): Plugin;
+declare function createWriteGuard(): Plugin;
+declare const BUILTIN_PLUGINS: Plugin[];
+declare function registerBuiltinHooks(registry: PluginRegistry, services: PluginServices, names?: string[]): Promise<void>;
+export { BUILTIN_PLUGINS, createToolAuditLogger, createWriteGuard, registerBuiltinHooks };

package/dist/plugins/builtin.js

@@ -0,0 +1,54 @@
+// src/plugins/builtin.ts
+import { existsSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import { activatePlugin } from './lifecycle.js';
+import { createLogger } from './logger.js';
+import { registerPlugin } from './registry.js';
+function createToolAuditLogger() {
+    const logger = createLogger('tool-audit');
+    return {
+        name: 'tool-audit-log',
+        version: '1.0.0',
+        description: 'Logs all tool execution activity',
+        setup: (ctx) => {
+            ctx.on('tool:before', (data) => {
+                logger.info(`tool:before → ${data.tool}`, { input: data.input });
+            });
+            ctx.on('tool:after', (data) => {
+                const status = data.result._tag;
+                logger.info(`tool:after ← ${data.tool} [${status}]`);
+            });
+        },
+    };
+}
+function createWriteGuard() {
+    const logger = createLogger('write-guard');
+    return {
+        name: 'write-guard',
+        version: '1.0.0',
+        description: 'Warns before overwriting existing files',
+        setup: (ctx) => {
+            ctx.on('tool:before', (data) => {
+                if (data.tool !== 'write' && data.tool !== 'edit')
+                    return;
+                const input = data.input;
+                const rawPath = input?.path ?? input?.file;
+                if (typeof rawPath !== 'string')
+                    return;
+                const fullPath = isAbsolute(rawPath) ? rawPath : resolve(data.ctx.cwd, rawPath);
+                if (existsSync(fullPath)) {
+                    logger.warn(`Overwriting existing file: ${fullPath}`);
+                }
+            }, 50);
+        },
+    };
+}
+const BUILTIN_PLUGINS = [createToolAuditLogger(), createWriteGuard()];
+async function registerBuiltinHooks(registry, services, names) {
+    const selected = names ? BUILTIN_PLUGINS.filter((p) => names.includes(p.name)) : BUILTIN_PLUGINS;
+    for (const plugin of selected) {
+        registerPlugin(registry, plugin);
+        await activatePlugin(registry, plugin, services);
+    }
+}
+export { BUILTIN_PLUGINS, createToolAuditLogger, createWriteGuard, registerBuiltinHooks };

package/dist/plugins/hooks.d.ts

@@ -0,0 +1,3 @@
+import type { HookRunner, HookRunnerOptions } from './types.js';
+declare function createHookRunner(opts?: HookRunnerOptions): HookRunner;
+export { createHookRunner };

package/dist/plugins/hooks.js

@@ -0,0 +1,79 @@
+// src/plugins/hooks.ts
+import { createLogger } from './logger.js';
+function withTimeout(promise, ms) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`Hook handler timed out after ${ms}ms`)), ms);
+        promise.then((val) => {
+            clearTimeout(timer);
+            resolve(val);
+        }, (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+function sortByPriority(regs) {
+    return regs.slice().sort((a, b) => a.priority - b.priority);
+}
+function createHookRunner(opts) {
+    const timeout = opts?.timeout ?? 5000;
+    const logger = opts?.logger ?? createLogger('hooks');
+    const handlers = new Map();
+    const on = (event, handler, priority) => {
+        const key = event;
+        const regs = handlers.get(key) ?? [];
+        regs.push({ handler, priority });
+        handlers.set(key, regs);
+    };
+    const off = (event, handler) => {
+        const key = event;
+        const regs = handlers.get(key);
+        if (!regs)
+            return;
+        const filtered = regs.filter((r) => r.handler !== handler);
+        handlers.set(key, filtered);
+    };
+    const runHooks = async (event, data) => {
+        const regs = handlers.get(event);
+        if (!regs || regs.length === 0)
+            return data;
+        let current = data;
+        for (const reg of sortByPriority(regs)) {
+            try {
+                const result = await withTimeout(Promise.resolve(reg.handler(current)), timeout);
+                if (result === false)
+                    return false;
+                if (result !== undefined)
+                    current = result;
+            }
+            catch (err) {
+                logger.warn(`Handler for "${String(event)}" failed:`, err);
+            }
+        }
+        return current;
+    };
+    const fireHooks = async (event, data) => {
+        const regs = handlers.get(event);
+        if (!regs || regs.length === 0)
+            return;
+        await Promise.allSettled(sortByPriority(regs).map(async (reg) => {
+            try {
+                await withTimeout(Promise.resolve(reg.handler(data)), timeout);
+            }
+            catch (err) {
+                logger.warn(`Handler for "${String(event)}" failed:`, err);
+            }
+        }));
+    };
+    const dispose = () => {
+        handlers.clear();
+    };
+    return {
+        on: ((event, handler, priority = 100) => on(event, handler, priority)),
+        off: off,
+        runHooks: runHooks,
+        fireHooks: fireHooks,
+        dispose,
+    };
+}
+export { createHookRunner };

package/dist/plugins/index.d.ts

@@ -0,0 +1,9 @@
+export { BUILTIN_PLUGINS, createToolAuditLogger, createWriteGuard, registerBuiltinHooks, } from './builtin.js';
+export { createHookRunner } from './hooks.js';
+export type { InitPluginsOptions, InitPluginsResult } from './init.js';
+export { initPlugins } from './init.js';
+export { activatePlugin, createPluginContext, deactivateAll, deactivatePlugin, } from './lifecycle.js';
+export { discoverPlugins, loadPlugin, validatePluginModule } from './loader.js';
+export { createLogger } from './logger.js';
+export { createPluginRegistry, getPlugin, listPlugins, registerPlugin, unregisterPlugin, } from './registry.js';
+export type { HookHandler, HookMap, HookRunner, HookRunnerOptions, Logger, LogLevel, Plugin, PluginContext, PluginRecord, PluginRegistry, PluginServices, PluginStatus, } from './types.js';

package/dist/plugins/index.js

@@ -0,0 +1,8 @@
+// src/plugins/index.ts
+export { BUILTIN_PLUGINS, createToolAuditLogger, createWriteGuard, registerBuiltinHooks, } from './builtin.js';
+export { createHookRunner } from './hooks.js';
+export { initPlugins } from './init.js';
+export { activatePlugin, createPluginContext, deactivateAll, deactivatePlugin, } from './lifecycle.js';
+export { discoverPlugins, loadPlugin, validatePluginModule } from './loader.js';
+export { createLogger } from './logger.js';
+export { createPluginRegistry, getPlugin, listPlugins, registerPlugin, unregisterPlugin, } from './registry.js';

package/dist/plugins/init.d.ts

@@ -0,0 +1,23 @@
+import type { Config } from '../shared/types/config.js';
+import type { HookRunner, PluginRegistry } from './types.js';
+type InitPluginsOptions = {
+    cwd: string;
+    config: Config;
+    /** 工具注册表；插件通过 registerTool 往这里注入（spec §7.2 PluginContext）。 */
+    toolRegistry: unknown;
+    /** LLM 注册表；插件通过 registerProvider 往这里注入。 */
+    llmRegistry: unknown;
+};
+type InitPluginsResult = {
+    pluginRegistry: PluginRegistry;
+    hookRunner: HookRunner;
+};
+/**
+ * 初始化插件系统：注册表 + hook runner + 内置插件 + 外部插件发现。
+ *
+ * 失败的外部插件被静默跳过（loader 已处理），单个坏插件不影响其余加载。
+ * 内置插件（tool-audit-log / write-guard）始终激活。
+ */
+declare function initPlugins(opts: InitPluginsOptions): Promise<InitPluginsResult>;
+export type { InitPluginsOptions, InitPluginsResult };
+export { initPlugins };

package/dist/plugins/init.js

@@ -0,0 +1,30 @@
+import { registerBuiltinHooks } from './builtin.js';
+import { createHookRunner } from './hooks.js';
+import { activatePlugin } from './lifecycle.js';
+import { discoverPlugins } from './loader.js';
+import { createPluginRegistry, registerPlugin } from './registry.js';
+/**
+ * 初始化插件系统：注册表 + hook runner + 内置插件 + 外部插件发现。
+ *
+ * 失败的外部插件被静默跳过（loader 已处理），单个坏插件不影响其余加载。
+ * 内置插件（tool-audit-log / write-guard）始终激活。
+ */
+async function initPlugins(opts) {
+    const hookRunner = createHookRunner();
+    const pluginRegistry = createPluginRegistry(hookRunner);
+    const services = {
+        config: opts.config,
+        toolRegistry: opts.toolRegistry,
+        llmRegistry: opts.llmRegistry,
+    };
+    // 内置插件先激活：它们注册 tool:before/after hook，对后续外部插件同样生效。
+    await registerBuiltinHooks(pluginRegistry, services);
+    // 发现并加载外部插件（项目 .c0de/plugins 与全局 ~/.c0de/plugins）。
+    const discovered = await discoverPlugins(opts.cwd);
+    for (const { plugin } of discovered) {
+        registerPlugin(pluginRegistry, plugin);
+        await activatePlugin(pluginRegistry, plugin, services);
+    }
+    return { pluginRegistry, hookRunner };
+}
+export { initPlugins };

package/dist/plugins/lifecycle.d.ts

@@ -0,0 +1,6 @@
+import type { HookRunner, Plugin, PluginContext, PluginRegistry, PluginServices } from './types.js';
+declare function createPluginContext(services: PluginServices, hookRunner: HookRunner, disposeHandlers: (() => void | Promise<void>)[]): PluginContext;
+declare function activatePlugin(registry: PluginRegistry, plugin: Plugin, services: PluginServices): Promise<void>;
+declare function deactivatePlugin(registry: PluginRegistry, name: string): Promise<void>;
+declare function deactivateAll(registry: PluginRegistry): Promise<void>;
+export { activatePlugin, createPluginContext, deactivateAll, deactivatePlugin };

package/dist/plugins/lifecycle.js

@@ -0,0 +1,74 @@
+// src/plugins/lifecycle.ts
+import { registerProvider as registerLLMProvider } from '../llm/registry.js';
+import { registerTool } from '../tools/registry.js';
+import { createLogger } from './logger.js';
+function createPluginContext(services, hookRunner, disposeHandlers) {
+    const toolRegistry = services.toolRegistry;
+    const llmRegistry = services.llmRegistry;
+    return {
+        registerTool: (tool) => {
+            registerTool(toolRegistry, tool);
+        },
+        registerProvider: (provider) => {
+            if (provider.baseURL) {
+                registerLLMProvider(llmRegistry, {
+                    name: provider.name,
+                    baseURL: provider.baseURL,
+                    apiKey: provider.apiKey,
+                });
+            }
+        },
+        on: hookRunner.on,
+        off: hookRunner.off,
+        getConfig: () => services.config,
+        getLogger: (name) => createLogger(name),
+        onDispose: (handler) => {
+            disposeHandlers.push(handler);
+        },
+    };
+}
+async function activatePlugin(registry, plugin, services) {
+    const record = registry.plugins.get(plugin.name);
+    if (!record)
+        return;
+    if (record.status === 'active')
+        return;
+    const ctx = createPluginContext(services, registry.hookRunner, record.disposeHandlers);
+    try {
+        await plugin.setup(ctx);
+        record.status = 'active';
+        record.error = undefined;
+    }
+    catch (err) {
+        record.status = 'error';
+        record.error = err instanceof Error ? err.message : String(err);
+    }
+}
+async function deactivatePlugin(registry, name) {
+    const record = registry.plugins.get(name);
+    if (!record)
+        return;
+    for (const handler of record.disposeHandlers) {
+        try {
+            await handler();
+        }
+        catch {
+            // Dispose errors are non-fatal
+        }
+    }
+    record.disposeHandlers = [];
+    if (record.plugin.dispose) {
+        try {
+            await record.plugin.dispose();
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+    record.status = 'inactive';
+}
+async function deactivateAll(registry) {
+    const names = Array.from(registry.plugins.keys());
+    await Promise.all(names.map((name) => deactivatePlugin(registry, name)));
+}
+export { activatePlugin, createPluginContext, deactivateAll, deactivatePlugin };

package/dist/plugins/loader.d.ts

@@ -0,0 +1,16 @@
+import type { Plugin } from './types.js';
+type ValidationResult = {
+    valid: true;
+    plugin: Plugin;
+} | {
+    valid: false;
+    error: string;
+};
+declare function validatePluginModule(mod: unknown): ValidationResult;
+declare function loadPlugin(path: string): Promise<Plugin>;
+declare function discoverPlugins(projectDir: string): Promise<{
+    name: string;
+    path: string;
+    plugin: Plugin;
+}[]>;
+export { discoverPlugins, loadPlugin, validatePluginModule };

package/dist/plugins/loader.js

@@ -0,0 +1,68 @@
+// src/plugins/loader.ts
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+function validatePluginModule(mod) {
+    const candidate = mod?.default ?? mod;
+    if (typeof candidate !== 'object' || candidate === null) {
+        return { valid: false, error: 'Plugin module must export an object' };
+    }
+    const obj = candidate;
+    if (typeof obj.name !== 'string' || obj.name.length === 0) {
+        return { valid: false, error: 'Plugin must have a non-empty "name" string' };
+    }
+    if (typeof obj.version !== 'string') {
+        return { valid: false, error: 'Plugin must have a "version" string' };
+    }
+    if (typeof obj.setup !== 'function') {
+        return { valid: false, error: 'Plugin must have a "setup" function' };
+    }
+    return { valid: true, plugin: obj };
+}
+async function loadPlugin(path) {
+    // 动态导入运行时扫描到的插件路径，Vite 无法静态分析，故显式忽略
+    const mod = await import(/* @vite-ignore */ path);
+    const result = validatePluginModule(mod);
+    if (!result.valid) {
+        throw new Error(`Invalid plugin at ${path}: ${result.error}`);
+    }
+    return result.plugin;
+}
+function scanPluginDir(dir) {
+    if (!existsSync(dir))
+        return [];
+    const entries = readdirSync(dir);
+    const plugins = [];
+    for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        try {
+            if (!statSync(fullPath).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const indexPath = join(fullPath, 'index.js');
+        if (existsSync(indexPath)) {
+            plugins.push({ name: entry, path: fullPath });
+        }
+    }
+    return plugins;
+}
+async function discoverPlugins(projectDir) {
+    const projectPluginsDir = join(projectDir, '.c0de', 'plugins');
+    const globalPluginsDir = join(homedir(), '.c0de', 'plugins');
+    const discovered = [...scanPluginDir(projectPluginsDir), ...scanPluginDir(globalPluginsDir)];
+    const results = [];
+    for (const entry of discovered) {
+        try {
+            const plugin = await loadPlugin(join(entry.path, 'index.js'));
+            results.push({ name: entry.name, path: entry.path, plugin });
+        }
+        catch {
+            // Skip plugins that fail to load
+        }
+    }
+    return results;
+}
+export { discoverPlugins, loadPlugin, validatePluginModule };

package/dist/plugins/logger.d.ts

@@ -0,0 +1,4 @@
+import type { Logger, LogLevel } from './types.js';
+/** Create a named, level-filtered logger that writes to console. */
+declare function createLogger(name: string, level?: LogLevel): Logger;
+export { createLogger };

package/dist/plugins/logger.js

@@ -0,0 +1,31 @@
+const LEVEL_ORDER = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    silent: 4,
+};
+/** Create a named, level-filtered logger that writes to console. */
+function createLogger(name, level = 'info') {
+    const prefix = `[${name}]`;
+    const shouldLog = (target) => LEVEL_ORDER[level] <= LEVEL_ORDER[target];
+    return {
+        debug: (msg, ...args) => {
+            if (shouldLog('debug'))
+                console.debug(prefix, msg, ...args);
+        },
+        info: (msg, ...args) => {
+            if (shouldLog('info'))
+                console.info(prefix, msg, ...args);
+        },
+        warn: (msg, ...args) => {
+            if (shouldLog('warn'))
+                console.warn(prefix, msg, ...args);
+        },
+        error: (msg, ...args) => {
+            if (shouldLog('error'))
+                console.error(prefix, msg, ...args);
+        },
+    };
+}
+export { createLogger };

package/dist/plugins/registry.d.ts

@@ -0,0 +1,7 @@
+import type { HookRunner, Plugin, PluginRecord, PluginRegistry } from './types.js';
+declare function createPluginRegistry(hookRunner: HookRunner): PluginRegistry;
+declare function registerPlugin(registry: PluginRegistry, plugin: Plugin): void;
+declare function getPlugin(registry: PluginRegistry, name: string): PluginRecord | undefined;
+declare function listPlugins(registry: PluginRegistry): PluginRecord[];
+declare function unregisterPlugin(registry: PluginRegistry, name: string): boolean;
+export { createPluginRegistry, getPlugin, listPlugins, registerPlugin, unregisterPlugin };

package/dist/plugins/registry.js

@@ -0,0 +1,24 @@
+function createPluginRegistry(hookRunner) {
+    return {
+        plugins: new Map(),
+        hookRunner,
+    };
+}
+function registerPlugin(registry, plugin) {
+    const record = {
+        plugin,
+        status: 'loaded',
+        disposeHandlers: [],
+    };
+    registry.plugins.set(plugin.name, record);
+}
+function getPlugin(registry, name) {
+    return registry.plugins.get(name);
+}
+function listPlugins(registry) {
+    return Array.from(registry.plugins.values());
+}
+function unregisterPlugin(registry, name) {
+    return registry.plugins.delete(name);
+}
+export { createPluginRegistry, getPlugin, listPlugins, registerPlugin, unregisterPlugin };