@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/plugin-handlers/agent-priority-order.ts

@@ -1,63 +0,0 @@
-import { getAgentListDisplayName } from "../shared/agent-display-names"
-
-/**
- * CRITICAL: This is the ONLY source of truth for core agent ordering.
- * The order is: bob → coder → strategist → guard
- *
- * DO NOT CHANGE THIS ORDER. Any PR attempting to modify this order
- * or introduce alternative ordering mechanisms (ZWSP prefixes, sort
- * shims, etc.) will be rejected.
- *
- * See: src/plugin-handlers/AGENTS.md for architectural context.
- */
-export const CANONICAL_CORE_AGENT_ORDER = [
-  "bob",
-  "coder",
-  "strategist",
-  "guard",
-] as const
-
-type CoreAgentName = (typeof CANONICAL_CORE_AGENT_ORDER)[number]
-
-const CORE_AGENT_ORDER: ReadonlyArray<{
-  configKey: CoreAgentName
-  displayName: string
-  order: number
-}> = CANONICAL_CORE_AGENT_ORDER.map((configKey, index) => ({
-  configKey,
-  displayName: getAgentListDisplayName(configKey),
-  order: index + 1,
-}))
-
-const CORE_DISPLAY_NAMES = new Set(CORE_AGENT_ORDER.map((a) => a.displayName))
-
-function injectOrderField(agentConfig: unknown, order: number): unknown {
-  if (typeof agentConfig === "object" && agentConfig !== null) {
-    return { ...agentConfig, order }
-  }
-  return agentConfig
-}
-
-export function reorderAgentsByPriority(
-  agents: Record<string, unknown>,
-): Record<string, unknown> {
-  const ordered: Record<string, unknown> = {}
-  const seen = new Set<string>()
-
-  for (const { displayName, order } of CORE_AGENT_ORDER) {
-    if (Object.prototype.hasOwnProperty.call(agents, displayName)) {
-      ordered[displayName] = injectOrderField(agents[displayName], order)
-      seen.add(displayName)
-    }
-  }
-
-  const nonCoreKeys = Object.keys(agents)
-    .filter((key) => !seen.has(key))
-    .sort((a, b) => a.localeCompare(b))
-
-  for (const key of nonCoreKeys) {
-    ordered[key] = agents[key]
-  }
-
-  return ordered
-}

package/src/plugin-handlers/category-config-resolver.ts

@@ -1,9 +0,0 @@
-import type { CategoryConfig } from "../config/schema";
-import { DEFAULT_CATEGORIES } from "../tools/delegate-task/constants";
-
-export function resolveCategoryConfig(
-  categoryName: string,
-  userCategories?: Record<string, CategoryConfig>,
-): CategoryConfig | undefined {
-  return userCategories?.[categoryName] ?? DEFAULT_CATEGORIES[categoryName];
-}

package/src/plugin-handlers/command-config-handler.ts

@@ -1,115 +0,0 @@
-import type { HiaiOpenCodeConfig } from "../config";
-import {
-  getAgentConfigKey,
-  getAgentListDisplayName,
-} from "../shared/agent-display-names";
-import {
-  loadUserCommands,
-  loadProjectCommands,
-  loadOpencodeGlobalCommands,
-  loadOpencodeProjectCommands,
-} from "../features/claude-code-command-loader";
-import { loadBuiltinCommands } from "../features/builtin-commands";
-import {
-  discoverConfigSourceSkills,
-  loadManagedPluginSkills,
-  loadGlobalAgentsSkills,
-  loadProjectAgentsSkills,
-  loadUserSkills,
-  loadProjectSkills,
-  loadOpencodeGlobalSkills,
-  loadOpencodeProjectSkills,
-  skillsToCommandDefinitionRecord,
-} from "../features/opencode-skill-loader";
-import {
-  detectExternalSkillPlugin,
-  getSkillPluginConflictWarning,
-  log,
-} from "../shared";
-import type { PluginComponents } from "./plugin-components-loader";
-import { resolveSkillDiscoveryConfig } from "../plugin/skill-discovery-config";
-
-export async function applyCommandConfig(params: {
-  config: Record<string, unknown>;
-  pluginConfig: HiaiOpenCodeConfig;
-  ctx: { directory: string };
-  pluginComponents: PluginComponents;
-}): Promise<void> {
-  const builtinCommands = loadBuiltinCommands(params.pluginConfig.disabled_commands, {
-    useRegisteredAgents: true,
-  });
-  const systemCommands = (params.config.command as Record<string, unknown>) ?? {};
-
-  const includeClaudeCommands = params.pluginConfig.claude_code?.commands ?? true;
-  const discovery = resolveSkillDiscoveryConfig(params.pluginConfig);
-
-  const externalSkillPlugin = detectExternalSkillPlugin(params.ctx.directory);
-  if (
-    (discovery.project_claude || discovery.global_claude || discovery.global_opencode) &&
-    externalSkillPlugin.detected
-  ) {
-    log(getSkillPluginConflictWarning(externalSkillPlugin.pluginName!));
-  }
-
-  const [
-    configSourceSkills,
-    userCommands,
-    projectCommands,
-    opencodeGlobalCommands,
-    opencodeProjectCommands,
-    managedPluginSkills,
-    userSkills,
-    globalAgentsSkills,
-    projectSkills,
-    projectAgentsSkills,
-    opencodeGlobalSkills,
-    opencodeProjectSkills,
-  ] = await Promise.all([
-    discovery.config_sources
-      ? discoverConfigSourceSkills({
-        config: params.pluginConfig.skills,
-        configDir: params.ctx.directory,
-      })
-      : Promise.resolve([]),
-    includeClaudeCommands ? loadUserCommands() : Promise.resolve({}),
-    includeClaudeCommands ? loadProjectCommands(params.ctx.directory) : Promise.resolve({}),
-    loadOpencodeGlobalCommands(),
-    loadOpencodeProjectCommands(params.ctx.directory),
-    loadManagedPluginSkills(),
-    discovery.global_claude ? loadUserSkills() : Promise.resolve({}),
-    discovery.global_agents ? loadGlobalAgentsSkills() : Promise.resolve({}),
-    discovery.project_claude ? loadProjectSkills(params.ctx.directory) : Promise.resolve({}),
-    discovery.project_agents ? loadProjectAgentsSkills(params.ctx.directory) : Promise.resolve({}),
-    discovery.global_opencode ? loadOpencodeGlobalSkills() : Promise.resolve({}),
-    discovery.project_opencode ? loadOpencodeProjectSkills(params.ctx.directory) : Promise.resolve({}),
-  ]);
-
-  params.config.command = {
-    ...builtinCommands,
-    ...managedPluginSkills,
-    ...skillsToCommandDefinitionRecord(configSourceSkills),
-    ...userCommands,
-    ...userSkills,
-    ...globalAgentsSkills,
-    ...opencodeGlobalCommands,
-    ...opencodeGlobalSkills,
-    ...systemCommands,
-    ...projectCommands,
-    ...projectSkills,
-    ...projectAgentsSkills,
-    ...opencodeProjectCommands,
-    ...opencodeProjectSkills,
-    ...params.pluginComponents.commands,
-    ...params.pluginComponents.skills,
-  };
-
-  remapCommandAgentFields(params.config.command as Record<string, Record<string, unknown>>);
-}
-
-function remapCommandAgentFields(commands: Record<string, Record<string, unknown>>): void {
-  for (const cmd of Object.values(commands)) {
-    if (cmd?.agent && typeof cmd.agent === "string") {
-      cmd.agent = getAgentListDisplayName(getAgentConfigKey(cmd.agent));
-    }
-  }
-}

package/src/plugin-handlers/config-handler.ts

@@ -1,61 +0,0 @@
-import type { HiaiOpenCodeConfig } from "../config";
-import { setAdditionalAllowedMcpEnvVars } from "../features/claude-code-mcp-loader";
-import type { ModelCacheState } from "../plugin-state";
-import { log } from "../shared";
-import { applyAgentConfig } from "./agent-config-handler";
-import { applyCommandConfig } from "./command-config-handler";
-import { applyMcpConfig } from "./mcp-config-handler";
-import { applyProviderConfig } from "./provider-config-handler";
-import { loadPluginComponents } from "./plugin-components-loader";
-import { applyToolConfig } from "./tool-config-handler";
-import { buildLspConfig } from "../lsp";
-import { getPlatformLspDefaults } from "../shared/runtime-plugin-config";
-import { clearFormatterCache } from "../tools/hashline-edit/formatter-trigger"
-
-export { resolveCategoryConfig } from "./category-config-resolver";
-
-export interface ConfigHandlerDeps {
-  ctx: { directory: string; client?: any };
-  pluginConfig: HiaiOpenCodeConfig;
-  modelCacheState: ModelCacheState;
-}
-
-export function createConfigHandler(deps: ConfigHandlerDeps) {
-  const { ctx, pluginConfig, modelCacheState } = deps;
-
-  return async (config: Record<string, unknown>) => {
-    const formatterConfig = config.formatter;
-
-    setAdditionalAllowedMcpEnvVars(pluginConfig.mcp_env_allowlist ?? [])
-    applyProviderConfig({ config, modelCacheState });
-    clearFormatterCache()
-
-    const pluginComponents = await loadPluginComponents({ pluginConfig });
-
-    const agentResult = await applyAgentConfig({
-      config,
-      pluginConfig,
-      ctx,
-      pluginComponents,
-    });
-
-    applyToolConfig({ config, pluginConfig, agentResult });
-    await applyMcpConfig({ config, pluginConfig, pluginComponents });
-    await applyCommandConfig({ config, pluginConfig, ctx, pluginComponents });
-    const lspDefaults = getPlatformLspDefaults(pluginConfig);
-    if (Object.keys(lspDefaults).length > 0) {
-      config.lsp = {
-        ...((config.lsp as Record<string, unknown> | undefined) ?? {}),
-        ...buildLspConfig(lspDefaults),
-      };
-    }
-
-    config.formatter = formatterConfig;
-
-    log("[config-handler] config handler applied", {
-      agentCount: Object.keys(agentResult).length,
-      commandCount: Object.keys((config.command as Record<string, unknown>) ?? {})
-        .length,
-    });
-  };
-}

package/src/plugin-handlers/index.ts

@@ -1,10 +0,0 @@
-export { createConfigHandler, type ConfigHandlerDeps } from "./config-handler";
-export * from "./provider-config-handler";
-export * from "./agent-config-handler";
-export * from "./tool-config-handler";
-export * from "./mcp-config-handler";
-export * from "./command-config-handler";
-export * from "./plugin-components-loader";
-export * from "./category-config-resolver";
-export * from "./strategist-agent-config-builder";
-export * from "./agent-priority-order";

package/src/plugin-handlers/mcp-config-handler.test.ts

@@ -1,63 +0,0 @@
-import { expect, test } from "bun:test"
-
-import { applyMcpConfig } from "./mcp-config-handler"
-
-const emptyPluginComponents = {
-  commands: {},
-  skills: {},
-  agents: {},
-  mcpServers: {},
-  hooksConfigs: [],
-  plugins: [],
-  errors: [],
-}
-
-test("context7 auth fallback from hiai-opencode config is used when env placeholder is empty", async () => {
-  const config: Record<string, unknown> = {}
-
-  await applyMcpConfig({
-    config,
-    pluginConfig: {
-      auth: { context7: "ctx-test-key" },
-      claude_code: { mcp: false },
-      __platformDefaults: {
-        mcp: {
-          context7: {
-            enabled: true,
-            type: "remote",
-            url: "https://mcp.context7.com/mcp",
-            headers: { "X-API-KEY": "{env:CONTEXT7_API_KEY}" },
-          },
-        },
-      },
-    } as any,
-    pluginComponents: emptyPluginComponents,
-  })
-
-  expect((config.mcp as any).context7.headers).toEqual({ "X-API-KEY": "ctx-test-key" })
-})
-
-test("firecrawl auth fallback from hiai-opencode config is used when env placeholder is empty", async () => {
-  const config: Record<string, unknown> = {}
-
-  await applyMcpConfig({
-    config,
-    pluginConfig: {
-      auth: { firecrawl: "fc-test-key" },
-      claude_code: { mcp: false },
-      __platformDefaults: {
-        mcp: {
-          firecrawl: {
-            enabled: true,
-            type: "remote",
-            url: "http://localhost/firecrawl",
-            environment: { FIRECRAWL_API_KEY: "{env:FIRECRAWL_API_KEY}" },
-          },
-        },
-      },
-    } as any,
-    pluginComponents: emptyPluginComponents,
-  })
-
-  expect((config.mcp as any).firecrawl.environment).toEqual({ FIRECRAWL_API_KEY: "fc-test-key" })
-})

package/src/plugin-handlers/mcp-config-handler.ts

@@ -1,220 +0,0 @@
-import type { HiaiOpenCodeConfig } from "../config";
-import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { loadMcpConfigs } from "../features/claude-code-mcp-loader";
-import type { PluginComponents } from "./plugin-components-loader";
-import { log } from "../shared";
-import { getPlatformMcpDefaults } from "../shared/runtime-plugin-config";
-import { resolveEnvVars } from "../config";
-
-type McpEntry = Record<string, unknown>;
-
-function resolveHeaderAuthFallback(
-  pluginConfig: HiaiOpenCodeConfig,
-  name: string,
-): Record<string, string> | undefined {
-  const resolveAuth = (value: string | undefined): string | undefined => {
-    if (!value?.trim()) return undefined;
-    const resolved = resolveEnvVars(value).trim();
-    return resolved.length > 0 ? resolved : undefined;
-  };
-
-  if (name === "stitch") {
-    const key = resolveAuth(pluginConfig.auth?.stitch);
-    return key ? { "X-Goog-Api-Key": key } : undefined;
-  }
-
-  if (name === "context7") {
-    const key = resolveAuth(pluginConfig.auth?.context7);
-    return key ? { "X-API-KEY": key } : undefined;
-  }
-
-  return undefined;
-}
-
-function resolveEnvironmentAuthFallback(
-  pluginConfig: HiaiOpenCodeConfig,
-  name: string,
-): Record<string, string> | undefined {
-  if (name === "firecrawl") {
-    const key = pluginConfig.auth?.firecrawl ? resolveEnvVars(pluginConfig.auth.firecrawl).trim() : "";
-    return key ? { FIRECRAWL_API_KEY: key } : undefined;
-  }
-
-  return undefined;
-}
-
-function isDisabledMcpEntry(value: unknown): value is McpEntry & { enabled: false } {
-  return typeof value === "object" && value !== null && (value as McpEntry).enabled === false;
-}
-
-function captureUserDisabledMcps(
-  userMcp: Record<string, unknown> | undefined
-): Set<string> {
-  const disabled = new Set<string>();
-  if (!userMcp) return disabled;
-
-  for (const [name, value] of Object.entries(userMcp)) {
-    if (isDisabledMcpEntry(value)) {
-      disabled.add(name);
-    }
-  }
-
-  return disabled;
-}
-
-function expandStringRecord(
-  record: Record<string, string> | undefined,
-): Record<string, string> | undefined {
-  if (!record) return undefined;
-
-  const expanded = Object.fromEntries(
-    Object.entries(record).map(([key, value]) => [key, resolveEnvVars(value)]),
-  );
-
-  return Object.keys(expanded).length > 0 ? expanded : undefined;
-}
-
-function hasMissingResolvedValue(record: Record<string, string> | undefined): boolean {
-  if (!record) return false;
-  return Object.values(record).some((value) => value.trim().length === 0);
-}
-
-function hasUsableLocalMcpRuntime(name: string, entry: McpEntry): boolean {
-  const command = entry.command;
-  if (!Array.isArray(command) || command.length === 0) {
-    return true;
-  }
-
-  const [binary, ...args] = command;
-  if (typeof binary !== "string" || binary.trim().length === 0) {
-    return false;
-  }
-
-  if (binary === "node" && typeof args[0] === "string" && args[0].endsWith(".mjs")) {
-    if (!existsSync(args[0])) {
-      return false;
-    }
-
-    const probe = spawnSync(binary, ["--version"], {
-      stdio: "ignore",
-      timeout: 5000,
-    });
-    return probe.status === 0;
-  }
-
-  const probeArgs =
-    binary === "npx"
-      ? ["--version"]
-      : [...args.slice(0, 1), "--help"];
-  const probe = spawnSync(binary, probeArgs, {
-    stdio: "ignore",
-    timeout: 5000,
-  });
-  return probe.status === 0;
-}
-
-function normalizePlatformMcpDefaults(
-  defaults: Record<string, unknown>,
-  pluginConfig: HiaiOpenCodeConfig,
-): Record<string, McpEntry> {
-  const normalized: Record<string, McpEntry> = {};
-
-  for (const [name, entry] of Object.entries(defaults)) {
-    if (typeof entry !== "object" || entry === null) {
-      continue;
-    }
-
-    const nextEntry: McpEntry = { ...(entry as McpEntry) };
-    const headers = expandStringRecord(
-      (nextEntry.headers as Record<string, string> | undefined),
-    );
-    const environment = expandStringRecord(
-      (nextEntry.environment as Record<string, string> | undefined),
-    );
-    const headerFallback = resolveHeaderAuthFallback(pluginConfig, name);
-    const environmentFallback = resolveEnvironmentAuthFallback(pluginConfig, name);
-    const usableHeaders = headers && !hasMissingResolvedValue(headers) ? headers : undefined;
-    const usableEnvironment = environment && !hasMissingResolvedValue(environment) ? environment : undefined;
-    const headersWithFallback =
-      usableHeaders && headerFallback
-        ? { ...headerFallback, ...usableHeaders }
-        : usableHeaders ?? headerFallback;
-    const environmentWithFallback =
-      usableEnvironment && environmentFallback
-        ? { ...environmentFallback, ...usableEnvironment }
-        : usableEnvironment ?? environmentFallback;
-
-    const missingResolvedValues =
-      (!!headers && !usableHeaders && !headerFallback) ||
-      (!!environment && !usableEnvironment && !environmentFallback);
-
-    if (missingResolvedValues) {
-      log(`MCP server "${name}" is missing environment-backed auth; keeping it visible in config`);
-    }
-
-    if (!hasUsableLocalMcpRuntime(name, nextEntry)) {
-      log(`Skipping MCP server "${name}" because its local runtime is unavailable`);
-      continue;
-    }
-
-    if (headersWithFallback && !hasMissingResolvedValue(headersWithFallback)) {
-      nextEntry.headers = headersWithFallback;
-    }
-
-    if (environmentWithFallback && !hasMissingResolvedValue(environmentWithFallback)) {
-      nextEntry.environment = environmentWithFallback;
-    }
-
-    delete nextEntry.provider;
-
-    normalized[name] = nextEntry;
-  }
-
-  return normalized;
-}
-
-export async function applyMcpConfig(params: {
-  config: Record<string, unknown>;
-  pluginConfig: HiaiOpenCodeConfig;
-  pluginComponents: PluginComponents;
-}): Promise<void> {
-  const disabledMcps = params.pluginConfig.disabled_mcps ?? [];
-  const userMcp = params.config.mcp as Record<string, unknown> | undefined;
-  const userDisabledMcps = captureUserDisabledMcps(userMcp);
-
-  const mcpResult = params.pluginConfig.claude_code?.mcp ?? true
-    ? await loadMcpConfigs(disabledMcps)
-    : { servers: {} };
-
-  if (userMcp) {
-    for (const name of Object.keys(userMcp)) {
-      if (name in mcpResult.servers) {
-        log(`warning: MCP server "${name}" from user config overrides Claude Code .mcp.json`);
-      }
-    }
-  }
-
-  const merged = {
-    ...normalizePlatformMcpDefaults(
-      getPlatformMcpDefaults(params.pluginConfig) as unknown as Record<string, unknown>,
-      params.pluginConfig,
-    ),
-    ...mcpResult.servers,
-    ...(userMcp ?? {}),
-    ...params.pluginComponents.mcpServers,
-  } as Record<string, McpEntry>;
-
-  for (const name of userDisabledMcps) {
-    if (merged[name]) {
-      merged[name] = { ...merged[name], enabled: false };
-    }
-  }
-
-  const disabledSet = new Set(disabledMcps);
-  for (const name of disabledSet) {
-    delete merged[name];
-  }
-
-  params.config.mcp = merged;
-}

package/src/plugin-handlers/plan-model-inheritance.ts

@@ -1,27 +0,0 @@
-const MODEL_SETTINGS_KEYS = [
-  "model",
-  "variant",
-  "temperature",
-  "top_p",
-  "maxTokens",
-  "thinking",
-  "reasoningEffort",
-  "textVerbosity",
-  "providerOptions",
-] as const
-
-export function buildPlanDemoteConfig(
-  strategistConfig: Record<string, unknown> | undefined,
-  planOverride: Record<string, unknown> | undefined,
-): Record<string, unknown> {
-  const modelSettings: Record<string, unknown> = {}
-
-  for (const key of MODEL_SETTINGS_KEYS) {
-    const value = planOverride?.[key] ?? strategistConfig?.[key]
-    if (value !== undefined) {
-      modelSettings[key] = value
-    }
-  }
-
-  return { mode: "subagent" as const, hidden: true, ...modelSettings }
-}

package/src/plugin-handlers/plugin-components-loader.ts

@@ -1,70 +0,0 @@
-import type { HiaiOpenCodeConfig } from "../config";
-import { loadAllPluginComponents } from "../features/claude-code-plugin-loader";
-import { addConfigLoadError, log } from "../shared";
-
-export type PluginComponents = {
-  commands: Record<string, unknown>;
-  skills: Record<string, unknown>;
-  agents: Record<string, unknown>;
-  mcpServers: Record<string, unknown>;
-  hooksConfigs: Array<{ hooks?: Record<string, unknown> }>;
-  plugins: Array<{ name: string; version: string }>;
-  errors: Array<{ pluginKey: string; installPath: string; error: string }>;
-};
-
-const EMPTY_PLUGIN_COMPONENTS: PluginComponents = {
-  commands: {},
-  skills: {},
-  agents: {},
-  mcpServers: {},
-  hooksConfigs: [],
-  plugins: [],
-  errors: [],
-};
-
-export async function loadPluginComponents(params: {
-  pluginConfig: HiaiOpenCodeConfig;
-}): Promise<PluginComponents> {
-  const pluginsEnabled = params.pluginConfig.claude_code?.plugins ?? true;
-  if (!pluginsEnabled) {
-    return EMPTY_PLUGIN_COMPONENTS;
-  }
-
-  const timeoutMs = params.pluginConfig.experimental?.plugin_load_timeout_ms ?? 10000;
-
-  try {
-    let timeoutId: ReturnType<typeof setTimeout> | undefined;
-    const timeoutPromise = new Promise<never>((_, reject) => {
-      timeoutId = setTimeout(
-        () => reject(new Error(`Plugin loading timed out after ${timeoutMs}ms`)),
-        timeoutMs,
-      );
-    });
-
-    const pluginComponents = (await Promise.race([
-      loadAllPluginComponents({
-        enabledPluginsOverride: params.pluginConfig.claude_code?.plugins_override,
-      }),
-      timeoutPromise,
-    ]).finally(() => {
-      if (timeoutId) clearTimeout(timeoutId);
-    })) as PluginComponents;
-
-    if (pluginComponents.plugins.length > 0) {
-      log(`Loaded ${pluginComponents.plugins.length} Claude Code plugins`, {
-        plugins: pluginComponents.plugins.map((p) => `${p.name}@${p.version}`),
-      });
-    }
-
-    if (pluginComponents.errors.length > 0) {
-      log(`Plugin load errors`, { errors: pluginComponents.errors });
-    }
-
-    return pluginComponents;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    log("[config-handler] Plugin loading failed", { error: errorMessage });
-    addConfigLoadError({ path: "plugin-loading", error: errorMessage });
-    return EMPTY_PLUGIN_COMPONENTS;
-  }
-}