opencode-agent-skill 7.7.0

package/lib/task-graph.mjs

@@ -0,0 +1,262 @@
+import path from "node:path"
+
+const VALID_RISKS = new Set(["low", "medium", "high", "critical"])
+
+function unsafeRepoPath(value) {
+  const raw = String(value || "").replaceAll("\\", "/")
+  if (!raw) return false
+  if (path.posix.isAbsolute(raw) || /^[A-Za-z]:\//.test(raw)) return true
+  const normalized = path.posix.normalize(raw).replace(/^\.\//, "")
+  return normalized === ".." || normalized.startsWith("../")
+}
+
+function normalizeFile(value) {
+  if (unsafeRepoPath(value)) return ""
+  const normalized = path.posix
+    .normalize(String(value || "").replaceAll("\\", "/"))
+    .replace(/^\.\//, "")
+  return normalized === "." ? "" : normalized
+}
+
+export function taskFiles(task) {
+  const files = task?.files
+  if (Array.isArray(files)) return [...new Set(files.map(normalizeFile).filter(Boolean))].sort()
+  if (!files || typeof files !== "object") return []
+
+  const values = []
+  for (const key of ["create", "modify", "test", "delete", "read"]) {
+    if (!Array.isArray(files[key])) continue
+    values.push(...files[key])
+  }
+  return [...new Set(values.map(normalizeFile).filter(Boolean))].sort()
+}
+
+export function taskWriteFiles(task) {
+  const files = task?.files
+  if (Array.isArray(files)) return taskFiles(task)
+  if (!files || typeof files !== "object") return []
+  const values = []
+  for (const key of ["create", "modify", "test", "delete"]) {
+    if (Array.isArray(files[key])) values.push(...files[key])
+  }
+  return [...new Set(values.map(normalizeFile).filter(Boolean))].sort()
+}
+
+export function taskReadFiles(task) {
+  const files = task?.files
+  if (!files || Array.isArray(files) || typeof files !== "object") return []
+  return [...new Set((files.read || []).map(normalizeFile).filter(Boolean))].sort()
+}
+
+function taskMap(plan) {
+  return new Map((plan?.tasks || []).map((task) => [task.id, task]))
+}
+
+export function validatePlan(plan) {
+  const errors = []
+  const warnings = []
+
+  if (!plan || typeof plan !== "object" || Array.isArray(plan)) {
+    return { valid: false, errors: ["plan must be a JSON object"], warnings }
+  }
+  if (plan.schemaVersion !== 1) errors.push("schemaVersion must be 1")
+  if (!String(plan.goal || "").trim()) errors.push("goal must be a non-empty string")
+  if (!Array.isArray(plan.tasks) || plan.tasks.length === 0) {
+    errors.push("tasks must be a non-empty array")
+    return { valid: false, errors, warnings }
+  }
+
+  const ids = new Set()
+  for (const [index, task] of plan.tasks.entries()) {
+    const prefix = `tasks[${index}]`
+    if (!task || typeof task !== "object" || Array.isArray(task)) {
+      errors.push(`${prefix} must be an object`)
+      continue
+    }
+
+    const id = String(task.id || "").trim()
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(id)) {
+      errors.push(`${prefix}.id must use letters, numbers, dot, underscore or dash`)
+    } else if (ids.has(id)) {
+      errors.push(`duplicate task id: ${id}`)
+    } else {
+      ids.add(id)
+    }
+
+    if (!String(task.title || "").trim()) errors.push(`${prefix}.title is required`)
+    if (!String(task.summary || "").trim()) warnings.push(`${id || prefix}: summary is empty`)
+
+    const deps = task.dependsOn ?? []
+    if (!Array.isArray(deps)) errors.push(`${id || prefix}.dependsOn must be an array`)
+    else if (deps.includes(id)) errors.push(`${id}: task cannot depend on itself`)
+
+    if (!Array.isArray(task.acceptance) || task.acceptance.length === 0) {
+      errors.push(`${id || prefix}: acceptance must contain at least one observable criterion`)
+    }
+    if (!Array.isArray(task.verification) || task.verification.length === 0) {
+      errors.push(`${id || prefix}: verification must contain at least one concrete check`)
+    }
+
+    const risk = task.risk ?? "medium"
+    if (!VALID_RISKS.has(risk)) errors.push(`${id || prefix}: invalid risk '${risk}'`)
+
+    const rawFiles = task.files
+    const rawValues = Array.isArray(rawFiles)
+      ? rawFiles
+      : rawFiles && typeof rawFiles === "object"
+        ? ["create", "modify", "test", "delete", "read"].flatMap((key) => Array.isArray(rawFiles[key]) ? rawFiles[key] : [])
+        : []
+    for (const file of rawValues) {
+      if (unsafeRepoPath(file)) errors.push(`${id || prefix}: file scope must stay inside the repository: ${file}`)
+    }
+
+    const files = taskFiles(task)
+    if (files.length === 0) warnings.push(`${id || prefix}: no files declared; parallel scheduling will be conservative`)
+  }
+
+  const map = taskMap(plan)
+  for (const task of plan.tasks) {
+    if (!task?.id || !Array.isArray(task.dependsOn)) continue
+    for (const dep of task.dependsOn) {
+      if (!map.has(dep)) errors.push(`${task.id}: unknown dependency '${dep}'`)
+    }
+  }
+
+  const cycle = findCycle(plan)
+  if (cycle.length) errors.push(`dependency cycle: ${cycle.join(" -> ")}`)
+
+  return { valid: errors.length === 0, errors, warnings }
+}
+
+function findCycle(plan) {
+  const map = taskMap(plan)
+  const visiting = new Set()
+  const visited = new Set()
+  const stack = []
+
+  function visit(id) {
+    if (visiting.has(id)) {
+      const start = stack.indexOf(id)
+      return [...stack.slice(start), id]
+    }
+    if (visited.has(id)) return []
+
+    visiting.add(id)
+    stack.push(id)
+    for (const dep of map.get(id)?.dependsOn || []) {
+      const cycle = visit(dep)
+      if (cycle.length) return cycle
+    }
+    stack.pop()
+    visiting.delete(id)
+    visited.add(id)
+    return []
+  }
+
+  for (const id of map.keys()) {
+    const cycle = visit(id)
+    if (cycle.length) return cycle
+  }
+  return []
+}
+
+function overlaps(taskA, taskB) {
+  const allA = taskFiles(taskA)
+  const allB = taskFiles(taskB)
+  if (allA.length === 0 || allB.length === 0) return true
+
+  const writeA = new Set(taskWriteFiles(taskA))
+  const writeB = new Set(taskWriteFiles(taskB))
+  const readA = new Set(taskReadFiles(taskA))
+  const readB = new Set(taskReadFiles(taskB))
+
+  if ([...writeA].some((file) => writeB.has(file) || readB.has(file))) return true
+  if ([...writeB].some((file) => readA.has(file))) return true
+  return false
+}
+
+export function computeTopologicalWaves(plan) {
+  const validation = validatePlan(plan)
+  if (!validation.valid) {
+    const error = new Error("invalid task plan")
+    error.validation = validation
+    throw error
+  }
+
+  const map = taskMap(plan)
+  const complete = new Set()
+  const remaining = new Set(map.keys())
+  const waves = []
+
+  while (remaining.size) {
+    const ready = [...remaining]
+      .filter((id) => (map.get(id).dependsOn || []).every((dep) => complete.has(dep)))
+      .sort()
+
+    if (ready.length === 0) throw new Error("task graph cannot make progress")
+    waves.push(ready)
+    for (const id of ready) {
+      remaining.delete(id)
+      complete.add(id)
+    }
+  }
+  return waves
+}
+
+export function computeSafeWaves(plan) {
+  const validation = validatePlan(plan)
+  if (!validation.valid) {
+    const error = new Error("invalid task plan")
+    error.validation = validation
+    throw error
+  }
+
+  const map = taskMap(plan)
+  const complete = new Set()
+  const remaining = new Set(map.keys())
+  const waves = []
+  const serialized = []
+
+  while (remaining.size) {
+    const ready = [...remaining]
+      .filter((id) => (map.get(id).dependsOn || []).every((dep) => complete.has(dep)))
+      .sort()
+
+    if (ready.length === 0) throw new Error("task graph cannot make progress")
+
+    const selected = []
+    for (const id of ready) {
+      const task = map.get(id)
+      const conflict = selected.find((otherID) => overlaps(task, map.get(otherID)))
+      if (conflict) {
+        serialized.push({ task: id, conflictsWith: conflict, reason: "declared write/read conflict or unknown file scope" })
+        continue
+      }
+      selected.push(id)
+    }
+
+    if (selected.length === 0) selected.push(ready[0])
+    waves.push(selected)
+    for (const id of selected) {
+      remaining.delete(id)
+      complete.add(id)
+    }
+  }
+
+  return { waves, serialized }
+}
+
+export function analyzePlan(plan) {
+  const validation = validatePlan(plan)
+  if (!validation.valid) return { ...validation, topologicalWaves: [], safeWaves: [], serialized: [] }
+
+  const topologicalWaves = computeTopologicalWaves(plan)
+  const safe = computeSafeWaves(plan)
+  return {
+    ...validation,
+    topologicalWaves,
+    safeWaves: safe.waves,
+    serialized: safe.serialized,
+    taskCount: plan.tasks.length,
+  }
+}

package/lib/update-resolver.mjs

@@ -0,0 +1,43 @@
+function parseJsonString(stdout) {
+  try {
+    const value = JSON.parse(String(stdout || "").trim())
+    return typeof value === "string" && value ? value : null
+  } catch {
+    return null
+  }
+}
+
+function parseLatestTag(stdout) {
+  for (const line of String(stdout || "").split(/\r?\n/)) {
+    const match = line.trim().match(/^latest:\s*(\S+)$/)
+    if (match) return match[1]
+  }
+  return null
+}
+
+export function resolveLatestPublishedVersion({ runCapture, packageName, cwd }) {
+  const direct = runCapture(
+    "npm",
+    ["view", `${packageName}@latest`, "version", "--json"],
+    { cwd },
+  )
+  if (direct.status === 0) {
+    const version = parseJsonString(direct.stdout)
+    if (version) return { version, source: "view@latest" }
+  }
+
+  const tags = runCapture("npm", ["dist-tag", "ls", packageName], { cwd })
+  if (tags.status === 0) {
+    const version = parseLatestTag(tags.stdout)
+    if (version) return { version, source: "dist-tag" }
+  }
+
+  const detail = [direct.stderr, direct.stdout, tags.stderr, tags.stdout]
+    .map((value) => String(value || "").trim())
+    .filter(Boolean)
+    .join("\n")
+
+  const error = new Error("Could not resolve npm latest dist-tag safely." + (detail ? "\n" + detail : ""))
+  error.exitCode = direct.status || tags.status || 1
+  throw error
+}

package/lib/verification-plan.mjs

@@ -0,0 +1,52 @@
+import path from "node:path"
+import { detectStack, detectTestCommands, checkWorkingTree } from "./repo-inspect.mjs"
+import { reviewScope } from "./review-scope.mjs"
+
+export async function buildVerificationPlan(root = process.cwd(), base = null) {
+  root = path.resolve(root)
+  const [stack, commands, workingTree] = await Promise.all([
+    detectStack(root),
+    detectTestCommands(root),
+    checkWorkingTree(root),
+  ])
+  const scope = reviewScope(root, base)
+
+  const recommended = []
+  const add = (kind, command, reason) => {
+    if (!command || recommended.some((item) => item.command === command)) return
+    recommended.push({ kind, command, reason })
+  }
+
+  for (const item of commands) {
+    if (["test", "typecheck", "check", "lint", "build", "analyze", "ci"].includes(item.kind)) {
+      add(item.kind, item.command, "project-native " + item.kind + " command from " + item.source)
+    }
+  }
+
+  if (scope.git && ["high", "critical"].includes(scope.overallRisk)) {
+    add("diff-review", "git diff --check", "high-risk changes require whitespace/conflict-marker sanity")
+  }
+
+  const acceptancePrompts = []
+  if (scope.git) {
+    for (const file of scope.files) {
+      for (const reason of file.risk.reasons) {
+        if (reason === "auth/security") acceptancePrompts.push("Verify denied/unauthorized cases, not only the happy path.")
+        if (reason === "payment") acceptancePrompts.push("Verify idempotency/retry/state-transition behavior with negative cases.")
+        if (reason === "persistence/schema") acceptancePrompts.push("Verify migration compatibility, existing rows, rollback/roll-forward behavior.")
+        if (reason === "public/interface") acceptancePrompts.push("Verify producers and consumers of changed contracts.")
+        if (reason === "delivery/infrastructure") acceptancePrompts.push("Verify configuration/deployment behavior in a representative environment.")
+      }
+    }
+  }
+
+  return {
+    schemaVersion: 1,
+    root,
+    stack,
+    workingTree,
+    scope,
+    recommended,
+    acceptancePrompts: [...new Set(acceptancePrompts)],
+  }
+}

package/lib/version.mjs

@@ -0,0 +1,47 @@
+function parse(value) {
+  const match = String(value).trim().match(
+    /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/,
+  )
+  if (!match) throw new Error(`Invalid semantic version: ${value}`)
+
+  return {
+    core: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4] ? match[4].split(".") : [],
+  }
+}
+
+function compareIdentifier(left, right) {
+  const leftNumber = /^\d+$/.test(left) ? Number(left) : null
+  const rightNumber = /^\d+$/.test(right) ? Number(right) : null
+
+  if (leftNumber !== null && rightNumber !== null) return Math.sign(leftNumber - rightNumber)
+  if (leftNumber !== null) return -1
+  if (rightNumber !== null) return 1
+  return left === right ? 0 : left < right ? -1 : 1
+}
+
+export function compareVersions(left, right) {
+  const a = parse(left)
+  const b = parse(right)
+
+  for (let index = 0; index < 3; index += 1) {
+    if (a.core[index] !== b.core[index]) {
+      return Math.sign(a.core[index] - b.core[index])
+    }
+  }
+
+  if (a.prerelease.length === 0 && b.prerelease.length === 0) return 0
+  if (a.prerelease.length === 0) return 1
+  if (b.prerelease.length === 0) return -1
+
+  const length = Math.max(a.prerelease.length, b.prerelease.length)
+  for (let index = 0; index < length; index += 1) {
+    if (a.prerelease[index] === undefined) return -1
+    if (b.prerelease[index] === undefined) return 1
+
+    const compared = compareIdentifier(a.prerelease[index], b.prerelease[index])
+    if (compared !== 0) return compared
+  }
+
+  return 0
+}

package/lib/workspace-snapshot.mjs

@@ -0,0 +1,45 @@
+import { createHash } from "node:crypto"
+import { readFile, readdir, stat } from "node:fs/promises"
+import path from "node:path"
+
+const SKIP = new Set([".git", "node_modules", ".next", "dist", "build", "coverage"])
+
+async function walk(root) {
+  const files = []
+  async function visit(dir) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => [])
+    for (const entry of entries) {
+      if (SKIP.has(entry.name)) continue
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) await visit(full)
+      else if (entry.isFile()) files.push(full)
+    }
+  }
+  await visit(root)
+  return files
+}
+
+export async function snapshotWorkspace(root) {
+  const snapshot = {}
+  for (const file of await walk(root)) {
+    const info = await stat(file).catch(() => null)
+    if (!info || info.size > 2 * 1024 * 1024) continue
+    const bytes = await readFile(file)
+    snapshot[path.relative(root, file)] = {
+      size: bytes.length,
+      sha256: createHash("sha256").update(bytes).digest("hex"),
+    }
+  }
+  return snapshot
+}
+
+export function diffWorkspaceSnapshots(before, after) {
+  const paths = new Set([...Object.keys(before), ...Object.keys(after)])
+  const changed = []
+  for (const file of [...paths].sort()) {
+    if (!before[file]) changed.push({ path: file, change: "added" })
+    else if (!after[file]) changed.push({ path: file, change: "removed" })
+    else if (before[file].sha256 !== after[file].sha256) changed.push({ path: file, change: "modified" })
+  }
+  return changed
+}

package/lib/worktree-sandbox.mjs

@@ -0,0 +1,59 @@
+import { existsSync } from "node:fs"
+import { mkdir, rm } from "node:fs/promises"
+import { spawnSync } from "node:child_process"
+import path from "node:path"
+
+function git(root, args) {
+  return spawnSync("git", args, { cwd: root, encoding: "utf8", maxBuffer: 4 * 1024 * 1024 })
+}
+
+function safeName(value) {
+  return String(value || "").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "")
+}
+
+export async function createTaskSandbox(root, slug, taskID, options = {}) {
+  root = path.resolve(root)
+  const base = options.baseDir
+    ? path.resolve(options.baseDir)
+    : path.join(path.dirname(root), "." + path.basename(root) + ".ues-sandboxes")
+  const name = safeName(slug + "-" + taskID)
+  if (!name) throw new Error("sandbox name is empty")
+  const dir = path.join(base, name)
+  if (existsSync(dir)) throw new Error("sandbox already exists: " + dir)
+
+  await mkdir(base, { recursive: true })
+  const branch = options.branch || "ues/" + name
+  const startPoint = options.startPoint || "HEAD"
+  const result = git(root, ["worktree", "add", "-b", branch, dir, startPoint])
+  if (result.status !== 0) throw new Error((result.stderr || result.stdout || "git worktree add failed").trim())
+
+  return { schemaVersion: 1, root, dir, branch, slug, taskID, startPoint }
+}
+
+export async function removeTaskSandbox(root, dir, options = {}) {
+  root = path.resolve(root)
+  dir = path.resolve(dir)
+  const result = git(root, ["worktree", "remove", ...(options.force ? ["--force"] : []), dir])
+  if (result.status !== 0 && existsSync(dir)) {
+    if (options.force) await rm(dir, { recursive: true, force: true })
+    else throw new Error((result.stderr || result.stdout || "git worktree remove failed").trim())
+  }
+  git(root, ["worktree", "prune"])
+  return { removed: !existsSync(dir), dir }
+}
+
+export function listTaskSandboxes(root) {
+  const result = git(path.resolve(root), ["worktree", "list", "--porcelain"])
+  if (result.status !== 0) throw new Error((result.stderr || result.stdout || "git worktree list failed").trim())
+  const items = []
+  let current = null
+  for (const line of result.stdout.split(/\r?\n/)) {
+    if (line.startsWith("worktree ")) {
+      if (current) items.push(current)
+      current = { path: line.slice(9) }
+    } else if (current && line.startsWith("HEAD ")) current.head = line.slice(5)
+    else if (current && line.startsWith("branch ")) current.branch = line.slice(7)
+  }
+  if (current) items.push(current)
+  return items
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "opencode-agent-skill",
+  "version": "7.7.0",
+  "description": "Adaptive crash-safe engineering runtime, durable orchestration, structured evidence, learning loop and control center for OpenCode",
+  "type": "module",
+  "bin": {
+    "ocskill": "bin/ocskill.mjs"
+  },
+  "files": [
+    "bin/ocskill.mjs",
+    "lib/",
+    "scripts/",
+    "global-config/",
+    "evals/",
+    "docs/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "syntax": "node scripts/syntax-check.mjs",
+    "validate": "node scripts/validate.mjs",
+    "evals": "node scripts/eval-skills.mjs",
+    "evals:live:validate": "node scripts/validate-live-suite.mjs",
+    "test": "node --test test/*.test.mjs",
+    "ci": "npm run syntax && npm run validate && npm run evals && npm run evals:router && npm run evals:live:validate && npm run evals:long:validate && npm test && npm pack --dry-run && npm run smoke:pack",
+    "postinstall": "node scripts/install.mjs",
+    "preuninstall": "node scripts/uninstall.mjs",
+    "prepublishOnly": "npm run ci",
+    "evals:live": "node scripts/eval-live.mjs",
+    "smoke:pack": "node scripts/smoke-packed-install.mjs",
+    "inspect:stack": "node scripts/detect-stack.mjs",
+    "inspect:tests": "node scripts/detect-test-commands.mjs",
+    "inspect:repo": "node scripts/repo-map.mjs",
+    "inspect:impact": "node scripts/impact-map.mjs",
+    "inspect:evidence": "node scripts/collect-evidence.mjs",
+    "inspect:git": "node scripts/check-working-tree.mjs",
+    "evals:report": "node scripts/eval-report.mjs",
+    "evals:router": "node scripts/eval-router.mjs",
+    "evals:long:validate": "node scripts/validate-live-suite.mjs --suite long",
+    "evals:long": "node scripts/eval-live.mjs --suite long",
+    "dashboard": "node scripts/control-center.mjs"
+  },
+  "keywords": [
+    "opencode",
+    "agent-skills",
+    "coding-agent",
+    "developer-tools",
+    "engineering-workflow",
+    "code-review",
+    "debugging",
+    "verification"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/laivannha0202/opencode-agent-skill-.git"
+  },
+  "homepage": "https://github.com/laivannha0202/opencode-agent-skill-#readme",
+  "bugs": {
+    "url": "https://github.com/laivannha0202/opencode-agent-skill-/issues"
+  },
+  "license": "MIT"
+}

package/scripts/check-working-tree.mjs

@@ -0,0 +1,2 @@
+import { checkWorkingTree } from "../lib/repo-inspect.mjs"
+console.log(JSON.stringify(await checkWorkingTree(process.argv[2] || process.cwd()), null, 2))

package/scripts/collect-evidence.mjs

@@ -0,0 +1,2 @@
+import { collectEvidence } from "../lib/repo-inspect.mjs"
+console.log(JSON.stringify(await collectEvidence(process.argv[2] || process.cwd()), null, 2))

package/scripts/control-center.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { createServer } from "node:http"
+import { readFile } from "node:fs/promises"
+import path from "node:path"
+import { collectControlCenterData, writeControlCenter } from "../lib/control-center.mjs"
+
+const args = process.argv.slice(2)
+const root = path.resolve(args[0] && !args[0].startsWith("--") ? args[0] : process.cwd())
+const outputIndex = args.indexOf("--output")
+const output = outputIndex >= 0 ? args[outputIndex + 1] : null
+const portIndex = args.indexOf("--port")
+const port = portIndex >= 0 ? Number.parseInt(args[portIndex + 1] || "4177", 10) : 4177
+const serve = args.includes("--serve")
+
+const result = await writeControlCenter(root, output)
+console.log("[ues] Control Center: " + result.file)
+
+if (serve) {
+  const server = createServer(async (req, res) => {
+    if (req.url === "/data.json") {
+      const current = await collectControlCenterData(root)
+      const body = JSON.stringify(current, null, 2) + "\n"
+      res.writeHead(200, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store",
+      })
+      res.end(body)
+      return
+    }
+    const body = await readFile(result.file)
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8" })
+    res.end(body)
+  })
+  server.listen(port, "127.0.0.1", () => {
+    console.log("[ues] Serving http://127.0.0.1:" + port)
+  })
+}

package/scripts/detect-stack.mjs

@@ -0,0 +1,2 @@
+import { detectStack } from "../lib/repo-inspect.mjs"
+console.log(JSON.stringify(await detectStack(process.argv[2] || process.cwd()), null, 2))

package/scripts/detect-test-commands.mjs

@@ -0,0 +1,2 @@
+import { detectTestCommands } from "../lib/repo-inspect.mjs"
+console.log(JSON.stringify(await detectTestCommands(process.argv[2] || process.cwd()), null, 2))