promptpilot 0.1.3 → 0.1.4

package/dist/index.js

@@ -327,13 +327,13 @@ var modeGuidance = {
   clarity: "Improve clarity, remove ambiguity, and keep the request easy for a downstream model to follow.",
   concise: "Minimize token count while preserving user intent, constraints, and expected output.",
   detailed: "Make the request explicit and complete, including structure and success criteria.",
-  structured: "Organize the request into clean sections with compact headings and bullet points where helpful.",
+  structured: "Organize the request into sections only when that improves clarity or token efficiency.",
   persuasive: "Refine wording so the request is compelling and likely to elicit a thoughtful response.",
   compress: "Aggressively compress redundant wording while preserving the meaning and critical constraints.",
   claude_cli: "Optimize specifically for Claude CLI: compact sections, direct instructions, and minimal boilerplate."
 };
 var presetGuidance = {
-  code: "Favor precise technical requirements, edge cases, and expected output format for code tasks.",
+  code: "Favor precise technical requirements, edge cases, expected output format, and a compact inspect-plan-act-test-reflect loop for code tasks.",
   email: "Preserve the sender's goal, tone, and audience; aim for a realistic and usable writing request.",
   essay: "Preserve thesis, structure, and voice guidance while making the prompt clearer.",
   support: "Favor concise issue context, user impact, and desired resolution details.",
@@ -351,6 +351,10 @@ function getOptimizationSystemPrompt(mode, preset) {
     "- Preserve critical constraints and task goals.",
     "- Improve clarity, structure, and downstream usefulness.",
     "- Keep the result compact when the mode requests compression.",
+    "- Do not force sections when direct phrasing is shorter and equally clear.",
+    "- Remove redundancy aggressively when the source prompt repeats the same goal multiple ways.",
+    "- For code tasks, prefer a terse agent brief over narrative prose.",
+    "- For code tasks, structure the prompt around a Karpathy-style loop: inspect, plan, act, test, reflect, repeat.",
     `Mode guidance: ${modeGuidance[mode]}`,
     preset ? `Preset guidance: ${presetGuidance[preset]}` : "Preset guidance: none"
   ].join("\n");
@@ -679,7 +683,11 @@ function tokenize(value) {
   );
 }
 function extractConstraints(value) {
-  return value.split(/\n+/).map((line) => line.trim()).filter((line) => /(must|should|avoid|do not|don't|never|exactly|at most|under|limit|max)/i.test(line)).slice(0, 8);
+  return Array.from(
+    new Set(
+      value.split(/\n+/).flatMap((line) => line.split(/(?<=[.!?])\s+/)).map((line) => line.trim().replace(/^[-*]\s*/, "")).filter((line) => line.length > 0 && line.length <= 180).filter((line) => /(must|should|avoid|do not|don't|never|exactly|at most|under|limit|max|preserve|keep)/i.test(line))
+    )
+  ).slice(0, 8);
 }
 function extractEntities(value) {
   return Array.from(
@@ -874,6 +882,7 @@ var PromptOptimizer = class {
     );
     let provider = input.bypassOptimization ? "heuristic" : this.config.provider ?? DEFAULT_PROVIDER;
     let model = provider === "ollama" ? this.config.ollamaModel ?? "auto" : "heuristic";
+    let usedPreprocessedFallback = false;
     let optimizedPrompt = originalPrompt;
     let providerWarnings = [];
     let providerChanges = [];
@@ -908,6 +917,11 @@ var PromptOptimizer = class {
         optimizedPrompt = ollamaResult.optimizedPrompt;
         providerWarnings = ollamaResult.warnings;
         providerChanges = ollamaResult.changes;
+        if (ollamaResult.source === "preprocessed") {
+          provider = "heuristic";
+          model = "cheap-preprocess";
+          usedPreprocessedFallback = true;
+        }
       } else if (provider === "ollama") {
         provider = "heuristic";
         model = "heuristic";
@@ -916,7 +930,7 @@ var PromptOptimizer = class {
         ];
       }
     }
-    if (provider === "heuristic") {
+    if (provider === "heuristic" && !usedPreprocessedFallback) {
       const fallback = this.heuristicOptimize({
         input: {
           ...input,
@@ -1048,29 +1062,88 @@ var PromptOptimizer = class {
     });
   }
   async tryOllamaOptimization(options) {
+    const preprocessedPrompt = cheapCompress(options.input.prompt);
+    const preprocessedTokenCount = this.estimator.estimateText(preprocessedPrompt);
+    const ultraMode = preprocessedTokenCount > 500;
     try {
       if (!await this.client.isAvailable()) {
-        return null;
+        return {
+          optimizedPrompt: preprocessedPrompt,
+          changes: ["Applied cheap local preprocessing because Ollama was unavailable."],
+          warnings: ["Ollama was unavailable, so PromptPilot kept the cheap preprocessed prompt."],
+          source: "preprocessed"
+        };
+      }
+      const systemPrompt = ultraMode ? `${getOptimizationSystemPrompt(options.input.mode, options.input.preset)}
+Mode: Ultra compression. Minimize tokens aggressively.` : getOptimizationSystemPrompt(options.input.mode, options.input.preset);
+      const optimizationPrompt = buildOptimizationPrompt(
+        {
+          ...options.input,
+          prompt: preprocessedPrompt
+        },
+        options.relevantContext,
+        options.extractedConstraints
+      );
+      const timeoutMs = options.input.timeoutMs ?? this.config.timeoutMs;
+      let optimizedPrompt = "";
+      let responseChanges = [];
+      let responseWarnings = [];
+      try {
+        const response = await this.client.generateJson({
+          systemPrompt,
+          prompt: optimizationPrompt,
+          timeoutMs,
+          model: options.model,
+          temperature: this.config.temperature,
+          format: "json"
+        });
+        optimizedPrompt = normalizeWhitespace(response.optimizedPrompt ?? "");
+        responseChanges = response.changes ?? [];
+        responseWarnings = response.warnings ?? [];
+      } catch {
+        const raw = await this.client.generate({
+          systemPrompt,
+          prompt: optimizationPrompt,
+          timeoutMs,
+          model: options.model,
+          temperature: this.config.temperature
+        });
+        optimizedPrompt = sanitizeTextOptimizationOutput(raw);
+        responseChanges = [`Applied text-only Ollama optimization with ${options.model}.`];
       }
-      const response = await this.client.generateJson({
-        systemPrompt: getOptimizationSystemPrompt(options.input.mode, options.input.preset),
-        prompt: buildOptimizationPrompt(options.input, options.relevantContext, options.extractedConstraints),
-        timeoutMs: options.input.timeoutMs ?? this.config.timeoutMs,
-        model: options.model,
-        temperature: this.config.temperature,
-        format: "json"
-      });
-      const optimizedPrompt = normalizeWhitespace(response.optimizedPrompt ?? "");
       if (!optimizedPrompt) {
-        return null;
+        return {
+          optimizedPrompt: preprocessedPrompt,
+          changes: ["Applied cheap local preprocessing because the model returned an empty optimization."],
+          warnings: ["The local optimizer returned an empty result, so PromptPilot kept the preprocessed prompt."],
+          source: "preprocessed"
+        };
+      }
+      const optimizedTokenCount = this.estimator.estimateText(optimizedPrompt);
+      if (isCompressionSensitiveMode(options.input.mode) && optimizedTokenCount >= preprocessedTokenCount) {
+        return {
+          optimizedPrompt: preprocessedPrompt,
+          changes: [
+            ...responseChanges,
+            "Kept the cheap preprocessed prompt because the model output was not smaller."
+          ],
+          warnings: responseWarnings,
+          source: "preprocessed"
+        };
       }
       return {
         optimizedPrompt,
-        changes: response.changes ?? [`Applied Ollama optimization with ${options.model}.`],
-        warnings: response.warnings ?? []
+        changes: responseChanges.length > 0 ? responseChanges : [`Applied Ollama optimization with ${options.model}.`],
+        warnings: responseWarnings,
+        source: "ollama"
       };
     } catch {
-      return null;
+      return {
+        optimizedPrompt: preprocessedPrompt,
+        changes: ["Applied cheap local preprocessing because Ollama optimization failed."],
+        warnings: ["Ollama optimization failed, so PromptPilot kept the preprocessed prompt."],
+        source: "preprocessed"
+      };
     }
   }
   async resolveOllamaModel(options) {
@@ -1373,16 +1446,14 @@ var PromptOptimizer = class {
     }
   }
   heuristicOptimize(options) {
-    const lines = [
-      `Request: ${options.input.prompt}`,
-      options.input.task ? `Task type: ${options.input.task}` : "",
-      options.input.tone ? `Tone: ${options.input.tone}` : "",
-      options.input.outputFormat ? `Output format: ${options.input.outputFormat}` : "",
-      options.input.maxLength ? `Maximum length: ${options.input.maxLength}` : "",
-      options.constraints.length ? `Critical constraints: ${options.constraints.join("; ")}` : ""
-    ].filter(Boolean);
+    const isCodeRequest = isCodeFirstRequest(options.input);
+    const lines = isCodeRequest ? buildCodeFirstHeuristicPrompt(options.input, options.constraints) : buildGeneralHeuristicPrompt(options.input, options.constraints);
     const optimizedPrompt = lines.join("\n");
-    const changes = ["Normalized prompt structure for downstream model consumption."];
+    const changes = isCodeRequest ? [
+      "Compressed the prompt into a code-agent brief.",
+      "Removed redundant narrative phrasing.",
+      "Applied a Karpathy-style inspect-plan-act-test-reflect loop."
+    ] : ["Normalized prompt structure for downstream model consumption."];
     if (options.input.mode === "compress" || options.input.mode === "concise") {
       changes.push("Applied concise formatting to reduce token usage.");
     }
@@ -1463,6 +1534,14 @@ ${contextBlock}`);
   if (constraints.length > 0) {
     sections.push(`Constraints:
 - ${constraints.join("\n- ")}`);
+  }
+  if (isCodeFirstRequest(input.input)) {
+    sections.push(`Execution loop:
+- Inspect the relevant files and current behavior.
+- Plan the smallest safe next step.
+- Act with minimal, reversible changes.
+- Test or validate the result.
+- Reflect on gaps or risks, then repeat.`);
   }
   const desiredOutput = [
     input.routingDecision.selectedTarget ? `Selected target: ${formatTargetLabel(input.routingDecision.selectedTarget)}` : input.input.targetModel ? `Target model: ${input.input.targetModel}` : "Target model: claude",
@@ -1562,6 +1641,108 @@ function describeDownstreamTarget(target) {
 function formatTargetLabel(target) {
   return target.label ?? `${target.provider}:${target.model}`;
 }
+function isCompressionSensitiveMode(mode) {
+  return mode === "compress" || mode === "concise" || mode === "claude_cli";
+}
+function cheapCompress(text) {
+  return normalizeWhitespace(text).replace(/\b(?:please|kindly|just)\b/gi, "").replace(/\bI\s+(?:want|need|would\s+like\s+to)\b/gi, "").replace(/\s+([,.;:!?])/g, "$1").replace(/\s{2,}/g, " ").trim();
+}
+function sanitizeTextOptimizationOutput(raw) {
+  const normalized = normalizeWhitespace(raw);
+  if (!normalized) {
+    return "";
+  }
+  if (!containsReasoningLeak(normalized)) {
+    return stripWrappingQuotes(normalized);
+  }
+  const candidates = raw.split(/\n{2,}/).map((chunk) => stripWrappingQuotes(normalizeWhitespace(chunk))).filter(Boolean).filter((chunk) => !containsReasoningLeak(chunk)).filter((chunk) => !/^(role|task|guidelines|thinking|thinking process|attempt|critique|final decision|analysis)\b/i.test(chunk)).filter((chunk) => !/^[-*]\s/.test(chunk)).filter((chunk) => !/^\d+\.\s/.test(chunk));
+  return candidates.at(-1) ?? stripWrappingQuotes(normalized);
+}
+function containsReasoningLeak(text) {
+  return /(thinking process|analyze the request|drafting the optimized prompt|critique \d|attempt \d|final decision)/i.test(text);
+}
+function stripWrappingQuotes(text) {
+  return text.replace(/^["'`]+|["'`]+$/g, "").trim();
+}
+function isCodeFirstRequest(input) {
+  if (input.task === "code" || input.preset === "code") {
+    return true;
+  }
+  if ((input.targetHints ?? []).some((hint) => ["coding", "agentic", "refactor", "debugging", "tool_use", "architecture"].includes(hint))) {
+    return true;
+  }
+  return /\b(code|coding|repo|repository|refactor|patch|debug|bug|ci|test|typescript|javascript|agent|tool)\b/i.test(
+    input.prompt
+  );
+}
+function buildGeneralHeuristicPrompt(input, constraints) {
+  return [
+    `Request: ${summarizePrompt(input.prompt, 320)}`,
+    input.task ? `Task type: ${input.task}` : "",
+    input.tone ? `Tone: ${input.tone}` : "",
+    input.outputFormat ? `Output format: ${input.outputFormat}` : "",
+    input.maxLength ? `Maximum length: ${input.maxLength}` : "",
+    constraints.length ? `Critical constraints: ${constraints.join("; ")}` : ""
+  ].filter(Boolean);
+}
+function buildCodeFirstHeuristicPrompt(input, constraints) {
+  const deliverables = inferCodeDeliverables(input.prompt);
+  return [
+    `Goal: ${summarizeCodeGoal(input.prompt)}`,
+    input.tone ? `Tone: ${input.tone}` : "",
+    deliverables.length ? `Deliverables:
+- ${deliverables.join("\n- ")}` : "",
+    constraints.length ? `Constraints: ${constraints.join("; ")}` : "",
+    "Use a Karpathy loop: inspect, plan, act, test, reflect, repeat."
+  ].filter(Boolean);
+}
+function summarizePrompt(prompt, maxLength) {
+  const normalized = normalizeWhitespace(prompt);
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxLength - 1).trim()}\u2026`;
+}
+function summarizeCodeGoal(prompt) {
+  const normalized = summarizePrompt(prompt, 220);
+  const lowered = prompt.toLowerCase();
+  if (/auth|authentication|login|token/.test(lowered)) {
+    return "Inspect the codebase, understand the authentication flow, and produce a safe incremental refactor plan.";
+  }
+  if (/ci|debug|failing|failure|test/.test(lowered)) {
+    return "Inspect the codebase and failing signals, identify root causes, and produce a practical debugging plan.";
+  }
+  if (/refactor/.test(lowered)) {
+    return "Inspect the codebase and produce a phased refactor plan with minimal-risk execution steps.";
+  }
+  return normalized;
+}
+function inferCodeDeliverables(prompt) {
+  const lowered = prompt.toLowerCase();
+  const deliverables = [];
+  if (/inspect|codebase|repo|repository/.test(lowered)) {
+    deliverables.push("Summarize the relevant modules, ownership boundaries, and current behavior.");
+  }
+  if (/shared abstraction|shared abstractions|duplicate|duplicated/.test(lowered)) {
+    deliverables.push("Identify duplicated logic and the best shared abstractions to extract.");
+  }
+  if (/incremental|phase|phased|rollout|step/.test(lowered)) {
+    deliverables.push("Propose an incremental plan with small, reversible steps.");
+  }
+  if (/risk|migration|compatibility|backward/.test(lowered)) {
+    deliverables.push("Call out migration risks, compatibility concerns, and rollback points.");
+  }
+  if (/test|tests/.test(lowered)) {
+    deliverables.push("List the tests or validation needed before and after each phase.");
+  }
+  if (/avoid hand-wavy|practical|concrete/.test(lowered)) {
+    deliverables.push("Keep the recommendations concrete, implementation-oriented, and free of vague architecture advice.");
+  }
+  if (deliverables.length === 0) {
+    deliverables.push("Produce a compact, execution-ready plan for the coding task.");
+  }
+  return deliverables.slice(0, 6);
+}
 
 // src/index.ts
 function createOptimizer(config = {}) {