@jmtrin/opencode-kevin-tui 1.3.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./tui.js";
+export * from "./tui-types.js";
+export { tui as default } from "./tui.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+// @jmtrin/opencode-kevin-tui — target-exclusive TUI package (K13-004)
+// Re-exports the TUI module and its view types; the host imports this package directly.
+// The main plugin's exports["./tui"] redirects to this package (bare specifier) so
+// external consumers see no change via `import "@jmtrin/opencode-kevin/tui"`.
+export * from "./tui.js";
+export * from "./tui-types.js";
+export { tui as default } from "./tui.js";

package/dist/tui-types.d.ts

@@ -0,0 +1,59 @@
+export interface ProposalView {
+    readonly id: string;
+    readonly kind: string;
+    readonly target_path: string;
+    readonly diff: string;
+    readonly memory_ids: readonly string[];
+    readonly created_at: string;
+    readonly truncated?: boolean;
+    readonly token?: string;
+}
+export interface ConflictView {
+    readonly id: string;
+    readonly kind: string;
+    readonly a_summary: string;
+    readonly b_summary: string;
+    readonly opened_at: string;
+}
+export interface HealthView {
+    readonly verdict: string;
+    readonly reason: string;
+    readonly hooks: readonly {
+        readonly hook: string;
+        readonly state: string;
+        readonly fire_count: number;
+        readonly expected_count: number;
+    }[];
+    readonly perf: readonly {
+        readonly scope: string;
+        readonly p95: number;
+        readonly budget_p95: number;
+        readonly within_budget: boolean;
+    }[];
+    readonly contract_digest: string;
+    readonly counters: Record<string, number>;
+}
+export interface TuiSnapshotSet {
+    readonly generatedAt: string;
+    readonly proposals: readonly ProposalView[];
+    readonly conflicts: readonly ConflictView[];
+    readonly health: HealthView;
+}
+export type TuiAction = {
+    readonly type: "approve";
+    readonly proposalId: string;
+    readonly token: string;
+} | {
+    readonly type: "reject";
+    readonly proposalId: string;
+    readonly token: string;
+    readonly note?: string;
+} | {
+    readonly type: "acknowledge";
+    readonly conflictId: string;
+};
+export interface ActionResult {
+    readonly action: TuiAction;
+    readonly status: "applied" | "rejected" | "stale_skipped" | "error";
+    readonly detail?: string;
+}

package/dist/tui-types.js

@@ -0,0 +1,4 @@
+// v1.2.0 (K12-002 / plan §4.2-§4.3) — shared view types (type-only module).
+// This file MUST contain only type/interface exports — zero runtime values.
+// The TUI module may import it ONLY as `import type`.
+export {};

package/dist/tui.d.ts

@@ -0,0 +1,18 @@
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+import type { ConflictView, HealthView, ProposalView } from "./tui-types.js";
+export declare function tuiRoot(): string;
+export declare function readJsonSafe(name: string): {
+    data: unknown;
+} | {
+    error: "missing" | "corrupt";
+};
+export declare function truncateSummary(text: string, max?: number): string;
+export declare function formatProposalRow(p: ProposalView): string;
+export declare function formatConflictRow(c: ConflictView): string;
+export declare function formatHealthVerdict(h: HealthView): string;
+export declare const tui: TuiPlugin;
+declare const _default: {
+    id: string;
+    tui: TuiPlugin;
+};
+export default _default;

package/dist/tui.js

@@ -0,0 +1,198 @@
+// v1.2.0 (K12-008 skeleton + K12-009 panels / plan §4.4 R1, D12-02) — TUI module (target-exclusive, conditional on K12-016 GO).
+// Allowed imports ONLY: @opencode-ai/plugin/tui, node:fs, node:path, node:os, import type from ./tui-types.js
+// No console.log; user feedback via host toast API.
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function tuiRoot() {
+    return join(homedir(), ".opencode-kevin", "tui");
+}
+export function readJsonSafe(name) {
+    const path = join(tuiRoot(), name);
+    try {
+        const raw = readFileSync(path, "utf8");
+        try {
+            return { data: JSON.parse(raw) };
+        }
+        catch {
+            return { error: "corrupt" };
+        }
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT")
+            return { error: "missing" };
+        return { error: "corrupt" };
+    }
+}
+// --- Pure helpers (K12-009) — unit-testable, no host dependency ---
+export function truncateSummary(text, max = 80) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max - 1)}…`;
+}
+export function formatProposalRow(p) {
+    const trunc = p.truncated ? " [truncated]" : "";
+    const ids = p.memory_ids.length ? ` memories:${p.memory_ids.join(",")}` : "";
+    return `${p.id} ${p.kind} ${p.target_path} ${p.created_at}${trunc}${ids}`;
+}
+export function formatConflictRow(c) {
+    return `${c.kind} ${c.id} A:${truncateSummary(c.a_summary)} B:${truncateSummary(c.b_summary)}`;
+}
+export function formatHealthVerdict(h) {
+    return `${h.verdict} — ${h.reason} — ${h.contract_digest}`;
+}
+// Mailbox writer — atomic tmp+rename, append semantics (pure fs, no network)
+function writeMailboxAction(action) {
+    const dir = tuiRoot();
+    mkdirSync(dir, { recursive: true });
+    const target = join(dir, "actions.json");
+    let existing = null;
+    try {
+        const raw = readFileSync(target, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed && Array.isArray(parsed.actions)) {
+            existing = {
+                issuedAt: String(parsed.issuedAt ?? new Date().toISOString()),
+                actions: parsed.actions,
+            };
+        }
+    }
+    catch {
+        // missing/corrupt → start fresh
+    }
+    const next = {
+        issuedAt: new Date().toISOString(),
+        actions: existing ? [...existing.actions, action] : [action],
+    };
+    const tmp = `${target}.tmp`;
+    writeFileSync(tmp, JSON.stringify(next, null, 2), "utf8");
+    renameSync(tmp, target);
+}
+function emptyState(reason) {
+    return reason;
+}
+export const tui = async (api) => {
+    // Helper to show toast via host
+    const toast = (message, variant = "info") => {
+        try {
+            api.ui.toast({ message, variant });
+        }
+        catch {
+            // best-effort
+        }
+    };
+    api.route.register([
+        {
+            name: "kevin",
+            render: () => {
+                // Re-read on focus (caller invokes render on focus)
+                const proposalsRes = readJsonSafe("proposals.json");
+                const conflictsRes = readJsonSafe("conflicts.json");
+                const healthRes = readJsonSafe("health.json");
+                if ("error" in proposalsRes ||
+                    "error" in conflictsRes ||
+                    "error" in healthRes) {
+                    const reason = "error" in proposalsRes
+                        ? `proposals.json: ${proposalsRes.error}`
+                        : "error" in conflictsRes
+                            ? `conflicts.json: ${conflictsRes.error}`
+                            : `health.json: ${healthRes.error}`;
+                    return emptyState(`no snapshots yet — open an opencode session with the plugin enabled (${reason})`);
+                }
+                const proposals = proposalsRes.data;
+                const conflicts = conflictsRes.data;
+                const health = healthRes.data;
+                // Skeleton counts + tabular summaries (full JSX rendering is host-driven;
+                // this string representation carries the same data for headless verification).
+                // Interactive flows (Enter→diff, a→approve, r→reject, x→acknowledge) are exposed as keymap commands below
+                // and via api.ui.Dialog* when a host renders the route with Solid JSX — the string fallback ensures degrade-to-empty discipline.
+                const proposalLines = Array.isArray(proposals) && proposals.length
+                    ? proposals
+                        .map((p) => `· ${formatProposalRow(p)}\n  diff: ${truncateSummary(p.diff, 120)}${p.truncated ? " [truncated]" : ""}`)
+                        .join("\n")
+                    : "  (no pending proposals)";
+                const conflictLines = Array.isArray(conflicts) && conflicts.length
+                    ? conflicts.map((c) => `· ${formatConflictRow(c)}`).join("\n")
+                    : "  (no open conflicts)";
+                const healthLine = health ? formatHealthVerdict(health) : "unknown";
+                const hooksLine = health?.hooks?.length
+                    ? health.hooks
+                        .map((h) => `  ${h.hook} ${h.state} ${h.fire_count}/${h.expected_count}`)
+                        .join("\n")
+                    : "  (no hooks)";
+                const perfLine = health?.perf?.length
+                    ? health.perf
+                        .map((p) => `  ${p.scope} p95:${p.p95} budget:${p.budget_p95} ${p.within_budget ? "ok" : "OVER"}`)
+                        .join("\n")
+                    : "  (no perf)";
+                const countersLine = health?.counters
+                    ? Object.entries(health.counters)
+                        .map(([k, v]) => `${k}=${v}`)
+                        .join(" ")
+                    : "(no counters)";
+                const msg = [
+                    `Kevin — Proposals (${Array.isArray(proposals) ? proposals.length : 0})`,
+                    proposalLines,
+                    "",
+                    `Conflicts (${Array.isArray(conflicts) ? conflicts.length : 0})`,
+                    conflictLines,
+                    "",
+                    `Health — ${healthLine}`,
+                    "hooks:",
+                    hooksLine,
+                    "perf:",
+                    perfLine,
+                    `counters: ${countersLine}`,
+                    "",
+                    "Keys: Enter=diff · a=approve · r=reject · x=acknowledge (via command palette) · k=open",
+                ].join("\n");
+                return emptyState(msg);
+            },
+        },
+    ]);
+    // Keymap layer: `k` opens the kevin route; also expose approve/reject/acknowledge commands for palette.
+    try {
+        const km = api.keymap;
+        km.registerLayer?.({
+            commands: {
+                "kevin.open": {
+                    title: "Kevin — open",
+                    description: "Open the Kevin route",
+                },
+                "kevin.proposal.approve": { title: "Kevin — approve proposal" },
+                "kevin.proposal.reject": { title: "Kevin — reject proposal" },
+                "kevin.conflict.acknowledge": { title: "Kevin — acknowledge conflict" },
+            },
+            bindings: {
+                "kevin.open": "k",
+            },
+        });
+    }
+    catch {
+        // best-effort
+    }
+    // Expose mailbox writers via command handlers (invoked from palette or future JSX buttons).
+    // These are also callable from tests via exported helpers — the route render's interactive dialogs
+    // would call the same writeMailboxAction in a real host with DialogConfirm/Select.
+    void writeMailboxAction;
+    // Attach helper closures to api for potential solid JSX callbacks (not part of typed API — cast).
+    const extended = api;
+    extended.kevinTui = {
+        approve: (proposalId, token) => {
+            writeMailboxAction({ type: "approve", proposalId, token });
+            toast("queued — applies at session idle", "info");
+        },
+        reject: (proposalId, token, note) => {
+            writeMailboxAction(note !== undefined
+                ? { type: "reject", proposalId, token, note }
+                : { type: "reject", proposalId, token });
+            toast("queued — applies at session idle", "info");
+        },
+        acknowledge: (conflictId) => {
+            writeMailboxAction({ type: "acknowledge", conflictId });
+            toast("queued — applies at session idle", "info");
+        },
+    };
+};
+export default { id: "opencode-kevin", tui };

package/package.json

@@ -0,0 +1,29 @@
+{
+	"name": "@jmtrin/opencode-kevin-tui",
+	"version": "1.3.0",
+	"description": "Kevin TUI — target-exclusive panel (Bedrock)",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": ["dist"],
+	"scripts": {
+		"build": "tsc -p tsconfig.json",
+		"typecheck": "tsc --noEmit"
+	},
+	"dependencies": {
+		"@opencode-ai/plugin": "^1.18.16"
+	},
+	"engines": {
+		"node": ">=22.5.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"license": "MIT"
+}