idea-gauntlet 0.1.0

package/dist/chunk-VQHEJYTS.js

@@ -0,0 +1,32 @@
+// src/prompts/immunePrompt.ts
+function buildImmuneSystemPrompt(role) {
+  return `You are the ${role} in IdeaGauntlet.
+Your job is to find the strongest reasons this product idea may fail.
+Do not be polite for its own sake.
+Do not give generic startup advice.
+Focus on hidden assumptions, user apathy, behavior-change cost, substitutes, distribution risk, retention risk, and monetization weakness.
+Return specific, testable objections.`;
+}
+
+// src/agents/skeptic.ts
+var skeptic = (idea) => ({
+  system: buildImmuneSystemPrompt("Skeptic"),
+  userMessage: `Product idea: ${idea.idea}${idea.targetUsers ? `
+Target users: ${idea.targetUsers.join(", ")}` : ""}${idea.market ? `
+Market: ${idea.market}` : ""}
+
+Return your critique as a JSON object with these fields:
+- coreInsight (string)
+- strongestCase (string)
+- weakestAssumption (string)
+- risks (array of {title, severity: "low"|"medium"|"high"|"critical", explanation, mitigation?})
+- assumptions (array of {title, whyItMatters, howToTest, confidence: "low"|"medium"|"high"})
+- killTests (array of {title, method, timeframe, successSignal, killSignal})
+- nextActions (array of string)
+
+Only return valid JSON. No markdown fences.`
+});
+
+export {
+  skeptic
+};

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/index.js

@@ -0,0 +1,644 @@
+#!/usr/bin/env node
+import {
+  setupCommand
+} from "../chunk-HW6JACOL.js";
+import {
+  safeWriteOutput,
+  startMcpServer
+} from "../chunk-A6GCV4RD.js";
+import {
+  buildReport,
+  getApiKey,
+  isNodeGte,
+  resolveProvider,
+  runCompareEngine,
+  runCourtEngine,
+  runImmuneEngine,
+  runMvpPlanner,
+  runUserLab
+} from "../chunk-P4FDULQC.js";
+import {
+  skeptic
+} from "../chunk-VQHEJYTS.js";
+import {
+  defender
+} from "../chunk-FF7CULAJ.js";
+
+// src/cli/index.ts
+import { cac } from "cac";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve4, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/loadIdeaFile.ts
+import { readFileSync } from "fs";
+import { isAbsolute, resolve } from "path";
+function loadIdeaInput(ideaArg) {
+  if (ideaArg.endsWith(".md") || ideaArg.includes("/") || ideaArg.includes("\\")) {
+    try {
+      const filePath = isAbsolute(ideaArg) ? ideaArg : resolve(process.cwd(), ideaArg);
+      const content = readFileSync(filePath, "utf-8").trim();
+      if (!content) throw new Error(`File is empty: ${ideaArg}`);
+      return content;
+    } catch (err) {
+      if (err.code === "ENOENT") return ideaArg;
+      throw err;
+    }
+  }
+  return ideaArg;
+}
+
+// src/utils/parseInput.ts
+function parseIdeaInput(params) {
+  return {
+    idea: params.idea,
+    mode: params.mode,
+    stage: params.stage ?? void 0,
+    market: params.market,
+    targetUsers: params.targetUsers?.split(",").map((s) => s.trim()).filter(Boolean)
+  };
+}
+function normalizeOptions(opts) {
+  const result = {};
+  for (const [key, value] of Object.entries(opts)) {
+    const camelKey = key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    result[camelKey] = value;
+  }
+  return result;
+}
+
+// src/cli/onboarding.ts
+import { createInterface } from "readline/promises";
+async function showOnboardingMenu() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  console.log("\n\u26A0 No API key or provider configured.");
+  console.log("Choose how to proceed:\n");
+  console.log("  1) Use Ollama/local model (if installed)");
+  console.log("  2) Generate structured prompt for Claude/Cursor/Codex (no API key needed)");
+  console.log("  3) Run mock/demo mode (deterministic output)");
+  console.log("  4) Configure API key now");
+  console.log("  5) Set up agent-native integration files (setup)\n");
+  const answer = await rl.question("Enter choice (1-5): ");
+  rl.close();
+  switch (answer.trim()) {
+    case "1":
+      return "ollama";
+    case "2":
+      return "generate_prompt";
+    case "3":
+      return "mock";
+    case "4":
+      return "configure_key";
+    case "5":
+      return "setup_agent_native";
+    default:
+      console.log("Invalid choice. Please enter 1-5.");
+      rl.close();
+      return showOnboardingMenu();
+  }
+}
+
+// src/cli/commands/quick.ts
+async function quickCommand(ideaArg, rawOptions) {
+  const options = normalizeOptions(rawOptions);
+  const ideaText = loadIdeaInput(ideaArg);
+  const mock = !!options.mock;
+  const idea = parseIdeaInput({
+    idea: ideaText,
+    mode: "quick",
+    stage: options.stage,
+    market: options.market,
+    targetUsers: options.targetUsers
+  });
+  let providerRes = resolveProvider({ mock, apiKey: options.apiKey, baseUrl: options.baseUrl, model: options.model });
+  if (!providerRes) {
+    const choice = await showOnboardingMenu();
+    switch (choice) {
+      case "mock":
+        providerRes = resolveProvider({ mock: true });
+        break;
+      case "generate_prompt":
+        await promptQuickCommand(ideaText, options);
+        return;
+      case "configure_key": {
+        const rl = (await import("readline/promises")).createInterface({ input: process.stdin, output: process.stdout });
+        const key = await rl.question("Enter API key: ");
+        rl.close();
+        if (key.trim()) providerRes = resolveProvider({ apiKey: key.trim() });
+        break;
+      }
+      case "setup_agent_native": {
+        const { setupCommand: setupCommand2 } = await import("../setup-QMYBP3QE.js");
+        await setupCommand2({});
+        return;
+      }
+      case "ollama": {
+        console.log("Ollama support coming soon. Use --mock for now.");
+        providerRes = resolveProvider({ mock: true });
+        break;
+      }
+    }
+  }
+  if (!providerRes) {
+    console.error("No provider available. Run with --mock for demo mode.");
+    process.exit(2);
+  }
+  try {
+    const report = await runImmuneEngine(idea, providerRes.provider);
+    report.markdown = buildReport(report);
+    const isJson = !!options.json;
+    const output = options.output;
+    if (isJson) {
+      const json = JSON.stringify(report, null, 2);
+      const r = safeWriteOutput(output, json, "Report");
+      if (!r.ok) {
+        console.error(r.message);
+        process.exit(2);
+      }
+    } else {
+      const r = safeWriteOutput(output, report.markdown, "Report");
+      if (!r.ok) {
+        console.error(r.message);
+        process.exit(2);
+      }
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(3);
+  }
+}
+async function promptQuickCommand(ideaText, options) {
+  const { skeptic: skeptic2 } = await import("../skeptic-KU7EW27C.js");
+  const { defender: defender2 } = await import("../defender-IQOS3YI7.js");
+  const idea = parseIdeaInput({
+    idea: ideaText,
+    mode: "quick",
+    stage: options.stage,
+    market: options.market,
+    targetUsers: options.targetUsers
+  });
+  const skepticPrompt = skeptic2(idea);
+  const defenderPrompt = defender2(idea);
+  const output = [
+    "# IdeaGauntlet \u2014 Quick Critique Prompt",
+    "",
+    "Copy the prompts below into your preferred AI assistant.",
+    "",
+    "---",
+    "",
+    "## Skeptic Prompt",
+    "",
+    `**System:** ${skepticPrompt.system}`,
+    "",
+    skepticPrompt.userMessage,
+    "",
+    "---",
+    "",
+    "## Defender Prompt",
+    "",
+    `**System:** ${defenderPrompt.system}`,
+    "",
+    defenderPrompt.userMessage,
+    "",
+    "---",
+    "",
+    "Ask your AI to respond to both prompts, then synthesize a verdict with: core insight, strongest case, weakest assumption, top failure modes, dangerous assumptions, kill tests, and next actions."
+  ].join("\n");
+  const outFile = options.output;
+  const r = safeWriteOutput(outFile, output, "Prompt");
+  if (!r.ok) {
+    console.error(r.message);
+    process.exit(2);
+  }
+}
+
+// src/cli/commands/court.ts
+async function courtCommand(ideaArg, rawOptions) {
+  const options = normalizeOptions(rawOptions);
+  const ideaText = loadIdeaInput(ideaArg);
+  const idea = parseIdeaInput({
+    idea: ideaText,
+    mode: "court",
+    stage: options.stage
+  });
+  const providerRes = resolveProvider({
+    mock: !!options.mock,
+    model: options.model
+  });
+  if (!providerRes) {
+    console.error("No provider available. Use --mock.");
+    process.exit(2);
+  }
+  try {
+    const report = await runCourtEngine(idea, providerRes.provider);
+    report.markdown = buildReport(report);
+    const isJson = !!options.json;
+    const output = options.output;
+    if (isJson) {
+      const json = JSON.stringify(report, null, 2);
+      const r = safeWriteOutput(output, json, "Report");
+      if (!r.ok) {
+        console.error(r.message);
+        process.exit(2);
+      }
+    } else {
+      const r = safeWriteOutput(output, report.markdown, "Report");
+      if (!r.ok) {
+        console.error(r.message);
+        process.exit(2);
+      }
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(3);
+  }
+}
+
+// src/cli/commands/users.ts
+async function usersCommand(ideaArg, rawOptions) {
+  const options = normalizeOptions(rawOptions);
+  const ideaText = loadIdeaInput(ideaArg);
+  const idea = parseIdeaInput({
+    idea: ideaText,
+    mode: "users",
+    stage: options.stage
+  });
+  const count = parseInt(String(options.personas ?? "6"), 10);
+  const providerRes = resolveProvider({
+    mock: !!options.mock,
+    model: options.model
+  });
+  if (!providerRes) {
+    console.error("No provider available. Use --mock.");
+    process.exit(2);
+  }
+  try {
+    const report = await runUserLab(idea, providerRes.provider, count);
+    report.markdown = buildReport(report);
+    const isJson = !!options.json;
+    const output = options.output;
+    if (isJson) {
+      const json = JSON.stringify(report, null, 2);
+      const r = safeWriteOutput(output, json, "Report");
+      if (!r.ok) {
+        console.error(r.message);
+        process.exit(2);
+      }
+    } else {
+      const r = safeWriteOutput(output, report.markdown, "Report");
+      if (!r.ok) {
+        console.error(r.message);
+        process.exit(2);
+      }
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(3);
+  }
+}
+
+// src/cli/commands/mvp.ts
+async function mvpCommand(ideaArg, rawOptions) {
+  const options = normalizeOptions(rawOptions);
+  const providerRes = resolveProvider({ mock: !!options.mock, model: options.model });
+  if (!providerRes) {
+    console.error("No provider. Use --mock.");
+    process.exit(2);
+  }
+  const idea = parseIdeaInput({ idea: loadIdeaInput(ideaArg), mode: "mvp", stage: options.stage });
+  const report = await runMvpPlanner(idea, providerRes.provider);
+  report.markdown = buildReport(report);
+  const isJson = !!options.json;
+  const output = options.output;
+  if (isJson) {
+    const r = safeWriteOutput(output, JSON.stringify(report, null, 2), "Report");
+    if (!r.ok) {
+      console.error(r.message);
+      process.exit(2);
+    }
+  } else {
+    const r = safeWriteOutput(output, report.markdown, "Report");
+    if (!r.ok) {
+      console.error(r.message);
+      process.exit(2);
+    }
+  }
+}
+
+// src/cli/commands/compare.ts
+async function compareCommand(ideas, rawOptions) {
+  const options = normalizeOptions(rawOptions);
+  const providerRes = resolveProvider({ mock: !!options.mock, model: options.model });
+  if (!providerRes) {
+    console.error("No provider. Use --mock.");
+    process.exit(2);
+  }
+  const parsed = ideas.map((i) => parseIdeaInput({ idea: loadIdeaInput(i), mode: "compare" }));
+  const report = await runCompareEngine(parsed, providerRes.provider);
+  report.markdown = buildReport(report);
+  const output = options.output;
+  const r = safeWriteOutput(output, report.markdown, "Report");
+  if (!r.ok) {
+    console.error(r.message);
+    process.exit(2);
+  }
+}
+
+// src/cli/commands/prompt.ts
+async function promptCommand(mode, ideaArg, rawOptions) {
+  const options = normalizeOptions(rawOptions);
+  const ideaText = loadIdeaInput(ideaArg);
+  const idea = parseIdeaInput({
+    idea: ideaText,
+    mode,
+    stage: options.stage,
+    market: options.market,
+    targetUsers: options.targetUsers
+  });
+  let output = "";
+  switch (mode) {
+    case "quick":
+      output = buildQuickPrompt(ideaText);
+      break;
+    case "court":
+      output = buildCourtPrompt(ideaText);
+      break;
+    case "users":
+      output = buildUsersPrompt(ideaText, options.personas);
+      break;
+    case "mvp":
+      output = buildMvpPrompt(ideaText);
+      break;
+    default:
+      console.error(`Unknown prompt mode: ${mode}. Use: quick, court, users, mvp`);
+      process.exit(1);
+  }
+  const outFile = options.output;
+  const r = safeWriteOutput(outFile, output, "Prompt");
+  if (!r.ok) {
+    console.error(r.message);
+    process.exit(2);
+  }
+}
+function buildQuickPrompt(ideaText) {
+  const sk = skeptic({ idea: ideaText });
+  const df = defender({ idea: ideaText });
+  return [
+    "# IdeaGauntlet \u2014 Quick Critique Prompt",
+    "",
+    "Copy the prompts below into your AI assistant.",
+    "",
+    "---",
+    "",
+    "## Prompt 1: Skeptic",
+    `**System:** ${sk.system}`,
+    "",
+    sk.userMessage,
+    "",
+    "## Prompt 2: Defender",
+    `**System:** ${df.system}`,
+    "",
+    df.userMessage,
+    "",
+    "## Instructions for the AI",
+    "Respond to both prompts, then synthesize a verdict with: core insight, strongest case, weakest assumption, top failure modes, dangerous assumptions, kill tests, and next actions."
+  ].join("\n");
+}
+function buildCourtPrompt(ideaText) {
+  return [
+    "# IdeaGauntlet \u2014 Court Debate Prompt",
+    "",
+    `Product idea: ${ideaText}`,
+    "",
+    "Run a structured debate with these roles:",
+    "1. **Prosecutor** \u2014 attacks the idea",
+    "2. **Defender** \u2014 argues why it could work",
+    "3. **User Advocate** \u2014 argues from the user's perspective",
+    "4. **Investor** \u2014 evaluates market, scale, defensibility",
+    "5. **Competitor** \u2014 explains how the idea could be copied or crushed",
+    "6. **Judge** \u2014 summarizes the verdict",
+    "",
+    "Each role speaks once, max 300 words. End with a judge verdict and unresolved questions."
+  ].join("\n");
+}
+function buildUsersPrompt(ideaText, personas = "6") {
+  return [
+    "# IdeaGauntlet \u2014 Synthetic User Prompt",
+    "",
+    `Product idea: ${ideaText}`,
+    "",
+    `Generate ${personas} fictional user archetypes who would encounter this product.`,
+    "",
+    "For each persona, include:",
+    "- Name and archetype label",
+    "- Goal they are trying to accomplish",
+    "- Current workaround (what they do today)",
+    "- Trigger that would make them try this product",
+    "- Primary objection (why they would hesitate)",
+    "- Willingness to pay (none/low/medium/high)",
+    "- Likely reason they would churn",
+    "- A quote expressing their skepticism",
+    "- One question a founder should ask a real user like this",
+    "",
+    "**IMPORTANT:** These are fictional archetypes for hypothesis generation, not real validation."
+  ].join("\n");
+}
+function buildMvpPrompt(ideaText) {
+  return [
+    "# IdeaGauntlet \u2014 MVP Validation Plan Prompt",
+    "",
+    `Product idea: ${ideaText}`,
+    "",
+    "Generate an aggressive MVP validation plan with:",
+    "- 14-day MVP plan (max 3 things to build)",
+    "- Fake-door test design (what would the landing page say?)",
+    "- User interview script (5 questions to ask)",
+    "- Success metrics (what numbers justify continuing?)",
+    "- Kill criteria (what results mean pivot or stop?)",
+    "- Pivot options (adjacent directions if the core doesn't work)",
+    "",
+    "Be aggressive about reducing scope."
+  ].join("\n");
+}
+
+// src/cli/commands/init.ts
+import { mkdirSync, writeFileSync, existsSync } from "fs";
+import { resolve as resolve2 } from "path";
+var IDEA_TEMPLATE = `# My Product Idea
+
+## Title
+[Your product name]
+
+## Description
+[Describe your product idea in 2-3 sentences. What does it do? Who is it for?]
+
+## Target Users
+- [User type 1]
+- [User type 2]
+
+## Market
+[What market does this serve?]
+
+## Stage
+napkin / pre-mvp / mvp / growth
+
+## Constraints
+- Team size:
+- Budget:
+- Timeline:
+
+## Known Competitors
+- [Competitor 1]
+- [Competitor 2]
+
+## Evidence So Far
+- [Any user interviews, signups, or validation data]
+`;
+var CONFIG_TEMPLATE = `{
+  "name": "my-idea-gauntlet",
+  "defaultMode": "quick",
+  "model": "gpt-4o-mini"
+}
+`;
+async function initCommand(directory, options) {
+  const dir = directory ? resolve2(process.cwd(), directory) : resolve2(process.cwd(), ".idea-gauntlet");
+  const force = !!options?.force;
+  if (existsSync(dir)) {
+    const ideasDir = resolve2(dir, "ideas");
+    const reportsDir = resolve2(dir, "reports");
+    const configFile = resolve2(dir, "config.json");
+    const ideaFile = resolve2(ideasDir, "my-idea.md");
+    if (!force) {
+      console.log(`Directory exists: ${dir}`);
+      if (!existsSync(ideasDir)) mkdirSync(ideasDir, { recursive: true });
+      if (!existsSync(reportsDir)) mkdirSync(reportsDir, { recursive: true });
+      if (!existsSync(ideaFile)) writeFileSync(ideaFile, IDEA_TEMPLATE, "utf-8");
+      if (!existsSync(configFile)) writeFileSync(configFile, CONFIG_TEMPLATE, "utf-8");
+      console.log("\u2713 Workspace exists. Missing template files created.");
+      return;
+    }
+  } else {
+    mkdirSync(dir, { recursive: true });
+  }
+  mkdirSync(resolve2(dir, "ideas"), { recursive: true });
+  mkdirSync(resolve2(dir, "reports"), { recursive: true });
+  writeFileSync(resolve2(dir, "ideas", "my-idea.md"), IDEA_TEMPLATE, "utf-8");
+  writeFileSync(resolve2(dir, "config.json"), CONFIG_TEMPLATE, "utf-8");
+  console.log(`\u2713 IdeaGauntlet workspace created at ${dir}`);
+  console.log(`  ${dir}/ideas/my-idea.md`);
+  console.log(`  ${dir}/reports/`);
+  console.log(`  ${dir}/config.json`);
+}
+
+// src/cli/commands/doctor.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+async function doctorCommand(options) {
+  const verbose = !!options?.verbose;
+  const results = [];
+  const nodeOk = isNodeGte(18);
+  results.push({
+    label: "Node version (>=18)",
+    status: nodeOk ? "pass" : "fail",
+    message: process.version,
+    detail: verbose ? `Detected: ${process.version} at ${process.execPath}` : void 0
+  });
+  const hasKey = !!getApiKey();
+  results.push({
+    label: "API key (IDEAGAUNTLET_API_KEY)",
+    status: hasKey ? "pass" : "warn",
+    message: hasKey ? "Set" : "Not set (prompt/mock/setup still work)"
+  });
+  const executableOk = checkExecutable();
+  results.push({
+    label: "CLI executable",
+    status: executableOk ? "pass" : "warn",
+    message: executableOk ? "Found" : "Not found (run build first)",
+    detail: verbose ? `Checked: ${resolve3(process.cwd(), "dist/cli/index.js")}` : void 0
+  });
+  const codexConfigOk = checkPathExists(".codex/config.toml");
+  results.push({
+    label: ".codex/config.toml",
+    status: codexConfigOk ? "pass" : "warn",
+    message: codexConfigOk ? "Found" : "Not found (used by Codex integration)",
+    detail: verbose ? `Checked: ${resolve3(process.cwd(), ".codex/config.toml")}` : void 0
+  });
+  const ollamaOk = await checkOllama();
+  results.push({
+    label: "Ollama availability",
+    status: ollamaOk ? "pass" : "warn",
+    message: ollamaOk ? "Running at localhost:11434" : "Not detected",
+    detail: verbose && ollamaOk ? "API responded to /api/tags" : void 0
+  });
+  const mcpOk = await checkMcpServer();
+  results.push({
+    label: "MCP server startup",
+    status: mcpOk ? "pass" : "warn",
+    message: mcpOk ? "Tools list fetched" : "Could not start (run with --verbose)",
+    detail: verbose ? mcpOk ? "MCP server started, received tools/list response" : "MCP server failed to respond to tools/list request" : void 0
+  });
+  console.log("\nIdeaGauntlet Doctor");
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  for (const r of results) {
+    const icon = r.status === "pass" ? "\u2713" : r.status === "warn" ? "\u26A0" : "\u2717";
+    console.log(`${icon} ${r.label}: ${r.message}`);
+    if (r.detail && verbose) {
+      console.log(`   ${r.detail}`);
+    }
+  }
+  const failures = results.filter((r) => r.status === "fail").length;
+  if (failures > 0) console.log(`
+${failures} failure(s) found.`);
+  else console.log("\nAll critical checks passed.");
+}
+function checkExecutable() {
+  const paths = [
+    resolve3(process.cwd(), "dist/cli/index.js"),
+    resolve3(process.cwd(), "src/cli/index.ts")
+  ];
+  return paths.some((p) => existsSync2(p));
+}
+function checkPathExists(relativePath) {
+  return existsSync2(resolve3(process.cwd(), relativePath));
+}
+async function checkOllama() {
+  try {
+    const res = await fetch("http://localhost:11434/api/tags");
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function checkMcpServer() {
+  try {
+    const { startMcpServer: startMcpServer2 } = await import("../server-FLE4IK6S.js");
+    return typeof startMcpServer2 === "function";
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/commands/mcp.ts
+async function mcpCommand(options) {
+  startMcpServer();
+}
+
+// src/cli/index.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(
+  readFileSync2(resolve4(__dirname, "../../package.json"), "utf-8")
+);
+var cli = cac("idea-gauntlet");
+cli.version(pkg.version);
+cli.help();
+cli.command("quick <idea>", "Run a fast adversarial critique").option("--stage <stage>", "Idea stage: napkin, pre-mvp, mvp, growth").option("--market <market>", "Target market description").option("--target-users <users>", "Comma-separated target users").option("--model <model>", "LLM model override").option("--base-url <url>", "API base URL override").option("--api-key <key>", "API key override").option("--mock", "Use mock provider").option("--json", "Output JSON instead of Markdown").option("--output <file>", "Write to file").action((idea, options) => quickCommand(idea, options));
+cli.command("court <idea>", "Run a court-style debate").option("--stage <stage>", "Idea stage").option("--model <model>", "LLM model override").option("--mock", "Use mock provider").option("--json", "Output JSON").option("--output <file>", "Write to file").action((idea, options) => courtCommand(idea, options));
+cli.command("users <idea>", "Generate synthetic user personas").option("--personas <number>", "Number of personas", { default: "6" }).option("--stage <stage>", "Idea stage").option("--model <model>", "LLM model override").option("--mock", "Use mock provider").option("--json", "Output JSON").option("--output <file>", "Write to file").action((idea, options) => usersCommand(idea, options));
+cli.command("mvp <idea>", "Generate a validation/MVP plan").option("--stage <stage>", "Idea stage").option("--model <model>", "LLM model override").option("--mock", "Use mock provider").option("--json", "Output JSON").option("--output <file>", "Write to file").action((idea, options) => mvpCommand(idea, options));
+cli.command("compare <...ideas>", "Compare multiple product ideas").option("--model <model>", "LLM model override").option("--mock", "Use mock provider").option("--output <file>", "Write to file").action((ideas, options) => compareCommand(ideas, options));
+cli.command("prompt <mode> <idea>", "Generate structured prompt for any AI (no API key)").option("--stage <stage>", "Idea stage").option("--market <market>", "Target market").option("--target-users <users>", "Target users").option("--personas <number>", "Number of personas (for users mode)").option("--output <file>", "Write to file").action((mode, idea, options) => promptCommand(mode, idea, options));
+cli.command("init [directory]", "Scaffold an IdeaGauntlet workspace template").option("--name <name>", "Project name").option("--force", "Overwrite existing files").action((directory, options) => initCommand(directory, options));
+cli.command("setup", "Generate integration files for Claude/Cursor/Codex/MCP").option("--all", "Install all integrations non-interactively").option("--dry-run", "Show what would be written without writing").option("--force", "Overwrite existing files without confirmation").option("--targets <targets>", "Comma-separated targets to install").action((options) => setupCommand(options));
+cli.command("doctor", "Check environment and configuration").option("--verbose", "Detailed output").action((options) => doctorCommand(options));
+cli.command("mcp", "Start the MCP stdio server").option("--port <port>", "HTTP port (for HTTP transport)").option("--http", "Use HTTP transport instead of stdio").action((options) => mcpCommand(options));
+cli.parse();

package/dist/defender-IQOS3YI7.js

@@ -0,0 +1,6 @@
+import {
+  defender
+} from "./chunk-FF7CULAJ.js";
+export {
+  defender
+};