@hiai-gg/hiai-opencode 0.1.2 → 0.1.4

package/assets/cli/hiai-opencode.mjs

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process"
+import { existsSync, readFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { homedir } from "node:os"
+import { parse } from "jsonc-parser"
+
+const DEFAULT_RAG_URL = "http://localhost:9002/tools/search"
+
+const MCP_REGISTRY = {
+  playwright: {
+    defaultEnabled: true,
+    requiredEnv: [],
+    check: checkNodeNpx,
+  },
+  rag: {
+    defaultEnabled: true,
+    requiredEnv: [],
+    check: checkRag,
+  },
+  firecrawl: {
+    defaultEnabled: true,
+    requiredEnv: ["FIRECRAWL_API_KEY"],
+    authFallback: "firecrawl",
+    check: checkNodeNpx,
+  },
+  mempalace: {
+    defaultEnabled: true,
+    requiredEnv: [],
+    check: checkMempalace,
+  },
+  stitch: {
+    defaultEnabled: true,
+    requiredEnv: ["STITCH_AI_API_KEY"],
+    authFallback: "stitch",
+    check: checkRemoteKeyOnly,
+  },
+  context7: {
+    defaultEnabled: true,
+    requiredEnv: [],
+    check: checkRemoteOptionalKey,
+  },
+  "sequential-thinking": {
+    defaultEnabled: true,
+    requiredEnv: [],
+    check: checkNodeNpx,
+  },
+}
+
+function usage() {
+  console.log(`hiai-opencode
+
+Usage:
+  hiai-opencode mcp-status
+
+Commands:
+  mcp-status   Check hiai-opencode MCP configuration, keys, and local runtimes.
+`)
+}
+
+function resolveEnvTemplate(value) {
+  if (typeof value !== "string") return value
+  return value.replace(/\{env:([^}]+)\}/g, (_match, expression) => {
+    const [name, fallback] = String(expression).split(":-", 2)
+    return process.env[name] || fallback || ""
+  })
+}
+
+function candidateConfigPaths() {
+  const cwd = process.cwd()
+  const paths = [
+    join(cwd, "hiai-opencode.json"),
+    join(cwd, "hiai-opencode.jsonc"),
+    join(cwd, ".opencode", "hiai-opencode.json"),
+    join(cwd, ".opencode", "hiai-opencode.jsonc"),
+    join(homedir(), ".config", "opencode", "hiai-opencode.json"),
+    join(homedir(), ".config", "opencode", "hiai-opencode.jsonc"),
+  ]
+
+  if (process.platform === "win32" && process.env.APPDATA) {
+    paths.push(join(process.env.APPDATA, "opencode", "hiai-opencode.json"))
+    paths.push(join(process.env.APPDATA, "opencode", "hiai-opencode.jsonc"))
+  }
+
+  return paths
+}
+
+function loadConfig() {
+  for (const path of candidateConfigPaths()) {
+    if (!existsSync(path)) continue
+    try {
+      return {
+        path,
+        config: parse(readFileSync(path, "utf-8")) ?? {},
+      }
+    } catch (error) {
+      return {
+        path,
+        config: {},
+        error: error instanceof Error ? error.message : String(error),
+      }
+    }
+  }
+
+  return { path: null, config: {} }
+}
+
+function hasCommand(command, args = ["--version"]) {
+  const result = spawnSync(command, args, {
+    stdio: "ignore",
+    timeout: 10000,
+    shell: process.platform === "win32",
+  })
+  return result.status === 0
+}
+
+function hasNode() {
+  return hasCommand(process.platform === "win32" ? "node.exe" : "node")
+}
+
+function hasNpx() {
+  return hasCommand(process.platform === "win32" ? "npx.cmd" : "npx")
+}
+
+function checkNodeNpx() {
+  const node = hasNode()
+  const npx = hasNpx()
+  if (node && npx) return { level: "ok", detail: "backend ok" }
+  return {
+    level: "error",
+    detail: `${node ? "node ok" : "node not found"}, ${npx ? "npx ok" : "npx not found"}`,
+  }
+}
+
+function pythonCandidates() {
+  const configured = process.env.MEMPALACE_PYTHON?.trim()
+  const candidates = []
+  if (configured) candidates.push(configured)
+  if (process.platform === "win32") {
+    candidates.push("py", "python", "python3")
+  } else {
+    candidates.push("python3", "python")
+  }
+  return [...new Set(candidates)]
+}
+
+function canImportMempalace(command) {
+  const args =
+    command === "py"
+      ? ["-3", "-c", "import mempalace.mcp_server"]
+      : ["-c", "import mempalace.mcp_server"]
+  const result = spawnSync(command, args, {
+    stdio: "ignore",
+    timeout: 10000,
+    shell: process.platform === "win32",
+  })
+  return result.status === 0
+}
+
+function checkMempalace() {
+  if (hasCommand(process.platform === "win32" ? "uv.exe" : "uv")) {
+    return { level: "ok", detail: "uv available" }
+  }
+
+  for (const candidate of pythonCandidates()) {
+    if (canImportMempalace(candidate)) {
+      return { level: "ok", detail: `${candidate} with mempalace available` }
+    }
+  }
+
+  const hasPython = pythonCandidates().some((candidate) =>
+    hasCommand(candidate, candidate === "py" ? ["-3", "--version"] : ["--version"]),
+  )
+
+  return {
+    level: "error",
+    detail: hasPython ? "mempalace Python package not found" : "python not found",
+  }
+}
+
+async function checkRag(config) {
+  const url =
+    process.env.OPENCODE_RAG_URL?.trim()
+    || resolveEnvTemplate(config?.mcp?.rag?.environment?.OPENCODE_RAG_URL)
+    || DEFAULT_RAG_URL
+
+  try {
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), 2500)
+    const response = await fetch(url, { method: "GET", signal: controller.signal })
+    clearTimeout(timeout)
+
+    if (response.status < 500) {
+      return { level: "ok", detail: `enabled, ${url} reachable` }
+    }
+    return { level: "warn", detail: `enabled, ${url} returned ${response.status}` }
+  } catch {
+    return { level: "warn", detail: `enabled, ${url} not reachable` }
+  }
+}
+
+function checkRemoteKeyOnly() {
+  return { level: "ok", detail: "remote endpoint configured" }
+}
+
+function checkRemoteOptionalKey(_config, name) {
+  if (name === "context7" && !process.env.CONTEXT7_API_KEY?.trim()) {
+    return { level: "ok", detail: "remote endpoint configured, API key optional/missing" }
+  }
+  return { level: "ok", detail: "remote endpoint configured" }
+}
+
+function hasEnvOrAuth(config, envName, authKey) {
+  if (process.env[envName]?.trim()) return true
+  if (authKey && config?.auth?.[authKey]?.trim()) return true
+  return false
+}
+
+function statusIcon(level) {
+  if (level === "ok") return "✅"
+  if (level === "warn") return "⚠️ "
+  return "❌"
+}
+
+async function mcpStatus() {
+  const { path, config, error } = loadConfig()
+  console.log("hiai-opencode mcp-status")
+  console.log(`Config: ${path ?? "not found; using defaults"}`)
+  if (error) console.log(`Config parse warning: ${error}`)
+  console.log("")
+  console.log("MCP Servers:")
+
+  for (const [name, entry] of Object.entries(MCP_REGISTRY)) {
+    const userEntry = config?.mcp?.[name]
+    const enabled = userEntry?.enabled ?? entry.defaultEnabled
+    if (!enabled) {
+      console.log(`⚪ ${name.padEnd(20)} - disabled`)
+      continue
+    }
+
+    const missingEnv = entry.requiredEnv.filter((envName) =>
+      !hasEnvOrAuth(config, envName, entry.authFallback),
+    )
+
+    if (missingEnv.length > 0) {
+      console.log(`⚠️  ${name.padEnd(20)} - enabled, API key missing (${missingEnv.join(", ")})`)
+      continue
+    }
+
+    const result = await entry.check(config, name)
+    console.log(`${statusIcon(result.level)} ${name.padEnd(20)} - ${result.detail}`)
+  }
+}
+
+async function main() {
+  const command = process.argv[2]
+  if (!command || command === "-h" || command === "--help") {
+    usage()
+    return
+  }
+
+  if (command === "mcp-status") {
+    await mcpStatus()
+    return
+  }
+
+  console.error(`Unknown command: ${command}`)
+  usage()
+  process.exit(1)
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error))
+  process.exit(1)
+})

package/assets/mcp/mempalace.mjs

@@ -74,6 +74,37 @@ function resolvePythonForMempalace() {
   return null;
 }
 
+function resolvePythonForPip() {
+  for (const candidate of pythonCandidates()) {
+    const probe = spawnSync(
+      candidate.command,
+      [...candidate.args, "-m", "pip", "--version"],
+      { stdio: "ignore", timeout: 10000 },
+    );
+
+    if (probe.status === 0) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function shouldAutoInstall() {
+  const value = process.env.HIAI_MCP_AUTO_INSTALL?.trim().toLowerCase();
+  return value !== "0" && value !== "false" && value !== "no";
+}
+
+function installMempalaceWithPip(candidate) {
+  const result = spawnSync(
+    candidate.command,
+    [...candidate.args, "-m", "pip", "install", "--user", "mempalace"],
+    { stdio: "inherit", timeout: 300000 },
+  );
+
+  return result.status === 0 && canRunModule(candidate, "mempalace.mcp_server");
+}
+
 function resolveUvCacheRoot() {
   return process.env.UV_CACHE_DIR
     || join(resolveCacheRoot(), "hiai-opencode", "uv");
@@ -128,16 +159,28 @@ function main() {
   }
 
   const python = resolvePythonForMempalace();
-  if (!python) {
+  const fallbackPython =
+    python
+    || (shouldAutoInstall()
+      ? (() => {
+        const pipPython = resolvePythonForPip();
+        if (pipPython && installMempalaceWithPip(pipPython)) {
+          return pipPython;
+        }
+        return null;
+      })()
+      : null);
+
+  if (!fallbackPython) {
     console.error(
-      "[hiai-opencode] mempalace skipped: install uv or Python 3.9+ with `pip install mempalace`",
+      "[hiai-opencode] mempalace skipped: install uv or Python 3.9+ with `pip install --user mempalace`",
     );
     process.exit(0);
   }
 
   const child = spawn(
-    python.command,
-    [...python.args, "-m", "mempalace.mcp_server", "--palace", palacePath],
+    fallbackPython.command,
+    [...fallbackPython.args, "-m", "mempalace.mcp_server", "--palace", palacePath],
     {
       stdio: "inherit",
       env: {

package/assets/mcp/playwright.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+import { mkdirSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { spawn, spawnSync } from "node:child_process"
+
+function resolveCacheRoot() {
+  const xdgCache = process.env.XDG_CACHE_HOME?.trim()
+  if (xdgCache) return xdgCache
+
+  const scriptDir = dirname(fileURLToPath(import.meta.url))
+  const pluginRoot = join(scriptDir, "..", "..")
+  return join(pluginRoot, ".runtime-cache")
+}
+
+function runNpx(args, stdio = "inherit") {
+  const cacheRoot = join(resolveCacheRoot(), "hiai-opencode", "npm")
+  const tempRoot = join(cacheRoot, "tmp")
+  mkdirSync(tempRoot, { recursive: true })
+
+  const npxCommand = process.platform === "win32" ? "npx.cmd" : "npx"
+  return spawnSync(npxCommand, args, {
+    stdio,
+    shell: process.platform === "win32",
+    env: {
+      ...process.env,
+      npm_config_cache: cacheRoot,
+      NPM_CONFIG_CACHE: cacheRoot,
+      TEMP: tempRoot,
+      TMP: tempRoot,
+    },
+  })
+}
+
+function shouldInstallBrowsers() {
+  const value = process.env.HIAI_PLAYWRIGHT_INSTALL_BROWSERS?.trim().toLowerCase()
+  return value === "1" || value === "true" || value === "yes"
+}
+
+if (shouldInstallBrowsers()) {
+  const result = runNpx(["-y", "playwright@latest", "install", "chromium"])
+  if (result.status !== 0) {
+    console.error("[hiai-opencode] playwright browser install failed")
+    console.error("[hiai-opencode] Try: npx playwright install chromium")
+  }
+
+  if (process.platform === "linux") {
+    console.error("[hiai-opencode] Playwright Chromium may also need Linux system libraries.")
+    console.error("[hiai-opencode] If browser launch fails with libnspr4/libnss3/libgtk errors, run: sudo npx playwright install-deps chromium")
+    console.error("[hiai-opencode] Without sudo, use an existing browser by adding args in hiai-opencode.json, e.g. --browser chrome")
+  }
+}
+
+const cacheRoot = join(resolveCacheRoot(), "hiai-opencode", "npm")
+const tempRoot = join(cacheRoot, "tmp")
+mkdirSync(tempRoot, { recursive: true })
+
+const npxCommand = process.platform === "win32" ? "npx.cmd" : "npx"
+const child = spawn(npxCommand, ["-y", "@playwright/mcp@latest", ...process.argv.slice(2)], {
+  stdio: "inherit",
+  shell: process.platform === "win32",
+  env: {
+    ...process.env,
+    npm_config_cache: cacheRoot,
+    NPM_CONFIG_CACHE: cacheRoot,
+    TEMP: tempRoot,
+    TMP: tempRoot,
+  },
+})
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal)
+    return
+  }
+  process.exit(code ?? 0)
+})
+
+child.on("error", (error) => {
+  console.error("[hiai-opencode] playwright launcher failed:", error)
+  process.exit(1)
+})

package/config/hiai-opencode.schema.json

@@ -16,6 +16,23 @@
         "required": ["model"]
       }
     },
+    "agentRequirements": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "fallbackChain": {
+            "type": "array",
+            "items": { "$ref": "#/definitions/fallbackEntry" }
+          },
+          "variant": { "type": "string" },
+          "requiresModel": { "type": "string" },
+          "requiresAnyModel": { "type": "boolean" },
+          "requiresProvider": { "type": "array", "items": { "type": "string" } }
+        },
+        "required": ["fallbackChain"]
+      }
+    },
     "categories": {
       "type": "object",
       "additionalProperties": {
@@ -23,11 +40,47 @@
         "properties": {
           "model": { "type": "string" },
           "variant": { "type": "string" },
-          "description": { "type": "string" }
+          "description": { "type": "string" },
+          "fallbackChain": {
+            "type": "array",
+            "items": { "$ref": "#/definitions/fallbackEntry" }
+          }
         },
         "required": ["model"]
       }
     },
+    "categoryRequirements": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "fallbackChain": {
+            "type": "array",
+            "items": { "$ref": "#/definitions/fallbackEntry" }
+          },
+          "variant": { "type": "string" },
+          "requiresModel": { "type": "string" },
+          "requiresAnyModel": { "type": "boolean" },
+          "requiresProvider": { "type": "array", "items": { "type": "string" } }
+        },
+        "required": ["fallbackChain"]
+      }
+    },
+    "modelFamilies": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "family": { "type": "string" },
+          "includes": { "type": "array", "items": { "type": "string" } },
+          "pattern": { "type": "string" },
+          "variants": { "type": "array", "items": { "type": "string" } },
+          "reasoningEfforts": { "type": "array", "items": { "type": "string" } },
+          "supportsThinking": { "type": "boolean" }
+        },
+        "required": ["family"]
+      }
+    },
     "mcp": {
       "type": "object",
       "additionalProperties": {
@@ -36,6 +89,7 @@
           "enabled": { "type": "boolean", "default": true },
           "type": { "enum": ["remote", "local"] },
           "url": { "type": "string" },
+          "headers": { "type": "object", "additionalProperties": { "type": "string" } },
           "command": { "type": "array", "items": { "type": "string" } },
           "timeout": { "type": "number" },
           "environment": { "type": "object", "additionalProperties": { "type": "string" } }
@@ -69,6 +123,19 @@
         "disabled": { "type": "array", "items": { "type": "string" } }
       }
     },
+    "skill_discovery": {
+      "type": "object",
+      "description": "Controls which external skill directories are scanned. Defaults keep installs deterministic: hiai-opencode skills plus project .opencode/skills only.",
+      "properties": {
+        "config_sources": { "type": "boolean", "default": true },
+        "project_opencode": { "type": "boolean", "default": true },
+        "global_opencode": { "type": "boolean", "default": false },
+        "project_claude": { "type": "boolean", "default": false },
+        "global_claude": { "type": "boolean", "default": false },
+        "project_agents": { "type": "boolean", "default": false },
+        "global_agents": { "type": "boolean", "default": false }
+      }
+    },
     "permissions": {
       "type": "object",
       "properties": {
@@ -77,6 +144,51 @@
         "bash": { "type": "object", "additionalProperties": { "type": "string" } },
         "deny_paths": { "type": "array", "items": { "type": "string" } }
       }
+    },
+    "auth": {
+      "type": "object",
+      "additionalProperties": { "type": "string" }
+    },
+    "ollama": {
+      "type": "object",
+      "properties": {
+        "enabled": { "type": "boolean", "default": false },
+        "model": { "type": "string" },
+        "baseUrl": { "type": "string" },
+        "purpose": { "enum": ["verification", "helper", "fallback"] }
+      }
+    },
+    "fast_apply": {
+      "type": "object",
+      "properties": {
+        "enabled": { "type": "boolean", "default": false },
+        "ollama_url": { "type": "string" },
+        "model": { "type": "string" },
+        "timeout": { "type": "number" }
+      }
+    }
+  },
+  "definitions": {
+    "fallbackEntry": {
+      "type": "object",
+      "properties": {
+        "providers": { "type": "array", "items": { "type": "string" } },
+        "model": { "type": "string" },
+        "variant": { "type": "string" },
+        "reasoningEffort": { "type": "string" },
+        "temperature": { "type": "number" },
+        "top_p": { "type": "number" },
+        "maxTokens": { "type": "number" },
+        "thinking": {
+          "type": "object",
+          "properties": {
+            "type": { "enum": ["enabled", "disabled"] },
+            "budgetTokens": { "type": "number" }
+          },
+          "required": ["type"]
+        }
+      },
+      "required": ["providers", "model"]
     }
   }
 }

package/dist/config/index.d.ts

@@ -9,7 +9,6 @@
 export { loadConfig, resolveEnvVars, resolveMcpEnv } from "./loader.js";
 export { HiaiOpencodeConfigSchema } from "./platform-schema.js";
 export { defaultConfig } from "./defaults.js";
-export { MODEL_PRESETS, MODEL_ROLE_GUIDE, PROVIDER_MODEL_RULES } from "./models.js";
 export type { HiaiOpencodeConfig, AgentConfig, CategoryConfig, McpServerConfig, LspServerConfig, Subtask2Config, SkillsConfig as PlatformSkillsConfig, PermissionsConfig as PlatformPermissionsConfig, } from "./types.js";
 export { HiaiOpenCodeConfigSchema } from "./schema/oh-my-opencode-config.js";
 export type { HiaiOpenCodeConfig } from "./schema/oh-my-opencode-config.js";