prjct-cli 1.22.0 → 1.23.0

package/core/__tests__/utils/output.test.ts

@@ -1,278 +0,0 @@
-/**
- * Output Module Tests
- * Minimal output system for prjct-cli
- */
-
-import { afterEach, beforeEach, describe, expect, it, spyOn } from 'bun:test'
-import out, {
-  formatForHuman,
-  getOutputTier,
-  getTierConfig,
-  limitLines,
-  OUTPUT_TIERS,
-  setOutputTier,
-} from '../../utils/output'
-
-describe('Output Module', () => {
-  let consoleLogSpy: ReturnType<typeof spyOn>
-  let consoleErrorSpy: ReturnType<typeof spyOn>
-  let stdoutWriteSpy: ReturnType<typeof spyOn>
-
-  beforeEach(() => {
-    consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
-    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
-    stdoutWriteSpy = spyOn(process.stdout, 'write').mockImplementation(() => true)
-    out.stop()
-  })
-
-  afterEach(() => {
-    consoleLogSpy.mockRestore()
-    consoleErrorSpy.mockRestore()
-    stdoutWriteSpy.mockRestore()
-    out.stop()
-  })
-
-  describe('done()', () => {
-    it('should output success message with checkmark', () => {
-      out.done('task completed')
-
-      expect(consoleLogSpy).toHaveBeenCalledTimes(1)
-      const output = consoleLogSpy.mock.calls[0][0]
-      expect(output).toContain('✓')
-      expect(output).toContain('task completed')
-    })
-
-    it('should truncate long messages', () => {
-      const longMessage = 'a'.repeat(100)
-      out.done(longMessage)
-
-      const output = consoleLogSpy.mock.calls[0][0]
-      expect(output.length).toBeLessThan(80)
-    })
-
-    it('should return self for chaining', () => {
-      const result = out.done('test')
-      expect(result).toBe(out)
-    })
-  })
-
-  describe('fail()', () => {
-    it('should output error message with X mark', () => {
-      out.fail('something failed')
-
-      expect(consoleErrorSpy).toHaveBeenCalledTimes(1)
-      const output = consoleErrorSpy.mock.calls[0][0]
-      expect(output).toContain('✗')
-      expect(output).toContain('something failed')
-    })
-
-    it('should truncate long error messages', () => {
-      const longMessage = 'error '.repeat(50)
-      out.fail(longMessage)
-
-      const output = consoleErrorSpy.mock.calls[0][0]
-      expect(output.length).toBeLessThan(80)
-    })
-
-    it('should return self for chaining', () => {
-      const result = out.fail('test')
-      expect(result).toBe(out)
-    })
-  })
-
-  describe('warn()', () => {
-    it('should output warning message with warning symbol', () => {
-      out.warn('be careful')
-
-      expect(consoleLogSpy).toHaveBeenCalledTimes(1)
-      const output = consoleLogSpy.mock.calls[0][0]
-      expect(output).toContain('⚠')
-      expect(output).toContain('be careful')
-    })
-
-    it('should return self for chaining', () => {
-      const result = out.warn('test')
-      expect(result).toBe(out)
-    })
-  })
-
-  describe('spin()', () => {
-    it('should start spinner with message', async () => {
-      out.spin('loading')
-
-      await new Promise((resolve) => setTimeout(resolve, 150))
-
-      expect(stdoutWriteSpy).toHaveBeenCalled()
-      const output = stdoutWriteSpy.mock.calls[0][0]
-      expect(output).toContain('loading')
-
-      out.stop()
-    })
-
-    it('should return self for chaining', () => {
-      const result = out.spin('test')
-      out.stop()
-      expect(result).toBe(out)
-    })
-  })
-
-  describe('stop()', () => {
-    it('should stop spinner and clear line', async () => {
-      out.spin('loading')
-      await new Promise((resolve) => setTimeout(resolve, 150))
-
-      stdoutWriteSpy.mockClear()
-      out.stop()
-
-      // In TTY, stop() writes a clear sequence; in non-TTY, spinner doesn't
-      // use setInterval so stop() is a no-op (clear skips in non-TTY)
-      if (process.stdout.isTTY) {
-        expect(stdoutWriteSpy).toHaveBeenCalled()
-      } else {
-        expect(stdoutWriteSpy).not.toHaveBeenCalled()
-      }
-    })
-
-    it('should be safe to call multiple times', () => {
-      expect(() => {
-        out.stop()
-        out.stop()
-        out.stop()
-      }).not.toThrow()
-    })
-
-    it('should return self for chaining', () => {
-      const result = out.stop()
-      expect(result).toBe(out)
-    })
-  })
-
-  describe('edge cases', () => {
-    it('should handle empty messages', () => {
-      expect(() => out.done('')).not.toThrow()
-      expect(() => out.fail('')).not.toThrow()
-      expect(() => out.warn('')).not.toThrow()
-    })
-
-    it('should handle null/undefined messages', () => {
-      expect(() => out.done(null as unknown as string)).not.toThrow()
-      expect(() => out.done(undefined as unknown as string)).not.toThrow()
-    })
-
-    it('should handle messages with special characters', () => {
-      out.done('test with émojis 🎉 and spëcial çhars')
-      expect(consoleLogSpy).toHaveBeenCalled()
-    })
-  })
-
-  describe('Output Tiers', () => {
-    afterEach(() => {
-      setOutputTier('compact') // Reset to default
-    })
-
-    it('should have correct tier configs', () => {
-      expect(OUTPUT_TIERS.silent.maxLines).toBe(0)
-      expect(OUTPUT_TIERS.minimal.maxLines).toBe(1)
-      expect(OUTPUT_TIERS.compact.maxLines).toBe(4)
-      expect(OUTPUT_TIERS.verbose.maxLines).toBe(Infinity)
-    })
-
-    it('should get and set output tier', () => {
-      setOutputTier('verbose')
-      expect(getOutputTier()).toBe('verbose')
-
-      setOutputTier('minimal')
-      expect(getOutputTier()).toBe('minimal')
-    })
-
-    it('should return correct tier config', () => {
-      setOutputTier('compact')
-      const config = getTierConfig()
-      expect(config.maxLines).toBe(4)
-      expect(config.maxCharsPerLine).toBe(80)
-      expect(config.showMetrics).toBe(true)
-    })
-  })
-
-  describe('limitLines()', () => {
-    it('should limit content to maxLines', () => {
-      setOutputTier('compact') // maxLines = 4
-      const content = 'line1\nline2\nline3\nline4\nline5\nline6'
-      const result = limitLines(content)
-
-      expect(result.split('\n').length).toBe(5) // 4 lines + "...2 more lines"
-      expect(result).toContain('...2 more lines')
-    })
-
-    it('should not truncate if under limit', () => {
-      setOutputTier('compact')
-      const content = 'line1\nline2'
-      const result = limitLines(content)
-
-      expect(result).toBe(content)
-    })
-
-    it('should respect custom maxLines parameter', () => {
-      const content = 'line1\nline2\nline3\nline4'
-      const result = limitLines(content, 2)
-
-      expect(result.split('\n').length).toBe(3) // 2 lines + indicator
-      expect(result).toContain('...2 more lines')
-    })
-
-    it('should return content unchanged for verbose tier', () => {
-      setOutputTier('verbose')
-      const content = 'line1\nline2\nline3\nline4\nline5'
-      const result = limitLines(content)
-
-      expect(result).toBe(content)
-    })
-  })
-
-  describe('formatForHuman()', () => {
-    afterEach(() => {
-      setOutputTier('compact')
-    })
-
-    it('should format Linear issue object', () => {
-      const issue = {
-        identifier: 'PRJ-123',
-        title: 'Test issue title',
-        status: 'in_progress',
-        priority: 'high',
-        url: 'https://linear.app/test',
-      }
-
-      const result = formatForHuman(issue)
-      expect(result).toContain('PRJ-123')
-      expect(result).toContain('Test issue title')
-      expect(result).toContain('in_progress')
-    })
-
-    it('should format issue list', () => {
-      const list = {
-        issues: [
-          { identifier: 'PRJ-1', title: 'First issue', priority: 'high' },
-          { identifier: 'PRJ-2', title: 'Second issue', priority: 'none' },
-        ],
-      }
-
-      const result = formatForHuman(list)
-      expect(result).toContain('PRJ-1')
-      expect(result).toContain('PRJ-2')
-    })
-
-    it('should return empty string for silent tier', () => {
-      setOutputTier('silent')
-      const result = formatForHuman({ test: 'data' })
-      expect(result).toBe('')
-    })
-
-    it('should return full JSON for verbose tier', () => {
-      setOutputTier('verbose')
-      const data = { test: 'data', nested: { key: 'value' } }
-      const result = formatForHuman(data)
-      expect(result).toBe(JSON.stringify(data, null, 2))
-    })
-  })
-})

package/core/__tests__/utils/preserve-sections.test.ts

@@ -1,216 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import {
-  extractPreservedContent,
-  extractPreservedSections,
-  hasPreservedSections,
-  mergePreservedSections,
-  stripPreservedSections,
-  validatePreserveBlocks,
-  wrapInPreserveMarkers,
-} from '../../utils/preserve-sections'
-
-describe('preserve-sections', () => {
-  describe('extractPreservedSections', () => {
-    it('should extract a single preserved section', () => {
-      const content = `# Header
-
-<!-- prjct:preserve -->
-My custom content
-<!-- /prjct:preserve -->
-
-# Footer`
-
-      const sections = extractPreservedSections(content)
-      expect(sections).toHaveLength(1)
-      expect(sections[0].content).toContain('My custom content')
-    })
-
-    it('should extract multiple preserved sections', () => {
-      const content = `# Header
-
-<!-- prjct:preserve -->
-First section
-<!-- /prjct:preserve -->
-
-Some content
-
-<!-- prjct:preserve -->
-Second section
-<!-- /prjct:preserve -->`
-
-      const sections = extractPreservedSections(content)
-      expect(sections).toHaveLength(2)
-      expect(sections[0].content).toContain('First section')
-      expect(sections[1].content).toContain('Second section')
-    })
-
-    it('should handle named sections', () => {
-      const content = `<!-- prjct:preserve:custom-rules -->
-My rules
-<!-- /prjct:preserve -->`
-
-      const sections = extractPreservedSections(content)
-      expect(sections).toHaveLength(1)
-      expect(sections[0].id).toBe('custom-rules')
-    })
-
-    it('should return empty array when no preserved sections', () => {
-      const content = '# Just normal content'
-      const sections = extractPreservedSections(content)
-      expect(sections).toHaveLength(0)
-    })
-
-    it('should ignore unclosed preserve blocks', () => {
-      const content = `<!-- prjct:preserve -->
-No closing tag here`
-
-      const sections = extractPreservedSections(content)
-      expect(sections).toHaveLength(0)
-    })
-  })
-
-  describe('extractPreservedContent', () => {
-    it('should extract inner content without markers', () => {
-      const content = `<!-- prjct:preserve -->
-My content
-<!-- /prjct:preserve -->`
-
-      const inner = extractPreservedContent(content)
-      expect(inner).toHaveLength(1)
-      expect(inner[0]).toBe('My content')
-    })
-  })
-
-  describe('hasPreservedSections', () => {
-    it('should return true when preserved sections exist', () => {
-      const content = '<!-- prjct:preserve -->content<!-- /prjct:preserve -->'
-      expect(hasPreservedSections(content)).toBe(true)
-    })
-
-    it('should return false when no preserved sections', () => {
-      const content = '# Normal markdown'
-      expect(hasPreservedSections(content)).toBe(false)
-    })
-  })
-
-  describe('mergePreservedSections', () => {
-    it('should append preserved sections to new content', () => {
-      const oldContent = `# Old Header
-
-<!-- prjct:preserve -->
-# My Rules
-- Use tabs
-<!-- /prjct:preserve -->`
-
-      const newContent = `# New Generated Content
-
-This is fresh.`
-
-      const merged = mergePreservedSections(newContent, oldContent)
-
-      expect(merged).toContain('# New Generated Content')
-      expect(merged).toContain('My Rules')
-      expect(merged).toContain('Use tabs')
-      expect(merged).toContain('prjct:preserve')
-    })
-
-    it('should return new content unchanged when no preserved sections', () => {
-      const oldContent = '# Old content without preserve markers'
-      const newContent = '# New content'
-
-      const merged = mergePreservedSections(newContent, oldContent)
-      expect(merged).toBe(newContent)
-    })
-
-    it('should preserve multiple sections', () => {
-      const oldContent = `<!-- prjct:preserve -->
-Section 1
-<!-- /prjct:preserve -->
-
-<!-- prjct:preserve -->
-Section 2
-<!-- /prjct:preserve -->`
-
-      const newContent = '# New'
-
-      const merged = mergePreservedSections(newContent, oldContent)
-      expect(merged).toContain('Section 1')
-      expect(merged).toContain('Section 2')
-    })
-  })
-
-  describe('wrapInPreserveMarkers', () => {
-    it('should wrap content with default markers', () => {
-      const content = 'My content'
-      const wrapped = wrapInPreserveMarkers(content)
-
-      expect(wrapped).toContain('<!-- prjct:preserve -->')
-      expect(wrapped).toContain('My content')
-      expect(wrapped).toContain('<!-- /prjct:preserve -->')
-    })
-
-    it('should wrap content with named markers', () => {
-      const content = 'My content'
-      const wrapped = wrapInPreserveMarkers(content, 'custom')
-
-      expect(wrapped).toContain('<!-- prjct:preserve:custom -->')
-    })
-  })
-
-  describe('stripPreservedSections', () => {
-    it('should remove preserved sections from content', () => {
-      const content = `# Header
-
-<!-- prjct:preserve -->
-Custom stuff
-<!-- /prjct:preserve -->
-
-# Footer`
-
-      const stripped = stripPreservedSections(content)
-      expect(stripped).toContain('# Header')
-      expect(stripped).toContain('# Footer')
-      expect(stripped).not.toContain('Custom stuff')
-      expect(stripped).not.toContain('prjct:preserve')
-    })
-
-    it('should return content unchanged when no preserved sections', () => {
-      const content = '# Normal content'
-      const stripped = stripPreservedSections(content)
-      expect(stripped).toBe(content)
-    })
-  })
-
-  describe('validatePreserveBlocks', () => {
-    it('should validate correct blocks', () => {
-      const content = `<!-- prjct:preserve -->
-Content
-<!-- /prjct:preserve -->`
-
-      const result = validatePreserveBlocks(content)
-      expect(result.valid).toBe(true)
-      expect(result.errors).toHaveLength(0)
-    })
-
-    it('should detect mismatched markers', () => {
-      const content = `<!-- prjct:preserve -->
-Content without closing`
-
-      const result = validatePreserveBlocks(content)
-      expect(result.valid).toBe(false)
-      expect(result.errors.length).toBeGreaterThan(0)
-    })
-
-    it('should detect nested blocks', () => {
-      const content = `<!-- prjct:preserve -->
-<!-- prjct:preserve -->
-Nested
-<!-- /prjct:preserve -->
-<!-- /prjct:preserve -->`
-
-      const result = validatePreserveBlocks(content)
-      expect(result.valid).toBe(false)
-      expect(result.errors.some((e) => e.includes('Nested'))).toBe(true)
-    })
-  })
-})

package/core/__tests__/utils/project-commands.test.ts

@@ -1,71 +0,0 @@
-/**
- * Project command detection tests
- * Ensures prjct-cli uses the repo's own test/lint tooling (not hardcoded).
- */
-
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-
-import { detectProjectCommands } from '../../utils/project-commands'
-
-let tmpRoot: string | null = null
-
-async function writeJson(filePath: string, data: unknown): Promise<void> {
-  await fs.mkdir(path.dirname(filePath), { recursive: true })
-  await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8')
-}
-
-async function writeText(filePath: string, content: string): Promise<void> {
-  await fs.mkdir(path.dirname(filePath), { recursive: true })
-  await fs.writeFile(filePath, content, 'utf-8')
-}
-
-describe('detectProjectCommands', () => {
-  beforeEach(async () => {
-    tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'prjct-detect-commands-'))
-  })
-
-  afterEach(async () => {
-    if (!tmpRoot) return
-    await fs.rm(tmpRoot, { recursive: true, force: true })
-    tmpRoot = null
-  })
-
-  it('detects JS project and respects declared pnpm packageManager', async () => {
-    await writeJson(path.join(tmpRoot!, 'package.json'), {
-      name: 'x',
-      packageManager: 'pnpm@9.0.0',
-      scripts: { test: 'vitest', lint: 'eslint .', typecheck: 'tsc -p tsconfig.json' },
-    })
-
-    const detected = await detectProjectCommands(tmpRoot!)
-    expect(detected.stack).toBe('js')
-    expect(detected.packageManager).toBe('pnpm')
-    expect(detected.test?.command).toBe('pnpm test')
-    expect(detected.lint?.command).toBe('pnpm run lint')
-    expect(detected.typecheck?.command).toBe('pnpm run typecheck')
-  })
-
-  it('detects Python pytest via pytest.ini', async () => {
-    await writeText(path.join(tmpRoot!, 'pytest.ini'), '[pytest]\n')
-    const detected = await detectProjectCommands(tmpRoot!)
-    expect(detected.stack).toBe('python')
-    expect(detected.test?.command).toBe('pytest')
-  })
-
-  it('detects Go via go.mod', async () => {
-    await writeText(path.join(tmpRoot!, 'go.mod'), 'module example.com/test\n')
-    const detected = await detectProjectCommands(tmpRoot!)
-    expect(detected.stack).toBe('go')
-    expect(detected.test?.command).toBe('go test ./...')
-  })
-
-  it('detects Rust via Cargo.toml', async () => {
-    await writeText(path.join(tmpRoot!, 'Cargo.toml'), '[package]\nname="x"\nversion="0.1.0"\n')
-    const detected = await detectProjectCommands(tmpRoot!)
-    expect(detected.stack).toBe('rust')
-    expect(detected.test?.command).toBe('cargo test')
-  })
-})