@fitlab-ai/agent-infra 0.8.5 → 0.9.0

package/dist/lib/task/resolve-ref.js

@@ -1,7 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { execFileSync, spawnSync } from 'node:child_process';
-import { normalizeShortIdInput } from './short-id.js';
+import { execFileSync } from 'node:child_process';
+import { normalizeShortIdInput, resolveShortIdReadOnly } from './short-id.js';
+import { parseTaskFrontmatter } from './frontmatter.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 // Flat-structured workspace dirs that hold tasks under `{dir}/{taskId}/task.md`.
 // Note: `archive` uses a three-level YYYY/MM/DD layout and is handled separately.
@@ -29,20 +30,6 @@ function readShortIdLength(repoRoot) {
     }
     return 2;
 }
-function resolveShortIdToTaskId(arg, repoRoot) {
-    const scriptPath = path.join(repoRoot, '.agents', 'scripts', 'task-short-id.js');
-    if (!fs.existsSync(scriptPath)) {
-        throw new Error(`task-short-id.js not found at ${scriptPath}`);
-    }
-    const result = spawnSync('node', [scriptPath, 'resolve', arg], {
-        encoding: 'utf8',
-        cwd: repoRoot
-    });
-    if (result.status !== 0) {
-        throw new Error((result.stderr || '').trim() || `failed to resolve '${arg}'`);
-    }
-    return result.stdout.trim();
-}
 function listSortedNumeric(dir, width) {
     if (!fs.existsSync(dir))
         return [];
@@ -76,9 +63,10 @@ function findTaskMd(repoRoot, taskId) {
     for (const sub of FLAT_WORKSPACE_DIRS) {
         const candidate = path.join(repoRoot, '.agents', 'workspace', sub, taskId, 'task.md');
         if (fs.existsSync(candidate))
-            return candidate;
+            return { taskMdPath: candidate, state: sub };
     }
-    return findInArchive(repoRoot, taskId);
+    const archived = findInArchive(repoRoot, taskId);
+    return archived ? { taskMdPath: archived, state: 'archive' } : null;
 }
 /**
  * Enumerate every task directory under the flat workspace states
@@ -103,16 +91,35 @@ function enumerateTaskDirs(repoRoot) {
     }
     return out;
 }
+function locateHotTaskDirs(repoRoot, taskId) {
+    return FLAT_WORKSPACE_DIRS.flatMap((state) => {
+        const taskDir = path.join(repoRoot, '.agents', 'workspace', state, taskId);
+        const taskMdPath = path.join(taskDir, 'task.md');
+        return fs.existsSync(taskMdPath) ? [{ taskId, taskDir, taskMdPath, state }] : [];
+    });
+}
 /**
- * Resolve a task ref (bare short id, `#N`, or `TASK-YYYYMMDD-HHMMSS`) to its
+ * Resolve a task ref (bare short id or `TASK-YYYYMMDD-HHMMSS`) to its
  * task directory across active / blocked / completed / archive.
  *
  * The returned `message` on failure is command-agnostic (no `ai task <cmd>:`
  * prefix); callers prepend their own prefix so each command keeps its existing
  * stderr wording byte-for-byte.
  */
-function resolveTaskRef(arg) {
-    const repoRoot = detectRepoRoot();
+function resolveTaskRef(arg, options = {}) {
+    let repoRoot;
+    try {
+        repoRoot = options.repoRoot ? path.resolve(options.repoRoot) : detectRepoRoot();
+    }
+    catch (error) {
+        return {
+            ok: false,
+            code: 'REPO_ROOT_NOT_FOUND',
+            message: error instanceof Error ? error.message : String(error),
+            repoRoot: null,
+            taskId: null
+        };
+    }
     let taskId;
     if (TASK_ID_RE.test(arg)) {
         taskId = arg;
@@ -121,30 +128,143 @@ function resolveTaskRef(arg) {
         const shortIdLength = readShortIdLength(repoRoot);
         const normalized = normalizeShortIdInput(arg, { shortIdLength });
         if (normalized.kind === 'error') {
-            return { ok: false, message: normalized.message };
+            return {
+                ok: false,
+                code: normalized.code,
+                message: normalized.message,
+                repoRoot,
+                taskId: null
+            };
         }
         if (normalized.kind === 'pass') {
             return {
                 ok: false,
+                code: 'INVALID_TASK_REF',
                 message: `'${arg}' is not a valid short id or TASK-id; ` +
-                    `expected bare digits, '#N', or 'TASK-YYYYMMDD-HHMMSS'`
+                    `expected bare digits or 'TASK-YYYYMMDD-HHMMSS'`,
+                repoRoot,
+                taskId: null
             };
         }
-        try {
-            taskId = resolveShortIdToTaskId(normalized.value, repoRoot);
+        const shortResult = resolveShortIdReadOnly(normalized.value, repoRoot, { shortIdLength });
+        if (!shortResult.ok) {
+            return {
+                ok: false,
+                code: shortResult.code,
+                message: shortResult.message,
+                repoRoot,
+                taskId: shortResult.taskId
+            };
         }
-        catch (e) {
-            return { ok: false, message: e.message };
+        taskId = shortResult.taskId;
+    }
+    const located = findTaskMd(repoRoot, taskId);
+    if (!located) {
+        return {
+            ok: false,
+            code: 'TASK_NOT_FOUND',
+            message: `task ${taskId} not found in active / blocked / completed / archive`,
+            repoRoot,
+            taskId
+        };
+    }
+    return {
+        ok: true,
+        repoRoot,
+        taskId,
+        taskDir: path.dirname(located.taskMdPath),
+        taskMdPath: located.taskMdPath,
+        state: located.state
+    };
+}
+function resolveTaskContext(taskRef, options = {}) {
+    if (taskRef !== undefined)
+        return resolveTaskRef(taskRef, options);
+    let repoRoot;
+    try {
+        repoRoot = options.repoRoot ? path.resolve(options.repoRoot) : detectRepoRoot();
+    }
+    catch (error) {
+        return {
+            ok: false,
+            code: 'REPO_ROOT_NOT_FOUND',
+            message: error instanceof Error ? error.message : String(error),
+            repoRoot: null,
+            taskId: null
+        };
+    }
+    let branch;
+    try {
+        branch = execFileSync('git', ['symbolic-ref', '--quiet', '--short', 'HEAD'], {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+    }
+    catch {
+        return {
+            ok: false,
+            code: 'TASK_CONTEXT_DETACHED_HEAD',
+            message: 'cannot infer the current task from detached HEAD',
+            repoRoot,
+            taskId: null
+        };
+    }
+    const activeDir = path.join(repoRoot, '.agents', 'workspace', 'active');
+    const matches = [];
+    if (fs.existsSync(activeDir)) {
+        for (const entry of fs.readdirSync(activeDir).sort()) {
+            if (!TASK_ID_RE.test(entry))
+                continue;
+            const taskDir = path.join(activeDir, entry);
+            const taskMdPath = path.join(taskDir, 'task.md');
+            if (!fs.existsSync(taskMdPath))
+                continue;
+            try {
+                const frontmatter = parseTaskFrontmatter(fs.readFileSync(taskMdPath, 'utf8'));
+                if (!frontmatter.id || !frontmatter.branch) {
+                    return {
+                        ok: false,
+                        code: 'TASK_CONTEXT_UNREADABLE',
+                        message: `cannot prove current task context because ${entry}/task.md has invalid frontmatter`,
+                        repoRoot,
+                        taskId: null
+                    };
+                }
+                if (frontmatter.branch === branch)
+                    matches.push({ taskId: entry, taskDir, taskMdPath });
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    code: 'TASK_CONTEXT_UNREADABLE',
+                    message: `cannot read active task candidate ${entry}: ${error instanceof Error ? error.message : String(error)}`,
+                    repoRoot,
+                    taskId: null
+                };
+            }
         }
     }
-    const taskMdPath = findTaskMd(repoRoot, taskId);
-    if (!taskMdPath) {
+    if (matches.length === 0) {
+        return {
+            ok: false,
+            code: 'TASK_CONTEXT_NOT_FOUND',
+            message: `no active task matches current branch '${branch}'; use --task <ref>`,
+            repoRoot,
+            taskId: null
+        };
+    }
+    if (matches.length > 1) {
         return {
             ok: false,
-            message: `task ${taskId} not found in active / blocked / completed / archive`
+            code: 'TASK_CONTEXT_AMBIGUOUS',
+            message: `multiple active tasks match current branch '${branch}'; use --task <ref>`,
+            repoRoot,
+            taskId: null
         };
     }
-    return { ok: true, repoRoot, taskId, taskDir: path.dirname(taskMdPath), taskMdPath };
+    const match = matches[0];
+    return { ok: true, repoRoot, ...match, state: 'active' };
 }
-export { resolveTaskRef, detectRepoRoot, enumerateTaskDirs, TASK_ID_RE };
+export { resolveTaskRef, resolveTaskContext, detectRepoRoot, enumerateTaskDirs, locateHotTaskDirs, TASK_ID_RE };
 //# sourceMappingURL=resolve-ref.js.map

package/dist/lib/task/review-artifacts.js

@@ -0,0 +1,101 @@
+// Shared helpers for review-artifact parsing.
+// Imported by typed artifact lifecycle and verification so the round/verdict vocabulary stays
+// in a single source of truth (prevents the cross-file drift this lifecycle
+// is designed to eliminate).
+import fs from "node:fs";
+import path from "node:path";
+export function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function maxRound(entries, stem) {
+    let max = 0;
+    for (const entry of entries) {
+        if (entry === `${stem}.md`) {
+            max = Math.max(max, 1);
+            continue;
+        }
+        const match = entry.match(new RegExp(`^${escapeRegExp(stem)}-r(\\d+)\\.md$`));
+        if (match) {
+            max = Math.max(max, Number(match[1]));
+        }
+    }
+    return max;
+}
+export function artifactName(stem, round) {
+    return round === 1 ? `${stem}.md` : `${stem}-r${round}.md`;
+}
+export function normalizeVerdict(raw) {
+    const value = String(raw).trim().toLowerCase();
+    if (value === "通过" || value === "approved") {
+        return "Approved";
+    }
+    if (value === "需要修改" || value === "changes requested") {
+        return "Changes Requested";
+    }
+    if (value === "拒绝" || value === "rejected") {
+        return "Rejected";
+    }
+    return "";
+}
+export function extractSection(content, names) {
+    const lines = content.split(/\r?\n/);
+    const nameSet = new Set(names);
+    const start = lines.findIndex((line) => {
+        const match = line.trim().match(/^##\s+(.+?)\s*$/);
+        return match ? nameSet.has(match[1]) : false;
+    });
+    if (start === -1) {
+        return "";
+    }
+    const sectionLines = [];
+    for (let index = start + 1; index < lines.length; index += 1) {
+        if (/^##\s+/.test(lines[index])) {
+            break;
+        }
+        sectionLines.push(lines[index]);
+    }
+    return sectionLines.join("\n");
+}
+// Parse the canonical verdict out of a review-* artifact.
+// Returns { ok, verdict, message }. Verdict collapses Approved into
+// "Approved-with-issues" when the findings counts are non-zero.
+export function parseVerdict(reviewPath) {
+    if (!fs.existsSync(reviewPath)) {
+        return { ok: false, verdict: null, message: `Review artifact not found: ${path.basename(reviewPath)}` };
+    }
+    const content = fs.readFileSync(reviewPath, "utf8");
+    const summary = extractSection(content, ["审查摘要", "Review Summary"]);
+    const fileName = path.basename(reviewPath);
+    if (!summary) {
+        return { ok: false, verdict: null, message: `cannot locate review summary section in ${fileName}` };
+    }
+    const verdictMatch = summary.match(/^[-*]?\s*\*\*(?:总体结论|Overall Verdict)\*\*[:：]\s*(.+?)\s*$/im);
+    if (!verdictMatch) {
+        return { ok: false, verdict: null, message: `cannot parse verdict in ${fileName}` };
+    }
+    const verdict = normalizeVerdict(verdictMatch[1]);
+    if (!verdict) {
+        return {
+            ok: false,
+            verdict: null,
+            message: `unrecognized verdict '${verdictMatch[1].trim()}' in ${fileName}`
+        };
+    }
+    if (verdict !== "Approved") {
+        return { ok: true, verdict };
+    }
+    const findingsMatch = summary.match(/^[-*]?\s*\*\*(?:发现（AI 可处理）|Findings \(AI-actionable\))\*\*[:：]\s*(.+?)\s*$/im);
+    if (!findingsMatch) {
+        return { ok: false, verdict, message: `cannot parse findings count in ${fileName}` };
+    }
+    const counts = findingsMatch[1].match(/(\d+)\s*(?:阻塞项|blockers?).*?(\d+)\s*(?:主要|majors?).*?(\d+)\s*(?:次要|minors?)/i);
+    if (!counts) {
+        return { ok: false, verdict, message: `cannot parse findings count in ${fileName}` };
+    }
+    const [, blockers, majors, minors] = counts.map(Number);
+    return {
+        ok: true,
+        verdict: blockers === 0 && majors === 0 && minors === 0 ? "Approved" : "Approved-with-issues"
+    };
+}
+//# sourceMappingURL=review-artifacts.js.map

package/dist/lib/task/review-fingerprint.js

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import path from "node:path";
+import { artifactName, maxRound } from "./review-artifacts.js";
+// Paths excluded from the post-review coverage gate. Fail-closed: the gate
+// covers ALL tracked changes by default. This default denylist is EMPTY —
+// projects opt into exclusions explicitly via review.post_review_exclude_globs.
+export const DEFAULT_POST_REVIEW_EXCLUDES = [];
+export function resolvePostReviewGlobs(config = {}, reviewConfig = {}) {
+    const projectExcludes = [
+        ...(Array.isArray(reviewConfig.post_review_exclude_globs) ? reviewConfig.post_review_exclude_globs : []),
+        ...(Array.isArray(config.post_review_exclude_globs) ? config.post_review_exclude_globs : [])
+    ];
+    const excludes = [...new Set([...DEFAULT_POST_REVIEW_EXCLUDES, ...projectExcludes])];
+    return [":/", ...excludes.map((p) => `:(top,exclude)${p}`)];
+}
+export function findAuthoritativeReviewCodeArtifact(taskDir) {
+    const entries = fs.existsSync(taskDir) ? fs.readdirSync(taskDir) : [];
+    const round = maxRound(entries, "review-code");
+    if (round === 0) {
+        return { ok: false, round: 0, fileName: null, path: null };
+    }
+    const fileName = artifactName("review-code", round);
+    return {
+        ok: true,
+        round,
+        fileName,
+        path: path.join(taskDir, fileName)
+    };
+}
+export function extractReviewBaseline(content) {
+    const match = String(content).match(/^[-*]?\s*\*\*(?:审查基线提交|Review Baseline Commit)\*\*[:：]\s*(.*?)\s*$/m);
+    return match ? match[1].trim().replace(/`/g, "") : "";
+}
+export function extractReviewDiffFingerprint(content) {
+    const match = String(content).match(/^[-*]?\s*\*\*(?:审查差异指纹|Reviewed Diff Fingerprint)\*\*[:：]\s*(.*?)\s*$/m);
+    return match ? match[1].trim().replace(/`/g, "") : "";
+}
+export function extractReviewedSnapshotTree(content) {
+    const match = String(content).match(/^[-*]?\s*\*\*(?:审查快照树|Reviewed Snapshot Tree)\*\*[:：]\s*(.*?)\s*$/m);
+    return match ? match[1].trim().replace(/`/g, "") : "";
+}
+export function parseReviewVerdict(content) {
+    const match = String(content).match(/^[-*]?\s*\*\*(?:总体结论|Overall Verdict)\*\*[:：]\s*(.*?)\s*$/m);
+    return match ? match[1].trim() : "";
+}
+//# sourceMappingURL=review-fingerprint.js.map