idea-gauntlet 0.1.0

package/dist/chunk-HW6JACOL.js

@@ -0,0 +1,324 @@
+// src/cli/commands/setup.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { resolve, dirname } from "path";
+import { createInterface } from "readline/promises";
+
+// src/integrations/claude/generateSkills.ts
+function generateClaudeSkills() {
+  return [
+    {
+      path: ".claude/skills/gauntlet-quick/SKILL.md",
+      description: "Claude Code skill for quick critique",
+      content: `---
+name: gauntlet-quick
+description: Run a quick adversarial critique of a product idea
+---
+
+# Gauntlet Quick
+
+Run a structured adversarial critique of a product idea.
+
+## Instructions
+1. Understand the product idea from the user's input.
+2. Analyze it using the skeptic and defender roles below.
+3. Present the report with: verdict, core insight, risks, assumptions, kill tests, next actions.
+
+## Prompt: Skeptic
+You are the Skeptic in IdeaGauntlet. Find the strongest reasons this product idea may fail. Focus on hidden assumptions, user apathy, behavior-change cost, substitutes, distribution risk, retention risk, and monetization weakness. Return specific, testable objections.
+
+## Prompt: Defender
+You are the Defender in IdeaGauntlet. Make the strongest honest case for the idea. Identify the most compelling wedge, the likely early adopters, and the narrow version of the idea most likely to work.
+`
+    },
+    {
+      path: ".claude/skills/gauntlet-court/SKILL.md",
+      description: "Claude Code skill for court debate",
+      content: `---
+name: gauntlet-court
+description: Run a structured court-style debate on a product idea
+---
+
+# Gauntlet Court
+
+Run a multi-role structured debate.
+
+## 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
+
+## Output
+Judge verdict with unresolved questions.
+`
+    },
+    {
+      path: ".claude/skills/gauntlet-users/SKILL.md",
+      description: "Claude Code skill for synthetic user generation",
+      content: `---
+name: gauntlet-users
+description: Generate synthetic user personas for hypothesis generation
+---
+
+# Gauntlet Users
+
+Generate fictional user archetypes to surface objections and prepare interview questions.
+
+**IMPORTANT:** These are fictional archetypes for hypothesis generation, not real validation. Always label them as such.
+`
+    },
+    {
+      path: ".claude/skills/gauntlet-mvp/SKILL.md",
+      description: "Claude Code skill for MVP validation planning",
+      content: `---
+name: gauntlet-mvp
+description: Generate an aggressive MVP validation plan
+---
+
+# Gauntlet MVP
+
+Turn critique into a concrete validation plan. Be aggressive about reducing scope. A 14-day plan should not include auth, payments, or onboarding flows.
+`
+    }
+  ];
+}
+
+// src/integrations/claude/generateAgents.ts
+function generateClaudeAgents() {
+  return [
+    {
+      path: ".claude/agents/skeptic.md",
+      description: "Claude Code subagent for Skeptic role",
+      content: `---
+model:
+  name: claude-sonnet-5
+instructions: |
+  You are the Skeptic in IdeaGauntlet.
+  Find the strongest reasons a product idea may fail.
+  Focus on hidden assumptions, user apathy, behavior-change cost, substitutes, distribution risk, retention risk, and monetization weakness.
+  Return specific, testable objections.
+`
+    },
+    {
+      path: ".claude/agents/defender.md",
+      description: "Claude Code subagent for Defender role",
+      content: `---
+model:
+  name: claude-sonnet-5
+instructions: |
+  You are the Defender in IdeaGauntlet.
+  Make the strongest honest case for a 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.
+`
+    },
+    {
+      path: ".claude/agents/judge.md",
+      description: "Claude Code subagent for Judge role",
+      content: `---
+model:
+  name: claude-sonnet-5
+instructions: |
+  You are the Judge in IdeaGauntlet.
+  Synthesize arguments from all agents into a conservative verdict.
+  Separate what is known, what is assumed, and what must be tested.
+  Do not predict success. Recommend the next validation step.
+`
+    }
+  ];
+}
+
+// src/integrations/claude/generateCommands.ts
+function generateClaudeCommands() {
+  return [
+    {
+      path: ".claude/commands/gauntlet-quick.md",
+      description: "Claude Code slash command for quick critique",
+      content: `---
+name: gauntlet-quick
+description: Run an IdeaGauntlet quick critique on the current product idea
+---
+Run a structured adversarial critique using the Skeptic and Defender roles. Output a verdict with core insight, risks, assumptions, kill tests, and next actions.
+`
+    },
+    {
+      path: ".claude/commands/gauntlet-court.md",
+      description: "Claude Code slash command for court debate",
+      content: `---
+name: gauntlet-court
+description: Run an IdeaGauntlet court-style debate
+---
+Run a structured debate with Prosecutor, Defender, User Advocate, Investor, and Competitor roles. End with a Judge verdict.
+`
+    }
+  ];
+}
+
+// src/integrations/cursor/generateCursorRules.ts
+function generateCursorRules() {
+  return [
+    {
+      path: ".cursor/rules/idea-gauntlet-quick.mdc",
+      description: "Cursor rule for quick critique",
+      content: `---
+description: Run an IdeaGauntlet-style quick critique on product ideas
+globs: *.md
+---
+When asked to evaluate a product idea, use the IdeaGauntlet framework:
+1. Identify the core insight
+2. Find the weakest assumption
+3. List top failure modes
+4. Propose kill tests
+5. Suggest next actions
+`
+    }
+  ];
+}
+
+// src/integrations/codex/generateAgentsMd.ts
+function generateCodexConfig() {
+  return [
+    {
+      path: "AGENTS.md",
+      description: "Codex agent definitions",
+      content: `# Codex Agents \u2014 IdeaGauntlet
+
+## skeptic
+An agent that attacks product ideas to find weaknesses.
+
+## defender
+An agent that makes the strongest honest case for a product idea.
+
+## judge
+An agent that synthesizes arguments into a conservative verdict.
+`
+    },
+    {
+      path: ".codex/config.toml",
+      description: "Codex TOML configuration",
+      content: `[agents]
+skeptic = { definition = "AGENTS.md#skeptic" }
+defender = { definition = "AGENTS.md#defender" }
+judge = { definition = "AGENTS.md#judge" }
+`
+    }
+  ];
+}
+
+// src/integrations/github/generateActionYaml.ts
+function generateGitHubAction() {
+  return [
+    {
+      path: ".github/workflows/idea-gauntlet.yml",
+      description: "GitHub Action for PR idea critique",
+      content: `name: IdeaGauntlet Critique
+on:
+  issues:
+    types: [opened]
+jobs:
+  critique:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: npx idea-gauntlet quick "\${{ github.event.issue.title }}" --mock
+`
+    }
+  ];
+}
+
+// src/cli/commands/setup.ts
+var ALL_GROUPS = [
+  { key: "claude-skills", label: "Claude Code skills", files: generateClaudeSkills() },
+  { key: "claude-agents", label: "Claude Code agents", files: generateClaudeAgents() },
+  { key: "claude-commands", label: "Claude Code commands", files: generateClaudeCommands() },
+  { key: "cursor", label: "Cursor rules", files: generateCursorRules() },
+  { key: "codex", label: "Codex AGENTS.md + config", files: generateCodexConfig() },
+  { key: "github-action", label: "GitHub Action workflow", files: generateGitHubAction() }
+];
+async function setupCommand(options) {
+  const all = !!options.all;
+  const dryRun = !!(options["dry-run"] ?? options.dryRun);
+  const force = !!options.force;
+  const targets = options.targets ?? (all ? ALL_GROUPS.map((g) => g.key).join(",") : "");
+  const selected = ALL_GROUPS.filter((g) => targets.split(",").map((s) => s.trim()).includes(g.key));
+  if (selected.length === 0) {
+    console.log("No integration targets selected. Use --all or --targets.");
+    console.log("Available: " + ALL_GROUPS.map((g) => g.key).join(", "));
+    return;
+  }
+  const allFiles = selected.flatMap((g) => g.files);
+  if (dryRun) {
+    console.log("\n\u{1F4CB} Dry run \u2014 files that would be created:\n");
+    for (const g of selected) {
+      if (g.files.length === 0) continue;
+      console.log(`  ${g.label}:`);
+      for (const f of g.files) {
+        const exists = existsSync(resolve(process.cwd(), f.path));
+        console.log(`    ${exists ? "\u26A0" : " "} ${f.path}  (${f.description})`);
+      }
+      console.log("");
+    }
+    const total = selected.reduce((s, g) => s + g.files.length, 0);
+    console.log(`${total} file(s) would be processed.`);
+    return;
+  }
+  let written = 0;
+  let skipped = 0;
+  for (const f of allFiles) {
+    const fullPath = resolve(process.cwd(), f.path);
+    const dir = dirname(fullPath);
+    if (existsSync(fullPath) && !force) {
+      const action = await resolveConflict(f.path);
+      if (action === "skip") {
+        skipped++;
+        continue;
+      }
+      if (action === "overwrite") {
+      }
+      if (action === "sidecar") {
+        const sidecarPath = fullPath + ".idea-gauntlet";
+        mkdirSync(dirname(sidecarPath), { recursive: true });
+        writeFileSync(sidecarPath, f.content, "utf-8");
+        written++;
+        continue;
+      }
+      if (action === "append") {
+        const existing = (await import("fs")).readFileSync(fullPath, "utf-8");
+        writeFileSync(fullPath, existing + "\n\n<!-- IdeaGauntlet -->\n" + f.content, "utf-8");
+        written++;
+        continue;
+      }
+    }
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(fullPath, f.content, "utf-8");
+    written++;
+  }
+  console.log(`
+\u2713 ${written} file(s) written, ${skipped} skipped.`);
+}
+async function resolveConflict(path) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  console.log(`
+File already exists: ${path}`);
+  console.log("  [A] Append IdeaGauntlet section");
+  console.log("  [B] Create sidecar file");
+  console.log("  [C] Skip");
+  console.log("  [D] Overwrite");
+  const answer = (await rl.question("Choose (A/B/C/D): ")).trim().toLowerCase();
+  rl.close();
+  switch (answer) {
+    case "a":
+      return "append";
+    case "b":
+      return "sidecar";
+    case "d":
+      return "overwrite";
+    default:
+      return "skip";
+  }
+}
+
+export {
+  setupCommand
+};