@fitlab-ai/agent-infra 0.7.3 → 0.7.5

package/lib/task/artifacts.ts

@@ -0,0 +1,72 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+type Artifact = {
+  index: number;
+  name: string;
+  path: string;
+  size: number;
+  mtimeMs: number;
+};
+
+/**
+ * Enumerate a task directory's artifacts ordered by modification time, oldest
+ * first, so the listing reads like the task's timeline. Filename ascending is a
+ * deterministic tiebreak when two files share the same mtime (e.g. written in
+ * the same millisecond).
+ *
+ * Only top-level regular files are included; subdirectories and dotfiles are
+ * skipped so every entry is something `cat` can print. The returned 1-based
+ * `index` is the source of truth shared by `files` and `cat`.
+ */
+function enumerateArtifacts(taskDir: string): Artifact[] {
+  const entries = fs
+    .readdirSync(taskDir, { withFileTypes: true })
+    .filter((dirent) => dirent.isFile() && !dirent.name.startsWith('.'))
+    .map((dirent) => {
+      const abs = path.join(taskDir, dirent.name);
+      const stat = fs.statSync(abs);
+      return { name: dirent.name, path: abs, size: stat.size, mtimeMs: stat.mtimeMs };
+    });
+
+  entries.sort((a, b) => {
+    if (a.mtimeMs !== b.mtimeMs) return a.mtimeMs - b.mtimeMs;
+    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+  });
+
+  return entries.map((entry, i) => ({ index: i + 1, ...entry }));
+}
+
+/**
+ * Resolve an artifact selector to an absolute path within `taskDir`. The
+ * selector is either a 1-based index `N` (as listed by `files`) or a filename
+ * (with or without the `.md` suffix). Throws with a clear message on failure.
+ */
+function resolveArtifact(taskDir: string, artifactOrN: string): string {
+  if (path.basename(artifactOrN) !== artifactOrN) {
+    throw new Error('artifact name must not contain path separators');
+  }
+
+  if (/^\d+$/.test(artifactOrN)) {
+    const n = Number(artifactOrN);
+    const match = enumerateArtifacts(taskDir).find((a) => a.index === n);
+    if (!match) {
+      throw new Error(`invalid artifact index ${n} (run 'ai task files <ref>' to list)`);
+    }
+    return match.path;
+  }
+
+  const candidates = artifactOrN.endsWith('.md')
+    ? [artifactOrN]
+    : [artifactOrN, `${artifactOrN}.md`];
+  for (const candidate of candidates) {
+    const abs = path.join(taskDir, candidate);
+    if (fs.existsSync(abs) && fs.statSync(abs).isFile()) {
+      return abs;
+    }
+  }
+  throw new Error(`artifact '${artifactOrN}' not found in task directory`);
+}
+
+export { enumerateArtifacts, resolveArtifact };
+export type { Artifact };

package/lib/task/commands/cat.ts

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import { resolveTaskRef } from '../resolve-ref.ts';
+import { resolveArtifact } from '../artifacts.ts';
+
+const USAGE = `Usage: ai task cat <N | #N | TASK-id> <artifact | N>
+
+Prints a task artifact's raw content to stdout.
+  <ref>            Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+  <artifact | N>   Artifact filename (with or without '.md'), or the number from 'ai task files'.
+`;
+
+function cat(args: string[] = []): void {
+  if (args[0] === '--help' || args[0] === '-h') {
+    process.stdout.write(USAGE);
+    return;
+  }
+  if (args.length < 2) {
+    process.stdout.write(USAGE);
+    process.exitCode = 1;
+    return;
+  }
+  const resolved = resolveTaskRef(args[0]!);
+  if (!resolved.ok) {
+    process.stderr.write(`ai task cat: ${resolved.message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  let artifactPath: string;
+  try {
+    artifactPath = resolveArtifact(resolved.taskDir, args[1]!);
+  } catch (e) {
+    process.stderr.write(`ai task cat: ${(e as Error).message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(fs.readFileSync(artifactPath, 'utf8'));
+}
+
+export { cat };

package/lib/task/commands/files.ts

@@ -0,0 +1,53 @@
+import { formatTable } from '../../table.ts';
+import { resolveTaskRef } from '../resolve-ref.ts';
+import { enumerateArtifacts } from '../artifacts.ts';
+
+const USAGE = `Usage: ai task files <N | #N | TASK-id>
+
+Lists the artifacts in a task directory with stable numbers.
+  <ref>   Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+
+Columns: # (artifact number, usable with 'ai task cat') / NAME / SIZE (bytes) / MTIME
+`;
+
+const TABLE_HEADERS = ['#', 'NAME', 'SIZE', 'MTIME'] as const;
+
+function pad2(n: number): string {
+  return String(n).padStart(2, '0');
+}
+
+function formatMtime(mtimeMs: number): string {
+  const d = new Date(mtimeMs);
+  return (
+    `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ` +
+    `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`
+  );
+}
+
+function files(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 files: ${resolved.message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  const artifacts = enumerateArtifacts(resolved.taskDir);
+  // Show the name without the `.md` suffix so the NAME column is exactly what
+  // `ai task cat <ref> <name>` accepts (the resolver re-adds `.md`).
+  const rows = artifacts.map((a) => [
+    String(a.index),
+    a.name.replace(/\.md$/, ''),
+    String(a.size),
+    formatMtime(a.mtimeMs)
+  ]);
+  for (const line of formatTable(TABLE_HEADERS, rows, { zebra: Boolean(process.stdout.isTTY) })) {
+    process.stdout.write(`${line}\n`);
+  }
+}
+
+export { files };

package/lib/task/commands/grep.ts

@@ -0,0 +1,147 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveTaskRef, detectRepoRoot, enumerateTaskDirs } from '../resolve-ref.ts';
+import { enumerateArtifacts, resolveArtifact } from '../artifacts.ts';
+import { loadShortIdByTaskId } from '../short-id.ts';
+
+const USAGE = `Usage: ai task grep <pattern> [ref] [artifact | N]
+
+Literal (non-regex) line search across task artifacts.
+  <pattern>          Literal substring to match (NOT a regex). Case-sensitive by default.
+  [ref]              Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+                     Omit to scan every task under active / blocked / completed
+                     (archive is skipped). With a ref, narrows to that single task
+                     (a TASK-id ref can also resolve an archived task).
+  [artifact | N]     Only valid with <ref>. Artifact filename (with or without '.md')
+                     or the number from 'ai task files'. Narrows to a single artifact.
+
+Options:
+  -i, --ignore-case  Case-insensitive matching.
+  --                 Treat the rest as positional (use for patterns starting with '-').
+
+Output: '{taskId} [#short] {fileStem}:{line}: {matched-line}' (short id only for active tasks).
+Exits 1 with no output when nothing matches.
+`;
+
+function makeMatcher(pattern: string, ignoreCase: boolean): (line: string) => boolean {
+  if (ignoreCase) {
+    const needle = pattern.toLowerCase();
+    return (line) => line.toLowerCase().includes(needle);
+  }
+  return (line) => line.includes(pattern);
+}
+
+// Split content into lines with grep-like semantics: a trailing newline does
+// not yield a phantom final empty line, but genuine interior blank lines stay.
+function splitLines(content: string): string[] {
+  const lines = content.split(/\r?\n/);
+  if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}
+
+function scanArtifact(
+  taskId: string,
+  shortToken: string | undefined,
+  artifactPath: string,
+  matcher: (line: string) => boolean,
+  emit: (line: string) => void
+): number {
+  const content = fs.readFileSync(artifactPath, 'utf8');
+  const stem = path.basename(artifactPath).replace(/\.md$/, '');
+  const prefix = shortToken ? `${taskId} ${shortToken}` : taskId;
+  let count = 0;
+  splitLines(content).forEach((line, i) => {
+    if (matcher(line)) {
+      emit(`${prefix} ${stem}:${i + 1}: ${line}\n`);
+      count++;
+    }
+  });
+  return count;
+}
+
+function grep(args: string[] = []): void {
+  const positional: string[] = [];
+  let ignoreCase = false;
+  let optsEnded = false;
+  for (const a of args) {
+    if (!optsEnded && a === '--') { optsEnded = true; continue; }
+    if (!optsEnded && (a === '-h' || a === '--help')) {
+      process.stdout.write(USAGE);
+      return;
+    }
+    if (!optsEnded && (a === '-i' || a === '--ignore-case')) { ignoreCase = true; continue; }
+    if (!optsEnded && a.startsWith('-') && a !== '-') {
+      process.stderr.write(`ai task grep: unknown flag: ${a}\n`);
+      process.exitCode = 1;
+      return;
+    }
+    positional.push(a);
+  }
+
+  if (positional.length === 0) {
+    process.stdout.write(USAGE);
+    process.exitCode = 1;
+    return;
+  }
+  if (positional.length > 3) {
+    process.stderr.write('ai task grep: too many arguments\n');
+    process.exitCode = 1;
+    return;
+  }
+
+  const [pattern, ref, artifactOrN] = positional;
+  const matcher = makeMatcher(pattern!, ignoreCase);
+  const chunks: string[] = [];
+  const emit = (line: string) => chunks.push(line);
+  let total = 0;
+
+  if (ref === undefined) {
+    // No ref: full scan across active / blocked / completed (no archive).
+    let repoRoot: string;
+    try {
+      repoRoot = detectRepoRoot();
+    } catch (e) {
+      process.stderr.write(`ai task grep: ${(e as Error).message}\n`);
+      process.exitCode = 1;
+      return;
+    }
+    const shortMap = loadShortIdByTaskId(repoRoot);
+    for (const { taskId, taskDir } of enumerateTaskDirs(repoRoot)) {
+      const shortToken = shortMap.get(taskId);
+      for (const a of enumerateArtifacts(taskDir)) {
+        total += scanArtifact(taskId, shortToken, a.path, matcher, emit);
+      }
+    }
+  } else {
+    const resolved = resolveTaskRef(ref);
+    if (!resolved.ok) {
+      process.stderr.write(`ai task grep: ${resolved.message}\n`);
+      process.exitCode = 1;
+      return;
+    }
+    const shortToken = loadShortIdByTaskId(resolved.repoRoot).get(resolved.taskId);
+    if (artifactOrN !== undefined) {
+      let artifactPath: string;
+      try {
+        artifactPath = resolveArtifact(resolved.taskDir, artifactOrN);
+      } catch (e) {
+        process.stderr.write(`ai task grep: ${(e as Error).message}\n`);
+        process.exitCode = 1;
+        return;
+      }
+      total += scanArtifact(resolved.taskId, shortToken, artifactPath, matcher, emit);
+    } else {
+      for (const a of enumerateArtifacts(resolved.taskDir)) {
+        total += scanArtifact(resolved.taskId, shortToken, a.path, matcher, emit);
+      }
+    }
+  }
+
+  if (total === 0) {
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(chunks.join(''));
+}
+
+export { grep };

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 };