c0de-agent 1.2.0 → 1.3.0

package/dist/core/workflows/context.js

@@ -0,0 +1,232 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative, resolve } from 'node:path';
+/** SubAgentResult → WorkflowAgentResult 映射。 */
+function mapResult(result) {
+    if (result._tag === 'success') {
+        return { ok: true, output: result.output, data: result.data };
+    }
+    if (result._tag === 'error') {
+        return { ok: false, error: result.error };
+    }
+    return { ok: false, error: 'subagent returned running (background not supported in workflows)' };
+}
+/** 构建 WorkflowContext，注入 runSubagent/utils/progress。 */
+function buildWorkflowContext(opts) {
+    const { deps, parent, args, onProgress, projectName, runSubAgentFn } = opts;
+    const rootDir = deps.cwd;
+    // 默认 runSubAgent：通过动态 import 避免循环依赖
+    const doRunSubAgent = runSubAgentFn ??
+        (async (request) => {
+            const { runSubAgent } = await import('../loop.js');
+            return runSubAgent(deps, parent, request);
+        });
+    return {
+        project: {
+            rootDir,
+            name: projectName ?? 'project',
+        },
+        args,
+        runSubagent: async (type, params) => {
+            const result = await doRunSubAgent({
+                agentType: type,
+                prompt: params.assignment,
+                description: params.description,
+                model: params.model,
+            });
+            return mapResult(result);
+        },
+        runSubagents: async (type, tasks, context) => {
+            const { mapWithConcurrencyLimit } = await import('../agents/parallel.js');
+            const concurrency = 3;
+            const { results } = await mapWithConcurrencyLimit(tasks, concurrency, async (task) => {
+                try {
+                    const result = await doRunSubAgent({
+                        agentType: type,
+                        prompt: task.assignment,
+                        description: task.description,
+                        role: task.role,
+                        context,
+                    });
+                    return mapResult(result);
+                }
+                catch (e) {
+                    // 隔离单个任务的异常：不向上抛，避免 mapWithConcurrencyLimit 的
+                    // fail-fast 终止所有尚未启动的兄弟任务。按合约返回 per-task { ok: false }。
+                    return {
+                        ok: false,
+                        error: e instanceof Error ? e.message : String(e),
+                    };
+                }
+            });
+            return results.filter((r) => r !== undefined);
+        },
+        progress: onProgress,
+        utils: {
+            glob: async (pattern) => {
+                return globRecursive(rootDir, pattern);
+            },
+            grep: async (pattern, searchPath) => {
+                const baseDir = searchPath ? resolve(rootDir, searchPath) : rootDir;
+                return grepRecursive(baseDir, pattern, rootDir);
+            },
+            read: async (filePath, range) => {
+                const absPath = resolve(rootDir, filePath);
+                const content = await readFile(absPath, 'utf-8');
+                if (!range)
+                    return content;
+                const lines = content.split('\n');
+                return lines.slice(range.start - 1, range.end).join('\n');
+            },
+            splitByDirectory: async (dir, opts) => {
+                return splitByDir(resolve(rootDir, dir), opts?.depth ?? 1, opts?.ignore ?? []);
+            },
+        },
+    };
+}
+// ── 工具函数 ──
+/** 递归 glob（简单实现，匹配文件名后缀或通配符）。 */
+async function globRecursive(rootDir, pattern) {
+    const results = [];
+    const regex = new RegExp(pattern.replace(/\./g, '\\.').replace(/\*/g, '.*'));
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                continue;
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else if (regex.test(entry.name)) {
+                results.push(relative(rootDir, fullPath));
+            }
+        }
+    }
+    await walk(rootDir);
+    return results;
+}
+/** 递归 grep（正则搜索文件内容）。 */
+async function grepRecursive(baseDir, pattern, rootDir) {
+    const results = [];
+    let regex;
+    try {
+        regex = new RegExp(pattern);
+    }
+    catch {
+        regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    }
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                continue;
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else {
+                try {
+                    const content = await readFile(fullPath, 'utf-8');
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i];
+                        if (line && regex.test(line)) {
+                            results.push({
+                                path: relative(rootDir, fullPath),
+                                line: i + 1,
+                                text: line.trim(),
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // 二进制文件等，跳过
+                }
+            }
+        }
+    }
+    await walk(baseDir);
+    return results;
+}
+/**
+ * 按目录拆分模块。depth=N 时从 rootDir 向下走 N 层，每棵深度为 N 的子目录成为一个模块；
+ * 深度不足 N 的叶子目录（没有子目录）也成为一个模块，避免被跳过。
+ * 模块名 = 相对 rootDir 的路径（如 "src/a"）；rootDir 自身成为模块时命名为 "root"。
+ */
+async function splitByDir(rootDir, depth, ignore) {
+    const modules = [];
+    async function collectFiles(dir) {
+        const files = [];
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return files;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                continue;
+            if (ignore.includes(entry.name))
+                continue;
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...(await collectFiles(fullPath)));
+            }
+            else {
+                files.push(relative(rootDir, fullPath));
+            }
+        }
+        return files;
+    }
+    async function readSubdirs(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        return entries.filter((e) => e.isDirectory() && !e.name.startsWith('.') && !ignore.includes(e.name));
+    }
+    async function pushModule(dir) {
+        const rel = relative(rootDir, dir);
+        modules.push({
+            name: rel === '' ? 'root' : rel,
+            path: dir,
+            files: await collectFiles(dir),
+        });
+    }
+    async function collectModules(currentDir, currentDepth) {
+        // 到达目标深度：当前目录成为模块
+        if (currentDepth >= depth) {
+            await pushModule(currentDir);
+            return;
+        }
+        // 未到达目标深度：继续向下走
+        const subdirs = await readSubdirs(currentDir);
+        // 深度不足 N 的叶子目录（无子目录）：成为模块，避免被跳过
+        if (subdirs.length === 0) {
+            await pushModule(currentDir);
+            return;
+        }
+        for (const subdir of subdirs) {
+            await collectModules(join(currentDir, subdir.name), currentDepth + 1);
+        }
+    }
+    await collectModules(rootDir, 0);
+    return modules;
+}
+export { buildWorkflowContext };

package/dist/core/workflows/discovery.d.ts

@@ -0,0 +1,11 @@
+import type { WorkflowEntry } from './types.js';
+/**
+ * 扫描项目目录下的 `.c0de/workflows/*.js` 文件，source 标记为 'project'。
+ */
+declare function discoverWorkflows(projectDir: string): Promise<WorkflowEntry[]>;
+/**
+ * 扫描全局 `~/.c0de/workflows/*.js` 文件，source 标记为 'user'。
+ * 目录不存在时返回空数组（与项目级一致）。
+ */
+declare function discoverGlobalWorkflows(): Promise<WorkflowEntry[]>;
+export { discoverGlobalWorkflows, discoverWorkflows };

package/dist/core/workflows/discovery.js

@@ -0,0 +1,69 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+/** 项目级工作流目录相对路径。 */
+const PROJECT_WORKFLOWS_DIR = '.c0de/workflows';
+/** 用户级（全局）工作流目录：~/.c0de/workflows。 */
+const GLOBAL_WORKFLOWS_DIR = join('.c0de', 'workflows');
+/**
+ * 扫描指定目录下的 `*.js` 工作流文件，dynamic import 后转为 WorkflowEntry。
+ * import 失败的文件跳过（warn），不阻塞其他工作流加载。
+ *
+ * 由 discoverWorkflows（projectDir）与 discoverGlobalWorkflows（~/.c0de/workflows）复用，
+ * 仅 dirPath 与 source 字段不同。
+ */
+async function discoverFromDir(dirPath, source) {
+    const entries = [];
+    let files;
+    try {
+        const dirents = await readdir(dirPath);
+        files = dirents.filter((f) => f.endsWith('.js'));
+    }
+    catch {
+        // 目录不存在或不可读 → 返回空
+        return entries;
+    }
+    for (const file of files) {
+        const filePath = join(dirPath, file);
+        try {
+            const sourceCode = await readFile(filePath, 'utf-8');
+            const fileUrl = pathToFileURL(filePath).href;
+            const mod = (await import(fileUrl));
+            if (!mod.meta || typeof mod.default !== 'function') {
+                console.warn(`[workflow] skipping ${file}: missing meta or default export`);
+                continue;
+            }
+            // meta.name 缺省时取文件名（去 .js）
+            const meta = {
+                ...mod.meta,
+                name: mod.meta.name ?? basename(file, '.js'),
+            };
+            entries.push({
+                meta,
+                source,
+                filePath,
+                sourceCode,
+                execute: mod.default,
+            });
+        }
+        catch (e) {
+            console.warn(`[workflow] failed to load ${file}: ${e instanceof Error ? e.message : e}`);
+        }
+    }
+    return entries;
+}
+/**
+ * 扫描项目目录下的 `.c0de/workflows/*.js` 文件，source 标记为 'project'。
+ */
+async function discoverWorkflows(projectDir) {
+    return discoverFromDir(join(projectDir, PROJECT_WORKFLOWS_DIR), 'project');
+}
+/**
+ * 扫描全局 `~/.c0de/workflows/*.js` 文件，source 标记为 'user'。
+ * 目录不存在时返回空数组（与项目级一致）。
+ */
+async function discoverGlobalWorkflows() {
+    return discoverFromDir(join(homedir(), GLOBAL_WORKFLOWS_DIR), 'user');
+}
+export { discoverGlobalWorkflows, discoverWorkflows };

package/dist/core/workflows/index.d.ts

@@ -0,0 +1,7 @@
+export { BUILTIN_WORKFLOWS, createBuiltinWorkflows } from './builtins.js';
+export { buildWorkflowContext } from './context.js';
+export { discoverGlobalWorkflows, discoverWorkflows } from './discovery.js';
+export type { WorkflowRegistry } from './registry.js';
+export { createAndPopulateRegistry, createWorkflowRegistry } from './registry.js';
+export { executeWorkflow } from './runtime.js';
+export type { WorkflowAgentResult, WorkflowContext, WorkflowEntry, WorkflowMeta, WorkflowModule, WorkflowResult, WorkflowSource, WorkflowUtils, } from './types.js';

package/dist/core/workflows/index.js

@@ -0,0 +1,5 @@
+export { BUILTIN_WORKFLOWS, createBuiltinWorkflows } from './builtins.js';
+export { buildWorkflowContext } from './context.js';
+export { discoverGlobalWorkflows, discoverWorkflows } from './discovery.js';
+export { createAndPopulateRegistry, createWorkflowRegistry } from './registry.js';
+export { executeWorkflow } from './runtime.js';

package/dist/core/workflows/registry.d.ts

@@ -0,0 +1,20 @@
+import type { WorkflowEntry } from './types.js';
+/** 工作流注册表：内存 Map<name, WorkflowEntry>，后注册覆盖同名。 */
+declare function createWorkflowRegistry(): {
+    register(entry: WorkflowEntry): void;
+    get(name: string): WorkflowEntry | undefined;
+    list(): WorkflowEntry[];
+    has(name: string): boolean;
+    delete(name: string): boolean;
+};
+type WorkflowRegistry = ReturnType<typeof createWorkflowRegistry>;
+/**
+ * 创建并填充工作流注册表（三级发现，后注册覆盖同名）：
+ *  1. 注册内置工作流（builtin）
+ *  2. 发现并注册全局 `~/.c0de/workflows/*.js`（user）
+ *  3. 发现并注册项目 `.c0de/workflows/*.js`（project）
+ * 覆盖优先级：project > user > builtin。
+ */
+declare function createAndPopulateRegistry(projectDir: string): Promise<WorkflowRegistry>;
+export type { WorkflowRegistry };
+export { createAndPopulateRegistry, createWorkflowRegistry };

package/dist/core/workflows/registry.js

@@ -0,0 +1,49 @@
+import { createBuiltinWorkflows } from './builtins.js';
+import { discoverGlobalWorkflows, discoverWorkflows } from './discovery.js';
+/** 工作流注册表：内存 Map<name, WorkflowEntry>，后注册覆盖同名。 */
+function createWorkflowRegistry() {
+    const entries = new Map();
+    return {
+        register(entry) {
+            entries.set(entry.meta.name, entry);
+        },
+        get(name) {
+            return entries.get(name);
+        },
+        list() {
+            return Array.from(entries.values());
+        },
+        has(name) {
+            return entries.has(name);
+        },
+        delete(name) {
+            return entries.delete(name);
+        },
+    };
+}
+/**
+ * 创建并填充工作流注册表（三级发现，后注册覆盖同名）：
+ *  1. 注册内置工作流（builtin）
+ *  2. 发现并注册全局 `~/.c0de/workflows/*.js`（user）
+ *  3. 发现并注册项目 `.c0de/workflows/*.js`（project）
+ * 覆盖优先级：project > user > builtin。
+ */
+async function createAndPopulateRegistry(projectDir) {
+    const registry = createWorkflowRegistry();
+    // 1. 内置（由源码字符串动态导入生成，show === run）
+    for (const wf of await createBuiltinWorkflows()) {
+        registry.register(wf);
+    }
+    // 2. 全局级（~/.c0de/workflows）
+    const globalWorkflows = await discoverGlobalWorkflows();
+    for (const wf of globalWorkflows) {
+        registry.register(wf);
+    }
+    // 3. 项目级（.c0de/workflows）
+    const projectWorkflows = await discoverWorkflows(projectDir);
+    for (const wf of projectWorkflows) {
+        registry.register(wf);
+    }
+    return registry;
+}
+export { createAndPopulateRegistry, createWorkflowRegistry };

package/dist/core/workflows/runtime.d.ts

@@ -0,0 +1,18 @@
+import type { AgentDependencies, AgentState, CommandResult } from '../types.js';
+import type { WorkflowRegistry } from './registry.js';
+/** executeWorkflow 的参数。 */
+type ExecuteWorkflowOpts = {
+    registry: WorkflowRegistry;
+    name: string;
+    args: string;
+    deps: AgentDependencies;
+    parent: AgentState;
+    onProgress?: (message: string, detail?: unknown) => void;
+};
+/**
+ * 执行工作流：查注册表 → 构建 ctx → 调用 entry.execute → 返回 CommandResult。
+ *
+ * 工作流 return 的 output 作为 text 返回；异常捕获为 error。
+ */
+declare function executeWorkflow(opts: ExecuteWorkflowOpts): Promise<CommandResult>;
+export { executeWorkflow };

package/dist/core/workflows/runtime.js

@@ -0,0 +1,70 @@
+import { buildWorkflowContext } from './context.js';
+/** 工作流超时错误（用于 Promise.race 中识别超时）。 */
+class WorkflowTimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WorkflowTimeoutError';
+    }
+}
+/** 等待 ms 后 reject，timer.unref() 保证不阻塞 Node 退出。 */
+function createTimeoutPromise(timeoutMs, timeoutSeconds) {
+    return new Promise((_, reject) => {
+        const timer = setTimeout(() => reject(new WorkflowTimeoutError(`timed out after ${timeoutSeconds}s`)), timeoutMs);
+        if (typeof timer === 'object' && 'unref' in timer)
+            timer.unref();
+    });
+}
+/**
+ * 执行工作流：查注册表 → 构建 ctx → 调用 entry.execute → 返回 CommandResult。
+ *
+ * 工作流 return 的 output 作为 text 返回；异常捕获为 error。
+ */
+async function executeWorkflow(opts) {
+    const { registry, name, args, deps, parent, onProgress } = opts;
+    const entry = registry.get(name);
+    if (!entry) {
+        const available = registry
+            .list()
+            .map((e) => e.meta.name)
+            .join(', ');
+        return {
+            _tag: 'error',
+            message: `Unknown workflow: "${name}". Available: ${available || '(none)'}`,
+        };
+    }
+    const ctx = buildWorkflowContext({
+        deps,
+        parent,
+        args,
+        onProgress: onProgress ?? (() => { }),
+    });
+    const { timeout } = entry.meta;
+    const hasTimeout = typeof timeout === 'number' && timeout > 0;
+    const timeoutSeconds = hasTimeout ? timeout : undefined;
+    try {
+        const execPromise = entry.execute(ctx);
+        const result = timeoutSeconds !== undefined
+            ? await Promise.race([
+                execPromise,
+                createTimeoutPromise(timeoutSeconds * 1000, timeoutSeconds),
+            ])
+            : await execPromise;
+        return {
+            _tag: 'text',
+            text: result.output ?? 'Workflow completed (no output).',
+        };
+    }
+    catch (e) {
+        if (e instanceof WorkflowTimeoutError) {
+            return {
+                _tag: 'error',
+                message: `Workflow "${name}" timed out after ${timeoutSeconds}s`,
+            };
+        }
+        return {
+            _tag: 'error',
+            message: `Workflow "${name}" failed: ${e instanceof Error ? e.message : String(e)}`,
+        };
+    }
+}
+export { executeWorkflow };

package/dist/core/workflows/types.d.ts

@@ -0,0 +1,95 @@
+/** 工作流元数据（脚本导出的 meta 对象）。 */
+interface WorkflowMeta {
+    /** 唯一标识，同时也是 slash 命令名。 */
+    name: string;
+    /** 显示用描述。 */
+    description: string;
+    /** 参数提示（如 '[扫描目标描述]'）。 */
+    argsHint?: string;
+    /** 执行阶段标签（用于进度展示）。 */
+    phases?: string[];
+    /** 超时（秒），超时终止。 */
+    timeout?: number;
+}
+/** 工作流执行结果。 */
+type WorkflowResult = {
+    /** 人类可读总结（显示给用户）。 */
+    output?: string;
+    /** 结构化数据（存档/程序化消费）。 */
+    data?: unknown;
+};
+/** 子 agent 返回结果（区分成功/失败）。 */
+type WorkflowAgentResult = {
+    ok: true;
+    output: string;
+    data?: unknown;
+} | {
+    ok: false;
+    error: string;
+};
+/** 工作流内置工具集（受限文件系统操作）。 */
+interface WorkflowUtils {
+    glob: (pattern: string) => Promise<string[]>;
+    grep: (pattern: string, path?: string) => Promise<Array<{
+        path: string;
+        line: number;
+        text: string;
+    }>>;
+    read: (filePath: string, range?: {
+        start: number;
+        end: number;
+    }) => Promise<string>;
+    splitByDirectory: (rootDir: string, opts?: {
+        depth?: number;
+        ignore?: string[];
+    }) => Promise<Array<{
+        name: string;
+        path: string;
+        files: string[];
+    }>>;
+}
+/** 工作流上下文（注入给脚本 default 函数的参数）。 */
+interface WorkflowContext {
+    /** 项目信息。 */
+    project: {
+        rootDir: string;
+        name: string;
+        gitBranch?: string;
+    };
+    /** 用户传入的参数字符串。 */
+    args: string;
+    /** 派发单个子 agent。委托 runSubAgent。 */
+    runSubagent: (type: string, params: {
+        assignment: string;
+        description?: string;
+        model?: string;
+    }) => Promise<WorkflowAgentResult>;
+    /** 批量并行派发子 agent。委托 runSubAgent，concurrency pool。 */
+    runSubagents: (type: string, tasks: Array<{
+        assignment: string;
+        description?: string;
+        role?: string;
+    }>, context?: string) => Promise<WorkflowAgentResult[]>;
+    /** 进度上报（→ SSE → 前端）。 */
+    progress: (message: string, detail?: unknown) => void;
+    /** 内置工具。 */
+    utils: WorkflowUtils;
+}
+/** 工作流脚本模块（dynamic import 后的形状）。 */
+interface WorkflowModule {
+    meta: WorkflowMeta;
+    default: (ctx: WorkflowContext) => Promise<WorkflowResult>;
+}
+/** 工作流来源层级（后注册覆盖同名：project > user > builtin）。 */
+type WorkflowSource = 'builtin' | 'user' | 'project';
+/** 注册表中的条目。 */
+interface WorkflowEntry {
+    meta: WorkflowMeta;
+    source: WorkflowSource;
+    filePath?: string;
+    /** 执行器。 */
+    execute: (ctx: WorkflowContext) => Promise<WorkflowResult>;
+    /** 源码文本（show 命令和编辑用）。 */
+    sourceCode?: string;
+}
+export type { WorkflowAgentResult, WorkflowContext, WorkflowEntry, WorkflowMeta, WorkflowModule, WorkflowResult, WorkflowSource, WorkflowUtils, };

package/dist/core/workflows/types.js

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

package/dist/server/app.js

@@ -21,6 +21,7 @@ import { createSessionRoute } from './routes/session.js';
 import { createTerminalRoute } from './routes/terminal.js';
 import { createToolRoute } from './routes/tool.js';
 import { createUpdateRoute } from './routes/update.js';
+import { createWorkflowsRoute } from './routes/workflows.js';
 /** 创建完整的 Hono 应用，挂载所有路由 + 中间件。 */
 function createApp(ctx) {
     const app = new Hono();
@@ -46,6 +47,7 @@ function createApp(ctx) {
     app.route('/api/permissions', createPermissionsRoute(ctx));
     app.route('/api/files', createFilesRoute(ctx));
     app.route('/api/terminal', createTerminalRoute(ctx));
+    app.route('/api/workflows', createWorkflowsRoute(ctx));
     // 根路径
     app.get('/', (c) => c.json({
         name: 'c0de-agent',
@@ -66,6 +68,7 @@ function createApp(ctx) {
             '/api/permissions',
             '/api/files',
             '/api/terminal',
+            '/api/workflows',
         ],
     }));
     // 静态文件服务（生产环境 dist-web/ 存在时启用）

package/dist/server/context.js

@@ -1,6 +1,7 @@
 // src/server/context.ts
 import { BUILTIN_AGENTS, createAgentRegistry } from '../core/agents/index.js';
 import { DEFAULT_CONFIG, mergeConfig } from '../core/config.js';
+import { BUILTIN_WORKFLOWS, createWorkflowRegistry } from '../core/workflows/index.js';
 import { createHookRunner, createPluginRegistry } from '../plugins/index.js';
 import { createDefaultRegistry, createDefaultURLRegistry } from '../tools/index.js';
 import { createUpdateScheduler } from '../update/index.js';
@@ -21,6 +22,7 @@ function createServerContext(opts) {
                 reg.register(def);
             return reg;
         })();
+    let _workflowRegistry;
     return {
         db: opts.db,
         config,
@@ -33,6 +35,15 @@ function createServerContext(opts) {
         permissionStore: createPermissionStore(),
         permissionMode: config.permission.defaultMode,
         agentRegistry,
+        // 工作流注册表：惰性初始化，只含内置（项目级 discovery 由 bootstrap 或 API 触发热加载）。
+        get workflowRegistry() {
+            if (!_workflowRegistry) {
+                _workflowRegistry = createWorkflowRegistry();
+                for (const wf of BUILTIN_WORKFLOWS)
+                    _workflowRegistry.register(wf);
+            }
+            return _workflowRegistry;
+        },
         // 测试上下文：默认 scheduler 不启动（enabled=false 由调用方控制）。
         updateScheduler: createUpdateScheduler({
             checkFn: async () => ({