@objctp/opencode-better-prompt 0.8.0

package/plugins/better-prompt/tui/sidebar-panel.tsx

@@ -0,0 +1,220 @@
+/** @jsxImportSource @opentui/solid */
+
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createEffect, createSignal, onCleanup } from "solid-js";
+import { CONFIG_DEFAULTS, CONFIG_PATH, parseConfig } from "../config";
+import type { Config } from "../config";
+import { formatDuration, formatTokens } from "../format";
+import type { PipelineState, StageState } from "../types";
+
+const POLL_MS = 500;
+
+const STATE_PATH = join(homedir(), ".local", "state", "opencode", "better-prompt", "state.json");
+
+const STAGE_DEFS = [
+  { key: "correction" as const, label: "correction", enabled: (c: Config) => c.correction },
+  { key: "translation" as const, label: "translation", enabled: (c: Config) => c.translation },
+  { key: "context" as const, label: "context", enabled: (c: Config) => c.enhancement },
+  { key: "enhancement" as const, label: "enhancement", enabled: (c: Config) => c.enhancement },
+];
+
+export function SidebarPanel(props: { theme: Record<string, unknown> }) {
+  const [state, setState] = createSignal<PipelineState | null>(null);
+  const [config, setConfig] = createSignal<Config>({ ...CONFIG_DEFAULTS });
+
+  const accent = () => (props.theme.accent as string) || "#A78BFA";
+  const muted = () => (props.theme.textMuted as string) || "#888888";
+  const success = () => (props.theme.success as string) || "#22C55E";
+  const warning = () => (props.theme.warning as string) || "#F59E0B";
+  const info = () => (props.theme.info as string) || "#06B6D4";
+
+  createEffect(() => {
+    function load() {
+      try {
+        setConfig(parseConfig(CONFIG_PATH));
+      } catch {
+        // config read may fail if file doesn't exist yet
+      }
+      try {
+        if (!existsSync(STATE_PATH)) {
+          setState(null);
+          return;
+        }
+        const raw = readFileSync(STATE_PATH, "utf8").trim();
+        if (!raw) {
+          setState(null);
+          return;
+        }
+        setState(JSON.parse(raw) as PipelineState);
+      } catch {
+        // stale read is fine
+      }
+    }
+    load();
+    const timer = setInterval(load, POLL_MS);
+    onCleanup(() => clearInterval(timer));
+  });
+
+  const isVisible = () => state() !== null;
+
+  function stageSymbol(status: StageState["status"]): { char: string; color: string } {
+    switch (status) {
+      case "active":
+        return { char: "\u25C6", color: info() };
+      case "complete":
+        return { char: "\u25C7", color: success() };
+      case "skipped":
+        return { char: "\u25CB", color: muted() };
+      case "error":
+        return { char: "\u25B2", color: warning() };
+      default:
+        return { char: "\u25CB", color: muted() };
+    }
+  }
+
+  function stageVerb(label: string): string {
+    const map: Record<string, string> = {
+      correction: "correcting",
+      translation: "translating",
+      context: "summarising",
+      enhancement: "enhancing",
+    };
+    return map[label] || `${label}...`;
+  }
+
+  function stageDetail(def: (typeof STAGE_DEFS)[number], ss: StageState, s: PipelineState): string {
+    if (ss.status === "active") {
+      return stageVerb(def.label);
+    }
+    if (ss.status === "complete") {
+      const parts: string[] = ["done"];
+      const dur = formatDuration(ss.durationMs);
+      if (dur) parts.push(dur);
+      if (def.key === "correction" && s.mistakes > 0) {
+        parts.push(`${s.mistakes} mistake${s.mistakes > 1 ? "s" : ""}`);
+      }
+      return parts.join(" \u00B7 ");
+    }
+    if (ss.status === "skipped") {
+      const parts: string[] = ["skipped"];
+      if (def.key === "translation" && s.language === "en") parts.push("(en)");
+      return parts.join(" ");
+    }
+    if (ss.status === "error") {
+      return ss.error || "error";
+    }
+    return "";
+  }
+
+  return (
+    <box width="100%" flexDirection="column" marginBottom={isVisible() ? 1 : 0}>
+      {isVisible() && (
+        <text fg={accent()}>
+          <b>Better Prompt</b>
+        </text>
+      )}
+
+      {isVisible() && (
+        <box width="100%" flexDirection="column" paddingLeft={1}>
+          {(() => {
+            const s = state();
+            if (!s) return [];
+            const c = config();
+            const verbose = c.verbose;
+            const visibleStages = STAGE_DEFS.filter((def) => def.enabled(c));
+            const elements: unknown[] = [];
+
+            for (let i = 0; i < visibleStages.length; i++) {
+              const def = visibleStages[i];
+              const ss = s.stages[def.key];
+              const sym = stageSymbol(ss.status);
+              const isLast = i === visibleStages.length - 1;
+              const connector = isLast ? "  " : "\u2502 ";
+
+              elements.push(
+                <box flexDirection="row">
+                  <text fg={sym.color}>{sym.char}</text>
+                  <text fg={accent()}> {def.label}</text>
+                </box>,
+              );
+
+              const detail = stageDetail(def, ss, s);
+              const showLangBadge =
+                def.key === "correction" && s.language && ss.status !== "pending";
+
+              elements.push(
+                <box flexDirection="row">
+                  <text fg={muted()}>{connector}</text>
+                  {showLangBadge ? (
+                    <>
+                      <text bg="#374151" fg="#E5E7EB">
+                        {" "}
+                        {s.language}{" "}
+                      </text>
+                      <text fg={ss.status === "error" ? warning() : muted()}> {detail}</text>
+                    </>
+                  ) : (
+                    <text fg={ss.status === "error" ? warning() : muted()}> {detail}</text>
+                  )}
+                </box>,
+              );
+
+              if (
+                verbose &&
+                def.key === "correction" &&
+                ss.status === "complete" &&
+                s.preview?.mistakeDetails &&
+                s.preview.mistakeDetails.length > 0
+              ) {
+                for (const m of s.preview.mistakeDetails.slice(0, 5)) {
+                  elements.push(
+                    <box flexDirection="row">
+                      <text fg={muted()}>{connector}</text>
+                      <text fg={muted()}>
+                        {" "}
+                        {m.type}: "{m.original}" → "{m.correction}"
+                      </text>
+                    </box>,
+                  );
+                }
+              }
+
+              if (!isLast) {
+                elements.push(<text fg={muted()}>│</text>);
+              }
+            }
+
+            if (s.inputTokens > 0 || s.outputTokens > 0) {
+              const costParts: string[] = [];
+              if (s.cost > 0) costParts.push(`$${s.cost.toFixed(4)}`);
+              costParts.push(
+                `${formatTokens(s.inputTokens)}\u2192${formatTokens(s.outputTokens)}t`,
+              );
+              elements.push(
+                <box flexDirection="row" marginTop={0}>
+                  <text fg={muted()}> </text>
+                  {s.cost > 0 ? (
+                    <text fg={muted()}> {costParts.join(" \u00B7 ")}</text>
+                  ) : (
+                    <text fg={muted()}> {costParts[0]}</text>
+                  )}
+                  {s.sessionInputTokens > 0 ? (
+                    <text fg={muted()}>
+                      {" "}
+                      (sess: {formatTokens(s.sessionInputTokens)}→
+                      {formatTokens(s.sessionOutputTokens)}t)
+                    </text>
+                  ) : null}
+                </box>,
+              );
+            }
+
+            return elements;
+          })()}
+        </box>
+      )}
+    </box>
+  );
+}

package/plugins/better-prompt/types.ts

@@ -0,0 +1,137 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+
+// :::: Model / catalog types :::: ///////////////////////////
+
+export type ModelRef = { providerID: string; modelID: string };
+
+export interface ModelEntry {
+  id: string;
+  providerID: string;
+  modelID: string;
+  tier: "fast" | "capable" | "powerful";
+  context: number;
+  cost: number;
+  toolCall: boolean;
+}
+
+export interface CatalogModel {
+  id: string;
+  name?: string;
+  tool_call?: boolean;
+  limit?: { context?: number; output?: number };
+  cost?: { input?: number; output?: number };
+}
+
+export interface CatalogProvider {
+  id: string;
+  name?: string;
+  env?: string[];
+  models?: Record<string, CatalogModel>;
+}
+
+export type Catalog = Record<string, CatalogProvider>;
+
+export interface CatalogCandidate {
+  id: string;
+  context: number;
+  cost: number;
+  toolCall: boolean;
+}
+
+export interface OpenCodeConfig {
+  disabled_providers?: string[];
+  enabled_providers?: string[];
+  provider?: Record<string, { models?: Record<string, unknown> }>;
+  [key: string]: unknown;
+}
+
+// :::: Pipeline types :::: //////////////////////////////////
+
+export interface Usage {
+  cost: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheWriteTokens: number;
+  cacheReadTokens: number;
+}
+
+export interface PipelineResult {
+  result: string;
+  corrected: string | null;
+  detectedLanguage: string | null;
+  mistakes: Array<{ type: string; original: string; correction: string }>;
+  contextSummary: string;
+  usage: Usage;
+}
+
+export type StageStatus = "starting" | "complete" | "skipped" | "error";
+export type StageNotifier = (stage: string, status: StageStatus, detail?: string) => void;
+
+export interface SessionContext {
+  summary: string;
+  lastMessageID: string;
+  messageCount: number;
+}
+
+export interface AuditEntry {
+  date: string;
+  prompt: string;
+  language: string | null;
+  corrected: string | null;
+  enhanced: string | null;
+  "mistake-nature": string[];
+  mistakes: Array<{ type: string; original: string; correction: string }>;
+  models: {
+    correction: string | null;
+    translation: string | null;
+    enhancement: string | null;
+    context: string | null;
+  };
+  usage: Usage;
+}
+
+// :::: State types :::: /////////////////////////////////////
+
+export interface StageState {
+  status: "pending" | "active" | "complete" | "skipped" | "error";
+  durationMs: number | null;
+  error?: string;
+}
+
+export interface PipelineState {
+  timestamp: string;
+  status: "running" | "modified" | "no_changes" | "error";
+  language: string | null;
+  mistakes: number;
+  stages: {
+    correction: StageState;
+    translation: StageState;
+    context: StageState;
+    enhancement: StageState;
+  };
+  cost: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheWriteTokens: number;
+  cacheReadTokens: number;
+  sessionCost: number;
+  sessionInputTokens: number;
+  sessionOutputTokens: number;
+  preview?: {
+    original: string;
+    processed: string;
+    mistakeDetails: Array<{ type: string; original: string; correction: string }>;
+  };
+}
+
+// :::: Plugin dependency injection :::: /////////////////////
+
+export type ToastVariant = "info" | "success" | "error";
+
+export interface PipelineDeps {
+  client: PluginInput["client"];
+  logError: (message: string, error?: unknown) => Promise<void>;
+  logWarn: (message: string, detail?: string) => Promise<void>;
+  toast: (message: string, variant?: ToastVariant, duration?: number) => Promise<void>;
+  sessionContexts: Map<string, SessionContext>;
+}

package/plugins/better-prompt-tui.tsx

@@ -0,0 +1,129 @@
+/** @jsxImportSource @opentui/solid */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { TuiPlugin, TuiPluginModule } from "@opencode-ai/plugin/tui";
+import { SidebarPanel } from "./better-prompt/tui/sidebar-panel";
+import { AuditRoute, ConfigRoute, ToggleRoute } from "./better-prompt/tui/routes";
+
+// :::: TUI Plugin :::: //////////////////////////////////////
+
+const tui: TuiPlugin = async (api) => {
+  function getAuditPath(): string {
+    return join(api.state.path.directory, ".opencode", "better-prompt", "audit.json");
+  }
+
+  // Track previous route so we can navigate back
+  let prevRoute: { name: string; params?: Record<string, unknown> } = {
+    name: "home",
+  };
+
+  function goBack() {
+    api.route.navigate(prevRoute.name, prevRoute.params);
+  }
+
+  function snapshotCurrentRoute() {
+    return {
+      name: api.route.current.name,
+      params: (api.route.current as Record<string, unknown>).params as
+        | Record<string, unknown>
+        | undefined,
+    };
+  }
+
+  // :::: Command handlers (orchestration) :::: /////////////
+
+  function handleToggle() {
+    prevRoute = snapshotCurrentRoute();
+    api.route.navigate("better-prompt:toggle");
+  }
+
+  function handleConfig() {
+    prevRoute = snapshotCurrentRoute();
+    api.route.navigate("better-prompt:config");
+  }
+
+  function handleAudit() {
+    const auditPath = getAuditPath();
+
+    if (!existsSync(auditPath)) {
+      api.ui.toast({
+        variant: "info",
+        message: "No audit data available. Enable with /better-prompt:toggle audit on",
+      });
+      return;
+    }
+
+    const allLines = readFileSync(auditPath, "utf8")
+      .trim()
+      .split("\n")
+      .filter((l: string) => l.trim());
+
+    if (allLines.length === 0) {
+      api.ui.toast({ variant: "info", message: "Audit trail is empty." });
+      return;
+    }
+
+    prevRoute = snapshotCurrentRoute();
+    api.route.navigate("better-prompt:audit");
+  }
+
+  // :::: Registration :::: /////////////////////////////////
+
+  api.slots.register({
+    order: 150,
+    slots: {
+      sidebar_content(ctx) {
+        return (
+          <SidebarPanel
+            theme={(ctx.theme as unknown as { current: Record<string, unknown> }).current ?? {}}
+          />
+        );
+      },
+    },
+  });
+
+  api.route.register([
+    { name: "better-prompt:toggle", render: () => <ToggleRoute api={api} goBack={goBack} /> },
+    { name: "better-prompt:config", render: () => <ConfigRoute api={api} goBack={goBack} /> },
+    { name: "better-prompt:audit", render: () => <AuditRoute api={api} goBack={goBack} /> },
+  ]);
+
+  api.keymap.registerLayer({
+    commands: [
+      {
+        name: "better-prompt.toggle",
+        title: "BP: Toggle Stage",
+        category: "Better Prompt",
+        namespace: "palette",
+        slashName: "better-prompt:toggle",
+        run: handleToggle,
+      },
+      {
+        name: "better-prompt.config",
+        title: "BP: Show Config",
+        category: "Better Prompt",
+        namespace: "palette",
+        slashName: "better-prompt:config",
+        run: handleConfig,
+      },
+      {
+        name: "better-prompt.audit",
+        title: "BP: Audit Trail",
+        category: "Better Prompt",
+        namespace: "palette",
+        slashName: "better-prompt:audit",
+        run: handleAudit,
+      },
+    ],
+  });
+};
+
+// :::: Module export :::: ///////////////////////////////////
+
+const plugin: TuiPluginModule & { id: string } = {
+  id: "@objctp/opencode-better-prompt",
+  tui,
+};
+
+export default plugin;