@gustavobrunodev/ai-tools 1.0.1 → 1.1.0

package/src/services/__tests__/lockfile.security.spec.ts

@@ -0,0 +1,132 @@
+import { mkdir, rm, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { readSkillLock, removeSkillFromLock, addSkillToLock } from '../lockfile'
+import type { AgentType } from '../../types'
+
+describe('Lockfile Security', () => {
+  let testDir: string
+  let originalCwd: string
+
+  beforeEach(async () => {
+    originalCwd = process.cwd()
+    testDir = join(tmpdir(), `lockfile-test-${Date.now()}`)
+    await mkdir(testDir, { recursive: true })
+    process.chdir(testDir)
+  })
+
+  afterEach(async () => {
+    process.chdir(originalCwd)
+    await rm(testDir, { recursive: true, force: true }).catch(() => {})
+  })
+
+  describe('Lockfile Integrity', () => {
+    it('should handle corrupted lockfile gracefully', async () => {
+      const agentsDir = join(testDir, '.agents')
+      await mkdir(agentsDir, { recursive: true })
+      await writeFile(join(agentsDir, '.skill-lock.json'), 'invalid json{{{')
+      
+      const lock = await readSkillLock(false)
+      expect(lock.version).toBe(2)
+      expect(lock.skills).toEqual({})
+    })
+
+    it('should create backup before writing', async () => {
+      const agents: AgentType[] = ['github-copilot']
+      await addSkillToLock('test-skill', agents, { source: 'local' })
+      
+      // Write again to trigger backup
+      await addSkillToLock('test-skill-2', agents, { source: 'local' })
+      
+      // Backup should exist (we can't easily verify without exposing internal paths)
+      const lock = await readSkillLock(false)
+      expect(lock.skills['test-skill']).toBeDefined()
+      expect(lock.skills['test-skill-2']).toBeDefined()
+    })
+
+    it('should use atomic writes', async () => {
+      const agents: AgentType[] = ['github-copilot']
+      
+      // Write sequentially to avoid race conditions in test
+      await addSkillToLock('skill-1', agents, { source: 'local' })
+      await addSkillToLock('skill-2', agents, { source: 'local' })
+      await addSkillToLock('skill-3', agents, { source: 'local' })
+      
+      const lock = await readSkillLock(false)
+      expect(Object.keys(lock.skills).length).toBe(3)
+    })
+  })
+
+  describe('Lockfile Migration', () => {
+    it('should migrate v1 lockfile to v2', async () => {
+      const agentsDir = join(testDir, '.agents')
+      await mkdir(agentsDir, { recursive: true })
+      
+      const v1Lock = {
+        version: 1,
+        skills: {
+          'old-skill': {
+            name: 'old-skill',
+            source: 'local',
+            installedAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+          },
+        },
+      }
+      
+      await writeFile(join(agentsDir, '.skill-lock.json'), JSON.stringify(v1Lock))
+      
+      const lock = await readSkillLock(false)
+      expect(lock.version).toBe(2)
+      expect(lock.skills['old-skill']).toBeDefined()
+      expect(lock.skills['old-skill'].method).toBe('copy')
+      expect(lock.skills['old-skill'].global).toBe(false)
+    })
+  })
+
+  describe('Lockfile Operations', () => {
+    it('should prevent duplicate entries', async () => {
+      const agents: AgentType[] = ['github-copilot']
+      
+      await addSkillToLock('test-skill', agents, { source: 'local' })
+      await addSkillToLock('test-skill', agents, { source: 'local' })
+      
+      const lock = await readSkillLock(false)
+      expect(Object.keys(lock.skills)).toHaveLength(1)
+    })
+
+    it('should update timestamps on re-add', async () => {
+      const agents: AgentType[] = ['github-copilot']
+      
+      await addSkillToLock('test-skill', agents, { source: 'local' })
+      const lock1 = await readSkillLock(false)
+      const firstUpdate = lock1.skills['test-skill'].updatedAt
+      
+      // Wait a bit
+      await new Promise((resolve) => setTimeout(resolve, 10))
+      
+      await addSkillToLock('test-skill', agents, { source: 'local' })
+      const lock2 = await readSkillLock(false)
+      const secondUpdate = lock2.skills['test-skill'].updatedAt
+      
+      expect(secondUpdate).not.toBe(firstUpdate)
+    })
+
+    it('should remove skills correctly', async () => {
+      const agents: AgentType[] = ['github-copilot']
+      
+      await addSkillToLock('test-skill', agents, { source: 'local' })
+      const removed = await removeSkillFromLock('test-skill', false)
+      
+      expect(removed).toBe(true)
+      
+      const lock = await readSkillLock(false)
+      expect(lock.skills['test-skill']).toBeUndefined()
+    })
+
+    it('should return false when removing non-existent skill', async () => {
+      const removed = await removeSkillFromLock('non-existent', false)
+      expect(removed).toBe(false)
+    })
+  })
+})

package/src/services/__tests__/markdown-parser.spec.ts

@@ -0,0 +1,185 @@
+import { parseMarkdown, parseInline } from '../markdown-parser'
+
+describe('parseMarkdown', () => {
+  it('strips YAML frontmatter', () => {
+    const input = `---
+name: test-skill
+description: A test
+---
+
+# Title`
+
+    const tokens = parseMarkdown(input)
+    expect(tokens[0]).toEqual({ type: 'heading', level: 1, text: 'Title' })
+  })
+
+  it('parses headings at levels 1-3', () => {
+    const tokens = parseMarkdown('# H1\n## H2\n### H3')
+    expect(tokens).toEqual([
+      { type: 'heading', level: 1, text: 'H1' },
+      { type: 'heading', level: 2, text: 'H2' },
+      { type: 'heading', level: 3, text: 'H3' },
+    ])
+  })
+
+  it('parses unordered list items with - and *', () => {
+    const tokens = parseMarkdown('- first\n* second')
+    expect(tokens).toEqual([
+      { type: 'list-item', text: 'first', indent: 0 },
+      { type: 'list-item', text: 'second', indent: 0 },
+    ])
+  })
+
+  it('detects nested list item indentation', () => {
+    const tokens = parseMarkdown('- top\n  - nested\n    - deep')
+    expect(tokens).toEqual([
+      { type: 'list-item', text: 'top', indent: 0 },
+      { type: 'list-item', text: 'nested', indent: 1 },
+      { type: 'list-item', text: 'deep', indent: 2 },
+    ])
+  })
+
+  it('parses numbered list items', () => {
+    const tokens = parseMarkdown('1. first\n2. second')
+    expect(tokens).toEqual([
+      { type: 'list-item', text: 'first', indent: 0 },
+      { type: 'list-item', text: 'second', indent: 0 },
+    ])
+  })
+
+  it('parses fenced code blocks with language', () => {
+    const input = '```typescript\nconst x = 1\nconsole.log(x)\n```'
+    const tokens = parseMarkdown(input)
+    expect(tokens).toEqual([
+      { type: 'code-block', language: 'typescript', lines: ['const x = 1', 'console.log(x)'] },
+    ])
+  })
+
+  it('parses code blocks without language', () => {
+    const tokens = parseMarkdown('```\nhello\n```')
+    expect(tokens).toEqual([
+      { type: 'code-block', language: '', lines: ['hello'] },
+    ])
+  })
+
+  it('parses horizontal rules', () => {
+    const tokens = parseMarkdown('---')
+    expect(tokens).toEqual([{ type: 'hr' }])
+  })
+
+  it('treats blank lines as blank tokens', () => {
+    const tokens = parseMarkdown('text\n\nmore')
+    expect(tokens).toEqual([
+      { type: 'paragraph', text: 'text' },
+      { type: 'blank' },
+      { type: 'paragraph', text: 'more' },
+    ])
+  })
+
+  it('treats plain text as paragraphs', () => {
+    const tokens = parseMarkdown('Hello world')
+    expect(tokens).toEqual([{ type: 'paragraph', text: 'Hello world' }])
+  })
+
+  it('handles a realistic SKILL.md structure', () => {
+    const input = `---
+name: test
+---
+
+# My Skill
+
+A description paragraph.
+
+## Usage
+
+- Step one
+- Step two
+
+\`\`\`bash
+npm install
+\`\`\`
+`
+    const tokens = parseMarkdown(input)
+    const types = tokens.map((t) => t.type)
+    expect(types).toContain('heading')
+    expect(types).toContain('paragraph')
+    expect(types).toContain('list-item')
+    expect(types).toContain('code-block')
+  })
+
+  // Property: every non-empty line produces a token
+  it('produces at least one token for any non-empty input', () => {
+    const inputs = ['hello', '# heading', '- item', '```\ncode\n```', '---']
+    for (const input of inputs) {
+      const tokens = parseMarkdown(input)
+      expect(tokens.length).toBeGreaterThan(0)
+    }
+  })
+
+  // Property: no frontmatter tokens leak through
+  it('never produces tokens containing frontmatter delimiters', () => {
+    const input = '---\nkey: value\n---\n# Title'
+    const tokens = parseMarkdown(input)
+    for (const token of tokens) {
+      if ('text' in token) {
+        expect(token.text).not.toMatch(/^---$/)
+        expect(token.text).not.toMatch(/^key: value$/)
+      }
+    }
+  })
+})
+
+describe('parseInline', () => {
+  it('returns plain text as single segment', () => {
+    expect(parseInline('hello')).toEqual([{ text: 'hello' }])
+  })
+
+  it('parses bold text', () => {
+    const segments = parseInline('this is **bold** text')
+    expect(segments).toEqual([
+      { text: 'this is ' },
+      { text: 'bold', bold: true },
+      { text: ' text' },
+    ])
+  })
+
+  it('parses italic text', () => {
+    const segments = parseInline('this is *italic* text')
+    expect(segments).toEqual([
+      { text: 'this is ' },
+      { text: 'italic', italic: true },
+      { text: ' text' },
+    ])
+  })
+
+  it('parses inline code', () => {
+    const segments = parseInline('use `npm install` here')
+    expect(segments).toEqual([
+      { text: 'use ' },
+      { text: 'npm install', code: true },
+      { text: ' here' },
+    ])
+  })
+
+  it('handles mixed inline formatting', () => {
+    const segments = parseInline('**bold** and `code` and *italic*')
+    expect(segments).toHaveLength(5)
+    expect(segments[0]).toEqual({ text: 'bold', bold: true })
+    expect(segments[2]).toEqual({ text: 'code', code: true })
+    expect(segments[4]).toEqual({ text: 'italic', italic: true })
+  })
+
+  it('handles text with no formatting', () => {
+    const segments = parseInline('just plain text here')
+    expect(segments).toHaveLength(1)
+    expect(segments[0].text).toBe('just plain text here')
+  })
+
+  // Property: concatenated segment text equals original stripped of formatting
+  it('preserves all text content', () => {
+    const input = '**bold** and `code` text'
+    const segments = parseInline(input)
+    const reconstructed = segments.map((s) => s.text).join('')
+    expect(reconstructed).toBe('bold and code text')
+  })
+})

package/src/services/__tests__/terminal-dimensions.pbt.test.ts

@@ -0,0 +1,246 @@
+import * as fc from 'fast-check'
+import { describe, it, expect, afterEach } from '@jest/globals'
+import { getTerminalSize, shouldUseBottomPanel } from '../terminal-dimensions'
+
+describe('terminal-dimensions service - Property-Based Tests', () => {
+  // Store original values
+  const originalColumns = process.stdout.columns
+  const originalRows = process.stdout.rows
+
+  afterEach(() => {
+    // Restore original values
+    process.stdout.columns = originalColumns
+    process.stdout.rows = originalRows
+  })
+
+  /**
+   * **Validates: Requirements 3.4.3**
+   *
+   * Property 7: Panel position by terminal size
+   *
+   * For any terminal dimensions, the detail panel should be positioned on the side
+   * when width >= 120, and at the bottom when width < 120. This property validates that:
+   * 1. Width >= 120 results in side position (shouldUseBottomPanel returns false)
+   * 2. Width < 120 results in bottom position (shouldUseBottomPanel returns true)
+   * 3. The threshold boundary at 120 columns is correctly enforced
+   */
+  it('should position panel based on terminal width threshold of 120 columns', () => {
+    fc.assert(
+      fc.property(
+        // Generate terminal widths from 1 to 300 columns
+        fc.integer({ min: 1, max: 300 }),
+        // Generate terminal heights from 1 to 100 rows (height doesn't affect panel position)
+        fc.integer({ min: 1, max: 100 }),
+        (width, height) => {
+          // Setup: Set terminal dimensions
+          process.stdout.columns = width
+          process.stdout.rows = height
+
+          // Act: Check panel position
+          const useBottomPanel = shouldUseBottomPanel()
+
+          // Assert: Panel should be at bottom when width < 120, side when width >= 120
+          const expectedBottomPanel = width < 120
+
+          expect(useBottomPanel).toBe(expectedBottomPanel)
+
+          // Additional assertion: Verify terminal size is read correctly
+          const size = getTerminalSize()
+          expect(size.width).toBe(width)
+          expect(size.height).toBe(height)
+        }
+      ),
+      { numRuns: 500 }
+    )
+  })
+
+  /**
+   * Additional property: Boundary precision at 120 columns
+   *
+   * Validates that the threshold is precise at exactly 120 columns
+   */
+  it('should have precise threshold boundary at 120 columns', () => {
+    fc.assert(
+      fc.property(
+        // Generate small offsets around the 120 column boundary (-50 to +50)
+        fc.integer({ min: -50, max: 50 }),
+        fc.integer({ min: 24, max: 100 }),
+        (offset, height) => {
+          // Setup: Set width to exactly 120 + offset
+          const width = 120 + offset
+          process.stdout.columns = width
+          process.stdout.rows = height
+
+          // Act: Check panel position
+          const useBottomPanel = shouldUseBottomPanel()
+
+          // Assert: Should use bottom panel only when offset is negative (width < 120)
+          const expectedBottomPanel = offset < 0
+
+          expect(useBottomPanel).toBe(expectedBottomPanel)
+        }
+      ),
+      { numRuns: 300 }
+    )
+  })
+
+  /**
+   * Additional property: Panel position independence from height
+   *
+   * Validates that panel positioning is determined solely by width,
+   * not affected by terminal height
+   */
+  it('should determine panel position based on width only, independent of height', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 1, max: 300 }),
+        // Generate two different heights
+        fc.integer({ min: 1, max: 100 }),
+        fc.integer({ min: 1, max: 100 }),
+        (width, height1, height2) => {
+          // Setup: Test with same width but different heights
+          process.stdout.columns = width
+          
+          // First test with height1
+          process.stdout.rows = height1
+          const result1 = shouldUseBottomPanel()
+
+          // Second test with height2
+          process.stdout.rows = height2
+          const result2 = shouldUseBottomPanel()
+
+          // Assert: Both should return the same result since width is the same
+          expect(result1).toBe(result2)
+
+          // Both should match the expected result based on width
+          const expectedBottomPanel = width < 120
+          expect(result1).toBe(expectedBottomPanel)
+          expect(result2).toBe(expectedBottomPanel)
+        }
+      ),
+      { numRuns: 300 }
+    )
+  })
+
+  /**
+   * Additional property: Consistent results across multiple calls
+   *
+   * Validates that calling shouldUseBottomPanel multiple times with
+   * the same terminal dimensions returns consistent results
+   */
+  it('should return consistent results across multiple calls with same dimensions', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 1, max: 300 }),
+        fc.integer({ min: 1, max: 100 }),
+        // Generate number of calls (2-10)
+        fc.integer({ min: 2, max: 10 }),
+        (width, height, numCalls) => {
+          // Setup: Set terminal dimensions
+          process.stdout.columns = width
+          process.stdout.rows = height
+
+          // Act: Call shouldUseBottomPanel multiple times
+          const results = Array.from({ length: numCalls }, () => shouldUseBottomPanel())
+
+          // Assert: All calls should return the same result
+          const firstResult = results[0]
+          for (const result of results) {
+            expect(result).toBe(firstResult)
+          }
+
+          // Verify the result matches the expected value
+          const expectedBottomPanel = width < 120
+          expect(firstResult).toBe(expectedBottomPanel)
+        }
+      ),
+      { numRuns: 200 }
+    )
+  })
+
+  /**
+   * Additional property: Edge cases at minimum and maximum widths
+   *
+   * Validates behavior at extreme terminal widths
+   */
+  it('should handle extreme terminal widths correctly', () => {
+    fc.assert(
+      fc.property(
+        // Generate extreme widths: very small (1-10) or very large (200-500)
+        fc.oneof(
+          fc.integer({ min: 1, max: 10 }),
+          fc.integer({ min: 200, max: 500 })
+        ),
+        fc.integer({ min: 1, max: 100 }),
+        (width, height) => {
+          // Setup: Set terminal dimensions
+          process.stdout.columns = width
+          process.stdout.rows = height
+
+          // Act: Check panel position
+          const useBottomPanel = shouldUseBottomPanel()
+
+          // Assert: Should follow the same rule regardless of extreme values
+          const expectedBottomPanel = width < 120
+
+          expect(useBottomPanel).toBe(expectedBottomPanel)
+
+          // For very small widths, should always use bottom panel
+          if (width < 120) {
+            expect(useBottomPanel).toBe(true)
+          }
+
+          // For very large widths, should always use side panel
+          if (width >= 200) {
+            expect(useBottomPanel).toBe(false)
+          }
+        }
+      ),
+      { numRuns: 200 }
+    )
+  })
+
+  describe('specific boundary examples', () => {
+    it('should use bottom panel at exactly 119 columns', () => {
+      process.stdout.columns = 119
+      process.stdout.rows = 30
+
+      expect(shouldUseBottomPanel()).toBe(true)
+    })
+
+    it('should use side panel at exactly 120 columns', () => {
+      process.stdout.columns = 120
+      process.stdout.rows = 30
+
+      expect(shouldUseBottomPanel()).toBe(false)
+    })
+
+    it('should use side panel at exactly 121 columns', () => {
+      process.stdout.columns = 121
+      process.stdout.rows = 30
+
+      expect(shouldUseBottomPanel()).toBe(false)
+    })
+
+    it('should use bottom panel for minimum terminal width', () => {
+      process.stdout.columns = 80
+      process.stdout.rows = 24
+
+      expect(shouldUseBottomPanel()).toBe(true)
+    })
+
+    it('should use side panel for very wide terminals', () => {
+      process.stdout.columns = 200
+      process.stdout.rows = 50
+
+      expect(shouldUseBottomPanel()).toBe(false)
+    })
+
+    it('should use bottom panel for narrow terminals', () => {
+      process.stdout.columns = 100
+      process.stdout.rows = 40
+
+      expect(shouldUseBottomPanel()).toBe(true)
+    })
+  })
+})

package/src/services/__tests__/terminal-dimensions.test.ts

@@ -0,0 +1,109 @@
+import { afterEach, describe, expect, it } from '@jest/globals'
+
+import { canShowDetailPanel, getTerminalSize, shouldUseBottomPanel } from '../terminal-dimensions'
+
+describe('terminal-dimensions service', () => {
+  const originalColumns = process.stdout.columns
+  const originalRows = process.stdout.rows
+
+  const mockTerminalSize = (columns: number | undefined, rows: number | undefined) => {
+    Object.defineProperty(process.stdout, 'columns', {
+      value: columns,
+      configurable: true,
+      writable: true,
+    })
+    Object.defineProperty(process.stdout, 'rows', {
+      value: rows,
+      configurable: true,
+      writable: true,
+    })
+  }
+
+  afterEach(() => {
+    mockTerminalSize(originalColumns, originalRows)
+  })
+
+  describe('getTerminalSize', () => {
+    it('should return current terminal dimensions', () => {
+      mockTerminalSize(120, 30)
+      const size = getTerminalSize()
+      expect(size).toEqual({ width: 120, height: 30 })
+    })
+
+    it('should return default dimensions when stdout values are undefined', () => {
+      mockTerminalSize(undefined, undefined)
+      const size = getTerminalSize()
+      expect(size).toEqual({ width: 80, height: 24 })
+    })
+
+    it('should handle zero values by using defaults', () => {
+      mockTerminalSize(0, 0)
+      const size = getTerminalSize()
+      expect(size).toEqual({ width: 80, height: 24 })
+    })
+  })
+
+  describe('shouldUseBottomPanel', () => {
+    it('should return true when width is less than 120', () => {
+      mockTerminalSize(119, 30)
+      const result = shouldUseBottomPanel()
+      expect(result).toBe(true)
+    })
+
+    it('should return false when width is 120 or greater', () => {
+      mockTerminalSize(120, 30)
+      const result = shouldUseBottomPanel()
+      expect(result).toBe(false)
+    })
+
+    it('should return false for very wide terminals', () => {
+      mockTerminalSize(200, 50)
+      const result = shouldUseBottomPanel()
+      expect(result).toBe(false)
+    })
+
+    it('should return true for narrow terminals', () => {
+      mockTerminalSize(80, 24)
+      const result = shouldUseBottomPanel()
+      expect(result).toBe(true)
+    })
+  })
+
+  describe('canShowDetailPanel', () => {
+    it('should return true when dimensions meet minimum requirements', () => {
+      mockTerminalSize(80, 24)
+      const result = canShowDetailPanel()
+      expect(result).toBe(true)
+    })
+
+    it('should return true when dimensions exceed minimum requirements', () => {
+      mockTerminalSize(120, 40)
+      const result = canShowDetailPanel()
+      expect(result).toBe(true)
+    })
+
+    it('should return false when width is below minimum', () => {
+      mockTerminalSize(79, 24)
+      const result = canShowDetailPanel()
+      expect(result).toBe(false)
+    })
+
+    it('should return false when height is below minimum', () => {
+      mockTerminalSize(80, 23)
+      const result = canShowDetailPanel()
+      expect(result).toBe(false)
+    })
+
+    it('should return false when both dimensions are below minimum', () => {
+      mockTerminalSize(70, 20)
+      const result = canShowDetailPanel()
+      expect(result).toBe(false)
+    })
+
+    it('should handle default dimensions correctly', () => {
+      mockTerminalSize(undefined, undefined)
+      const result = canShowDetailPanel()
+      expect(result).toBe(true)
+    })
+  })
+})