@hiai-gg/hiai-opencode 0.1.4 → 0.1.6

package/assets/mcp/mempalace.mjs

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 
-import { mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn, spawnSync } from "node:child_process";
+import { homedir } from "node:os";
+import { parse as parseJsonc } from "jsonc-parser";
 
 function resolveCacheRoot() {
   const xdgCache = process.env.XDG_CACHE_HOME?.trim();
@@ -27,14 +29,103 @@ function parsePalacePath(argv) {
     || join(resolveCacheRoot(), "hiai-opencode", "mempalace-palace");
 }
 
+function resolveEnvTemplate(value) {
+  if (typeof value !== "string") return "";
+  return value.replace(/\{env:([^}]+)\}/g, (_match, expression) => {
+    const [name, fallback] = String(expression).split(":-", 2);
+    return process.env[name] || fallback || "";
+  }).trim();
+}
+
+function candidateConfigPaths() {
+  const cwd = process.cwd();
+  const home = homedir();
+  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(home, ".config", "opencode", "hiai-opencode.json"),
+    join(home, ".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 loadUserConfig() {
+  for (const path of candidateConfigPaths()) {
+    if (!existsSync(path)) continue;
+    try {
+      return parseJsonc(readFileSync(path, "utf-8")) ?? {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+function getConfiguredPythonPath() {
+  const config = loadUserConfig();
+  const value = config?.mcp?.mempalace?.pythonPath;
+  return resolveEnvTemplate(typeof value === "string" ? value : "");
+}
+
+function resolveVenvPythonCandidates(basePath) {
+  if (!basePath) return [];
+
+  if (process.platform === "win32") {
+    return [
+      join(basePath, ".venv", "Scripts", "python.exe"),
+      join(basePath, "venv", "Scripts", "python.exe"),
+    ];
+  }
+
+  return [
+    join(basePath, ".venv", "bin", "python"),
+    join(basePath, ".venv", "bin", "python3"),
+    join(basePath, "venv", "bin", "python"),
+    join(basePath, "venv", "bin", "python3"),
+  ];
+}
+
 function pythonCandidates() {
+  const configPython = getConfiguredPythonPath();
   const explicit = process.env.MEMPALACE_PYTHON?.trim();
+  const scriptDir = dirname(fileURLToPath(import.meta.url));
+  const pluginRoot = join(scriptDir, "..", "..");
   const candidates = [];
 
   if (explicit) {
     candidates.push({ command: explicit, args: [] });
   }
 
+  if (configPython) {
+    candidates.push({ command: configPython, args: [] });
+  }
+
+  for (const candidate of resolveVenvPythonCandidates(process.cwd())) {
+    if (existsSync(candidate)) {
+      candidates.push({ command: candidate, args: [] });
+    }
+  }
+
+  for (const candidate of resolveVenvPythonCandidates(pluginRoot)) {
+    if (existsSync(candidate)) {
+      candidates.push({ command: candidate, args: [] });
+    }
+  }
+
+  for (const candidate of resolveVenvPythonCandidates(join(homedir(), ".config", "opencode", "plugins", "hiai-opencode"))) {
+    if (existsSync(candidate)) {
+      candidates.push({ command: candidate, args: [] });
+    }
+  }
+
   if (process.platform === "win32") {
     candidates.push({ command: "py", args: ["-3"] });
   }
@@ -42,7 +133,13 @@ function pythonCandidates() {
   candidates.push({ command: "python3", args: [] });
   candidates.push({ command: "python", args: [] });
 
-  return candidates;
+  const seen = new Set();
+  return candidates.filter((candidate) => {
+    const key = `${candidate.command}\0${candidate.args.join("\0")}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
 }
 
 function hasUv() {
@@ -57,7 +154,7 @@ function hasUv() {
 function canRunModule(candidate, moduleName) {
   const probe = spawnSync(
     candidate.command,
-    [...candidate.args, "-c", `import importlib.util, sys; sys.exit(0 if importlib.util.find_spec("${moduleName}") else 1)`],
+    [...candidate.args, "-c", `import importlib, sys; importlib.import_module("${moduleName}")`],
     { stdio: "ignore", timeout: 10000 },
   );
 
@@ -105,6 +202,31 @@ function installMempalaceWithPip(candidate) {
   return result.status === 0 && canRunModule(candidate, "mempalace.mcp_server");
 }
 
+function spawnWithUv(uvBinary, palacePath) {
+  return spawn(
+    uvBinary,
+    [
+      "tool",
+      "run",
+      "--from",
+      "mempalace[all]>=3.3.0",
+      "python",
+      "-m",
+      "mempalace.mcp_server",
+      "--palace",
+      palacePath,
+    ],
+    {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        UV_CACHE_DIR: resolveUvCacheRoot(),
+        MEMPALACE_PALACE_PATH: palacePath,
+      },
+    },
+  );
+}
+
 function resolveUvCacheRoot() {
   return process.env.UV_CACHE_DIR
     || join(resolveCacheRoot(), "hiai-opencode", "uv");
@@ -129,30 +251,30 @@ function main() {
   const palacePath = parsePalacePath(process.argv.slice(2));
   mkdirSync(palacePath, { recursive: true });
 
+  const configuredPython =
+    process.env.MEMPALACE_PYTHON?.trim() || getConfiguredPythonPath();
+  if (configuredPython) {
+    const configuredCandidate = { command: configuredPython, args: [] };
+    if (canRunModule(configuredCandidate, "mempalace.mcp_server")) {
+      const configuredChild = spawn(
+        configuredCandidate.command,
+        [...configuredCandidate.args, "-m", "mempalace.mcp_server", "--palace", palacePath],
+        {
+          stdio: "inherit",
+          env: {
+            ...process.env,
+            MEMPALACE_PALACE_PATH: palacePath,
+          },
+        },
+      );
+      forwardChildExit(configuredChild, "[hiai-opencode] mempalace launcher failed:");
+      return;
+    }
+  }
+
   const uvBinary = hasUv();
   if (uvBinary) {
-    const child = spawn(
-      uvBinary,
-      [
-        "tool",
-        "run",
-        "--from",
-        "mempalace[all]>=3.3.0",
-        "python",
-        "-m",
-        "mempalace.mcp_server",
-        "--palace",
-        palacePath,
-      ],
-      {
-        stdio: "inherit",
-        env: {
-          ...process.env,
-          UV_CACHE_DIR: resolveUvCacheRoot(),
-          MEMPALACE_PALACE_PATH: palacePath,
-        },
-      },
-    );
+    const child = spawnWithUv(uvBinary, palacePath);
 
     forwardChildExit(child, "[hiai-opencode] mempalace uv launcher failed:");
     return;
@@ -167,10 +289,22 @@ function main() {
         if (pipPython && installMempalaceWithPip(pipPython)) {
           return pipPython;
         }
+
+        const fallbackUv = hasUv();
+        if (fallbackUv) {
+          const uvChild = spawnWithUv(fallbackUv, palacePath);
+          forwardChildExit(uvChild, "[hiai-opencode] mempalace uv fallback failed:");
+          return "__uv_fallback_started__";
+        }
+
         return null;
       })()
       : null);
 
+  if (fallbackPython === "__uv_fallback_started__") {
+    return;
+  }
+
   if (!fallbackPython) {
     console.error(
       "[hiai-opencode] mempalace skipped: install uv or Python 3.9+ with `pip install --user mempalace`",

package/config/hiai-opencode.schema.json

@@ -1,131 +1,74 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "hiai-opencode Configuration",
-  "description": "Unified configuration for hiai-opencode plugin",
+  "description": "User-facing hiai-opencode config. Users choose 10 primary agent models, service auth placeholders, and enable/disable MCP/LSP integrations. Internal routing derives hidden agents and task categories from these model slots.",
   "type": "object",
   "properties": {
     "$schema": { "type": "string" },
-    "agents": {
+    "models": {
       "type": "object",
-      "additionalProperties": {
-        "type": "object",
-        "properties": {
-          "model": { "type": "string" },
-          "description": { "type": "string" }
-        },
-        "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": {
-        "type": "object",
-        "properties": {
-          "model": { "type": "string" },
-          "variant": { "type": "string" },
-          "description": { "type": "string" },
-          "fallbackChain": {
-            "type": "array",
-            "items": { "$ref": "#/definitions/fallbackEntry" }
-          }
-        },
-        "required": ["model"]
-      }
+      "description": "The only user-facing model source of truth. Use fully qualified OpenCode model IDs.",
+      "properties": {
+        "bob": { "$ref": "#/definitions/modelSlot" },
+        "coder": { "$ref": "#/definitions/modelSlot" },
+        "strategist": { "$ref": "#/definitions/modelSlot" },
+        "guard": { "$ref": "#/definitions/modelSlot" },
+        "critic": { "$ref": "#/definitions/modelSlot" },
+        "designer": { "$ref": "#/definitions/modelSlot" },
+        "researcher": { "$ref": "#/definitions/modelSlot" },
+        "manager": { "$ref": "#/definitions/modelSlot" },
+        "brainstormer": { "$ref": "#/definitions/modelSlot" },
+        "vision": { "$ref": "#/definitions/modelSlot" }
+      },
+      "required": [
+        "bob",
+        "coder",
+        "strategist",
+        "guard",
+        "critic",
+        "designer",
+        "researcher",
+        "manager",
+        "brainstormer",
+        "vision"
+      ]
     },
-    "categoryRequirements": {
+    "auth": {
       "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"]
+      "additionalProperties": { "type": "string" },
+      "properties": {
+        "stitch": { "type": "string" },
+        "firecrawl": { "type": "string" },
+        "context7": { "type": "string" }
       }
     },
     "mcp": {
       "type": "object",
-      "additionalProperties": {
-        "type": "object",
-        "properties": {
-          "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" } }
-        },
-        "required": ["enabled"]
-      }
-    },
-    "lsp": {
-      "type": "object",
-      "additionalProperties": {
-        "type": "object",
-        "properties": {
-          "command": { "type": "array", "items": { "type": "string" } },
-          "extensions": { "type": "array", "items": { "type": "string" } },
-          "initialization": { "type": "object" }
-        },
-        "required": ["command", "extensions"]
-      }
-    },
-    "subtask2": {
-      "type": "object",
+      "additionalProperties": false,
       "properties": {
-        "replace_generic": { "type": "boolean" },
-        "generic_return": { "type": ["string", "null"] }
+        "playwright": { "$ref": "#/definitions/toggle" },
+        "stitch": { "$ref": "#/definitions/toggle" },
+        "sequential-thinking": { "$ref": "#/definitions/toggle" },
+        "firecrawl": { "$ref": "#/definitions/toggle" },
+        "rag": { "$ref": "#/definitions/toggle" },
+        "mempalace": { "$ref": "#/definitions/mempalaceToggle" },
+        "context7": { "$ref": "#/definitions/toggle" }
       }
     },
-    "skills": {
+    "lsp": {
       "type": "object",
+      "additionalProperties": false,
       "properties": {
-        "enabled": { "type": "boolean", "default": true },
-        "disabled": { "type": "array", "items": { "type": "string" } }
+        "typescript": { "$ref": "#/definitions/toggle" },
+        "svelte": { "$ref": "#/definitions/toggle" },
+        "eslint": { "$ref": "#/definitions/toggle" },
+        "bash": { "$ref": "#/definitions/toggle" },
+        "pyright": { "$ref": "#/definitions/toggle" }
       }
     },
     "skill_discovery": {
       "type": "object",
-      "description": "Controls which external skill directories are scanned. Defaults keep installs deterministic: hiai-opencode skills plus project .opencode/skills only.",
+      "description": "Controls external skill folder scanning. Defaults keep installs deterministic.",
       "properties": {
         "config_sources": { "type": "boolean", "default": true },
         "project_opencode": { "type": "boolean", "default": true },
@@ -136,59 +79,50 @@
         "global_agents": { "type": "boolean", "default": false }
       }
     },
-    "permissions": {
-      "type": "object",
-      "properties": {
-        "read": { "type": "object", "additionalProperties": { "type": "string" } },
-        "edit": { "type": "object", "additionalProperties": { "type": "string" } },
-        "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": {
+    "subtask2": {
       "type": "object",
       "properties": {
-        "enabled": { "type": "boolean", "default": false },
-        "ollama_url": { "type": "string" },
-        "model": { "type": "string" },
-        "timeout": { "type": "number" }
+        "replace_generic": { "type": "boolean" }
       }
     }
   },
+  "required": ["models"],
   "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": {
+    "modelSlot": {
+      "oneOf": [
+        { "type": "string" },
+        {
           "type": "object",
           "properties": {
-            "type": { "enum": ["enabled", "disabled"] },
-            "budgetTokens": { "type": "number" }
+            "model": { "type": "string" },
+            "recommended": {
+              "enum": ["xhigh", "high", "middle", "fast", "vision", "writing", "design"]
+            }
           },
-          "required": ["type"]
+          "required": ["model"],
+          "additionalProperties": false
+        }
+      ]
+    },
+    "toggle": {
+      "type": "object",
+      "properties": {
+        "enabled": { "type": "boolean", "default": true }
+      },
+      "required": ["enabled"],
+      "additionalProperties": false
+    },
+    "mempalaceToggle": {
+      "type": "object",
+      "properties": {
+        "enabled": { "type": "boolean", "default": true },
+        "pythonPath": {
+          "type": "string",
+          "description": "Optional explicit Python executable for MemPalace (for example: ./.venv/bin/python)."
         }
       },
-      "required": ["providers", "model"]
+      "required": ["enabled"],
+      "additionalProperties": false
     }
   }
 }

package/dist/agents/dynamic-agent-core-sections.d.ts

@@ -8,7 +8,10 @@ import type { AvailableTool } from "./dynamic-agent-prompt-types";
  */
 export declare function buildAgentIdentitySection(agentName: string, roleDescription: string): string;
 export declare function buildKeyTriggersSection(agents: AvailableAgent[], _skills?: AvailableSkill[]): string;
-export declare function buildToolSelectionTable(agents: AvailableAgent[], tools?: AvailableTool[], _skills?: AvailableSkill[]): string;
+export declare function buildToolSelectionTable(agents: AvailableAgent[], tools?: AvailableTool[], _skills?: AvailableSkill[], options?: {
+    includeIntegrationPrimer?: boolean;
+}): string;
+export declare function buildHiaiIntegrationPrimerSection(): string;
 export declare function buildResearcherSection(agents: AvailableAgent[]): string;
 export declare function buildDelegationTable(agents: AvailableAgent[]): string;
 export declare function buildStrategistAndCriticSection(agents: AvailableAgent[]): string;

package/dist/agents/dynamic-agent-prompt-builder.d.ts

@@ -1,5 +1,5 @@
 export type { AvailableAgent, AvailableTool, AvailableSkill, AvailableCategory, } from "./dynamic-agent-prompt-types";
 export { categorizeTools } from "./dynamic-agent-tool-categorization";
-export { buildAgentIdentitySection, buildKeyTriggersSection, buildToolSelectionTable, buildResearcherSection, buildDelegationTable, buildStrategistAndCriticSection, buildNonClaudePlannerSection, buildParallelDelegationSection, } from "./dynamic-agent-core-sections";
+export { buildAgentIdentitySection, buildKeyTriggersSection, buildToolSelectionTable, buildResearcherSection, buildDelegationTable, buildHiaiIntegrationPrimerSection, buildStrategistAndCriticSection, buildNonClaudePlannerSection, buildParallelDelegationSection, } from "./dynamic-agent-core-sections";
 export { buildCategorySkillsDelegationGuide } from "./dynamic-agent-category-skills-guide";
 export { buildHardBlocksSection, buildAntiPatternsSection, buildHardRulesSection, buildToolCallFormatSection, buildUltraworkSection, buildAntiDuplicationSection, buildToolUsageRulesSection, } from "./dynamic-agent-policy-sections";

package/dist/config/defaults.d.ts

@@ -1,2 +1,3 @@
 import type { HiaiOpencodeConfig } from "./types.js";
+export declare function applyModelSlots(config: HiaiOpencodeConfig): HiaiOpencodeConfig;
 export declare const defaultConfig: HiaiOpencodeConfig;