clikit-plugin 0.3.12 → 0.3.13

package/dist/index.js

@@ -18247,6 +18247,498 @@ async function cassMemoryReflect(params = {}) {
   return embeddedReflect(p);
 }
 
+// src/tools/augment.ts
+var REVIEW_RULE = {
+  intent: "review",
+  patterns: [
+    /\breview\b/,
+    /\baudit\b/,
+    /\bsecurity issues?\b/,
+    /\bfindings?\b/,
+    /\bpr\b/
+  ]
+};
+var DEBUG_RULE = {
+  intent: "debug",
+  patterns: [
+    /\bdebug\b/,
+    /\bfix\b/,
+    /\bbug\b/,
+    /\bbroken\b/,
+    /\bfails?\b/,
+    /\bfailing\b/,
+    /\b404\b/,
+    /\berrors?\b/,
+    /\broot cause\b/
+  ]
+};
+var REFACTOR_RULE = {
+  intent: "refactor",
+  patterns: [
+    /\brefactor\b/,
+    /\bclean\s+up\b/,
+    /\bcleanup\b/,
+    /\bsimplif(?:y|ication)\b/,
+    /\bdedupe\b/,
+    /\bdeduplicate\b/,
+    /\brestructure\b/,
+    /\breorganize\b/,
+    /\bduplication\b/
+  ]
+};
+var TEST_FIX_RULE = {
+  intent: "test-fix",
+  patterns: [
+    /\btests?\b/,
+    /\bregression\b/,
+    /\bfix tests?\b/,
+    /\badd tests?\b/,
+    /\bupdate tests?\b/
+  ]
+};
+var DOCS_RULE = {
+  intent: "docs",
+  patterns: [
+    /\breadme\b/i,
+    /\bdocs?\b/,
+    /\bdocument(?:ation)?\b/,
+    /\busage guide\b/
+  ]
+};
+var RESEARCH_RULE = {
+  intent: "research",
+  patterns: [
+    /\bresearch\b/,
+    /\binvestigate\b/,
+    /\blook up\b/,
+    /\bcompare\b/,
+    /\bevaluate\b/,
+    /\bbest approach\b/
+  ]
+};
+var EXPLAIN_RULE = {
+  intent: "explain",
+  patterns: [
+    /^explain\b/,
+    /^how\b/,
+    /^why\b/,
+    /\bwalk me through\b/,
+    /\bhelp me understand\b/
+  ]
+};
+var IMPLEMENT_RULE = {
+  intent: "implement",
+  patterns: [
+    /\bimplement\b/,
+    /\bbuild\b/,
+    /\bcreate\b/,
+    /\badd\b/,
+    /\bintegrate\b/,
+    /\bwire up\b/,
+    /\bsupport\b/
+  ]
+};
+var STRONG_INTENT_RULES = [
+  REVIEW_RULE,
+  DEBUG_RULE,
+  REFACTOR_RULE,
+  TEST_FIX_RULE,
+  DOCS_RULE,
+  RESEARCH_RULE,
+  EXPLAIN_RULE,
+  IMPLEMENT_RULE
+];
+var EXECUTION_CONTRACT_INTENTS = new Set([
+  "implement",
+  "debug",
+  "refactor",
+  "review",
+  "research",
+  "docs",
+  "test-fix"
+]);
+var STANDARD_INTENTS = new Set([
+  "implement",
+  "debug",
+  "refactor",
+  "review",
+  "research",
+  "docs",
+  "test-fix"
+]);
+var DEEP_SIGNALS = [
+  /\bcareful\b/,
+  /\bdeep\b/,
+  /\bthorough\b/,
+  /\bhigh.?stakes?\b/,
+  /\bproduction\b/,
+  /\bcritical\b/,
+  /\barchitecture\b/,
+  /\bsecurity\b/
+];
+function detectTaskIntent(draft) {
+  const normalized = normalizeDraft(draft);
+  if (!normalized) {
+    return "general";
+  }
+  for (const rule of STRONG_INTENT_RULES) {
+    if (rule.patterns.some((pattern) => pattern.test(normalized))) {
+      return rule.intent;
+    }
+  }
+  return "general";
+}
+function resolveRewriteMode(configuredMode, intent) {
+  if (configuredMode === "plain" || configuredMode === "execution-contract") {
+    return configuredMode;
+  }
+  return EXECUTION_CONTRACT_INTENTS.has(intent) ? "execution-contract" : "plain";
+}
+function inferIntensity(draft, intent) {
+  const normalized = normalizeDraft(draft);
+  if (DEEP_SIGNALS.some((pattern) => pattern.test(normalized))) {
+    return "Deep";
+  }
+  return STANDARD_INTENTS.has(intent) ? "Standard" : "Light";
+}
+function buildPromptLeverageBlocks(draft, intent, intensity) {
+  return {
+    objective: buildObjective(draft),
+    context: buildContext(intent),
+    workStyle: buildWorkStyle(intent, intensity),
+    toolRules: buildToolRules(intent),
+    outputContract: buildOutputContract(intent),
+    verification: buildVerification(intent),
+    doneCriteria: buildDoneCriteria(intent)
+  };
+}
+function augmentPrompt(draft, options2 = {}) {
+  const normalized = collapseWhitespace(draft);
+  if (!normalized) {
+    throw new Error("Prompt is required.");
+  }
+  const intent = detectTaskIntent(normalized);
+  const mode = resolveRewriteMode(options2.mode ?? "auto", intent);
+  const intensity = inferIntensity(normalized, intent);
+  const blocks = buildPromptLeverageBlocks(normalized, intent, intensity);
+  return {
+    original: normalized,
+    intent,
+    mode,
+    intensity,
+    blocks,
+    enhanced: mode === "execution-contract" ? formatExecutionContract(normalized, blocks) : formatPlainRewrite(normalized, intent, blocks.outputContract),
+    enhancementSource: "deterministic"
+  };
+}
+async function augmentPromptWithRefinement(draft, options2 = {}) {
+  const deterministic = augmentPrompt(draft, options2);
+  if (!options2.refine) {
+    return deterministic;
+  }
+  try {
+    const refined = await options2.refine({
+      original: deterministic.original,
+      enhanced: deterministic.enhanced,
+      intent: deterministic.intent,
+      mode: deterministic.mode,
+      intensity: deterministic.intensity,
+      blocks: deterministic.blocks
+    });
+    const normalized = normalizeEnhancedPrompt(refined);
+    if (!normalized) {
+      return {
+        ...deterministic,
+        fallbackReason: "LLM refinement returned empty output."
+      };
+    }
+    return {
+      ...deterministic,
+      enhanced: normalized,
+      enhancementSource: "llm",
+      fallbackReason: undefined
+    };
+  } catch (error45) {
+    return {
+      ...deterministic,
+      fallbackReason: error45 instanceof Error ? error45.message : "LLM refinement failed."
+    };
+  }
+}
+function formatExecutionContract(draft, blocks) {
+  const task = stripObjectivePrefix(blocks.objective) || toSentence(draft);
+  return [
+    wrapTag("task", task),
+    wrapTag("context", bulletize(blocks.context)),
+    wrapTag("constraints", bulletize([blocks.workStyle, blocks.toolRules].filter(Boolean).join(`
+`))),
+    wrapTag("verification", bulletize(blocks.verification)),
+    wrapTag("deliverable", [blocks.outputContract, blocks.doneCriteria].filter(Boolean).join(`
+`))
+  ].join(`
+
+`);
+}
+function formatPlainRewrite(draft, intent, outputContract) {
+  const sentence = toSentence(draft);
+  if (intent === "explain") {
+    return [
+      sentence,
+      "Keep the explanation clear and well-structured without turning it into an execution plan."
+    ].join(" ");
+  }
+  if (intent === "general") {
+    return [
+      sentence,
+      "Return a clear, well-structured response matched to the task. Keep it concise unless extra detail is necessary."
+    ].join(" ");
+  }
+  return [sentence, outputContract].join(" ");
+}
+function buildObjective(draft) {
+  return `Complete this task: ${toSentence(draft)}`;
+}
+function buildContext(intent) {
+  switch (intent) {
+    case "implement":
+      return [
+        "Review the current code path and identify the narrowest safe integration point.",
+        "Preserve existing behavior outside the requested change."
+      ].join(`
+`);
+    case "debug":
+      return [
+        "Reproduce the issue first and confirm the failing path before editing.",
+        "Inspect the code and data flow around the suspected failure point."
+      ].join(`
+`);
+    case "refactor":
+      return [
+        "Map the current structure before extracting or consolidating logic.",
+        "Identify duplication and branching that can be simplified without changing behavior."
+      ].join(`
+`);
+    case "review":
+      return [
+        "Read enough surrounding context to understand intent before critiquing.",
+        "Focus on confirmed issues first, then call out plausible risks separately."
+      ].join(`
+`);
+    case "research":
+      return [
+        "Gather evidence from authoritative sources before concluding.",
+        "Preserve uncertainty explicitly when the evidence is incomplete or conflicting."
+      ].join(`
+`);
+    case "docs":
+      return [
+        "Read the current behavior and documentation surface before rewriting anything.",
+        "Keep commands, examples, and terminology aligned with the actual system."
+      ].join(`
+`);
+    case "test-fix":
+      return [
+        "Decide whether the test, the implementation, or both are wrong before changing anything.",
+        "Keep regression coverage close to the observed failure mode."
+      ].join(`
+`);
+    case "explain":
+      return [
+        "Preserve the original question and answer it directly.",
+        "Use structure only when it improves clarity."
+      ].join(`
+`);
+    case "general":
+    default:
+      return [
+        "Preserve the user\u2019s intent and constraints.",
+        "Add only enough structure to improve clarity and usefulness."
+      ].join(`
+`);
+  }
+}
+function buildWorkStyle(intent, intensity) {
+  const guidance = [];
+  switch (intent) {
+    case "implement":
+      guidance.push("Understand the problem broadly enough to avoid narrow mistakes, then go deep where the risk is highest.");
+      guidance.push("Use first-principles reasoning before proposing changes.");
+      break;
+    case "debug":
+      guidance.push("Inspect before editing and find the root cause, not just the symptom.");
+      break;
+    case "refactor":
+      guidance.push("Preserve behavior while reducing duplication, branching, or complexity.");
+      break;
+    case "review":
+      guidance.push("Distinguish confirmed issues from plausible risks and order them by impact.");
+      break;
+    case "research":
+      guidance.push("Synthesize evidence into a recommendation instead of a raw note dump.");
+      break;
+    case "docs":
+      guidance.push("Optimize for accuracy, clarity, and examples that match real behavior.");
+      break;
+    case "test-fix":
+      guidance.push("Keep changes focused on the failing behavior and preserve useful coverage.");
+      break;
+    case "explain":
+      guidance.push("Stay explanatory and avoid turning the answer into an execution plan.");
+      break;
+    case "general":
+      guidance.push("Be specific, structured, and proportionate to the request.");
+      break;
+  }
+  if (intensity === "Deep") {
+    guidance.push("Review the result once with fresh eyes before finalizing.");
+  }
+  if (intensity === "Standard") {
+    guidance.push("Cover the main edge cases before finalizing.");
+  }
+  return guidance.join(`
+`);
+}
+function buildToolRules(intent) {
+  switch (intent) {
+    case "implement":
+    case "refactor":
+    case "debug":
+    case "test-fix":
+      return "Inspect the relevant files and dependencies first. Validate the final change with the narrowest useful checks before broadening scope.";
+    case "research":
+      return "Retrieve evidence from reliable sources before concluding. Do not guess facts that can be checked.";
+    case "review":
+      return "Read enough surrounding context to understand intent before critiquing. Distinguish confirmed issues from plausible risks.";
+    case "docs":
+      return "Read the current documentation and runtime behavior before rewriting. Keep examples and commands accurate.";
+    case "explain":
+    case "general":
+    default:
+      return "Use extra tools or context only when they materially improve correctness or completeness.";
+  }
+}
+function buildOutputContract(intent) {
+  switch (intent) {
+    case "implement":
+    case "refactor":
+    case "test-fix":
+      return "Return a practical execution result: concise summary, concrete changes, validation notes, and any remaining risks.";
+    case "debug":
+      return "Return a diagnosis with root cause, the fix, validation steps, and regression notes.";
+    case "research":
+      return "Return a structured synthesis with key findings, supporting evidence, and a concise recommendation.";
+    case "docs":
+      return "Return polished documentation aligned with current runtime behavior and verified examples.";
+    case "review":
+      return "Return findings grouped by severity or importance, explain why each matters, and suggest the smallest credible next step.";
+    case "explain":
+      return "Return a clear, well-structured explanation matched to the question.";
+    case "general":
+    default:
+      return "Return a clear, well-structured response matched to the task.";
+  }
+}
+function buildVerification(intent) {
+  switch (intent) {
+    case "implement":
+    case "refactor":
+    case "test-fix":
+      return [
+        "Check correctness, completeness, and edge cases.",
+        "Run relevant checks such as tests, lint, or typecheck when appropriate."
+      ].join(`
+`);
+    case "debug":
+      return [
+        "Check correctness, completeness, and edge cases.",
+        "Confirm the root cause is addressed and add regression coverage when appropriate."
+      ].join(`
+`);
+    case "review":
+      return [
+        "Check correctness and completeness.",
+        "Avoid speculative redesign unless it is necessary to explain a risk."
+      ].join(`
+`);
+    case "docs":
+      return [
+        "Check correctness and completeness.",
+        "Verify commands, examples, and terminology against the current behavior."
+      ].join(`
+`);
+    case "research":
+      return [
+        "Check correctness, completeness, and edge cases.",
+        "Call out uncertainty explicitly when evidence is incomplete or conflicting."
+      ].join(`
+`);
+    case "explain":
+    case "general":
+    default:
+      return [
+        "Check correctness, completeness, and edge cases.",
+        "Improve obvious weaknesses if a better phrasing is available within scope."
+      ].join(`
+`);
+  }
+}
+function buildDoneCriteria(intent) {
+  switch (intent) {
+    case "implement":
+    case "refactor":
+    case "test-fix":
+      return "Stop only when the change is complete, the important checks pass, and there are no known regressions.";
+    case "debug":
+      return "Stop only when the root cause is confirmed fixed and regression coverage is in place when appropriate.";
+    case "review":
+      return "Stop only when the findings are clear, prioritized, and actionable.";
+    case "research":
+      return "Stop only when the synthesis is grounded in evidence and ends with a recommended path.";
+    case "docs":
+      return "Stop only when the documentation matches the current behavior and examples are accurate.";
+    case "explain":
+      return "Stop only when the explanation clearly answers the question.";
+    case "general":
+    default:
+      return "Stop only when the response satisfies the task and matches the requested format.";
+  }
+}
+function bulletize(text) {
+  return text.split(`
+`).map((line) => collapseWhitespace(line)).filter(Boolean).map((line) => `- ${line}`).join(`
+`);
+}
+function wrapTag(tagName, content) {
+  return `<${tagName}>
+${content}
+</${tagName}>`;
+}
+function stripObjectivePrefix(objective) {
+  return objective.replace(/^Complete this task:\s*/i, "").trim();
+}
+function normalizeDraft(draft) {
+  return collapseWhitespace(draft).toLowerCase();
+}
+function normalizeEnhancedPrompt(value) {
+  return (value ?? "").replace(/\r\n/g, `
+`).trim();
+}
+function collapseWhitespace(value) {
+  return value.replace(/\r\n/g, `
+`).replace(/\s+/g, " ").trim();
+}
+function toSentence(value) {
+  const normalized = collapseWhitespace(value);
+  if (!normalized) {
+    return "";
+  }
+  const capitalized = normalized.charAt(0).toUpperCase() + normalized.slice(1);
+  if (/[.!?]$/.test(capitalized)) {
+    return capitalized;
+  }
+  return `${capitalized}.`;
+}
+
 // src/tools/context-summary.ts
 function parseStringArray(value) {
   if (typeof value !== "string" || !value.trim()) {
@@ -18416,6 +18908,47 @@ var CliKitPlugin = async (ctx) => {
   function getToolInput(args) {
     return args && typeof args === "object" ? args : {};
   }
+  function getSessionClient() {
+    if (!ctx.client || typeof ctx.client !== "object") {
+      return;
+    }
+    const clientRecord = ctx.client;
+    const sessionValue = clientRecord.session;
+    if (!sessionValue || typeof sessionValue !== "object") {
+      return;
+    }
+    const sessionRecord = sessionValue;
+    const create = sessionRecord.create;
+    const prompt = sessionRecord.prompt;
+    const deleteSession = sessionRecord.delete;
+    if (typeof create !== "function" || typeof prompt !== "function") {
+      return;
+    }
+    return {
+      create,
+      prompt,
+      delete: typeof deleteSession === "function" ? deleteSession : undefined
+    };
+  }
+  function getTuiClient() {
+    if (!ctx.client || typeof ctx.client !== "object") {
+      return;
+    }
+    const clientRecord = ctx.client;
+    const tuiValue = clientRecord.tui;
+    if (!tuiValue || typeof tuiValue !== "object") {
+      return;
+    }
+    const tuiRecord = tuiValue;
+    const showToastMethod = tuiRecord.showToast;
+    const appendPromptMethod = tuiRecord.appendPrompt;
+    const clearPromptMethod = tuiRecord.clearPrompt;
+    return {
+      showToast: typeof showToastMethod === "function" ? showToastMethod : undefined,
+      appendPrompt: typeof appendPromptMethod === "function" ? appendPromptMethod : undefined,
+      clearPrompt: typeof clearPromptMethod === "function" ? clearPromptMethod : undefined
+    };
+  }
   function blockToolExecution(reason) {
     throw new Error(`[CliKit] Blocked tool execution: ${reason}`);
   }
@@ -18434,6 +18967,32 @@ var CliKitPlugin = async (ctx) => {
       return false;
     }
   }
+  async function injectPromptIntoTui(prompt) {
+    const tuiClient = getTuiClient();
+    if (!tuiClient?.appendPrompt) {
+      return false;
+    }
+    try {
+      if (tuiClient.clearPrompt) {
+        await tuiClient.clearPrompt({
+          query: {
+            directory: ctx.directory
+          }
+        });
+      }
+      await tuiClient.appendPrompt({
+        body: {
+          text: prompt
+        },
+        query: {
+          directory: ctx.directory
+        }
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
   function normalizeTodos(rawTodos) {
     if (!Array.isArray(rawTodos)) {
       return [];
@@ -18681,6 +19240,99 @@ ${(content || "").trim()}`.trim();
   }
   return {
     tool: {
+      augment_prompt: tool({
+        description: "Rewrite a draft prompt into a stronger, intent-aware prompt for user review.",
+        args: {
+          draft: tool.schema.string().describe("Draft prompt to enhance before sending to the model."),
+          mode: tool.schema.enum(["auto", "plain", "execution-contract"]).optional().describe("Optional rewrite mode override (default: auto).")
+        },
+        async execute(args) {
+          const draft = typeof args.draft === "string" ? args.draft.trim() : "";
+          if (!draft) {
+            return JSON.stringify({
+              success: false,
+              error: "Draft prompt is required."
+            }, null, 2);
+          }
+          await showToast("Enhancing prompt\u2026", "info", "CliKit Augment");
+          const mode = args.mode === "plain" || args.mode === "execution-contract" ? args.mode : "auto";
+          const sessionClient = getSessionClient();
+          const result = await augmentPromptWithRefinement(draft, {
+            mode,
+            refine: sessionClient ? async ({ enhanced, mode: resolvedMode, intent, intensity }) => {
+              const createResult = await sessionClient.create({
+                directory: ctx.directory,
+                title: `augment:${intent}`
+              });
+              if (createResult.error || !createResult.data?.id) {
+                throw new Error("Unable to create OpenCode session for prompt enhancement.");
+              }
+              const sessionID = createResult.data.id;
+              try {
+                const refinementPrompt = [
+                  "You are refining an already-structured prompt for OpenCode.",
+                  `Intent: ${intent}`,
+                  `Rewrite mode: ${resolvedMode}`,
+                  `Effort: ${intensity}`,
+                  "Preserve the original user request exactly.",
+                  "Keep the output as a single prompt only.",
+                  "Do not add commentary, preambles, markdown fences, or explanations.",
+                  "If the prompt is already strong, return a minimally polished version.",
+                  "Return only the final rewritten prompt.",
+                  "",
+                  enhanced
+                ].join(`
+`);
+                const promptResult = await sessionClient.prompt({
+                  sessionID,
+                  directory: ctx.directory,
+                  parts: [
+                    {
+                      type: "text",
+                      text: refinementPrompt
+                    }
+                  ]
+                });
+                if (promptResult.error) {
+                  throw new Error("OpenCode prompt enhancement request failed.");
+                }
+                const textPart = promptResult.data?.parts?.find((part) => part.type === "text");
+                if (!textPart || !("text" in textPart) || typeof textPart.text !== "string") {
+                  throw new Error("OpenCode prompt enhancement returned no text output.");
+                }
+                return textPart.text;
+              } finally {
+                if (sessionClient.delete) {
+                  sessionClient.delete({
+                    sessionID,
+                    directory: ctx.directory
+                  }).catch(() => {
+                    return;
+                  });
+                }
+              }
+            } : undefined
+          });
+          const injectedIntoTui = await injectPromptIntoTui(result.enhanced);
+          const completionTitle = "CliKit Augment";
+          if (result.fallbackReason) {
+            await showToast(injectedIntoTui ? `Injected deterministic fallback. ${result.fallbackReason}` : `Using deterministic fallback. ${result.fallbackReason}`, "warning", completionTitle);
+          } else {
+            await showToast(injectedIntoTui ? `Enhanced prompt inserted (${result.enhancementSource ?? "deterministic"}).` : `Enhanced prompt ready (${result.enhancementSource ?? "deterministic"}).`, "success", completionTitle);
+          }
+          return JSON.stringify({
+            success: true,
+            original: result.original,
+            enhanced: result.enhanced,
+            intent: result.intent,
+            mode: result.mode,
+            intensity: result.intensity,
+            injectedIntoTui,
+            enhancementSource: result.enhancementSource,
+            fallbackReason: result.fallbackReason
+          }, null, 2);
+        }
+      }),
       context_summary: tool({
         description: "Summarize memory observations (decisions, learnings, blockers, progress) into a structured context digest. Useful for compaction or session handoff.",
         args: {