repowisestage 0.0.46 → 0.0.47

package/dist/bin/repowise.js

@@ -721,6 +721,200 @@ var init_registry = __esm({
   }
 });
 
+// ../listener/dist/lsp/installer.js
+import { promises as fs } from "fs";
+import { join as join14, dirname as dirname5 } from "path";
+import { spawn as spawn3 } from "child_process";
+function getLspInstallDir() {
+  return join14(getConfigDir(), "lsp-servers");
+}
+function getLspBinDir() {
+  return join14(getLspInstallDir(), "node_modules", ".bin");
+}
+async function ensureNpmLspInstalled(config2) {
+  if (!config2.npmPackage)
+    return { installed: false, skipped: "no-npm-package" };
+  const installDir = getLspInstallDir();
+  const binPath = join14(installDir, "node_modules", ".bin", config2.command);
+  if (await pathExists(binPath)) {
+    return { installed: false, skipped: "already-present" };
+  }
+  try {
+    await fs.mkdir(installDir, { recursive: true });
+    const pkgJsonPath = join14(installDir, "package.json");
+    if (!await pathExists(pkgJsonPath)) {
+      await fs.writeFile(pkgJsonPath, JSON.stringify({ name: "repowise-lsp-servers", private: true, version: "0.0.0" }, null, 2), "utf-8");
+    }
+    await runNpmInstall(installDir, config2.npmPackage);
+    if (!await pathExists(binPath)) {
+      return {
+        installed: false,
+        error: `npm install completed but ${config2.command} still not at ${binPath}`
+      };
+    }
+    return { installed: true };
+  } catch (err) {
+    return {
+      installed: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function resolveNpmCommand() {
+  const nodeDir = dirname5(process.execPath);
+  for (const candidate of [join14(nodeDir, "npm"), join14(nodeDir, "npm.cmd")]) {
+    try {
+      await fs.access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  for (const candidate of ["/opt/homebrew/bin/npm", "/usr/local/bin/npm", "/usr/bin/npm"]) {
+    try {
+      await fs.access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return "npm";
+}
+async function runNpmInstall(cwd, pkg2) {
+  const npmCmd = await resolveNpmCommand();
+  const nodeDir = dirname5(process.execPath);
+  const augmentedPath = process.env.PATH ? `${nodeDir}:${process.env.PATH}` : nodeDir;
+  return new Promise((resolve4, reject) => {
+    const child = spawn3(npmCmd, ["install", "--no-audit", "--no-fund", "--silent", pkg2], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, PATH: augmentedPath }
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (err) => reject(err));
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve4();
+      } else {
+        reject(new Error(`npm install ${pkg2} exited ${(code ?? -1).toString()}: ${sanitizeNpmStderr(stderr)}`));
+      }
+    });
+  });
+}
+function sanitizeNpmStderr(raw) {
+  const truncated = raw.split("\n").slice(0, 3).join(" ").trim();
+  return truncated.replace(/(https?:\/\/)[^@\s/]*@/g, (_match, scheme) => `${scheme}<redacted>@`);
+}
+async function pathExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectRepoLanguages(repoRoot) {
+  const found = /* @__PURE__ */ new Set();
+  let inspected = 0;
+  const MAX_INSPECT = 200;
+  async function inspect(dir) {
+    if (inspected >= MAX_INSPECT)
+      return;
+    let entries;
+    try {
+      entries = await fs.readdir(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (inspected >= MAX_INSPECT)
+        return;
+      if (name.startsWith("."))
+        continue;
+      if (name === "node_modules" || name === "dist" || name === "build")
+        continue;
+      const lang = detectLanguage(name);
+      if (lang) {
+        found.add(lang);
+        inspected += 1;
+      }
+    }
+  }
+  await inspect(repoRoot);
+  let topEntries = [];
+  try {
+    topEntries = await fs.readdir(repoRoot);
+  } catch {
+    return found;
+  }
+  for (const name of topEntries) {
+    if (name.startsWith("."))
+      continue;
+    if (name === "node_modules" || name === "dist" || name === "build")
+      continue;
+    const sub = join14(repoRoot, name);
+    try {
+      const stat7 = await fs.stat(sub);
+      if (stat7.isDirectory())
+        await inspect(sub);
+    } catch {
+    }
+  }
+  return found;
+}
+async function prepareLspServersForRepos(repos) {
+  const detected = /* @__PURE__ */ new Set();
+  for (const r of repos) {
+    if (!r.localPath)
+      continue;
+    try {
+      const stat7 = await fs.stat(r.localPath);
+      if (!stat7.isDirectory())
+        continue;
+    } catch {
+      continue;
+    }
+    try {
+      const langs = await detectRepoLanguages(r.localPath);
+      for (const l of langs)
+        detected.add(l);
+    } catch {
+    }
+  }
+  const results = [];
+  for (const language of detected) {
+    const configs = LSP_REGISTRY[language];
+    const npmConfig = configs.find((c) => c.npmPackage);
+    if (!npmConfig) {
+      results.push({
+        language,
+        installed: false,
+        alreadyPresent: false,
+        skippedNoNpmPackage: true,
+        hint: configs[0]?.installHint
+      });
+      continue;
+    }
+    const outcome = await ensureNpmLspInstalled(npmConfig);
+    results.push({
+      language,
+      installed: outcome.installed,
+      alreadyPresent: outcome.skipped === "already-present",
+      skippedNoNpmPackage: false,
+      error: outcome.error
+    });
+  }
+  return results;
+}
+var init_installer = __esm({
+  "../listener/dist/lsp/installer.js"() {
+    "use strict";
+    init_config_dir();
+    init_registry();
+  }
+});
+
 // ../../packages/shared/src/types/typed-resolution.ts
 function typedResolutionKey(filePath, propertyName, line, column) {
   return `${filePath}\0${propertyName}\0${line.toString()}\0${column.toString()}`;
@@ -1132,7 +1326,8 @@ __export(lsp_tools_exports, {
   lspWorkspaceSymbol: () => lspWorkspaceSymbol
 });
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { relative as pathRelative, resolve as pathResolve3 } from "path";
+import { relative as pathRelative, resolve as pathResolve3, join as pathJoin } from "path";
+import { existsSync } from "fs";
 import { execSync } from "child_process";
 function probeBinary(command) {
   if (process.env["VITEST"])
@@ -1142,8 +1337,12 @@ function probeBinary(command) {
     return cached;
   let found = false;
   try {
-    execSync(`which ${command}`, { stdio: "ignore", timeout: 200 });
-    found = true;
+    if (existsSync(pathJoin(getLspBinDir(), command))) {
+      found = true;
+    } else {
+      execSync(`which ${command}`, { stdio: "ignore", timeout: 200 });
+      found = true;
+    }
   } catch {
     found = false;
   }
@@ -1465,6 +1664,7 @@ var init_lsp_tools = __esm({
   "../listener/dist/lsp/lsp-tools.js"() {
     "use strict";
     init_registry();
+    init_installer();
     binaryProbeCache = /* @__PURE__ */ new Map();
   }
 });
@@ -3042,196 +3242,8 @@ var LspClient = class extends EventEmitter {
   }
 };
 
-// ../listener/dist/lsp/installer.js
-init_config_dir();
-init_registry();
-import { promises as fs } from "fs";
-import { join as join14, dirname as dirname5 } from "path";
-import { spawn as spawn3 } from "child_process";
-function getLspInstallDir() {
-  return join14(getConfigDir(), "lsp-servers");
-}
-function getLspBinDir() {
-  return join14(getLspInstallDir(), "node_modules", ".bin");
-}
-async function ensureNpmLspInstalled(config2) {
-  if (!config2.npmPackage)
-    return { installed: false, skipped: "no-npm-package" };
-  const installDir = getLspInstallDir();
-  const binPath = join14(installDir, "node_modules", ".bin", config2.command);
-  if (await pathExists(binPath)) {
-    return { installed: false, skipped: "already-present" };
-  }
-  try {
-    await fs.mkdir(installDir, { recursive: true });
-    const pkgJsonPath = join14(installDir, "package.json");
-    if (!await pathExists(pkgJsonPath)) {
-      await fs.writeFile(pkgJsonPath, JSON.stringify({ name: "repowise-lsp-servers", private: true, version: "0.0.0" }, null, 2), "utf-8");
-    }
-    await runNpmInstall(installDir, config2.npmPackage);
-    if (!await pathExists(binPath)) {
-      return {
-        installed: false,
-        error: `npm install completed but ${config2.command} still not at ${binPath}`
-      };
-    }
-    return { installed: true };
-  } catch (err) {
-    return {
-      installed: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
-}
-async function resolveNpmCommand() {
-  const nodeDir = dirname5(process.execPath);
-  for (const candidate of [join14(nodeDir, "npm"), join14(nodeDir, "npm.cmd")]) {
-    try {
-      await fs.access(candidate);
-      return candidate;
-    } catch {
-    }
-  }
-  for (const candidate of ["/opt/homebrew/bin/npm", "/usr/local/bin/npm", "/usr/bin/npm"]) {
-    try {
-      await fs.access(candidate);
-      return candidate;
-    } catch {
-    }
-  }
-  return "npm";
-}
-async function runNpmInstall(cwd, pkg2) {
-  const npmCmd = await resolveNpmCommand();
-  const nodeDir = dirname5(process.execPath);
-  const augmentedPath = process.env.PATH ? `${nodeDir}:${process.env.PATH}` : nodeDir;
-  return new Promise((resolve4, reject) => {
-    const child = spawn3(npmCmd, ["install", "--no-audit", "--no-fund", "--silent", pkg2], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, PATH: augmentedPath }
-    });
-    let stderr = "";
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", (err) => reject(err));
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve4();
-      } else {
-        reject(new Error(`npm install ${pkg2} exited ${(code ?? -1).toString()}: ${sanitizeNpmStderr(stderr)}`));
-      }
-    });
-  });
-}
-function sanitizeNpmStderr(raw) {
-  const truncated = raw.split("\n").slice(0, 3).join(" ").trim();
-  return truncated.replace(/(https?:\/\/)[^@\s/]*@/g, (_match, scheme) => `${scheme}<redacted>@`);
-}
-async function pathExists(p) {
-  try {
-    await fs.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function detectRepoLanguages(repoRoot) {
-  const found = /* @__PURE__ */ new Set();
-  let inspected = 0;
-  const MAX_INSPECT = 200;
-  async function inspect(dir) {
-    if (inspected >= MAX_INSPECT)
-      return;
-    let entries;
-    try {
-      entries = await fs.readdir(dir);
-    } catch {
-      return;
-    }
-    for (const name of entries) {
-      if (inspected >= MAX_INSPECT)
-        return;
-      if (name.startsWith("."))
-        continue;
-      if (name === "node_modules" || name === "dist" || name === "build")
-        continue;
-      const lang = detectLanguage(name);
-      if (lang) {
-        found.add(lang);
-        inspected += 1;
-      }
-    }
-  }
-  await inspect(repoRoot);
-  let topEntries = [];
-  try {
-    topEntries = await fs.readdir(repoRoot);
-  } catch {
-    return found;
-  }
-  for (const name of topEntries) {
-    if (name.startsWith("."))
-      continue;
-    if (name === "node_modules" || name === "dist" || name === "build")
-      continue;
-    const sub = join14(repoRoot, name);
-    try {
-      const stat7 = await fs.stat(sub);
-      if (stat7.isDirectory())
-        await inspect(sub);
-    } catch {
-    }
-  }
-  return found;
-}
-async function prepareLspServersForRepos(repos) {
-  const detected = /* @__PURE__ */ new Set();
-  for (const r of repos) {
-    if (!r.localPath)
-      continue;
-    try {
-      const stat7 = await fs.stat(r.localPath);
-      if (!stat7.isDirectory())
-        continue;
-    } catch {
-      continue;
-    }
-    try {
-      const langs = await detectRepoLanguages(r.localPath);
-      for (const l of langs)
-        detected.add(l);
-    } catch {
-    }
-  }
-  const results = [];
-  for (const language of detected) {
-    const configs = LSP_REGISTRY[language];
-    const npmConfig = configs.find((c) => c.npmPackage);
-    if (!npmConfig) {
-      results.push({
-        language,
-        installed: false,
-        alreadyPresent: false,
-        skippedNoNpmPackage: true,
-        hint: configs[0]?.installHint
-      });
-      continue;
-    }
-    const outcome = await ensureNpmLspInstalled(npmConfig);
-    results.push({
-      language,
-      installed: outcome.installed,
-      alreadyPresent: outcome.skipped === "already-present",
-      skippedNoNpmPackage: false,
-      error: outcome.error
-    });
-  }
-  return results;
-}
-
 // ../listener/dist/lsp/workspace-session.js
+init_installer();
 function keyOf(args) {
   return `${args.repoRoot}\0${args.language}`;
 }
@@ -4866,24 +4878,49 @@ function batchQuery(graphJson, req) {
   const allQueries = req.queries ?? [];
   const queries = allQueries.slice(0, BATCH_CAP);
   const droppedCount = Math.max(0, allQueries.length - queries.length);
-  const results = queries.map((q) => {
+  const results = queries.map((rawQ) => {
+    const q = rawQ;
+    const toolName = q.tool ?? "";
+    const params = q.params ?? q.arguments;
+    if (!params || typeof params !== "object" || Array.isArray(params)) {
+      return {
+        ok: false,
+        tool: toolName,
+        error: "params required (object) \u2014 pass `params` or `arguments` per sub-query"
+      };
+    }
+    const args = params;
     try {
-      switch (q.tool) {
+      switch (toolName) {
         case "find_symbol":
-          return { ok: true, tool: q.tool, result: findSymbol(graph, q.params) };
+          return {
+            ok: true,
+            tool: toolName,
+            result: findSymbol(graph, args)
+          };
         case "get_symbol":
-          return { ok: true, tool: q.tool, result: getSymbol(graph, q.params) };
+          return { ok: true, tool: toolName, result: getSymbol(graph, args) };
         case "get_impact":
-          return { ok: true, tool: q.tool, result: getImpact(graph, q.params) };
+          return { ok: true, tool: toolName, result: getImpact(graph, args) };
         case "list_edges":
-          return { ok: true, tool: q.tool, result: listEdges(graph, q.params) };
+          return { ok: true, tool: toolName, result: listEdges(graph, args) };
         case "search_pattern":
-          return { ok: true, tool: q.tool, result: searchPattern(graph, q.params) };
+          return {
+            ok: true,
+            tool: toolName,
+            result: searchPattern(graph, args)
+          };
+        default:
+          return {
+            ok: false,
+            tool: toolName,
+            error: `unsupported sub-query tool: ${String(toolName)}`
+          };
       }
     } catch (err) {
       return {
         ok: false,
-        tool: q.tool,
+        tool: toolName,
         error: err instanceof Error ? err.message : String(err)
       };
     }
@@ -5121,7 +5158,14 @@ function handleRequest(req, res, options, sessions, secretCtx) {
         sessions.set(sessionId, { repoId: body.repoId });
         return sendJson(res, 200, { sessionId });
       });
-    }).catch((err) => sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) }));
+    }).catch((err) => {
+      const rawMsg = err instanceof Error ? err.message : String(err);
+      const safeMsg = stripAbsolutePaths(rawMsg);
+      if (err?.code === "ENOENT") {
+        return sendJson(res, 404, { error: "unknown_repo" });
+      }
+      sendJson(res, 500, { error: safeMsg });
+    });
     return;
   }
   if (method === "POST" && url === "/mcp/disconnect") {
@@ -5305,6 +5349,7 @@ function dispatchSessionTool(req, res, url, sessions, logger, handler) {
         latencyMs: Date.now() - startedAt,
         error: "unknown_session"
       });
+      logToStdout("rejected", tool, null, Date.now() - startedAt, "unknown_session");
       return sendJson(res, 404, { error: "unknown_session" });
     }
     try {
@@ -5319,8 +5364,10 @@ function dispatchSessionTool(req, res, url, sessions, logger, handler) {
           status: "ok",
           latencyMs: Date.now() - startedAt
         });
+        logToStdout("ok", tool, session.repoId, Date.now() - startedAt);
         return sendJson(res, 200, result.value);
       }
+      const rejectErr = typeof result.body["error"] === "string" ? result.body["error"] : "tool_rejected";
       recordLog(logger, {
         ts: new Date(startedAt).toISOString(),
         sessionId: body.sessionId,
@@ -5329,8 +5376,9 @@ function dispatchSessionTool(req, res, url, sessions, logger, handler) {
         args: redactArgs(body),
         status: "rejected",
         latencyMs: Date.now() - startedAt,
-        error: typeof result.body["error"] === "string" ? result.body["error"] : "tool_rejected"
+        error: rejectErr
       });
+      logToStdout("rejected", tool, session.repoId, Date.now() - startedAt, rejectErr);
       return sendJson(res, result.status, result.body);
     } catch (err) {
       const isTimeout = err instanceof ToolTimeoutError;
@@ -5346,6 +5394,7 @@ function dispatchSessionTool(req, res, url, sessions, logger, handler) {
         latencyMs: Date.now() - startedAt,
         error: safeMsg
       });
+      logToStdout("error", tool, session.repoId, Date.now() - startedAt, safeMsg);
       if (isTimeout) {
         return sendJson(res, 504, { error: "tool-timeout", tool });
       }
@@ -5365,6 +5414,11 @@ function recordLog(logger, entry) {
     return;
   void logger.append(entry);
 }
+function logToStdout(status2, tool, repoId, latencyMs, error) {
+  const repoFrag = repoId ? `repo=${repoId}` : "repo=\u2014";
+  const errFrag = error ? ` error=${error}` : "";
+  console.log(`[mcp] ${status2} ${tool} ${repoFrag} ${latencyMs}ms${errFrag}`);
+}
 var REDACT_FIELDS = /* @__PURE__ */ new Set([
   "query",
   "pattern",
@@ -6044,6 +6098,9 @@ async function runAutoConfig(opts) {
   return results;
 }
 
+// ../listener/dist/main.js
+init_installer();
+
 // ../listener/dist/typed-resolution/resolver-loop.js
 init_src();
 init_registry();
@@ -7727,11 +7784,11 @@ async function writeClaudeSubagentHook(repoRoot, contextFolder) {
 }
 
 // src/lib/gitignore.ts
-import { readFileSync as readFileSync2, writeFileSync, existsSync } from "fs";
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2 } from "fs";
 import { join as join32 } from "path";
 function ensureGitignore(repoRoot, entry) {
   const gitignorePath = join32(repoRoot, ".gitignore");
-  if (existsSync(gitignorePath)) {
+  if (existsSync2(gitignorePath)) {
     const content = readFileSync2(gitignorePath, "utf-8");
     const lines = content.split("\n").map((l) => l.trim());
     if (lines.includes(entry) || lines.includes(entry + "/")) {
@@ -10521,6 +10578,7 @@ async function mcpShim(opts) {
   const stderr = opts.stderr ?? process.stderr;
   const maxBytes = opts.maxRequestBytes ?? DEFAULT_MAX;
   const postJson = opts.postJson ?? defaultPostJson;
+  const getJson = opts.getJson ?? defaultGetJson;
   const sessionState = { sessionId: null };
   const rl = createInterface2({ input: stdin, crlfDelay: Infinity });
   for await (const rawLine of rl) {
@@ -10566,6 +10624,7 @@ async function mcpShim(opts) {
         opts.repoId,
         parsed,
         postJson,
+        getJson,
         headers,
         sessionState
       );
@@ -10608,7 +10667,7 @@ function writeJson(stream, value) {
   stream.write(`${JSON.stringify(value)}
 `);
 }
-async function routeMessage(endpoint, repoId, message, postJson, headers, sessionState) {
+async function routeMessage(endpoint, repoId, message, postJson, getJson, headers, sessionState) {
   const msg = message;
   const rpcId = msg.id;
   const method = msg.method;
@@ -10624,41 +10683,28 @@ async function routeMessage(endpoint, repoId, message, postJson, headers, sessio
     };
   }
   if (method === "tools/list") {
-    const tools = [
-      "find_symbol",
-      "get_symbol",
-      "get_impact",
-      "list_edges",
-      "search_pattern",
-      "batch_query",
-      "find_callers",
-      "find_references",
-      "get_deps",
-      "get_call_graph",
-      "find_tests_for_symbol",
-      "get_todos",
-      "get_freshness",
-      "lsp_definition",
-      "lsp_references",
-      "lsp_hover",
-      "lsp_workspace_symbol",
-      "lsp_document_symbol",
-      "lsp_call_hierarchy",
-      "lsp_implementation",
-      "lsp_type_hierarchy"
-    ].map((name) => ({ name, description: "", inputSchema: { type: "object" } }));
+    const catalog = await getJson(`${endpoint}/mcp/tools`, headers);
+    const tools = (catalog.tools ?? []).map((t) => ({
+      name: t.name,
+      description: [t.description, t.whenToUse].filter((s) => s && s.length > 0).join("\n\n"),
+      inputSchema: t.inputSchema ?? { type: "object" }
+    }));
     return { jsonrpc: "2.0", id: rpcId, result: { tools } };
   }
-  if (!sessionState.sessionId) {
+  async function connect() {
     const connectResp = await postJson(`${endpoint}/mcp/connect`, { repoId }, headers);
-    if (!connectResp.sessionId) {
+    return connectResp.sessionId ?? null;
+  }
+  if (!sessionState.sessionId) {
+    const sid = await connect();
+    if (!sid) {
       return {
         jsonrpc: "2.0",
         id: rpcId,
         error: { code: -32002, message: "failed to establish MCP session" }
       };
     }
-    sessionState.sessionId = connectResp.sessionId;
+    sessionState.sessionId = sid;
   }
   if (method === "tools/call") {
     const params = msg.params ?? {};
@@ -10672,12 +10718,33 @@ async function routeMessage(endpoint, repoId, message, postJson, headers, sessio
         error: { code: -32602, message: "tools/call missing name" }
       };
     }
-    const result = await postJson(
-      `${endpoint}/mcp/tools/${name}`,
-      { sessionId: sessionState.sessionId, ...args },
-      headers
-    );
-    return { jsonrpc: "2.0", id: rpcId, result };
+    const callTool = (sid) => postJson(`${endpoint}/mcp/tools/${name}`, { sessionId: sid, ...args }, headers);
+    let result;
+    try {
+      result = await callTool(sessionState.sessionId);
+    } catch (err) {
+      const detail = err.message;
+      const isStaleSession = /HTTP (401|404)/.test(detail) || /session/i.test(detail) || /unknown_session/i.test(detail);
+      if (!isStaleSession) throw err;
+      sessionState.sessionId = null;
+      const fresh = await connect();
+      if (!fresh) {
+        return {
+          jsonrpc: "2.0",
+          id: rpcId,
+          error: { code: -32002, message: "failed to establish MCP session (after retry)" }
+        };
+      }
+      sessionState.sessionId = fresh;
+      result = await callTool(fresh);
+    }
+    return {
+      jsonrpc: "2.0",
+      id: rpcId,
+      result: {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      }
+    };
   }
   return {
     jsonrpc: "2.0",
@@ -10702,6 +10769,19 @@ async function defaultPostJson(url, body, headers = { "content-type": "applicati
   }
   return await res.json();
 }
+async function defaultGetJson(url, headers = {}) {
+  const res = await fetch(url, { method: "GET", headers });
+  if (!res.ok) {
+    let detail = "";
+    try {
+      const errBody = await res.json();
+      detail = errBody.message ?? errBody.error ?? "";
+    } catch {
+    }
+    throw new Error(`HTTP ${res.status.toString()}${detail ? `: ${detail}` : ""}`);
+  }
+  return await res.json();
+}
 
 // src/commands/mcp-serve.ts
 import { createInterface as createInterface3 } from "readline";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repowisestage",
-  "version": "0.0.46",
+  "version": "0.0.47",
   "type": "module",
   "description": "AI-optimized codebase context generator",
   "bin": {