@objctp/opencode-better-prompt 0.8.0

package/plugins/better-prompt/pipeline.ts

@@ -0,0 +1,190 @@
+import { CONFIG_DEFAULTS } from "./config";
+import type { Config } from "./config";
+import { resolveModel } from "./catalog";
+import { invokeAgent, summariseContext } from "./agents";
+import type { PipelineDeps, PipelineResult, StageNotifier, Usage } from "./types";
+
+// A correction is consistent when every claimed fix actually appears in the
+// corrected text.  A model that lists a fix for text it then dropped has
+// rewritten or extracted a subset rather than applying discrete fixes — the
+// correction should be discarded and the original kept.
+function correctionIsConsistent(
+  corrected: string,
+  mistakes: Array<{ correction?: string }>,
+): boolean {
+  for (const m of mistakes) {
+    const fix = m.correction;
+    if (!fix) continue;
+    if (!corrected.toLowerCase().includes(fix.toLowerCase())) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export async function runPipeline(
+  deps: PipelineDeps,
+  text: string,
+  sessionID: string,
+  config: Config,
+  notify: StageNotifier,
+  currentMessageID?: string,
+): Promise<PipelineResult> {
+  const { toast, logWarn } = deps;
+
+  let working = text;
+  let corrected: string | null = null;
+  let detectedLanguage: string | null = null;
+  let mistakes: Array<{ type: string; original: string; correction: string }> = [];
+  const totalUsage: Usage = {
+    cost: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheWriteTokens: 0,
+    cacheReadTokens: 0,
+  };
+
+  function addUsage(u: Usage) {
+    totalUsage.cost += u.cost;
+    totalUsage.inputTokens += u.inputTokens;
+    totalUsage.outputTokens += u.outputTokens;
+    totalUsage.cacheWriteTokens += u.cacheWriteTokens;
+    totalUsage.cacheReadTokens += u.cacheReadTokens;
+  }
+
+  const { correction, translation, enhancement } = config;
+  const anyStage = correction || translation || enhancement;
+  if (!anyStage) {
+    return {
+      result: text,
+      corrected: null,
+      detectedLanguage: null,
+      mistakes: [],
+      contextSummary: "",
+      usage: totalUsage,
+    };
+  }
+
+  const skipCorrection = enhancement && !translation && correction;
+  const correctionOnlyForLanguage = translation && !correction;
+
+  // :::: Correction //
+  if (!skipCorrection && (correction || correctionOnlyForLanguage)) {
+    notify("correction", "starting");
+    const model = await resolveModel(config.correction_model, CONFIG_DEFAULTS.correction_model);
+    const correctionResult = await invokeAgent(deps, "prompt-correction", working, model);
+    addUsage(correctionResult.usage);
+    const raw = correctionResult.text;
+
+    let correctionFailed = false;
+    let correctionError = "";
+    try {
+      const fenceMatch = raw.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+      const cleaned = fenceMatch ? fenceMatch[1].trim() : raw.trim();
+      const parsed = JSON.parse(cleaned);
+      if (parsed.corrected && typeof parsed.corrected === "string") {
+        if (correctionOnlyForLanguage) {
+          detectedLanguage = parsed.language || null;
+        } else {
+          const candidateMistakes = Array.isArray(parsed.mistakes) ? parsed.mistakes : [];
+          // Guard: every claimed fix must appear in the corrected text; otherwise
+          // the model rewrote/extracted a subset instead of applying discrete fixes
+          // — discard and keep the original prompt.
+          if (!correctionIsConsistent(parsed.corrected, candidateMistakes)) {
+            correctionFailed = true;
+            correctionError = "discarded: dropped a claimed fix";
+            void logWarn("correction discarded — output dropped a claimed fix; keeping original");
+          } else {
+            working = parsed.corrected;
+            corrected = parsed.corrected;
+            detectedLanguage = parsed.language || null;
+            mistakes = candidateMistakes;
+          }
+        }
+      } else {
+        correctionFailed = true;
+        correctionError = "missing corrected field";
+        void logWarn(`correction agent returned JSON without "corrected" field`);
+      }
+    } catch {
+      correctionFailed = true;
+      correctionError = "non-JSON response";
+      void logWarn(`correction agent returned non-JSON`, raw?.substring(0, 200));
+    }
+    if (correctionFailed) {
+      notify("correction", "error", correctionError);
+      const discarded = correctionError.startsWith("discarded");
+      await toast(
+        discarded ? "Correction discarded — keeping original" : "Correction failed — using original prompt",
+        discarded ? "info" : "error",
+        3000,
+      );
+    } else {
+      notify("correction", "complete");
+    }
+  } else {
+    notify("correction", "skipped");
+  }
+
+  // :::: Translation //
+  if (translation) {
+    if (detectedLanguage === "en") {
+      notify("translation", "skipped");
+    } else {
+      notify("translation", "starting");
+      const model = await resolveModel(config.translation_model, CONFIG_DEFAULTS.translation_model);
+      const translationResult = await invokeAgent(deps, "prompt-translation", working, model);
+      addUsage(translationResult.usage);
+      if (translationResult.text?.trim()) {
+        working = translationResult.text;
+      }
+      notify("translation", "complete");
+    }
+  } else {
+    notify("translation", "skipped");
+  }
+
+  // :::: Context summarisation (only with enhancement) //
+  let contextSummary = "";
+  if (enhancement) {
+    notify("context", "starting");
+    const ctxResult = await summariseContext(deps, sessionID, currentMessageID ?? "", config);
+    contextSummary = ctxResult.summary;
+    addUsage(ctxResult.usage);
+    deps.sessionContexts.set(sessionID, {
+      summary: ctxResult.summary,
+      lastMessageID: ctxResult.lastMessageID,
+      messageCount: ctxResult.messageCount,
+    });
+    notify("context", "complete");
+  }
+
+  // :::: Enhancement //
+  if (enhancement) {
+    notify("enhancement", "starting");
+    let enhanceInput = "";
+    if (contextSummary) {
+      enhanceInput += `Conversation context: ${contextSummary}\n\n`;
+    }
+    enhanceInput += working;
+
+    const model = await resolveModel(config.enhancement_model, CONFIG_DEFAULTS.enhancement_model);
+    const enhancementResult = await invokeAgent(deps, "prompt-enhancement", enhanceInput, model);
+    addUsage(enhancementResult.usage);
+    if (enhancementResult.text?.trim()) {
+      working = enhancementResult.text;
+    }
+    notify("enhancement", "complete");
+  } else {
+    notify("enhancement", "skipped");
+  }
+
+  return {
+    result: working,
+    corrected,
+    detectedLanguage,
+    mistakes,
+    contextSummary,
+    usage: totalUsage,
+  };
+}

package/plugins/better-prompt/state.ts

@@ -0,0 +1,21 @@
+import { appendFileSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import type { AuditEntry, PipelineState } from "./types";
+
+export function writeAudit(auditPath: string, entry: AuditEntry): void {
+  mkdirSync(dirname(auditPath), { recursive: true });
+  appendFileSync(auditPath, `${JSON.stringify(entry)}\n`);
+}
+
+export function writeState(statePath: string, state: PipelineState): void {
+  mkdirSync(dirname(statePath), { recursive: true });
+  writeFileSync(statePath, `${JSON.stringify(state)}\n`);
+}
+
+export function clearState(statePath: string): void {
+  try {
+    unlinkSync(statePath);
+  } catch {
+    // best effort
+  }
+}

package/plugins/better-prompt/tui/format.ts

@@ -0,0 +1,42 @@
+import { findModelEntry, MODEL_DEFAULTS, TIER_ALIASES, TIER_CYCLE } from "../catalog";
+import { formatContext, formatCost } from "../format";
+import type { ModelEntry } from "../types";
+
+type ModelTiers = { fast: ModelEntry[]; capable: ModelEntry[]; powerful: ModelEntry[] };
+
+export function formatModelDisplay(value: string, tiers: ModelTiers | null, key: string): string {
+  const isDefault = value === MODEL_DEFAULTS[key];
+  if (isDefault) return `${value} (inherits session model)`;
+
+  // Legacy alias: haiku → fast, sonnet → capable, opus → powerful
+  const alias = TIER_ALIASES[value];
+  if (alias) {
+    if (!tiers) return `${value} ≡ ${alias}`;
+    const tierModels = tiers[alias as "fast" | "capable" | "powerful"];
+    const best = tierModels?.[0];
+    return `${value} ≡ ${alias} ${
+      best ? `(${best.id}  ${formatCost(best.cost)}  ctx:${formatContext(best.context)})` : ""
+    }`;
+  }
+
+  // Tier name: fast/capable/powerful
+  if (TIER_CYCLE.includes(value)) {
+    if (!tiers) return value;
+    const tierModels = tiers[value as "fast" | "capable" | "powerful"];
+    const best = tierModels?.[0];
+    return `${value} ${
+      best ? `(${best.id}  ${formatCost(best.cost)}  ctx:${formatContext(best.context)})` : ""
+    }`;
+  }
+
+  // Explicit provider/model
+  if (tiers) {
+    const entry = findModelEntry(value, tiers);
+    if (entry) {
+      return `${value} (${entry.tier}  ${formatCost(entry.cost)}  ctx:${formatContext(
+        entry.context,
+      )})`;
+    }
+  }
+  return value;
+}

package/plugins/better-prompt/tui/routes.tsx

@@ -0,0 +1,310 @@
+/** @jsxImportSource @opentui/solid */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+import { createSignal } from "solid-js";
+import { CONFIG_PATH, MODEL_FIELDS, parseConfig, updateConfig } from "../config";
+import type { Config } from "../config";
+import { getModelTiers, resolveTier, TIER_ALIASES, TIER_CYCLE } from "../catalog";
+import type { ModelEntry } from "../types";
+import { formatModelDisplay } from "./format";
+import { SelectView, type SelectOption } from "./select-view";
+
+export interface RouteProps {
+  api: TuiPluginApi;
+  goBack: () => void;
+}
+
+function auditPath(api: TuiPluginApi): string {
+  return join(api.state.path.directory, ".opencode", "better-prompt", "audit.json");
+}
+
+// :::: /better-prompt:toggle :::: ///////////////////////////
+
+export function ToggleRoute(props: RouteProps) {
+  const TOGGLE_KEYS = [
+    "enabled",
+    "correction",
+    "translation",
+    "enhancement",
+    "audit",
+    "verbose",
+  ] as const;
+
+  const buildStages = (): SelectOption[] => {
+    const config = parseConfig(CONFIG_PATH);
+    return TOGGLE_KEYS.map((stage) => ({
+      title: stage,
+      description: `Currently: ${
+        (config as unknown as Record<string, unknown>)[stage] ? "ON" : "OFF"
+      }`,
+      value: stage,
+    }));
+  };
+
+  const [stages, setStages] = createSignal<SelectOption[]>(buildStages());
+
+  return (
+    <SelectView
+      title="Better Prompt: Toggle Stage"
+      options={() => stages()}
+      onSelect={(opt) => {
+        const current = parseConfig(CONFIG_PATH);
+        const newVal = !(current as unknown as Record<string, unknown>)[opt.value];
+        updateConfig(CONFIG_PATH, { [opt.value]: newVal });
+        props.api.ui.toast({
+          variant: "success",
+          message: `${opt.value} is now ${newVal ? "ON" : "OFF"}`,
+        });
+        setStages(buildStages());
+      }}
+      onBack={props.goBack}
+    />
+  );
+}
+
+// :::: /better-prompt:config :::: ///////////////////////////
+
+export function ConfigRoute(props: RouteProps) {
+  const [configData, setConfigData] = createSignal(parseConfig(CONFIG_PATH));
+  const [tiersData, setTiersData] = createSignal<{
+    fast: ModelEntry[];
+    capable: ModelEntry[];
+    powerful: ModelEntry[];
+  } | null>(null);
+  const [cycleIndex, setCycleIndex] = createSignal<Record<string, number>>({});
+
+  // Load model tiers asynchronously
+  getModelTiers()
+    .then(setTiersData)
+    .catch(() => {
+      props.api.ui.toast({
+        variant: "error",
+        message: "Could not load model tiers",
+      });
+    });
+
+  const refreshConfig = () => {
+    setConfigData(parseConfig(CONFIG_PATH));
+  };
+
+  const options = () => {
+    const config = configData();
+    return Object.entries(config).map(([k, v]) => {
+      const isModel = (MODEL_FIELDS as readonly string[]).includes(k);
+
+      if (isModel) {
+        const display = formatModelDisplay(String(v), tiersData(), k);
+        return {
+          title: k,
+          description: display,
+          value: k,
+        };
+      }
+
+      const isBool = typeof v === "boolean";
+      return {
+        title: k,
+        description: `${v}${isBool ? "  (select to toggle)" : ""}`,
+        value: k,
+      };
+    });
+  };
+
+  const handleSelect = (opt: SelectOption) => {
+    const key = opt.value as keyof Config;
+    const config = configData();
+    const currentVal = config[key];
+
+    if (typeof currentVal === "boolean") {
+      updateConfig(CONFIG_PATH, { [key]: !currentVal });
+      props.api.ui.toast({
+        variant: "success",
+        message: `${key}: ${currentVal} -> ${!currentVal}`,
+      });
+      refreshConfig();
+      return;
+    }
+
+    // Model field: cycle tier on Enter
+    if ((MODEL_FIELDS as readonly string[]).includes(key)) {
+      const current = String(currentVal);
+      const resolvedTier = resolveTier(current, tiersData());
+      const currentTierName = resolvedTier || TIER_ALIASES[current] || current;
+
+      const currentIdx = TIER_CYCLE.indexOf(currentTierName);
+      const nextIdx = currentIdx >= 0 ? (currentIdx + 1) % TIER_CYCLE.length : 0;
+      const next = TIER_CYCLE[nextIdx];
+
+      updateConfig(CONFIG_PATH, { [key]: next });
+      setCycleIndex({ ...cycleIndex(), [key]: 0 });
+      props.api.ui.toast({ variant: "success", message: `${key}: ${next}` });
+      refreshConfig();
+    }
+  };
+
+  const handleAltSelect = (opt: SelectOption) => {
+    const key = opt.value as keyof Config;
+    if (!(MODEL_FIELDS as readonly string[]).includes(key)) return;
+
+    const tierData = tiersData();
+    if (!tierData) {
+      props.api.ui.toast({
+        variant: "error",
+        message: "Model data not loaded yet",
+      });
+      return;
+    }
+
+    const config = configData();
+    const currentVal = String(config[key]);
+    const resolvedTier = resolveTier(currentVal, tierData) || "fast";
+    const modelsInTier = tierData[resolvedTier as "fast" | "capable" | "powerful"];
+    if (!modelsInTier || modelsInTier.length === 0) {
+      props.api.ui.toast({
+        variant: "error",
+        message: `No models available for tier: ${resolvedTier}`,
+      });
+      return;
+    }
+
+    const currentIdx = (cycleIndex()[key] || 0) % modelsInTier.length;
+    const picked = modelsInTier[currentIdx];
+    updateConfig(CONFIG_PATH, { [key]: picked.id });
+    setCycleIndex({ ...cycleIndex(), [key]: currentIdx + 1 });
+    props.api.ui.toast({
+      variant: "success",
+      message: `${key}: ${picked.id} (${resolvedTier})`,
+    });
+    refreshConfig();
+  };
+
+  return (
+    <SelectView
+      title="Better Prompt Configuration"
+      options={options}
+      onSelect={handleSelect}
+      onAltSelect={handleAltSelect}
+      onBack={props.goBack}
+    />
+  );
+}
+
+// :::: /better-prompt:audit :::: ////////////////////////////
+
+export function AuditRoute(props: RouteProps) {
+  const path = auditPath(props.api);
+
+  if (!existsSync(path)) {
+    return (
+      <box border paddingTop={0} paddingBottom={0} paddingLeft={1} paddingRight={1}>
+        <text>No audit data available.</text>
+      </box>
+    );
+  }
+
+  const allLines = readFileSync(path, "utf8")
+    .trim()
+    .split("\n")
+    .filter((l: string) => l.trim());
+
+  if (allLines.length === 0) {
+    return (
+      <box border paddingTop={0} paddingBottom={0} paddingLeft={1} paddingRight={1}>
+        <text>Audit trail is empty.</text>
+      </box>
+    );
+  }
+
+  const recent = allLines.slice(-10);
+  const auditOptions: SelectOption[] = [];
+
+  for (let i = 0; i < recent.length; i++) {
+    try {
+      const entry = JSON.parse(recent[i]);
+      const num = allLines.length - recent.length + i + 1;
+      const mistakes = entry.mistakes?.length ?? 0;
+      const parts: string[] = [entry.prompt.substring(0, 60)];
+      if (entry.language) parts.push(`lang: ${entry.language}`);
+      if (mistakes > 0) {
+        parts.push(`${mistakes} mistake${mistakes > 1 ? "s" : ""}`);
+      }
+      auditOptions.push({
+        title: `Entry #${num}`,
+        description: parts.join(" | "),
+        value: String(num),
+      });
+    } catch {
+      // skip malformed entries
+    }
+  }
+
+  auditOptions.push({
+    title: "Clear audit trail",
+    description: `${allLines.length} entries total`,
+    value: "clear",
+  });
+
+  return (
+    <SelectView
+      title="Audit Trail"
+      options={() => auditOptions}
+      onSelect={(opt) => {
+        if (opt.value === "clear") {
+          writeFileSync(path, "");
+          props.api.ui.toast({
+            variant: "success",
+            message: "Audit trail cleared.",
+          });
+          props.goBack();
+          return;
+        }
+        const num = parseInt(opt.value, 10);
+        const line = allLines[num - 1];
+        try {
+          const entry = JSON.parse(line);
+          const details: string[] = [`#${num} ${entry.date}`, `Original: "${entry.prompt}"`];
+          if (entry.language) details.push(`Language: ${entry.language}`);
+          if (entry.corrected) {
+            details.push(`Corrected: "${entry.corrected}"`);
+          }
+          if (entry.enhanced) details.push(`Enhanced: "${entry.enhanced}"`);
+          if (entry.mistakes?.length > 0) {
+            details.push(
+              "Mistakes: " +
+                entry.mistakes
+                  .map(
+                    (m: { type: string; original: string; correction: string }) =>
+                      `[${m.type}] "${m.original}" -> "${m.correction}"`,
+                  )
+                  .join("; "),
+            );
+          }
+          if (entry.models) {
+            const used: string[] = [];
+            if (entry.models.correction) {
+              used.push(`correction=${entry.models.correction}`);
+            }
+            if (entry.models.translation) {
+              used.push(`translation=${entry.models.translation}`);
+            }
+            if (entry.models.enhancement) {
+              used.push(`enhancement=${entry.models.enhancement}`);
+            }
+            if (used.length) details.push(`Models: ${used.join(", ")}`);
+          }
+          props.api.ui.toast({
+            variant: "info",
+            message: details.join("\n"),
+            duration: 8000,
+          });
+        } catch {
+          // skip
+        }
+        props.goBack();
+      }}
+      onBack={props.goBack}
+    />
+  );
+}

package/plugins/better-prompt/tui/select-view.tsx

@@ -0,0 +1,58 @@
+/** @jsxImportSource @opentui/solid */
+
+import { useKeyboard } from "@opentui/solid";
+import { createSignal } from "solid-js";
+
+export interface SelectOption {
+  title: string;
+  description: string;
+  value: string;
+}
+
+export function SelectView(props: {
+  title: string;
+  options: () => SelectOption[];
+  onSelect: (opt: SelectOption) => void;
+  onAltSelect?: (opt: SelectOption) => void;
+  onBack: () => void;
+}) {
+  const [idx, setIdx] = createSignal(0);
+
+  useKeyboard((key: { name: string }) => {
+    const opts = props.options();
+    const max = opts.length - 1;
+    if (key.name === "up" || key.name === "k") {
+      setIdx((i: number) => Math.max(0, i - 1));
+    }
+    if (key.name === "down" || key.name === "j") {
+      setIdx((i: number) => Math.min(max, i + 1));
+    }
+    if (key.name === "return") {
+      const opt = opts[idx()];
+      if (opt) props.onSelect(opt);
+    }
+    if (key.name === "space") {
+      if (props.onAltSelect) {
+        const opt = opts[idx()];
+        if (opt) props.onAltSelect(opt);
+      }
+    }
+    if (key.name === "escape") {
+      props.onBack();
+    }
+  });
+
+  return (
+    <box border paddingTop={0} paddingBottom={0} paddingLeft={1} paddingRight={1}>
+      <text>
+        <strong>{props.title}</strong>
+      </text>
+      {props.options().map((opt: SelectOption, i: number) => (
+        <text fg={idx() === i ? "#ffffff" : "#888888"}>
+          {`${idx() === i ? "> " : "  "}${opt.title}  ${opt.description}`}
+        </text>
+      ))}
+      <text fg="#555555">Up/Dn Navigate Enter Cycle Tier Space Pick Model Esc Back</text>
+    </box>
+  );
+}