@boyingliu01/opencode-plugin 0.10.8 → 0.10.10

package/index.ts

@@ -55,7 +55,7 @@ async function fetchNpmLatestVersion(url: string): Promise<string | null> {
   }
 }
 
-function readCache(file: string): { ts: number; remoteVersion: string; status?: string } | null {
+function readCache(file: string): { ts: number; remoteVersion: string; localVersion?: string; status?: string } | null {
   try {
     if (!existsSync(file)) return null
     const raw = readFileSync(file, "utf8")
@@ -100,11 +100,16 @@ function getLocalXpGateVersion(): string | null {
 
 async function checkXpGateUpdate(): Promise<UpgradeResult> {
   const cached = readCache(XP_GATE_CACHE_FILE)
-  if (cached?.status === "current" && cached.remoteVersion) {
-    return { action: "noop", localVersion: cached.remoteVersion, remoteVersion: cached.remoteVersion }
+  const localVersion = getLocalXpGateVersion()
+
+  // If cache exists and local version hasn't changed AND status is "current",
+  // the cache is still valid — skip network check
+  if (cached?.status === "current" && cached.remoteVersion && localVersion && cached.localVersion === localVersion) {
+    return { action: "noop", localVersion, remoteVersion: cached.remoteVersion }
   }
 
-  const localVersion = getLocalXpGateVersion()
+  // If we have a valid cache but local version changed (e.g., manual upgrade)
+  // or cache has no "current" status, we need to re-check remote
   if (!localVersion) return { action: "noop", localVersion: null, remoteVersion: null }
 
   const remoteVersion = await fetchNpmLatestVersion(XP_GATE_REGISTRY_URL)
@@ -174,6 +179,22 @@ async function checkPluginUpdate(pluginDir: string): Promise<void> {
   }
 }
 
+// ── TUI upgrade notice ──
+
+const UPGRADE_NOTICE_FILE = join(homedir(), ".xp-gate", "upgrade-notice.json")
+
+type UpgradeNotice = {
+  kind: "upgraded" | "outdated" | "error"
+  localVersion: string | null
+  remoteVersion: string | null
+  message: string
+  ts: number
+}
+
+function writeUpgradeNotice(notice: UpgradeNotice): void {
+  writeCache(UPGRADE_NOTICE_FILE, notice)
+}
+
 // ── Combined background check (runs once on first chat.message) ──
 
 async function runBackgroundUpdates(pluginDir: string): Promise<string | null> {
@@ -181,10 +202,19 @@ async function runBackgroundUpdates(pluginDir: string): Promise<string | null> {
   await checkPluginUpdate(pluginDir)
 
   if (result.action === "upgraded") {
-    return `[XP-Gate] Auto-upgraded from v${result.localVersion} to v${result.remoteVersion}`
+    const msg = `[XP-Gate] Auto-upgraded from v${result.localVersion} to v${result.remoteVersion}`
+    writeUpgradeNotice({ kind: "upgraded", localVersion: result.localVersion, remoteVersion: result.remoteVersion, message: msg, ts: Date.now() })
+    return msg
   }
   if (result.action === "error") {
-    return `[XP-Gate] Upgrade check: v${result.remoteVersion} available (auto-upgrade failed: ${result.error})`
+    const msg = `[XP-Gate] Upgrade check: v${result.remoteVersion} available (auto-upgrade failed: ${result.error})`
+    writeUpgradeNotice({ kind: "error", localVersion: result.localVersion, remoteVersion: result.remoteVersion, message: msg, ts: Date.now() })
+    return msg
+  }
+  if (result.remoteVersion && result.localVersion && semverLt(result.localVersion, result.remoteVersion)) {
+    const msg = `[XP-Gate] New version v${result.remoteVersion} available (you have v${result.localVersion})`
+    writeUpgradeNotice({ kind: "outdated", localVersion: result.localVersion, remoteVersion: result.remoteVersion, message: msg, ts: Date.now() })
+    return msg
   }
   return null
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/opencode-plugin",
-  "version": "0.10.8",
+  "version": "0.10.10",
   "type": "module",
   "main": "index.ts",
   "description": "XP-Gate quality gates + AI workflow skills + Sprint Flow TUI sidebar for OpenCode",

package/skills/delphi-review/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
 **Generated:** 2026-06-23
-**Commit:** 34d5784
+**Commit:** bac916f
 **Branch:** main
-**Version:** 0.10.8.0
+**Version:** 0.10.10.0
 
 ## OVERVIEW
 Delphi Consensus Review — multi-round anonymous expert review (≥90% threshold, 3 experts from ≥2 providers, domestic models only). Supports design + code-walkthrough modes.

package/skills/sprint-flow/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/SPRINT-FLOW KNOWLEDGE BASE
 
 **Generated:** 2026-06-23
-**Commit:** 34d5784
+**Commit:** bac916f
 **Branch:** main
-**Version:** 0.10.8.0
+**Version:** 0.10.10.0
 
 ## OVERVIEW
 **11-phase** development pipeline: ISOLATE → AUTO-ESTIMATE → THINK → PLAN → BUILD → REVIEW → USER ACCEPTANCE → FEEDBACK → SHIP → LAND → CLEANUP. Phase 2 default build mode is **ralph-loop** (REQ-level iteration, 40-67% token savings vs parallel). HARD-GATE in Phase 1: design must pass Delphi review (≥90% consensus) before any coding.

package/skills/test-specification-alignment/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/TEST-SPECIFICATION-ALIGNMENT KNOWLEDGE BASE
 
 **Generated:** 2026-06-23
-**Commit:** 34d5784
+**Commit:** bac916f
 **Branch:** main
-**Version:** 0.10.8.0
+**Version:** 0.10.10.0
 
 ## OVERVIEW
 Test-Specification Alignment Engine — two-stage validation ensuring tests accurately reflect requirements and design specs.

package/tui-plugin.ts

@@ -2,7 +2,7 @@
  * XP-Gate OpenCode TUI Slot Plugin
  *
  * Registers sidebar_content slot to display Sprint Flow progress
- * from .sprint-state/sprint-state.json.
+ * from active sprint states discovered in .worktrees/sprint/ subdirectories.
  *
  * This is a separate plugin file because SDK 1.x PluginModule does not
  * support server + tui in the same module. Users register this file
@@ -10,13 +10,17 @@
  *   { "plugin": ["@boyingliu01/opencode-plugin/tui"] }
  *
  * The npm package exports "./tui" from package.json for this resolution.
+ *
+ * Discovery logic is inlined here (mirrors src/npm-package/lib/sprint-discovery.js)
+ * because the plugin ships separately from the CLI package at runtime.
  */
 
-import { existsSync, readFileSync } from "node:fs"
-import { join } from "node:path"
+import { existsSync, readFileSync, readdirSync } from "node:fs"
+import { join, dirname, resolve, parse } from "node:path"
+import { homedir } from "node:os"
 import type { TuiPlugin, TuiSlotPlugin, TuiSlotProps } from "@opencode-ai/plugin/tui"
-// ── Phase constants (inlined from ../../src/npm-package/lib/shared-phase-constants.js)
-//   This file is inlined because the installed npm package does not bundle src/ at publish time. ──
+
+// ── Phase constants (inlined from ../../src/npm-package/lib/shared-phase-constants.js) ──
 
 const PHASE_NAMES: Record<string, string> = {
   '-1': 'ISOLATE',
@@ -34,30 +38,6 @@ const PHASE_NAMES: Record<string, string> = {
 
 const PHASE_ORDER = ['-1', '-0.5', '0', '1', '2', '3', '4', '5', '6', '7', '8'];
 
-function parseTime(value: unknown): number {
-  return new Date(value as string).getTime();
-}
-
-function isStale(state: SprintState | null): boolean {
-  if (!state || !state.started_at) return false;
-  const latest = sprintTimestamp(state);
-  return latest > 0 && Date.now() - latest > 3600000;
-}
-
-function sprintTimestamp(state: SprintState | null): number {
-  if (!state || !state.started_at) return 0;
-  const started = parseTime(state.started_at);
-  if (isNaN(started)) return 0;
-  let latest = started;
-  if (Array.isArray(state.phase_history)) {
-    for (const ph of state.phase_history) {
-      latest = ph.completed_at ? Math.max(latest, parseTime(ph.completed_at)) : latest;
-      latest = ph.started_at ? Math.max(latest, parseTime(ph.started_at)) : latest;
-    }
-  }
-  return latest;
-}
-
 // ── Sprint state schema ──
 
 interface SprintReq {
@@ -86,16 +66,142 @@ interface SprintState {
   phase_history?: SprintPhaseHistory[]
 }
 
-// ── Helpers ──
+interface DiscoveredSprint {
+  state: SprintState
+  sourcePath: string
+  worktreeExists: boolean
+}
+
+// ── Discovery: inlined from src/npm-package/lib/sprint-discovery.js ──
+
+const MAX_DISCOVERY_RESULTS = 5;
+
+function findGitRoot(startDir: string): string | null {
+  let current = resolve(startDir);
+  const root = parse(current).root;
+  const seen = new Set<string>();
+
+  while (current !== root) {
+    if (seen.has(current)) break;
+    seen.add(current);
+    if (existsSync(join(current, '.git'))) return current;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  if (existsSync(join(root, '.git'))) return root;
+  return null;
+}
 
 function readSprintState(dir: string): SprintState | null {
   try {
-    const stateFile = join(dir, ".sprint-state", "sprint-state.json")
-    if (!existsSync(stateFile)) return null
-    return JSON.parse(readFileSync(stateFile, "utf8"))
+    const stateFile = join(dir, '.sprint-state', 'sprint-state.json');
+    if (!existsSync(stateFile)) return null;
+    return JSON.parse(readFileSync(stateFile, 'utf8')) as SprintState;
   } catch {
-    return null
+    return null;
+  }
+}
+
+function checkWorktreeExists(worktreePath: string | undefined): boolean {
+  if (!worktreePath) return false;
+  try { return existsSync(worktreePath); } catch { return false; }
+}
+
+function discoverActiveSprints(dir: string): DiscoveredSprint[] {
+  const gitRoot = findGitRoot(dir);
+  const results: DiscoveredSprint[] = [];
+
+  if (gitRoot) {
+    const worktreeBase = join(gitRoot, '.worktrees', 'sprint');
+    let entries: { name: string; isDirectory: () => boolean }[] = [];
+    try {
+      if (existsSync(worktreeBase)) {
+        entries = readdirSync(worktreeBase, { withFileTypes: true });
+      }
+    } catch { /* EACCES */ }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const sprintDir = join(worktreeBase, entry.name);
+      const state = readSprintState(sprintDir);
+      if (!state?.id) continue;
+      const worktreeExists = checkWorktreeExists(sprintDir);
+      if (isStaleSprint(state) && !worktreeExists) continue;
+
+      results.push({ state, sourcePath: join(sprintDir, '.sprint-state', 'sprint-state.json'), worktreeExists });
+    }
   }
+
+  // Fallback: cwd's own .sprint-state/
+  const localState = readSprintState(dir);
+  if (localState?.id) {
+    const localWorktreePath = localState.isolation?.worktree_path;
+    const hasExplicitWorktree = !!localWorktreePath;
+    const localWorktreeExists = hasExplicitWorktree ? checkWorktreeExists(localWorktreePath) : false;
+    if (!hasExplicitWorktree || localWorktreeExists) {
+      results.push({
+        state: localState,
+        sourcePath: join(dir, '.sprint-state', 'sprint-state.json'),
+        worktreeExists: localWorktreeExists,
+      });
+    }
+  }
+
+  // Dedup by state.id
+  const deduped = new Map<string, DiscoveredSprint>();
+  for (const entry of results) {
+    const id = entry.state.id!;
+    const existing = deduped.get(id);
+    if (!existing) { deduped.set(id, entry); continue; }
+    if (entry.worktreeExists && !existing.worktreeExists) { deduped.set(id, entry); continue; }
+    if (!entry.worktreeExists && existing.worktreeExists) continue;
+    const entryTs = entry.state.started_at ? new Date(entry.state.started_at).getTime() : 0;
+    const existingTs = existing.state.started_at ? new Date(existing.state.started_at).getTime() : 0;
+    if (entryTs > existingTs || (entryTs === existingTs && entry.sourcePath < existing.sourcePath)) {
+      deduped.set(id, entry);
+    }
+  }
+
+  return Array.from(deduped.values())
+    .sort((a, b) => {
+      const aTs = a.state.started_at ? new Date(a.state.started_at).getTime() : 0;
+      const bTs = b.state.started_at ? new Date(b.state.started_at).getTime() : 0;
+      if (bTs !== aTs) return bTs - aTs;
+      return String(b.state.id).localeCompare(String(a.state.id));
+    })
+    .slice(0, MAX_DISCOVERY_RESULTS);
+}
+
+// ── Cache (module-level, 5s TTL) ──
+
+let _cache: { data: DiscoveredSprint[]; upgradeNotice: string | null; ts: number; dir: string } | null = null;
+const CACHE_TTL_MS = 5_000;
+
+// ── Helpers ──
+
+function parseTime(value: unknown): number {
+  return new Date(value as string).getTime();
+}
+
+function sprintTimestamp(state: SprintState): number {
+  if (!state.started_at) return 0;
+  const started = parseTime(state.started_at);
+  if (isNaN(started)) return 0;
+  let latest = started;
+  if (Array.isArray(state.phase_history)) {
+    for (const ph of state.phase_history) {
+      latest = ph.completed_at ? Math.max(latest, parseTime(ph.completed_at)) : latest;
+      latest = ph.started_at ? Math.max(latest, parseTime(ph.started_at)) : latest;
+    }
+  }
+  return latest;
+}
+
+function isStaleSprint(state: SprintState | null): boolean {
+  if (!state?.started_at) return false;
+  const latest = sprintTimestamp(state);
+  return latest > 0 && Date.now() - latest > 3_600_000;
 }
 
 function statusSymbol(status: string | undefined, key: string, currentPhase: string | number | undefined): string {
@@ -131,8 +237,8 @@ function buildMetricsLine(metrics: SprintState["metrics"]): string | null {
 }
 
 function buildStaleWarning(state: SprintState): string | null {
-  if (!state || !state.started_at) return null
-  return isStale(state) ? "⚠ idle >1h" : null
+  if (!state?.started_at) return null
+  return isStaleSprint(state) ? "⚠ idle >1h" : null
 }
 
 function renderBuildReqs(history: SprintPhaseHistory): string[] {
@@ -178,17 +284,107 @@ function renderSprintSidebar(state: SprintState): string {
   return lines.join("\n")
 }
 
+function renderSprintTitle(state: SprintState): string {
+  if (state.task_description) return state.task_description;
+  if (state.id) {
+    // Fallback: extract date from sprint ID like "sprint-2026-06-23-01"
+    const match = state.id.match(/sprint-(\d{4}-\d{2}-\d{2})-(\d+)/);
+    if (match) return `Sprint ${match[1]} #${match[2]}`;
+    return state.id;
+  }
+  return 'Unknown Sprint';
+}
+
+function renderMultiSprintSidebar(sprints: DiscoveredSprint[]): string | null {
+  if (sprints.length === 0) return null;
+
+  const blocks: string[] = [];
+  const displayCount = Math.min(sprints.length, 3);
+
+  for (let i = 0; i < displayCount; i++) {
+    const { state } = sprints[i];
+    const title = renderSprintTitle(state);
+    const block: string[] = [`SPRINT: ${title}`];
+
+    if (state.isolation?.branch) {
+      block.push(`  ${state.isolation.branch}`);
+    }
+
+    const metricsLine = buildMetricsLine(state.metrics);
+    if (metricsLine) block.push(`  ${metricsLine}`);
+
+    const staleWarning = buildStaleWarning(state);
+    if (staleWarning) block.push(`  ${staleWarning}`);
+
+    const historyByPhase = buildPhaseLookup(state);
+    block.push(...renderPhaseLines(historyByPhase, state.phase));
+
+    blocks.push(block.join("\n"));
+  }
+
+  if (sprints.length > 3) {
+    blocks.push(`… +${sprints.length - 3} more`);
+  }
+
+  return blocks.join("\n---\n");
+}
+
+function renderContent(sprints: DiscoveredSprint[], upgradeNotice: string | null): string | null {
+  const sprintContent = renderMultiSprintSidebar(sprints)
+  if (upgradeNotice && sprintContent) return `${upgradeNotice}\n---\n${sprintContent}`
+  if (upgradeNotice) return upgradeNotice
+  return sprintContent
+}
+
+// ── Upgrade notice ──
+
+const UPGRADE_NOTICE_FILE = join(homedir(), ".xp-gate", "upgrade-notice.json")
+const UPGRADE_NOTICE_TTL_MS = 86_400_000 // 24h
+
+type UpgradeNotice = {
+  kind: string
+  localVersion: string | null
+  remoteVersion: string | null
+  message: string
+  ts: number
+}
+
+function readUpgradeNotice(): UpgradeNotice | null {
+  try {
+    if (!existsSync(UPGRADE_NOTICE_FILE)) return null
+    const raw = readFileSync(UPGRADE_NOTICE_FILE, "utf8")
+    const data = JSON.parse(raw) as UpgradeNotice
+    if (Date.now() - data.ts < UPGRADE_NOTICE_TTL_MS && data.message) return data
+    return null
+  } catch {
+    return null
+  }
+}
+
+function renderUpgradeNotice(): string | null {
+  const notice = readUpgradeNotice()
+  if (!notice) return null
+  const icon = notice.kind === "upgraded" ? "✓" : notice.kind === "outdated" ? "↑" : "⚠"
+  return `${icon} ${notice.message}`
+}
+
 // ── TUI Slot Plugin ──
 
 const tuiPlugin: TuiSlotPlugin = {
   slots: {
     sidebar_content: (_props: TuiSlotProps) => {
-      const dir = process.env.XP_GATE_PROJECT_DIR || process.cwd()
-      const state = readSprintState(dir)
-      if (!state) return null
-      const text = renderSprintSidebar(state)
-      if (!text) return null
-      return text
+      const dir = process.env.XP_GATE_PROJECT_DIR || process.cwd();
+      const now = Date.now();
+
+      // Use cache if still valid for current directory
+      if (_cache && _cache.dir === dir && now - _cache.ts < CACHE_TTL_MS) {
+        return renderContent(_cache.data, _cache.upgradeNotice);
+      }
+
+      const sprints = discoverActiveSprints(dir);
+      const upgradeNotice = renderUpgradeNotice()
+      _cache = { data: sprints, ts: now, dir, upgradeNotice };
+      return renderContent(sprints, upgradeNotice);
     },
   },
 }