@fitlab-ai/agent-infra 0.4.4 → 0.5.0

package/README.md

@@ -133,10 +133,18 @@ npm install -g @fitlab-ai/agent-infra
 curl -fsSL https://raw.githubusercontent.com/fitlab-ai/agent-infra/main/install.sh | sh
 ```
 
+**Option C - Homebrew (macOS)**
+
+```bash
+brew install fitlab-ai/tap/agent-infra
+```
+
 ### Updating agent-infra
 
 ```bash
 npm update -g @fitlab-ai/agent-infra
+# or, if installed via Homebrew:
+brew upgrade agent-infra
 ```
 
 Check your current version:
@@ -171,6 +179,12 @@ Open the project in any AI TUI and run `update-agent-infra`:
 
 This detects the packaged template version and renders all managed files. The same command is used both for first-time setup and for future template upgrades.
 
+### Sandbox aliases and GitHub CLI
+
+`ai sandbox create` now bootstraps the host-side aliases file at `~/.ai-sandbox-aliases` on first run. The generated file includes ready-to-edit yolo shortcuts for Claude, Codex, Gemini CLI, and OpenCode, and every sandbox syncs that file into `/home/devuser/.bash_aliases`.
+
+The sandbox image also preinstalls `gh`. When `gh auth token` succeeds on the host, `ai sandbox create` injects the token into the container as `GH_TOKEN`, so `gh` commands work inside the sandbox without extra setup.
+
 <a id="architecture-overview"></a>
 
 ## Architecture Overview
@@ -179,7 +193,7 @@ agent-infra is intentionally simple: a bootstrap CLI creates the seed configurat
 
 ### End-to-End Flow
 
-1. **Install** — `npm install -g @fitlab-ai/agent-infra` (or use the shell script wrapper)
+1. **Install** — `npm install -g @fitlab-ai/agent-infra` (or `brew install fitlab-ai/tap/agent-infra` on macOS, or use the shell script wrapper)
 2. **Initialize** — `ai init` in the project root to generate `.agents/.airc.json` and install the seed command
 3. **Render** — run `update-agent-infra` in any AI TUI to detect the bundled template version and generate all managed files
 4. **Develop** — use built-in skills to drive the full lifecycle: `analysis → design → implementation → review → fix → commit`
@@ -380,7 +394,7 @@ The generated `.agents/.airc.json` file is the central contract between the boot
   "project": "my-project",
   "org": "my-org",
   "language": "en",
-  "templateVersion": "v0.4.4",
+  "templateVersion": "v0.5.0",
   "files": {
     "managed": [
       ".agents/workspace/README.md",

package/README.zh-CN.md

@@ -133,10 +133,18 @@ npm install -g @fitlab-ai/agent-infra
 curl -fsSL https://raw.githubusercontent.com/fitlab-ai/agent-infra/main/install.sh | sh
 ```
 
+**方式 C - Homebrew (macOS)**
+
+```bash
+brew install fitlab-ai/tap/agent-infra
+```
+
 ### 更新 agent-infra
 
 ```bash
 npm update -g @fitlab-ai/agent-infra
+# 或者通过 Homebrew 安装时：
+brew upgrade agent-infra
 ```
 
 查看当前版本：
@@ -171,6 +179,12 @@ CLI 会收集项目元数据，向所有支持的 AI TUI 安装 `update-agent-in
 
 该命令会检测当前打包模板版本并渲染所有受管理文件。首次安装和后续升级都使用同一条命令。
 
+### 沙箱 aliases 与 GitHub CLI
+
+`ai sandbox create` 在首次运行时会自动生成宿主机侧的 `~/.ai-sandbox-aliases`。该文件内置了 Claude、Codex、Gemini CLI 和 OpenCode 的 yolo 快捷命令模板，你可以直接修改；每次创建沙箱时，这个文件都会同步到容器内的 `/home/devuser/.bash_aliases`。
+
+沙箱镜像也会预装 `gh`。如果宿主机上的 `gh auth token` 能成功返回 token，`ai sandbox create` 会把它以 `GH_TOKEN` 环境变量注入容器，让你在沙箱里直接使用 `gh`，无需额外登录配置。
+
 <a id="architecture-overview"></a>
 
 ## 架构概览
@@ -179,7 +193,7 @@ agent-infra 的结构刻意保持简单：引导 CLI 负责生成种子配置，
 
 ### 端到端流程
 
-1. **安装** — `npm install -g @fitlab-ai/agent-infra`（或使用 shell 脚本便捷封装）
+1. **安装** — `npm install -g @fitlab-ai/agent-infra`（或在 macOS 上使用 `brew install fitlab-ai/tap/agent-infra`，或使用 shell 脚本便捷封装）
 2. **初始化** — 在项目根目录运行 `ai init`，生成 `.agents/.airc.json` 并安装种子命令
 3. **渲染** — 在任意 AI TUI 中执行 `update-agent-infra`，检测当前打包模板版本并生成所有受管理文件
 4. **开发** — 使用内置 skill 驱动完整生命周期：`analysis → design → implementation → review → fix → commit`
@@ -380,7 +394,7 @@ import-issue #42                    从 GitHub Issue 导入任务
   "project": "my-project",
   "org": "my-org",
   "language": "en",
-  "templateVersion": "v0.4.4",
+  "templateVersion": "v0.5.0",
   "files": {
     "managed": [
       ".agents/workspace/README.md",

package/bin/cli.js

@@ -14,7 +14,9 @@ const USAGE = `agent-infra - bootstrap AI collaboration infrastructure
 
 Usage:
   agent-infra init        Initialize a new project with update-agent-infra seed command
+  agent-infra merge       Merge archived tasks from another archive directory
   agent-infra update      Update seed files and sync file registry for an existing project
+  agent-infra sandbox     Manage Docker-based AI sandboxes
   agent-infra version     Show version
   agent-infra help        Show this help message
 
@@ -23,6 +25,7 @@ Shorthand: ai (e.g. ai init)
 Install methods:
   npm:   npm install -g @fitlab-ai/agent-infra
   npx:   npx @fitlab-ai/agent-infra init
+  brew:  brew install fitlab-ai/tap/agent-infra  (macOS)
   curl:  curl -fsSL https://raw.githubusercontent.com/fitlab-ai/agent-infra/main/install.sh | sh  (runs npm install -g internally)
 
 Examples:
@@ -49,6 +52,22 @@ switch (command) {
     });
     break;
   }
+  case 'merge': {
+    const { cmdMerge } = await import('../lib/merge.js');
+    await cmdMerge(process.argv.slice(3)).catch((e) => {
+      process.stderr.write(`Error: ${e.message}\n`);
+      process.exitCode = 1;
+    });
+    break;
+  }
+  case 'sandbox': {
+    const { runSandbox } = await import('../lib/sandbox/index.js');
+    await runSandbox(process.argv.slice(3)).catch((e) => {
+      process.stderr.write(`Error: ${e.message}\n`);
+      process.exitCode = 1;
+    });
+    break;
+  }
   case 'version': {
     console.log(`agent-infra ${VERSION}`);
     break;

package/lib/defaults.json

@@ -1,4 +1,21 @@
 {
+  "sandbox": {
+    "runtimes": [
+      "node20"
+    ],
+    "tools": [
+      "claude-code",
+      "codex",
+      "opencode",
+      "gemini-cli"
+    ],
+    "dockerfile": null,
+    "vm": {
+      "cpu": null,
+      "memory": null,
+      "disk": null
+    }
+  },
   "labels": {
     "in": {}
   },

package/lib/init.js

@@ -162,6 +162,7 @@ async function cmdInit() {
     org: orgName,
     language,
     templateVersion: VERSION,
+    sandbox: structuredClone(defaults.sandbox),
     labels: structuredClone(defaults.labels),
     files: structuredClone(defaults.files)
   };

package/lib/log.js

@@ -1,27 +1,22 @@
-const isTTY = process.stdout.isTTY;
-const isTTYErr = process.stderr.isTTY;
-
-function color(code, text, tty) {
-  return tty ? `\x1b[${code}m${text}\x1b[0m` : text;
-}
+import pc from 'picocolors';
 
 function info(...args) {
   const msg = args.join(' ');
-  process.stdout.write(`  ${color('1;34', '>', isTTY)} ${msg}\n`);
+  process.stdout.write(`  ${pc.bold(pc.blue('>'))} ${msg}\n`);
 }
 
 function ok(...args) {
   const msg = args.join(' ');
-  process.stdout.write(`  ${color('1;32', '\u2713', isTTY)} ${msg}\n`);
+  process.stdout.write(`  ${pc.bold(pc.green('\u2713'))} ${msg}\n`);
 }
 
 function err(...args) {
   const msg = args.join(' ');
-  process.stderr.write(`  ${color('1;31', '\u2717', isTTYErr)} ${msg}\n`);
+  process.stderr.write(`  ${pc.bold(pc.red('\u2717'))} ${msg}\n`);
 }
 
 function ask(text) {
-  process.stdout.write(`  ${color('1;33', '?', isTTY)} ${text}`);
+  process.stdout.write(`  ${pc.bold(pc.yellow('?'))} ${text}`);
 }
 
 export { info, ok, err, ask };

package/lib/merge.js

@@ -0,0 +1,465 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { info, ok } from './log.js';
+
+const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+const TITLE_RE = /^# (.+)$/m;
+const DATE_FROM_PATH_RE = /(?:^|[/\\])(\d{4})[/\\](\d{2})[/\\](\d{2})(?:[/\\]|$)/;
+
+function extractField(content, fieldName) {
+  const match = content.match(FRONTMATTER_RE);
+  if (!match) {
+    return null;
+  }
+
+  const lines = match[1].split(/\r?\n/);
+  const prefix = `${fieldName}:`;
+
+  for (const line of lines) {
+    if (!line.startsWith(prefix)) {
+      continue;
+    }
+
+    const value = line.slice(prefix.length).trim().replace(/^['"]|['"]$/g, '');
+    return value || null;
+  }
+
+  return null;
+}
+
+function extractTitle(content) {
+  const withoutFrontmatter = content.replace(FRONTMATTER_RE, '');
+  const match = withoutFrontmatter.match(TITLE_RE);
+  if (!match) {
+    return null;
+  }
+
+  return match[1]
+    .trim()
+    .replace(/^任务：/, '')
+    .replace(/^Task:\s*/, '')
+    .replace(/\\/g, '\\\\')
+    .replace(/\|/g, '\\|') || null;
+}
+
+function normalizeTaskRecord(taskDir, taskFile, dateParts) {
+  const taskId = path.basename(taskDir);
+  const content = fs.readFileSync(taskFile, 'utf8');
+  const completedAt = extractField(content, 'completed_at');
+  const updatedAt = extractField(content, 'updated_at');
+  const taskDate = completedAt || updatedAt || `${dateParts.year}-${dateParts.month}-${dateParts.day}`;
+  const title = extractTitle(content) || taskId;
+  const type = extractField(content, 'type') || 'unknown';
+
+  return {
+    taskId,
+    taskDir,
+    relativePath: `${dateParts.year}/${dateParts.month}/${dateParts.day}/${taskId}/`,
+    year: dateParts.year,
+    month: dateParts.month,
+    day: dateParts.day,
+    title,
+    type,
+    completedAt: taskDate
+  };
+}
+
+function fallbackDateParts(taskDir, content) {
+  const pathMatch = taskDir.match(DATE_FROM_PATH_RE);
+  if (pathMatch) {
+    return {
+      year: pathMatch[1],
+      month: pathMatch[2],
+      day: pathMatch[3]
+    };
+  }
+
+  const completedAt = extractField(content, 'completed_at');
+  const updatedAt = extractField(content, 'updated_at');
+  const source = completedAt || updatedAt;
+  const dateMatch = source?.match(/^(\d{4})-(\d{2})-(\d{2})/);
+
+  if (dateMatch) {
+    return {
+      year: dateMatch[1],
+      month: dateMatch[2],
+      day: dateMatch[3]
+    };
+  }
+
+  return null;
+}
+
+function scanSourceTasks(sourceDir) {
+  const tasks = [];
+  const years = fs.existsSync(sourceDir) ? fs.readdirSync(sourceDir, { withFileTypes: true }) : [];
+
+  for (const yearEntry of years) {
+    if (!yearEntry.isDirectory() || !/^\d{4}$/.test(yearEntry.name)) {
+      continue;
+    }
+
+    const yearDir = path.join(sourceDir, yearEntry.name);
+    for (const monthEntry of fs.readdirSync(yearDir, { withFileTypes: true })) {
+      if (!monthEntry.isDirectory() || !/^\d{2}$/.test(monthEntry.name)) {
+        continue;
+      }
+
+      const monthDir = path.join(yearDir, monthEntry.name);
+      for (const dayEntry of fs.readdirSync(monthDir, { withFileTypes: true })) {
+        if (!dayEntry.isDirectory() || !/^\d{2}$/.test(dayEntry.name)) {
+          continue;
+        }
+
+        const dayDir = path.join(monthDir, dayEntry.name);
+        for (const taskEntry of fs.readdirSync(dayDir, { withFileTypes: true })) {
+          if (!taskEntry.isDirectory() || !TASK_ID_RE.test(taskEntry.name)) {
+            continue;
+          }
+
+          const taskDir = path.join(dayDir, taskEntry.name);
+          const taskFile = path.join(taskDir, 'task.md');
+          if (!fs.existsSync(taskFile)) {
+            continue;
+          }
+
+          tasks.push(normalizeTaskRecord(taskDir, taskFile, {
+            year: yearEntry.name,
+            month: monthEntry.name,
+            day: dayEntry.name
+          }));
+        }
+      }
+    }
+  }
+
+  if (tasks.length > 0) {
+    return tasks;
+  }
+
+  // Fall back to a deeper scan if the source layout is unusual but still contains archived tasks.
+  const stack = [sourceDir];
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+    if (!currentDir || !fs.existsSync(currentDir)) {
+      continue;
+    }
+
+    for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
+      const entryPath = path.join(currentDir, entry.name);
+      if (!entry.isDirectory()) {
+        continue;
+      }
+
+      if (TASK_ID_RE.test(entry.name)) {
+        const taskFile = path.join(entryPath, 'task.md');
+        if (!fs.existsSync(taskFile)) {
+          continue;
+        }
+
+        const content = fs.readFileSync(taskFile, 'utf8');
+        const dateParts = fallbackDateParts(entryPath, content);
+        if (!dateParts) {
+          continue;
+        }
+
+        tasks.push(normalizeTaskRecord(entryPath, taskFile, dateParts));
+        continue;
+      }
+
+      stack.push(entryPath);
+    }
+  }
+
+  return tasks.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+
+function findTaskDirById(rootDir, taskId) {
+  if (!fs.existsSync(rootDir)) {
+    return null;
+  }
+
+  for (const yearEntry of fs.readdirSync(rootDir, { withFileTypes: true })) {
+    if (!yearEntry.isDirectory() || !/^\d{4}$/.test(yearEntry.name)) {
+      continue;
+    }
+
+    const yearDir = path.join(rootDir, yearEntry.name);
+    for (const monthEntry of fs.readdirSync(yearDir, { withFileTypes: true })) {
+      if (!monthEntry.isDirectory() || !/^\d{2}$/.test(monthEntry.name)) {
+        continue;
+      }
+
+      const monthDir = path.join(yearDir, monthEntry.name);
+      for (const dayEntry of fs.readdirSync(monthDir, { withFileTypes: true })) {
+        if (!dayEntry.isDirectory() || !/^\d{2}$/.test(dayEntry.name)) {
+          continue;
+        }
+
+        const candidate = path.join(monthDir, dayEntry.name, taskId);
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+          return candidate;
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+function taskExistsInArchive(archiveDir, taskId) {
+  return findTaskDirById(archiveDir, taskId);
+}
+
+function formatManifestHeader(generatedAt) {
+  return [
+    '# Archive Manifest',
+    '',
+    '> Auto-generated by archive-tasks. Do not edit manually.',
+    `> Last updated: ${generatedAt}`,
+    ''
+  ];
+}
+
+function collectArchiveEntries(archiveDir) {
+  const entries = [];
+  if (!fs.existsSync(archiveDir)) {
+    return entries;
+  }
+
+  for (const yearEntry of fs.readdirSync(archiveDir, { withFileTypes: true })) {
+    if (!yearEntry.isDirectory() || !/^\d{4}$/.test(yearEntry.name)) {
+      continue;
+    }
+
+    const yearDir = path.join(archiveDir, yearEntry.name);
+    for (const monthEntry of fs.readdirSync(yearDir, { withFileTypes: true })) {
+      if (!monthEntry.isDirectory() || !/^\d{2}$/.test(monthEntry.name)) {
+        continue;
+      }
+
+      const monthDir = path.join(yearDir, monthEntry.name);
+      for (const dayEntry of fs.readdirSync(monthDir, { withFileTypes: true })) {
+        if (!dayEntry.isDirectory() || !/^\d{2}$/.test(dayEntry.name)) {
+          continue;
+        }
+
+        const dayDir = path.join(monthDir, dayEntry.name);
+        for (const taskEntry of fs.readdirSync(dayDir, { withFileTypes: true })) {
+          if (!taskEntry.isDirectory() || !TASK_ID_RE.test(taskEntry.name)) {
+            continue;
+          }
+
+          const taskDir = path.join(dayDir, taskEntry.name);
+          const taskFile = path.join(taskDir, 'task.md');
+          const relativePath = `${yearEntry.name}/${monthEntry.name}/${dayEntry.name}/${taskEntry.name}/`;
+          let title = taskEntry.name;
+          let type = 'unknown';
+          let completedAt = `${yearEntry.name}-${monthEntry.name}-${dayEntry.name}`;
+
+          if (fs.existsSync(taskFile)) {
+            const content = fs.readFileSync(taskFile, 'utf8');
+            title = extractTitle(content) || title;
+            type = extractField(content, 'type') || type;
+            completedAt = extractField(content, 'completed_at') || completedAt;
+          }
+
+          entries.push({
+            year: yearEntry.name,
+            month: monthEntry.name,
+            completedAt,
+            taskId: taskEntry.name,
+            title,
+            type,
+            relativePath
+          });
+        }
+      }
+    }
+  }
+
+  return entries;
+}
+
+function rebuildManifests(archiveDir) {
+  fs.mkdirSync(archiveDir, { recursive: true });
+  const entries = collectArchiveEntries(archiveDir);
+  const generatedAt = new Date().toISOString().slice(0, 19).replace('T', ' ');
+
+  removeManifestFiles(archiveDir);
+
+  const monthGroups = new Map();
+  const yearCounts = new Map();
+  const monthCounts = new Map();
+
+  for (const entry of entries) {
+    const monthKey = `${entry.year}\t${entry.month}`;
+    if (!monthGroups.has(monthKey)) {
+      monthGroups.set(monthKey, []);
+    }
+    monthGroups.get(monthKey).push(entry);
+    yearCounts.set(entry.year, (yearCounts.get(entry.year) || 0) + 1);
+    monthCounts.set(monthKey, (monthCounts.get(monthKey) || 0) + 1);
+  }
+
+  for (const [monthKey, monthEntries] of [...monthGroups.entries()].sort()) {
+    const [year, month] = monthKey.split('\t');
+    const monthManifestPath = path.join(archiveDir, year, month, 'manifest.md');
+    fs.mkdirSync(path.dirname(monthManifestPath), { recursive: true });
+
+    const sortedEntries = [...monthEntries].sort((left, right) => {
+      const completedCompare = right.completedAt.localeCompare(left.completedAt);
+      if (completedCompare !== 0) {
+        return completedCompare;
+      }
+      return right.taskId.localeCompare(left.taskId);
+    });
+
+    const lines = [
+      ...formatManifestHeader(generatedAt),
+      '| Task ID | Title | Type | Completed | Path |',
+      '| --- | --- | --- | --- | --- |'
+    ];
+
+    for (const entry of sortedEntries.slice(0, 1000)) {
+      lines.push(
+        `| ${entry.taskId} | ${entry.title} | ${entry.type} | ${entry.completedAt} | ${entry.relativePath} |`
+      );
+    }
+
+    if (sortedEntries.length > 1000) {
+      lines.push('', `> Showing 1000 of ${sortedEntries.length} entries.`);
+    }
+
+    fs.writeFileSync(monthManifestPath, `${lines.join('\n')}\n`, 'utf8');
+  }
+
+  for (const year of [...yearCounts.keys()].sort().reverse()) {
+    const yearManifestPath = path.join(archiveDir, year, 'manifest.md');
+    fs.mkdirSync(path.dirname(yearManifestPath), { recursive: true });
+
+    const lines = [
+      ...formatManifestHeader(generatedAt),
+      '| Month | Tasks | Manifest |',
+      '| --- | --- | --- |'
+    ];
+
+    for (const month of [...monthGroups.keys()]
+      .filter((key) => key.startsWith(`${year}\t`))
+      .map((key) => key.split('\t')[1])
+      .sort()
+      .reverse()) {
+      lines.push(
+        `| ${month} | ${monthCounts.get(`${year}\t${month}`)} | [${month}/manifest.md](${month}/manifest.md) |`
+      );
+    }
+
+    fs.writeFileSync(yearManifestPath, `${lines.join('\n')}\n`, 'utf8');
+  }
+
+  const rootLines = [
+    ...formatManifestHeader(generatedAt),
+    '| Year | Tasks | Manifest |',
+    '| --- | --- | --- |'
+  ];
+
+  for (const year of [...yearCounts.keys()].sort().reverse()) {
+    rootLines.push(
+      `| ${year} | ${yearCounts.get(year)} | [${year}/manifest.md](${year}/manifest.md) |`
+    );
+  }
+
+  fs.writeFileSync(path.join(archiveDir, 'manifest.md'), `${rootLines.join('\n')}\n`, 'utf8');
+}
+
+function removeManifestFiles(rootDir) {
+  if (!fs.existsSync(rootDir)) {
+    return;
+  }
+
+  for (const entry of fs.readdirSync(rootDir, { withFileTypes: true })) {
+    const entryPath = path.join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith('TASK-')) {
+        continue;
+      }
+      removeManifestFiles(entryPath);
+      continue;
+    }
+
+    if (entry.isFile() && entry.name === 'manifest.md') {
+      fs.rmSync(entryPath, { force: true });
+    }
+  }
+}
+
+async function cmdMerge(args) {
+  const sourcePath = args[0];
+  if (!sourcePath) {
+    throw new Error('Usage: agent-infra merge <source-path>');
+  }
+
+  const resolvedSource = path.resolve(sourcePath);
+  if (!fs.existsSync(resolvedSource)) {
+    throw new Error(`Source path does not exist: ${sourcePath}`);
+  }
+
+  if (!fs.statSync(resolvedSource).isDirectory()) {
+    throw new Error(`Source path is not a directory: ${sourcePath}`);
+  }
+
+  const archiveDir = path.join(process.cwd(), '.agents', 'workspace', 'archive');
+  const sourceTasks = scanSourceTasks(resolvedSource);
+  const merged = [];
+  const skipped = [];
+
+  fs.mkdirSync(archiveDir, { recursive: true });
+
+  for (const task of sourceTasks) {
+    const existingTaskDir = taskExistsInArchive(archiveDir, task.taskId);
+    if (existingTaskDir) {
+      skipped.push({
+        taskId: task.taskId,
+        relativePath: path.relative(archiveDir, existingTaskDir).split(path.sep).join('/') + '/'
+      });
+      continue;
+    }
+
+    const destinationDir = path.join(archiveDir, task.relativePath);
+    fs.mkdirSync(path.dirname(destinationDir), { recursive: true });
+    fs.cpSync(task.taskDir, destinationDir, { recursive: true });
+    merged.push({
+      taskId: task.taskId,
+      relativePath: task.relativePath
+    });
+  }
+
+  rebuildManifests(archiveDir);
+
+  if (sourceTasks.length === 0) {
+    info(`No archived tasks found in ${sourcePath}`);
+  }
+
+  for (const task of merged) {
+    ok(`Merged ${task.taskId} -> ${task.relativePath}`);
+  }
+
+  for (const task of skipped) {
+    info(`Skipped ${task.taskId} (already exists at ${task.relativePath})`);
+  }
+
+  process.stdout.write('\n');
+  info('Merge summary');
+  info(`- Merged: ${merged.length}`);
+  info(`- Skipped: ${skipped.length}`);
+}
+
+export {
+  cmdMerge,
+  extractField,
+  extractTitle,
+  rebuildManifests,
+  scanSourceTasks,
+  taskExistsInArchive
+};