webnav-ts-mcp 0.1.0

package/dist/shared/errors.js

@@ -0,0 +1,80 @@
+/**
+ * Expected tool failures, rendered as agent-readable text.
+ *
+ * The MCP framework collapses any exception a tool throws into an opaque
+ * "Error executing tool …", hiding actionable causes like a mistyped path.
+ * Tools catch what `isToolError` accepts and return `formatToolError(exc)`.
+ */
+/** The caller asked for something the tool can't serve (e.g. unsupported file type). */
+export class ToolInputError extends Error {
+    name = "ToolInputError";
+}
+/** JSON-RPC error response from the language server. */
+export class LspRequestError extends Error {
+    method;
+    code;
+    name = "LspRequestError";
+    constructor(method, code, message) {
+        super(message);
+        this.method = method;
+        this.code = code;
+    }
+}
+/** The language server process ended while a request was pending. */
+export class LanguageServerExitedError extends Error {
+    name = "LanguageServerExitedError";
+}
+/** A tool was asked about a line/column that doesn't exist in the file. */
+export class InvalidPositionError extends Error {
+    name = "InvalidPositionError";
+}
+/** A language-server request outlived its deadline. */
+export class LspTimeoutError extends Error {
+    name = "LspTimeoutError";
+}
+/** A file that isn't valid UTF-8 text. */
+export class Utf8DecodeError extends Error {
+    name = "Utf8DecodeError";
+}
+export function isFsError(exc) {
+    return exc instanceof Error && typeof exc.code === "string" && "syscall" in exc;
+}
+/** True for every failure a tool should report as text instead of throwing. */
+export function isToolError(exc) {
+    return (exc instanceof LspRequestError ||
+        exc instanceof LanguageServerExitedError ||
+        exc instanceof ToolInputError ||
+        exc instanceof InvalidPositionError ||
+        exc instanceof LspTimeoutError ||
+        exc instanceof Utf8DecodeError ||
+        isFsError(exc));
+}
+export function formatToolError(exc) {
+    if (exc instanceof LspRequestError) {
+        return `LSP error on ${exc.method}: ${exc.message}`;
+    }
+    if (exc instanceof LspTimeoutError) {
+        return "Language server timed out (it may still be indexing the workspace); retry shortly.";
+    }
+    if (exc instanceof Utf8DecodeError) {
+        return `Cannot read file as UTF-8 text: ${exc.message}.`;
+    }
+    if (isFsError(exc)) {
+        const spawnFailure = exc.syscall?.startsWith("spawn") ?? false;
+        const reason = exc.message.replace(/^[A-Z_]+: /, "").replace(/, (?:open|stat|spawn|scandir|read)\b.*$/, "");
+        if (exc.code === "ENOENT" && !spawnFailure && exc.path) {
+            return `File not found: ${exc.path} (relative paths resolve against the workspace root).`;
+        }
+        if (exc.code === "ENOENT") {
+            return `Cannot start language server (file not found): ${reason}.`;
+        }
+        if (spawnFailure) {
+            return `Cannot start language server: ${reason}.`;
+        }
+        if (exc.path) {
+            return `Cannot read ${exc.path}: ${reason}.`;
+        }
+        return `${reason}.`;
+    }
+    return exc.message;
+}

package/dist/shared/exclude.js

@@ -0,0 +1,32 @@
+/**
+ * Directory names every workspace scan skips: vendored/generated/virtualenv
+ * trees that are never a project's own source, so scanning them wastes time
+ * at best and can abort a whole call on the first non-UTF-8 file at worst.
+ */
+import path from "node:path";
+export const EXCLUDED_DIR_NAMES = new Set([
+    "node_modules",
+    ".git",
+    "vendor",
+    "dist",
+    "build",
+    "__pycache__",
+    ".venv",
+    "venv",
+    ".venv-bare",
+    "env",
+    ".env",
+    "site-packages",
+    ".tox",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".pytest-testmon",
+    ".eggs",
+]);
+/** Whether `p` (absolute or root-relative) sits under a directory name in `EXCLUDED_DIR_NAMES` anywhere below `root`. */
+export function isExcluded(p, root) {
+    const rel = path.relative(root, p);
+    const parts = (rel.startsWith("..") || path.isAbsolute(rel) ? p : rel).split(path.sep);
+    return parts.some((part) => EXCLUDED_DIR_NAMES.has(part));
+}