promptpilot 0.1.7 → 0.2.1

package/dist/cli.d.ts

@@ -21,6 +21,7 @@ interface CliDependencies {
         columns?: number;
         user?: string;
     };
+    spawnClaude?: (prompt: string) => Promise<number>;
 }
 declare function runCli(argv: string[], io?: CliIO, dependencies?: CliDependencies): Promise<number>;
 

package/dist/cli.js

@@ -3,7 +3,7 @@
 // src/cli.ts
 import { readFileSync, realpathSync } from "fs";
 import { fileURLToPath } from "url";
-import { execSync } from "child_process";
+import { execSync, spawn } from "child_process";
 
 // src/errors.ts
 var InvalidPromptError = class extends Error {
@@ -1417,6 +1417,18 @@ Mode: Ultra compression. Minimize tokens aggressively.` : getOptimizationSystemP
       };
     }
     if (!this.client.listModels) {
+      if (isClaudeTiersOnlyTargetSet(availableTargets)) {
+        const selected = selectClaudeTierHeuristic(options.input, options.routingPriority, availableTargets);
+        if (selected) {
+          return {
+            selectedTarget: stripInternalTargetFields(selected),
+            rankedTargets: [{ ...stripInternalTargetFields(selected), rank: 1, reason: "Selected by Claude tier heuristic (no local Qwen router available)." }],
+            routingReason: "Selected by Claude tier heuristic (no local Qwen router available).",
+            routingWarnings: [],
+            routingProvider: "heuristic"
+          };
+        }
+      }
       return {
         selectedTarget: null,
         rankedTargets: [],
@@ -1441,12 +1453,23 @@ Mode: Ultra compression. Minimize tokens aggressively.` : getOptimizationSystemP
           routingProvider: null
         };
       }
+      const claudeTiersOnly = isClaudeTiersOnlyTargetSet(availableTargets);
+      const routingCandidates = claudeTiersOnly ? filterClaudeTierCandidates(availableTargets, options.input, options.routingPriority) : availableTargets;
+      if (routingCandidates.length === 1) {
+        return {
+          selectedTarget: stripInternalTargetFields(routingCandidates[0]),
+          rankedTargets: [{ ...stripInternalTargetFields(routingCandidates[0]), rank: 1, reason: "Selected by Claude tier pre-filter based on prompt signals." }],
+          routingReason: "Selected by Claude tier pre-filter based on prompt signals.",
+          routingWarnings: [],
+          routingProvider: "heuristic"
+        };
+      }
       const response = await this.client.generateJson({
         model: routerModel,
         timeoutMs: options.input.timeoutMs ?? this.config.timeoutMs,
         temperature: 0,
         format: "json",
-        systemPrompt: buildDownstreamRoutingSystemPrompt(options.routingPriority, options.workloadBias),
+        systemPrompt: buildDownstreamRoutingSystemPrompt(options.routingPriority, options.workloadBias, claudeTiersOnly),
         prompt: JSON.stringify(
           {
             objective: "Rank the caller-supplied downstream targets for this prompt and choose the best top target.",
@@ -1458,7 +1481,7 @@ Mode: Ultra compression. Minimize tokens aggressively.` : getOptimizationSystemP
             targetHints: options.input.targetHints ?? [],
             workloadBias: options.workloadBias,
             routingPriority: options.routingPriority,
-            candidateTargets: availableTargets.map((target) => ({
+            candidateTargets: routingCandidates.map((target) => ({
               id: target.id,
               provider: target.provider,
               model: target.model,
@@ -1477,7 +1500,7 @@ Mode: Ultra compression. Minimize tokens aggressively.` : getOptimizationSystemP
         new Set((response.rankedTargetIds ?? []).map((value) => value.trim()).filter(Boolean))
       ).slice(0, Math.max(1, options.routingTopK));
       const rankedTargets = rankedTargetIds.map((id, index) => {
-        const target = availableTargets.find((candidate) => candidate.id === id);
+        const target = routingCandidates.find((candidate) => candidate.id === id);
         if (!target) {
           return null;
         }
@@ -1488,7 +1511,7 @@ Mode: Ultra compression. Minimize tokens aggressively.` : getOptimizationSystemP
         };
       }).filter((value) => value !== null);
       const selectedTargetId = response.selectedTargetId?.trim();
-      const selectedTargetCandidate = (selectedTargetId && availableTargets.find((candidate) => candidate.id === selectedTargetId)) ?? (rankedTargets[0] ? availableTargets.find(
+      const selectedTargetCandidate = (selectedTargetId && routingCandidates.find((candidate) => candidate.id === selectedTargetId)) ?? (rankedTargets[0] ? routingCandidates.find(
         (candidate) => candidate.provider === rankedTargets[0].provider && candidate.model === rankedTargets[0].model && candidate.label === rankedTargets[0].label
       ) ?? null : null);
       if (!selectedTargetCandidate || rankedTargets.length === 0) {
@@ -1510,6 +1533,18 @@ Mode: Ultra compression. Minimize tokens aggressively.` : getOptimizationSystemP
         routingProvider: routerModel
       };
     } catch {
+      if (isClaudeTiersOnlyTargetSet(availableTargets)) {
+        const selected = selectClaudeTierHeuristic(options.input, options.routingPriority, availableTargets);
+        if (selected) {
+          return {
+            selectedTarget: stripInternalTargetFields(selected),
+            rankedTargets: [{ ...stripInternalTargetFields(selected), rank: 1, reason: "Selected by Claude tier heuristic (Qwen routing failed)." }],
+            routingReason: "Selected by Claude tier heuristic (Qwen routing failed).",
+            routingWarnings: ["Qwen downstream routing failed; fell back to Claude tier heuristic."],
+            routingProvider: "heuristic"
+          };
+        }
+      }
       return {
         selectedTarget: null,
         rankedTargets: [],
@@ -1658,8 +1693,8 @@ function stripInternalTargetFields(target) {
     latencyRank: target.latencyRank
   };
 }
-function buildDownstreamRoutingSystemPrompt(priority, workloadBias) {
-  return [
+function buildDownstreamRoutingSystemPrompt(priority, workloadBias, claudeTiersOnly = false) {
+  const lines = [
     "You are a downstream model router for PromptPilot.",
     "Return strict JSON only with this shape:",
     '{"selectedTargetId":"string","rankedTargetIds":["string"],"reason":"string"}',
@@ -1670,7 +1705,108 @@ function buildDownstreamRoutingSystemPrompt(priority, workloadBias) {
     "Code-first means ambiguous prompts should default toward coding-capable or agentic-capable targets.",
     "Explicit email, support, chat, and lightweight writing prompts may prefer cheaper lighter targets.",
     "Do not invent targets. Do not output prose outside JSON."
-  ].join("\n");
+  ];
+  if (claudeTiersOnly) {
+    lines.push(
+      "You are choosing between Claude model tiers (Haiku, Sonnet, Opus).",
+      "Haiku: fastest and cheapest. ONLY suitable for email, chat, support, summarization, and trivial one-sentence rewrites. Do NOT use Haiku for any coding, debugging, refactoring, or technical tasks.",
+      "Sonnet: balanced cost and capability. The DEFAULT for all coding, debugging, refactoring, writing, and general-purpose tasks. If the prompt mentions code, a file, a module, a bug, or any technical work, choose Sonnet at minimum.",
+      "Opus: most capable and most expensive. Use for complex architecture decisions, multi-constraint agentic planning, system design, long-horizon reasoning, or when the prompt explicitly requires the strongest model.",
+      "When routing priority is cheapest_adequate: Haiku for non-technical lightweight tasks only, Sonnet for anything involving code or technical content, Opus only when clearly necessary.",
+      "When routing priority is best_quality: Opus for all code and reasoning tasks, Sonnet for writing and non-technical tasks.",
+      "When routing priority is fastest_adequate: Haiku only for lightweight non-technical tasks, Sonnet otherwise.",
+      "IMPORTANT: refactor, debug, fix, auth, module, CI, test, and TypeScript are all coding signals \u2014 always choose Sonnet or Opus for these, never Haiku."
+    );
+  }
+  return lines.join("\n");
+}
+var CLAUDE_TIER_TARGETS = [
+  {
+    provider: "anthropic",
+    model: "claude-haiku-4-5",
+    label: "anthropic:claude-haiku-4-5",
+    capabilities: ["writing", "email", "support", "chat", "summarization"],
+    costRank: 1,
+    latencyRank: 1
+  },
+  {
+    provider: "anthropic",
+    model: "claude-sonnet-4-6",
+    label: "anthropic:claude-sonnet-4-6",
+    capabilities: ["coding", "writing", "agentic", "tool_use", "refactor", "debugging"],
+    costRank: 2,
+    latencyRank: 2
+  },
+  {
+    provider: "anthropic",
+    model: "claude-opus-4-6",
+    label: "anthropic:claude-opus-4-6",
+    capabilities: ["coding", "agentic", "tool_use", "refactor", "debugging", "architecture", "writing"],
+    costRank: 3,
+    latencyRank: 3
+  }
+];
+function isClaudeTiersOnlyTargetSet(targets) {
+  return targets.length >= 2 && targets.every(
+    (t) => t.provider === "anthropic" && /haiku|sonnet|opus/i.test(t.model)
+  );
+}
+function isCodeSignal(input) {
+  const task = (input.task ?? "").toLowerCase();
+  const preset = (input.preset ?? "").toLowerCase();
+  const hints = input.targetHints ?? [];
+  return task === "code" || preset === "code" || hints.some((h) => ["coding", "agentic", "tool_use", "refactor", "debugging", "architecture"].includes(h)) || /\b(refactor|debug|fix|auth|module|ci|test|typescript|javascript|function|class|api|endpoint|build|deploy|lint|migration)\b/i.test(input.prompt);
+}
+function isArchitectureSignal(input) {
+  const hints = input.targetHints ?? [];
+  return hints.includes("architecture") || /\b(architect|architecture|design system|migration plan|multi.?step|long.?horizon|agentic.*plan|system design|microservice|monolith)\b/i.test(input.prompt);
+}
+function filterClaudeTierCandidates(targets, input, priority) {
+  if (priority === "best_quality") {
+    const filtered = targets.filter((t) => /opus|sonnet/i.test(t.model));
+    return filtered.length > 0 ? filtered : targets;
+  }
+  if (priority === "cheapest_adequate") {
+    if (isArchitectureSignal(input)) {
+      const filtered2 = targets.filter((t) => /opus|sonnet/i.test(t.model));
+      return filtered2.length > 0 ? filtered2 : targets;
+    }
+    if (isCodeSignal(input)) {
+      const sonnet = targets.find((t) => /sonnet/i.test(t.model));
+      return sonnet ? [sonnet] : targets.filter((t) => !/haiku/i.test(t.model));
+    }
+    const filtered = targets.filter((t) => /haiku|sonnet/i.test(t.model));
+    return filtered.length > 0 ? filtered : targets;
+  }
+  if (priority === "fastest_adequate") {
+    const filtered = targets.filter((t) => !/opus/i.test(t.model));
+    return filtered.length > 0 ? filtered : targets;
+  }
+  return targets;
+}
+function selectClaudeTierHeuristic(input, priority, targets) {
+  const haiku = targets.find((t) => /haiku/i.test(t.model)) ?? null;
+  const sonnet = targets.find((t) => /sonnet/i.test(t.model)) ?? null;
+  const opus = targets.find((t) => /opus/i.test(t.model)) ?? null;
+  const task = (input.task ?? "").toLowerCase();
+  const preset = (input.preset ?? "").toLowerCase();
+  const hints = input.targetHints ?? [];
+  const prompt = input.prompt;
+  const isLightweight = ["email", "chat", "support", "summarization"].includes(task) || ["email", "chat", "support", "summarization"].includes(preset) || hints.some((h) => ["email", "support", "chat", "summarization"].includes(h));
+  const needsOpus = /\b(architect|architecture|design system|migration plan|multi.?step|complex.*refactor|long.?horizon|agentic.*plan)\b/i.test(prompt) || hints.includes("architecture") || priority === "best_quality";
+  const isCodeTask = ["code"].includes(task) || ["code"].includes(preset) || hints.some((h) => ["coding", "agentic", "tool_use", "refactor", "debugging", "architecture"].includes(h)) || /\b(refactor|debug|fix|auth|module|ci|test|typescript|javascript|function|class|api|endpoint)\b/i.test(prompt);
+  if (priority === "fastest_adequate") {
+    if (needsOpus) return opus ?? sonnet;
+    if (isCodeTask) return sonnet ?? opus;
+    return haiku ?? sonnet;
+  }
+  if (priority === "best_quality") {
+    return opus ?? sonnet ?? haiku;
+  }
+  if (needsOpus) return opus ?? sonnet;
+  if (isCodeTask) return sonnet ?? opus;
+  if (isLightweight) return haiku ?? sonnet;
+  return sonnet ?? haiku ?? opus;
 }
 function inferCapabilities(target) {
   const lower = `${target.provider} ${target.model} ${target.label ?? ""}`.toLowerCase();
@@ -1819,6 +1955,109 @@ function createOptimizer(config = {}) {
   return new PromptOptimizer(config);
 }
 
+// src/cliMenu.ts
+var ARROW_UP = "\x1B[A";
+var ARROW_DOWN = "\x1B[B";
+var ENTER = "\r";
+var CTRL_C = "";
+var ESCAPE = "\x1B";
+var CLAUDE_TIER_OPTIONS = [
+  {
+    key: "auto",
+    label: "Auto",
+    badge: "recommended",
+    description: "PromptPilot picks the best tier for your prompt"
+  },
+  {
+    key: "haiku",
+    label: "Haiku",
+    badge: "fastest \xB7 cheapest",
+    description: "email, chat, summarization, simple rewrites"
+  },
+  {
+    key: "sonnet",
+    label: "Sonnet",
+    badge: "balanced",
+    description: "coding, debugging, writing, general-purpose"
+  },
+  {
+    key: "opus",
+    label: "Opus",
+    badge: "most capable",
+    description: "architecture, complex reasoning, agentic planning"
+  }
+];
+function renderClaudeMenu(options, selected) {
+  const lines = ["Select Claude model tier:\n"];
+  for (let index = 0; index < options.length; index++) {
+    const opt = options[index];
+    const isSelected = index === selected;
+    const cursor = isSelected ? "\u276F" : " ";
+    const label = isSelected ? `\x1B[1m${opt.label}\x1B[0m` : opt.label;
+    const badge = `\x1B[2m${opt.badge}\x1B[0m`;
+    const desc = `\x1B[2m${opt.description}\x1B[0m`;
+    lines.push(`  ${cursor} ${label.padEnd(isSelected ? 14 : 6)}  ${badge}`);
+    lines.push(`      ${desc}`);
+  }
+  lines.push("\n  \x1B[2m\u2191/\u2193 move  Enter confirm  q cancel\x1B[0m");
+  return lines.join("\n");
+}
+async function promptClaudeTierMenu(stderr, stdin) {
+  return new Promise((resolve) => {
+    let selected = 0;
+    const options = CLAUDE_TIER_OPTIONS;
+    const lineCount = options.length * 2 + 3;
+    const draw = (first) => {
+      if (!first) {
+        stderr.write(`\x1B[${lineCount}A`);
+      }
+      stderr.write(`\x1B[?25l${renderClaudeMenu(options, selected)}
+`);
+    };
+    const cleanup = () => {
+      stderr.write("\x1B[?25h");
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+    };
+    const onData = (chunk) => {
+      if (chunk === CTRL_C) {
+        cleanup();
+        process.exit(0);
+      }
+      if (chunk === "q" || chunk === ESCAPE) {
+        cleanup();
+        stderr.write("\n");
+        resolve(null);
+        return;
+      }
+      if (chunk === ARROW_UP) {
+        selected = (selected - 1 + options.length) % options.length;
+        draw(false);
+        return;
+      }
+      if (chunk === ARROW_DOWN) {
+        selected = (selected + 1) % options.length;
+        draw(false);
+        return;
+      }
+      if (chunk === ENTER) {
+        cleanup();
+        stderr.write(`
+  Selected: \x1B[1m${options[selected].label}\x1B[0m
+
+`);
+        resolve(options[selected].key);
+      }
+    };
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdin.on("data", onData);
+    draw(true);
+  });
+}
+
 // src/cliWelcome.ts
 import { basename } from "path";
 var MIN_WIDE_COLUMNS = 76;
@@ -2036,7 +2275,7 @@ async function runCli(argv, io = { stdout: process.stdout, stderr: process.stder
 `);
     return 0;
   }
-  if (command !== "optimize") {
+  if (command !== "optimize" && command !== "claude") {
     io.stderr.write(`Unknown command: ${command}
 `);
     io.stderr.write(`${getHelpText()}
@@ -2079,6 +2318,20 @@ async function runCli(argv, io = { stdout: process.stdout, stderr: process.stder
     io.stderr.write("A prompt is required.\n");
     return 1;
   }
+  const wantTierMenu = command === "claude" || parsed.autoClaudeTiers;
+  let claudeTierChoice = null;
+  if (wantTierMenu && io.stderr.isTTY && io.stdin) {
+    claudeTierChoice = await promptClaudeTierMenu(io.stderr, io.stdin);
+    if (claudeTierChoice === null) {
+      return 0;
+    }
+  }
+  const resolvedTargets = (() => {
+    if (!wantTierMenu) return parsed.targets;
+    if (!claudeTierChoice || claudeTierChoice === "auto") return [...CLAUDE_TIER_TARGETS, ...parsed.targets];
+    const picked = CLAUDE_TIER_TARGETS.find((t) => t.model.toLowerCase().includes(claudeTierChoice));
+    return picked ? [picked, ...parsed.targets] : [...CLAUDE_TIER_TARGETS, ...parsed.targets];
+  })();
   const spinner = createSpinner(io.stderr, io.stderr.isTTY ?? false);
   try {
     spinner.start("optimizing");
@@ -2096,7 +2349,7 @@ async function runCli(argv, io = { stdout: process.stdout, stderr: process.stder
       maxLength: parsed.maxLength,
       tags: parsed.tags,
       pinnedConstraints: parsed.pinnedConstraints,
-      availableTargets: parsed.targets,
+      availableTargets: resolvedTargets,
       routingEnabled: parsed.routingEnabled,
       routingPriority: parsed.routingPriority,
       routingTopK: parsed.routingTopK,
@@ -2111,6 +2364,11 @@ async function runCli(argv, io = { stdout: process.stdout, stderr: process.stder
       bypassOptimization: parsed.bypassOptimization
     });
     spinner.stop();
+    if (command === "claude") {
+      const doSpawn = dependencies.spawnClaude ?? spawnClaudeProcess;
+      const exitCode = await doSpawn(result.finalPrompt);
+      return exitCode;
+    }
     if (parsed.json) {
       io.stdout.write(`${toPrettyJson(result)}
 `);
@@ -2168,6 +2426,7 @@ function parseOptimizeArgs(args) {
     clearSession: false,
     useContext: true,
     bypassOptimization: false,
+    autoClaudeTiers: false,
     help: false,
     tags: [],
     pinnedConstraints: [],
@@ -2278,6 +2537,9 @@ function parseOptimizeArgs(args) {
       case "--bypass-optimization":
         parsed.bypassOptimization = true;
         break;
+      case "--claude":
+        parsed.autoClaudeTiers = true;
+        break;
       case "--help":
       case "-h":
         parsed.help = true;
@@ -2291,9 +2553,16 @@ function parseOptimizeArgs(args) {
 }
 function getHelpText() {
   return [
-    "promptpilot optimize <prompt> [options]",
+    "Usage:",
     "",
-    "Options:",
+    "  promptpilot claude <prompt> [options]",
+    "    Optimize your prompt and pipe it directly to the claude CLI.",
+    "    Shows a tier picker (Haiku / Sonnet / Opus / Auto) in interactive mode.",
+    "",
+    "  promptpilot optimize <prompt> [options]",
+    "    Optimize and print the result to stdout.",
+    "",
+    "Options (shared):",
     "  --session <id>",
     "  --model <name>           Override auto-selected local Ollama model",
     "  --mode <mode>",
@@ -2315,9 +2584,6 @@ function getHelpText() {
     "  --store <local|sqlite>",
     "  --storage-dir <path>",
     "  --sqlite-path <path>",
-    "  --plain",
-    "  --json",
-    "  --clipboard       Copy optimized prompt to clipboard",
     "  --debug",
     "  --save-context",
     "  --no-context",
@@ -2326,7 +2592,13 @@ function getHelpText() {
     "  --max-context-tokens <n>",
     "  --max-input-tokens <n>",
     "  --timeout <ms>",
-    "  --bypass-optimization"
+    "  --bypass-optimization",
+    "",
+    "Options (optimize only):",
+    "  --plain",
+    "  --json",
+    "  --clipboard       Copy optimized prompt to clipboard",
+    "  --claude          Route between Haiku, Sonnet, and Opus automatically"
   ].join("\n");
 }
 function parseTargetCandidate(raw, index) {
@@ -2387,6 +2659,19 @@ function readPackageVersion() {
     return "dev";
   }
 }
+function spawnClaudeProcess(prompt) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("claude", [], { stdio: ["pipe", "inherit", "inherit"] });
+    if (!child.stdin) {
+      reject(new Error("Failed to open stdin pipe to claude process"));
+      return;
+    }
+    child.stdin.write(prompt);
+    child.stdin.end();
+    child.on("close", (code) => resolve(code ?? 1));
+    child.on("error", reject);
+  });
+}
 function copyToClipboard(text) {
   const commands = [
     { cmd: "xclip", args: ["-selection", "clipboard"], platform: "linux" },