@plaited/development-skills 0.5.0 → 0.6.1

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
+  agentsMdSection: string
+  claudeMdReference: 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,311 @@ 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()
+  describe('output structure', () => {
+    test('defaults to .plaited/rules path', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
-      expect(result.agent).toBe('claude')
-      expect(result.rulesPath).toBe('.claude/rules')
-      expect(result.format).toBe('multi-file')
-      expect(result.supportsAgentsMd).toBe(false)
+      expect(result.rulesPath).toBe('.plaited/rules')
     })
 
-    test('processes has-sandbox for Claude (sandbox environment)', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=claude --format=json`.json()
+    test('includes claudeMdReference with markers and @AGENTS.md', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
-      const gitWorkflow = result.templates['git-workflow']
-      expect(gitWorkflow).toBeDefined()
+      expect(result.claudeMdReference).toContain('<!-- PLAITED-RULES-START -->')
+      expect(result.claudeMdReference).toContain('<!-- PLAITED-RULES-END -->')
+      expect(result.claudeMdReference).toContain('@AGENTS.md')
+      expect(result.claudeMdReference).toContain('## Project Rules')
+    })
 
-      // Claude has sandbox - should include sandbox-specific content
-      expect(gitWorkflow!.content).toContain('sandbox environment')
-      expect(gitWorkflow!.content).toContain('single-quoted strings')
+    test('includes agentsMdSection with markers and dual format', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
-      // Should not have conditional syntax
-      expect(gitWorkflow!.content).not.toContain('{{#if has-sandbox}}')
-      expect(gitWorkflow!.content).not.toContain('{{/if}}')
+      expect(result.agentsMdSection).toContain('<!-- PLAITED-RULES-START -->')
+      expect(result.agentsMdSection).toContain('<!-- PLAITED-RULES-END -->')
+      // Should have @ syntax for Claude Code
+      expect(result.agentsMdSection).toContain('@.plaited/rules/')
+      // Should have markdown links for other tools
+      expect(result.agentsMdSection).toContain('](.plaited/rules/')
+      expect(result.agentsMdSection).toContain('## Rules')
     })
 
-    test('processes supports-slash-commands for Claude', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=claude --format=json`.json()
+    test('claudeMdReference does not list individual rules', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
-      const accuracy = result.templates.accuracy
-      expect(accuracy).toBeDefined()
-
-      // Claude supports slash commands
-      expect(accuracy!.content).toContain('/lsp-hover')
-      expect(accuracy!.content).toContain('/lsp-find')
+      // claudeMdReference should be a simple reference to AGENTS.md, not a list of rules
+      expect(result.claudeMdReference).not.toContain('.plaited/rules/')
+      expect(result.claudeMdReference).toContain('@AGENTS.md')
     })
 
-    test('generates Claude-style cross-references', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=claude --format=json`.json()
+    test('agentsMdSection lists all selected rules in dual format', 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}}')
+      for (const [ruleId, template] of Object.entries(result.templates)) {
+        // Each rule should have both @ syntax and markdown link
+        expect(result.agentsMdSection).toContain(`@.plaited/rules/${template.filename}`)
+        expect(result.agentsMdSection).toContain(`[${ruleId}](.plaited/rules/${template.filename})`)
+      }
     })
   })
 
-  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()
+  describe('claudeMdReference behavior', () => {
+    test('has exact expected content structure', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
+
+      // Verify the exact structure of claudeMdReference
+      const lines = result.claudeMdReference.split('\n')
+      expect(lines[0]).toBe('<!-- PLAITED-RULES-START -->')
+      expect(lines[1]).toBe('')
+      expect(lines[2]).toBe('## Project Rules')
+      expect(lines[3]).toBe('')
+      expect(lines[4]).toBe('See @AGENTS.md for shared development rules.')
+      expect(lines[5]).toBe('')
+      expect(lines[6]).toBe('<!-- PLAITED-RULES-END -->')
+    })
+
+    test('is constant regardless of rules selected', async () => {
+      const allRules: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
+      const oneRule: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --rules testing`.json()
+      const twoRules: ScaffoldOutput =
+        await $`bun ${binDir}/cli.ts scaffold-rules --rules testing --rules accuracy`.json()
 
-      expect(result.agent).toBe('agents-md')
-      expect(result.rulesPath).toBe('.plaited/rules')
-      expect(result.format).toBe('agents-md')
-      expect(result.supportsAgentsMd).toBe(true)
+      // claudeMdReference should be identical in all cases
+      expect(oneRule.claudeMdReference).toBe(allRules.claudeMdReference)
+      expect(twoRules.claudeMdReference).toBe(allRules.claudeMdReference)
     })
 
-    test('generates AGENTS.md content', async () => {
-      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=agents-md --format=json`.json()
+    test('is constant regardless of rules-dir', async () => {
+      const defaultPath: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
+      const customPath: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --rules-dir=.cursor/rules`.json()
+      const anotherPath: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --rules-dir=custom/path`.json()
 
-      expect(result.agentsMdContent).toBeDefined()
-      expect(result.agentsMdContent).toContain('# AGENTS.md')
-      expect(result.agentsMdContent).toContain('.plaited/rules/')
-      expect(result.agentsMdContent).toContain('## Rules')
+      // claudeMdReference should be identical regardless of rules-dir
+      expect(customPath.claudeMdReference).toBe(defaultPath.claudeMdReference)
+      expect(anotherPath.claudeMdReference).toBe(defaultPath.claudeMdReference)
     })
 
-    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('uses shared markers with agentsMdSection', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules`.json()
 
-      const agentsMd = result.agentsMdContent ?? ''
+      // Both sections should use the same markers for consistency
+      const startMarker = '<!-- PLAITED-RULES-START -->'
+      const endMarker = '<!-- PLAITED-RULES-END -->'
 
-      // 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.claudeMdReference).toContain(startMarker)
+      expect(result.claudeMdReference).toContain(endMarker)
+      expect(result.agentsMdSection).toContain(startMarker)
+      expect(result.agentsMdSection).toContain(endMarker)
+    })
+  })
+
+  describe('agentsMdSection with filtered rules', () => {
+    test('only includes selected rules in dual format', async () => {
+      const result: ScaffoldOutput =
+        await $`bun ${binDir}/cli.ts scaffold-rules --rules testing --rules bun-apis`.json()
+
+      // Should contain selected rules (both @ and markdown formats)
+      expect(result.agentsMdSection).toContain('@.plaited/rules/testing.md')
+      expect(result.agentsMdSection).toContain('[testing]')
+      expect(result.agentsMdSection).toContain('@.plaited/rules/bun-apis.md')
+      expect(result.agentsMdSection).toContain('[bun-apis]')
+
+      // Should NOT contain other rules
+      expect(result.agentsMdSection).not.toContain('@.plaited/rules/accuracy.md')
+      expect(result.agentsMdSection).not.toContain('[accuracy]')
+      expect(result.agentsMdSection).not.toContain('@.plaited/rules/git-workflow.md')
     })
 
-    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()
+    test('has valid structure with single rule in dual format', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --rules testing`.json()
+
+      expect(result.agentsMdSection).toContain('<!-- PLAITED-RULES-START -->')
+      expect(result.agentsMdSection).toContain('## Rules')
+      // Both formats present
+      expect(result.agentsMdSection).toContain('@.plaited/rules/testing.md')
+      expect(result.agentsMdSection).toContain('[testing](.plaited/rules/testing.md)')
+      expect(result.agentsMdSection).toContain('<!-- PLAITED-RULES-END -->')
+    })
+
+    test('has empty rules list when no rules match', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --rules nonexistent`.nothrow().json()
+
+      // Should still have valid structure with markers
+      expect(result.agentsMdSection).toContain('<!-- PLAITED-RULES-START -->')
+      expect(result.agentsMdSection).toContain('## Rules')
+      expect(result.agentsMdSection).toContain('<!-- PLAITED-RULES-END -->')
+
+      // But no rule references (neither @ nor markdown)
+      expect(result.agentsMdSection).not.toMatch(/@\.plaited\/rules\/.*\.md/)
+      expect(result.agentsMdSection).not.toMatch(/\[.*\]\(\.plaited\/rules\/.*\.md\)/)
+    })
+  })
+
+  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('claudeMdReference is path-independent', 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/')
+      // claudeMdReference always references AGENTS.md regardless of rules path
+      expect(result.claudeMdReference).toContain('@AGENTS.md')
+      expect(result.claudeMdReference).not.toContain('.cursor/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 in both formats', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --rules-dir=.cursor/rules`.json()
 
-      expect(result.agentsMdPath).toBe('docs/AGENTS.md')
+      // Both @ syntax and markdown links should use custom path
+      expect(result.agentsMdSection).toContain('@.cursor/rules/')
+      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.claudeMdReference).toContain('<!-- PLAITED-RULES-START -->')
+      expect(result.claudeMdReference).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).