opencode-agent-skill 13.0.0-beta.2 → 14.2.0-beta.1

package/scripts/smoke-package-closure.mjs

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict"
+import { existsSync, readFileSync } from "node:fs"
+import path from "node:path"
+import { spawnSync } from "node:child_process"
+import { fileURLToPath } from "node:url"
+import { resolveWindowsCommand } from "../lib/windows-shim.mjs"
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+
+function run(executable, args, options = {}) {
+  if (process.platform !== "win32") return spawnSync(executable, args, options)
+  const resolved = resolveWindowsCommand(executable)
+  if (!resolved) {
+    return { status: 127, stdout: "", stderr: "Unable to resolve Windows command: " + executable }
+  }
+  return spawnSync(resolved.executable, [...resolved.argsPrefix, ...args], options)
+}
+
+function parseJsonOutput(result, label) {
+  assert.equal(result.status, 0, label + " failed: " + String(result.stderr || result.stdout || ""))
+  return JSON.parse(String(result.stdout || "").trim())
+}
+
+const packed = parseJsonOutput(
+  run("npm", ["pack", "--dry-run", "--json", "--ignore-scripts"], {
+    cwd: root,
+    encoding: "utf8",
+    maxBuffer: 8 * 1024 * 1024,
+  }),
+  "npm pack --dry-run",
+)
+
+assert.ok(Array.isArray(packed) && packed.length >= 1, "npm pack did not return package metadata")
+const files = new Set((packed[0].files || []).map((entry) => String(entry.path).replaceAll("\\", "/")))
+
+for (const required of [
+  "bin/ocskill.mjs",
+  "pi/extensions/ues.ts",
+  "pi/extensions/ues-child-runtime.ts",
+  "docs/V14.2-TURBO-WEAK-MODEL-RUNTIME.md",
+  "lib/process-supervisor.mjs",
+  "lib/pi-rpc-pool.mjs",
+  "lib/adaptive-context-budget.mjs",
+  "lib/skill-compiler.mjs",
+  "lib/affected-tests.mjs",
+  "lib/verification-broker.mjs",
+  "lib/verification-command.mjs",
+  "lib/task-policy.mjs",
+  "lib/model-policy.mjs",
+  "lib/context-engine-v11.mjs",
+  "lib/runtime-config.mjs",
+  "scripts/eval-pi.mjs",
+  "scripts/eval-report.mjs",
+  "evals/live/tasks.json",
+  "global-config/AGENTS.md",
+  "global-config/commands/run.md",
+  "global-config/plugins/ues-router/index.js",
+]) {
+  assert.ok(files.has(required), "packed package is missing required runtime file: " + required)
+}
+
+const controllerStat = (packed[0].files || []).find((entry) => String(entry.path).replaceAll("\\", "/") === "pi/extensions/ues.ts")
+assert.ok(Number(controllerStat?.size || 0) > 80_000, "packed UES controller appears truncated")
+
+const childRuntimeStat = (packed[0].files || []).find((entry) => String(entry.path).replaceAll("\\", "/") === "pi/extensions/ues-child-runtime.ts")
+assert.ok(Number(childRuntimeStat?.size || 0) > 6_000, "packed UES child runtime appears truncated")
+
+const codeFiles = [...files].filter((file) => /\.(?:mjs|js|ts)$/.test(file))
+const missingRelativeImports = []
+
+function resolvePackedImport(fromFile, specifier) {
+  const base = path.posix.normalize(path.posix.join(path.posix.dirname(fromFile), specifier))
+  const candidates = path.posix.extname(base)
+    ? [base]
+    : [base, base + ".mjs", base + ".js", base + ".ts", path.posix.join(base, "index.mjs"), path.posix.join(base, "index.js")]
+  return candidates.find((candidate) => existsSync(path.join(root, ...candidate.split("/")))) || null
+}
+
+for (const file of codeFiles) {
+  const absolute = path.join(root, ...file.split("/"))
+  if (!existsSync(absolute)) continue
+  const source = readFileSync(absolute, "utf8")
+  const regex = /(?:\bfrom\s+|\bimport\s*\(\s*|\bimport\s+)[\"'](\.{1,2}\/[^\"']+)[\"']/g
+  let match
+  while ((match = regex.exec(source))) {
+    const resolved = resolvePackedImport(file, match[1])
+    if (resolved && !files.has(resolved)) {
+      missingRelativeImports.push({ from: file, import: match[1], resolved })
+    }
+  }
+}
+
+assert.deepEqual(
+  missingRelativeImports,
+  [],
+  "packed runtime has relative imports to files excluded from npm package: " + JSON.stringify(missingRelativeImports),
+)
+
+const taskPolicy = parseJsonOutput(
+  run(process.execPath, [path.join(root, "bin", "ocskill.mjs"), "task-policy", "fix a high-risk authentication bug", "--json"], {
+    cwd: root,
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024,
+  }),
+  "packaged task-policy smoke",
+)
+assert.equal(taskPolicy.risk, "high")
+assert.equal(taskPolicy.modelTier, "heavy")
+
+console.log(`Package closure smoke passed: ${files.size} packed file(s), ${codeFiles.length} code file(s) checked`)

package/scripts/smoke-packed-install.mjs

@@ -38,6 +38,7 @@ const temp = await mkdtemp(path.join(os.tmpdir(), "ocskill-pack-smoke-"))
 const packDir = path.join(temp, "pack")
 const prefix = path.join(temp, "prefix")
 const configDir = path.join(temp, "opencode")
+const uesConfigDir = path.join(temp, "ues-config")
 
 try {
   await mkdir(packDir, { recursive: true })
@@ -49,19 +50,13 @@ try {
   assert.equal(tarballs.length, 1, "expected exactly one packed tarball")
   const tarball = path.join(packDir, tarballs[0])
 
-  const npmVersion = runNpm(["--version"], { cwd: temp })
-  requireSuccess(npmVersion, "npm --version")
-  const npmMajor = Number.parseInt(npmVersion.stdout.trim().split(".")[0], 10)
-  const installArgs = ["install", "-g", tarball, "--prefix", prefix]
-  if (Number.isFinite(npmMajor) && npmMajor >= 11) {
-    installArgs.push(`--allow-scripts=${packageName}`)
-  }
+  const installArgs = ["install", "-g", tarball, "--prefix", prefix, "--ignore-scripts"]
 
   const install = runNpm(installArgs, {
     cwd: temp,
-    env: { ...process.env, OPENCODE_CONFIG_DIR: configDir, UES_OPENCODE_MAJOR: "2" },
+    env: process.env,
   })
-  requireSuccess(install, "packed global install with automatic OpenCode sync")
+  requireSuccess(install, "packed global install")
 
   const root = runNpm(["root", "-g", "--prefix", prefix], { cwd: temp })
   requireSuccess(root, "npm root -g")
@@ -81,7 +76,19 @@ try {
   assert.equal(packageJson.name, packageName)
 
   const cli = path.join(packageDir, "bin", "ocskill.mjs")
-  const env = { ...process.env, OPENCODE_CONFIG_DIR: configDir }
+  const env = {
+    ...process.env,
+    OPENCODE_CONFIG_DIR: configDir,
+    UES_CONFIG_DIR: uesConfigDir,
+    UES_OPENCODE_MAJOR: "2",
+  }
+
+  const sync = spawnSync(process.execPath, [cli, "install"], {
+    cwd: temp,
+    env,
+    encoding: "utf8",
+  })
+  requireSuccess(sync, "explicit legacy OpenCode sync from packed copy")
 
   const status = spawnSync(process.execPath, [cli, "status"], {
     cwd: temp,
@@ -470,7 +477,13 @@ try {
     encoding: "utf8",
   })
   requireSuccess(modelStatus, "ocskill models status from packed copy")
-  assert.match(modelStatus.stdout, /"enabled": false/)
+  const initialModelStatus = JSON.parse(modelStatus.stdout)
+  assert.equal(initialModelStatus.enabled, false)
+  assert.equal(
+    path.resolve(initialModelStatus.file),
+    path.resolve(uesConfigDir, ".ues", "model-policy.json"),
+    "packed smoke must not read the user's real UES model policy",
+  )
 
   const modelSet = spawnSync(process.execPath, [cli, "models", "set", "standard", "provider/mid"], {
     cwd: temp,

package/scripts/smoke-pi-extension.mjs

@@ -0,0 +1,144 @@
+import assert from "node:assert/strict"
+import { existsSync } from "node:fs"
+import { mkdtemp, rm } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { spawnSync } from "node:child_process"
+import { pathToFileURL, fileURLToPath } from "node:url"
+import { resolveWindowsCommand } from "../lib/windows-shim.mjs"
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const extensionPath = path.join(root, "pi", "extensions", "ues.ts")
+const childRuntimeExtensionPath = path.join(root, "pi", "extensions", "ues-child-runtime.ts")
+const skillsPath = path.join(root, "global-config", "skills")
+const promptsPath = path.join(root, "pi", "prompts")
+const agentDir = path.join(root, ".tmp-pi-agent")
+const PI_SMOKE_VERSION = process.env.UES_PI_SMOKE_VERSION || "0.87.1"
+const TYPEBOX_SMOKE_VERSION = process.env.UES_TYPEBOX_SMOKE_VERSION || "1.3.27"
+
+function sanitizedNpmChildEnv(base = process.env) {
+  return Object.fromEntries(
+    Object.entries(base).filter(([key]) => key.toLowerCase() !== "npm_config_allow_scripts"),
+  )
+}
+
+function run(executable, args, options = {}) {
+  const spawnOptions = executable === "npm"
+    ? { ...options, env: sanitizedNpmChildEnv(options.env || process.env) }
+    : options
+
+  if (process.platform !== "win32") return spawnSync(executable, args, spawnOptions)
+  const resolved = resolveWindowsCommand(executable)
+  if (!resolved) return { status: 127, stdout: "", stderr: "Unable to resolve command: " + executable }
+  return spawnSync(resolved.executable, [...resolved.argsPrefix, ...args], spawnOptions)
+}
+
+async function importSdkFromDir(nodeModulesRoot) {
+  const entry = path.join(
+    nodeModulesRoot,
+    "@earendil-works",
+    "pi-coding-agent",
+    "dist",
+    "index.js",
+  )
+  if (!existsSync(entry)) return null
+  return import(pathToFileURL(entry).href)
+}
+
+async function loadPiSdk() {
+  try {
+    return {
+      sdk: await import("@earendil-works/pi-coding-agent"),
+      source: "local-node-modules",
+      tempDir: null,
+    }
+  } catch (error) {
+    if (error?.code !== "ERR_MODULE_NOT_FOUND") throw error
+  }
+
+  const globalRoot = run("npm", ["root", "-g"], { encoding: "utf8" })
+  if (globalRoot.status === 0) {
+    const sdk = await importSdkFromDir(String(globalRoot.stdout || "").trim())
+    if (sdk) return { sdk, source: "global-npm", tempDir: null }
+  }
+
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), "ues-pi-smoke-host-"))
+  const installed = run(
+    "npm",
+    [
+      "install",
+      "--ignore-scripts",
+      "--no-package-lock",
+      "--no-save",
+      `@earendil-works/pi-coding-agent@${PI_SMOKE_VERSION}`,
+      `typebox@${TYPEBOX_SMOKE_VERSION}`,
+    ],
+    {
+      cwd: tempDir,
+      encoding: "utf8",
+      maxBuffer: 8 * 1024 * 1024,
+    },
+  )
+
+  if (installed.status !== 0) {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {})
+    throw new Error(
+      "Unable to provision Pi SDK for smoke test:\n" +
+      String(installed.stderr || installed.stdout || "npm install failed"),
+    )
+  }
+
+  const sdk = await importSdkFromDir(path.join(tempDir, "node_modules"))
+  if (!sdk) {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {})
+    throw new Error("Provisioned Pi SDK is missing dist/index.js")
+  }
+  return { sdk, source: "isolated-temp-install", tempDir }
+}
+
+const loaded = await loadPiSdk()
+const { DefaultResourceLoader } = loaded.sdk
+
+try {
+  const loader = new DefaultResourceLoader({
+    cwd: root,
+    agentDir,
+    additionalExtensionPaths: [extensionPath, childRuntimeExtensionPath],
+    additionalSkillPaths: [skillsPath],
+    additionalPromptTemplatePaths: [promptsPath],
+  })
+
+  await loader.reload()
+  const result = loader.getExtensions()
+
+  assert.equal(
+    result.errors.length,
+    0,
+    result.errors.map((entry) => `${entry.path}: ${entry.error}`).join("\n"),
+  )
+  assert.ok(result.extensions.length >= 2, "Pi did not load the UES controller + child runtime extensions")
+
+  const skillResult = loader.getSkills()
+  assert.equal(
+    skillResult.diagnostics.length,
+    0,
+    skillResult.diagnostics.map((entry) => `${entry.path || entry.filePath || "skill"}: ${entry.message || entry.error || JSON.stringify(entry)}`).join("\n"),
+  )
+  assert.ok(skillResult.skills.length >= 40, "Pi did not load the bundled UES skills")
+
+  const promptResult = loader.getPrompts()
+  assert.equal(
+    promptResult.diagnostics.length,
+    0,
+    promptResult.diagnostics.map((entry) => `${entry.path || entry.filePath || "prompt"}: ${entry.message || entry.error || JSON.stringify(entry)}`).join("\n"),
+  )
+  assert.ok(promptResult.prompts.length >= 11, "Pi did not load the bundled UES prompts")
+
+  console.log(
+    `Pi package smoke passed via ${loaded.source}: ${result.extensions.length} extension(s), ${skillResult.skills.length} skill(s), ${promptResult.prompts.length} prompt(s) loaded`,
+  )
+} finally {
+  if (loaded.tempDir) {
+    await rm(loaded.tempDir, { recursive: true, force: true }).catch(() => {})
+  }
+}

package/scripts/uninstall.mjs

@@ -1,5 +1,49 @@
+import { spawnSync } from "node:child_process"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
 import { removeResources } from "../lib/installer.mjs"
 
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const normalizedRoot = packageRoot.replaceAll("\\", "/").toLowerCase()
+
+function isPiPackageInstall() {
+  return [
+    "/.pi/agent/git/",
+    "/.pi/agent/npm/",
+    "/.pi/git/",
+    "/.pi/npm/",
+  ].some((marker) => normalizedRoot.includes(marker))
+}
+
+function npmGlobalPrefix() {
+  if (process.platform === "win32") {
+    const result = spawnSync(
+      process.env.ComSpec || "cmd.exe",
+      ["/d", "/s", "/c", "npm prefix -g"],
+      { encoding: "utf8" },
+    )
+    return result.status === 0 ? result.stdout?.trim() : null
+  }
+
+  const result = spawnSync("npm", ["prefix", "-g"], { encoding: "utf8" })
+  return result.status === 0 ? result.stdout?.trim() : null
+}
+
+function isGlobalInstall() {
+  if (process.env.npm_config_global === "true" || process.env.npm_config_global === "1") {
+    return true
+  }
+
+  const prefix = npmGlobalPrefix()
+  if (!prefix) return false
+  return packageRoot.toLowerCase().startsWith(path.resolve(prefix).toLowerCase())
+}
+
+if (isPiPackageInstall() || !isGlobalInstall()) {
+  console.log("[ocskill] Non-global/Pi package uninstall detected; leaving OpenCode resources untouched.")
+  process.exit(0)
+}
+
 try {
   const result = await removeResources()
   for (const warning of result.warnings || []) {