opencode-codeops 2.2.0 → 2.2.1

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to CodeOps are recorded here.
 
+## 2.2.1 — 2026-10-10
+
+### Fixes
+
+- scripts: pin the changelog feature guard to the document, not one release
+- tui: precompile the packaged TUI entry for npm installs
+
 ## 2.2.0 — 2026-10-10
 
 ### Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-codeops",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Specification-first engineering for complex systems — CodeOps plugin for OpenCode",
   "type": "module",
   "engines": {
@@ -11,13 +11,14 @@
   "exports": {
     ".": "./plugin/index.ts",
     "./server": "./plugin/index.ts",
-    "./tui": "./plugin/tui.tsx"
+    "./tui": "./plugin/tui.js"
   },
   "bin": {
     "opencode-codeops": "bin/index.mjs"
   },
   "scripts": {
     "test": "node --test",
+    "build:tui": "node scripts/build-tui.mjs",
     "typecheck": "tsc --noEmit",
     "check:version": "node scripts/check-version.mjs",
     "verify": "npm run typecheck && npm run test && npm run check:version",

package/plugin/tui.js

@@ -0,0 +1,113 @@
+// Generated from plugin/tui.tsx — do not edit; run `npm run build:tui` to regenerate.
+import { insert as _$insert } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+/**
+ * The CodeOps TUI entry: the live run-progress view in the session sidebar.
+ *
+ * The view is deliberately honest: it shows only reported values from the
+ * server's run state, always with an as-of time, and it renders nothing when
+ * there is no run, when the host lacks the events API, or when every call
+ * fails. There are no timers — the text recomputes whenever the component
+ * re-renders — and no file access; all display and merge logic lives in the
+ * shared helper module so it can be tested under plain Node.
+ *
+ * @module tui
+ */
+
+import { Plugin, usePlugin } from "@opencode/plugin/tui";
+import { createEffect, createResource, createSignal, onCleanup, Show } from "solid-js";
+import { acceptRunCleared, acceptRunUpdate, describeRun, mergeRunState } from "../bin/lib/codeops-progress.mjs";
+import { CodeOpsRpc, requestProgress } from "../bin/lib/codeops-rpc.mjs";
+
+/**
+ * The live run-progress view.
+ *
+ * Resolves the session's location once, subscribes to the `updated` and
+ * `cleared` events before requesting an initial snapshot, and merges both
+ * delivery paths monotonically. A clear records its server-stamped
+ * `clearedAt`; both merge paths ignore deliveries at or before it, so a late
+ * snapshot or update can never resurrect a cleared run. Every failure path is
+ * silent: a host without the events API still renders from the snapshot, and
+ * an invalid or missing snapshot renders nothing.
+ *
+ * @returns The three display lines, or nothing when no run is known.
+ */
+function CodeOpsProgress() {
+  const context = usePlugin();
+  const location = context.location ?? context.data.location.default();
+  const directory = location?.directory ?? "";
+  const [run, setRun] = createSignal(null);
+  const [clearedAt, setClearedAt] = createSignal(0);
+
+  // Subscribe BEFORE the snapshot: events are live-only, so a snapshot
+  // fetched first could miss an update arriving in between. Guarded: a host
+  // without the events API still renders from the snapshot below.
+  const stops = [];
+  try {
+    const events = context.client.rpc(CodeOpsRpc).events;
+    const stopUpdated = events.on("updated", event => {
+      const snapshot = acceptRunUpdate(event, directory);
+      if (snapshot && snapshot.updatedAt > clearedAt()) {
+        setRun(current => mergeRunState(current, snapshot));
+      }
+    });
+    stops.push(stopUpdated);
+    const stopCleared = events.on("cleared", event => {
+      const cleared = acceptRunCleared(event, directory);
+      if (!cleared) return;
+      // Record the clear time for every accepted clear, before the identity
+      // gate: a clear that arrives before the initial snapshot must still
+      // suppress that snapshot, or a cleared run could reappear.
+      setClearedAt(cleared.clearedAt);
+      const current = run();
+      if (current && cleared.plan === current.plan && cleared.sessionID === current.sessionID) {
+        setRun(null);
+      }
+    });
+    stops.push(stopCleared);
+  } catch {
+    // Events unavailable: the snapshot-only view below still renders.
+  }
+  onCleanup(() => stops.forEach(stop => stop()));
+
+  // Initial snapshot; null or a failure means "nothing known". The clear
+  // guard applies here too: a snapshot at or before the last clear is ignored.
+  const [initial] = createResource(async () => requestProgress(context.client, {
+    location
+  }));
+  createEffect(() => {
+    const snapshot = initial();
+    if (snapshot && snapshot.updatedAt > clearedAt()) {
+      setRun(current => mergeRunState(current, snapshot));
+    }
+  });
+  return _$createComponent(Show, {
+    get when() {
+      return run();
+    },
+    children: snapshot => {
+      const view = () => describeRun(snapshot(), Date.now());
+      return _$memo(() => view().lines.map(line => (() => {
+        var _el$ = _$createElement("text");
+        _$insert(_el$, line);
+        return _el$;
+      })()));
+    }
+  });
+}
+
+/**
+ * The opencode-codeops TUI plugin: claims the sidebar content slot with the
+ * live run view. The host disposes the claim when the plugin unloads.
+ */
+export default Plugin.define({
+  id: "opencode-codeops-tui",
+  setup(context) {
+    return context.ui.slot({
+      append: "sidebar.content",
+      render: () => _$createComponent(CodeOpsProgress, {})
+    });
+  }
+});

package/scripts/build-tui.mjs

@@ -0,0 +1,73 @@
+/**
+ * Build the packaged TUI entry.
+ *
+ * OpenCode transpiles plugin TSX with its OpenTUI renderer runtime only for
+ * files outside `node_modules`. A published package always installs into
+ * `node_modules`, so a source `.tsx` entry falls back to the default React
+ * JSX transform and fails to load ("Cannot find package 'react'"). Compiling
+ * `plugin/tui.tsx` with `@opentui/solid`'s own transform — the same pipeline
+ * the host applies to project-local plugins — produces a plain-JavaScript
+ * entry whose runtime imports (`@opentui/solid`, `solid-js`) the host
+ * rewrites to its bundled renderer.
+ *
+ * The generated artifact `plugin/tui.js` is committed and shipped as the
+ * `./tui` export; `scripts/tui-entry-build.spec.test.mjs` fails when it is
+ * stale, so the release verification blocks a stale entry.
+ *
+ * @module build-tui
+ */
+
+import { readFileSync, writeFileSync } from "node:fs"
+import { createRequire } from "node:module"
+import { dirname, join } from "node:path"
+import { fileURLToPath, pathToFileURL } from "node:url"
+
+/** Repository root: this file lives in `<root>/scripts/`. */
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
+
+/** Source of the TUI entry, authored as TSX. */
+const SOURCE = join(ROOT, "plugin", "tui.tsx")
+
+/** Generated JavaScript entry shipped as `./tui`. */
+const TARGET = join(ROOT, "plugin", "tui.js")
+
+/** Header marking the artifact as generated. */
+const HEADER =
+  "// Generated from plugin/tui.tsx — do not edit; run `npm run build:tui` to regenerate.\n"
+
+/**
+ * Load `@opentui/solid`'s Solid JSX transform.
+ *
+ * The transform module is not part of the package's public exports map, so it
+ * is resolved through the package root: resolve the package entry point, then
+ * import the transform beside it.
+ *
+ * @returns The `transformSolidSource(code, options)` function.
+ */
+async function loadTransform() {
+  const require = createRequire(join(ROOT, "scripts", "build-tui.mjs"))
+  const packageEntry = require.resolve("@opentui/solid")
+  const modulePath = join(dirname(packageEntry), "scripts", "solid-transform.js")
+  const module = await import(pathToFileURL(modulePath).href)
+  return module.transformSolidSource
+}
+
+/**
+ * Compile the current `plugin/tui.tsx` into the shipped entry source.
+ *
+ * @returns The complete `plugin/tui.js` content, header included.
+ */
+export async function buildTuiSource() {
+  const transformSolidSource = await loadTransform()
+  const source = readFileSync(SOURCE, "utf8")
+  const transformed = await transformSolidSource(source, { filename: SOURCE })
+  const code = typeof transformed === "string" ? transformed : transformed.code
+  return HEADER + code
+}
+
+// When run directly (`npm run build:tui`), regenerate the committed artifact.
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const code = await buildTuiSource()
+  writeFileSync(TARGET, code)
+  console.log(`built plugin/tui.js (${code.length} chars)`)
+}