@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-KDQJCT2J.js

@@ -0,0 +1,45 @@
+// src/types/prompt.ts
+var BUILTIN_PROMPT_CATEGORIES = [
+  "coding",
+  "debugging",
+  "refactoring",
+  "testing",
+  "code-review",
+  "architecture",
+  "devops",
+  "documentation",
+  "data-analysis",
+  "writing",
+  "research",
+  "product",
+  "agentic-workflows",
+  "meta-prompting",
+  "uncategorized"
+];
+var PROMPT_CATEGORY_LABELS = {
+  coding: "Coding",
+  debugging: "Debugging",
+  refactoring: "Refactoring",
+  testing: "Testing",
+  "code-review": "Code Review",
+  architecture: "Architecture",
+  devops: "DevOps",
+  documentation: "Documentation",
+  "data-analysis": "Data Analysis",
+  writing: "Writing",
+  research: "Research",
+  product: "Product",
+  "agentic-workflows": "Agentic Workflows",
+  "meta-prompting": "Meta-Prompting",
+  uncategorized: "Uncategorized"
+};
+function isBuiltinCategory(value) {
+  return BUILTIN_PROMPT_CATEGORIES.includes(value);
+}
+
+export {
+  BUILTIN_PROMPT_CATEGORIES,
+  PROMPT_CATEGORY_LABELS,
+  isBuiltinCategory
+};
+//# sourceMappingURL=chunk-KDQJCT2J.js.map

package/dist/chunk-KJ2ZTQSL.js

@@ -0,0 +1,47 @@
+// src/types/config/runtime.ts
+function normalizeTokenSavingTier(val) {
+  if (val === void 0) return "off";
+  if (typeof val === "boolean") return val ? "medium" : "off";
+  if (val === "auto") return "medium";
+  const validTiers = /* @__PURE__ */ new Set([
+    "off",
+    "minimal",
+    "light",
+    "medium",
+    "aggressive"
+  ]);
+  return validTiers.has(val) ? val : "off";
+}
+function resolveTokenSavingTier(val, maxContext) {
+  if (val === "auto") {
+    if (typeof maxContext !== "number" || !Number.isFinite(maxContext) || maxContext <= 0) {
+      return "off";
+    }
+    if (maxContext < 32e3) return "medium";
+    if (maxContext < 128e3) return "light";
+    return "minimal";
+  }
+  return normalizeTokenSavingTier(val);
+}
+var DEFAULT_TUI_THINKING_WORD = "thinking";
+var MAX_TUI_THINKING_WORD_LENGTH = 16;
+var MAX_WRONGPROXY_URL_LENGTH = 2048;
+function normalizeTuiThinkingWord(value) {
+  if (typeof value !== "string") return DEFAULT_TUI_THINKING_WORD;
+  const word = value.trim();
+  if (word.length === 0 || word.length > MAX_TUI_THINKING_WORD_LENGTH) {
+    return DEFAULT_TUI_THINKING_WORD;
+  }
+  if (!/^[\p{L}\p{N}_-]+$/u.test(word)) return DEFAULT_TUI_THINKING_WORD;
+  return word;
+}
+
+export {
+  normalizeTokenSavingTier,
+  resolveTokenSavingTier,
+  DEFAULT_TUI_THINKING_WORD,
+  MAX_TUI_THINKING_WORD_LENGTH,
+  MAX_WRONGPROXY_URL_LENGTH,
+  normalizeTuiThinkingWord
+};
+//# sourceMappingURL=chunk-KJ2ZTQSL.js.map

package/dist/chunk-KZMSZV32.js

@@ -0,0 +1,187 @@
+import {
+  ERROR_CODES,
+  WrongStackError
+} from "./chunk-25LSLC3G.js";
+
+// src/kernel/container.ts
+var Container = class {
+  entries = /* @__PURE__ */ new Map();
+  /**
+   * Tokens currently mid-resolve. Tracked so we can detect circular
+   * dependencies (A → B → A) and throw a structured error instead of
+   * overflowing the call stack with "Maximum call stack size exceeded".
+   *
+   * Not a memoization cache — the per-entry `cache` field is the source
+   * of truth for "have I built this before?". This set only lives for
+   * the duration of a single resolve call.
+   */
+  resolving = /* @__PURE__ */ new Set();
+  bind(token, factory, opts = {}) {
+    if (this.entries.has(token)) {
+      throw new WrongStackError({
+        message: `Container: token "${token.description ?? "unknown"}" already bound`,
+        code: ERROR_CODES.CONTAINER_TOKEN_ALREADY_BOUND,
+        subsystem: "container",
+        context: { token: token.description }
+      });
+    }
+    this.entries.set(token, {
+      factory,
+      singleton: opts.singleton ?? true,
+      decorators: [],
+      hasCache: false,
+      owner: opts.owner ?? "core"
+    });
+  }
+  override(token, factory, opts = {}) {
+    const existing = this.entries.get(token);
+    if (!existing) {
+      throw new WrongStackError({
+        message: `Container: cannot override "${token.description ?? "unknown"}" \u2014 not bound`,
+        code: ERROR_CODES.CONTAINER_TOKEN_NOT_BOUND,
+        subsystem: "container",
+        context: { token: token.description }
+      });
+    }
+    this.entries.set(token, {
+      factory,
+      singleton: opts.singleton ?? existing.singleton,
+      decorators: existing.decorators,
+      hasCache: false,
+      owner: opts.owner ?? existing.owner
+    });
+  }
+  decorate(token, decorator, owner = "core") {
+    const existing = this.entries.get(token);
+    if (!existing) {
+      throw new WrongStackError({
+        message: `Container: cannot decorate "${token.description ?? "unknown"}" \u2014 not bound`,
+        code: ERROR_CODES.CONTAINER_TOKEN_NOT_BOUND,
+        subsystem: "container",
+        context: { token: token.description }
+      });
+    }
+    existing.decorators.push(decorator);
+    existing.cache = void 0;
+    existing.hasCache = false;
+    existing.owner = `${existing.owner}+${owner}`;
+  }
+  resolve(token) {
+    const entry = this.entries.get(token);
+    if (!entry) {
+      throw new WrongStackError({
+        message: `Container: token "${token.description ?? "unknown"}" not bound`,
+        code: ERROR_CODES.CONTAINER_TOKEN_NOT_BOUND,
+        subsystem: "container",
+        context: { token: token.description }
+      });
+    }
+    if (entry.singleton && entry.hasCache) {
+      return entry.cache;
+    }
+    if (this.resolving.has(token)) {
+      const cycle = this.describeCycle(token);
+      throw new WrongStackError({
+        message: `Container: circular dependency detected \u2014 ${cycle}`,
+        code: ERROR_CODES.CONTAINER_CIRCULAR_DEPENDENCY,
+        subsystem: "container",
+        context: { token: token.description, cycle }
+      });
+    }
+    this.resolving.add(token);
+    try {
+      let value = entry.factory(this);
+      for (const d of entry.decorators) {
+        value = d(value, this);
+      }
+      if (entry.singleton) {
+        entry.cache = value;
+        entry.hasCache = true;
+      }
+      return value;
+    } finally {
+      this.resolving.delete(token);
+    }
+  }
+  /**
+   * Build a human-readable description of the dependency cycle that
+   * caused the resolution to re-enter. Lists the tokens in the order
+   * they were entered, then appends the re-entered token to close the
+   * loop. Falls back to a generic message if the resolving set is
+   * somehow empty (shouldn't happen, but defensive).
+   */
+  describeCycle(reentry) {
+    const descs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of this.resolving) {
+      if (seen.has(t)) continue;
+      seen.add(t);
+      descs.push(t.description ?? "unknown");
+    }
+    descs.push(reentry.description ?? "unknown");
+    return descs.join(" \u2192 ");
+  }
+  has(token) {
+    return this.entries.has(token);
+  }
+  /**
+   * Resolve a token if it is bound, otherwise return undefined.
+   * Unlike `resolve()`, this does not throw if the token is unbound.
+   *
+   * Single map lookup — `has()` + `resolve()` would walk the entries
+   * map twice. The bound check is folded into the resolve path so a
+   * non-existent token can never enter the `resolving` cycle-detection
+   * set.
+   */
+  safeResolve(token) {
+    if (!this.entries.has(token)) return void 0;
+    return this.resolve(token);
+  }
+  ownerOf(token) {
+    return this.entries.get(token)?.owner;
+  }
+  /**
+   * Remove a token's binding (along with any decorators stacked on it).
+   * Returns true if the token existed. Use this to withdraw temporary
+   * bindings installed by a short-lived run or plugin — without it, the
+   * entry persists in the map forever.
+   */
+  unbind(token) {
+    return this.entries.delete(token);
+  }
+  /**
+   * Drop every binding. Intended for tests and short-lived CLI invocations
+   * that rebuild the container from scratch. Production code should prefer
+   * `unbind` on the specific tokens it owns.
+   */
+  clear() {
+    this.entries.clear();
+  }
+  list() {
+    return Array.from(this.entries.entries()).map(([token, entry]) => ({
+      token,
+      owner: entry.owner
+    }));
+  }
+  /**
+   * Inspect a binding's full shape, including decorator count and whether
+   * a singleton value is cached. Returns null if the token is unbound.
+   * Decorator and factory function references are not exposed — only counts
+   * and metadata, to keep internal state hidden.
+   */
+  inspect(token) {
+    const entry = this.entries.get(token);
+    if (!entry) return null;
+    return {
+      owner: entry.owner,
+      singleton: entry.singleton,
+      decoratorCount: entry.decorators.length,
+      cached: entry.hasCache
+    };
+  }
+};
+
+export {
+  Container
+};
+//# sourceMappingURL=chunk-KZMSZV32.js.map

package/dist/chunk-LA7CLDRW.js

@@ -0,0 +1,129 @@
+// src/utils/ip-guard.ts
+import * as dns from "node:dns/promises";
+import * as net from "node:net";
+function isPrivateIPv4(addr) {
+  const parts = addr.split(".").map((p) => {
+    if (!/^\d+$/.test(p)) return Number.NaN;
+    if (p.length > 1 && p.startsWith("0")) return Number.NaN;
+    return Number.parseInt(p, 10);
+  });
+  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n) || n < 0 || n > 255)) {
+    return true;
+  }
+  const [a, b, c] = parts;
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 192 && b === 0 && c === 0) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a >= 224) return true;
+  return false;
+}
+function isPrivateIPv6(raw) {
+  const lower = raw.toLowerCase();
+  if (lower === "::" || lower === "::1") return true;
+  const groups = expandIPv6(lower);
+  if (!groups) return true;
+  if (groups[0] === 100 && groups[1] === 65435 && groups[2] === 1) return true;
+  if (groups[0] === 0 && groups[1] === 0 && groups[2] === 0 && groups[3] === 0 && groups[4] === 0 && groups[5] === 65535) {
+    const a = (groups[6] ?? 0) >> 8;
+    const b = (groups[6] ?? 0) & 255;
+    const c = (groups[7] ?? 0) >> 8;
+    const d = (groups[7] ?? 0) & 255;
+    return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
+  }
+  const embedded = embeddedIPv4(groups);
+  if (embedded) return isPrivateIPv4(embedded);
+  const high = groups[0] ?? 0;
+  if ((high & 65024) === 64512) return true;
+  if ((high & 65472) === 65152) return true;
+  if ((high & 65280) === 65280) return true;
+  return false;
+}
+function quad(hi, lo) {
+  return `${(hi ?? 0) >> 8}.${(hi ?? 0) & 255}.${(lo ?? 0) >> 8}.${(lo ?? 0) & 255}`;
+}
+function embeddedIPv4(groups) {
+  const g = (i) => groups[i] ?? 0;
+  if (g(0) === 100 && g(1) === 65435) {
+    if (g(2) === 0 && g(3) === 0 && g(4) === 0 && g(5) === 0) {
+      return quad(g(6), g(7));
+    }
+  }
+  if (g(0) === 8194) return quad(g(1), g(2));
+  if (g(0) === 8193 && g(1) === 0) {
+    return quad(~g(6) & 65535, ~g(7) & 65535);
+  }
+  if ((g(4) === 0 || g(4) === 512) && g(5) === 24318) {
+    return quad(g(6), g(7));
+  }
+  const highZero = g(0) === 0 && g(1) === 0 && g(2) === 0 && g(3) === 0;
+  if (highZero && g(4) === 65535 && g(5) === 0) return quad(g(6), g(7));
+  if (highZero && g(4) === 0 && g(5) === 0) return quad(g(6), g(7));
+  return void 0;
+}
+function expandIPv6(addr) {
+  const parts = addr.split("::");
+  if (parts.length > 2) return null;
+  const parseGroups = (s) => {
+    if (s === "") return [];
+    const out = [];
+    for (const g of s.split(":")) {
+      if (g.length === 0 || g.length > 4) return null;
+      const n = Number.parseInt(g, 16);
+      if (Number.isNaN(n) || n < 0 || n > 65535) return null;
+      out.push(n);
+    }
+    return out;
+  };
+  if (parts.length === 1) {
+    const groups = parseGroups(parts[0] ?? "");
+    if (groups?.length !== 8) return null;
+    return groups;
+  }
+  const head = parseGroups(parts[0] ?? "");
+  const tail = parseGroups(parts[1] ?? "");
+  if (!head || !tail) return null;
+  const fill = 8 - head.length - tail.length;
+  if (fill < 0) return null;
+  return [...head, ...new Array(fill).fill(0), ...tail];
+}
+async function assertNotPrivateHost(hostname) {
+  const host = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  if (host === "localhost" || host.endsWith(".localhost")) {
+    throw new Error("fetch: blocked localhost target");
+  }
+  const ipVersion = net.isIP(host);
+  if (ipVersion === 4) {
+    if (isPrivateIPv4(host)) {
+      throw new Error(`fetch: blocked private/loopback address "${host}"`);
+    }
+  } else if (ipVersion === 6) {
+    if (isPrivateIPv6(host)) {
+      throw new Error(`fetch: blocked private/loopback address "${host}"`);
+    }
+  } else {
+    try {
+      const records = await dns.lookup(host, { all: true });
+      for (const r of records) {
+        const bad = r.family === 4 ? isPrivateIPv4(r.address) : isPrivateIPv6(r.address);
+        if (bad) {
+          throw new Error(`fetch: resolved to private address ${r.address}`);
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && err.message.startsWith("fetch:")) throw err;
+    }
+  }
+}
+
+export {
+  isPrivateIPv4,
+  isPrivateIPv6,
+  expandIPv6,
+  assertNotPrivateHost
+};
+//# sourceMappingURL=chunk-LA7CLDRW.js.map

package/dist/chunk-LHOA5DWA.js

@@ -0,0 +1,28 @@
+// src/utils/win32-cmd.ts
+var WIN32_CMD_META = /[&|<>"%\r\n\0]/;
+function buildWin32CmdShimInvocation(command, args = []) {
+  assertSafeWin32CmdArgs([command, ...args]);
+  const line = ["call", quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(" ");
+  return {
+    command: process.env["COMSPEC"] ?? "cmd.exe",
+    args: ["/d", "/c", line],
+    windowsVerbatimArguments: true
+  };
+}
+function assertSafeWin32CmdArgs(args) {
+  for (const arg of args) {
+    if (typeof arg === "string" && WIN32_CMD_META.test(arg)) {
+      throw new Error(
+        'win32 cmd shim spawn: argument contains a shell metacharacter (one of & | < > ", or a newline) that could enable command injection through the .cmd/.bat wrapper - refusing to run. Offending argument: ' + JSON.stringify(arg)
+      );
+    }
+  }
+}
+function quoteWin32CmdArg(arg) {
+  return `"${arg}"`;
+}
+
+export {
+  buildWin32CmdShimInvocation
+};
+//# sourceMappingURL=chunk-LHOA5DWA.js.map

package/dist/chunk-LSMMOS2Z.js

@@ -0,0 +1,119 @@
+import {
+  expectDefined
+} from "./chunk-PFZO3C6H.js";
+
+// src/utils/message-invariants.ts
+function repairToolUseAdjacency(messages, opts = {}) {
+  const removedToolUses = [];
+  const removedToolResults = [];
+  let removedMessages = 0;
+  let changed = false;
+  const out = [];
+  for (let i = 0; i < messages.length; i++) {
+    const original = expectDefined(messages[i]);
+    let msg = original;
+    if (hasToolUse(msg)) {
+      const nextIds = toolResultIds(messages[i + 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          const preserveTrailing = opts.preserveTrailingToolUse === true && i === messages.length - 1 && block.type === "tool_use";
+          if (block.type === "tool_use" && !nextIds.has(block.id) && !preserveTrailing) {
+            removedToolUses.push(block.id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
+        }
+        return next;
+      });
+      msg = filtered ?? msg;
+    }
+    if (hasToolResult(msg)) {
+      const allowed = toolUseIds(out[out.length - 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          if (block.type === "tool_result" && !allowed.has(block.tool_use_id)) {
+            removedToolResults.push(block.tool_use_id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
+        }
+        return next;
+      });
+      msg = filtered ?? msg;
+    }
+    if (isEmptyMessage(msg)) {
+      removedMessages++;
+      changed = true;
+      continue;
+    }
+    out.push(msg);
+  }
+  return {
+    messages: changed ? out : messages,
+    report: { changed, removedToolUses, removedToolResults, removedMessages }
+  };
+}
+function hasToolUse(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_use");
+}
+function hasToolResult(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_result");
+}
+function toolUseIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (msg?.role !== "assistant") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_use") ids.add(block.id);
+  }
+  return ids;
+}
+function toolResultIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (msg?.role !== "user") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_result") ids.add(block.tool_use_id);
+  }
+  return ids;
+}
+function contentBlocks(msg) {
+  return msg && Array.isArray(msg.content) ? msg.content : [];
+}
+function mapContent(msg, fn) {
+  if (!Array.isArray(msg.content)) return msg;
+  const next = fn(msg.content);
+  if (next.length === msg.content.length && next.every((b, idx) => b === msg.content[idx])) {
+    return msg;
+  }
+  return { ...msg, content: next };
+}
+function hasMeaningfulContent(content) {
+  if (!content) return false;
+  if (typeof content === "string") return content.trim().length > 0;
+  if (!Array.isArray(content)) return false;
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    if (block.type === "text") {
+      if (block.text.trim().length > 0) return true;
+      continue;
+    }
+    if (block.type === "thinking") {
+      if (block.thinking.trim().length > 0 || block.signature) return true;
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+function isEmptyMessage(msg) {
+  return !hasMeaningfulContent(msg.content);
+}
+
+export {
+  repairToolUseAdjacency,
+  hasMeaningfulContent
+};
+//# sourceMappingURL=chunk-LSMMOS2Z.js.map

package/dist/chunk-LX5QWLBL.js

@@ -0,0 +1,27 @@
+// src/utils/sqlite-warning.ts
+var SQLITE_EXPERIMENTAL_WARNING_RE = /sqlite is an experimental feature/i;
+function isSqliteExperimentalWarning(warning, rest) {
+  const message = typeof warning === "string" ? warning : warning instanceof Error ? warning.message : "";
+  const typeOrOptions = rest[0];
+  const warningType = typeof warning === "string" ? typeof typeOrOptions === "string" ? typeOrOptions : typeof typeOrOptions === "object" && typeOrOptions !== null && "type" in typeOrOptions && typeof typeOrOptions.type === "string" ? typeOrOptions.type : "" : warning instanceof Error ? warning.name : "";
+  const warningCode = typeof warning === "string" ? typeof typeOrOptions === "object" && typeOrOptions !== null && "code" in typeOrOptions && typeof typeOrOptions.code === "string" ? typeOrOptions.code : typeof rest[1] === "string" ? rest[1] : "" : warning instanceof Error && "code" in warning && typeof warning.code === "string" ? warning.code : "";
+  return SQLITE_EXPERIMENTAL_WARNING_RE.test(message) && (warningType === "ExperimentalWarning" || warningCode === "ExperimentalWarning");
+}
+function withSqliteExperimentalWarningSuppressed(run) {
+  const originalEmitWarning = process.emitWarning;
+  const forwardWarning = originalEmitWarning.bind(process);
+  process.emitWarning = ((warning, ...rest) => {
+    if (isSqliteExperimentalWarning(warning, rest)) return;
+    forwardWarning(warning, ...rest);
+  });
+  try {
+    return run();
+  } finally {
+    process.emitWarning = originalEmitWarning;
+  }
+}
+
+export {
+  withSqliteExperimentalWarningSuppressed
+};
+//# sourceMappingURL=chunk-LX5QWLBL.js.map