opencode-repos 0.3.0 → 0.3.1

package/oh-my-opencode/src/hooks/context-window-monitor.ts

@@ -1,99 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { createSystemDirective, SystemDirectiveTypes } from "../shared/system-directive"
-
-const ANTHROPIC_DISPLAY_LIMIT = 1_000_000
-const ANTHROPIC_ACTUAL_LIMIT =
-  process.env.ANTHROPIC_1M_CONTEXT === "true" ||
-  process.env.VERTEX_ANTHROPIC_1M_CONTEXT === "true"
-    ? 1_000_000
-    : 200_000
-const CONTEXT_WARNING_THRESHOLD = 0.70
-
-const CONTEXT_REMINDER = `${createSystemDirective(SystemDirectiveTypes.CONTEXT_WINDOW_MONITOR)}
-
-You are using Anthropic Claude with 1M context window.
-You have plenty of context remaining - do NOT rush or skip tasks.
-Complete your work thoroughly and methodically.`
-
-interface AssistantMessageInfo {
-  role: "assistant"
-  providerID: string
-  tokens: {
-    input: number
-    output: number
-    reasoning: number
-    cache: { read: number; write: number }
-  }
-}
-
-interface MessageWrapper {
-  info: { role: string } & Partial<AssistantMessageInfo>
-}
-
-export function createContextWindowMonitorHook(ctx: PluginInput) {
-  const remindedSessions = new Set<string>()
-
-  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
-
-    try {
-      const response = await ctx.client.session.messages({
-        path: { id: sessionID },
-      })
-
-      const messages = (response.data ?? response) as MessageWrapper[]
-
-      const assistantMessages = messages
-        .filter((m) => m.info.role === "assistant")
-        .map((m) => m.info as AssistantMessageInfo)
-
-      if (assistantMessages.length === 0) return
-
-      const lastAssistant = assistantMessages[assistantMessages.length - 1]
-      if (lastAssistant.providerID !== "anthropic") return
-
-      // Use only the last assistant message's input tokens
-      // This reflects the ACTUAL current context window usage (post-compaction)
-      const lastTokens = lastAssistant.tokens
-      const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0)
-
-      const actualUsagePercentage = totalInputTokens / ANTHROPIC_ACTUAL_LIMIT
-
-      if (actualUsagePercentage < CONTEXT_WARNING_THRESHOLD) return
-
-      remindedSessions.add(sessionID)
-
-      const displayUsagePercentage = totalInputTokens / ANTHROPIC_DISPLAY_LIMIT
-      const usedPct = (displayUsagePercentage * 100).toFixed(1)
-      const remainingPct = ((1 - displayUsagePercentage) * 100).toFixed(1)
-      const usedTokens = totalInputTokens.toLocaleString()
-      const limitTokens = ANTHROPIC_DISPLAY_LIMIT.toLocaleString()
-
-      output.output += `\n\n${CONTEXT_REMINDER}
-[Context Status: ${usedPct}% used (${usedTokens}/${limitTokens} tokens), ${remainingPct}% remaining]`
-    } catch {
-      // Graceful degradation - do not disrupt tool execution
-    }
-  }
-
-  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)
-      }
-    }
-  }
-
-  return {
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler,
-  }
-}

package/oh-my-opencode/src/hooks/delegate-task-retry/index.test.ts

@@ -1,119 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import {
-  DELEGATE_TASK_ERROR_PATTERNS,
-  detectDelegateTaskError,
-  buildRetryGuidance,
-} from "./index"
-
-describe("sisyphus-task-retry", () => {
-  describe("DELEGATE_TASK_ERROR_PATTERNS", () => {
-    // #given error patterns are defined
-    // #then should include all known delegate_task error types
-    it("should contain all known error patterns", () => {
-      expect(DELEGATE_TASK_ERROR_PATTERNS.length).toBeGreaterThan(5)
-      
-      const patternTexts = DELEGATE_TASK_ERROR_PATTERNS.map(p => p.pattern)
-      expect(patternTexts).toContain("run_in_background")
-      expect(patternTexts).toContain("skills")
-      expect(patternTexts).toContain("category OR subagent_type")
-      expect(patternTexts).toContain("Unknown category")
-      expect(patternTexts).toContain("Unknown agent")
-    })
-  })
-
-  describe("detectDelegateTaskError", () => {
-    // #given tool output with run_in_background error
-    // #when detecting error
-    // #then should return matching error info
-    it("should detect run_in_background missing error", () => {
-      const output = "❌ Invalid arguments: 'run_in_background' parameter is REQUIRED. Use run_in_background=false for task delegation."
-      
-      const result = detectDelegateTaskError(output)
-      
-      expect(result).not.toBeNull()
-      expect(result?.errorType).toBe("missing_run_in_background")
-    })
-
-    it("should detect skills missing error", () => {
-      const output = "❌ Invalid arguments: 'skills' parameter is REQUIRED. Use skills=[] if no skills needed."
-      
-      const result = detectDelegateTaskError(output)
-      
-      expect(result).not.toBeNull()
-      expect(result?.errorType).toBe("missing_skills")
-    })
-
-    it("should detect category/subagent mutual exclusion error", () => {
-      const output = "❌ Invalid arguments: Provide EITHER category OR subagent_type, not both."
-      
-      const result = detectDelegateTaskError(output)
-      
-      expect(result).not.toBeNull()
-      expect(result?.errorType).toBe("mutual_exclusion")
-    })
-
-    it("should detect unknown category error", () => {
-      const output = '❌ Unknown category: "invalid-cat". Available: visual-engineering, ultrabrain, quick'
-      
-      const result = detectDelegateTaskError(output)
-      
-      expect(result).not.toBeNull()
-      expect(result?.errorType).toBe("unknown_category")
-    })
-
-    it("should detect unknown agent error", () => {
-      const output = '❌ Unknown agent: "fake-agent". Available agents: explore, librarian, oracle'
-      
-      const result = detectDelegateTaskError(output)
-      
-      expect(result).not.toBeNull()
-      expect(result?.errorType).toBe("unknown_agent")
-    })
-
-    it("should return null for successful output", () => {
-      const output = "Background task launched.\n\nTask ID: bg_12345\nSession ID: ses_abc"
-      
-      const result = detectDelegateTaskError(output)
-      
-      expect(result).toBeNull()
-    })
-  })
-
-  describe("buildRetryGuidance", () => {
-    // #given detected error
-    // #when building retry guidance
-    // #then should return actionable fix instructions
-    it("should provide fix for missing run_in_background", () => {
-      const errorInfo = { errorType: "missing_run_in_background", originalOutput: "" }
-      
-      const guidance = buildRetryGuidance(errorInfo)
-      
-      expect(guidance).toContain("run_in_background")
-      expect(guidance).toContain("REQUIRED")
-    })
-
-    it("should provide fix for unknown category with available list", () => {
-      const errorInfo = { 
-        errorType: "unknown_category", 
-        originalOutput: '❌ Unknown category: "bad". Available: visual-engineering, ultrabrain' 
-      }
-      
-      const guidance = buildRetryGuidance(errorInfo)
-      
-      expect(guidance).toContain("visual-engineering")
-      expect(guidance).toContain("ultrabrain")
-    })
-
-    it("should provide fix for unknown agent with available list", () => {
-      const errorInfo = { 
-        errorType: "unknown_agent", 
-        originalOutput: '❌ Unknown agent: "fake". Available agents: explore, oracle' 
-      }
-      
-      const guidance = buildRetryGuidance(errorInfo)
-      
-      expect(guidance).toContain("explore")
-      expect(guidance).toContain("oracle")
-    })
-  })
-})

package/oh-my-opencode/src/hooks/delegate-task-retry/index.ts

@@ -1,136 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-
-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: "skills",
-    errorType: "missing_skills",
-    fixHint: "Add skills=[] parameter (empty array if no skills needed)",
-  },
-  {
-    pattern: "category OR subagent_type",
-    errorType: "mutual_exclusion",
-    fixHint: "Provide ONLY one of: category (e.g., 'general', 'quick') OR subagent_type (e.g., 'oracle', 'explore')",
-  },
-  {
-    pattern: "Must provide either category or subagent_type",
-    errorType: "missing_category_or_agent",
-    fixHint: "Add either category='general' OR subagent_type='explore'",
-  },
-  {
-    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 delegate_task. Use a subagent like 'explore', 'oracle', or 'librarian'",
-  },
-  {
-    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("❌")) return null
-
-  for (const errorPattern of DELEGATE_TASK_ERROR_PATTERNS) {
-    if (output.includes(errorPattern.pattern)) {
-      return {
-        errorType: errorPattern.errorType,
-        originalOutput: output,
-      }
-    }
-  }
-
-  return null
-}
-
-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 `[delegate_task ERROR] Fix the error and retry with correct parameters.`
-  }
-
-  let guidance = `
-[delegate_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 delegate_task NOW with corrected parameters.
-
-Example of CORRECT call:
-\`\`\`
-delegate_task(
-  description="Task description",
-  prompt="Detailed prompt...",
-  category="unspecified-low",  // OR subagent_type="explore"
-  run_in_background=false,
-  skills=[]
-)
-\`\`\`
-`
-
-  return guidance
-}
-
-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() !== "delegate_task") return
-
-      const errorInfo = detectDelegateTaskError(output.output)
-      if (errorInfo) {
-        const guidance = buildRetryGuidance(errorInfo)
-        output.output += `\n${guidance}`
-      }
-    },
-  }
-}

package/oh-my-opencode/src/hooks/directory-agents-injector/constants.ts

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

package/oh-my-opencode/src/hooks/directory-agents-injector/index.ts

@@ -1,182 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import {
-  loadInjectedPaths,
-  saveInjectedPaths,
-  clearInjectedPaths,
-} from "./storage";
-import { AGENTS_FILENAME } from "./constants";
-import { createDynamicTruncator } from "../../shared/dynamic-truncator";
-
-interface ToolExecuteInput {
-  tool: string;
-  sessionID: string;
-  callID: string;
-}
-
-interface ToolExecuteOutput {
-  title: string;
-  output: string;
-  metadata: unknown;
-}
-
-interface ToolExecuteBeforeOutput {
-  args: unknown;
-}
-
-interface BatchToolCall {
-  tool: string;
-  parameters: Record<string, unknown>;
-}
-
-interface EventInput {
-  event: {
-    type: string;
-    properties?: unknown;
-  };
-}
-
-export function createDirectoryAgentsInjectorHook(ctx: PluginInput) {
-  const sessionCaches = new Map<string, Set<string>>();
-  const pendingBatchReads = new Map<string, string[]>();
-  const truncator = createDynamicTruncator(ctx);
-
-  function getSessionCache(sessionID: string): Set<string> {
-    if (!sessionCaches.has(sessionID)) {
-      sessionCaches.set(sessionID, loadInjectedPaths(sessionID));
-    }
-    return sessionCaches.get(sessionID)!;
-  }
-
-  function resolveFilePath(path: string): string | null {
-    if (!path) return null;
-    if (path.startsWith("/")) return path;
-    return resolve(ctx.directory, path);
-  }
-
-  function findAgentsMdUp(startDir: string): string[] {
-    const found: string[] = [];
-    let current = startDir;
-
-    while (true) {
-      // Skip root AGENTS.md - OpenCode's system.ts already loads it via custom()
-      // See: https://github.com/code-yeongyu/oh-my-opencode/issues/379
-      const isRootDir = current === ctx.directory;
-      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(ctx.directory)) break;
-      current = parent;
-    }
-
-    return found.reverse();
-  }
-
-  async function processFilePathForInjection(
-    filePath: string,
-    sessionID: string,
-    output: ToolExecuteOutput,
-  ): Promise<void> {
-    const resolved = resolveFilePath(filePath);
-    if (!resolved) return;
-
-    const dir = dirname(resolved);
-    const cache = getSessionCache(sessionID);
-    const agentsPaths = findAgentsMdUp(dir);
-
-    for (const agentsPath of agentsPaths) {
-      const agentsDir = dirname(agentsPath);
-      if (cache.has(agentsDir)) continue;
-
-      try {
-        const content = readFileSync(agentsPath, "utf-8");
-        const { result, truncated } = await truncator.truncate(sessionID, content);
-        const truncationNotice = truncated
-          ? `\n\n[Note: Content was truncated to save context window space. For full context, please read the file directly: ${agentsPath}]`
-          : "";
-        output.output += `\n\n[Directory Context: ${agentsPath}]\n${result}${truncationNotice}`;
-        cache.add(agentsDir);
-      } catch {}
-    }
-
-    saveInjectedPaths(sessionID, cache);
-  }
-
-  const toolExecuteBefore = async (
-    input: ToolExecuteInput,
-    output: ToolExecuteBeforeOutput,
-  ) => {
-    if (input.tool.toLowerCase() !== "batch") return;
-
-    const args = output.args as { tool_calls?: BatchToolCall[] } | undefined;
-    if (!args?.tool_calls) return;
-
-    const readFilePaths: string[] = [];
-    for (const call of args.tool_calls) {
-      if (call.tool.toLowerCase() === "read" && call.parameters?.filePath) {
-        readFilePaths.push(call.parameters.filePath as string);
-      }
-    }
-
-    if (readFilePaths.length > 0) {
-      pendingBatchReads.set(input.callID, readFilePaths);
-    }
-  };
-
-  const toolExecuteAfter = async (
-    input: ToolExecuteInput,
-    output: ToolExecuteOutput,
-  ) => {
-    const toolName = input.tool.toLowerCase();
-
-    if (toolName === "read") {
-      await processFilePathForInjection(output.title, input.sessionID, output);
-      return;
-    }
-
-    if (toolName === "batch") {
-      const filePaths = pendingBatchReads.get(input.callID);
-      if (filePaths) {
-        for (const filePath of filePaths) {
-          await processFilePathForInjection(filePath, input.sessionID, output);
-        }
-        pendingBatchReads.delete(input.callID);
-      }
-    }
-  };
-
-  const eventHandler = async ({ event }: EventInput) => {
-    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) {
-        sessionCaches.delete(sessionInfo.id);
-        clearInjectedPaths(sessionInfo.id);
-      }
-    }
-
-    if (event.type === "session.compacted") {
-      const sessionID = (props?.sessionID ??
-        (props?.info as { id?: string } | undefined)?.id) as string | undefined;
-      if (sessionID) {
-        sessionCaches.delete(sessionID);
-        clearInjectedPaths(sessionID);
-      }
-    }
-  };
-
-  return {
-    "tool.execute.before": toolExecuteBefore,
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler,
-  };
-}

package/oh-my-opencode/src/hooks/directory-agents-injector/storage.ts

@@ -1,48 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-  unlinkSync,
-} from "node:fs";
-import { join } from "node:path";
-import { AGENTS_INJECTOR_STORAGE } from "./constants";
-import type { InjectedPathsData } from "./types";
-
-function getStoragePath(sessionID: string): string {
-  return join(AGENTS_INJECTOR_STORAGE, `${sessionID}.json`);
-}
-
-export function loadInjectedPaths(sessionID: string): Set<string> {
-  const filePath = getStoragePath(sessionID);
-  if (!existsSync(filePath)) return new Set();
-
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    const data: InjectedPathsData = JSON.parse(content);
-    return new Set(data.injectedPaths);
-  } catch {
-    return new Set();
-  }
-}
-
-export function saveInjectedPaths(sessionID: string, paths: Set<string>): void {
-  if (!existsSync(AGENTS_INJECTOR_STORAGE)) {
-    mkdirSync(AGENTS_INJECTOR_STORAGE, { recursive: true });
-  }
-
-  const data: InjectedPathsData = {
-    sessionID,
-    injectedPaths: [...paths],
-    updatedAt: Date.now(),
-  };
-
-  writeFileSync(getStoragePath(sessionID), JSON.stringify(data, null, 2));
-}
-
-export function clearInjectedPaths(sessionID: string): void {
-  const filePath = getStoragePath(sessionID);
-  if (existsSync(filePath)) {
-    unlinkSync(filePath);
-  }
-}

package/oh-my-opencode/src/hooks/directory-agents-injector/types.ts

@@ -1,5 +0,0 @@
-export interface InjectedPathsData {
-  sessionID: string;
-  injectedPaths: string[];
-  updatedAt: number;
-}

package/oh-my-opencode/src/hooks/directory-readme-injector/constants.ts

@@ -1,9 +0,0 @@
-import { join } from "node:path";
-import { getOpenCodeStorageDir } from "../../shared/data-path";
-
-export const OPENCODE_STORAGE = getOpenCodeStorageDir();
-export const README_INJECTOR_STORAGE = join(
-  OPENCODE_STORAGE,
-  "directory-readme",
-);
-export const README_FILENAME = "README.md";