parallel-codex-tui 0.1.3 → 0.1.4

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 };
+}