agent-md-generator 0.1.0 → 0.1.1

package/dist/cli.js

@@ -0,0 +1,1541 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import * as p5 from "@clack/prompts";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// ../shared/src/lib/questions.ts
+var QUESTIONS = [
+  {
+    id: "project_name",
+    step: 1,
+    category: "Identity",
+    question: "What is the name of your project?",
+    hint: "This will be the main title of your AGENT.md",
+    type: "text",
+    placeholder: "e.g. MyApp, Preflight, DeutschFlow...",
+    required: true
+  },
+  {
+    id: "project_type",
+    step: 1,
+    category: "Identity",
+    question: "What type of project is this?",
+    hint: "This defines the overall architecture and conventions",
+    type: "select",
+    required: true,
+    options: [
+      { value: "web_app", label: "Web Application", description: "Next.js, React, Vue, SvelteKit..." },
+      { value: "mobile_app", label: "Mobile Application", description: "React Native, Expo, Flutter..." },
+      { value: "vscode_extension", label: "VS Code Extension", description: "TypeScript, VS Code API..." },
+      { value: "npm_package", label: "npm Package / Library", description: "TypeScript library, SDK, CLI..." },
+      { value: "api_backend", label: "API / Backend", description: "Express, Fastify, NestJS, Hono..." },
+      { value: "fullstack", label: "Full-Stack Application", description: "Frontend + Backend in one repo" },
+      { value: "cli_tool", label: "CLI Tool", description: "Command-line application" },
+      { value: "other", label: "Other", description: "Something else entirely" }
+    ]
+  },
+  {
+    id: "mobile_platforms",
+    step: 1,
+    category: "Identity",
+    question: "What mobile platforms will you target?",
+    hint: "Affects build config, testing setup, and platform-specific code conventions",
+    type: "select",
+    required: false,
+    dependsOn: { questionId: "project_type", value: "mobile_app" },
+    options: [
+      { value: "ios_only", label: "iOS only", description: "Target Apple devices only" },
+      { value: "android_only", label: "Android only", description: "Target Android devices only" },
+      { value: "both", label: "iOS + Android", description: "Cross-platform for both" }
+    ]
+  },
+  {
+    id: "npm_distribution",
+    step: 1,
+    category: "Identity",
+    question: "How will your package be distributed?",
+    hint: "Affects build output, bundler config, and import conventions",
+    type: "select",
+    required: false,
+    dependsOn: { questionId: "project_type", value: "npm_package" },
+    options: [
+      { value: "esm_only", label: "ESM only", description: "Modern ESM-only package" },
+      { value: "cjs_esm", label: "CommonJS + ESM", description: "Dual-format for broad compatibility" },
+      { value: "browser_node", label: "Browser + Node.js", description: "Universal package for both environments" }
+    ]
+  },
+  {
+    id: "project_description",
+    step: 1,
+    category: "Identity",
+    question: "Describe your project in 2-3 sentences.",
+    hint: "What does it do? Who is it for? What problem does it solve?",
+    coaching: "Impacts the ## Overview section. A rich description gives the AI full context to write more accurate conventions. Aim for 80+ characters.",
+    type: "textarea",
+    placeholder: "e.g. Preflight is a VS Code extension that helps developers ship cleaner code by detecting debug statements, tracking TODOs with deadlines, and generating AI-powered commit messages...",
+    required: true
+  },
+  {
+    id: "tech_stack",
+    step: 2,
+    category: "Tech Stack",
+    question: "What is your primary tech stack?",
+    hint: "Select all that apply to your project",
+    coaching: "Impacts ## Tech Stack and ## Conventions. Each technology adds framework-specific rules (e.g. Next.js \u2192 Server Components, Prisma \u2192 ORM patterns). Select all relevant tools.",
+    type: "multiselect",
+    required: true,
+    options: [
+      { value: "typescript", label: "TypeScript" },
+      { value: "javascript", label: "JavaScript" },
+      { value: "react", label: "React" },
+      { value: "nextjs", label: "Next.js" },
+      { value: "react_native", label: "React Native" },
+      { value: "expo", label: "Expo" },
+      { value: "tailwind", label: "Tailwind CSS" },
+      { value: "nodejs", label: "Node.js" },
+      { value: "python", label: "Python" },
+      { value: "go", label: "Go" },
+      { value: "rust", label: "Rust" },
+      { value: "prisma", label: "Prisma" },
+      { value: "supabase", label: "Supabase" },
+      { value: "vercel_ai", label: "Vercel AI SDK" },
+      { value: "zustand", label: "Zustand" },
+      { value: "zod", label: "Zod" }
+    ]
+  },
+  {
+    id: "ai_features",
+    step: 2,
+    category: "Tech Stack",
+    question: "Does your project use AI / LLM features?",
+    type: "select",
+    required: true,
+    options: [
+      { value: "yes_core", label: "Yes \u2014 AI is a core feature", description: "The app is built around AI capabilities" },
+      { value: "yes_secondary", label: "Yes \u2014 AI is a secondary feature", description: "AI enhances some features but is not the core" },
+      { value: "no", label: "No AI features", description: "Pure logic, no LLM integration" }
+    ]
+  },
+  {
+    id: "ai_providers",
+    step: 2,
+    category: "Tech Stack",
+    question: "Which AI providers will you use?",
+    hint: "Select all that apply",
+    type: "multiselect",
+    required: false,
+    dependsOn: { questionId: "ai_features", value: ["yes_core", "yes_secondary"] },
+    options: [
+      { value: "openai", label: "OpenAI" },
+      { value: "anthropic", label: "Anthropic (Claude)" },
+      { value: "deepseek", label: "DeepSeek" },
+      { value: "google", label: "Google Gemini" },
+      { value: "ollama", label: "Ollama (local)" },
+      { value: "model_agnostic", label: "Model-agnostic (any provider)" }
+    ]
+  },
+  {
+    id: "python_framework",
+    step: 2,
+    category: "Tech Stack",
+    question: "Which Python framework are you using?",
+    hint: "Determines routing, ORM, and project structure conventions",
+    type: "select",
+    required: false,
+    dependsOn: { questionId: "tech_stack", value: "python" },
+    options: [
+      { value: "django", label: "Django", description: "Full-stack web framework with ORM" },
+      { value: "fastapi", label: "FastAPI", description: "Modern async API framework" },
+      { value: "flask", label: "Flask", description: "Lightweight WSGI microframework" },
+      { value: "none", label: "No framework", description: "Pure Python / scripts" }
+    ]
+  },
+  {
+    id: "folder_structure",
+    step: 3,
+    category: "Architecture",
+    question: "Describe your folder structure.",
+    hint: "List the main folders and what they contain. The AI will use this to enforce conventions.",
+    coaching: "Impacts the ## Folder Structure section directly. A detailed tree prevents the AI from creating files in wrong places. The more specific, the better.",
+    type: "textarea",
+    placeholder: `src/
+  app/        <- Next.js App Router pages
+  components/ <- reusable UI components
+  lib/        <- utilities and helpers
+  types/      <- TypeScript types
+  hooks/      <- custom React hooks`,
+    required: true
+  },
+  {
+    id: "coding_conventions",
+    step: 3,
+    category: "Architecture",
+    question: "What are your most important coding conventions?",
+    hint: "Rules the AI must always follow when writing code for this project",
+    coaching: "These become enforced rules in the ## Coding Conventions section. More selections = more specific constraints = fewer AI mistakes. Pick at least 3.",
+    type: "multiselect",
+    required: true,
+    options: [
+      { value: "no_any", label: "No TypeScript any", description: "Strict typing, use unknown instead" },
+      { value: "no_comments", label: "No code comments", description: "Code must be self-documenting" },
+      { value: "functional", label: "Functional components only", description: "No class components" },
+      { value: "server_components", label: "Prefer Server Components", description: "Use client components only when needed" },
+      { value: "named_exports", label: "Named exports only", description: "No default exports" },
+      { value: "small_files", label: "Small focused files", description: "One responsibility per file" },
+      { value: "no_overengineering", label: "No overengineering", description: "Build the simplest thing that works" },
+      { value: "modular", label: "Modular architecture", description: "Clear separation of concerns" },
+      { value: "error_handling", label: "Explicit error handling", description: "Always handle errors gracefully" },
+      { value: "env_secrets", label: "No secrets in frontend", description: "API keys only in server/env" }
+    ]
+  },
+  {
+    id: "ui_style",
+    step: 3,
+    category: "Architecture",
+    question: "What is the UI style and tone?",
+    hint: "How should the interface feel?",
+    type: "multiselect",
+    required: false,
+    dependsOn: { questionId: "project_type", value: ["web_app", "mobile_app", "fullstack"] },
+    options: [
+      { value: "modern", label: "Modern & minimal" },
+      { value: "playful", label: "Playful & friendly" },
+      { value: "premium", label: "Premium & polished" },
+      { value: "dark", label: "Dark theme first" },
+      { value: "accessible", label: "Accessibility first" },
+      { value: "mobile_first", label: "Mobile first" },
+      { value: "pixel_perfect", label: "Pixel-perfect from designs" }
+    ]
+  },
+  {
+    id: "constraints",
+    step: 4,
+    category: "Constraints",
+    question: "What are the hard constraints for this project?",
+    hint: "Things the AI must NEVER do in this project",
+    coaching: "These become a strict ## Hard Constraints table \u2014 the most critical section. Each selected constraint is a guardrail the AI will respect on every response.",
+    type: "multiselect",
+    required: true,
+    options: [
+      { value: "no_db", label: "No database", description: "Use local state or files only" },
+      { value: "no_auth", label: "No authentication", description: "No login or user accounts" },
+      { value: "no_new_deps", label: "No new dependencies without approval", description: "Ask before adding packages" },
+      { value: "no_telemetry", label: "No telemetry or tracking", description: "No analytics or user tracking" },
+      { value: "no_breaking_changes", label: "No breaking API changes", description: "Maintain backward compatibility" },
+      { value: "offline_first", label: "Offline first", description: "Must work without internet" },
+      { value: "lightweight", label: "Keep it lightweight", description: "Minimize bundle size" },
+      { value: "no_class_components", label: "No class components" }
+    ]
+  },
+  {
+    id: "dev_philosophy",
+    step: 4,
+    category: "Constraints",
+    question: "What is your development philosophy?",
+    hint: "How should the AI approach building features?",
+    coaching: "Shapes the ## Development Philosophy section. This single choice influences how the AI balances speed vs. quality on every decision it makes.",
+    type: "select",
+    required: true,
+    options: [
+      { value: "mvp_first", label: "MVP first, iterate later", description: "Build the smallest useful version, then improve" },
+      { value: "production_grade", label: "Production-grade from day one", description: "Build it right the first time" },
+      { value: "teachable", label: "Teachable & approachable", description: "Code should be easy to understand and explain" },
+      { value: "performance", label: "Performance first", description: "Optimize for speed and efficiency" }
+    ]
+  },
+  {
+    id: "extra_context",
+    step: 4,
+    category: "Constraints",
+    question: "Any additional context or special instructions?",
+    hint: "Anything else the AI should know \u2014 edge cases, specific patterns, important decisions already made...",
+    type: "textarea",
+    placeholder: "e.g. This project uses the Vercel AI SDK for all LLM calls. The API keys are stored in .env.local and never exposed to the client. The app is deployed on Vercel...",
+    required: false
+  },
+  {
+    id: "initialize_project",
+    step: 4,
+    category: "Constraints",
+    question: "Initialize the project with a Technical Roadmap & Prompt Blueprints?",
+    hint: "If enabled, we will generate highly detailed ROADMAP.md and session-optimized PROMPTS.md files in addition to agent profiles.",
+    type: "select",
+    required: true,
+    options: [
+      { value: "yes", label: "Yes \u2014 Generate Roadmap & Prompts", description: "Create a comprehensive project execution plan" },
+      { value: "no", label: "No \u2014 Only generate AGENT.md / configs", description: "Skip roadmap and prompts creation" }
+    ]
+  }
+];
+var STEP_LABELS = {
+  1: "Identity",
+  2: "Tech Stack",
+  3: "Architecture",
+  4: "Constraints"
+};
+function isQuestionVisible(question, answers) {
+  if (!question.dependsOn) return true;
+  const { questionId, value } = question.dependsOn;
+  const answer = answers[questionId];
+  if (!answer) return false;
+  if (Array.isArray(value)) {
+    if (Array.isArray(answer)) return value.some((v) => answer.includes(v));
+    return value.includes(answer);
+  }
+  if (Array.isArray(answer)) return answer.includes(value);
+  return answer === value;
+}
+
+// ../shared/src/lib/buildPrompt.ts
+function getLabel(questionId, value) {
+  const question = QUESTIONS.find((q) => q.id === questionId);
+  if (!question?.options) return Array.isArray(value) ? value.join(", ") : value;
+  if (Array.isArray(value)) {
+    return value.map((v) => question.options?.find((o) => o.value === v)?.label ?? v).join(", ");
+  }
+  return question.options.find((o) => o.value === value)?.label ?? value;
+}
+function buildPrompt(answers) {
+  const projectName = answers["project_name"] ?? "My Project";
+  const projectType = getLabel("project_type", answers["project_type"] ?? "");
+  const description = answers["project_description"] ?? "";
+  const mobilePlatforms = answers["mobile_platforms"] ? getLabel("mobile_platforms", answers["mobile_platforms"]) : null;
+  const npmDistribution = answers["npm_distribution"] ? getLabel("npm_distribution", answers["npm_distribution"]) : null;
+  const techStack = getLabel("tech_stack", answers["tech_stack"] ?? []);
+  const pythonFramework = answers["python_framework"] ? getLabel("python_framework", answers["python_framework"]) : null;
+  const aiFeatures = getLabel("ai_features", answers["ai_features"] ?? "no");
+  const aiProviders = answers["ai_providers"] ? getLabel("ai_providers", answers["ai_providers"]) : "None";
+  const folderStructure = answers["folder_structure"] ?? "";
+  const conventions = getLabel("coding_conventions", answers["coding_conventions"] ?? []);
+  const uiStyle = answers["ui_style"] ? getLabel("ui_style", answers["ui_style"]) : "Not specified";
+  const constraints = getLabel("constraints", answers["constraints"] ?? []);
+  const devPhilosophy = getLabel("dev_philosophy", answers["dev_philosophy"] ?? "");
+  const extraContext = answers["extra_context"] ?? "";
+  const initProject = answers["initialize_project"] === "yes";
+  let systemPrompt = `You are an expert software architect. Generate a complete, detailed, and production-quality AGENT.md file for the following project.
+
+The AGENT.md is a comprehensive engineering README that will be used by AI coding assistants (like Claude, GPT-4, Kiro, Cursor) to understand the project deeply and write code that perfectly matches the project's conventions, architecture, and constraints.
+
+The output must be a single Markdown document. It must be thorough, specific, and actionable \u2014 not generic. Every section should contain real, project-specific content.
+
+Use the DeutschFlow AGENT.md and Preflight AGENT.md as structural references for quality and depth. Match that level of detail.
+
+---
+
+PROJECT INFORMATION:
+
+Project Name: ${projectName}
+Project Type: ${projectType}${mobilePlatforms ? `
+Mobile Platforms: ${mobilePlatforms}` : ""}${npmDistribution ? `
+Package Distribution: ${npmDistribution}` : ""}
+Description: ${description}
+
+Tech Stack: ${techStack}${pythonFramework ? `
+Python Framework: ${pythonFramework}` : ""}
+AI Features: ${aiFeatures}
+AI Providers: ${aiProviders}
+
+Folder Structure:
+${folderStructure}
+
+Coding Conventions: ${conventions}
+UI Style: ${uiStyle}
+Hard Constraints: ${constraints}
+Development Philosophy: ${devPhilosophy}
+${extraContext ? `
+Additional Context:
+${extraContext}` : ""}
+
+---
+
+Generate the AGENT.md with these sections (adapt section names to fit the project):
+
+1. A header introducing the AI assistant's role for this specific project
+2. Project Identity (name, vision, what makes it unique)
+3. Core Product Principles (what it does and does NOT do)
+4. Important Constraints (VERY IMPORTANT section \u2014 hard rules)
+5. Tech Stack (with specific versions/choices and why)
+6. Folder Structure (with role of each folder/file)
+7. Architecture Guidelines (patterns, naming conventions, component rules)
+8. Coding Conventions (with \u2705 CORRECT and \u274C INCORRECT examples where useful)
+9. TypeScript Rules (if applicable)
+10. Feature Implementation Rules (step-by-step process)
+11. Development Philosophy
+12. Decision Making & Clarifications
+13. Communication Style
+14. Final Reminder
+
+Rules for the output:
+- Be specific to THIS project, not generic
+- Use real code examples that match the tech stack
+- Include \u2705 CORRECT / \u274C INCORRECT examples for important rules
+- Use tables where they add clarity
+- Keep the tone direct and professional
+- No filler content \u2014 every sentence must be actionable
+- The document should be long enough to be genuinely useful (aim for 600-1000 lines)`;
+  if (initProject) {
+    systemPrompt += `
+
+================================================================================
+CRITICAL WORKSPACE INITIALIZATION FILES REQUESTED
+================================================================================
+Because the user selected "Yes" to project initialization, in addition to the AGENT.md file, you MUST generate two other files: ROADMAP.md and PROMPTS.md.
+You MUST output ALL THREE FILES inside a single response, separated EXACTLY by these custom line-delimiters (do not wrap the delimiters in code blocks, write them as plain text on their own lines):
+
+===AGENT_MD===
+[Place the complete AGENT.md text here]
+===ROADMAP_MD===
+[Place the complete, highly detailed ROADMAP.md text here]
+===PROMPTS_MD===
+[Place the complete, advanced PROMPTS.md text here]
+
+--------------------------------------------------------------------------------
+SPECIFIC FILE REQUIREMENTS:
+--------------------------------------------------------------------------------
+
+1. ROADMAP.md:
+   - Must be a highly detailed, highly technical project implementation roadmap.
+   - Break down the target product features into clear, logical milestones and phases.
+   - For each feature/task, list specific architectural guidelines, implementation checklists, and structural changes.
+   - The roadmap must be extremely robust and powerful, specifically designed for an AI Coding Agent to read, parse, and execute cleanly step-by-step.
+
+2. PROMPTS.md:
+   - Provide a set of advanced, production-ready engineering prompt blueprints for each and every feature or step defined in the ROADMAP.md.
+   - Every single feature prompt MUST start with a phrase like:
+     "Read the AGENT.md/AGENTS.md file in the root directory and follow its rules strictly."
+   - Provide highly precise, well-structured prompt blueprints that guide the AI to implement the feature exactly according to the conventions.
+   - CRITICAL: For each prompt, include a section called "Session-Saving Tip" that advises the user to start a new chat/agent session for that feature, pointing out that because AGENT.md contains all the context and constraints of the codebase, clean independent chat sessions will save massive amounts of tokens, prevent prompt/context dilution, and guarantee high-quality execution.
+
+--------------------------------------------------------------------------------
+`;
+  }
+  systemPrompt += `
+- Output ONLY the Markdown content, no preamble, no explanation`;
+  return systemPrompt;
+}
+
+// ../shared/src/lib/buildUpdatePrompt.ts
+function buildUpdatePrompt(existingContent, changeDescription) {
+  return `You are an expert software architect. You are updating an existing AGENT.md file based on specific change instructions.
+
+CHANGE INSTRUCTIONS FROM THE USER:
+${changeDescription}
+
+---
+
+EXISTING AGENT.md (TO BE UPDATED):
+${existingContent}
+
+---
+
+CRITICAL REQUIREMENTS FOR THE UPDATE:
+1. STRICT PRESERVATION: Do NOT delete, summarize, truncate, or omit any section, paragraph, rule, list item, or code snippet from the original document unless the change instructions explicitly demand its removal. Everything else must remain 100% intact.
+2. TARGETED MODIFICATION: Only modify the specific parts of the document that are directly relevant to the user's change instructions.
+3. CONTEXT INTEGRATION: If adding a new section, insert it at the most logical position within the document structure (e.g. adding a "Testing" section right after "Coding Conventions" or "Tech Stack").
+4. MAINTAIN STYLE: Keep the exact same tone, document layout, formatting, and markdown styles. If the original uses a specific visual style like checklist boxes [ ] or correct/incorrect emoji blocks (\u2705 CORRECT / \u274C INCORRECT), you MUST use that exact same style for the new content.
+5. HEADING HIERARCHY: Maintain the same markdown heading nesting (e.g., #, ##, ###).
+6. COMPLETE OUTPUT: You must output the ENTIRE updated AGENT.md file from start to finish. Do NOT output a diff, do NOT output only the modified parts, and do NOT truncate the document with placeholders like "... [rest of document] ...".
+7. CLEAN MARKDOWN: Output ONLY valid Markdown. Do NOT wrap the markdown in a code block, do NOT write any intro/outro explanations, and do NOT include any conversational responses. Start immediately with the updated content.`;
+}
+
+// ../shared/src/lib/formatOutput.ts
+var OUTPUT_FORMATS = [
+  { label: "AGENT.md", filename: "AGENT.md", tool: "Kiro" },
+  { label: "CLAUDE.md", filename: "CLAUDE.md", tool: "Claude Code" },
+  { label: ".cursorrules", filename: ".cursorrules", tool: "Cursor" },
+  { label: ".windsurfrules", filename: ".windsurfrules", tool: "Windsurf" },
+  { label: "copilot-instructions.md", filename: "copilot-instructions.md", tool: "GitHub Copilot" }
+];
+
+// ../shared/src/lib/parseManifest.ts
+var PACKAGE_TO_STACK = {
+  next: "nextjs",
+  react: "react",
+  "react-dom": "react",
+  "react-native": "react_native",
+  expo: "expo",
+  tailwindcss: "tailwind",
+  "@prisma/client": "prisma",
+  prisma: "prisma",
+  "@supabase/supabase-js": "supabase",
+  zustand: "zustand",
+  zod: "zod",
+  ai: "vercel_ai",
+  "@ai-sdk/openai": "vercel_ai",
+  "@ai-sdk/anthropic": "vercel_ai",
+  "@ai-sdk/deepseek": "vercel_ai",
+  "@ai-sdk/google": "vercel_ai",
+  "@ai-sdk/xai": "vercel_ai",
+  typescript: "typescript"
+};
+var REQUIREMENTS_TO_STACK = {
+  django: "python",
+  flask: "python",
+  fastapi: "python",
+  uvicorn: "python",
+  sqlalchemy: "python",
+  pytest: "python",
+  pydantic: "python",
+  numpy: "python",
+  pandas: "python"
+};
+function parsePackageJson(text4) {
+  try {
+    const pkg = JSON.parse(text4);
+    const deps = pkg.dependencies && typeof pkg.dependencies === "object" ? pkg.dependencies : {};
+    const devDeps = pkg.devDependencies && typeof pkg.devDependencies === "object" ? pkg.devDependencies : {};
+    const allDeps = { ...deps, ...devDeps };
+    const found = /* @__PURE__ */ new Set(["nodejs"]);
+    for (const dep of Object.keys(allDeps)) {
+      const mapped = PACKAGE_TO_STACK[dep];
+      if (mapped) found.add(mapped);
+    }
+    return Array.from(found);
+  } catch {
+    return [];
+  }
+}
+function parseRequirementsTxt(text4) {
+  const found = /* @__PURE__ */ new Set();
+  for (const line of text4.split("\n")) {
+    const pkg = line.split(/[>=<!]/)[0].trim().toLowerCase();
+    if (!pkg || pkg.startsWith("#")) continue;
+    const mapped = REQUIREMENTS_TO_STACK[pkg];
+    if (mapped) found.add(mapped);
+  }
+  if (found.size > 0) found.add("python");
+  return Array.from(found);
+}
+function parseManifest(filename, text4) {
+  if (filename === "package.json" || filename.endsWith("/package.json")) return parsePackageJson(text4);
+  if (filename === "requirements.txt" || filename.endsWith("/requirements.txt")) return parseRequirementsTxt(text4);
+  return [];
+}
+function parsePackageJsonMeta(text4) {
+  try {
+    const pkg = JSON.parse(text4);
+    return { name: pkg.name, description: pkg.description };
+  } catch {
+    return {};
+  }
+}
+
+// ../shared/src/lib/scoreOutput.ts
+var CANONICAL_SECTIONS = [
+  "Tech Stack",
+  "Architecture",
+  "Constraints",
+  "Coding Conventions",
+  "Development Philosophy",
+  "Folder Structure",
+  "TypeScript",
+  "Feature Implementation",
+  "Decision Making",
+  "Communication Style",
+  "Testing",
+  "Security"
+];
+function scoreOutput(content) {
+  const sections = CANONICAL_SECTIONS.map((label) => ({
+    label,
+    present: new RegExp(`#{1,3}\\s+[^\\n]*${label}`, "i").test(content)
+  }));
+  return {
+    found: sections.filter((s) => s.present).length,
+    total: sections.length,
+    sections
+  };
+}
+
+// ../shared/src/lib/shareConfig.ts
+function encodeConfig(answers) {
+  const json = JSON.stringify(answers);
+  return Buffer.from(json).toString("base64url");
+}
+function buildShareUrl(answers, baseUrl = "https://agent-md-generator.edwinfom.dev") {
+  return `${baseUrl}?config=${encodeConfig(answers)}`;
+}
+
+// ../shared/src/lib/templates.ts
+var TEMPLATES = [
+  {
+    id: "nextjs_saas",
+    name: "Next.js SaaS",
+    description: "Full-stack web app with authentication, database, and modern UI",
+    stack: "TypeScript \xB7 React \xB7 Next.js \xB7 Tailwind \xB7 Prisma \xB7 Supabase",
+    answers: {
+      project_type: "web_app",
+      tech_stack: ["typescript", "react", "nextjs", "tailwind", "prisma", "supabase"],
+      ai_features: "no",
+      coding_conventions: ["no_any", "functional", "server_components", "named_exports", "env_secrets"],
+      dev_philosophy: "production_grade",
+      constraints: ["no_telemetry"],
+      ui_style: ["modern", "accessible"]
+    }
+  },
+  {
+    id: "api_backend",
+    name: "API Backend Node.js",
+    description: "Lightweight REST or RPC backend with schema validation",
+    stack: "TypeScript \xB7 Node.js \xB7 Fastify / Hono \xB7 Zod",
+    answers: {
+      project_type: "api_backend",
+      tech_stack: ["typescript", "nodejs", "zod"],
+      ai_features: "no",
+      coding_conventions: ["no_any", "named_exports", "small_files", "error_handling", "env_secrets"],
+      dev_philosophy: "production_grade",
+      constraints: ["no_new_deps"]
+    }
+  },
+  {
+    id: "mobile_rn",
+    name: "Mobile React Native",
+    description: "Cross-platform mobile app for iOS and Android",
+    stack: "TypeScript \xB7 React Native \xB7 Expo",
+    answers: {
+      project_type: "mobile_app",
+      tech_stack: ["typescript", "react", "react_native", "expo"],
+      ai_features: "no",
+      coding_conventions: ["no_any", "functional", "named_exports"],
+      dev_philosophy: "mvp_first",
+      constraints: ["lightweight"],
+      ui_style: ["mobile_first", "accessible"]
+    }
+  },
+  {
+    id: "fullstack_monorepo",
+    name: "Full-Stack Monorepo",
+    description: "Frontend and backend in one repo, sharing types and tooling",
+    stack: "TypeScript \xB7 React \xB7 Next.js \xB7 Node.js \xB7 Prisma",
+    answers: {
+      project_type: "fullstack",
+      tech_stack: ["typescript", "react", "nextjs", "nodejs", "prisma"],
+      ai_features: "no",
+      coding_conventions: ["no_any", "functional", "named_exports", "modular", "env_secrets"],
+      dev_philosophy: "production_grade",
+      constraints: ["no_new_deps", "no_telemetry"],
+      ui_style: ["modern"]
+    }
+  },
+  {
+    id: "cli_tool",
+    name: "CLI Tool",
+    description: "Command-line application distributed via npm",
+    stack: "TypeScript \xB7 Node.js",
+    answers: {
+      project_type: "cli_tool",
+      tech_stack: ["typescript", "nodejs", "zod"],
+      ai_features: "no",
+      coding_conventions: ["no_any", "named_exports", "small_files", "error_handling"],
+      dev_philosophy: "mvp_first",
+      constraints: ["lightweight", "offline_first"]
+    }
+  }
+];
+
+// ../shared/src/lib/validateOutput.ts
+var SECTION_GROUPS = [
+  {
+    label: "Tech Stack",
+    patterns: ["tech stack", "technology", "dependencies", "stack"]
+  },
+  {
+    label: "Architecture / Structure",
+    patterns: ["architecture", "folder structure", "project structure", "structure", "layout"]
+  },
+  {
+    label: "Constraints",
+    patterns: ["constraint", "hard rule", "never do", "restriction", "must not", "do not"]
+  },
+  {
+    label: "Coding Conventions",
+    patterns: ["coding convention", "code style", "convention", "style guide"]
+  },
+  {
+    label: "Commands / Workflow",
+    patterns: ["command", "script", "workflow", "build", "run ", "development setup", "getting started"]
+  },
+  {
+    label: "Philosophy",
+    patterns: ["philosophy", "principle", "approach", "mindset", "development philosophy"]
+  },
+  {
+    label: "Identity / Overview",
+    patterns: ["identity", "overview", "project identity", "vision", "what it does", "introduction"]
+  }
+];
+var MIN_LENGTH = 2e3;
+var MIN_SECTIONS = 5;
+function isSectionPresent(content, patterns) {
+  return patterns.some(
+    (pattern) => new RegExp(`#{1,3}\\s+[^\\n]*${pattern}`, "i").test(content)
+  );
+}
+function validateOutput(content) {
+  const warnings = [];
+  if (content.length < MIN_LENGTH) {
+    warnings.push(
+      `Generated file is too short (${content.length} chars \u2014 expected \u2265 ${MIN_LENGTH}). The output may be incomplete.`
+    );
+  }
+  const results = SECTION_GROUPS.map((g) => ({
+    label: g.label,
+    present: isSectionPresent(content, g.patterns)
+  }));
+  const presentCount = results.filter((r) => r.present).length;
+  const missing = results.filter((r) => !r.present).map((r) => r.label);
+  if (presentCount < MIN_SECTIONS) {
+    warnings.push(
+      `Only ${presentCount}/${SECTION_GROUPS.length} expected sections found. Missing: ${missing.join(", ")}.`
+    );
+  }
+  return { warnings };
+}
+
+// src/detect.ts
+import * as p from "@clack/prompts";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { basename, extname, join } from "path";
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  "out",
+  ".turbo",
+  ".cache",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".env",
+  "env",
+  "target",
+  "vendor",
+  ".cargo",
+  "coverage",
+  ".nyc_output",
+  "storybook-static",
+  ".vercel",
+  ".swc",
+  "tmp",
+  ".tmp"
+]);
+var IGNORE_EXTS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".ico",
+  ".webp",
+  ".avif",
+  ".svg",
+  ".ttf",
+  ".woff",
+  ".woff2",
+  ".eot",
+  ".otf",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".wasm",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".rar",
+  ".7z",
+  ".bz2",
+  ".pdf",
+  ".mp4",
+  ".mp3",
+  ".mov",
+  ".avi",
+  ".wav",
+  ".tsbuildinfo",
+  ".DS_Store",
+  ".pyc",
+  ".db",
+  ".sqlite",
+  ".sqlite3",
+  ".bin",
+  ".dat",
+  ".lock"
+]);
+var IGNORE_FILES = /* @__PURE__ */ new Set([
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "poetry.lock",
+  "bun.lockb",
+  "Cargo.lock",
+  ".DS_Store",
+  "Thumbs.db",
+  ".gitkeep",
+  "next-env.d.ts",
+  ".env",
+  ".env.local",
+  ".env.production",
+  ".env.development"
+]);
+var PROJECT_MARKERS = {
+  "package.json": "npm",
+  "pyproject.toml": "python",
+  "requirements.txt": "python",
+  "go.mod": "go",
+  "Cargo.toml": "rust"
+};
+var MAX_DEPTH = 6;
+var MAX_FILES_PER_DIR = 40;
+function buildTree(dirPath, prefix = "", depth = 0) {
+  if (depth > MAX_DEPTH) return "";
+  let entries;
+  try {
+    entries = readdirSync(dirPath);
+  } catch {
+    return "";
+  }
+  const dirs = [];
+  const files = [];
+  for (const entry of entries) {
+    if (entry.startsWith(".") && entry !== ".env.example" && entry !== ".gitignore") {
+      if (IGNORE_DIRS.has(entry)) continue;
+    }
+    if (IGNORE_DIRS.has(entry)) continue;
+    if (IGNORE_FILES.has(entry)) continue;
+    const ext = extname(entry).toLowerCase();
+    if (IGNORE_EXTS.has(ext)) continue;
+    const fullPath = join(dirPath, entry);
+    let stat;
+    try {
+      stat = statSync(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      dirs.push(entry);
+    } else {
+      files.push(entry);
+    }
+  }
+  const lines = [];
+  const allEntries = [...dirs.sort(), ...files.sort()].slice(0, MAX_FILES_PER_DIR);
+  for (let i = 0; i < allEntries.length; i++) {
+    const entry = allEntries[i];
+    const isLast = i === allEntries.length - 1;
+    const isDir = dirs.includes(entry);
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const childPrefix = prefix + (isLast ? "    " : "\u2502   ");
+    if (isDir) {
+      lines.push(`${prefix}${connector}${entry}/`);
+      const sub = buildTree(join(dirPath, entry), childPrefix, depth + 1);
+      if (sub) lines.push(sub);
+    } else {
+      lines.push(`${prefix}${connector}${entry}`);
+    }
+  }
+  return lines.join("\n");
+}
+function detectMarker(rootPath) {
+  for (const [marker, type] of Object.entries(PROJECT_MARKERS)) {
+    if (existsSync(join(rootPath, marker))) {
+      return { type, file: marker };
+    }
+  }
+  return { type: "unknown" };
+}
+function isEmptyish(rootPath) {
+  try {
+    const entries = readdirSync(rootPath).filter((e) => !e.startsWith("."));
+    return entries.length === 0;
+  } catch {
+    return false;
+  }
+}
+async function detectProject(startPath) {
+  let rootPath = startPath;
+  if (isEmptyish(rootPath)) {
+    p.log.warn("The current directory seems empty or does not contain a project.");
+    const entered = await p.text({
+      message: "Path to your project (absolute or relative):",
+      placeholder: "e.g. ../my-project or C:/Users/you/projects/my-app",
+      validate: (v) => {
+        if (!v.trim()) return "Project path is required.";
+        if (!existsSync(v.trim())) return `Directory not found: ${v.trim()}`;
+      }
+    });
+    if (p.isCancel(entered)) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+    rootPath = entered.trim();
+  }
+  const { type: manifestType, file: manifestFile } = detectMarker(rootPath);
+  let techStack = [];
+  let projectName = basename(rootPath);
+  let description = "";
+  if (manifestFile) {
+    const manifestPath = join(rootPath, manifestFile);
+    try {
+      const content = readFileSync(manifestPath, "utf-8");
+      techStack = parseManifest(manifestFile, content);
+      if (manifestFile === "package.json") {
+        const meta = parsePackageJsonMeta(content);
+        if (meta.name) projectName = meta.name;
+        if (meta.description) description = meta.description;
+      } else if (manifestFile === "go.mod") {
+        const match = content.match(/^module\s+(\S+)/m);
+        if (match) projectName = match[1].split("/").pop() ?? projectName;
+      } else if (manifestFile === "Cargo.toml") {
+        const nameMatch = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
+        if (nameMatch) projectName = nameMatch[1];
+      }
+    } catch {
+    }
+  }
+  const rootLine = `${basename(rootPath)}/`;
+  const childTree = buildTree(rootPath);
+  const tree = childTree ? `${rootLine}
+${childTree}` : rootLine;
+  return { rootPath, tree, techStack, projectName, description, manifestType };
+}
+
+// src/models.ts
+import * as p2 from "@clack/prompts";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { resolve } from "path";
+var MODELS = [
+  {
+    provider: "deepseek",
+    modelId: "deepseek-chat",
+    label: "DeepSeek Chat",
+    envKey: "DEEPSEEK_API_KEY",
+    hint: "Fast \xB7 Cheap \xB7 Recommended \u2014 platform.deepseek.com"
+  },
+  {
+    provider: "deepseek",
+    modelId: "deepseek-reasoner",
+    label: "DeepSeek Reasoner (R1)",
+    envKey: "DEEPSEEK_API_KEY",
+    hint: "Slower \xB7 Best for complex reasoning"
+  },
+  {
+    provider: "google",
+    modelId: "gemini-2.0-flash",
+    label: "Gemini 2.0 Flash",
+    envKey: "GOOGLE_GENERATIVE_AI_API_KEY",
+    hint: "Fast \xB7 Multimodal \u2014 aistudio.google.com"
+  },
+  {
+    provider: "google",
+    modelId: "gemini-1.5-pro",
+    label: "Gemini 1.5 Pro",
+    envKey: "GOOGLE_GENERATIVE_AI_API_KEY",
+    hint: "Long context (2M tokens) \xB7 High quality"
+  },
+  {
+    provider: "xai",
+    modelId: "grok-beta",
+    label: "Grok Beta",
+    envKey: "XAI_API_KEY",
+    hint: "xAI \xB7 Recent knowledge \u2014 console.x.ai"
+  },
+  {
+    provider: "xai",
+    modelId: "grok-3-mini",
+    label: "Grok 3 Mini",
+    envKey: "XAI_API_KEY",
+    hint: "xAI \xB7 Fast \xB7 Cost-effective"
+  },
+  {
+    provider: "ollama",
+    modelId: "llama3.2",
+    label: "Llama 3.2 (Local Ollama)",
+    envKey: null,
+    hint: "Local \xB7 Free \xB7 No API key required \u2014 ollama.com"
+  },
+  {
+    provider: "ollama",
+    modelId: "mistral",
+    label: "Mistral (Local Ollama)",
+    envKey: null,
+    hint: "Local \xB7 Free \xB7 Good for coding"
+  }
+];
+function loadEnv(cwd) {
+  const envPath = resolve(cwd, ".env.local");
+  const env = {};
+  if (!existsSync2(envPath)) return env;
+  const lines = readFileSync2(envPath, "utf-8").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    const val = trimmed.slice(eqIndex + 1).trim().replace(/^["']|["']$/g, "");
+    env[key] = val;
+  }
+  return env;
+}
+function saveKeyToEnvLocal(cwd, key, value) {
+  const envPath = resolve(cwd, ".env.local");
+  const existing = existsSync2(envPath) ? readFileSync2(envPath, "utf-8") : "";
+  const line = `${key}=${value}
+`;
+  const updated = existing.endsWith("\n") || existing === "" ? existing + line : existing + "\n" + line;
+  writeFileSync(envPath, updated, "utf-8");
+}
+async function checkOllamaRunning() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2e3);
+    const res = await fetch("http://localhost:11434/api/tags", { signal: controller.signal });
+    clearTimeout(timeout);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function selectModel(cwd) {
+  const env = { ...loadEnv(cwd), ...process.env };
+  const options = MODELS.map((m) => {
+    const hasKey = m.envKey === null || Boolean(env[m.envKey]);
+    return {
+      value: m.modelId,
+      label: `${m.label}${hasKey ? "  \u2713" : ""}`,
+      hint: hasKey && m.envKey ? "API key found" : m.hint
+    };
+  });
+  const chosen = await p2.select({
+    message: "Which model do you want to use for generation?",
+    options
+  });
+  if (p2.isCancel(chosen)) {
+    p2.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const config = MODELS.find((m) => m.modelId === chosen);
+  if (config.provider === "ollama") {
+    const running = await checkOllamaRunning();
+    if (!running) {
+      p2.log.warn(
+        "Ollama does not seem to be running on localhost:11434.\nStart it with: ollama serve\nThen in another terminal run: ollama pull " + config.modelId
+      );
+      const cont = await p2.confirm({ message: "Continue anyway?", initialValue: false });
+      if (p2.isCancel(cont) || !cont) {
+        p2.cancel("Cancelled.");
+        process.exit(0);
+      }
+    } else {
+      p2.log.success(`Ollama detected on localhost:11434`);
+    }
+    return { config, apiKey: null };
+  }
+  const envKeyName = config.envKey;
+  let apiKey = env[envKeyName];
+  if (!apiKey) {
+    const entered = await p2.password({
+      message: `Enter your API key for ${config.label} (${envKeyName})`,
+      validate: (v) => !v.trim() ? "API key is required." : void 0
+    });
+    if (p2.isCancel(entered)) {
+      p2.cancel("Cancelled.");
+      process.exit(0);
+    }
+    apiKey = entered;
+    const save = await p2.confirm({
+      message: `Save ${envKeyName} to .env.local for future use?`,
+      initialValue: true
+    });
+    if (!p2.isCancel(save) && save) {
+      saveKeyToEnvLocal(cwd, envKeyName, apiKey);
+      p2.log.success(`.env.local updated with ${envKeyName}`);
+    }
+  } else {
+    p2.log.success(`API key ${envKeyName} found in the environment`);
+  }
+  return { config, apiKey };
+}
+
+// src/generate.ts
+import { createDeepSeek } from "@ai-sdk/deepseek";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createXai } from "@ai-sdk/xai";
+import { createOllama } from "ollama-ai-provider";
+import { streamText } from "ai";
+function createLanguageModel(config, apiKey) {
+  switch (config.provider) {
+    case "deepseek": {
+      const deepseek = createDeepSeek({ apiKey });
+      return deepseek(config.modelId);
+    }
+    case "google": {
+      const google = createGoogleGenerativeAI({ apiKey });
+      return google(config.modelId);
+    }
+    case "xai": {
+      const xai = createXai({ apiKey });
+      return xai(config.modelId);
+    }
+    case "ollama": {
+      const ollama = createOllama({ baseURL: "http://localhost:11434/api" });
+      return ollama(config.modelId);
+    }
+  }
+}
+async function callModel(config, apiKey, prompt, onChunk) {
+  const model = createLanguageModel(config, apiKey);
+  const { fullStream } = streamText({
+    model,
+    prompt,
+    temperature: 0.3,
+    maxOutputTokens: 8e3
+  });
+  let fullText = "";
+  for await (const part of fullStream) {
+    if (part.type === "text-delta") {
+      fullText += part.textDelta;
+      onChunk(part.textDelta);
+    }
+  }
+  return fullText;
+}
+
+// src/history.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import * as p3 from "@clack/prompts";
+var HISTORY_DIR = join2(homedir(), ".agent-md-generator");
+var HISTORY_FILE = join2(HISTORY_DIR, "history.json");
+var MAX_ENTRIES = 5;
+function saveToCliHistory(answers, content, modelLabel) {
+  const entry = {
+    id: Date.now().toString(),
+    timestamp: Date.now(),
+    projectName: answers["project_name"] || "Untitled",
+    modelLabel,
+    contentLength: content.length,
+    content
+  };
+  const existing = loadCliHistory();
+  const updated = [entry, ...existing].slice(0, MAX_ENTRIES);
+  try {
+    if (!existsSync3(HISTORY_DIR)) {
+      mkdirSync(HISTORY_DIR, { recursive: true });
+    }
+    writeFileSync2(HISTORY_FILE, JSON.stringify(updated, null, 2), "utf-8");
+  } catch {
+  }
+}
+function loadCliHistory() {
+  try {
+    if (!existsSync3(HISTORY_FILE)) return [];
+    const raw = readFileSync3(HISTORY_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+async function showHistory() {
+  const entries = loadCliHistory();
+  if (entries.length === 0) {
+    p3.log.info("No generation history found.");
+    return;
+  }
+  p3.log.info(`Latest ${entries.length} generation(s):
+`);
+  for (const entry of entries) {
+    const date = new Date(entry.timestamp).toLocaleString("en-US");
+    const lines = entry.content.split("\n").length;
+    p3.log.message(
+      `  ${entry.projectName}  \xB7  ${entry.modelLabel}  \xB7  ${lines} lines
+  ${date}
+`
+    );
+  }
+  const chosen = await p3.select({
+    message: "What would you like to do?",
+    options: [
+      { value: "view", label: "View the latest generation" },
+      { value: "exit", label: "Exit" }
+    ]
+  });
+  if (p3.isCancel(chosen) || chosen === "exit") return;
+  if (chosen === "view" && entries[0]) {
+    console.log("\n" + "\u2500".repeat(60));
+    console.log(entries[0].content);
+    console.log("\u2500".repeat(60) + "\n");
+  }
+}
+
+// src/prompts.ts
+import * as p4 from "@clack/prompts";
+async function promptQuestion(question, prefill) {
+  const message = question.hint ? `${question.question}
+  ${question.hint}` : question.question;
+  switch (question.type) {
+    case "text":
+    case "textarea":
+      return p4.text({
+        message,
+        placeholder: question.placeholder,
+        initialValue: typeof prefill === "string" ? prefill : void 0,
+        validate: question.required ? (v) => v.trim() === "" ? "This field is required." : void 0 : void 0
+      });
+    case "select":
+      return p4.select({
+        message,
+        options: (question.options ?? []).map((o) => ({
+          value: o.value,
+          label: o.label,
+          hint: o.description
+        })),
+        initialValue: typeof prefill === "string" ? prefill : void 0
+      });
+    case "multiselect":
+      return p4.multiselect({
+        message,
+        options: (question.options ?? []).map((o) => ({
+          value: o.value,
+          label: o.label,
+          hint: o.description
+        })),
+        required: question.required,
+        initialValues: Array.isArray(prefill) ? prefill : void 0
+      });
+  }
+}
+function reviewAnswers(answers) {
+  const steps = [1, 2, 3, 4];
+  for (const step of steps) {
+    const stepLabel = STEP_LABELS[step] ?? `Step ${step}`;
+    const stepQuestions = QUESTIONS.filter(
+      (q) => q.step === step && isQuestionVisible(q, answers)
+    );
+    const lines = [];
+    for (const q of stepQuestions) {
+      const val = answers[q.id];
+      if (!val) continue;
+      const displayVal = Array.isArray(val) ? val.join(", ") : val;
+      lines.push(`  ${q.question.split("?")[0]}:
+    ${displayVal}`);
+    }
+    if (lines.length > 0) {
+      p4.log.step(`Step ${step} \u2014 ${stepLabel}`);
+      p4.log.message(lines.join("\n"));
+    }
+  }
+}
+
+// src/index.ts
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = { update: false, history: false, yes: false, init: false, templateId: void 0 };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--update") result.update = true;
+    else if (args[i] === "--history") result.history = true;
+    else if (args[i] === "--yes") result.yes = true;
+    else if (args[i] === "--init") result.init = true;
+    else if (args[i] === "--template" && args[i + 1]) {
+      result.templateId = args[i + 1];
+      i++;
+    }
+  }
+  return result;
+}
+function loadEnvLocal(cwd) {
+  const envPath = resolve2(cwd, ".env.local");
+  const env = {};
+  if (!existsSync4(envPath)) return env;
+  const lines = readFileSync4(envPath, "utf-8").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    const val = trimmed.slice(eqIndex + 1).trim().replace(/^["']|["']$/g, "");
+    env[key] = val;
+    if (!process.env[key]) process.env[key] = val;
+  }
+  return env;
+}
+async function runUpdateMode(cwd) {
+  let agentMdPath = resolve2(cwd, "AGENT.md");
+  if (!existsSync4(agentMdPath)) {
+    const entered = await p5.text({
+      message: "Path to AGENT.md to update:",
+      validate: (v) => {
+        if (!v.trim()) return "Required.";
+        if (!existsSync4(v.trim())) return `File not found: ${v}`;
+      }
+    });
+    if (p5.isCancel(entered)) {
+      p5.cancel("Cancelled.");
+      process.exit(0);
+    }
+    agentMdPath = entered.trim();
+  }
+  const existingContent = readFileSync4(agentMdPath, "utf-8");
+  p5.log.success(`AGENT.md loaded (${existingContent.split("\n").length} lines)`);
+  const change = await p5.text({
+    message: "What do you want to change or add?",
+    placeholder: "e.g. Add a Testing section with Jest. Update the tech stack with Drizzle.",
+    validate: (v) => !v.trim() ? "Required." : void 0
+  });
+  if (p5.isCancel(change)) {
+    p5.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const { config, apiKey } = await selectModel(cwd);
+  console.log("\n");
+  p5.log.step(`Updating with ${config.label}...`);
+  console.log("\u2500".repeat(60));
+  const prompt = buildUpdatePrompt(existingContent, change);
+  let content = "";
+  try {
+    content = await callModel(config, apiKey, prompt, (chunk) => {
+      process.stdout.write(chunk);
+    });
+  } catch (err) {
+    console.log("\n");
+    p5.cancel(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+  console.log("\n" + "\u2500".repeat(60) + "\n");
+  writeFileSync3(agentMdPath, content, "utf-8");
+  p5.outro(`\u2713 AGENT.md updated \u2192 ${agentMdPath}`);
+}
+function splitInitOutput(raw) {
+  if (!raw.includes("===AGENT_MD===")) return { agent: raw };
+  const agentMatch = raw.match(/===AGENT_MD===([\s\S]*?)(?:===ROADMAP_MD===|$)/);
+  const roadmapMatch = raw.match(/===ROADMAP_MD===([\s\S]*?)(?:===PROMPTS_MD===|$)/);
+  const promptsMatch = raw.match(/===PROMPTS_MD===([\s\S]*)$/);
+  return {
+    agent: agentMatch?.[1]?.trim() ?? raw,
+    roadmap: roadmapMatch?.[1]?.trim(),
+    prompts: promptsMatch?.[1]?.trim()
+  };
+}
+async function main() {
+  const cwd = process.cwd();
+  const loadedEnv = loadEnvLocal(cwd);
+  const args = parseArgs();
+  console.clear();
+  p5.intro("  agent-md-generator  ");
+  if (args.history) {
+    await showHistory();
+    process.exit(0);
+  }
+  if (args.update) {
+    await runUpdateMode(cwd);
+    process.exit(0);
+  }
+  if (args.init) {
+    p5.log.step("Running automatic non-interactive initialization...");
+    const detected2 = await detectProject(cwd);
+    const env = { ...loadedEnv, ...process.env };
+    let selectedConfig = MODELS[0];
+    let apiKey2 = null;
+    if (env.DEEPSEEK_API_KEY) {
+      selectedConfig = MODELS.find((m) => m.modelId === "deepseek-chat");
+      apiKey2 = env.DEEPSEEK_API_KEY;
+    } else if (env.GOOGLE_GENERATIVE_AI_API_KEY) {
+      selectedConfig = MODELS.find((m) => m.modelId === "gemini-2.0-flash");
+      apiKey2 = env.GOOGLE_GENERATIVE_AI_API_KEY;
+    } else if (env.XAI_API_KEY) {
+      selectedConfig = MODELS.find((m) => m.modelId === "grok-3-mini");
+      apiKey2 = env.XAI_API_KEY;
+    } else {
+      selectedConfig = MODELS.find((m) => m.modelId === "llama3.2");
+      apiKey2 = null;
+      p5.log.info("No API keys found in environment, falling back to local Llama 3.2 Ollama.");
+    }
+    const answers2 = {
+      project_name: detected2.projectName || "Untitled Project",
+      project_type: detected2.manifestType === "unknown" ? "web_app" : detected2.manifestType === "npm" ? "web_app" : "other",
+      project_description: detected2.description || "A software application project.",
+      tech_stack: detected2.techStack.length ? detected2.techStack : ["typescript"],
+      ai_features: "no",
+      folder_structure: detected2.tree,
+      coding_conventions: ["no_any", "small_files", "named_exports"],
+      dev_philosophy: "production_grade",
+      constraints: ["no_telemetry"],
+      initialize_project: "no"
+    };
+    p5.log.step(`Generating AGENT.md using ${selectedConfig.label}...`);
+    const prompt2 = buildPrompt(answers2);
+    let rawContent2 = "";
+    try {
+      rawContent2 = await callModel(selectedConfig, apiKey2, prompt2, (chunk) => {
+        process.stdout.write(chunk);
+      });
+    } catch (err) {
+      console.log("\n");
+      p5.cancel(err instanceof Error ? err.message : "Generation error");
+      process.exit(1);
+    }
+    console.log("\n" + "\u2500".repeat(60) + "\n");
+    const { agent: agentContent2 } = splitInitOutput(rawContent2);
+    const agentPath = resolve2(detected2.rootPath, "AGENT.md");
+    const claudePath = resolve2(detected2.rootPath, "CLAUDE.md");
+    writeFileSync3(agentPath, agentContent2, "utf-8");
+    writeFileSync3(claudePath, agentContent2, "utf-8");
+    saveToCliHistory(answers2, agentContent2, selectedConfig.label);
+    p5.outro(`\u2713 Done! Initialization complete:
+  \u2192 ${agentPath}
+  \u2192 ${claudePath}`);
+    process.exit(0);
+  }
+  p5.log.step("Analyzing project...");
+  const detected = await detectProject(cwd);
+  const prefillSummary = [];
+  if (detected.projectName) prefillSummary.push(`Name: ${detected.projectName}`);
+  if (detected.techStack.length) prefillSummary.push(`Tech stack: ${detected.techStack.join(", ")}`);
+  prefillSummary.push(`Structure read from: ${detected.rootPath}`);
+  p5.log.success(`Project detected (${detected.manifestType})
+  ${prefillSummary.join("\n  ")}`);
+  const { config: modelConfig, apiKey } = await selectModel(cwd);
+  let answers = {};
+  if (args.templateId) {
+    const template = TEMPLATES.find((t) => t.id === args.templateId);
+    if (template) {
+      answers = { ...template.answers };
+      p5.log.success(`Template "${template.name}" applied`);
+    } else {
+      p5.log.warn(`Template "${args.templateId}" not found. Starting from scratch.`);
+    }
+  } else {
+    const useTemplate = await p5.select({
+      message: "Start from a template?",
+      options: [
+        { value: "__none__", label: "Start from scratch" },
+        ...TEMPLATES.map((t) => ({ value: t.id, label: t.name, hint: t.stack }))
+      ]
+    });
+    if (p5.isCancel(useTemplate)) {
+      p5.cancel("Cancelled.");
+      process.exit(0);
+    }
+    if (useTemplate !== "__none__") {
+      const template = TEMPLATES.find((t) => t.id === useTemplate);
+      answers = { ...template.answers };
+      p5.log.success(`Template "${template.name}" loaded`);
+    }
+  }
+  if (detected.projectName && !answers["project_name"]) {
+    answers["project_name"] = detected.projectName;
+  }
+  if (detected.description && !answers["project_description"]) {
+    answers["project_description"] = detected.description;
+  }
+  if (detected.techStack.length && !answers["tech_stack"]) {
+    answers["tech_stack"] = detected.techStack;
+  }
+  for (const question of QUESTIONS) {
+    if (!isQuestionVisible(question, answers)) continue;
+    if (question.id === "folder_structure") {
+      answers["folder_structure"] = detected.tree;
+      p5.log.success("Project structure auto-injected");
+      continue;
+    }
+    const prefill = answers[question.id];
+    const value = await promptQuestion(question, prefill);
+    if (p5.isCancel(value)) {
+      p5.cancel("Cancelled.");
+      process.exit(0);
+    }
+    if (value !== void 0 && (typeof value !== "string" || value !== "")) {
+      answers[question.id] = value;
+    }
+  }
+  p5.log.step("Summary of your answers:");
+  reviewAnswers(answers);
+  const confirmed = await p5.confirm({
+    message: "Generate AGENT.md now?",
+    initialValue: true
+  });
+  if (p5.isCancel(confirmed) || !confirmed) {
+    p5.cancel("Cancelled.");
+    process.exit(0);
+  }
+  console.log("\n");
+  p5.log.step(`Generating with ${modelConfig.label}...`);
+  console.log("\u2500".repeat(60));
+  const prompt = buildPrompt(answers);
+  let rawContent = "";
+  try {
+    rawContent = await callModel(modelConfig, apiKey, prompt, (chunk) => {
+      process.stdout.write(chunk);
+    });
+  } catch (err) {
+    console.log("\n");
+    p5.cancel(err instanceof Error ? err.message : "Generation error");
+    process.exit(1);
+  }
+  console.log("\n" + "\u2500".repeat(60) + "\n");
+  const { agent: agentContent, roadmap: roadmapContent, prompts: promptsContent } = splitInitOutput(rawContent);
+  const { warnings } = validateOutput(agentContent);
+  const score = scoreOutput(agentContent);
+  p5.log.step(`Validating generated content`);
+  const lines = agentContent.split("\n").length;
+  p5.log.success(`${lines} lines generated`);
+  if (warnings.length > 0) {
+    for (const w of warnings) p5.log.warn(w);
+  }
+  const scoreLabel = `${score.found}/${score.total} sections covered`;
+  if (score.found >= 8) {
+    p5.log.success(`Completeness score: ${scoreLabel}`);
+  } else {
+    p5.log.warn(`Completeness score: ${scoreLabel}`);
+  }
+  const missingSections = score.sections.filter((s) => !s.present).map((s) => s.label);
+  if (missingSections.length) {
+    p5.log.info(`Missing sections: ${missingSections.join(", ")}`);
+  }
+  const formatOptions = OUTPUT_FORMATS.map((f) => ({
+    value: f.filename,
+    label: `${f.filename}  (${f.tool})`
+  }));
+  const selectedFormats = await p5.multiselect({
+    message: "Which files do you want to generate?",
+    options: formatOptions,
+    initialValues: ["AGENT.md", "CLAUDE.md"],
+    required: true
+  });
+  if (p5.isCancel(selectedFormats)) {
+    p5.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const writtenFiles = [];
+  for (const filename of selectedFormats) {
+    const outputPath = resolve2(detected.rootPath, filename);
+    writeFileSync3(outputPath, agentContent, "utf-8");
+    writtenFiles.push(outputPath);
+  }
+  if (roadmapContent) {
+    const roadmapPath = resolve2(detected.rootPath, "ROADMAP.md");
+    writeFileSync3(roadmapPath, roadmapContent, "utf-8");
+    writtenFiles.push(roadmapPath);
+    p5.log.success("ROADMAP.md generated");
+  }
+  if (promptsContent) {
+    const promptsPath = resolve2(detected.rootPath, "PROMPTS.md");
+    writeFileSync3(promptsPath, promptsContent, "utf-8");
+    writtenFiles.push(promptsPath);
+    p5.log.success("PROMPTS.md generated");
+  }
+  saveToCliHistory(answers, agentContent, modelConfig.label);
+  const shareUrl = buildShareUrl(answers);
+  p5.log.info(`Share your config:
+  ${shareUrl}`);
+  p5.outro(
+    `\u2713 Done! Files written:
+${writtenFiles.map((f) => `  \u2192 ${f}`).join("\n")}`
+  );
+}
+main();