@fitlab-ai/agent-infra 0.7.0 → 0.7.2

package/lib/sandbox/image-prune.ts

@@ -0,0 +1,23 @@
+import * as p from '@clack/prompts';
+import type { SandboxConfig } from './config.ts';
+import { sandboxLabel } from './constants.ts';
+import { runEngine } from './shell.ts';
+
+export function pruneSandboxDanglingImages(
+  config: Pick<SandboxConfig, 'project'>,
+  engine: string
+): void {
+  try {
+    runEngine(engine, 'docker', [
+      'image',
+      'prune',
+      '-f',
+      '--filter',
+      `label=${sandboxLabel(config)}`
+    ]);
+  } catch {
+    p.log.warn(
+      `Failed to prune dangling sandbox images (label=${sandboxLabel(config)}); leaving them in place.`
+    );
+  }
+}

package/lib/sandbox/index.ts

@@ -2,9 +2,13 @@ const USAGE = `Usage: ai sandbox <command> [options]
 
 Commands:
   create <branch> [base]       Create a sandbox (VM + image + worktree + container)
-  exec <branch | '#N'> [cmd...]
-                               Enter sandbox or run a command (use leftmost '#' column from 'ls')
-  ls                           List sandboxes for the current project
+  exec <branch | TASK-id | N | '#N'> [cmd...]
+                               Enter sandbox or run a command. N (bare) is the
+                               recommended form for task short ids (e.g.
+                               'ai sandbox exec 11'); '#N' is also accepted.
+  ls                           List sandboxes for the current project (the '#'
+                               column is a display-only row number; the 'SHORT'
+                               column shows the active task short id, '-' if none)
   prune [--dry-run]            Remove orphaned per-branch state dirs
   rebuild [--quiet] [--refresh]
                                Rebuild the sandbox image (--refresh pulls base + tools)

package/lib/sandbox/task-resolver.ts

@@ -1,9 +1,27 @@
+import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+const SHORT_ID_RE = /^#?\d+$/;
 const WORKSPACE_DIRS = ['active', 'completed', 'blocked', 'archive'];
 
+function resolveShortIdStrict(arg: string, repoRoot: string): string {
+  const scriptPath = path.join(repoRoot, '.agents', 'scripts', 'task-short-id.js');
+  if (!fs.existsSync(scriptPath)) {
+    throw new Error(
+      `Short id '${arg}' provided but task-short-id.js script is missing at ${scriptPath}`
+    );
+  }
+  const result = spawnSync('node', [scriptPath, 'resolve', arg], { encoding: 'utf8', cwd: repoRoot });
+  if (result.status !== 0) {
+    throw new Error(
+      `Short id '${arg}' not found in active task registry: ${(result.stderr || '').trim()}`
+    );
+  }
+  return result.stdout.trim();
+}
+
 function stripQuotes(value: string): string {
   return value.replace(/^(["'])(.*)\1$/, '$2');
 }
@@ -33,10 +51,14 @@ function resolveBranchFromTaskContent(content: string, taskId: string): string {
 }
 
 export function resolveTaskBranch(arg: string, repoRoot: string): string {
+  if (SHORT_ID_RE.test(arg)) {
+    const taskId = resolveShortIdStrict(arg, repoRoot);
+    const content = readTaskContent(repoRoot, taskId);
+    return resolveBranchFromTaskContent(content, taskId);
+  }
   if (!TASK_ID_RE.test(arg)) {
     return arg;
   }
-
   const content = readTaskContent(repoRoot, arg);
   return resolveBranchFromTaskContent(content, arg);
 }

package/lib/sandbox/tools.ts

@@ -35,7 +35,7 @@ function createBuiltinTools(home: string, project: string): Record<string, Sandb
     'claude-code': {
       id: 'claude-code',
       name: 'Claude Code',
-      install: { type: 'npm', cmd: '@anthropic-ai/claude-code@stable' },
+      install: { type: 'npm', cmd: '@anthropic-ai/claude-code@latest' },
       sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'claude-code'),
       containerMount: '/home/devuser/.claude',
       versionCmd: 'claude --version',

package/lib/table.ts

@@ -0,0 +1,32 @@
+function formatTable(
+  headers: readonly string[],
+  rows: readonly (readonly string[])[]
+): string[] {
+  const columnCount = headers.length;
+  const widths = headers.map((header, i) => {
+    const headerLen = header.length;
+    let max = headerLen;
+    for (const row of rows) {
+      const cell = row[i] ?? '';
+      if (cell.length > max) max = cell.length;
+    }
+    return max;
+  });
+
+  const renderRow = (values: readonly string[]): string => {
+    const parts: string[] = [];
+    for (let i = 0; i < columnCount; i += 1) {
+      const cell = values[i] ?? '';
+      if (i === columnCount - 1) {
+        parts.push(cell);
+      } else {
+        parts.push(cell.padEnd(widths[i]!));
+      }
+    }
+    return parts.join('  ').trimEnd();
+  };
+
+  return [renderRow(headers), ...rows.map((row) => renderRow(row))];
+}
+
+export { formatTable };

package/lib/task/commands/ls.ts

@@ -0,0 +1,138 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { formatTable } from '../../table.ts';
+import { parseTaskFrontmatter, extractTitle } from '../frontmatter.ts';
+import { loadShortIdByTaskId } from '../short-id.ts';
+
+const USAGE = `Usage: ai task ls [--all | --blocked | --completed]
+
+Lists tasks under .agents/workspace/. Defaults to active tasks only.
+  --all         Include active + blocked + completed (excludes archive)
+  --blocked     Only blocked tasks
+  --completed   Only completed tasks
+
+Columns: # (display-only row number) / SHORT (task short id, usable as an argument) / type / status / current_step / branch / title
+`;
+
+const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+const TABLE_HEADERS = ['#', 'SHORT', 'TYPE', 'STATUS', 'STEP', 'BRANCH', 'TITLE'] as const;
+
+type Selection = ('active' | 'blocked' | 'completed')[];
+
+function detectRepoRoot(): string {
+  try {
+    return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+  } catch {
+    throw new Error('ai task: current directory is not inside a git repository');
+  }
+}
+
+type ParseResult =
+  | { ok: true; selection: Selection }
+  | { ok: false; message: string };
+
+function parseSelection(args: string[]): ParseResult {
+  const positional = args.filter((a) => !a.startsWith('--'));
+  if (positional.length > 0) {
+    return {
+      ok: false,
+      message: `ai task ls: unexpected positional argument(s): ${positional.join(' ')}`
+    };
+  }
+  const flags = args.filter((a) => a.startsWith('--'));
+  if (flags.length === 0) return { ok: true, selection: ['active'] };
+  if (flags.length > 1) {
+    return {
+      ok: false,
+      message: 'ai task ls: pass at most one of --all / --blocked / --completed'
+    };
+  }
+  switch (flags[0]) {
+    case '--all':
+      return { ok: true, selection: ['active', 'blocked', 'completed'] };
+    case '--blocked':
+      return { ok: true, selection: ['blocked'] };
+    case '--completed':
+      return { ok: true, selection: ['completed'] };
+    default:
+      return { ok: false, message: `ai task ls: unknown flag: ${flags[0]}` };
+  }
+}
+
+type TaskRow = {
+  shortId: string;
+  type: string;
+  status: string;
+  step: string;
+  branch: string;
+  title: string;
+};
+
+function collectTasks(repoRoot: string, state: 'active' | 'blocked' | 'completed'): TaskRow[] {
+  const dir = path.join(repoRoot, '.agents', 'workspace', state);
+  if (!fs.existsSync(dir)) return [];
+  // Short ids live only in the registry and only for active tasks; archived
+  // (blocked/completed) tasks have released their short id and render '-'.
+  const shortIdByTaskId = state === 'active' ? loadShortIdByTaskId(repoRoot) : new Map<string, string>();
+  const rows: TaskRow[] = [];
+  for (const entry of fs.readdirSync(dir).sort()) {
+    if (!TASK_ID_RE.test(entry)) continue;
+    const taskMdPath = path.join(dir, entry, 'task.md');
+    if (!fs.existsSync(taskMdPath)) continue;
+    const content = fs.readFileSync(taskMdPath, 'utf8');
+    const fm = parseTaskFrontmatter(content);
+    const title = extractTitle(content);
+    const shortId = shortIdByTaskId.get(entry) ?? '-';
+    rows.push({
+      shortId,
+      type: fm.type ?? '-',
+      status: fm.status ?? state,
+      step: fm.current_step ?? '-',
+      branch: fm.branch ?? '-',
+      title: title || fm.id || entry
+    });
+  }
+  return rows;
+}
+
+function ls(args: string[] = []): void {
+  if (args[0] === '--help' || args[0] === '-h') {
+    process.stdout.write(USAGE);
+    return;
+  }
+  const result = parseSelection(args);
+  if (!result.ok) {
+    process.stderr.write(`${result.message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  const { selection } = result;
+  const repoRoot = detectRepoRoot();
+  const rows: TaskRow[] = [];
+  for (const state of selection) {
+    rows.push(...collectTasks(repoRoot, state));
+  }
+  if (rows.length === 0) {
+    process.stdout.write(`No tasks under .agents/workspace/${selection.join('|')}\n`);
+    return;
+  }
+  const tableRows = rows.map((r, i) => [
+    String(i + 1),
+    r.shortId,
+    r.type,
+    r.status,
+    r.step,
+    r.branch,
+    r.title
+  ]);
+  for (const line of formatTable(TABLE_HEADERS, tableRows)) {
+    process.stdout.write(`${line}\n`);
+  }
+  process.stdout.write(`Total: ${rows.length} tasks\n`);
+}
+
+export { ls };

package/lib/task/commands/show.ts

@@ -0,0 +1,139 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { normalizeShortIdInput } from '../short-id.ts';
+
+const USAGE = `Usage: ai task show <N | #N | TASK-id>
+
+Prints the task.md content for the matching task.
+  N (bare numeric)   Recommended; resolves the active short id via the registry.
+  '#N'               Compatibility form for old commands.
+  TASK-YYYYMMDD-HHMMSS  Locates a task in active / blocked / completed / archive.
+`;
+
+const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+// Flat-structured workspace dirs that hold tasks under `{dir}/{taskId}/task.md`.
+// Note: `archive` uses a three-level YYYY/MM/DD layout and is handled separately.
+const FLAT_WORKSPACE_DIRS = ['active', 'blocked', 'completed'] as const;
+
+function detectRepoRoot(): string {
+  try {
+    return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+  } catch {
+    throw new Error('ai task: current directory is not inside a git repository');
+  }
+}
+
+function readShortIdLength(repoRoot: string): number {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
+    const v = cfg?.task?.shortIdLength;
+    if (typeof v === 'number' && Number.isFinite(v) && v >= 1) return v;
+  } catch {
+    // fall through to default
+  }
+  return 2;
+}
+
+function resolveShortIdToTaskId(arg: string, repoRoot: string): string {
+  const scriptPath = path.join(repoRoot, '.agents', 'scripts', 'task-short-id.js');
+  if (!fs.existsSync(scriptPath)) {
+    throw new Error(`task-short-id.js not found at ${scriptPath}`);
+  }
+  const result = spawnSync('node', [scriptPath, 'resolve', arg], {
+    encoding: 'utf8',
+    cwd: repoRoot
+  });
+  if (result.status !== 0) {
+    throw new Error((result.stderr || '').trim() || `failed to resolve '${arg}'`);
+  }
+  return result.stdout.trim();
+}
+
+function listSortedNumeric(dir: string, width: number): string[] {
+  if (!fs.existsSync(dir)) return [];
+  const pattern = new RegExp(`^\\d{${width}}$`);
+  return fs
+    .readdirSync(dir)
+    .filter((entry) => pattern.test(entry))
+    .sort()
+    .reverse();
+}
+
+function findInArchive(repoRoot: string, taskId: string): string | null {
+  // archive-tasks SKILL writes to .agents/workspace/archive/YYYY/MM/DD/{taskId}/task.md
+  // where YYYY/MM/DD comes from completed_at (or updated_at fallback) — NOT from
+  // the task id's creation date. So we cannot derive the path from taskId alone;
+  // walk the bounded YYYY/MM/DD tree instead. Newest-first to favor recent archives.
+  const archiveDir = path.join(repoRoot, '.agents', 'workspace', 'archive');
+  for (const year of listSortedNumeric(archiveDir, 4)) {
+    const yearDir = path.join(archiveDir, year);
+    for (const month of listSortedNumeric(yearDir, 2)) {
+      const monthDir = path.join(yearDir, month);
+      for (const day of listSortedNumeric(monthDir, 2)) {
+        const candidate = path.join(monthDir, day, taskId, 'task.md');
+        if (fs.existsSync(candidate)) return candidate;
+      }
+    }
+  }
+  return null;
+}
+
+function findTaskMd(repoRoot: string, taskId: string): string | null {
+  for (const sub of FLAT_WORKSPACE_DIRS) {
+    const candidate = path.join(repoRoot, '.agents', 'workspace', sub, taskId, 'task.md');
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return findInArchive(repoRoot, taskId);
+}
+
+function show(args: string[] = []): void {
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    process.stdout.write(USAGE);
+    if (args.length === 0) process.exitCode = 1;
+    return;
+  }
+  const repoRoot = detectRepoRoot();
+  const arg = args[0]!;
+  let taskId: string;
+  if (TASK_ID_RE.test(arg)) {
+    taskId = arg;
+  } else {
+    const shortIdLength = readShortIdLength(repoRoot);
+    const normalized = normalizeShortIdInput(arg, { shortIdLength });
+    if (normalized.kind === 'error') {
+      process.stderr.write(`ai task show: ${normalized.message}\n`);
+      process.exitCode = 1;
+      return;
+    }
+    if (normalized.kind === 'pass') {
+      process.stderr.write(
+        `ai task show: '${arg}' is not a valid short id or TASK-id; ` +
+          `expected bare digits, '#N', or 'TASK-YYYYMMDD-HHMMSS'\n`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      taskId = resolveShortIdToTaskId(normalized.value, repoRoot);
+    } catch (e) {
+      process.stderr.write(`ai task show: ${(e as Error).message}\n`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const taskMdPath = findTaskMd(repoRoot, taskId);
+  if (!taskMdPath) {
+    process.stderr.write(
+      `ai task show: task ${taskId} not found in active / blocked / completed / archive\n`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(fs.readFileSync(taskMdPath, 'utf8'));
+}
+
+export { show };

package/lib/task/frontmatter.ts

@@ -0,0 +1,30 @@
+type Frontmatter = Record<string, string>;
+
+function parseTaskFrontmatter(content: string): Frontmatter {
+  const result: Frontmatter = {};
+  if (!content.startsWith('---')) return result;
+  const end = content.indexOf('\n---', 3);
+  if (end === -1) return result;
+  const body = content.slice(3, end);
+  for (const rawLine of body.split('\n')) {
+    const line = rawLine.replace(/\r$/, '');
+    if (!line.trim()) continue;
+    const colon = line.indexOf(':');
+    if (colon === -1) continue;
+    const key = line.slice(0, colon).trim();
+    const value = line.slice(colon + 1).trim();
+    if (key) result[key] = value;
+  }
+  return result;
+}
+
+function extractTitle(content: string): string {
+  for (const line of content.split('\n')) {
+    const m = /^#\s+(?:任务[:：]?\s*)?(.+)$/.exec(line.trim());
+    if (m && m[1]) return m[1].trim();
+  }
+  return '';
+}
+
+export { parseTaskFrontmatter, extractTitle };
+export type { Frontmatter };

package/lib/task/index.ts

@@ -0,0 +1,44 @@
+const USAGE = `Usage: ai task <command> [options]
+
+Commands:
+  ls [--all | --blocked | --completed]   List tasks (default: active)
+  show <N | #N | TASK-id>                Print a task.md
+
+Examples:
+  ai task ls
+  ai task show 11
+  ai task show TASK-20260612-162737
+
+Run 'ai task <command> --help' for details.`;
+
+export async function runTask(args: string[]): Promise<void> {
+  const [subcommand, ...rest] = args;
+
+  if (!subcommand) {
+    process.stdout.write(`${USAGE}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (subcommand === '--help' || subcommand === '-h' || subcommand === 'help') {
+    process.stdout.write(`${USAGE}\n`);
+    return;
+  }
+
+  switch (subcommand) {
+    case 'ls': {
+      const { ls } = await import('./commands/ls.ts');
+      ls(rest);
+      break;
+    }
+    case 'show': {
+      const { show } = await import('./commands/show.ts');
+      show(rest);
+      break;
+    }
+    default:
+      process.stderr.write(`Unknown task command: ${subcommand}\n\n`);
+      process.stdout.write(`${USAGE}\n`);
+      process.exitCode = 1;
+  }
+}

package/lib/task/short-id.ts

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const REGISTRY_NAME = '.short-ids.json';
+
+type NormalizeResult =
+  | { kind: 'shortId'; value: string }
+  | { kind: 'pass'; value: string }
+  | { kind: 'error'; message: string };
+
+type NormalizeOpts = { shortIdLength: number };
+
+function normalizeShortIdInput(input: string, opts: NormalizeOpts): NormalizeResult {
+  const L = opts.shortIdLength;
+  const m = /^#?(\d+)$/.exec(input);
+  if (!m) {
+    return { kind: 'pass', value: input };
+  }
+  const n = Number(m[1]);
+  if (n === 0) {
+    return {
+      kind: 'error',
+      message: `short id '${input}' is invalid (#${'0'.repeat(L)} is reserved)`
+    };
+  }
+  const max = Math.pow(10, L) - 1;
+  if (n > max) {
+    return {
+      kind: 'error',
+      message: `short id ${n} exceeds shortIdLength=${L} capacity (max=${max}); archive tasks or raise task.shortIdLength in .agents/.airc.json`
+    };
+  }
+  return { kind: 'shortId', value: `#${String(n).padStart(L, '0')}` };
+}
+
+type RegistrySchema = {
+  version: number;
+  ids: Record<string, string>;
+};
+
+function readRegistry(repoRoot: string): RegistrySchema | null {
+  const registryPath = path.join(repoRoot, '.agents', 'workspace', 'active', REGISTRY_NAME);
+  if (!fs.existsSync(registryPath)) return null;
+  try {
+    const raw = fs.readFileSync(registryPath, 'utf8');
+    const data = JSON.parse(raw) as RegistrySchema;
+    if (!data || typeof data !== 'object' || !data.ids) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+function readBranchFromTaskMd(repoRoot: string, taskId: string): string | null {
+  const taskMdPath = path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md');
+  if (!fs.existsSync(taskMdPath)) return null;
+  const content = fs.readFileSync(taskMdPath, 'utf8');
+  const m = content.match(/^branch:\s*(.+)$/m);
+  if (!m || !m[1]) return null;
+  return m[1].trim().replace(/^(["'])(.*)\1$/, '$2');
+}
+
+function loadShortIdByTaskId(repoRoot: string): Map<string, string> {
+  const registry = readRegistry(repoRoot);
+  const map = new Map<string, string>();
+  if (!registry) return map;
+  for (const [key, taskId] of Object.entries(registry.ids)) {
+    map.set(taskId, `#${key}`);
+  }
+  return map;
+}
+
+function lookupShortIdByBranch(
+  branch: string,
+  repoRoot: string,
+  _opts?: { shortIdLength?: number }
+): string | null {
+  const registry = readRegistry(repoRoot);
+  if (!registry) return null;
+  const matches: string[] = [];
+  for (const [key, taskId] of Object.entries(registry.ids)) {
+    const taskBranch = readBranchFromTaskMd(repoRoot, taskId);
+    if (taskBranch && taskBranch === branch) {
+      matches.push(`#${key}`);
+    }
+  }
+  if (matches.length === 0) return null;
+  if (matches.length > 1) {
+    process.stderr.write(
+      `Warning: branch '${branch}' is bound to multiple active tasks: ${matches.join(', ')}; using ${matches[0]}\n`
+    );
+  }
+  return matches[0]!;
+}
+
+export { normalizeShortIdInput, lookupShortIdByBranch, loadShortIdByTaskId };
+export type { NormalizeResult, NormalizeOpts };