@tea-agent/loop-agent 0.26.0 → 0.26.1

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(),
+    };
+}

package/dist/task/source-prepare/path-policy.js

@@ -0,0 +1,197 @@
+import { canonicalizePath } from "../contract/canonicalize.js";
+import { PREPARE_DEFAULT_FORBIDDEN_PATHS } from "./types.js";
+function hasNul(value) {
+    return value.includes("\0");
+}
+function isAbsolutePath(value) {
+    if (value.startsWith("/"))
+        return true;
+    // Windows drive or UNC
+    if (/^[a-zA-Z]:[\\/]/.test(value))
+        return true;
+    if (value.startsWith("\\\\") || value.startsWith("//"))
+        return true;
+    return false;
+}
+function hasTraversalSegment(value) {
+    const parts = value.split("/");
+    return parts.some((part) => part === "..");
+}
+/**
+ * Normalize path globs for policy comparison:
+ * - trim
+ * - backslash → /
+ * - collapse leading ./
+ * - reject empty / NUL
+ */
+export function normalizePreparePath(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return { ok: false, reason: "path is empty" };
+    }
+    if (hasNul(trimmed)) {
+        return { ok: false, reason: "path contains NUL" };
+    }
+    let normalized = canonicalizePath(trimmed);
+    while (normalized.startsWith("./")) {
+        normalized = normalized.slice(2);
+    }
+    if (normalized === "./" || normalized === ".") {
+        normalized = ".";
+    }
+    if (normalized === "./**") {
+        normalized = "**";
+    }
+    if (!normalized) {
+        return { ok: false, reason: "path is empty after normalization" };
+    }
+    if (isAbsolutePath(normalized)) {
+        return { ok: false, reason: "absolute paths are not allowed" };
+    }
+    if (hasTraversalSegment(normalized)) {
+        return { ok: false, reason: "path traversal (..) is not allowed" };
+    }
+    return { ok: true, value: normalized };
+}
+export function dedupeStable(paths) {
+    const seen = new Set();
+    const out = [];
+    for (const item of paths) {
+        if (seen.has(item))
+            continue;
+        seen.add(item);
+        out.push(item);
+    }
+    return out;
+}
+/**
+ * Protected defaults always merge unless noDefaultForbiddenPaths is set.
+ * Explicit forbiddenPaths append.
+ */
+export function mergeForbiddenPaths(input) {
+    const parts = [];
+    if (!input.noDefaultForbiddenPaths) {
+        parts.push(...PREPARE_DEFAULT_FORBIDDEN_PATHS);
+    }
+    if (input.existing)
+        parts.push(...input.existing);
+    if (input.explicit)
+        parts.push(...input.explicit);
+    const normalized = [];
+    for (const raw of parts) {
+        const result = normalizePreparePath(raw);
+        if (result.ok)
+            normalized.push(result.value);
+        else
+            normalized.push(raw.trim());
+    }
+    return dedupeStable(normalized);
+}
+function forbiddenAncestorCoversAllowed(allowed, forbidden) {
+    // Only the deterministic prefix/** ancestor rule from C2.1.
+    if (!forbidden.endsWith("/**"))
+        return false;
+    const prefix = forbidden.slice(0, -3); // drop /**
+    if (!prefix)
+        return false;
+    if (allowed === prefix)
+        return true;
+    if (allowed.startsWith(`${prefix}/`))
+        return true;
+    return false;
+}
+export function assessPreparePaths(input) {
+    const blocking = [];
+    const elevated = [];
+    const warnings = [];
+    const allowed = [];
+    const forbidden = [];
+    for (const raw of input.allowedPaths) {
+        const result = normalizePreparePath(raw);
+        if (!result.ok) {
+            blocking.push({
+                code: "UNSAFE_ALLOWED_PATH",
+                level: "blocking",
+                message: `allowed path invalid: ${raw} (${result.reason})`,
+                path: raw,
+            });
+            continue;
+        }
+        allowed.push(result.value);
+    }
+    for (const raw of input.forbiddenPaths) {
+        const result = normalizePreparePath(raw);
+        if (!result.ok) {
+            blocking.push({
+                code: "UNSAFE_FORBIDDEN_PATH",
+                level: "blocking",
+                message: `forbidden path invalid: ${raw} (${result.reason})`,
+                path: raw,
+            });
+            continue;
+        }
+        forbidden.push(result.value);
+    }
+    const allowedSet = new Set(allowed);
+    for (const f of forbidden) {
+        if (allowedSet.has(f)) {
+            blocking.push({
+                code: "ALLOWED_FORBIDDEN_OVERLAP",
+                level: "blocking",
+                message: `allowedPaths and forbiddenPaths overlap exactly: ${f}`,
+                path: f,
+            });
+        }
+    }
+    for (const a of allowed) {
+        for (const f of forbidden) {
+            if (forbiddenAncestorCoversAllowed(a, f)) {
+                blocking.push({
+                    code: "ALLOWED_UNDER_FORBIDDEN_ANCESTOR",
+                    level: "blocking",
+                    message: `allowed path ${a} is fully covered by forbidden ancestor ${f}`,
+                    path: a,
+                });
+            }
+        }
+    }
+    for (const a of allowed) {
+        if (a === "**" || a === "*" || a === ".") {
+            elevated.push({
+                code: "BROAD_ALLOWED_ROOT",
+                level: "elevated",
+                message: `allowed path ${a} grants repo-root broad write`,
+                path: a,
+            });
+        }
+        else if (a === "src/**") {
+            elevated.push({
+                code: "BROAD_ALLOWED_SRC",
+                level: "elevated",
+                message: "allowed path src/** is broad for large repos; prefer a narrower glob",
+                path: a,
+            });
+        }
+    }
+    if (input.noDefaultForbiddenPaths) {
+        elevated.push({
+            code: "DEFAULT_FORBIDDEN_DISABLED",
+            level: "elevated",
+            message: "--no-default-forbidden-paths disabled protected defaults (.harness/**, node_modules/**)",
+        });
+        if (!forbidden.includes(".harness/**")) {
+            warnings.push({
+                code: "MISSING_HARNESS_FORBIDDEN",
+                level: "routine",
+                message: "forbiddenPaths lacks .harness/** after disabling protected defaults",
+            });
+        }
+    }
+    return {
+        allowed: dedupeStable(allowed),
+        forbidden: dedupeStable(forbidden),
+        blocking,
+        elevated,
+        warnings,
+    };
+}