@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-UJILKYES.js

@@ -0,0 +1,75 @@
+// src/plugins/review-finding-types.ts
+import { createHash } from "node:crypto";
+var FindingNotFoundError = class extends Error {
+  findingId;
+  constructor(findingId) {
+    super(`Finding not found: ${findingId}`);
+    this.name = "FindingNotFoundError";
+    this.findingId = findingId;
+  }
+};
+var InvalidTransitionError = class extends Error {
+  from;
+  to;
+  constructor(from, to, reason) {
+    const msg = reason ?? `Invalid transition from "${from}" to "${to}"`;
+    super(msg);
+    this.name = "InvalidTransitionError";
+    this.from = from;
+    this.to = to;
+  }
+};
+var FindingStoreLockError = class extends Error {
+  path;
+  constructor(path, cause) {
+    super(`Could not acquire finding store lock: ${path}${cause ? ` (${cause})` : ""}`);
+    this.name = "FindingStoreLockError";
+    this.path = path;
+  }
+};
+function normalizeFingerprintTitle(title) {
+  return title.trim().toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, " ").trim();
+}
+function computeFindingFingerprint(file, line, title) {
+  const normalizedTitle = normalizeFingerprintTitle(title);
+  const normalizedFile = file.replace(/\\/g, "/").trim().toLowerCase();
+  const lineStr = line != null && line >= 0 ? String(line) : "0";
+  const hash = createHash("sha256");
+  hash.update(`${normalizedFile}:${lineStr}:${normalizedTitle}`);
+  return hash.digest("hex");
+}
+var TRANSITION_MATRIX = {
+  active: /* @__PURE__ */ new Set(["triaged", "ignored", "resolved"]),
+  triaged: /* @__PURE__ */ new Set(["in_progress", "ignored", "resolved"]),
+  in_progress: /* @__PURE__ */ new Set(["resolved", "active"]),
+  ignored: /* @__PURE__ */ new Set(["active"]),
+  resolved: /* @__PURE__ */ new Set(["active"])
+};
+function validateTransition(from, to) {
+  if (from === to) return;
+  const allowed = TRANSITION_MATRIX[from];
+  if (!allowed?.has(to)) {
+    throw new InvalidTransitionError(from, to);
+  }
+}
+function validateResolution(status, outcome) {
+  if (status !== "resolved") return;
+  if (!outcome) {
+    throw new InvalidTransitionError(
+      "active",
+      "resolved",
+      'A resolution outcome is required when transitioning to "resolved"'
+    );
+  }
+}
+
+export {
+  FindingNotFoundError,
+  InvalidTransitionError,
+  FindingStoreLockError,
+  normalizeFingerprintTitle,
+  computeFindingFingerprint,
+  validateTransition,
+  validateResolution
+};
+//# sourceMappingURL=chunk-UJILKYES.js.map

package/dist/chunk-ULMAQV3T.js

@@ -0,0 +1,234 @@
+// src/types/session-markers.ts
+var SESSION_MARKER_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "mode_changed",
+  "compaction",
+  "checkpoint",
+  "skill_activated",
+  "skill_deactivated",
+  "agent_spawned",
+  "agent_session_linked",
+  "agent_stopped",
+  "agent_error",
+  "delegate_started",
+  "delegate_completed",
+  "loop_detected",
+  "model_switched",
+  "error",
+  "provider_retry",
+  "provider_error",
+  "message_truncated"
+]);
+var CHAT_EXCLUDED_MARKER_SOURCES = /* @__PURE__ */ new Set([
+  "checkpoint",
+  "agent_spawned",
+  "agent_session_linked",
+  "agent_stopped",
+  "agent_error",
+  "delegate_started",
+  "delegate_completed"
+]);
+var CHAT_MARKER_SOURCES = new Set(
+  [...SESSION_MARKER_EVENT_TYPES].filter((type) => !CHAT_EXCLUDED_MARKER_SOURCES.has(type))
+);
+function sessionEventToMarker(ev) {
+  switch (ev.type) {
+    case "compaction": {
+      const before = (ev.before / 1e3).toFixed(0);
+      const after = (ev.after / 1e3).toFixed(0);
+      const level = ev.level ? ` (${ev.level})` : "";
+      const reductions = ev.reductions && ev.reductions.length > 0 ? ` [${ev.reductions.map((r) => `${r.phase}: \u2212${r.saved}`).join(", ")}]` : "";
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: `\u27F2 context compacted${level}: ${before}K \u2192 ${after}K tokens${reductions}`
+      };
+    }
+    case "error":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "error",
+        text: ev.phase ? `[${ev.phase}] ${ev.message}` : ev.message
+      };
+    case "provider_retry": {
+      const secs = (ev.delayMs / 1e3).toFixed(ev.delayMs >= 1e3 ? 1 : 2);
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "warn",
+        text: ev.status ? `\u27F3 retry ${ev.attempt} (HTTP ${ev.status}) after ${secs}s \u2014 ${ev.description}` : `\u27F3 retry ${ev.attempt} after ${secs}s \u2014 ${ev.description}`
+      };
+    }
+    case "provider_error":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "error",
+        text: ev.status ? `provider error (HTTP ${ev.status}, ${ev.retryable ? "retryable" : "fatal"}): ${ev.description}` : `provider error (${ev.retryable ? "retryable" : "fatal"}): ${ev.description}`
+      };
+    case "checkpoint":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: `\u2713 checkpoint #${ev.promptIndex}: "${ev.promptPreview.slice(0, 60)}"`
+      };
+    case "agent_spawned":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: `spawned as ${ev.role}`,
+        agentId: ev.agentId
+      };
+    case "agent_session_linked":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        // The transcript path is the point of the marker: it is how a reader
+        // of a resumed session gets from "this agent ran" to what it actually
+        // did. Falls back to the journal id when the writer had no file.
+        text: `transcript \u2192 ${ev.transcriptPath ?? ev.agentSessionId}`,
+        agentId: ev.agentId
+      };
+    case "agent_stopped":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: "stopped",
+        agentId: ev.agentId
+      };
+    case "delegate_started":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: `\u{1F91D} delegating \u2192 ${ev.target}: ${ev.task.length > 100 ? `${ev.task.slice(0, 99)}\u2026` : ev.task}`,
+        agentId: ev.subagentId,
+        detail: { kind: "delegate_started", target: ev.target, task: ev.task }
+      };
+    case "delegate_completed": {
+      const cost = ev.costUsd && ev.costUsd > 0 ? ` \xB7 $${ev.costUsd.toFixed(4)}` : "";
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: ev.ok ? "info" : "error",
+        text: `${ev.ok ? "\u2705" : "\u274C"} ${ev.summary}${cost}`,
+        agentId: ev.subagentId,
+        detail: {
+          kind: "delegate_completed",
+          target: ev.target,
+          task: ev.task,
+          ok: ev.ok,
+          status: ev.status,
+          summary: ev.summary,
+          durationMs: ev.durationMs,
+          iterations: ev.iterations,
+          toolCalls: ev.toolCalls,
+          costUsd: ev.costUsd
+        }
+      };
+    }
+    case "loop_detected": {
+      const what = ev.kind === "message" ? "the same reply" : ev.tools ? `\`${ev.tools}\`` : "the same step";
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "warn",
+        text: ev.action === "steer" ? `\u{1F501} Loop detected \u2014 ${what} repeated ${ev.repeatCount}\xD7 ; the run was steered.` : `\u{1F501} Loop detected \u2014 ${what} repeated ${ev.repeatCount}\xD7 ; the run was stopped.`
+      };
+    }
+    case "model_switched": {
+      const to = `${ev.to.providerId}/${ev.to.model}`;
+      const from = ev.from ? `${ev.from.providerId}/${ev.from.model} \u2192 ` : "";
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: ev.reason === "fallback" ? "warn" : "info",
+        text: ev.reason === "fallback" ? `\u26A0 fallback${ev.status ? ` (HTTP ${ev.status})` : ""}: ${from}${to}` : `model: ${from}${to}`
+      };
+    }
+    case "agent_error":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "error",
+        text: `error: ${ev.error.slice(0, 80)}`,
+        agentId: ev.agentId
+      };
+    case "mode_changed":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: `mode: ${ev.from} \u2192 ${ev.to}`
+      };
+    case "skill_activated":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: `skill activated: ${ev.skillName}`
+      };
+    case "skill_deactivated":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: `skill deactivated: ${ev.skillName}`
+      };
+    case "message_truncated":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "warn",
+        text: ev.after < ev.before ? `message truncated: ${ev.before} \u2192 ${ev.after} tokens` : `message truncated at ${ev.after} tokens`
+      };
+    default:
+      return null;
+  }
+}
+function projectSessionMarkers(events, sources = SESSION_MARKER_EVENT_TYPES) {
+  const markers = [];
+  for (const ev of events) {
+    if (!sources.has(ev.type)) continue;
+    const marker = sessionEventToMarker(ev);
+    if (marker) markers.push(marker);
+  }
+  return markers;
+}
+var SYSTEM_INJECTION_PREFIXES = [
+  "[MAILBOX]",
+  "[MAILBOX BTW]",
+  "[BY THE WAY \u2014",
+  "[QUEUED MESSAGES \u2014",
+  "[FLEET PULSE]",
+  "[loop-detector]",
+  // Written by `compaction-elision.ts` in place of the tool history it
+  // elided — a note addressed to the MODEL about what it can no longer see.
+  // It was replaying as the first line of the transcript, so every resumed
+  // session opened with a machine-readable inventory of its own compaction
+  // instead of the user's first prompt.
+  "[tool_history_digest:",
+  "[session.resume] Request targeted session"
+];
+function isSystemInjectedMessage(text) {
+  const trimmed = text.trimStart();
+  for (const prefix of SYSTEM_INJECTION_PREFIXES) {
+    if (trimmed.startsWith(prefix)) return true;
+  }
+  return false;
+}
+
+export {
+  SESSION_MARKER_EVENT_TYPES,
+  CHAT_MARKER_SOURCES,
+  sessionEventToMarker,
+  projectSessionMarkers,
+  SYSTEM_INJECTION_PREFIXES,
+  isSystemInjectedMessage
+};
+//# sourceMappingURL=chunk-ULMAQV3T.js.map

package/dist/chunk-VVBP6KGT.js

@@ -0,0 +1,9 @@
+// src/types/system-prompt.ts
+function flattenSystemPromptRegions(regions) {
+  return [...regions.core, ...regions.session, ...regions.volatile];
+}
+
+export {
+  flattenSystemPromptRegions
+};
+//# sourceMappingURL=chunk-VVBP6KGT.js.map

package/dist/chunk-W5VITDM2.js

@@ -0,0 +1,168 @@
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// src/utils/safe-json.ts
+function safeParse(input, maxBytes = 5e6) {
+  if (Buffer.byteLength(input, "utf8") > maxBytes) {
+    return { ok: false, error: `Input exceeds limit (${maxBytes} bytes)` };
+  }
+  try {
+    return { ok: true, value: JSON.parse(input) };
+  } catch (err) {
+    return {
+      ok: false,
+      error: toErrorMessage(err)
+    };
+  }
+}
+function safeStringify(value, pretty = false) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const replacer = (_k, v) => {
+    if (typeof v === "bigint") return v.toString();
+    if (v instanceof Error) {
+      return { name: v.name, message: v.message, stack: v.stack };
+    }
+    if (typeof v === "object" && v !== null) {
+      if (seen.has(v)) return "[Circular]";
+      seen.add(v);
+    }
+    return v;
+  };
+  try {
+    return JSON.stringify(value, replacer, pretty ? 2 : void 0) ?? "null";
+  } catch (err) {
+    return JSON.stringify({
+      __serialization_error: toErrorMessage(err)
+    });
+  }
+}
+function sanitizeJsonString(s) {
+  let out = s.trim();
+  out = stripJsonComments(out);
+  out = out.replace(/,(\s*[}\]])/g, "$1");
+  out = escapeControlCharsInStrings(out);
+  try {
+    JSON.parse(out);
+    return out;
+  } catch {
+    return null;
+  }
+}
+function stripCodeFences(s) {
+  const trimmed = s.trim();
+  const opener = /^```[\w+-]*[ \t]*\r?\n?/.exec(trimmed);
+  if (opener) {
+    const inner = trimmed.slice(opener[0].length).replace(/(\r?\n)?[ \t]*```[ \t]*$/, "");
+    return inner.trim();
+  }
+  const embedded = /```[\w+-]*[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]*```/.exec(trimmed);
+  if (embedded) return (embedded[1] ?? "").trim();
+  return null;
+}
+function escapeControlCharsInStrings(s) {
+  let inString = false;
+  let escaped = false;
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charAt(i);
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+        out += c;
+        continue;
+      }
+      if (c === "\\") {
+        escaped = true;
+        out += c;
+        continue;
+      }
+      if (c === '"') {
+        inString = false;
+        out += c;
+        continue;
+      }
+      const code = c.charCodeAt(0);
+      if (code < 32) {
+        switch (c) {
+          case "\n":
+            out += "\\n";
+            break;
+          case "\r":
+            out += "\\r";
+            break;
+          case "	":
+            out += "\\t";
+            break;
+          case "\b":
+            out += "\\b";
+            break;
+          case "\f":
+            out += "\\f";
+            break;
+          default:
+            out += `\\u${code.toString(16).padStart(4, "0")}`;
+        }
+        continue;
+      }
+      out += c;
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+    }
+    out += c;
+  }
+  return out;
+}
+function stripJsonComments(s) {
+  let inString = false;
+  let escaped = false;
+  const chars = [];
+  let i = 0;
+  while (i < s.length) {
+    const c = s.charAt(i);
+    if (inString) {
+      chars.push(c);
+      if (escaped) {
+        escaped = false;
+      } else if (c === "\\") {
+        escaped = true;
+      } else if (c === '"') {
+        inString = false;
+      }
+      i++;
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+      chars.push(c);
+      i++;
+      continue;
+    }
+    if (c === "/" && s.charAt(i + 1) === "/") {
+      while (i < s.length && s.charAt(i) !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && s.charAt(i + 1) === "*") {
+      const end = s.indexOf("*/", i + 2);
+      if (end === -1) {
+        chars.push(s.slice(i));
+        break;
+      }
+      i = end + 2;
+      continue;
+    }
+    chars.push(c);
+    i++;
+  }
+  return chars.join("");
+}
+
+export {
+  safeParse,
+  safeStringify,
+  sanitizeJsonString,
+  stripCodeFences
+};
+//# sourceMappingURL=chunk-W5VITDM2.js.map

package/dist/chunk-WAHQVNWT.js

@@ -0,0 +1,194 @@
+import {
+  expectDefined
+} from "./chunk-PFZO3C6H.js";
+
+// src/utils/glob-match.ts
+function escapeRegex(s) {
+  return s.replace(/[.+^${}()|\\]/g, "\\$&");
+}
+var COMPILED_GLOB_CACHE = /* @__PURE__ */ new Map();
+var CACHE_MAX_SIZE = 2e3;
+var NEVER_MATCH = /[^\s\S]/;
+var COMMAND_WILDCARD_STOP = ";&|\\n\\r`$<>";
+function getCachedGlob(pattern, commandSubject = false) {
+  const cacheKey = commandSubject ? `cmd\0${pattern}` : pattern;
+  const cached = COMPILED_GLOB_CACHE.get(cacheKey);
+  if (cached) return cached;
+  if (COMPILED_GLOB_CACHE.size >= CACHE_MAX_SIZE) {
+    const keys = [...COMPILED_GLOB_CACHE.keys()];
+    for (let i = 0; i < Math.floor(CACHE_MAX_SIZE / 4); i++) {
+      COMPILED_GLOB_CACHE.delete(expectDefined(keys[i]));
+    }
+  }
+  let re;
+  try {
+    re = compileGlob(pattern, commandSubject);
+  } catch {
+    re = NEVER_MATCH;
+  }
+  COMPILED_GLOB_CACHE.set(cacheKey, re);
+  return re;
+}
+var MAX_GLOB_PATTERN_LEN = 1024;
+function compileGlob(pattern, commandSubject = false) {
+  if (pattern.length > MAX_GLOB_PATTERN_LEN) {
+    throw new Error(`Glob pattern exceeds ${MAX_GLOB_PATTERN_LEN} characters`);
+  }
+  const star = commandSubject ? `[^/${COMMAND_WILDCARD_STOP}]*` : "[^/]*";
+  const question = commandSubject ? `[^/${COMMAND_WILDCARD_STOP}]` : "[^/]";
+  let i = 0;
+  let re = "^";
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        re += commandSubject ? `[^${COMMAND_WILDCARD_STOP}]*` : ".*";
+        i += 2;
+        if (pattern[i] === "/") i++;
+      } else {
+        re += star;
+        i++;
+      }
+    } else if (c === "?") {
+      re += question;
+      i++;
+    } else if (c === "[") {
+      const closeIndex = pattern.indexOf("]", i + 1);
+      if (closeIndex === -1) {
+        re += "\\[";
+        i++;
+        continue;
+      }
+      let cls = "[";
+      i++;
+      if (pattern[i] === "!" || pattern[i] === "^") {
+        cls += "^";
+        i++;
+      }
+      while (i < pattern.length && pattern[i] !== "]") {
+        const ch = pattern[i] ?? "";
+        if (ch === "\\") {
+          cls += "\\\\";
+        } else if (ch === "]" || ch === "^") {
+          cls += `\\${ch}`;
+        } else {
+          cls += ch;
+        }
+        i++;
+      }
+      cls += "]";
+      re += cls;
+      i++;
+    } else {
+      re += escapeRegex(c ?? "");
+      i++;
+    }
+  }
+  re += "$";
+  return new RegExp(re);
+}
+function matchGlob(pattern, input) {
+  return getCachedGlob(pattern).test(input);
+}
+function matchAny(patterns, input) {
+  return patterns.some((p) => matchGlob(p, input));
+}
+function matchCommandGlob(pattern, input) {
+  return getCachedGlob(pattern, true).test(input);
+}
+function matchAnyCommand(patterns, input) {
+  return patterns.some((p) => matchCommandGlob(p, input));
+}
+
+// src/utils/tool-subject.ts
+var GLOB_METACHARACTERS = /[*?[\]]/g;
+function escapeGlobSubject(value) {
+  return value.replace(GLOB_METACHARACTERS, (char) => `\\${char}`);
+}
+function normalizePathSubject(value) {
+  return escapeGlobSubject(value.replace(/\\/g, "/"));
+}
+function isPathSubjectKey(subjectKey) {
+  return subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
+}
+function renderCommandLine(command, args) {
+  if (!Array.isArray(args) || args.length === 0) return command;
+  const rendered = args.map((arg) => {
+    const str = String(arg);
+    return /\s/.test(str) ? `"${str.replace(/"/g, '\\"')}"` : str;
+  });
+  return [command, ...rendered].join(" ");
+}
+function renderSubjectFields(obj, fields) {
+  const parts = [];
+  for (const field of fields) {
+    const value = obj[field];
+    if (value === void 0 || value === null || value === "" || value === false) continue;
+    const str = String(value);
+    parts.push(`${field}=${/\s/.test(str) ? `"${str.replace(/"/g, '\\"')}"` : str}`);
+  }
+  return parts.join(" ");
+}
+function subjectForToolInput(toolName, input, subjectKey, subjectFields) {
+  if (!input || typeof input !== "object") return void 0;
+  const obj = input;
+  const extra = subjectFields && subjectFields.length > 0 ? renderSubjectFields(obj, subjectFields) : "";
+  const withExtra = (base) => extra ? `${base} ${extra}` : base;
+  if (subjectKey) {
+    const value = obj[subjectKey];
+    if (Array.isArray(value)) {
+      return escapeGlobSubject(JSON.stringify(value));
+    }
+    if (typeof value === "string") {
+      if (isPathSubjectKey(subjectKey)) {
+        const normalized = normalizePathSubject(value);
+        if (subjectKey === "files" && obj["check"] === true) return `${normalized}:check`;
+        if (subjectKey === "files" && obj["dry_run"] === true) return `${normalized}:dry-run`;
+        return normalized;
+      }
+      if (subjectKey === "command") {
+        const rendered = renderCommandLine(value, obj["args"]);
+        if (value === "commit" && obj["dry_run"] === true) {
+          return `${escapeGlobSubject(withExtra(rendered))}:dry-run`;
+        }
+        return escapeGlobSubject(withExtra(rendered));
+      }
+      if (subjectKey === "directory" && obj["dry_run"] === true) {
+        return `${escapeGlobSubject(value)}:dry-run`;
+      }
+      if (subjectKey === "packages" && obj["dry_run"] === true) {
+        return `${escapeGlobSubject(value)}:dry-run`;
+      }
+      if (subjectKey === "name" && obj["dry_run"] === true) {
+        return `${escapeGlobSubject(value)}:dry-run`;
+      }
+      return escapeGlobSubject(value);
+    }
+  }
+  if (toolName === "bash" && typeof obj.command === "string") {
+    return escapeGlobSubject(obj.command);
+  }
+  if (typeof obj.path === "string") {
+    return normalizePathSubject(obj.path);
+  }
+  if (typeof obj.url === "string") {
+    return escapeGlobSubject(obj.url);
+  }
+  if (typeof obj.name === "string") {
+    return escapeGlobSubject(obj.name);
+  }
+  return void 0;
+}
+
+export {
+  compileGlob,
+  matchGlob,
+  matchAny,
+  matchCommandGlob,
+  matchAnyCommand,
+  escapeGlobSubject,
+  normalizePathSubject,
+  isPathSubjectKey,
+  subjectForToolInput
+};
+//# sourceMappingURL=chunk-WAHQVNWT.js.map