@objctp/opencode-better-prompt 0.8.0

package/plugins/better-prompt/agents.ts

@@ -0,0 +1,238 @@
+import type { Part } from "@opencode-ai/sdk";
+import { CONFIG_DEFAULTS } from "./config";
+import type { Config } from "./config";
+import { resolveModel } from "./catalog";
+import type { ModelRef, PipelineDeps, Usage } from "./types";
+
+export const SUB_AGENTS = new Set([
+  "prompt-correction",
+  "prompt-translation",
+  "prompt-enhancement",
+  "prompt-summarisation",
+]);
+
+export const FULL_REFRESH_THRESHOLD = 10;
+
+interface PromptInfo {
+  cost?: number;
+  tokens?: {
+    input?: number;
+    output?: number;
+    cache?: { write?: number; read?: number };
+  };
+}
+
+const ZERO_USAGE: Usage = {
+  cost: 0,
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheWriteTokens: 0,
+  cacheReadTokens: 0,
+};
+
+// :::: Agent invocation :::: ////////////////////////////////
+
+export async function invokeAgent(
+  deps: PipelineDeps,
+  agent: string,
+  text: string,
+  model?: ModelRef,
+): Promise<{ text: string; usage: Usage }> {
+  const { client, toast, logError, logWarn } = deps;
+  let childId: string | undefined;
+  try {
+    const { data: child } = await client.session.create({
+      body: {},
+    });
+    if (!child) {
+      await toast(`${agent}: could not create session`, "error");
+      return { text, usage: { ...ZERO_USAGE } };
+    }
+    childId = child.id;
+
+    const { data: result } = await client.session.prompt({
+      body: {
+        agent,
+        parts: [{ type: "text", text }],
+        ...(model && { model }),
+      },
+      path: { id: child.id },
+    });
+
+    if (!result?.parts) {
+      return { text, usage: { ...ZERO_USAGE } };
+    }
+
+    const textPart = result.parts.find((p: Part) => p.type === "text" && "text" in p);
+    const resultText = textPart && "text" in textPart ? (textPart as { text: string }).text : text;
+
+    const info = (result as Record<string, unknown>).info as PromptInfo | undefined;
+    const usage: Usage = {
+      cost: info?.cost ?? 0,
+      inputTokens: info?.tokens?.input ?? 0,
+      outputTokens: info?.tokens?.output ?? 0,
+      cacheWriteTokens: info?.tokens?.cache?.write ?? 0,
+      cacheReadTokens: info?.tokens?.cache?.read ?? 0,
+    };
+
+    return { text: resultText, usage };
+  } catch (err) {
+    void logError(`invokeAgent(${agent}) failed`, err);
+    await toast(`${agent} error`, "error");
+    return { text, usage: { ...ZERO_USAGE } };
+  } finally {
+    if (childId) {
+      client.session.delete({ path: { id: childId } }).catch((err: unknown) => {
+        void logWarn(
+          `invokeAgent: failed to delete child session ${childId}`,
+          err instanceof Error ? err.message : String(err),
+        );
+      });
+    }
+  }
+}
+
+// :::: Context summarisation :::: ///////////////////////////
+
+function formatFullSummaryInput(userMessages: string[], lastAssistant: string): string {
+  let input =
+    "Summarise this conversation in 3-5 sentences. Focus on the topic, technical context, user's goal, and key decisions. Be concise.\n\n";
+  for (const msg of userMessages) {
+    input += `User: ${msg}\n`;
+  }
+  if (lastAssistant) {
+    input += `\nAssistant: ${lastAssistant}\n`;
+  }
+  input += "\nSummary:";
+  return input;
+}
+
+function formatIncrementalInput(
+  existingSummary: string,
+  userMsg: string,
+  assistantMsg: string,
+): string {
+  let input = `Given this summary:\n${existingSummary}\n\nUpdate it with this new exchange:\nUser: ${userMsg}`;
+  if (assistantMsg) {
+    input += `\nAssistant: ${assistantMsg}`;
+  }
+  input +=
+    "\n\nProvide an updated summary in 3-5 sentences. Drop stale details if no longer relevant.\n\nUpdated summary:";
+  return input;
+}
+
+function extractTextFromParts(parts: unknown[]): string {
+  if (!parts || !Array.isArray(parts)) return "";
+  const texts: string[] = [];
+  for (const p of parts) {
+    const part = p as Record<string, unknown>;
+    if (part?.type === "text" && typeof part.text === "string" && part.text.trim()) {
+      texts.push(part.text.trim());
+    }
+  }
+  return texts.join("\n");
+}
+
+export async function summariseContext(
+  deps: PipelineDeps,
+  sessionID: string,
+  currentMessageID: string,
+  config: Config,
+): Promise<{
+  summary: string;
+  lastMessageID: string;
+  messageCount: number;
+  usage: Usage;
+}> {
+  const { sessionContexts, client, logError, logWarn } = deps;
+  const existing = sessionContexts.get(sessionID);
+
+  if (!existing || existing.messageCount === 0) {
+    return {
+      summary: "",
+      lastMessageID: existing?.lastMessageID ?? "",
+      messageCount: 1,
+      usage: { ...ZERO_USAGE },
+    };
+  }
+
+  let messages: Record<string, unknown>[];
+  try {
+    const result = await client.session.messages({ path: { id: sessionID } });
+    messages = Array.isArray(result) ? result : [];
+  } catch (err) {
+    void logError("summariseContext: session.messages failed", err);
+    return {
+      summary: existing?.summary ?? "",
+      lastMessageID: existing?.lastMessageID ?? "",
+      messageCount: existing?.messageCount ?? 0,
+      usage: { ...ZERO_USAGE },
+    };
+  }
+
+  const userMessages: string[] = [];
+  let lastAssistantText = "";
+  let latestMessageID = existing?.lastMessageID ?? "";
+
+  for (const msg of messages) {
+    const info = (msg?.info ?? {}) as Record<string, unknown>;
+    if (!info?.id) continue;
+
+    if (currentMessageID && info.id === currentMessageID) continue;
+
+    if (info.agent && SUB_AGENTS.has(info.agent as string)) continue;
+
+    const text = extractTextFromParts(msg?.parts as unknown[]);
+    if (!text) continue;
+
+    if (info.role === "user") {
+      userMessages.push(text);
+    } else if (info.role === "assistant") {
+      lastAssistantText = text;
+    }
+
+    latestMessageID = info.id as string;
+  }
+
+  if (userMessages.length === 0 && !lastAssistantText) {
+    return {
+      summary: existing?.summary ?? "",
+      lastMessageID: (latestMessageID || existing?.lastMessageID) ?? "",
+      messageCount: existing?.messageCount ?? 0,
+      usage: { ...ZERO_USAGE },
+    };
+  }
+
+  const needFullRefresh =
+    !existing || existing.messageCount >= FULL_REFRESH_THRESHOLD || existing.lastMessageID === "";
+
+  let summary: string;
+  let summarisationUsage: Usage = { ...ZERO_USAGE };
+
+  if (needFullRefresh) {
+    const model = await resolveModel(config.enhancement_model, CONFIG_DEFAULTS.enhancement_model);
+    const input = formatFullSummaryInput(userMessages, lastAssistantText);
+    const fullResult = await invokeAgent(deps, "prompt-summarisation", input, model);
+    summary = fullResult.text;
+    summarisationUsage = fullResult.usage;
+  } else {
+    const model = await resolveModel(config.correction_model, CONFIG_DEFAULTS.correction_model);
+    const newUserMsg = userMessages[userMessages.length - 1] || "";
+    const input = formatIncrementalInput(existing.summary, newUserMsg, lastAssistantText);
+    const incrResult = await invokeAgent(deps, "prompt-summarisation", input, model);
+    summary = incrResult.text;
+    summarisationUsage = incrResult.usage;
+  }
+
+  if (!summary?.trim()) {
+    void logWarn("summarisation: agent returned empty, keeping existing summary");
+    summary = existing?.summary ?? "";
+  }
+
+  return {
+    summary: summary.trim(),
+    lastMessageID: latestMessageID,
+    messageCount: existing ? existing.messageCount + 1 : 2,
+    usage: summarisationUsage,
+  };
+}

package/plugins/better-prompt/catalog.ts

@@ -0,0 +1,271 @@
+import { readFileSync } from "node:fs";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import process from "node:process";
+import type {
+  Catalog,
+  CatalogCandidate,
+  CatalogModel,
+  ModelEntry,
+  ModelRef,
+  OpenCodeConfig,
+} from "./types";
+
+// :::: Constants :::: ///////////////////////////////////////
+
+export const TIER_CYCLE: readonly string[] = ["fast", "capable", "powerful"];
+
+export const TIER_ALIASES: Record<string, string> = {
+  haiku: "fast",
+  sonnet: "capable",
+  opus: "powerful",
+};
+
+export const MODEL_DEFAULTS: Record<string, string> = {
+  correction_model: "haiku",
+  translation_model: "haiku",
+  enhancement_model: "sonnet",
+};
+
+const CATALOG_CACHE_PATH = join(homedir(), ".cache", "opencode", "models-dev.json");
+
+const CATALOG_STALE_MS = 24 * 60 * 60 * 1000;
+
+let _catalog: Catalog | null = null;
+
+// :::: Catalog loading :::: /////////////////////////////////
+
+export async function loadCatalog(): Promise<Catalog> {
+  if (_catalog) return _catalog;
+
+  const isStale = (mtime: number): boolean => Date.now() - mtime > CATALOG_STALE_MS;
+
+  try {
+    const info = await stat(CATALOG_CACHE_PATH);
+    if (!isStale(info.mtimeMs)) {
+      _catalog = JSON.parse(await readFile(CATALOG_CACHE_PATH, "utf-8")) as Catalog;
+      return _catalog;
+    }
+  } catch {
+    /* cache read failed, proceed to fetch */
+  }
+
+  try {
+    const res = await fetch("https://models.dev/api.json");
+    const data: Catalog = await res.json();
+    _catalog = data;
+    await mkdir(dirname(CATALOG_CACHE_PATH), { recursive: true });
+    await writeFile(CATALOG_CACHE_PATH, JSON.stringify(data));
+    return data;
+  } catch {
+    try {
+      _catalog = JSON.parse(await readFile(CATALOG_CACHE_PATH, "utf-8")) as Catalog;
+      return _catalog;
+    } catch {
+      return {};
+    }
+  }
+}
+
+// :::: OpenCode config merge :::: //////////////////////////
+
+function deepMerge<T extends Record<string, unknown>>(a: T, b: Partial<T>): T {
+  const result = { ...a };
+  for (const key of Object.keys(b) as (keyof T)[]) {
+    const bVal = b[key];
+    const aVal = a[key];
+    if (
+      bVal &&
+      typeof bVal === "object" &&
+      !Array.isArray(bVal) &&
+      aVal &&
+      typeof aVal === "object" &&
+      !Array.isArray(aVal)
+    ) {
+      (result as Record<string, unknown>)[key as string] = deepMerge(
+        aVal as Record<string, unknown>,
+        bVal as Record<string, unknown>,
+      );
+    } else {
+      (result as Record<string, unknown>)[key as string] = bVal;
+    }
+  }
+  return result;
+}
+
+export function loadMergedConfig(): OpenCodeConfig {
+  const load = (p: string): OpenCodeConfig => {
+    try {
+      return JSON.parse(readFileSync(p, "utf-8"));
+    } catch {
+      return {};
+    }
+  };
+  const globalCfg = load(join(homedir(), ".config", "opencode", "opencode.json"));
+  const projCfg = load("opencode.json");
+  return deepMerge(globalCfg, projCfg);
+}
+
+export async function getConnectedProviders(): Promise<Set<string>> {
+  const catalog = await loadCatalog();
+  const connected = new Set<string>();
+
+  try {
+    const authPath = join(homedir(), ".local", "share", "opencode", "auth.json");
+    const raw = readFileSync(authPath, "utf-8");
+    const auth = JSON.parse(raw);
+    for (const key of Object.keys(auth)) connected.add(key);
+  } catch {
+    /* auth file read failed */
+  }
+
+  for (const [pid, pdata] of Object.entries(catalog)) {
+    for (const envVar of pdata.env ?? []) {
+      if (process.env[envVar]) connected.add(pid);
+    }
+  }
+
+  const cfg = loadMergedConfig();
+  for (const p of Object.keys(cfg.provider ?? {})) connected.add(p);
+
+  for (const d of cfg.disabled_providers ?? []) connected.delete(d);
+
+  if (cfg.enabled_providers) {
+    const wl = new Set(cfg.enabled_providers);
+    for (const p of connected) {
+      if (!wl.has(p)) connected.delete(p);
+    }
+  }
+
+  return connected;
+}
+
+// :::: Tier resolution :::: ////////////////////////////////
+
+export async function getModelTiers(): Promise<{
+  fast: ModelEntry[];
+  capable: ModelEntry[];
+  powerful: ModelEntry[];
+}> {
+  const connected = await getConnectedProviders();
+  const catalog = await loadCatalog();
+  const cfg = loadMergedConfig();
+
+  const allCandidates: CatalogCandidate[] = [];
+  const entryMap = new Map<string, CatalogModel>();
+
+  for (const pid of connected) {
+    const catModels = catalog[pid]?.models ?? {};
+    const customModels =
+      (cfg.provider as Record<string, Record<string, unknown>>)?.[pid]?.models ?? {};
+    const merged = { ...catModels, ...customModels };
+
+    for (const [mid, m] of Object.entries(merged)) {
+      const model = m as CatalogModel;
+      const id = `${pid}/${mid}`;
+      allCandidates.push({
+        id,
+        context: model?.limit?.context ?? 0,
+        cost: (model?.cost?.input ?? 0) + (model?.cost?.output ?? 0),
+        toolCall: model?.tool_call ?? false,
+      });
+      entryMap.set(id, model);
+    }
+  }
+
+  const withTools = allCandidates.filter((m) => m.toolCall);
+  const pool = withTools.length > 0 ? withTools : allCandidates;
+  const byCost = [...pool].sort((a, b) => a.cost - b.cost);
+
+  const third = Math.max(1, Math.ceil(byCost.length / 3));
+  const fastEntries: ModelEntry[] = [];
+  const capableEntries: ModelEntry[] = [];
+  const powerfulEntries: ModelEntry[] = [];
+
+  for (let i = 0; i < byCost.length; i++) {
+    const c = byCost[i];
+    const model = entryMap.get(c.id);
+    const entry: ModelEntry = {
+      id: c.id,
+      providerID: c.id.split("/")[0],
+      modelID: c.id.split("/")[1],
+      tier: i < third ? "fast" : i < third * 2 ? "capable" : "powerful",
+      context: model?.limit?.context ?? 0,
+      cost: (model?.cost?.input ?? 0) + (model?.cost?.output ?? 0),
+      toolCall: model?.tool_call ?? false,
+    };
+
+    if (entry.tier === "fast") fastEntries.push(entry);
+    else if (entry.tier === "capable") capableEntries.push(entry);
+    else powerfulEntries.push(entry);
+  }
+
+  return {
+    fast: fastEntries,
+    capable: capableEntries,
+    powerful: powerfulEntries,
+  };
+}
+
+export async function resolveShortName(shortName: string): Promise<ModelRef | undefined> {
+  const tierName =
+    TIER_ALIASES[shortName] ?? (TIER_CYCLE.includes(shortName) ? shortName : undefined);
+  if (!tierName) return undefined;
+
+  const tiers = await getModelTiers();
+  const entries = tiers[tierName as "fast" | "capable" | "powerful"];
+  if (!entries || entries.length === 0) return undefined;
+
+  const entry = entries[0];
+  return { providerID: entry.providerID, modelID: entry.modelID };
+}
+
+export function resolveModel(
+  shortName: string,
+  defaultName: string,
+): Promise<ModelRef | undefined> {
+  if (shortName === defaultName) return Promise.resolve(undefined);
+
+  const slashIdx = shortName.indexOf("/");
+  if (slashIdx > 0) {
+    return Promise.resolve({
+      providerID: shortName.slice(0, slashIdx),
+      modelID: shortName.slice(slashIdx + 1),
+    });
+  }
+
+  return resolveShortName(shortName);
+}
+
+export function resolveTier(
+  value: string,
+  tiers: { fast: ModelEntry[]; capable: ModelEntry[]; powerful: ModelEntry[] } | null,
+): "fast" | "capable" | "powerful" | null {
+  if (TIER_ALIASES[value]) {
+    return TIER_ALIASES[value] as "fast" | "capable" | "powerful";
+  }
+  if (TIER_CYCLE.includes(value)) {
+    return value as "fast" | "capable" | "powerful";
+  }
+
+  if (tiers) {
+    for (const tier of TIER_CYCLE as ("fast" | "capable" | "powerful")[]) {
+      if (tiers[tier].some((e) => e.id === value)) return tier;
+    }
+  }
+
+  return null;
+}
+
+export function findModelEntry(
+  value: string,
+  tiers: { fast: ModelEntry[]; capable: ModelEntry[]; powerful: ModelEntry[] } | null,
+): ModelEntry | null {
+  if (!tiers) return null;
+  for (const tier of TIER_CYCLE as ("fast" | "capable" | "powerful")[]) {
+    const found = tiers[tier].find((e) => e.id === value);
+    if (found) return found;
+  }
+  return null;
+}

package/plugins/better-prompt/config.ts

@@ -0,0 +1,104 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+
+export const CONFIG_PATH = join(homedir(), ".config", "opencode", "better-prompt.local.md");
+
+export const ConfigSchema = z.object({
+  enabled: z.boolean(),
+  correction: z.boolean(),
+  correction_model: z.string(),
+  translation: z.boolean(),
+  translation_model: z.string(),
+  enhancement: z.boolean(),
+  enhancement_model: z.string(),
+  audit: z.boolean(),
+  verbose: z.boolean(),
+});
+
+export type Config = z.infer<typeof ConfigSchema>;
+
+export const CONFIG_DEFAULTS: Config = {
+  enabled: true,
+  correction: true,
+  correction_model: "haiku",
+  translation: false,
+  translation_model: "haiku",
+  enhancement: false,
+  enhancement_model: "sonnet",
+  audit: true,
+  verbose: false,
+};
+
+export const MODEL_FIELDS: ReadonlyArray<keyof Config> = [
+  "correction_model",
+  "translation_model",
+  "enhancement_model",
+] as const;
+
+export function parseConfig(configPath: string): Config {
+  if (!existsSync(configPath)) return { ...CONFIG_DEFAULTS };
+
+  const raw = readFileSync(configPath, "utf8");
+  const fmMatch = raw.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) return { ...CONFIG_DEFAULTS };
+
+  const fm = fmMatch[1];
+  const get = (key: string): string | undefined => {
+    const m = fm.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+    return m ? m[1].trim() : undefined;
+  };
+
+  const bool = (key: string, fallback: boolean): boolean => {
+    const v = get(key);
+    return v !== undefined ? v === "true" : fallback;
+  };
+
+  const str = (key: string, fallback: string): string => {
+    const v = get(key);
+    return v !== undefined ? v : fallback;
+  };
+
+  const built = {
+    enabled: bool("enabled", CONFIG_DEFAULTS.enabled),
+    correction: bool("correction", CONFIG_DEFAULTS.correction),
+    correction_model: str("correction_model", CONFIG_DEFAULTS.correction_model),
+    translation: bool("translation", CONFIG_DEFAULTS.translation),
+    translation_model: str("translation_model", CONFIG_DEFAULTS.translation_model),
+    enhancement: bool("enhancement", CONFIG_DEFAULTS.enhancement),
+    enhancement_model: str("enhancement_model", CONFIG_DEFAULTS.enhancement_model),
+    audit: bool("audit", CONFIG_DEFAULTS.audit),
+    verbose: bool("verbose", CONFIG_DEFAULTS.verbose),
+  };
+
+  return ConfigSchema.parse(built);
+}
+
+export function updateConfig(configPath: string, updates: Partial<Config>): void {
+  let raw = "";
+  if (existsSync(configPath)) {
+    raw = readFileSync(configPath, "utf8");
+  }
+
+  let fm = "";
+  let body = "";
+  const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (fmMatch) {
+    fm = fmMatch[1];
+    body = fmMatch[2];
+  }
+
+  for (const [key, value] of Object.entries(updates)) {
+    if (value === undefined) continue;
+    const line = `${key}: ${value}`;
+    const regex = new RegExp(`^${key}: .+$`, "m");
+    if (regex.test(fm)) {
+      fm = fm.replace(regex, line);
+    } else {
+      fm += `\n${line}`;
+    }
+  }
+
+  writeFileSync(configPath, `---\n${fm}\n---\n${body}`);
+}

package/plugins/better-prompt/format.ts

@@ -0,0 +1,26 @@
+export function formatCost(cost: number): string {
+  if (cost === 0) return "$0/M";
+  if (cost < 0.01) return `$${cost.toFixed(4)}/M`;
+  if (cost < 1) return `$${cost.toFixed(2)}/M`;
+  return `$${cost.toFixed(2)}/M`;
+}
+
+export function formatContext(ctx: number): string {
+  if (ctx >= 1_000_000) {
+    return `${(ctx / 1_000_000).toFixed(ctx % 1_000_000 === 0 ? 0 : 1)}M`;
+  }
+  if (ctx >= 1_000) return `${Math.round(ctx / 1_000)}K`;
+  return String(ctx);
+}
+
+export function formatTokens(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`;
+  return String(n);
+}
+
+export function formatDuration(ms: number | null): string {
+  if (ms === null) return "";
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}