prjct-cli 0.10.0 → 0.10.2

package/core/__tests__/domain/analyzer.test.js

@@ -1,324 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { createRequire } from 'module'
-import path from 'path'
-import fs from 'fs/promises'
-import os from 'os'
-
-const require = createRequire(import.meta.url)
-
-describe('Codebase Analyzer', () => {
-  let analyzer
-  let testProjectPath
-  let tempDir
-
-  beforeEach(async () => {
-    analyzer = require('../../domain/analyzer.js')
-
-    // Create temporary test directory
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'prjct-test-'))
-    testProjectPath = tempDir
-
-    analyzer.init(testProjectPath)
-  })
-
-  afterEach(async () => {
-    if (tempDir) {
-      try {
-        await fs.rm(tempDir, { recursive: true, force: true })
-      } catch (error) {
-        // Ignore cleanup errors
-      }
-    }
-  })
-
-  describe('init()', () => {
-    it('should initialize with project path', () => {
-      analyzer.init('/test/path')
-      expect(analyzer.projectPath).toBe('/test/path')
-    })
-
-    it('should use current directory if no path provided', () => {
-      analyzer.init()
-      expect(analyzer.projectPath).toBeDefined()
-    })
-  })
-
-  describe('readPackageJson()', () => {
-    it('should read package.json when it exists', async () => {
-      const packageJson = {
-        name: 'test-project',
-        version: '1.0.0',
-        dependencies: { express: '^4.18.0' }
-      }
-      await fs.writeFile(
-        path.join(testProjectPath, 'package.json'),
-        JSON.stringify(packageJson, null, 2)
-      )
-
-      const result = await analyzer.readPackageJson()
-
-      expect(result).toBeDefined()
-      expect(result.name).toBe('test-project')
-      expect(result.dependencies.express).toBeDefined()
-    })
-
-    it('should return null when package.json does not exist', async () => {
-      const result = await analyzer.readPackageJson()
-
-      expect(result).toBeNull()
-    })
-
-    it('should return null for invalid JSON', async () => {
-      await fs.writeFile(path.join(testProjectPath, 'package.json'), 'invalid json{')
-
-      const result = await analyzer.readPackageJson()
-
-      expect(result).toBeNull()
-    })
-  })
-
-  describe('readCargoToml()', () => {
-    it('should read Cargo.toml when it exists', async () => {
-      const cargoContent = '[package]\nname = "test-project"\nversion = "0.1.0"'
-      await fs.writeFile(path.join(testProjectPath, 'Cargo.toml'), cargoContent)
-
-      const result = await analyzer.readCargoToml()
-
-      expect(result).toBeDefined()
-      expect(result).toContain('test-project')
-    })
-
-    it('should return null when Cargo.toml does not exist', async () => {
-      const result = await analyzer.readCargoToml()
-
-      expect(result).toBeNull()
-    })
-  })
-
-  describe('readRequirements()', () => {
-    it('should read requirements.txt when it exists', async () => {
-      const requirements = 'flask==2.0.0\nrequests==2.28.0'
-      await fs.writeFile(path.join(testProjectPath, 'requirements.txt'), requirements)
-
-      const result = await analyzer.readRequirements()
-
-      expect(result).toBeDefined()
-      expect(result).toContain('flask')
-    })
-
-    it('should return null when requirements.txt does not exist', async () => {
-      const result = await analyzer.readRequirements()
-
-      expect(result).toBeNull()
-    })
-  })
-
-  describe('readGoMod()', () => {
-    it('should read go.mod when it exists', async () => {
-      const goMod = 'module test-project\n\ngo 1.19'
-      await fs.writeFile(path.join(testProjectPath, 'go.mod'), goMod)
-
-      const result = await analyzer.readGoMod()
-
-      expect(result).toBeDefined()
-      expect(result).toContain('test-project')
-    })
-
-    it('should return null when go.mod does not exist', async () => {
-      const result = await analyzer.readGoMod()
-
-      expect(result).toBeNull()
-    })
-  })
-
-  describe('listDirectories()', () => {
-    it('should list directories in project root', async () => {
-      await fs.mkdir(path.join(testProjectPath, 'src'), { recursive: true })
-      await fs.mkdir(path.join(testProjectPath, 'tests'), { recursive: true })
-      await fs.writeFile(path.join(testProjectPath, 'file.txt'), 'content')
-
-      const directories = await analyzer.listDirectories()
-
-      expect(directories).toContain('src')
-      expect(directories).toContain('tests')
-      expect(directories).not.toContain('file.txt')
-    })
-
-    it('should exclude hidden directories', async () => {
-      await fs.mkdir(path.join(testProjectPath, '.git'), { recursive: true })
-      await fs.mkdir(path.join(testProjectPath, 'src'), { recursive: true })
-
-      const directories = await analyzer.listDirectories()
-
-      expect(directories).not.toContain('.git')
-      expect(directories).toContain('src')
-    })
-
-    it('should exclude node_modules', async () => {
-      await fs.mkdir(path.join(testProjectPath, 'node_modules'), { recursive: true })
-      await fs.mkdir(path.join(testProjectPath, 'src'), { recursive: true })
-
-      const directories = await analyzer.listDirectories()
-
-      expect(directories).not.toContain('node_modules')
-      expect(directories).toContain('src')
-    })
-
-    it('should return empty array for non-existent directory', async () => {
-      analyzer.init('/nonexistent/path')
-
-      const directories = await analyzer.listDirectories()
-
-      expect(directories).toEqual([])
-    })
-  })
-
-  describe('fileExists()', () => {
-    it('should return true for existing file', async () => {
-      await fs.writeFile(path.join(testProjectPath, 'test.txt'), 'content')
-
-      const exists = await analyzer.fileExists('test.txt')
-
-      expect(exists).toBe(true)
-    })
-
-    it('should return false for non-existent file', async () => {
-      const exists = await analyzer.fileExists('nonexistent.txt')
-
-      expect(exists).toBe(false)
-    })
-  })
-
-  describe('readFile()', () => {
-    it('should read file content', async () => {
-      const content = 'file content here'
-      await fs.writeFile(path.join(testProjectPath, 'test.txt'), content)
-
-      const result = await analyzer.readFile('test.txt')
-
-      expect(result).toBe(content)
-    })
-
-    it('should return null for non-existent file', async () => {
-      const result = await analyzer.readFile('nonexistent.txt')
-
-      expect(result).toBeNull()
-    })
-
-    it('should read nested files', async () => {
-      await fs.mkdir(path.join(testProjectPath, 'src'), { recursive: true })
-      await fs.writeFile(path.join(testProjectPath, 'src', 'app.js'), 'console.log("test")')
-
-      const result = await analyzer.readFile('src/app.js')
-
-      expect(result).toBe('console.log("test")')
-    })
-  })
-
-  describe('getGitLog()', () => {
-    it('should return git log when git repo exists', async () => {
-      // Initialize git repo for testing
-      try {
-        const { exec } = require('child_process')
-        const { promisify } = require('util')
-        const execAsync = promisify(exec)
-
-        await execAsync('git init', { cwd: testProjectPath })
-        await execAsync('git config user.email "test@test.com"', { cwd: testProjectPath })
-        await execAsync('git config user.name "Test User"', { cwd: testProjectPath })
-        await fs.writeFile(path.join(testProjectPath, 'test.txt'), 'content')
-        await execAsync('git add test.txt', { cwd: testProjectPath })
-        await execAsync('git commit -m "Initial commit"', { cwd: testProjectPath })
-
-        const log = await analyzer.getGitLog(10)
-
-        expect(typeof log).toBe('string')
-      } catch (error) {
-        // Git might not be available, skip test
-        expect(true).toBe(true)
-      }
-    })
-
-    it('should return empty string when git repo does not exist', async () => {
-      const log = await analyzer.getGitLog()
-
-      expect(log).toBe('')
-    })
-  })
-
-  describe('getGitStats()', () => {
-    it('should return git statistics when git repo exists', async () => {
-      try {
-        const { exec } = require('child_process')
-        const { promisify } = require('util')
-        const execAsync = promisify(exec)
-
-        await execAsync('git init', { cwd: testProjectPath })
-        await execAsync('git config user.email "test@test.com"', { cwd: testProjectPath })
-        await execAsync('git config user.name "Test User"', { cwd: testProjectPath })
-        await fs.writeFile(path.join(testProjectPath, 'test.txt'), 'content')
-        await execAsync('git add test.txt', { cwd: testProjectPath })
-        await execAsync('git commit -m "Initial commit"', { cwd: testProjectPath })
-
-        const stats = await analyzer.getGitStats()
-
-        expect(stats).toBeDefined()
-        expect(stats.totalCommits).toBeGreaterThanOrEqual(0)
-        expect(stats.contributors).toBeGreaterThanOrEqual(0)
-      } catch (error) {
-        // Git might not be available, skip test
-        expect(true).toBe(true)
-      }
-    })
-
-    it('should return default stats when git repo does not exist', async () => {
-      const stats = await analyzer.getGitStats()
-
-      expect(stats).toBeDefined()
-      expect(stats.totalCommits).toBe(0)
-      expect(stats.contributors).toBe(0)
-      expect(stats.age).toBe('unknown')
-    })
-  })
-
-  describe('countFiles()', () => {
-    it('should count files in project', async () => {
-      await fs.writeFile(path.join(testProjectPath, 'file1.txt'), 'content')
-      await fs.writeFile(path.join(testProjectPath, 'file2.txt'), 'content')
-      await fs.mkdir(path.join(testProjectPath, 'src'), { recursive: true })
-      await fs.writeFile(path.join(testProjectPath, 'src', 'app.js'), 'content')
-
-      const count = await analyzer.countFiles()
-
-      expect(count).toBeGreaterThan(0)
-    })
-
-    it('should return 0 for empty directory', async () => {
-      const count = await analyzer.countFiles()
-
-      // May have some files, so just check it's a number
-      expect(typeof count).toBe('number')
-    })
-  })
-
-  describe('findFiles()', () => {
-    it('should find files matching pattern', async () => {
-      await fs.writeFile(path.join(testProjectPath, 'app.js'), 'content')
-      await fs.writeFile(path.join(testProjectPath, 'test.js'), 'content')
-      await fs.mkdir(path.join(testProjectPath, 'src'), { recursive: true })
-      await fs.writeFile(path.join(testProjectPath, 'src', 'app.js'), 'content')
-
-      const files = await analyzer.findFiles('app.js')
-
-      expect(files.length).toBeGreaterThan(0)
-      expect(files.some(f => f.includes('app.js'))).toBe(true)
-    })
-
-    it('should return empty array when no files match', async () => {
-      const files = await analyzer.findFiles('nonexistent-pattern-xyz')
-
-      expect(files).toEqual([])
-    })
-  })
-})
-

package/core/__tests__/infrastructure/author-detector.test.js

@@ -1,103 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest'
-import { createRequire } from 'module'
-
-const require = createRequire(import.meta.url)
-
-describe('Author Detector', () => {
-  let AuthorDetector
-
-  beforeEach(() => {
-    AuthorDetector = require('../../infrastructure/author-detector.js')
-  })
-
-  describe('detect()', () => {
-    it('should return author object with all fields', async () => {
-      const author = await AuthorDetector.detect()
-
-      expect(author).toBeDefined()
-      expect(author).toHaveProperty('name')
-      expect(author).toHaveProperty('email')
-      expect(author).toHaveProperty('github')
-    })
-
-    it('should have name field', async () => {
-      const author = await AuthorDetector.detect()
-
-      expect(author.name).toBeDefined()
-      expect(typeof author.name).toBe('string')
-    })
-
-    it('should use github as name fallback', async () => {
-      // This test verifies the fallback logic exists
-      // Actual behavior depends on system git config
-      const author = await AuthorDetector.detect()
-
-      if (!author.name && author.github) {
-        // Fallback should have been applied in detect()
-        expect(author.name).toBeDefined()
-      }
-    })
-
-    it('should default to Unknown if no name found', async () => {
-      // This test verifies the final fallback
-      const author = await AuthorDetector.detect()
-
-      // Should always have a name (at least 'Unknown')
-      expect(author.name).toBeDefined()
-      expect(author.name.length).toBeGreaterThan(0)
-    })
-  })
-
-  describe('detectGitHubUsername()', () => {
-    it('should attempt to detect GitHub username', async () => {
-      const username = await AuthorDetector.detectGitHubUsername()
-
-      // May return null if GitHub CLI not configured
-      expect(username === null || typeof username === 'string').toBe(true)
-    })
-  })
-
-  describe('detectGitName()', () => {
-    it('should attempt to detect git name', async () => {
-      const name = await AuthorDetector.detectGitName()
-
-      // May return null if git not configured
-      expect(name === null || typeof name === 'string').toBe(true)
-    })
-  })
-
-  describe('detectGitEmail()', () => {
-    it('should attempt to detect git email', async () => {
-      const email = await AuthorDetector.detectGitEmail()
-
-      // May return null if git not configured
-      expect(email === null || typeof email === 'string').toBe(true)
-    })
-  })
-
-  describe('execCommand()', () => {
-    it('should execute commands safely', async () => {
-      const result = await AuthorDetector.execCommand('echo "test"')
-
-      expect(result).toBeDefined()
-      expect(result).toHaveProperty('success')
-      expect(result).toHaveProperty('output')
-    })
-
-    it('should handle command failures gracefully', async () => {
-      const result = await AuthorDetector.execCommand('nonexistent-command-xyz-123')
-
-      expect(result.success).toBe(false)
-      expect(result.output).toBe('')
-    })
-
-    it('should return output for successful commands', async () => {
-      const result = await AuthorDetector.execCommand('echo "hello"')
-
-      if (result.success) {
-        expect(result.output).toContain('hello')
-      }
-    })
-  })
-})
-