@fitlab-ai/agent-infra 0.7.6 → 0.8.0

package/lib/server/runner.ts

@@ -0,0 +1,95 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export type RunnerResult = {
+  exitCode: number | null;
+  signal: NodeJS.Signals | null;
+  stdout: string;
+  stderr: string;
+};
+
+export type RunnerOptions = {
+  spawn?: (file: string, args: string[], onChunk?: (chunk: string) => void | Promise<void>) => Promise<RunnerResult>;
+  onChunk?: (chunk: string) => void | Promise<void>;
+};
+
+function resolveCommand(file: string): string {
+  if (process.platform !== 'win32' || path.extname(file)) {
+    return file;
+  }
+
+  const pathValue = process.env.Path || process.env.PATH || '';
+  const extensions = (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean);
+  for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
+    for (const extension of extensions) {
+      const lowerCandidate = path.join(dir, `${file}${extension.toLowerCase()}`);
+      if (fs.existsSync(lowerCandidate)) return lowerCandidate;
+      const upperCandidate = path.join(dir, `${file}${extension.toUpperCase()}`);
+      if (fs.existsSync(upperCandidate)) return upperCandidate;
+    }
+  }
+
+  return file;
+}
+
+function needsShell(file: string): boolean {
+  return process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(file);
+}
+
+function spawnCapture(
+  file: string,
+  args: string[],
+  onChunk?: (chunk: string) => void | Promise<void>
+): Promise<RunnerResult> {
+  return new Promise((resolve, reject) => {
+    const resolvedFile = resolveCommand(file);
+    const child = spawn(resolvedFile, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      shell: needsShell(resolvedFile)
+    });
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    let pendingChunks = Promise.resolve();
+
+    const rejectOnce = (error: unknown): void => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    };
+
+    const resolveOnce = (result: RunnerResult): void => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+
+    const enqueueChunk = (chunk: string): void => {
+      if (!onChunk) return;
+      pendingChunks = pendingChunks.then(() => onChunk(chunk));
+      pendingChunks.catch(rejectOnce);
+    };
+
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk;
+      enqueueChunk(chunk);
+    });
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk;
+      enqueueChunk(chunk);
+    });
+    child.on('error', rejectOnce);
+    child.on('close', (exitCode, signal) => {
+      pendingChunks
+        .then(() => resolveOnce({ exitCode, signal, stdout, stderr }))
+        .catch(rejectOnce);
+    });
+  });
+}
+
+export async function runAi(args: string[], options: RunnerOptions = {}): Promise<RunnerResult> {
+  return (options.spawn ?? spawnCapture)('ai', args, options.onChunk);
+}

package/lib/server/server.schema.json

@@ -0,0 +1,127 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/fitlab-ai/agent-infra/lib/server/server.schema.json",
+  "title": "agent-infra server configuration",
+  "description": "Schema for .agents/server.json. Secrets (appSecret, tokens, passwords) must NOT be committed here — put them in .agents/server.local.json or AGENT_INFRA_SERVER_* environment variables.",
+  "type": "object",
+  "additionalProperties": true,
+  "properties": {
+    "$schema": {
+      "type": "string"
+    },
+    "log": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "path": {
+          "type": "string",
+          "description": "Log file path. Defaults to ~/.agent-infra/logs/<project>/<repo-hash>/server.log (outside the repo; the repo-hash isolates checkouts that share a project). Relative paths resolve against the repo root; absolute paths are used as-is."
+        },
+        "rotateAtBytes": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Rotate the log to <path>.1 at startup if it already exceeds this size.",
+          "default": 52428800
+        }
+      }
+    },
+    "heartbeatMs": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Interval between daemon heartbeat log lines, in milliseconds.",
+      "default": 30000
+    },
+    "adapters": {
+      "type": "object",
+      "description": "Per-adapter configuration. Only adapters with enabled=true are loaded.",
+      "properties": {
+        "feishu": {
+          "type": "object",
+          "description": "Feishu (Lark) IM adapter. The appSecret must NOT be committed here — put it in .agents/server.local.json or AGENT_INFRA_SERVER_adapters__feishu__appSecret.",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "default": false
+            },
+            "appId": {
+              "type": "string",
+              "description": "Feishu self-built app App ID."
+            },
+            "domain": {
+              "type": "string",
+              "enum": ["feishu", "lark"],
+              "default": "feishu",
+              "description": "Open platform domain: feishu (default) or lark."
+            }
+          },
+          "required": ["enabled"]
+        }
+      },
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "enabled": {
+            "type": "boolean",
+            "default": false
+          }
+        },
+        "required": ["enabled"]
+      }
+    },
+    "command": {
+      "type": "object",
+      "description": "Command protocol defaults and skill allow-list.",
+      "additionalProperties": false,
+      "properties": {
+        "defaultTui": {
+          "type": "string",
+          "enum": ["claude", "codex", "gemini", "opencode"],
+          "default": "codex"
+        },
+        "skillTuiDefaults": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "enum": ["claude", "codex", "gemini", "opencode"]
+          }
+        },
+        "allowedSkills": {
+          "type": "array",
+          "items": { "type": "string" }
+        }
+      }
+    },
+    "auth": {
+      "type": "object",
+      "description": "Adapter-qualified user roles. Keys look like feishu:ou_xxx.",
+      "additionalProperties": false,
+      "properties": {
+        "users": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": true,
+            "properties": {
+              "role": {
+                "type": "string",
+                "enum": ["read", "write", "exec"]
+              },
+              "name": { "type": "string" }
+            },
+            "required": ["role"]
+          }
+        }
+      }
+    },
+    "stream": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "throttleMs": { "type": "integer", "minimum": 0, "default": 1500 },
+        "chunkChars": { "type": "integer", "minimum": 1, "default": 4000 },
+        "tailChars": { "type": "integer", "minimum": 1, "default": 8000 },
+        "timeoutMs": { "type": "integer", "minimum": 1, "default": 1800000 }
+      }
+    }
+  }
+}

package/lib/server/streamer.ts

@@ -0,0 +1,57 @@
+import { redactSecrets } from './redact.ts';
+import type { RunnerResult } from './runner.ts';
+
+export type StreamOptions = {
+  title: string;
+  chunkChars?: number;
+  throttleMs?: number;
+};
+
+function chunks(text: string, size: number): string[] {
+  if (text.length === 0) return [];
+  const out: string[] = [];
+  for (let i = 0; i < text.length; i += size) {
+    out.push(text.slice(i, i + size));
+  }
+  return out;
+}
+
+export async function streamCommand(
+  options: StreamOptions,
+  run: (emit?: (chunk: string) => Promise<void>) => Promise<RunnerResult>,
+  send: (text: string) => Promise<void>
+): Promise<RunnerResult> {
+  await send(`started ${options.title}`);
+  const size = options.chunkChars ?? 4000;
+  const throttleMs = options.throttleMs ?? 0;
+  let streamed = false;
+  let buffer = '';
+  let lastFlush = 0;
+
+  const flush = async (): Promise<void> => {
+    if (!buffer) return;
+    const text = redactSecrets(buffer);
+    buffer = '';
+    lastFlush = Date.now();
+    for (const chunk of chunks(text, size)) {
+      await send(chunk);
+    }
+  };
+
+  const emit = async (chunk: string): Promise<void> => {
+    streamed = true;
+    buffer += chunk;
+    const due = throttleMs === 0 || Date.now() - lastFlush >= throttleMs;
+    if (buffer.length >= size || due) {
+      await flush();
+    }
+  };
+
+  const result = await run(emit);
+  if (!streamed) {
+    buffer += [result.stdout, result.stderr].filter(Boolean).join('\n');
+  }
+  await flush();
+  await send(`finished ${options.title} exitCode=${result.exitCode} signal=${result.signal ?? 'null'}`);
+  return result;
+}

package/lib/task/commands/decisions.ts

@@ -0,0 +1,272 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { formatTable } from '../../table.ts';
+import { resolveTaskRef } from '../resolve-ref.ts';
+import { parseLedger, HUMAN_DECISION_STATUSES, type LedgerRow } from '../ledger.ts';
+import { extractSubSection } from '../sections.ts';
+
+const USAGE = `Usage: ai task decisions <N | #N | TASK-id> [selector] [options]
+
+Lists the human-decision (HD-) items recorded in a task's review disagreement
+ledger, or prints the full detail block for a single item. Read-only.
+
+  <ref>          Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+  [selector]     Ordinal (1-based) or HD id (e.g. 'HD-3') to show one item's detail.
+
+Options:
+  --all              Include already-decided (human-decided) items, not just pending.
+  --stage <s>        Filter to one stage: analysis | plan | code.
+  --format <fmt>     Output format: text (default) | markdown.
+  -h, --help         Show this help.
+
+Aliased as 'ai task d'.
+`;
+
+const STAGES = new Set(['analysis', 'plan', 'code']);
+const FORMATS = new Set(['text', 'markdown']);
+const HD_ID_RE = /^HD-\d+$/;
+
+function fail(message: string): void {
+  process.stderr.write(`ai task decisions: ${message}\n`);
+  process.exitCode = 1;
+}
+
+type ParsedArgs = {
+  positionals: string[];
+  all: boolean;
+  stage?: string;
+  format: string;
+};
+
+// Returns null and sets the exit code when an option is malformed.
+function parseArgs(args: string[]): ParsedArgs | null {
+  const out: ParsedArgs = { positionals: [], all: false, format: 'text' };
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i]!;
+    if (a === '--all') {
+      out.all = true;
+    } else if (a === '--stage') {
+      const v = args[i + 1];
+      if (v === undefined) {
+        fail('--stage requires a value (analysis|plan|code)');
+        return null;
+      }
+      out.stage = v;
+      i += 1;
+    } else if (a.startsWith('--stage=')) {
+      out.stage = a.slice('--stage='.length);
+    } else if (a === '--format') {
+      const v = args[i + 1];
+      if (v === undefined) {
+        fail('--format requires a value (text|markdown)');
+        return null;
+      }
+      out.format = v;
+      i += 1;
+    } else if (a.startsWith('--format=')) {
+      out.format = a.slice('--format='.length);
+    } else if (a.startsWith('-')) {
+      fail(`unknown option '${a}'`);
+      return null;
+    } else {
+      out.positionals.push(a);
+    }
+  }
+  return out;
+}
+
+// Parse `<file>.md#anchor` evidence into its filename, when present.
+function evidenceFile(evidence: string): string | null {
+  const m = /([\w.-]+\.md)#/.exec(evidence);
+  return m ? m[1]! : null;
+}
+
+function roundOf(file: string): number {
+  const m = /-r(\d+)\.md$/.exec(file);
+  return m ? Number.parseInt(m[1]!, 10) : 1;
+}
+
+// Locate the `### HD-N` detail block for a row. Prefer the artifact named by the
+// row's evidence anchor; otherwise scan analysis/plan/code artifacts and return
+// the block from the highest-round file that contains it. Returns '' when none
+// is found (caller degrades gracefully — plan B3).
+function findDetailBlock(row: LedgerRow, taskDir: string): string {
+  const hinted = evidenceFile(row.evidence);
+  if (hinted) {
+    const p = path.join(taskDir, hinted);
+    if (fs.existsSync(p)) {
+      const block = extractSubSection(fs.readFileSync(p, 'utf8'), row.id);
+      if (block) return block;
+    }
+  }
+  let best = '';
+  let bestRound = -1;
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(taskDir);
+  } catch {
+    return '';
+  }
+  for (const file of entries) {
+    if (!/^(analysis|plan|code)(-r\d+)?\.md$/.test(file)) continue;
+    const block = extractSubSection(fs.readFileSync(path.join(taskDir, file), 'utf8'), row.id);
+    if (block && roundOf(file) > bestRound) {
+      best = block;
+      bestRound = roundOf(file);
+    }
+  }
+  return best;
+}
+
+// Pull the `## 人工裁决` record lines that mention this HD id, so a decided item
+// shows the human's recorded ruling alongside its detail block.
+function findDecisionRecord(id: string, content: string): string[] {
+  const lines = content.split('\n');
+  let i = 0;
+  while (i < lines.length && !/^##\s+(人工裁决|Human Decisions?)\s*$/.test(lines[i]!)) i += 1;
+  if (i >= lines.length) return [];
+  const idRe = new RegExp(`(^|[^\\w-])${id}(?![\\w-])`);
+  const out: string[] = [];
+  for (let j = i + 1; j < lines.length; j += 1) {
+    if (/^##\s/.test(lines[j]!)) break;
+    if (lines[j]!.trim().startsWith('-') && idRe.test(lines[j]!)) out.push(lines[j]!);
+  }
+  return out;
+}
+
+function titleOf(row: LedgerRow, taskDir: string): string {
+  const block = findDetailBlock(row, taskDir);
+  if (block) {
+    return block
+      .split('\n')[0]!
+      .replace(/^###\s+/, '')
+      .replace(/\s*\[needs-human-decision\]\s*$/, '')
+      .trim();
+  }
+  return row.evidence || '(无详情)';
+}
+
+function renderList(rows: LedgerRow[], format: string, taskDir: string): void {
+  if (rows.length === 0) {
+    process.stdout.write('无待裁决项。\n');
+    return;
+  }
+  const headers = ['#', 'ID', 'STAGE', 'SEVERITY', 'STATUS', 'EVIDENCE', 'TITLE'];
+  const data = rows.map((r, i) => [
+    String(i + 1),
+    r.id,
+    r.stage,
+    r.severity,
+    r.status,
+    r.evidence,
+    titleOf(r, taskDir)
+  ]);
+  if (format === 'markdown') {
+    const sep = headers.map(() => '---');
+    const md = [
+      `| ${headers.join(' | ')} |`,
+      `| ${sep.join(' | ')} |`,
+      ...data.map((row) => `| ${row.join(' | ')} |`)
+    ];
+    process.stdout.write(`${md.join('\n')}\n`);
+    return;
+  }
+  process.stdout.write(`${formatTable(headers, data).join('\n')}\n`);
+}
+
+function renderDetail(
+  rows: LedgerRow[],
+  selector: string,
+  format: string,
+  taskDir: string,
+  content: string
+): void {
+  let row: LedgerRow | undefined;
+  if (/^\d+$/.test(selector)) {
+    const idx = Number.parseInt(selector, 10) - 1;
+    if (idx < 0 || idx >= rows.length) {
+      fail(`ordinal '${selector}' out of range (1..${rows.length})`);
+      return;
+    }
+    row = rows[idx];
+  } else {
+    const want = selector.toUpperCase();
+    const matches = rows.filter((r) => r.id.toUpperCase() === want);
+    if (matches.length === 0) {
+      fail(`no decision item matches '${selector}'`);
+      return;
+    }
+    if (matches.length > 1) {
+      fail(`duplicate id '${selector}' in ledger; select by ordinal instead`);
+      return;
+    }
+    row = matches[0];
+  }
+
+  const r = row!;
+  const block = findDetailBlock(r, taskDir);
+  const lines: string[] = [];
+  if (format === 'markdown') {
+    lines.push(`**${r.id}** (${r.stage}/${r.severity}) · status=\`${r.status}\` · evidence: \`${r.evidence}\``, '');
+  } else {
+    lines.push(`${r.id} (${r.stage}/${r.severity}) status=${r.status}`, `evidence: ${r.evidence}`, '');
+  }
+  if (block) {
+    lines.push(block);
+  } else {
+    lines.push(
+      `（详情块未找到：未在任务产物中定位到 \`### ${r.id}\` 锚点，可能为历史产物或尚未写入；evidence 指向 ${r.evidence}）`
+    );
+  }
+  if (r.status === 'human-decided') {
+    const record = findDecisionRecord(r.id, content);
+    if (record.length) {
+      lines.push('', '人工裁定：', ...record);
+    }
+  }
+  process.stdout.write(`${lines.join('\n')}\n`);
+}
+
+function decisions(args: string[] = []): void {
+  if (args[0] === '--help' || args[0] === '-h') {
+    process.stdout.write(USAGE);
+    return;
+  }
+  const parsed = parseArgs(args);
+  if (!parsed) return;
+  if (parsed.positionals.length === 0) {
+    process.stdout.write(USAGE);
+    process.exitCode = 1;
+    return;
+  }
+  if (parsed.stage !== undefined && !STAGES.has(parsed.stage)) {
+    fail(`invalid --stage '${parsed.stage}' (expected analysis|plan|code)`);
+    return;
+  }
+  if (!FORMATS.has(parsed.format)) {
+    fail(`invalid --format '${parsed.format}' (expected text|markdown)`);
+    return;
+  }
+
+  const resolved = resolveTaskRef(parsed.positionals[0]!);
+  if (!resolved.ok) {
+    fail(resolved.message);
+    return;
+  }
+
+  const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+  let rows = parseLedger(content).filter((r) => HD_ID_RE.test(r.id));
+  rows = rows.filter((r) =>
+    parsed.all ? HUMAN_DECISION_STATUSES.has(r.status) : r.status === 'needs-human-decision'
+  );
+  if (parsed.stage !== undefined) rows = rows.filter((r) => r.stage === parsed.stage);
+
+  const selector = parsed.positionals[1];
+  if (selector === undefined) {
+    renderList(rows, parsed.format, resolved.taskDir);
+  } else {
+    renderDetail(rows, selector, parsed.format, resolved.taskDir, content);
+  }
+}
+
+export { decisions };

package/lib/task/commands/issue-body.ts

@@ -0,0 +1,102 @@
+import fs from 'node:fs';
+import { resolveTaskRef } from '../resolve-ref.ts';
+import { extractTitle } from '../frontmatter.ts';
+import { extractSection, findSectionHeading } from '../sections.ts';
+import { renderTemplateBody, PLACEHOLDER } from '../issue-form.ts';
+import type { TaskFields } from '../issue-form.ts';
+
+const USAGE = `Usage: ai task issue-body <N | #N | TASK-id> [--template <path>]
+
+Print a deterministic Issue body extracted from a task's task.md.
+  <ref>               Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+  --template <path>   Render the final body for the given GitHub Issue Form (scenario A);
+                      without it, print the default '描述 + 需求' body (scenario B).
+
+Only the task title, '## 描述' and '## 需求' sections are ever emitted; the rest of
+task.md (scaffolding sections, placeholders) is never written to the body.
+`;
+
+const DESCRIPTION_ALIASES = ['描述', 'Description'];
+const REQUIREMENTS_ALIASES = ['需求', 'Requirements'];
+
+/**
+ * Build the scenario B default body, mirroring whichever heading language the
+ * task.md actually uses, with empty sections falling back to `N/A`.
+ */
+function buildDefaultBody(content: string): string {
+  const descHeading = findSectionHeading(content, DESCRIPTION_ALIASES);
+  const reqHeading = findSectionHeading(content, REQUIREMENTS_ALIASES);
+  const description = extractSection(content, DESCRIPTION_ALIASES) || PLACEHOLDER;
+  const requirements = extractSection(content, REQUIREMENTS_ALIASES) || PLACEHOLDER;
+  return `## ${descHeading}\n\n${description}\n\n## ${reqHeading}\n\n${requirements}\n`;
+}
+
+function readTaskFields(content: string): TaskFields {
+  return {
+    title: extractTitle(content),
+    description: extractSection(content, DESCRIPTION_ALIASES),
+    requirements: extractSection(content, REQUIREMENTS_ALIASES)
+  };
+}
+
+function issueBody(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;
+  }
+
+  let ref: string | undefined;
+  let templatePath: string | undefined;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i]!;
+    if (arg === '--template') {
+      templatePath = args[i + 1];
+      i += 1;
+    } else if (ref === undefined) {
+      ref = arg;
+    }
+  }
+
+  if (!ref) {
+    process.stderr.write('ai task issue-body: missing task ref\n');
+    process.exitCode = 1;
+    return;
+  }
+  if (templatePath === undefined && args.includes('--template')) {
+    process.stderr.write('ai task issue-body: --template requires a path\n');
+    process.exitCode = 1;
+    return;
+  }
+
+  const resolved = resolveTaskRef(ref);
+  if (!resolved.ok) {
+    process.stderr.write(`ai task issue-body: ${resolved.message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+
+  if (templatePath !== undefined) {
+    let formText: string;
+    try {
+      formText = fs.readFileSync(templatePath, 'utf8');
+    } catch (e) {
+      process.stderr.write(`ai task issue-body: cannot read template '${templatePath}': ${(e as Error).message}\n`);
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      process.stdout.write(renderTemplateBody(formText, readTaskFields(content)));
+    } catch (e) {
+      process.stderr.write(`ai task issue-body: cannot render template '${templatePath}': ${(e as Error).message}\n`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  process.stdout.write(buildDefaultBody(content));
+}
+
+export { issueBody, buildDefaultBody };