@fitlab-ai/agent-infra 0.7.6 → 0.8.0

package/dist/lib/task/sections.js

@@ -0,0 +1,73 @@
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Return the body of the first `## {alias}` section (any alias matches), from
+ * the heading line to the next `## ` heading or EOF. Lines are preserved
+ * verbatim (checkbox text is never normalized); only leading/trailing blank
+ * lines are trimmed. Returns '' when no alias heading is present.
+ */
+function extractSection(content, aliases) {
+    const lines = content.split('\n');
+    let start = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i].trim();
+        if (aliases.some((alias) => new RegExp(`^##\\s+${escapeRegExp(alias)}\\s*$`).test(line))) {
+            start = i + 1;
+            break;
+        }
+    }
+    if (start === -1)
+        return '';
+    let end = lines.length;
+    for (let i = start; i < lines.length; i += 1) {
+        if (/^##\s+/.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    return lines.slice(start, end).join('\n').replace(/^\n+/, '').replace(/\n+$/, '');
+}
+/**
+ * Return the heading alias that actually appears as a `## {alias}` line, so a
+ * rendered section can mirror the source language. Falls back to the first
+ * alias when none is present.
+ */
+function findSectionHeading(content, aliases) {
+    for (const alias of aliases) {
+        if (new RegExp(`^##\\s+${escapeRegExp(alias)}\\s*$`, 'm').test(content))
+            return alias;
+    }
+    return aliases[0];
+}
+/**
+ * Return the body of the first `### {headingPrefix}` sub-section, from the
+ * heading line (inclusive) to the next `### ` / `## ` heading or EOF. Used to
+ * pull a single `### HD-N` human-decision detail block out of an artifact. The
+ * prefix must be followed by a word boundary so `HD-1` does not match `HD-10`
+ * (e.g. `### HD-1`, `### HD-1：标题`, `### HD-1 [needs-human-decision]`). Leading
+ * and trailing blank lines are trimmed. Returns '' when no match is present.
+ */
+function extractSubSection(content, headingPrefix) {
+    const lines = content.split('\n');
+    const headRe = new RegExp(`^###\\s+${escapeRegExp(headingPrefix)}(?![\\w-])`);
+    let start = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+        if (headRe.test(lines[i].trim())) {
+            start = i;
+            break;
+        }
+    }
+    if (start === -1)
+        return '';
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i += 1) {
+        if (/^###?\s+/.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    return lines.slice(start, end).join('\n').replace(/^\n+/, '').replace(/\n+$/, '');
+}
+export { extractSection, findSectionHeading, extractSubSection };
+//# sourceMappingURL=sections.js.map

package/lib/decide.ts

@@ -0,0 +1,124 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { VERSION } from './version.ts';
+import { resolveTaskRef } from './task/resolve-ref.ts';
+
+const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+
+type DecideOptions = {
+  repoRoot?: string;
+  now?: () => string;
+  version?: string;
+};
+
+function detectRepoRoot(): string {
+  return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+    encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'pipe']
+  }).trim();
+}
+
+function defaultNow(): string {
+  return new Intl.DateTimeFormat('sv-SE', {
+    timeZoneName: 'longOffset',
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hour12: false
+  })
+    .format(new Date())
+    .replace(' GMT', '');
+}
+
+function taskPath(repoRoot: string, ref: string): string {
+  if (!TASK_ID_RE.test(ref)) {
+    const resolved = resolveTaskRef(ref);
+    if (!resolved.ok) throw new Error(resolved.message);
+    if (!resolved.taskDir.includes(`${path.join('.agents', 'workspace', 'active')}${path.sep}`)) {
+      throw new Error(`task ${resolved.taskId} is not active`);
+    }
+    return resolved.taskMdPath;
+  }
+  const candidate = path.join(repoRoot, '.agents', 'workspace', 'active', ref, 'task.md');
+  if (!fs.existsSync(candidate)) throw new Error(`active task not found: ${ref}`);
+  return candidate;
+}
+
+function replaceFrontmatterField(content: string, field: string, value: string): string {
+  const re = new RegExp(`^${field}:.*$`, 'm');
+  if (re.test(content)) return content.replace(re, `${field}: ${value}`);
+  return content.replace(/^---\n/, `---\n${field}: ${value}\n`);
+}
+
+function replaceLedgerRow(content: string, hdId: string): { content: string; found: boolean; pending: boolean } {
+  const lines = content.split('\n');
+  let found = false;
+  let pending = false;
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] as string;
+    if (!line.trim().startsWith(`| ${hdId} |`)) continue;
+    found = true;
+    const cells = line.split('|').slice(1, -1).map((cell) => cell.trim());
+    if (cells[4] !== 'needs-human-decision') break;
+    pending = true;
+    cells[4] = 'human-decided';
+    cells[5] = `task.md#${hdId}`;
+    lines[i] = `| ${cells.join(' | ')} |`;
+    break;
+  }
+  return { content: lines.join('\n'), found, pending };
+}
+
+function appendUnderHeading(content: string, heading: string, block: string): string {
+  if (!content.includes(`${heading}\n`)) {
+    return `${content.trimEnd()}\n\n${heading}\n\n${block}\n`;
+  }
+  const idx = content.indexOf(`${heading}\n`) + heading.length + 1;
+  const before = content.slice(0, idx);
+  const after = content.slice(idx);
+  return `${before}\n${block}\n${after.replace(/^\n/, '')}`;
+}
+
+export async function decide(args: string[], options: DecideOptions = {}): Promise<number> {
+  const [taskRef, hdId, ...decisionParts] = args;
+  if (!taskRef || !hdId || decisionParts.length === 0) {
+    process.stderr.write('Usage: ai decide <task-ref> <HD-id> <decision>\n');
+    return 1;
+  }
+  try {
+    const repoRoot = options.repoRoot ?? detectRepoRoot();
+    const file = taskPath(repoRoot, taskRef);
+    let content = fs.readFileSync(file, 'utf8');
+    const replaced = replaceLedgerRow(content, hdId);
+    if (!replaced.found) throw new Error(`${hdId} not found in review ledger`);
+    if (!replaced.pending) throw new Error(`${hdId} is not needs-human-decision`);
+    content = replaced.content;
+    const now = (options.now ?? defaultNow)();
+    content = replaceFrontmatterField(content, 'updated_at', now);
+    content = replaceFrontmatterField(content, 'agent_infra_version', options.version ?? VERSION);
+    const decision = decisionParts.join(' ');
+    content = appendUnderHeading(
+      content,
+      '## 人工裁决',
+      `### ${hdId}\n\n- **裁决时间**：${now}\n- **裁决结果**：${decision}`
+    );
+    content = appendUnderHeading(
+      content,
+      '## 活动日志',
+      `- ${now} — **Human Decision** by human — ${hdId} decided`
+    );
+    fs.writeFileSync(file, content);
+    return 0;
+  } catch (error) {
+    process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+}
+
+export async function cmdDecide(args: string[]): Promise<void> {
+  process.exitCode = await decide(args);
+}

package/lib/run/host.ts

@@ -0,0 +1,47 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export type RunProcessResult = {
+  exitCode: number | null;
+  signal?: NodeJS.Signals | null;
+  stdout?: string;
+  stderr?: string;
+};
+
+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);
+}
+
+export async function runHostCommand(command: string[]): Promise<RunProcessResult> {
+  const [file, ...args] = command;
+  if (!file) throw new Error('run: missing command');
+  return new Promise((resolve, reject) => {
+    const resolvedFile = resolveCommand(file);
+    const child = spawn(resolvedFile, args, {
+      stdio: ['ignore', 'inherit', 'inherit'],
+      shell: needsShell(resolvedFile)
+    });
+    child.on('error', reject);
+    child.on('close', (exitCode, signal) => resolve({ exitCode, signal }));
+  });
+}

package/lib/run/index.ts

@@ -0,0 +1,124 @@
+import { loadServerConfig } from '../server/config.ts';
+import { resolveTaskBranch } from '../sandbox/task-resolver.ts';
+import { runInSandbox } from '../sandbox/capture.ts';
+import { buildTuiCommand, renderPrompt, selectTui } from './tui.ts';
+import { getSkillRunSpec } from './skills.ts';
+import { runHostCommand, type RunProcessResult } from './host.ts';
+
+export type ParsedRunArgs = {
+  skill: string;
+  taskRef: string | null;
+  args: string[];
+  tui: string | null;
+};
+
+export type SandboxRunRequest = {
+  taskRef: string;
+  branch: string;
+  command: string[];
+};
+
+export type RunSkillOptions = {
+  command?: Record<string, unknown>;
+  repoRoot?: string;
+  runHost?: (command: string[]) => Promise<RunProcessResult>;
+  runSandbox?: (request: SandboxRunRequest) => Promise<RunProcessResult>;
+  writeStdout?: (chunk: string) => void;
+  writeStderr?: (chunk: string) => void;
+};
+
+const USAGE = `Usage: ai run <skill> [task-ref] [args...] [--tui <name>]
+
+Examples:
+  ai run create-task "describe the task" --tui codex
+  ai run code-task #7 --tui codex`;
+
+function extractTui(args: string[]): { rest: string[]; tui: string | null } {
+  const rest: string[] = [];
+  let tui: string | null = null;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i] as string;
+    if (arg === '--tui') {
+      const value = args[i + 1];
+      if (!value) throw new Error('--tui requires a value');
+      tui = value;
+      i += 1;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { rest, tui };
+}
+
+export function parseRunArgs(args: string[]): ParsedRunArgs {
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    throw new Error(USAGE);
+  }
+  const { rest, tui } = extractTui(args);
+  const [skill = '', maybeTaskRef, ...remaining] = rest;
+  const spec = getSkillRunSpec(skill);
+  if (!spec) throw new Error(`Unknown skill '${skill}'`);
+  if (spec.kind === 'create') {
+    const createArgs = rest.slice(1);
+    if (createArgs.length === 0) throw new Error('create-task requires a description');
+    return { skill, taskRef: null, args: createArgs, tui };
+  }
+  if (!maybeTaskRef) throw new Error(`${skill} requires a task-ref`);
+  return { skill, taskRef: maybeTaskRef, args: remaining, tui };
+}
+
+function assertAllowedByConfig(skill: string, commandConfig: Record<string, unknown>): void {
+  const allowed = commandConfig.allowedSkills;
+  if (!Array.isArray(allowed)) return;
+  if (!allowed.every((entry) => typeof entry === 'string')) {
+    throw new Error('command.allowedSkills must be an array of skill names');
+  }
+  if (!allowed.includes(skill)) {
+    throw new Error(`Skill '${skill}' is not allowed by command.allowedSkills`);
+  }
+}
+
+export async function runSkill(args: string[], options: RunSkillOptions = {}): Promise<number> {
+  const parsed = parseRunArgs(args);
+  const config = options.command ? null : loadServerConfig({ rootDir: options.repoRoot });
+  const commandConfig = options.command ?? config?.command ?? {};
+  assertAllowedByConfig(parsed.skill, commandConfig);
+  const tui = selectTui(parsed.skill, { cliTui: parsed.tui, command: commandConfig });
+  const promptArgs = parsed.taskRef === null ? parsed.args : [parsed.taskRef, ...parsed.args];
+  const prompt = renderPrompt({ tui, skill: parsed.skill, args: promptArgs });
+  const [file, argv] = buildTuiCommand(tui, prompt);
+  const command = [file, ...argv];
+
+  if (parsed.taskRef === null) {
+    const result = await (options.runHost ?? runHostCommand)(command);
+    return result.exitCode ?? (result.signal ? 1 : 0);
+  }
+
+  const repoRoot = options.repoRoot ?? config?.repoRoot ?? process.cwd();
+  const branch = resolveTaskBranch(parsed.taskRef, repoRoot);
+  const runSandbox = options.runSandbox ?? ((request: SandboxRunRequest) => runInSandbox(request));
+  const result = await runSandbox({ taskRef: parsed.taskRef, branch, command });
+  if (result.stdout) {
+    (options.writeStdout ?? ((chunk: string) => process.stdout.write(chunk)))(result.stdout);
+  }
+  if (result.stderr) {
+    (options.writeStderr ?? ((chunk: string) => process.stderr.write(chunk)))(result.stderr);
+  }
+  return result.exitCode ?? (result.signal ? 1 : 0);
+}
+
+export async function cmdRun(args: string[]): Promise<void> {
+  try {
+    const code = await runSkill(args);
+    process.exitCode = code;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.startsWith('Usage:')) {
+      process.stdout.write(`${message}\n`);
+      process.exitCode = args.length === 0 ? 1 : 0;
+    } else {
+      process.stderr.write(`Error: ${message}\n`);
+      process.exitCode = 1;
+    }
+  }
+}

package/lib/run/prompt.ts

@@ -0,0 +1 @@
+export { renderPrompt } from './tui.ts';

package/lib/run/skills.ts

@@ -0,0 +1,34 @@
+export type SkillRunSpec =
+  | { kind: 'task'; skill: string; role: 'exec'; requiresSandbox: true }
+  | { kind: 'create'; skill: 'create-task'; role: 'exec'; requiresSandbox: false };
+
+const TASK_SKILLS = new Set([
+  'analyze-task',
+  'block-task',
+  'cancel-task',
+  'code-task',
+  'commit',
+  'complete-task',
+  'create-pr',
+  'plan-task',
+  'review-analysis',
+  'review-code',
+  'review-plan',
+  'test',
+  'test-integration',
+  'watch-pr'
+]);
+
+export function getSkillRunSpec(skill: string): SkillRunSpec | null {
+  if (skill === 'create-task') {
+    return { kind: 'create', skill: 'create-task', role: 'exec', requiresSandbox: false };
+  }
+  if (TASK_SKILLS.has(skill)) {
+    return { kind: 'task', skill, role: 'exec', requiresSandbox: true };
+  }
+  return null;
+}
+
+export function allowedSkillNames(): string[] {
+  return ['create-task', ...TASK_SKILLS].sort();
+}

package/lib/run/tui.ts

@@ -0,0 +1,40 @@
+export type TuiName = 'claude' | 'codex' | 'gemini' | 'opencode';
+
+const TUI_NAMES = new Set(['claude', 'codex', 'gemini', 'opencode']);
+
+export type CommandConfig = {
+  defaultTui?: unknown;
+  skillTuiDefaults?: unknown;
+};
+
+function isTuiName(value: unknown): value is TuiName {
+  return typeof value === 'string' && TUI_NAMES.has(value);
+}
+
+export function selectTui(
+  skill: string,
+  options: { cliTui?: string | null; command?: CommandConfig }
+): TuiName {
+  if (isTuiName(options.cliTui)) return options.cliTui;
+  const defaults = options.command?.skillTuiDefaults;
+  if (defaults && typeof defaults === 'object' && !Array.isArray(defaults)) {
+    const value = (defaults as Record<string, unknown>)[skill];
+    if (isTuiName(value)) return value;
+  }
+  if (isTuiName(options.command?.defaultTui)) return options.command.defaultTui;
+  return 'codex';
+}
+
+export function renderPrompt(params: { tui: TuiName; skill: string; args: string[] }): string {
+  const suffix = [params.skill, ...params.args].join(' ').trim();
+  if (params.tui === 'codex') return `$${suffix}`;
+  if (params.tui === 'gemini') return `/agent-infra:${suffix}`;
+  return `/${suffix}`;
+}
+
+export function buildTuiCommand(tui: TuiName, prompt: string): [string, string[]] {
+  if (tui === 'claude') return ['claude', ['--dangerously-skip-permissions', '--print', prompt]];
+  if (tui === 'gemini') return ['gemini', ['--approval-mode', 'yolo', '--prompt', prompt]];
+  if (tui === 'opencode') return ['opencode', ['run', '--dangerously-skip-permissions', prompt]];
+  return ['codex', ['exec', '--dangerously-bypass-approvals-and-sandbox', prompt]];
+}

package/lib/sandbox/capture.ts

@@ -0,0 +1,84 @@
+import { spawn } from 'node:child_process';
+import { loadConfig } from './config.ts';
+import { containerNameCandidates, sandboxBranchLabel, sandboxLabel } from './constants.ts';
+import { detectEngine } from './engine.ts';
+import { hostTimezoneEnvFlags, terminalEnvFlags } from './commands/enter.ts';
+import {
+  fetchSandboxRows,
+  selectSandboxContainer,
+  startSandboxContainer,
+  type SandboxRow
+} from './commands/list-running.ts';
+
+export type SandboxCaptureRequest = {
+  taskRef: string;
+  branch: string;
+  command: string[];
+  timeoutMs?: number;
+};
+
+export type SandboxCaptureResult = {
+  exitCode: number | null;
+  signal: NodeJS.Signals | null;
+  stdout: string;
+  stderr: string;
+};
+
+export type SandboxCaptureOptions = {
+  engine?: string;
+  repoRoot?: string;
+  containerCandidates?: string[];
+  rows?: SandboxRow[];
+  startContainer?: (name: string) => void;
+  spawn?: (file: string, args: string[]) => Promise<SandboxCaptureResult>;
+};
+
+async function spawnCapture(file: string, args: string[]): Promise<SandboxCaptureResult> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(file, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk;
+    });
+    child.on('error', reject);
+    child.on('close', (exitCode, signal) => resolve({ exitCode, signal, stdout, stderr }));
+  });
+}
+
+export async function runInSandbox(
+  request: SandboxCaptureRequest,
+  options: SandboxCaptureOptions = {}
+): Promise<SandboxCaptureResult> {
+  const config = options.engine ? null : loadConfig();
+  const engine = options.engine ?? detectEngine(config!);
+  const rows =
+    options.rows ??
+    (() => {
+      const fetched = fetchSandboxRows(engine, sandboxLabel(config!), sandboxBranchLabel(config!));
+      return [...fetched.running, ...fetched.nonRunning];
+    })();
+  const candidates = options.containerCandidates ?? containerNameCandidates(config!, request.branch);
+  const found = selectSandboxContainer(rows, candidates);
+  if (!found) {
+    throw new Error(
+      `Sandbox for ${request.branch} not found. Create it first with ai sandbox create ${request.taskRef}.`
+    );
+  }
+  if (!found.running) {
+    (options.startContainer ?? ((name: string) => startSandboxContainer(engine, name)))(found.name);
+  }
+  const dockerArgs = [
+    'exec',
+    ...terminalEnvFlags(),
+    ...hostTimezoneEnvFlags(),
+    found.name,
+    ...request.command
+  ];
+  return (options.spawn ?? spawnCapture)('docker', dockerArgs);
+}

package/lib/sandbox/commands/create.ts

@@ -740,6 +740,63 @@ function readHostJsonSafe(filePath: string): JsonObject | null {
   }
 }
 
+const CLAUDE_SETTINGS_INHERIT_TOP_LEVEL_KEYS = [
+  'model',
+  'fallbackModel',
+  'availableModels',
+  'modelOverrides',
+  'enforceAvailableModels',
+  'advisorModel',
+  'apiKeyHelper',
+  'effortLevel'
+];
+
+function isJsonObjectRecord(value: unknown): value is JsonObject {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function mergeMissingStringEnvFields(target: JsonObject, source: JsonObject): boolean {
+  if (!isJsonObjectRecord(source.env)) {
+    return false;
+  }
+  if (Object.hasOwn(target, 'env') && !isJsonObjectRecord(target.env)) {
+    return false;
+  }
+
+  let targetEnv = target.env as JsonObject | undefined;
+  let changed = false;
+  for (const [key, value] of Object.entries(source.env)) {
+    if (typeof value !== 'string' || value === '') {
+      continue;
+    }
+    if (!targetEnv) {
+      targetEnv = {};
+      target.env = targetEnv;
+    }
+    if (!Object.hasOwn(targetEnv, key)) {
+      targetEnv[key] = value;
+      changed = true;
+    }
+  }
+  return changed;
+}
+
+function mergeMissingTopLevelSettings(target: JsonObject, source: JsonObject): boolean {
+  let changed = false;
+  for (const key of CLAUDE_SETTINGS_INHERIT_TOP_LEVEL_KEYS) {
+    if (!Object.hasOwn(source, key) || Object.hasOwn(target, key)) {
+      continue;
+    }
+    const value = source[key];
+    if (value === null || value === undefined || value === '') {
+      continue;
+    }
+    target[key] = value;
+    changed = true;
+  }
+  return changed;
+}
+
 export function ensureClaudeOnboarding(toolDir: string, hostHomeDir?: string): void {
   const claudeJsonPath = path.join(toolDir, '.claude.json');
   let data: JsonObject & {
@@ -810,7 +867,7 @@ export function ensureClaudeOnboarding(toolDir: string, hostHomeDir?: string): v
 
 export function ensureClaudeSettings(toolDir: string, hostHomeDir?: string): void {
   const settingsPath = path.join(toolDir, 'settings.json');
-  let data: JsonObject & { skipDangerousModePermissionPrompt?: boolean; effortLevel?: string } = {};
+  let data: JsonObject & { skipDangerousModePermissionPrompt?: boolean } = {};
   if (fs.existsSync(settingsPath)) {
     try {
       data = JSON.parse(fs.readFileSync(settingsPath, 'utf8')) as typeof data;
@@ -825,14 +882,9 @@ export function ensureClaudeSettings(toolDir: string, hostHomeDir?: string): voi
   }
   if (hostHomeDir) {
     const hostSettings = readHostJsonSafe(path.join(hostHomeDir, '.claude', 'settings.json'));
-    if (
-      hostSettings
-      && typeof hostSettings.effortLevel === 'string'
-      && hostSettings.effortLevel !== ''
-      && !Object.hasOwn(data, 'effortLevel')
-    ) {
-      data.effortLevel = hostSettings.effortLevel;
-      changed = true;
+    if (hostSettings) {
+      changed = mergeMissingStringEnvFields(data, hostSettings) || changed;
+      changed = mergeMissingTopLevelSettings(data, hostSettings) || changed;
     }
   }
   if (changed) {