@plaited/development-skills 0.5.0 → 0.6.0

package/src/tests/scaffold-rules.spec.ts

@@ -9,12 +9,9 @@ type Template = {
 }
 
 type ScaffoldOutput = {
-  agent: string
   rulesPath: string
-  agentsMdPath: string
-  format: 'multi-file' | 'agents-md'
-  supportsAgentsMd: boolean
-  agentsMdContent?: string
+  claudeMdSection: string
+  agentsMdSection: string
   templates: Record<string, Template>
 }
 
@@ -22,7 +19,7 @@ const binDir = join(import.meta.dir, '../../bin')
 
 describe('scaffold-rules', () => {
   test('outputs JSON with all templates', async () => {
-    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --format=json`.json()
+    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
     expect(result).toHaveProperty('templates')
     expect(result.templates).toBeObject()
@@ -35,10 +32,11 @@ describe('scaffold-rules', () => {
     expect(templateKeys).toContain('git-workflow')
     expect(templateKeys).toContain('github')
     expect(templateKeys).toContain('testing')
+    expect(templateKeys).toContain('module-organization')
   })
 
   test('each template has required properties', async () => {
-    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --format=json`.json()
+    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
     for (const [ruleId, template] of Object.entries(result.templates)) {
       expect(template).toHaveProperty('filename')
@@ -52,7 +50,7 @@ describe('scaffold-rules', () => {
   })
 
   test('removes template headers from content', async () => {
-    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --format=json`.json()
+    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
     // Check that template headers are removed
     for (const template of Object.values(result.templates)) {
@@ -62,7 +60,7 @@ describe('scaffold-rules', () => {
   })
 
   test('processes development-skills conditionals', async () => {
-    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --format=json`.json()
+    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
     const accuracy = result.templates.accuracy
     expect(accuracy).toBeDefined()
@@ -78,8 +76,7 @@ describe('scaffold-rules', () => {
   })
 
   test('filters to specific rules when requested', async () => {
-    const result: ScaffoldOutput =
-      await $`bun ${binDir}/cli.ts scaffold-rules --rules testing --rules bun-apis --format=json`.json()
+    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --rules testing --rules bun-apis`.json()
 
     const templateKeys = Object.keys(result.templates)
 
@@ -94,7 +91,7 @@ describe('scaffold-rules', () => {
   })
 
   test('extracts meaningful descriptions', async () => {
-    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --format=json`.json()
+    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
     // Check a few descriptions
     const accuracy = result.templates.accuracy
@@ -108,179 +105,212 @@ describe('scaffold-rules', () => {
     expect(testing!.description.length).toBeGreaterThan(10)
   })
 
-  test('exits with error for invalid agent', async () => {
-    const proc = Bun.spawn(['bun', `${binDir}/cli.ts`, 'scaffold-rules', '--agent=invalid'], {
-      stderr: 'pipe',
-    })
-
-    const exitCode = await proc.exited
-    expect(exitCode).not.toBe(0)
-  })
-
   test('handles missing bundled rules directory gracefully', async () => {
     // This test ensures the script fails gracefully if templates are missing
-    // In production, .claude/rules/ should always be bundled with the package
-    const result = await $`bun ${binDir}/cli.ts scaffold-rules --format=json`.nothrow().quiet()
+    // In production, .plaited/rules/ should always be bundled with the package
+    const result = await $`bun ${binDir}/cli.ts scaffold-rules`.nothrow().quiet()
 
-    // Should succeed because .claude/rules/ exists in development
+    // Should succeed because .plaited/rules/ exists in development
     expect(result.exitCode).toBe(0)
   })
 
-  describe('Claude Code target', () => {
-    test('defaults to Claude Code format', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --format=json`.json()
-
-      expect(result.agent).toBe('claude')
-      expect(result.rulesPath).toBe('.claude/rules')
-      expect(result.format).toBe('multi-file')
-      expect(result.supportsAgentsMd).toBe(false)
-    })
-
-    test('processes has-sandbox for Claude (sandbox environment)', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=claude --format=json`.json()
-
-      const gitWorkflow = result.templates['git-workflow']
-      expect(gitWorkflow).toBeDefined()
-
-      // Claude has sandbox - should include sandbox-specific content
-      expect(gitWorkflow!.content).toContain('sandbox environment')
-      expect(gitWorkflow!.content).toContain('single-quoted strings')
-
-      // Should not have conditional syntax
-      expect(gitWorkflow!.content).not.toContain('{{#if has-sandbox}}')
-      expect(gitWorkflow!.content).not.toContain('{{/if}}')
-    })
-
-    test('processes supports-slash-commands for Claude', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=claude --format=json`.json()
-
-      const accuracy = result.templates.accuracy
-      expect(accuracy).toBeDefined()
+  describe('output structure', () => {
+    test('defaults to .plaited/rules path', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
-      // Claude supports slash commands
-      expect(accuracy!.content).toContain('/lsp-hover')
-      expect(accuracy!.content).toContain('/lsp-find')
+      expect(result.rulesPath).toBe('.plaited/rules')
     })
 
-    test('generates Claude-style cross-references', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=claude --format=json`.json()
+    test('includes claudeMdSection with markers and @ syntax', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
-      const accuracy = result.templates.accuracy
-      expect(accuracy).toBeDefined()
-      expect(accuracy!.content).toContain('@.claude/rules/testing.md')
-      expect(accuracy!.content).not.toContain('{{LINK:testing}}')
+      expect(result.claudeMdSection).toContain('<!-- PLAITED-RULES-START -->')
+      expect(result.claudeMdSection).toContain('<!-- PLAITED-RULES-END -->')
+      expect(result.claudeMdSection).toContain('@.plaited/rules/')
+      expect(result.claudeMdSection).toContain('## Project Rules')
     })
-  })
 
-  describe('AGENTS.md target (universal format)', () => {
-    test('supports agents-md format', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=agents-md --format=json`.json()
+    test('includes agentsMdSection with markers and markdown links', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
-      expect(result.agent).toBe('agents-md')
-      expect(result.rulesPath).toBe('.plaited/rules')
-      expect(result.format).toBe('agents-md')
-      expect(result.supportsAgentsMd).toBe(true)
+      expect(result.agentsMdSection).toContain('<!-- PLAITED-RULES-START -->')
+      expect(result.agentsMdSection).toContain('<!-- PLAITED-RULES-END -->')
+      expect(result.agentsMdSection).toContain('[')
+      expect(result.agentsMdSection).toContain('](.plaited/rules/')
+      expect(result.agentsMdSection).toContain('## Rules')
     })
 
-    test('generates AGENTS.md content', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=agents-md --format=json`.json()
+    test('claudeMdSection lists all selected rules', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
-      expect(result.agentsMdContent).toBeDefined()
-      expect(result.agentsMdContent).toContain('# AGENTS.md')
-      expect(result.agentsMdContent).toContain('.plaited/rules/')
-      expect(result.agentsMdContent).toContain('## Rules')
+      for (const template of Object.values(result.templates)) {
+        expect(result.claudeMdSection).toContain(`@.plaited/rules/${template.filename}`)
+      }
     })
 
-    test('AGENTS.md links to all rule files', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=agents-md --format=json`.json()
+    test('agentsMdSection lists all selected rules', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
-      const agentsMd = result.agentsMdContent ?? ''
-
-      // Should link to each rule file
       for (const [ruleId, template] of Object.entries(result.templates)) {
-        expect(agentsMd).toContain(`[${ruleId}](.plaited/rules/${template.filename})`)
+        expect(result.agentsMdSection).toContain(`[${ruleId}](.plaited/rules/${template.filename})`)
       }
     })
+  })
 
-    test('agents-md has no sandbox (uses standard commit format)', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=agents-md --format=json`.json()
+  describe('template content', () => {
+    test('git-workflow uses standard commit format', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
       const gitWorkflow = result.templates['git-workflow']
       expect(gitWorkflow).toBeDefined()
-      expect(gitWorkflow!.content).not.toContain('sandbox environment')
       expect(gitWorkflow!.content).toContain('multi-line commit')
+      expect(gitWorkflow!.content).toContain('git commit -m')
     })
 
-    test('agents-md uses CLI syntax (no slash commands)', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=agents-md --format=json`.json()
+    test('accuracy uses CLI syntax for LSP tools', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
       const accuracy = result.templates.accuracy
       expect(accuracy).toBeDefined()
 
-      // Should use CLI instead of slash commands
+      // Should use CLI syntax
       expect(accuracy!.content).toContain('bunx @plaited/development-skills lsp-')
-      expect(accuracy!.content).not.toContain('/lsp-hover')
     })
 
-    test('generates agents-md-style cross-references', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=agents-md --format=json`.json()
+    test('cross-references use path syntax', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
       const accuracy = result.templates.accuracy
       expect(accuracy).toBeDefined()
       expect(accuracy!.content).toContain('.plaited/rules/testing.md')
+      expect(accuracy!.content).not.toContain('{{LINK:testing}}')
     })
   })
 
   describe('path customization', () => {
-    test('includes default agentsMdPath in output', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=agents-md --format=json`.json()
+    test('--rules-dir overrides default rules path', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --rules-dir=.cursor/rules`.json()
 
-      expect(result.agentsMdPath).toBe('AGENTS.md')
+      expect(result.rulesPath).toBe('.cursor/rules')
     })
 
-    test('--rules-dir overrides default rules path', async () => {
-      const result: ScaffoldOutput =
-        await $`bun ${binDir}/cli.ts scaffold-rules --agent=agents-md --rules-dir=.cursor/rules --format=json`.json()
+    test('claudeMdSection uses custom path', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --rules-dir=.cursor/rules`.json()
 
-      expect(result.rulesPath).toBe('.cursor/rules')
-      // AGENTS.md content should use custom path
-      expect(result.agentsMdContent).toContain('.cursor/rules/')
-      expect(result.agentsMdContent).not.toContain('.plaited/rules/')
+      expect(result.claudeMdSection).toContain('@.cursor/rules/')
+      expect(result.claudeMdSection).not.toContain('.plaited/rules/')
     })
 
-    test('--agents-md-path overrides default AGENTS.md location', async () => {
-      const result: ScaffoldOutput =
-        await $`bun ${binDir}/cli.ts scaffold-rules --agent=agents-md --agents-md-path=docs/AGENTS.md --format=json`.json()
+    test('agentsMdSection uses custom path', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --rules-dir=.cursor/rules`.json()
 
-      expect(result.agentsMdPath).toBe('docs/AGENTS.md')
+      expect(result.agentsMdSection).toContain('.cursor/rules/')
+      expect(result.agentsMdSection).not.toContain('.plaited/rules/')
     })
 
     test('cross-references use custom rules-dir', async () => {
-      const result: ScaffoldOutput =
-        await $`bun ${binDir}/cli.ts scaffold-rules --agent=agents-md --rules-dir=.factory/rules --format=json`.json()
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --rules-dir=.factory/rules`.json()
 
       const accuracy = result.templates.accuracy
       expect(accuracy).toBeDefined()
       expect(accuracy!.content).toContain('.factory/rules/testing.md')
     })
 
-    test('short flags work (-d and -m)', async () => {
-      const result: ScaffoldOutput =
-        await $`bun ${binDir}/cli.ts scaffold-rules --agent=agents-md -d custom/rules -m custom/AGENTS.md --format=json`.json()
+    test('short flag -d works', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules -d custom/rules`.json()
 
       expect(result.rulesPath).toBe('custom/rules')
-      expect(result.agentsMdPath).toBe('custom/AGENTS.md')
     })
+  })
 
-    test('claude agent also respects --rules-dir', async () => {
-      const result: ScaffoldOutput =
-        await $`bun ${binDir}/cli.ts scaffold-rules --agent=claude --rules-dir=.my-rules --format=json`.json()
+  describe('--list flag', () => {
+    test('outputs array of available rules', async () => {
+      const result = await $`bun ${binDir}/cli.ts scaffold-rules --list`.json()
+
+      expect(result).toBeArray()
+      expect(result.length).toBeGreaterThan(0)
+
+      // Each entry should have id and filename
+      for (const rule of result) {
+        expect(rule).toHaveProperty('id')
+        expect(rule).toHaveProperty('filename')
+        expect(rule.filename).toBe(`${rule.id}.md`)
+      }
+    })
+
+    test('includes expected rules', async () => {
+      const result = await $`bun ${binDir}/cli.ts scaffold-rules --list`.json()
+      const ids = result.map((r: { id: string }) => r.id)
+
+      expect(ids).toContain('accuracy')
+      expect(ids).toContain('testing')
+      expect(ids).toContain('bun-apis')
+    })
+
+    test('short flag -l works', async () => {
+      const result = await $`bun ${binDir}/cli.ts scaffold-rules -l`.json()
+
+      expect(result).toBeArray()
+      expect(result.length).toBeGreaterThan(0)
+    })
+  })
+
+  describe('--rules validation', () => {
+    test('warns about unknown rules', async () => {
+      const result = await $`bun ${binDir}/cli.ts scaffold-rules --rules nonexistent --rules testing`.nothrow()
+
+      // Should still succeed but with warning
+      expect(result.exitCode).toBe(0)
+      expect(result.stderr.toString()).toContain('Warning: Unknown rules: nonexistent')
+    })
+
+    test('shows available rules in warning', async () => {
+      const result = await $`bun ${binDir}/cli.ts scaffold-rules --rules fake-rule`.nothrow()
+
+      expect(result.stderr.toString()).toContain('Available rules:')
+      expect(result.stderr.toString()).toContain('testing')
+    })
+  })
+
+  describe('edge cases', () => {
+    test('handles all rules filtered out gracefully', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --rules nonexistent`.nothrow().json()
+
+      // Should return valid output with empty templates
+      expect(result.templates).toEqual({})
+      expect(result.claudeMdSection).toContain('<!-- PLAITED-RULES-START -->')
+      expect(result.claudeMdSection).toContain('<!-- PLAITED-RULES-END -->')
+    })
+
+    test('description extraction falls back for heading-only content', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
+
+      // All templates should have non-empty descriptions
+      for (const template of Object.values(result.templates)) {
+        expect(template.description).toBeTruthy()
+        expect(template.description.length).toBeGreaterThan(0)
+      }
+    })
+
+    test('processes nested conditionals correctly', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --rules accuracy`.json()
 
-      expect(result.rulesPath).toBe('.my-rules')
-      // Cross-references should use custom path
       const accuracy = result.templates.accuracy
       expect(accuracy).toBeDefined()
-      expect(accuracy!.content).toContain('@.my-rules/testing.md')
+
+      // Should not contain any unprocessed conditional syntax
+      expect(accuracy!.content).not.toContain('{{#if')
+      expect(accuracy!.content).not.toContain('{{^if')
+      expect(accuracy!.content).not.toContain('{{/if}}')
+    })
+
+    test('template content has no excessive blank lines', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
+
+      for (const template of Object.values(result.templates)) {
+        // Should not have 3+ consecutive newlines
+        expect(template.content).not.toMatch(/\n{3,}/)
+      }
     })
   })
 })

package/.claude/commands/lsp-analyze.md

@@ -1,66 +0,0 @@
----
-description: Analyze a TypeScript file structure, exports, and symbols
-allowed-tools: Bash
----
-
-# LSP Analyze
-
-Batch analysis of a TypeScript/JavaScript file. Get an overview of exports, symbols, and optionally type info at specific positions.
-
-**Arguments:** $ARGUMENTS
-
-## Usage
-
-```
-/lsp-analyze <file> [options]
-```
-
-Options:
-- `--symbols` or `-s`: List all symbols
-- `--exports` or `-e`: List only exported symbols (default if no options)
-- `--hover <line:char>`: Get type info at position (repeatable)
-- `--refs <line:char>`: Find references at position (repeatable)
-- `--all`: Run symbols + exports analysis
-
-## Instructions
-
-### Step 1: Parse Arguments
-
-Extract file path and options from `$ARGUMENTS`.
-
-If file is missing, show usage:
-```
-Usage: /lsp-analyze <file> [options]
-
-Examples:
-  /lsp-analyze src/utils/parser.ts --exports
-  /lsp-analyze src/lib/config.ts --all
-  /lsp-analyze src/index.ts --hover 50:10 --refs 60:5
-```
-
-Default to `--exports` if no options provided.
-
-### Step 2: Run LSP Analyze
-
-Execute the development-skills CLI command:
-```bash
-bunx @plaited/development-skills lsp-analyze <file> [options]
-```
-
-### Step 3: Format Output
-
-Parse the JSON output and present in a structured format:
-
-**File:** `<file>`
-
-**Exports:**
-| Name | Kind | Line |
-|------|------|------|
-| ... | ... | ... |
-
-**Symbols:** (if requested)
-| Name | Kind | Line |
-|------|------|------|
-| ... | ... | ... |
-
-For hover/refs results, format as described in the individual commands.

package/.claude/commands/lsp-find.md

@@ -1,74 +0,0 @@
----
-description: Search for TypeScript SYMBOLS (functions, types, classes) - NOT text
-allowed-tools: Bash
----
-
-# LSP Find
-
-Search for TypeScript **symbols** (functions, types, classes, variables) across the codebase.
-
-**Arguments:** $ARGUMENTS
-
-## When to Use Each Tool
-
-| Tool | Purpose |
-|------|---------|
-| **Glob** | Find files by pattern |
-| **Grep** | Search text content |
-| **lsp-find** | Search TypeScript symbols |
-| **lsp-hover** | Get type info + TSDoc documentation |
-
-## Usage
-
-```
-/lsp-find <query> <context-file>
-```
-
-- `query`: TypeScript symbol name (function, type, class, variable)
-- `context-file`: Any `.ts` file in the project for LSP context
-
-## When NOT to Use
-
-```
-# ❌ WRONG: Searching for text (use Grep instead)
-/lsp-find scaffold
-/lsp-find TODO
-
-# ❌ WRONG: Missing context file
-/lsp-find createClient
-
-# ✅ CORRECT: Symbol search with context file
-/lsp-find createClient src/lsp-client.ts
-```
-
-## Instructions
-
-### Step 1: Parse Arguments
-
-Extract query and context file from `$ARGUMENTS`.
-
-If either is missing, show usage:
-```
-Usage: /lsp-find <query> <context-file>
-
-Examples:
-  /lsp-find LspClient src/lsp-client.ts
-  /lsp-find createClient src/app.ts
-```
-
-### Step 2: Run LSP Find
-
-Execute the development-skills CLI command:
-```bash
-bunx @plaited/development-skills lsp-find <query> <context-file>
-```
-
-### Step 3: Format Output
-
-Parse the JSON output and present results as a table:
-
-| Symbol | Kind | File | Line |
-|--------|------|------|------|
-| ... | ... | ... | ... |
-
-Group results by file if there are many matches. Highlight the most relevant matches (exact name matches first).

package/.claude/commands/lsp-hover.md

@@ -1,57 +0,0 @@
----
-description: Get TypeScript type signature + TSDoc documentation at a position
-allowed-tools: Bash
----
-
-# LSP Hover
-
-Get type signature and TSDoc documentation at a specific position in a TypeScript/JavaScript file.
-
-**Arguments:** $ARGUMENTS
-
-## When to Use Each Tool
-
-| Tool | Purpose |
-|------|---------|
-| **Glob** | Find files by pattern |
-| **Grep** | Search text content |
-| **lsp-find** | Search TypeScript symbols |
-| **lsp-hover** | Get type info + TSDoc documentation |
-
-## Usage
-
-```
-/lsp-hover <file> <line> <char>
-```
-
-- `file`: Path to TypeScript/JavaScript file (absolute, relative, or package export path)
-- `line`: Line number (0-indexed)
-- `char`: Character position (0-indexed)
-
-## Instructions
-
-### Step 1: Parse Arguments
-
-Extract file path, line, and character from `$ARGUMENTS`.
-
-If arguments are missing, show usage:
-```
-Usage: /lsp-hover <file> <line> <char>
-
-Example: /lsp-hover src/utils/parser.ts 42 15
-```
-
-### Step 2: Run LSP Hover
-
-Execute the development-skills CLI command:
-```bash
-bunx @plaited/development-skills lsp-hover <file> <line> <char>
-```
-
-### Step 3: Format Output
-
-Parse the JSON output and present the type information in a readable format:
-
-- Show the type signature in a code block
-- If documentation is present, show it below
-- If no hover info found, explain that no type information is available at that position

package/.claude/commands/lsp-refs.md

@@ -1,64 +0,0 @@
----
-description: Find all references to a TypeScript symbol across the codebase
-allowed-tools: Bash
----
-
-# LSP References
-
-Find all references to a symbol at a specific position. Use this before modifying or deleting exports to understand impact.
-
-**Arguments:** $ARGUMENTS
-
-## When to Use Each Tool
-
-| Tool | Purpose |
-|------|---------|
-| **Glob** | Find files by pattern |
-| **Grep** | Search text content |
-| **lsp-find** | Search TypeScript symbols |
-| **lsp-refs** | Find all references to a symbol |
-
-## Usage
-
-```
-/lsp-refs <file> <line> <char>
-```
-
-- `file`: Path to TypeScript/JavaScript file
-- `line`: Line number (0-indexed)
-- `char`: Character position (0-indexed)
-
-## Instructions
-
-### Step 1: Parse Arguments
-
-Extract file path, line, and character from `$ARGUMENTS`.
-
-If arguments are missing, show usage:
-```
-Usage: /lsp-refs <file> <line> <char>
-
-Example: /lsp-refs src/utils/parser.ts 42 10
-```
-
-### Step 2: Run LSP References
-
-Execute the development-skills CLI command:
-```bash
-bunx @plaited/development-skills lsp-refs <file> <line> <char>
-```
-
-### Step 3: Format Output
-
-Parse the JSON output and present references grouped by file:
-
-**Found X references:**
-
-`src/file1.ts`
-- Line 42: `const x = targetSymbol()`
-- Line 58: `import { targetSymbol } from...`
-
-`src/file2.ts`
-- Line 15: `targetSymbol.method()`
-
-If no references found, indicate that the symbol may be unused or only defined.