@neurynae/toolcairn-mcp 0.8.4 → 0.8.6

package/dist/index.js

@@ -77,9 +77,442 @@ var require_dist = __commonJS({
   }
 });
 
+// ../../packages/errors/dist/error-codes.js
+var require_error_codes = __commonJS({
+  "../../packages/errors/dist/error-codes.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ErrorCode = void 0;
+    exports.ErrorCode = {
+      // ── Database ────────────────────────────────────────────────────────────────
+      ERR_DB_CONNECTION: "ERR_DB_CONNECTION",
+      ERR_DB_QUERY: "ERR_DB_QUERY",
+      ERR_DB_TIMEOUT: "ERR_DB_TIMEOUT",
+      ERR_DB_CONSTRAINT: "ERR_DB_CONSTRAINT",
+      ERR_DB_NOT_FOUND: "ERR_DB_NOT_FOUND",
+      // ── Validation ──────────────────────────────────────────────────────────────
+      ERR_VALIDATION_INPUT: "ERR_VALIDATION_INPUT",
+      ERR_VALIDATION_SCHEMA: "ERR_VALIDATION_SCHEMA",
+      // ── Auth ────────────────────────────────────────────────────────────────────
+      ERR_AUTH_TOKEN_EXPIRED: "ERR_AUTH_TOKEN_EXPIRED",
+      ERR_AUTH_UNAUTHORIZED: "ERR_AUTH_UNAUTHORIZED",
+      ERR_AUTH_FORBIDDEN: "ERR_AUTH_FORBIDDEN",
+      // ── External services ───────────────────────────────────────────────────────
+      ERR_EXTERNAL_GITHUB: "ERR_EXTERNAL_GITHUB",
+      ERR_EXTERNAL_NOMIC: "ERR_EXTERNAL_NOMIC",
+      ERR_EXTERNAL_QDRANT: "ERR_EXTERNAL_QDRANT",
+      ERR_EXTERNAL_MEMGRAPH: "ERR_EXTERNAL_MEMGRAPH",
+      ERR_EXTERNAL_RAZORPAY: "ERR_EXTERNAL_RAZORPAY",
+      // ── Queue ───────────────────────────────────────────────────────────────────
+      ERR_QUEUE_PUBLISH: "ERR_QUEUE_PUBLISH",
+      ERR_QUEUE_CONSUME: "ERR_QUEUE_CONSUME",
+      ERR_QUEUE_TIMEOUT: "ERR_QUEUE_TIMEOUT",
+      // ── Search ──────────────────────────────────────────────────────────────────
+      ERR_SEARCH_PIPELINE: "ERR_SEARCH_PIPELINE",
+      ERR_SEARCH_EMBEDDING: "ERR_SEARCH_EMBEDDING",
+      ERR_SEARCH_NO_RESULTS: "ERR_SEARCH_NO_RESULTS",
+      // ── Indexer ─────────────────────────────────────────────────────────────────
+      ERR_INDEXER_CRAWL: "ERR_INDEXER_CRAWL",
+      ERR_INDEXER_PROCESS: "ERR_INDEXER_PROCESS",
+      ERR_INDEXER_WRITE: "ERR_INDEXER_WRITE",
+      // ── Network ─────────────────────────────────────────────────────────────────
+      ERR_NETWORK_TIMEOUT: "ERR_NETWORK_TIMEOUT",
+      ERR_NETWORK_UNREACHABLE: "ERR_NETWORK_UNREACHABLE",
+      // ── MCP ─────────────────────────────────────────────────────────────────────
+      ERR_MCP_HANDLER: "ERR_MCP_HANDLER",
+      ERR_MCP_AUTH: "ERR_MCP_AUTH",
+      // ── Generic ─────────────────────────────────────────────────────────────────
+      ERR_INTERNAL: "ERR_INTERNAL",
+      ERR_NOT_FOUND: "ERR_NOT_FOUND",
+      ERR_RATE_LIMIT: "ERR_RATE_LIMIT"
+    };
+  }
+});
+
+// ../../packages/errors/dist/errors.js
+var require_errors = __commonJS({
+  "../../packages/errors/dist/errors.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.VectorError = exports.IndexerError = exports.SearchError = exports.QueueError = exports.ExternalServiceError = exports.AuthError = exports.ValidationError = exports.NetworkError = exports.DatabaseError = exports.AppError = void 0;
+    var error_codes_js_1 = require_error_codes();
+    var AppError = class extends Error {
+      code;
+      httpStatus;
+      severity;
+      isOperational;
+      context;
+      timestamp;
+      constructor(opts) {
+        super(opts.message, { cause: opts.cause });
+        this.name = this.constructor.name;
+        this.code = opts.code;
+        this.httpStatus = opts.httpStatus ?? 500;
+        this.severity = opts.severity ?? "medium";
+        this.isOperational = opts.isOperational ?? true;
+        this.context = opts.context ?? {};
+        this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        Object.setPrototypeOf(this, new.target.prototype);
+      }
+      /** Structured JSON representation used by the pino error serializer */
+      toJSON() {
+        return {
+          name: this.name,
+          code: this.code,
+          message: this.message,
+          httpStatus: this.httpStatus,
+          severity: this.severity,
+          isOperational: this.isOperational,
+          context: this.context,
+          timestamp: this.timestamp,
+          stack: this.stack,
+          cause: this.cause instanceof Error ? { name: this.cause.name, message: this.cause.message, stack: this.cause.stack } : this.cause
+        };
+      }
+    };
+    exports.AppError = AppError;
+    var DatabaseError = class extends AppError {
+      constructor(opts) {
+        super({
+          code: opts.code ?? error_codes_js_1.ErrorCode.ERR_DB_QUERY,
+          message: opts.message,
+          httpStatus: 503,
+          severity: "high",
+          isOperational: true,
+          cause: opts.cause,
+          context: opts.context
+        });
+      }
+    };
+    exports.DatabaseError = DatabaseError;
+    var NetworkError2 = class extends AppError {
+      constructor(opts) {
+        super({
+          code: opts.code ?? error_codes_js_1.ErrorCode.ERR_NETWORK_TIMEOUT,
+          message: opts.message,
+          httpStatus: 502,
+          severity: "high",
+          isOperational: true,
+          cause: opts.cause,
+          context: opts.context
+        });
+      }
+    };
+    exports.NetworkError = NetworkError2;
+    var ValidationError = class extends AppError {
+      constructor(opts) {
+        super({
+          code: opts.code ?? error_codes_js_1.ErrorCode.ERR_VALIDATION_INPUT,
+          message: opts.message,
+          httpStatus: 400,
+          severity: "low",
+          isOperational: true,
+          cause: opts.cause,
+          context: opts.context
+        });
+      }
+    };
+    exports.ValidationError = ValidationError;
+    var AuthError2 = class extends AppError {
+      constructor(opts) {
+        super({
+          code: opts.code ?? error_codes_js_1.ErrorCode.ERR_AUTH_UNAUTHORIZED,
+          message: opts.message,
+          httpStatus: 401,
+          severity: "medium",
+          isOperational: true,
+          cause: opts.cause,
+          context: opts.context
+        });
+      }
+    };
+    exports.AuthError = AuthError2;
+    var ExternalServiceError = class extends AppError {
+      constructor(opts) {
+        super({
+          code: opts.code ?? error_codes_js_1.ErrorCode.ERR_INTERNAL,
+          message: `[${opts.service}] ${opts.message}`,
+          httpStatus: 502,
+          severity: "high",
+          isOperational: true,
+          cause: opts.cause,
+          context: { ...opts.context, service: opts.service }
+        });
+      }
+    };
+    exports.ExternalServiceError = ExternalServiceError;
+    var QueueError = class extends AppError {
+      constructor(opts) {
+        super({
+          code: opts.code ?? error_codes_js_1.ErrorCode.ERR_QUEUE_PUBLISH,
+          message: opts.message,
+          httpStatus: 503,
+          severity: "high",
+          isOperational: true,
+          cause: opts.cause,
+          context: opts.context
+        });
+      }
+    };
+    exports.QueueError = QueueError;
+    var SearchError = class extends AppError {
+      constructor(opts) {
+        super({
+          code: opts.code ?? error_codes_js_1.ErrorCode.ERR_SEARCH_PIPELINE,
+          message: opts.message,
+          httpStatus: 500,
+          severity: "medium",
+          isOperational: true,
+          cause: opts.cause,
+          context: opts.context
+        });
+      }
+    };
+    exports.SearchError = SearchError;
+    var IndexerError = class extends AppError {
+      constructor(opts) {
+        super({
+          code: opts.code ?? error_codes_js_1.ErrorCode.ERR_INDEXER_PROCESS,
+          message: opts.message,
+          httpStatus: 500,
+          severity: "medium",
+          isOperational: true,
+          cause: opts.cause,
+          context: opts.context
+        });
+      }
+    };
+    exports.IndexerError = IndexerError;
+    var VectorError = class extends AppError {
+      constructor(opts) {
+        super({
+          code: opts.code ?? error_codes_js_1.ErrorCode.ERR_EXTERNAL_NOMIC,
+          message: opts.message,
+          httpStatus: 502,
+          severity: "high",
+          isOperational: true,
+          cause: opts.cause,
+          context: opts.context
+        });
+      }
+    };
+    exports.VectorError = VectorError;
+  }
+});
+
+// ../../packages/errors/dist/serializers.js
+var require_serializers = __commonJS({
+  "../../packages/errors/dist/serializers.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.errorSerializer = errorSerializer;
+    var errors_js_1 = require_errors();
+    function errorSerializer(err) {
+      if (err instanceof errors_js_1.AppError) {
+        return err.toJSON();
+      }
+      if (err instanceof Error) {
+        return {
+          name: err.name,
+          message: err.message,
+          stack: err.stack,
+          cause: err.cause instanceof Error ? { name: err.cause.name, message: err.cause.message, stack: err.cause.stack } : err.cause
+        };
+      }
+      return { message: String(err) };
+    }
+  }
+});
+
+// ../../packages/errors/dist/logger.js
+var require_logger = __commonJS({
+  "../../packages/errors/dist/logger.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createMcpLogger = createMcpLogger10;
+    exports.createLogger = createMcpLogger10;
+    var node_os_1 = __require("os");
+    var node_path_1 = __require("path");
+    var pino_1 = __importDefault(__require("pino"));
+    var serializers_js_1 = require_serializers();
+    var REDACT_PATHS = [
+      "password",
+      "token",
+      "accessToken",
+      "access_token",
+      "refreshToken",
+      "refresh_token",
+      "apiKey",
+      "api_key",
+      "secret",
+      "TOOLPILOT_API_KEY",
+      "authorization",
+      "cookie",
+      "*.password",
+      "*.token",
+      "*.secret",
+      "*.apiKey",
+      "*.api_key"
+    ];
+    function createMcpLogger10(opts) {
+      const level = opts.level ?? process.env.LOG_LEVEL ?? (process.env.NODE_ENV !== "production" ? "debug" : "info");
+      const pinoOpts = {
+        name: opts.name,
+        level,
+        serializers: {
+          err: serializers_js_1.errorSerializer,
+          error: serializers_js_1.errorSerializer
+        },
+        redact: {
+          paths: REDACT_PATHS,
+          censor: "[REDACTED]"
+        },
+        timestamp: pino_1.default.stdTimeFunctions.isoTime,
+        base: {
+          pid: process.pid,
+          ...opts.defaultFields
+        }
+      };
+      const isProd = process.env.NODE_ENV === "production";
+      if (!isProd) {
+        return (0, pino_1.default)({ ...pinoOpts, transport: { target: "pino/file", options: { destination: 2 } } });
+      }
+      const logDir = (0, node_path_1.join)((0, node_os_1.homedir)(), ".toolcairn", "logs");
+      const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const errorLogPath = (0, node_path_1.join)(logDir, `mcp-error-${today}.log`);
+      const transport = pino_1.default.transport({
+        targets: [
+          { target: "pino/file", options: { destination: 2 }, level },
+          { target: "pino/file", options: { destination: errorLogPath, mkdir: true }, level: "warn" }
+        ]
+      });
+      return (0, pino_1.default)(pinoOpts, transport);
+    }
+  }
+});
+
+// ../../packages/errors/dist/mcp-error-wrapper.js
+var require_mcp_error_wrapper = __commonJS({
+  "../../packages/errors/dist/mcp-error-wrapper.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.withErrorHandling = withErrorHandling2;
+    var error_codes_js_1 = require_error_codes();
+    var errors_js_1 = require_errors();
+    function withErrorHandling2(toolName, logger10, handler) {
+      return async (args) => {
+        try {
+          return await handler(args);
+        } catch (err) {
+          if (err instanceof errors_js_1.AppError) {
+            const logLevel = err.severity === "critical" || err.severity === "high" ? "error" : "warn";
+            logger10[logLevel]({ err, tool: toolName }, `Tool ${toolName} failed: ${err.message}`);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    ok: false,
+                    error: err.code,
+                    message: err.isOperational ? err.message : "An internal error occurred"
+                  })
+                }
+              ],
+              isError: true
+            };
+          }
+          logger10.error({ err, tool: toolName }, `Unexpected error in tool ${toolName}`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  ok: false,
+                  error: error_codes_js_1.ErrorCode.ERR_MCP_HANDLER,
+                  message: err instanceof Error ? err.message : String(err)
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+      };
+    }
+  }
+});
+
+// ../../packages/errors/dist/index.js
+var require_dist2 = __commonJS({
+  "../../packages/errors/dist/index.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.withErrorHandling = exports.createLogger = exports.createMcpLogger = exports.errorSerializer = exports.VectorError = exports.IndexerError = exports.SearchError = exports.QueueError = exports.ExternalServiceError = exports.AuthError = exports.ValidationError = exports.NetworkError = exports.DatabaseError = exports.AppError = exports.ErrorCode = void 0;
+    var error_codes_js_1 = require_error_codes();
+    Object.defineProperty(exports, "ErrorCode", { enumerable: true, get: function() {
+      return error_codes_js_1.ErrorCode;
+    } });
+    var errors_js_1 = require_errors();
+    Object.defineProperty(exports, "AppError", { enumerable: true, get: function() {
+      return errors_js_1.AppError;
+    } });
+    Object.defineProperty(exports, "DatabaseError", { enumerable: true, get: function() {
+      return errors_js_1.DatabaseError;
+    } });
+    Object.defineProperty(exports, "NetworkError", { enumerable: true, get: function() {
+      return errors_js_1.NetworkError;
+    } });
+    Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() {
+      return errors_js_1.ValidationError;
+    } });
+    Object.defineProperty(exports, "AuthError", { enumerable: true, get: function() {
+      return errors_js_1.AuthError;
+    } });
+    Object.defineProperty(exports, "ExternalServiceError", { enumerable: true, get: function() {
+      return errors_js_1.ExternalServiceError;
+    } });
+    Object.defineProperty(exports, "QueueError", { enumerable: true, get: function() {
+      return errors_js_1.QueueError;
+    } });
+    Object.defineProperty(exports, "SearchError", { enumerable: true, get: function() {
+      return errors_js_1.SearchError;
+    } });
+    Object.defineProperty(exports, "IndexerError", { enumerable: true, get: function() {
+      return errors_js_1.IndexerError;
+    } });
+    Object.defineProperty(exports, "VectorError", { enumerable: true, get: function() {
+      return errors_js_1.VectorError;
+    } });
+    var serializers_js_1 = require_serializers();
+    Object.defineProperty(exports, "errorSerializer", { enumerable: true, get: function() {
+      return serializers_js_1.errorSerializer;
+    } });
+    var logger_js_1 = require_logger();
+    Object.defineProperty(exports, "createMcpLogger", { enumerable: true, get: function() {
+      return logger_js_1.createMcpLogger;
+    } });
+    Object.defineProperty(exports, "createLogger", { enumerable: true, get: function() {
+      return logger_js_1.createLogger;
+    } });
+    var mcp_error_wrapper_js_1 = require_mcp_error_wrapper();
+    Object.defineProperty(exports, "withErrorHandling", { enumerable: true, get: function() {
+      return mcp_error_wrapper_js_1.withErrorHandling;
+    } });
+  }
+});
+
 // src/index.prod.ts
 init_esm_shims();
-var import_config3 = __toESM(require_dist(), 1);
+var import_config4 = __toESM(require_dist(), 1);
+var import_errors11 = __toESM(require_dist2(), 1);
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // ../../packages/remote/dist/index.js
@@ -87,6 +520,7 @@ init_esm_shims();
 
 // ../../packages/remote/dist/client.js
 init_esm_shims();
+var import_errors = __toESM(require_dist2(), 1);
 var DEFAULT_TIMEOUT_MS = 3e4;
 var ToolCairnClient = class {
   baseUrl;
@@ -167,7 +601,7 @@ var ToolCairnClient = class {
             type: "text",
             text: JSON.stringify({
               ok: false,
-              error: "network_error",
+              error: import_errors.ErrorCode.ERR_NETWORK_UNREACHABLE,
               message: `ToolCairn API unreachable: ${msg}. Check your internet connection or try again later.`
             })
           }
@@ -287,6 +721,7 @@ async function clearAuthentication() {
 
 // ../../packages/remote/dist/device-auth.js
 init_esm_shims();
+var import_errors2 = __toESM(require_dist2(), 1);
 async function openBrowser(url) {
   const { spawn } = await import("child_process");
   try {
@@ -310,8 +745,12 @@ async function openBrowser(url) {
 }
 async function requestDeviceCode(apiUrl) {
   const res = await fetch(`${apiUrl}/v1/auth/device-code`, { method: "POST" });
-  if (!res.ok)
-    throw new Error("Failed to start device auth. Check your internet connection.");
+  if (!res.ok) {
+    throw new import_errors2.NetworkError({
+      code: import_errors2.ErrorCode.ERR_NETWORK_UNREACHABLE,
+      message: "Failed to start device auth. Check your internet connection."
+    });
+  }
   const data = await res.json();
   await savePendingAuth({
     device_code: data.device_code,
@@ -379,10 +818,17 @@ async function pollForToken(apiUrl, deviceCode, intervalSec) {
       continue;
     if (data.error === "expired_token") {
       await clearPendingAuth();
-      throw new Error("Device code expired. Please try again.");
+      throw new import_errors2.AuthError({
+        code: import_errors2.ErrorCode.ERR_AUTH_TOKEN_EXPIRED,
+        message: "Device code expired. Please try again."
+      });
+    }
+    if (data.error) {
+      throw new import_errors2.AuthError({
+        code: import_errors2.ErrorCode.ERR_AUTH_UNAUTHORIZED,
+        message: `Authorization failed: ${data.error}`
+      });
     }
-    if (data.error)
-      throw new Error(`Authorization failed: ${data.error}`);
     if (data.access_token)
       return data;
   }
@@ -392,15 +838,14 @@ function sleep(ms) {
 }
 
 // src/index.prod.ts
-import pino9 from "pino";
 import { z as z3 } from "zod";
 
 // src/project-setup.ts
 init_esm_shims();
+var import_errors3 = __toESM(require_dist2(), 1);
 import { access, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 import { platform, type } from "os";
 import { join as join2 } from "path";
-import pino from "pino";
 
 // src/tools/generate-tracker.ts
 init_esm_shims();
@@ -808,7 +1253,7 @@ if (!EVENTS_PATH || EVENTS_PATH === 'null') {
 }
 
 // src/project-setup.ts
-var logger = pino({ name: "@toolcairn/mcp-server:project-setup" });
+var logger = (0, import_errors3.createMcpLogger)({ name: "@toolcairn/mcp-server:project-setup" });
 var INITIAL_CONFIG = {
   version: "1.0",
   project: {
@@ -874,7 +1319,8 @@ async function createIfAbsent(filePath, content, label) {
 
 // src/server.prod.ts
 init_esm_shims();
-var import_config = __toESM(require_dist(), 1);
+var import_config2 = __toESM(require_dist(), 1);
+var import_errors10 = __toESM(require_dist2(), 1);
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // ../../packages/tools-local/dist/index.js
@@ -1021,8 +1467,8 @@ function errResult(error, message) {
 
 // ../../packages/tools-local/dist/handlers/classify-prompt.js
 init_esm_shims();
-import pino2 from "pino";
-var logger2 = pino2({ name: "@toolcairn/tools:classify-prompt" });
+var import_errors4 = __toESM(require_dist2(), 1);
+var logger2 = (0, import_errors4.createMcpLogger)({ name: "@toolcairn/tools:classify-prompt" });
 var TOOL_REQUIRED_CLASSIFICATIONS = [
   "tool_discovery",
   "stack_building",
@@ -1083,7 +1529,7 @@ Respond with ONLY 0 or 1.`;
 
 // ../../packages/tools-local/dist/handlers/toolcairn-init.js
 init_esm_shims();
-import pino3 from "pino";
+var import_errors5 = __toESM(require_dist2(), 1);
 
 // ../../packages/tools-local/dist/templates/agent-instructions.js
 init_esm_shims();
@@ -1633,7 +2079,7 @@ if (!EVENTS_PATH || EVENTS_PATH === 'null') {
 }
 
 // ../../packages/tools-local/dist/handlers/toolcairn-init.js
-var logger3 = pino3({ name: "@toolcairn/tools:toolpilot-init" });
+var logger3 = (0, import_errors5.createMcpLogger)({ name: "@toolcairn/tools:toolpilot-init" });
 async function handleToolcairnInit(args) {
   try {
     logger3.info({ agent: args.agent, project_root: args.project_root }, "toolpilot_init called");
@@ -1721,8 +2167,8 @@ async function handleToolcairnInit(args) {
 
 // ../../packages/tools-local/dist/handlers/init-project-config.js
 init_esm_shims();
-import pino4 from "pino";
-var logger4 = pino4({ name: "@toolcairn/tools:init-project-config" });
+var import_errors6 = __toESM(require_dist2(), 1);
+var logger4 = (0, import_errors6.createMcpLogger)({ name: "@toolcairn/tools:init-project-config" });
 async function handleInitProjectConfig(args) {
   try {
     logger4.info({ project: args.project_name }, "init_project_config called");
@@ -1735,7 +2181,7 @@ async function handleInitProjectConfig(args) {
       chosen_reason: "Auto-detected from project files during toolpilot_init",
       alternatives_considered: []
     }));
-    const config4 = {
+    const config5 = {
       version: "1.0",
       project: {
         name: args.project_name,
@@ -1755,7 +2201,7 @@ async function handleInitProjectConfig(args) {
         }
       ]
     };
-    const config_json = JSON.stringify(config4, null, 2);
+    const config_json = JSON.stringify(config5, null, 2);
     return okResult({
       config_json,
       file_path: ".toolpilot/config.json",
@@ -1771,8 +2217,8 @@ async function handleInitProjectConfig(args) {
 
 // ../../packages/tools-local/dist/handlers/read-project-config.js
 init_esm_shims();
-import pino5 from "pino";
-var logger5 = pino5({ name: "@toolcairn/tools:read-project-config" });
+var import_errors7 = __toESM(require_dist2(), 1);
+var logger5 = (0, import_errors7.createMcpLogger)({ name: "@toolcairn/tools:read-project-config" });
 var STALENESS_THRESHOLD_DAYS = 90;
 function daysSince(isoDate) {
   return (Date.now() - new Date(isoDate).getTime()) / (1e3 * 60 * 60 * 24);
@@ -1780,18 +2226,18 @@ function daysSince(isoDate) {
 async function handleReadProjectConfig(args) {
   try {
     logger5.info("read_project_config called");
-    let config4;
+    let config5;
     try {
-      config4 = JSON.parse(args.config_content);
+      config5 = JSON.parse(args.config_content);
     } catch {
       return errResult("parse_error", "config_content is not valid JSON");
     }
-    if (config4.version !== "1.0") {
-      return errResult("version_error", `Unsupported config version: ${config4.version}`);
+    if (config5.version !== "1.0") {
+      return errResult("version_error", `Unsupported config version: ${config5.version}`);
     }
-    const confirmedToolNames = config4.tools.confirmed.map((t) => t.name);
-    const pendingToolNames = config4.tools.pending_evaluation.map((t) => t.name);
-    const staleTools = config4.tools.confirmed.filter((t) => {
+    const confirmedToolNames = config5.tools.confirmed.map((t) => t.name);
+    const pendingToolNames = config5.tools.pending_evaluation.map((t) => t.name);
+    const staleTools = config5.tools.confirmed.filter((t) => {
       const date = t.last_verified ?? t.chosen_at ?? t.confirmed_at;
       return date ? daysSince(date) > STALENESS_THRESHOLD_DAYS : true;
     }).map((t) => {
@@ -1804,10 +2250,10 @@ async function handleReadProjectConfig(args) {
         recommendation: "Consider using check_issue to verify no new known issues"
       };
     });
-    const non_oss_tools = config4.tools.confirmed.filter((t) => t.source === "non_oss").map((t) => t.name);
-    const toolpilot_indexed_tools = config4.tools.confirmed.filter((t) => t.source === "toolpilot").map((t) => t.name);
+    const non_oss_tools = config5.tools.confirmed.filter((t) => t.source === "non_oss").map((t) => t.name);
+    const toolpilot_indexed_tools = config5.tools.confirmed.filter((t) => t.source === "toolpilot").map((t) => t.name);
     return okResult({
-      project: config4.project,
+      project: config5.project,
       confirmed_tools: confirmedToolNames,
       pending_tools: pendingToolNames,
       non_oss_tools,
@@ -1815,9 +2261,9 @@ async function handleReadProjectConfig(args) {
       stale_tools: staleTools,
       total_confirmed: confirmedToolNames.length,
       total_pending: pendingToolNames.length,
-      last_audit_entry: config4.audit_log.at(-1) ?? null,
+      last_audit_entry: config5.audit_log.at(-1) ?? null,
       agent_instructions: [
-        `Project: ${config4.project.name} (${config4.project.language}${config4.project.framework ? `, ${config4.project.framework}` : ""})`,
+        `Project: ${config5.project.name} (${config5.project.language}${config5.project.framework ? `, ${config5.project.framework}` : ""})`,
         `Already confirmed tools: ${confirmedToolNames.join(", ") || "none"}`,
         "When recommending tools, skip any already in confirmed_tools.",
         non_oss_tools.length > 0 ? `Non-OSS tools in project (handle separately): ${non_oss_tools.join(", ")}` : "",
@@ -1832,14 +2278,14 @@ async function handleReadProjectConfig(args) {
 
 // ../../packages/tools-local/dist/handlers/update-project-config.js
 init_esm_shims();
-import pino6 from "pino";
-var logger6 = pino6({ name: "@toolcairn/tools:update-project-config" });
+var import_errors8 = __toESM(require_dist2(), 1);
+var logger6 = (0, import_errors8.createMcpLogger)({ name: "@toolcairn/tools:update-project-config" });
 async function handleUpdateProjectConfig(args) {
   try {
     logger6.info({ action: args.action, tool: args.tool_name }, "update_project_config called");
-    let config4;
+    let config5;
     try {
-      config4 = JSON.parse(args.current_config);
+      config5 = JSON.parse(args.current_config);
     } catch {
       return errResult("parse_error", "current_config is not valid JSON");
     }
@@ -1847,8 +2293,8 @@ async function handleUpdateProjectConfig(args) {
     const data = args.data ?? {};
     switch (args.action) {
       case "add_tool": {
-        config4.tools.pending_evaluation = config4.tools.pending_evaluation.filter((t) => t.name !== args.tool_name);
-        if (!config4.tools.confirmed.some((t) => t.name === args.tool_name)) {
+        config5.tools.pending_evaluation = config5.tools.pending_evaluation.filter((t) => t.name !== args.tool_name);
+        if (!config5.tools.confirmed.some((t) => t.name === args.tool_name)) {
           const newTool = {
             name: args.tool_name,
             source: data.source ?? "toolpilot",
@@ -1860,9 +2306,9 @@ async function handleUpdateProjectConfig(args) {
             query_id: data.query_id,
             notes: data.notes
           };
-          config4.tools.confirmed.push(newTool);
+          config5.tools.confirmed.push(newTool);
         }
-        config4.audit_log.push({
+        config5.audit_log.push({
           action: "add_tool",
           tool: args.tool_name,
           timestamp: now,
@@ -1871,9 +2317,9 @@ async function handleUpdateProjectConfig(args) {
         break;
       }
       case "remove_tool": {
-        config4.tools.confirmed = config4.tools.confirmed.filter((t) => t.name !== args.tool_name);
-        config4.tools.pending_evaluation = config4.tools.pending_evaluation.filter((t) => t.name !== args.tool_name);
-        config4.audit_log.push({
+        config5.tools.confirmed = config5.tools.confirmed.filter((t) => t.name !== args.tool_name);
+        config5.tools.pending_evaluation = config5.tools.pending_evaluation.filter((t) => t.name !== args.tool_name);
+        config5.audit_log.push({
           action: "remove_tool",
           tool: args.tool_name,
           timestamp: now,
@@ -1882,22 +2328,22 @@ async function handleUpdateProjectConfig(args) {
         break;
       }
       case "update_tool": {
-        const idx = config4.tools.confirmed.findIndex((t) => t.name === args.tool_name);
+        const idx = config5.tools.confirmed.findIndex((t) => t.name === args.tool_name);
         if (idx === -1) {
           return errResult("not_found", `Tool "${args.tool_name}" not found in confirmed tools`);
         }
-        const existing = config4.tools.confirmed[idx];
+        const existing = config5.tools.confirmed[idx];
         if (!existing) {
           return errResult("not_found", `Tool "${args.tool_name}" not found`);
         }
-        config4.tools.confirmed[idx] = {
+        config5.tools.confirmed[idx] = {
           ...existing,
           ...data.version !== void 0 ? { version: data.version } : {},
           ...data.notes !== void 0 ? { notes: data.notes } : {},
           ...data.chosen_reason !== void 0 ? { chosen_reason: data.chosen_reason } : {},
           ...data.alternatives_considered !== void 0 ? { alternatives_considered: data.alternatives_considered } : {}
         };
-        config4.audit_log.push({
+        config5.audit_log.push({
           action: "update_tool",
           tool: args.tool_name,
           timestamp: now,
@@ -1906,15 +2352,15 @@ async function handleUpdateProjectConfig(args) {
         break;
       }
       case "add_evaluation": {
-        if (!config4.tools.pending_evaluation.some((t) => t.name === args.tool_name) && !config4.tools.confirmed.some((t) => t.name === args.tool_name)) {
+        if (!config5.tools.pending_evaluation.some((t) => t.name === args.tool_name) && !config5.tools.confirmed.some((t) => t.name === args.tool_name)) {
           const pending = {
             name: args.tool_name,
             category: data.category ?? "other",
             added_at: now
           };
-          config4.tools.pending_evaluation.push(pending);
+          config5.tools.pending_evaluation.push(pending);
         }
-        config4.audit_log.push({
+        config5.audit_log.push({
           action: "add_evaluation",
           tool: args.tool_name,
           timestamp: now,
@@ -1923,14 +2369,14 @@ async function handleUpdateProjectConfig(args) {
         break;
       }
     }
-    const updated_config_json = JSON.stringify(config4, null, 2);
+    const updated_config_json = JSON.stringify(config5, null, 2);
     return okResult({
       updated_config_json,
       file_path: ".toolpilot/config.json",
       action_applied: args.action,
       tool_name: args.tool_name,
-      confirmed_count: config4.tools.confirmed.length,
-      pending_count: config4.tools.pending_evaluation.length,
+      confirmed_count: config5.tools.confirmed.length,
+      pending_count: config5.tools.pending_evaluation.length,
       instructions: "Write updated_config_json to .toolpilot/config.json to persist this change."
     });
   } catch (e) {
@@ -1940,15 +2386,15 @@ async function handleUpdateProjectConfig(args) {
 }
 
 // src/server.prod.ts
-import pino8 from "pino";
 import { z as z2 } from "zod";
 
 // src/middleware/event-logger.ts
 init_esm_shims();
+var import_config = __toESM(require_dist(), 1);
+var import_errors9 = __toESM(require_dist2(), 1);
 import { appendFile, mkdir as mkdir3 } from "fs/promises";
 import { dirname } from "path";
-import pino7 from "pino";
-var logger7 = pino7({ name: "@toolcairn/mcp-server:event-logger" });
+var logger7 = (0, import_errors9.createMcpLogger)({ name: "@toolcairn/mcp-server:event-logger" });
 function isTrackingEnabled() {
   return process.env.TOOLCAIRN_TRACKING_ENABLED !== "false";
 }
@@ -1995,6 +2441,28 @@ async function writeToFile(eventsPath, event) {
     logger7.warn({ err: e, path: eventsPath }, "Failed to write event to JSONL file");
   }
 }
+async function sendToApi(event) {
+  try {
+    const creds = await loadCredentials();
+    if (!creds) return;
+    const headers = { "Content-Type": "application/json" };
+    if (creds.access_token) headers.Authorization = `Bearer ${creds.access_token}`;
+    if (creds.client_id) headers["X-ToolCairn-Key"] = creds.client_id;
+    await fetch(`${import_config.config.TOOLPILOT_API_URL}/v1/events`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        tool_name: event.tool_name,
+        query_id: event.query_id,
+        duration_ms: event.duration_ms,
+        status: event.status,
+        metadata: event.metadata
+      })
+    });
+  } catch (e) {
+    logger7.debug({ err: e }, "Failed to send event to API \u2014 non-fatal");
+  }
+}
 function withEventLogging(toolName, handler) {
   return async (args) => {
     if (!isTrackingEnabled()) {
@@ -2020,6 +2488,8 @@ function withEventLogging(toolName, handler) {
         metadata: result ? extractMetadata(toolName, result) : null,
         created_at: (/* @__PURE__ */ new Date()).toISOString()
       };
+      sendToApi(event).catch(() => {
+      });
       const eventsPath = getEventsPath();
       if (eventsPath) {
         writeToFile(eventsPath, event).catch(() => {
@@ -2031,7 +2501,7 @@ function withEventLogging(toolName, handler) {
 }
 
 // src/server.prod.ts
-var logger8 = pino8({ name: "@toolcairn/mcp-server:prod" });
+var logger8 = (0, import_errors10.createMcpLogger)({ name: "@toolcairn/mcp-server:prod" });
 var SETUP_INSTRUCTIONS = `
 # ToolCairn \u2014 Agent Setup Instructions
 
@@ -2081,18 +2551,24 @@ async function addToolsToServer(server) {
     throw new Error("ToolCairn: authentication required.");
   }
   const remote = new ToolCairnClient({
-    baseUrl: import_config.config.TOOLPILOT_API_URL,
+    baseUrl: import_config2.config.TOOLPILOT_API_URL,
     apiKey: creds.client_id,
     accessToken: creds.access_token
   });
   logger8.info({ user: creds.user_email }, "Registering production tools");
+  function wrap(toolName, fn) {
+    return withEventLogging(toolName, (0, import_errors10.withErrorHandling)(toolName, logger8, fn));
+  }
   server.registerTool(
     "classify_prompt",
     {
       description: "Classify a developer prompt to determine if ToolCairn tool search is needed. Returns a structured classification prompt for the agent to evaluate.",
       inputSchema: classifyPromptSchema
     },
-    withEventLogging("classify_prompt", async (args) => handleClassifyPrompt(args))
+    wrap(
+      "classify_prompt",
+      async (args) => handleClassifyPrompt(args)
+    )
   );
   server.registerTool(
     "toolcairn_init",
@@ -2100,7 +2576,10 @@ async function addToolsToServer(server) {
       description: "Set up ToolCairn integration for the current project. Generates agent instruction content, MCP config entry, and project config initializer.",
       inputSchema: toolpilotInitSchema
     },
-    withEventLogging("toolcairn_init", async (args) => handleToolcairnInit(args))
+    wrap(
+      "toolcairn_init",
+      async (args) => handleToolcairnInit(args)
+    )
   );
   server.registerTool(
     "init_project_config",
@@ -2108,7 +2587,10 @@ async function addToolsToServer(server) {
       description: "Initialize a .toolcairn/config.json file for the current project. Returns the config JSON for the agent to write to disk.",
       inputSchema: initProjectConfigSchema
     },
-    withEventLogging("init_project_config", async (args) => handleInitProjectConfig(args))
+    wrap(
+      "init_project_config",
+      async (args) => handleInitProjectConfig(args)
+    )
   );
   server.registerTool(
     "read_project_config",
@@ -2116,7 +2598,10 @@ async function addToolsToServer(server) {
       description: "Parse and validate a .toolcairn/config.json file. Returns confirmed tools, pending evaluations, stale tools, and agent instructions.",
       inputSchema: readProjectConfigSchema
     },
-    withEventLogging("read_project_config", async (args) => handleReadProjectConfig(args))
+    wrap(
+      "read_project_config",
+      async (args) => handleReadProjectConfig(args)
+    )
   );
   server.registerTool(
     "update_project_config",
@@ -2124,7 +2609,10 @@ async function addToolsToServer(server) {
       description: "Apply a mutation to .toolcairn/config.json and return the updated content. Actions: add_tool, remove_tool, update_tool, add_evaluation.",
       inputSchema: updateProjectConfigSchema
     },
-    withEventLogging("update_project_config", async (args) => handleUpdateProjectConfig(args))
+    wrap(
+      "update_project_config",
+      async (args) => handleUpdateProjectConfig(args)
+    )
   );
   server.registerTool(
     "search_tools",
@@ -2132,7 +2620,7 @@ async function addToolsToServer(server) {
       description: "Search for the best tool for a specific need using a natural language query. Initiates a guided discovery session with clarification questions when needed.",
       inputSchema: searchToolsSchema
     },
-    withEventLogging("search_tools", async (args) => remote.searchTools(args))
+    wrap("search_tools", async (args) => remote.searchTools(args))
   );
   server.registerTool(
     "search_tools_respond",
@@ -2140,15 +2628,15 @@ async function addToolsToServer(server) {
       description: "Submit clarification answers for an in-progress tool search session and receive refined results.",
       inputSchema: searchToolsRespondSchema
     },
-    withEventLogging("search_tools_respond", async (args) => remote.searchToolsRespond(args))
+    wrap("search_tools_respond", async (args) => remote.searchToolsRespond(args))
   );
   server.registerTool(
     "get_stack",
     {
-      description: "Get a recommended tool stack for a specific use case with optional deployment and language constraints.",
+      description: "Build a complementary tool stack for a project use case. Returns diverse, integration-aware tools across different functional layers (not competing alternatives), with docs, health signals, and notes on how stack members integrate with each other.",
       inputSchema: getStackSchema
     },
-    withEventLogging("get_stack", async (args) => remote.getStack(args))
+    wrap("get_stack", async (args) => remote.getStack(args))
   );
   server.registerTool(
     "check_compatibility",
@@ -2156,7 +2644,7 @@ async function addToolsToServer(server) {
       description: "Check compatibility between two tools. Returns direct graph relationships and inferred compatibility from shared neighbors.",
       inputSchema: checkCompatibilitySchema
     },
-    withEventLogging("check_compatibility", async (args) => remote.checkCompatibility(args))
+    wrap("check_compatibility", async (args) => remote.checkCompatibility(args))
   );
   server.registerTool(
     "compare_tools",
@@ -2164,7 +2652,7 @@ async function addToolsToServer(server) {
       description: "Compare two tools head-to-head using health signals, graph relationships, and community data.",
       inputSchema: compareToolsSchema
     },
-    withEventLogging("compare_tools", async (args) => remote.compareTools(args))
+    wrap("compare_tools", async (args) => remote.compareTools(args))
   );
   server.registerTool(
     "refine_requirement",
@@ -2172,7 +2660,7 @@ async function addToolsToServer(server) {
       description: "Decompose a vague user use-case into specific, searchable tool requirements.",
       inputSchema: refineRequirementSchema
     },
-    withEventLogging("refine_requirement", async (args) => remote.refineRequirement(args))
+    wrap("refine_requirement", async (args) => remote.refineRequirement(args))
   );
   server.registerTool(
     "check_issue",
@@ -2180,7 +2668,7 @@ async function addToolsToServer(server) {
       description: "LAST RESORT \u2014 check GitHub Issues for a known error after 4+ retries and docs review.",
       inputSchema: checkIssueSchema
     },
-    withEventLogging("check_issue", async (args) => remote.checkIssue(args))
+    wrap("check_issue", async (args) => remote.checkIssue(args))
   );
   server.registerTool(
     "verify_suggestion",
@@ -2188,7 +2676,7 @@ async function addToolsToServer(server) {
       description: "Validate agent-suggested tools against the ToolCairn graph.",
       inputSchema: verifySuggestionSchema
     },
-    withEventLogging("verify_suggestion", async (args) => remote.verifySuggestion(args))
+    wrap("verify_suggestion", async (args) => remote.verifySuggestion(args))
   );
   server.registerTool(
     "report_outcome",
@@ -2196,7 +2684,7 @@ async function addToolsToServer(server) {
       description: "Report the outcome of using a tool recommended by ToolCairn (fire-and-forget).",
       inputSchema: reportOutcomeSchema
     },
-    withEventLogging("report_outcome", async (args) => remote.reportOutcome(args))
+    wrap("report_outcome", async (args) => remote.reportOutcome(args))
   );
   server.registerTool(
     "suggest_graph_update",
@@ -2204,7 +2692,7 @@ async function addToolsToServer(server) {
       description: "Suggest a new tool, relationship, use case, or health update to the ToolCairn graph.",
       inputSchema: suggestGraphUpdateSchema
     },
-    withEventLogging("suggest_graph_update", async (args) => remote.suggestGraphUpdate(args))
+    wrap("suggest_graph_update", async (args) => remote.suggestGraphUpdate(args))
   );
   server.registerTool(
     "toolcairn_auth",
@@ -2249,7 +2737,7 @@ async function addToolsToServer(server) {
         };
       }
       try {
-        const user = await startDeviceAuth(import_config.config.TOOLPILOT_API_URL);
+        const user = await startDeviceAuth(import_config2.config.TOOLPILOT_API_URL);
         return {
           content: [
             {
@@ -2284,7 +2772,7 @@ async function buildProdServer() {
 
 // src/transport.ts
 init_esm_shims();
-var import_config2 = __toESM(require_dist(), 1);
+var import_config3 = __toESM(require_dist(), 1);
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 function createTransport() {
@@ -2298,7 +2786,7 @@ function createTransport() {
 
 // src/index.prod.ts
 process.env.TOOLPILOT_MODE = "production";
-var logger9 = pino9({ name: "@toolcairn/mcp-server" });
+var logger9 = (0, import_errors11.createMcpLogger)({ name: "@toolcairn/mcp-server" });
 async function main() {
   await ensureProjectSetup();
   const creds = await loadCredentials();
@@ -2317,7 +2805,7 @@ async function main() {
         userCode = pending.user_code;
         logger9.info({ userCode }, "Resuming pending sign-in");
       } else {
-        const codeData = await requestDeviceCode(import_config3.config.TOOLPILOT_API_URL);
+        const codeData = await requestDeviceCode(import_config4.config.TOOLPILOT_API_URL);
         verificationUri = codeData.verification_uri;
         userCode = codeData.user_code;
         logger9.info({ userCode }, "New sign-in started");
@@ -2354,7 +2842,7 @@ Open the URL, sign in, and confirm the code shown. All 14 tools will appear auto
         ]
       })
     );
-    startDeviceAuth(import_config3.config.TOOLPILOT_API_URL).then(async () => {
+    startDeviceAuth(import_config4.config.TOOLPILOT_API_URL).then(async () => {
       logger9.info("Sign-in complete \u2014 adding all tools to running server");
       try {
         await addToolsToServer(server);
@@ -2371,7 +2859,10 @@ Open the URL, sign in, and confirm the code shown. All 14 tools will appear auto
   logger9.info(authenticated ? "ToolCairn MCP ready" : "ToolCairn MCP ready (awaiting sign-in)");
 }
 main().catch((error) => {
-  pino9({ name: "@toolcairn/mcp-server" }).error({ err: error }, "Failed to start MCP server");
+  (0, import_errors11.createMcpLogger)({ name: "@toolcairn/mcp-server" }).error(
+    { err: error },
+    "Failed to start MCP server"
+  );
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map