@leon135/opencode-learn 0.0.0-stage → 0.1.0

package/plugins/md-link/tui.ts

@@ -0,0 +1,360 @@
+/**
+ * md-link TUI plugin — silent toggle for the Obsidian live mirror.
+ *
+ * V2 loader contract: default export is { id, setup } via Plugin.define.
+ * setup may call ctx.keymap.layer() directly (the layer is removed when the
+ * plugin deactivates) and returns a cleanup that runs on deactivate/exit.
+ * Dialog API: await ctx.ui.dialog.prompt({...}) → string | undefined.
+ *
+ * Commands (all purely client-side — nothing is ever sent to the LLM):
+ *   ctrl+alt:m / /md-link [dir]   toggle mirroring for the focused session;
+ *                                 ON backfills up to 10 recent messages
+ *                                 (replies + your prompts)
+ *   /md-link-dir                  set the default output directory
+ *   /md-link-keep                 keep only the N newest replies (empty = all);
+ *                                 existing mirrors are trimmed immediately
+ *   /md-link-persist [on|off]     persistent mirrors: while ON, TUI exit keeps
+ *                                 this project's mirror files + session entries
+ *                                 and mirroring auto-resumes next launch;
+ *                                 explicit /md-link OFF still deletes at once
+ *
+ * On TUI exit, mirror files belonging to this project are deleted unless
+ * persistence (/md-link-persist) is ON. See core.ts for state/file contracts.
+ */
+
+import { accessSync, constants as fsConstants, existsSync, readFileSync, rmSync, statSync } from "fs"
+import { isAbsolute, join, normalize } from "path"
+import { homedir } from "os"
+import type { OpenCodeClient } from "@opencode/client"
+import type { Plugin } from "@opencode/plugin/tui"
+import {
+  appendMessage,
+  disableSession,
+  hasBlock,
+  isEnabled,
+  loadState,
+  messageText,
+  mirrorFile,
+  pruneMirror,
+  saveState,
+  touchMirror,
+  userPromptBlock,
+} from "./core.ts"
+
+type DirResult = { ok: true; abs: string } | { ok: false; error: string }
+type ToastVariant = "info" | "success" | "warning" | "error"
+
+/** Cap on how many historical messages a single enable may backfill (V1 parity). */
+const MAX_CATCHUP = 10
+
+/** Validate a user-supplied output dir. Must already exist and be writable. */
+function validateDir(raw: string, pwd: string): DirResult {
+  let d = String(raw ?? "").trim().replace(/^["']+|["']+$/g, "")
+  if (d.startsWith("~")) d = join(homedir(), d.slice(1))
+  if (d.length === 0) d = "."
+  if (d.includes("\0")) return { ok: false, error: "invalid path" }
+  if (d.split("/").includes("..")) return { ok: false, error: "path may not contain '..'" }
+  if (!/^[A-Za-z0-9 ._\-\/]+$/.test(d)) return { ok: false, error: `unsupported characters in "${d}"` }
+
+  const abs = isAbsolute(d) ? normalize(d) : normalize(join(pwd, d))
+  try {
+    if (!existsSync(abs)) return { ok: false, error: `directory does not exist: ${abs}` }
+    if (!statSync(abs).isDirectory()) return { ok: false, error: `not a directory: ${abs}` }
+    accessSync(abs, fsConstants.W_OK)
+  } catch (e: any) {
+    return { ok: false, error: `cannot use ${abs}: ${e?.code ?? e?.message ?? e}` }
+  }
+  return { ok: true, abs }
+}
+
+/** Pull a free-form argument out of whatever the slash/keybind run() hands us. */
+function extractArg(input: unknown): string {
+  if (typeof input === "string") return input
+  if (Array.isArray(input)) return input.map((x) => extractArg(x)).join(" ")
+  const r = input as any
+  if (r && typeof r === "object") {
+    for (const k of ["value", "arg", "args", "input", "arguments", "text", "message", "prompt"]) {
+      const v = r[k]
+      if (typeof v === "string") return v
+      if (Array.isArray(v)) return v.map((x) => extractArg(x)).join(" ")
+    }
+  }
+  return ""
+}
+
+/**
+ * Backfill recent history when mirroring is enabled for a session: up to
+ * MAX_CATCHUP newest messages, BOTH assistant replies and user prompts,
+ * appended oldest-first so the mirror stays chronological (V1 catch-up parity).
+ *
+ * The page is newest-first via the plugin client
+ * (ctx.client.message.list = GET /api/session/:id/message). Walking stops at
+ * the first already-mirrored marker, so a live event that won the race never
+ * produces a duplicate block.
+ *
+ * Replies still streaming when the toggle fires are skipped: their
+ * time.created is too recent, and live ordinals will finish them anyway.
+ */
+async function backfillLatestTurn(
+  client: OpenCodeClient,
+  sessionID: string,
+  file: string,
+  keep: number | null,
+  enabledAt: number,
+): Promise<number> {
+  let written = 0
+  try {
+    const { data: items } = await client.message.list({
+      sessionID,
+      order: "desc",
+      limit: 50,
+    })
+    const pending: { id: string; text: string }[] = []
+    for (const m of items) {
+      if (m.type !== "assistant" && m.type !== "user") continue
+      const created = Number(m.time?.created ?? 0)
+      if (m.type === "assistant" && created && enabledAt - created < 15_000) continue // likely still streaming
+      const text = messageText(m)
+      if (!text) continue
+      if (hasBlock(file, m.id)) break // already mirrored — everything older is too
+      pending.push({
+        id: `${m.id}#backfill`,
+        text: m.type === "user" ? userPromptBlock(text) : text,
+      })
+      if (pending.length >= MAX_CATCHUP) break
+    }
+    for (let i = pending.length - 1; i >= 0; i--) {
+      const res = appendMessage(file, { text: pending[i].text, markerKey: pending[i].id, replace: true }, keep)
+      if (res === "written") written++
+    }
+  } catch {}
+  return written
+}
+
+export async function setupMdLinkTui(ctx: Plugin.Context): Promise<Plugin.Cleanup> {
+  const pwd = (): string => ctx.data.location.default().directory || process.cwd()
+
+  const toast = (message: string, variant: ToastVariant = "info") => {
+    try {
+      ctx.ui.toast.show({ title: "md-link", message, variant })
+    } catch {}
+  }
+
+  const short = (s: string) => (s.length > 28 ? s.slice(0, 28) + "…" : s)
+
+  // ——— toggle ———
+
+  /** Collapse duplicate activations: stacked layers from hot-reloads fire
+   * run() twice per keypress (ON then instantly OFF). */
+  let lastRun = 0
+  async function run(input?: unknown): Promise<void> {
+    const now = Date.now()
+    if (now - lastRun < 500) return
+    lastRun = now
+
+    try {
+      const cur = ctx.ui.router.current()
+      const sessionID = cur.type === "session" ? cur.sessionID : undefined
+      if (!sessionID || typeof sessionID !== "string") {
+        toast("No active session found", "warning")
+        return
+      }
+
+      const st = loadState()
+      const arg = extractArg(input).trim()
+      const res = validateDir(arg || st.defaultDir || pwd(), pwd())
+      if (!res.ok) {
+        toast(`Invalid dir "${arg || st.defaultDir}": ${res.error}`, "error")
+        return
+      }
+      if (arg) st.defaultDir = res.abs // remember explicitly requested dirs
+
+      const file = join(res.abs, `${sessionID}_link.md`)
+      if (isEnabled(st, sessionID)) {
+        const oldDir = st.sessions[sessionID]
+        disableSession(st, sessionID)
+        for (const dir of new Set([oldDir, res.abs])) {
+          try { rmSync(join(dir ?? "", `${sessionID}_link.md`), { force: true }) } catch {}
+        }
+        toast(`Live mirror OFF (${short(sessionID)})`, "warning")
+        return
+      }
+
+      st.sessions[sessionID] = res.abs
+      saveState(st)
+      touchMirror(file)
+      const backfilled = await backfillLatestTurn(ctx.client, sessionID, file, st.keep, Date.now())
+      const tag = st.persist ? " (persistent)" : ""
+      toast(
+        backfilled > 0
+          ? `Live mirror ON, backfilled ${backfilled} message${backfilled === 1 ? "" : "s"} → ${short(file)}${tag}`
+          : `Live mirror ON → ${file}${tag}`,
+      )
+    } catch (e: any) {
+      toast(`Failed: ${e?.message ?? e}`, "error")
+    }
+  }
+
+  // ——— dialogs ———
+
+  async function openSetDirDialog(): Promise<void> {
+    try {
+      const v = await ctx.ui.dialog.prompt({
+        title: "md-link output directory",
+        placeholder: `relative to project (${pwd()}) or absolute path`,
+        value: loadState().defaultDir ?? "",
+      })
+      if (typeof v !== "string") return // cancelled
+      const res = validateDir(v, pwd())
+      if (!res.ok) {
+        toast(`Invalid dir: ${res.error}`, "error")
+        return
+      }
+      const st = loadState()
+      st.defaultDir = res.abs
+      saveState(st)
+      toast(`Default output dir set → ${res.abs}`)
+    } catch (e: any) {
+      toast(`Cannot open dialog: ${e?.message ?? e}`, "error")
+    }
+  }
+
+  async function openKeepDialog(): Promise<void> {
+    try {
+      const cur = loadState().keep
+      const v = await ctx.ui.dialog.prompt({
+        title: "md-link: show last N messages",
+        placeholder: "number of recent messages to keep (empty = unlimited)",
+        value: cur != null ? String(cur) : "",
+      })
+      if (typeof v !== "string") return // cancelled
+      const t = v.trim()
+      let keep: number | null = null
+      if (t.length > 0) {
+        const n = Number(t)
+        if (!Number.isInteger(n) || n < 1 || n > 500) {
+          toast(`Invalid count "${t}" — use 1..500 or empty`, "error")
+          return
+        }
+        keep = n
+      }
+      const st = loadState()
+      st.keep = keep
+      saveState(st)
+      if (keep == null) {
+        toast("Mirror keeps all messages")
+        return
+      }
+      // Apply immediately: trim every enabled session's live mirror now.
+      let trimmed = 0
+      for (const sid of Object.keys(st.sessions)) {
+        const f = mirrorFile(st, sid, pwd())
+        if (!f || !existsSync(f)) continue
+        const before = readFileSync(f, "utf-8")
+        pruneMirror(f, keep)
+        if (readFileSync(f, "utf-8") !== before) trimmed++
+      }
+      toast(`Mirror shows only the last ${keep}${trimmed ? ` (${trimmed} mirror${trimmed === 1 ? "" : "s"} trimmed)` : ""}`)
+    } catch (e: any) {
+      toast(`Cannot open dialog: ${e?.message ?? e}`, "error")
+    }
+  }
+
+  // ——— persistence toggle ———
+
+  /** Flip (or force via on|off arg) persistent-mirror mode: kept mirrors
+   * survive TUI exit and their sessions auto-resume on next launch. */
+  async function togglePersistence(input?: unknown): Promise<void> {
+    try {
+      const st = loadState()
+      const arg = extractArg(input).trim().toLowerCase()
+      if (arg === "on" || arg === "true" || arg === "1") st.persist = true
+      else if (arg === "off" || arg === "false" || arg === "0") st.persist = false
+      else st.persist = !st.persist
+      saveState(st)
+      toast(
+        st.persist
+          ? "Persistent mirrors ON — survive TUI exit, resume next launch"
+          : "Persistent mirrors OFF — mirrors deleted on TUI exit",
+        st.persist ? "info" : "warning",
+      )
+    } catch (e: any) {
+      toast(`Failed: ${e?.message ?? e}`, "error")
+    }
+  }
+
+  // ——— startup notice for persistent mirrors ———
+
+  try {
+    const root = pwd()
+    const resumed = Object.values(loadState().sessions).filter((d) => root && d.startsWith(root)).length
+    if (resumed > 0) toast(`md-link: resumed ${resumed} persistent mirror${resumed === 1 ? "" : "s"}`)
+  } catch {}
+
+  // ——— cleanup on TUI close (skipped while persistence is ON) ———
+
+  let cleaned = false
+  function cleanupOnExit(): void {
+    if (cleaned) return
+    cleaned = true
+    try {
+      const root = pwd()
+      const st = loadState()
+      if (st.persist) return // persistent mode: keep files + entries, resume next launch
+      for (const [sid, dir] of Object.entries(st.sessions)) {
+        // only remove mirrors owned by THIS project — other TUIs keep theirs
+        if (root && !dir.startsWith(root)) continue
+        try { rmSync(join(dir || ".", `${sid}_link.md`), { force: true }) } catch {}
+        delete st.sessions[sid]
+      }
+      saveState(st)
+    } catch {}
+  }
+  // belt-and-braces: host cleanup covers normal exit; this covers hard exits
+  try { process.once("exit", cleanupOnExit) } catch {}
+
+  // ——— registration (callable directly from setup; removed on deactivate) ———
+
+  ctx.keymap.layer(() => ({
+    mode: "global",
+    priority: 1,
+    enabled: true,
+    commands: [
+      {
+        id: "md-link.toggle",
+        title: "Live mirror",
+        group: "md-link",
+        bind: "ctrl+alt+m",
+        palette: true,
+        slash: { name: "md-link" },
+        run,
+      },
+      {
+        id: "md-link.setdir",
+        title: "Output directory…",
+        group: "md-link",
+        palette: true,
+        slash: { name: "md-link-dir" },
+        run: () => openSetDirDialog(),
+      },
+      {
+        id: "md-link.keep",
+        title: "Keep last N",
+        group: "md-link",
+        palette: true,
+        slash: { name: "md-link-keep" },
+        run: () => openKeepDialog(),
+      },
+      {
+        id: "md-link.persist",
+        title: "Persistence",
+        group: "md-link",
+        palette: true,
+        slash: { name: "md-link-persist" },
+        run: (input?: unknown) => togglePersistence(input),
+      },
+    ],
+  }))
+
+  return cleanupOnExit
+}