@plaited/development-skills 0.3.5

package/src/tests/fixtures/sample.ts

@@ -0,0 +1,27 @@
+/**
+ * Sample fixture for LSP tests
+ */
+export type Config = {
+  name: string
+  value: number
+}
+
+export const parseConfig = (input: string): Config => {
+  return { name: input, value: 42 }
+}
+
+export const validateInput = (input: unknown): input is string => {
+  return typeof input === 'string'
+}
+
+export class ConfigManager {
+  #config: Config | null = null
+
+  load(input: string): void {
+    this.#config = parseConfig(input)
+  }
+
+  get(): Config | null {
+    return this.#config
+  }
+}

package/src/tests/lsp-client.spec.ts

@@ -0,0 +1,180 @@
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
+import { LspClient } from '../lsp-client.ts'
+
+const rootUri = `file://${process.cwd()}`
+const testFile = `${import.meta.dir}/fixtures/sample.ts`
+const testUri = `file://${testFile}`
+
+describe('LspClient', () => {
+  let client: LspClient
+
+  beforeAll(() => {
+    client = new LspClient({ rootUri })
+  })
+
+  afterAll(async () => {
+    if (client.isRunning()) {
+      await client.stop()
+    }
+  })
+
+  test('initializes with rootUri', () => {
+    expect(client).toBeDefined()
+    expect(client.isRunning()).toBe(false)
+  })
+
+  test('starts and stops LSP server', async () => {
+    await client.start()
+    expect(client.isRunning()).toBe(true)
+
+    await client.stop()
+    expect(client.isRunning()).toBe(false)
+  })
+
+  test('throws when starting already running server', async () => {
+    await client.start()
+    expect(client.isRunning()).toBe(true)
+
+    await expect(client.start()).rejects.toThrow('LSP server already running')
+
+    await client.stop()
+  })
+
+  test('handles stop on non-running server gracefully', async () => {
+    expect(client.isRunning()).toBe(false)
+    await client.stop()
+    expect(client.isRunning()).toBe(false)
+  })
+
+  describe('LSP operations', () => {
+    beforeAll(async () => {
+      await client.start()
+    })
+
+    afterAll(async () => {
+      await client.stop()
+    })
+
+    test('opens and closes document', async () => {
+      const text = await Bun.file(testFile).text()
+
+      client.openDocument(testUri, 'typescript', 1, text)
+      client.closeDocument(testUri)
+    })
+
+    test('gets hover information', async () => {
+      const text = await Bun.file(testFile).text()
+
+      client.openDocument(testUri, 'typescript', 1, text)
+
+      // Find 'export' keyword position for reliable hover
+      const lines = text.split('\n')
+      let line = 0
+      let char = 0
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i]?.startsWith('export')) {
+          line = i
+          char = 0
+          break
+        }
+      }
+
+      const result = await client.hover(testUri, line, char)
+      expect(result).toBeDefined()
+
+      client.closeDocument(testUri)
+    })
+
+    test('gets document symbols', async () => {
+      const text = await Bun.file(testFile).text()
+
+      client.openDocument(testUri, 'typescript', 1, text)
+
+      const result = await client.documentSymbols(testUri)
+
+      expect(result).toBeDefined()
+      expect(Array.isArray(result)).toBe(true)
+
+      client.closeDocument(testUri)
+    })
+
+    test('searches workspace symbols', async () => {
+      // Open a document first so LSP has a project context
+      const text = await Bun.file(testFile).text()
+      client.openDocument(testUri, 'typescript', 1, text)
+
+      const result = await client.workspaceSymbols('parseConfig')
+
+      expect(result).toBeDefined()
+      expect(Array.isArray(result)).toBe(true)
+
+      client.closeDocument(testUri)
+    })
+
+    test('finds references', async () => {
+      const text = await Bun.file(testFile).text()
+
+      client.openDocument(testUri, 'typescript', 1, text)
+
+      // Find an exported symbol
+      const lines = text.split('\n')
+      let line = 0
+      let char = 0
+      for (let i = 0; i < lines.length; i++) {
+        const currentLine = lines[i]
+        if (!currentLine) continue
+        const match = currentLine.match(/export\s+const\s+(\w+)/)
+        if (match?.[1]) {
+          line = i
+          char = currentLine.indexOf(match[1])
+          break
+        }
+      }
+
+      const result = await client.references(testUri, line, char)
+      expect(result).toBeDefined()
+
+      client.closeDocument(testUri)
+    })
+
+    test('gets definition', async () => {
+      const text = await Bun.file(testFile).text()
+
+      client.openDocument(testUri, 'typescript', 1, text)
+
+      // Find an import to get definition for
+      const lines = text.split('\n')
+      let line = 0
+      let char = 0
+      for (let i = 0; i < lines.length; i++) {
+        const currentLine = lines[i]
+        if (!currentLine) continue
+        const match = currentLine.match(/import\s+.*{\s*(\w+)/)
+        if (match?.[1]) {
+          line = i
+          char = currentLine.indexOf(match[1])
+          break
+        }
+      }
+
+      const result = await client.definition(testUri, line, char)
+      expect(result).toBeDefined()
+
+      client.closeDocument(testUri)
+    })
+  })
+
+  describe('error handling', () => {
+    test('throws on request when server not running', async () => {
+      const notRunningClient = new LspClient({ rootUri })
+
+      await expect(notRunningClient.hover('file:///test.ts', 0, 0)).rejects.toThrow('LSP server not running')
+    })
+
+    test('throws on notify when server not running', () => {
+      const notRunningClient = new LspClient({ rootUri })
+
+      expect(() => notRunningClient.notify('test')).toThrow('LSP server not running')
+    })
+  })
+})

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

@@ -0,0 +1,33 @@
+import { describe, expect, test } from 'bun:test'
+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)
+  })
+
+  test('resolves relative path from cwd', async () => {
+    const relativePath = './plugin/skills/typescript-lsp/scripts/tests/fixtures/sample.ts'
+    const result = await resolveFilePath(relativePath)
+    expect(result).toBe(`${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)
+
+    // Should resolve to node_modules/typescript/...
+    expect(result).toContain('node_modules/typescript')
+    expect(result.startsWith('/')).toBe(true)
+  })
+
+  test('falls back to cwd for non-existent package', async () => {
+    const invalidPath = 'nonexistent-package/file.ts'
+    const result = await resolveFilePath(invalidPath)
+
+    expect(result).toBe(`${process.cwd()}/${invalidPath}`)
+  })
+})

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

@@ -0,0 +1,286 @@
+import { describe, expect, test } from 'bun:test'
+import { join } from 'node:path'
+import { $ } from 'bun'
+
+type Template = {
+  filename: string
+  content: string
+  description: string
+}
+
+type ScaffoldOutput = {
+  agent: string
+  rulesPath: string
+  agentsMdPath: string
+  format: 'multi-file' | 'agents-md'
+  supportsAgentsMd: boolean
+  agentsMdContent?: string
+  templates: Record<string, Template>
+}
+
+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()
+
+    expect(result).toHaveProperty('templates')
+    expect(result.templates).toBeObject()
+
+    // Check that we have the expected templates
+    const templateKeys = Object.keys(result.templates)
+    expect(templateKeys).toContain('accuracy')
+    expect(templateKeys).toContain('bun-apis')
+    expect(templateKeys).toContain('code-review')
+    expect(templateKeys).toContain('git-workflow')
+    expect(templateKeys).toContain('github')
+    expect(templateKeys).toContain('testing')
+  })
+
+  test('each template has required properties', async () => {
+    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --format=json`.json()
+
+    for (const [ruleId, template] of Object.entries(result.templates)) {
+      expect(template).toHaveProperty('filename')
+      expect(template).toHaveProperty('content')
+      expect(template).toHaveProperty('description')
+
+      expect(template.filename).toBe(`${ruleId}.md`)
+      expect(template.content).toBeString()
+      expect(template.content.length).toBeGreaterThan(0)
+    }
+  })
+
+  test('removes template headers from content', async () => {
+    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --format=json`.json()
+
+    // Check that template headers are removed
+    for (const template of Object.values(result.templates)) {
+      expect(template.content).not.toContain('<!-- RULE TEMPLATE')
+      expect(template.content).not.toContain('Variables:')
+    }
+  })
+
+  test('processes development-skills conditionals', async () => {
+    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --format=json`.json()
+
+    const accuracy = result.templates.accuracy
+    expect(accuracy).toBeDefined()
+
+    // Should include development-skills content (always true when using CLI)
+    expect(accuracy!.content).toContain('TypeScript/JavaScript projects')
+    expect(accuracy!.content).toContain('lsp-find')
+    expect(accuracy!.content).toContain('lsp-hover')
+
+    // Should not have conditional syntax
+    expect(accuracy!.content).not.toContain('{{#if development-skills}}')
+    expect(accuracy!.content).not.toContain('{{/if}}')
+  })
+
+  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 templateKeys = Object.keys(result.templates)
+
+    // Should only include requested rules
+    expect(templateKeys).toHaveLength(2)
+    expect(templateKeys).toContain('testing')
+    expect(templateKeys).toContain('bun-apis')
+
+    // Should not include other rules
+    expect(templateKeys).not.toContain('accuracy')
+    expect(templateKeys).not.toContain('git-workflow')
+  })
+
+  test('extracts meaningful descriptions', async () => {
+    const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --format=json`.json()
+
+    // Check a few descriptions
+    const accuracy = result.templates.accuracy
+    expect(accuracy).toBeDefined()
+    expect(accuracy!.description).toBeString()
+    expect(accuracy!.description.length).toBeGreaterThan(10)
+
+    const testing = result.templates.testing
+    expect(testing).toBeDefined()
+    expect(testing!.description).toBeString()
+    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()
+
+    // Should succeed because .claude/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()
+
+      // Claude supports slash commands
+      expect(accuracy!.content).toContain('/lsp-hover')
+      expect(accuracy!.content).toContain('/lsp-find')
+    })
+
+    test('generates Claude-style cross-references', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=claude --format=json`.json()
+
+      const accuracy = result.templates.accuracy
+      expect(accuracy).toBeDefined()
+      expect(accuracy!.content).toContain('@.claude/rules/testing.md')
+      expect(accuracy!.content).not.toContain('{{LINK:testing}}')
+    })
+  })
+
+  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()
+
+      expect(result.agent).toBe('agents-md')
+      expect(result.rulesPath).toBe('.plaited/rules')
+      expect(result.format).toBe('agents-md')
+      expect(result.supportsAgentsMd).toBe(true)
+    })
+
+    test('generates AGENTS.md content', async () => {
+      const result: ScaffoldOutput = await $`bun ${binDir}/cli.ts scaffold-rules --agent=agents-md --format=json`.json()
+
+      expect(result.agentsMdContent).toBeDefined()
+      expect(result.agentsMdContent).toContain('# AGENTS.md')
+      expect(result.agentsMdContent).toContain('.plaited/rules/')
+      expect(result.agentsMdContent).toContain('## Rules')
+    })
+
+    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()
+
+      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})`)
+      }
+    })
+
+    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()
+
+      const gitWorkflow = result.templates['git-workflow']
+      expect(gitWorkflow).toBeDefined()
+      expect(gitWorkflow!.content).not.toContain('sandbox environment')
+      expect(gitWorkflow!.content).toContain('multi-line commit')
+    })
+
+    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()
+
+      const accuracy = result.templates.accuracy
+      expect(accuracy).toBeDefined()
+
+      // Should use CLI instead of slash commands
+      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()
+
+      const accuracy = result.templates.accuracy
+      expect(accuracy).toBeDefined()
+      expect(accuracy!.content).toContain('.plaited/rules/testing.md')
+    })
+  })
+
+  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()
+
+      expect(result.agentsMdPath).toBe('AGENTS.md')
+    })
+
+    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()
+
+      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/')
+    })
+
+    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()
+
+      expect(result.agentsMdPath).toBe('docs/AGENTS.md')
+    })
+
+    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 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()
+
+      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()
+
+      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')
+    })
+  })
+})