@fitlab-ai/agent-infra 0.8.5 → 0.9.0

package/lib/task/verification-review.ts

@@ -0,0 +1,9 @@
+export {
+  extractReviewBaseline,
+  extractReviewDiffFingerprint,
+  extractReviewedSnapshotTree,
+  findAuthoritativeReviewCodeArtifact,
+  parseReviewVerdict,
+  resolvePostReviewGlobs
+} from './review-fingerprint.ts';
+export { parseLedger, summarizeLedgerStage, validateLedgerRows } from './ledger.ts';

package/lib/task/verification-types.ts

@@ -0,0 +1,29 @@
+type VerificationStatus = 'pass' | 'fail' | 'blocked';
+type VerificationCheckResult = {
+  type: string;
+  status: VerificationStatus;
+  message: string;
+  fail_type?: string;
+  warnings?: string[];
+};
+type VerificationContext = {
+  skillName: string;
+  taskDir: string;
+  artifactFile?: string;
+  config: Record<string, unknown>;
+};
+type VerificationEngineRequest = {
+  mode: 'gate' | 'checks';
+  skillName: string;
+  taskDir: string;
+  artifactFile?: string;
+  checks: readonly string[];
+  repositoryRoot?: string;
+};
+
+export type {
+  VerificationCheckResult,
+  VerificationContext,
+  VerificationEngineRequest,
+  VerificationStatus
+};

package/lib/task/verification.ts

@@ -0,0 +1,156 @@
+import path from 'node:path';
+// Verification runs in-process; configuration, review parsing and platform
+// checks are provided by typed domain modules without a stdout protocol.
+import { verifyInProcess } from './verification-engine.ts';
+
+import { parseArtifactName } from './artifact-lifecycle.ts';
+import type { ArtifactFamily } from './artifact-lifecycle.ts';
+import { resolveTaskRef } from './resolve-ref.ts';
+import type { TaskWorkspaceState } from './resolve-ref.ts';
+
+type VerificationEvent =
+  | 'analyze.awaiting-input' | 'analyze.completed'
+  | 'review-analysis.completed' | 'plan.completed' | 'review-plan.completed'
+  | 'code.completed' | 'review-code.completed' | 'manual-validation.completed'
+  | 'block-task.completed' | 'cancel-task.completed' | 'commit.completed'
+  | 'complete-task.preflight' | 'complete-task.completed'
+  | 'create-pr.completed' | 'create-task.completed'
+  | 'import-codescan.completed' | 'import-dependabot.completed'
+  | 'import-issue.completed' | 'watch-pr.completed';
+type VerificationSpec = {
+  skill: string;
+  expectedState: 'active' | 'blocked' | 'completed';
+  mode: 'gate' | 'checks';
+  checks?: readonly string[];
+  artifactFamily?: ArtifactFamily;
+};
+type VerificationInvocation = {
+  status: 'pass' | 'fail' | 'blocked';
+  exitCode: 0 | 1 | 2;
+  payload: Record<string, unknown>;
+};
+type TaskVerificationResult = {
+  status: 'pass' | 'fail' | 'blocked' | 'failed';
+  changed: false;
+  event: VerificationEvent | string;
+  requestRef: string;
+  taskId: string | null;
+  taskDir: string | null;
+  taskState: TaskWorkspaceState | null;
+  skill: string | null;
+  mode: 'gate' | 'checks' | null;
+  artifact: string | null;
+  invocations: readonly VerificationInvocation[];
+  error: { code: string; message: string } | null;
+};
+type VerificationOptions = {
+  repoRoot?: string;
+  engine?: typeof verifyInProcess;
+};
+
+const gate = (skill: string, expectedState: VerificationSpec['expectedState'], artifactFamily?: ArtifactFamily): VerificationSpec => ({
+  skill, expectedState, mode: 'gate', ...(artifactFamily ? { artifactFamily } : {})
+});
+const VERIFICATION_CATALOG: Readonly<Record<VerificationEvent, VerificationSpec>> = {
+  'analyze.awaiting-input': { skill: 'analyze-task', expectedState: 'active', mode: 'checks', checks: ['task-meta'] },
+  'analyze.completed': gate('analyze-task', 'active', 'analysis'),
+  'review-analysis.completed': gate('review-analysis', 'active', 'review-analysis'),
+  'plan.completed': gate('plan-task', 'active', 'plan'),
+  'review-plan.completed': gate('review-plan', 'active', 'review-plan'),
+  'code.completed': gate('code-task', 'active', 'code'),
+  'review-code.completed': gate('review-code', 'active', 'review-code'),
+  'manual-validation.completed': gate('complete-manual-validation', 'active', 'manual-validation'),
+  'block-task.completed': gate('block-task', 'blocked'),
+  'cancel-task.completed': gate('cancel-task', 'completed'),
+  'commit.completed': gate('commit', 'active'),
+  'complete-task.preflight': { skill: 'complete-task', expectedState: 'active', mode: 'checks', checks: ['review-ledger', 'post-review-commit', 'required-checks', 'platform-sync-preflight'] },
+  'complete-task.completed': gate('complete-task', 'completed'),
+  'create-pr.completed': gate('create-pr', 'active'),
+  'create-task.completed': gate('create-task', 'active'),
+  'import-codescan.completed': gate('import-codescan', 'active'),
+  'import-dependabot.completed': gate('import-dependabot', 'active'),
+  'import-issue.completed': gate('import-issue', 'active'),
+  'watch-pr.completed': gate('watch-pr', 'active')
+};
+
+function failure(request: { taskRef: string; event: string; artifact?: string }, code: string, message: string, extra: Partial<TaskVerificationResult> = {}): TaskVerificationResult {
+  return {
+    status: 'failed', changed: false, event: request.event, requestRef: request.taskRef,
+    taskId: null, taskDir: null, taskState: null, skill: null, mode: null,
+    artifact: request.artifact ?? null, invocations: [], error: { code, message }, ...extra
+  };
+}
+
+function verifyTaskEvent(request: { taskRef: string; event: string; artifact?: string }, options: VerificationOptions = {}): TaskVerificationResult {
+  const spec = VERIFICATION_CATALOG[request.event as VerificationEvent];
+  if (!spec) return failure(request, 'VERIFY_EVENT_UNKNOWN', `unknown verification event '${request.event}'`);
+  const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+  if (!resolved.ok) return failure(request, resolved.code, resolved.message, { taskId: resolved.taskId, skill: spec.skill, mode: spec.mode });
+  const identity = { taskId: resolved.taskId, taskDir: resolved.taskDir, taskState: resolved.state, skill: spec.skill, mode: spec.mode } as const;
+  if (resolved.state !== spec.expectedState) {
+    return failure(request, 'VERIFY_TASK_STATE_MISMATCH', `event '${request.event}' requires workspace '${spec.expectedState}', received '${resolved.state}'`, identity);
+  }
+  if (spec.artifactFamily) {
+    if (!request.artifact) return failure(request, 'VERIFY_ARTIFACT_REQUIRED', `event '${request.event}' requires an artifact`, identity);
+    const parsed = parseArtifactName(request.artifact);
+    if (path.basename(request.artifact) !== request.artifact || !parsed || parsed.family !== spec.artifactFamily) {
+      return failure(request, 'VERIFY_ARTIFACT_INVALID', `artifact '${request.artifact}' is not a canonical ${spec.artifactFamily} artifact`, identity);
+    }
+  } else if (request.artifact) {
+    return failure(request, 'VERIFY_ARTIFACT_UNEXPECTED', `event '${request.event}' does not accept an artifact`, identity);
+  }
+
+  const invocations: VerificationInvocation[] = [];
+  const engine = options.engine ?? verifyInProcess;
+  if (spec.mode === 'gate') {
+    const payload = engine({ mode: 'gate', skillName: spec.skill, taskDir: resolved.taskDir, artifactFile: request.artifact, checks: [], repositoryRoot: resolved.repoRoot }) as Record<string, unknown>;
+    const status = payload.gate as 'pass' | 'fail' | 'blocked';
+    invocations.push({ status, exitCode: ({ pass: 0, fail: 1, blocked: 2 } as const)[status], payload });
+  } else {
+    for (const check of spec.checks ?? []) {
+      const payload = engine({ mode: 'checks', skillName: spec.skill, taskDir: resolved.taskDir, artifactFile: request.artifact, checks: [check], repositoryRoot: resolved.repoRoot }) as Record<string, unknown>;
+      const status = payload.status as 'pass' | 'fail' | 'blocked';
+      invocations.push({ status, exitCode: ({ pass: 0, fail: 1, blocked: 2 } as const)[status], payload });
+      if (status !== 'pass') break;
+    }
+  }
+  const status = invocations.some((item) => item.status === 'blocked') ? 'blocked'
+    : invocations.some((item) => item.status === 'fail') ? 'fail' : 'pass';
+  return {
+    status, changed: false, event: request.event, requestRef: request.taskRef,
+    ...identity, artifact: request.artifact ?? null, invocations, error: null
+  };
+}
+
+function statusLabel(status: unknown): string {
+  return status === 'fail' ? 'FAIL' : status === 'blocked' ? 'BLOCKED' : 'pass';
+}
+
+function renderPayload(payload: Record<string, unknown>): string {
+  const lines: string[] = [];
+  if (Array.isArray(payload.checks)) {
+    lines.push(`Verification: ${payload.gate} | Skill: ${payload.skill}`, '');
+    for (const check of payload.checks as Array<Record<string, unknown>>) {
+      lines.push(`  [${statusLabel(check.status)}] ${check.type} - ${check.message}`);
+    }
+    lines.push('', `Result: ${payload.summary} - ${payload.action}`);
+  } else {
+    lines.push(`Check: ${payload.status} | Skill: ${payload.skill} | Type: ${payload.type}`, '');
+    lines.push(`  [${statusLabel(payload.status)}] ${payload.type} - ${payload.message}`);
+    const summary = payload.status === 'pass' ? '1 passed, 0 failed'
+      : payload.status === 'blocked' ? '0 passed, 0 failed, 1 blocked' : '0 passed, 1 failed';
+    const action = payload.status === 'pass' ? 'Requested check passed'
+      : payload.status === 'blocked' ? `Resolve blocked ${payload.type} check and re-run check`
+        : `Fix ${payload.type} issues and re-run check`;
+    lines.push('', `Result: ${summary} - ${action}`);
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+function renderTaskVerification(result: TaskVerificationResult): string {
+  if (result.status === 'failed') return `Verification failed: ${result.error?.code ?? 'VERIFY_FAILED'} - ${result.error?.message ?? 'unknown error'}\n`;
+  return result.invocations.map((invocation) => renderPayload(invocation.payload)).join('');
+}
+
+export { VERIFICATION_CATALOG, renderTaskVerification, verifyTaskEvent };
+export type { TaskVerificationResult, VerificationEvent, VerificationInvocation, VerificationOptions, VerificationSpec };

package/lib/task/workflow-warning-intents.ts

@@ -0,0 +1,142 @@
+import fs from 'node:fs';
+
+import { resolveTaskRef } from './resolve-ref.ts';
+import {
+  WORKFLOW_WARNING_COLUMNS,
+  WORKFLOW_WARNING_HEADINGS,
+  WORKFLOW_WARNING_SEVERITIES,
+  WORKFLOW_WARNING_STATUSES,
+  parseWorkflowWarnings
+} from './workflow-warnings.ts';
+import type { WorkflowWarning } from './workflow-warnings.ts';
+import { captureTaskWriteMetadata, writeTask } from './write.ts';
+import type { TaskMutation, TaskOperationSummary, TaskWriteOptions } from './write.ts';
+
+type WarningSeverity = 'IMPORTANT' | 'ACTION_REQUIRED';
+type WarningStatus = 'open' | 'resolved' | 'ignored';
+type WorkflowWarningIntent =
+  | { kind: 'add'; taskRef: string; step: string; severity: WarningSeverity; code: string; target: string; message: string; action: string; dryRun?: boolean }
+  | { kind: 'set-status'; taskRef: string; id: string; status: 'resolved' | 'ignored'; resolution: string; dryRun?: boolean }
+  | { kind: 'list'; taskRef: string; status?: WarningStatus };
+
+type WorkflowWarningIntentResult = {
+  status: 'planned' | 'applied' | 'no-op' | 'failed'; changed: boolean;
+  intent: WorkflowWarningIntent['kind']; taskId: string | null; entityId: string | null;
+  before: WorkflowWarning | null; after: WorkflowWarning | null;
+  warnings: readonly WorkflowWarning[]; operations: readonly TaskOperationSummary[];
+  error: { code: string; message: string } | null;
+};
+
+function failed(intent: WorkflowWarningIntent, code: string, message: string, taskId: string | null = null, entityId: string | null = null): WorkflowWarningIntentResult {
+  return { status: 'failed', changed: false, intent: intent.kind, taskId, entityId, before: null, after: null, warnings: [], operations: [], error: { code, message } };
+}
+
+function oneLine(value: string): string {
+  return value.replace(/\s*\r?\n\s*/g, ' ').trim();
+}
+
+function nextWarningId(rows: readonly WorkflowWarning[]): string {
+  let max = 0;
+  for (const row of rows) {
+    const match = /^WW-(\d+)$/.exec(row.id);
+    if (match) max = Math.max(max, Number(match[1]));
+  }
+  return `WW-${max + 1}`;
+}
+
+function validateRows(rows: readonly WorkflowWarning[]): { code: string; message: string } | null {
+  const ids = new Set<string>();
+  for (const row of rows) {
+    if (!/^WW-[1-9]\d*$/.test(row.id)) return { code: 'WARNING_ID_INVALID', message: `warning id '${row.id}' is invalid` };
+    if (ids.has(row.id)) return { code: 'WARNING_DUPLICATE_ID', message: `duplicate warning id '${row.id}'` };
+    ids.add(row.id);
+    if (!WORKFLOW_WARNING_SEVERITIES.has(row.severity) || !WORKFLOW_WARNING_STATUSES.has(row.status)) return { code: 'WARNING_DOCUMENT_INVALID', message: `warning '${row.id}' has invalid severity or status` };
+  }
+  return null;
+}
+
+function sectionMutation(content: string): TaskMutation[] {
+  if (/^##\s+(工作流告警|Workflow Warnings)\s*$/m.test(content)) return [];
+  const english = /^##\s+Activity Log\s*$/m.test(content);
+  return [{
+    kind: 'section', aliases: WORKFLOW_WARNING_HEADINGS, heading: english ? 'Workflow Warnings' : '工作流告警',
+    body: `| ${WORKFLOW_WARNING_COLUMNS.join(' | ')} |\n|----|------|------|----------|------|--------|--------|---------|--------|-------------|------------|`
+  }];
+}
+
+function rowMutation(row: WorkflowWarning): TaskMutation {
+  return {
+    kind: 'table-row', action: 'upsert', sectionAliases: WORKFLOW_WARNING_HEADINGS,
+    columns: WORKFLOW_WARNING_COLUMNS, keyColumn: 'id', key: row.id,
+    values: {
+      time: row.time, step: row.step, severity: row.severity, code: row.code, status: row.status,
+      target: row.target, message: row.message, action: row.action,
+      resolved_at: row.resolvedAt, resolution: row.resolution
+    }
+  };
+}
+
+function applyWorkflowWarningIntent(intent: WorkflowWarningIntent, options: TaskWriteOptions = {}): WorkflowWarningIntentResult {
+  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: string;
+  let rows: WorkflowWarning[];
+  try {
+    content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    rows = parseWorkflowWarnings(content);
+  } catch (error) {
+    const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : 'WARNING_DOCUMENT_INVALID';
+    return failed(intent, code, error instanceof Error ? error.message : String(error), resolved.taskId);
+  }
+  const invalid = validateRows(rows);
+  if (invalid) return failed(intent, invalid.code, invalid.message, resolved.taskId);
+  if (intent.kind === 'list') {
+    if (intent.status && !WORKFLOW_WARNING_STATUSES.has(intent.status)) return failed(intent, 'WARNING_PAYLOAD_INVALID', 'warning status is invalid', resolved.taskId);
+    const warnings = rows.filter((row) => !intent.status || row.status === intent.status);
+    return { status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: null, before: null, after: null, warnings, operations: [], error: null };
+  }
+
+  let metadata;
+  try { metadata = (options.metadataProvider ?? captureTaskWriteMetadata)(); }
+  catch (error) { return failed(intent, 'METADATA_CAPTURE_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId); }
+  let before: WorkflowWarning | null;
+  let after: WorkflowWarning;
+  if (intent.kind === 'add') {
+    const step = oneLine(intent.step); const code = oneLine(intent.code); const target = oneLine(intent.target);
+    const message = oneLine(intent.message); const action = oneLine(intent.action);
+    if (!step || !code || !target || !message || !action || !WORKFLOW_WARNING_SEVERITIES.has(intent.severity)) {
+      return failed(intent, 'WARNING_PAYLOAD_INVALID', 'warning add payload is invalid', resolved.taskId);
+    }
+    before = rows.find((row) => row.status === 'open' && row.step === step && row.code === code && row.target === target) ?? null;
+    after = before
+      ? { ...before, severity: intent.severity, message, action }
+      : { id: nextWarningId(rows), time: metadata.timestamp, step, severity: intent.severity, code, status: 'open', target, message, action, resolvedAt: '', resolution: '' };
+  } else {
+    if (!/^WW-[1-9]\d*$/.test(intent.id) || !['resolved', 'ignored'].includes(intent.status) || !oneLine(intent.resolution)) {
+      return failed(intent, 'WARNING_PAYLOAD_INVALID', 'warning status payload is invalid', resolved.taskId, intent.id);
+    }
+    before = rows.find((row) => row.id === intent.id) ?? null;
+    if (!before) return failed(intent, 'WARNING_NOT_FOUND', `warning '${intent.id}' was not found`, resolved.taskId, intent.id);
+    const resolution = oneLine(intent.resolution);
+    if (before.status === intent.status && before.resolution === resolution) after = { ...before };
+    else if (before.status !== 'open') return failed(intent, 'WARNING_TRANSITION_INVALID', `warning '${intent.id}' cannot transition from ${before.status}`, resolved.taskId, intent.id);
+    else after = { ...before, status: intent.status, resolvedAt: metadata.timestamp, resolution };
+  }
+
+  const writeResult = writeTask({
+    taskRef: intent.taskRef, expectedState: 'active', mutations: [...sectionMutation(content), rowMutation(after)], dryRun: intent.dryRun
+  }, {
+    ...options,
+    taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state },
+    metadataProvider: () => metadata
+  });
+  if (writeResult.status === 'failed') return failed(intent, writeResult.error.code, writeResult.error.message, writeResult.taskId, after.id);
+  return {
+    status: writeResult.status, changed: writeResult.changed, intent: intent.kind, taskId: writeResult.taskId,
+    entityId: after.id, before, after, warnings: [], operations: writeResult.operations, error: null
+  };
+}
+
+export { applyWorkflowWarningIntent };
+export type { WarningSeverity, WarningStatus, WorkflowWarningIntent, WorkflowWarningIntentResult };

package/lib/task/workflow-warnings.ts

@@ -1,8 +1,9 @@
-import { extractSection } from './sections.ts';
+import { parseTable } from './sections.ts';
 
 const WORKFLOW_WARNING_HEADINGS = ['工作流告警', 'Workflow Warnings'];
 const WORKFLOW_WARNING_STATUSES = new Set(['open', 'resolved', 'ignored']);
 const WORKFLOW_WARNING_SEVERITIES = new Set(['IMPORTANT', 'ACTION_REQUIRED']);
+const WORKFLOW_WARNING_COLUMNS = ['id', 'time', 'step', 'severity', 'code', 'status', 'target', 'message', 'action', 'resolved_at', 'resolution'] as const;
 
 type WorkflowWarning = {
   id: string;
@@ -18,84 +19,14 @@ type WorkflowWarning = {
   resolution: string;
 };
 
-function splitTableRow(line: string): string[] {
-  let value = line.trim();
-  if (!value.startsWith('|')) return [];
-  value = value.replace(/^\|/, '').replace(/\|$/, '');
-
-  const cells: string[] = [];
-  let cell = '';
-  for (let index = 0; index < value.length; index += 1) {
-    const char = value[index]!;
-    if (char === '|' && !isEscapedAt(value, index)) {
-      cells.push(unescapeTableCell(cell.trim()));
-      cell = '';
-      continue;
-    }
-    cell += char;
-  }
-  cells.push(unescapeTableCell(cell.trim()));
-  return cells;
-}
-
-function unescapeTableCell(value: string): string {
-  let output = '';
-  for (let index = 0; index < value.length; index += 1) {
-    const char = value[index]!;
-    const next = value[index + 1];
-    if (char === '\\' && (next === '\\' || next === '|')) {
-      output += next;
-      index += 1;
-      continue;
-    }
-    output += char;
-  }
-  return output;
-}
-
-function isEscapedAt(value: string, index: number): boolean {
-  let backslashes = 0;
-  for (let cursor = index - 1; cursor >= 0 && value[cursor] === '\\'; cursor -= 1) {
-    backslashes += 1;
-  }
-  return backslashes % 2 === 1;
-}
-
-function isSeparatorRow(cells: string[]): boolean {
-  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
-}
-
-/**
- * Parses well-formed workflow warning rows. Malformed rows are intentionally
- * ignored here; validate-artifact is responsible for reporting structure errors.
- */
+/** Parses workflow warning rows and fails closed on malformed table structure. */
 function parseWorkflowWarnings(content: string): WorkflowWarning[] {
-  const section = extractSection(content, WORKFLOW_WARNING_HEADINGS);
-  if (!section) return [];
-
-  const rows: WorkflowWarning[] = [];
-  for (const rawLine of section.split(/\r?\n/)) {
-    const cells = splitTableRow(rawLine);
-    if (cells.length === 0) continue;
-    if ((cells[0] ?? '').toLowerCase() === 'id') continue;
-    if (isSeparatorRow(cells)) continue;
-    if (cells.length < 11) continue;
-
-    rows.push({
-      id: cells[0] ?? '',
-      time: cells[1] ?? '',
-      step: cells[2] ?? '',
-      severity: cells[3] ?? '',
-      code: cells[4] ?? '',
-      status: cells[5] ?? '',
-      target: cells[6] ?? '',
-      message: cells[7] ?? '',
-      action: cells[8] ?? '',
-      resolvedAt: cells[9] ?? '',
-      resolution: cells[10] ?? ''
-    });
-  }
-  return rows;
+  const table = parseTable(content, { sectionAliases: WORKFLOW_WARNING_HEADINGS, columns: WORKFLOW_WARNING_COLUMNS });
+  return table?.rows.map(({ values }) => ({
+    id: values.id!, time: values.time!, step: values.step!, severity: values.severity!,
+    code: values.code!, status: values.status!, target: values.target!, message: values.message!,
+    action: values.action!, resolvedAt: values.resolved_at!, resolution: values.resolution!
+  })) ?? [];
 }
 
 function getOpenWorkflowWarnings(content: string): WorkflowWarning[] {
@@ -114,6 +45,7 @@ export {
   WORKFLOW_WARNING_HEADINGS,
   WORKFLOW_WARNING_STATUSES,
   WORKFLOW_WARNING_SEVERITIES,
+  WORKFLOW_WARNING_COLUMNS,
   parseWorkflowWarnings,
   getOpenWorkflowWarnings,
   formatWorkflowWarningSummary