popeye-cli 1.4.7 → 1.6.0

package/src/adapters/openai.ts

@@ -43,7 +43,7 @@ export async function requestConsensus(
   const client = await createClient();
 
   // Build the consensus review prompt (matches spec section 11.1)
-  const prompt = buildConsensusPrompt(plan, context);
+  const prompt = buildConsensusPrompt(plan, context, config.reviewerPersona);
 
   try {
     const completion = await client.chat.completions.create({
@@ -68,9 +68,14 @@ export async function requestConsensus(
 /**
  * Build the consensus review prompt
  * Follows spec section 11.1 format
+ *
+ * @param plan - The plan to review
+ * @param context - Project context
+ * @param persona - Optional custom reviewer persona (defaults to senior software architect)
  */
-function buildConsensusPrompt(plan: string, context: string): string {
-  return `You are a senior software architect reviewing a development plan.
+function buildConsensusPrompt(plan: string, context: string, persona?: string): string {
+  const reviewerRole = persona || 'a senior software architect';
+  return `You are ${reviewerRole} reviewing a development plan.
 Analyze the following plan for completeness, correctness, and feasibility.
 
 PROJECT CONTEXT:
@@ -256,17 +261,28 @@ export async function listAvailableModels(): Promise<string[]> {
  */
 export async function expandIdea(
   idea: string,
-  language: OutputLanguage
+  language: OutputLanguage,
+  userDocs?: string
 ): Promise<string> {
   const client = await createClient();
 
+  const isWebsiteProject = language === 'website' || language === 'all';
+
   const languageDesc = language === 'fullstack'
     ? 'React (TypeScript) frontend with FastAPI (Python) backend'
+    : language === 'website'
+    ? 'Next.js (TypeScript) marketing website'
+    : language === 'all'
+    ? 'React frontend + FastAPI backend + Next.js marketing website'
     : language === 'python'
     ? 'Python'
     : 'TypeScript';
 
-  const prompt = `You are a senior software architect. A user wants to build a project with the following idea:
+  const personaRole = isWebsiteProject
+    ? 'a Senior Product Marketing Strategist and Fullstack Web Architect'
+    : 'a senior software architect';
+
+  let prompt = `You are ${personaRole}. A user wants to build a project with the following idea:
 
 "${idea}"
 
@@ -285,10 +301,26 @@ Expand this into a complete software specification including:
 5. **API Specification** (if applicable): Key endpoints and their purposes
 6. **Data Models**: Key entities and their relationships
 7. **Non-Functional Requirements**: Performance, security, scalability considerations
-8. **Deployment**: Docker configuration and deployment approach
+8. **Deployment**: Docker configuration and deployment approach`;
+
+  // Add website-specific sections for website projects
+  if (isWebsiteProject) {
+    prompt += `
+9. **Ideal Customer Profile (ICP)**: Primary persona, pain points, goals, objections
+10. **SEO Strategy**: Primary keywords, long-tail keywords, content themes
+11. **Conversion Funnel**: Primary CTA, secondary CTA, trust signals, lead capture mechanism
+12. **Site Map**: All pages with their purpose and conversion goal
+13. **Competitive Positioning**: Category, key differentiators vs alternatives`;
+  }
+
+  prompt += `
 
 Be specific and actionable. The specification should be detailed enough that a developer could implement it without further clarification.`;
 
+  if (userDocs) {
+    prompt += `\n\nThe user has provided the following project documentation that describes their product:\n\n${userDocs.slice(0, 4000)}\n\nUse this documentation to create an accurate, detailed specification that reflects the actual product described. Do not invent features or pricing not mentioned in the docs.`;
+  }
+
   const completion = await client.chat.completions.create({
     model: 'gpt-4o',
     messages: [{ role: 'user', content: prompt }],

package/src/cli/commands/create.ts

@@ -5,6 +5,7 @@
 
 import { Command } from 'commander';
 import path from 'node:path';
+import { promises as fs } from 'node:fs';
 import { ProjectSpecSchema, type OutputLanguage, type OpenAIModel } from '../../types/project.js';
 import { requireAuth } from '../../auth/index.js';
 import { runWorkflow } from '../../workflow/index.js';
@@ -99,8 +100,8 @@ export function createCreateCommand(): Command {
         }
 
         // Generate project name from idea if not provided
-        const projectName = options.name || generateProjectName(idea);
         const outputDir = path.resolve(options.output);
+        const projectName = options.name || await generateProjectName(idea, outputDir);
         const projectDir = path.join(outputDir, projectName);
         const threshold = parseInt(options.threshold, 10);
         const maxIterations = parseInt(options.maxIterations, 10);
@@ -255,10 +256,63 @@ export function createCreateCommand(): Command {
 }
 
 /**
- * Generate a project name from an idea
+ * Directories that are too generic to use as project names
  */
-function generateProjectName(idea: string): string {
-  // Take first few words, lowercase, replace spaces with hyphens
+const GENERIC_DIR_NAMES = new Set([
+  'home', 'desktop', 'documents', 'downloads', 'projects', 'project',
+  'repos', 'code', 'dev', 'workspace', 'workspaces', 'src', 'tmp',
+  'temp', 'users', 'user', 'root', 'var', 'opt',
+]);
+
+/**
+ * Generate a project name, preferring CWD-derived names over prompt text.
+ *
+ * Priority: docs in CWD -> CWD basename -> idea text extraction
+ *
+ * @param idea - The user's project idea text
+ * @param cwd - Optional directory for context-aware naming
+ * @returns A kebab-case project name
+ */
+async function generateProjectName(idea: string, cwd?: string): Promise<string> {
+  const toKebab = (name: string): string =>
+    name
+      .replace(/([a-z])([A-Z])/g, '$1-$2')
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '');
+
+  if (cwd) {
+    // Check for doc-derived name
+    try {
+      const entries = await fs.readdir(cwd, { withFileTypes: true });
+      const mdFiles = entries
+        .filter(e => e.isFile() && e.name.endsWith('.md') && !e.name.toLowerCase().startsWith('readme'))
+        .map(e => path.join(cwd, e.name));
+
+      for (const mdFile of mdFiles) {
+        try {
+          const content = await fs.readFile(mdFile, 'utf-8');
+          const headingMatch = content.match(/^#\s+([A-Z][a-zA-Z0-9]+)/m);
+          if (headingMatch && headingMatch[1] && headingMatch[1].length >= 3 && headingMatch[1].length <= 30) {
+            return toKebab(headingMatch[1]);
+          }
+        } catch {
+          // Skip unreadable files
+        }
+      }
+    } catch {
+      // Directory not readable
+    }
+
+    // Check CWD basename
+    const dirName = path.basename(cwd);
+    if (dirName.length >= 3 && !GENERIC_DIR_NAMES.has(dirName.toLowerCase())) {
+      return toKebab(dirName);
+    }
+  }
+
+  // Fallback: extract from idea text
   return idea
     .toLowerCase()
     .replace(/[^a-z0-9\s]/g, '')

package/src/cli/interactive.ts

@@ -843,6 +843,7 @@ function showHelp(): void {
     ['/upgrade [target]', 'Upgrade project type (e.g., fullstack -> all)'],
     ['/new <idea>', 'Force start a new project (skips existing check)'],
     ['/resume', 'Resume interrupted project'],
+    ['/overview [fix]', 'Project review with analysis; fix to auto-discover docs'],
     ['/clear', 'Clear screen'],
     ['/exit', 'Exit Popeye'],
   ];
@@ -997,6 +998,10 @@ async function handleInput(input: string, state: SessionState): Promise<boolean>
         await handleUpgrade(state, args);
         break;
 
+      case '/overview':
+        await handleOverview(state, args);
+        break;
+
       case '/new':
         // Force start a new project even if existing projects found
         if (args.length === 0) {
@@ -1050,6 +1055,48 @@ async function handleStatus(state: SessionState): Promise<void> {
   console.log(summary);
 }
 
+/**
+ * Handle /overview command - full project plan and milestone review
+ */
+async function handleOverview(state: SessionState, args: string[] = []): Promise<void> {
+  if (!state.projectDir) {
+    printInfo('No active project. Start or resume a project first.');
+    return;
+  }
+
+  const subcommand = args[0]?.toLowerCase();
+
+  try {
+    if (subcommand === 'fix') {
+      // Run fix mode: re-discover docs, find brand assets, update website content
+      const { fixOverviewIssues, generateOverview, formatOverview } = await import('../workflow/overview.js');
+
+      printInfo('Running overview fix...');
+      const fixResult = await fixOverviewIssues(state.projectDir, (msg) => {
+        printInfo(msg);
+      });
+
+      // Show fix results
+      console.log('');
+      for (const msg of fixResult.messages) {
+        printInfo(msg);
+      }
+      console.log('');
+
+      // Show updated overview after fix
+      const overview = await generateOverview(state.projectDir);
+      console.log(formatOverview(overview));
+    } else {
+      // Display-only mode: show overview with analysis
+      const { generateOverview, formatOverview } = await import('../workflow/overview.js');
+      const overview = await generateOverview(state.projectDir);
+      console.log(formatOverview(overview));
+    }
+  } catch (error) {
+    printInfo(`Could not generate overview: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+}
+
 /**
  * Handle /config command
  */
@@ -2215,10 +2262,99 @@ async function handleResume(state: SessionState, args: string[]): Promise<void>
 }
 
 /**
- * Generate a meaningful project name from an idea
- * Extracts key nouns and creates a kebab-case name
+ * Directories that are too generic to use as project names.
+ * If the CWD basename matches one of these, we skip CWD-based naming.
+ */
+const GENERIC_DIR_NAMES = new Set([
+  'home', 'desktop', 'documents', 'downloads', 'projects', 'project',
+  'repos', 'code', 'dev', 'workspace', 'workspaces', 'src', 'tmp',
+  'temp', 'users', 'user', 'root', 'var', 'opt',
+]);
+
+/**
+ * Try to extract a product name from .md files in a directory.
+ * Looks for top-level headings (# ProductName) in markdown files.
+ *
+ * @param dir - Directory to scan for .md files
+ * @returns Product name if found, null otherwise
+ */
+export async function extractNameFromDocs(dir: string): Promise<string | null> {
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const mdFiles = entries
+      .filter(e => e.isFile() && e.name.endsWith('.md') && !e.name.toLowerCase().startsWith('readme'))
+      .map(e => path.join(dir, e.name));
+
+    for (const mdFile of mdFiles) {
+      try {
+        const content = await fs.readFile(mdFile, 'utf-8');
+        // Look for a top-level heading like "# Gateco" or "# Gateco - Subtitle"
+        const headingMatch = content.match(/^#\s+([A-Z][a-zA-Z0-9]+)/m);
+        if (headingMatch && headingMatch[1]) {
+          const name = headingMatch[1];
+          // Validate: must be a reasonable product name (3-30 chars, not a generic word)
+          if (name.length >= 3 && name.length <= 30 && !GENERIC_DIR_NAMES.has(name.toLowerCase())) {
+            return name;
+          }
+        }
+      } catch {
+        // Skip unreadable files
+      }
+    }
+  } catch {
+    // Directory not readable
+  }
+  return null;
+}
+
+/**
+ * Generate a meaningful project name from an idea, with CWD-aware logic.
+ *
+ * Priority chain:
+ * 1. If CWD contains .md docs with a "# ProductName" heading, use that
+ * 2. If CWD basename is a meaningful name (not generic), use it
+ * 3. Fall back to extracting a name from the idea text
+ *
+ * @param idea - The user's project idea text
+ * @param cwd - Optional current working directory for context-aware naming
+ * @returns A kebab-case project name
+ */
+export async function generateProjectName(idea: string, cwd?: string): Promise<string> {
+  // Normalize to kebab-case helper
+  const toKebab = (name: string): string =>
+    name
+      .replace(/([a-z])([A-Z])/g, '$1-$2')
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '');
+
+  if (cwd) {
+    // Priority 1: Check for doc-derived name in CWD
+    const docName = await extractNameFromDocs(cwd);
+    if (docName) {
+      return toKebab(docName);
+    }
+
+    // Priority 2: Use CWD basename if it's meaningful
+    const dirName = path.basename(cwd);
+    if (dirName.length >= 3 && !GENERIC_DIR_NAMES.has(dirName.toLowerCase())) {
+      return toKebab(dirName);
+    }
+  }
+
+  // Priority 3: Extract from idea text (original logic)
+  return generateProjectNameFromIdea(idea);
+}
+
+/**
+ * Extract a project name from the idea text alone.
+ * This is the original generateProjectName logic, used as a fallback.
+ *
+ * @param idea - The user's project idea text
+ * @returns A kebab-case project name
  */
-function generateProjectName(idea: string): string {
+export function generateProjectNameFromIdea(idea: string): string {
   // 1. First, try to find explicit project name patterns
   const explicitPatterns = [
     /(?:called|named|for|planning|project)\s+["']?([A-Z][a-zA-Z0-9]+)["']?/i,
@@ -2418,8 +2554,8 @@ async function handleIdea(idea: string, state: SessionState): Promise<void> {
     }
   }
 
-  // Generate a meaningful project name
-  const projectName = generateProjectName(idea);
+  // Generate a meaningful project name (CWD-aware: checks docs and dir name first)
+  const projectName = await generateProjectName(idea, cwd);
   const projectDir = path.join(cwd, projectName);
 
   console.log();
@@ -2534,8 +2670,8 @@ async function handleNewProject(idea: string, state: SessionState): Promise<void
 
   const cwd = state.projectDir || process.cwd();
 
-  // Generate a meaningful project name
-  const projectName = generateProjectName(idea);
+  // Generate a meaningful project name (CWD-aware: checks docs and dir name first)
+  const projectName = await generateProjectName(idea, cwd);
   const projectDir = path.join(cwd, projectName);
 
   console.log();