pi-readseek 0.3.2 → 0.3.3

package/src/doom-loop.ts

@@ -1,216 +0,0 @@
-import { SUGGESTIONS, GENERIC_SUGGESTION } from "./doom-loop-suggestions.js";
-export const MAX_RECENT_TOOL_CALLS = 24;
-
-export interface RecordedToolCall {
-  toolCallId: string;
-  toolName: string;
-  input: Record<string, unknown>;
-  fingerprint: string;
-}
-
-export interface DoomLoopStep {
-  toolName: string;
-  input: Record<string, unknown>;
-}
-
-export type DoomLoopWarning =
-  | {
-      kind: "identical-tail";
-      toolName: string;
-      fingerprint: string;
-    }
-  | {
-      kind: "repeated-subsequence";
-      toolName: string;
-      fingerprint: string;
-      steps: DoomLoopStep[];
-    };
-
-export interface DoomLoopState {
-  recentCalls: RecordedToolCall[];
-  pendingWarnings: Map<string, DoomLoopWarning>;
-}
-
-export function createDoomLoopState(): DoomLoopState {
-  return {
-    recentCalls: [],
-    pendingWarnings: new Map<string, DoomLoopWarning>(),
-  };
-}
-
-function stableStringify(value: unknown): string {
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-  }
-
-  if (value && typeof value === "object") {
-    const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) => a.localeCompare(b));
-    return `{${entries.map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`).join(",")}}`;
-  }
-
-  return JSON.stringify(value);
-}
-
-export function makeToolFingerprint(toolName: string, input: Record<string, unknown>): string {
-  return `${toolName}:${stableStringify(input)}`;
-}
-
-function sameFingerprints(left: RecordedToolCall[], right: RecordedToolCall[]): boolean {
-  return left.length === right.length && left.every((call, index) => call.fingerprint === right[index]?.fingerprint);
-}
-
-function hasIdenticalTail(calls: RecordedToolCall[]): boolean {
-  if (calls.length < 3) {
-    return false;
-  }
-
-  const last = calls[calls.length - 1]?.fingerprint;
-  return calls[calls.length - 2]?.fingerprint === last && calls[calls.length - 3]?.fingerprint === last;
-}
-
-function findRepeatedSubsequenceWindow(calls: RecordedToolCall[]): number | null {
-  const maxWindowSize = Math.floor(calls.length / 3);
-  for (let windowSize = 2; windowSize <= maxWindowSize; windowSize++) {
-    const newest = calls.slice(-windowSize);
-    const middle = calls.slice(-windowSize * 2, -windowSize);
-    const oldest = calls.slice(-windowSize * 3, -windowSize * 2);
-    if (sameFingerprints(newest, middle) && sameFingerprints(middle, oldest)) {
-      return windowSize;
-    }
-  }
-  return null;
-}
-
-export function recordToolCall(
-  state: DoomLoopState,
-  toolName: string,
-  toolCallId: string,
-  input: Record<string, unknown>,
-): void {
-  const fingerprint = makeToolFingerprint(toolName, input);
-  state.recentCalls.push({ toolCallId, toolName, input, fingerprint });
-
-  if (state.recentCalls.length > MAX_RECENT_TOOL_CALLS) {
-    state.recentCalls.splice(0, state.recentCalls.length - MAX_RECENT_TOOL_CALLS);
-  }
-
-  if (hasIdenticalTail(state.recentCalls)) {
-    state.pendingWarnings.set(toolCallId, {
-      kind: "identical-tail",
-      toolName,
-      fingerprint,
-    });
-    return;
-  }
-
-  const windowSize = findRepeatedSubsequenceWindow(state.recentCalls);
-  if (windowSize !== null) {
-    const newest = state.recentCalls.slice(-windowSize);
-    state.pendingWarnings.set(toolCallId, {
-      kind: "repeated-subsequence",
-      toolName,
-      fingerprint,
-      steps: newest.map((call) => ({ toolName: call.toolName, input: call.input })),
-    });
-  }
-}
-
-export function consumeDoomLoopWarning(
-  state: DoomLoopState,
-  toolCallId: string,
-): DoomLoopWarning | null {
-  const warning = state.pendingWarnings.get(toolCallId);
-  if (!warning) return null;
-  state.pendingWarnings.delete(toolCallId);
-  return warning;
-}
-
-const COMPACT_LINE_BUDGET = 80;
-const STEP_PREFIX = "  → ";
-
-function truncate(value: string, max: number): string {
-  if (value.length <= max) return value;
-  if (max <= 1) return "…";
-  return `${value.slice(0, max - 1)}…`;
-}
-
-function renderCompactStep(toolName: string, input: Record<string, unknown>): string {
-  const keys = Object.keys(input).sort();
-  const salient = keys.slice(0, 2);
-  const base = `${STEP_PREFIX}${toolName}`;
-  if (salient.length === 0) return truncate(`${base} {}`, COMPACT_LINE_BUDGET);
-
-  let line = base;
-  for (const key of salient) {
-    const rendered = JSON.stringify(input[key]);
-    const part = ` ${key}=${rendered}`;
-    const candidate = line + part;
-    if (candidate.length > COMPACT_LINE_BUDGET) {
-      const remaining = COMPACT_LINE_BUDGET - (line + ` ${key}=`).length;
-      line = `${line} ${key}=${truncate(rendered, Math.max(1, remaining))}`;
-      return line;
-    }
-    line = candidate;
-  }
-  return truncate(line, COMPACT_LINE_BUDGET);
-}
-
-function parseFingerprintInput(fingerprint: string): Record<string, unknown> {
-  const colon = fingerprint.indexOf(":");
-  if (colon < 0) return {};
-  const json = fingerprint.slice(colon + 1);
-  try {
-    const parsed = JSON.parse(json);
-    return parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : {};
-  } catch {
-    return {};
-  }
-}
-
-function suggestionsFor(toolName: string): string[] {
-  const entry = SUGGESTIONS[toolName];
-  if (entry && entry.length > 0) return [...entry];
-  return [GENERIC_SUGGESTION];
-}
-
-function renderSuggestionBullets(toolNames: string[]): string {
-  const seen = new Set<string>();
-  const lines: string[] = [];
-  for (const name of toolNames) {
-    if (seen.has(name)) continue;
-    seen.add(name);
-    const bullets = suggestionsFor(name);
-    lines.push(`For ${name}:`);
-    for (const bullet of bullets) {
-      lines.push(`  • ${bullet}`);
-    }
-  }
-  return lines.join("\n");
-}
-
-export function formatDoomLoopMessage(warning: DoomLoopWarning): string {
-  if (warning.kind === "identical-tail") {
-    const input = parseFingerprintInput(warning.fingerprint);
-    const compact = renderCompactStep(warning.toolName, input);
-    const suggestions = renderSuggestionBullets([warning.toolName]);
-    return [
-      "⚠ REPEATED-CALL WARNING: This is the 3rd identical tool call.",
-      compact,
-      "",
-      "Continuing this pattern will not make progress. Suggestions:",
-      suggestions,
-    ].join("\n");
-  }
-
-  const stepLines = warning.steps.map((step) => renderCompactStep(step.toolName, step.input));
-  const suggestions = renderSuggestionBullets(warning.steps.map((step) => step.toolName));
-  return [
-    `⚠ ALTERNATING-CALL WARNING: You have called this sequence ${warning.steps.length > 0 ? "3 times" : ""}:`.trimEnd(),
-    ...stepLines,
-    "",
-    "Neither call is producing new information. Break the loop with a different approach.",
-    "",
-    suggestions,
-  ].join("\n");
-}
-