opencode-codeops 2.1.1 → 2.2.1

package/plugin/tui.tsx

@@ -0,0 +1,112 @@
+/**
+ * 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 type { CodeOpsRunState } 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<CodeOpsRunState | null>(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: (() => void)[] = []
+  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 (
+    <Show when={run()}>
+      {(snapshot) => {
+        const view = () => describeRun(snapshot(), Date.now())
+        return (
+          <>
+            {view().lines.map((line) => (
+              <text>{line}</text>
+            ))}
+          </>
+        )
+      }}
+    </Show>
+  )
+}
+
+/**
+ * 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: () => <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)`)
+}

package/scripts/codeops_plan.py

@@ -13,6 +13,7 @@ import re
 import sys
 from dataclasses import asdict, dataclass
 from pathlib import Path
+from typing import Iterator
 
 
 IMPLEMENTS_RE = re.compile(r"^>[ \t]*\*\*Implements\*\*:[ \t]*(.+?)[ \t]*$", re.MULTILINE)
@@ -21,7 +22,9 @@ TARGET_RE = re.compile(
     r"(?:RD-(?:[A-Za-z0-9]+-)*\d+|T-\d+|REQ-[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*)"
     r"(?![A-Za-z0-9_-])"
 )
-TASK_RE = re.compile(r"^-\s*\[([ xX~!])\]\s+(.+?)\s*$", re.MULTILINE)
+TASK_RE = re.compile(r"^-\s*\[([ xX~!])\]\s+(.+?)\s*$")
+FENCE_OPEN_RE = re.compile(r"^ {0,3}(`{3,}|~{3,})")
+TASK_ID_RE = re.compile(r"^\s*(?:\*\*)?([0-9]+\.[0-9]+\.[0-9]+|T-[0-9]+\.[0-9]+)(?=[\s*—–-]|$)")
 BLOCKED_REASON_RE = re.compile(r"(?:blocked|reason)\s*:\s*\S", re.IGNORECASE)
 _PROGRESS_WIDTH = 10
 _PROGRESS_FILLED = "█"
@@ -67,9 +70,70 @@ def parse_implements(index_text: str) -> tuple[str, ...]:
     return tuple(dict.fromkeys(TARGET_RE.findall(match.group(1))))
 
 
+def _task_lines(execution_text: str) -> Iterator[tuple[str, str, str]]:
+    """Yield ``(marker, text, task_id)`` for every real execution-task line.
+
+    A line qualifies when it carries one of the four checkbox markers outside a
+    fenced code block and its text begins with a task id. Fences follow the
+    Markdown shape: an opening run of three or more backticks or tildes (at
+    most three leading spaces, optional info string) hides everything up to a
+    closing run of the same character with at least the same length and nothing
+    else on the line; an unclosed fence hides the rest of the document. An id
+    is ``N.N.N`` or ``T-N.N`` after an optional ``**`` opener and must be
+    followed by whitespace, ``*``, a dash, or the end of the line, so
+    near-misses such as ``1.1.1.1``, ``T-05.1x``, and ``1.1.1:`` stay ignored.
+    Duplicate ids are yielded; the caller decides which occurrence counts.
+    """
+    fence_char = ""
+    fence_length = 0
+    for line in execution_text.splitlines():
+        line = line.rstrip()
+        if fence_char:
+            indent = len(line) - len(line.lstrip(" "))
+            body = line[indent:] if indent <= 3 else ""
+            if len(body) >= fence_length and body == fence_char * len(body):
+                fence_char = ""
+            continue
+        opener = FENCE_OPEN_RE.match(line)
+        if opener:
+            fence_char = opener.group(1)[0]
+            fence_length = len(opener.group(1))
+            continue
+        task = TASK_RE.match(line)
+        task_id = TASK_ID_RE.match(task.group(2)) if task else None
+        if task_id is None:
+            continue
+        yield task.group(1).lower(), task.group(2).strip(), task_id.group(1)
+
+
 def parse_tasks(execution_text: str) -> tuple[Task, ...]:
-    """Parse only the four authoritative execution checklist markers."""
-    return tuple(Task(marker.lower(), text.strip()) for marker, text in TASK_RE.findall(execution_text))
+    """Return the execution tasks a plan document really declares.
+
+    Fenced examples and checkbox lines without a task id (deliverable and
+    acceptance lists, quoted templates) are ignored, and a task id that appears
+    more than once counts once, from its first occurrence in document order.
+    """
+    tasks: list[Task] = []
+    seen: set[str] = set()
+    for marker, text, task_id in _task_lines(execution_text):
+        if task_id in seen:
+            continue
+        seen.add(task_id)
+        tasks.append(Task(marker, text))
+    return tuple(tasks)
+
+
+def has_checkbox_lines(execution_text: str) -> bool:
+    """Return whether a document carries at least one checklist line.
+
+    Presence is deliberately id-agnostic: legacy execution plans may list
+    tasks without ids, and migration admission must stay tolerant of them.
+    Counting correctness is ``parse_tasks``' job; this predicate only answers
+    "does the document look like it declares tasks at all". Fences are not
+    stripped here for the same reason — a quoted checklist still proves the
+    document format.
+    """
+    return any(TASK_RE.match(line.rstrip()) for line in execution_text.splitlines())
 
 
 def next_task(tasks: tuple[Task, ...]) -> Task | None:

package/scripts/codeops_plan_migrate.py

@@ -17,9 +17,21 @@ from dataclasses import dataclass
 from pathlib import Path
 
 try:
-    from scripts.codeops_plan import BLOCKED_REASON_RE, IMPLEMENTS_RE, parse_implements, parse_tasks
+    from scripts.codeops_plan import (
+        BLOCKED_REASON_RE,
+        IMPLEMENTS_RE,
+        has_checkbox_lines,
+        parse_implements,
+        parse_tasks,
+    )
 except ModuleNotFoundError:  # Direct execution adds scripts/, not the repository root, to sys.path.
-    from codeops_plan import BLOCKED_REASON_RE, IMPLEMENTS_RE, parse_implements, parse_tasks
+    from codeops_plan import (
+        BLOCKED_REASON_RE,
+        IMPLEMENTS_RE,
+        has_checkbox_lines,
+        parse_implements,
+        parse_tasks,
+    )
 
 
 TARGET_ID_RE = re.compile(
@@ -231,7 +243,9 @@ def inspect_migration(codeops_root: Path) -> Migration:
                 continue
             execution_text = execution.read_text(encoding="utf-8")
             tasks = parse_tasks(execution_text)
-            if not tasks:
+            # Presence stays checkbox-based (id-agnostic) so legacy id-less
+            # checklists keep migrating; only real tasks are checked further.
+            if not has_checkbox_lines(execution_text):
                 problems.append(f"{execution}: contains no execution tasks")
             for task in tasks:
                 if task.marker == "!" and not BLOCKED_REASON_RE.search(task.text):

package/skills/exec-plan/SKILL.md

@@ -172,6 +172,11 @@ For each task, in order:
    the Master Progress Checklist — see the protocol's dual-format detection) and bump the Progress
    counter / Last Updated stamp as soon as implementation finishes (crash-safe), promote it to
    `[x]` only after its verification passes. A task never shows `[x]` with a failing verify.
+
+   - **Report progress** — when the `codeops_progress` tool is available — at the transition
+     points in [execution-protocol.md](execution-protocol.md) §Progress Reporting; a failed or
+     missing report never blocks any step.
+
 3. **Verify** — run your project's verify command (from the project's AGENTS.md, or detected
    project conventions), output captured per the protocol's **Verify-output capture rule**
    (PASS one-liner; on failure the last 50 log lines + log path). Pass → promote `[~]` → `[x]`;

package/skills/exec-plan/execution-protocol.md

@@ -444,6 +444,35 @@ otherwise still `[~]` — with the progress counter and Last Updated stamp curre
 
 ---
 
+## Progress Reporting (fail-soft)
+
+While a plan executes, the agent may report live progress through the `codeops_progress` tool so
+the sidebar shows the current run. Reporting is an observability aid only: the Markdown execution
+plan remains the single progress source of truth, and a missing tool or a failed call never
+blocks, delays, or changes any verify, commit, or plan update — when the tool is unavailable,
+execution proceeds silently.
+
+Report at these moments; `plan` is the plan folder name, and every call carries `plan` and
+`activity` (absent optional fields are carried by the run state):
+
+| Moment | Report payload |
+| ------ | -------------- |
+| Run start (start point determined) | `{ plan, phase, task, activity: "implementing" }` |
+| Phase start (subsequent phases) | `{ plan, phase, activity: "starting" }` |
+| Task implemented (after the `[~]` mark) | `{ plan, task, activity: "implementing" }` |
+| Verification (before running verify) | `{ plan, activity: "verifying" }` |
+| Task verified (after `[x]` + the progress-bar display) | `{ plan, verified, total, activity: "implementing" }` — counts from that display |
+| Blocker (after the `[!]` mark) | `{ plan, activity: "blocked", detail: "<short reason>" }` |
+| Delegation (around an executor/reviewer dispatch) | `{ plan, activity: "delegating", detail: "<role>" }` |
+| Review step (post-phase quality loop) | `{ plan, activity: "reviewing" }` |
+| Waiting (before pausing for an explicit user decision) | `{ plan, activity: "waiting" }` |
+| Run done (all tasks complete) | `{ plan, activity: "done" }` |
+
+One call per listed moment, no other calls (noise control). A reporting failure or a host without
+the tool never blocks, delays, or changes any step.
+
+---
+
 ## Step 3: Session Wrap-Up
 
 1. Complete the current task before stopping.

package/plugin/temp-lifecycle.spec.test.mjs

@@ -1,55 +0,0 @@
-/**
- * Specification tests for the scratch-directory lifecycle.
- *
- * The plugin exports one scratch directory (`$CODEOPS_TMPDIR`) per plugin
- * runtime, and every session served by that runtime shares it. Deleting the
- * directory when a plugin instance unloads destroys in-flight scratch files of
- * sessions that are still running, so the contract is: the plugin never
- * deletes the shared directory; the age-based sweep reclaims abandoned
- * directories instead.
- *
- * This is the regression oracle for that contract: a failure here means the
- * repository reintroduced early deletion, never that the test is wrong.
- *
- * @module temp-lifecycle.spec.test
- */
-
-import assert from "node:assert/strict"
-import { readFileSync } from "node:fs"
-import { dirname, join, resolve } from "node:path"
-import { describe, it } from "node:test"
-import { fileURLToPath } from "node:url"
-
-const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..")
-
-/**
- * Read a repository file as UTF-8 text.
- * @param {string} relativePath - Path relative to the repository root.
- * @returns {string} The file contents.
- */
-function read(relativePath) {
-  return readFileSync(join(ROOT, relativePath), "utf8")
-}
-
-describe("scratch-directory lifecycle", () => {
-  it("keeps the plugin free of scratch-directory deletion", () => {
-    const plugin = read("plugin/index.ts")
-    assert.doesNotMatch(plugin, /removeSessionTmpDir/)
-    assert.match(plugin, /cleanStaleTmpDirs\(\)/)
-    assert.match(plugin, /controller\.abort\(\)/)
-  })
-
-  it("keeps the temp hygiene module free of exact-directory deletion", () => {
-    assert.doesNotMatch(read("bin/lib/tmp-hygiene.mjs"), /removeSessionTmpDir/)
-    assert.doesNotMatch(read("bin/lib/tmp-hygiene.d.mts"), /removeSessionTmpDir/)
-  })
-
-  it("documents the age-based sweep as the automatic cleanup", () => {
-    const hygiene = read("_shared/workspace-hygiene.md")
-    assert.doesNotMatch(hygiene, /removes that runtime's\s+directory when the plugin unloads/i)
-    assert.match(hygiene, /seven days/i)
-    const readme = read("README.md")
-    assert.doesNotMatch(readme, /removes the\s+directory when it unloads/i)
-    assert.match(readme, /sweeps\s+directories abandoned/i)
-  })
-})