@fitlab-ai/agent-infra 0.7.3 → 0.7.4

package/lib/task/commands/log.ts

@@ -0,0 +1,80 @@
+import fs from 'node:fs';
+import { formatTable } from '../../table.ts';
+import { resolveTaskRef } from '../resolve-ref.ts';
+
+const USAGE = `Usage: ai task log <N | #N | TASK-id>
+
+Renders a task's activity log as a chronological timeline table.
+  <ref>   Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+
+Columns: # (timeline position) / TIME / STEP / AGENT / NOTE
+`;
+
+const TABLE_HEADERS = ['#', 'TIME', 'STEP', 'AGENT', 'NOTE'] as const;
+
+// The activity-log H2 heading is language-dependent (zh template / en template).
+const HEADING_RE = /^##\s+(活动日志|Activity Log)\s*$/;
+const NEXT_H2_RE = /^##\s/;
+// `- {time} — **{step}** by {agent} — {note}` ; the separator is an em-dash
+// (U+2014). STEP/AGENT are non-greedy so a note that itself contains ' — ' or
+// '→' is not mis-split; NOTE greedily takes the rest of the line.
+const ENTRY_RE =
+  /^- (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}) — \*\*(.+?)\*\* by (.+?) — (.*)$/;
+
+type LogEntry = { time: string; step: string; agent: string; note: string };
+
+function parseActivityLog(content: string): { sectionFound: boolean; entries: LogEntry[] } {
+  const lines = content.split('\n');
+  let i = 0;
+  while (i < lines.length && !HEADING_RE.test(lines[i]!)) i += 1;
+  if (i >= lines.length) return { sectionFound: false, entries: [] };
+  const parsed: { entry: LogEntry; epoch: number; order: number }[] = [];
+  for (let j = i + 1; j < lines.length; j += 1) {
+    if (NEXT_H2_RE.test(lines[j]!)) break;
+    const m = ENTRY_RE.exec(lines[j]!);
+    if (!m) continue; // skip blank / non-entry / malformed lines
+    parsed.push({
+      entry: { time: m[1]!, step: m[2]!, agent: m[3]!, note: m[4]! },
+      epoch: Date.parse(m[1]!.replace(' ', 'T')),
+      order: parsed.length
+    });
+  }
+  // Ascending by time; stable tie-break on original order for equal timestamps.
+  parsed.sort((a, b) => a.epoch - b.epoch || a.order - b.order);
+  return { sectionFound: true, entries: parsed.map((p) => p.entry) };
+}
+
+function log(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 resolved = resolveTaskRef(args[0]!);
+  if (!resolved.ok) {
+    process.stderr.write(`ai task log: ${resolved.message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+  const { sectionFound, entries } = parseActivityLog(content);
+  if (!sectionFound) {
+    process.stderr.write(
+      `ai task log: no activity log section ('## 活动日志' or '## Activity Log') found in task ${resolved.taskId}\n`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (entries.length === 0) {
+    process.stderr.write(`ai task log: no activity log entries found in task ${resolved.taskId}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  const rows = entries.map((e, idx) => [String(idx + 1), e.time, e.step, e.agent, e.note]);
+  for (const line of formatTable(TABLE_HEADERS, rows, { zebra: Boolean(process.stdout.isTTY) })) {
+    process.stdout.write(`${line}\n`);
+  }
+  process.stdout.write(`Total: ${entries.length} entries\n`);
+}
+
+export { log, parseActivityLog };

package/lib/task/commands/show.ts

@@ -1,7 +1,5 @@
 import fs from 'node:fs';
-import path from 'node:path';
-import { execFileSync, spawnSync } from 'node:child_process';
-import { normalizeShortIdInput } from '../short-id.ts';
+import { resolveTaskRef } from '../resolve-ref.ts';
 
 const USAGE = `Usage: ai task show <N | #N | TASK-id>
 
@@ -11,129 +9,19 @@ Prints the task.md content for the matching task.
   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`
-    );
+  const resolved = resolveTaskRef(args[0]!);
+  if (!resolved.ok) {
+    process.stderr.write(`ai task show: ${resolved.message}\n`);
     process.exitCode = 1;
     return;
   }
-  process.stdout.write(fs.readFileSync(taskMdPath, 'utf8'));
+  process.stdout.write(fs.readFileSync(resolved.taskMdPath, 'utf8'));
 }
 
 export { show };

package/lib/task/commands/status.ts

@@ -0,0 +1,302 @@
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { resolveTaskRef } from '../resolve-ref.ts';
+import { enumerateArtifacts, type Artifact } from '../artifacts.ts';
+import { parseTaskFrontmatter, extractTitle, type Frontmatter } from '../frontmatter.ts';
+import { loadShortIdByTaskId } from '../short-id.ts';
+
+const USAGE = `Usage: ai task status <N | #N | TASK-id>
+
+Prints an aggregated "health check" view for a task: header, metadata, an
+artifacts summary, git branch state, and best-effort GitHub issue/PR status.
+  <ref>   Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+
+Git and Platform rows are best-effort: a failed git/gh call degrades that row to
+'-' without failing the command.
+`;
+
+const DASH = '-';
+
+// Subprocess boundary: the single place this command shells out. Injectable so
+// the collectors below can be unit-tested without spawning git/gh. Returns the
+// command's stdout; throws (like execFileSync) on a non-zero exit or spawn error.
+type Runner = (file: string, args: string[]) => string;
+
+function makeRunner(cwd: string): Runner {
+  return (file, args) =>
+    execFileSync(file, args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+}
+
+// Run `run` and swallow any failure into null, so a single failing git/gh call
+// degrades only its own field instead of aborting the whole view.
+function tryRun(run: Runner, file: string, args: string[]): string | null {
+  try {
+    return run(file, args);
+  } catch {
+    return null;
+  }
+}
+
+// Frontmatter keys shown in the Metadata section, in a fixed display order.
+const METADATA_KEYS = [
+  'type',
+  'status',
+  'current_step',
+  'priority',
+  'effort',
+  'branch',
+  'assigned_to',
+  'created_at',
+  'updated_at',
+  'issue_number',
+  'pr_status'
+] as const;
+
+function collectMetadata(fm: Frontmatter): [string, string][] {
+  return METADATA_KEYS.map((key) => [key, fm[key] ? fm[key]! : DASH]);
+}
+
+// Workflow stages in timeline order; artifacts are bucketed by filename prefix.
+// `review-*` prefixes are matched before their bare counterparts so that, e.g.,
+// `review-analysis.md` is never swallowed by the `analysis` bucket.
+const STAGE_ORDER = [
+  'analysis',
+  'review-analysis',
+  'plan',
+  'review-plan',
+  'code',
+  'review-code',
+  'task',
+  'other'
+] as const;
+
+function stageOf(name: string): string {
+  const stem = name.replace(/\.md$/, '');
+  if (stem === 'task') return 'task';
+  if (stem.startsWith('review-analysis')) return 'review-analysis';
+  if (stem.startsWith('review-plan')) return 'review-plan';
+  if (stem.startsWith('review-code')) return 'review-code';
+  if (stem.startsWith('analysis')) return 'analysis';
+  if (stem.startsWith('plan')) return 'plan';
+  if (stem.startsWith('code')) return 'code';
+  return 'other';
+}
+
+// Group artifacts by workflow stage, preserving the input order (mtime ascending
+// from enumerateArtifacts) within each stage and dropping empty stages.
+function groupArtifacts(artifacts: Artifact[]): { stage: string; files: string[] }[] {
+  const byStage = new Map<string, string[]>();
+  for (const artifact of artifacts) {
+    const stage = stageOf(artifact.name);
+    const bucket = byStage.get(stage);
+    if (bucket) bucket.push(artifact.name);
+    else byStage.set(stage, [artifact.name]);
+  }
+  const groups: { stage: string; files: string[] }[] = [];
+  for (const stage of STAGE_ORDER) {
+    const files = byStage.get(stage);
+    if (files && files.length > 0) groups.push({ stage, files });
+  }
+  return groups;
+}
+
+type GitInfo = {
+  current: string;
+  frontmatter: string;
+  match: string;
+  exists: string;
+  uncommitted: string;
+  aheadBehind: string;
+};
+
+// `frontmatterBranch` is the task.md `branch` field (caller passes '' when absent).
+// It is read straight from frontmatter and never depends on a subprocess, so it
+// keeps its value even when every git call fails. All other fields degrade to '-'
+// on failure of their own command.
+function collectGit(frontmatterBranch: string, run: Runner): GitInfo {
+  const frontmatter = frontmatterBranch ? frontmatterBranch : DASH;
+
+  let current = DASH;
+  const cur = tryRun(run, 'git', ['rev-parse', '--abbrev-ref', 'HEAD']);
+  if (cur !== null && cur.trim()) current = cur.trim();
+
+  let match = DASH;
+  if (current !== DASH && frontmatter !== DASH) {
+    match = current === frontmatter ? 'yes' : 'no';
+  }
+
+  let exists = DASH;
+  if (frontmatter !== DASH) {
+    const verified = tryRun(run, 'git', ['rev-parse', '--verify', '--quiet', `refs/heads/${frontmatter}`]);
+    exists = verified === null ? 'no' : 'yes';
+  }
+
+  let uncommitted = DASH;
+  const porcelain = tryRun(run, 'git', ['status', '--porcelain']);
+  if (porcelain !== null) {
+    const changed = porcelain.split('\n').filter((line) => line.trim() !== '');
+    uncommitted = changed.length === 0 ? 'clean' : `${changed.length} file(s)`;
+  }
+
+  let aheadBehind = DASH;
+  if (frontmatter !== DASH) {
+    const counts = tryRun(run, 'git', [
+      'rev-list',
+      '--left-right',
+      '--count',
+      `${frontmatter}...${frontmatter}@{upstream}`
+    ]);
+    if (counts !== null) {
+      const parts = counts.trim().split(/\s+/);
+      if (parts.length === 2) aheadBehind = `${parts[0]} ahead / ${parts[1]} behind`;
+    }
+  }
+
+  return { current, frontmatter, match, exists, uncommitted, aheadBehind };
+}
+
+type PlatformInfo = { issue: string; pr: string };
+
+function collectPlatform(fm: Frontmatter, run: Runner): PlatformInfo {
+  let issue = DASH;
+  if (fm.issue_number && /^\d+$/.test(fm.issue_number)) {
+    const out = tryRun(run, 'gh', ['issue', 'view', fm.issue_number, '--json', 'state,labels']);
+    if (out !== null) {
+      try {
+        const data = JSON.parse(out);
+        const labels = Array.isArray(data.labels)
+          ? data.labels.map((label: { name: string }) => label.name).join(', ')
+          : '';
+        issue = labels ? `${data.state} [${labels}]` : `${data.state}`;
+      } catch {
+        issue = DASH;
+      }
+    }
+  }
+
+  let pr = DASH;
+  if (fm.pr_status === 'created' && fm.pr_number && /^\d+$/.test(fm.pr_number)) {
+    const out = tryRun(run, 'gh', ['pr', 'view', fm.pr_number, '--json', 'state,statusCheckRollup']);
+    if (out !== null) {
+      try {
+        const data = JSON.parse(out);
+        const rollup = Array.isArray(data.statusCheckRollup) ? data.statusCheckRollup : [];
+        const passed = rollup.filter(
+          (check: { conclusion?: string; state?: string }) =>
+            check.conclusion === 'SUCCESS' || check.state === 'SUCCESS'
+        ).length;
+        pr = rollup.length > 0 ? `${data.state}, checks: ${passed}/${rollup.length}` : `${data.state}`;
+      } catch {
+        pr = DASH;
+      }
+    }
+  }
+
+  return { issue, pr };
+}
+
+type StatusModel = {
+  taskId: string;
+  shortId: string;
+  title: string;
+  issueNumber: string;
+  metadata: [string, string][];
+  artifacts: { count: number; groups: { stage: string; files: string[] }[] };
+  git: GitInfo;
+  platform: PlatformInfo;
+};
+
+// Indent each label/value pair by two spaces and pad labels to a common width so
+// every section reads as an aligned "key   value" block.
+function renderPairs(rows: [string, string][]): string[] {
+  const width = rows.reduce((max, [label]) => Math.max(max, label.length), 0);
+  return rows.map(([label, value]) => `  ${label.padEnd(width)}  ${value}`.trimEnd());
+}
+
+function renderStatus(model: StatusModel): string[] {
+  const lines: string[] = [];
+
+  lines.push(`Task ${model.taskId}  (${model.shortId})`);
+  if (model.title) lines.push(model.title);
+
+  lines.push('', 'Metadata', ...renderPairs(model.metadata));
+
+  lines.push('', `Artifacts (${model.artifacts.count})`);
+  if (model.artifacts.groups.length === 0) {
+    lines.push('  (none)');
+  } else {
+    lines.push(...renderPairs(model.artifacts.groups.map((group) => [group.stage, group.files.join(', ')])));
+  }
+
+  lines.push(
+    '',
+    'Git',
+    ...renderPairs([
+      ['current', model.git.current],
+      ['frontmatter', model.git.frontmatter],
+      ['match', model.git.match],
+      ['exists', model.git.exists],
+      ['uncommitted', model.git.uncommitted],
+      ['ahead/behind', model.git.aheadBehind]
+    ])
+  );
+
+  const issueLabel = model.issueNumber ? `issue #${model.issueNumber}` : 'issue';
+  lines.push(
+    '',
+    'Platform',
+    ...renderPairs([
+      [issueLabel, model.platform.issue],
+      ['pr', model.platform.pr]
+    ])
+  );
+
+  return lines;
+}
+
+function status(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 resolved = resolveTaskRef(args[0]!);
+  if (!resolved.ok) {
+    process.stderr.write(`ai task status: ${resolved.message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+  const fm = parseTaskFrontmatter(content);
+  const run = makeRunner(resolved.repoRoot);
+  const artifacts = enumerateArtifacts(resolved.taskDir);
+
+  const model: StatusModel = {
+    taskId: resolved.taskId,
+    shortId: loadShortIdByTaskId(resolved.repoRoot).get(resolved.taskId) ?? DASH,
+    title: extractTitle(content),
+    issueNumber: fm.issue_number && /^\d+$/.test(fm.issue_number) ? fm.issue_number : '',
+    metadata: collectMetadata(fm),
+    artifacts: { count: artifacts.length, groups: groupArtifacts(artifacts) },
+    git: collectGit(fm.branch ?? '', run),
+    platform: collectPlatform(fm, run)
+  };
+
+  for (const line of renderStatus(model)) {
+    process.stdout.write(`${line}\n`);
+  }
+}
+
+export {
+  status,
+  makeRunner,
+  collectMetadata,
+  groupArtifacts,
+  collectGit,
+  collectPlatform,
+  renderStatus,
+  METADATA_KEYS
+};
+export type { Runner, GitInfo, PlatformInfo, StatusModel };

package/lib/task/index.ts

@@ -1,13 +1,25 @@
 const USAGE = `Usage: ai task <command> [options]
 
 Commands:
+  cat <ref> <artifact | N>               Print a task artifact (by name or number)
+  files <ref>                            List artifacts in a task dir (numbered)
+  grep <pattern> [ref] [artifact | N]    Literal search across task artifacts (omit ref to scan all)
+  log <ref>                              Render a task's activity log as a timeline
   ls [--all | --blocked | --completed]   List tasks (default: active)
   show <N | #N | TASK-id>                Print a task.md
+  status <ref>                           Aggregated status view (metadata / artifacts / git / platform)
 
 Examples:
+  ai task cat 11 analysis
+  ai task cat 11 3
+  ai task files 11
+  ai task grep resolveArtifact
+  ai task grep resolveArtifact 11
+  ai task log 11
   ai task ls
   ai task show 11
   ai task show TASK-20260612-162737
+  ai task status 11
 
 Run 'ai task <command> --help' for details.`;
 
@@ -36,6 +48,31 @@ export async function runTask(args: string[]): Promise<void> {
       show(rest);
       break;
     }
+    case 'files': {
+      const { files } = await import('./commands/files.ts');
+      files(rest);
+      break;
+    }
+    case 'cat': {
+      const { cat } = await import('./commands/cat.ts');
+      cat(rest);
+      break;
+    }
+    case 'grep': {
+      const { grep } = await import('./commands/grep.ts');
+      grep(rest);
+      break;
+    }
+    case 'log': {
+      const { log } = await import('./commands/log.ts');
+      log(rest);
+      break;
+    }
+    case 'status': {
+      const { status } = await import('./commands/status.ts');
+      status(rest);
+      break;
+    }
     default:
       process.stderr.write(`Unknown task command: ${subcommand}\n\n`);
       process.stdout.write(`${USAGE}\n`);