@neurynae/toolcairn-mcp 0.10.0 → 0.10.1

package/dist/index.js

@@ -336,8 +336,8 @@ var require_logger = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.createMcpLogger = createMcpLogger14;
-    exports.createLogger = createMcpLogger14;
+    exports.createMcpLogger = createMcpLogger24;
+    exports.createLogger = createMcpLogger24;
     var node_os_1 = __require("os");
     var node_path_1 = __require("path");
     var pino_1 = __importDefault(__require("pino"));
@@ -361,7 +361,7 @@ var require_logger = __commonJS({
       "*.apiKey",
       "*.api_key"
     ];
-    function createMcpLogger14(opts) {
+    function createMcpLogger24(opts) {
       const level = opts.level ?? process.env.LOG_LEVEL ?? (process.env.NODE_ENV !== "production" ? "debug" : "info");
       const pinoOpts = {
         name: opts.name,
@@ -407,14 +407,14 @@ var require_mcp_error_wrapper = __commonJS({
     exports.withErrorHandling = withErrorHandling2;
     var error_codes_js_1 = require_error_codes();
     var errors_js_1 = require_errors();
-    function withErrorHandling2(toolName, logger14, handler) {
+    function withErrorHandling2(toolName, logger24, 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";
-            logger14[logLevel]({ err, tool: toolName }, `Tool ${toolName} failed: ${err.message}`);
+            logger24[logLevel]({ err, tool: toolName }, `Tool ${toolName} failed: ${err.message}`);
             return {
               content: [
                 {
@@ -429,7 +429,7 @@ var require_mcp_error_wrapper = __commonJS({
               isError: true
             };
           }
-          logger14.error({ err, tool: toolName }, `Unexpected error in tool ${toolName}`);
+          logger24.error({ err, tool: toolName }, `Unexpected error in tool ${toolName}`);
           return {
             content: [
               {
@@ -512,7 +512,7 @@ var require_dist2 = __commonJS({
 // src/index.prod.ts
 init_esm_shims();
 var import_config4 = __toESM(require_dist(), 1);
-var import_errors15 = __toESM(require_dist2(), 1);
+var import_errors25 = __toESM(require_dist2(), 1);
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // ../../packages/remote/dist/index.js
@@ -814,13 +814,13 @@ var import_errors2 = __toESM(require_dist2(), 1);
 async function openBrowser(url) {
   const { spawn } = await import("child_process");
   try {
-    const platform2 = process.platform;
+    const platform3 = process.platform;
     let cmd;
     let args;
-    if (platform2 === "win32") {
+    if (platform3 === "win32") {
       cmd = "cmd";
       args = ["/c", "start", "", url];
-    } else if (platform2 === "darwin") {
+    } else if (platform3 === "darwin") {
       cmd = "open";
       args = [url];
     } else {
@@ -1393,7 +1393,7 @@ async function createIfAbsent(filePath, content, label) {
 // src/server.prod.ts
 init_esm_shims();
 var import_config2 = __toESM(require_dist(), 1);
-var import_errors14 = __toESM(require_dist2(), 1);
+var import_errors24 = __toESM(require_dist2(), 1);
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // ../../packages/tools-local/dist/index.js
@@ -1602,7 +1602,7 @@ Respond with ONLY 0 or 1.`;
 
 // ../../packages/tools-local/dist/handlers/toolcairn-init.js
 init_esm_shims();
-var import_errors10 = __toESM(require_dist2(), 1);
+var import_errors20 = __toESM(require_dist2(), 1);
 
 // ../../packages/tools-local/dist/config-store/index.js
 init_esm_shims();
@@ -1915,8 +1915,8 @@ init_esm_shims();
 
 // ../../packages/tools-local/dist/discovery/scan-project.js
 init_esm_shims();
-var import_errors9 = __toESM(require_dist2(), 1);
-import { readFile as readFile17 } from "fs/promises";
+var import_errors19 = __toESM(require_dist2(), 1);
+import { readFile as readFile27 } from "fs/promises";
 import { basename, resolve } from "path";
 
 // ../../packages/tools-local/dist/discovery/ecosystem-detect.js
@@ -3415,10 +3415,754 @@ var PARSERS = {
   "swift-pm": parseSwift
 };
 
+// ../../packages/tools-local/dist/discovery/resolvers/index.js
+init_esm_shims();
+
+// ../../packages/tools-local/dist/discovery/resolvers/cargo.js
+init_esm_shims();
+var import_errors9 = __toESM(require_dist2(), 1);
+import { readFile as readFile16, readdir as readdir5 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join19 } from "path";
+import { parse as parseToml3 } from "smol-toml";
+
+// ../../packages/tools-local/dist/discovery/resolvers/url-normalise.js
+init_esm_shims();
+function normaliseGitHubUrl(raw) {
+  if (!raw)
+    return void 0;
+  let s = raw.trim();
+  if (!s)
+    return void 0;
+  if (s.startsWith("git+"))
+    s = s.slice(4);
+  if (s.startsWith("github:")) {
+    s = `https://github.com/${s.slice(7)}`;
+  }
+  if (/^[A-Za-z0-9_.\-]+\/[A-Za-z0-9_.\-]+$/.test(s)) {
+    s = `https://github.com/${s}`;
+  }
+  s = s.replace(/^git@github\.com:/, "https://github.com/");
+  s = s.replace(/^ssh:\/\/git@github\.com\//, "https://github.com/");
+  s = s.replace(/^http:\/\//, "https://");
+  if (!/^https:\/\/github\.com\//.test(s))
+    return void 0;
+  s = s.replace(/\.git$/, "");
+  s = s.replace(/\/$/, "");
+  const match = s.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)/);
+  if (!match)
+    return void 0;
+  return `https://github.com/${match[1]}/${match[2]}`;
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/cargo.js
+var logger7 = (0, import_errors9.createMcpLogger)({ name: "@toolcairn/tools:resolver:cargo" });
+async function findCachedCrate(name, preferredVersion) {
+  const registryRoot = join19(homedir2(), ".cargo", "registry", "src");
+  if (!await isDir(registryRoot))
+    return null;
+  let indexHosts;
+  try {
+    indexHosts = await readdir5(registryRoot);
+  } catch {
+    return null;
+  }
+  const matches = [];
+  for (const host of indexHosts) {
+    const hostDir = join19(registryRoot, host);
+    if (!await isDir(hostDir))
+      continue;
+    let entries;
+    try {
+      entries = await readdir5(hostDir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.startsWith(`${name}-`))
+        continue;
+      if (preferredVersion && entry !== `${name}-${preferredVersion}`)
+        continue;
+      const manifestPath = join19(hostDir, entry, "Cargo.toml");
+      if (await fileExists(manifestPath))
+        matches.push(manifestPath);
+    }
+  }
+  if (matches.length === 0)
+    return null;
+  matches.sort();
+  return matches[matches.length - 1] ?? null;
+}
+async function resolveCargoIdentity(_workspaceAbs, _projectRoot, depName, hints = {}) {
+  const manifestPath = await findCachedCrate(depName, hints.resolved_version);
+  if (!manifestPath)
+    return {};
+  try {
+    const raw = await readFile16(manifestPath, "utf-8");
+    const doc = parseToml3(raw);
+    const pkg = doc.package;
+    if (!pkg)
+      return {};
+    const out = {};
+    if (pkg.name && pkg.name !== depName)
+      out.canonical_package_name = pkg.name;
+    if (pkg.version)
+      out.resolved_version = pkg.version;
+    const normalised = normaliseGitHubUrl(pkg.repository ?? pkg.homepage);
+    if (normalised)
+      out.github_url = normalised;
+    return out;
+  } catch (err) {
+    logger7.debug({ err: err instanceof Error ? err.message : String(err), manifestPath }, "Failed to parse cached Cargo.toml");
+    return {};
+  }
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/composer.js
+init_esm_shims();
+var import_errors10 = __toESM(require_dist2(), 1);
+import { readFile as readFile17 } from "fs/promises";
+import { join as join20 } from "path";
+var logger8 = (0, import_errors10.createMcpLogger)({ name: "@toolcairn/tools:resolver:composer" });
+async function resolveComposerIdentity(workspaceAbs, _projectRoot, depName) {
+  const path2 = join20(workspaceAbs, "vendor", depName, "composer.json");
+  if (!await fileExists(path2))
+    return {};
+  try {
+    const pkg = JSON.parse(await readFile17(path2, "utf-8"));
+    const out = {};
+    if (pkg.name && pkg.name !== depName)
+      out.canonical_package_name = pkg.name;
+    if (pkg.version)
+      out.resolved_version = pkg.version;
+    const candidateUrl = pkg.source?.url ?? pkg.support?.source ?? pkg.homepage;
+    const normalised = normaliseGitHubUrl(candidateUrl);
+    if (normalised)
+      out.github_url = normalised;
+    return out;
+  } catch (err) {
+    logger8.debug({ err: err instanceof Error ? err.message : String(err), path: path2 }, "Failed to parse installed composer.json");
+    return {};
+  }
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/go.js
+init_esm_shims();
+function resolveGoIdentity(_workspaceAbs, _projectRoot, depName) {
+  if (!depName.startsWith("github.com/"))
+    return {};
+  const tail = depName.slice("github.com/".length);
+  const parts = tail.split("/");
+  if (parts.length < 2 || !parts[0] || !parts[1])
+    return {};
+  const owner = parts[0];
+  let repo = parts[1];
+  repo = repo.replace(/\.git$/, "");
+  const url = normaliseGitHubUrl(`https://github.com/${owner}/${repo}`);
+  return url ? { github_url: url } : {};
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/gradle.js
+init_esm_shims();
+import { readdir as readdir6 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join21 } from "path";
+
+// ../../packages/tools-local/dist/discovery/resolvers/pom-shared.js
+init_esm_shims();
+var import_errors11 = __toESM(require_dist2(), 1);
+import { readFile as readFile18 } from "fs/promises";
+import { XMLParser as XMLParser3 } from "fast-xml-parser";
+var logger9 = (0, import_errors11.createMcpLogger)({ name: "@toolcairn/tools:resolver:pom" });
+async function parsePomIdentity(path2, depName) {
+  if (!await fileExists(path2))
+    return {};
+  try {
+    const raw = await readFile18(path2, "utf-8");
+    const parser = new XMLParser3({ ignoreAttributes: true, parseTagValue: true });
+    const doc = parser.parse(raw);
+    const project = doc.project;
+    if (!project)
+      return {};
+    const out = {};
+    const canonical = project.groupId && project.artifactId ? `${project.groupId}:${project.artifactId}` : void 0;
+    if (canonical && canonical !== depName)
+      out.canonical_package_name = canonical;
+    if (project.version)
+      out.resolved_version = project.version;
+    const candidateUrls = [
+      project.scm?.url,
+      project.scm?.connection,
+      project.scm?.developerConnection,
+      project.url
+    ];
+    for (const u of candidateUrls) {
+      const normalised = normaliseGitHubUrl(u);
+      if (normalised) {
+        out.github_url = normalised;
+        break;
+      }
+    }
+    return out;
+  } catch (err) {
+    logger9.debug({ err: err instanceof Error ? err.message : String(err), path: path2 }, "Failed to parse .pom");
+    return {};
+  }
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/gradle.js
+async function findGradlePom(groupId, artifactId, preferredVersion) {
+  const base = join21(homedir3(), ".gradle", "caches", "modules-2", "files-2.1", groupId, artifactId);
+  if (!await isDir(base))
+    return null;
+  let versions;
+  try {
+    versions = await readdir6(base);
+  } catch {
+    return null;
+  }
+  const chosen = preferredVersion && versions.includes(preferredVersion) ? preferredVersion : versions.sort().at(-1);
+  if (!chosen)
+    return null;
+  const versionDir = join21(base, chosen);
+  let hashDirs;
+  try {
+    hashDirs = await readdir6(versionDir);
+  } catch {
+    return null;
+  }
+  for (const hash of hashDirs) {
+    const candidate = join21(versionDir, hash, `${artifactId}-${chosen}.pom`);
+    return candidate;
+  }
+  return null;
+}
+async function resolveGradleIdentity(_workspaceAbs, _projectRoot, depName, hints = {}) {
+  const colon = depName.indexOf(":");
+  if (colon < 0)
+    return {};
+  const groupId = depName.slice(0, colon);
+  const artifactId = depName.slice(colon + 1);
+  if (!groupId || !artifactId)
+    return {};
+  const pomPath = await findGradlePom(groupId, artifactId, hints.resolved_version);
+  if (!pomPath)
+    return {};
+  return parsePomIdentity(pomPath, depName);
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/hex.js
+init_esm_shims();
+var import_errors12 = __toESM(require_dist2(), 1);
+import { readFile as readFile19 } from "fs/promises";
+import { join as join22 } from "path";
+var logger10 = (0, import_errors12.createMcpLogger)({ name: "@toolcairn/tools:resolver:hex" });
+function extractHexMetadataUrl(raw) {
+  let match = raw.match(/<<"GitHub">>\s*,\s*<<"([^"]+)">>/i);
+  if (match?.[1])
+    return match[1];
+  match = raw.match(/<<"[^"]*github[^"]*">>\s*,\s*<<"(https?:\/\/[^"]+)">>/i);
+  if (match?.[1])
+    return match[1];
+  return void 0;
+}
+function extractMixExsUrl(raw) {
+  const atMatch = raw.match(/@source_url\s*\(?\s*["']([^"']+)["']/);
+  if (atMatch?.[1])
+    return atMatch[1];
+  const kwMatch = raw.match(/\bsource_url\s*:\s*["']([^"']+)["']/);
+  if (kwMatch?.[1])
+    return kwMatch[1];
+  return void 0;
+}
+async function resolveHexIdentity(workspaceAbs, _projectRoot, depName) {
+  const depDir = join22(workspaceAbs, "deps", depName);
+  const out = {};
+  const metaPath = join22(depDir, "hex_metadata.config");
+  if (await fileExists(metaPath)) {
+    try {
+      const raw = await readFile19(metaPath, "utf-8");
+      const url = extractHexMetadataUrl(raw);
+      const normalised = normaliseGitHubUrl(url);
+      if (normalised)
+        out.github_url = normalised;
+    } catch (err) {
+      logger10.debug({ err: err instanceof Error ? err.message : String(err), metaPath }, "Failed to read hex_metadata.config");
+    }
+  }
+  if (!out.github_url) {
+    const mixPath = join22(depDir, "mix.exs");
+    if (await fileExists(mixPath)) {
+      try {
+        const raw = await readFile19(mixPath, "utf-8");
+        const url = extractMixExsUrl(raw);
+        const normalised = normaliseGitHubUrl(url);
+        if (normalised)
+          out.github_url = normalised;
+      } catch {
+      }
+    }
+  }
+  return out;
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/maven.js
+init_esm_shims();
+import { readdir as readdir7 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join23 } from "path";
+async function findMavenPom(groupId, artifactId, preferredVersion) {
+  const groupPath = groupId.replace(/\./g, "/");
+  const base = join23(homedir4(), ".m2", "repository", groupPath, artifactId);
+  if (!await isDir(base))
+    return null;
+  let versions;
+  try {
+    versions = await readdir7(base);
+  } catch {
+    return null;
+  }
+  let chosen;
+  if (preferredVersion && versions.includes(preferredVersion)) {
+    chosen = preferredVersion;
+  } else {
+    versions.sort();
+    chosen = versions[versions.length - 1];
+  }
+  if (!chosen)
+    return null;
+  return join23(base, chosen, `${artifactId}-${chosen}.pom`);
+}
+async function resolveMavenIdentity(_workspaceAbs, _projectRoot, depName, hints = {}) {
+  const colon = depName.indexOf(":");
+  if (colon < 0)
+    return {};
+  const groupId = depName.slice(0, colon);
+  const artifactId = depName.slice(colon + 1);
+  if (!groupId || !artifactId)
+    return {};
+  const pomPath = await findMavenPom(groupId, artifactId, hints.resolved_version);
+  if (!pomPath)
+    return {};
+  return parsePomIdentity(pomPath, depName);
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/npm.js
+init_esm_shims();
+var import_errors13 = __toESM(require_dist2(), 1);
+import { readFile as readFile20 } from "fs/promises";
+import { join as join24 } from "path";
+var logger11 = (0, import_errors13.createMcpLogger)({ name: "@toolcairn/tools:resolver:npm" });
+function extractRepoUrl(pkg) {
+  const r = pkg.repository;
+  if (!r)
+    return void 0;
+  if (typeof r === "string")
+    return r;
+  return r.url;
+}
+async function findInstalledManifest(workspaceAbs, projectRoot, depKey) {
+  let cursor = workspaceAbs;
+  const stopAt = projectRoot;
+  for (let i = 0; i < 10; i++) {
+    const candidate = join24(cursor, "node_modules", depKey, "package.json");
+    if (await fileExists(candidate))
+      return candidate;
+    if (cursor === stopAt)
+      break;
+    const parent = join24(cursor, "..");
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return null;
+}
+async function resolveNpmIdentity(workspaceAbs, projectRoot, depKey) {
+  const manifestPath = await findInstalledManifest(workspaceAbs, projectRoot, depKey);
+  if (!manifestPath)
+    return {};
+  let pkg;
+  try {
+    pkg = JSON.parse(await readFile20(manifestPath, "utf-8"));
+  } catch (err) {
+    logger11.debug({ err: err instanceof Error ? err.message : String(err), manifestPath }, "Failed to parse installed package.json \u2014 skipping url resolution");
+    return {};
+  }
+  const out = {};
+  if (pkg.name && pkg.name !== depKey) {
+    out.canonical_package_name = pkg.name;
+  }
+  if (pkg.version) {
+    out.resolved_version = pkg.version;
+  }
+  const url = extractRepoUrl(pkg);
+  const normalised = normaliseGitHubUrl(url);
+  if (normalised)
+    out.github_url = normalised;
+  return out;
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/nuget.js
+init_esm_shims();
+var import_errors14 = __toESM(require_dist2(), 1);
+import { readFile as readFile21, readdir as readdir8 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { join as join25 } from "path";
+import { XMLParser as XMLParser4 } from "fast-xml-parser";
+var logger12 = (0, import_errors14.createMcpLogger)({ name: "@toolcairn/tools:resolver:nuget" });
+async function findNuspec(depName, preferredVersion) {
+  const pkgRoot = join25(homedir5(), ".nuget", "packages", depName.toLowerCase());
+  if (!await isDir(pkgRoot))
+    return null;
+  let versions;
+  try {
+    versions = await readdir8(pkgRoot);
+  } catch {
+    return null;
+  }
+  const chosen = preferredVersion && versions.includes(preferredVersion) ? preferredVersion : versions.sort().at(-1);
+  if (!chosen)
+    return null;
+  const path2 = join25(pkgRoot, chosen, `${depName.toLowerCase()}.nuspec`);
+  return await fileExists(path2) ? path2 : null;
+}
+async function resolveNugetIdentity(_workspaceAbs, _projectRoot, depName, hints = {}) {
+  const path2 = await findNuspec(depName, hints.resolved_version);
+  if (!path2)
+    return {};
+  try {
+    const raw = await readFile21(path2, "utf-8");
+    const parser = new XMLParser4({ ignoreAttributes: false });
+    const doc = parser.parse(raw);
+    const meta = doc.package?.metadata;
+    if (!meta)
+      return {};
+    const out = {};
+    if (meta.id && meta.id !== depName)
+      out.canonical_package_name = meta.id;
+    if (meta.version)
+      out.resolved_version = meta.version;
+    const repoUrl = meta.repository?.["@_url"] ?? meta.repository?.url;
+    const candidate = normaliseGitHubUrl(repoUrl ?? meta.projectUrl);
+    if (candidate)
+      out.github_url = candidate;
+    return out;
+  } catch (err) {
+    logger12.debug({ err: err instanceof Error ? err.message : String(err), path: path2 }, "Failed to parse .nuspec");
+    return {};
+  }
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/pub.js
+init_esm_shims();
+var import_errors15 = __toESM(require_dist2(), 1);
+import { readFile as readFile22 } from "fs/promises";
+import { homedir as homedir6, platform as platform2 } from "os";
+import { join as join26 } from "path";
+import { parse as parseYaml3 } from "yaml";
+var logger13 = (0, import_errors15.createMcpLogger)({ name: "@toolcairn/tools:resolver:pub" });
+function pubCacheRoot() {
+  if (platform2() === "win32") {
+    const local = process.env.LOCALAPPDATA;
+    if (local)
+      return join26(local, "Pub", "Cache", "hosted", "pub.dev");
+  }
+  return join26(homedir6(), ".pub-cache", "hosted", "pub.dev");
+}
+async function findPubspec(depName, version) {
+  const root = pubCacheRoot();
+  if (version) {
+    const direct = join26(root, `${depName}-${version}`, "pubspec.yaml");
+    return await fileExists(direct) ? direct : null;
+  }
+  try {
+    const { readdir: readdir12 } = await import("fs/promises");
+    const entries = await readdir12(root);
+    const matches = entries.filter((e) => e.startsWith(`${depName}-`)).sort();
+    const chosen = matches.at(-1);
+    if (!chosen)
+      return null;
+    const candidate = join26(root, chosen, "pubspec.yaml");
+    return await fileExists(candidate) ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+async function resolvePubIdentity(_workspaceAbs, _projectRoot, depName, hints = {}) {
+  const path2 = await findPubspec(depName, hints.resolved_version);
+  if (!path2)
+    return {};
+  try {
+    const raw = await readFile22(path2, "utf-8");
+    const pkg = parseYaml3(raw);
+    const out = {};
+    if (pkg.name && pkg.name !== depName)
+      out.canonical_package_name = pkg.name;
+    if (pkg.version)
+      out.resolved_version = pkg.version;
+    const candidate = normaliseGitHubUrl(pkg.repository ?? pkg.homepage);
+    if (candidate)
+      out.github_url = candidate;
+    return out;
+  } catch (err) {
+    logger13.debug({ err: err instanceof Error ? err.message : String(err), path: path2 }, "Failed to parse pubspec.yaml");
+    return {};
+  }
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/pypi.js
+init_esm_shims();
+var import_errors16 = __toESM(require_dist2(), 1);
+import { readFile as readFile23, readdir as readdir9 } from "fs/promises";
+import { join as join27 } from "path";
+var logger14 = (0, import_errors16.createMcpLogger)({ name: "@toolcairn/tools:resolver:pypi" });
+async function findSitePackagesDirs(workspaceAbs) {
+  const candidates = [];
+  const venvs = [".venv", "venv", ".virtualenv"];
+  for (const venv of venvs) {
+    const venvDir = join27(workspaceAbs, venv);
+    if (!await isDir(venvDir))
+      continue;
+    const winSite = join27(venvDir, "Lib", "site-packages");
+    if (await isDir(winSite))
+      candidates.push(winSite);
+    const libDir = join27(venvDir, "lib");
+    if (await isDir(libDir)) {
+      try {
+        for (const entry of await readdir9(libDir)) {
+          if (!entry.startsWith("python"))
+            continue;
+          const sp = join27(libDir, entry, "site-packages");
+          if (await isDir(sp))
+            candidates.push(sp);
+        }
+      } catch {
+      }
+    }
+  }
+  return candidates;
+}
+function normalisePypiName(name) {
+  return name.toLowerCase().replace(/[._]+/g, "-");
+}
+async function findMetadataPath(siteDir, depName) {
+  const normalised = normalisePypiName(depName);
+  let entries;
+  try {
+    entries = await readdir9(siteDir);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (!entry.endsWith(".dist-info"))
+      continue;
+    const base = entry.replace(/-[^-]+\.dist-info$/, "");
+    if (normalisePypiName(base) === normalised) {
+      const metadataPath = join27(siteDir, entry, "METADATA");
+      if (await fileExists(metadataPath))
+        return metadataPath;
+    }
+  }
+  return null;
+}
+function parseMetadata(raw) {
+  const urls = [];
+  let name;
+  let version;
+  const lines = raw.split("\n");
+  for (const line of lines) {
+    if (line.trim() === "")
+      break;
+    const colon = line.indexOf(":");
+    if (colon < 0)
+      continue;
+    const key = line.slice(0, colon).trim();
+    const val = line.slice(colon + 1).trim();
+    if (key === "Name" && !name)
+      name = val;
+    else if (key === "Version" && !version)
+      version = val;
+    else if (key === "Home-page")
+      urls.push(val);
+    else if (key === "Project-URL") {
+      const comma = val.indexOf(",");
+      if (comma >= 0)
+        urls.push(val.slice(comma + 1).trim());
+      else
+        urls.push(val);
+    }
+  }
+  return { name, version, urls };
+}
+async function resolvePypiIdentity(workspaceAbs, _projectRoot, depName) {
+  const siteDirs = await findSitePackagesDirs(workspaceAbs);
+  for (const siteDir of siteDirs) {
+    const path2 = await findMetadataPath(siteDir, depName);
+    if (!path2)
+      continue;
+    try {
+      const raw = await readFile23(path2, "utf-8");
+      const { name, version, urls } = parseMetadata(raw);
+      const out = {};
+      if (name && normalisePypiName(name) !== normalisePypiName(depName)) {
+        out.canonical_package_name = name;
+      }
+      if (version)
+        out.resolved_version = version;
+      for (const u of urls) {
+        const normalised = normaliseGitHubUrl(u);
+        if (normalised) {
+          out.github_url = normalised;
+          break;
+        }
+      }
+      return out;
+    } catch (err) {
+      logger14.debug({ err: err instanceof Error ? err.message : String(err), path: path2 }, "Failed to parse METADATA");
+    }
+  }
+  return {};
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/ruby.js
+init_esm_shims();
+var import_errors17 = __toESM(require_dist2(), 1);
+import { readFile as readFile24, readdir as readdir10 } from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { join as join28 } from "path";
+var logger15 = (0, import_errors17.createMcpLogger)({ name: "@toolcairn/tools:resolver:ruby" });
+async function findGemspec(workspaceAbs, depName, preferredVersion) {
+  const specsDirs = [];
+  const bundleRubyDir = join28(workspaceAbs, "vendor", "bundle", "ruby");
+  if (await isDir(bundleRubyDir)) {
+    try {
+      for (const entry of await readdir10(bundleRubyDir)) {
+        const dir = join28(bundleRubyDir, entry, "specifications");
+        if (await isDir(dir))
+          specsDirs.push(dir);
+      }
+    } catch {
+    }
+  }
+  const homeSpecs = join28(homedir7(), ".gem", "specifications");
+  if (await isDir(homeSpecs))
+    specsDirs.push(homeSpecs);
+  for (const dir of specsDirs) {
+    let entries;
+    try {
+      entries = await readdir10(dir);
+    } catch {
+      continue;
+    }
+    const matches = entries.filter((e) => e.endsWith(".gemspec") && e.startsWith(`${depName}-`)).filter((e) => {
+      if (!preferredVersion)
+        return true;
+      return e === `${depName}-${preferredVersion}.gemspec`;
+    }).sort();
+    const chosen = matches.at(-1);
+    if (chosen) {
+      const path2 = join28(dir, chosen);
+      if (await fileExists(path2))
+        return path2;
+    }
+  }
+  return null;
+}
+function extractGemspecFields(raw) {
+  const out = {};
+  const pick = (pattern) => {
+    const m = raw.match(pattern);
+    return m ? m[1] : void 0;
+  };
+  out.name = pick(/(?:s|spec)\.name\s*=\s*(['"])([^'"]+)\1/) ? raw.match(/(?:s|spec)\.name\s*=\s*['"]([^'"]+)['"]/)?.[1] : void 0;
+  out.version = raw.match(/(?:s|spec)\.version\s*=\s*['"]([^'"]+)['"]/)?.[1];
+  out.homepage = raw.match(/(?:s|spec)\.homepage\s*=\s*['"]([^'"]+)['"]/)?.[1];
+  out.source_code_uri = raw.match(/["']source_code_uri["']\s*=>\s*["']([^'"]+)["']/)?.[1];
+  return out;
+}
+async function resolveRubyIdentity(workspaceAbs, _projectRoot, depName, hints = {}) {
+  const path2 = await findGemspec(workspaceAbs, depName, hints.resolved_version);
+  if (!path2)
+    return {};
+  try {
+    const raw = await readFile24(path2, "utf-8");
+    const fields = extractGemspecFields(raw);
+    const out = {};
+    if (fields.name && fields.name !== depName)
+      out.canonical_package_name = fields.name;
+    if (fields.version)
+      out.resolved_version = fields.version;
+    const candidate = normaliseGitHubUrl(fields.source_code_uri ?? fields.homepage);
+    if (candidate)
+      out.github_url = candidate;
+    return out;
+  } catch (err) {
+    logger15.debug({ err: err instanceof Error ? err.message : String(err), path: path2 }, "Failed to read/parse gemspec");
+    return {};
+  }
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/swift-pm.js
+init_esm_shims();
+var import_errors18 = __toESM(require_dist2(), 1);
+import { readFile as readFile25 } from "fs/promises";
+import { join as join29 } from "path";
+var logger16 = (0, import_errors18.createMcpLogger)({ name: "@toolcairn/tools:resolver:swift-pm" });
+async function resolveSwiftPmIdentity(workspaceAbs, _projectRoot, depName) {
+  const path2 = join29(workspaceAbs, "Package.resolved");
+  if (!await fileExists(path2))
+    return {};
+  try {
+    const raw = await readFile25(path2, "utf-8");
+    const doc = JSON.parse(raw);
+    const out = {};
+    for (const pin of doc.pins ?? []) {
+      if (pin.identity === depName) {
+        if (pin.state?.version)
+          out.resolved_version = pin.state.version;
+        const normalised = normaliseGitHubUrl(pin.location);
+        if (normalised)
+          out.github_url = normalised;
+        return out;
+      }
+    }
+    for (const pin of doc.object?.pins ?? []) {
+      if (pin.package === depName) {
+        if (pin.state?.version)
+          out.resolved_version = pin.state.version;
+        const normalised = normaliseGitHubUrl(pin.repositoryURL);
+        if (normalised)
+          out.github_url = normalised;
+        return out;
+      }
+    }
+    return {};
+  } catch (err) {
+    logger16.debug({ err: err instanceof Error ? err.message : String(err), path: path2 }, "Failed to parse Package.resolved during resolve");
+    return {};
+  }
+}
+
+// ../../packages/tools-local/dist/discovery/resolvers/index.js
+var RESOLVERS = {
+  npm: resolveNpmIdentity,
+  pypi: resolvePypiIdentity,
+  cargo: resolveCargoIdentity,
+  go: (w, p, n) => resolveGoIdentity(w, p, n),
+  rubygems: resolveRubyIdentity,
+  maven: resolveMavenIdentity,
+  gradle: resolveGradleIdentity,
+  composer: resolveComposerIdentity,
+  hex: resolveHexIdentity,
+  pub: resolvePubIdentity,
+  nuget: resolveNugetIdentity,
+  "swift-pm": resolveSwiftPmIdentity
+};
+
 // ../../packages/tools-local/dist/discovery/workspaces/glob.js
 init_esm_shims();
-import { readdir as readdir5 } from "fs/promises";
-import { join as join19, relative as relative3, sep as sep2 } from "path";
+import { readdir as readdir11 } from "fs/promises";
+import { join as join30, relative as relative3, sep as sep2 } from "path";
 async function expandWorkspaceGlobs(rootDir, patterns) {
   const excluded = /* @__PURE__ */ new Set();
   const included = /* @__PURE__ */ new Set();
@@ -3454,11 +4198,11 @@ async function walkPattern(rootDir, currentDir, parts, index, out) {
   if (segment === "**") {
     await walkPattern(rootDir, currentDir, parts, index + 1, out);
     try {
-      const entries = await readdir5(currentDir, { withFileTypes: true });
+      const entries = await readdir11(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory() || IGNORED_DIRS.has(entry.name))
           continue;
-        await walkPattern(rootDir, join19(currentDir, entry.name), parts, index, out);
+        await walkPattern(rootDir, join30(currentDir, entry.name), parts, index, out);
       }
     } catch {
     }
@@ -3467,19 +4211,19 @@ async function walkPattern(rootDir, currentDir, parts, index, out) {
   if (segment.includes("*")) {
     const re = globSegmentToRegex(segment);
     try {
-      const entries = await readdir5(currentDir, { withFileTypes: true });
+      const entries = await readdir11(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory() || IGNORED_DIRS.has(entry.name))
           continue;
         if (re.test(entry.name)) {
-          await walkPattern(rootDir, join19(currentDir, entry.name), parts, index + 1, out);
+          await walkPattern(rootDir, join30(currentDir, entry.name), parts, index + 1, out);
         }
       }
     } catch {
     }
     return;
   }
-  await walkPattern(rootDir, join19(currentDir, segment), parts, index + 1, out);
+  await walkPattern(rootDir, join30(currentDir, segment), parts, index + 1, out);
 }
 function globSegmentToRegex(segment) {
   const escaped = segment.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
@@ -3492,10 +4236,10 @@ function toRelPosix(projectRoot, absPath) {
 
 // ../../packages/tools-local/dist/discovery/workspaces/walker.js
 init_esm_shims();
-import { readFile as readFile16 } from "fs/promises";
-import { join as join20 } from "path";
-import { parse as parseToml3 } from "smol-toml";
-import { parse as parseYaml3 } from "yaml";
+import { readFile as readFile26 } from "fs/promises";
+import { join as join31 } from "path";
+import { parse as parseToml4 } from "smol-toml";
+import { parse as parseYaml4 } from "yaml";
 async function discoverWorkspaces(projectRoot, maxDepth = 5) {
   const warnings = [];
   const discovered = /* @__PURE__ */ new Set([projectRoot]);
@@ -3521,10 +4265,10 @@ async function discoverWorkspaces(projectRoot, maxDepth = 5) {
 }
 async function readWorkspaceGlobs(dir, warnings) {
   const globs = [];
-  const pnpmPath = join20(dir, "pnpm-workspace.yaml");
+  const pnpmPath = join31(dir, "pnpm-workspace.yaml");
   if (await fileExists(pnpmPath)) {
     try {
-      const doc = parseYaml3(await readFile16(pnpmPath, "utf-8"));
+      const doc = parseYaml4(await readFile26(pnpmPath, "utf-8"));
       if (Array.isArray(doc.packages))
         globs.push(...doc.packages);
     } catch (err) {
@@ -3535,10 +4279,10 @@ async function readWorkspaceGlobs(dir, warnings) {
       });
     }
   }
-  const pkgPath = join20(dir, "package.json");
+  const pkgPath = join31(dir, "package.json");
   if (await fileExists(pkgPath)) {
     try {
-      const doc = JSON.parse(await readFile16(pkgPath, "utf-8"));
+      const doc = JSON.parse(await readFile26(pkgPath, "utf-8"));
       if (Array.isArray(doc.workspaces)) {
         globs.push(...doc.workspaces);
       } else if (doc.workspaces && Array.isArray(doc.workspaces.packages)) {
@@ -3552,10 +4296,10 @@ async function readWorkspaceGlobs(dir, warnings) {
       });
     }
   }
-  const cargoPath = join20(dir, "Cargo.toml");
+  const cargoPath = join31(dir, "Cargo.toml");
   if (await fileExists(cargoPath)) {
     try {
-      const doc = parseToml3(await readFile16(cargoPath, "utf-8"));
+      const doc = parseToml4(await readFile26(cargoPath, "utf-8"));
       if (Array.isArray(doc.workspace?.members))
         globs.push(...doc.workspace.members);
     } catch (err) {
@@ -3566,10 +4310,10 @@ async function readWorkspaceGlobs(dir, warnings) {
       });
     }
   }
-  const goWorkPath = join20(dir, "go.work");
+  const goWorkPath = join31(dir, "go.work");
   if (await fileExists(goWorkPath)) {
     try {
-      const raw = await readFile16(goWorkPath, "utf-8");
+      const raw = await readFile26(goWorkPath, "utf-8");
       const useMatch = raw.match(/use\s*\(([^)]*)\)/s);
       if (useMatch?.[1]) {
         for (const line of useMatch[1].split("\n")) {
@@ -3592,10 +4336,10 @@ async function readWorkspaceGlobs(dir, warnings) {
       });
     }
   }
-  const lernaPath = join20(dir, "lerna.json");
+  const lernaPath = join31(dir, "lerna.json");
   if (await fileExists(lernaPath)) {
     try {
-      const doc = JSON.parse(await readFile16(lernaPath, "utf-8"));
+      const doc = JSON.parse(await readFile26(lernaPath, "utf-8"));
       if (Array.isArray(doc.packages))
         globs.push(...doc.packages);
     } catch (err) {
@@ -3606,10 +4350,10 @@ async function readWorkspaceGlobs(dir, warnings) {
       });
     }
   }
-  const nxPath = join20(dir, "nx.json");
+  const nxPath = join31(dir, "nx.json");
   if (await fileExists(nxPath)) {
     try {
-      const doc = JSON.parse(await readFile16(nxPath, "utf-8"));
+      const doc = JSON.parse(await readFile26(nxPath, "utf-8"));
       const base = doc.workspaceLayout?.projectsDir ?? "packages";
       globs.push(`${base}/*`);
     } catch (err) {
@@ -3624,13 +4368,13 @@ async function readWorkspaceGlobs(dir, warnings) {
 }
 
 // ../../packages/tools-local/dist/discovery/scan-project.js
-var logger7 = (0, import_errors9.createMcpLogger)({ name: "@toolcairn/tools:scan-project" });
+var logger17 = (0, import_errors19.createMcpLogger)({ name: "@toolcairn/tools:scan-project" });
 async function scanProject(projectRoot, options = {}) {
   const start = Date.now();
   const { batchResolve, maxDepth = 5 } = options;
   const absRoot = resolve(projectRoot);
   const warnings = [];
-  logger7.info({ projectRoot: absRoot }, "Starting project scan");
+  logger17.info({ projectRoot: absRoot }, "Starting project scan");
   const { paths: workspaceAbs, warnings: wsWarnings } = await discoverWorkspaces(absRoot, maxDepth);
   warnings.push(...wsWarnings);
   const allDetected = [];
@@ -3688,9 +4432,41 @@ async function scanProject(projectRoot, options = {}) {
       mergedMap.set(key, { name: dep.name, ecosystem: dep.ecosystem, locations: [location] });
     }
   }
+  await Promise.all([...mergedMap.values()].map(async (entry) => {
+    const resolver = RESOLVERS[entry.ecosystem];
+    if (!resolver)
+      return;
+    for (const loc of entry.locations) {
+      const workspaceAbs2 = resolve(absRoot, loc.workspace_path);
+      const hints = { resolved_version: loc.resolved_version };
+      try {
+        const identity = await resolver(workspaceAbs2, absRoot, entry.name, hints);
+        if (identity.canonical_package_name) {
+          entry.canonical_package_name = identity.canonical_package_name;
+        }
+        if (identity.github_url) {
+          entry.local_github_url = identity.github_url;
+        }
+        if (identity.canonical_package_name || identity.github_url)
+          break;
+      } catch (err) {
+        logger17.debug({
+          ecosystem: entry.ecosystem,
+          name: entry.name,
+          workspace: loc.workspace_path,
+          err: err instanceof Error ? err.message : String(err)
+        }, "Resolver threw \u2014 skipping this location");
+      }
+    }
+  }));
   const workspaceRels = workspaceAbs.map((abs) => toRelPosix(absRoot, abs));
   const languages = await detectLanguages(absRoot, workspaceRels);
-  const resolveInputs = [...mergedMap.values()].map(({ name: name2, ecosystem }) => ({ name: name2, ecosystem }));
+  const resolveInputs = [...mergedMap.values()].map(({ name: name2, ecosystem, canonical_package_name, local_github_url }) => ({
+    name: name2,
+    ecosystem,
+    canonical_package_name,
+    github_url: local_github_url
+  }));
   const resolved = /* @__PURE__ */ new Map();
   const methods = /* @__PURE__ */ new Map();
   const githubUrls = /* @__PURE__ */ new Map();
@@ -3722,7 +4498,7 @@ async function scanProject(projectRoot, options = {}) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const confirmed = [];
   let toolsResolvedCount = 0;
-  for (const { name: name2, ecosystem, locations } of mergedMap.values()) {
+  for (const { name: name2, ecosystem, locations, local_github_url } of mergedMap.values()) {
     const key = `${ecosystem}:${name2}`;
     const graph = resolved.get(key);
     const matchMethod = methods.get(key) ?? "none";
@@ -3732,7 +4508,7 @@ async function scanProject(projectRoot, options = {}) {
     const source = matched ? "toolcairn" : "non_oss";
     const canonical = graph?.tool?.canonical_name;
     const categories = graph?.tool?.categories;
-    const github_url = githubUrls.get(key);
+    const github_url = githubUrls.get(key) ?? local_github_url;
     const version = locations.find((l) => l.resolved_version)?.resolved_version ?? locations[0]?.version_constraint;
     confirmed.push({
       name: name2,
@@ -3764,7 +4540,7 @@ async function scanProject(projectRoot, options = {}) {
     duration_ms: Date.now() - start,
     completed_at: now
   };
-  logger7.info({
+  logger17.info({
     projectRoot: absRoot,
     workspaces: workspaceAbs.length,
     ecosystems: scan_metadata.ecosystems_scanned,
@@ -3816,7 +4592,7 @@ async function inferProjectName(projectRoot) {
   const pkgPath = resolve(projectRoot, "package.json");
   if (await fileExists(pkgPath)) {
     try {
-      const doc = JSON.parse(await readFile17(pkgPath, "utf-8"));
+      const doc = JSON.parse(await readFile27(pkgPath, "utf-8"));
       if (doc.name)
         return doc.name;
     } catch {
@@ -3998,10 +4774,10 @@ function getOpenCodeMcpEntry(serverPath) {
 }
 
 // ../../packages/tools-local/dist/handlers/toolcairn-init.js
-var logger8 = (0, import_errors10.createMcpLogger)({ name: "@toolcairn/tools:toolcairn-init" });
+var logger18 = (0, import_errors20.createMcpLogger)({ name: "@toolcairn/tools:toolcairn-init" });
 async function handleToolcairnInit(args, deps = {}) {
   try {
-    logger8.info({ agent: args.agent, project_root: args.project_root }, "toolcairn_init called");
+    logger18.info({ agent: args.agent, project_root: args.project_root }, "toolcairn_init called");
     const scan = await scanProject(args.project_root, { batchResolve: deps.batchResolve });
     const audit = {
       action: "init",
@@ -4072,22 +4848,22 @@ async function handleToolcairnInit(args, deps = {}) {
       next_steps: "Config written. Apply the setup_steps above (CLAUDE.md rules + .mcp.json merge + .gitignore). Then proceed with normal tool calls \u2014 the server owns .toolcairn/ going forward."
     });
   } catch (e) {
-    logger8.error({ err: e }, "toolcairn_init failed");
+    logger18.error({ err: e }, "toolcairn_init failed");
     return errResult("init_error", e instanceof Error ? e.message : String(e));
   }
 }
 
 // ../../packages/tools-local/dist/handlers/read-project-config.js
 init_esm_shims();
-var import_errors11 = __toESM(require_dist2(), 1);
-var logger9 = (0, import_errors11.createMcpLogger)({ name: "@toolcairn/tools:read-project-config" });
+var import_errors21 = __toESM(require_dist2(), 1);
+var logger19 = (0, import_errors21.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);
 }
 async function handleReadProjectConfig(args) {
   try {
-    logger9.info({ project_root: args.project_root }, "read_project_config called");
+    logger19.info({ project_root: args.project_root }, "read_project_config called");
     const { config: initial, corrupt_backup_path } = await readConfig(args.project_root);
     if (!initial) {
       return okResult({
@@ -4170,18 +4946,18 @@ async function handleReadProjectConfig(args) {
       agent_instructions: instructions_lines.join("\n")
     });
   } catch (e) {
-    logger9.error({ err: e }, "read_project_config failed");
+    logger19.error({ err: e }, "read_project_config failed");
     return errResult("read_config_error", e instanceof Error ? e.message : String(e));
   }
 }
 
 // ../../packages/tools-local/dist/handlers/update-project-config.js
 init_esm_shims();
-var import_errors12 = __toESM(require_dist2(), 1);
-var logger10 = (0, import_errors12.createMcpLogger)({ name: "@toolcairn/tools:update-project-config" });
+var import_errors22 = __toESM(require_dist2(), 1);
+var logger20 = (0, import_errors22.createMcpLogger)({ name: "@toolcairn/tools:update-project-config" });
 async function handleUpdateProjectConfig(args) {
   try {
-    logger10.info({ project_root: args.project_root, action: args.action, tool: args.tool_name }, "update_project_config called");
+    logger20.info({ project_root: args.project_root, action: args.action, tool: args.tool_name }, "update_project_config called");
     const data = args.data ?? {};
     let notFound = false;
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -4266,7 +5042,7 @@ async function handleUpdateProjectConfig(args) {
       audit_log_path: ".toolcairn/audit-log.jsonl"
     });
   } catch (e) {
-    logger10.error({ err: e }, "update_project_config failed");
+    logger20.error({ err: e }, "update_project_config failed");
     return errResult("update_config_error", e instanceof Error ? e.message : String(e));
   }
 }
@@ -4289,10 +5065,10 @@ import { z as z2 } from "zod";
 // src/middleware/event-logger.ts
 init_esm_shims();
 var import_config = __toESM(require_dist(), 1);
-var import_errors13 = __toESM(require_dist2(), 1);
+var import_errors23 = __toESM(require_dist2(), 1);
 import { appendFile as appendFile2, mkdir as mkdir6 } from "fs/promises";
 import { dirname } from "path";
-var logger11 = (0, import_errors13.createMcpLogger)({ name: "@toolcairn/mcp-server:event-logger" });
+var logger21 = (0, import_errors23.createMcpLogger)({ name: "@toolcairn/mcp-server:event-logger" });
 function isTrackingEnabled() {
   return process.env.TOOLCAIRN_TRACKING_ENABLED !== "false";
 }
@@ -4336,7 +5112,7 @@ async function writeToFile(eventsPath, event) {
     await appendFile2(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch (e) {
-    logger11.warn({ err: e, path: eventsPath }, "Failed to write event to JSONL file");
+    logger21.warn({ err: e, path: eventsPath }, "Failed to write event to JSONL file");
   }
 }
 async function sendToApi(event) {
@@ -4358,7 +5134,7 @@ async function sendToApi(event) {
       })
     });
   } catch (e) {
-    logger11.debug({ err: e }, "Failed to send event to API \u2014 non-fatal");
+    logger21.debug({ err: e }, "Failed to send event to API \u2014 non-fatal");
   }
 }
 function withEventLogging(toolName, handler) {
@@ -4399,7 +5175,7 @@ function withEventLogging(toolName, handler) {
 }
 
 // src/server.prod.ts
-var logger12 = (0, import_errors14.createMcpLogger)({ name: "@toolcairn/mcp-server:prod" });
+var logger22 = (0, import_errors24.createMcpLogger)({ name: "@toolcairn/mcp-server:prod" });
 var SETUP_INSTRUCTIONS = `
 # ToolCairn \u2014 Agent Setup Instructions
 
@@ -4465,9 +5241,9 @@ async function addToolsToServer(server) {
     apiKey: creds.client_id,
     accessToken: creds.access_token
   });
-  logger12.info({ user: creds.user_email }, "Registering production tools");
+  logger22.info({ user: creds.user_email }, "Registering production tools");
   function wrap(toolName, fn) {
-    return withEventLogging(toolName, (0, import_errors14.withErrorHandling)(toolName, logger12, fn));
+    return withEventLogging(toolName, (0, import_errors24.withErrorHandling)(toolName, logger22, fn));
   }
   server.registerTool(
     "classify_prompt",
@@ -4687,14 +5463,14 @@ function createTransport() {
 
 // src/index.prod.ts
 process.env.TOOLPILOT_MODE = "production";
-var logger13 = (0, import_errors15.createMcpLogger)({ name: "@toolcairn/mcp-server" });
+var logger23 = (0, import_errors25.createMcpLogger)({ name: "@toolcairn/mcp-server" });
 async function main() {
   await ensureProjectSetup();
   const creds = await loadCredentials();
   const authenticated = creds !== null && isTokenValid(creds);
   let server;
   if (authenticated) {
-    logger13.info({ user: creds.user_email }, "Authenticated \u2014 starting full server");
+    logger23.info({ user: creds.user_email }, "Authenticated \u2014 starting full server");
     server = await buildProdServer();
   } else {
     let verificationUri = "https://toolcairn.neurynae.com/signup";
@@ -4704,15 +5480,15 @@ async function main() {
       if (pending) {
         verificationUri = pending.verification_uri;
         userCode = pending.user_code;
-        logger13.info({ userCode }, "Resuming pending sign-in");
+        logger23.info({ userCode }, "Resuming pending sign-in");
       } else {
         const codeData = await requestDeviceCode(import_config4.config.TOOLPILOT_API_URL);
         verificationUri = codeData.verification_uri;
         userCode = codeData.user_code;
-        logger13.info({ userCode }, "New sign-in started");
+        logger23.info({ userCode }, "New sign-in started");
       }
     } catch (err) {
-      logger13.error({ err }, "Could not reach ToolCairn API \u2014 check your connection");
+      logger23.error({ err }, "Could not reach ToolCairn API \u2014 check your connection");
     }
     const instructions = userCode ? `# ToolCairn \u2014 Sign In Required
 
@@ -4744,23 +5520,23 @@ Open the URL, sign in, and confirm the code shown. All 14 tools will appear auto
       })
     );
     startDeviceAuth(import_config4.config.TOOLPILOT_API_URL).then(async () => {
-      logger13.info("Sign-in complete \u2014 adding all tools to running server");
+      logger23.info("Sign-in complete \u2014 adding all tools to running server");
       try {
         await addToolsToServer(server);
-        logger13.info("All ToolCairn tools now available");
+        logger23.info("All ToolCairn tools now available");
       } catch (err) {
-        logger13.error({ err }, "Failed to add tools after sign-in \u2014 please reconnect");
+        logger23.error({ err }, "Failed to add tools after sign-in \u2014 please reconnect");
       }
     }).catch((err) => {
-      logger13.error({ err }, "Sign-in failed \u2014 please try again");
+      logger23.error({ err }, "Sign-in failed \u2014 please try again");
     });
   }
   const transport = createTransport();
   await server.connect(transport);
-  logger13.info(authenticated ? "ToolCairn MCP ready" : "ToolCairn MCP ready (awaiting sign-in)");
+  logger23.info(authenticated ? "ToolCairn MCP ready" : "ToolCairn MCP ready (awaiting sign-in)");
 }
 main().catch((error) => {
-  (0, import_errors15.createMcpLogger)({ name: "@toolcairn/mcp-server" }).error(
+  (0, import_errors25.createMcpLogger)({ name: "@toolcairn/mcp-server" }).error(
     { err: error },
     "Failed to start MCP server"
   );