@fitlab-ai/agent-infra 0.8.5 → 0.9.1

package/dist/lib/task/issue-form.js

@@ -28,6 +28,23 @@ function mapFieldValue(id, fields) {
         return fields.requirements;
     return '';
 }
+function parseFormFields(formText) {
+    const doc = parse(formText);
+    if (!doc || typeof doc !== 'object' || !Array.isArray(doc.body)) {
+        throw new Error('Issue Form has no body[] list');
+    }
+    return doc.body;
+}
+function requirementFieldLabels(formText) {
+    return parseFormFields(formText).flatMap((raw) => {
+        if (!raw || typeof raw !== 'object')
+            return [];
+        const type = typeof raw.type === 'string' ? raw.type : '';
+        const id = typeof raw.id === 'string' ? raw.id : '';
+        const label = typeof raw.attributes?.label === 'string' ? raw.attributes.label.trim() : '';
+        return TEXT_FIELD_TYPES.has(type) && REQUIREMENTS_IDS.has(id) && label ? [label] : [];
+    });
+}
 /**
  * Render the final Issue body for a GitHub Issue Form (scenario A).
  *
@@ -41,12 +58,8 @@ function mapFieldValue(id, fields) {
  * caller can fall back to the default body.
  */
 function renderTemplateBody(formText, fields) {
-    const doc = parse(formText);
-    if (!doc || typeof doc !== 'object' || !Array.isArray(doc.body)) {
-        throw new Error('Issue Form has no body[] list');
-    }
     const sections = [];
-    for (const raw of doc.body) {
+    for (const raw of parseFormFields(formText)) {
         if (!raw || typeof raw !== 'object')
             continue;
         const type = typeof raw.type === 'string' ? raw.type : '';
@@ -60,7 +73,9 @@ function renderTemplateBody(formText, fields) {
         const value = mapped.trim() === '' ? PLACEHOLDER : mapped;
         sections.push(`### ${label}\n\n${value}`);
     }
+    const taskInput = fields.taskInput.trim() === '' ? PLACEHOLDER : fields.taskInput;
+    sections.push(`### ${fields.taskInputHeading}\n\n${taskInput}`);
     return `${sections.join('\n\n')}\n`;
 }
-export { renderTemplateBody, mapFieldValue, PLACEHOLDER };
+export { requirementFieldLabels, renderTemplateBody, mapFieldValue, PLACEHOLDER };
 //# sourceMappingURL=issue-form.js.map

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

@@ -0,0 +1,185 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { LEDGER_COLUMNS, LEDGER_HEADINGS, nextHdId, parseLedger, validateLedgerRows } from './ledger.js';
+import { resolveTaskRef } from './resolve-ref.js';
+import { writeTask } from './write.js';
+const PREFIX = { analysis: 'AN', plan: 'PL', code: 'CD' };
+const RESPONSE = new Set(['accepted', 'adjusted', 'refuted', 'cannot-judge']);
+const DISPOSITION = new Set(['confirmed', 'closed', 'open', 'needs-human-decision']);
+const REVIEW_ARTIFACT = {
+    analysis: /^review-analysis(?:-r(?:[2-9]|[1-9]\d+))?\.md$/,
+    plan: /^review-plan(?:-r(?:[2-9]|[1-9]\d+))?\.md$/,
+    code: /^review-code(?:-r(?:[2-9]|[1-9]\d+))?\.md$/
+};
+const ARTIFACT = {
+    analysis: /^analysis(?:-r(?:[2-9]|[1-9]\d+))?\.md$/,
+    plan: /^plan(?:-r(?:[2-9]|[1-9]\d+))?\.md$/,
+    code: /^code(?:-r(?:[2-9]|[1-9]\d+))?\.md$/
+};
+function failed(intent, code, message, taskId = null, entityId = null) {
+    return { status: 'failed', changed: false, intent: intent.kind, taskId, entityId, before: null, after: null, operations: [], error: { code, message } };
+}
+function normalizedEvidence(value) {
+    return value.trim();
+}
+function ledgerReadErrorCode(error) {
+    const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+    return code === 'TABLE_DUPLICATE_KEY' ? 'LEDGER_DUPLICATE_ID' : 'LEDGER_DOCUMENT_INVALID';
+}
+function maxHandshakeRounds(repoRoot) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
+        const value = parsed.review?.maxHandshakeRounds;
+        return Number.isInteger(value) && Number(value) > 0 ? Number(value) : 3;
+    }
+    catch {
+        return 3;
+    }
+}
+function nextFindingId(rows, stage) {
+    const prefix = PREFIX[stage];
+    let max = 0;
+    for (const row of rows) {
+        const match = new RegExp(`^${prefix}-(\\d+)$`).exec(row.id);
+        if (match)
+            max = Math.max(max, Number(match[1]));
+    }
+    return `${prefix}-${max + 1}`;
+}
+function reviewArtifactRound(reviewArtifact) {
+    const match = /-r([1-9]\d*)\.md$/.exec(reviewArtifact);
+    return match ? Number(match[1]) : 1;
+}
+function rowMutation(row) {
+    return {
+        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: row.status, evidence: row.evidence }
+    };
+}
+function ledgerSectionMutation(content) {
+    if (/^##\s+(审查分歧账本|Review Disagreement Ledger)\s*$/m.test(content))
+        return [];
+    const english = /^##\s+Activity Log\s*$/m.test(content);
+    return [{
+            kind: 'section', aliases: LEDGER_HEADINGS, heading: english ? 'Review Disagreement Ledger' : '审查分歧账本',
+            body: `| ${LEDGER_COLUMNS.join(' | ')} |\n|----|-------|-------|----------|--------|----------|`
+        }];
+}
+function mapWrite(intent, entityId, before, after, result) {
+    if (result.status === 'failed')
+        return failed(intent, result.error.code, result.error.message, result.taskId, entityId);
+    return { status: result.status, changed: result.changed, intent: intent.kind, taskId: result.taskId, entityId, before, after, operations: result.operations, error: null };
+}
+function applyLedgerIntent(intent, options = {}) {
+    const resolved = resolveTaskRef(intent.taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(intent, resolved.code, resolved.message, resolved.taskId);
+    if (resolved.state !== 'active')
+        return failed(intent, '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(intent, ledgerReadErrorCode(error), error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
+    const invalidRows = validateLedgerRows(rows);
+    if (invalidRows)
+        return failed(intent, invalidRows.code, invalidRows.message, resolved.taskId);
+    if (intent.kind === 'decision-next-id') {
+        return { status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: nextHdId(rows), before: null, after: null, operations: [], error: null };
+    }
+    let before = null;
+    let after;
+    if (intent.kind === 'finding-upsert') {
+        if (!REVIEW_ARTIFACT[intent.stage]?.test(intent.reviewArtifact) || !Number.isInteger(intent.ordinal) || intent.ordinal < 1 || !['blocker', 'major', 'minor'].includes(intent.severity)) {
+            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'finding identity, stage, ordinal, or severity is invalid', resolved.taskId);
+        }
+        const evidence = normalizedEvidence(intent.evidence);
+        if (!evidence.startsWith(`${intent.reviewArtifact}#`) || /[\r\n]/.test(evidence)) {
+            return failed(intent, 'LEDGER_EVIDENCE_INVALID', 'finding evidence must be a single-line anchor in the review artifact', resolved.taskId);
+        }
+        const artifactRows = rows.filter((row) => row.stage === intent.stage && row.id.startsWith(`${PREFIX[intent.stage]}-`) && row.evidence.startsWith(`${intent.reviewArtifact}#`));
+        if (artifactRows.length < intent.ordinal - 1)
+            return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'finding ordinals must be submitted in order', resolved.taskId);
+        before = artifactRows[intent.ordinal - 1] ?? null;
+        if (before) {
+            if (before.severity !== intent.severity || before.evidence !== evidence || before.status !== 'open') {
+                return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'finding identity conflicts with the existing open row', resolved.taskId, before.id);
+            }
+            after = { ...before };
+        }
+        else {
+            const id = nextFindingId(rows, intent.stage);
+            after = {
+                id, stage: intent.stage, round: String(reviewArtifactRound(intent.reviewArtifact)),
+                severity: intent.severity, status: 'open', evidence, sourceLine: -1
+            };
+        }
+    }
+    else if (intent.kind === 'decision-upsert') {
+        if (!/^HD-[1-9]\d*$/.test(intent.id) || !ARTIFACT[intent.stage]?.test(intent.artifact)) {
+            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'decision id, stage, or artifact is invalid', resolved.taskId, intent.id);
+        }
+        const evidence = `${intent.artifact}#${intent.id}`;
+        before = rows.find((row) => row.id === intent.id) ?? null;
+        if (before) {
+            if (before.stage !== intent.stage || before.round !== '-' || before.severity !== 'decision' || before.status !== 'needs-human-decision' || before.evidence !== evidence) {
+                return failed(intent, 'LEDGER_IDENTITY_CONFLICT', `decision id '${intent.id}' conflicts with an existing row`, resolved.taskId, intent.id);
+            }
+            after = { ...before };
+        }
+        else {
+            if (intent.id !== nextHdId(rows))
+                return failed(intent, 'LEDGER_ID_CONFLICT', `next decision id is ${nextHdId(rows)}`, resolved.taskId, intent.id);
+            after = { id: intent.id, stage: intent.stage, round: '-', severity: 'decision', status: 'needs-human-decision', evidence, sourceLine: -1 };
+        }
+    }
+    else {
+        before = rows.find((row) => row.id === intent.id) ?? null;
+        if (!before || !/^(AN|PL|CD)-[1-9]\d*$/.test(before.id))
+            return failed(intent, 'LEDGER_NOT_FOUND', `finding '${intent.id}' was not found`, resolved.taskId, intent.id);
+        const evidence = normalizedEvidence(intent.evidence);
+        if (!evidence || /[\r\n]/.test(evidence))
+            return failed(intent, 'LEDGER_EVIDENCE_INVALID', 'evidence must be a non-empty single line', resolved.taskId, intent.id);
+        if (intent.kind === 'finding-respond') {
+            if (!RESPONSE.has(intent.status) || !Number.isInteger(intent.round) || intent.round < 1)
+                return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'response status or round is invalid', resolved.taskId, intent.id);
+            if (before.status === intent.status && before.round === String(intent.round) && before.evidence === evidence)
+                after = { ...before };
+            else if (before.status !== 'open' || Number(before.round) + 1 !== intent.round)
+                return failed(intent, 'LEDGER_TRANSITION_INVALID', `finding '${intent.id}' cannot accept this response`, resolved.taskId, intent.id);
+            else
+                after = { ...before, round: String(intent.round), status: intent.status, evidence };
+        }
+        else {
+            if (!DISPOSITION.has(intent.status))
+                return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'review disposition is invalid', resolved.taskId, intent.id);
+            if (before.status === intent.status && before.evidence === evidence)
+                after = { ...before };
+            else {
+                const allowed = before.status === 'accepted'
+                    ? new Set(['closed', 'open', 'needs-human-decision'])
+                    : before.status === 'adjusted' || before.status === 'refuted'
+                        ? new Set(['confirmed', 'open', 'needs-human-decision'])
+                        : before.status === 'cannot-judge' ? new Set(['open', 'needs-human-decision']) : new Set();
+                const sameRoundMinorClose = before.status === 'open' && before.severity === 'minor' && intent.status === 'closed';
+                if ((!sameRoundMinorClose && !allowed.has(intent.status)) || (intent.status === 'open' && Number(before.round) >= maxHandshakeRounds(resolved.repoRoot))) {
+                    return failed(intent, 'LEDGER_TRANSITION_INVALID', `finding '${intent.id}' cannot transition from ${before.status} to ${intent.status}`, resolved.taskId, intent.id);
+                }
+                after = { ...before, status: intent.status, evidence };
+            }
+        }
+    }
+    const result = writeTask({
+        taskRef: intent.taskRef, expectedState: 'active',
+        mutations: [...ledgerSectionMutation(content), rowMutation(after)],
+        dryRun: 'dryRun' in intent ? intent.dryRun : false
+    }, { ...options, taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state } });
+    return mapWrite(intent, after.id, before, after, result);
+}
+export { applyLedgerIntent };
+//# sourceMappingURL=ledger-intents.js.map

package/dist/lib/task/ledger.js

@@ -1,50 +1,80 @@
 // Shared parser for the task.md `## 审查分歧账本` (Review Disagreement Ledger).
 // Single source of truth for ledger row parsing across `ai task` commands
 // (log, decisions) — see the plan's D1 constraint "no third parser". The gate
-// parser in `.agents/scripts/validate-artifact.js` is a separate concern and
-// must be kept semantically in sync by hand (noted in review-handshake.md).
+// verification parsing consumes this module directly, so commands and gates
+// share the same table parser.
 // The ledger H2 heading is language-dependent (zh template / en template).
-const LEDGER_HEADING_RE = /^##\s+(审查分歧账本|Review Disagreement Ledger)\s*$/;
-const NEXT_H2_RE = /^##\s/;
+import { parseTable } from './sections.js';
+const LEDGER_HEADINGS = ['审查分歧账本', 'Review Disagreement Ledger'];
+const LEDGER_COLUMNS = ['id', 'stage', 'round', 'severity', 'status', 'evidence'];
 // Terminal statuses the completion gates treat as resolved.
 const LEDGER_TERMINAL = new Set(['confirmed', 'closed', 'human-decided']);
-// Statuses that represent an executor-raised human-decision row (pending or done).
+// Statuses that represent a decision row awaiting or carrying a human ruling.
 const HUMAN_DECISION_STATUSES = new Set(['needs-human-decision', 'human-decided']);
+const FINDING_STATUSES = new Set(['open', 'accepted', 'adjusted', 'refuted', 'cannot-judge', 'confirmed', 'needs-human-decision', 'closed', 'human-decided']);
+function isReviewStage(stage) {
+    return stage === 'analysis' || stage === 'plan' || stage === 'code';
+}
 // Parse all rows of the disagreement ledger table. Skips the heading, the
 // header row (`| id | ... |`) and the `|---|` separator; ignores non-`|` lines.
 // Rows with fewer than 6 columns are skipped (mirrors the JS gate parser).
 function parseLedger(content) {
-    const lines = content.split('\n');
-    let i = 0;
-    while (i < lines.length && !LEDGER_HEADING_RE.test(lines[i]))
-        i += 1;
-    if (i >= lines.length)
-        return [];
-    const rows = [];
-    for (let j = i + 1; j < lines.length; j += 1) {
-        if (NEXT_H2_RE.test(lines[j]))
-            break;
-        const line = lines[j].trim();
-        if (!line.startsWith('|'))
-            continue;
-        const cells = line
-            .split('|')
-            .slice(1, -1)
-            .map((cell) => cell.trim());
-        if (cells.length < 6)
-            continue;
-        if (cells[0] === 'id' || /^-+$/.test(cells[0] ?? ''))
+    const table = parseTable(content, { sectionAliases: LEDGER_HEADINGS, columns: LEDGER_COLUMNS });
+    return table?.rows.map(({ values, sourceLine }) => ({
+        id: values.id, stage: values.stage, round: values.round, severity: values.severity,
+        status: values.status, evidence: values.evidence, sourceLine
+    })) ?? [];
+}
+function validateLedgerRows(rows) {
+    const seen = new Set();
+    for (const row of rows) {
+        if (seen.has(row.id))
+            return { code: 'LEDGER_DUPLICATE_ID', message: `duplicate ledger id '${row.id}'` };
+        seen.add(row.id);
+        if (/^PRC-[1-9]\d*$/.test(row.id))
             continue;
-        rows.push({
-            id: cells[0],
-            stage: cells[1],
-            round: cells[2],
-            severity: cells[3],
-            status: cells[4],
-            evidence: cells[5]
-        });
+        if (!/^(AN|PL|CD|HD)-[1-9]\d*$/.test(row.id))
+            return { code: 'LEDGER_ID_INVALID', message: `ledger id '${row.id}' is invalid` };
+        if (!['analysis', 'plan', 'code', 'post-review-commit'].includes(row.stage))
+            return { code: 'LEDGER_STAGE_INVALID', message: `ledger stage '${row.stage}' is invalid` };
+        if (!FINDING_STATUSES.has(row.status))
+            return { code: 'LEDGER_STATUS_INVALID', message: `ledger status '${row.status}' is invalid` };
+        if (row.id.startsWith('AN-') && row.stage !== 'analysis' || row.id.startsWith('PL-') && row.stage !== 'plan' || row.id.startsWith('CD-') && row.stage !== 'code') {
+            return { code: 'LEDGER_STAGE_INVALID', message: `ledger id '${row.id}' conflicts with stage '${row.stage}'` };
+        }
+        if (row.id.startsWith('HD-')) {
+            if (row.round !== '-' || row.severity !== 'decision' || !HUMAN_DECISION_STATUSES.has(row.status))
+                return { code: 'LEDGER_DOCUMENT_INVALID', message: `decision row '${row.id}' is invalid` };
+        }
+        else if (!/^[1-9]\d*$/.test(row.round) || !['blocker', 'major', 'minor'].includes(row.severity)) {
+            return { code: 'LEDGER_DOCUMENT_INVALID', message: `finding row '${row.id}' is invalid` };
+        }
+    }
+    return null;
+}
+function summarizeLedgerStage(rows, stage) {
+    const scoped = rows.filter((row) => row.stage === stage);
+    const unresolved = scoped.filter((row) => !LEDGER_TERMINAL.has(row.status));
+    const terminal = scoped.filter((row) => LEDGER_TERMINAL.has(row.status));
+    const findingCounts = { blocker: 0, major: 0, minor: 0 };
+    const unresolvedFindingCounts = { blocker: 0, major: 0, minor: 0 };
+    for (const row of scoped) {
+        if (row.severity === 'blocker' || row.severity === 'major' || row.severity === 'minor')
+            findingCounts[row.severity] += 1;
+    }
+    for (const row of unresolved) {
+        if (row.severity === 'blocker' || row.severity === 'major' || row.severity === 'minor')
+            unresolvedFindingCounts[row.severity] += 1;
     }
-    return rows;
+    return {
+        stage,
+        canAdvance: unresolved.length === 0,
+        findingCounts,
+        unresolvedFindingCounts,
+        pendingHumanDecisions: unresolved.filter((row) => row.status === 'needs-human-decision').length,
+        unresolved,
+        terminal
+    };
 }
 // Allocate the next globally-unique human-decision id. Scans every `HD-<n>`
 // already present in the ledger (across all stages) and returns `HD-{max+1}`,
@@ -62,5 +92,5 @@ function nextHdId(rows) {
     }
     return `HD-${max + 1}`;
 }
-export { parseLedger, nextHdId, LEDGER_TERMINAL, HUMAN_DECISION_STATUSES };
+export { LEDGER_HEADINGS, LEDGER_COLUMNS, parseLedger, nextHdId, isReviewStage, validateLedgerRows, summarizeLedgerStage, LEDGER_TERMINAL, HUMAN_DECISION_STATUSES };
 //# sourceMappingURL=ledger.js.map