prinfer 0.3.0 → 0.4.1

package/README.md

@@ -1,77 +1,87 @@
 # prinfer
 
-TypeScript type inference inspection tool. Inspect the inferred types of functions and variables in your TypeScript code.
+**Typehints for your AI agent.**
 
-## Installation
+prinfer gives AI coding assistants the ability to inspect TypeScript's inferred types — so they can write cleaner code without redundant type annotations.
 
-```bash
-npm install prinfer
-```
+## Why?
 
-## CLI Usage
+AI agents write TypeScript, but they can't see what the compiler infers. This leads to:
+- Unnecessary explicit type annotations everywhere
+- Verbose code that fights against TypeScript's design
+- Missed opportunities to leverage type inference
 
-```bash
-# Basic usage
-prinfer src/utils.ts myFunction
+prinfer solves this by exposing TypeScript's type inference to your agent via MCP.
 
-# With custom tsconfig
-prinfer src/utils.ts myFunction --project ./tsconfig.json
+## Quick Start
 
-# Show help
-prinfer --help
+```bash
+npm i -g prinfer
 ```
 
-### Output
+That's it. On install, prinfer automatically:
+1. Adds itself as an MCP tool for Claude
+2. Installs a skill that teaches Claude to prefer type inference
+
+## What Gets Installed
+
+### MCP Server (`prinfer-mcp`)
+
+Your agent gets an `infer_type` tool to check what TypeScript infers:
 
 ```
-(x: number, y: string) => boolean
-returns: boolean
+infer_type(file: "src/utils.ts", name: "myFunction")
+infer_type(file: "src/utils.ts", name: "commandResult", line: 75)
 ```
 
-## Programmatic API
+### Claude Skill (`~/.claude/skills/prinfer.md`)
 
-```typescript
-import { inferType } from "prinfer";
+A coding guideline that encourages your agent to:
+- Rely on type inference instead of explicit annotations
+- Use prinfer to verify types before adding redundant hints
+- Write idiomatic TypeScript
 
-// Basic usage
-const result = inferType("./src/utils.ts", "myFunction");
-console.log(result.signature);
-// => "(x: number, y: string) => boolean"
-console.log(result.returnType);
-// => "boolean"
+Plus a `/check-type` command for quick lookups.
 
-// With custom tsconfig
-const result2 = inferType("./src/utils.ts", "myFunction", "./tsconfig.json");
-```
+## MCP Setup
 
-### API Reference
+If the auto-setup didn't work, add to `~/.claude/claude_desktop_config.json`:
 
-#### `inferType(file, name, project?)`
+```json
+{
+  "mcpServers": {
+    "prinfer": {
+      "command": "prinfer-mcp"
+    }
+  }
+}
+```
+
+## CLI Usage
 
-Infer the type of a function or variable in a TypeScript file.
+prinfer also works as a standalone CLI:
 
-**Parameters:**
-- `file` - Path to the TypeScript file
-- `name` - Name of the function/variable to inspect
-- `project` - Optional path to tsconfig.json
+```bash
+prinfer src/utils.ts myFunction
+prinfer src/utils.ts:75 commandResult
+```
 
-**Returns:** `InferredTypeResult`
-- `signature` - The inferred type signature
-- `returnType` - The return type (for functions)
+Output:
+```
+(x: number, y: string) => boolean
+returns: boolean
+```
 
-#### Types
+## Programmatic API
 
 ```typescript
-interface Options {
-  file: string;
-  name: string;
-  project?: string;
-}
+import { inferType } from "prinfer";
 
-interface InferredTypeResult {
-  signature: string;
-  returnType?: string;
-}
+const result = inferType("./src/utils.ts", "myFunction");
+// => { signature: "(x: number, y: string) => boolean", returnType: "boolean", line: 4 }
+
+// With line number for disambiguation
+const result2 = inferType("./src/utils.ts", "commandResult", { line: 75 });
 ```
 
 ## Requirements

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.1",
 	"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 ."