prinfer 0.3.0 → 0.4.0

package/README.md

@@ -14,6 +14,9 @@ npm install prinfer
 # Basic usage
 prinfer src/utils.ts myFunction
 
+# Find variable at specific line
+prinfer src/utils.ts:75 commandResult
+
 # With custom tsconfig
 prinfer src/utils.ts myFunction --project ./tsconfig.json
 
@@ -40,24 +43,32 @@ console.log(result.signature);
 console.log(result.returnType);
 // => "boolean"
 
+// Find variable at specific line
+const result2 = inferType("./src/utils.ts", "commandResult", { line: 75 });
+console.log(result2.signature);
+// => "Result<VaultAction[], CommandError>"
+
 // With custom tsconfig
-const result2 = inferType("./src/utils.ts", "myFunction", "./tsconfig.json");
+const result3 = inferType("./src/utils.ts", "myFunction", { project: "./tsconfig.json" });
 ```
 
 ### API Reference
 
-#### `inferType(file, name, project?)`
+#### `inferType(file, name, options?)`
 
 Infer the type of a function or variable in a TypeScript file.
 
 **Parameters:**
 - `file` - Path to the TypeScript file
 - `name` - Name of the function/variable to inspect
-- `project` - Optional path to tsconfig.json
+- `options` - Optional object with:
+  - `line` - Line number to narrow search (1-based)
+  - `project` - Path to tsconfig.json
 
 **Returns:** `InferredTypeResult`
 - `signature` - The inferred type signature
 - `returnType` - The return type (for functions)
+- `line` - The line number where the symbol was found
 
 #### Types
 
@@ -65,15 +76,64 @@ Infer the type of a function or variable in a TypeScript file.
 interface Options {
   file: string;
   name: string;
+  line?: number;
   project?: string;
 }
 
 interface InferredTypeResult {
   signature: string;
   returnType?: string;
+  line?: number;
 }
 ```
 
+## MCP Server (Claude Integration)
+
+prinfer includes an MCP server for use with Claude Code or Claude Desktop.
+
+### Setup for Claude Code
+
+Add to your `~/.claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "prinfer": {
+      "command": "npx",
+      "args": ["prinfer-mcp"]
+    }
+  }
+}
+```
+
+Or if installed globally (`npm i -g prinfer`):
+
+```json
+{
+  "mcpServers": {
+    "prinfer": {
+      "command": "prinfer-mcp"
+    }
+  }
+}
+```
+
+### Tool Usage
+
+Once configured, Claude can use the `infer_type` tool:
+
+```
+infer_type(file: "src/utils.ts", name: "myFunction")
+infer_type(file: "src/utils.ts", name: "commandResult", line: 75)
+```
+
+### Auto-installed Skill
+
+When you install prinfer globally (`npm i -g prinfer`), a Claude skill is automatically added to `~/.claude/skills/prinfer.md`. This provides:
+
+1. **Coding guideline** - Encourages Claude to prefer type inference over explicit annotations
+2. **`/check-type` command** - Check types directly: `/check-type src/utils.ts:75 commandResult`
+
 ## Requirements
 
 - Node.js >= 18.0.0

package/dist/postinstall.cjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/postinstall.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var SKILL_CONTENT = `# TypeScript Type Inference (prinfer)
+
+## Coding Guideline
+
+When writing TypeScript code, prefer relying on type inference over explicit type annotations:
+
+- Let TypeScript infer return types for functions when the implementation makes them obvious
+- Let TypeScript infer variable types from their initializers
+- Only add explicit types when:
+  - The inferred type is too wide (e.g., \`string\` instead of a literal type)
+  - 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.
+
+## Commands
+
+### /check-type
+
+Check the inferred type of a TypeScript symbol.
+
+Usage: \`/check-type <file>:<line> <name>\` or \`/check-type <file> <name>\`
+
+Examples:
+- \`/check-type src/utils.ts:75 commandResult\`
+- \`/check-type src/utils.ts myFunction\`
+
+<command-name>check-type</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
+`;
+function main() {
+  const homeDir = import_node_os.default.homedir();
+  const skillsDir = import_node_path.default.join(homeDir, ".claude", "skills");
+  const skillFile = import_node_path.default.join(skillsDir, "prinfer.md");
+  const claudeDir = import_node_path.default.join(homeDir, ".claude");
+  if (!import_node_fs.default.existsSync(claudeDir)) {
+    console.log(
+      "~/.claude directory not found. Skipping skill installation."
+    );
+    console.log("To manually install, create ~/.claude/skills/prinfer.md");
+    return;
+  }
+  if (!import_node_fs.default.existsSync(skillsDir)) {
+    import_node_fs.default.mkdirSync(skillsDir, { recursive: true });
+  }
+  if (import_node_fs.default.existsSync(skillFile)) {
+    console.log(
+      "prinfer skill already installed at ~/.claude/skills/prinfer.md"
+    );
+    return;
+  }
+  import_node_fs.default.writeFileSync(skillFile, SKILL_CONTENT);
+  console.log("Installed prinfer skill to ~/.claude/skills/prinfer.md");
+  console.log("You can now use /check-type to verify TypeScript types!");
+}
+main();
+//# sourceMappingURL=postinstall.cjs.map

package/dist/postinstall.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/postinstall.ts"],"sourcesContent":["#!/usr/bin/env node\nimport fs from \"node:fs\";\nimport os from \"node:os\";\nimport path from \"node:path\";\n\nconst SKILL_CONTENT = `# TypeScript Type Inference (prinfer)\n\n## Coding Guideline\n\nWhen writing TypeScript code, prefer relying on type inference over explicit type annotations:\n\n- Let TypeScript infer return types for functions when the implementation makes them obvious\n- Let TypeScript infer variable types from their initializers\n- Only add explicit types when:\n  - The inferred type is too wide (e.g., \\`string\\` instead of a literal type)\n  - The type serves as documentation for complex structures\n  - You're defining a public API contract\n\nUse the \\`prinfer\\` MCP tool (\\`infer_type\\`) to verify what TypeScript infers before adding explicit types.\n\n## Commands\n\n### /check-type\n\nCheck the inferred type of a TypeScript symbol.\n\nUsage: \\`/check-type <file>:<line> <name>\\` or \\`/check-type <file> <name>\\`\n\nExamples:\n- \\`/check-type src/utils.ts:75 commandResult\\`\n- \\`/check-type src/utils.ts myFunction\\`\n\n<command-name>check-type</command-name>\n\nUse the \\`infer_type\\` MCP tool to check the type:\n1. Parse the arguments to extract file, optional line number, and symbol name\n2. Call \\`infer_type(file, name, line?)\\`\n3. Report the inferred signature and return type\n`;\n\nfunction main() {\n\tconst homeDir = os.homedir();\n\tconst skillsDir = path.join(homeDir, \".claude\", \"skills\");\n\tconst skillFile = path.join(skillsDir, \"prinfer.md\");\n\n\t// Check if ~/.claude exists\n\tconst claudeDir = path.join(homeDir, \".claude\");\n\tif (!fs.existsSync(claudeDir)) {\n\t\tconsole.log(\n\t\t\t\"~/.claude directory not found. Skipping skill installation.\",\n\t\t);\n\t\tconsole.log(\"To manually install, create ~/.claude/skills/prinfer.md\");\n\t\treturn;\n\t}\n\n\t// Create skills directory if it doesn't exist\n\tif (!fs.existsSync(skillsDir)) {\n\t\tfs.mkdirSync(skillsDir, { recursive: true });\n\t}\n\n\t// Check if skill already exists\n\tif (fs.existsSync(skillFile)) {\n\t\tconsole.log(\n\t\t\t\"prinfer skill already installed at ~/.claude/skills/prinfer.md\",\n\t\t);\n\t\treturn;\n\t}\n\n\t// Write the skill file\n\tfs.writeFileSync(skillFile, SKILL_CONTENT);\n\tconsole.log(\"Installed prinfer skill to ~/.claude/skills/prinfer.md\");\n\tconsole.log(\"You can now use /check-type to verify TypeScript types!\");\n}\n\nmain();\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,qBAAe;AACf,qBAAe;AACf,uBAAiB;AAEjB,IAAM,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmCtB,SAAS,OAAO;AACf,QAAM,UAAU,eAAAA,QAAG,QAAQ;AAC3B,QAAM,YAAY,iBAAAC,QAAK,KAAK,SAAS,WAAW,QAAQ;AACxD,QAAM,YAAY,iBAAAA,QAAK,KAAK,WAAW,YAAY;AAGnD,QAAM,YAAY,iBAAAA,QAAK,KAAK,SAAS,SAAS;AAC9C,MAAI,CAAC,eAAAC,QAAG,WAAW,SAAS,GAAG;AAC9B,YAAQ;AAAA,MACP;AAAA,IACD;AACA,YAAQ,IAAI,yDAAyD;AACrE;AAAA,EACD;AAGA,MAAI,CAAC,eAAAA,QAAG,WAAW,SAAS,GAAG;AAC9B,mBAAAA,QAAG,UAAU,WAAW,EAAE,WAAW,KAAK,CAAC;AAAA,EAC5C;AAGA,MAAI,eAAAA,QAAG,WAAW,SAAS,GAAG;AAC7B,YAAQ;AAAA,MACP;AAAA,IACD;AACA;AAAA,EACD;AAGA,iBAAAA,QAAG,cAAc,WAAW,aAAa;AACzC,UAAQ,IAAI,wDAAwD;AACpE,UAAQ,IAAI,yDAAyD;AACtE;AAEA,KAAK;","names":["os","path","fs"]}

package/dist/postinstall.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/postinstall.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/postinstall.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+// src/postinstall.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var SKILL_CONTENT = `# TypeScript Type Inference (prinfer)
+
+## Coding Guideline
+
+When writing TypeScript code, prefer relying on type inference over explicit type annotations:
+
+- Let TypeScript infer return types for functions when the implementation makes them obvious
+- Let TypeScript infer variable types from their initializers
+- Only add explicit types when:
+  - The inferred type is too wide (e.g., \`string\` instead of a literal type)
+  - 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.
+
+## Commands
+
+### /check-type
+
+Check the inferred type of a TypeScript symbol.
+
+Usage: \`/check-type <file>:<line> <name>\` or \`/check-type <file> <name>\`
+
+Examples:
+- \`/check-type src/utils.ts:75 commandResult\`
+- \`/check-type src/utils.ts myFunction\`
+
+<command-name>check-type</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
+`;
+function main() {
+  const homeDir = os.homedir();
+  const skillsDir = path.join(homeDir, ".claude", "skills");
+  const skillFile = path.join(skillsDir, "prinfer.md");
+  const claudeDir = path.join(homeDir, ".claude");
+  if (!fs.existsSync(claudeDir)) {
+    console.log(
+      "~/.claude directory not found. Skipping skill installation."
+    );
+    console.log("To manually install, create ~/.claude/skills/prinfer.md");
+    return;
+  }
+  if (!fs.existsSync(skillsDir)) {
+    fs.mkdirSync(skillsDir, { recursive: true });
+  }
+  if (fs.existsSync(skillFile)) {
+    console.log(
+      "prinfer skill already installed at ~/.claude/skills/prinfer.md"
+    );
+    return;
+  }
+  fs.writeFileSync(skillFile, SKILL_CONTENT);
+  console.log("Installed prinfer skill to ~/.claude/skills/prinfer.md");
+  console.log("You can now use /check-type to verify TypeScript types!");
+}
+main();
+//# sourceMappingURL=postinstall.js.map

package/dist/postinstall.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/postinstall.ts"],"sourcesContent":["#!/usr/bin/env node\nimport fs from \"node:fs\";\nimport os from \"node:os\";\nimport path from \"node:path\";\n\nconst SKILL_CONTENT = `# TypeScript Type Inference (prinfer)\n\n## Coding Guideline\n\nWhen writing TypeScript code, prefer relying on type inference over explicit type annotations:\n\n- Let TypeScript infer return types for functions when the implementation makes them obvious\n- Let TypeScript infer variable types from their initializers\n- Only add explicit types when:\n  - The inferred type is too wide (e.g., \\`string\\` instead of a literal type)\n  - The type serves as documentation for complex structures\n  - You're defining a public API contract\n\nUse the \\`prinfer\\` MCP tool (\\`infer_type\\`) to verify what TypeScript infers before adding explicit types.\n\n## Commands\n\n### /check-type\n\nCheck the inferred type of a TypeScript symbol.\n\nUsage: \\`/check-type <file>:<line> <name>\\` or \\`/check-type <file> <name>\\`\n\nExamples:\n- \\`/check-type src/utils.ts:75 commandResult\\`\n- \\`/check-type src/utils.ts myFunction\\`\n\n<command-name>check-type</command-name>\n\nUse the \\`infer_type\\` MCP tool to check the type:\n1. Parse the arguments to extract file, optional line number, and symbol name\n2. Call \\`infer_type(file, name, line?)\\`\n3. Report the inferred signature and return type\n`;\n\nfunction main() {\n\tconst homeDir = os.homedir();\n\tconst skillsDir = path.join(homeDir, \".claude\", \"skills\");\n\tconst skillFile = path.join(skillsDir, \"prinfer.md\");\n\n\t// Check if ~/.claude exists\n\tconst claudeDir = path.join(homeDir, \".claude\");\n\tif (!fs.existsSync(claudeDir)) {\n\t\tconsole.log(\n\t\t\t\"~/.claude directory not found. Skipping skill installation.\",\n\t\t);\n\t\tconsole.log(\"To manually install, create ~/.claude/skills/prinfer.md\");\n\t\treturn;\n\t}\n\n\t// Create skills directory if it doesn't exist\n\tif (!fs.existsSync(skillsDir)) {\n\t\tfs.mkdirSync(skillsDir, { recursive: true });\n\t}\n\n\t// Check if skill already exists\n\tif (fs.existsSync(skillFile)) {\n\t\tconsole.log(\n\t\t\t\"prinfer skill already installed at ~/.claude/skills/prinfer.md\",\n\t\t);\n\t\treturn;\n\t}\n\n\t// Write the skill file\n\tfs.writeFileSync(skillFile, SKILL_CONTENT);\n\tconsole.log(\"Installed prinfer skill to ~/.claude/skills/prinfer.md\");\n\tconsole.log(\"You can now use /check-type to verify TypeScript types!\");\n}\n\nmain();\n"],"mappings":";;;AACA,OAAO,QAAQ;AACf,OAAO,QAAQ;AACf,OAAO,UAAU;AAEjB,IAAM,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmCtB,SAAS,OAAO;AACf,QAAM,UAAU,GAAG,QAAQ;AAC3B,QAAM,YAAY,KAAK,KAAK,SAAS,WAAW,QAAQ;AACxD,QAAM,YAAY,KAAK,KAAK,WAAW,YAAY;AAGnD,QAAM,YAAY,KAAK,KAAK,SAAS,SAAS;AAC9C,MAAI,CAAC,GAAG,WAAW,SAAS,GAAG;AAC9B,YAAQ;AAAA,MACP;AAAA,IACD;AACA,YAAQ,IAAI,yDAAyD;AACrE;AAAA,EACD;AAGA,MAAI,CAAC,GAAG,WAAW,SAAS,GAAG;AAC9B,OAAG,UAAU,WAAW,EAAE,WAAW,KAAK,CAAC;AAAA,EAC5C;AAGA,MAAI,GAAG,WAAW,SAAS,GAAG;AAC7B,YAAQ;AAAA,MACP;AAAA,IACD;AACA;AAAA,EACD;AAGA,KAAG,cAAc,WAAW,aAAa;AACzC,UAAQ,IAAI,wDAAwD;AACpE,UAAQ,IAAI,yDAAyD;AACtE;AAEA,KAAK;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "prinfer",
-	"version": "0.3.0",
+	"version": "0.4.0",
 	"description": "TypeScript type inference inspection tool",
 	"type": "module",
 	"main": "./dist/index.cjs",
@@ -33,7 +33,8 @@
 		"version": "changeset version",
 		"release": "bun run build && changeset publish",
 		"prepublishOnly": "bun run ci",
-		"prepare": "simple-git-hooks"
+		"prepare": "simple-git-hooks",
+		"postinstall": "node ./dist/postinstall.js || true"
 	},
 	"simple-git-hooks": {
 		"pre-commit": "bunx biome check ."