@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-FXQLIX3K.js

@@ -0,0 +1,211 @@
+// 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"],
+  passthroughEnv: ["GITHUB_PERSONAL_ACCESS_TOKEN", "GITHUB_TOKEN"],
+  permission: "confirm"
+});
+var context7Server = () => ({
+  name: "context7",
+  description: "Codebase-aware documentation and Q&A (context7.ai)",
+  transport: "streamable-http",
+  url: "https://mcp.context7.com/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"],
+  passthroughEnv: ["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"],
+  passthroughEnv: ["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"],
+  passthroughEnv: ["SLACK_BOT_TOKEN", "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"],
+  passthroughEnv: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION", "AWS_SESSION_TOKEN"],
+  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"],
+  passthroughEnv: ["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 zaiVisionServer = () => ({
+  name: "zai-vision",
+  description: "Z.AI Vision MCP \u2014 image analysis and screenshot understanding",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@z_ai/mcp-server@latest"],
+  env: { Z_AI_MODE: "ZAI" },
+  passthroughEnv: ["Z_AI_API_KEY"],
+  allowedTools: [
+    "image_analysis",
+    "extract_text_from_screenshot",
+    "diagnose_error_screenshot",
+    "understand_technical_diagram",
+    "analyze_data_visualization",
+    "ui_diff_check"
+  ],
+  permission: "auto"
+});
+var playwrightServer = () => ({
+  name: "playwright",
+  description: "Browser automation \u2014 navigate, screenshot, click, type, evaluate JS (headless Chromium)",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-playwright"],
+  permission: "confirm"
+});
+var miniMaxVisionServer = () => ({
+  name: "minimax-vision",
+  description: "MiniMax MCP \u2014 image understanding via understand_image",
+  transport: "stdio",
+  command: "uvx",
+  args: ["minimax-coding-plan-mcp", "-y"],
+  env: {
+    MINIMAX_MCP_BASE_PATH: "./.wrongstack/minimax-output",
+    MINIMAX_API_HOST: "https://api.minimax.io",
+    MINIMAX_API_RESOURCE_MODE: "url"
+  },
+  passthroughEnv: ["MINIMAX_API_KEY"],
+  allowedTools: ["understand_image"],
+  permission: "auto"
+});
+var sshManagerServer = () => ({
+  name: "ssh",
+  description: "Remote SSH management \u2014 execute commands, transfer files, tunnels, health checks (mcp-ssh-manager)",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "mcp-ssh-manager"],
+  env: {
+    MCP_SSH_COMPACT_JSON: "true",
+    MCP_SSH_DEFAULT_TIMEOUT: "120000"
+  },
+  permission: "confirm",
+  requestTimeoutMs: 18e4
+});
+var requirementIntakeServer = () => ({
+  name: "requirement-intake",
+  description: "WrongStack Requirements Intake \u2014 list intake records and file new ones (project-scoped, --writable)",
+  transport: "stdio",
+  command: "wstack-requirement-intake-mcp",
+  args: ["--project-root", ".", "--writable"],
+  permission: "auto"
+});
+var kanbanServer = () => ({
+  name: "kanban",
+  description: "WrongStack Kanban \u2014 inspect and manage project work boards (project-scoped, manage tier, no destructive ops)",
+  transport: "stdio",
+  command: "wstack-kanban-mcp",
+  args: ["--project-root", ".", "--writable"],
+  permission: "confirm"
+});
+var mailboxServer = () => ({
+  name: "mailbox",
+  description: "WrongStack Mailbox \u2014 read and send project agent mail (project-scoped, no admin/credentials)",
+  transport: "stdio",
+  command: "wstack-mailbox-mcp",
+  args: ["--project-root", ".", "--actor", "external-agent", "--writable"],
+  permission: "auto"
+});
+var codebaseIndexServer = () => ({
+  name: "codebase-index",
+  description: "WrongStack Codebase Index \u2014 symbol search and dependency graphs (project-scoped, --writable)",
+  transport: "stdio",
+  command: "wstack-codebase-index-mcp",
+  args: ["--project-root", ".", "--writable"],
+  permission: "auto"
+});
+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 },
+  "zai-vision": { ...zaiVisionServer(), enabled: false },
+  "minimax-vision": { ...miniMaxVisionServer(), enabled: false },
+  playwright: { ...playwrightServer(), enabled: false },
+  ssh: { ...sshManagerServer(), enabled: false },
+  kanban: { ...kanbanServer(), enabled: false },
+  mailbox: { ...mailboxServer(), enabled: false },
+  "codebase-index": { ...codebaseIndexServer(), enabled: false },
+  "requirement-intake": { ...requirementIntakeServer(), enabled: false }
+});
+
+export {
+  filesystemServer,
+  githubServer,
+  context7Server,
+  braveSearchServer,
+  blockServer,
+  everArtServer,
+  slackServer,
+  awsServer,
+  googleMapsServer,
+  sentinelServer,
+  zaiVisionServer,
+  playwrightServer,
+  miniMaxVisionServer,
+  sshManagerServer,
+  allServers
+};
+//# sourceMappingURL=chunk-FXQLIX3K.js.map

package/dist/chunk-G5AAKEEZ.js

@@ -0,0 +1,228 @@
+import {
+  ERROR_CODES,
+  WrongStackError
+} from "./chunk-WOEZV3Q4.js";
+import {
+  expectDefined
+} from "./chunk-PFZO3C6H.js";
+
+// src/extension/registry.ts
+var ExtensionRegistry = class {
+  extensions = [];
+  promptContributors = [];
+  log;
+  setLogger(log) {
+    this.log = log;
+  }
+  /**
+   * Register a system prompt contributor. Returns an unregister function.
+   * Contributors are called on every system prompt build in registration
+   * order. Their output blocks are inserted after the core environment
+   * block, before the mode and plan blocks.
+   */
+  registerSystemPromptContributor(c) {
+    this.promptContributors.push(c);
+    return () => {
+      const idx = this.promptContributors.indexOf(c);
+      if (idx >= 0) this.promptContributors.splice(idx, 1);
+    };
+  }
+  /**
+   * Build all registered system prompt contributions.
+   * Failures are caught and logged — one bad contributor doesn't
+   * break the prompt assembly.
+   */
+  async buildSystemPromptContributions(ctx) {
+    const blocks = [];
+    const snapshot = [...this.promptContributors];
+    for (const c of snapshot) {
+      try {
+        const contributed = await c(ctx);
+        blocks.push(...contributed);
+      } catch (err) {
+        this.log?.error("SystemPromptContributor failed", err);
+      }
+    }
+    return blocks;
+  }
+  /**
+   * Returns the live array of contributors (readonly snapshot for
+   * passing to DefaultSystemPromptBuilder at build time).
+   */
+  listSystemPromptContributors() {
+    return this.promptContributors;
+  }
+  /**
+   * Register an extension. Duplicate names are rejected.
+   * Returns an unregister function.
+   */
+  register(ext) {
+    if (this.extensions.some((e) => e.name === ext.name)) {
+      throw new WrongStackError({
+        message: `Extension "${ext.name}" already registered`,
+        code: ERROR_CODES.REGISTRY_DUPLICATE,
+        subsystem: "container",
+        context: { extension: ext.name }
+      });
+    }
+    this.extensions.push(ext);
+    return () => this.unregister(ext.name);
+  }
+  /**
+   * Register an extension, silently replacing any previous registration
+   * with the same name. Use this when overriding a default extension.
+   */
+  registerOrReplace(ext) {
+    const idx = this.extensions.findIndex((e) => e.name === ext.name);
+    if (idx >= 0) this.extensions.splice(idx, 1);
+    return this.register(ext);
+  }
+  /**
+   * Unregister an extension by name. Returns true if found.
+   */
+  unregister(name) {
+    const idx = this.extensions.findIndex((e) => e.name === name);
+    if (idx === -1) return false;
+    this.extensions.splice(idx, 1);
+    return true;
+  }
+  /**
+   * List registered extension names in order.
+   */
+  list() {
+    return this.extensions.map((e) => e.name);
+  }
+  /**
+   * Check if an extension with the given name is registered.
+   */
+  has(name) {
+    return this.extensions.some((e) => e.name === name);
+  }
+  /**
+   * Remove all registered extensions and contributors.
+   */
+  clear() {
+    this.extensions.length = 0;
+    this.promptContributors.length = 0;
+  }
+  // ── Hook runners ─────────────────────────────────────────────────
+  async runBeforeRun(...args) {
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.beforeRun) continue;
+      try {
+        await ext.beforeRun(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" beforeRun hook failed`, err);
+      }
+    }
+  }
+  async runAfterRun(...args) {
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.afterRun) continue;
+      try {
+        await ext.afterRun(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" afterRun hook failed`, err);
+      }
+    }
+  }
+  async runBeforeIteration(...args) {
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.beforeIteration) continue;
+      try {
+        await ext.beforeIteration(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" beforeIteration hook failed`, err);
+      }
+    }
+  }
+  async runAfterIteration(...args) {
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.afterIteration) continue;
+      try {
+        await ext.afterIteration(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" afterIteration hook failed`, err);
+      }
+    }
+  }
+  /**
+   * Run onError hooks in order. The first hook that returns a non-void
+   * result wins; subsequent hooks are skipped.
+   */
+  async runOnError(...args) {
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.onError) continue;
+      try {
+        const result = await ext.onError(...args);
+        if (result) return result;
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" onError hook failed`, err);
+      }
+    }
+  }
+  /**
+   * Build a composed provider runner. Extensions with `wrapProviderRunner`
+   * form a middleware-style chain: the innermost extension wraps the
+   * default runner, each subsequent wrapper wraps the previous.
+   *
+   * Utility calls may exclude agent-loop-only middleware (notably
+   * `fallback-model`) while retaining request-safety wrappers such as the
+   * prompt firewall. One-shot orchestration owns its provider and fallback
+   * route, so an agent-loop fallback wrapper cannot safely run against it.
+   */
+  wrapProviderRunner(inner, options) {
+    const excluded = new Set(options?.exclude);
+    const wrappers = this.extensions.filter((e) => e.wrapProviderRunner && !excluded.has(e.name)).map((e) => ({ name: e.name, wrap: expectDefined(e.wrapProviderRunner) }));
+    if (wrappers.length === 0) return inner;
+    let composed = inner;
+    for (let i = wrappers.length - 1; i >= 0; i--) {
+      const wrapper = wrappers[i];
+      if (!wrapper) continue;
+      const next = composed;
+      composed = async (ctx, req) => {
+        try {
+          return await wrapper.wrap(ctx, req, next);
+        } catch (err) {
+          this.log?.error(`Extension "${wrapper.name}" wrapProviderRunner failed`, err);
+          throw err;
+        }
+      };
+    }
+    return composed;
+  }
+  async runBeforeToolExecution(...args) {
+    let toolUses = args[1];
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.beforeToolExecution) continue;
+      try {
+        toolUses = await ext.beforeToolExecution(args[0], toolUses);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" beforeToolExecution hook failed`, err);
+      }
+    }
+    return toolUses;
+  }
+  async runAfterToolExecution(...args) {
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.afterToolExecution) continue;
+      try {
+        await ext.afterToolExecution(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" afterToolExecution hook failed`, err);
+      }
+    }
+  }
+};
+
+export {
+  ExtensionRegistry
+};
+//# sourceMappingURL=chunk-G5AAKEEZ.js.map

package/dist/chunk-G5S3S5ZN.js

@@ -0,0 +1,38 @@
+// src/types/design-kit.ts
+var DESIGN_STACKS = ["web", "react-native", "flutter", "swiftui", "compose"];
+function isDesignStack(v) {
+  return DESIGN_STACKS.includes(v);
+}
+var KNOWN_TOKEN_GROUPS = {
+  /** Corner radii. */
+  radius: ["radius-none", "radius-sm", "radius-md", "radius-lg", "radius-xl", "radius-full"],
+  /** Spacing scale (4/8px rhythm). */
+  space: ["space-1", "space-2", "space-3", "space-4", "space-6", "space-8", "space-12"],
+  /** Type sizes. */
+  text: ["text-xs", "text-sm", "text-base", "text-lg", "text-xl", "text-2xl", "text-3xl"],
+  /** Line-heights (unitless). */
+  leading: ["leading-tight", "leading-normal", "leading-relaxed"],
+  /** Font weights (unitless). */
+  weight: ["weight-normal", "weight-medium", "weight-semibold", "weight-bold"],
+  /** Letter-spacing. */
+  tracking: ["tracking-tight", "tracking-normal", "tracking-wide"],
+  /** Elevation / shadow ramp. */
+  shadow: ["shadow-1", "shadow-2", "shadow-3", "shadow-4"],
+  /** Border widths. */
+  border: ["border-hairline", "border-thin", "border-thick"],
+  /** Motion durations. */
+  duration: ["duration-fast", "duration-base", "duration-slow"],
+  /** Motion easings. */
+  ease: ["ease-standard", "ease-emphasized"],
+  /** Font families. */
+  font: ["font-sans", "font-mono", "font-display"]
+};
+var KNOWN_TOKEN_NAMES = Object.values(KNOWN_TOKEN_GROUPS).flat();
+
+export {
+  DESIGN_STACKS,
+  isDesignStack,
+  KNOWN_TOKEN_GROUPS,
+  KNOWN_TOKEN_NAMES
+};
+//# sourceMappingURL=chunk-G5S3S5ZN.js.map