@wrongstack/core 0.280.1 → 0.281.0

package/dist/{mcp-servers-D910X5_r.d.ts → mcp-servers-EKRAcJDi.d.ts}

@@ -1,6 +1,7 @@
-import { C as Compactor } from './compactor-U3agvUIG.js';
-import { M as Message, T as Tool } from './tool-BkOgs_KL.js';
-import { c as MCPServerConfig } from './config-Cr3312zc.js';
+import { C as Compactor } from './compactor-BxddyCFu.js';
+import { M as Message, g as Tool } from './tool-LVSLiE1s.js';
+import { L as Logger, a as LogLevel } from './logger-B63L5bTg.js';
+import { b as MCPServerConfig } from './config-CN-vdDEI.js';
 
 type ContextManagerAction = 'check' | 'summary' | 'prune' | 'add_note' | 'compact' | 'repair';
 interface ContextManagerInput {
@@ -81,6 +82,98 @@ declare function createContextManagerTool(opts?: ContextManagerToolOptions): Too
 /** Pre-built instance with no compactor — compact action will return an error. */
 declare const contextManagerTool: Tool<ContextManagerInput, ContextManagerResult>;
 
+type LogFormat = 'pretty' | 'json';
+interface DefaultLoggerOptions {
+    level?: LogLevel | undefined;
+    file?: string | undefined;
+    /**
+     * @deprecated Use `format: 'json'` instead. Kept for backward compat
+     * with existing callers but has no effect on output — the `format`
+     * option controls whether stderr receives pretty-printed or JSON lines.
+     */
+    pretty?: boolean | undefined;
+    /** Output format for stderr. `pretty` (colored, human-readable) or `json` (machine-parseable). Defaults to `WRONGSTACK_LOG_FORMAT` env var, falling back to `pretty`. */
+    format?: LogFormat | undefined;
+    bindings?: Record<string, unknown>;
+    /**
+     * When false, suppress stderr output entirely — only write to the log
+     * file (if configured). Use this in TUI mode so plugin/library log
+     * messages don't interleave with Ink's terminal rendering.
+     * Default: true (stderr output is enabled).
+     */
+    stderr?: boolean | undefined;
+    /**
+     * Rotate the log file once it exceeds this many bytes: the current file is
+     * renamed to `<file>.1` (replacing any previous one) and a fresh file
+     * starts. Bounds total disk to ~2× this value. Default 10 MB.
+     */
+    maxFileBytes?: number | undefined;
+}
+declare class DefaultLogger implements Logger {
+    /** How many file writes between rotation size checks (statSync is not free). */
+    private static readonly ROTATE_CHECK_EVERY;
+    level: LogLevel;
+    private file?;
+    private bindings;
+    private format;
+    private stderr;
+    private maxFileBytes;
+    private writesSinceRotateCheck;
+    /**
+     * Serialized async tail for file writes. Every appendFile (and any
+     * chained rotation) is awaited through this promise so file I/O
+     * never overlaps itself — preserving the per-line ordering the
+     * sync version had, but without blocking the caller thread. Any
+     * rejection is swallowed (`catch(() => {})`) because logging must
+     * never crash the host.
+     *
+     * Children share the parent's tail: `child.tail === parent.tail`
+     * for the lifetime of the chain. Read/write access goes through
+     * `_tail` so that, when a child has been wired to a parent, both
+     * `enqueueRotate` and `log` always observe the parent's current tail
+     * rather than a stale snapshot taken at `child()` time.
+     */
+    private tail;
+    private parent;
+    /**
+     * Resolve the current tail. For the root logger this is the field;
+     * for a child logger we always read through the parent so that a
+     * child's appends land on the parent's most recent tail, and a
+     * parent's `flush()` waits for everything the child chained.
+     */
+    private get _tail();
+    private set _tail(value);
+    constructor(opts?: DefaultLoggerOptions);
+    error(msg: string, ctx?: unknown): void;
+    warn(msg: string, ctx?: unknown): void;
+    info(msg: string, ctx?: unknown): void;
+    debug(msg: string, ctx?: unknown): void;
+    trace(msg: string, ctx?: unknown): void;
+    child(bindings: Record<string, unknown>): Logger;
+    /**
+     * Wait until all queued file writes (and any pending rotation) have
+     * completed. `log()` is fire-and-forget by design — the caller never
+     * blocks on disk — so tests, shutdown handlers, and processes that
+     * need a deterministic "everything is on disk now" guarantee should
+     * `await logger.flush()` before reading the file or exiting.
+     */
+    flush(): Promise<void>;
+    /**
+     * Size-based rotation: when the file outgrows `maxFileBytes`, rename it to
+     * `<file>.1` (dropping the previous `.1`) so the live file restarts empty.
+     * Checked on the first write and every ROTATE_CHECK_EVERY writes after.
+     * Best-effort: a rename can fail on Windows while another process holds
+     * the file — the next check retries. Multiple processes appending to the
+     * same log all run this check; whoever crosses the threshold first wins.
+     *
+     * Async: the rotation runs on the file-write tail (so its writes don't
+     * interleave with the next append), and the caller never blocks on a
+     * statSync / renameSync syscall on the hot log path.
+     */
+    private enqueueRotate;
+    private log;
+}
+
 /**
  * Built-in MCP server presets available to all WrongStack users out of the box.
  * These servers must be explicitly enabled in config (disabled by default).
@@ -163,4 +256,4 @@ declare const sshManagerServer: () => MCPServerConfig;
 /** Everything bundled — full set of built-in servers. Useful for `wstack mcp add --all`. */
 declare const allServers: () => Record<string, MCPServerConfig>;
 
-export { type ContextManagerAction as C, type ContextManagerInput as a, type ContextManagerResult as b, type ContextManagerToolOptions as c, allServers as d, awsServer as e, blockServer as f, braveSearchServer as g, context7Server as h, contextManagerTool as i, createContextManagerTool as j, everArtServer as k, filesystemServer as l, githubServer as m, googleMapsServer as n, miniMaxVisionServer as o, playwrightServer as p, slackServer as q, sshManagerServer as r, sentinelServer as s, zaiVisionServer as z };
+export { type ContextManagerAction as C, DefaultLogger as D, type LogFormat as L, type ContextManagerInput as a, type ContextManagerResult as b, type ContextManagerToolOptions as c, type DefaultLoggerOptions as d, allServers as e, awsServer as f, blockServer as g, braveSearchServer as h, context7Server as i, contextManagerTool as j, createContextManagerTool as k, everArtServer as l, filesystemServer as m, githubServer as n, googleMapsServer as o, miniMaxVisionServer as p, playwrightServer as q, slackServer as r, sentinelServer as s, sshManagerServer as t, zaiVisionServer as z };

package/dist/models/index.d.ts

@@ -1,8 +1,7 @@
-export { D as DefaultModelsRegistry, a as DefaultModelsRegistryOptions, c as classifyFamily } from '../models-registry-CLkoOcHk.js';
-export { C as CODEX_MODELS, a as CodexModelMeta, D as DefaultModeStore, L as LLMSelector, b as LLMSelectorOptions, M as ModeLoaderOptions, P as ProviderModelDescriptor, c as codexModelMeta, d as describeCatalogModel, l as loadProjectModes, e as loadUserModes, r as resolveProviderModelList } from '../provider-model-resolve-CwQNZWt_.js';
-import { d as ModelMatrixEntry, P as ProviderConfig } from '../config-Cr3312zc.js';
-import '../tool-BkOgs_KL.js';
-import '../selector-Dy-MzKp1.js';
+export { C as CODEX_MODELS, a as CodexModelMeta, D as DefaultModeStore, b as DefaultModelsRegistry, c as DefaultModelsRegistryOptions, L as LLMSelector, d as LLMSelectorOptions, M as ModeLoaderOptions, P as ProviderModelDescriptor, e as classifyFamily, f as codexModelMeta, g as describeCatalogModel, l as loadProjectModes, h as loadUserModes, r as resolveProviderModelList } from '../provider-model-resolve-KgIdiEQ6.js';
+import { a as ModelMatrixEntry, P as ProviderConfig } from '../config-CN-vdDEI.js';
+import '../tool-LVSLiE1s.js';
+import '../selector-Bx2HgUkU.js';
 import '../mode-CZlO9iU1.js';
 
 /**

package/dist/models/index.js

@@ -833,23 +833,32 @@ async function loadUserModes(modesDir) {
 function isTextBlock(b) {
   return b.type === "text";
 }
+var textCache = /* @__PURE__ */ new Map();
+var rootCandidates;
 function readBundledInstructionText(relativePath) {
+  const cached = textCache.get(relativePath);
+  if (cached !== void 0) return cached;
+  let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
-      return readFileSync(path4.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync(path4.join(root, relativePath), "utf8").trimEnd();
+      break;
     } catch {
     }
   }
-  return "";
+  textCache.set(relativePath, resolved);
+  return resolved;
 }
 function instructionRootCandidates() {
+  if (rootCandidates !== void 0) return rootCandidates;
   const here = path4.dirname(fileURLToPath(import.meta.url));
   const candidates = [
     path4.resolve(here, "../../instructions"),
     path4.resolve(here, "../instructions"),
     path4.resolve(here, "instructions")
   ];
-  return candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
+  rootCandidates = candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
+  return rootCandidates;
 }
 function isDirectory2(candidate) {
   try {
@@ -1076,7 +1085,7 @@ function describeCatalogModel(m) {
     ]
   };
 }
-function resolveProviderModelList(savedModels, catalog) {
+function resolveProviderModelList(savedModels, catalog, providerHint) {
   if (savedModels && savedModels.length > 0) {
     const byId = new Map((catalog?.models ?? []).map((m) => [m.id, m]));
     return savedModels.map((id) => {
@@ -1092,7 +1101,15 @@ function resolveProviderModelList(savedModels, catalog) {
       return { id, name: id, capabilities: [] };
     });
   }
-  if (catalog) return catalog.models.map(describeCatalogModel);
+  if (catalog && catalog.models.length > 0) return catalog.models.map(describeCatalogModel);
+  if (providerHint === "openai-codex") {
+    return CODEX_MODELS.map((m) => ({
+      id: m.id,
+      name: m.name,
+      description: m.description,
+      capabilities: []
+    }));
+  }
   return [];
 }