teapot-coding-agent 0.37.59 → 0.37.61

package/dist/agent/compact-rules.js

@@ -1,37 +1,5 @@
-/**
- * Keep the operator's hard rules alive across a compaction.
- *
- * ## Why this is not just another summary section
- *
- * A compaction summary is generated text: everything in it was re-derived by a model from the
- * conversation it was shown. That is fine for facts, because facts can be re-checked against the
- * code. A RULE cannot — "never install this into Wine", "do not clone repositories to study them"
- * were each stated once, obeyed silently for dozens of turns, and are not repeated anywhere the
- * next pass could find them. When the summary drops one, nothing downstream notices; the agent
- * just starts doing it.
- *
- * So the rules get a section with a SHAPE the code can check (`MUST` / `MUST NOT` / `SHOULD` at the
- * start of each line), extracted on the way out and RE-INSERTED on the way in if a pass lost them.
- * The summarizer is still the thing that decides what the rules ARE; this module only makes sure
- * that once known they cannot disappear.
- *
- * ## Why the shape matters more than the wording
- *
- * A free-form section lets a model merge three rules into one sentence, which is how a `MUST NOT`
- * turns into a `SHOULD avoid` and then into nothing. A fixed keyword per line keeps each rule a
- * separate, checkable item. `should` is included deliberately — the operator asked for it — but it
- * is ranked below the musts so a squeeze drops the weakest first.
- */
 export const RULES_HEADING = "## Hard constraints";
-/** the levels, strongest first — the order a squeeze must respect */
 const LEVELS = ["MUST NOT", "MUST", "SHOULD"];
-/**
- * Parse the `## Hard constraints` section out of a summary.
- *
- * Tolerant on purpose: the summarizer is asked for a shape, not guaranteed to produce it. A line
- * that does not start with a keyword is ignored rather than guessed at, because inventing a rule
- * from prose is worse than losing one — a wrong rule is obeyed.
- */
 export function extractRules(summary) {
     const lines = summary.split("\n");
     const start = lines.findIndex((l) => l.trim().toLowerCase() === RULES_HEADING.toLowerCase());
@@ -41,13 +9,11 @@ export function extractRules(summary) {
     const seen = new Set();
     for (let i = start + 1; i < lines.length; i++) {
         const raw = lines[i];
-        // a new `##` heading ends the section
         if (/^#{1,6}\s/.test(raw.trim()))
             break;
         const line = raw.replace(/^\s*[-*+]\s*/, "").trim();
         if (!line)
             continue;
-        // longest keyword first, or `MUST NOT` parses as `MUST` + "NOT …"
         const m = /^(MUST NOT|MUST|SHOULD)\b[:\s]*(.*)$/i.exec(line);
         if (!m)
             continue;
@@ -55,7 +21,6 @@ export function extractRules(summary) {
         const text = m[2].trim();
         if (!text)
             continue;
-        // de-duplicate on the normalised text: two paraphrases of one rule is one rule
         const key = text.toLowerCase().replace(/[^a-z0-9 ]+/g, "").replace(/\s+/g, " ").trim();
         if (seen.has(key))
             continue;
@@ -64,7 +29,6 @@ export function extractRules(summary) {
     }
     return out;
 }
-/** the section body for a set of rules, in strongest-first order */
 export function renderRules(rules) {
     const rank = (r) => LEVELS.indexOf(r.level);
     return [...rules]
@@ -72,16 +36,6 @@ export function renderRules(rules) {
         .map((r) => `- ${r.level} ${r.text}`)
         .join("\n");
 }
-/**
- * Re-insert rules a compaction pass dropped.
- *
- * `before` is what was known going in, `after` is the section the new summary produced. Anything in
- * `before` whose text is not present in `after` is appended (strongest first) so a pass can add
- * rules and reword them, but can never lose one. Returns the summary with the section rewritten.
- *
- * Rewriting rather than appending is what makes this idempotent: running it twice on the same
- * summary produces the same summary, which matters because the update path compacts repeatedly.
- */
 export function enforceRules(summary, before) {
     const after = extractRules(summary);
     const present = new Set(after.map((r) => r.text.toLowerCase().replace(/[^a-z0-9 ]+/g, "").replace(/\s+/g, " ").trim()));
@@ -95,7 +49,6 @@ export function enforceRules(summary, before) {
     const lines = summary.split("\n");
     const start = lines.findIndex((l) => l.trim().toLowerCase() === RULES_HEADING.toLowerCase());
     if (start < 0) {
-        // no section at all — append one rather than silently keeping nothing
         return { summary: `${summary.trimEnd()}\n\n${section}`, restored };
     }
     let end = lines.length;
@@ -110,12 +63,6 @@ export function enforceRules(summary, before) {
         restored,
     };
 }
-/**
- * The rules as a line the summarizer is asked to keep, for the UPDATE path.
- *
- * Passed as part of the prior checkpoint so a pass that is told "preserve what is still true" can
- * see the rules explicitly instead of having to find them in prose.
- */
 export function rulesForPrompt(rules) {
     if (!rules.length)
         return "";

package/dist/agent/editorconfig.js

@@ -1,52 +1,16 @@
-/**
- * `.editorconfig` support (#109) — "edit_file の改行コードを .editorconfig に合わせて
- * 正規化するとか?".
- *
- * ## What this DOES and deliberately does NOT do
- *
- * An EXISTING file already keeps its own line ending (#84, `detectEol`): the file's
- * own bytes are the strongest possible evidence, and a `.editorconfig` that
- * disagrees with the file on disk is nearly always stale relative to it. So this
- * only supplies an answer where there was NONE:
- *
- *   - a NEW file (nothing to detect), and
- *   - a MIXED-EOL file, where `detectEol` returns null on purpose because choosing
- *     a winner would be a silent whole-file rewrite.
- *
- * That keeps one rule: **the file's own content outranks configuration, which
- * outranks the LF default.** `end_of_line = crlf` in a repo whose files are LF does
- * not silently convert every file the agent touches.
- *
- * ## Why this is not a general editorconfig library
- *
- * The format has glob sections, brace expansion and a precedence order. Only the
- * facts that change how a WRITE behaves are read — today that is `end_of_line`
- * (plus `insert_final_newline`, which decides whether a new file ends in a
- * newline). Anything else (`indent_style`, `charset`, …) has no in-repo consumer,
- * and guessing at it would be untested surface.
- */
 import { readFileSync, existsSync } from "node:fs";
 import path from "node:path";
 const NONE = { eol: null };
-/**
- * Read the `.editorconfig` files that apply to `targetPath`, nearest-wins.
- *
- * Walks from the file's own directory up to the filesystem root so a nested
- * `.editorconfig` overrides the repo root, which is the documented precedence.
- * Sections are matched against the path RELATIVE to the file that declared them.
- * A `root = true` stops the walk, as the format requires.
- */
 export function editorConfigFor(targetPath) {
     const dirs = [];
     let dir = path.dirname(path.resolve(targetPath));
     for (;;) {
-        dirs.push(dir); // nearest first, which is also the precedence order
+        dirs.push(dir);
         const parent = path.dirname(dir);
         if (parent === dir)
             break;
         dir = parent;
     }
-    // nearest-first, so the FIRST answer found wins; `root = true` truncates the walk
     const applicable = [];
     for (const d of dirs) {
         const file = path.join(d, ".editorconfig");
@@ -61,9 +25,8 @@ export function editorConfigFor(targetPath) {
         }
         applicable.push({ dir: d, text });
         if (/^\s*root\s*=\s*true\s*$/im.test(text))
-            break; // this file is the root
+            break;
     }
-    // apply outermost -> innermost so the nearest file's value lands last
     let out = NONE;
     for (const { dir: declDir, text } of applicable.reverse()) {
         const rel = path.relative(declDir, path.resolve(targetPath)).split(path.sep).join("/");
@@ -86,7 +49,6 @@ export function editorConfigFor(targetPath) {
     }
     return out;
 }
-/** `[section]` blocks with their `key = value` pairs. Comments and blanks ignored. */
 function parseSections(text) {
     const sections = [];
     let current = null;
@@ -101,26 +63,17 @@ function parseSections(text) {
             continue;
         }
         if (!current)
-            continue; // a property outside any section applies to nothing
+            continue;
         const eq = line.indexOf("=");
         if (eq === -1)
             continue;
         const key = line.slice(0, eq).trim().toLowerCase();
         const value = line.slice(eq + 1).trim().toLowerCase();
-        // the FIRST value wins within a section (the format's rule)
         if (key && value && !current.props.has(key))
             current.props.set(key, value);
     }
     return sections;
 }
-/**
- * Does an editorconfig glob match a POSIX-style relative path?
- *
- * Supports the parts that appear in real configs: `*` (within a segment), `**`
- * (across segments), `?`, `{a,b}` alternation, and a `[abc]` class. A section with
- * no `/` matches the BASENAME at any depth, which is the format's documented special
- * case (and why `[*.md]` in a root file applies to `docs/x.md`).
- */
 export function sectionMatches(pattern, relPath) {
     const anchored = pattern.includes("/");
     const names = anchored ? [relPath] : [relPath.split("/").pop() ?? ""];
@@ -128,14 +81,12 @@ export function sectionMatches(pattern, relPath) {
     const re = globToRegExp(body, anchored);
     return names.some((n) => re.test(n));
 }
-/** Translate an editorconfig glob into a RegExp. */
 function globToRegExp(glob, anchored) {
     let out = "";
     for (let i = 0; i < glob.length; i++) {
         const c = glob[i];
         if (c === "*") {
             if (glob[i + 1] === "*") {
-                // `**/` matches zero or more leading segments; a bare `**` is `.*`
                 if (glob[i + 2] === "/") {
                     out += "(?:.*/)?";
                     i += 2;
@@ -146,7 +97,7 @@ function globToRegExp(glob, anchored) {
                 }
             }
             else {
-                out += "[^/]*"; // a single star never crosses a separator
+                out += "[^/]*";
             }
             continue;
         }
@@ -169,7 +120,6 @@ function globToRegExp(glob, anchored) {
         if (c === "[") {
             const close = glob.indexOf("]", i);
             if (close !== -1) {
-                // a character class is passed through as-is, minus any escaping surprises
                 out += glob.slice(i, close + 1).replace(/[\\^]/g, "\\$&");
                 i = close;
                 continue;
@@ -177,7 +127,5 @@ function globToRegExp(glob, anchored) {
         }
         out += c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     }
-    // anchored patterns are relative to the config's directory; a basename pattern
-    // already matched against the basename, so neither needs a prefix
     return new RegExp(`^${out}$`, anchored ? "" : "");
 }

package/dist/agent/goal-audit.js

@@ -1,26 +1,4 @@
-/**
- * Completion-audit verdict parsing and the auditor prompt.
- *
- * The auditor is an INDEPENDENT reviewer: a separate LLM call that decides whether the worker's
- * `finish(goalComplete=true)` is honest against the goal's verification contract. Its answer must
- * be unambiguous, because the two readings are not symmetric — a missed approval costs one more
- * round, while a misread rejection sends the worker to fix gaps that nobody named.
- */
-/** provider fallbacks for a message with no usable text */
 const PLACEHOLDER = /^\((tool call|no content|no output)\)$/i;
-/**
- * Read the auditor's verdict.
- *
- * The verdict must be the LAST non-empty line, and it must carry a reason. Upstream pi-goal-x made
- * this exact correction: matching the marker ANYWHERE lets a prose mention of it be read as the
- * verdict — "I would only approve if the tests passed" is a REJECTION that contains the word.
- *
- * MEASURED against the real failure: an auditor that answered `Independent verification against …`
- * (prose, no marker) was scored as a verdict three times in a row, hit the unavailable cap, and the
- * goal was abandoned with the audit never actually running. Requiring the marker on the last line
- * turns that into an honest "no verdict", which the caller already handles by retrying or failing
- * closed with a loud note.
- */
 export function parseAuditVerdict(reply) {
     const text = String(reply ?? "").trim();
     if (!text || PLACEHOLDER.test(text))
@@ -29,7 +7,6 @@ export function parseAuditVerdict(reply) {
         .split("\n")
         .map((l) => l.trim())
         .filter(Boolean);
-    // the verdict line is the LAST one; a reason may wrap onto earlier lines
     const last = lines[lines.length - 1] ?? "";
     const approved = /^APPROVED\b(:|\s-|$)(.*)$/i.exec(last);
     if (approved) {
@@ -39,19 +16,8 @@ export function parseAuditVerdict(reply) {
     if (rejected) {
         return { kind: "changes-required", reason: (rejected[2] ?? "").trim() || "(no gaps named)" };
     }
-    /**
-     * No marker on the last line. The reason still matters — it is shown to the worker when this
-     * happens repeatedly — so keep the tail rather than discarding the reply.
-     */
     return { kind: "none", detail: `auditor reply had no verdict on its last line: ${last.slice(0, 200)}` };
 }
-/**
- * The auditor's instructions.
- *
- * Deliberately NOT the worker's conversation: this call is a review, and handing the auditor a
- * 200k-token work log makes it continue the work instead of judging it. MEASURED: three audits in
- * one session replied with prose that started re-verifying the goal rather than naming a verdict.
- */
 export function auditPrompt(input) {
     return [
         "You are an independent completion AUDITOR, not the worker. Decide whether the goal is genuinely complete.",

package/dist/agent/key-pool.js

@@ -1,34 +1,3 @@
-/**
- * Multiple API keys per provider (#170) — "複数鍵登録しといて、規定のリトライ回数を超えたら
- * 次の鍵にローテ / 全キーを回ってもまだレートリミットだったらエラーで停止".
- *
- * ## The algorithm, deliberately small
- *
- * A request is made with the current key. The HTTP client already retries a rate limit
- * a fixed number of times on that key (its own backoff ladder). When those retries are
- * spent and the failure is STILL a rate limit, the pool moves to the next key and the
- * whole ladder runs again on it. When the last key is exhausted too, the error is
- * raised and the turn stops.
- *
- * That is the entire policy:
- *
- *     key1 [retry × N]  ->  key2 [retry × N]  ->  …  ->  raise
- *
- * ## What this intentionally does NOT do
- *
- * An earlier version of this file tracked per-key "recovered at" timestamps, parsed
- * provider reset hints, classified a 429 as transient-vs-exhausted, and persisted spent
- * accounts to disk. None of that was asked for, none of it was generic (the hint
- * formats are provider-specific), and the operator's actual ask is the loop above. A
- * simpler rule is also easier to reason about when it goes wrong: with this policy the
- * only state is "which key am I on", and the only outcome is success or a raised error.
- *
- * ## Provider-agnostic
- *
- * Nothing here knows about any particular endpoint. "Rate limited" is the HTTP 429 that
- * every OpenAI-compatible provider uses; the caller decides which statuses qualify.
- */
-/** Build a pool from config order, dropping blanks and duplicates. */
 export function makeKeyPool(keys) {
     const seen = new Set();
     const unique = [];
@@ -41,22 +10,11 @@ export function makeKeyPool(keys) {
     }
     return { keys: unique, current: 0 };
 }
-/** The key in use, or null for an empty pool (or no pool at all). */
 export function currentKey(pool) {
-    // tolerate a missing pool: most callers simply have no `keyPool`, and making every
-    // one of them guard first is how a `undefined.keys` crash reaches a 400 (measured)
     if (!pool)
         return null;
     return pool.keys[pool.current] ?? null;
 }
-/**
- * Move to the next key, or null when every key has already had its turn.
- *
- * Null is the "全キーを回ってもまだレートリミットだった" signal: the caller stops and raises
- * the last error instead of cycling forever. No wraparound on purpose — wrapping would
- * re-try keys whose retry ladder was just spent, turning a hard limit into an infinite
- * loop.
- */
 export function nextKey(pool) {
     const next = pool.current + 1;
     if (next >= pool.keys.length)
@@ -64,22 +22,12 @@ export function nextKey(pool) {
     pool.current = next;
     return pool.keys[next];
 }
-/** Start over from the first key (a fresh turn gets the full cycle again). */
 export function resetPool(pool) {
     pool.current = 0;
 }
-/** How many keys this pool holds. */
 export function poolSize(pool) {
     return pool.keys.length;
 }
-/**
- * Is this failure a rate limit — the only kind rotating can fix?
- *
- * 429 is the universal spelling. 402 ("payment required") and 403 are included because
- * an exhausted subscription and a quota-blocked key answer that way, and a second
- * account is exactly what resolves them. Everything else (5xx, 400, a network error) is
- * NOT rotated: it would fail identically on every key, so rotating just burns the cycle.
- */
 export function isRateLimitStatus(status) {
     return status === 429 || status === 402 || status === 403;
 }

package/dist/agent/kill.js

@@ -1,19 +1,10 @@
-/** can this platform kill a whole process group? */
 export function canKillProcessGroup(platform = process.platform) {
     return platform !== "win32";
 }
-/**
- * Kill a spawned child, and its whole group where the platform allows it.
- *
- * Deliberately does NOT throw: callers are timeouts and abort handlers, where a
- * throw would replace the real message with a secondary failure.
- */
 export function killTree(child, platform = process.platform) {
     if (!child?.pid)
         return { killed: false, wholeTree: false, reason: "no-pid" };
     if (!canKillProcessGroup(platform)) {
-        // Windows: no group kill. Try the direct child so at least THAT stops, and
-        // report that the tree is not covered rather than implying it is.
         try {
             process.kill(child.pid, "SIGKILL");
             return { killed: true, wholeTree: false };
@@ -28,13 +19,11 @@ export function killTree(child, platform = process.platform) {
         }
     }
     try {
-        process.kill(-child.pid, "SIGKILL"); // whole group
+        process.kill(-child.pid, "SIGKILL");
         return { killed: true, wholeTree: true };
     }
     catch (err) {
         const code = err.code;
-        // EPERM on the group can still mean the child is killable directly, and
-        // EPERM is what a partially-privileged tree produces.
         if (code === "EPERM") {
             try {
                 process.kill(child.pid, "SIGKILL");
@@ -49,7 +38,6 @@ export function killTree(child, platform = process.platform) {
         return { killed: false, wholeTree: false, reason: "error" };
     }
 }
-/** a sentence for the tool result, so a partial kill is never silent */
 export function describeKill(outcome) {
     if (outcome.killed && outcome.wholeTree)
         return "killed (whole process group)";