parallel-codex-tui 0.1.3 → 0.1.5

package/dist/orchestrator/final-acceptance.js

@@ -0,0 +1,86 @@
+import { z } from "zod";
+const FinalAcceptanceItemSchema = z.object({
+    criterion_id: z.string().regex(/^A-\d{1,4}$/),
+    status: z.enum(["passed", "failed"]),
+    evidence: z.string().trim().min(1).max(4000)
+}).strict();
+export const FinalJudgeAcceptanceSchema = z.object({
+    version: z.literal(1),
+    decision: z.enum(["approved", "rejected"]),
+    summary: z.string().trim().min(1).max(4000),
+    acceptance: z.array(FinalAcceptanceItemSchema).min(1).max(100),
+    changed_paths: z.array(z.string().trim().min(1).max(1000)).max(10000)
+}).strict();
+export function validateFinalJudgeAcceptance(input, expectedCriterionIds, expectedChangedPaths) {
+    const parsed = FinalJudgeAcceptanceSchema.safeParse(input);
+    if (!parsed.success) {
+        return {
+            acceptance: null,
+            report: {
+                version: 1,
+                state: "invalid",
+                decision: "unknown",
+                issues: parsed.error.issues.map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`)
+            }
+        };
+    }
+    const acceptance = parsed.data;
+    const issues = [];
+    const actualIds = acceptance.acceptance.map((item) => item.criterion_id);
+    const duplicateIds = repeated(actualIds);
+    if (duplicateIds.length > 0) {
+        issues.push(`duplicate acceptance criteria: ${duplicateIds.join(", ")}`);
+    }
+    const expectedIds = [...new Set(expectedCriterionIds)].sort();
+    const uniqueActualIds = [...new Set(actualIds)].sort();
+    const missingIds = expectedIds.filter((id) => !uniqueActualIds.includes(id));
+    const unknownIds = uniqueActualIds.filter((id) => !expectedIds.includes(id));
+    if (missingIds.length > 0) {
+        issues.push(`missing acceptance criteria: ${missingIds.join(", ")}`);
+    }
+    if (unknownIds.length > 0) {
+        issues.push(`unknown acceptance criteria: ${unknownIds.join(", ")}`);
+    }
+    const failedIds = acceptance.acceptance
+        .filter((item) => item.status === "failed")
+        .map((item) => item.criterion_id);
+    if (acceptance.decision === "approved" && failedIds.length > 0) {
+        issues.push(`approved decision contains failed criteria: ${failedIds.join(", ")}`);
+    }
+    if (acceptance.decision === "rejected" && failedIds.length === 0) {
+        issues.push("rejected decision must identify at least one failed criterion");
+    }
+    const expectedPaths = [...new Set(expectedChangedPaths)].sort();
+    const actualPaths = [...new Set(acceptance.changed_paths)].sort();
+    if (acceptance.changed_paths.length !== actualPaths.length) {
+        issues.push(`duplicate changed paths: ${repeated(acceptance.changed_paths).join(", ")}`);
+    }
+    const missingPaths = expectedPaths.filter((path) => !actualPaths.includes(path));
+    const unknownPaths = actualPaths.filter((path) => !expectedPaths.includes(path));
+    if (missingPaths.length > 0) {
+        issues.push(`missing changed paths: ${missingPaths.join(", ")}`);
+    }
+    if (unknownPaths.length > 0) {
+        issues.push(`unknown changed paths: ${unknownPaths.join(", ")}`);
+    }
+    return {
+        acceptance,
+        report: {
+            version: 1,
+            state: issues.length === 0 ? "valid" : "invalid",
+            decision: acceptance.decision,
+            issues
+        }
+    };
+}
+function repeated(values) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const value of values) {
+        if (seen.has(value)) {
+            duplicates.add(value);
+        }
+        seen.add(value);
+    }
+    return [...duplicates].sort();
+}

package/dist/orchestrator/judge-artifacts.js

@@ -0,0 +1,236 @@
+import { Lexer } from "marked";
+export const JUDGE_REQUIRED_ARTIFACTS = [
+    "requirements.md",
+    "plan.md",
+    "acceptance.md",
+    "actor-brief.md",
+    "critic-brief.md"
+];
+export const JUDGE_VALIDATION_FILE = "judge-validation.json";
+const CONTRACT_ARTIFACTS = {
+    "requirements.md": { prefix: "R", label: "requirement" },
+    "plan.md": { prefix: "P", label: "plan step" },
+    "acceptance.md": { prefix: "A", label: "acceptance criterion" }
+};
+const PLACEHOLDER_PATTERN = /^(?:todo|tbd|pending|placeholder|to be determined|coming soon|n\/?a|none|待定|稍后(?:补充|处理)?|后续(?:补充|再说)?|暂无|未定|占位(?:内容)?)(?:\s*[:：-].*)?$/iu;
+const ARTIFACT_NAME_PATTERN = /^(?:requirements|plan|acceptance|actor-brief|critic-brief)\.md$/iu;
+export function validateJudgeArtifacts(input) {
+    const requirements = validateContractArtifact("requirements.md", input["requirements.md"] ?? "");
+    const plan = validateContractArtifact("plan.md", input["plan.md"] ?? "");
+    const acceptance = validateContractArtifact("acceptance.md", input["acceptance.md"] ?? "");
+    const actorBrief = validateBriefArtifact("actor-brief.md", input["actor-brief.md"] ?? "");
+    const criticBrief = validateBriefArtifact("critic-brief.md", input["critic-brief.md"] ?? "");
+    const requirementIds = new Set(requirements.items.map((item) => item.id));
+    for (const item of acceptance.items) {
+        const unknown = item.references.filter((reference) => !requirementIds.has(reference));
+        if (unknown.length > 0) {
+            acceptance.validation.issues.push(issue("acceptance.md", "unknown_requirement_reference", `${item.id} references unknown requirement${unknown.length === 1 ? "" : "s"}: ${unknown.join(", ")}.`));
+            acceptance.validation.state = "invalid";
+        }
+    }
+    const artifacts = {
+        "requirements.md": requirements.validation,
+        "plan.md": plan.validation,
+        "acceptance.md": acceptance.validation,
+        "actor-brief.md": actorBrief.validation,
+        "critic-brief.md": criticBrief.validation
+    };
+    const issues = JUDGE_REQUIRED_ARTIFACTS.flatMap((file) => artifacts[file].issues);
+    return {
+        version: 1,
+        state: issues.length === 0 ? "valid" : "invalid",
+        artifacts,
+        contract: {
+            requirements: requirements.items,
+            plan: plan.items,
+            acceptance: acceptance.items
+        },
+        briefs: {
+            actor: actorBrief.content,
+            critic: criticBrief.content
+        },
+        issues
+    };
+}
+function validateContractArtifact(file, markdown) {
+    const parsed = parseMarkdown(markdown);
+    const issues = [];
+    const spec = CONTRACT_ARTIFACTS[file];
+    if (!markdown.trim()) {
+        issues.push(issue(file, "missing", `${file} is missing or empty.`));
+    }
+    else if (parsed.parseError) {
+        issues.push(issue(file, "parse_error", `${file} is not valid Markdown: ${parsed.parseError}`));
+    }
+    const normalized = parsed.listItems.map((text, index) => normalizeContractItem(text, spec.prefix, index));
+    const meaningful = normalized.filter((item) => isMeaningful(item.text));
+    const placeholders = normalized.filter((item) => !isMeaningful(item.text));
+    if (markdown.trim() && !parsed.parseError && parsed.listItems.length === 0) {
+        issues.push(issue(file, "missing_list_items", `${file} must contain at least one Markdown list ${spec.label}.`));
+    }
+    else if (parsed.listItems.length > 0 && meaningful.length === 0) {
+        issues.push(issue(file, "placeholder_only", `${file} contains only placeholder ${spec.label}s.`));
+    }
+    else if (placeholders.length > 0) {
+        issues.push(issue(file, "placeholder_items", `${file} still contains ${placeholders.length} placeholder ${spec.label}${placeholders.length === 1 ? "" : "s"}.`));
+    }
+    const duplicateIds = repeatedIds(meaningful);
+    if (duplicateIds.length > 0) {
+        issues.push(issue(file, "duplicate_item_id", `${file} repeats item id${duplicateIds.length === 1 ? "" : "s"}: ${duplicateIds.join(", ")}.`));
+    }
+    return {
+        validation: {
+            state: issues.length === 0 ? "valid" : "invalid",
+            item_count: parsed.listItems.length,
+            content_count: parsed.content.length,
+            issues
+        },
+        items: meaningful
+    };
+}
+function validateBriefArtifact(file, markdown) {
+    const parsed = parseMarkdown(markdown);
+    const issues = [];
+    const meaningful = parsed.content.filter(isMeaningful);
+    const placeholders = parsed.content.filter((content) => !isMeaningful(content));
+    if (!markdown.trim()) {
+        issues.push(issue(file, "missing", `${file} is missing or empty.`));
+    }
+    else if (parsed.parseError) {
+        issues.push(issue(file, "parse_error", `${file} is not valid Markdown: ${parsed.parseError}`));
+    }
+    else if (parsed.content.length === 0) {
+        issues.push(issue(file, "missing_content", `${file} must contain implementation guidance below its heading.`));
+    }
+    else if (meaningful.length === 0) {
+        issues.push(issue(file, "placeholder_only", `${file} contains only placeholder guidance.`));
+    }
+    else if (placeholders.length > 0) {
+        issues.push(issue(file, "placeholder_items", `${file} still contains placeholder guidance.`));
+    }
+    return {
+        validation: {
+            state: issues.length === 0 ? "valid" : "invalid",
+            item_count: parsed.listItems.length,
+            content_count: parsed.content.length,
+            issues
+        },
+        content: meaningful
+    };
+}
+function parseMarkdown(markdown) {
+    if (!markdown.trim()) {
+        return { listItems: [], content: [] };
+    }
+    try {
+        const tokens = Lexer.lex(markdown);
+        return {
+            listItems: collectListItems(tokens),
+            content: collectContent(tokens)
+        };
+    }
+    catch (error) {
+        return {
+            listItems: [],
+            content: [],
+            parseError: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function collectListItems(tokens) {
+    const items = [];
+    for (const token of tokens) {
+        if (isListToken(token)) {
+            for (const item of token.items) {
+                const text = normalizeWhitespace(item.tokens
+                    .filter((itemToken) => itemToken.type !== "list")
+                    .map(tokenPlainText)
+                    .join(" "));
+                items.push(text);
+                items.push(...collectListItems(item.tokens.filter(isListToken)));
+            }
+            continue;
+        }
+        const nested = tokenTokens(token);
+        if (nested.length > 0) {
+            items.push(...collectListItems(nested));
+        }
+    }
+    return items;
+}
+function collectContent(tokens) {
+    const content = [];
+    for (const token of tokens) {
+        if (token.type === "heading" || token.type === "space" || token.type === "hr" || token.type === "def") {
+            continue;
+        }
+        if (isListToken(token)) {
+            content.push(...collectListItems([token]));
+            continue;
+        }
+        if (token.type === "blockquote") {
+            content.push(...collectContent(tokenTokens(token)));
+            continue;
+        }
+        const text = normalizeWhitespace(tokenPlainText(token));
+        if (text) {
+            content.push(text);
+        }
+    }
+    return content;
+}
+function normalizeContractItem(text, prefix, index) {
+    const idPattern = new RegExp(`^\\[?(${prefix}-\\d{1,4})\\]?\\s*(?:[:：-]\\s*)?`, "iu");
+    const match = text.match(idPattern);
+    const id = match?.[1]?.toUpperCase() ?? `${prefix}-${String(index + 1).padStart(3, "0")}`;
+    const normalizedText = normalizeWhitespace(match ? text.slice(match[0].length) : text);
+    const references = Array.from(normalizedText.matchAll(/\bR-\d{1,4}\b/giu), (reference) => reference[0].toUpperCase());
+    return {
+        id,
+        text: normalizedText,
+        references: [...new Set(references)]
+    };
+}
+function tokenPlainText(token) {
+    if (token.type === "checkbox" || token.type === "space" || token.type === "def") {
+        return "";
+    }
+    const nested = tokenTokens(token);
+    if (nested.length > 0) {
+        return nested.map(tokenPlainText).join(" ");
+    }
+    if ("text" in token && typeof token.text === "string") {
+        return token.text;
+    }
+    return typeof token.raw === "string" ? token.raw : "";
+}
+function tokenTokens(token) {
+    return "tokens" in token && Array.isArray(token.tokens) ? token.tokens : [];
+}
+function isListToken(token) {
+    return token.type === "list" && "items" in token && Array.isArray(token.items);
+}
+function normalizeWhitespace(value) {
+    return value.replace(/\s+/gu, " ").trim();
+}
+function isMeaningful(value) {
+    const normalized = normalizeWhitespace(value).replace(/[.。,，;；:：!！?？]+$/gu, "").trim();
+    return Boolean(normalized)
+        && /[\p{L}\p{N}]/u.test(normalized)
+        && !PLACEHOLDER_PATTERN.test(normalized)
+        && !ARTIFACT_NAME_PATTERN.test(normalized);
+}
+function repeatedIds(items) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const item of items) {
+        if (seen.has(item.id)) {
+            duplicates.add(item.id);
+        }
+        seen.add(item.id);
+    }
+    return [...duplicates];
+}
+function issue(file, code, message) {
+    return { file, code, message };
+}