opencode-repos 0.2.0 → 0.3.0

package/oh-my-opencode/src/features/task-toast-manager/manager.test.ts

@@ -0,0 +1,249 @@
+import { describe, test, expect, beforeEach, mock } from "bun:test"
+import { TaskToastManager } from "./manager"
+import type { ConcurrencyManager } from "../background-agent/concurrency"
+
+describe("TaskToastManager", () => {
+  let mockClient: {
+    tui: {
+      showToast: ReturnType<typeof mock>
+    }
+  }
+  let toastManager: TaskToastManager
+  let mockConcurrencyManager: ConcurrencyManager
+
+  beforeEach(() => {
+    mockClient = {
+      tui: {
+        showToast: mock(() => Promise.resolve()),
+      },
+    }
+    mockConcurrencyManager = {
+      getConcurrencyLimit: mock(() => 5),
+    } as unknown as ConcurrencyManager
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    toastManager = new TaskToastManager(mockClient as any, mockConcurrencyManager)
+  })
+
+  describe("skills in toast message", () => {
+    test("should display skills when provided", () => {
+      // #given - a task with skills
+      const task = {
+        id: "task_1",
+        description: "Test task",
+        agent: "Sisyphus-Junior",
+        isBackground: true,
+        skills: ["playwright", "git-master"],
+      }
+
+      // #when - addTask is called
+      toastManager.addTask(task)
+
+      // #then - toast message should include skills
+      expect(mockClient.tui.showToast).toHaveBeenCalled()
+      const call = mockClient.tui.showToast.mock.calls[0][0]
+      expect(call.body.message).toContain("playwright")
+      expect(call.body.message).toContain("git-master")
+    })
+
+    test("should not display skills section when no skills provided", () => {
+      // #given - a task without skills
+      const task = {
+        id: "task_2",
+        description: "Test task without skills",
+        agent: "explore",
+        isBackground: true,
+      }
+
+      // #when - addTask is called
+      toastManager.addTask(task)
+
+      // #then - toast message should not include skills prefix
+      expect(mockClient.tui.showToast).toHaveBeenCalled()
+      const call = mockClient.tui.showToast.mock.calls[0][0]
+      expect(call.body.message).not.toContain("Skills:")
+    })
+  })
+
+  describe("concurrency info in toast message", () => {
+    test("should display concurrency status in toast", () => {
+      // #given - multiple running tasks
+      toastManager.addTask({
+        id: "task_1",
+        description: "First task",
+        agent: "explore",
+        isBackground: true,
+      })
+      toastManager.addTask({
+        id: "task_2",
+        description: "Second task",
+        agent: "librarian",
+        isBackground: true,
+      })
+
+      // #when - third task is added
+      toastManager.addTask({
+        id: "task_3",
+        description: "Third task",
+        agent: "explore",
+        isBackground: true,
+      })
+
+      // #then - toast should show concurrency info
+      expect(mockClient.tui.showToast).toHaveBeenCalledTimes(3)
+      const lastCall = mockClient.tui.showToast.mock.calls[2][0]
+      // Should show "Running (3):" header
+      expect(lastCall.body.message).toContain("Running (3):")
+    })
+
+    test("should display concurrency limit info when available", () => {
+      // #given - a concurrency manager with known limit
+      const mockConcurrencyWithCounts = {
+        getConcurrencyLimit: mock(() => 5),
+        getRunningCount: mock(() => 2),
+        getQueuedCount: mock(() => 1),
+      } as unknown as ConcurrencyManager
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const managerWithConcurrency = new TaskToastManager(mockClient as any, mockConcurrencyWithCounts)
+
+      // #when - a task is added
+      managerWithConcurrency.addTask({
+        id: "task_1",
+        description: "Test task",
+        agent: "explore",
+        isBackground: true,
+      })
+
+      // #then - toast should show concurrency status like "2/5 slots"
+      expect(mockClient.tui.showToast).toHaveBeenCalled()
+      const call = mockClient.tui.showToast.mock.calls[0][0]
+      expect(call.body.message).toMatch(/\d+\/\d+/)
+    })
+  })
+
+  describe("combined skills and concurrency display", () => {
+    test("should display both skills and concurrency info together", () => {
+      // #given - a task with skills and concurrency manager
+      const task = {
+        id: "task_1",
+        description: "Full info task",
+        agent: "Sisyphus-Junior",
+        isBackground: true,
+        skills: ["frontend-ui-ux"],
+      }
+
+      // #when - addTask is called
+      toastManager.addTask(task)
+
+      // #then - toast should include both skills and task count
+      expect(mockClient.tui.showToast).toHaveBeenCalled()
+      const call = mockClient.tui.showToast.mock.calls[0][0]
+      expect(call.body.message).toContain("frontend-ui-ux")
+      expect(call.body.message).toContain("Running (1):")
+    })
+  })
+
+  describe("model fallback info in toast message", () => {
+    test("should NOT display warning when model is category-default (normal behavior)", () => {
+      // #given - category-default is the intended behavior, not a fallback
+      const task = {
+        id: "task_1",
+        description: "Task with category default model",
+        agent: "Sisyphus-Junior",
+        isBackground: false,
+        modelInfo: { model: "google/gemini-3-pro-preview", type: "category-default" as const },
+      }
+
+      // #when - addTask is called
+      toastManager.addTask(task)
+
+      // #then - toast should NOT show warning - category default is expected
+      expect(mockClient.tui.showToast).toHaveBeenCalled()
+      const call = mockClient.tui.showToast.mock.calls[0][0]
+      expect(call.body.message).not.toContain("⚠️")
+      expect(call.body.message).not.toContain("(category default)")
+    })
+
+    test("should display warning when model falls back to system-default", () => {
+      // #given - system-default is a fallback (no category default, no user config)
+      const task = {
+        id: "task_1b",
+        description: "Task with system default model",
+        agent: "Sisyphus-Junior",
+        isBackground: false,
+        modelInfo: { model: "anthropic/claude-sonnet-4-5", type: "system-default" as const },
+      }
+
+      // #when - addTask is called
+      toastManager.addTask(task)
+
+      // #then - toast should show fallback warning
+      expect(mockClient.tui.showToast).toHaveBeenCalled()
+      const call = mockClient.tui.showToast.mock.calls[0][0]
+      expect(call.body.message).toContain("⚠️")
+      expect(call.body.message).toContain("anthropic/claude-sonnet-4-5")
+      expect(call.body.message).toContain("(system default fallback)")
+    })
+
+    test("should display warning when model is inherited from parent", () => {
+      // #given - inherited is a fallback (custom category without model definition)
+      const task = {
+        id: "task_2",
+        description: "Task with inherited model",
+        agent: "Sisyphus-Junior",
+        isBackground: false,
+        modelInfo: { model: "cliproxy/claude-opus-4-5", type: "inherited" as const },
+      }
+
+      // #when - addTask is called
+      toastManager.addTask(task)
+
+      // #then - toast should show fallback warning
+      expect(mockClient.tui.showToast).toHaveBeenCalled()
+      const call = mockClient.tui.showToast.mock.calls[0][0]
+      expect(call.body.message).toContain("⚠️")
+      expect(call.body.message).toContain("cliproxy/claude-opus-4-5")
+      expect(call.body.message).toContain("(inherited from parent)")
+    })
+
+    test("should not display model info when user-defined", () => {
+      // #given - a task with user-defined model
+      const task = {
+        id: "task_3",
+        description: "Task with user model",
+        agent: "Sisyphus-Junior",
+        isBackground: false,
+        modelInfo: { model: "my-provider/my-model", type: "user-defined" as const },
+      }
+
+      // #when - addTask is called
+      toastManager.addTask(task)
+
+      // #then - toast should NOT show model warning
+      expect(mockClient.tui.showToast).toHaveBeenCalled()
+      const call = mockClient.tui.showToast.mock.calls[0][0]
+      expect(call.body.message).not.toContain("⚠️ Model:")
+      expect(call.body.message).not.toContain("(inherited)")
+      expect(call.body.message).not.toContain("(category default)")
+      expect(call.body.message).not.toContain("(system default)")
+    })
+
+    test("should not display model info when not provided", () => {
+      // #given - a task without model info
+      const task = {
+        id: "task_4",
+        description: "Task without model info",
+        agent: "explore",
+        isBackground: true,
+      }
+
+      // #when - addTask is called
+      toastManager.addTask(task)
+
+      // #then - toast should NOT show model warning
+      expect(mockClient.tui.showToast).toHaveBeenCalled()
+      const call = mockClient.tui.showToast.mock.calls[0][0]
+      expect(call.body.message).not.toContain("⚠️ Model:")
+    })
+  })
+})

package/oh-my-opencode/src/features/task-toast-manager/manager.ts

@@ -0,0 +1,215 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+import type { TrackedTask, TaskStatus, ModelFallbackInfo } from "./types"
+import type { ConcurrencyManager } from "../background-agent/concurrency"
+
+type OpencodeClient = PluginInput["client"]
+
+export class TaskToastManager {
+  private tasks: Map<string, TrackedTask> = new Map()
+  private client: OpencodeClient
+  private concurrencyManager?: ConcurrencyManager
+
+  constructor(client: OpencodeClient, concurrencyManager?: ConcurrencyManager) {
+    this.client = client
+    this.concurrencyManager = concurrencyManager
+  }
+
+  setConcurrencyManager(manager: ConcurrencyManager): void {
+    this.concurrencyManager = manager
+  }
+
+  addTask(task: {
+    id: string
+    description: string
+    agent: string
+    isBackground: boolean
+    status?: TaskStatus
+    skills?: string[]
+    modelInfo?: ModelFallbackInfo
+  }): void {
+    const trackedTask: TrackedTask = {
+      id: task.id,
+      description: task.description,
+      agent: task.agent,
+      status: task.status ?? "running",
+      startedAt: new Date(),
+      isBackground: task.isBackground,
+      skills: task.skills,
+      modelInfo: task.modelInfo,
+    }
+
+    this.tasks.set(task.id, trackedTask)
+    this.showTaskListToast(trackedTask)
+  }
+
+  /**
+   * Update task status
+   */
+  updateTask(id: string, status: TaskStatus): void {
+    const task = this.tasks.get(id)
+    if (task) {
+      task.status = status
+    }
+  }
+
+  /**
+   * Remove completed/error task
+   */
+  removeTask(id: string): void {
+    this.tasks.delete(id)
+  }
+
+  /**
+   * Get all running tasks (newest first)
+   */
+  getRunningTasks(): TrackedTask[] {
+    const running = Array.from(this.tasks.values())
+      .filter((t) => t.status === "running")
+      .sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime())
+    return running
+  }
+
+  /**
+   * Get all queued tasks
+   */
+  getQueuedTasks(): TrackedTask[] {
+    return Array.from(this.tasks.values())
+      .filter((t) => t.status === "queued")
+      .sort((a, b) => a.startedAt.getTime() - b.startedAt.getTime())
+  }
+
+  /**
+   * Format duration since task started
+   */
+  private formatDuration(startedAt: Date): string {
+    const seconds = Math.floor((Date.now() - startedAt.getTime()) / 1000)
+    if (seconds < 60) return `${seconds}s`
+    const minutes = Math.floor(seconds / 60)
+    if (minutes < 60) return `${minutes}m ${seconds % 60}s`
+    const hours = Math.floor(minutes / 60)
+    return `${hours}h ${minutes % 60}m`
+  }
+
+  private getConcurrencyInfo(): string {
+    if (!this.concurrencyManager) return ""
+    const running = this.getRunningTasks()
+    const queued = this.getQueuedTasks()
+    const total = running.length + queued.length
+    const limit = this.concurrencyManager.getConcurrencyLimit("default")
+    if (limit === Infinity) return ""
+    return ` [${total}/${limit}]`
+  }
+
+  private buildTaskListMessage(newTask: TrackedTask): string {
+    const running = this.getRunningTasks()
+    const queued = this.getQueuedTasks()
+    const concurrencyInfo = this.getConcurrencyInfo()
+
+    const lines: string[] = []
+
+    const isFallback = newTask.modelInfo && (
+      newTask.modelInfo.type === "inherited" || newTask.modelInfo.type === "system-default"
+    )
+    if (isFallback) {
+      const suffixMap: Record<"inherited" | "system-default", string> = {
+        inherited: " (inherited from parent)",
+        "system-default": " (system default fallback)",
+      }
+      const suffix = suffixMap[newTask.modelInfo!.type as "inherited" | "system-default"]
+      lines.push(`⚠️ Model fallback: ${newTask.modelInfo!.model}${suffix}`)
+      lines.push("")
+    }
+
+    if (running.length > 0) {
+      lines.push(`Running (${running.length}):${concurrencyInfo}`)
+      for (const task of running) {
+        const duration = this.formatDuration(task.startedAt)
+        const bgIcon = task.isBackground ? "⚡" : "🔄"
+        const isNew = task.id === newTask.id ? " ← NEW" : ""
+        const skillsInfo = task.skills?.length ? ` [${task.skills.join(", ")}]` : ""
+        lines.push(`${bgIcon} ${task.description} (${task.agent})${skillsInfo} - ${duration}${isNew}`)
+      }
+    }
+
+    if (queued.length > 0) {
+      if (lines.length > 0) lines.push("")
+      lines.push(`Queued (${queued.length}):`)
+      for (const task of queued) {
+        const bgIcon = task.isBackground ? "⏳" : "⏸️"
+        const skillsInfo = task.skills?.length ? ` [${task.skills.join(", ")}]` : ""
+        const isNew = task.id === newTask.id ? " ← NEW" : ""
+        lines.push(`${bgIcon} ${task.description} (${task.agent})${skillsInfo} - Queued${isNew}`)
+      }
+    }
+
+    return lines.join("\n")
+  }
+
+  /**
+   * Show consolidated toast with all running/queued tasks
+   */
+  private showTaskListToast(newTask: TrackedTask): void {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const tuiClient = this.client as any
+    if (!tuiClient.tui?.showToast) return
+
+    const message = this.buildTaskListMessage(newTask)
+    const running = this.getRunningTasks()
+    const queued = this.getQueuedTasks()
+
+    const title = newTask.isBackground
+      ? `⚡ New Background Task`
+      : `🔄 New Task Executed`
+
+    tuiClient.tui.showToast({
+      body: {
+        title,
+        message: message || `${newTask.description} (${newTask.agent})`,
+        variant: "info",
+        duration: running.length + queued.length > 2 ? 5000 : 3000,
+      },
+    }).catch(() => {})
+  }
+
+  /**
+   * Show task completion toast
+   */
+  showCompletionToast(task: { id: string; description: string; duration: string }): void {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const tuiClient = this.client as any
+    if (!tuiClient.tui?.showToast) return
+
+    this.removeTask(task.id)
+
+    const remaining = this.getRunningTasks()
+    const queued = this.getQueuedTasks()
+
+    let message = `✅ "${task.description}" finished in ${task.duration}`
+    if (remaining.length > 0 || queued.length > 0) {
+      message += `\n\nStill running: ${remaining.length} | Queued: ${queued.length}`
+    }
+
+    tuiClient.tui.showToast({
+      body: {
+        title: "Task Completed",
+        message,
+        variant: "success",
+        duration: 5000,
+      },
+    }).catch(() => {})
+  }
+}
+
+let instance: TaskToastManager | null = null
+
+export function getTaskToastManager(): TaskToastManager | null {
+  return instance
+}
+
+export function initTaskToastManager(
+  client: OpencodeClient,
+  concurrencyManager?: ConcurrencyManager
+): TaskToastManager {
+  instance = new TaskToastManager(client, concurrencyManager)
+  return instance
+}

package/oh-my-opencode/src/features/task-toast-manager/types.ts

@@ -0,0 +1,24 @@
+export type TaskStatus = "running" | "queued" | "completed" | "error"
+
+export interface ModelFallbackInfo {
+  model: string
+  type: "user-defined" | "inherited" | "category-default" | "system-default"
+}
+
+export interface TrackedTask {
+  id: string
+  description: string
+  agent: string
+  status: TaskStatus
+  startedAt: Date
+  isBackground: boolean
+  skills?: string[]
+  modelInfo?: ModelFallbackInfo
+}
+
+export interface TaskToastOptions {
+  title: string
+  message: string
+  variant: "info" | "success" | "warning" | "error"
+  duration?: number
+}

package/oh-my-opencode/src/hooks/AGENTS.md

@@ -0,0 +1,73 @@
+# HOOKS KNOWLEDGE BASE
+
+## OVERVIEW
+
+31 lifecycle hooks intercepting/modifying agent behavior. Events: PreToolUse, PostToolUse, UserPromptSubmit, Stop, onSummarize.
+
+## STRUCTURE
+
+```
+hooks/
+├── atlas/                      # Main orchestration & delegation (771 lines)
+├── anthropic-context-window-limit-recovery/  # Auto-summarize at token limit
+├── todo-continuation-enforcer.ts # Force TODO completion
+├── ralph-loop/                 # Self-referential dev loop until done
+├── claude-code-hooks/          # settings.json hook compat layer (13 files)
+├── comment-checker/            # Prevents AI slop/excessive comments
+├── auto-slash-command/         # Detects /command patterns
+├── rules-injector/             # Conditional rules from .claude/rules/
+├── directory-agents-injector/  # Auto-injects AGENTS.md files
+├── directory-readme-injector/  # Auto-injects README.md files
+├── preemptive-compaction/      # Triggers summary at 85% context
+├── edit-error-recovery/        # Recovers from tool failures
+├── thinking-block-validator/   # Ensures valid <thinking> format
+├── context-window-monitor.ts   # Reminds agents of remaining headroom
+├── session-recovery/           # Auto-recovers from crashes
+├── think-mode/                 # Dynamic thinking budget
+├── keyword-detector/           # ultrawork/search/analyze modes
+├── background-notification/    # OS notification on task completion
+└── tool-output-truncator.ts    # Prevents context bloat
+```
+
+## HOOK EVENTS
+
+| Event | Timing | Can Block | Use Case |
+|-------|--------|-----------|----------|
+| PreToolUse | Before tool | Yes | Validate/modify inputs, inject context |
+| PostToolUse | After tool | No | Append warnings, truncate output |
+| UserPromptSubmit | On prompt | Yes | Keyword detection, mode switching |
+| Stop | Session idle | No | Auto-continue (todo-continuation, ralph-loop) |
+| onSummarize | Compaction | No | Preserve critical state |
+
+## EXECUTION ORDER
+
+**chat.message**: keywordDetector → claudeCodeHooks → autoSlashCommand → startWork → ralphLoop
+
+**tool.execute.before**: claudeCodeHooks → nonInteractiveEnv → commentChecker → directoryAgentsInjector → directoryReadmeInjector → rulesInjector
+
+**tool.execute.after**: editErrorRecovery → delegateTaskRetry → commentChecker → toolOutputTruncator → emptyTaskResponseDetector → claudeCodeHooks
+
+## HOW TO ADD
+
+1. Create `src/hooks/name/` with `index.ts` exporting `createMyHook(ctx)`
+2. Implement event handlers: `"tool.execute.before"`, `"tool.execute.after"`, etc.
+3. Add hook name to `HookNameSchema` in `src/config/schema.ts`
+4. Register in `src/index.ts`:
+   ```typescript
+   const myHook = isHookEnabled("my-hook") ? createMyHook(ctx) : null
+   // Add to event handlers
+   ```
+
+## PATTERNS
+
+- **Session-scoped state**: `Map<sessionID, Set<string>>` for tracking per-session
+- **Conditional execution**: Check `input.tool` before processing
+- **Output modification**: `output.output += "\n${REMINDER}"` to append context
+- **Async state**: Use promises for CLI path resolution, cache results
+
+## ANTI-PATTERNS
+
+- **Blocking non-critical**: Use PostToolUse warnings instead of PreToolUse blocks
+- **Heavy computation**: Keep PreToolUse light - slows every tool call
+- **Redundant injection**: Track injected files to prevent duplicates
+- **Verbose output**: Keep hook messages technical, brief

package/oh-my-opencode/src/hooks/agent-usage-reminder/constants.ts

@@ -0,0 +1,54 @@
+import { join } from "node:path";
+import { getOpenCodeStorageDir } from "../../shared/data-path";
+
+export const OPENCODE_STORAGE = getOpenCodeStorageDir();
+export const AGENT_USAGE_REMINDER_STORAGE = join(
+  OPENCODE_STORAGE,
+  "agent-usage-reminder",
+);
+
+// All tool names normalized to lowercase for case-insensitive matching
+export const TARGET_TOOLS = new Set([
+  "grep",
+  "safe_grep",
+  "glob",
+  "safe_glob",
+  "webfetch",
+  "context7_resolve-library-id",
+  "context7_query-docs",
+  "websearch_web_search_exa",
+  "context7_get-library-docs",
+  "grep_app_searchgithub",
+]);
+
+export const AGENT_TOOLS = new Set([
+  "task",
+  "call_omo_agent",
+  "delegate_task",
+]);
+
+export const REMINDER_MESSAGE = `
+[Agent Usage Reminder]
+
+You called a search/fetch tool directly without leveraging specialized agents.
+
+RECOMMENDED: Use delegate_task with explore/librarian agents for better results:
+
+\`\`\`
+// Parallel exploration - fire multiple agents simultaneously
+delegate_task(agent="explore", prompt="Find all files matching pattern X")
+delegate_task(agent="explore", prompt="Search for implementation of Y") 
+delegate_task(agent="librarian", prompt="Lookup documentation for Z")
+
+// Then continue your work while they run in background
+// System will notify you when each completes
+\`\`\`
+
+WHY:
+- Agents can perform deeper, more thorough searches
+- Background tasks run in parallel, saving time
+- Specialized agents have domain expertise
+- Reduces context window usage in main session
+
+ALWAYS prefer: Multiple parallel delegate_task calls > Direct tool calls
+`;