@myvillage/cli 1.3.0 → 1.5.1

package/src/commands/bizreqs.js

@@ -0,0 +1,965 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { z } from 'zod';
+import { createInterface } from 'readline';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join, resolve } from 'path';
+import { isAuthenticated } from '../utils/auth.js';
+import { getConfig } from '../utils/config.js';
+import { brand, villageSpinner, formatAIResponse } from '../utils/brand.js';
+import {
+  createBizReqsSubmission,
+  listBizReqsSubmissions,
+  getBizReqsSubmission,
+  getBizReqsStatus,
+  saveBizReqsSpec,
+} from '../utils/api.js';
+import {
+  formatBizReqsList,
+  formatBizReqsStatusCounts,
+  formatBizReqsStatus,
+  formatRecommendationBox,
+} from '../utils/formatters.js';
+
+// ── AI System Prompt ────────────────────────────────────
+
+const INTAKE_SYSTEM_PROMPT = `You are a business solutions consultant for MyVillage Project, a community impact organization where student developers build real technology solutions for businesses and nonprofits.
+
+Your job is to analyze a client's initial description and quickly arrive at a recommendation. You're warm, professional, and concise. You speak in plain language — no jargon.
+
+## How the Conversation Works
+
+The client has already written a description of their organization, what they do, and what challenges they face. You will receive this upfront.
+
+1. **First response:** Briefly acknowledge what you heard (2-3 sentences max). Then, if you have enough to make a recommendation, call the ready_for_recommendation tool. If something critical is unclear, ask ONE specific follow-up question — never more than one question per response.
+2. **Follow-up responses:** After the client answers, either call ready_for_recommendation or ask ONE more question. You should need at most 2 follow-ups. Do not ask open-ended questions — be specific about what's missing.
+
+## Rules
+- NEVER ask more than one question per response
+- NEVER ask a question that bundles multiple sub-questions (e.g., "What's your budget and timeline and team size?")
+- Prefer calling ready_for_recommendation over asking another question — only ask if truly critical info is missing
+- Keep responses short — no long summaries or recaps unless the client asks
+- Do not repeat back everything the client said
+
+## MyVillageOS Capability Mapping
+
+When thinking about recommendations, map client needs to these platform tools:
+
+| Client Need | Platform Tool | Description |
+|-------------|--------------|-------------|
+| Website, dashboard, admin panel | portal | Web portal creation |
+| Youth engagement, gamified learning | game (M-UNI) | Educational game platform |
+| Automation, monitoring, reminders | agent | Autonomous AI agent |
+| Community updates, social presence | feed (MAN) | Community network |
+| Staff training, pattern recognition | model | Custom ML/AI model |
+| Phone system, voice assistant | voice | Voice cloning + agent |
+| STEM, hardware, robotics | robot | TechRoots robotics |
+
+## Honesty Guidelines
+- Be honest about what MyVillageOS can and cannot do well
+- If something doesn't map well to the platform, say so and suggest what DOES fit
+- Don't oversell — recommend only what genuinely serves the client's needs
+- Most real-world needs map to a COMBINATION of tools, not just one`;
+
+// ── Simple text input (avoids inquirer readline cursor issues) ──
+
+function askInput(prompt) {
+  // Print styled prompt separately so readline doesn't count ANSI codes as width
+  process.stdout.write(brand.gold('? ') + chalk.bold(prompt) + ' ');
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question('', (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// ── Tool Schemas (Zod — required by Vercel AI SDK v4) ──
+
+const readyForRecommendationParams = z.object({
+  situation: z.string().describe('Brief summary of the organization and what they do'),
+  problems: z.string().describe('Key challenges and pain points identified'),
+  goals: z.string().optional().describe('Aspirations or goals mentioned, if any'),
+});
+
+const recommendationParams = z.object({
+  solutionName: z.string().describe('A descriptive name for the recommended solution (e.g., "NorthStar Learning Hub")'),
+  components: z.array(z.object({
+    name: z.string().describe('Component name'),
+    type: z.enum(['portal', 'game', 'agent', 'feed', 'model', 'voice', 'robot']).describe('MyVillageOS platform tool type'),
+    description: z.string().describe('What this component does for the client'),
+    complexity: z.enum(['low', 'medium', 'high']).describe('Component complexity'),
+  })).describe('Recommended solution components'),
+  estimatedTimeline: z.string().describe('Estimated build timeline (e.g., "6-8 weeks")'),
+  estimatedMVT: z.number().describe('Estimated MVT token budget'),
+  overallComplexity: z.enum(['LOW', 'MEDIUM', 'HIGH']).describe('Overall project complexity'),
+  priorityOrder: z.string().optional().describe('Recommended build order / priority for components'),
+});
+
+// ── Helper: Get Anthropic client ────────────────────────
+
+async function getAnthropicProvider() {
+  const { createAnthropic } = await import('@ai-sdk/anthropic');
+  const config = getConfig();
+  let apiKey = config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+
+  if (!apiKey) {
+    console.log(chalk.yellow('\n  Anthropic API key required for AI-powered intake.'));
+    console.log(brand.teal('  Get yours at: https://console.anthropic.com\n'));
+
+    const { key } = await inquirer.prompt([{
+      type: 'password',
+      name: 'key',
+      message: 'Anthropic API key:',
+      mask: '*',
+      validate: (input) => input.trim().length > 0 || 'API key is required',
+    }]);
+
+    apiKey = key.trim();
+    const { setConfig } = await import('../utils/config.js');
+    setConfig({ anthropicApiKey: apiKey });
+    console.log(brand.green('  ✓ API key saved to ~/.myvillage/config.json\n'));
+  }
+
+  return createAnthropic({ apiKey });
+}
+
+
+// ── bizreqs list ────────────────────────────────────────
+
+export async function bizreqsListCommand(options) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const spinner = villageSpinner('Loading submissions...').start();
+
+  try {
+    const params = {
+      limit: parseInt(options.limit) || 50,
+      offset: parseInt(options.offset) || 0,
+      counts: 'true',
+    };
+    if (options.status) params.status = options.status.toUpperCase().replace('-', '_');
+    if (options.city) params.city = options.city;
+    if (options.sort) params.sort = options.sort;
+    if (options.search) params.search = options.search;
+
+    const result = await listBizReqsSubmissions(params);
+    spinner.stop();
+
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const statusLabel = options.status
+      ? ` — ${options.status.replace('-', ' ').replace(/\b\w/g, c => c.toUpperCase())}`
+      : '';
+
+    console.log(`\n  ${chalk.bold(`Business Requirements Pipeline${statusLabel}`)}`);
+    formatBizReqsList(result.submissions);
+
+    if (result.statusCounts) {
+      formatBizReqsStatusCounts(result.statusCounts);
+    }
+
+    if (result.pagination?.hasMore) {
+      console.log(brand.teal(`  ── More results available. Use --offset=${result.pagination.offset + result.pagination.limit} to see next page\n`));
+    }
+  } catch (err) {
+    const message = err.response?.data?.error || err.message;
+    spinner.fail(`Failed to load submissions: ${message}`);
+  }
+}
+
+// ── bizreqs status ──────────────────────────────────────
+
+export async function bizreqsStatusCommand(id) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const spinner = villageSpinner(`Loading status for ${id}...`).start();
+
+  try {
+    const result = await getBizReqsStatus(id);
+    spinner.stop();
+
+    if (!result.success || !result.status) {
+      console.log(chalk.red(`  ✗ Submission not found: ${id}`));
+      return;
+    }
+
+    console.log(`\n  ${chalk.bold('Project Status')}`);
+    formatBizReqsStatus(result.status);
+  } catch (err) {
+    if (err.response?.status === 404) {
+      spinner.fail(`Submission not found: ${id}`);
+    } else {
+      const message = err.response?.data?.error || err.message;
+      spinner.fail(`Failed to load status: ${message}`);
+    }
+  }
+}
+
+// ── bizreqs new ─────────────────────────────────────────
+
+export async function bizreqsNewCommand(options) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  let anthropic;
+  try {
+    anthropic = await getAnthropicProvider();
+  } catch (err) {
+    console.log(chalk.red(`  ✗ ${err.message}`));
+    return;
+  }
+
+  const { streamText, generateText } = await import('ai');
+
+  // Gather basic context
+  console.log(`\n  ${brand.gold(chalk.bold('\u2726 MyVillage Project \u2014 Business Solutions Intake'))}\n`);
+  console.log(brand.cream('  Tell us about your organization and what you need.'));
+  console.log(brand.cream('  Our student developers will use this to build'));
+  console.log(brand.cream('  something great for you.\n'));
+  console.log(brand.teal('  Tip: Type /quit at any prompt to cancel.\n'));
+
+  let orgName = options.org;
+  let contactName = options.contact;
+
+  if (!orgName) {
+    const answer = await inquirer.prompt([{
+      type: 'input',
+      name: 'orgName',
+      message: 'Organization name:',
+      validate: v => v.trim() ? true : 'Required',
+    }]);
+    orgName = answer.orgName.trim();
+  }
+
+  if (!contactName) {
+    const answer = await inquirer.prompt([{
+      type: 'input',
+      name: 'contactName',
+      message: 'Contact name (optional):',
+    }]);
+    contactName = answer.contactName.trim() || undefined;
+  }
+
+  // Read pre-context from file/URL if provided
+  let preContext = '';
+  if (options.fromFile) {
+    try {
+      preContext = readFileSync(resolve(options.fromFile), 'utf-8');
+      console.log(brand.teal(`\n  📎 Read context from: ${options.fromFile}\n`));
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Could not read file: ${err.message}`));
+    }
+  }
+
+  if (options.fromUrl) {
+    try {
+      const { default: axios } = await import('axios');
+      const response = await axios.get(options.fromUrl, { timeout: 10000 });
+      const text = response.data
+        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .substring(0, 3000);
+      preContext += `\n\nWebsite content from ${options.fromUrl}:\n${text}`;
+      console.log(brand.teal(`  🌐 Scanned: ${options.fromUrl}\n`));
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Could not fetch URL: ${err.message}`));
+    }
+  }
+
+  // Set up conversation
+  const messages = [];
+  const intakeSummary = {};
+  const maxFollowUps = options.quick ? 0 : 3;
+
+  // Collect bulk input upfront
+  console.log(brand.darkGold('  Describe your organization and the challenges you\'re facing.'));
+  console.log(brand.cream('  Include what you do, who you serve, what\'s working, what\'s not,'));
+  console.log(brand.cream('  and what you\'d love to see in the future. The more you share'));
+  console.log(brand.cream('  now, the fewer follow-up questions we\'ll need.\n'));
+
+  const bulkInput = await askInput('Your description');
+
+  if (!bulkInput) {
+    console.log(chalk.yellow('\n  No input provided. Intake cancelled.\n'));
+    return;
+  }
+  if (bulkInput.toLowerCase() === '/quit' || bulkInput.toLowerCase() === '/exit') {
+    console.log(brand.teal('\n  Intake cancelled.\n'));
+    return;
+  }
+
+  // Build initial message with all context
+  let initialMessage = `Organization: "${orgName}"`;
+  if (contactName) initialMessage += ` | Contact: ${contactName}`;
+  if (preContext) initialMessage += `\n\nPre-provided context:\n${preContext}`;
+  initialMessage += `\n\nClient's description:\n${bulkInput}`;
+
+  messages.push({ role: 'user', content: initialMessage });
+
+  // Follow-up loop: AI can ask single questions or signal ready
+  for (let i = 0; i <= maxFollowUps; i++) {
+    let fullResponse = '';
+    let toolCallMade = false;
+
+    try {
+      const result = await streamText({
+        model: anthropic('claude-sonnet-4-5-20250929'),
+        system: INTAKE_SYSTEM_PROMPT + `\n\nThe organization is "${orgName}". This is follow-up ${i} of ${maxFollowUps} max.${i === maxFollowUps ? ' You MUST call ready_for_recommendation now — no more questions.' : ''}`,
+        messages,
+        tools: {
+          ready_for_recommendation: {
+            description: 'Signal that you have enough information to generate a recommendation. Call this instead of asking another question.',
+            parameters: readyForRecommendationParams,
+          },
+        },
+        maxTokens: 512,
+      });
+
+      const aiSpinner = villageSpinner('Thinking...').start();
+      for await (const chunk of result.textStream) {
+        fullResponse += chunk;
+      }
+
+      const finalResult = await result;
+      aiSpinner.stop();
+
+      if (fullResponse.trim()) {
+        console.log(formatAIResponse(fullResponse.trim()));
+        messages.push({ role: 'assistant', content: fullResponse });
+      }
+
+      if (finalResult.toolCalls && finalResult.toolCalls.length > 0) {
+        for (const call of finalResult.toolCalls) {
+          if (call.toolName === 'ready_for_recommendation') {
+            toolCallMade = true;
+            intakeSummary.situation = call.args.situation;
+            intakeSummary.problems = call.args.problems;
+            intakeSummary.goals = call.args.goals || null;
+          }
+        }
+      }
+    } catch (err) {
+      console.log(chalk.red(`\n  AI error: ${err.message}`));
+      break;
+    }
+
+    if (toolCallMade) break;
+
+    // If this was the last allowed follow-up, force move on
+    if (i === maxFollowUps) break;
+
+    // Get user response to the follow-up question
+    const userInput = await askInput('Your response');
+
+    if (!userInput) continue;
+    if (userInput.toLowerCase() === '/quit' || userInput.toLowerCase() === '/exit') {
+      console.log(brand.teal('\n  Intake cancelled.\n'));
+      return;
+    }
+
+    messages.push({ role: 'user', content: userInput });
+  }
+
+  // Generate recommendation
+  console.log(`\n  \uD83C\uDFAF ${brand.gold('Generating recommendation...')}\n`);
+
+  const recSpinner = villageSpinner('Analyzing intake data...').start();
+
+  const recPrompt = `Based on the entire conversation above about "${orgName}", generate a comprehensive solution recommendation. Consider all the problems discussed, the client's aspirations, and which MyVillageOS platform tools would best serve their needs. Call the generate_recommendation tool with your recommendation.`;
+
+  messages.push({ role: 'user', content: recPrompt });
+
+  let recommendation = null;
+
+  try {
+    const recResult = await generateText({
+      model: anthropic('claude-sonnet-4-5-20250929'),
+      system: INTAKE_SYSTEM_PROMPT,
+      messages,
+      tools: {
+        generate_recommendation: {
+          description: 'Generate a structured solution recommendation based on the intake conversation',
+          parameters: recommendationParams,
+        },
+      },
+      maxTokens: 2048,
+    });
+
+    if (recResult.toolCalls && recResult.toolCalls.length > 0) {
+      for (const call of recResult.toolCalls) {
+        if (call.toolName === 'generate_recommendation') {
+          recommendation = call.args;
+        }
+      }
+    }
+
+    recSpinner.stop();
+
+    if (!recommendation) {
+      console.log(chalk.yellow('  ⚠ AI did not generate a structured recommendation. Saving transcript only.'));
+    } else {
+      formatRecommendationBox({ ...recommendation, organizationName: orgName });
+
+      // Ask for confirmation
+      const { confirmed } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmed',
+        message: 'Does this recommendation look right?',
+        default: true,
+      }]);
+
+      if (!confirmed) {
+        const { adjustments } = await inquirer.prompt([{
+          type: 'input',
+          name: 'adjustments',
+          message: 'What would you like to adjust?',
+        }]);
+
+        if (adjustments.trim()) {
+          messages.push({
+            role: 'user',
+            content: `Please adjust the recommendation: ${adjustments}. Call generate_recommendation again with the updated recommendation.`,
+          });
+
+          const adjustSpinner = villageSpinner('Adjusting recommendation...').start();
+
+          const adjustResult = await generateText({
+            model: anthropic('claude-sonnet-4-5-20250929'),
+            system: INTAKE_SYSTEM_PROMPT,
+            messages,
+            tools: {
+              generate_recommendation: {
+                description: 'Generate a structured solution recommendation based on the intake conversation',
+                parameters: recommendationParams,
+              },
+            },
+            maxTokens: 2048,
+          });
+
+          adjustSpinner.stop();
+
+          if (adjustResult.toolCalls?.length > 0) {
+            for (const call of adjustResult.toolCalls) {
+              if (call.toolName === 'generate_recommendation') {
+                recommendation = call.args;
+              }
+            }
+            formatRecommendationBox({ ...recommendation, organizationName: orgName });
+          }
+        }
+      }
+    }
+  } catch (err) {
+    recSpinner.fail(`AI recommendation failed: ${err.message}`);
+    console.log(brand.teal('  Saving transcript without recommendation...\n'));
+  }
+
+  // Save to backend (with local fallback)
+  const payload = {
+    organizationName: orgName,
+    contactName,
+    intakeMethod: 'CLI_INTERACTIVE',
+    conversationTranscript: messages.filter(m => m.role !== 'system'),
+    extractedSituation: intakeSummary.situation || null,
+    extractedProblems: intakeSummary.problems ? [intakeSummary.problems] : null,
+    extractedDreams: intakeSummary.goals ? [intakeSummary.goals] : null,
+  };
+
+  if (recommendation) {
+    payload.solutionName = recommendation.solutionName;
+    payload.components = recommendation.components;
+    payload.estimatedTimeline = recommendation.estimatedTimeline;
+    payload.estimatedMVT = recommendation.estimatedMVT;
+    payload.overallComplexity = recommendation.overallComplexity;
+  }
+
+  const saveSpinner = villageSpinner('Saving submission...').start();
+
+  try {
+    const result = await createBizReqsSubmission(payload);
+    saveSpinner.stop();
+
+    const sub = result.submission;
+    console.log(brand.green(`\n  \u2713 Intake complete! Submission ID: ${chalk.bold(sub.submissionId)}\n`));
+    console.log(brand.teal('  \uD83D\uDCC4 Run \'myvillage bizreqs spec ' + sub.submissionId + '\' to generate a full project specification'));
+    console.log(brand.teal('  \uD83D\uDCCB Run \'myvillage bizreqs status ' + sub.submissionId + '\' to check status'));
+    console.log('');
+  } catch (err) {
+    saveSpinner.stop();
+
+    // Save locally so nothing is lost
+    const savedPath = saveIntakeLocally(payload);
+    const message = err.response?.data?.error || err.message;
+    console.log(chalk.yellow(`\n  \u26A0 Could not reach server: ${message}`));
+    console.log(brand.green(`  \u2713 Intake saved locally: ${chalk.bold(savedPath)}`));
+    console.log(brand.teal(`\n  You can submit it later with:`));
+    console.log(brand.gold(`    myvillage bizreqs import --file ${savedPath}\n`));
+  }
+}
+
+function saveIntakeLocally(payload) {
+  const homeDir = process.env.HOME || process.env.USERPROFILE;
+  const draftsDir = join(homeDir, '.myvillage', 'bizreqs-drafts');
+  if (!existsSync(draftsDir)) mkdirSync(draftsDir, { recursive: true });
+
+  const slug = payload.organizationName
+    .toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
+  const ts = new Date().toISOString().slice(0, 10);
+  const filename = `${slug}-${ts}.json`;
+  const filepath = join(draftsDir, filename);
+
+  writeFileSync(filepath, JSON.stringify(payload, null, 2));
+  return filepath;
+}
+
+// ── bizreqs spec ────────────────────────────────────────
+
+export async function bizreqsSpecCommand(id, options) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  let anthropic;
+  try {
+    anthropic = await getAnthropicProvider();
+  } catch (err) {
+    console.log(chalk.red(`  ✗ ${err.message}`));
+    return;
+  }
+
+  const { generateText } = await import('ai');
+
+  // Fetch submission
+  const fetchSpinner = villageSpinner(`Loading submission ${id}...`).start();
+  let submission;
+
+  try {
+    const result = await getBizReqsSubmission(id);
+    submission = result.submission;
+    fetchSpinner.stop();
+
+    if (!submission) {
+      console.log(chalk.red(`  ✗ Submission not found: ${id}`));
+      return;
+    }
+
+    if (!submission.solutionName && !submission.components) {
+      console.log(chalk.yellow('  ⚠ This submission has no recommendation data yet.'));
+      console.log(brand.teal('  Run \'myvillage bizreqs new\' to generate a recommendation first.\n'));
+      return;
+    }
+  } catch (err) {
+    if (err.response?.status === 404) {
+      fetchSpinner.fail(`Submission not found: ${id}`);
+    } else {
+      fetchSpinner.fail(`Failed to load submission: ${err.response?.data?.error || err.message}`);
+    }
+    return;
+  }
+
+  // Generate spec
+  const detailLevel = options.detail || 'standard';
+  const genSpinner = villageSpinner('Generating project specification...').start();
+
+  const specPrompt = `Generate a comprehensive project specification document in Markdown format.
+
+## Submission Details
+
+- **Submission ID:** ${submission.submissionId}
+- **Organization:** ${submission.organizationName}
+- **Contact:** ${submission.contactName || 'N/A'}
+- **City:** ${submission.city || 'N/A'}
+- **Org Type:** ${submission.orgType || 'N/A'}
+
+## Recommended Solution: ${submission.solutionName}
+
+### Components
+${JSON.stringify(submission.components, null, 2)}
+
+### Estimates
+- Timeline: ${submission.estimatedTimeline || 'TBD'}
+- MVT Budget: ${submission.estimatedMVT || 'TBD'}
+- Complexity: ${submission.overallComplexity || 'TBD'}
+
+## Intake Context
+${submission.extractedSituation ? `### Situation\n${submission.extractedSituation}` : ''}
+${submission.extractedProblems ? `### Problems\n${JSON.stringify(submission.extractedProblems)}` : ''}
+${submission.extractedDreams ? `### Dreams\n${JSON.stringify(submission.extractedDreams)}` : ''}
+
+## Conversation Transcript
+${submission.conversationTranscript ? JSON.stringify(submission.conversationTranscript, null, 2) : 'No transcript available'}
+
+---
+
+Generate the spec with the following 9 sections:
+1. Executive Summary
+2. Client Context
+3. Solution Architecture
+4. Component Specifications (one subsection per component with user stories, key screens/mechanics, acceptance criteria)
+5. Implementation Plan (phases, sprints, milestones)
+6. MVT Budget (allocation per component and role)
+7. Success Metrics
+8. Client Deliverables
+9. Appendix
+
+Detail level: ${detailLevel}
+${detailLevel === 'brief' ? 'Keep it concise — 2-3 pages, high-level overview.' : ''}
+${detailLevel === 'comprehensive' ? 'Be thorough — include wireframe descriptions, data models, and detailed user stories.' : ''}
+
+Format as clean Markdown. Start with a YAML-style header block.`;
+
+  try {
+    const specResult = await generateText({
+      model: anthropic('claude-sonnet-4-5-20250929'),
+      system: 'You are a technical project specification writer for MyVillage Project. Generate clear, actionable project specifications that student developers can use to build real solutions. Use Markdown formatting.',
+      messages: [{ role: 'user', content: specPrompt }],
+      maxTokens: 8192,
+    });
+
+    genSpinner.stop();
+
+    const specContent = specResult.text;
+
+    if (!specContent || specContent.trim().length < 100) {
+      console.log(chalk.yellow('  ⚠ Spec generation produced insufficient content.'));
+      return;
+    }
+
+    // Save locally
+    const outputDir = resolve(options.output || './specs');
+    if (!existsSync(outputDir)) {
+      mkdirSync(outputDir, { recursive: true });
+    }
+
+    const slug = (submission.solutionName || submission.organizationName)
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '')
+      .substring(0, 40);
+
+    const fileName = `${submission.submissionId}-${slug}.md`;
+    const filePath = join(outputDir, fileName);
+    writeFileSync(filePath, specContent, 'utf-8');
+
+    console.log(brand.green(`\n  ✅ Specification generated!\n`));
+    console.log(`  ${brand.teal('📄 Saved to:')} ${filePath}`);
+
+    // Save to backend
+    const saveSpinner = villageSpinner('Saving spec to backend...').start();
+    try {
+      await saveBizReqsSpec(submission.submissionId, {
+        specContent,
+        format: 'markdown',
+        detailLevel,
+      });
+      saveSpinner.stop();
+      console.log(brand.teal('  ☁️  Saved to MyVillageOS backend'));
+    } catch (err) {
+      saveSpinner.fail(`Could not save to backend: ${err.response?.data?.error || err.message}`);
+    }
+
+    console.log('');
+    console.log(brand.teal(`  Next: Run 'myvillage bizreqs status ${submission.submissionId}' to check status\n`));
+  } catch (err) {
+    genSpinner.fail(`Spec generation failed: ${err.message}`);
+  }
+}
+
+// ── bizreqs import ──────────────────────────────────────
+
+export async function bizreqsImportCommand(options) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  if (!options.file && !options.url) {
+    console.log(chalk.red('  ✗ Please provide --file or --url'));
+    console.log(brand.teal('  Usage: myvillage bizreqs import --file ./requirements.md'));
+    console.log(brand.teal('         myvillage bizreqs import --url https://example.org\n'));
+    return;
+  }
+
+  let anthropic;
+  try {
+    anthropic = await getAnthropicProvider();
+  } catch (err) {
+    console.log(chalk.red(`  ✗ ${err.message}`));
+    return;
+  }
+
+  const { generateText } = await import('ai');
+
+  console.log(brand.teal('\n  📄 Importing business requirements...\n'));
+
+  // Read content
+  let content = '';
+  let sourceName = '';
+
+  if (options.file) {
+    const filePath = resolve(options.file);
+    const ext = filePath.split('.').pop()?.toLowerCase();
+
+    if (!['txt', 'md'].includes(ext)) {
+      console.log(chalk.yellow(`  ⚠ Only .txt and .md files are supported in v1. Got: .${ext}`));
+      return;
+    }
+
+    try {
+      content = readFileSync(filePath, 'utf-8');
+      sourceName = options.file;
+      console.log(brand.teal(`  📎 Reading: ${options.file} (${content.length} chars)`));
+    } catch (err) {
+      console.log(chalk.red(`  ✗ Could not read file: ${err.message}`));
+      return;
+    }
+  }
+
+  if (options.url) {
+    try {
+      const { default: axios } = await import('axios');
+      const spinner = villageSpinner(`Fetching ${options.url}...`).start();
+      const response = await axios.get(options.url, { timeout: 15000 });
+      const text = response.data
+        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .substring(0, 5000);
+      content += (content ? '\n\n---\n\n' : '') + `Content from ${options.url}:\n${text}`;
+      sourceName = sourceName ? `${sourceName} + ${options.url}` : options.url;
+      spinner.stop();
+      console.log(brand.teal(`  🌐 Scanned: ${options.url}`));
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Could not fetch URL: ${err.message}`));
+      if (!content) return;
+    }
+  }
+
+  // Prompt for org/contact
+  let orgName = options.org;
+  let contactName = options.contact;
+
+  if (!orgName) {
+    const answer = await inquirer.prompt([{
+      type: 'input',
+      name: 'orgName',
+      message: 'Organization name (or press Enter to auto-detect):',
+    }]);
+    orgName = answer.orgName.trim() || null;
+  }
+
+  if (!contactName) {
+    const answer = await inquirer.prompt([{
+      type: 'input',
+      name: 'contactName',
+      message: 'Contact name (optional):',
+    }]);
+    contactName = answer.contactName.trim() || undefined;
+  }
+
+  // AI analysis
+  const analysisSpinner = villageSpinner('Analyzing content...').start();
+
+  try {
+    const analysisResult = await generateText({
+      model: anthropic('claude-sonnet-4-5-20250929'),
+      system: INTAKE_SYSTEM_PROMPT,
+      messages: [{
+        role: 'user',
+        content: `Analyze the following content from a potential client${orgName ? ` (${orgName})` : ''}. Extract:
+
+1. Organization name and profile (if not provided, infer from content)
+2. Their current situation
+3. Problems and challenges
+4. Any stated dreams or goals
+5. 2-3 follow-up questions for anything unclear
+
+Source: ${sourceName}
+
+Content:
+${content}
+
+After your analysis, if you have enough information, call the generate_recommendation tool to create a solution recommendation. If you need more information first, ask your follow-up questions.`,
+      }],
+      tools: {
+        generate_recommendation: {
+          description: 'Generate a structured solution recommendation based on the intake conversation',
+          parameters: recommendationParams,
+        },
+      },
+      maxTokens: 2048,
+    });
+
+    analysisSpinner.stop();
+
+    // Display analysis text
+    if (analysisResult.text) {
+      console.log('\n' + formatAIResponse(analysisResult.text.trim()));
+    }
+
+    let recommendation = null;
+
+    // Check if recommendation was generated
+    if (analysisResult.toolCalls?.length > 0) {
+      for (const call of analysisResult.toolCalls) {
+        if (call.toolName === 'generate_recommendation') {
+          recommendation = call.args;
+        }
+      }
+    }
+
+    // If no recommendation yet, do follow-up Q&A
+    if (!recommendation) {
+      console.log('');
+      const messages = [
+        { role: 'user', content: `Content to analyze:\n${content}` },
+        { role: 'assistant', content: analysisResult.text || 'Analysis complete.' },
+      ];
+
+      // 2-3 follow-up exchanges
+      for (let i = 0; i < 3; i++) {
+        const answer = await askInput('Your response (/done to finish)');
+
+        if (!answer || answer.toLowerCase() === '/done' || answer.toLowerCase() === '/skip') break;
+
+        messages.push({ role: 'user', content: answer });
+
+        const followUp = await generateText({
+          model: anthropic('claude-sonnet-4-5-20250929'),
+          system: INTAKE_SYSTEM_PROMPT,
+          messages,
+          tools: {
+            generate_recommendation: {
+              description: 'Generate a structured solution recommendation based on the intake conversation',
+              parameters: recommendationParams,
+            },
+          },
+          maxTokens: 1024,
+        });
+
+        if (followUp.text) {
+          console.log('\n' + formatAIResponse(followUp.text.trim()));
+          messages.push({ role: 'assistant', content: followUp.text });
+        }
+
+        if (followUp.toolCalls?.length > 0) {
+          for (const call of followUp.toolCalls) {
+            if (call.toolName === 'generate_recommendation') {
+              recommendation = call.args;
+            }
+          }
+          if (recommendation) break;
+        }
+      }
+
+      // Force recommendation if still not generated
+      if (!recommendation) {
+        const forceSpinner = villageSpinner('Generating recommendation...').start();
+        messages.push({
+          role: 'user',
+          content: 'Based on everything discussed, please call generate_recommendation with your best recommendation.',
+        });
+
+        const forceResult = await generateText({
+          model: anthropic('claude-sonnet-4-5-20250929'),
+          system: INTAKE_SYSTEM_PROMPT,
+          messages,
+          tools: {
+            generate_recommendation: {
+              description: 'Generate a structured solution recommendation based on the intake conversation',
+              parameters: recommendationParams,
+            },
+          },
+          maxTokens: 2048,
+        });
+
+        forceSpinner.stop();
+
+        if (forceResult.toolCalls?.length > 0) {
+          for (const call of forceResult.toolCalls) {
+            if (call.toolName === 'generate_recommendation') {
+              recommendation = call.args;
+            }
+          }
+        }
+      }
+    }
+
+    if (recommendation) {
+      if (!orgName) orgName = recommendation.organizationName || 'Unknown Organization';
+      formatRecommendationBox({ ...recommendation, organizationName: orgName });
+
+      const { confirmed } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmed',
+        message: 'Save this to the pipeline?',
+        default: true,
+      }]);
+
+      if (!confirmed) {
+        console.log(brand.teal('\n  Import cancelled.\n'));
+        return;
+      }
+    } else {
+      console.log(chalk.yellow('\n  ⚠ Could not generate a recommendation. Saving as-is.\n'));
+      if (!orgName) {
+        const answer = await inquirer.prompt([{
+          type: 'input',
+          name: 'orgName',
+          message: 'Organization name (required):',
+          validate: v => v.trim() ? true : 'Required',
+        }]);
+        orgName = answer.orgName.trim();
+      }
+    }
+
+    // Save to backend
+    const saveSpinner = villageSpinner('Saving submission...').start();
+
+    const payload = {
+      organizationName: orgName,
+      contactName,
+      intakeMethod: 'CLI_IMPORT',
+      conversationTranscript: [{ role: 'system', content: `Imported from: ${sourceName}` }, { role: 'user', content }],
+      extractedSituation: analysisResult.text || null,
+    };
+
+    if (recommendation) {
+      payload.solutionName = recommendation.solutionName;
+      payload.components = recommendation.components;
+      payload.estimatedTimeline = recommendation.estimatedTimeline;
+      payload.estimatedMVT = recommendation.estimatedMVT;
+      payload.overallComplexity = recommendation.overallComplexity;
+    }
+
+    const result = await createBizReqsSubmission(payload);
+    saveSpinner.stop();
+
+    const sub = result.submission;
+    console.log(brand.green(`\n  ✅ Import complete! Submission ID: ${chalk.bold(sub.submissionId)}\n`));
+    console.log(brand.teal('  📄 Run \'myvillage bizreqs spec ' + sub.submissionId + '\' to generate a full project specification\n'));
+  } catch (err) {
+    analysisSpinner.stop();
+    console.log(chalk.red(`  ✗ Import failed: ${err.message}`));
+  }
+}