pi-smart-compact 8.0.8 → 9.1.0

package/dist/provider-eval.js

@@ -156,7 +156,7 @@ function formatProviderEvaluation(report) {
 import fs2 from "fs";
 
 // src/constants.ts
-var VERSION = "8.0.8";
+var VERSION = "9.1.0";
 var COMPACT_SYSTEM_PREFIX = "You are an expert conversation summarizer for a coding agent. " + "Produce structured markdown summaries. " + "Follow output format exactly. " + "Use EXACT names \u2014 never paraphrase code identifiers. " + "Trust deterministic extraction data over intuition.";
 var PROFILES = {
   light: {
@@ -198,7 +198,7 @@ var DEFAULT_CONFIG = {
   backupEnabled: true,
   backupDir: "",
   minContextPercent: 60,
-  requireApproval: false,
+  requireApproval: true,
   scrubSecrets: true,
   scrubPii: false,
   maxLlmCalls: 8,
@@ -238,6 +238,8 @@ Output EXACTLY this format:
 - **[Decision]**: [Rationale]
 ` + `## Files Modified
 - [Verified list from deterministic extraction]
+` + `## Files Deleted
+- [Verified deleted paths from deterministic extraction]
 ` + `## Files Read
 - [Verified list from deterministic extraction]
 ` + `## Next Steps
@@ -261,6 +263,7 @@ Rules for Accuracy:
 ` + `**Summary**: [2-4 sentences: what happened, errors, code changes with paths]
 ` + `**Decisions**: [comma-separated, or "None"]
 ` + `**Modified**: [comma-separated paths, or "None"]
+` + `**Deleted**: [comma-separated paths, or "None"]
 ` + `**Read**: [comma-separated paths, or "None"]
 `;
 var ASSEMBLY_PROMPT_PREFIX = `Merge these topic summaries into ONE coherent summary.
@@ -292,6 +295,8 @@ var ASSEMBLY_PROMPT_PREFIX = `Merge these topic summaries into ONE coherent summ
 - **[Decision]**: [Rationale]
 ` + `## Files Modified
 - [Verified deterministic list]
+` + `## Files Deleted
+- [Verified deterministic deleted paths]
 ` + `## Files Read
 - [Verified deterministic list]
 ` + `## Next Steps
@@ -307,6 +312,14 @@ var FIVE_MINUTES_MS = 5 * 60 * 1000;
 var ONE_HOUR_MS = 60 * 60 * 1000;
 var SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
 var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
+var ID_PREFIX = {
+  PROJECT: "proj-",
+  COMPACT_SESSION: "sc-",
+  MULTI_TOOL_USE_SYNTHETIC: "mtu_",
+  OPEN_LOOP: "loop-",
+  DECISION: "decision-",
+  ERROR: "error-"
+};
 var TUNING = {
   EMA_PREV: 0.7,
   EMA_SAMPLE: 0.3,
@@ -346,6 +359,7 @@ var TRUNC = {
   BACKUP_PREVIEW_LINES: 5,
   FINGERPRINT_SEG: 2
 };
+var LIKELY_ERROR_RE = /(?:command not found|no such file|permission denied|syntax error|cannot find|module not found|compilation error|build failed|test failed|^FAIL\b|ERROR:)/i;
 var METRICS_BUFFER_MAX = 200;
 var RUNTIME_LOG_MAX_BYTES = 5 * 1024 * 1024;
 var EXPLORER_SYSTEM_PROMPT = `You are a conversation analyst. You have deterministic extraction data and can query the raw conversation using tools.
@@ -421,6 +435,15 @@ function calibrationKey(provider, model) {
 }
 
 // src/utils/type-guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isTextBlock(c) {
+  return isRecord(c) && c.type === "text" && typeof c.text === "string";
+}
+function isToolCallBlock(c) {
+  return isRecord(c) && c.type === "toolCall" && typeof c.name === "string" && isRecord(c.arguments);
+}
 var KNOWN_METHODS = new Set(["eesv", "single-pass", "heuristic"]);
 var KNOWN_PROFILES = new Set(["light", "balanced", "aggressive"]);
 var KNOWN_MODES = new Set(["balanced", "aggressive", "fast", "thorough"]);
@@ -479,6 +502,74 @@ function isKnownPathReference(ref, knownPaths) {
   });
 }
 
+// src/domain/tool-semantics.ts
+var PATH_KEYS = [
+  "path",
+  "file_path",
+  "filePath",
+  "filename",
+  "file",
+  "target_file",
+  "file_uri",
+  "absolute_path"
+];
+var PAYLOAD_KEYS = [
+  "content",
+  "newText",
+  "oldText",
+  "new_str",
+  "old_str",
+  "new_string",
+  "old_string",
+  "edits",
+  "patch",
+  "replacement"
+];
+var COMMAND_KEYS = ["command", "cmd", "script"];
+function hasPresent(args, keys) {
+  return keys.some((k) => args[k] != null);
+}
+function extractToolPath(args) {
+  if (!args || typeof args !== "object")
+    return;
+  const a = args;
+  for (const k of PATH_KEYS) {
+    const v = a[k];
+    if (typeof v === "string" && v.length > 0)
+      return v;
+  }
+  return;
+}
+function normalizeToolName(name) {
+  if (typeof name !== "string")
+    return "";
+  return name.replace(/^functions[.:/_-]+/i, "").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function nameHas(name, hints) {
+  const words = name.split("_");
+  return hints.some((hint) => words.includes(hint));
+}
+function classifyToolOperation(args, toolName) {
+  const a = args && typeof args === "object" ? args : {};
+  const name = normalizeToolName(toolName);
+  const hasPath = extractToolPath(a) !== undefined;
+  if (hasPath && hasPresent(a, PAYLOAD_KEYS))
+    return "mutate";
+  if (hasPresent(a, COMMAND_KEYS))
+    return "execute";
+  if (hasPath && hasPresent(a, ["text"]) && nameHas(name, ["write", "edit", "patch", "replace", "append", "create", "update", "insert"]))
+    return "mutate";
+  if (hasPath && nameHas(name, ["delete", "remove", "unlink"]))
+    return "delete";
+  if (hasPresent(a, ["pattern", "query", "glob"]) || nameHas(name, ["grep", "search", "find", "glob", "rg"]))
+    return "search";
+  if (nameHas(name, ["list", "ls", "tree"]))
+    return "list";
+  if (hasPath || nameHas(name, ["read"]))
+    return "read";
+  return "unknown";
+}
+
 // src/utils/file-ref-detect.ts
 var CODE_EXT_RE = /\.(ts|tsx|js|jsx|mjs|cjs|rs|py|go|java|rb|cs|cpp|c|h|hpp|swift|kt|scala|php|css|scss|html|json|yaml|yml|toml|md|mdx|sh|sql|tf|ini|env|lock|gradle|xml)$/i;
 var VERSION_RE = /^v?\d+(?:\.\d+)+(?:[-+][\w.-]+)?$/i;
@@ -514,6 +605,8 @@ function classifyHeading(raw) {
     return "files-modified";
   if (text.includes("file") && (text.includes("read") || text.includes("viewed")))
     return "files-read";
+  if (text.includes("file") && (text.includes("delet") || text.includes("remov")))
+    return "files-deleted";
   if (text.includes("next step") || text === "next actions")
     return "next-steps";
   if (text.includes("critical context") || text === "important context")
@@ -547,6 +640,7 @@ function parseSummary(markdown) {
   let currentHeading = "";
   let currentKind = "unknown";
   let bodyLines = [];
+  let fence = null;
   let started = false;
   const flush = () => {
     if (!started)
@@ -560,16 +654,31 @@ function parseSummary(markdown) {
       sections.push({ kind: currentKind, heading: currentHeading.trim(), body });
   };
   for (const line of lines) {
-    const m = line.match(HEADING_RE);
-    if (m) {
-      const kind = classifyHeading(m[2]);
-      if (m[1].length <= 2 || kind !== "unknown") {
-        flush();
-        currentHeading = "## " + m[2].trim();
-        currentKind = kind;
-        bodyLines = [];
-        started = true;
-        continue;
+    const fenceMatch = line.match(/^\s{0,3}(`{3,}|~{3,})(.*)$/);
+    if (fenceMatch) {
+      const marker = fenceMatch[1][0];
+      const markerLength = fenceMatch[1].length;
+      if (!fence) {
+        fence = { marker, length: markerLength };
+      } else if (marker === fence.marker && markerLength >= fence.length && !fenceMatch[2].trim()) {
+        fence = null;
+      }
+      if (started)
+        bodyLines.push(line);
+      continue;
+    }
+    if (!fence) {
+      const heading = line.match(HEADING_RE);
+      if (heading) {
+        const kind = classifyHeading(heading[2]);
+        if (heading[1].length <= 2 || kind !== "unknown") {
+          flush();
+          currentHeading = "## " + heading[2].trim();
+          currentKind = kind;
+          bodyLines = [];
+          started = true;
+          continue;
+        }
       }
     }
     if (started)
@@ -584,12 +693,68 @@ function findSection(summary, kind) {
 }
 
 // src/utils/extraction.ts
+function nestedToolCallId(wrapperId, messageIndex, toolIndex, nestedId) {
+  return typeof nestedId === "string" ? nestedId : wrapperId ? wrapperId + "_" + toolIndex : ID_PREFIX.MULTI_TOOL_USE_SYNTHETIC + messageIndex + "_" + toolIndex;
+}
+function flattenToolCallBlock(b) {
+  if (!isToolCallBlock(b))
+    return [];
+  if (b.name === "multi_tool_use.parallel" && Array.isArray(b.arguments?.tool_uses)) {
+    return b.arguments.tool_uses.map((u) => {
+      const recipient = u?.recipient_name ?? "";
+      return {
+        name: recipient.replace(/^functions\./, ""),
+        id: u?.id ?? undefined,
+        arguments: u?.parameters ?? {}
+      };
+    });
+  }
+  return [{ name: b.name, id: b.id, arguments: b.arguments }];
+}
+function extractText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((b) => {
+    if (typeof b === "string")
+      return b;
+    if (isTextBlock(b))
+      return b.text;
+    return "";
+  }).join("");
+}
+function buildToolCallIndex(msgs) {
+  const idx = new Map;
+  for (let i = 0;i < msgs.length; i++) {
+    const m = msgs[i];
+    if (m.role !== "assistant")
+      continue;
+    const blocks = Array.isArray(m.content) ? m.content : [];
+    for (const b of blocks) {
+      if (!isToolCallBlock(b))
+        continue;
+      if (b.id) {
+        idx.set(b.id, { name: b.name, arguments: b.arguments, msgIndex: i });
+      }
+      if (b.name === "multi_tool_use.parallel" && Array.isArray(b.arguments?.tool_uses)) {
+        const nested = flattenToolCallBlock(b);
+        for (let t = 0;t < nested.length; t++) {
+          const tool = nested[t];
+          const id = nestedToolCallId(b.id, i, t, tool.id);
+          idx.set(id, { name: tool.name, arguments: tool.arguments, msgIndex: i });
+        }
+      }
+    }
+  }
+  return idx;
+}
 var CONSTRAINT_PATTERNS = [
   { re: /\b(?:must|need|require|has to|important)\b.*\b(?:be|use|have|include|support)\b/i, cat: "requirement", conf: TUNING.CONFIDENCE_HIGH },
   { re: /\b(?:don't|never|avoid|shouldn't|must not|do not|no\s+(?:need|want))\b/i, cat: "prohibition", conf: TUNING.CONFIDENCE_MEDIUM },
   { re: /\b(?:prefer|like|want|would rather|should)\b.*\b(?:use|be|have|with)\b/i, cat: "preference", conf: TUNING.CONFIDENCE_LOW },
-  { re: /(?<![A-Za-z0-9_])(?:kritik|kritikal|\u00F6nemli|onemli|\u015Fart|sart|zorunlu|\u015Fart ko\u015Ful|\u00F6nemli \u015Fart|kesinlikle|kesinlikle \u015Fart|asla|sak\u0131n|sak\u0131nha|bunu yapma|b\u00F6yle olsun|b\u00F6yle yap\u0131n|\u015F\u00F6yle olsun|\u015F\u00F6yle yap\u0131n)(?![A-Za-z0-9_])/iu, cat: "requirement", conf: TUNING.CONFIDENCE_MEDIUM },
-  { re: /(?<![A-Za-z0-9_])(?:yapma|kullanma|sak\u0131n|asla\s+(?:kullanma|yapma|getirme))(?![A-Za-z0-9_])/iu, cat: "prohibition", conf: TUNING.CONFIDENCE_MEDIUM },
+  { re: /(?<![A-Za-z0-9_])(?:yapma|kullanma|sak\u0131n|sak\u0131nha|asla(?:\s+(?:kullanma|yapma|getirme))?|bunu yapma)(?![A-Za-z0-9_])/iu, cat: "prohibition", conf: TUNING.CONFIDENCE_MEDIUM },
+  { re: /(?<![A-Za-z0-9_])(?:kritik|kritikal|\u00F6nemli|onemli|\u015Fart|sart|zorunlu|\u015Fart ko\u015Ful|\u00F6nemli \u015Fart|kesinlikle|kesinlikle \u015Fart|b\u00F6yle olsun|b\u00F6yle yap\u0131n|\u015F\u00F6yle olsun|\u015F\u00F6yle yap\u0131n)(?![A-Za-z0-9_])/iu, cat: "requirement", conf: TUNING.CONFIDENCE_MEDIUM },
   { re: /(?<![A-Za-z0-9_])(?:tercih|isterim|olsun|kullanal\u0131m|yapal\u0131m|istiyorum)(?![A-Za-z0-9_])/iu, cat: "preference", conf: TUNING.CONFIDENCE_LOW }
 ];
 function isDiagnosticConstraintText(text) {
@@ -656,7 +821,6 @@ function readJsonlTail(target, limit, maxBytes = 512 * 1024) {
   }
   return values.slice(-limit);
 }
-var scheduledTailTrims = new Set;
 
 // src/infra/clock.ts
 var systemClock = {
@@ -741,6 +905,35 @@ function assertSuccessful(message) {
   }
   return message;
 }
+async function withProviderDeadline(opts, invoke) {
+  if (opts.signal?.aborted)
+    throw new Error("LLM request aborted before dispatch");
+  const controller = new AbortController;
+  const watchdogMs = resolveCodexWatchdogMs(opts.maxTokens, opts.codexWatchdogMs);
+  const abort = Promise.withResolvers();
+  const abortFromCaller = () => {
+    controller.abort(opts.signal?.reason);
+    abort.reject(new Error("LLM request aborted by caller"));
+  };
+  opts.signal?.addEventListener("abort", abortFromCaller, { once: true });
+  const timeout = Promise.withResolvers();
+  const timer = setTimeout(() => {
+    controller.abort("provider-watchdog");
+    timeout.reject(new Error("Provider watchdog stopped generation after " + watchdogMs + "ms"));
+  }, watchdogMs);
+  if (typeof timer === "object" && "unref" in timer)
+    timer.unref();
+  try {
+    return await Promise.race([
+      invoke({ ...opts, signal: controller.signal }),
+      abort.promise,
+      timeout.promise
+    ]);
+  } finally {
+    clearTimeout(timer);
+    opts.signal?.removeEventListener("abort", abortFromCaller);
+  }
+}
 async function completeChatGptCodex(model, body, opts) {
   const controller = new AbortController;
   const watchdogMs = resolveCodexWatchdogMs(opts.maxTokens, opts.codexWatchdogMs);
@@ -784,10 +977,12 @@ async function completeChatGptCodex(model, body, opts) {
 var rawLlmClient = {
   complete: async (model, body, originalOpts) => {
     const opts = withCodexWireLimit(model, originalOpts);
-    if (isChatGptCodex(model))
-      return completeChatGptCodex(model, body, opts);
-    const response = opts.reasoning === undefined ? await (await resolveComplete())(model, body, opts) : await (await resolveCompleteSimple())(model, body, opts);
-    return assertSuccessful(response);
+    return withProviderDeadline(opts, async (bounded) => {
+      if (isChatGptCodex(model))
+        return completeChatGptCodex(model, body, bounded);
+      const response = bounded.reasoning === undefined ? await (await resolveComplete())(model, body, bounded) : await (await resolveCompleteSimple())(model, body, bounded);
+      return assertSuccessful(response);
+    });
   }
 };
 var defaultLlmClient = rawLlmClient;
@@ -803,14 +998,23 @@ import crypto from "crypto";
 var SECRET_PATTERNS = [
   { kind: "private-key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g },
   { kind: "aws-access-key", regex: /\bAKIA[0-9A-Z]{16}\b/g },
-  { kind: "github-token", regex: /\bgh[pousr]_[A-Za-z0-9]{30,}\b/g },
+  { kind: "google-api-key", regex: /\bAIza[0-9A-Za-z_-]{30,}\b/g },
+  { kind: "stripe-key", regex: /\b[rs]k_(?:live|test)_[0-9A-Za-z]{16,}\b/g },
+  { kind: "gitlab-token", regex: /\bglpat-[0-9A-Za-z_-]{20,}\b/g },
+  { kind: "npm-token", regex: /\bnpm_[0-9A-Za-z]{30,}\b/g },
+  { kind: "github-token", regex: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g },
   { kind: "api-key", regex: /\bsk-(?:ant-)?[A-Za-z0-9_-]{20,}\b/g },
-  { kind: "slack-token", regex: /\bxox[baprs]-[A-Za-z0-9-]{20,}\b/g },
+  { kind: "slack-token", regex: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g },
   { kind: "jwt", regex: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g },
-  { kind: "bearer-token", regex: /\bBearer\s+[A-Za-z0-9._~+\/-]{24,}/gi, replacement: () => "Bearer [REDACTED:bearer-token]" },
+  { kind: "bearer-token", regex: /\bBearer\s+[A-Za-z0-9._~+\/-]{12,}=*/gi, replacement: () => "Bearer [REDACTED:bearer-token]" },
+  {
+    kind: "connection-password",
+    regex: /\b([a-z][a-z0-9+.-]*:\/\/[^:\s/@]+:)[^@\s/]+(@)/gi,
+    replacement: (prefix, suffix) => prefix + "[REDACTED:password]" + suffix
+  },
   {
     kind: "credential",
-    regex: /\b(api[_-]?key|access[_-]?token|auth[_-]?token|token|password|passwd|secret)\s*([:=])\s*["']?([A-Za-z0-9._~+\/-]{16,})["']?/gi,
+    regex: /\b((?:[A-Za-z0-9]+[_-])*(?:api[_-]?key|access[_-]?token|auth[_-]?token|token|password|passwd|secret(?:[_-]?(?:access)?[_-]?key)?|client[_-]?secret)(?:[_-][A-Za-z0-9]+)*)\s*([:=])\s*["']?([^\s"']{16,})["']?/gi,
     replacement: (name, separator) => name + separator + "[REDACTED:credential]"
   }
 ];
@@ -838,6 +1042,42 @@ function mergeFindings(target, findings) {
   for (const finding of findings)
     target.set(finding.kind, (target.get(finding.kind) ?? 0) + finding.count);
 }
+var SECRET_KEY_NAMES = {
+  api_key: true,
+  apikey: true,
+  access_token: true,
+  auth_token: true,
+  authorization: true,
+  password: true,
+  passwd: true,
+  secret: true,
+  secret_key: true,
+  secret_access_key: true,
+  client_secret: true,
+  private_key: true,
+  database_url: true,
+  connection_string: true,
+  token: true,
+  refresh_token: true,
+  session_token: true,
+  credential: true,
+  credentials: true,
+  cookie: true,
+  set_cookie: true,
+  otp: true,
+  one_time_password: true,
+  pin: true,
+  passcode: true
+};
+function normalizeObjectKey(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function isSecretBearingKey(key) {
+  const normalized = normalizeObjectKey(key);
+  if (SECRET_KEY_NAMES[normalized])
+    return true;
+  return /(?:^|_)(?:api_key|access_token|auth_token|password|passwd|secret_access_key|client_secret|private_key|refresh_token|session_token|one_time_password|passcode)(?:_|$)/.test(normalized);
+}
 
 class SecretScrubber {
   secretsEnabled;
@@ -867,6 +1107,10 @@ class SecretScrubber {
   scrubValue(input) {
     const findings = new Map;
     const seen = new WeakMap;
+    const recordCredential = () => {
+      findings.set("credential", (findings.get("credential") ?? 0) + 1);
+      this.total++;
+    };
     const visit = (value2) => {
       if (typeof value2 === "string") {
         const result = this.scrubText(value2);
@@ -887,8 +1131,15 @@ class SecretScrubber {
       }
       const output = {};
       seen.set(value2, output);
-      for (const [key, item] of Object.entries(value2))
-        output[key] = visit(item);
+      for (const [key, item] of Object.entries(value2)) {
+        const carriesSecret = typeof item === "string" ? item.length > 0 : item != null;
+        if (this.secretsEnabled && isSecretBearingKey(key) && carriesSecret) {
+          output[key] = "[REDACTED:credential]";
+          recordCredential();
+        } else {
+          output[key] = visit(item);
+        }
+      }
       return output;
     };
     const value = visit(input);
@@ -1147,8 +1398,8 @@ function readMetricsLog(limit = 100) {
     const fd = fs2.openSync(logPath, "r");
     try {
       const buf = Buffer.alloc(wantBytes);
-      fs2.readSync(fd, buf, 0, wantBytes, startPos);
-      let text = buf.toString("utf8");
+      const bytesRead = fs2.readSync(fd, buf, 0, wantBytes, startPos);
+      let text = buf.subarray(0, bytesRead).toString("utf8");
       if (startPos > 0) {
         const nl = text.indexOf(`
 `);