@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/agents/dynamic-agent-policy-sections.ts

@@ -1,182 +0,0 @@
-import type {
-  AvailableAgent,
-  AvailableCategory,
-  AvailableSkill,
-} from "./dynamic-agent-prompt-types"
-
-export function buildHardBlocksSection(): string {
-  const blocks = [
-    "- Type error suppression (`as any`, `@ts-ignore`) - **Never**",
-    "- Commit without explicit request - **Never**",
-    "- Speculate about unread code - **Never**",
-    "- Leave code in broken state after failures - **Never**",
-    "- `background_cancel(all=true)` - **Never.** Always cancel individually by taskId.",
-    "- Delivering final answer before collecting Critic result when a review gate was requested - **Never.**",
-  ]
-
-  return `## Hard Blocks (NEVER violate)
-
-${blocks.join("\n")}`
-}
-
-export function buildAntiPatternsSection(): string {
-  const patterns = [
-    "- **Type Safety**: `as any`, `@ts-ignore`, `@ts-expect-error`",
-    "- **Error Handling**: Empty catch blocks `catch(e) {}`",
-    '- **Testing**: Deleting failing tests to "pass"',
-    "- **Search**: Firing agents for single-line typos or obvious syntax errors",
-    "- **Debugging**: Shotgun debugging, random changes",
-    "- **Background Tasks**: Polling `background_output` on running tasks - end response and wait for notification",
-    "- **Delegation Duplication**: Delegating research to researcher and then manually doing the same search yourself",
-    "- **Critic**: Delivering answer without collecting Critic results when a review gate was requested",
-  ]
-
-  return `## Anti-Patterns (blocking violations)
-
-${patterns.join("\n")}`
-}
-
-export function buildHardRulesSection(): string {
-  return buildHardBlocksSection() + "\n\n" + buildAntiPatternsSection()
-}
-
-export function buildToolCallFormatSection(): string {
-  return `## Tool Call Format
-
-**ALWAYS use the native tool calling mechanism. NEVER output tool calls as text.**
-
-When you need to call a tool:
-1. Use the tool call interface provided by the system
-2. Do NOT write tool calls as plain text like \`assistant to=functions.XXX\`
-3. Do NOT output JSON directly in your text response
-4. The system handles tool call formatting automatically
-
-**CORRECT**: Invoke the tool through the tool call interface
-**WRONG**: Writing \`assistant to=functions.todowrite\` or \`json\n{...}\` as text
-
-Your tool calls are processed automatically. Just invoke the tool - do not format the call yourself.`
-}
-
-export function buildUltraworkSection(
-  agents: AvailableAgent[],
-  categories: AvailableCategory[],
-  skills: AvailableSkill[],
-): string {
-  const lines: string[] = []
-
-  if (categories.length > 0) {
-    lines.push("**Categories** (for implementation tasks):")
-    for (const category of categories) {
-      const shortDescription = category.description || category.name
-      lines.push(`- \`${category.name}\`: ${shortDescription}`)
-    }
-    lines.push("")
-  }
-
-  if (skills.length > 0) {
-    const builtinSkills = skills.filter((skill) => skill.location === "plugin")
-    const customSkills = skills.filter((skill) => skill.location !== "plugin")
-
-    if (builtinSkills.length > 0) {
-      lines.push("**Built-in Skills** (combine with categories):")
-      for (const skill of builtinSkills) {
-        const shortDescription = skill.description.split(".")[0] || skill.description
-        lines.push(`- \`${skill.name}\`: ${shortDescription}`)
-      }
-      lines.push("")
-    }
-
-    if (customSkills.length > 0) {
-      lines.push("**User-Installed Skills** (HIGH PRIORITY - user installed these for their workflow):")
-      for (const skill of customSkills) {
-        const shortDescription = skill.description.split(".")[0] || skill.description
-        lines.push(`- \`${skill.name}\`: ${shortDescription}`)
-      }
-      lines.push("")
-    }
-  }
-
-  if (agents.length > 0) {
-    const ultraworkAgentPriority = ["researcher", "strategist", "critic"]
-    const sortedAgents = [...agents].sort((left, right) => {
-      const leftIndex = ultraworkAgentPriority.indexOf(left.name)
-      const rightIndex = ultraworkAgentPriority.indexOf(right.name)
-      if (leftIndex === -1 && rightIndex === -1) {
-        return 0
-      }
-      if (leftIndex === -1) {
-        return 1
-      }
-      if (rightIndex === -1) {
-        return -1
-      }
-      return leftIndex - rightIndex
-    })
-
-    lines.push("**Agents** (for specialized consultation and research):")
-    for (const agent of sortedAgents) {
-      const shortDescription =
-        agent.description.length > 120
-          ? `${agent.description.slice(0, 120)}...`
-          : agent.description
-      const suffix =
-        agent.name === "researcher" ? " (multiple/background)" : ""
-      lines.push(`- \`${agent.name}${suffix}\`: ${shortDescription}`)
-    }
-  }
-
-  return lines.join("\n")
-}
-
-export function buildAntiDuplicationSection(): string {
-  return `<Anti_Duplication>
-## Anti-Duplication Rule
-
-Once you delegate research to researcher, **DO NOT perform the same search yourself**.
-
-### What this means:
-
-**FORBIDDEN:**
-- After firing researcher, manually grep/search for the same information
-- Re-doing the research the agents were just tasked with
-- "Just quickly checking" the same files the background agents are checking
-
-**ALLOWED:**
-- Continue with **non-overlapping work** - work that doesn't depend on the delegated research
-- Work on unrelated parts of the codebase
-- Preparation work (e.g., setting up files, configs) that can proceed independently
-
-### Wait for Results Properly:
-
-When you need the delegated results but they're not ready:
-
-1. **End your response** - do NOT continue with work that depends on those results
-2. **Wait for the completion notification** - the system will trigger your next turn
-3. **Then** collect results via \`background_output(task_id="...")\`
-4. **Do NOT** impatiently re-search the same topics while waiting
-
-### Example:
-
-\`\`\`typescript
-// WRONG: After delegating, re-doing the search
-task(subagent_type="researcher", run_in_background=true, ...)
-// Then immediately grep for the same thing yourself - FORBIDDEN
-
-// CORRECT: Continue non-overlapping work
-task(subagent_type="researcher", run_in_background=true, ...)
-// Work on a different, unrelated file while they search
-// End your response and wait for the notification
-\`\`\`
-</Anti_Duplication>`
-}
-
-export function buildToolUsageRulesSection(): string {
-  return `<tool_usage_rules>
-- Parallelize independent tool calls: multiple file reads, grep searches, agent fires - all at once
-- Researcher = background grep. ALWAYS \`run_in_background=true\`, ALWAYS parallel
-- Fire 2-5 researcher agents in parallel for any non-trivial codebase question
-- Parallelize independent file reads - don't read files one at a time
-- After any write/edit tool call, briefly restate what changed, where, and what validation follows
-- Prefer tools over internal knowledge whenever you need specific data (files, configs, patterns)
-</tool_usage_rules>`;
-}

package/src/agents/dynamic-agent-prompt-builder.ts

@@ -1,32 +0,0 @@
-export type {
-  AvailableAgent,
-  AvailableTool,
-  AvailableSkill,
-  AvailableCategory,
-} from "./dynamic-agent-prompt-types"
-
-export { categorizeTools } from "./dynamic-agent-tool-categorization"
-
-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/src/agents/dynamic-agent-prompt-types.ts

@@ -1,24 +0,0 @@
-import type { AgentPromptMetadata } from "./types"
-
-export interface AvailableAgent {
-  name: string
-  description: string
-  metadata: AgentPromptMetadata
-}
-
-export interface AvailableTool {
-  name: string
-  category: "lsp" | "ast" | "search" | "session" | "command" | "other"
-}
-
-export interface AvailableSkill {
-  name: string
-  description: string
-  location: "user" | "project" | "plugin"
-}
-
-export interface AvailableCategory {
-  name: string
-  description: string
-  model?: string
-}

package/src/agents/dynamic-agent-tool-categorization.ts

@@ -1,45 +0,0 @@
-import type { AvailableTool } from "./dynamic-agent-prompt-types"
-
-export function categorizeTools(toolNames: string[]): AvailableTool[] {
-  return toolNames.map((name) => {
-    let category: AvailableTool["category"] = "other"
-    if (name.startsWith("lsp_")) {
-      category = "lsp"
-    } else if (name.startsWith("ast_grep")) {
-      category = "ast"
-    } else if (name === "grep" || name === "glob") {
-      category = "search"
-    } else if (name.startsWith("session_")) {
-      category = "session"
-    } else if (name === "skill") {
-      category = "command"
-    }
-    return { name, category }
-  })
-}
-
-function formatToolsForPrompt(tools: AvailableTool[]): string {
-  const lspTools = tools.filter((tool) => tool.category === "lsp")
-  const astTools = tools.filter((tool) => tool.category === "ast")
-  const searchTools = tools.filter((tool) => tool.category === "search")
-
-  const parts: string[] = []
-
-  if (searchTools.length > 0) {
-    parts.push(...searchTools.map((tool) => `\`${tool.name}\``))
-  }
-
-  if (lspTools.length > 0) {
-    parts.push("`lsp_*`")
-  }
-
-  if (astTools.length > 0) {
-    parts.push("`ast_grep`")
-  }
-
-  return parts.join(", ")
-}
-
-export function getToolsPromptDisplay(tools: AvailableTool[]): string {
-  return formatToolsForPrompt(tools)
-}

package/src/agents/env-context.ts

@@ -1,16 +0,0 @@
-/**
- * Creates OmO-specific environment context (timezone, locale).
- * Note: Working directory, platform, and date are already provided by OpenCode's system.ts,
- * so we only include fields that OpenCode doesn't provide to avoid duplication.
- * See: https://github.com/code-yeongyu/hiai-opencode/issues/379
- */
-export function createEnvContext(): string {
-  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone
-  const locale = Intl.DateTimeFormat().resolvedOptions().locale
-
-  return `
-<omo-env>
-  Timezone: ${timezone}
-  Locale: ${locale}
-</omo-env>`
-}

package/src/agents/gpt-apply-patch-guard.ts

@@ -1,7 +0,0 @@
-import { isGptModel } from "./types"
-
-export const GPT_APPLY_PATCH_GUIDANCE = "Use the `edit` and `write` tools for file changes. Do not use `apply_patch` on GPT models - it is unreliable here and can hang during verification."
-
-export function getGptApplyPatchPermission(model: string): Record<string, "deny"> {
-  return isGptModel(model) ? { apply_patch: "deny" as const } : {}
-}

package/src/agents/guard/agent.ts

@@ -1,146 +0,0 @@
-/**
- * Guard - Master Orchestrator Agent
- *
- * Orchestrates work via task() to complete ALL tasks in a todo list until fully done.
- * You are the conductor of a symphony of specialized agents.
- *
- * Routing:
- * 1. GPT models (openai/*, github-copilot/gpt-*) → gpt.ts (GPT-5.4 optimized)
- * 2. Gemini models (google/*, google-vertex/*) → gemini.ts (Gemini-optimized)
- * 3. Default (Claude, etc.) → default.ts (Claude-optimized)
- */
-
-import type { AgentConfig } from "@opencode-ai/sdk"
-import type { AgentMode, AgentPromptMetadata } from "../types"
-import { isGptModel, isGeminiModel } from "../types"
-import type { AvailableAgent, AvailableSkill, AvailableCategory } from "../dynamic-agent-prompt-builder"
-import { buildAgentIdentitySection, buildCategorySkillsDelegationGuide } from "../dynamic-agent-prompt-builder"
-import type { CategoryConfig } from "../../config/schema"
-import { mergeCategories } from "../../shared/merge-categories"
-
-import { getDefaultGuardPrompt } from "./default"
-import { getGptGuardPrompt } from "./gpt"
-import { getGeminiGuardPrompt } from "./gemini"
-import {
-  getCategoryDescription,
-  buildAgentSelectionSection,
-  buildCategorySection,
-  buildSkillsSection,
-  buildDecisionMatrix,
-} from "./prompt-section-builder"
-
-const MODE: AgentMode = "primary"
-
-export type GuardPromptSource = "default" | "gpt" | "gemini"
-
-/**
- * Determines which Guard prompt to use based on model.
- */
-export function getGuardPromptSource(model?: string): GuardPromptSource {
-  if (model && isGptModel(model)) {
-    return "gpt"
-  }
-  if (model && isGeminiModel(model)) {
-    return "gemini"
-  }
-  return "default"
-}
-
-export interface OrchestratorContext {
-  model?: string
-  availableAgents?: AvailableAgent[]
-  availableSkills?: AvailableSkill[]
-  userCategories?: Record<string, CategoryConfig>
-}
-
-/**
- * Gets the appropriate Guard prompt based on model.
- */
-export function getGuardPrompt(model?: string): string {
-  const source = getGuardPromptSource(model)
-
-  switch (source) {
-    case "gpt":
-      return getGptGuardPrompt()
-    case "gemini":
-      return getGeminiGuardPrompt()
-    case "default":
-    default:
-      return getDefaultGuardPrompt()
-  }
-}
-
-function buildDynamicOrchestratorPrompt(ctx?: OrchestratorContext): string {
-  const agents = ctx?.availableAgents ?? []
-  const skills = ctx?.availableSkills ?? []
-  const userCategories = ctx?.userCategories
-  const model = ctx?.model
-
-  const allCategories = mergeCategories(userCategories)
-  const availableCategories: AvailableCategory[] = Object.entries(allCategories).map(([name]) => ({
-    name,
-    description: getCategoryDescription(name, userCategories),
-  }))
-
-  const categorySection = buildCategorySection(userCategories)
-  const agentSection = buildAgentSelectionSection(agents)
-  const decisionMatrix = buildDecisionMatrix(agents, userCategories)
-  const skillsSection = buildSkillsSection(skills)
-  const categorySkillsGuide = buildCategorySkillsDelegationGuide(availableCategories, skills)
-
-  const agentIdentity = buildAgentIdentitySection(
-    "Guard",
-    "Master Orchestrator agent from HiaiOpenCode that coordinates specialized agents to complete todo lists",
-  )
-  const basePrompt = getGuardPrompt(model)
-
-  return agentIdentity + "\n" + basePrompt
-    .replace("{CATEGORY_SECTION}", categorySection)
-    .replace("{AGENT_SECTION}", agentSection)
-    .replace("{DECISION_MATRIX}", decisionMatrix)
-    .replace("{SKILLS_SECTION}", skillsSection)
-    .replace("{{CATEGORY_SKILLS_DELEGATION_GUIDE}}", categorySkillsGuide)
-}
-
-export function createGuardAgent(ctx: OrchestratorContext): AgentConfig {
-  const baseConfig = {
-    description:
-      "Orchestrates work via task() to complete ALL tasks in a todo list until fully done. (Guard - HiaiOpenCode)",
-    mode: MODE,
-    ...(ctx.model ? { model: ctx.model } : {}),
-    temperature: 0.1,
-    prompt: buildDynamicOrchestratorPrompt(ctx),
-    color: "#10B981",
-  }
-
-  return baseConfig as AgentConfig
-}
-createGuardAgent.mode = MODE
-
-export const guardPromptMetadata: AgentPromptMetadata = {
-  category: "advisor",
-  cost: "EXPENSIVE",
-  promptAlias: "Guard",
-  triggers: [
-    {
-      domain: "Todo list orchestration",
-      trigger: "Complete ALL tasks in a todo list with verification",
-    },
-    {
-      domain: "Multi-agent coordination",
-      trigger: "Parallel task execution across specialized agents",
-    },
-  ],
-  useWhen: [
-    "User provides a todo list path (.bob/plans/{name}.md)",
-    "Multiple tasks need to be completed in sequence or parallel",
-    "Work requires coordination across multiple specialized agents",
-  ],
-  avoidWhen: [
-    "Single simple task that doesn't require orchestration",
-    "Tasks that can be handled directly by one agent",
-    "When user wants to execute tasks manually",
-  ],
-  keyTrigger:
-    "Todo list path provided OR multiple tasks requiring multi-agent orchestration",
-}