popeye-cli 1.10.0 → 2.0.0

package/tests/pipeline/role-execution-adapter.test.ts

@@ -0,0 +1,299 @@
+/**
+ * Role Execution Adapter tests — context building, prompt injection, role detection.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  buildRoleExecutionContext,
+  executeWithRoleContext,
+  buildAllRoleContexts,
+} from '../../src/pipeline/role-execution-adapter.js';
+import type { RoleExecutionContext, ClaudeExecuteOptions } from '../../src/pipeline/role-execution-adapter.js';
+import type { ArtifactEntry, PipelineRole } from '../../src/pipeline/types.js';
+import { createDefaultPipelineState } from '../../src/pipeline/types.js';
+
+const TEST_DIR = join(process.cwd(), 'tmp-role-adapter-test');
+
+function makeMockSkill(role: string) {
+  return {
+    role,
+    systemPrompt: `You are ${role}. Follow best practices.`,
+    constraints: ['Stay in scope', 'Do not modify tests'],
+    tools: [],
+  };
+}
+
+function makeRolePlanArtifact(role: string): ArtifactEntry {
+  return {
+    id: `plan-${role}`,
+    type: 'role_plan',
+    phase: 'ROLE_PLANNING',
+    version: 1,
+    path: `docs/role-plans/${role}.md`,
+    sha256: 'abc123',
+    timestamp: new Date().toISOString(),
+    immutable: true,
+    content_type: 'markdown',
+    group_id: `group-${role}`,
+  };
+}
+
+beforeEach(() => {
+  mkdirSync(join(TEST_DIR, 'docs', 'role-plans'), { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(TEST_DIR)) {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+});
+
+describe('buildRoleExecutionContext', () => {
+  it('should build context with role, system prompt, and task scope', () => {
+    const planContent = [
+      '# FRONTEND_PROGRAMMER Role Plan',
+      '## Tasks',
+      '- Build login page in src/app/login/',
+      '- Implement dashboard components',
+      '## Dependencies',
+      'Requires API contracts from BACKEND_PROGRAMMER.',
+    ].join('\n');
+    const artifact = makeRolePlanArtifact('FRONTEND_PROGRAMMER');
+    writeFileSync(join(TEST_DIR, artifact.path), planContent);
+
+    const ctx = buildRoleExecutionContext(
+      'FRONTEND_PROGRAMMER',
+      makeMockSkill('FRONTEND_PROGRAMMER'),
+      artifact,
+      TEST_DIR,
+    );
+
+    expect(ctx.role).toBe('FRONTEND_PROGRAMMER');
+    expect(ctx.systemPrompt).toContain('FRONTEND_PROGRAMMER');
+    expect(ctx.systemPrompt).toContain('You are FRONTEND_PROGRAMMER');
+    expect(ctx.taskScope).toContain('Build login page');
+    expect(ctx.allowedPaths.length).toBeGreaterThan(0);
+  });
+
+  it('should include forbidden patterns for frontend role', () => {
+    const artifact = makeRolePlanArtifact('FRONTEND_PROGRAMMER');
+    writeFileSync(join(TEST_DIR, artifact.path), '# FRONTEND_PROGRAMMER Plan\n## Tasks\n- UI work');
+
+    const ctx = buildRoleExecutionContext(
+      'FRONTEND_PROGRAMMER',
+      makeMockSkill('FRONTEND_PROGRAMMER'),
+      artifact,
+      TEST_DIR,
+    );
+
+    expect(ctx.forbiddenPatterns).toContain('server/');
+    expect(ctx.forbiddenPatterns).toContain('prisma/');
+  });
+
+  it('should include forbidden patterns in system prompt', () => {
+    const artifact = makeRolePlanArtifact('FRONTEND_PROGRAMMER');
+    writeFileSync(join(TEST_DIR, artifact.path), '# FRONTEND_PROGRAMMER Plan\n## Tasks\n- UI');
+
+    const ctx = buildRoleExecutionContext(
+      'FRONTEND_PROGRAMMER',
+      makeMockSkill('FRONTEND_PROGRAMMER'),
+      artifact,
+      TEST_DIR,
+    );
+
+    expect(ctx.systemPrompt).toContain('Forbidden Paths');
+    expect(ctx.systemPrompt).toContain('server/');
+  });
+
+  it('should have no forbidden patterns for QA_TESTER', () => {
+    const artifact = makeRolePlanArtifact('QA_TESTER');
+    writeFileSync(join(TEST_DIR, artifact.path), '# QA_TESTER Plan\n## Tasks\n- Test all');
+
+    const ctx = buildRoleExecutionContext(
+      'QA_TESTER',
+      makeMockSkill('QA_TESTER'),
+      artifact,
+      TEST_DIR,
+    );
+
+    expect(ctx.forbiddenPatterns).toEqual([]);
+    expect(ctx.systemPrompt).not.toContain('Forbidden Paths');
+  });
+
+  it('should include skill constraints in system prompt', () => {
+    const artifact = makeRolePlanArtifact('BACKEND_PROGRAMMER');
+    writeFileSync(join(TEST_DIR, artifact.path), '# BACKEND_PROGRAMMER Plan\n## Tasks\n- API');
+
+    const ctx = buildRoleExecutionContext(
+      'BACKEND_PROGRAMMER',
+      makeMockSkill('BACKEND_PROGRAMMER'),
+      artifact,
+      TEST_DIR,
+    );
+
+    expect(ctx.systemPrompt).toContain('Stay in scope');
+    expect(ctx.systemPrompt).toContain('Do not modify tests');
+  });
+
+  it('should extract file paths from plan content as allowed paths', () => {
+    const planContent = [
+      '# BACKEND_PROGRAMMER Plan',
+      '## Tasks',
+      '- Implement API routes in src/api/routes.ts',
+      '- Update server/middleware.ts',
+    ].join('\n');
+    const artifact = makeRolePlanArtifact('BACKEND_PROGRAMMER');
+    writeFileSync(join(TEST_DIR, artifact.path), planContent);
+
+    const ctx = buildRoleExecutionContext(
+      'BACKEND_PROGRAMMER',
+      makeMockSkill('BACKEND_PROGRAMMER'),
+      artifact,
+      TEST_DIR,
+    );
+
+    expect(ctx.allowedPaths).toContain('src/api/routes.ts');
+    expect(ctx.allowedPaths).toContain('server/middleware.ts');
+  });
+
+  it('should handle missing plan file gracefully', () => {
+    const artifact = makeRolePlanArtifact('BACKEND_PROGRAMMER');
+    // Don't write the file
+
+    const ctx = buildRoleExecutionContext(
+      'BACKEND_PROGRAMMER',
+      makeMockSkill('BACKEND_PROGRAMMER'),
+      artifact,
+      TEST_DIR,
+    );
+
+    expect(ctx.role).toBe('BACKEND_PROGRAMMER');
+    expect(ctx.taskScope).toBe('');
+    expect(ctx.systemPrompt).toContain('BACKEND_PROGRAMMER');
+  });
+});
+
+describe('executeWithRoleContext', () => {
+  it('should inject systemPrompt into options', () => {
+    const ctx: RoleExecutionContext = {
+      role: 'FRONTEND_PROGRAMMER',
+      systemPrompt: 'You are FRONTEND_PROGRAMMER. Build the UI.',
+      allowedPaths: ['src/'],
+      forbiddenPatterns: ['server/'],
+      taskScope: 'Build login page',
+    };
+
+    const options: ClaudeExecuteOptions = {
+      projectDir: '/test/project',
+    };
+
+    const result = executeWithRoleContext(ctx, options);
+    expect(result.systemPrompt).toBe('You are FRONTEND_PROGRAMMER. Build the UI.');
+    expect(result.projectDir).toBe('/test/project');
+  });
+
+  it('should override existing systemPrompt', () => {
+    const ctx: RoleExecutionContext = {
+      role: 'BACKEND_PROGRAMMER',
+      systemPrompt: 'Role-specific prompt',
+      allowedPaths: [],
+      forbiddenPatterns: [],
+      taskScope: '',
+    };
+
+    const options: ClaudeExecuteOptions = {
+      projectDir: '/test',
+      systemPrompt: 'Old prompt',
+    };
+
+    const result = executeWithRoleContext(ctx, options);
+    expect(result.systemPrompt).toBe('Role-specific prompt');
+  });
+
+  it('should preserve other options', () => {
+    const ctx: RoleExecutionContext = {
+      role: 'QA_TESTER',
+      systemPrompt: 'Test prompt',
+      allowedPaths: [],
+      forbiddenPatterns: [],
+      taskScope: '',
+    };
+
+    const options: ClaudeExecuteOptions = {
+      projectDir: '/test',
+      customField: 'preserved',
+    };
+
+    const result = executeWithRoleContext(ctx, options);
+    expect(result.customField).toBe('preserved');
+  });
+});
+
+describe('buildAllRoleContexts', () => {
+  it('should build contexts for all detected roles', () => {
+    const pipeline = createDefaultPipelineState();
+    pipeline.activeRoles = ['FRONTEND_PROGRAMMER', 'BACKEND_PROGRAMMER'];
+
+    // Create plan files
+    const fePlan = makeRolePlanArtifact('FRONTEND_PROGRAMMER');
+    const bePlan = makeRolePlanArtifact('BACKEND_PROGRAMMER');
+    pipeline.artifacts.push(fePlan, bePlan);
+
+    writeFileSync(
+      join(TEST_DIR, fePlan.path),
+      '# FRONTEND_PROGRAMMER Role Plan\n## Tasks\n- Build UI',
+    );
+    writeFileSync(
+      join(TEST_DIR, bePlan.path),
+      '# BACKEND_PROGRAMMER Role Plan\n## Tasks\n- Build API',
+    );
+
+    const mockSkillLoader = {
+      loadSkill: (role: string) => makeMockSkill(role),
+      listSkills: () => [],
+    };
+
+    const contexts = buildAllRoleContexts(pipeline, mockSkillLoader as any, TEST_DIR);
+    expect(contexts.size).toBe(2);
+    expect(contexts.has('FRONTEND_PROGRAMMER')).toBe(true);
+    expect(contexts.has('BACKEND_PROGRAMMER')).toBe(true);
+  });
+
+  it('should skip roles with missing plan files', () => {
+    const pipeline = createDefaultPipelineState();
+    pipeline.activeRoles = ['FRONTEND_PROGRAMMER', 'BACKEND_PROGRAMMER'];
+
+    const fePlan = makeRolePlanArtifact('FRONTEND_PROGRAMMER');
+    pipeline.artifacts.push(fePlan);
+
+    // Only write FE plan, not BE
+    writeFileSync(
+      join(TEST_DIR, fePlan.path),
+      '# FRONTEND_PROGRAMMER Role Plan\n## Tasks\n- Build UI',
+    );
+
+    const mockSkillLoader = {
+      loadSkill: (role: string) => makeMockSkill(role),
+      listSkills: () => [],
+    };
+
+    const contexts = buildAllRoleContexts(pipeline, mockSkillLoader as any, TEST_DIR);
+    expect(contexts.size).toBe(1);
+    expect(contexts.has('FRONTEND_PROGRAMMER')).toBe(true);
+  });
+
+  it('should return empty map when no role plans exist', () => {
+    const pipeline = createDefaultPipelineState();
+    pipeline.activeRoles = ['FRONTEND_PROGRAMMER'];
+
+    const mockSkillLoader = {
+      loadSkill: (role: string) => makeMockSkill(role),
+      listSkills: () => [],
+    };
+
+    const contexts = buildAllRoleContexts(pipeline, mockSkillLoader as any, TEST_DIR);
+    expect(contexts.size).toBe(0);
+  });
+});

package/tests/pipeline/skill-loader.test.ts

@@ -0,0 +1,186 @@
+/**
+ * Skill Loader tests — frontmatter parsing, raw fallback, merge, caching.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  SkillLoader,
+  parseSkillMarkdown,
+  getDefaultSkill,
+  createSkillLoader,
+} from '../../src/pipeline/skill-loader.js';
+
+const TEST_DIR = join(process.cwd(), '.test-skill-loader');
+const SKILLS_DIR = join(TEST_DIR, 'skills');
+
+describe('SkillLoader', () => {
+  beforeEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+    mkdirSync(SKILLS_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+  });
+
+  describe('parseSkillMarkdown', () => {
+    it('should parse frontmatter with body', () => {
+      const md = `---
+role: ARCHITECT
+version: 2.0
+required_outputs:
+  - architecture_doc
+  - api_contracts
+constraints:
+  - no implementation details
+  - all contracts explicit
+---
+# System Prompt
+You are the Architect responsible for system design.`;
+
+      const result = parseSkillMarkdown(md);
+      expect(result.role).toBe('ARCHITECT');
+      expect(result.version).toBe('2.0');
+      expect(result.required_outputs).toEqual(['architecture_doc', 'api_contracts']);
+      expect(result.constraints).toEqual(['no implementation details', 'all contracts explicit']);
+      expect(result.systemPrompt).toContain('You are the Architect');
+    });
+
+    it('should treat entire content as systemPrompt when no frontmatter', () => {
+      const md = 'You are a specialized reviewer.\nReview all code carefully.';
+      const result = parseSkillMarkdown(md);
+
+      expect(result.systemPrompt).toBe(md);
+      expect(result.role).toBeUndefined();
+      expect(result.version).toBeUndefined();
+    });
+
+    it('should handle frontmatter with scalar values', () => {
+      const md = `---
+role: DEBUGGER
+version: 1.5
+---
+Debug the issue.`;
+
+      const result = parseSkillMarkdown(md);
+      expect(result.role).toBe('DEBUGGER');
+      expect(result.version).toBe('1.5');
+      expect(result.systemPrompt).toBe('Debug the issue.');
+    });
+
+    it('should handle empty body after frontmatter', () => {
+      const md = `---
+role: QA_TESTER
+version: 1.0
+---
+`;
+
+      const result = parseSkillMarkdown(md);
+      expect(result.role).toBe('QA_TESTER');
+      expect(result.systemPrompt).toBeUndefined();
+    });
+  });
+
+  describe('getDefaultSkill', () => {
+    it('should return a valid skill for known roles', () => {
+      const skill = getDefaultSkill('ARCHITECT');
+      expect(skill.role).toBe('ARCHITECT');
+      expect(skill.systemPrompt).toBeDefined();
+      expect(skill.systemPrompt.length).toBeGreaterThan(0);
+      expect(Array.isArray(skill.required_outputs)).toBe(true);
+      expect(Array.isArray(skill.constraints)).toBe(true);
+    });
+
+    it('should return fallback for unknown roles', () => {
+      const skill = getDefaultSkill('NONEXISTENT' as any);
+      expect(skill.role).toBe('NONEXISTENT');
+      expect(skill.systemPrompt).toContain('NONEXISTENT');
+    });
+  });
+
+  describe('SkillLoader class', () => {
+    it('should load default skills when no override exists', () => {
+      const loader = new SkillLoader(SKILLS_DIR);
+      const skill = loader.loadSkill('ARCHITECT');
+
+      expect(skill.role).toBe('ARCHITECT');
+      expect(skill.systemPrompt).toBeDefined();
+    });
+
+    it('should merge .md override with default', () => {
+      writeFileSync(join(SKILLS_DIR, 'ARCHITECT.md'), `---
+version: 3.0
+constraints:
+  - custom constraint
+---
+Custom architect prompt.`);
+
+      const loader = new SkillLoader(SKILLS_DIR);
+      const skill = loader.loadSkill('ARCHITECT');
+
+      expect(skill.role).toBe('ARCHITECT');
+      expect(skill.version).toBe('3.0');
+      expect(skill.systemPrompt).toBe('Custom architect prompt.');
+      expect(skill.constraints).toEqual(['custom constraint']);
+    });
+
+    it('should cache loaded skills', () => {
+      const loader = new SkillLoader(SKILLS_DIR);
+      const s1 = loader.loadSkill('DEBUGGER');
+      const s2 = loader.loadSkill('DEBUGGER');
+      expect(s1).toBe(s2); // Same reference = cached
+    });
+
+    it('should clear cache', () => {
+      const loader = new SkillLoader(SKILLS_DIR);
+      const s1 = loader.loadSkill('DEBUGGER');
+      loader.clearCache();
+      const s2 = loader.loadSkill('DEBUGGER');
+      expect(s1).not.toBe(s2); // Different reference after cache clear
+    });
+
+    it('should load all skills for given roles', () => {
+      const loader = new SkillLoader(SKILLS_DIR);
+      const skills = loader.loadAllSkills(['ARCHITECT', 'DEBUGGER', 'QA_TESTER']);
+
+      expect(skills.size).toBe(3);
+      expect(skills.has('ARCHITECT')).toBe(true);
+      expect(skills.has('DEBUGGER')).toBe(true);
+      expect(skills.has('QA_TESTER')).toBe(true);
+    });
+
+    it('should list available overrides', () => {
+      writeFileSync(join(SKILLS_DIR, 'ARCHITECT.md'), 'prompt');
+      writeFileSync(join(SKILLS_DIR, 'REVIEWER.md'), 'prompt');
+
+      const loader = new SkillLoader(SKILLS_DIR);
+      const overrides = loader.listAvailableOverrides();
+
+      expect(overrides).toContain('ARCHITECT');
+      expect(overrides).toContain('REVIEWER');
+    });
+
+    it('should handle no skills directory gracefully', () => {
+      const loader = new SkillLoader('/nonexistent/path');
+      const skill = loader.loadSkill('ARCHITECT');
+
+      // Falls back to default
+      expect(skill.role).toBe('ARCHITECT');
+      expect(skill.systemPrompt).toBeDefined();
+    });
+  });
+
+  describe('createSkillLoader', () => {
+    it('should create loader with skills dir', () => {
+      const loader = createSkillLoader(TEST_DIR);
+      expect(loader).toBeInstanceOf(SkillLoader);
+    });
+
+    it('should create loader without project dir', () => {
+      const loader = createSkillLoader();
+      expect(loader).toBeInstanceOf(SkillLoader);
+    });
+  });
+});

package/tests/pipeline/start-env-checks.test.ts

@@ -0,0 +1,123 @@
+/**
+ * Start & Env Checks tests — application start check,
+ * environment variable validation from .env.example.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { runStartCheck, runEnvCheck } from '../../src/pipeline/check-runner.js';
+
+const TEST_DIR = join(process.cwd(), 'tmp-start-env-test');
+
+beforeEach(() => {
+  mkdirSync(TEST_DIR, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(TEST_DIR)) {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+});
+
+describe('runStartCheck', () => {
+  it('should pass when process stays alive past timeout', async () => {
+    // 'sleep 10' will stay alive for 10s, well past our 1s timeout
+    const result = await runStartCheck('sleep 10', TEST_DIR, { timeoutMs: 1000 });
+    expect(result.check_type).toBe('start');
+    expect(result.status).toBe('pass');
+    expect(result.exit_code).toBe(0);
+  }, 10000);
+
+  it('should fail when process crashes immediately', async () => {
+    const result = await runStartCheck('exit 1', TEST_DIR, { timeoutMs: 3000 });
+    expect(result.check_type).toBe('start');
+    expect(result.status).toBe('fail');
+  }, 10000);
+
+  it('should fail for dangerous commands', async () => {
+    const result = await runStartCheck('sudo rm -rf /', TEST_DIR);
+    expect(result.status).toBe('fail');
+    expect(result.stderr_summary).toContain('rejected');
+  });
+
+  it('should return start check type', async () => {
+    const result = await runStartCheck('echo hello', TEST_DIR, { timeoutMs: 1000 });
+    expect(result.check_type).toBe('start');
+  }, 5000);
+});
+
+describe('runEnvCheck', () => {
+  it('should pass when no .env.example exists', () => {
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.check_type).toBe('env_check');
+    expect(result.status).toBe('pass');
+    expect(result.stderr_summary).toContain('No .env.example');
+  });
+
+  it('should fail when .env.example exists but .env is missing', () => {
+    writeFileSync(join(TEST_DIR, '.env.example'), 'API_KEY=\nDB_URL=');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('fail');
+    expect(result.stderr_summary).toContain('.env file not found');
+    expect(result.stderr_summary).toContain('API_KEY');
+    expect(result.stderr_summary).toContain('DB_URL');
+  });
+
+  it('should pass when all required vars are present', () => {
+    writeFileSync(join(TEST_DIR, '.env.example'), 'API_KEY=your-key\nDB_URL=postgres://');
+    writeFileSync(join(TEST_DIR, '.env'), 'API_KEY=real-key\nDB_URL=postgres://localhost/db');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('pass');
+  });
+
+  it('should fail when required vars are missing from .env', () => {
+    writeFileSync(join(TEST_DIR, '.env.example'), 'API_KEY=\nDB_URL=\nSECRET=');
+    writeFileSync(join(TEST_DIR, '.env'), 'API_KEY=real-key');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('fail');
+    expect(result.stderr_summary).toContain('Missing vars');
+    expect(result.stderr_summary).toContain('DB_URL');
+    expect(result.stderr_summary).toContain('SECRET');
+  });
+
+  it('should warn about empty vars but still pass', () => {
+    writeFileSync(join(TEST_DIR, '.env.example'), 'API_KEY=\nOPTIONAL_VAR=');
+    writeFileSync(join(TEST_DIR, '.env'), 'API_KEY=real-key\nOPTIONAL_VAR=');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('pass');
+    expect(result.stderr_summary).toContain('Empty vars');
+    expect(result.stderr_summary).toContain('OPTIONAL_VAR');
+  });
+
+  it('should skip comments in .env.example', () => {
+    writeFileSync(
+      join(TEST_DIR, '.env.example'),
+      '# Database config\nDB_URL=postgres://\n# API keys\nAPI_KEY=',
+    );
+    writeFileSync(join(TEST_DIR, '.env'), 'DB_URL=postgres://localhost\nAPI_KEY=key123');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('pass');
+  });
+
+  it('should handle quoted values in .env', () => {
+    writeFileSync(join(TEST_DIR, '.env.example'), 'SECRET=');
+    writeFileSync(join(TEST_DIR, '.env'), 'SECRET="my-secret-value"');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('pass');
+  });
+
+  it('should skip empty lines in .env.example', () => {
+    writeFileSync(join(TEST_DIR, '.env.example'), '\nAPI_KEY=\n\nDB_URL=\n\n');
+    writeFileSync(join(TEST_DIR, '.env'), 'API_KEY=key\nDB_URL=url');
+
+    const result = runEnvCheck(TEST_DIR);
+    expect(result.status).toBe('pass');
+  });
+});