@hiai-gg/hiai-opencode 0.1.1 → 0.1.2

package/src/hooks/context-window-monitor.ts

@@ -1,113 +1,113 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import {
-  resolveActualContextLimit,
-  type ContextLimitModelCacheState,
-} from "../shared/context-limit-resolver"
-import { createSystemDirective, SystemDirectiveTypes } from "../shared/system-directive"
-
-const CONTEXT_WARNING_THRESHOLD = 0.70
-
-function createContextReminder(actualLimit: number): string {
-  const limitTokens = actualLimit.toLocaleString()
-
-  return `${createSystemDirective(SystemDirectiveTypes.CONTEXT_WINDOW_MONITOR)}
-
-You are using a ${limitTokens}-token context window.
-You still have context remaining - do NOT rush or skip tasks.
-Complete your work thoroughly and methodically.`
-}
-
-interface TokenInfo {
-  input: number
-  output: number
-  reasoning: number
-  cache: { read: number; write: number }
-}
-
-interface CachedTokenState {
-  providerID: string
-  modelID: string
-  tokens: TokenInfo
-}
-
-export function createContextWindowMonitorHook(
-  _ctx: PluginInput,
-  modelCacheState?: ContextLimitModelCacheState,
-) {
-  const remindedSessions = new Set<string>()
-  const tokenCache = new Map<string, CachedTokenState>()
-
-  const toolExecuteAfter = async (
-    input: { tool: string; sessionID: string; callID: string },
-    output: { title: string; output: string; metadata: unknown }
-  ) => {
-    const { sessionID } = input
-
-    if (remindedSessions.has(sessionID)) return
-
-    const cached = tokenCache.get(sessionID)
-    if (!cached) return
-
-    const actualLimit = resolveActualContextLimit(
-      cached.providerID,
-      cached.modelID,
-      modelCacheState,
-    )
-
-    if (!actualLimit) return
-
-    const lastTokens = cached.tokens
-    const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0)
-
-    const actualUsagePercentage = totalInputTokens / actualLimit
-
-    if (actualUsagePercentage < CONTEXT_WARNING_THRESHOLD) return
-
-    remindedSessions.add(sessionID)
-
-    const usedPct = (actualUsagePercentage * 100).toFixed(1)
-    const remainingPct = ((1 - actualUsagePercentage) * 100).toFixed(1)
-    const usedTokens = totalInputTokens.toLocaleString()
-    const limitTokens = actualLimit.toLocaleString()
-
-    output.output += `\n\n${createContextReminder(actualLimit)}
-[Context Status: ${usedPct}% used (${usedTokens}/${limitTokens} tokens), ${remainingPct}% remaining]`
-  }
-
-  const eventHandler = async ({ event }: { event: { type: string; properties?: unknown } }) => {
-    const props = event.properties as Record<string, unknown> | undefined
-
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info as { id?: string } | undefined
-      if (sessionInfo?.id) {
-        remindedSessions.delete(sessionInfo.id)
-        tokenCache.delete(sessionInfo.id)
-      }
-    }
-
-    if (event.type === "message.updated") {
-      const info = props?.info as {
-        role?: string
-        sessionID?: string
-        providerID?: string
-        modelID?: string
-        finish?: boolean
-        tokens?: TokenInfo
-      } | undefined
-
-      if (!info || info.role !== "assistant" || !info.finish) return
-      if (!info.sessionID || !info.providerID || !info.tokens) return
-
-      tokenCache.set(info.sessionID, {
-        providerID: info.providerID,
-        modelID: info.modelID ?? "",
-        tokens: info.tokens,
-      })
-    }
-  }
-
-  return {
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler,
-  }
-}
+import type { PluginInput } from "@opencode-ai/plugin"
+import {
+  resolveActualContextLimit,
+  type ContextLimitModelCacheState,
+} from "../shared/context-limit-resolver"
+import { createSystemDirective, SystemDirectiveTypes } from "../shared/system-directive"
+
+const CONTEXT_WARNING_THRESHOLD = 0.70
+
+function createContextReminder(actualLimit: number): string {
+  const limitTokens = actualLimit.toLocaleString()
+
+  return `${createSystemDirective(SystemDirectiveTypes.CONTEXT_WINDOW_MONITOR)}
+
+You are using a ${limitTokens}-token context window.
+You still have context remaining - do NOT rush or skip tasks.
+Complete your work thoroughly and methodically.`
+}
+
+interface TokenInfo {
+  input: number
+  output: number
+  reasoning: number
+  cache: { read: number; write: number }
+}
+
+interface CachedTokenState {
+  providerID: string
+  modelID: string
+  tokens: TokenInfo
+}
+
+export function createContextWindowMonitorHook(
+  _ctx: PluginInput,
+  modelCacheState?: ContextLimitModelCacheState,
+) {
+  const remindedSessions = new Set<string>()
+  const tokenCache = new Map<string, CachedTokenState>()
+
+  const toolExecuteAfter = async (
+    input: { tool: string; sessionID: string; callID: string },
+    output: { title: string; output: string; metadata: unknown }
+  ) => {
+    const { sessionID } = input
+
+    if (remindedSessions.has(sessionID)) return
+
+    const cached = tokenCache.get(sessionID)
+    if (!cached) return
+
+    const actualLimit = resolveActualContextLimit(
+      cached.providerID,
+      cached.modelID,
+      modelCacheState,
+    )
+
+    if (!actualLimit) return
+
+    const lastTokens = cached.tokens
+    const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0)
+
+    const actualUsagePercentage = totalInputTokens / actualLimit
+
+    if (actualUsagePercentage < CONTEXT_WARNING_THRESHOLD) return
+
+    remindedSessions.add(sessionID)
+
+    const usedPct = (actualUsagePercentage * 100).toFixed(1)
+    const remainingPct = ((1 - actualUsagePercentage) * 100).toFixed(1)
+    const usedTokens = totalInputTokens.toLocaleString()
+    const limitTokens = actualLimit.toLocaleString()
+
+    output.output += `\n\n${createContextReminder(actualLimit)}
+[Context Status: ${usedPct}% used (${usedTokens}/${limitTokens} tokens), ${remainingPct}% remaining]`
+  }
+
+  const eventHandler = async ({ event }: { event: { type: string; properties?: unknown } }) => {
+    const props = event.properties as Record<string, unknown> | undefined
+
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info as { id?: string } | undefined
+      if (sessionInfo?.id) {
+        remindedSessions.delete(sessionInfo.id)
+        tokenCache.delete(sessionInfo.id)
+      }
+    }
+
+    if (event.type === "message.updated") {
+      const info = props?.info as {
+        role?: string
+        sessionID?: string
+        providerID?: string
+        modelID?: string
+        finish?: boolean
+        tokens?: TokenInfo
+      } | undefined
+
+      if (!info || info.role !== "assistant" || !info.finish) return
+      if (!info.sessionID || !info.providerID || !info.tokens) return
+
+      tokenCache.set(info.sessionID, {
+        providerID: info.providerID,
+        modelID: info.modelID ?? "",
+        tokens: info.tokens,
+      })
+    }
+  }
+
+  return {
+    "tool.execute.after": toolExecuteAfter,
+    event: eventHandler,
+  }
+}

package/src/hooks/delegate-task-retry/guidance.ts

@@ -1,45 +1,45 @@
-import { DELEGATE_TASK_ERROR_PATTERNS, type DetectedError } from "./patterns"
-
-function extractAvailableList(output: string): string | null {
-  const availableMatch = output.match(/Available[^:]*:\s*(.+)$/m)
-  return availableMatch ? availableMatch[1].trim() : null
-}
-
-export function buildRetryGuidance(errorInfo: DetectedError): string {
-  const pattern = DELEGATE_TASK_ERROR_PATTERNS.find(
-    (p) => p.errorType === errorInfo.errorType
-  )
-
-  if (!pattern) {
-    return `[task ERROR] Fix the error and retry with correct parameters.`
-  }
-
-  let guidance = `
- [task CALL FAILED - IMMEDIATE RETRY REQUIRED]
- 
- **Error Type**: ${errorInfo.errorType}
- **Fix**: ${pattern.fixHint}
- `
-
-  const availableList = extractAvailableList(errorInfo.originalOutput)
-  if (availableList) {
-    guidance += `\n**Available Options**: ${availableList}\n`
-  }
-
-  guidance += `
- **Action**: Retry task NOW with corrected parameters.
- 
- Example of CORRECT call:
- \`\`\`
- task(
-   description="Task description",
-   prompt="Detailed prompt...",
-   category="unspecified-low",  // OR subagent_type="researcher"
-   run_in_background=false,
-   load_skills=[]
- )
- \`\`\`
- `
-
-  return guidance
-}
+import { DELEGATE_TASK_ERROR_PATTERNS, type DetectedError } from "./patterns"
+
+function extractAvailableList(output: string): string | null {
+  const availableMatch = output.match(/Available[^:]*:\s*(.+)$/m)
+  return availableMatch ? availableMatch[1].trim() : null
+}
+
+export function buildRetryGuidance(errorInfo: DetectedError): string {
+  const pattern = DELEGATE_TASK_ERROR_PATTERNS.find(
+    (p) => p.errorType === errorInfo.errorType
+  )
+
+  if (!pattern) {
+    return `[task ERROR] Fix the error and retry with correct parameters.`
+  }
+
+  let guidance = `
+ [task CALL FAILED - IMMEDIATE RETRY REQUIRED]
+ 
+ **Error Type**: ${errorInfo.errorType}
+ **Fix**: ${pattern.fixHint}
+ `
+
+  const availableList = extractAvailableList(errorInfo.originalOutput)
+  if (availableList) {
+    guidance += `\n**Available Options**: ${availableList}\n`
+  }
+
+  guidance += `
+ **Action**: Retry task NOW with corrected parameters.
+ 
+ Example of CORRECT call:
+ \`\`\`
+ task(
+   description="Task description",
+   prompt="Detailed prompt...",
+   category="unspecified-low",  // OR subagent_type="researcher"
+   run_in_background=false,
+   load_skills=[]
+ )
+ \`\`\`
+ `
+
+  return guidance
+}

package/src/hooks/delegate-task-retry/hook.ts

@@ -1,22 +1,22 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-
-import { buildRetryGuidance } from "./guidance"
-import { detectDelegateTaskError } from "./patterns"
-
-export function createDelegateTaskRetryHook(_ctx: PluginInput) {
-  return {
-    "tool.execute.after": async (
-      input: { tool: string; sessionID: string; callID: string },
-      output: { title: string; output: string; metadata: unknown }
-    ) => {
-      if (input.tool.toLowerCase() !== "task") return
-      if (typeof output.output !== "string") return
-
-      const errorInfo = detectDelegateTaskError(output.output)
-      if (errorInfo) {
-        const guidance = buildRetryGuidance(errorInfo)
-        output.output += `\n${guidance}`
-      }
-    },
-  }
-}
+import type { PluginInput } from "@opencode-ai/plugin"
+
+import { buildRetryGuidance } from "./guidance"
+import { detectDelegateTaskError } from "./patterns"
+
+export function createDelegateTaskRetryHook(_ctx: PluginInput) {
+  return {
+    "tool.execute.after": async (
+      input: { tool: string; sessionID: string; callID: string },
+      output: { title: string; output: string; metadata: unknown }
+    ) => {
+      if (input.tool.toLowerCase() !== "task") return
+      if (typeof output.output !== "string") return
+
+      const errorInfo = detectDelegateTaskError(output.output)
+      if (errorInfo) {
+        const guidance = buildRetryGuidance(errorInfo)
+        output.output += `\n${guidance}`
+      }
+    },
+  }
+}

package/src/hooks/delegate-task-retry/index.ts

@@ -1,4 +1,4 @@
-export type { DelegateTaskErrorPattern, DetectedError } from "./patterns"
-export { DELEGATE_TASK_ERROR_PATTERNS, detectDelegateTaskError } from "./patterns"
-export { buildRetryGuidance } from "./guidance"
-export { createDelegateTaskRetryHook } from "./hook"
+export type { DelegateTaskErrorPattern, DetectedError } from "./patterns"
+export { DELEGATE_TASK_ERROR_PATTERNS, detectDelegateTaskError } from "./patterns"
+export { buildRetryGuidance } from "./guidance"
+export { createDelegateTaskRetryHook } from "./hook"

package/src/hooks/delegate-task-retry/patterns.ts

@@ -1,77 +1,77 @@
-export interface DelegateTaskErrorPattern {
-  pattern: string
-  errorType: string
-  fixHint: string
-}
-
-export const DELEGATE_TASK_ERROR_PATTERNS: DelegateTaskErrorPattern[] = [
-  {
-    pattern: "run_in_background",
-    errorType: "missing_run_in_background",
-    fixHint:
-      "Add run_in_background=false (for delegation) or run_in_background=true (for parallel exploration)",
-  },
-  {
-    pattern: "load_skills",
-    errorType: "missing_load_skills",
-    fixHint:
-      "Add load_skills=[] parameter (empty array if no skills needed). Note: Calling Skill tool does NOT populate this.",
-  },
-  {
-    pattern: "category OR subagent_type",
-    errorType: "mutual_exclusion",
-    fixHint:
-      "Provide ONLY one of: category (e.g., 'general', 'quick') OR subagent_type (e.g., 'researcher', 'strategist')",
-  },
-  {
-    pattern: "Must provide either category or subagent_type",
-    errorType: "missing_category_or_agent",
-    fixHint: "Add either category='general' OR subagent_type='researcher'",
-  },
-  {
-    pattern: "Unknown category",
-    errorType: "unknown_category",
-    fixHint: "Use a valid category from the Available list in the error message",
-  },
-  {
-    pattern: "Agent name cannot be empty",
-    errorType: "empty_agent",
-    fixHint: "Provide a non-empty subagent_type value",
-  },
-  {
-    pattern: "Unknown agent",
-    errorType: "unknown_agent",
-    fixHint: "Use a valid agent from the Available agents list in the error message",
-  },
-  {
-    pattern: "Cannot call primary agent",
-    errorType: "primary_agent",
-    fixHint:
-      "Primary agents cannot be called via task. Use a delegated agent like 'researcher', 'strategist', or 'critic'",
-  },
-  {
-    pattern: "Skills not found",
-    errorType: "unknown_skills",
-    fixHint: "Use valid skill names from the Available list in the error message",
-  },
-]
-
-export interface DetectedError {
-  errorType: string
-  originalOutput: string
-}
-
-export function detectDelegateTaskError(output: string): DetectedError | null {
-  if (!output.includes("[ERROR]") && !output.includes("Invalid arguments")) return null
-
-  for (const errorPattern of DELEGATE_TASK_ERROR_PATTERNS) {
-    if (output.includes(errorPattern.pattern)) {
-      return {
-        errorType: errorPattern.errorType,
-        originalOutput: output,
-      }
-    }
-  }
-
-  return null
-}
+export interface DelegateTaskErrorPattern {
+  pattern: string
+  errorType: string
+  fixHint: string
+}
+
+export const DELEGATE_TASK_ERROR_PATTERNS: DelegateTaskErrorPattern[] = [
+  {
+    pattern: "run_in_background",
+    errorType: "missing_run_in_background",
+    fixHint:
+      "Add run_in_background=false (for delegation) or run_in_background=true (for parallel exploration)",
+  },
+  {
+    pattern: "load_skills",
+    errorType: "missing_load_skills",
+    fixHint:
+      "Add load_skills=[] parameter (empty array if no skills needed). Note: Calling Skill tool does NOT populate this.",
+  },
+  {
+    pattern: "category OR subagent_type",
+    errorType: "mutual_exclusion",
+    fixHint:
+      "Provide ONLY one of: category (e.g., 'general', 'quick') OR subagent_type (e.g., 'researcher', 'strategist')",
+  },
+  {
+    pattern: "Must provide either category or subagent_type",
+    errorType: "missing_category_or_agent",
+    fixHint: "Add either category='general' OR subagent_type='researcher'",
+  },
+  {
+    pattern: "Unknown category",
+    errorType: "unknown_category",
+    fixHint: "Use a valid category from the Available list in the error message",
+  },
+  {
+    pattern: "Agent name cannot be empty",
+    errorType: "empty_agent",
+    fixHint: "Provide a non-empty subagent_type value",
+  },
+  {
+    pattern: "Unknown agent",
+    errorType: "unknown_agent",
+    fixHint: "Use a valid agent from the Available agents list in the error message",
+  },
+  {
+    pattern: "Cannot call primary agent",
+    errorType: "primary_agent",
+    fixHint:
+      "Primary agents cannot be called via task. Use a delegated agent like 'researcher', 'strategist', or 'critic'",
+  },
+  {
+    pattern: "Skills not found",
+    errorType: "unknown_skills",
+    fixHint: "Use valid skill names from the Available list in the error message",
+  },
+]
+
+export interface DetectedError {
+  errorType: string
+  originalOutput: string
+}
+
+export function detectDelegateTaskError(output: string): DetectedError | null {
+  if (!output.includes("[ERROR]") && !output.includes("Invalid arguments")) return null
+
+  for (const errorPattern of DELEGATE_TASK_ERROR_PATTERNS) {
+    if (output.includes(errorPattern.pattern)) {
+      return {
+        errorType: errorPattern.errorType,
+        originalOutput: output,
+      }
+    }
+  }
+
+  return null
+}

package/src/hooks/directory-agents-injector/constants.ts

@@ -1,7 +1,7 @@
-import { join } from "node:path";
-import { OPENCODE_STORAGE } from "../../shared";
-export const AGENTS_INJECTOR_STORAGE = join(
-  OPENCODE_STORAGE,
-  "directory-agents",
-);
-export const AGENTS_FILENAME = "AGENTS.md";
+import { join } from "node:path";
+import { OPENCODE_STORAGE } from "../../shared";
+export const AGENTS_INJECTOR_STORAGE = join(
+  OPENCODE_STORAGE,
+  "directory-agents",
+);
+export const AGENTS_FILENAME = "AGENTS.md";

package/src/hooks/directory-agents-injector/finder.ts

@@ -1,38 +1,38 @@
-import { existsSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-
-import { AGENTS_FILENAME } from "./constants";
-
-export function resolveFilePath(rootDirectory: string, path: string): string | null {
-  if (!path) return null;
-  if (isAbsolute(path)) return path;
-  return resolve(rootDirectory, path);
-}
-
-export function findAgentsMdUp(input: {
-  startDir: string;
-  rootDir: string;
-}): string[] {
-  const found: string[] = [];
-  let current = input.startDir;
-
-  while (true) {
-    // Skip root AGENTS.md - OpenCode's system.ts already loads it via custom()
-    // See: https://github.com/code-yeongyu/hiai-opencode/issues/379
-    const isRootDir = current === input.rootDir;
-    if (!isRootDir) {
-      const agentsPath = join(current, AGENTS_FILENAME);
-      if (existsSync(agentsPath)) {
-        found.push(agentsPath);
-      }
-    }
-
-    if (isRootDir) break;
-    const parent = dirname(current);
-    if (parent === current) break;
-    if (!parent.startsWith(input.rootDir)) break;
-    current = parent;
-  }
-
-  return found.reverse();
-}
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+
+import { AGENTS_FILENAME } from "./constants";
+
+export function resolveFilePath(rootDirectory: string, path: string): string | null {
+  if (!path) return null;
+  if (isAbsolute(path)) return path;
+  return resolve(rootDirectory, path);
+}
+
+export function findAgentsMdUp(input: {
+  startDir: string;
+  rootDir: string;
+}): string[] {
+  const found: string[] = [];
+  let current = input.startDir;
+
+  while (true) {
+    // Skip root AGENTS.md - OpenCode's system.ts already loads it via custom()
+    // See: https://github.com/code-yeongyu/hiai-opencode/issues/379
+    const isRootDir = current === input.rootDir;
+    if (!isRootDir) {
+      const agentsPath = join(current, AGENTS_FILENAME);
+      if (existsSync(agentsPath)) {
+        found.push(agentsPath);
+      }
+    }
+
+    if (isRootDir) break;
+    const parent = dirname(current);
+    if (parent === current) break;
+    if (!parent.startsWith(input.rootDir)) break;
+    current = parent;
+  }
+
+  return found.reverse();
+}