prinfer 0.5.2 → 0.6.0

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
+import { execSync } from "child_process";
 import fs2 from "fs";
 import os from "os";
 import path3 from "path";
@@ -48,66 +49,203 @@ function loadProgram(entryFileAbs, project) {
 function isArrowOrFnExpr(n) {
   return !!n && (ts.isArrowFunction(n) || ts.isFunctionExpression(n));
 }
-function nodeNameText(n) {
-  if (!n) return void 0;
-  if (ts.isIdentifier(n)) return n.text;
-  if (ts.isStringLiteral(n)) return n.text;
-  if (ts.isNumericLiteral(n)) return n.text;
-  return void 0;
-}
-function isFunctionLikeNamed(node, name) {
-  if (ts.isFunctionDeclaration(node) && node.name?.text === name) return true;
-  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === name) {
-    return isArrowOrFnExpr(node.initializer);
-  }
-  if ((ts.isMethodDeclaration(node) || ts.isMethodSignature(node)) && nodeNameText(node.name) === name) {
-    return true;
-  }
-  if (ts.isPropertyAssignment(node) && nodeNameText(node.name) === name) {
-    return isArrowOrFnExpr(node.initializer);
+function findSmallestNodeAtPosition(sourceFile, position) {
+  let result;
+  function visit(node) {
+    const start = node.getStart(sourceFile);
+    const end = node.getEnd();
+    if (position < start || position >= end) {
+      return;
+    }
+    if (!result || node.getWidth(sourceFile) <= result.getWidth(sourceFile)) {
+      result = node;
+    }
+    ts.forEachChild(node, visit);
   }
-  return false;
+  visit(sourceFile);
+  return result;
 }
-function isVariableNamed(node, name) {
-  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === name) {
+function findHoverableAncestor(sourceFile, position) {
+  const smallestNode = findSmallestNodeAtPosition(sourceFile, position);
+  if (!smallestNode) return void 0;
+  let bestMatch = smallestNode;
+  function visit(n) {
+    const start = n.getStart(sourceFile);
+    const end = n.getEnd();
+    if (position < start || position >= end) {
+      return false;
+    }
+    if (ts.isCallExpression(n)) {
+      const expr = n.expression;
+      if (ts.isIdentifier(expr)) {
+        if (position >= expr.getStart(sourceFile) && position < expr.getEnd()) {
+          bestMatch = n;
+        }
+      } else if (ts.isPropertyAccessExpression(expr)) {
+        if (position >= expr.name.getStart(sourceFile) && position < expr.name.getEnd()) {
+          bestMatch = n;
+        }
+      }
+    }
+    if (ts.isFunctionDeclaration(n) && n.name) {
+      if (position >= n.name.getStart(sourceFile) && position < n.name.getEnd()) {
+        bestMatch = n;
+      }
+    }
+    if (ts.isVariableDeclaration(n) && ts.isIdentifier(n.name)) {
+      if (position >= n.name.getStart(sourceFile) && position < n.name.getEnd()) {
+        bestMatch = n;
+      }
+    }
+    if ((ts.isMethodDeclaration(n) || ts.isMethodSignature(n)) && ts.isIdentifier(n.name)) {
+      if (position >= n.name.getStart(sourceFile) && position < n.name.getEnd()) {
+        bestMatch = n;
+      }
+    }
+    if (ts.isClassDeclaration(n) && n.name) {
+      if (position >= n.name.getStart(sourceFile) && position < n.name.getEnd()) {
+        bestMatch = n;
+      }
+    }
+    if (ts.isInterfaceDeclaration(n) && n.name) {
+      if (position >= n.name.getStart(sourceFile) && position < n.name.getEnd()) {
+        bestMatch = n;
+      }
+    }
+    ts.forEachChild(n, visit);
     return true;
   }
-  return false;
-}
-function isNamedNode(node, name) {
-  return isFunctionLikeNamed(node, name) || isVariableNamed(node, name);
+  visit(sourceFile);
+  return bestMatch;
 }
-function getLineNumber(sourceFile, node) {
-  const { line } = sourceFile.getLineAndCharacterOfPosition(
-    node.getStart(sourceFile)
+function findNodeAtPosition(sourceFile, line, column) {
+  const lineCount = sourceFile.getLineStarts().length;
+  if (line < 1 || line > lineCount) {
+    return void 0;
+  }
+  const lineStart = sourceFile.getLineStarts()[line - 1];
+  const lineEnd = line < lineCount ? sourceFile.getLineStarts()[line] : sourceFile.getEnd();
+  const lineLength = lineEnd - lineStart;
+  if (column < 1 || column > lineLength + 1) {
+    return void 0;
+  }
+  const position = sourceFile.getPositionOfLineAndCharacter(
+    line - 1,
+    column - 1
   );
-  return line + 1;
+  return findHoverableAncestor(sourceFile, position);
 }
-function findNodeByNameAndLine(sourceFile, name, line) {
-  let found;
-  const visit = (node) => {
-    if (found) return;
-    if (isNamedNode(node, name)) {
-      if (line !== void 0) {
-        const nodeLine = getLineNumber(sourceFile, node);
-        if (nodeLine === line) {
-          found = node;
-          return;
-        }
-      } else {
-        found = node;
-        return;
-      }
+function getSymbolKind(node) {
+  if (ts.isFunctionDeclaration(node)) return "function";
+  if (ts.isArrowFunction(node)) return "function";
+  if (ts.isFunctionExpression(node)) return "function";
+  if (ts.isMethodDeclaration(node)) return "method";
+  if (ts.isMethodSignature(node)) return "method";
+  if (ts.isVariableDeclaration(node)) {
+    const init = node.initializer;
+    if (init && (ts.isArrowFunction(init) || ts.isFunctionExpression(init))) {
+      return "function";
     }
-    ts.forEachChild(node, visit);
-  };
-  visit(sourceFile);
-  return found;
+    return "variable";
+  }
+  if (ts.isParameter(node)) return "parameter";
+  if (ts.isPropertyDeclaration(node)) return "property";
+  if (ts.isPropertySignature(node)) return "property";
+  if (ts.isPropertyAccessExpression(node)) return "property";
+  if (ts.isCallExpression(node)) return "call";
+  if (ts.isTypeAliasDeclaration(node)) return "type";
+  if (ts.isInterfaceDeclaration(node)) return "interface";
+  if (ts.isClassDeclaration(node)) return "class";
+  if (ts.isIdentifier(node)) return "identifier";
+  return "unknown";
 }
-function getTypeInfo(program, node, sourceFile) {
+function getNodeName(node) {
+  if (ts.isFunctionDeclaration(node) && node.name) {
+    return node.name.text;
+  }
+  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+    return node.name.text;
+  }
+  if ((ts.isMethodDeclaration(node) || ts.isMethodSignature(node)) && ts.isIdentifier(node.name)) {
+    return node.name.text;
+  }
+  if (ts.isPropertyAccessExpression(node)) {
+    return node.name.text;
+  }
+  if (ts.isCallExpression(node)) {
+    const expr = node.expression;
+    if (ts.isIdentifier(expr)) return expr.text;
+    if (ts.isPropertyAccessExpression(expr)) return expr.name.text;
+  }
+  if (ts.isParameter(node) && ts.isIdentifier(node.name)) {
+    return node.name.text;
+  }
+  if (ts.isIdentifier(node)) {
+    return node.text;
+  }
+  if (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isClassDeclaration(node)) {
+    return node.name?.text;
+  }
+  return void 0;
+}
+function getDocumentation(checker, symbol) {
+  if (!symbol) return void 0;
+  const docs = symbol.getDocumentationComment(checker);
+  if (docs.length === 0) return void 0;
+  return ts.displayPartsToString(docs);
+}
+function getHoverInfo(program, node, sourceFile, includeDocs) {
   const checker = program.getTypeChecker();
-  const sf = sourceFile ?? node.getSourceFile();
-  const line = getLineNumber(sf, node);
+  const sf = sourceFile;
+  const { line, character } = sf.getLineAndCharacterOfPosition(
+    node.getStart(sf)
+  );
+  const flags = ts.TypeFormatFlags.NoTruncation;
+  const kind = getSymbolKind(node);
+  const name = getNodeName(node);
+  let symbol;
+  if (ts.isCallExpression(node)) {
+    const expr = node.expression;
+    if (ts.isPropertyAccessExpression(expr)) {
+      symbol = checker.getSymbolAtLocation(expr.name);
+    } else {
+      symbol = checker.getSymbolAtLocation(expr);
+    }
+  } else {
+    const nodeWithName2 = node;
+    if (nodeWithName2.name) {
+      symbol = checker.getSymbolAtLocation(nodeWithName2.name);
+    } else {
+      symbol = checker.getSymbolAtLocation(node);
+    }
+  }
+  const documentation = includeDocs ? getDocumentation(checker, symbol) : void 0;
+  if (ts.isCallExpression(node)) {
+    const sig2 = checker.getResolvedSignature(node);
+    if (sig2) {
+      const signature = checker.signatureToString(sig2, void 0, flags);
+      const ret = checker.getReturnTypeOfSignature(sig2);
+      const returnType = checker.typeToString(ret, void 0, flags);
+      return {
+        signature,
+        returnType,
+        line: line + 1,
+        column: character + 1,
+        documentation,
+        kind,
+        name
+      };
+    }
+    const t2 = checker.getTypeAtLocation(node);
+    return {
+      signature: checker.typeToString(t2, void 0, flags),
+      line: line + 1,
+      column: character + 1,
+      documentation,
+      kind,
+      name
+    };
+  }
   let sig;
   if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) {
     sig = checker.getSignatureFromDeclaration(node) ?? void 0;
@@ -122,26 +260,39 @@ function getTypeInfo(program, node, sourceFile) {
   } else if (ts.isMethodSignature(node)) {
     sig = checker.getSignatureFromDeclaration(node) ?? void 0;
   }
-  const flags = ts.TypeFormatFlags.NoTruncation;
   if (sig) {
     const signature = checker.signatureToString(sig, void 0, flags);
     const ret = checker.getReturnTypeOfSignature(sig);
     const returnType = checker.typeToString(ret, void 0, flags);
-    return { signature, returnType, line };
+    return {
+      signature,
+      returnType,
+      line: line + 1,
+      column: character + 1,
+      documentation,
+      kind,
+      name
+    };
   }
   const nodeWithName = node;
-  let nameNode = node;
+  let targetNode = node;
   if (nodeWithName.name && ts.isIdentifier(nodeWithName.name)) {
-    nameNode = nodeWithName.name;
+    targetNode = nodeWithName.name;
   }
-  const t = checker.getTypeAtLocation(nameNode);
-  return { signature: checker.typeToString(t, void 0, flags), line };
+  const t = checker.getTypeAtLocation(targetNode);
+  return {
+    signature: checker.typeToString(t, void 0, flags),
+    line: line + 1,
+    column: character + 1,
+    documentation,
+    kind,
+    name
+  };
 }
 
 // src/index.ts
-function inferType(file, name, options) {
-  const opts = typeof options === "string" ? { project: options } : options ?? {};
-  const { line, project } = opts;
+function hover(file, line, column, options) {
+  const { project, include_docs = false } = options ?? {};
   const entryFileAbs = path2.resolve(process.cwd(), file);
   if (!fs.existsSync(entryFileAbs)) {
     throw new Error(`File not found: ${entryFileAbs}`);
@@ -153,14 +304,11 @@ function inferType(file, name, options) {
       `Could not load source file into the program (check tsconfig include/exclude): ${entryFileAbs}`
     );
   }
-  const node = findNodeByNameAndLine(sourceFile, name, line);
+  const node = findNodeAtPosition(sourceFile, line, column);
   if (!node) {
-    const lineInfo = line !== void 0 ? ` at line ${line}` : "";
-    throw new Error(
-      `No symbol named "${name}"${lineInfo} found in ${entryFileAbs}`
-    );
+    throw new Error(`No symbol found at ${entryFileAbs}:${line}:${column}`);
   }
-  return getTypeInfo(program, node, sourceFile);
+  return getHoverInfo(program, node, sourceFile, include_docs);
 }
 
 // src/cli.ts
@@ -168,43 +316,56 @@ var HELP = `
 prinfer - TypeScript type inference inspection tool
 
 Usage:
-  prinfer <file.ts>[:<line>] <name> [--project <tsconfig.json>]
+  prinfer <file.ts>:<line>:<column> [--docs] [--project <tsconfig.json>]
   prinfer setup
 
 Commands:
   setup                Install MCP server and skill for Claude Code
 
 Arguments:
-  file.ts              Path to the TypeScript file
-  :line                Optional line number to narrow search (e.g., file.ts:75)
-  name                 Name of the function/variable to inspect
+  file.ts:line:column  Path to TypeScript file with 1-based line and column
 
 Options:
+  --docs, -d           Include JSDoc/TSDoc documentation
   --project, -p        Path to tsconfig.json (optional)
   --help, -h           Show this help message
 
 Examples:
-  prinfer src/utils.ts myFunction
-  prinfer src/utils.ts:75 commandResult
+  prinfer src/utils.ts:75:10
+  prinfer src/utils.ts:75:10 --docs
+  prinfer src/utils.ts:75:10 --project ./tsconfig.json
   prinfer setup
 `.trim();
 var MANUAL_SETUP = `
 Manual setup instructions:
 
-1. Add MCP server to ~/.claude/settings.json:
-
-   {
-     "mcpServers": {
-       "prinfer": {
-         "command": "prinfer-mcp"
-       }
-     }
-   }
+1. Add MCP server:
+   Run: claude mcp add prinfer node /path/to/prinfer-mcp
 
 2. Create skill file at ~/.claude/skills/prefer-infer.md:
-
    See https://github.com/clockblocker/prinfer for skill content.
 `.trim();
+function getMcpBinaryPath() {
+  const thisScript = new URL(import.meta.url).pathname;
+  return path3.join(path3.dirname(thisScript), "mcp.js");
+}
+function installMcpServer() {
+  try {
+    const mcpPath = getMcpBinaryPath();
+    try {
+      execSync("claude mcp remove prinfer", { stdio: "pipe" });
+    } catch {
+    }
+    execSync(`claude mcp add prinfer node ${mcpPath}`, {
+      stdio: "inherit"
+    });
+    console.log("[ok] Added prinfer MCP server");
+    return true;
+  } catch (err) {
+    console.error(`[error] MCP setup failed: ${err.message}`);
+    return false;
+  }
+}
 var SKILL_CONTENT = `# TypeScript Type Inference (prinfer)
 
 ## Coding Guideline
@@ -218,26 +379,26 @@ When writing TypeScript code, prefer relying on type inference over explicit typ
   - The type serves as documentation for complex structures
   - You're defining a public API contract
 
-Use the \`prinfer\` MCP tool (\`infer_type\`) to verify what TypeScript infers before adding explicit types.
+Use the \`prinfer\` MCP tool (\`hover\`) to verify what TypeScript infers before adding explicit types.
 
 ## Commands
 
-### /check-type
+### /hover
 
-Check the inferred type of a TypeScript symbol.
+Check the inferred type at a specific position in a TypeScript file.
 
-Usage: \`/check-type <file>:<line> <name>\` or \`/check-type <file> <name>\`
+Usage: \`/hover <file>:<line>:<column>\`
 
 Examples:
-- \`/check-type src/utils.ts:75 commandResult\`
-- \`/check-type src/utils.ts myFunction\`
+- \`/hover src/utils.ts:75:10\`
+- \`/hover src/utils.ts:42:5\`
 
-<command-name>check-type</command-name>
+<command-name>hover</command-name>
 
-Use the \`infer_type\` MCP tool to check the type:
-1. Parse the arguments to extract file, optional line number, and symbol name
-2. Call \`infer_type(file, name, line?)\`
-3. Report the inferred signature and return type
+Use the \`hover\` MCP tool to check the type:
+1. Parse the arguments to extract file, line, and column
+2. Call \`hover(file, line, column, { include_docs: true })\`
+3. Report the inferred signature, return type, and documentation
 `;
 function runSetup() {
   const homeDir = os.homedir();
@@ -248,33 +409,8 @@ function runSetup() {
     console.error(MANUAL_SETUP);
     process.exit(1);
   }
-  let mcpOk = false;
+  const mcpOk = installMcpServer();
   let skillOk = false;
-  const configFile = path3.join(claudeDir, "settings.json");
-  try {
-    let config = {};
-    if (fs2.existsSync(configFile)) {
-      config = JSON.parse(fs2.readFileSync(configFile, "utf-8"));
-    }
-    if (config.mcpServers?.prinfer) {
-      console.log("[ok] MCP server already configured");
-      mcpOk = true;
-    } else {
-      config.mcpServers = config.mcpServers || {};
-      config.mcpServers.prinfer = { command: "prinfer-mcp" };
-      fs2.writeFileSync(
-        configFile,
-        `${JSON.stringify(config, null, 2)}
-`
-      );
-      console.log("[ok] Added MCP server to settings.json");
-      mcpOk = true;
-    }
-  } catch (err) {
-    console.error(
-      `[error] Failed to configure MCP server: ${err.message}`
-    );
-  }
   const skillsDir = path3.join(claudeDir, "skills");
   const skillFile = path3.join(skillsDir, "prefer-infer.md");
   try {
@@ -304,12 +440,16 @@ function runSetup() {
     process.exit(1);
   }
 }
-function parseFileArg(arg) {
-  const match = arg.match(/^(.+):(\d+)$/);
+function parsePositionArg(arg) {
+  const match = arg.match(/^(.+):(\d+):(\d+)$/);
   if (match) {
-    return { file: match[1], line: Number.parseInt(match[2], 10) };
+    return {
+      file: match[1],
+      line: Number.parseInt(match[2], 10),
+      column: Number.parseInt(match[3], 10)
+    };
   }
-  return { file: arg };
+  return null;
 }
 function parseArgs(argv) {
   const args = argv.slice(2);
@@ -321,16 +461,17 @@ function parseArgs(argv) {
     runSetup();
     return null;
   }
-  const fileArg = args[0];
-  const name = args[1];
-  if (!fileArg || !name) {
+  const positionArg = args[0];
+  const parsed = parsePositionArg(positionArg);
+  if (!parsed) {
     console.error(
-      "Error: Both <file> and <name> arguments are required.\n"
+      "Error: Position argument must be in format <file>:<line>:<column>\n"
     );
     console.log(HELP);
     process.exit(1);
   }
-  const { file, line } = parseFileArg(fileArg);
+  const { file, line, column } = parsed;
+  const includeDocs = args.includes("--docs") || args.includes("-d");
   let project;
   const projectIdx = args.findIndex((a) => a === "--project" || a === "-p");
   if (projectIdx >= 0) {
@@ -341,7 +482,7 @@ function parseArgs(argv) {
       process.exit(1);
     }
   }
-  return { file, name, line, project };
+  return { file, line, column, includeDocs, project };
 }
 function main() {
   const options = parseArgs(process.argv);
@@ -349,14 +490,21 @@ function main() {
     process.exit(0);
   }
   try {
-    const result = inferType(options.file, options.name, {
-      line: options.line,
+    const result = hover(options.file, options.line, options.column, {
+      include_docs: options.includeDocs,
       project: options.project
     });
     console.log(result.signature);
     if (result.returnType) {
       console.log("returns:", result.returnType);
     }
+    if (result.name) {
+      console.log("name:", result.name);
+    }
+    console.log("kind:", result.kind);
+    if (result.documentation) {
+      console.log("docs:", result.documentation);
+    }
   } catch (error) {
     console.error(error.message);
     process.exit(1);