@wrongstack/core 0.1.8 → 0.1.10

package/dist/infrastructure/index.d.ts

@@ -0,0 +1,10 @@
+export { D as DefaultLogger, a as DefaultLoggerOptions } from '../logger-BH6AE0W9.js';
+export { D as DefaultPathResolver, a as DefaultTokenCounter } from '../path-resolver-DBjaoXFq.js';
+export { C as ContextManagerAction, a as ContextManagerInput, b as ContextManagerResult, c as ContextManagerToolOptions, d as allServers, e as awsServer, f as blockServer, g as braveSearchServer, h as context7Server, i as contextManagerTool, j as createContextManagerTool, k as everArtServer, l as filesystemServer, m as githubServer, n as googleMapsServer, s as sentinelServer, o as slackServer } from '../mcp-servers-Dzgg4x1w.js';
+import '../logger-BMQgxvdy.js';
+import '../events-BMNaEFZl.js';
+import '../context-BmM2xGUZ.js';
+import '../models-registry-Y2xbog0E.js';
+import '../path-resolver-CPRj4bFY.js';
+import '../compactor-B4mQZXf2.js';
+import '../config-BU9f_5yH.js';

package/dist/infrastructure/index.js

@@ -0,0 +1,575 @@
+import * as fs from 'fs';
+import * as path2 from 'path';
+
+// src/infrastructure/logger.ts
+
+// src/utils/color.ts
+var isColorTty = () => {
+  if (process.env.NO_COLOR) return false;
+  if (process.env.FORCE_COLOR) return true;
+  return Boolean(process.stdout?.isTTY);
+};
+var COLOR = isColorTty();
+var wrap = (open, close) => (s) => COLOR ? `\x1B[${open}m${s}\x1B[${close}m` : s;
+var color = {
+  reset: wrap("0", "0"),
+  bold: wrap("1", "22"),
+  dim: wrap("2", "22"),
+  italic: wrap("3", "23"),
+  underline: wrap("4", "24"),
+  red: wrap("31", "39"),
+  green: wrap("32", "39"),
+  yellow: wrap("33", "39"),
+  blue: wrap("34", "39"),
+  magenta: wrap("35", "39"),
+  cyan: wrap("36", "39"),
+  gray: wrap("90", "39"),
+  amber: wrap("38;5;214", "39"),
+  pink: wrap("38;5;205", "39"),
+  bgRed: wrap("41", "49"),
+  bgGreen: wrap("42", "49")
+};
+
+// src/infrastructure/logger.ts
+var LEVEL_RANK = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+var COLORS = {
+  error: color.red,
+  warn: color.yellow,
+  info: color.cyan,
+  debug: color.gray,
+  trace: color.dim
+};
+var DefaultLogger = class _DefaultLogger {
+  level;
+  file;
+  bindings;
+  pretty;
+  constructor(opts = {}) {
+    this.level = opts.level ?? process.env.WRONGSTACK_LOG_LEVEL ?? "info";
+    this.file = opts.file;
+    this.bindings = opts.bindings ?? {};
+    this.pretty = opts.pretty ?? true;
+    if (this.file) {
+      try {
+        fs.mkdirSync(path2.dirname(this.file), { recursive: true });
+      } catch {
+      }
+    }
+  }
+  error(msg, ctx) {
+    this.log("error", msg, ctx);
+  }
+  warn(msg, ctx) {
+    this.log("warn", msg, ctx);
+  }
+  info(msg, ctx) {
+    this.log("info", msg, ctx);
+  }
+  debug(msg, ctx) {
+    this.log("debug", msg, ctx);
+  }
+  trace(msg, ctx) {
+    this.log("trace", msg, ctx);
+  }
+  child(bindings) {
+    return new _DefaultLogger({
+      level: this.level,
+      file: this.file,
+      pretty: this.pretty,
+      bindings: { ...this.bindings, ...bindings }
+    });
+  }
+  log(level, msg, ctx) {
+    const r = LEVEL_RANK[level];
+    const allowed = LEVEL_RANK[this.level];
+    if (r > allowed) return;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = { ts, level, msg, ...this.bindings };
+    if (ctx !== void 0) {
+      entry.ctx = ctx instanceof Error ? { message: ctx.message, stack: ctx.stack } : ctx;
+    }
+    if (this.file) {
+      try {
+        fs.appendFileSync(this.file, `${JSON.stringify(entry)}
+`);
+      } catch {
+      }
+    }
+    if (r <= LEVEL_RANK.warn || this.level === "debug" || this.level === "trace") {
+      const head = `${color.dim(ts)} ${COLORS[level](level.toUpperCase().padEnd(5))} ${msg}`;
+      if (ctx !== void 0) {
+        process.stderr.write(`${head} ${formatCtx(ctx)}
+`);
+      } else {
+        process.stderr.write(`${head}
+`);
+      }
+    }
+  }
+};
+function formatCtx(ctx) {
+  if (ctx instanceof Error) return color.dim(ctx.message);
+  if (typeof ctx === "string") return color.dim(ctx);
+  try {
+    return color.dim(JSON.stringify(ctx));
+  } catch {
+    return color.dim(String(ctx));
+  }
+}
+var PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "pnpm-workspace.yaml",
+  "go.mod",
+  "Cargo.toml",
+  "pyproject.toml",
+  ".wrongstack"
+];
+var DefaultPathResolver = class {
+  projectRoot;
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = path2.resolve(cwd);
+    this.projectRoot = this.detectProjectRoot(this.cwd);
+  }
+  detectProjectRoot(start) {
+    let dir = path2.resolve(start);
+    const root = path2.parse(dir).root;
+    while (dir !== root) {
+      for (const marker of PROJECT_MARKERS) {
+        try {
+          fs.accessSync(path2.join(dir, marker));
+          return dir;
+        } catch {
+        }
+      }
+      const parent = path2.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    return path2.resolve(start);
+  }
+  resolve(input) {
+    const abs = path2.isAbsolute(input) ? input : path2.resolve(this.cwd, input);
+    let real;
+    try {
+      real = fs.realpathSync(abs);
+    } catch {
+      real = path2.normalize(abs);
+    }
+    return real;
+  }
+  isInsideRoot(absPath) {
+    const normalized = path2.normalize(absPath);
+    const root = path2.normalize(this.projectRoot);
+    if (normalized === root) return true;
+    const rel = path2.relative(root, normalized);
+    return !rel.startsWith("..") && !path2.isAbsolute(rel);
+  }
+  ensureInsideRoot(absPath) {
+    const resolved = this.resolve(absPath);
+    if (!this.isInsideRoot(resolved)) {
+      const display = path2.isAbsolute(absPath) ? path2.basename(absPath) : absPath;
+      const err = new Error(`Path "${display}" resolves outside the project root`);
+      err.fullPath = absPath;
+      err.projectRoot = this.projectRoot;
+      throw err;
+    }
+    return resolved;
+  }
+};
+
+// src/infrastructure/token-counter.ts
+var DefaultTokenCounter = class {
+  input = 0;
+  output = 0;
+  cacheRead = 0;
+  cacheWrite = 0;
+  costInput = 0;
+  costOutput = 0;
+  registry;
+  providerId;
+  events;
+  priceCache = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.registry = opts.registry;
+    this.providerId = opts.providerId;
+    this.events = opts.events;
+  }
+  account(usage, model) {
+    this.input += usage.input;
+    this.output += usage.output;
+    this.cacheRead += usage.cacheRead ?? 0;
+    this.cacheWrite += usage.cacheWrite ?? 0;
+    const price = model ? this.priceCache.get(model) : void 0;
+    if (price) {
+      this.applyPrice(usage, price);
+    } else if (this.registry && this.providerId && model) {
+      void this.registry.getModel(this.providerId, model).then((m) => {
+        if (m) {
+          const p = priceFromModel(m);
+          this.priceCache.set(model, p);
+          this.applyPrice(usage, p);
+        }
+      }).catch(() => {
+        this.events?.emit("token.cost_estimate_unavailable", { model: model ?? "<unknown>" });
+        return void 0;
+      });
+    }
+  }
+  /** Synchronous variant for code paths that have already resolved the model. */
+  accountWithModel(usage, resolved) {
+    this.input += usage.input;
+    this.output += usage.output;
+    this.cacheRead += usage.cacheRead ?? 0;
+    this.cacheWrite += usage.cacheWrite ?? 0;
+    const price = priceFromModel(resolved);
+    this.priceCache.set(resolved.modelId, price);
+    this.applyPrice(usage, price);
+  }
+  total() {
+    return {
+      input: this.input,
+      output: this.output,
+      cacheRead: this.cacheRead,
+      cacheWrite: this.cacheWrite
+    };
+  }
+  estimateCost() {
+    return {
+      input: round4(this.costInput),
+      output: round4(this.costOutput),
+      total: round4(this.costInput + this.costOutput),
+      currency: "USD"
+    };
+  }
+  cacheStats() {
+    const denom = this.cacheRead + this.input;
+    return {
+      readTokens: this.cacheRead,
+      writeTokens: this.cacheWrite,
+      hitRatio: denom === 0 ? 0 : this.cacheRead / denom
+    };
+  }
+  /** Invalidate cached prices so the next account() call fetches fresh data. */
+  invalidateCache() {
+    this.priceCache.clear();
+  }
+  reset() {
+    this.input = 0;
+    this.output = 0;
+    this.cacheRead = 0;
+    this.cacheWrite = 0;
+    this.costInput = 0;
+    this.costOutput = 0;
+  }
+  applyPrice(usage, price) {
+    if (price.input) this.costInput += usage.input / 1e6 * price.input;
+    if (price.output) this.costOutput += usage.output / 1e6 * price.output;
+    if (usage.cacheRead && price.cacheRead) {
+      this.costInput += usage.cacheRead / 1e6 * price.cacheRead;
+    }
+    if (usage.cacheWrite && price.cacheWrite) {
+      this.costInput += usage.cacheWrite / 1e6 * price.cacheWrite;
+    }
+  }
+};
+function priceFromModel(m) {
+  return {
+    input: m.cost?.input,
+    output: m.cost?.output,
+    cacheRead: m.cost?.cache_read,
+    cacheWrite: m.cost?.cache_write
+  };
+}
+function round4(n) {
+  return Math.round(n * 1e4) / 1e4;
+}
+
+// src/infrastructure/mcp-servers.ts
+var filesystemServer = () => ({
+  name: "filesystem",
+  description: "Read, write, and navigate the local filesystem (read-heavy tools)",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
+  permission: "confirm"
+});
+var githubServer = () => ({
+  name: "github",
+  description: "GitHub API \u2014 issues, PRs, repos, search, file ops (requires GITHUB_PERSONAL_ACCESS_TOKEN)",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-github"],
+  env: { GITHUB_PERSONAL_ACCESS_TOKEN: process.env.GITHUB_PERSONAL_ACCESS_TOKEN ?? "" },
+  permission: "confirm"
+});
+var context7Server = () => ({
+  name: "context7",
+  description: "Codebase-aware documentation and Q&A (context7.ai)",
+  transport: "streamable-http",
+  url: "https://server.context7.ai/mcp",
+  permission: "confirm"
+});
+var braveSearchServer = () => ({
+  name: "brave-search",
+  description: "Web search (Brave). Requires BRAVE_SEARCH_API_KEY \u2014 free tier 2k queries/month",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-brave-search"],
+  env: { BRAVE_SEARCH_API_KEY: process.env.BRAVE_SEARCH_API_KEY ?? "" },
+  permission: "confirm"
+});
+var blockServer = () => ({
+  name: "block",
+  description: "Postgres database access via SQL (Block MCP server)",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-block"],
+  permission: "confirm"
+});
+var everArtServer = () => ({
+  name: "everart",
+  description: "AI image generation (EverArt). Requires EVERART_API_KEY",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-everart"],
+  env: { EVERART_API_KEY: process.env.EVERART_API_KEY ?? "" },
+  permission: "confirm"
+});
+var slackServer = () => ({
+  name: "slack",
+  description: "Slack \u2014 messaging, channels, search. Requires SLACK_BOT_TOKEN + SLACK_TEAM_ID",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-slack"],
+  env: {
+    SLACK_BOT_TOKEN: process.env.SLACK_BOT_TOKEN ?? "",
+    SLACK_TEAM_ID: process.env.SLACK_TEAM_ID ?? ""
+  },
+  permission: "confirm"
+});
+var awsServer = () => ({
+  name: "aws",
+  description: "AWS \u2014 EC2, S3, Lambda, IAM, CloudFormation, costs. Requires AWS credentials",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-aws"],
+  permission: "confirm"
+});
+var googleMapsServer = () => ({
+  name: "google-maps",
+  description: "Google Maps \u2014 directions, geocoding, places. Requires GOOGLE_MAPS_API_KEY",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-google-maps"],
+  env: { GOOGLE_MAPS_API_KEY: process.env.GOOGLE_MAPS_API_KEY ?? "" },
+  permission: "confirm"
+});
+var sentinelServer = () => ({
+  name: "sentinel",
+  description: "Security vulnerability scanning (Sentinel)",
+  transport: "streamable-http",
+  url: "https://mcp.sentinel.ai",
+  permission: "deny"
+  // security tool — require explicit confirmation
+});
+var allServers = () => ({
+  filesystem: { ...filesystemServer(), enabled: false },
+  github: { ...githubServer(), enabled: false },
+  context7: { ...context7Server(), enabled: false },
+  "brave-search": { ...braveSearchServer(), enabled: false },
+  block: { ...blockServer(), enabled: false },
+  everart: { ...everArtServer(), enabled: false },
+  slack: { ...slackServer(), enabled: false },
+  aws: { ...awsServer(), enabled: false },
+  "google-maps": { ...googleMapsServer(), enabled: false },
+  sentinel: { ...sentinelServer(), enabled: false }
+});
+
+// src/infrastructure/context-manager.ts
+var CONTEXT_MANAGER_TOOL_NAME = "context_manager";
+function roughEstimate(messages) {
+  let total = 0;
+  for (const m of messages) {
+    if (typeof m.content === "string") {
+      total += Math.ceil(m.content.length / 4);
+    } else if (Array.isArray(m.content)) {
+      for (const b of m.content) {
+        if (b.type === "text") total += Math.ceil(b.text.length / 4);
+        else if (b.type === "tool_use" || b.type === "tool_result") {
+          total += Math.ceil(JSON.stringify(b).length / 4);
+        }
+      }
+    }
+  }
+  return total;
+}
+function createContextManagerTool(opts = {}) {
+  return {
+    name: CONTEXT_MANAGER_TOOL_NAME,
+    description: 'Inspect or reorganize the conversation context window. Use "check" to see token budget. Use "summary" to collapse a message range into a concise note (provide "text" for custom summary). Use "prune" to remove specific messages by index. Use "add_note" to inject a summary note. Use "compact" to run aggressive compaction.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["check", "summary", "prune", "add_note", "compact"],
+          description: "The context operation to perform."
+        },
+        from: {
+          type: "number",
+          description: "Start index (inclusive) for summary/prune operations."
+        },
+        to: {
+          type: "number",
+          description: "End index (inclusive) for summary/prune operations."
+        },
+        text: {
+          type: "string",
+          description: 'Summary or note text. For "summary": the model-provided summary of the removed range. For "add_note": the note to inject.'
+        },
+        afterIndex: {
+          type: "number",
+          description: "Insert after this index (for add_note). Defaults to prepend (0)."
+        }
+      },
+      required: ["action"]
+    },
+    permission: "auto",
+    mutating: true,
+    async execute(input, ctx) {
+      const messages = ctx.messages;
+      const beforeTokens = roughEstimate(messages);
+      const applyMessages = (next) => {
+        if (ctx.state) {
+          ctx.state.replaceMessages(next);
+        } else {
+          messages.length = 0;
+          messages.splice(0, 0, ...next);
+        }
+      };
+      switch (input.action) {
+        case "check": {
+          return {
+            action: "check",
+            beforeTokens,
+            messageCount: messages.length,
+            notes: JSON.stringify({
+              messages: messages.length,
+              tokens: beforeTokens,
+              readFiles: ctx.readFiles.size,
+              todos: ctx.todos.length,
+              inProgress: ctx.todos.filter((t) => t.status === "in_progress").length
+            })
+          };
+        }
+        case "compact": {
+          if (!opts.compactor) {
+            return {
+              action: "compact",
+              beforeTokens,
+              messageCount: messages.length,
+              notes: "No compactor registered. Use /compact aggressive via slash command instead."
+            };
+          }
+          const report = await opts.compactor.compact(ctx);
+          return {
+            action: "compact",
+            beforeTokens,
+            afterTokens: report.after,
+            messageCount: messages.length
+          };
+        }
+        case "prune": {
+          const from = input.from ?? 0;
+          const to = input.to ?? messages.length - 1;
+          if (from < 0 || to >= messages.length || from > to) {
+            return {
+              action: "prune",
+              beforeTokens,
+              messageCount: messages.length,
+              notes: `Invalid range [${from}, ${to}] for ${messages.length} messages.`
+            };
+          }
+          const copy = [...messages];
+          const removed = copy.splice(from, to - from + 1);
+          applyMessages(copy);
+          const afterTokens = roughEstimate(copy);
+          return {
+            action: "prune",
+            beforeTokens,
+            afterTokens,
+            messageCount: copy.length,
+            removedCount: removed.length
+          };
+        }
+        case "add_note": {
+          const noteText = input.text ?? "(no summary)";
+          const afterIdx = Math.min(input.afterIndex ?? 0, messages.length);
+          const noteMsg = {
+            role: "system",
+            content: `[note: ${noteText}]`
+          };
+          const copy = [...messages];
+          copy.splice(afterIdx, 0, noteMsg);
+          applyMessages(copy);
+          const afterTokens = roughEstimate(copy);
+          return {
+            action: "add_note",
+            beforeTokens,
+            afterTokens,
+            messageCount: copy.length,
+            summary: noteText
+          };
+        }
+        case "summary": {
+          const from = input.from ?? 0;
+          const to = input.to ?? messages.length - 1;
+          if (from < 0 || to >= messages.length || from > to) {
+            return {
+              action: "summary",
+              beforeTokens,
+              messageCount: messages.length,
+              notes: `Invalid range [${from}, ${to}] for ${messages.length} messages.`
+            };
+          }
+          const summaryText = input.text ?? '[summary placeholder \u2014 provide "text" to record the summary]';
+          const summaryMsg = {
+            role: "system",
+            content: `[summary of messages ${from}\u2013${to}]: ${summaryText}`
+          };
+          const copy = [...messages];
+          copy.splice(from, to - from + 1, summaryMsg);
+          applyMessages(copy);
+          const afterTokens = roughEstimate(copy);
+          return {
+            action: "summary",
+            beforeTokens,
+            afterTokens,
+            messageCount: copy.length,
+            summary: summaryText
+          };
+        }
+        default:
+          return {
+            action: input.action,
+            beforeTokens,
+            messageCount: messages.length,
+            notes: `Unknown action: ${input.action}`
+          };
+      }
+    }
+  };
+}
+var contextManagerTool = createContextManagerTool();
+
+export { DefaultLogger, DefaultPathResolver, DefaultTokenCounter, allServers, awsServer, blockServer, braveSearchServer, context7Server, contextManagerTool, createContextManagerTool, everArtServer, filesystemServer, githubServer, googleMapsServer, sentinelServer, slackServer };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map