TypeScript type context for AI coding assistants. Auto-injects type signatures into file reads, provides type error feedback on writes, and offers type lookup tools.

Installation

OpenCode

Full plugin with automatic type injection on file reads and MCP tools:

{
  "plugin": ["@nick-vi/opencode-type-inject"]
}

Or MCP server only (tools only, no auto-injection):

{
  "mcp": {
    "type-inject": {
      "type": "local",
      "command": ["npx", "-y", "@nick-vi/type-inject-mcp"]
    }
  }
}

Claude Code

One-liner install (adds MCP server + hooks):

curl -fsSL https://raw.githubusercontent.com/nick-vi/type-inject/main/scripts/claude-install.sh | bash

# Global (all projects)
claude mcp add type-inject -s user -- npx -y @nick-vi/type-inject-mcp

# Or project-only
claude mcp add type-inject -- npx -y @nick-vi/type-inject-mcp

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Read",
        "hooks": [
          {
            "type": "command",
            "command": "npx -y @nick-vi/claude-type-inject-hook"
          }
        ]
      },
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx -y @nick-vi/claude-type-inject-hook"
          }
        ]
      }
    ]
  }
}

Cursor

Add to .cursor/mcp.json:

{
  "mcpServers": {
    "type-inject": {
      "command": "npx",
      "args": ["-y", "@nick-vi/type-inject-mcp"]
    }
  }
}

What It Does

Automatic Type Injection (Read Hook)

When an LLM reads a TypeScript or Svelte file, this plugin automatically:

1. Extracts type signatures (functions, types, interfaces, enums, classes, constants)
2. Resolves imported types from other files (up to 4 levels deep)
3. Applies smart filtering (only types actually used in the code)
4. Enforces a token budget with priority-based ordering
5. Injects the signatures as additional context

For partial file reads (with offset/limit), only types relevant to that section are injected.

Type Checking (Write Hook - Claude Code only)

When an LLM writes a TypeScript file, the hook runs type checking and reports errors:

TypeScript errors in the file you just wrote:
<file_diagnostics>
ERROR [5:2] Type 'string' is not assignable to type 'boolean'.
</file_diagnostics>
TypeScript errors in other project files:
<project_diagnostics>
src/utils.ts
  ERROR [12:5] Property 'foo' does not exist on type 'User'.
</project_diagnostics>

This gives the LLM immediate feedback to fix type errors without manual intervention.

How it works:

• Only reports errors (not warnings or hints)
• Shows errors in the written file first (<file_diagnostics>)
• Shows errors in other project files (<project_diagnostics>)
• Limits: 20 errors per file, 5 files max for project diagnostics
• Requires a tsconfig.json in the project (searches up from the file)

MCP Tools

The plugin provides three tools:

• lookup_type - Look up any type by name without reading files
• list_types - List all types in the project
• type_check - Run TypeScript type checking on the project or a specific file

Example Output

When reading a file, the LLM receives additional context:

Type definitions referenced in this file but defined elsewhere:
<types count="3" tokens="~85">
function getUser(id: string): User  // [offset=2,limit=8]

type User = { id: string; name: string; role: Role; }

type Role = { name: string; permissions: Permission[]; }  // [filePath=./lib/role.ts]
</types>

For partial reads (with offset/limit), the description changes to "Type definitions referenced in this range..."

Key Features

Token Budget with Priority Ordering

Types are prioritized by importance:

Import Resolution

Types are automatically resolved from imported files up to 4 levels deep.

Smart Filtering

Only types actually used in the code are included. For partial file reads (with offset/limit), only types relevant to that section are injected.

Barrel File Detection

Files that only contain export * from statements are skipped.

Svelte Support

Svelte files (.svelte) are fully supported:

• Extracts types from both <script lang="ts"> (instance) and <script module lang="ts"> (module) blocks
• Resolves imports between Svelte and TypeScript files in any direction (TS → Svelte, Svelte → TS)
• Calculates correct line numbers for each script block
• Requires svelte as an optional peer dependency (only loaded if installed)

Understanding the Output

What Gets Shown

Location Comments

Since functions and classes only show signatures, we provide location hints so you can read the implementation when needed:

function processUser(id: string): User  // [offset=15,limit=28]

The format matches the read tool parameters directly - no translation needed.

When filePath is Included

// Direct import - you can see the import statement above
type User = { ... }

// Transitive import (2+ levels deep) - source not obvious
type Permission = { ... }  // [filePath=./lib/permission.ts]

Direct imports are visible in the file's import statements. Transitive imports aren't - so we include where they live for navigation and refactoring.

Tools

Both tools support TypeScript and Svelte files.

lookup_type

Look up type definitions by name (works with .ts, .tsx, and .svelte files).

Arguments:

• name (required): Type name to search for
• exact (optional): Exact match or contains. Default: true
• kind (optional): Filter by kind (function, type, interface, enum, class, const)
• includeUsages (optional): Include files that import this type. Default: false
• limit (optional): Maximum results. Default: 5

Output includes:

## TypeName (kind)
File: ./path/to/file.ts [offset=9,limit=50]

## CounterProps (type)
File: ./components/Counter.svelte [offset=6,limit=5]

The offset and limit match the read tool parameters for easy navigation.

list_types

List all type names in the project (includes both TypeScript and Svelte files).

Arguments:

• kind (optional): Filter by kind
• limit (optional): Maximum results. Default: 100

type_check

Run TypeScript type checking on the project or a specific file.

Arguments:

• file (optional): File path to check. If omitted, checks the entire project.

Output:

TypeScript errors in the file you just wrote:
<file_diagnostics>
ERROR [5:2] Type 'string' is not assignable to type 'boolean'.
</file_diagnostics>

Or for project-wide check:

TypeScript errors in other project files:
<project_diagnostics>
src/utils.ts
  ERROR [12:5] Property 'foo' does not exist on type 'User'.
</project_diagnostics>

Returns a success message if no errors are found.

Packages

This is a monorepo with four packages:

License

MIT