alanbox 0.1.1

package/0commondflowv1/src/core/handoff.js

@@ -0,0 +1,100 @@
+/**
+ * handoff 辅助函数。
+ * 提取 HANDOFF_JSON，并为后续 worker 构造精简的上游上下文。
+ */
+
+function buildPriorResultsContext(priorResults) {
+  if (priorResults.length === 0) return '';
+  return [
+    '上游 worker 已完成结果。以下内容来自结构化 handoff memory，请优先参考字段，不要解析完整 stdout：',
+    ...priorResults.map((item) => [
+      `- ${item.id} (${item.worker}/${item.role})`,
+      `  memory key: ${item.memoryKey}`,
+      `  memory file: ${item.memoryPath}`,
+      `  output file: ${item.outputPath}`,
+      `  status: ${item.handoff.value.status}`,
+      `  summary: ${item.handoff.value.summary}`,
+      item.handoff.value.files.length ? `  files: ${item.handoff.value.files.join(', ')}` : '',
+      item.handoff.value.findings.length ? `  findings: ${item.handoff.value.findings.join('；')}` : '',
+      item.handoff.value.nextSteps.length ? `  nextSteps: ${item.handoff.value.nextSteps.join('；')}` : '',
+      item.handoff.value.verification.length ? `  verification: ${item.handoff.value.verification.join('；')}` : '',
+    ].filter(Boolean).join('\n')),
+  ].join('\n');
+}
+
+function buildWorkerHandoff(task, result, outputPath) {
+  const parsed = extractHandoffJson(result.stdout || '');
+  const fallbackSummary = compactText(result.stdout || result.stderr).slice(0, 180);
+  const value = normalizeHandoff(parsed, {
+    status: result.code === 0 ? 'completed' : 'failed',
+    summary: fallbackSummary || `worker ${task.id} exited with code ${result.code}`,
+    artifacts: [outputPath],
+  });
+
+  if (!value.artifacts.includes(outputPath)) {
+    value.artifacts.push(outputPath);
+  }
+
+  return {
+    key: `${task.id}-result`,
+    namespace: task.namespace,
+    worker: task.worker,
+    role: task.role,
+    parsed: Boolean(parsed),
+    value,
+  };
+}
+
+function extractHandoffJson(text) {
+  const source = String(text || '');
+  const patterns = [
+    /```HANDOFF_JSON\s*([\s\S]*?)```/i,
+    /```json\s*([\s\S]*?"status"[\s\S]*?)```/i,
+  ];
+
+  for (const pattern of patterns) {
+    const match = source.match(pattern);
+    if (!match) continue;
+    try {
+      return JSON.parse(match[1].trim());
+    } catch {
+      return null;
+    }
+  }
+
+  return null;
+}
+
+function normalizeHandoff(value, fallback) {
+  const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  const status = ['completed', 'blocked', 'failed'].includes(source.status) ? source.status : fallback.status;
+  return {
+    status,
+    summary: compactText(source.summary || fallback.summary).slice(0, 240),
+    files: normalizeStringArray(source.files),
+    findings: normalizeStringArray(source.findings),
+    nextSteps: normalizeStringArray(source.nextSteps),
+    artifacts: normalizeStringArray(source.artifacts || fallback.artifacts),
+    verification: normalizeStringArray(source.verification),
+  };
+}
+
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => compactText(item)).filter(Boolean);
+}
+
+function compactText(text) {
+  return String(text || '').replace(/\s+/g, ' ').trim();
+}
+
+module.exports = {
+  buildPriorResultsContext,
+  buildWorkerHandoff,
+  extractHandoffJson,
+  normalizeHandoff,
+  normalizeStringArray,
+  compactText,
+};
+
+

package/0commondflowv1/src/core/prompt-builder.js

@@ -0,0 +1,93 @@
+/**
+ * prompt 构造辅助函数。
+ * 读取共享 context / skill 文件，并生成注入后的 multi-agent prompt。
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function readOptionalFile(filePath, cwd = process.cwd()) {
+  if (!filePath) return '';
+  const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+  return fs.readFileSync(resolved, 'utf8').trim();
+}
+
+function buildInjectedPrompt(input = {}) {
+  const {
+    role = 'worker',
+    worker = '',
+    platform = 'OpenAI Codex',
+    cwd = '',
+    namespace = 'sub-codex',
+    context = '',
+    task = '',
+    skill = '',
+    resultKey = '',
+    primary = false,
+  } = input;
+  const label = worker ? `${worker}/${role}` : role;
+  const handoffKey = resultKey || `${namespace}/${label}`;
+
+  const parts = [
+    `你是协作式 multi-agent swarm 中的 ${role.toUpperCase()} agent。`,
+    `平台：${platform}`,
+    worker ? `当前 worker：${worker}` : '',
+    cwd ? `工作目录：${cwd}` : '',
+    `共享命名空间：${namespace}`,
+    `结果键：${handoffKey}`,
+    primary
+      ? '职责：主 worker，负责形成可整合的主结论或主实现。'
+      : '职责：辅助 worker，负责独立完成分配的子任务，并输出可合并结果。',
+    '',
+    '协作协议：',
+    `1. 关键阶段可以输出短日志，格式为：[${label}][阶段] 内容。`,
+    '2. 阶段名称只使用：启动、读取、分析、修改、验证、完成、问题。',
+    '3. 只完成 YOUR TASK 分配给你的工作，不扩展到其他 worker 的职责。',
+    '4. 如果修改文件，只修改与子任务直接相关的文件。',
+    '5. 不要依赖长篇自然语言作为交接结果；最终必须输出结构化交接块。',
+    '6. 最终交接块必须是一个 fenced JSON 代码块，代码块标签固定为 HANDOFF_JSON。',
+    '7. JSON 必须是单个对象，稳定字段为：status、summary、files、findings、nextSteps、artifacts；可选字段 verification 用来记录验证证据。',
+    '8. status 只能是 completed、blocked、failed；files/findings/nextSteps/artifacts/verification 必须是数组。',
+    '9. summary 控制在 120 个中文字符以内；findings、nextSteps 和 verification 每项控制在 80 个中文字符以内。',
+    '10. 用中文输出。',
+    '',
+    '最终输出示例：',
+    '```HANDOFF_JSON',
+    JSON.stringify({
+      status: 'completed',
+      summary: '完成了指定检查，并记录关键风险。',
+      files: ['path/to/file.ts'],
+      findings: ['发现的关键问题'],
+      nextSteps: ['建议下一步动作'],
+      artifacts: ['%USERPROFILE%/.multirunagent/namespace/results/lead.md'],
+      verification: ['运行或检查过的证据'],
+    }, null, 2),
+    '```',
+    '',
+    context ? `共享背景：\n${context}` : '',
+    skill ? `注入 skill / 能力说明：\n${skill}` : '',
+    '',
+    `YOUR TASK:\n${task}`,
+    '',
+    '提醒：其他 agent 或主进程会优先读取你的 HANDOFF_JSON。自然语言说明可以有，但必须简短。',
+  ];
+
+  return parts.filter((part) => part !== '').join('\n');
+}
+
+function buildContext({ context, contextFile, skillFile, cwd }) {
+  const contextFromFile = readOptionalFile(contextFile, cwd);
+  const skill = readOptionalFile(skillFile, cwd);
+  return {
+    context: [context, contextFromFile].filter(Boolean).join('\n\n').trim(),
+    skill,
+  };
+}
+
+module.exports = {
+  buildInjectedPrompt,
+  buildContext,
+  readOptionalFile,
+};
+
+

package/0commondflowv1/src/core/prompt-templates.js

@@ -0,0 +1,92 @@
+/**
+ * Auto workflow prompt 模板辅助函数。
+ * 模板位于 0commondflowv1/src/prompt/<role>.md，role 会先清洗，找不到时回退到 default.md 或内联模板。
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { sanitizePathPart } = require('./storage');
+
+const PROMPT_ROOT = path.resolve(__dirname, '..', 'prompt');
+
+function renderRoleTemplate({ role, goal, task, cwd, constraints, expectedState }) {
+  const resolution = resolveRoleTemplate(role);
+  const variables = {
+    role: role || 'worker',
+    goal: goal || '',
+    task: task || '',
+    cwd: cwd || '',
+    constraints: constraints || '',
+    expectedState: expectedState || '',
+  };
+  const rendered = applyVariables(resolution.content, variables);
+  if (resolution.hasPlaceholders) {
+    return { text: rendered, resolution };
+  }
+
+  const text = [
+    rendered,
+    '',
+    '## 本次任务',
+    task || goal || '',
+    '',
+    cwd ? `工作目录：${cwd}` : '',
+    constraints ? `补充约束：${constraints}` : '',
+    expectedState ? `预期状态变化：${expectedState}` : '',
+  ].filter(Boolean).join('\n');
+  return { text, resolution };
+}
+
+function resolveRoleTemplate(role) {
+  const safeRole = sanitizePathPart(String(role || 'default').toLowerCase());
+  const candidates = [
+    { name: safeRole, path: path.join(PROMPT_ROOT, `${safeRole}.md`) },
+    { name: 'default', path: path.join(PROMPT_ROOT, 'default.md') },
+  ];
+
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate.path)) continue;
+    const content = fs.readFileSync(candidate.path, 'utf8').trim();
+    return {
+      role,
+      template: candidate.name,
+      path: candidate.path,
+      fallback: candidate.name !== safeRole,
+      inline: false,
+      hasPlaceholders: /{{\s*[A-Za-z]+\s*}}/.test(content),
+      content,
+    };
+  }
+
+  const content = [
+    `你是 {{role}} agent。`,
+    '目标：{{goal}}',
+    '任务：{{task}}',
+    '工作目录：{{cwd}}',
+    '约束：{{constraints}}',
+    '预期状态变化：{{expectedState}}',
+    '请用中文输出，并在最后给出 HANDOFF_JSON。',
+  ].join('\n');
+  return {
+    role,
+    template: 'inline-default',
+    path: '',
+    fallback: true,
+    inline: true,
+    hasPlaceholders: true,
+    content,
+  };
+}
+
+function applyVariables(template, variables) {
+  return String(template || '').replace(/{{\s*([A-Za-z]+)\s*}}/g, (match, key) => {
+    if (!Object.prototype.hasOwnProperty.call(variables, key)) return match;
+    return String(variables[key] || '');
+  });
+}
+
+module.exports = {
+  PROMPT_ROOT,
+  renderRoleTemplate,
+  resolveRoleTemplate,
+};

package/0commondflowv1/src/core/storage.js

@@ -0,0 +1,98 @@
+/**
+ * 本地运行结果存储辅助函数。
+ * 把 worker 输出和结构化 handoff memory 写入用户级 .multirunagent。
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function writeWorkerResult(resultDir, task, result) {
+  fs.mkdirSync(resultDir, { recursive: true });
+  const fileName = `${sanitizePathPart(task.id)}.md`;
+  const outputPath = path.join(resultDir, fileName);
+  const body = [
+    `# ${task.id}`,
+    '',
+    `worker: ${task.worker}`,
+    `role: ${task.role}`,
+    `code: ${result.code}`,
+    '',
+    '## stdout',
+    '',
+    result.stdout || '',
+    '',
+    '## stderr',
+    '',
+    result.stderr || '',
+  ].join('\n');
+  fs.writeFileSync(outputPath, body, 'utf8');
+  return outputPath;
+}
+
+function writeMemoryEntry(memoryDir, task, handoff) {
+  fs.mkdirSync(memoryDir, { recursive: true });
+  const fileName = `${sanitizePathPart(handoff.key)}.json`;
+  const memoryPath = path.join(memoryDir, fileName);
+  const body = {
+    namespace: handoff.namespace,
+    key: handoff.key,
+    worker: handoff.worker,
+    role: handoff.role,
+    updatedAt: new Date().toISOString(),
+    value: handoff.value,
+  };
+  fs.writeFileSync(memoryPath, JSON.stringify(body, null, 2), 'utf8');
+  updateMemoryIndex(memoryDir, body);
+  return memoryPath;
+}
+
+function updateMemoryIndex(memoryDir, entry) {
+  const indexPath = path.join(memoryDir, 'index.json');
+  let index = { entries: [] };
+  if (fs.existsSync(indexPath)) {
+    try {
+      index = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
+    } catch {
+      index = { entries: [] };
+    }
+  }
+
+  const entries = Array.isArray(index.entries) ? index.entries : [];
+  const nextEntries = entries.filter((item) => item.key !== entry.key);
+  nextEntries.push({
+    key: entry.key,
+    worker: entry.worker,
+    role: entry.role,
+    status: entry.value.status,
+    summary: entry.value.summary,
+    updatedAt: entry.updatedAt,
+  });
+  fs.writeFileSync(indexPath, JSON.stringify({ entries: nextEntries }, null, 2), 'utf8');
+}
+
+function getUserStateRoot() {
+  const homeDir = process.env.USERPROFILE || process.env.HOME;
+  if (!homeDir) {
+    throw new Error('cannot resolve user home directory for multirunagent state');
+  }
+  return path.join(homeDir, '.multirunagent');
+}
+
+function resolveRunDir(namespace) {
+  return path.join(getUserStateRoot(), sanitizePathPart(namespace));
+}
+
+function sanitizePathPart(value) {
+  return String(value || 'default').replace(/[^a-zA-Z0-9_.-]/g, '-').replace(/^-+|-+$/g, '') || 'default';
+}
+
+module.exports = {
+  writeWorkerResult,
+  writeMemoryEntry,
+  updateMemoryIndex,
+  getUserStateRoot,
+  resolveRunDir,
+  sanitizePathPart,
+};
+
+

package/0commondflowv1/src/core/swarm-executor.js

@@ -0,0 +1,167 @@
+/**
+ * 共享 swarm 执行器。
+ * 普通 swarm 和 auto workflow 都通过这里执行 task graph，避免复制 runner / handoff / storage 协议。
+ */
+
+const path = require('path');
+const {
+  accountNameForWorker,
+  resolveProvider,
+  execPrompt,
+} = require('../runner/codex-runner');
+const { buildInjectedPrompt } = require('./prompt-builder');
+const { buildDependencyLevels } = require('./workers');
+const { buildPriorResultsContext, buildWorkerHandoff } = require('./handoff');
+const { writeWorkerResult, writeMemoryEntry } = require('./storage');
+
+function buildCommonOptions(args, config) {
+  return {
+    config,
+    model: args.model || args.m,
+    profile: args.profile || (!args.auto ? args.p : ''),
+    sandbox: args.sandbox || args.s,
+    stream: false,
+  };
+}
+
+async function executeTaskGraph({
+  args,
+  config,
+  cwd,
+  tasks,
+  namespace,
+  runDir,
+  resultDir,
+  memoryDir,
+  injected,
+  failOnHandoffStatus = false,
+  onTaskStart,
+  onTaskFinish,
+}) {
+  const commonOptions = buildCommonOptions(args, config);
+  const levels = buildDependencyLevels(tasks);
+  const startedAt = Date.now();
+  const results = [];
+  const errors = [];
+  const priorResults = [];
+
+  for (const level of levels) {
+    const runs = level.map((task) => {
+      const promptContext = [injected.context, buildPriorResultsContext(priorResults)].filter(Boolean).join('\n\n').trim();
+      const providerName = task.provider || config.workers?.[task.worker]?.provider || config.defaultProvider || 'codex';
+      const prompt = buildInjectedPrompt({
+        role: task.role,
+        worker: task.worker,
+        platform: providerName === 'claude' ? 'Anthropic Claude Code' : 'OpenAI Codex',
+        cwd,
+        namespace,
+        context: promptContext,
+        skill: injected.skill,
+        task: task.prompt,
+        resultKey: `${namespace}/${task.worker}/${task.role}`,
+        primary: task.worker === config.primaryWorker,
+      });
+
+      if (typeof onTaskStart === 'function') {
+        onTaskStart(task, { priorResults: priorResults.slice() });
+      }
+      console.error(`[swarm] start ${task.worker}/${task.role}`);
+
+      return execPrompt(prompt, {
+        ...commonOptions,
+        worker: task.worker,
+        provider: task.provider,
+        account: resolveTaskAccount(config, task),
+        cwd,
+      }).then((result) => ({ task, result }));
+    });
+
+    const settled = await Promise.allSettled(runs);
+    for (const item of settled) {
+      if (item.status === 'rejected') {
+        const message = item.reason?.message || String(item.reason);
+        errors.push(message);
+        const entry = { ok: false, error: message };
+        results.push(entry);
+        if (typeof onTaskFinish === 'function') onTaskFinish(null, entry);
+        continue;
+      }
+
+      const task = item.value.task;
+      const result = item.value.result;
+      const okByExit = result.code === 0;
+      const outputPath = writeWorkerResult(resultDir, task, result);
+      const handoff = buildWorkerHandoff(task, result, outputPath);
+      const memoryPath = writeMemoryEntry(memoryDir, task, handoff);
+      const handoffParsedOk = !failOnHandoffStatus || handoff.parsed;
+      const handoffStatusOk = !failOnHandoffStatus || handoff.value.status === 'completed';
+      const handoffOk = handoffParsedOk && handoffStatusOk;
+      const ok = okByExit && handoffOk;
+      const priorResult = {
+        id: task.id,
+        worker: task.worker,
+        role: task.role,
+        outputPath,
+        memoryKey: handoff.key,
+        memoryPath,
+        handoff,
+      };
+      priorResults.push(priorResult);
+
+      if (!okByExit) {
+        errors.push(`${task.id}: exited with code ${result.code}`);
+      } else if (!handoffParsedOk) {
+        errors.push(`${task.id}: missing valid HANDOFF_JSON`);
+      } else if (!handoffStatusOk) {
+        errors.push(`${task.id}: handoff status ${handoff.value.status}`);
+      }
+
+      const entry = {
+        ok,
+        id: task.id,
+        worker: task.worker,
+        platform: task.platform,
+        role: task.role,
+        dependsOn: task.dependsOn,
+        code: result.code,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        outputPath,
+        memoryKey: handoff.key,
+        memoryPath,
+        handoff: handoff.value,
+        handoffParsed: handoff.parsed,
+      };
+      results.push(entry);
+      if (typeof onTaskFinish === 'function') onTaskFinish(task, entry);
+    }
+  }
+
+  return {
+    success: errors.length === 0,
+    namespace,
+    runDir,
+    resultDir,
+    memoryDir,
+    totalDuration: Date.now() - startedAt,
+    pipeline: levels.map((level) => level.map((task) => task.id)),
+    errors,
+    results,
+  };
+}
+
+function resolveTaskAccount(config, task, workerConfig, provider, providerOverridden) {
+  const resolvedWorkerConfig = workerConfig === undefined ? config.workers?.[task.worker] || null : workerConfig;
+  const resolvedProvider = provider || resolveProvider(config, task.provider ? { ...(resolvedWorkerConfig || {}), provider: task.provider } : resolvedWorkerConfig);
+  const overridden = providerOverridden === undefined
+    ? Boolean(task.provider && task.provider !== resolvedWorkerConfig?.provider)
+    : providerOverridden;
+  return (!overridden && resolvedProvider.name === resolvedWorkerConfig?.provider ? resolvedWorkerConfig?.account : '')
+    || (config.accountsDir ? accountNameForWorker(task.worker, resolvedProvider.name) : '')
+    || config.defaultAccount;
+}
+
+module.exports = {
+  buildCommonOptions,
+  executeTaskGraph,
+};