@boyingliu01/xp-gate 0.9.1 → 0.9.3

package/plugins/opencode/__tests__/xp-gate-update.test.ts

@@ -0,0 +1,255 @@
+/**
+ * XP-Gate auto-update tests
+ *
+ * Tests for:
+ * - semverLt: version comparison
+ * - checkXpGateUpdate: xp-gate npm registry check + cache + auto-upgrade
+ * - chat.message integration
+ * - Legacy checkPluginUpdate modified to detect BOTH packages
+ */
+
+import { describe, it, before, after } from "node:test"
+import assert from "node:assert/strict"
+import { randomUUID } from "node:crypto"
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir, homedir } from "node:os"
+import { execSync } from "node:child_process"
+
+// ── Pure function: semverLt ──
+
+function semverLt(a: string, b: string): boolean {
+  const pa = a.replace(/^v/, "").split(".").map(Number)
+  const pb = b.replace(/^v/, "").split(".").map(Number)
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const na = pa[i] ?? 0
+    const nb = pb[i] ?? 0
+    if (na !== nb) return na < nb
+  }
+  return false
+}
+
+// ── XP-GATE specific: these are the new functions we need to implement ──
+
+const XP_GATE_CACHE_FILE = join(homedir(), ".xp-gate", "xp-gate-version-check.json")
+const XP_GATE_NPM_PKG = "@boyingliu01/xp-gate"
+const XP_GATE_REGISTRY_URL = `https://registry.npmjs.org/-/package/${encodeURIComponent(XP_GATE_NPM_PKG)}/dist-tags`
+const CACHE_TTL_MS = 86_400_000 // 24h
+
+type XpGateCache = {
+  ts: number
+  localVersion: string
+  remoteVersion: string
+  status?: "current" | "upgraded"
+}
+
+/**
+ * Read version from installed xp-gate npm package.
+ * Returns null if not installed.
+ */
+function getLocalXpGateVersion(): string | null {
+  try {
+    const pkgPath = join(
+      execSync("npm root -g", { encoding: "utf8" }).trim(),
+      XP_GATE_NPM_PKG,
+      "package.json"
+    )
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"))
+    return pkg.version || null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Read cache file, returns null if absent / stale.
+ */
+function readXpGateCache(): XpGateCache | null {
+  try {
+    if (!existsSync(XP_GATE_CACHE_FILE)) return null
+    const raw = readFileSync(XP_GATE_CACHE_FILE, "utf8")
+    const data: XpGateCache = JSON.parse(raw)
+    if (Date.now() - data.ts < CACHE_TTL_MS && data.remoteVersion) {
+      return data
+    }
+    return null // stale
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Write cache file.
+ */
+function writeXpGateCache(data: XpGateCache): void {
+  try {
+    mkdirSync(join(homedir(), ".xp-gate"), { recursive: true })
+    const tmp = XP_GATE_CACHE_FILE + ".tmp." + process.pid
+    writeFileSync(tmp, JSON.stringify(data), "utf8")
+    try { rmSync(XP_GATE_CACHE_FILE) } catch {}
+    const orig = readFileSync(tmp, "utf8")
+    writeFileSync(XP_GATE_CACHE_FILE, orig, "utf8")
+    rmSync(tmp)
+  } catch {
+    // silent
+  }
+}
+
+/**
+ * Fetch latest version from npm registry. Returns null on failure.
+ */
+async function fetchNpmLatestVersion(url: string, timeoutMs = 5000): Promise<string | null> {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeoutMs)
+  try {
+    const response = await fetch(url, { signal: controller.signal })
+    if (!response.ok) return null
+    const data: Record<string, unknown> = await response.json()
+    const latest = data.latest
+    return typeof latest === "string" ? latest : null
+  } catch {
+    return null
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+type UpgradeResult = {
+  action: "noop" | "upgraded" | "error"
+  localVersion: string | null
+  remoteVersion: string | null
+  error?: string
+}
+
+/**
+ * Check xp-gate version and auto-upgrade if outdated.
+ *
+ * - Respects daily cache
+ * - Fires npm install -g in background
+ * - Returns result for user notification
+ */
+async function checkXpGateUpdate(): Promise<UpgradeResult> {
+  // 1. Check cache
+  const cached = readXpGateCache()
+  if (cached && cached.status === "current") {
+    return { action: "noop", localVersion: cached.localVersion, remoteVersion: cached.remoteVersion }
+  }
+
+  // 2. Get local version
+  const localVersion = getLocalXpGateVersion()
+  if (!localVersion) {
+    return { action: "noop", localVersion: null, remoteVersion: null }
+  }
+
+  // 3. Fetch remote
+  const remoteVersion = await fetchNpmLatestVersion(XP_GATE_REGISTRY_URL)
+  if (!remoteVersion) {
+    return { action: "noop", localVersion, remoteVersion: null }
+  }
+
+  // 4. Compare
+  if (!semverLt(localVersion, remoteVersion)) {
+    writeXpGateCache({ ts: Date.now(), localVersion, remoteVersion, status: "current" })
+    return { action: "noop", localVersion, remoteVersion }
+  }
+
+  // 5. Outdated — auto upgrade
+  writeXpGateCache({ ts: Date.now(), localVersion, remoteVersion })
+  try {
+    execSync(`npm install -g ${XP_GATE_NPM_PKG}@${remoteVersion}`, {
+      stdio: "pipe",
+      timeout: 120_000,
+    })
+    writeXpGateCache({ ts: Date.now(), localVersion: remoteVersion, remoteVersion, status: "current" })
+    return { action: "upgraded", localVersion, remoteVersion }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    return { action: "error", localVersion, remoteVersion, error: msg }
+  }
+}
+
+// ── Tests ──
+
+void describe("semverLt", () => {
+  void it("returns true when local < remote", () => {
+    assert.equal(semverLt("0.9.1", "0.9.2"), true)
+  })
+
+  void it("returns false when local > remote", () => {
+    assert.equal(semverLt("0.9.3", "0.9.2"), false)
+  })
+
+  void it("returns false when versions equal", () => {
+    assert.equal(semverLt("0.9.2", "0.9.2"), false)
+  })
+
+  void it("handles 'v' prefix", () => {
+    assert.equal(semverLt("v0.9.1", "v0.9.2"), true)
+  })
+
+  void it("handles mixed prefix", () => {
+    assert.equal(semverLt("v0.9.1", "0.9.2"), true)
+  })
+
+  void it("handles different segment counts", () => {
+    assert.equal(semverLt("0.9", "0.9.2"), true)
+  })
+
+  void it("handles major version bumps", () => {
+    assert.equal(semverLt("0.9.2", "1.0.0"), true)
+  })
+
+  void it("returns false for identical versions with v prefix", () => {
+    assert.equal(semverLt("v1.0.0", "1.0.0"), false)
+  })
+})
+
+void describe("checkXpGateUpdate — cache & upgrade", () => {
+  const fakeHome = join(tmpdir(), "xp-gate-upd-test-" + randomUUID())
+  const origHome = process.env.HOME
+
+  before(() => {
+    process.env.HOME = fakeHome
+    mkdirSync(join(fakeHome, ".xp-gate"), { recursive: true })
+  })
+
+  after(() => {
+    process.env.HOME = origHome
+    rmSync(fakeHome, { recursive: true, force: true })
+  })
+
+  void it("returns noop when no xp-gate installed locally", async () => {
+    const result = await checkXpGateUpdate()
+    assert.equal(result.action, "noop")
+    // localVersion may be null (no install) or the actual version (test env has global)
+    // Either is acceptable — the key behavior is noop, not the value
+  })
+
+  void it("returns noop when cache says current", async () => {
+    const cachePath = join(fakeHome, ".xp-gate", "xp-gate-version-check.json")
+    writeFileSync(cachePath, JSON.stringify({
+      ts: Date.now(),
+      localVersion: "0.9.2",
+      remoteVersion: "0.9.2",
+      status: "current",
+    }))
+
+    const result = await checkXpGateUpdate()
+    assert.equal(result.action, "noop")
+    assert.equal(result.remoteVersion, "0.9.2")
+  })
+
+  void it("handles cache expiry correctly", async () => {
+    const cachePath = join(fakeHome, ".xp-gate", "xp-gate-version-check.json")
+    writeFileSync(cachePath, JSON.stringify({
+      ts: Date.now() - 86_400_000 - 3600_000, // 25h old
+      localVersion: "0.9.1",
+      remoteVersion: "0.9.2",
+    }))
+
+    const result = await checkXpGateUpdate()
+    // Stale cache should be ignored — should check npm registry
+    // If network check fails, returns noop with localVersion if found
+    assert.equal(result.action, "noop")
+  })
+})

package/plugins/opencode/index.ts

@@ -1,8 +1,8 @@
 import { tool } from "@opencode-ai/plugin"
 import { z } from "zod"
-import { exec } from "child_process"
-import { promisify } from "util"
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs"
+import { exec, execSync } from "node:child_process"
+import { promisify } from "node:util"
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync } from "node:fs"
 import { join } from "node:path"
 import { homedir } from "node:os"
 
@@ -13,6 +13,158 @@ interface OpenCodePluginInput {
   $: (strings: TemplateStringsArray, ...values: unknown[]) => Promise<{ text(): Promise<string> }>
 }
 
+// ── Constants ──
+
+const CACHE_TTL_MS = 86_400_000 // 24h
+const FETCH_TIMEOUT_MS = 5_000
+
+const XP_GATE_NPM_PKG = "@boyingliu01/xp-gate"
+const XP_GATE_CACHE_FILE = join(homedir(), ".xp-gate", "xp-gate-version-check.json")
+const XP_GATE_REGISTRY_URL = `https://registry.npmjs.org/-/package/${encodeURIComponent(XP_GATE_NPM_PKG)}/dist-tags`
+
+const OPENCODE_PLUGIN_REGISTRY = "https://registry.npmjs.org/-/package/@boyingliu01%2Fopencode-plugin/dist-tags"
+const OPENCODE_CACHE_FILE = join(homedir(), ".xp-gate", "opencode-plugin-version-check.json")
+
+let checked = false
+
+// ── Utilities ──
+
+function semverLt(a: string, b: string): boolean {
+  const pa = a.replace(/^v/, "").split(".").map(Number)
+  const pb = b.replace(/^v/, "").split(".").map(Number)
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const na = pa[i] ?? 0
+    const nb = pb[i] ?? 0
+    if (na !== nb) return na < nb
+  }
+  return false
+}
+
+async function fetchNpmLatestVersion(url: string): Promise<string | null> {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS)
+  try {
+    const response = await fetch(url, { signal: controller.signal })
+    if (!response.ok) return null
+    const data: Record<string, unknown> = await response.json()
+    return typeof data.latest === "string" ? data.latest : null
+  } catch {
+    return null
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+function readCache(file: string): { ts: number; remoteVersion: string; status?: string } | null {
+  try {
+    if (!existsSync(file)) return null
+    const raw = readFileSync(file, "utf8")
+    const data = JSON.parse(raw)
+    if (Date.now() - data.ts < CACHE_TTL_MS && data.remoteVersion) return data
+    return null
+  } catch {
+    return null
+  }
+}
+
+function writeCache(file: string, data: object): void {
+  try {
+    mkdirSync(join(homedir(), ".xp-gate"), { recursive: true })
+    writeFileSync(file + ".tmp", JSON.stringify(data), "utf8")
+    try { rmSync(file) } catch {}
+    writeFileSync(file, readFileSync(file + ".tmp", "utf8"), "utf8")
+    try { rmSync(file + ".tmp") } catch {}
+  } catch {
+    // silent
+  }
+}
+
+// ── XP-Gate npm package auto-update ──
+
+type UpgradeResult = {
+  action: "noop" | "upgraded" | "error"
+  localVersion: string | null
+  remoteVersion: string | null
+  error?: string
+}
+
+function getLocalXpGateVersion(): string | null {
+  try {
+    const globalRoot = execSync("npm root -g", { encoding: "utf8" }).trim()
+    const pkg = JSON.parse(readFileSync(join(globalRoot, XP_GATE_NPM_PKG, "package.json"), "utf8"))
+    return pkg.version || null
+  } catch {
+    return 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 (!localVersion) return { action: "noop", localVersion: null, remoteVersion: null }
+
+  const remoteVersion = await fetchNpmLatestVersion(XP_GATE_REGISTRY_URL)
+  if (!remoteVersion) return { action: "noop", localVersion, remoteVersion: null }
+
+  if (!semverLt(localVersion, remoteVersion)) {
+    writeCache(XP_GATE_CACHE_FILE, { ts: Date.now(), localVersion, remoteVersion, status: "current" })
+    return { action: "noop", localVersion, remoteVersion }
+  }
+
+  writeCache(XP_GATE_CACHE_FILE, { ts: Date.now(), localVersion, remoteVersion })
+  try {
+    execSync(`npm install -g ${XP_GATE_NPM_PKG}@${remoteVersion}`, { stdio: "pipe", timeout: 120_000 })
+    writeCache(XP_GATE_CACHE_FILE, { ts: Date.now(), localVersion: remoteVersion, remoteVersion, status: "current" })
+    return { action: "upgraded", localVersion, remoteVersion }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    return { action: "error", localVersion, remoteVersion, error: msg }
+  }
+}
+
+// ── OpenCode plugin version check (notification only) ──
+
+async function checkPluginUpdate(pluginDir: string): Promise<void> {
+  const cached = readCache(OPENCODE_CACHE_FILE)
+  if (cached?.status === "current" && cached.remoteVersion) return
+
+  let localVersion = ""
+  try {
+    const pkg = JSON.parse(readFileSync(join(pluginDir, "package.json"), "utf8"))
+    localVersion = pkg.version || ""
+  } catch {
+    return
+  }
+
+  const remoteVersion = await fetchNpmLatestVersion(OPENCODE_PLUGIN_REGISTRY)
+  if (!remoteVersion) return
+
+  if (remoteVersion && localVersion && semverLt(localVersion, remoteVersion)) {
+    writeCache(OPENCODE_CACHE_FILE, { ts: Date.now(), localVersion, remoteVersion })
+  } else if (remoteVersion && localVersion) {
+    writeCache(OPENCODE_CACHE_FILE, { ts: Date.now(), localVersion, remoteVersion, status: "current" })
+  }
+}
+
+// ── Combined background check (runs once on first chat.message) ──
+
+async function runBackgroundUpdates(pluginDir: string): Promise<string | null> {
+  const result = await checkXpGateUpdate()
+  await checkPluginUpdate(pluginDir)
+
+  if (result.action === "upgraded") {
+    return `[XP-Gate] Auto-upgraded from v${result.localVersion} to v${result.remoteVersion}`
+  }
+  if (result.action === "error") {
+    return `[XP-Gate] Upgrade check: v${result.remoteVersion} available (auto-upgrade failed: ${result.error})`
+  }
+  return null
+}
+
 async function runCmd(cmd: string, cwd: string): Promise<string> {
   try {
     const { stdout } = await execAsync(cmd, { cwd, timeout: 30000 })
@@ -49,77 +201,6 @@ async function getUpgradeSuggestion(cwd: string): Promise<string> {
   }
 }
 
-// ── Auto-update check for opencode-plugin ──
-
-const CACHE_TTL_MS = 86_400_000
-const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/@boyingliu01%2Fopencode-plugin/dist-tags"
-const FETCH_TIMEOUT_MS = 5_000
-const CACHE_FILE = join(homedir(), ".xp-gate", "opencode-plugin-version-check.json")
-
-let checked = false
-let checkInFlight: Promise<void> | null = null
-
-function semverLt(a: string, b: string): boolean {
-  const pa = a.replace(/^v/, "").split(".").map(Number)
-  const pb = b.replace(/^v/, "").split(".").map(Number)
-  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-    const na = pa[i] ?? 0
-    const nb = pb[i] ?? 0
-    if (na !== nb) return na < nb
-  }
-  return false
-}
-
-async function checkPluginUpdate(pluginDir: string): Promise<void> {
-  if (checkInFlight) return
-
-  checkInFlight = (async () => {
-    try {
-      mkdirSync(join(homedir(), ".xp-gate"), { recursive: true })
-
-      if (existsSync(CACHE_FILE)) {
-        const cached = JSON.parse(readFileSync(CACHE_FILE, "utf8"))
-        if (Date.now() - cached.ts < CACHE_TTL_MS) return
-      }
-
-      let localVersion = ""
-      try {
-        const pkg = JSON.parse(readFileSync(join(pluginDir, "package.json"), "utf8"))
-        localVersion = pkg.version || ""
-      } catch {
-        return
-      }
-
-      const controller = new AbortController()
-      const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS)
-      try {
-        const response = await fetch(NPM_REGISTRY_URL, { signal: controller.signal })
-        if (!response.ok) return
-        const data: Record<string, unknown> = await response.json()
-        const remoteVersion = String(data.latest || "")
-
-        if (remoteVersion && localVersion && semverLt(localVersion, remoteVersion)) {
-          writeFileSync(CACHE_FILE, JSON.stringify({ ts: Date.now(), localVersion, remoteVersion }))
-          process.stderr.write(
-            `[XP-Gate] New opencode-plugin version v${remoteVersion} available (you have v${localVersion})\n` +
-            `[XP-Gate] Update with: cd ~/.config/opencode && npm update @boyingliu01/opencode-plugin\n`
-          )
-        } else if (remoteVersion && localVersion) {
-          // Cache "up to date" to avoid re-fetching every session
-          writeFileSync(CACHE_FILE, JSON.stringify({ ts: Date.now(), localVersion, remoteVersion, status: "current" }))
-        }
-      } finally {
-        clearTimeout(timer)
-      }
-    } catch {
-      // All errors silently ignored
-    }
-  })()
-
-  await checkInFlight
-  checkInFlight = null
-}
-
 // ── Plugin definition ──
 
 export const XpGatePlugin = async (input: OpenCodePluginInput) => {
@@ -184,7 +265,9 @@ export const XpGatePlugin = async (input: OpenCodePluginInput) => {
     "chat.message": async (_input: { message: string }) => {
       if (!checked) {
         checked = true
-        checkPluginUpdate(directory).catch((_err) => { /* silent: non-critical background check */ })
+        runBackgroundUpdates(directory).then((msg) => {
+          if (msg) process.stderr.write(`${msg}\n`)
+        })
       }
       return { action: "continue" }
     },

package/plugins/opencode/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@boyingliu01/opencode-plugin",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "type": "module",
   "main": "index.ts",
-  "description": "XP-Gate quality gates + AI workflow skills for OpenCode",
+  "description": "XP-Gate quality gates + AI workflow skills + Sprint Flow TUI sidebar for OpenCode",
   "repository": {
     "type": "git",
     "url": "https://github.com/boyingliu01/xp-gate",
@@ -13,8 +13,19 @@
     "registry": "https://registry.npmjs.org",
     "access": "public"
   },
+  "exports": {
+    ".": {
+      "import": "./index.ts",
+      "types": "./index.ts"
+    },
+    "./tui": {
+      "import": "./tui-plugin.ts",
+      "types": "./tui-plugin.ts"
+    }
+  },
   "files": [
     "index.ts",
+    "tui-plugin.ts",
     "skills/",
     "tsconfig.json",
     "README.md"
@@ -24,7 +35,7 @@
     "check": "tsc --noEmit"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "^1.15.0"
+    "@opencode-ai/plugin": "^1.17.8"
   },
   "devDependencies": {
     "typescript": "^5.4.0"

package/plugins/opencode/skills/delphi-review/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
 **Generated:** 2026-06-18
-**Commit:** 33cf3f2
+**Commit:** b67fc85
 **Branch:** main
-**Version:** 0.9.1.0
+**Version:** 0.9.3.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/plugins/opencode/skills/sprint-flow/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/SPRINT-FLOW KNOWLEDGE BASE
 
 **Generated:** 2026-06-18
-**Commit:** 33cf3f2
+**Commit:** b67fc85
 **Branch:** main
-**Version:** 0.9.1.0
+**Version:** 0.9.3.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/plugins/opencode/skills/test-specification-alignment/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/TEST-SPECIFICATION-ALIGNMENT KNOWLEDGE BASE
 
 **Generated:** 2026-06-18
-**Commit:** 33cf3f2
+**Commit:** b67fc85
 **Branch:** main
-**Version:** 0.9.1.0
+**Version:** 0.9.3.0
 
 ## OVERVIEW
 Test-Specification Alignment Engine — two-stage validation ensuring tests accurately reflect requirements and design specs.

package/plugins/opencode/tsconfig.json

@@ -10,6 +10,6 @@
     "declaration": false,
     "noEmit": true
   },
-  "include": ["index.ts"],
+  "include": ["index.ts", "tui-plugin.ts"],
   "exclude": ["node_modules", "dist", "skills"]
 }