prjct-cli 1.22.0 → 1.24.0

package/core/__tests__/services/dependency-validator.test.ts

@@ -1,175 +0,0 @@
-/**
- * Dependency Validator Tests
- * Tests for graceful degradation when system dependencies are missing
- *
- * @see PRJ-114
- */
-
-import { beforeEach, describe, expect, it } from 'bun:test'
-import { DependencyError, dependencyValidator, TOOLS } from '../../services/dependency-validator'
-
-describe('DependencyValidator', () => {
-  beforeEach(() => {
-    // Clear cache before each test
-    dependencyValidator.clearCache()
-  })
-
-  describe('checkTool', () => {
-    it('should return available: true for installed tools (git)', () => {
-      const result = dependencyValidator.checkTool('git')
-      expect(result.available).toBe(true)
-      expect(result.version).toBeDefined()
-    })
-
-    it('should return available: true for installed tools (node)', () => {
-      const result = dependencyValidator.checkTool('node')
-      expect(result.available).toBe(true)
-      expect(result.version).toBeDefined()
-    })
-
-    it('should return available: false for non-existent tools', () => {
-      const result = dependencyValidator.checkTool('definitely-not-a-real-tool-xyz123')
-      expect(result.available).toBe(false)
-      expect(result.error).toBeDefined()
-      expect(result.error?.message).toContain('not installed')
-    })
-
-    it('should cache results', () => {
-      const result1 = dependencyValidator.checkTool('git')
-      const result2 = dependencyValidator.checkTool('git')
-      // Same object reference means cached
-      expect(result1).toBe(result2)
-    })
-  })
-
-  describe('isAvailable', () => {
-    it('should return true for available tools', () => {
-      expect(dependencyValidator.isAvailable('git')).toBe(true)
-      expect(dependencyValidator.isAvailable('node')).toBe(true)
-    })
-
-    it('should return false for unavailable tools', () => {
-      expect(dependencyValidator.isAvailable('fake-tool-abc')).toBe(false)
-    })
-  })
-
-  describe('getVersion', () => {
-    it('should return version string for available tools', () => {
-      const version = dependencyValidator.getVersion('git')
-      expect(version).toBeDefined()
-      expect(typeof version).toBe('string')
-      // Git version is like "2.39.0" or similar
-      expect(version).toMatch(/^\d+\.\d+/)
-    })
-
-    it('should return undefined for unavailable tools', () => {
-      const version = dependencyValidator.getVersion('fake-tool-xyz')
-      expect(version).toBeUndefined()
-    })
-  })
-
-  describe('ensureTool', () => {
-    it('should not throw for available tools', () => {
-      expect(() => dependencyValidator.ensureTool('git')).not.toThrow()
-      expect(() => dependencyValidator.ensureTool('node')).not.toThrow()
-    })
-
-    it('should throw DependencyError for unavailable tools', () => {
-      expect(() => dependencyValidator.ensureTool('fake-tool-xyz')).toThrow(DependencyError)
-    })
-
-    it('should include helpful hint in error', () => {
-      try {
-        dependencyValidator.ensureTool('fake-tool-xyz')
-      } catch (error) {
-        expect(error).toBeInstanceOf(DependencyError)
-        expect((error as DependencyError).hint).toBeDefined()
-      }
-    })
-  })
-
-  describe('ensureTools', () => {
-    it('should not throw when all tools are available', () => {
-      expect(() => dependencyValidator.ensureTools(['git', 'node'])).not.toThrow()
-    })
-
-    it('should throw when any tool is unavailable', () => {
-      expect(() => dependencyValidator.ensureTools(['git', 'fake-tool-xyz'])).toThrow(
-        DependencyError
-      )
-    })
-
-    it('should list all missing tools in error', () => {
-      try {
-        dependencyValidator.ensureTools(['fake-tool-1', 'fake-tool-2'])
-      } catch (error) {
-        expect(error).toBeInstanceOf(DependencyError)
-        expect((error as DependencyError).message).toContain('fake-tool-1')
-        expect((error as DependencyError).message).toContain('fake-tool-2')
-      }
-    })
-  })
-
-  describe('checkAll', () => {
-    it('should return status for all default tools', () => {
-      const results = dependencyValidator.checkAll()
-      expect(results.size).toBeGreaterThan(0)
-      expect(results.has('git')).toBe(true)
-      expect(results.has('node')).toBe(true)
-    })
-
-    it('should return status for specified tools', () => {
-      const results = dependencyValidator.checkAll(['git', 'node'])
-      expect(results.size).toBe(2)
-      expect(results.get('git')?.available).toBe(true)
-      expect(results.get('node')?.available).toBe(true)
-    })
-  })
-
-  describe('clearCache', () => {
-    it('should clear cached results', () => {
-      const result1 = dependencyValidator.checkTool('git')
-      dependencyValidator.clearCache()
-      const result2 = dependencyValidator.checkTool('git')
-      // Different object reference after cache clear
-      expect(result1).not.toBe(result2)
-    })
-  })
-
-  describe('TOOLS definitions', () => {
-    it('should have required tools marked as required', () => {
-      expect(TOOLS.git.required).toBe(true)
-      expect(TOOLS.node.required).toBe(true)
-    })
-
-    it('should have optional tools marked as not required', () => {
-      expect(TOOLS.bun.required).toBe(false)
-      expect(TOOLS.gh.required).toBe(false)
-    })
-
-    it('should have install hints for all tools', () => {
-      for (const tool of Object.values(TOOLS)) {
-        expect(tool.installHint).toBeDefined()
-        expect(tool.installHint.length).toBeGreaterThan(0)
-      }
-    })
-  })
-
-  describe('DependencyError', () => {
-    it('should have correct name', () => {
-      const error = new DependencyError({ message: 'test' })
-      expect(error.name).toBe('DependencyError')
-    })
-
-    it('should preserve hint and docs', () => {
-      const error = new DependencyError({
-        message: 'Tool not found',
-        hint: 'Install it',
-        docs: 'https://example.com',
-      })
-      expect(error.message).toBe('Tool not found')
-      expect(error.hint).toBe('Install it')
-      expect(error.docs).toBe('https://example.com')
-    })
-  })
-})

package/core/__tests__/services/hierarchical-agent-resolver.test.ts

@@ -1,359 +0,0 @@
-/**
- * Tests for HierarchicalAgentResolver
- * PRJ-101: Hierarchical scope system
- */
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import HierarchicalAgentResolver from '../../services/hierarchical-agent-resolver'
-
-let testDir: string
-let resolver: HierarchicalAgentResolver
-
-beforeEach(async () => {
-  testDir = path.join(os.tmpdir(), `prjct-har-test-${Date.now()}`)
-  await fs.mkdir(testDir, { recursive: true })
-  resolver = new HierarchicalAgentResolver(testDir)
-})
-
-afterEach(async () => {
-  try {
-    await fs.rm(testDir, { recursive: true, force: true })
-  } catch {
-    // Ignore cleanup errors
-  }
-})
-
-// =============================================================================
-// Basic Resolution Tests
-// =============================================================================
-
-describe('HierarchicalAgentResolver - Basic', () => {
-  test('resolves agents from root AGENTS.md', async () => {
-    await fs.writeFile(
-      path.join(testDir, 'AGENTS.md'),
-      `## Backend
-
-Backend development specialist.
-
-### Triggers
-- api
-- endpoint
-- server
-
-### Rules
-- Use async/await
-- Validate inputs
-`
-    )
-
-    const result = await resolver.resolveAgentsForPath(testDir)
-
-    expect(result.agents).toHaveLength(1)
-    expect(result.agents[0].name).toBe('Backend')
-    expect(result.agents[0].description).toBe('Backend development specialist.')
-    expect(result.agents[0].triggers).toContain('api')
-    expect(result.agents[0].rules).toContain('Use async/await')
-  })
-
-  test('returns empty result when no AGENTS.md exists', async () => {
-    const result = await resolver.resolveAgentsForPath(testDir)
-
-    expect(result.agents).toHaveLength(0)
-    expect(result.discoveredFiles).toHaveLength(0)
-  })
-
-  test('tracks discovered files', async () => {
-    await fs.writeFile(path.join(testDir, 'AGENTS.md'), '## Agent\n\nTest.')
-
-    const result = await resolver.resolveAgentsForPath(testDir)
-
-    expect(result.discoveredFiles).toHaveLength(1)
-    expect(result.discoveredFiles[0]).toBe(path.join(testDir, 'AGENTS.md'))
-  })
-
-  test('resolveRootAgents uses root path', async () => {
-    await fs.writeFile(path.join(testDir, 'AGENTS.md'), '## Root\n\nRoot agent.')
-
-    const subDir = path.join(testDir, 'sub')
-    await fs.mkdir(subDir)
-    await fs.writeFile(path.join(subDir, 'AGENTS.md'), '## Sub\n\nSub agent.')
-
-    // resolveRootAgents should return root agents
-    const result = await resolver.resolveRootAgents()
-
-    // Root has only 1 agent (no inheritance from children)
-    expect(result.agents).toHaveLength(1)
-    expect(result.agents[0].name).toBe('Root')
-  })
-})
-
-// =============================================================================
-// Get Agent By Name Tests
-// =============================================================================
-
-describe('HierarchicalAgentResolver - getAgentByName', () => {
-  test('finds agent by name', async () => {
-    await fs.writeFile(
-      path.join(testDir, 'AGENTS.md'),
-      `## Frontend
-
-Frontend specialist.
-
-## Backend
-
-Backend specialist.
-`
-    )
-
-    const agent = await resolver.getAgentByName('Backend')
-
-    expect(agent).not.toBeNull()
-    expect(agent?.name).toBe('Backend')
-  })
-
-  test('returns null for non-existent agent', async () => {
-    await fs.writeFile(path.join(testDir, 'AGENTS.md'), '## Frontend\n\nFrontend.')
-
-    const agent = await resolver.getAgentByName('NonExistent')
-
-    expect(agent).toBeNull()
-  })
-
-  test('case-insensitive search', async () => {
-    await fs.writeFile(path.join(testDir, 'AGENTS.md'), '## Backend\n\nBackend.')
-
-    const agent = await resolver.getAgentByName('BACKEND')
-
-    expect(agent).not.toBeNull()
-    expect(agent?.name).toBe('Backend')
-  })
-})
-
-// =============================================================================
-// Get All Agent Names Tests
-// =============================================================================
-
-describe('HierarchicalAgentResolver - getAllAgentNames', () => {
-  test('returns all unique agent names', async () => {
-    await fs.writeFile(
-      path.join(testDir, 'AGENTS.md'),
-      `## Alpha
-
-Alpha agent.
-
-## Beta
-
-Beta agent.
-`
-    )
-
-    const names = await resolver.getAllAgentNames()
-
-    expect(names).toEqual(['Alpha', 'Beta'])
-  })
-
-  test('includes agents from nested files', async () => {
-    await fs.writeFile(path.join(testDir, 'AGENTS.md'), '## Root\n\nRoot.')
-
-    const subDir = path.join(testDir, 'sub')
-    await fs.mkdir(subDir)
-    await fs.writeFile(path.join(subDir, 'AGENTS.md'), '## Sub\n\nSub.')
-
-    const names = await resolver.getAllAgentNames()
-
-    expect(names.sort()).toEqual(['Root', 'Sub'])
-  })
-
-  test('deduplicates agent names', async () => {
-    await fs.writeFile(path.join(testDir, 'AGENTS.md'), '## Shared\n\nRoot shared.')
-
-    const subDir = path.join(testDir, 'sub')
-    await fs.mkdir(subDir)
-    await fs.writeFile(path.join(subDir, 'AGENTS.md'), '## Shared\n\nSub shared.')
-
-    const names = await resolver.getAllAgentNames()
-
-    expect(names).toEqual(['Shared'])
-  })
-})
-
-// =============================================================================
-// Agent Existence Check Tests
-// =============================================================================
-
-describe('HierarchicalAgentResolver - agentExists', () => {
-  test('returns true for existing agent', async () => {
-    await fs.writeFile(path.join(testDir, 'AGENTS.md'), '## Frontend\n\nFrontend.')
-
-    const exists = await resolver.agentExists('Frontend')
-
-    expect(exists).toBe(true)
-  })
-
-  test('returns false for non-existing agent', async () => {
-    await fs.writeFile(path.join(testDir, 'AGENTS.md'), '## Frontend\n\nFrontend.')
-
-    const exists = await resolver.agentExists('Backend')
-
-    expect(exists).toBe(false)
-  })
-
-  test('case-insensitive check', async () => {
-    await fs.writeFile(path.join(testDir, 'AGENTS.md'), '## Frontend\n\nFrontend.')
-
-    const exists = await resolver.agentExists('FRONTEND')
-
-    expect(exists).toBe(true)
-  })
-})
-
-// =============================================================================
-// Markdown Generation Tests
-// =============================================================================
-
-describe('HierarchicalAgentResolver - generateAgentMarkdown', () => {
-  test('generates markdown with all sections', async () => {
-    await fs.writeFile(
-      path.join(testDir, 'AGENTS.md'),
-      `## Backend
-
-Backend development specialist.
-
-### Domain
-backend
-
-### Triggers
-- api
-- server
-
-### Rules
-- Use TypeScript
-- Log errors
-
-### Patterns
-\`\`\`typescript
-export async function handler() {}
-\`\`\`
-`
-    )
-
-    const result = await resolver.resolveAgentsForPath(testDir)
-    const md = resolver.generateAgentMarkdown(result.agents[0])
-
-    expect(md).toContain('# Backend Agent')
-    expect(md).toContain('Backend development specialist.')
-    expect(md).toContain('## DOMAIN AUTHORITY')
-    expect(md).toContain('backend domain')
-    expect(md).toContain('## Triggers')
-    expect(md).toContain('- api')
-    expect(md).toContain('## Rules')
-    expect(md).toContain('- Use TypeScript')
-    expect(md).toContain('## Patterns')
-  })
-
-  test('includes source attribution', async () => {
-    await fs.writeFile(path.join(testDir, 'AGENTS.md'), '## Agent\n\nTest agent.')
-
-    const result = await resolver.resolveAgentsForPath(testDir)
-    const md = resolver.generateAgentMarkdown(result.agents[0])
-
-    expect(md).toContain('*Resolved from:')
-    expect(md).toContain('AGENTS.md')
-  })
-})
-
-// =============================================================================
-// Hierarchical Resolution Tests
-// =============================================================================
-
-describe('HierarchicalAgentResolver - Hierarchy', () => {
-  test('merges triggers from parent and child', async () => {
-    await fs.writeFile(
-      path.join(testDir, 'AGENTS.md'),
-      `## Shared
-
-Base agent.
-
-### Triggers
-- root-trigger
-`
-    )
-
-    const childDir = path.join(testDir, 'child')
-    await fs.mkdir(childDir)
-    await fs.writeFile(
-      path.join(childDir, 'AGENTS.md'),
-      `## Shared
-
-Extended agent.
-
-### Triggers
-- child-trigger
-`
-    )
-
-    const result = await resolver.resolveAgentsForPath(childDir)
-
-    expect(result.agents[0].triggers).toContain('root-trigger')
-    expect(result.agents[0].triggers).toContain('child-trigger')
-  })
-
-  test('tracks overridden agents', async () => {
-    await fs.writeFile(path.join(testDir, 'AGENTS.md'), '## Agent\n\nRoot.')
-
-    const childDir = path.join(testDir, 'child')
-    await fs.mkdir(childDir)
-    await fs.writeFile(path.join(childDir, 'AGENTS.md'), '## Agent @override\n\nChild override.')
-
-    const result = await resolver.resolveAgentsForPath(childDir)
-
-    expect(result.overriddenAgents).toContain('Agent')
-    expect(result.agents[0].wasOverridden).toBe(true)
-  })
-
-  test('path-specific resolution', async () => {
-    await fs.writeFile(path.join(testDir, 'AGENTS.md'), '## Global\n\nGlobal.')
-
-    const apiDir = path.join(testDir, 'packages', 'api')
-    await fs.mkdir(apiDir, { recursive: true })
-    await fs.writeFile(path.join(apiDir, 'AGENTS.md'), '## API\n\nAPI specific.')
-
-    const webDir = path.join(testDir, 'packages', 'web')
-    await fs.mkdir(webDir, { recursive: true })
-    await fs.writeFile(path.join(webDir, 'AGENTS.md'), '## Web\n\nWeb specific.')
-
-    // Resolve for API path
-    const apiResult = await resolver.resolveAgentsForPath(apiDir)
-    expect(apiResult.agents.map((a) => a.name).sort()).toEqual(['API', 'Global'])
-
-    // Resolve for Web path
-    const webResult = await resolver.resolveAgentsForPath(webDir)
-    expect(webResult.agents.map((a) => a.name).sort()).toEqual(['Global', 'Web'])
-  })
-})
-
-// =============================================================================
-// Agent File Tree Tests
-// =============================================================================
-
-describe('HierarchicalAgentResolver - getAgentFileTree', () => {
-  test('returns hierarchical tree structure', async () => {
-    await fs.writeFile(path.join(testDir, 'AGENTS.md'), '## Root\n\nRoot.')
-
-    const childDir = path.join(testDir, 'child')
-    await fs.mkdir(childDir)
-    await fs.writeFile(path.join(childDir, 'AGENTS.md'), '## Child\n\nChild.')
-
-    const tree = await resolver.getAgentFileTree()
-
-    expect(tree).toHaveLength(2)
-    const root = tree.find((n) => n.depth === 0)
-    const child = tree.find((n) => n.depth > 0)
-
-    expect(root?.children).toContain(child)
-    expect(child?.parent).toBe(root)
-  })
-})