@plaited/development-skills 0.4.1 → 0.6.0

package/src/tests/resolve-file-path.spec.ts

@@ -3,73 +3,112 @@ import { join } from 'node:path'
 import { resolveFilePath } from '../resolve-file-path.ts'
 
 describe('resolveFilePath', () => {
-  test('returns absolute path as-is', async () => {
-    const absolutePath = '/Users/test/file.ts'
-    const result = await resolveFilePath(absolutePath)
-    expect(result).toBe(absolutePath)
+  describe('absolute paths', () => {
+    test('returns absolute path as-is', () => {
+      const absolutePath = '/Users/test/file.ts'
+      const result = resolveFilePath(absolutePath)
+      expect(result).toBe(absolutePath)
+    })
   })
 
-  test('resolves relative path from cwd', async () => {
-    const relativePath = './src/resolve-file-path.ts'
-    const result = await resolveFilePath(relativePath)
-    // join() normalizes paths, removing the ./
-    expect(result).toBe(join(process.cwd(), relativePath))
-  })
-
-  test('resolves package export path via Bun.resolve', async () => {
-    // Use typescript package which is installed as devDependency
-    const packagePath = 'typescript'
-    const result = await resolveFilePath(packagePath)
+  describe('relative paths with extension', () => {
+    test('resolves ./path from cwd', () => {
+      const relativePath = './src/resolve-file-path.ts'
+      const result = resolveFilePath(relativePath)
+      expect(result).toBe(join(process.cwd(), relativePath))
+    })
 
-    // Should resolve to node_modules/typescript/...
-    expect(result).toContain('node_modules/typescript')
-    expect(result.startsWith('/')).toBe(true)
-  })
+    test('resolves ../path from cwd', () => {
+      const relativePath = '../other/file.ts'
+      const result = resolveFilePath(relativePath)
+      expect(result).toBe(join(process.cwd(), relativePath))
+    })
 
-  test('falls back to cwd for non-existent package', async () => {
-    const invalidPath = 'nonexistent-package/file.ts'
-    const result = await resolveFilePath(invalidPath)
+    test('resolves various file extensions', () => {
+      const extensions = ['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs', 'json']
 
-    expect(result).toBe(join(process.cwd(), invalidPath))
+      for (const ext of extensions) {
+        const path = `./src/file.${ext}`
+        const result = resolveFilePath(path)
+        expect(result).toBe(join(process.cwd(), path))
+      }
+    })
   })
 
-  test('resolves implicit relative path (src/foo.ts format) from cwd', async () => {
-    // Paths that look like file paths (contain / and end with extension)
-    // should resolve from cwd without trying Bun.resolve()
-    const implicitRelative = 'src/utils/parser.ts'
-    const result = await resolveFilePath(implicitRelative)
-
-    expect(result).toBe(join(process.cwd(), implicitRelative))
+  describe('relative paths without extension', () => {
+    test('falls back to cwd when no exports match', () => {
+      // ./testing has no extension, tries Bun.resolveSync first
+      // Falls back to cwd since this project has no exports field
+      const path = './testing'
+      const result = resolveFilePath(path)
+      expect(result).toBe(join(process.cwd(), path))
+    })
   })
 
-  test('resolves various file extensions as implicit relative paths', async () => {
-    const extensions = ['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs', 'json']
+  describe('implicit relative paths', () => {
+    test('resolves src/foo.ts via fallback to cwd', () => {
+      // No ./ prefix, has extension - tries Bun.resolveSync (fails), falls back to cwd
+      const path = 'src/resolve-file-path.ts'
+      const result = resolveFilePath(path)
+      expect(result).toBe(join(process.cwd(), path))
+    })
 
-    for (const ext of extensions) {
-      const path = `src/file.${ext}`
-      const result = await resolveFilePath(path)
+    test('resolves nested implicit path via fallback', () => {
+      const path = 'src/tests/fixtures/sample.ts'
+      const result = resolveFilePath(path)
       expect(result).toBe(join(process.cwd(), path))
-    }
+    })
   })
 
-  test('treats bare package names without extensions as package specifiers', async () => {
-    // A path like 'typescript' (no slash, no extension) should try Bun.resolve()
-    const barePkg = 'typescript'
-    const result = await resolveFilePath(barePkg)
+  describe('bare package specifiers', () => {
+    test('resolves bare package name', () => {
+      const result = resolveFilePath('typescript')
+      expect(result).toContain('node_modules/typescript')
+      expect(result.startsWith('/')).toBe(true)
+    })
 
-    // Should resolve to node_modules, not cwd/typescript
-    expect(result).toContain('node_modules/typescript')
+    test('falls back to cwd for non-existent package', () => {
+      const invalidPath = 'nonexistent-package'
+      const result = resolveFilePath(invalidPath)
+      expect(result).toBe(join(process.cwd(), invalidPath))
+    })
   })
 
-  test('treats scoped packages as package specifiers, not implicit file paths', async () => {
-    // Scoped packages like @org/pkg/file.ts should NOT be treated as implicit
-    // relative paths, even if they contain / and end with an extension.
-    // They should go through Bun.resolve() first, falling back to cwd if not found.
-    const scopedPkg = '@nonexistent/pkg/src/file.ts'
-    const result = await resolveFilePath(scopedPkg)
+  describe('scoped package specifiers', () => {
+    test('resolves scoped package subpath export', () => {
+      // @modelcontextprotocol/sdk/client is a defined export
+      const result = resolveFilePath('@modelcontextprotocol/sdk/client')
+      expect(result).toContain('node_modules/@modelcontextprotocol/sdk')
+      expect(result).toContain('client')
+    })
+
+    test('resolves scoped package server subpath', () => {
+      const result = resolveFilePath('@modelcontextprotocol/sdk/server')
+      expect(result).toContain('node_modules/@modelcontextprotocol/sdk')
+      expect(result).toContain('server')
+    })
+
+    test('resolves scoped package deep subpath with extension', () => {
+      // Deep subpath with .js extension via wildcard export "./*"
+      const path = '@modelcontextprotocol/sdk/server/auth/middleware/bearerAuth.js'
+      const result = resolveFilePath(path)
+      expect(result).toContain('node_modules/@modelcontextprotocol/sdk')
+      expect(result).toContain('bearerAuth')
+    })
+
+    test('falls back to cwd for non-existent scoped package', () => {
+      const scopedPkg = '@nonexistent/pkg/src/file.ts'
+      const result = resolveFilePath(scopedPkg)
+      expect(result).toBe(join(process.cwd(), scopedPkg))
+    })
+  })
 
-    // Falls back to cwd since package doesn't exist, but importantly it tried
-    // Bun.resolve() first (doesn't match looksLikeFilePath due to @ prefix)
-    expect(result).toBe(join(process.cwd(), scopedPkg))
+  describe('package subpaths', () => {
+    test('resolves package subpath with extension', () => {
+      // typescript/lib/typescript.js is a real subpath
+      const result = resolveFilePath('typescript/lib/typescript.js')
+      expect(result).toContain('node_modules/typescript')
+      expect(result).toContain('typescript.js')
+    })
   })
 })

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.