@tea-agent/loop-agent 0.25.6 → 0.26.1

package/dist/task/source-prepare/completeness.js

@@ -0,0 +1,195 @@
+const FRESH_SOURCE_MISSING_CODES = new Set([
+    "MISSING_REQUIREMENT",
+    "MISSING_CONSTRAINTS",
+]);
+export function isFreshLegacyUnversioned(state, sourceFilesPresent) {
+    if (state.effectiveStatus !== "legacy-unversioned")
+        return false;
+    if (state.observationErrors.some((e) => e.code === "NOT_FOUND"))
+        return false;
+    // Fresh new-task: both source files missing/empty. Any non-empty source is dirty.
+    if (sourceFilesPresent &&
+        (sourceFilesPresent.requirement || sourceFilesPresent.constraints)) {
+        return false;
+    }
+    const codes = state.observationErrors.map((e) => e.code);
+    // Allow empty errors only when caller already proved both files are empty.
+    if (codes.length === 0) {
+        return Boolean(sourceFilesPresent);
+    }
+    return codes.every((code) => FRESH_SOURCE_MISSING_CODES.has(code));
+}
+export function observationBlocksPrepare(state) {
+    if (state.observationErrors.some((e) => e.code === "NOT_FOUND")) {
+        return {
+            code: "TASK_NOT_FOUND",
+            level: "blocking",
+            message: "task not found",
+        };
+    }
+    if (state.effectiveStatus === "transaction-incomplete") {
+        return {
+            code: "TRANSACTION_INCOMPLETE",
+            level: "blocking",
+            message: "unfinished contract transaction; run task contract recover before prepare",
+        };
+    }
+    const disallowed = state.observationErrors.filter((e) => !FRESH_SOURCE_MISSING_CODES.has(e.code));
+    // EXTERNALLY_MODIFIED alone is the dirty-source signal handled by C6.
+    // Any other observation code (e.g. MANIFEST_MISSING, OBSERVE_FAILED,
+    // INVALID_CONTRACT_JSON) is independently blocking; force cannot bypass it.
+    const hard = disallowed.filter((e) => e.code !== "EXTERNALLY_MODIFIED");
+    if (hard.length > 0) {
+        return {
+            code: "OBSERVATION_ERROR",
+            level: "blocking",
+            message: hard.map((e) => e.message).join("; "),
+        };
+    }
+    return null;
+}
+export function listPrepareGaps(input) {
+    const gaps = [];
+    const risks = [];
+    const { draft } = input;
+    const obs = observationBlocksPrepare(input.state);
+    if (obs)
+        gaps.push(obs);
+    if (!draft.requirement.objective?.trim()) {
+        gaps.push({
+            code: "EMPTY_OBJECTIVE",
+            level: "blocking",
+            field: "objective",
+            message: "requirement.objective is required",
+        });
+    }
+    if (draft.requirement.acceptanceCriteria.length === 0) {
+        gaps.push({
+            code: "EMPTY_ACCEPTANCE",
+            level: "blocking",
+            field: "acceptanceCriteria",
+            message: "at least one acceptance criterion is required",
+        });
+    }
+    if (input.acceptanceConflicts && input.acceptanceConflicts.length > 0) {
+        for (const conflict of input.acceptanceConflicts) {
+            gaps.push({
+                code: "ACCEPTANCE_ID_CONFLICT",
+                level: "blocking",
+                field: "acceptanceCriteria",
+                message: `acceptance criterion id ${conflict.id} has conflicting texts`,
+            });
+        }
+    }
+    if (draft.constraints.allowedPaths.length === 0) {
+        gaps.push({
+            code: "EMPTY_ALLOWED_PATHS",
+            level: "blocking",
+            field: "allowedPaths",
+            message: "allowedPaths must be non-empty before apply",
+        });
+    }
+    if (!draft.taskKind?.trim()) {
+        gaps.push({
+            code: "EMPTY_TASK_KIND",
+            level: "blocking",
+            field: "taskKind",
+            message: "taskKind is required",
+        });
+    }
+    if (draft.taskKind === "knowledge-sync" && !draft.featureId) {
+        gaps.push({
+            code: "MISSING_FEATURE_ID",
+            level: "blocking",
+            field: "featureId",
+            message: "featureId is required when taskKind is knowledge-sync",
+        });
+    }
+    if (draft.requirement.scope.length === 0) {
+        gaps.push({
+            code: "EMPTY_SCOPE",
+            level: "warning",
+            field: "scope",
+            message: "scope is empty; projection will show (none)",
+        });
+    }
+    if (draft.requirement.nonGoals.length === 0) {
+        gaps.push({
+            code: "EMPTY_NON_GOALS",
+            level: "warning",
+            field: "nonGoals",
+            message: "nonGoals is empty; projection will show (none)",
+        });
+    }
+    if (draft.verification.commands.length === 0) {
+        gaps.push({
+            code: "EMPTY_VERIFY",
+            level: "warning",
+            field: "verifyCommands",
+            message: "verifyCommands is empty",
+        });
+    }
+    if (input.sourceIntegrity) {
+        for (const issue of input.sourceIntegrity.issues) {
+            if (issue.level === "blocking") {
+                gaps.push({
+                    code: issue.code,
+                    level: "blocking",
+                    message: issue.message,
+                    field: issue.path,
+                });
+            }
+            else {
+                gaps.push({
+                    code: issue.code,
+                    level: "warning",
+                    message: issue.message,
+                    field: issue.path,
+                });
+            }
+        }
+    }
+    if (input.pathAssessment) {
+        risks.push(...input.pathAssessment.blocking, ...input.pathAssessment.elevated, ...input.pathAssessment.warnings);
+        for (const risk of input.pathAssessment.blocking) {
+            gaps.push({
+                code: risk.code,
+                level: "blocking",
+                message: risk.message,
+                field: risk.path,
+            });
+        }
+    }
+    // Dirty source gate (C6 / D14)
+    const status = input.state.effectiveStatus;
+    const hasExistingSource = Boolean(input.sourceFilesPresent?.requirement ||
+        input.sourceFilesPresent?.constraints);
+    const hasDirtySource = status === "externally-modified" ||
+        (status === "legacy-unversioned" && hasExistingSource);
+    if (hasDirtySource && !input.forceOverwriteSource) {
+        gaps.push({
+            code: "DIRTY_SOURCE",
+            level: "blocking",
+            message: "existing non-empty or externally-modified source refuses --apply; use show/diff/adopt/recover or --force-overwrite-source",
+        });
+        risks.push({
+            code: "DIRTY_SOURCE",
+            level: "blocking",
+            message: "source is dirty/externally-modified; prepare will not overwrite without --force-overwrite-source",
+        });
+    }
+    if (!input.hasImportedPrd) {
+        gaps.push({
+            code: "NO_IMPORTED_PRD",
+            level: "warning",
+            message: "no imported PRD in use; prefer detailed PRD → import-prd → prepare (escape hatch only)",
+        });
+    }
+    return { gaps, risks };
+}
+export function hasBlockingGaps(gaps) {
+    return gaps.some((gap) => gap.level === "blocking");
+}
+export function hasBlockingRisks(risks) {
+    return risks.some((risk) => risk.level === "blocking");
+}

package/dist/task/source-prepare/index.js

@@ -0,0 +1,7 @@
+export * from "./types.js";
+export * from "./path-policy.js";
+export * from "./parse-intent.js";
+export * from "./reference-integrity.js";
+export * from "./completeness.js";
+export * from "./build-draft.js";
+export * from "./prepare.js";

package/dist/task/source-prepare/parse-intent.js

@@ -0,0 +1,373 @@
+const HEADING_ALIASES = {
+    objective: new Set(["目标", "objective", "问题与目标"]),
+    scope: new Set(["范围", "scope", "in scope"]),
+    nonGoals: new Set(["非目标", "out of scope", "non-goals", "non goals"]),
+    acceptance: new Set(["验收标准", "acceptance criteria", "acceptance"]),
+    constraints: new Set(["约束", "constraints", "不变式", "invariants"]),
+    openQuestions: new Set(["待决问题", "open questions", "open-questions"]),
+    assumptions: new Set(["假设", "assumptions"]),
+};
+const OBJECTIVE_MAX_CHARS = 1200;
+function stripFencedAndComments(text) {
+    // Remove fenced code blocks and HTML comments so headings inside them are ignored.
+    return text
+        .replace(/```[\s\S]*?```/g, "\n")
+        .replace(/~~~[\s\S]*?~~~/g, "\n")
+        .replace(/<!--[\s\S]*?-->/g, "\n");
+}
+function normalizeHeadingText(raw) {
+    return raw
+        .trim()
+        .toLowerCase()
+        .replace(/[:：]\s*$/u, "")
+        .replace(/\s+/g, " ");
+}
+function classifyHeading(text) {
+    const normalized = normalizeHeadingText(text);
+    for (const [key, aliases] of Object.entries(HEADING_ALIASES)) {
+        if (aliases.has(normalized))
+            return key;
+    }
+    return "other";
+}
+function isAtxHeading(line) {
+    const match = /^(#{1,6})\s+(.+?)\s*$/u.exec(line);
+    if (!match)
+        return null;
+    return { level: match[1].length, text: match[2] };
+}
+function parseListItem(line) {
+    const match = /^\s*(?:[-*+]|\d+[.)])\s+(?:\[(?: |x|X)\]\s+)?(.+?)\s*$/u.exec(line);
+    if (!match)
+        return null;
+    return match[1].trim();
+}
+function parseAcceptanceLine(line, nextId) {
+    const checklist = /^\s*[-*+]\s+\[(?: |x|X)\]\s+(.+?)\s*$/u.exec(line);
+    const bullet = /^\s*(?:[-*+]|\d+[.)])\s+(.+?)\s*$/u.exec(line);
+    const body = (checklist?.[1] ?? bullet?.[1] ?? line.trim()).trim();
+    if (!body)
+        return null;
+    const withId = /^(AC[-_]?\d+)\s*[:：]\s*(.+)$/iu.exec(body);
+    if (withId) {
+        return { id: withId[1].toUpperCase().replace("_", "-"), text: withId[2].trim() };
+    }
+    const bareAc = /^(AC[-_]?\d+)\s+(.+)$/iu.exec(body);
+    if (bareAc) {
+        return {
+            id: bareAc[1].toUpperCase().replace("_", "-"),
+            text: bareAc[2].trim(),
+        };
+    }
+    return { id: nextId(), text: body };
+}
+function firstParagraph(lines) {
+    const chunks = [];
+    let collecting = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            if (collecting)
+                break;
+            continue;
+        }
+        if (isAtxHeading(trimmed))
+            break;
+        if (parseListItem(trimmed)) {
+            if (!collecting) {
+                // Prefer list items only if no paragraph started.
+                return parseListItem(trimmed) ?? trimmed;
+            }
+            break;
+        }
+        collecting = true;
+        chunks.push(trimmed);
+    }
+    return chunks.join(" ").trim();
+}
+function collectListItems(lines) {
+    const items = [];
+    for (const line of lines) {
+        const item = parseListItem(line);
+        if (item)
+            items.push(item);
+    }
+    return items;
+}
+function extractTitle(markdown) {
+    const lines = stripFencedAndComments(markdown).split(/\r?\n/);
+    for (const line of lines) {
+        const heading = isAtxHeading(line);
+        if (heading && heading.level === 1) {
+            const text = heading.text.trim();
+            return text || undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * Deterministic heading-based extraction. No LLM. No engineering-field extraction.
+ */
+export function extractRequirementFactsFromMarkdown(markdown, options) {
+    const cleaned = stripFencedAndComments(markdown);
+    const lines = cleaned.split(/\r?\n/);
+    const sections = [];
+    let current = { key: "other", lines: [] };
+    sections.push(current);
+    for (const line of lines) {
+        const heading = isAtxHeading(line);
+        if (heading) {
+            const key = classifyHeading(heading.text);
+            current = { key, lines: [] };
+            sections.push(current);
+            continue;
+        }
+        current.lines.push(line);
+    }
+    let acCounter = options?.acCounterStart ?? 1;
+    const nextId = () => {
+        const id = `AC-${String(acCounter).padStart(3, "0")}`;
+        acCounter += 1;
+        return id;
+    };
+    let objective;
+    const scope = [];
+    const nonGoals = [];
+    const acceptanceCriteria = [];
+    const invariants = [];
+    const openQuestions = [];
+    const assumptions = [];
+    for (const section of sections) {
+        if (section.key === "objective" && !objective) {
+            const paragraph = firstParagraph(section.lines);
+            if (paragraph) {
+                objective =
+                    paragraph.length > OBJECTIVE_MAX_CHARS
+                        ? paragraph.slice(0, OBJECTIVE_MAX_CHARS)
+                        : paragraph;
+            }
+        }
+        else if (section.key === "scope") {
+            scope.push(...collectListItems(section.lines));
+        }
+        else if (section.key === "nonGoals") {
+            nonGoals.push(...collectListItems(section.lines));
+        }
+        else if (section.key === "acceptance") {
+            for (const line of section.lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                // Only list/checklist lines become AC; bare paragraphs ignored for stability.
+                if (!/^\s*(?:[-*+]|\d+[.)])\s+/.test(line))
+                    continue;
+                const ac = parseAcceptanceLine(line, nextId);
+                if (ac?.text)
+                    acceptanceCriteria.push(ac);
+            }
+        }
+        else if (section.key === "constraints") {
+            invariants.push(...collectListItems(section.lines));
+        }
+        else if (section.key === "openQuestions") {
+            openQuestions.push(...collectListItems(section.lines));
+        }
+        else if (section.key === "assumptions") {
+            assumptions.push(...collectListItems(section.lines));
+        }
+    }
+    // Fallback: first non-heading paragraph as objective when no objective section.
+    if (!objective) {
+        const bodyLines = lines.filter((line) => !isAtxHeading(line));
+        const paragraph = firstParagraph(bodyLines);
+        if (paragraph) {
+            objective =
+                paragraph.length > OBJECTIVE_MAX_CHARS
+                    ? paragraph.slice(0, OBJECTIVE_MAX_CHARS)
+                    : paragraph;
+        }
+    }
+    const acceptance = dedupeAcceptance(acceptanceCriteria);
+    return {
+        title: extractTitle(markdown),
+        objective,
+        scope: dedupeText(scope),
+        nonGoals: dedupeText(nonGoals),
+        acceptanceCriteria: acceptance.items,
+        invariants: dedupeText(invariants),
+        openQuestions: dedupeText(openQuestions),
+        assumptions: dedupeText(assumptions),
+        sourceLabels: options?.sourceLabel ? [options.sourceLabel] : [],
+        acceptanceConflicts: acceptance.conflicts,
+    };
+}
+function dedupeText(items) {
+    const seen = new Set();
+    const out = [];
+    for (const item of items) {
+        const trimmed = item.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+    }
+    return out;
+}
+function dedupeAcceptance(items) {
+    const byId = new Map();
+    const order = [];
+    const conflicts = new Map();
+    for (const item of items) {
+        const id = item.id.trim();
+        const text = item.text.trim();
+        if (!id || !text)
+            continue;
+        const existing = byId.get(id);
+        if (existing === undefined) {
+            byId.set(id, text);
+            order.push(id);
+            continue;
+        }
+        if (existing !== text) {
+            const texts = conflicts.get(id) ?? new Set([existing]);
+            texts.add(text);
+            conflicts.set(id, texts);
+        }
+    }
+    return {
+        items: order.map((id) => ({ id, text: byId.get(id) })),
+        conflicts: [...conflicts].map(([id, texts]) => ({ id, texts: [...texts] })),
+    };
+}
+export function mergeAcceptanceCriteria(parts) {
+    const byId = new Map();
+    const order = [];
+    for (const group of parts) {
+        for (const item of group) {
+            const id = item.id.trim();
+            const text = item.text.trim();
+            if (!id || !text)
+                continue;
+            if (!byId.has(id)) {
+                byId.set(id, new Set());
+                order.push(id);
+            }
+            byId.get(id)?.add(text);
+        }
+    }
+    const conflicts = [];
+    const items = [];
+    for (const id of order) {
+        const texts = [...(byId.get(id) ?? [])];
+        if (texts.length === 1) {
+            items.push({ id, text: texts[0] });
+        }
+        else if (texts.length > 1) {
+            conflicts.push({ id, texts });
+        }
+    }
+    return { items, conflicts };
+}
+export function mergeRequirementFacts(parts) {
+    let title;
+    let objective;
+    const scope = [];
+    const nonGoals = [];
+    const invariants = [];
+    const openQuestions = [];
+    const assumptions = [];
+    const sourceLabels = [];
+    const acGroups = [];
+    const internalAcceptanceConflicts = [];
+    for (const part of parts) {
+        if (!title && part.title)
+            title = part.title;
+        if (!objective && part.objective)
+            objective = part.objective;
+        scope.push(...part.scope);
+        nonGoals.push(...part.nonGoals);
+        invariants.push(...part.invariants);
+        openQuestions.push(...part.openQuestions);
+        assumptions.push(...part.assumptions);
+        sourceLabels.push(...part.sourceLabels);
+        acGroups.push(part.acceptanceCriteria);
+        internalAcceptanceConflicts.push(...(part.acceptanceConflicts ?? []));
+    }
+    const ac = mergeAcceptanceCriteria(acGroups);
+    return {
+        title,
+        objective,
+        scope: dedupeText(scope),
+        nonGoals: dedupeText(nonGoals),
+        acceptanceCriteria: ac.items,
+        invariants: dedupeText(invariants),
+        openQuestions: dedupeText(openQuestions),
+        assumptions: dedupeText(assumptions),
+        sourceLabels: dedupeText(sourceLabels),
+        acceptanceConflicts: [
+            ...internalAcceptanceConflicts,
+            ...ac.conflicts,
+        ],
+    };
+}
+/**
+ * Supplemental text only fills missing PRD fields (C3.1).
+ * Does not append/override scope, nonGoals, or AC when base already has values.
+ */
+export function fillMissingRequirementFacts(base, supplemental) {
+    const acceptance = base.acceptanceCriteria.length > 0
+        ? base.acceptanceCriteria
+        : supplemental.acceptanceCriteria;
+    return {
+        title: base.title ?? supplemental.title,
+        objective: base.objective ?? supplemental.objective,
+        scope: base.scope.length > 0 ? base.scope : supplemental.scope,
+        nonGoals: base.nonGoals.length > 0 ? base.nonGoals : supplemental.nonGoals,
+        acceptanceCriteria: acceptance,
+        invariants: base.invariants.length > 0 ? base.invariants : supplemental.invariants,
+        openQuestions: base.openQuestions.length > 0
+            ? base.openQuestions
+            : supplemental.openQuestions,
+        assumptions: base.assumptions.length > 0
+            ? base.assumptions
+            : supplemental.assumptions,
+        sourceLabels: dedupeText([
+            ...base.sourceLabels,
+            ...supplemental.sourceLabels,
+        ]),
+        acceptanceConflicts: base.acceptanceConflicts ?? [],
+    };
+}
+export function parseVerifyFlag(raw) {
+    const idx = raw.indexOf(":");
+    if (idx <= 0 || idx === raw.length - 1) {
+        throw new Error(`invalid --verify value "${raw}"; expected <label>:<command>`);
+    }
+    return {
+        label: raw.slice(0, idx).trim(),
+        command: raw.slice(idx + 1).trim(),
+    };
+}
+export function parseVerifyTimeoutFlag(raw) {
+    const idx = raw.indexOf(":");
+    if (idx <= 0 || idx === raw.length - 1) {
+        throw new Error(`invalid --verify-timeout value "${raw}"; expected <label>:<timeoutMs>`);
+    }
+    const label = raw.slice(0, idx).trim();
+    const timeoutRaw = raw.slice(idx + 1).trim();
+    const timeoutMs = Number(timeoutRaw);
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+        throw new Error(`invalid --verify-timeout value "${raw}"; timeoutMs must be a positive integer`);
+    }
+    return { label, timeoutMs };
+}
+export function parseAcceptanceFlag(raw) {
+    const idx = raw.indexOf(":");
+    if (idx <= 0 || idx === raw.length - 1) {
+        throw new Error(`invalid --ac/--acceptance value "${raw}"; expected <id>:<text>`);
+    }
+    return {
+        id: raw.slice(0, idx).trim(),
+        text: raw.slice(idx + 1).trim(),
+    };
+}