popeye-cli 1.9.5 → 2.0.0

package/src/pipeline/command-resolver.ts

@@ -0,0 +1,168 @@
+/**
+ * Command Resolver — detects project-type-specific build/test/lint/typecheck
+ * commands from a RepoSnapshot. Used by CheckRunner and ProductionGate.
+ */
+
+import type { RepoSnapshot, ResolvedCommands } from './types.js';
+
+// ─── Project Type Detection ──────────────────────────────
+
+export type ProjectType = 'node' | 'python' | 'mixed' | 'unknown';
+
+export function detectProjectType(snapshot: RepoSnapshot): ProjectType {
+  const hasNode = snapshot.config_files.some((c) => c.type === 'package.json');
+  const hasPython = snapshot.config_files.some(
+    (c) => c.type === 'pyproject.toml' || c.type === 'requirements.txt' || c.type === 'setup.py',
+  );
+
+  if (hasNode && hasPython) return 'mixed';
+  if (hasNode) return 'node';
+  if (hasPython) return 'python';
+  return 'unknown';
+}
+
+// ─── Command Resolution ──────────────────────────────────
+
+export function resolveCommands(
+  snapshot: RepoSnapshot,
+  overrides?: Partial<ResolvedCommands>,
+): ResolvedCommands {
+  const projectType = detectProjectType(snapshot);
+  const pm = snapshot.package_manager ?? 'npm';
+  const scripts = snapshot.scripts;
+
+  let resolved: ResolvedCommands;
+
+  switch (projectType) {
+    case 'node':
+      resolved = resolveNodeCommands(pm, scripts, snapshot);
+      break;
+    case 'python':
+      resolved = resolvePythonCommands(snapshot);
+      break;
+    case 'mixed':
+      // Prefer Node commands, augment with Python where Node is missing
+      resolved = resolveNodeCommands(pm, scripts, snapshot);
+      if (!resolved.test) {
+        const pyResolved = resolvePythonCommands(snapshot);
+        resolved.test = pyResolved.test;
+      }
+      break;
+    default:
+      resolved = { resolved_from: 'none' };
+  }
+
+  // Apply overrides
+  if (overrides) {
+    if (overrides.build) resolved.build = overrides.build;
+    if (overrides.test) resolved.test = overrides.test;
+    if (overrides.lint) resolved.lint = overrides.lint;
+    if (overrides.typecheck) resolved.typecheck = overrides.typecheck;
+    if (overrides.migrations) resolved.migrations = overrides.migrations;
+    if (overrides.start) resolved.start = overrides.start;
+  }
+
+  return resolved;
+}
+
+// ─── Node Resolution ─────────────────────────────────────
+
+function resolveNodeCommands(
+  pm: string,
+  scripts: Record<string, string>,
+  snapshot: RepoSnapshot,
+): ResolvedCommands {
+  const run = pm === 'yarn' ? 'yarn' : pm === 'pnpm' ? 'pnpm' : `${pm} run`;
+  const npx = pm === 'pnpm' ? 'pnpm exec' : pm === 'yarn' ? 'yarn' : 'npx';
+
+  const resolved: ResolvedCommands = {
+    resolved_from: 'package.json',
+  };
+
+  // Build
+  if (scripts.build) {
+    resolved.build = `${run} build`;
+  }
+
+  // Test
+  if (scripts.test) {
+    resolved.test = `${run} test`;
+  } else if (snapshot.test_framework === 'vitest') {
+    resolved.test = `${npx} vitest run`;
+  } else if (snapshot.test_framework === 'jest') {
+    resolved.test = `${npx} jest`;
+  }
+
+  // Lint
+  if (scripts.lint) {
+    resolved.lint = `${run} lint`;
+  }
+
+  // Typecheck
+  if (scripts.typecheck) {
+    resolved.typecheck = `${run} typecheck`;
+  } else if (snapshot.languages_detected.includes('typescript')) {
+    resolved.typecheck = `${npx} tsc --noEmit`;
+  }
+
+  // Migrations
+  const hasPrisma = snapshot.config_files.some(
+    (c) => c.type === 'prisma/schema.prisma',
+  );
+  if (hasPrisma) {
+    resolved.migrations = `${npx} prisma migrate deploy`;
+  }
+
+  // Start
+  if (scripts.start) {
+    resolved.start = `${run} start`;
+  } else if (scripts.dev) {
+    resolved.start = `${run} dev`;
+  }
+
+  return resolved;
+}
+
+// ─── Python Resolution ───────────────────────────────────
+
+function resolvePythonCommands(snapshot: RepoSnapshot): ResolvedCommands {
+  const resolved: ResolvedCommands = {
+    resolved_from: snapshot.config_files
+      .find((c) => c.type === 'pyproject.toml' || c.type === 'requirements.txt')
+      ?.path ?? 'python-defaults',
+  };
+
+  // Test
+  if (snapshot.test_framework === 'pytest') {
+    resolved.test = 'pytest tests/';
+  } else {
+    resolved.test = 'pytest tests/';  // default for Python
+  }
+
+  // Lint
+  const hasPyproject = snapshot.config_files.some((c) => c.type === 'pyproject.toml');
+  if (hasPyproject) {
+    resolved.lint = 'ruff check .';
+  } else {
+    resolved.lint = 'flake8 src/';
+  }
+
+  // Typecheck
+  if (snapshot.languages_detected.includes('python')) {
+    resolved.typecheck = 'mypy src/';
+  }
+
+  // Build
+  resolved.build = 'python -m build';
+
+  // Migrations
+  const hasAlembic = snapshot.config_files.some((c) => c.type === 'alembic.ini');
+  if (hasAlembic) {
+    resolved.migrations = 'alembic upgrade head';
+  }
+
+  // Start
+  resolved.start = 'uvicorn main:app --host 0.0.0.0 --port 8000';
+
+  return resolved;
+}

package/src/pipeline/consensus/consensus-runner.ts

@@ -0,0 +1,317 @@
+/**
+ * Consensus Runner — adapter layer between structured packets
+ * and existing consensus machinery.
+ *
+ * Two modes (P1-D):
+ * 1. Independent Review (DEFAULT): N reviewers review simultaneously,
+ *    no reviewer sees other reviewers' output.
+ * 2. Iterative Consensus (optional): for recovery plan iteration.
+ */
+
+import { createHash } from 'node:crypto';
+
+import type {
+  PlanPacket,
+  ConsensusPacket,
+  ReviewerVote,
+} from '../types.js';
+import type { GateDefinition } from '../gate-engine.js';
+import { buildConsensusPacket } from '../packets/consensus-packet-builder.js';
+import type { ConsensusRules } from '../packets/consensus-packet-builder.js';
+
+// Re-use existing consensus infrastructure
+import { iterateUntilConsensus } from '../../workflow/consensus.js';
+import type { ConsensusConfig, ConsensusResult } from '../../types/consensus.js';
+
+// ─── Types ───────────────────────────────────────────────
+
+export interface ConsensusRunnerConfig {
+  mode: 'independent' | 'iterative';
+  minReviewers: number;
+  threshold: number;
+  quorum: number;
+  projectDir: string;
+  consensusConfig?: Partial<ConsensusConfig>;
+  /** Provider configurations for multi-LLM review */
+  reviewerProviders?: ReviewerProviderConfig[];
+}
+
+export interface ReviewerProviderConfig {
+  provider: string;   // 'openai' | 'gemini' | 'grok'
+  model: string;
+  temperature: number;
+}
+
+const DEFAULT_PROVIDERS: ReviewerProviderConfig[] = [
+  { provider: 'openai', model: 'gpt-4o', temperature: 0.3 },
+  { provider: 'gemini', model: 'gemini-2.0-flash', temperature: 0.3 },
+];
+
+// ─── Consensus Runner ────────────────────────────────────
+
+export class ConsensusRunner {
+  private readonly config: ConsensusRunnerConfig;
+
+  constructor(config: ConsensusRunnerConfig) {
+    this.config = config;
+  }
+
+  /** Run structured consensus on a plan packet */
+  async runStructuredConsensus(
+    planPacket: PlanPacket,
+    gateDefinition: GateDefinition,
+  ): Promise<ConsensusPacket> {
+    const rules: ConsensusRules = {
+      threshold: gateDefinition.consensusThreshold ?? this.config.threshold,
+      quorum: this.config.quorum,
+      min_reviewers: gateDefinition.minReviewers ?? this.config.minReviewers,
+    };
+
+    let votes: ReviewerVote[];
+
+    if (this.config.mode === 'independent') {
+      votes = await this.runIndependentReview(planPacket);
+    } else {
+      votes = await this.runIterativeReview(planPacket);
+    }
+
+    // Build consensus packet from votes
+    const packet = buildConsensusPacket({
+      planPacketRef: {
+        artifact_id: planPacket.metadata.packet_id,
+        path: '',
+        sha256: '',
+        version: planPacket.metadata.version,
+        type: 'consensus',
+      },
+      votes,
+      rules,
+    });
+
+    return packet;
+  }
+
+  /** Independent review: spawn N reviewers, each reviews independently */
+  async runIndependentReview(planPacket: PlanPacket): Promise<ReviewerVote[]> {
+    const providers = this.config.reviewerProviders ?? DEFAULT_PROVIDERS;
+    const numReviewers = Math.max(
+      this.config.minReviewers,
+      providers.length,
+    );
+
+    // Build the review prompt from the plan packet
+    const prompt = buildReviewPrompt(planPacket);
+    const promptHash = createHash('sha256').update(prompt).digest('hex');
+
+    // Spawn reviewers in parallel
+    const reviewPromises: Promise<ReviewerVote>[] = [];
+    for (let i = 0; i < numReviewers; i++) {
+      const provider = providers[i % providers.length];
+      reviewPromises.push(
+        this.spawnSingleReviewer(
+          prompt,
+          promptHash,
+          provider,
+          `reviewer-${provider.provider}-${i}`,
+        ),
+      );
+    }
+
+    return Promise.all(reviewPromises);
+  }
+
+  /** Iterative review: wraps existing iterateUntilConsensus */
+  async runIterativeReview(planPacket: PlanPacket): Promise<ReviewerVote[]> {
+    const prompt = buildReviewPrompt(planPacket);
+
+    try {
+      const result = await iterateUntilConsensus(
+        prompt,
+        `Phase: ${planPacket.metadata.phase}`,
+        {
+          projectDir: this.config.projectDir,
+          config: this.config.consensusConfig,
+        },
+      );
+
+      // Convert legacy result to ReviewerVote format
+      const vote: ReviewerVote = {
+        reviewer_id: 'iterative-reviewer',
+        provider: 'openai',
+        model: this.config.consensusConfig?.openaiModel ?? 'gpt-4o',
+        temperature: this.config.consensusConfig?.temperature ?? 0.3,
+        prompt_hash: createHash('sha256').update(prompt).digest('hex'),
+        vote: result.approved ? 'APPROVE' : 'REJECT',
+        confidence: result.finalScore ?? 0.5,
+        blocking_issues: result.finalConcerns ?? [],
+        suggestions: result.finalRecommendations ?? [],
+        evidence_refs: [],
+      };
+
+      return [vote];
+    } catch {
+      return [{
+        reviewer_id: 'iterative-reviewer-error',
+        provider: 'openai',
+        model: 'unknown',
+        temperature: 0,
+        prompt_hash: '',
+        vote: 'REJECT',
+        confidence: 0,
+        blocking_issues: ['Iterative consensus failed'],
+        suggestions: [],
+        evidence_refs: [],
+      }];
+    }
+  }
+
+  /** Spawn a single independent reviewer */
+  private async spawnSingleReviewer(
+    prompt: string,
+    promptHash: string,
+    provider: ReviewerProviderConfig,
+    reviewerId: string,
+  ): Promise<ReviewerVote> {
+    try {
+      const result = await this.callProviderForReview(prompt, provider);
+
+      return {
+        reviewer_id: reviewerId,
+        provider: provider.provider,
+        model: provider.model,
+        temperature: provider.temperature,
+        prompt_hash: promptHash,
+        vote: result.approved ? 'APPROVE' : 'REJECT',
+        confidence: result.confidence,
+        blocking_issues: result.blockingIssues,
+        suggestions: result.suggestions,
+        evidence_refs: [],
+      };
+    } catch {
+      return {
+        reviewer_id: reviewerId,
+        provider: provider.provider,
+        model: provider.model,
+        temperature: provider.temperature,
+        prompt_hash: promptHash,
+        vote: 'REJECT',
+        confidence: 0,
+        blocking_issues: [`Review failed for ${provider.provider}`],
+        suggestions: [],
+        evidence_refs: [],
+      };
+    }
+  }
+
+  /** Call the appropriate provider adapter for a review */
+  private async callProviderForReview(
+    prompt: string,
+    provider: ReviewerProviderConfig,
+  ): Promise<ProviderReviewResult> {
+    switch (provider.provider) {
+      case 'openai': {
+        const { requestConsensus } = await import('../../adapters/openai.js');
+        const result = await requestConsensus(prompt, '', {
+          openaiModel: provider.model,
+          temperature: provider.temperature,
+        } as Partial<ConsensusConfig>);
+        return parseConsensusResult(result);
+      }
+      case 'gemini': {
+        const { requestConsensus } = await import('../../adapters/gemini.js');
+        const result = await requestConsensus(prompt, '', {
+          model: provider.model as never,
+          temperature: provider.temperature,
+        });
+        return parseConsensusResult(result);
+      }
+      case 'grok': {
+        const { requestConsensus } = await import('../../adapters/grok.js');
+        const result = await requestConsensus(prompt, '', {
+          model: provider.model,
+          temperature: provider.temperature,
+        });
+        return parseConsensusResult(result);
+      }
+      default:
+        throw new Error(`Unknown provider: ${provider.provider}`);
+    }
+  }
+}
+
+// ─── Helper Types ────────────────────────────────────────
+
+interface ProviderReviewResult {
+  approved: boolean;
+  confidence: number;
+  blockingIssues: string[];
+  suggestions: string[];
+}
+
+function parseConsensusResult(result: ConsensusResult): ProviderReviewResult {
+  return {
+    approved: result.approved,
+    confidence: result.score / 100, // score is 0-100, confidence is 0-1
+    blockingIssues: result.concerns ?? [],
+    suggestions: result.recommendations ?? [],
+  };
+}
+
+// ─── Prompt Builder ──────────────────────────────────────
+
+export function buildReviewPrompt(planPacket: PlanPacket): string {
+  const lines: string[] = [
+    `# Independent Plan Review`,
+    ``,
+    `## Phase: ${planPacket.metadata.phase}`,
+    `## Submitted by: ${planPacket.metadata.submitted_by}`,
+    `## Version: ${planPacket.metadata.version}`,
+    ``,
+    `## Acceptance Criteria`,
+    ...planPacket.acceptance_criteria.map((c) => `- ${c}`),
+    ``,
+    `## Constraints`,
+    ...planPacket.constraints.map((c) => `- [${c.type}] ${c.description}`),
+    ``,
+  ];
+
+  if (planPacket.open_questions?.length) {
+    lines.push(`## Open Questions`);
+    lines.push(...planPacket.open_questions.map((q) => `- ${q}`));
+    lines.push('');
+  }
+
+  lines.push(
+    `## Review Instructions`,
+    ``,
+    `You are an independent reviewer. Evaluate this plan for:`,
+    `1. Completeness — are all required artifacts defined?`,
+    `2. Consistency — do acceptance criteria match constraints?`,
+    `3. Feasibility — can this be implemented as described?`,
+    `4. Constitution compliance — does it follow governance rules?`,
+    ``,
+    `Respond with:`,
+    `- APPROVE, REJECT, or CONDITIONAL`,
+    `- Confidence score (0-1)`,
+    `- Blocking issues (if any)`,
+    `- Suggestions for improvement`,
+  );
+
+  return lines.join('\n');
+}
+
+// ─── Factory ─────────────────────────────────────────────
+
+export function createConsensusRunner(
+  projectDir: string,
+  consensusConfig?: Partial<ConsensusConfig>,
+): ConsensusRunner {
+  return new ConsensusRunner({
+    mode: 'independent',
+    minReviewers: 2,
+    threshold: 0.95,
+    quorum: 2,
+    projectDir,
+    consensusConfig,
+  });
+}

package/src/pipeline/constitution.ts

@@ -0,0 +1,109 @@
+/**
+ * Constitution management — artifact creation, hashing, and verification.
+ * The constitution (skills/POPEYE_CONSTITUTION.md) is the immutable governance
+ * document for the pipeline. This module ensures it is tracked as an artifact
+ * and its integrity is verified at every gate.
+ */
+
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import type { ArtifactEntry, PipelineState } from './types.js';
+import type { ArtifactManager } from './artifact-manager.js';
+
+// ─── Constants ───────────────────────────────────────────
+
+const CONSTITUTION_FILENAME = 'POPEYE_CONSTITUTION.md';
+const SKILLS_DIR = 'skills';
+
+// ─── Hash Computation ────────────────────────────────────
+
+/**
+ * Compute SHA-256 hash of constitution file content.
+ *
+ * Args:
+ *   projectDir: Root project directory containing skills/ folder.
+ *
+ * Returns:
+ *   Hex-encoded SHA-256 hash, or empty string if file not found.
+ */
+export function computeConstitutionHash(projectDir: string): string {
+  const constitutionPath = join(projectDir, SKILLS_DIR, CONSTITUTION_FILENAME);
+  if (!existsSync(constitutionPath)) {
+    return '';
+  }
+
+  const content = readFileSync(constitutionPath, 'utf-8');
+  return createHash('sha256').update(content, 'utf-8').digest('hex');
+}
+
+// ─── Artifact Creation ───────────────────────────────────
+
+/**
+ * Create a constitution artifact from the skills/POPEYE_CONSTITUTION.md file.
+ *
+ * Args:
+ *   projectDir: Root project directory.
+ *   artifactManager: The artifact manager instance.
+ *
+ * Returns:
+ *   The created ArtifactEntry, or null if constitution file not found.
+ */
+export function createConstitutionArtifact(
+  projectDir: string,
+  artifactManager: ArtifactManager,
+): ArtifactEntry | null {
+  const constitutionPath = join(projectDir, SKILLS_DIR, CONSTITUTION_FILENAME);
+  if (!existsSync(constitutionPath)) {
+    return null;
+  }
+
+  const content = readFileSync(constitutionPath, 'utf-8');
+  return artifactManager.createAndStoreText(
+    'constitution',
+    content,
+    'INTAKE',
+  );
+}
+
+// ─── Verification ────────────────────────────────────────
+
+/**
+ * Verify the constitution file has not been modified since pipeline start.
+ * Compares current file hash against the hash stored in pipeline state.
+ *
+ * Args:
+ *   pipeline: Current pipeline state (contains constitutionHash).
+ *   projectDir: Root project directory.
+ *
+ * Returns:
+ *   Object with valid=true if hash matches, or valid=false with reason.
+ */
+export function verifyConstitution(
+  pipeline: PipelineState,
+  projectDir: string,
+): { valid: boolean; reason?: string } {
+  // If no hash stored yet (pre-INTAKE), skip verification
+  if (!pipeline.constitutionHash) {
+    return { valid: true };
+  }
+
+  const currentHash = computeConstitutionHash(projectDir);
+
+  if (!currentHash) {
+    return {
+      valid: false,
+      reason: 'Constitution file not found — may have been deleted',
+    };
+  }
+
+  if (currentHash !== pipeline.constitutionHash) {
+    return {
+      valid: false,
+      reason: 'Constitution has been modified since pipeline start',
+    };
+  }
+
+  return { valid: true };
+}