@compilr-dev/agents-coding-ts 0.1.2 → 0.1.4

package/dist/tools/get-documentation.js

@@ -4,11 +4,11 @@
  * Extract JSDoc/TSDoc documentation from source files.
  * Provides documentation coverage metrics and identifies undocumented exports.
  */
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import * as ts from 'typescript';
-import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
-import { detectLanguage, isLanguageSupported } from '../parser/typescript-parser.js';
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as ts from "typescript";
+import { defineTool, createSuccessResult, createErrorResult, } from "@compilr-dev/agents";
+import { detectLanguage, isLanguageSupported, } from "../parser/typescript-parser.js";
 // Tool description
 const TOOL_DESCRIPTION = `Extract JSDoc/TSDoc documentation from source files.
 Returns documented symbols with their signatures and documentation content.
@@ -16,52 +16,52 @@ Calculates documentation coverage metrics and identifies undocumented exports.
 Useful for generating API documentation and measuring doc coverage.`;
 // Tool input schema
 const TOOL_INPUT_SCHEMA = {
-    type: 'object',
+    type: "object",
     properties: {
         path: {
-            type: 'string',
-            description: 'File or directory to analyze',
+            type: "string",
+            description: "File or directory to analyze",
         },
         recursive: {
-            type: 'boolean',
-            description: 'Recursive analysis for directories (default: false)',
+            type: "boolean",
+            description: "Recursive analysis for directories (default: false)",
             default: false,
         },
         kinds: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'Filter by symbol kinds: function, class, interface, type, enum, variable, method, property',
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by symbol kinds: function, class, interface, type, enum, variable, method, property",
         },
         exportedOnly: {
-            type: 'boolean',
-            description: 'Only include exported symbols (default: false)',
+            type: "boolean",
+            description: "Only include exported symbols (default: false)",
             default: false,
         },
         documentedOnly: {
-            type: 'boolean',
-            description: 'Only include symbols with documentation (default: true)',
+            type: "boolean",
+            description: "Only include symbols with documentation (default: true)",
             default: true,
         },
         maxFiles: {
-            type: 'number',
-            description: 'Maximum files to analyze (default: 50)',
+            type: "number",
+            description: "Maximum files to analyze (default: 50)",
             default: 50,
         },
         includePrivate: {
-            type: 'boolean',
-            description: 'Include private class members (default: false)',
+            type: "boolean",
+            description: "Include private class members (default: false)",
             default: false,
         },
     },
-    required: ['path'],
+    required: ["path"],
 };
 // Default exclusions
-const DEFAULT_EXCLUDE = ['node_modules', 'dist', 'build', '.git', 'coverage'];
+const DEFAULT_EXCLUDE = ["node_modules", "dist", "build", ".git", "coverage"];
 /**
  * getDocumentation tool
  */
 export const getDocumentationTool = defineTool({
-    name: 'get_documentation',
+    name: "get_documentation",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeGetDocumentation,
@@ -120,7 +120,9 @@ async function executeGetDocumentation(input) {
                 }
             }
         }
-        const coveragePercent = totalSymbols > 0 ? Math.round((documentedSymbols / totalSymbols) * 100) : 100;
+        const coveragePercent = totalSymbols > 0
+            ? Math.round((documentedSymbols / totalSymbols) * 100)
+            : 100;
         const result = {
             path: resolvedPath,
             files: fileResults,
@@ -170,7 +172,8 @@ async function collectFiles(dirPath, files, maxDepth, maxFiles, currentDepth = 0
             }
             else if (entry.isFile()) {
                 // Only include TypeScript/JavaScript files
-                if (/\.(ts|tsx|js|jsx)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+                if (/\.(ts|tsx|js|jsx)$/.test(entry.name) &&
+                    !entry.name.endsWith(".d.ts")) {
                     files.push(fullPath);
                 }
             }
@@ -185,12 +188,12 @@ async function collectFiles(dirPath, files, maxDepth, maxFiles, currentDepth = 0
  */
 async function analyzeFile(filePath, options) {
     try {
-        const content = await fs.readFile(filePath, 'utf-8');
+        const content = await fs.readFile(filePath, "utf-8");
         const detection = detectLanguage(filePath);
         if (!detection.language || !isLanguageSupported(detection.language)) {
             return null;
         }
-        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, filePath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
         // Extract file-level documentation
         const fileDoc = extractFileDocumentation(sourceFile);
         // Extract symbol documentation
@@ -212,7 +215,9 @@ async function analyzeFile(filePath, options) {
         const totalSymbols = allSymbols.length;
         const documentedCount = allSymbols.filter((s) => hasDocumentation(s.documentation)).length;
         const undocumentedCount = totalSymbols - documentedCount;
-        const coveragePercent = totalSymbols > 0 ? Math.round((documentedCount / totalSymbols) * 100) : 100;
+        const coveragePercent = totalSymbols > 0
+            ? Math.round((documentedCount / totalSymbols) * 100)
+            : 100;
         return {
             path: filePath,
             fileDoc: fileDoc && hasDocumentation(fileDoc) ? fileDoc : undefined,
@@ -239,25 +244,27 @@ function extractFileDocumentation(sourceFile) {
     if (!match)
         return undefined;
     const commentText = match[1];
-    const lines = commentText.split('\n').map((l) => l.replace(/^\s*\*\s?/, '').trim());
+    const lines = commentText
+        .split("\n")
+        .map((l) => l.replace(/^\s*\*\s?/, "").trim());
     // Filter out @module and similar file-level tags, and empty lines
     const descLines = [];
     let isFileLevel = false;
     for (const line of lines) {
-        if (line.startsWith('@module') ||
-            line.startsWith('@fileoverview') ||
-            line.startsWith('@file')) {
+        if (line.startsWith("@module") ||
+            line.startsWith("@fileoverview") ||
+            line.startsWith("@file")) {
             isFileLevel = true;
         }
-        else if (!line.startsWith('@') && line.length > 0) {
+        else if (!line.startsWith("@") && line.length > 0) {
             descLines.push(line);
         }
     }
     // Only return if this looks like a file-level comment
     if (!isFileLevel && descLines.length === 0)
         return undefined;
-    const summary = descLines[0] || '';
-    const description = descLines.length > 1 ? descLines.slice(1).join('\n').trim() : undefined;
+    const summary = descLines[0] || "";
+    const description = descLines.length > 1 ? descLines.slice(1).join("\n").trim() : undefined;
     return {
         summary,
         description,
@@ -269,56 +276,58 @@ function extractFileDocumentation(sourceFile) {
 function extractSymbols(node, sourceFile, symbols, options, _containerName) {
     // Function declarations
     if (ts.isFunctionDeclaration(node) && node.name) {
-        symbols.push(extractSymbolInfo(node, sourceFile, 'function', node.name.text));
+        symbols.push(extractSymbolInfo(node, sourceFile, "function", node.name.text));
     }
     // Variable declarations (arrow functions, const values)
     else if (ts.isVariableStatement(node)) {
         for (const decl of node.declarationList.declarations) {
             if (ts.isIdentifier(decl.name)) {
                 const kind = decl.initializer &&
-                    (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))
-                    ? 'function'
-                    : 'variable';
+                    (ts.isArrowFunction(decl.initializer) ||
+                        ts.isFunctionExpression(decl.initializer))
+                    ? "function"
+                    : "variable";
                 symbols.push(extractSymbolInfo(node, sourceFile, kind, decl.name.text));
             }
         }
     }
     // Class declarations
     else if (ts.isClassDeclaration(node) && node.name) {
-        symbols.push(extractSymbolInfo(node, sourceFile, 'class', node.name.text));
+        symbols.push(extractSymbolInfo(node, sourceFile, "class", node.name.text));
         // Extract class members
         for (const member of node.members) {
             // Skip private members if not included
             if (!options.includePrivate && isPrivateMember(member))
                 continue;
             if (ts.isMethodDeclaration(member) && ts.isIdentifier(member.name)) {
-                symbols.push(extractSymbolInfo(member, sourceFile, 'method', member.name.text, node.name.text));
+                symbols.push(extractSymbolInfo(member, sourceFile, "method", member.name.text, node.name.text));
             }
-            else if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
-                symbols.push(extractSymbolInfo(member, sourceFile, 'property', member.name.text, node.name.text));
+            else if (ts.isPropertyDeclaration(member) &&
+                ts.isIdentifier(member.name)) {
+                symbols.push(extractSymbolInfo(member, sourceFile, "property", member.name.text, node.name.text));
             }
         }
     }
     // Interface declarations
     else if (ts.isInterfaceDeclaration(node)) {
-        symbols.push(extractSymbolInfo(node, sourceFile, 'interface', node.name.text));
+        symbols.push(extractSymbolInfo(node, sourceFile, "interface", node.name.text));
         // Extract interface members
         for (const member of node.members) {
             if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
-                symbols.push(extractSymbolInfo(member, sourceFile, 'property', member.name.text, node.name.text));
+                symbols.push(extractSymbolInfo(member, sourceFile, "property", member.name.text, node.name.text));
             }
             else if (ts.isMethodSignature(member) && ts.isIdentifier(member.name)) {
-                symbols.push(extractSymbolInfo(member, sourceFile, 'method', member.name.text, node.name.text));
+                symbols.push(extractSymbolInfo(member, sourceFile, "method", member.name.text, node.name.text));
             }
         }
     }
     // Type alias declarations
     else if (ts.isTypeAliasDeclaration(node)) {
-        symbols.push(extractSymbolInfo(node, sourceFile, 'type', node.name.text));
+        symbols.push(extractSymbolInfo(node, sourceFile, "type", node.name.text));
     }
     // Enum declarations
     else if (ts.isEnumDeclaration(node)) {
-        symbols.push(extractSymbolInfo(node, sourceFile, 'enum', node.name.text));
+        symbols.push(extractSymbolInfo(node, sourceFile, "enum", node.name.text));
     }
     // Continue traversing (but skip into class/interface bodies as they're handled above)
     if (!ts.isClassDeclaration(node) && !ts.isInterfaceDeclaration(node)) {
@@ -334,7 +343,7 @@ function isPrivateMember(node) {
     if (!ts.canHaveModifiers(node))
         return false;
     const modifiers = ts.getModifiers(node);
-    return modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword) ?? false;
+    return (modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword) ?? false);
 }
 /**
  * Extract symbol information
@@ -364,7 +373,7 @@ function isExported(node) {
         const varStatement = varDeclList.parent;
         if (ts.canHaveModifiers(varStatement)) {
             const modifiers = ts.getModifiers(varStatement);
-            return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+            return (modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
         }
         return false;
     }
@@ -382,131 +391,154 @@ function isExported(node) {
     if (!ts.canHaveModifiers(node))
         return false;
     const modifiers = ts.getModifiers(node);
-    return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+    return (modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
 }
 /**
  * Extract signature from node
  */
 function extractSignature(node, sourceFile, kind) {
     switch (kind) {
-        case 'function': {
+        case "function": {
             if (ts.isFunctionDeclaration(node) && node.name) {
-                const params = node.parameters.map((p) => p.getText(sourceFile)).join(', ');
-                const returnType = node.type ? `: ${node.type.getText(sourceFile)}` : '';
+                const params = node.parameters
+                    .map((p) => p.getText(sourceFile))
+                    .join(", ");
+                const returnType = node.type
+                    ? `: ${node.type.getText(sourceFile)}`
+                    : "";
                 const generics = node.typeParameters
-                    ? `<${node.typeParameters.map((t) => t.getText(sourceFile)).join(', ')}>`
-                    : '';
+                    ? `<${node.typeParameters.map((t) => t.getText(sourceFile)).join(", ")}>`
+                    : "";
                 return `function ${node.name.text}${generics}(${params})${returnType}`;
             }
             if (ts.isVariableStatement(node)) {
                 const decl = node.declarationList.declarations[0];
                 if (ts.isIdentifier(decl.name)) {
                     if (decl.initializer &&
-                        (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+                        (ts.isArrowFunction(decl.initializer) ||
+                            ts.isFunctionExpression(decl.initializer))) {
                         const func = decl.initializer;
-                        const params = func.parameters.map((p) => p.getText(sourceFile)).join(', ');
-                        const returnType = func.type ? `: ${func.type.getText(sourceFile)}` : '';
+                        const params = func.parameters
+                            .map((p) => p.getText(sourceFile))
+                            .join(", ");
+                        const returnType = func.type
+                            ? `: ${func.type.getText(sourceFile)}`
+                            : "";
                         return `const ${decl.name.text} = (${params})${returnType} => ...`;
                     }
                 }
             }
-            return node.getText(sourceFile).split('\n')[0];
+            return node.getText(sourceFile).split("\n")[0];
         }
-        case 'class': {
+        case "class": {
             if (ts.isClassDeclaration(node) && node.name) {
                 const generics = node.typeParameters
-                    ? `<${node.typeParameters.map((t) => t.getText(sourceFile)).join(', ')}>`
-                    : '';
-                let heritage = '';
+                    ? `<${node.typeParameters.map((t) => t.getText(sourceFile)).join(", ")}>`
+                    : "";
+                let heritage = "";
                 if (node.heritageClauses) {
                     for (const clause of node.heritageClauses) {
                         const tokenKind = clause.token;
                         if (tokenKind === ts.SyntaxKind.ExtendsKeyword) {
-                            heritage += ` extends ${clause.types.map((t) => t.getText(sourceFile)).join(', ')}`;
+                            heritage += ` extends ${clause.types.map((t) => t.getText(sourceFile)).join(", ")}`;
                         }
                         else if (tokenKind === ts.SyntaxKind.ImplementsKeyword) {
-                            heritage += ` implements ${clause.types.map((t) => t.getText(sourceFile)).join(', ')}`;
+                            heritage += ` implements ${clause.types.map((t) => t.getText(sourceFile)).join(", ")}`;
                         }
                     }
                 }
                 return `class ${node.name.text}${generics}${heritage}`;
             }
-            return node.getText(sourceFile).split('\n')[0];
+            return node.getText(sourceFile).split("\n")[0];
         }
-        case 'interface': {
+        case "interface": {
             if (ts.isInterfaceDeclaration(node)) {
                 const generics = node.typeParameters
-                    ? `<${node.typeParameters.map((t) => t.getText(sourceFile)).join(', ')}>`
-                    : '';
-                let heritage = '';
+                    ? `<${node.typeParameters.map((t) => t.getText(sourceFile)).join(", ")}>`
+                    : "";
+                let heritage = "";
                 if (node.heritageClauses) {
                     for (const clause of node.heritageClauses) {
-                        heritage += ` extends ${clause.types.map((t) => t.getText(sourceFile)).join(', ')}`;
+                        heritage += ` extends ${clause.types.map((t) => t.getText(sourceFile)).join(", ")}`;
                     }
                 }
                 return `interface ${node.name.text}${generics}${heritage}`;
             }
-            return node.getText(sourceFile).split('\n')[0];
+            return node.getText(sourceFile).split("\n")[0];
         }
-        case 'type': {
+        case "type": {
             if (ts.isTypeAliasDeclaration(node)) {
                 const generics = node.typeParameters
-                    ? `<${node.typeParameters.map((t) => t.getText(sourceFile)).join(', ')}>`
-                    : '';
+                    ? `<${node.typeParameters.map((t) => t.getText(sourceFile)).join(", ")}>`
+                    : "";
                 const typeText = node.type.getText(sourceFile);
                 // Truncate long types
                 const maxLen = 80;
-                const truncatedType = typeText.length > maxLen ? typeText.slice(0, maxLen) + '...' : typeText;
+                const truncatedType = typeText.length > maxLen
+                    ? typeText.slice(0, maxLen) + "..."
+                    : typeText;
                 return `type ${node.name.text}${generics} = ${truncatedType}`;
             }
-            return node.getText(sourceFile).split('\n')[0];
+            return node.getText(sourceFile).split("\n")[0];
         }
-        case 'enum': {
+        case "enum": {
             if (ts.isEnumDeclaration(node)) {
-                const members = node.members.map((m) => m.name.getText(sourceFile)).slice(0, 5);
-                const suffix = node.members.length > 5 ? ', ...' : '';
-                return `enum ${node.name.text} { ${members.join(', ')}${suffix} }`;
+                const members = node.members
+                    .map((m) => m.name.getText(sourceFile))
+                    .slice(0, 5);
+                const suffix = node.members.length > 5 ? ", ..." : "";
+                return `enum ${node.name.text} { ${members.join(", ")}${suffix} }`;
             }
-            return node.getText(sourceFile).split('\n')[0];
+            return node.getText(sourceFile).split("\n")[0];
         }
-        case 'variable': {
+        case "variable": {
             if (ts.isVariableStatement(node)) {
                 const decl = node.declarationList.declarations[0];
                 if (ts.isIdentifier(decl.name)) {
-                    const typeText = decl.type ? `: ${decl.type.getText(sourceFile)}` : '';
+                    const typeText = decl.type
+                        ? `: ${decl.type.getText(sourceFile)}`
+                        : "";
                     return `const ${decl.name.text}${typeText}`;
                 }
             }
-            return node.getText(sourceFile).split('\n')[0];
+            return node.getText(sourceFile).split("\n")[0];
         }
-        case 'method': {
+        case "method": {
             if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) {
-                const params = node.parameters.map((p) => p.getText(sourceFile)).join(', ');
-                const returnType = node.type ? `: ${node.type.getText(sourceFile)}` : '';
+                const params = node.parameters
+                    .map((p) => p.getText(sourceFile))
+                    .join(", ");
+                const returnType = node.type
+                    ? `: ${node.type.getText(sourceFile)}`
+                    : "";
                 return `${node.name.text}(${params})${returnType}`;
             }
             if (ts.isMethodSignature(node) && ts.isIdentifier(node.name)) {
-                const params = node.parameters.map((p) => p.getText(sourceFile)).join(', ');
-                const returnType = node.type ? `: ${node.type.getText(sourceFile)}` : '';
+                const params = node.parameters
+                    .map((p) => p.getText(sourceFile))
+                    .join(", ");
+                const returnType = node.type
+                    ? `: ${node.type.getText(sourceFile)}`
+                    : "";
                 return `${node.name.text}(${params})${returnType}`;
             }
-            return node.getText(sourceFile).split('\n')[0];
+            return node.getText(sourceFile).split("\n")[0];
         }
-        case 'property': {
+        case "property": {
             if (ts.isPropertyDeclaration(node) && ts.isIdentifier(node.name)) {
-                const typeText = node.type ? `: ${node.type.getText(sourceFile)}` : '';
-                const optional = node.questionToken ? '?' : '';
+                const typeText = node.type ? `: ${node.type.getText(sourceFile)}` : "";
+                const optional = node.questionToken ? "?" : "";
                 return `${node.name.text}${optional}${typeText}`;
             }
             if (ts.isPropertySignature(node) && ts.isIdentifier(node.name)) {
-                const typeText = node.type ? `: ${node.type.getText(sourceFile)}` : '';
-                const optional = node.questionToken ? '?' : '';
+                const typeText = node.type ? `: ${node.type.getText(sourceFile)}` : "";
+                const optional = node.questionToken ? "?" : "";
                 return `${node.name.text}${optional}${typeText}`;
             }
-            return node.getText(sourceFile).split('\n')[0];
+            return node.getText(sourceFile).split("\n")[0];
         }
         default:
-            return node.getText(sourceFile).split('\n')[0];
+            return node.getText(sourceFile).split("\n")[0];
     }
 }
 /**
@@ -516,29 +548,29 @@ function extractDocumentation(node, sourceFile) {
     const jsDocTags = ts.getJSDocTags(node);
     const jsDocComments = node.jsDoc;
     const doc = {
-        summary: '',
+        summary: "",
     };
     // Get comment text
     if (jsDocComments?.length) {
         const firstDoc = jsDocComments[0];
-        if (typeof firstDoc.comment === 'string') {
-            const lines = firstDoc.comment.split('\n');
+        if (typeof firstDoc.comment === "string") {
+            const lines = firstDoc.comment.split("\n");
             doc.summary = lines[0].trim();
             if (lines.length > 1) {
-                doc.description = lines.slice(1).join('\n').trim();
+                doc.description = lines.slice(1).join("\n").trim();
             }
         }
-        else if (firstDoc.comment && typeof firstDoc.comment !== 'string') {
+        else if (firstDoc.comment && typeof firstDoc.comment !== "string") {
             // JSDocComment can be an array of JSDocText | JSDocLink
             const commentParts = firstDoc.comment;
             const text = commentParts
-                .map((c) => (c.kind === ts.SyntaxKind.JSDocText ? c.text : ''))
-                .join('')
+                .map((c) => (c.kind === ts.SyntaxKind.JSDocText ? c.text : ""))
+                .join("")
                 .trim();
-            const lines = text.split('\n');
+            const lines = text.split("\n");
             doc.summary = lines[0].trim();
             if (lines.length > 1) {
-                doc.description = lines.slice(1).join('\n').trim();
+                doc.description = lines.slice(1).join("\n").trim();
             }
         }
     }
@@ -549,37 +581,37 @@ function extractDocumentation(node, sourceFile) {
     const see = [];
     for (const tag of jsDocTags) {
         const tagName = tag.tagName.text;
-        let tagComment = '';
-        if (typeof tag.comment === 'string') {
+        let tagComment = "";
+        if (typeof tag.comment === "string") {
             tagComment = tag.comment;
         }
-        else if (tag.comment && typeof tag.comment !== 'string') {
+        else if (tag.comment && typeof tag.comment !== "string") {
             const commentParts = tag.comment;
             tagComment = commentParts
-                .map((c) => (c.kind === ts.SyntaxKind.JSDocText ? c.text : ''))
-                .join('')
+                .map((c) => (c.kind === ts.SyntaxKind.JSDocText ? c.text : ""))
+                .join("")
                 .trim();
         }
-        if (tagName === 'param' && ts.isJSDocParameterTag(tag)) {
+        if (tagName === "param" && ts.isJSDocParameterTag(tag)) {
             const paramName = tag.name.getText(sourceFile);
             params[paramName] = tagComment;
         }
-        else if (tagName === 'returns' || tagName === 'return') {
+        else if (tagName === "returns" || tagName === "return") {
             doc.returns = tagComment;
         }
-        else if (tagName === 'throws' || tagName === 'exception') {
+        else if (tagName === "throws" || tagName === "exception") {
             throws.push(tagComment);
         }
-        else if (tagName === 'example') {
+        else if (tagName === "example") {
             examples.push(tagComment);
         }
-        else if (tagName === 'see') {
+        else if (tagName === "see") {
             see.push(tagComment);
         }
         else if (ts.isJSDocDeprecatedTag(tag)) {
-            doc.deprecatedMessage = tagComment || 'This API is deprecated';
+            doc.deprecatedMessage = tagComment || "This API is deprecated";
         }
-        else if (tagName === 'since') {
+        else if (tagName === "since") {
             doc.since = tagComment;
         }
     }
@@ -598,7 +630,7 @@ function extractDocumentation(node, sourceFile) {
  */
 export function createGetDocumentationTool(options) {
     return defineTool({
-        name: options?.name ?? 'get_documentation',
+        name: options?.name ?? "get_documentation",
         description: options?.description ?? TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {

package/dist/tools/get-exports.d.ts

@@ -4,8 +4,8 @@
  * Get all exports from a module.
  * Uses TypeScript Compiler API for accurate AST analysis.
  */
-import type { Tool } from '@compilr-dev/agents';
-import type { GetExportsInput } from './types.js';
+import type { Tool } from "@compilr-dev/agents";
+import type { GetExportsInput } from "./types.js";
 /**
  * getExports tool - Get all exports from a module
  */