idea-gauntlet 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,210 @@
+import { z } from 'zod';
+
+type IdeaStage = "napkin" | "pre-mvp" | "mvp" | "growth";
+type GauntletMode = "quick" | "court" | "users" | "mvp" | "compare";
+type Verdict = "strong" | "promising_but_risky" | "unclear" | "weak" | "needs_real_evidence" | "pivot_recommended";
+type Severity = "low" | "medium" | "high" | "critical";
+type Confidence = "low" | "medium" | "high";
+type WillingnessToPay = "none" | "low" | "medium" | "high";
+type OnboardingChoice = "ollama" | "generate_prompt" | "mock" | "configure_key" | "setup_agent_native";
+type IntegrationTarget = "claude-skills" | "claude-agents" | "claude-commands" | "codex" | "cursor" | "mcp" | "github-action";
+declare const IdeaStageSchema: z.ZodEnum<["napkin", "pre-mvp", "mvp", "growth"]>;
+declare const GauntletModeSchema: z.ZodEnum<["quick", "court", "users", "mvp", "compare"]>;
+declare const SeveritySchema: z.ZodEnum<["low", "medium", "high", "critical"]>;
+declare const ConfidenceSchema: z.ZodEnum<["low", "medium", "high"]>;
+declare const WillingnessToPaySchema: z.ZodEnum<["none", "low", "medium", "high"]>;
+declare const VerdictSchema: z.ZodEnum<["strong", "promising_but_risky", "unclear", "weak", "needs_real_evidence", "pivot_recommended"]>;
+declare const IdeaInputSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    idea: z.ZodString;
+    targetUsers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    market: z.ZodOptional<z.ZodString>;
+    stage: z.ZodOptional<z.ZodEnum<["napkin", "pre-mvp", "mvp", "growth"]>>;
+    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    mode: z.ZodOptional<z.ZodEnum<["quick", "court", "users", "mvp", "compare"]>>;
+}, "strip", z.ZodTypeAny, {
+    idea: string;
+    title?: string | undefined;
+    targetUsers?: string[] | undefined;
+    market?: string | undefined;
+    stage?: "napkin" | "pre-mvp" | "mvp" | "growth" | undefined;
+    constraints?: Record<string, unknown> | undefined;
+    mode?: "mvp" | "quick" | "court" | "users" | "compare" | undefined;
+}, {
+    idea: string;
+    title?: string | undefined;
+    targetUsers?: string[] | undefined;
+    market?: string | undefined;
+    stage?: "napkin" | "pre-mvp" | "mvp" | "growth" | undefined;
+    constraints?: Record<string, unknown> | undefined;
+    mode?: "mvp" | "quick" | "court" | "users" | "compare" | undefined;
+}>;
+type IdeaInput = z.infer<typeof IdeaInputSchema>;
+interface Scorecard {
+    clarity: number;
+    pain: number;
+    differentiation: number;
+    buildability: number;
+    distribution: number;
+    monetization: number;
+    evidence: number;
+}
+interface Risk {
+    title: string;
+    severity: Severity;
+    explanation: string;
+    mitigation?: string;
+}
+interface Assumption {
+    title: string;
+    whyItMatters: string;
+    howToTest: string;
+    confidence: Confidence;
+}
+interface KillTest {
+    title: string;
+    method: string;
+    timeframe: string;
+    successSignal: string;
+    killSignal: string;
+}
+interface SyntheticPersona {
+    name: string;
+    archetype: string;
+    goal: string;
+    currentWorkaround: string;
+    triggerToTry: string;
+    primaryObjection: string;
+    willingnessToPay: WillingnessToPay;
+    likelyChurnReason: string;
+    quote: string;
+    interviewQuestion: string;
+}
+interface CourtTurn {
+    role: string;
+    argument: string;
+}
+interface CourtSession {
+    transcript: CourtTurn[];
+    verdict: string;
+    unresolvedQuestions: string[];
+}
+interface MVPPlan {
+    goal: string;
+    scope: string[];
+    nonGoals: string[];
+    timeline: string;
+    metrics: string[];
+}
+interface ComparedIdea {
+    title: string;
+    verdict: Verdict;
+    score: number;
+    riskiestAssumption: string;
+    evidenceScore: number;
+}
+interface ComparisonResult {
+    ideas: ComparedIdea[];
+    ranking: string[];
+    fastestToValidate: string;
+    highestUpside: string;
+    recommendedPick: string;
+}
+interface GauntletReport {
+    id: string;
+    createdAt: string;
+    mode: GauntletMode;
+    input: IdeaInput;
+    verdict: Verdict;
+    scores?: Scorecard;
+    coreInsight?: string;
+    strongestCase?: string;
+    weakestAssumption?: string;
+    risks?: Risk[];
+    assumptions?: Assumption[];
+    killTests?: KillTest[];
+    syntheticUsers?: SyntheticPersona[];
+    court?: CourtSession;
+    comparison?: ComparisonResult;
+    mvpPlan?: MVPPlan;
+    nextActions?: string[];
+    markdown: string;
+}
+interface CompletionOptions {
+    system?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+interface LLMProvider {
+    kind: "mock" | "openai" | "ollama" | "custom";
+    complete(prompt: string, options?: CompletionOptions): Promise<string>;
+}
+
+declare function runImmuneEngine(idea: IdeaInput, provider: LLMProvider): Promise<GauntletReport>;
+
+declare function runGauntlet(params: {
+    idea: string;
+    targetUsers?: string[];
+    market?: string;
+    stage?: string;
+    constraints?: Record<string, unknown>;
+    mode?: GauntletMode;
+    provider?: LLMProvider;
+}): Promise<GauntletReport>;
+
+declare function buildReport(report: GauntletReport): string;
+
+declare function calculateScores(params: {
+    hasEvidence: boolean;
+    evidenceStrength?: "weak" | "medium" | "strong";
+    overrides?: Partial<Scorecard>;
+}): Scorecard;
+declare function medianScore(scores: Scorecard): number;
+
+declare class MockProvider implements LLMProvider {
+    kind: "mock";
+    complete(prompt: string, options?: CompletionOptions): Promise<string>;
+}
+
+type OpenAICompatibleConfig = {
+    apiKey: string;
+    baseUrl?: string;
+    model?: string;
+};
+declare class OpenAICompatibleProvider implements LLMProvider {
+    kind: "openai";
+    private config;
+    constructor(config: OpenAICompatibleConfig);
+    complete(prompt: string, options?: CompletionOptions): Promise<string>;
+}
+
+declare class OllamaProvider implements LLMProvider {
+    kind: "ollama";
+    private baseUrl;
+    private model;
+    constructor(model?: string, baseUrl?: string);
+    complete(prompt: string, options?: CompletionOptions): Promise<string>;
+}
+
+type ProviderResolution = {
+    provider: LLMProvider;
+    source: "mock" | "flags" | "env" | "ollama" | null;
+};
+declare function resolveProvider(options?: {
+    mock?: boolean;
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    ollama?: boolean;
+}): ProviderResolution | null;
+declare function getProvider(options?: {
+    mock?: boolean;
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+}): LLMProvider;
+declare class NoProviderError extends Error {
+    constructor();
+}
+
+export { type Assumption, type ComparedIdea, type ComparisonResult, type CompletionOptions, type Confidence, ConfidenceSchema, type CourtSession, type CourtTurn, type GauntletMode, GauntletModeSchema, type GauntletReport, type IdeaInput, IdeaInputSchema, type IdeaStage, IdeaStageSchema, type IntegrationTarget, type KillTest, type LLMProvider, type MVPPlan, MockProvider, NoProviderError, OllamaProvider, type OnboardingChoice, OpenAICompatibleProvider, type Risk, type Scorecard, type Severity, SeveritySchema, type SyntheticPersona, type Verdict, VerdictSchema, type WillingnessToPay, WillingnessToPaySchema, buildReport, calculateScores, getProvider, medianScore, resolveProvider, runGauntlet, runImmuneEngine };

package/dist/index.js

@@ -0,0 +1,139 @@
+import {
+  MockProvider,
+  NoProviderError,
+  OpenAICompatibleProvider,
+  buildReport,
+  calculateScores,
+  getProvider,
+  medianScore,
+  resolveProvider,
+  runCompareEngine,
+  runCourtEngine,
+  runImmuneEngine,
+  runMvpPlanner,
+  runUserLab
+} from "./chunk-P4FDULQC.js";
+import "./chunk-VQHEJYTS.js";
+
+// src/core/types.ts
+import { z } from "zod";
+var IdeaStageSchema = z.enum(["napkin", "pre-mvp", "mvp", "growth"]);
+var GauntletModeSchema = z.enum([
+  "quick",
+  "court",
+  "users",
+  "mvp",
+  "compare"
+]);
+var SeveritySchema = z.enum(["low", "medium", "high", "critical"]);
+var ConfidenceSchema = z.enum(["low", "medium", "high"]);
+var WillingnessToPaySchema = z.enum(["none", "low", "medium", "high"]);
+var VerdictSchema = z.enum([
+  "strong",
+  "promising_but_risky",
+  "unclear",
+  "weak",
+  "needs_real_evidence",
+  "pivot_recommended"
+]);
+var IdeaInputSchema = z.object({
+  title: z.string().optional(),
+  idea: z.string(),
+  targetUsers: z.array(z.string()).optional(),
+  market: z.string().optional(),
+  stage: IdeaStageSchema.optional(),
+  constraints: z.record(z.unknown()).optional(),
+  mode: GauntletModeSchema.optional()
+});
+
+// src/core/runGauntlet.ts
+async function runGauntlet(params) {
+  if (!params.provider) {
+    throw new Error("LLM provider is required. Pass --mock or set IDEAGAUNTLET_API_KEY.");
+  }
+  const input = {
+    idea: params.idea,
+    targetUsers: params.targetUsers,
+    market: params.market,
+    stage: params.stage,
+    constraints: params.constraints,
+    mode: params.mode ?? "quick"
+  };
+  const mode = params.mode ?? "quick";
+  let report;
+  switch (mode) {
+    case "quick":
+      report = await runImmuneEngine(input, params.provider);
+      break;
+    case "court":
+      report = await runCourtEngine(input, params.provider);
+      break;
+    case "users":
+      report = await runUserLab(input, params.provider);
+      break;
+    case "mvp":
+      report = await runMvpPlanner(input, params.provider);
+      break;
+    case "compare":
+      report = await runCompareEngine([input], params.provider);
+      break;
+    default:
+      report = await runImmuneEngine(input, params.provider);
+      break;
+  }
+  report.markdown = buildReport(report);
+  return report;
+}
+
+// src/providers/ollamaProvider.ts
+var OllamaProvider = class {
+  kind = "ollama";
+  baseUrl;
+  model;
+  constructor(model, baseUrl) {
+    this.baseUrl = baseUrl ?? "http://localhost:11434";
+    this.model = model ?? "llama3";
+  }
+  async complete(prompt, options) {
+    const url = `${this.baseUrl}/api/chat`;
+    const messages = [];
+    if (options?.system) messages.push({ role: "system", content: options.system });
+    messages.push({ role: "user", content: prompt });
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: this.model,
+        messages,
+        stream: false,
+        options: { temperature: options?.temperature ?? 0.4, num_predict: options?.maxTokens ?? 2048 }
+      })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Ollama returned ${response.status}: ${text}`);
+    }
+    const data = await response.json();
+    return data.message?.content ?? "";
+  }
+};
+export {
+  ConfidenceSchema,
+  GauntletModeSchema,
+  IdeaInputSchema,
+  IdeaStageSchema,
+  MockProvider,
+  NoProviderError,
+  OllamaProvider,
+  OpenAICompatibleProvider,
+  SeveritySchema,
+  VerdictSchema,
+  WillingnessToPaySchema,
+  buildReport,
+  calculateScores,
+  getProvider,
+  medianScore,
+  resolveProvider,
+  runGauntlet,
+  runImmuneEngine
+};

package/dist/server-FLE4IK6S.js

@@ -0,0 +1,9 @@
+import {
+  startMcpServer
+} from "./chunk-A6GCV4RD.js";
+import "./chunk-P4FDULQC.js";
+import "./chunk-VQHEJYTS.js";
+import "./chunk-FF7CULAJ.js";
+export {
+  startMcpServer
+};

package/dist/setup-QMYBP3QE.js

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

package/dist/skeptic-KU7EW27C.js

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

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "idea-gauntlet",
+  "version": "0.1.0",
+  "description": "Stress-test product ideas with adversarial agents, synthetic users, and court-style critique.",
+  "type": "module",
+  "bin": {
+    "idea-gauntlet": "dist/cli/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./cli": {
+      "import": "./dist/cli/index.js",
+      "types": "./dist/cli/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/cli/index.ts --format esm --dts --clean",
+    "dev": "tsx src/cli/index.ts",
+    "start": "node dist/cli/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "product-discovery",
+    "validation",
+    "adversarial",
+    "startup",
+    "idea"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "cac": "^6.7.14",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0",
+    "tsup": "^8.2.0",
+    "tsx": "^4.16.0",
+    "vitest": "^2.0.0",
+    "@types/node": "^20.0.0"
+  }
+}