idea-gauntlet 0.1.0

package/README.md

@@ -0,0 +1,154 @@
+# IdeaGauntlet
+
+Stress-test product ideas with adversarial agents, synthetic users, and court-style critique.
+
+> Most AI tools help you generate more ideas. IdeaGauntlet helps you survive the one you already have.
+
+[![npm version](https://img.shields.io/npm/v/idea-gauntlet)](https://www.npmjs.com/package/idea-gauntlet)
+
+## Quick start
+
+```bash
+npx idea-gauntlet quick "A synthetic focus room app for remote workers" --mock
+```
+
+## Installation
+
+```bash
+npm install idea-gauntlet
+```
+
+Or run directly:
+
+```bash
+npx idea-gauntlet quick "Your product idea here"
+```
+
+## Usage Paths
+
+| Path | Provider? | Description |
+|---|---|---|
+| **Standalone CLI** | API key or Ollama | `idea-gauntlet quick "idea"` |
+| **Mock mode** | None needed | `idea-gauntlet quick "idea" --mock` |
+| **Prompt mode** | None needed | `idea-gauntlet prompt quick "idea"` |
+| **Agent-native** | None needed | `idea-gauntlet setup` |
+
+## CLI Commands
+
+### quick
+Fast adversarial critique.
+```bash
+idea-gauntlet quick "Your idea" [--mock] [--json] [--output report.md]
+```
+
+### court
+Multi-role structured debate.
+```bash
+idea-gauntlet court idea.md [--mock]
+```
+
+### users
+Generate synthetic user personas.
+```bash
+idea-gauntlet users idea.md --personas 6 [--mock]
+```
+
+### mvp
+Generate a 14-day validation plan.
+```bash
+idea-gauntlet mvp idea.md [--mock]
+```
+
+### compare
+Compare multiple ideas.
+```bash
+idea-gauntlet compare idea1.md idea2.md [--mock]
+```
+
+### prompt
+Generate structured prompts (no API key needed).
+```bash
+idea-gauntlet prompt quick "Your idea"
+idea-gauntlet prompt court idea.md
+idea-gauntlet prompt users idea.md --personas 8
+```
+
+### init
+Scaffold a workspace.
+```bash
+idea-gauntlet init [--directory path]
+```
+
+### setup
+Generate integration files for Claude Code, Cursor, Codex.
+```bash
+idea-gauntlet setup [--all] [--dry-run]
+```
+
+### doctor
+Check environment and configuration.
+```bash
+idea-gauntlet doctor
+```
+
+### mcp
+Start MCP server for Claude Desktop integration.
+```bash
+idea-gauntlet mcp
+```
+
+## TypeScript API
+
+```typescript
+import { runGauntlet, MockProvider } from "idea-gauntlet";
+
+const report = await runGauntlet({
+  idea: "A synthetic focus room app for remote workers",
+  targetUsers: ["remote workers", "students"],
+  mode: "quick",
+  provider: new MockProvider(),
+});
+
+console.log(report.markdown);
+```
+
+## Scoring Philosophy
+
+Scores are diagnostic signals, not predictions.
+
+| Dimension | What it measures |
+|---|---|
+| Clarity | Is the idea specific and well-defined? |
+| Pain | Does the user have a real, painful problem? |
+| Differentiation | Is the approach distinct? |
+| Buildability | Can a small team build this? |
+| Distribution | Can this reach its target users? |
+| Monetization | Is there a clear revenue model? |
+| Evidence | What real evidence supports the idea? |
+
+Evidence score defaults low unless you provide real user evidence.
+
+## No API Key? No Problem.
+
+- **Prompt mode** generates structured prompts for any AI
+- **Mock mode** runs deterministically for demos
+- **Agent-native mode** generates Claude/Cursor/Codex integration files
+- **Setup** never requires an API key
+
+## Product Philosophy
+
+IdeaGauntlet is:
+- adversarial but useful
+- skeptical but not cynical
+- evidence-aware
+- honest about uncertainty
+
+IdeaGauntlet is not:
+- a startup idea generator
+- a replacement for real user research
+- a market research oracle
+- a hype machine
+
+## License
+
+MIT

package/dist/chunk-A6GCV4RD.js

@@ -0,0 +1,379 @@
+import {
+  MockProvider,
+  buildReport,
+  resolveProvider,
+  runCompareEngine,
+  runCourtEngine,
+  runImmuneEngine,
+  runMvpPlanner,
+  runUserLab
+} from "./chunk-P4FDULQC.js";
+import {
+  skeptic
+} from "./chunk-VQHEJYTS.js";
+import {
+  defender
+} from "./chunk-FF7CULAJ.js";
+
+// src/utils/safeWrite.ts
+import { existsSync, writeFileSync } from "fs";
+import { isAbsolute, resolve } from "path";
+function safeWriteOutput(outputPath, content, label) {
+  if (!outputPath) {
+    console.log(content);
+    return { ok: true, path: "" };
+  }
+  const resolved2 = resolve(process.cwd(), outputPath);
+  const parts = outputPath.split(/[\\/]/);
+  if (!isAbsolute(outputPath) && parts.includes("..")) {
+    const cwd = process.cwd();
+    if (!resolved2.startsWith(cwd)) {
+      return {
+        ok: false,
+        reason: "traversal",
+        message: `Path traversal detected: '${outputPath}'. Use an absolute path or a path within the working directory.`
+      };
+    }
+  }
+  if (existsSync(resolved2)) {
+    return {
+      ok: false,
+      reason: "exists",
+      message: `'${outputPath}' already exists. Use --force to overwrite.`
+    };
+  }
+  writeFileSync(resolved2, content, "utf-8");
+  console.log(`${label ?? "File"} written to ${outputPath}`);
+  return { ok: true, path: resolved2 };
+}
+function safeWriteReport(reportId, content, workspaceDir) {
+  const baseDir = resolve(workspaceDir, ".idea-gauntlet", "reports");
+  const filePath = resolve(baseDir, `${reportId}.md`);
+  if (!filePath.startsWith(baseDir)) {
+    return {
+      ok: false,
+      reason: "traversal",
+      message: "Invalid path: report must be written inside .idea-gauntlet/reports/"
+    };
+  }
+  if (!existsSync(baseDir)) {
+    import("fs").then((fs) => fs.mkdirSync(baseDir, { recursive: true }));
+  }
+  writeFileSync(filePath, content, "utf-8");
+  return { ok: true, path: filePath };
+}
+
+// src/mcp/tools.ts
+var reports = /* @__PURE__ */ new Map();
+var provider = new MockProvider();
+var resolved = resolveProvider({});
+if (resolved) provider = resolved.provider;
+function getReportIds() {
+  return Array.from(reports.keys());
+}
+async function handleToolCall(name, args) {
+  switch (name) {
+    case "create_prompt": {
+      const mode = args.mode ?? "quick";
+      const ideaText = args.idea ?? "";
+      if (!ideaText) throw new Error("idea parameter required");
+      let output = "";
+      const idea = { idea: ideaText };
+      switch (mode) {
+        case "quick": {
+          const sk = skeptic(idea);
+          const df = defender(idea);
+          output = [
+            "# 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");
+          break;
+        }
+        case "court": {
+          const roles = [
+            "Prosecutor",
+            "Defender",
+            "User Advocate",
+            "Investor",
+            "Competitor",
+            "Judge"
+          ];
+          const roleDescriptions = [
+            "attacks the idea",
+            "argues why it could work",
+            "argues from the user's perspective",
+            "evaluates market, scale, defensibility",
+            "explains how the idea could be copied or crushed",
+            "summarizes the verdict"
+          ];
+          output = [
+            "# IdeaGauntlet \u2014 Court Debate Prompt",
+            "",
+            `Product idea: ${ideaText}`,
+            "",
+            "Run a structured debate with these roles:",
+            ...roles.map(
+              (r, i) => `${i + 1}. **${r}** \u2014 ${roleDescriptions[i]}`
+            ),
+            "",
+            "Each role speaks once, max 300 words. End with a judge verdict and unresolved questions."
+          ].join("\n");
+          break;
+        }
+        case "users": {
+          const count = args.personas ?? "6";
+          output = [
+            "# IdeaGauntlet \u2014 Synthetic User Prompt",
+            "",
+            `Product idea: ${ideaText}`,
+            "",
+            `Generate ${count} 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");
+          break;
+        }
+        case "mvp": {
+          output = [
+            "# 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");
+          break;
+        }
+        default:
+          throw new Error(
+            `Unknown prompt mode: ${mode}. Use: quick, court, users, mvp`
+          );
+      }
+      return { type: "text", text: output };
+    }
+    case "quick_critique": {
+      if (!args.idea) throw new Error("idea required");
+      const report = await runImmuneEngine({ idea: args.idea }, provider);
+      report.markdown = buildReport(report);
+      reports.set(report.id, report);
+      return { type: "text", text: report.markdown };
+    }
+    case "run_court": {
+      if (!args.idea) throw new Error("idea required");
+      const report = await runCourtEngine({ idea: args.idea }, provider);
+      reports.set(report.id, report);
+      return { type: "text", text: report.markdown };
+    }
+    case "generate_users": {
+      if (!args.idea) throw new Error("idea required");
+      const report = await runUserLab(
+        { idea: args.idea },
+        provider,
+        args.personas ?? 6
+      );
+      reports.set(report.id, report);
+      return { type: "text", text: report.markdown };
+    }
+    case "plan_mvp": {
+      if (!args.idea) throw new Error("idea required");
+      const report = await runMvpPlanner({ idea: args.idea }, provider);
+      reports.set(report.id, report);
+      return { type: "text", text: report.markdown };
+    }
+    case "compare_ideas": {
+      if (!args.ideas || !Array.isArray(args.ideas))
+        throw new Error("ideas array required");
+      const ideas = args.ideas.map((i) => ({ idea: i }));
+      const report = await runCompareEngine(ideas, provider);
+      reports.set(report.id, report);
+      return { type: "text", text: report.markdown };
+    }
+    case "save_report": {
+      if (!args.id) throw new Error("report id required");
+      const report = reports.get(args.id);
+      if (!report) throw new Error(`Report not found: ${args.id}`);
+      const result = safeWriteReport(args.id, report.markdown, process.cwd());
+      if (!result.ok) throw new Error(result.message);
+      return { type: "text", text: `Report saved to ${result.path}` };
+    }
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+var toolDefinitions = [
+  {
+    name: "create_prompt",
+    description: "Generate a structured prompt for any mode",
+    inputSchema: {
+      type: "object",
+      properties: {
+        mode: { type: "string" },
+        idea: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "quick_critique",
+    description: "Run quick adversarial critique",
+    inputSchema: {
+      type: "object",
+      properties: { idea: { type: "string" } },
+      required: ["idea"]
+    }
+  },
+  {
+    name: "run_court",
+    description: "Run court-style debate",
+    inputSchema: {
+      type: "object",
+      properties: { idea: { type: "string" } },
+      required: ["idea"]
+    }
+  },
+  {
+    name: "generate_users",
+    description: "Generate synthetic user personas",
+    inputSchema: {
+      type: "object",
+      properties: {
+        idea: { type: "string" },
+        personas: { type: "number" }
+      },
+      required: ["idea"]
+    }
+  },
+  {
+    name: "plan_mvp",
+    description: "Generate MVP validation plan",
+    inputSchema: {
+      type: "object",
+      properties: { idea: { type: "string" } },
+      required: ["idea"]
+    }
+  },
+  {
+    name: "compare_ideas",
+    description: "Compare multiple ideas",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ideas: { type: "array", items: { type: "string" } }
+      },
+      required: ["ideas"]
+    }
+  },
+  {
+    name: "save_report",
+    description: "Save report to .idea-gauntlet/reports/",
+    inputSchema: {
+      type: "object",
+      properties: { id: { type: "string" } },
+      required: ["id"]
+    }
+  }
+];
+
+// src/mcp/resources.ts
+function listResources(reportIds) {
+  return {
+    resources: [
+      ...reportIds.map((id) => ({
+        uri: `idea-gauntlet://report/${id}`,
+        name: `Report ${id}`,
+        mimeType: "text/markdown"
+      })),
+      ...reportIds.map((id) => ({
+        uri: `idea-gauntlet://report/${id}/summary`,
+        name: `Report ${id} Summary`,
+        mimeType: "text/plain"
+      }))
+    ]
+  };
+}
+
+// src/mcp/server.ts
+function respond(id, result, error) {
+  const msg = { jsonrpc: "2.0", id };
+  if (error) {
+    msg.error = { code: error.code ?? -32e3, message: error.message ?? "Unknown error" };
+  } else {
+    msg.result = result;
+  }
+  process.stdout.write(JSON.stringify(msg) + "\n");
+}
+function handleMessage(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+  let msg;
+  try {
+    msg = JSON.parse(trimmed);
+  } catch {
+    console.error("Failed to parse JSON-RPC message:", trimmed.slice(0, 200));
+    return;
+  }
+  if (msg.method === "tools/list") {
+    respond(msg.id, { tools: toolDefinitions });
+  } else if (msg.method === "tools/call") {
+    handleToolCall(msg.params.name, msg.params.arguments ?? {}).then((result) => respond(msg.id, { content: [result] })).catch(
+      (err) => respond(msg.id, null, { code: -32e3, message: err.message })
+    );
+  } else if (msg.method === "resources/list") {
+    respond(msg.id, listResources(getReportIds()));
+  } else {
+    respond(msg.id, null, { code: -32601, message: "Method not found" });
+  }
+}
+function startMcpServer() {
+  let buffer = "";
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk.toString("utf-8");
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      handleMessage(line);
+    }
+  });
+  process.stdin.on("error", (err) => {
+    console.error("stdin error:", err.message);
+  });
+  process.stdin.resume();
+}
+
+export {
+  safeWriteOutput,
+  startMcpServer
+};

package/dist/chunk-FF7CULAJ.js

@@ -0,0 +1,11 @@
+// src/agents/defender.ts
+var defender = (idea) => ({
+  system: "You are the Defender in IdeaGauntlet. Your job is to make the strongest honest case for the product idea. Do not exaggerate. Do not invent evidence. Identify the most compelling wedge, the likely early adopters, and the narrow version of the idea most likely to work.",
+  userMessage: `Product idea: ${idea.idea}
+
+Make the strongest honest case for this idea. Focus on the real problem it solves, the users who need it most, and the version most likely to work. Return plain text, 2-3 paragraphs.`
+});
+
+export {
+  defender
+};