@fitlab-ai/agent-infra 0.8.5 → 0.9.1

package/dist/lib/task/commands/log.js

@@ -1,13 +1,16 @@
 import fs from 'node:fs';
 import { formatTable } from '../../table.js';
-import { resolveTaskRef } from '../resolve-ref.js';
-import { parseLedger } from '../ledger.js';
-const USAGE = `Usage: ai task log <N | #N | TASK-id>
+import { parseTaskScope } from '../command-options.js';
+import { resolveTaskContext } from '../resolve-ref.js';
+import { isReviewStage, parseLedger } from '../ledger.js';
+import { parseActivityLog, pairEntries } from '../activity-log.js';
+const USAGE = `Usage: ai task log [<N | TASK-id> | --task <ref> | -t <ref>]
 
 Renders a task's activity log as a per-step status table. A step's start and
 completion are paired onto one row: STARTED holds the start time, DONE the
 completion time (or '(in progress)' while still running).
-  <ref>   Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+  Omit <ref>   Resolve the unique active task for the current branch.
+  <ref>   Bare numeric short id, or a full TASK-YYYYMMDD-HHMMSS id.
 
 Columns: # (row) / STEP / AGENT / STARTED / DONE / NOTE
   A human-executed step shows AGENT as 'human' and, when it has no start marker,
@@ -17,17 +20,16 @@ Columns: # (row) / STEP / AGENT / STARTED / DONE / NOTE
 `;
 const TABLE_HEADERS = ['#', 'STEP', 'AGENT', 'STARTED', 'DONE', 'NOTE'];
 // 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 (.+?) — (.*)$/;
+// One rendered row = one step instance. `started`/`done` are timestamps; an empty
+// `done` with a non-empty `started` means the step is still in flight, while an
+// empty `started` is a historical done-only entry (no start marker was written).
 // A start marker reuses the normal entry grammar and only suffixes its action
 // with ` [started]`; the matching done entry carries the identical base action
 // without the suffix. Pairing therefore keys on the base action (including any
 // `(Round N)`), so every round and every repeated execution pairs on its own.
-const STARTED_SUFFIX_RE = /\s*\[started\]\s*$/;
 // Short agent tokens that actually appear in activity logs for AI executors
 // (workflow recommended_agents claude/codex/gemini/cursor + enabled TUI opencode;
 // note these differ from the `.airc.json` long names claude-code/gemini-cli).
@@ -38,65 +40,11 @@ const REVIEW_STAGE_PREFIXES = [
     { prefix: 'Review Plan', stage: 'plan' },
     { prefix: 'Review Code', stage: 'code' }
 ];
-function parseActivityLog(content) {
-    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 = [];
-    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) };
-}
 // Collapse a chronological entry list into per-step rows: a `[started]` marker
 // opens a row, the next matching done entry fills it in place (FIFO per base
 // action). Started-only rows stay in flight; done-only entries (legacy logs with
 // no start marker) render as standalone rows. Result order = first-seen order,
 // which is already ascending because `entries` is sorted ascending.
-function pairEntries(entries) {
-    const rows = [];
-    const open = new Map();
-    for (const e of entries) {
-        const isStarted = STARTED_SUFFIX_RE.test(e.step);
-        const base = e.step.replace(STARTED_SUFFIX_RE, '');
-        if (isStarted) {
-            const row = { step: base, agent: e.agent, started: e.time, done: '', note: e.note };
-            rows.push(row);
-            const queue = open.get(base);
-            if (queue)
-                queue.push(row);
-            else
-                open.set(base, [row]);
-        }
-        else {
-            const pending = open.get(base)?.shift();
-            if (pending) {
-                // Done fills the open row; the done entry carries the meaningful note.
-                pending.done = e.time;
-                pending.agent = e.agent;
-                pending.note = e.note;
-            }
-            else {
-                rows.push({ step: base, agent: e.agent, started: '', done: e.time, note: e.note });
-            }
-        }
-    }
-    return rows;
-}
 function countHumanDecisionsByStage(rows) {
     const counts = new Map();
     for (const row of rows) {
@@ -106,9 +54,6 @@ function countHumanDecisionsByStage(rows) {
     }
     return counts;
 }
-function isReviewStage(stage) {
-    return stage === 'analysis' || stage === 'plan' || stage === 'code';
-}
 function reviewStageForStep(step) {
     return REVIEW_STAGE_PREFIXES.find(({ prefix }) => step.startsWith(prefix))?.stage;
 }
@@ -160,13 +105,25 @@ function foldHumanCounts(note, decisions, manualValidation) {
     return `${[...fields, group].join(', ')}${suffix}`;
 }
 function log(args = []) {
-    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
-        if (args.length === 0)
-            process.exitCode = 1;
         return;
     }
-    const resolved = resolveTaskRef(args[0]);
+    let scope;
+    try {
+        scope = parseTaskScope(args);
+    }
+    catch (error) {
+        process.stderr.write(`ai task log: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    if (scope.positionals.length > 1 || (scope.explicit && scope.positionals.length > 0)) {
+        process.stderr.write('ai task log: task ref must be provided once\n');
+        process.exitCode = 1;
+        return;
+    }
+    const resolved = resolveTaskContext(scope.taskRef ?? scope.positionals[0]);
     if (!resolved.ok) {
         process.stderr.write(`ai task log: ${resolved.message}\n`);
         process.exitCode = 1;
@@ -201,5 +158,5 @@ function log(args = []) {
     }
     process.stdout.write(`Total: ${steps.length} steps\n`);
 }
-export { log, parseActivityLog, pairEntries, isHumanAgent };
+export { log, isHumanAgent };
 //# sourceMappingURL=log.js.map

package/dist/lib/task/commands/show.js

@@ -1,20 +1,33 @@
 import fs from 'node:fs';
-import { resolveTaskRef } from '../resolve-ref.js';
-const USAGE = `Usage: ai task show <N | #N | TASK-id>
+import { parseTaskScope } from '../command-options.js';
+import { resolveTaskContext } from '../resolve-ref.js';
+const USAGE = `Usage: ai task show [<N | TASK-id> | --task <ref> | -t <ref>]
 
 Prints the task.md content for the matching task.
+  Omit the ref       Resolve the unique active task for the current branch.
   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.
 `;
 function show(args = []) {
-    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
-        if (args.length === 0)
-            process.exitCode = 1;
         return;
     }
-    const resolved = resolveTaskRef(args[0]);
+    let scope;
+    try {
+        scope = parseTaskScope(args);
+    }
+    catch (error) {
+        process.stderr.write(`ai task show: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    if (scope.positionals.length > 1 || (scope.explicit && scope.positionals.length > 0)) {
+        process.stderr.write('ai task show: task ref must be provided once\n');
+        process.exitCode = 1;
+        return;
+    }
+    const resolved = resolveTaskContext(scope.taskRef ?? scope.positionals[0]);
     if (!resolved.ok) {
         process.stderr.write(`ai task show: ${resolved.message}\n`);
         process.exitCode = 1;

package/dist/lib/task/commands/status.js

@@ -2,18 +2,20 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { commandForEngine } from '../../sandbox/shell.js';
-import { resolveTaskRef } from '../resolve-ref.js';
+import { parseTaskScope } from '../command-options.js';
+import { resolveTaskContext, resolveTaskRef } from '../resolve-ref.js';
 import { enumerateArtifacts } from '../artifacts.js';
 import { parseTaskFrontmatter, extractTitle } from '../frontmatter.js';
 import { loadShortIdByTaskId } from '../short-id.js';
 import { getOpenWorkflowWarnings, formatWorkflowWarningSummary } from '../workflow-warnings.js';
-import { parseActivityLog, pairEntries } from './log.js';
+import { parseActivityLog, pairEntries } from '../activity-log.js';
 import { statusCard } from '../../server/display.js';
-const USAGE = `Usage: ai task status <N | #N | TASK-id>
+const USAGE = `Usage: ai task status [<N | TASK-id> | --task <ref> | -t <ref>]
 
 Prints an aggregated "health check" view for a task: header, metadata,
 artifacts, workflow/runtime execution state, and git branch state.
-  <ref>   Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+  Omit <ref>   Resolve the unique active task for the current branch.
+  <ref>   Bare numeric short id, or a full TASK-YYYYMMDD-HHMMSS id.
 
 Git rows are best-effort: a failed git call degrades that row to '-' without
 failing the command.
@@ -361,15 +363,23 @@ function statusModelToDisplay(model) {
     ], renderStatus(model).join('\n'));
 }
 function status(args = []) {
-    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
-        if (args.length === 0)
-            process.exitCode = 1;
         return;
     }
     let model;
     try {
-        model = buildStatusModel(args[0]);
+        const scope = parseTaskScope(args);
+        if (scope.positionals.length > 1 || (scope.explicit && scope.positionals.length > 0)) {
+            throw new Error('task ref must be provided once');
+        }
+        const resolved = resolveTaskContext(scope.taskRef ?? scope.positionals[0]);
+        if (!resolved.ok)
+            throw new Error(resolved.message);
+        model = buildFromResolved({
+            taskId: resolved.taskId, taskDir: resolved.taskDir, taskMdPath: resolved.taskMdPath,
+            repoRoot: resolved.repoRoot
+        });
     }
     catch (error) {
         process.stderr.write(`ai task status: ${error instanceof Error ? error.message : String(error)}\n`);

package/dist/lib/task/decision-intents.js

@@ -0,0 +1,154 @@
+import fs from 'node:fs';
+import { appendActivityEntry, locateActivityLog } from './activity-log.js';
+import { isDecisionItem, listDecisionItems, selectDecisionItem } from './decision-items.js';
+import { createImplementationInput, IMPLEMENTATION_INPUT_ALIASES, parseImplementationInputs, renderImplementationInputs } from './implementation-inputs.js';
+import { LEDGER_COLUMNS, LEDGER_HEADINGS, parseLedger } from './ledger.js';
+import { resolveTaskContext } from './resolve-ref.js';
+import { extractSection, extractSubSection, findSectionHeading } from './sections.js';
+import { captureTaskWriteMetadata, writeTask } from './write.js';
+const DECISION_ALIASES = ['人工裁决', 'Human Rulings', 'Human Decisions', 'Human Decision'];
+const ACTIVITY_ALIASES = ['活动日志', 'Activity Log'];
+function failed(code, message, taskId = null, ledgerId = null) {
+    return { status: 'failed', changed: false, taskId, ledgerId, recordId: null, implementationInputId: null, operations: [], error: { code, message } };
+}
+function nextRecordId(content) {
+    let max = 0;
+    for (const match of content.matchAll(/^###\s+HDR-(\d+)\s*$/gm))
+        max = Math.max(max, Number(match[1]));
+    return `HDR-${max + 1}`;
+}
+function classifyMissing(rows, selector) {
+    const matches = rows.filter((row) => row.id.toUpperCase() === selector.toUpperCase());
+    const valid = matches.filter(isDecisionItem);
+    if (valid.some((row) => row.status === 'human-decided'))
+        return `${selector} is already decided`;
+    if (valid.length > 0)
+        return `${selector} is not a pending review decision`;
+    if (matches.length > 0 || !/^(AN|PL|CD|HD)-\d+$/i.test(selector))
+        return `${selector} is an invalid decision item`;
+    return `${selector} not found in review ledger`;
+}
+function prependBlock(body, block) {
+    return body ? `${block}\n\n${body}` : block;
+}
+function existingDecision(content, row, decision, needsImplementation) {
+    const match = /^task\.md#(HDR-[1-9]\d*)$/.exec(row.evidence);
+    if (!match)
+        return { conflict: `decided row '${row.id}' has invalid decision evidence` };
+    const recordId = match[1];
+    const block = extractSubSection(content, recordId);
+    if (!block || !block.includes(`**原账本 ID**：${row.id}`) || !block.includes(`**裁决结果**：${decision}`)) {
+        return { conflict: `decision for '${row.id}' conflicts with ${recordId}` };
+    }
+    if (row.stage !== 'code')
+        return needsImplementation === undefined
+            ? { recordId, implementationInputId: null }
+            : { conflict: '--needs-implementation is only valid for code-stage decisions' };
+    const inputs = parseImplementationInputs(content).rows.filter((input) => input.ledgerId === row.id && input.decisionEvidence === row.evidence);
+    if (inputs.length !== 1 || inputs[0].needsImplementation !== needsImplementation) {
+        return { conflict: `implementation intent for '${row.id}' conflicts with the existing decision` };
+    }
+    return { recordId, implementationInputId: inputs[0].id };
+}
+function applyHumanDecision(request, options = {}) {
+    if (!request.selector || !request.decision.trim())
+        return failed('DECISION_PAYLOAD_INVALID', 'selector and decision are required');
+    const resolved = resolveTaskContext(request.taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    if (resolved.state !== 'active')
+        return failed('TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
+    let content;
+    let rows;
+    try {
+        content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+        rows = parseLedger(content);
+    }
+    catch (error) {
+        return failed('DECISION_DOCUMENT_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
+    const direct = rows.filter((row) => row.id.toUpperCase() === request.selector.toUpperCase());
+    if (!/^-?\d+$/.test(request.selector) && direct.length === 1 && direct[0].status === 'human-decided' && isDecisionItem(direct[0])) {
+        try {
+            const replay = existingDecision(content, direct[0], request.decision.trim(), request.needsImplementation);
+            if ('conflict' in replay)
+                return failed('DECISION_CONFLICT', replay.conflict, resolved.taskId, direct[0].id);
+            return { status: 'no-op', changed: false, taskId: resolved.taskId, ledgerId: direct[0].id, recordId: replay.recordId, implementationInputId: replay.implementationInputId, operations: [], error: null };
+        }
+        catch (error) {
+            return failed('DECISION_DOCUMENT_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId, direct[0].id);
+        }
+    }
+    const candidates = listDecisionItems(rows);
+    const selected = selectDecisionItem(candidates, request.selector);
+    if (!selected.ok) {
+        const message = selected.code === 'not-found' && !/^-?\d+$/.test(request.selector)
+            ? classifyMissing(rows, request.selector) : selected.message;
+        return failed('DECISION_TARGET_INVALID', message, resolved.taskId);
+    }
+    const row = selected.row;
+    if (row.stage === 'code' && request.needsImplementation === undefined)
+        return failed('DECISION_PAYLOAD_INVALID', 'code-stage decisions require --needs-implementation true|false', resolved.taskId, row.id);
+    if (row.stage !== 'code' && request.needsImplementation !== undefined)
+        return failed('DECISION_PAYLOAD_INVALID', '--needs-implementation is only valid for code-stage decisions', resolved.taskId, row.id);
+    let metadata;
+    try {
+        metadata = (options.metadataProvider ?? captureTaskWriteMetadata)();
+    }
+    catch (error) {
+        return failed('METADATA_CAPTURE_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId, row.id);
+    }
+    const recordId = nextRecordId(content);
+    const evidence = `task.md#${recordId}`;
+    const decision = request.decision.trim();
+    const record = `### ${recordId}\n\n- **原账本 ID**：${row.id}\n- **裁决时间**：${metadata.timestamp}\n- **裁决结果**：${decision}`;
+    const activity = locateActivityLog(content);
+    if (!activity)
+        return failed('DECISION_ACTIVITY_MISSING', 'activity log section is missing or ambiguous', resolved.taskId, row.id);
+    const mutations = [
+        {
+            kind: 'table-row', action: 'upsert', sectionAliases: LEDGER_HEADINGS, columns: LEDGER_COLUMNS,
+            keyColumn: 'id', key: row.id,
+            values: { stage: row.stage, round: row.round, severity: row.severity, status: 'human-decided', evidence }
+        },
+        {
+            kind: 'section', aliases: DECISION_ALIASES,
+            heading: findSectionHeading(content, [...DECISION_ALIASES]),
+            body: prependBlock(extractSection(content, [...DECISION_ALIASES]), record)
+        }
+    ];
+    let implementationInputId = null;
+    if (row.stage === 'code') {
+        let parsed;
+        try {
+            parsed = parseImplementationInputs(content);
+        }
+        catch (error) {
+            return failed('DECISION_DOCUMENT_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId, row.id);
+        }
+        const input = createImplementationInput(parsed.rows, {
+            ledgerId: row.id, decisionEvidence: evidence,
+            needsImplementation: request.needsImplementation, decidedAt: metadata.timestamp
+        });
+        implementationInputId = input.id;
+        mutations.push({
+            kind: 'section', aliases: IMPLEMENTATION_INPUT_ALIASES,
+            heading: findSectionHeading(content, [...IMPLEMENTATION_INPUT_ALIASES]),
+            body: renderImplementationInputs([...parsed.rows, input])
+        });
+    }
+    mutations.push({
+        kind: 'section', aliases: ACTIVITY_ALIASES, heading: activity.heading,
+        body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Human Decision', agent: 'human', note: `${row.id} decided → ${recordId}` })
+    });
+    const writeResult = writeTask({ taskRef: resolved.taskId, expectedState: 'active', mutations, dryRun: request.dryRun }, {
+        ...options,
+        taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state },
+        metadataProvider: () => metadata
+    });
+    if (writeResult.status === 'failed')
+        return failed(writeResult.error.code, writeResult.error.message, writeResult.taskId, row.id);
+    return { status: writeResult.status, changed: writeResult.changed, taskId: writeResult.taskId, ledgerId: row.id, recordId, implementationInputId, operations: writeResult.operations, error: null };
+}
+export { applyHumanDecision };
+//# sourceMappingURL=decision-intents.js.map

package/dist/lib/task/decision-items.js

@@ -0,0 +1,53 @@
+import { isReviewStage } from './ledger.js';
+function isDecisionItem(row) {
+    if (!isReviewStage(row.stage))
+        return false;
+    if (/^HD-\d+$/i.test(row.id))
+        return true;
+    if (row.stage === 'analysis')
+        return /^AN-\d+$/i.test(row.id);
+    if (row.stage === 'plan')
+        return /^PL-\d+$/i.test(row.id);
+    return /^CD-\d+$/i.test(row.id);
+}
+function listDecisionItems(rows, options = {}) {
+    return rows.filter((row) => {
+        if (!isDecisionItem(row))
+            return false;
+        if (options.stage !== undefined && row.stage !== options.stage)
+            return false;
+        return options.includeDecided
+            ? row.status === 'needs-human-decision' || row.status === 'human-decided'
+            : row.status === 'needs-human-decision';
+    });
+}
+function selectDecisionItem(rows, selector) {
+    if (/^-?\d+$/.test(selector)) {
+        const ordinal = Number.parseInt(selector, 10);
+        if (ordinal < 1 || ordinal > rows.length) {
+            return {
+                ok: false,
+                code: 'ordinal-out-of-range',
+                message: `ordinal '${selector}' out of range (1..${rows.length})`
+            };
+        }
+        return { ok: true, row: rows[ordinal - 1] };
+    }
+    if (!/^[A-Za-z]+-\d+$/.test(selector)) {
+        return { ok: false, code: 'invalid-selector', message: `invalid selector '${selector}'` };
+    }
+    const matches = rows.filter((row) => row.id.toUpperCase() === selector.toUpperCase());
+    if (matches.length === 0) {
+        return { ok: false, code: 'not-found', message: `no decision item matches '${selector}'` };
+    }
+    if (matches.length > 1) {
+        return {
+            ok: false,
+            code: 'ambiguous',
+            message: `duplicate id '${selector}' in ledger; select by ordinal instead`
+        };
+    }
+    return { ok: true, row: matches[0] };
+}
+export { isDecisionItem, listDecisionItems, selectDecisionItem };
+//# sourceMappingURL=decision-items.js.map