popeye-cli 1.0.0

package/src/types/cli.ts

@@ -0,0 +1,146 @@
+/**
+ * CLI-related type definitions
+ * Defines command options, interactive mode state, and output formats
+ */
+
+import type { OutputLanguage, OpenAIModel } from './project.js';
+
+/**
+ * Global CLI options available on all commands
+ */
+export interface GlobalOptions {
+  verbose: boolean;
+  quiet: boolean;
+  noColor: boolean;
+}
+
+/**
+ * Options for the `create` command
+ */
+export interface CreateOptions extends GlobalOptions {
+  language: OutputLanguage;
+  openaiModel: OpenAIModel;
+  output?: string;
+  name?: string;
+}
+
+/**
+ * Options for the `resume` command
+ */
+export interface ResumeOptions extends GlobalOptions {
+  projectPath: string;
+}
+
+/**
+ * Options for the `status` command
+ */
+export interface StatusOptions extends GlobalOptions {
+  projectPath?: string;
+  json: boolean;
+}
+
+/**
+ * Options for the `auth` command
+ */
+export interface AuthOptions extends GlobalOptions {
+  service?: 'claude' | 'openai' | 'all';
+}
+
+/**
+ * Options for the `config` command
+ */
+export interface ConfigOptions extends GlobalOptions {
+  global: boolean;
+}
+
+/**
+ * Authentication status for display
+ */
+export interface AuthStatus {
+  claude: {
+    authenticated: boolean;
+    user?: string;
+    expires?: string;
+  };
+  openai: {
+    authenticated: boolean;
+    keyLastFour?: string;
+    modelAccess?: string[];
+  };
+}
+
+/**
+ * Interactive mode session state
+ */
+export interface InteractiveSession {
+  connected: boolean;
+  language: OutputLanguage;
+  openaiModel: OpenAIModel;
+  currentProject?: string;
+  history: string[];
+}
+
+/**
+ * Slash command definition for interactive mode
+ */
+export interface SlashCommand {
+  name: string;
+  aliases: string[];
+  description: string;
+  usage: string;
+  handler: (args: string[], session: InteractiveSession) => Promise<void>;
+}
+
+/**
+ * Progress display information
+ */
+export interface ProgressInfo {
+  phase: string;
+  milestone?: number;
+  totalMilestones?: number;
+  task?: number;
+  totalTasks?: number;
+  consensusIteration?: number;
+  consensusScore?: number;
+  status: 'pending' | 'running' | 'success' | 'error';
+  message: string;
+}
+
+/**
+ * Console output styles/colors
+ */
+export interface OutputStyles {
+  primary: string;
+  secondary: string;
+  success: string;
+  warning: string;
+  error: string;
+  info: string;
+  dim: string;
+  bold: string;
+}
+
+/**
+ * Banner configuration
+ */
+export interface BannerConfig {
+  version: string;
+  language: OutputLanguage;
+  openaiModel: OpenAIModel;
+  sessionId?: string;
+}
+
+/**
+ * CLI exit codes
+ */
+export const EXIT_CODES = {
+  SUCCESS: 0,
+  ERROR: 1,
+  AUTH_REQUIRED: 2,
+  INVALID_INPUT: 3,
+  CONSENSUS_FAILED: 4,
+  TEST_FAILED: 5,
+  INTERRUPTED: 130,
+} as const;
+
+export type ExitCode = (typeof EXIT_CODES)[keyof typeof EXIT_CODES];

package/src/types/consensus.ts

@@ -0,0 +1,116 @@
+/**
+ * Consensus-related type definitions
+ * Defines consensus results, iterations, and configuration
+ */
+
+import { z } from 'zod';
+import type { OpenAIModel } from './project.js';
+
+/**
+ * Result of a consensus review from OpenAI
+ */
+export interface ConsensusResult {
+  score: number;
+  analysis: string;
+  strengths: string[];
+  concerns: string[];
+  recommendations: string[];
+  approved: boolean;
+  rawResponse: string;
+}
+
+/**
+ * Single consensus iteration record
+ */
+export interface ConsensusIteration {
+  iteration: number;
+  plan: string;
+  result: ConsensusResult;
+  timestamp: string;
+}
+
+/**
+ * Configuration for consensus process
+ */
+export interface ConsensusConfig {
+  threshold: number;
+  maxIterations: number;
+  openaiKey: string;
+  openaiModel: OpenAIModel;
+  escalationAction: 'pause' | 'continue' | 'abort';
+  temperature: number;
+  maxTokens: number;
+}
+
+/**
+ * Default consensus configuration
+ */
+export const DEFAULT_CONSENSUS_CONFIG: Omit<ConsensusConfig, 'openaiKey'> = {
+  threshold: 95,
+  maxIterations: 5,
+  openaiModel: 'gpt-4o',
+  escalationAction: 'pause',
+  temperature: 0.3,
+  maxTokens: 4096,
+};
+
+/**
+ * Zod schema for consensus config validation
+ */
+export const ConsensusConfigSchema = z.object({
+  threshold: z.number().min(0).max(100).default(95),
+  maxIterations: z.number().min(1).max(10).default(5),
+  openaiKey: z.string().min(1),
+  openaiModel: z.enum(['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini']),
+  escalationAction: z.enum(['pause', 'continue', 'abort']).default('pause'),
+  temperature: z.number().min(0).max(2).default(0.3),
+  maxTokens: z.number().min(100).max(32000).default(4096),
+});
+
+/**
+ * Plan document structure for consensus review
+ */
+export interface PlanDocument {
+  milestone: number;
+  title: string;
+  background: string;
+  goals: string[];
+  useCases: string[];
+  risks: string[];
+  tasks: {
+    id: string;
+    description: string;
+    acceptanceCriteria: string[];
+    dependencies: string[];
+  }[];
+  testPlan: {
+    id: string;
+    type: 'unit' | 'integration' | 'e2e';
+    description: string;
+    setup: string;
+    steps: string[];
+    expectedResult: string;
+  }[];
+  summary: string;
+}
+
+/**
+ * Consensus request payload
+ */
+export interface ConsensusRequest {
+  plan: string;
+  context: string;
+  previousFeedback?: string;
+  iteration: number;
+}
+
+/**
+ * Escalation details when consensus cannot be reached
+ */
+export interface EscalationDetails {
+  reason: string;
+  iterations: ConsensusIteration[];
+  lastScore: number;
+  unresolvable_concerns: string[];
+  suggestedActions: string[];
+}

package/src/types/index.ts

@@ -0,0 +1,64 @@
+/**
+ * Central type exports for Popeye CLI
+ * Re-exports all types from subdirectories for easy importing
+ */
+
+// Project types
+export {
+  OutputLanguageSchema,
+  OpenAIModelSchema,
+  ProjectSpecSchema,
+  OPENAI_MODELS,
+  type OutputLanguage,
+  type OpenAIModel,
+  type ProjectSpec,
+  type GeneratedProject,
+  type GenerationOptions,
+} from './project.js';
+
+// Workflow types
+export {
+  WorkflowPhaseSchema,
+  TaskStatusSchema,
+  ProjectStateSchema,
+  ProjectStatusSchema,
+  TaskSchema,
+  MilestoneSchema,
+  type WorkflowPhase,
+  type ProjectStatus,
+  type TaskStatus,
+  type Task,
+  type Milestone,
+  type ProjectState,
+  type WorkflowEvent,
+} from './workflow.js';
+
+// Consensus types
+export {
+  ConsensusConfigSchema,
+  DEFAULT_CONSENSUS_CONFIG,
+  type ConsensusResult,
+  type ConsensusIteration,
+  type ConsensusConfig,
+  type PlanDocument,
+  type ConsensusRequest,
+  type EscalationDetails,
+} from './consensus.js';
+
+// CLI types
+export {
+  EXIT_CODES,
+  type GlobalOptions,
+  type CreateOptions,
+  type ResumeOptions,
+  type StatusOptions,
+  type AuthOptions,
+  type ConfigOptions,
+  type AuthStatus,
+  type InteractiveSession,
+  type SlashCommand,
+  type ProgressInfo,
+  type OutputStyles,
+  type BannerConfig,
+  type ExitCode,
+} from './cli.js';

package/src/types/project.ts

@@ -0,0 +1,85 @@
+/**
+ * Project-related type definitions
+ * Defines output languages, models, and project specifications
+ */
+
+import { z } from 'zod';
+
+/**
+ * Supported output languages for generated projects
+ */
+export const OutputLanguageSchema = z.enum(['python', 'typescript']);
+export type OutputLanguage = z.infer<typeof OutputLanguageSchema>;
+
+/**
+ * Supported OpenAI models for consensus reviews
+ */
+export const OpenAIModelSchema = z.enum([
+  'gpt-4o',
+  'gpt-4o-mini',
+  'gpt-4-turbo',
+  'o1-preview',
+  'o1-mini',
+]);
+export type OpenAIModel = z.infer<typeof OpenAIModelSchema>;
+
+/**
+ * Project specification provided by user
+ */
+export const ProjectSpecSchema = z.object({
+  idea: z.string().min(10, 'Idea must be at least 10 characters'),
+  name: z.string().optional(),
+  language: OutputLanguageSchema,
+  openaiModel: OpenAIModelSchema,
+  outputDir: z.string().optional(),
+});
+export type ProjectSpec = z.infer<typeof ProjectSpecSchema>;
+
+/**
+ * Generated project information
+ */
+export interface GeneratedProject {
+  name: string;
+  path: string;
+  language: OutputLanguage;
+  files: string[];
+  testsPath: string;
+  dockerComposePath: string;
+}
+
+/**
+ * Project generation options
+ */
+export interface GenerationOptions {
+  includeDocker: boolean;
+  includeTests: boolean;
+  includeDocs: boolean;
+  packageManager: 'pip' | 'poetry' | 'npm' | 'pnpm';
+  testFramework: 'pytest' | 'jest' | 'vitest';
+}
+
+/**
+ * Available OpenAI models with descriptions
+ */
+export const OPENAI_MODELS: Record<OpenAIModel, { description: string; recommended: string }> = {
+  'gpt-4o': {
+    description: 'Most capable, best reasoning',
+    recommended: 'Complex projects',
+  },
+  'gpt-4o-mini': {
+    description: 'Fast, cost-effective',
+    recommended: 'Simple projects',
+  },
+  'gpt-4-turbo': {
+    description: 'High capability, faster',
+    recommended: 'Medium complexity',
+  },
+  'o1-preview': {
+    description: 'Advanced reasoning',
+    recommended: 'Architectural decisions',
+  },
+  'o1-mini': {
+    description: 'Efficient reasoning',
+    recommended: 'Code review',
+  },
+};

package/src/types/workflow.ts

@@ -0,0 +1,149 @@
+/**
+ * Workflow-related type definitions
+ * Defines workflow modes, tasks, milestones, and state transitions
+ */
+
+import { z } from 'zod';
+import type { OutputLanguage, OpenAIModel } from './project.js';
+import type { ConsensusIteration } from './consensus.js';
+
+/**
+ * Workflow phases
+ */
+export const WorkflowPhaseSchema = z.enum(['plan', 'execution', 'complete']);
+export type WorkflowPhase = z.infer<typeof WorkflowPhaseSchema>;
+
+/**
+ * Project status
+ */
+export const ProjectStatusSchema = z.enum(['pending', 'in-progress', 'complete', 'failed']);
+export type ProjectStatus = z.infer<typeof ProjectStatusSchema>;
+
+/**
+ * Status of a task or milestone
+ */
+export const TaskStatusSchema = z.enum(['pending', 'in-progress', 'complete', 'failed']);
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+
+/**
+ * Individual task within a milestone
+ */
+export interface Task {
+  id: string;
+  name: string;
+  description: string;
+  status: TaskStatus;
+  testsPassed?: boolean;
+  testPlan?: string;
+  error?: string;
+}
+
+/**
+ * Zod schema for Task
+ */
+export const TaskSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  status: TaskStatusSchema,
+  testsPassed: z.boolean().optional(),
+  testPlan: z.string().optional(),
+  error: z.string().optional(),
+});
+
+/**
+ * Milestone containing multiple tasks
+ */
+export interface Milestone {
+  id: string;
+  name: string;
+  description: string;
+  status: TaskStatus;
+  tasks: Task[];
+}
+
+/**
+ * Zod schema for Milestone
+ */
+export const MilestoneSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  status: TaskStatusSchema,
+  tasks: z.array(TaskSchema),
+});
+
+/**
+ * Complete project state for persistence
+ */
+export interface ProjectState {
+  id: string;
+  name: string;
+  idea: string;
+  language: OutputLanguage;
+  openaiModel: OpenAIModel;
+  phase: WorkflowPhase;
+  status: ProjectStatus;
+  specification?: string;
+  plan?: string;
+  milestones: Milestone[];
+  currentMilestone: string | null;
+  currentTask: string | null;
+  consensusHistory: ConsensusIteration[];
+  error?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/**
+ * Zod schema for project state validation
+ */
+export const ProjectStateSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  idea: z.string(),
+  language: z.enum(['python', 'typescript']),
+  openaiModel: z.enum(['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini']),
+  phase: WorkflowPhaseSchema,
+  status: ProjectStatusSchema,
+  specification: z.string().optional(),
+  plan: z.string().optional(),
+  milestones: z.array(MilestoneSchema),
+  currentMilestone: z.string().nullable(),
+  currentTask: z.string().nullable(),
+  consensusHistory: z.array(
+    z.object({
+      iteration: z.number(),
+      plan: z.string(),
+      result: z.object({
+        score: z.number(),
+        analysis: z.string(),
+        strengths: z.array(z.string()),
+        concerns: z.array(z.string()),
+        recommendations: z.array(z.string()),
+        approved: z.boolean(),
+        rawResponse: z.string(),
+      }),
+      timestamp: z.string(),
+    })
+  ),
+  error: z.string().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+/**
+ * Workflow event types for state machine
+ */
+export type WorkflowEvent =
+  | { type: 'START_PLANNING' }
+  | { type: 'CONSENSUS_APPROVED'; score: number }
+  | { type: 'CONSENSUS_REJECTED'; score: number; feedback: string }
+  | { type: 'START_EXECUTION' }
+  | { type: 'TASK_COMPLETED'; taskId: string }
+  | { type: 'TASK_FAILED'; taskId: string; error: string }
+  | { type: 'TEST_PASSED' }
+  | { type: 'TEST_FAILED'; error: string }
+  | { type: 'MILESTONE_COMPLETED'; milestoneId: string }
+  | { type: 'PROJECT_COMPLETED' }
+  | { type: 'ESCALATE_TO_USER'; reason: string };