@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/tools/delegate-task/parent-context-resolver.ts

@@ -1,47 +0,0 @@
-import type { ToolContextWithMetadata } from "./types"
-import type { OpencodeClient } from "./types"
-import type { ParentContext } from "./executor-types"
-import { resolveMessageContext } from "../../features/hook-message-injector"
-import { getSessionAgent } from "../../features/claude-code-session-state"
-import { log } from "../../shared/logger"
-import { getMessageDir } from "../../shared/opencode-message-dir"
-
-export async function resolveParentContext(
-  ctx: ToolContextWithMetadata,
-  client: OpencodeClient
-): Promise<ParentContext> {
-  const messageDir = getMessageDir(ctx.sessionID)
-  const { prevMessage, firstMessageAgent } = await resolveMessageContext(
-    ctx.sessionID,
-    client,
-    messageDir
-  )
-
-  const sessionAgent = getSessionAgent(ctx.sessionID)
-  const parentAgent = ctx.agent ?? sessionAgent ?? firstMessageAgent ?? prevMessage?.agent
-
-  log("[task] parentAgent resolution", {
-    sessionID: ctx.sessionID,
-    messageDir,
-    ctxAgent: ctx.agent,
-    sessionAgent,
-    firstMessageAgent,
-    prevMessageAgent: prevMessage?.agent,
-    resolvedParentAgent: parentAgent,
-  })
-
-  const parentModel = prevMessage?.model?.providerID && prevMessage?.model?.modelID
-    ? {
-        providerID: prevMessage.model.providerID,
-        modelID: prevMessage.model.modelID,
-        ...(prevMessage.model.variant ? { variant: prevMessage.model.variant } : {}),
-      }
-    : undefined
-
-  return {
-    sessionID: ctx.sessionID,
-    messageID: ctx.messageID,
-    agent: parentAgent,
-    model: parentModel,
-  }
-}

package/src/tools/delegate-task/prompt-builder.ts

@@ -1,107 +0,0 @@
-import type { BuildSystemContentInput } from "./types"
-import type { AvailableSkill } from "../../agents/dynamic-agent-prompt-builder"
-import { buildPlanAgentSystemPrepend, isPlanAgent } from "./constants"
-import { buildSystemContentWithTokenLimit } from "./token-limiter"
-
-const FREE_OR_LOCAL_PROMPT_TOKEN_LIMIT = 24000
-const PLAN_AGENT_PROMPT_BASE = `
-
-Additional requirements for this planning request:
-- Answer in English.
-- Write the plan in English.
-- Plan well for ultrawork execution.
-- Include a clear atomic commit strategy.`
-
-const TDD_LINE = "- Use TDD-oriented planning."
-
-function buildPlanAgentPromptAppend(tddEnabled: boolean): string {
-  if (tddEnabled) {
-    return `${PLAN_AGENT_PROMPT_BASE}
-${TDD_LINE}`
-  }
-  return PLAN_AGENT_PROMPT_BASE
-}
-
-function buildAvailableSkillsSection(skills: AvailableSkill[]): string {
-  if (skills.length === 0) {
-    return ""
-  }
-
-  const rows = skills
-    .map((s) => `- \`${s.name}\`: ${s.description || s.name}`)
-    .join("\n")
-
-  return `<available_skills>
-Skills provide specialized instructions. Load via load_skills parameter when delegating tasks.
-
-${rows}
-</available_skills>`
-}
-
-function usesFreeOrLocalModel(model: { providerID: string; modelID: string; variant?: string } | undefined): boolean {
-  if (!model) {
-    return false
-  }
-
-  const provider = model.providerID.toLowerCase()
-  const modelId = model.modelID.toLowerCase()
-  return provider.includes("local")
-    || provider === "ollama"
-    || provider === "lmstudio"
-    || modelId.includes("free")
-}
-
-/**
- * Build the system content to inject into the agent prompt.
- * Combines skill content, category prompt append, and plan agent system prepend.
- */
-export function buildSystemContent(input: BuildSystemContentInput): string | undefined {
-  const {
-    skillContent,
-    skillContents,
-    categoryPromptAppend,
-    agentsContext,
-    maxPromptTokens,
-    model,
-    agentName,
-    availableCategories,
-    availableSkills,
-  } = input
-
-  const isPlan = isPlanAgent(agentName)
-  const planAgentPrepend = isPlan
-    ? buildPlanAgentSystemPrepend(availableCategories, availableSkills)
-    : ""
-
-  const skillsSection = !isPlan
-    ? buildAvailableSkillsSection(availableSkills ?? [])
-    : ""
-
-  const baseAgentsContext = agentsContext ?? planAgentPrepend
-  const effectiveAgentsContext = !isPlan && skillsSection
-    ? [baseAgentsContext, skillsSection].filter(Boolean).join("\n\n")
-    : baseAgentsContext
-
-  const effectiveMaxPromptTokens = maxPromptTokens
-    ?? (usesFreeOrLocalModel(model) ? FREE_OR_LOCAL_PROMPT_TOKEN_LIMIT : undefined)
-
-  return buildSystemContentWithTokenLimit(
-    {
-      skillContent,
-      skillContents,
-      categoryPromptAppend,
-      agentsContext: effectiveAgentsContext,
-      planAgentPrepend,
-    },
-    effectiveMaxPromptTokens
-  )
-}
-
-export function buildTaskPrompt(prompt: string, agentName: string | undefined, tddEnabled?: boolean): string {
-  if (!isPlanAgent(agentName)) {
-    return prompt
-  }
-
-  const effectiveTdd = tddEnabled ?? true
-  return `${prompt}${buildPlanAgentPromptAppend(effectiveTdd)}`
-}

package/src/tools/delegate-task/resolve-call-id.ts

@@ -1,5 +0,0 @@
-import type { ToolContextWithMetadata } from "./types"
-
-export function resolveCallID(ctx: ToolContextWithMetadata): string | undefined {
-  return ctx.callID ?? ctx.callId ?? ctx.call_id
-}

package/src/tools/delegate-task/skill-resolver.ts

@@ -1,22 +0,0 @@
-import type { GitMasterConfig, BrowserAutomationProvider } from "../../config/schema"
-import { resolveMultipleSkillsAsync } from "../../features/opencode-skill-loader/skill-content"
-import { discoverSkills } from "../../features/opencode-skill-loader"
-
-export async function resolveSkillContent(
-  skills: string[],
-  options: { gitMasterConfig?: GitMasterConfig; browserProvider?: BrowserAutomationProvider, disabledSkills?: Set<string>, directory?: string }
-): Promise<{ content: string | undefined; contents: string[]; error: string | null }> {
-  if (skills.length === 0) {
-    return { content: undefined, contents: [], error: null }
-  }
-
-  const { resolved, notFound } = await resolveMultipleSkillsAsync(skills, options)
-  if (notFound.length > 0) {
-    const allSkills = await discoverSkills({ includeClaudeCodePaths: true, directory: options?.directory })
-    const available = allSkills.map(s => s.name).join(", ")
-    return { content: undefined, contents: [], error: `Skills not found: ${notFound.join(", ")}. Available: ${available}` }
-  }
-
-  const contents = Array.from(resolved.values())
-  return { content: contents.join("\n\n"), contents, error: null }
-}

package/src/tools/delegate-task/sub-agent.ts

@@ -1,80 +0,0 @@
-import { getAgentConfigKey, getAgentDisplayName } from "../../shared/agent-display-names"
-import { log } from "../../shared/logger"
-
-export const SUB_AGENT_CONFIG_KEY = "sub"
-export const CODER_AGENT_CONFIG_KEY = "coder"
-export const CRITIC_AGENT_CONFIG_KEY = "critic"
-
-export const CANONICAL_DELEGATE_AGENT_KEYS = [
-  "bob",
-  "guard",
-  "strategist",
-  "critic",
-  "coder",
-  "sub",
-  "researcher",
-  "multimodal",
-  "designer",
-  "platform-manager",
-  "brainstormer",
-  "agent-skills",
-] as const
-
-type CanonicalDelegateAgentKey = (typeof CANONICAL_DELEGATE_AGENT_KEYS)[number]
-export type { CanonicalDelegateAgentKey }
-const CANONICAL_DELEGATE_AGENT_KEY_SET = new Set<string>(CANONICAL_DELEGATE_AGENT_KEYS)
-
-const LEGACY_DELEGATE_AGENT_ALIASES: Record<string, CanonicalDelegateAgentKey> = {
-  general: "bob",
-  zoe: "bob",
-  build: "bob",
-  "plan-consultant": "strategist",
-  "pre-plan": "strategist",
-  "planner-bob": "strategist",
-  "omo-plan": "strategist",
-  plan: "strategist",
-  logician: "strategist",
-  athena: "strategist",
-  "athena-junior": "strategist",
-  librarian: "researcher",
-  explore: "researcher",
-  "code-reviewer": "critic",
-  "systematic-debugger": "critic",
-  "ledger-creator": "platform-manager",
-  bootstrapper: "platform-manager",
-  "project-initializer": "platform-manager",
-  mindmodel: "platform-manager",
-  ui: "multimodal",
-  writer: "brainstormer",
-  copywriter: "brainstormer",
-  "content-writer": "brainstormer",
-  subagent: "sub",
-  "bob-junior": "sub",
-  oracle: "strategist",
-  hephaestus: "coder",
-  metis: "strategist",
-  momus: "critic",
-  "sisyphus-junior": "sub",
-  "multimodal-looker": "multimodal",
-}
-
-export function resolveCanonicalDelegateAgentKey(agentName: string): string {
-  const configKey = getAgentConfigKey(agentName).trim().toLowerCase()
-  if (!configKey) return configKey
-  const resolved = LEGACY_DELEGATE_AGENT_ALIASES[configKey]
-  if (resolved && resolved !== configKey) {
-    log("[delegate-task] Legacy agent alias resolved", { from: configKey, to: resolved })
-    return resolved
-  }
-  return configKey
-}
-
-export function isCanonicalDelegateAgentKey(agentName: string): boolean {
-  return CANONICAL_DELEGATE_AGENT_KEY_SET.has(resolveCanonicalDelegateAgentKey(agentName))
-}
-
-export function getCanonicalDelegateAgentDisplayName(agentName: string): string {
-  return getAgentDisplayName(resolveCanonicalDelegateAgentKey(agentName))
-}
-
-export const BOB_JUNIOR_AGENT = getAgentDisplayName(SUB_AGENT_CONFIG_KEY)

package/src/tools/delegate-task/subagent-discovery.test.ts

@@ -1,123 +0,0 @@
-import { expect, test, describe } from "bun:test"
-import { sanitizeSubagentType, findPrimaryAgentMatch, findCallableAgentMatch, listCallableAgentNames, isTaskCallableAgentMode } from "./subagent-discovery"
-
-describe("sanitizeSubagentType", () => {
-  test("trims whitespace", () => {
-    expect(sanitizeSubagentType("  researcher  ")).toBe("researcher")
-  })
-
-  test("removes surrounding quotes", () => {
-    expect(sanitizeSubagentType('"researcher"')).toBe("researcher")
-    expect(sanitizeSubagentType("'researcher'")).toBe("researcher")
-  })
-
-  test("removes surrounding slashes", () => {
-    expect(sanitizeSubagentType("/researcher/")).toBe("researcher")
-  })
-
-  test("removes backslashes", () => {
-    expect(sanitizeSubagentType("\\researcher\\")).toBe("researcher")
-  })
-
-  test("handles mixed characters", () => {
-    expect(sanitizeSubagentType('  /"researcher"\\ ')).toBe("researcher")
-  })
-})
-
-describe("isTaskCallableAgentMode", () => {
-  test("returns true for subagent mode", () => {
-    expect(isTaskCallableAgentMode("subagent")).toBe(true)
-  })
-
-  test("returns true for all mode", () => {
-    expect(isTaskCallableAgentMode("all")).toBe(true)
-  })
-
-  test("returns false for primary mode", () => {
-    expect(isTaskCallableAgentMode("primary")).toBe(false)
-  })
-
-  test("returns false for undefined", () => {
-    expect(isTaskCallableAgentMode(undefined)).toBe(false)
-  })
-})
-
-describe("findPrimaryAgentMatch", () => {
-  const agents = [
-    { name: "Bob", mode: "primary" as const, model: "openrouter/test/bob" },
-    { name: "Coder", mode: "primary" as const, model: "openrouter/test/coder" },
-    { name: "Researcher", mode: "primary" as const, model: "openrouter/test/researcher" },
-    { name: "SubAgent", mode: "subagent" as const, model: "openrouter/test/sub" },
-  ]
-
-  test("finds primary agent by exact name", () => {
-    const result = findPrimaryAgentMatch(agents, "Bob")
-    expect(result?.name).toBe("Bob")
-  })
-
-  test("finds primary agent by canonical key", () => {
-    const result = findPrimaryAgentMatch(agents, "researcher")
-    expect(result?.name).toBe("Researcher")
-  })
-
-  test("returns undefined for non-existent agent", () => {
-    const result = findPrimaryAgentMatch(agents, "Nonexistent")
-    expect(result).toBeUndefined()
-  })
-
-  test("returns undefined when searching for subagent mode", () => {
-    const result = findPrimaryAgentMatch(agents, "SubAgent")
-    expect(result).toBeUndefined()
-  })
-})
-
-describe("findCallableAgentMatch", () => {
-  const agents = [
-    { name: "Bob", mode: "primary" as const, model: "openrouter/test/bob" },
-    { name: "Coder", mode: "primary" as const, model: "openrouter/test/coder" },
-    { name: "Researcher", mode: "subagent" as const, model: "openrouter/test/researcher" },
-    { name: "SubAgent", mode: "subagent" as const, model: "openrouter/test/sub" },
-    { name: "Vision", mode: "all" as const, model: "openrouter/test/vision" },
-  ]
-
-  test("finds callable agent by subagent mode", () => {
-    const result = findCallableAgentMatch(agents, "SubAgent")
-    expect(result?.name).toBe("SubAgent")
-  })
-
-  test("finds callable agent by all mode", () => {
-    const result = findCallableAgentMatch(agents, "Vision")
-    expect(result?.name).toBe("Vision")
-  })
-
-  test("finds callable agent by canonical researcher (subagent mode)", () => {
-    const result = findCallableAgentMatch(agents, "researcher")
-    expect(result?.name).toBe("Researcher")
-  })
-
-  test("returns undefined for primary-only agent", () => {
-    const result = findCallableAgentMatch(agents, "Bob")
-    expect(result).toBeUndefined()
-  })
-})
-
-describe("listCallableAgentNames", () => {
-  test("lists callable agents sorted alphabetically (subagent and all modes)", () => {
-    const agents = [
-      { name: "Vision", mode: "all" as const },
-      { name: "Researcher", mode: "subagent" as const },
-      { name: "Bob", mode: "primary" as const },
-    ]
-    const result = listCallableAgentNames(agents)
-    expect(result).toBe("Researcher, Vision")
-  })
-
-  test("returns empty string for no callable agents", () => {
-    const agents = [
-      { name: "Bob", mode: "primary" as const },
-      { name: "Coder", mode: "primary" as const },
-    ]
-    const result = listCallableAgentNames(agents)
-    expect(result).toBe("")
-  })
-})

package/src/tools/delegate-task/subagent-discovery.ts

@@ -1,152 +0,0 @@
-import { getAgentConfigKey, getAgentDisplayName, stripAgentListSortPrefix } from "../../shared/agent-display-names"
-import { loadUserAgents, loadProjectAgents } from "../../features/claude-code-agent-loader"
-import {
-  getCanonicalDelegateAgentDisplayName,
-  isCanonicalDelegateAgentKey,
-  resolveCanonicalDelegateAgentKey,
-} from "./sub-agent"
-
-export type AgentMode = "subagent" | "primary" | "all" | undefined
-
-export type AgentInfo = {
-  name: string
-  mode?: "subagent" | "primary" | "all"
-  model?: string | { providerID: string; modelID: string }
-}
-
-export function sanitizeSubagentType(subagentType: string): string {
-  return subagentType.trim().replace(/^[\\\/"']+|[\\\/"']+$/g, "").trim()
-}
-
-export function mergeWithClaudeCodeAgents(
-  serverAgents: AgentInfo[],
-  directory: string | undefined,
-): AgentInfo[] {
-  const userAgentsRecord = loadUserAgents()
-  const projectAgentsRecord = loadProjectAgents(directory)
-
-  const toAgentInfoList = (record: Record<string, { mode?: string; model?: AgentInfo["model"] }>): AgentInfo[] =>
-    Object.entries(record).map(([name, config]) => ({
-      name,
-      mode: config.mode as AgentInfo["mode"],
-      model: config.model,
-    }))
-
-  const mergedAgentMap = new Map<string, AgentInfo>()
-  const addIfAbsent = (agent: AgentInfo): void => {
-    const key = stripAgentListSortPrefix(agent.name).trim().toLowerCase()
-    if (!mergedAgentMap.has(key)) {
-      mergedAgentMap.set(key, agent)
-    }
-  }
-
-  for (const agent of serverAgents) addIfAbsent(agent)
-  for (const agent of toAgentInfoList(projectAgentsRecord)) addIfAbsent(agent)
-  for (const agent of toAgentInfoList(userAgentsRecord)) addIfAbsent(agent)
-
-  return Array.from(mergedAgentMap.values())
-}
-
-function normalizeComparableName(agentName: string): string {
-  return stripAgentListSortPrefix(agentName).trim().toLowerCase()
-}
-
-function getCanonicalKey(agentName: string): string {
-  return resolveCanonicalDelegateAgentKey(agentName).trim().toLowerCase()
-}
-
-function buildComparableNames(agentName: string): Set<string> {
-  return new Set([
-    agentName,
-    getAgentDisplayName(agentName),
-    getAgentConfigKey(agentName),
-    resolveCanonicalDelegateAgentKey(agentName),
-    getCanonicalDelegateAgentDisplayName(agentName),
-  ].map(normalizeComparableName))
-}
-
-function matchesRequestedAgent(agent: AgentInfo, requestedAgentName: string): boolean {
-  const comparableNames = buildComparableNames(requestedAgentName)
-  const listedAgentName = normalizeComparableName(agent.name)
-  const listedAgentConfigKey = normalizeComparableName(getAgentConfigKey(agent.name))
-  const listedCanonicalKey = getCanonicalKey(agent.name)
-
-  return comparableNames.has(listedAgentName)
-    || comparableNames.has(listedAgentConfigKey)
-    || comparableNames.has(listedCanonicalKey)
-}
-
-export function isTaskCallableAgentMode(mode: AgentMode): boolean {
-  return mode === "all" || mode === "subagent"
-}
-
-function selectPreferredAgentMatch(
-  agents: AgentInfo[],
-  requestedAgentName: string,
-  modeMatcher: (mode: AgentMode) => boolean,
-): AgentInfo | undefined {
-  const candidates = agents.filter(
-    (agent) => modeMatcher(agent.mode) && matchesRequestedAgent(agent, requestedAgentName)
-  )
-  if (candidates.length === 0) {
-    return undefined
-  }
-
-  const requestedCanonicalKey = getCanonicalKey(requestedAgentName)
-  const canonicalCandidates = candidates.filter(
-    (agent) => getCanonicalKey(agent.name) === requestedCanonicalKey
-  )
-  if (canonicalCandidates.length === 0) {
-    return candidates[0]
-  }
-
-  // Prefer canonical runtime agent names over legacy aliases when both exist.
-  const preferredCanonical = canonicalCandidates.find((agent) =>
-    isCanonicalDelegateAgentKey(getAgentConfigKey(agent.name))
-  )
-  return preferredCanonical ?? canonicalCandidates[0]
-}
-
-export function findPrimaryAgentMatch(
-  agents: AgentInfo[],
-  requestedAgentName: string,
-): AgentInfo | undefined {
-  return selectPreferredAgentMatch(
-    agents,
-    requestedAgentName,
-    (mode) => mode === "primary",
-  )
-}
-
-export function findCallableAgentMatch(
-  agents: AgentInfo[],
-  requestedAgentName: string,
-): AgentInfo | undefined {
-  return selectPreferredAgentMatch(
-    agents,
-    requestedAgentName,
-    (mode) => isTaskCallableAgentMode(mode),
-  )
-}
-
-export function listCallableAgentNames(agents: AgentInfo[]): string {
-  const uniqueNames = new Map<string, string>()
-
-  for (const agent of agents) {
-    if (!isTaskCallableAgentMode(agent.mode)) {
-      continue
-    }
-    const canonicalKey = resolveCanonicalDelegateAgentKey(agent.name)
-    const displayName = isCanonicalDelegateAgentKey(canonicalKey)
-      ? getAgentDisplayName(canonicalKey)
-      : stripAgentListSortPrefix(agent.name)
-    const lookupKey = displayName.toLowerCase()
-    if (!uniqueNames.has(lookupKey)) {
-      uniqueNames.set(lookupKey, displayName)
-    }
-  }
-
-  return Array.from(uniqueNames.values())
-    .sort()
-    .join(", ")
-}