token-pilot 0.31.0 → 0.33.0

package/dist/core/validation.js

@@ -1,4 +1,34 @@
-import { resolve, relative } from 'node:path';
+import { resolve, relative } from "node:path";
+/**
+ * v0.33.0 (B9) — coerce an `unknown` argument value to an integer.
+ *
+ * MCP transports frequently round-trip numeric arguments through
+ * JSON or environment variables and re-emit them as strings (e.g.
+ * `"42"`). Accept that case and reject everything else, including
+ * non-finite numbers, decimals, and strings that don't parse cleanly.
+ *
+ * Returns the integer value or `null` when the input cannot be
+ * interpreted as one.
+ */
+export function coerceIntFromAny(value) {
+    if (typeof value === "number") {
+        if (!Number.isFinite(value) || !Number.isInteger(value))
+            return null;
+        return value;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.length === 0)
+            return null;
+        if (!/^-?\d+$/.test(trimmed))
+            return null;
+        const n = Number(trimmed);
+        if (!Number.isFinite(n) || !Number.isInteger(n))
+            return null;
+        return n;
+    }
+    return null;
+}
 /**
  * Resolve a user-provided path and validate it stays within projectRoot.
  * Prevents path traversal attacks (e.g. ../../etc/passwd).
@@ -6,7 +36,7 @@ import { resolve, relative } from 'node:path';
 export function resolveSafePath(projectRoot, userPath) {
     const absPath = resolve(projectRoot, userPath);
     const rel = relative(projectRoot, absPath);
-    if (rel.startsWith('..') || resolve(projectRoot, rel) !== absPath) {
+    if (rel.startsWith("..") || resolve(projectRoot, rel) !== absPath) {
         throw new Error(`Path "${userPath}" resolves outside project root.`);
     }
     return absPath;
@@ -15,40 +45,40 @@ export function resolveSafePath(projectRoot, userPath) {
  * Validate smart_read arguments.
  */
 export function validateSmartReadArgs(args) {
-    if (!args || typeof args !== 'object') {
-        throw new Error('Arguments must be an object.');
+    if (!args || typeof args !== "object") {
+        throw new Error("Arguments must be an object.");
     }
     const a = args;
-    if (typeof a.path !== 'string' || a.path.length === 0) {
+    if (typeof a.path !== "string" || a.path.length === 0) {
         throw new Error('Required parameter "path" must be a non-empty string.');
     }
     return {
         path: a.path,
-        show_imports: optionalBool(a.show_imports, 'show_imports'),
-        show_docs: optionalBool(a.show_docs, 'show_docs'),
-        show_references: optionalBool(a.show_references, 'show_references'),
-        depth: optionalNumber(a.depth, 'depth'),
-        max_tokens: optionalNumber(a.max_tokens, 'max_tokens'),
+        show_imports: optionalBool(a.show_imports, "show_imports"),
+        show_docs: optionalBool(a.show_docs, "show_docs"),
+        show_references: optionalBool(a.show_references, "show_references"),
+        depth: optionalNumber(a.depth, "depth"),
+        max_tokens: optionalNumber(a.max_tokens, "max_tokens"),
     };
 }
 /**
  * Validate read_symbol arguments.
  */
 export function validateReadSymbolArgs(args) {
-    if (!args || typeof args !== 'object') {
-        throw new Error('Arguments must be an object.');
+    if (!args || typeof args !== "object") {
+        throw new Error("Arguments must be an object.");
     }
     const a = args;
-    if (typeof a.path !== 'string' || a.path.length === 0) {
+    if (typeof a.path !== "string" || a.path.length === 0) {
         throw new Error('Required parameter "path" must be a non-empty string.');
     }
-    if (typeof a.symbol !== 'string' || a.symbol.length === 0) {
+    if (typeof a.symbol !== "string" || a.symbol.length === 0) {
         throw new Error('Required parameter "symbol" must be a non-empty string.');
     }
     let show;
     if (a.show !== undefined && a.show !== null) {
-        const valid = ['full', 'head', 'tail', 'outline'];
-        if (typeof a.show !== 'string' || !valid.includes(a.show)) {
+        const valid = ["full", "head", "tail", "outline"];
+        if (typeof a.show !== "string" || !valid.includes(a.show)) {
             throw new Error('"show" must be one of: full, head, tail, outline.');
         }
         show = a.show;
@@ -56,8 +86,8 @@ export function validateReadSymbolArgs(args) {
     return {
         path: a.path,
         symbol: a.symbol,
-        context_before: optionalNumber(a.context_before, 'context_before'),
-        context_after: optionalNumber(a.context_after, 'context_after'),
+        context_before: optionalNumber(a.context_before, "context_before"),
+        context_after: optionalNumber(a.context_after, "context_after"),
         show,
     };
 }
@@ -65,11 +95,11 @@ export function validateReadSymbolArgs(args) {
  * Validate read_symbols arguments (batch multi-symbol read).
  */
 export function validateReadSymbolsArgs(args) {
-    if (!args || typeof args !== 'object') {
-        throw new Error('Arguments must be an object.');
+    if (!args || typeof args !== "object") {
+        throw new Error("Arguments must be an object.");
     }
     const a = args;
-    if (typeof a.path !== 'string' || a.path.length === 0) {
+    if (typeof a.path !== "string" || a.path.length === 0) {
         throw new Error('Required parameter "path" must be a non-empty string.');
     }
     if (!Array.isArray(a.symbols) || a.symbols.length === 0) {
@@ -79,14 +109,14 @@ export function validateReadSymbolsArgs(args) {
         throw new Error('"symbols" can contain at most 10 symbols.');
     }
     for (const s of a.symbols) {
-        if (typeof s !== 'string' || s.length === 0) {
+        if (typeof s !== "string" || s.length === 0) {
             throw new Error('Each symbol in "symbols" must be a non-empty string.');
         }
     }
     let show;
     if (a.show !== undefined && a.show !== null) {
-        const valid = ['full', 'head', 'tail', 'outline'];
-        if (typeof a.show !== 'string' || !valid.includes(a.show)) {
+        const valid = ["full", "head", "tail", "outline"];
+        if (typeof a.show !== "string" || !valid.includes(a.show)) {
             throw new Error('"show" must be one of: full, head, tail, outline.');
         }
         show = a.show;
@@ -94,8 +124,8 @@ export function validateReadSymbolsArgs(args) {
     return {
         path: a.path,
         symbols: a.symbols,
-        context_before: optionalNumber(a.context_before, 'context_before'),
-        context_after: optionalNumber(a.context_after, 'context_after'),
+        context_before: optionalNumber(a.context_before, "context_before"),
+        context_after: optionalNumber(a.context_after, "context_after"),
         show,
     };
 }
@@ -103,78 +133,83 @@ export function validateReadSymbolsArgs(args) {
  * Validate read_range arguments.
  */
 export function validateReadRangeArgs(args) {
-    if (!args || typeof args !== 'object') {
-        throw new Error('Arguments must be an object.');
+    if (!args || typeof args !== "object") {
+        throw new Error("Arguments must be an object.");
     }
     const a = args;
-    if (typeof a.path !== 'string' || a.path.length === 0) {
+    if (typeof a.path !== "string" || a.path.length === 0) {
         throw new Error('Required parameter "path" must be a non-empty string.');
     }
-    if (typeof a.start_line !== 'number' || !Number.isInteger(a.start_line) || a.start_line < 1) {
+    // v0.33.0 (B9) — some MCP clients serialise numbers as strings;
+    // accept "10" the same as 10. Reject non-numeric strings.
+    const start = coerceIntFromAny(a.start_line);
+    if (start === null || start < 1) {
         throw new Error('Required parameter "start_line" must be a positive integer.');
     }
-    if (typeof a.end_line !== 'number' || !Number.isInteger(a.end_line) || a.end_line < 1) {
+    const end = coerceIntFromAny(a.end_line);
+    if (end === null || end < 1) {
         throw new Error('Required parameter "end_line" must be a positive integer.');
     }
-    if (a.end_line < a.start_line) {
+    if (end < start) {
         throw new Error('"end_line" must be >= "start_line".');
     }
-    return { path: a.path, start_line: a.start_line, end_line: a.end_line };
+    return { path: a.path, start_line: start, end_line: end };
 }
 /**
  * Validate read_diff arguments.
  */
 export function validateReadDiffArgs(args) {
-    if (!args || typeof args !== 'object') {
-        throw new Error('Arguments must be an object.');
+    if (!args || typeof args !== "object") {
+        throw new Error("Arguments must be an object.");
     }
     const a = args;
-    if (typeof a.path !== 'string' || a.path.length === 0) {
+    if (typeof a.path !== "string" || a.path.length === 0) {
         throw new Error('Required parameter "path" must be a non-empty string.');
     }
     return {
         path: a.path,
-        context_lines: optionalNumber(a.context_lines, 'context_lines'),
+        context_lines: optionalNumber(a.context_lines, "context_lines"),
     };
 }
 export function validateFindUsagesArgs(args) {
-    if (!args || typeof args !== 'object') {
-        throw new Error('Arguments must be an object.');
+    if (!args || typeof args !== "object") {
+        throw new Error("Arguments must be an object.");
     }
     const a = args;
-    if (typeof a.symbol !== 'string' || a.symbol.length === 0) {
+    if (typeof a.symbol !== "string" || a.symbol.length === 0) {
         throw new Error('Required parameter "symbol" must be a non-empty string.');
     }
     let kind;
     if (a.kind !== undefined && a.kind !== null) {
-        const validKinds = ['definitions', 'imports', 'usages', 'all'];
-        if (typeof a.kind !== 'string' || !validKinds.includes(a.kind)) {
-            throw new Error(`"kind" must be one of: ${validKinds.join(', ')}`);
+        const validKinds = ["definitions", "imports", "usages", "all"];
+        if (typeof a.kind !== "string" || !validKinds.includes(a.kind)) {
+            throw new Error(`"kind" must be one of: ${validKinds.join(", ")}`);
         }
         kind = a.kind;
     }
-    const limit = optionalNumber(a.limit, 'limit');
+    const limit = optionalNumber(a.limit, "limit");
     if (limit !== undefined && (limit < 1 || limit > 500)) {
         throw new Error('"limit" must be between 1 and 500.');
     }
-    const context_lines = optionalNumber(a.context_lines, 'context_lines');
-    if (context_lines !== undefined && (context_lines < 0 || context_lines > 10)) {
+    const context_lines = optionalNumber(a.context_lines, "context_lines");
+    if (context_lines !== undefined &&
+        (context_lines < 0 || context_lines > 10)) {
         throw new Error('"context_lines" must be between 0 and 10.');
     }
     let mode;
     if (a.mode !== undefined && a.mode !== null) {
-        const validModes = ['full', 'list'];
-        if (typeof a.mode !== 'string' || !validModes.includes(a.mode)) {
-            throw new Error(`"mode" must be one of: ${validModes.join(', ')}`);
+        const validModes = ["full", "list"];
+        if (typeof a.mode !== "string" || !validModes.includes(a.mode)) {
+            throw new Error(`"mode" must be one of: ${validModes.join(", ")}`);
         }
         mode = a.mode;
     }
     return {
         symbol: a.symbol,
-        scope: optionalString(a.scope, 'scope'),
+        scope: optionalString(a.scope, "scope"),
         kind,
         limit,
-        lang: optionalString(a.lang, 'lang'),
+        lang: optionalString(a.lang, "lang"),
         context_lines,
         mode,
     };
@@ -183,38 +218,41 @@ export function validateFindUsagesArgs(args) {
  * Validate smart_read_many arguments.
  */
 export function validateSmartReadManyArgs(args) {
-    if (!args || typeof args !== 'object') {
-        throw new Error('Arguments must be an object.');
+    if (!args || typeof args !== "object") {
+        throw new Error("Arguments must be an object.");
     }
     const a = args;
     if (!Array.isArray(a.paths)) {
         throw new Error('Required parameter "paths" must be an array of strings.');
     }
     for (const p of a.paths) {
-        if (typeof p !== 'string' || p.length === 0) {
+        if (typeof p !== "string" || p.length === 0) {
             throw new Error('Each path in "paths" must be a non-empty string.');
         }
     }
-    return { paths: a.paths, max_tokens: optionalNumber(a.max_tokens, 'max_tokens') };
+    return {
+        paths: a.paths,
+        max_tokens: optionalNumber(a.max_tokens, "max_tokens"),
+    };
 }
 function optionalString(val, name) {
     if (val === undefined || val === null)
         return undefined;
-    if (typeof val !== 'string')
+    if (typeof val !== "string")
         throw new Error(`"${name}" must be a string.`);
     return val;
 }
 function optionalBool(val, name) {
     if (val === undefined || val === null)
         return undefined;
-    if (typeof val !== 'boolean')
+    if (typeof val !== "boolean")
         throw new Error(`"${name}" must be a boolean.`);
     return val;
 }
 function optionalNumber(val, name) {
     if (val === undefined || val === null)
         return undefined;
-    if (typeof val !== 'number' || !Number.isFinite(val))
+    if (typeof val !== "number" || !Number.isFinite(val))
         throw new Error(`"${name}" must be a finite number.`);
     return val;
 }
@@ -222,14 +260,17 @@ function optionalNumber(val, name) {
  * Validate read_for_edit arguments.
  */
 export function validateReadForEditArgs(args) {
-    if (!args || typeof args !== 'object') {
-        throw new Error('Arguments must be an object.');
+    if (!args || typeof args !== "object") {
+        throw new Error("Arguments must be an object.");
     }
     const a = args;
-    if (typeof a.path !== 'string' || a.path.length === 0) {
+    if (typeof a.path !== "string" || a.path.length === 0) {
         throw new Error('Required parameter "path" must be a non-empty string.');
     }
-    if (!a.symbol && !a.line && (!Array.isArray(a.symbols) || a.symbols.length === 0) && !a.section) {
+    if (!a.symbol &&
+        !a.line &&
+        (!Array.isArray(a.symbols) || a.symbols.length === 0) &&
+        !a.section) {
         throw new Error('Either "symbol", "symbols", "line", or "section" must be provided.');
     }
     // Validate symbols array (batch mode)
@@ -242,7 +283,7 @@ export function validateReadForEditArgs(args) {
             throw new Error('"symbols" can contain at most 10 symbols.');
         }
         for (const s of a.symbols) {
-            if (typeof s !== 'string' || s.length === 0) {
+            if (typeof s !== "string" || s.length === 0) {
                 throw new Error('Each symbol in "symbols" must be a non-empty string.');
             }
         }
@@ -250,87 +291,106 @@ export function validateReadForEditArgs(args) {
     }
     return {
         path: a.path,
-        symbol: optionalString(a.symbol, 'symbol'),
+        symbol: optionalString(a.symbol, "symbol"),
         symbols,
-        line: optionalNumber(a.line, 'line'),
-        context: optionalNumber(a.context, 'context'),
-        include_callers: optionalBool(a.include_callers, 'include_callers'),
-        include_tests: optionalBool(a.include_tests, 'include_tests'),
-        include_changes: optionalBool(a.include_changes, 'include_changes'),
-        section: optionalString(a.section, 'section'),
+        line: optionalNumber(a.line, "line"),
+        context: optionalNumber(a.context, "context"),
+        include_callers: optionalBool(a.include_callers, "include_callers"),
+        include_tests: optionalBool(a.include_tests, "include_tests"),
+        include_changes: optionalBool(a.include_changes, "include_changes"),
+        section: optionalString(a.section, "section"),
     };
 }
 /**
  * Validate related_files arguments.
  */
 export function validateRelatedFilesArgs(args) {
-    if (!args || typeof args !== 'object') {
-        throw new Error('Arguments must be an object.');
+    if (!args || typeof args !== "object") {
+        throw new Error("Arguments must be an object.");
     }
     const a = args;
-    if (typeof a.path !== 'string' || a.path.length === 0) {
+    if (typeof a.path !== "string" || a.path.length === 0) {
         throw new Error('Required parameter "path" must be a non-empty string.');
     }
     return { path: a.path };
 }
 export function validateOutlineArgs(args) {
-    if (!args || typeof args !== 'object') {
-        throw new Error('Arguments must be an object.');
+    if (!args || typeof args !== "object") {
+        throw new Error("Arguments must be an object.");
     }
     const a = args;
-    if (typeof a.path !== 'string' || a.path.length === 0) {
+    if (typeof a.path !== "string" || a.path.length === 0) {
         throw new Error('Required parameter "path" must be a non-empty string.');
     }
-    const maxDepth = optionalNumber(a.max_depth, 'max_depth');
+    const maxDepth = optionalNumber(a.max_depth, "max_depth");
     if (maxDepth !== undefined && (maxDepth < 1 || maxDepth > 5)) {
         throw new Error('"max_depth" must be between 1 and 5.');
     }
     return {
         path: a.path,
-        recursive: optionalBool(a.recursive, 'recursive'),
+        recursive: optionalBool(a.recursive, "recursive"),
         max_depth: maxDepth,
     };
 }
 export function validateFindUnusedArgs(args) {
-    if (!args || typeof args !== 'object')
+    if (!args || typeof args !== "object")
         return {};
     const a = args;
     return {
-        module: optionalString(a.module, 'module'),
-        export_only: optionalBool(a.export_only, 'export_only'),
-        limit: optionalNumber(a.limit, 'limit'),
+        module: optionalString(a.module, "module"),
+        export_only: optionalBool(a.export_only, "export_only"),
+        limit: optionalNumber(a.limit, "limit"),
+    };
+}
+export function validateCallTreeArgs(args) {
+    if (!args || typeof args !== "object") {
+        throw new Error("call_tree requires { symbol: string }");
+    }
+    const a = args;
+    const symbol = optionalString(a.symbol, "symbol");
+    if (!symbol) {
+        throw new Error("call_tree: `symbol` is required and must be a non-empty string.");
+    }
+    return {
+        symbol,
+        depth: optionalNumber(a.depth, "depth"),
     };
 }
 export function validateCodeAuditArgs(args) {
-    if (!args || typeof args !== 'object') {
+    if (!args || typeof args !== "object") {
         throw new Error('Arguments must be an object with a "check" parameter.');
     }
     const a = args;
-    const validChecks = ['pattern', 'todo', 'deprecated', 'annotations', 'all'];
-    if (typeof a.check !== 'string' || !validChecks.includes(a.check)) {
-        throw new Error(`Required parameter "check" must be one of: ${validChecks.join(', ')}`);
+    const validChecks = ["pattern", "todo", "deprecated", "annotations", "all"];
+    if (typeof a.check !== "string" || !validChecks.includes(a.check)) {
+        throw new Error(`Required parameter "check" must be one of: ${validChecks.join(", ")}`);
     }
-    if (a.check === 'pattern') {
-        if (typeof a.pattern !== 'string' || a.pattern.length === 0) {
+    if (a.check === "pattern") {
+        if (typeof a.pattern !== "string" || a.pattern.length === 0) {
             throw new Error('Parameter "pattern" is required when check="pattern". Example: "except:" or "print($$$ARGS)"');
         }
     }
-    if (a.check === 'annotations') {
-        if (typeof a.name !== 'string' || a.name.length === 0) {
+    if (a.check === "annotations") {
+        if (typeof a.name !== "string" || a.name.length === 0) {
             throw new Error('Parameter "name" is required when check="annotations". Example: "Deprecated" or "Controller"');
         }
     }
     return {
         check: a.check,
-        pattern: optionalString(a.pattern, 'pattern'),
-        name: optionalString(a.name, 'name'),
-        lang: optionalString(a.lang, 'lang'),
-        limit: optionalNumber(a.limit, 'limit'),
+        pattern: optionalString(a.pattern, "pattern"),
+        name: optionalString(a.name, "name"),
+        lang: optionalString(a.lang, "lang"),
+        limit: optionalNumber(a.limit, "limit"),
     };
 }
-const VALID_INCLUDE_SECTIONS = ['stack', 'ci', 'quality', 'architecture'];
+const VALID_INCLUDE_SECTIONS = [
+    "stack",
+    "ci",
+    "quality",
+    "architecture",
+];
 export function validateProjectOverviewArgs(args) {
-    if (!args || typeof args !== 'object')
+    if (!args || typeof args !== "object")
         return {};
     const a = args;
     if (a.include !== undefined && a.include !== null) {
@@ -338,8 +398,9 @@ export function validateProjectOverviewArgs(args) {
             throw new Error('"include" must be an array of section names.');
         }
         for (const item of a.include) {
-            if (typeof item !== 'string' || !VALID_INCLUDE_SECTIONS.includes(item)) {
-                throw new Error(`Each element of "include" must be one of: ${VALID_INCLUDE_SECTIONS.join(', ')}. Got: "${item}"`);
+            if (typeof item !== "string" ||
+                !VALID_INCLUDE_SECTIONS.includes(item)) {
+                throw new Error(`Each element of "include" must be one of: ${VALID_INCLUDE_SECTIONS.join(", ")}. Got: "${item}"`);
             }
         }
         return { include: a.include };
@@ -347,55 +408,60 @@ export function validateProjectOverviewArgs(args) {
     return {};
 }
 export function validateModuleInfoArgs(args) {
-    if (!args || typeof args !== 'object') {
+    if (!args || typeof args !== "object") {
         throw new Error('Arguments must be an object with a "module" parameter.');
     }
     const a = args;
-    if (typeof a.module !== 'string' || a.module.length === 0) {
+    if (typeof a.module !== "string" || a.module.length === 0) {
         throw new Error('Required parameter "module" must be a non-empty string.');
     }
     let check;
     if (a.check !== undefined && a.check !== null) {
-        const validChecks = ['deps', 'dependents', 'api', 'unused-deps', 'all'];
-        if (typeof a.check !== 'string' || !validChecks.includes(a.check)) {
-            throw new Error(`"check" must be one of: ${validChecks.join(', ')}`);
+        const validChecks = ["deps", "dependents", "api", "unused-deps", "all"];
+        if (typeof a.check !== "string" || !validChecks.includes(a.check)) {
+            throw new Error(`"check" must be one of: ${validChecks.join(", ")}`);
         }
         check = a.check;
     }
     return {
         module: a.module,
-        check: check ?? 'all',
+        check: check ?? "all",
     };
 }
 export function validateSmartDiffArgs(args) {
-    if (!args || typeof args !== 'object')
-        return { scope: 'unstaged' };
+    if (!args || typeof args !== "object")
+        return { scope: "unstaged" };
     const a = args;
     let scope;
     if (a.scope !== undefined && a.scope !== null) {
-        const validScopes = ['unstaged', 'staged', 'commit', 'branch'];
-        if (typeof a.scope !== 'string' || !validScopes.includes(a.scope)) {
-            throw new Error(`"scope" must be one of: ${validScopes.join(', ')}`);
+        const validScopes = ["unstaged", "staged", "commit", "branch"];
+        if (typeof a.scope !== "string" || !validScopes.includes(a.scope)) {
+            throw new Error(`"scope" must be one of: ${validScopes.join(", ")}`);
         }
         scope = a.scope;
     }
-    const ref = optionalString(a.ref, 'ref');
-    if ((scope === 'commit' || scope === 'branch') && !ref) {
+    const ref = optionalString(a.ref, "ref");
+    if ((scope === "commit" || scope === "branch") && !ref) {
         throw new Error(`"ref" is required when scope="${scope}".`);
     }
     return {
-        scope: scope ?? 'unstaged',
-        path: optionalString(a.path, 'path'),
+        scope: scope ?? "unstaged",
+        path: optionalString(a.path, "path"),
         ref,
     };
 }
-const VALID_EXPLORE_SECTIONS = ['outline', 'imports', 'tests', 'changes'];
+const VALID_EXPLORE_SECTIONS = [
+    "outline",
+    "imports",
+    "tests",
+    "changes",
+];
 export function validateExploreAreaArgs(args) {
-    if (!args || typeof args !== 'object') {
+    if (!args || typeof args !== "object") {
         throw new Error('Arguments must be an object with a "path" parameter.');
     }
     const a = args;
-    if (typeof a.path !== 'string' || a.path.length === 0) {
+    if (typeof a.path !== "string" || a.path.length === 0) {
         throw new Error('Required parameter "path" must be a non-empty string.');
     }
     if (a.include !== undefined && a.include !== null) {
@@ -403,8 +469,9 @@ export function validateExploreAreaArgs(args) {
             throw new Error('"include" must be an array of section names.');
         }
         for (const item of a.include) {
-            if (typeof item !== 'string' || !VALID_EXPLORE_SECTIONS.includes(item)) {
-                throw new Error(`Each element of "include" must be one of: ${VALID_EXPLORE_SECTIONS.join(', ')}. Got: "${item}"`);
+            if (typeof item !== "string" ||
+                !VALID_EXPLORE_SECTIONS.includes(item)) {
+                throw new Error(`Each element of "include" must be one of: ${VALID_EXPLORE_SECTIONS.join(", ")}. Got: "${item}"`);
             }
         }
         return { path: a.path, include: a.include };
@@ -412,42 +479,51 @@ export function validateExploreAreaArgs(args) {
     return { path: a.path };
 }
 export function validateSmartLogArgs(args) {
-    if (!args || typeof args !== 'object')
+    if (!args || typeof args !== "object")
         return {};
     const a = args;
-    const path = optionalString(a.path, 'path');
+    const path = optionalString(a.path, "path");
     if (path !== undefined && path.length === 0) {
         throw new Error('"path" must be a non-empty string.');
     }
-    const count = optionalNumber(a.count, 'count');
+    const count = optionalNumber(a.count, "count");
     if (count !== undefined) {
         if (!Number.isInteger(count) || count < 1 || count > 50) {
             throw new Error('"count" must be an integer between 1 and 50.');
         }
     }
-    const ref = optionalString(a.ref, 'ref');
+    const ref = optionalString(a.ref, "ref");
     if (ref !== undefined && ref.length === 0) {
         throw new Error('"ref" must be a non-empty string.');
     }
     return { path, count, ref };
 }
-const VALID_RUNNERS = ['vitest', 'jest', 'pytest', 'phpunit', 'go', 'cargo', 'rspec', 'mocha'];
+const VALID_RUNNERS = [
+    "vitest",
+    "jest",
+    "pytest",
+    "phpunit",
+    "go",
+    "cargo",
+    "rspec",
+    "mocha",
+];
 export function validateTestSummaryArgs(args) {
-    if (!args || typeof args !== 'object') {
+    if (!args || typeof args !== "object") {
         throw new Error('Arguments must be an object with a "command" parameter.');
     }
     const a = args;
-    if (typeof a.command !== 'string' || a.command.length === 0) {
+    if (typeof a.command !== "string" || a.command.length === 0) {
         throw new Error('Required parameter "command" must be a non-empty string.');
     }
     let runner;
     if (a.runner !== undefined && a.runner !== null) {
-        if (typeof a.runner !== 'string' || !VALID_RUNNERS.includes(a.runner)) {
-            throw new Error(`"runner" must be one of: ${VALID_RUNNERS.join(', ')}`);
+        if (typeof a.runner !== "string" || !VALID_RUNNERS.includes(a.runner)) {
+            throw new Error(`"runner" must be one of: ${VALID_RUNNERS.join(", ")}`);
         }
         runner = a.runner;
     }
-    const timeout = optionalNumber(a.timeout, 'timeout');
+    const timeout = optionalNumber(a.timeout, "timeout");
     if (timeout !== undefined) {
         if (!Number.isInteger(timeout) || timeout < 1000 || timeout > 300000) {
             throw new Error('"timeout" must be an integer between 1000 and 300000 (ms).');
@@ -456,27 +532,27 @@ export function validateTestSummaryArgs(args) {
     return { command: a.command, runner, timeout };
 }
 export function validateReadSectionArgs(args) {
-    if (!args || typeof args !== 'object') {
-        throw new Error('Arguments must be an object.');
+    if (!args || typeof args !== "object") {
+        throw new Error("Arguments must be an object.");
     }
     const a = args;
-    if (typeof a.path !== 'string' || a.path.length === 0) {
+    if (typeof a.path !== "string" || a.path.length === 0) {
         throw new Error('Required parameter "path" must be a non-empty string.');
     }
-    if (typeof a.heading !== 'string' || a.heading.length === 0) {
+    if (typeof a.heading !== "string" || a.heading.length === 0) {
         throw new Error('Required parameter "heading" must be a non-empty string.');
     }
     return { path: a.path, heading: a.heading };
 }
 /** Detect roots that would cause ast-index to scan the entire filesystem */
 export function isDangerousRoot(root) {
-    const normalized = root.replace(/\/+$/, '') || '/';
+    const normalized = root.replace(/\/+$/, "") || "/";
     // System roots
-    if (normalized === '/' || normalized === '/tmp' || normalized === '/var')
+    if (normalized === "/" || normalized === "/tmp" || normalized === "/var")
         return true;
     // Home directories (macOS, Linux)
-    const home = process.env.HOME || process.env.USERPROFILE || '';
-    if (home && normalized === home.replace(/\/+$/, ''))
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    if (home && normalized === home.replace(/\/+$/, ""))
         return true;
     // Common dangerous patterns: /Users, /home, /root, C:\, C:\Users
     if (/^\/(?:Users|home|root)$/.test(normalized))