@mindfoldhq/trellis 0.4.0-beta.9 → 0.4.0-rc.1

package/dist/templates/opencode/lib/trellis-context.js

@@ -1,23 +1,16 @@
 /**
  * Trellis Context Manager
  *
- * Unified context management for OpenCode plugins.
- * Handles detection of oh-my-opencode, .claude/hooks/, and other edge cases.
- *
- * Usage:
- *   import { TrellisContext } from "./trellis-context.js"
- *   const ctx = new TrellisContext(directory)
- *   if (ctx.shouldSkipHook("session-start")) return
+ * Utility class for OpenCode plugins providing file reading,
+ * JSONL parsing, and context building capabilities.
  */
 
 import { existsSync, readFileSync, appendFileSync, readdirSync } from "fs"
 import { isAbsolute, join } from "path"
-import { homedir, platform } from "os"
+import { platform } from "os"
 import { execSync } from "child_process"
 
-// Python command: Windows uses 'python', macOS/Linux use 'python3'
 const PYTHON_CMD = platform() === "win32" ? "python" : "python3"
-
 // Debug logging
 const DEBUG_LOG = "/tmp/trellis-plugin-debug.log"
 
@@ -33,151 +26,17 @@ function debugLog(prefix, ...args) {
 
 /**
  * Trellis Context Manager
- *
- * Centralized logic for:
- * - Detecting oh-my-opencode installation
- * - Checking .claude/hooks/ presence
- * - Determining which plugin should handle each hook
  */
 export class TrellisContext {
   constructor(directory) {
     this.directory = directory
-    this._omoInstalled = null
-    this._omoHooksEnabled = null
-    this._claudeHooksPresent = {}
-
     debugLog("context", "TrellisContext initialized", { directory })
   }
 
-  // ============================================================
-  // oh-my-opencode Detection
-  // ============================================================
-
-  /**
-   * Check if oh-my-opencode is installed
-   *
-   * Detection order:
-   * 1. Check if oh-my-opencode.json exists (most reliable)
-   * 2. Fallback: check opencode.json plugin list
-   */
-  isOmoInstalled() {
-    if (this._omoInstalled !== null) {
-      return this._omoInstalled
-    }
-
-    try {
-      const configDir = join(homedir(), ".config", "opencode")
-
-      // Method 1: Check oh-my-opencode.json existence (omo-specific config)
-      const omoConfigPath = join(configDir, "oh-my-opencode.json")
-      if (existsSync(omoConfigPath)) {
-        this._omoInstalled = true
-        debugLog("context", "omo installed: oh-my-opencode.json exists")
-        return true
-      }
-
-      // Method 2: Fallback to plugin list check
-      const configPath = join(configDir, "opencode.json")
-      if (!existsSync(configPath)) {
-        this._omoInstalled = false
-        debugLog("context", "omo not installed: no config files")
-        return false
-      }
-
-      const content = readFileSync(configPath, "utf-8")
-      const config = JSON.parse(content)
-      const plugins = config.plugin || []
-
-      this._omoInstalled = plugins.some(p =>
-        typeof p === "string" && p.toLowerCase().includes("oh-my-opencode")
-      )
-
-      debugLog("context", "omo installed (plugin list):", this._omoInstalled)
-      return this._omoInstalled
-    } catch (e) {
-      debugLog("context", "omo detection error:", e.message)
-      this._omoInstalled = false
-      return false
-    }
-  }
-
-  /**
-   * Check if omo's claude_code.hooks is enabled
-   * Reads oh-my-opencode.json or defaults to true
-   */
-  isOmoHooksEnabled() {
-    if (this._omoHooksEnabled !== null) {
-      return this._omoHooksEnabled
-    }
-
-    if (!this.isOmoInstalled()) {
-      this._omoHooksEnabled = false
-      return false
-    }
-
-    try {
-      // Check global config
-      const globalConfig = join(homedir(), ".config", "opencode", "oh-my-opencode.json")
-      if (existsSync(globalConfig)) {
-        const content = readFileSync(globalConfig, "utf-8")
-        const config = JSON.parse(content)
-        if (config.claude_code?.hooks === false) {
-          this._omoHooksEnabled = false
-          debugLog("context", "omo hooks disabled in global config")
-          return false
-        }
-      }
-
-      // Check project config
-      const projectConfig = join(this.directory, "oh-my-opencode.json")
-      if (existsSync(projectConfig)) {
-        const content = readFileSync(projectConfig, "utf-8")
-        const config = JSON.parse(content)
-        if (config.claude_code?.hooks === false) {
-          this._omoHooksEnabled = false
-          debugLog("context", "omo hooks disabled in project config")
-          return false
-        }
-      }
-
-      // Default: enabled
-      this._omoHooksEnabled = true
-      debugLog("context", "omo hooks enabled (default)")
-      return true
-    } catch (e) {
-      debugLog("context", "omo hooks detection error:", e.message)
-      this._omoHooksEnabled = true // Default to enabled
-      return true
-    }
-  }
-
-  // ============================================================
-  // .claude/hooks/ Detection
-  // ============================================================
-
-  /**
-   * Check if a specific .claude/hooks/ file exists
-   */
-  hasClaudeHook(hookName) {
-    if (hookName in this._claudeHooksPresent) {
-      return this._claudeHooksPresent[hookName]
-    }
-
-    const hookPath = join(this.directory, ".claude", "hooks", `${hookName}.py`)
-    const exists = existsSync(hookPath)
-
-    this._claudeHooksPresent[hookName] = exists
-    debugLog("context", `claude hook ${hookName}:`, exists)
-    return exists
-  }
-
   // ============================================================
   // Trellis Project Detection
   // ============================================================
 
-  /**
-   * Check if this is a Trellis-managed project
-   */
   isTrellisProject() {
     return existsSync(join(this.directory, ".trellis"))
   }
@@ -237,54 +96,10 @@ export class TrellisContext {
     return join(this.directory, ".trellis", "tasks", normalized)
   }
 
-  // ============================================================
-  // Hook Decision Logic
-  // ============================================================
-
-  /**
-   * Determine if our plugin should skip this hook
-   * (because omo will handle it via .claude/hooks/)
-   *
-   * @param {string} hookName - Hook name without extension (e.g., "session-start")
-   * @returns {boolean} - true if we should skip, false if we should handle
-   */
-  shouldSkipHook(hookName) {
-    // Not a Trellis project? Skip.
-    if (!this.isTrellisProject()) {
-      debugLog("context", `shouldSkipHook(${hookName}): skip - not Trellis project`)
-      return true
-    }
-
-    // omo not installed? We handle it.
-    if (!this.isOmoInstalled()) {
-      debugLog("context", `shouldSkipHook(${hookName}): handle - omo not installed`)
-      return false
-    }
-
-    // omo installed but hooks disabled? We handle it.
-    if (!this.isOmoHooksEnabled()) {
-      debugLog("context", `shouldSkipHook(${hookName}): handle - omo hooks disabled`)
-      return false
-    }
-
-    // omo installed + hooks enabled + .claude/hooks/ exists? Skip (omo handles).
-    if (this.hasClaudeHook(hookName)) {
-      debugLog("context", `shouldSkipHook(${hookName}): skip - omo will handle via .claude/hooks/`)
-      return true
-    }
-
-    // omo installed but no .claude/hooks/ file? We handle it.
-    debugLog("context", `shouldSkipHook(${hookName}): handle - no .claude/hooks/ file`)
-    return false
-  }
-
   // ============================================================
   // File Reading Utilities
   // ============================================================
 
-  /**
-   * Read a file, return null on error
-   */
   readFile(filePath) {
     try {
       if (existsSync(filePath)) {
@@ -296,16 +111,10 @@ export class TrellisContext {
     return null
   }
 
-  /**
-   * Read a file relative to project directory
-   */
   readProjectFile(relativePath) {
     return this.readFile(join(this.directory, relativePath))
   }
 
-  /**
-   * Run a Python script and return output
-   */
   runScript(scriptPath, cwd = null) {
     try {
       const result = execSync(`${PYTHON_CMD} "${scriptPath}"`, {
@@ -324,12 +133,6 @@ export class TrellisContext {
   // JSONL Reading
   // ============================================================
 
-  /**
-   * Read all .md files in a directory
-   * @param {string} dirPath - Directory path relative to project root
-   * @param {number} maxFiles - Max files to read (prevent huge directories)
-   * @returns {Array<{path: string, content: string}>}
-   */
   readDirectoryMdFiles(dirPath, maxFiles = 20) {
     const results = []
     const fullPath = join(this.directory, dirPath)
@@ -379,11 +182,9 @@ export class TrellisContext {
         if (!file) continue
 
         if (entryType === "directory") {
-          // Read all .md files in directory
           const dirEntries = this.readDirectoryMdFiles(file)
           results.push(...dirEntries)
         } else {
-          // Read single file
           const fullPath = join(this.directory, file)
           const fileContent = this.readFile(fullPath)
           if (fileContent) {
@@ -397,74 +198,29 @@ export class TrellisContext {
     return results
   }
 
-  /**
-   * Build context string from file entries
-   */
   buildContextFromEntries(entries) {
     return entries.map(e => `=== ${e.path} ===\n${e.content}`).join("\n\n")
   }
 }
 
 // ============================================================
-// Context Collector (for synthetic message injection)
+// Context Collector (for session deduplication)
 // ============================================================
 
-/**
- * Simple context collector for cross-hook communication
- * Similar to oh-my-opencode's contextCollector
- */
 class ContextCollector {
   constructor() {
-    this.pending = new Map()
     this.processed = new Set()
   }
 
-  /**
-   * Store context for a session
-   */
-  store(sessionID, content) {
-    this.pending.set(sessionID, {
-      content,
-      timestamp: Date.now()
-    })
-    debugLog("collector", "stored context for session:", sessionID, "length:", content.length)
-  }
-
-  /**
-   * Check if session has pending context
-   */
-  hasPending(sessionID) {
-    return this.pending.has(sessionID)
-  }
-
-  /**
-   * Get and consume pending context
-   */
-  consume(sessionID) {
-    const pending = this.pending.get(sessionID)
-    this.pending.delete(sessionID)
-    return pending
-  }
-
-  /**
-   * Mark session as processed (for first-message-only injection)
-   */
   markProcessed(sessionID) {
     this.processed.add(sessionID)
   }
 
-  /**
-   * Check if session was already processed
-   */
   isProcessed(sessionID) {
     return this.processed.has(sessionID)
   }
 
-  /**
-   * Clear session state
-   */
   clear(sessionID) {
-    this.pending.delete(sessionID)
     this.processed.delete(sessionID)
   }
 }

package/dist/templates/opencode/plugins/inject-subagent-context.js

@@ -3,10 +3,6 @@
  *
  * Injects context when Task tool is called with supported subagent types.
  * Uses OpenCode's tool.execute.before hook.
- *
- * Compatibility:
- * - If oh-my-opencode handles via .claude/hooks/, this plugin skips
- * - Otherwise, this plugin handles injection
  */
 
 import { existsSync, writeFileSync, readdirSync } from "fs"
@@ -36,21 +32,18 @@ function updateCurrentPhase(ctx, taskDir, subagentType) {
     const currentPhase = taskData.current_phase || 0
     const nextActions = taskData.next_action || []
 
-    // Map action names to subagent types
     const actionToAgent = {
       "implement": "implement",
       "check": "check",
-      "finish": "check"  // finish uses check agent
+      "finish": "check"
     }
 
-    // Find the next phase that matches this subagent_type
     let newPhase = null
     for (const action of nextActions) {
       const phaseNum = action.phase || 0
       const actionName = action.action || ""
       const expectedAgent = actionToAgent[actionName]
 
-      // Only consider phases after current_phase
       if (phaseNum > currentPhase && expectedAgent === subagentType) {
         newPhase = phaseNum
         break
@@ -73,12 +66,10 @@ function updateCurrentPhase(ctx, taskDir, subagentType) {
 function getImplementContext(ctx, taskDir) {
   const parts = []
 
-  // 1. Read implement.jsonl (or fallback to spec.jsonl)
   let jsonlPath = join(ctx.directory, taskDir, "implement.jsonl")
   let entries = ctx.readJsonlWithFiles(jsonlPath)
 
   if (entries.length === 0) {
-    // Fallback to spec.jsonl
     jsonlPath = join(ctx.directory, taskDir, "spec.jsonl")
     entries = ctx.readJsonlWithFiles(jsonlPath)
   }
@@ -87,13 +78,11 @@ function getImplementContext(ctx, taskDir) {
     parts.push(ctx.buildContextFromEntries(entries))
   }
 
-  // 2. Requirements document
   const prd = ctx.readProjectFile(join(taskDir, "prd.md"))
   if (prd) {
     parts.push(`=== ${taskDir}/prd.md (Requirements) ===\n${prd}`)
   }
 
-  // 3. Technical design
   const info = ctx.readProjectFile(join(taskDir, "info.md"))
   if (info) {
     parts.push(`=== ${taskDir}/info.md (Technical Design) ===\n${info}`)
@@ -108,14 +97,12 @@ function getImplementContext(ctx, taskDir) {
 function getCheckContext(ctx, taskDir) {
   const parts = []
 
-  // 1. Read check.jsonl
   const jsonlPath = join(ctx.directory, taskDir, "check.jsonl")
   const entries = ctx.readJsonlWithFiles(jsonlPath)
 
   if (entries.length > 0) {
     parts.push(ctx.buildContextFromEntries(entries))
   } else {
-    // Fallback: hardcoded check files + spec.jsonl
     const checkFiles = [
       [".opencode/commands/trellis/finish-work.md", "Finish work checklist"],
       [".opencode/commands/trellis/check-cross-layer.md", "Cross-layer check spec"],
@@ -128,7 +115,6 @@ function getCheckContext(ctx, taskDir) {
       }
     }
 
-    // Add spec.jsonl
     const specJsonlPath = join(ctx.directory, taskDir, "spec.jsonl")
     const specEntries = ctx.readJsonlWithFiles(specJsonlPath)
     for (const entry of specEntries) {
@@ -136,7 +122,6 @@ function getCheckContext(ctx, taskDir) {
     }
   }
 
-  // 2. Requirements document
   const prd = ctx.readProjectFile(join(taskDir, "prd.md"))
   if (prd) {
     parts.push(`=== ${taskDir}/prd.md (Requirements - for understanding intent) ===\n${prd}`)
@@ -151,27 +136,23 @@ function getCheckContext(ctx, taskDir) {
 function getFinishContext(ctx, taskDir) {
   const parts = []
 
-  // 1. Try finish.jsonl first
   const jsonlPath = join(ctx.directory, taskDir, "finish.jsonl")
   const entries = ctx.readJsonlWithFiles(jsonlPath)
 
   if (entries.length > 0) {
     parts.push(ctx.buildContextFromEntries(entries))
   } else {
-    // Fallback: only finish-work.md (lightweight)
     const finishWork = ctx.readProjectFile(".opencode/commands/trellis/finish-work.md")
     if (finishWork) {
       parts.push(`=== .opencode/commands/trellis/finish-work.md (Finish checklist) ===\n${finishWork}`)
     }
   }
 
-  // 2. Spec update process (for active spec sync)
   const updateSpec = ctx.readProjectFile(".opencode/commands/trellis/update-spec.md")
   if (updateSpec) {
     parts.push(`=== .opencode/commands/trellis/update-spec.md (Spec update process) ===\n${updateSpec}`)
   }
 
-  // 3. Requirements document (for verifying requirements are met)
   const prd = ctx.readProjectFile(join(taskDir, "prd.md"))
   if (prd) {
     parts.push(`=== ${taskDir}/prd.md (Requirements - verify all met) ===\n${prd}`)
@@ -186,14 +167,12 @@ function getFinishContext(ctx, taskDir) {
 function getDebugContext(ctx, taskDir) {
   const parts = []
 
-  // 1. Read debug.jsonl (or fallback to spec.jsonl + check files)
   const jsonlPath = join(ctx.directory, taskDir, "debug.jsonl")
   const entries = ctx.readJsonlWithFiles(jsonlPath)
 
   if (entries.length > 0) {
     parts.push(ctx.buildContextFromEntries(entries))
   } else {
-    // Fallback: use spec.jsonl + hardcoded check files
     const specJsonlPath = join(ctx.directory, taskDir, "spec.jsonl")
     const specEntries = ctx.readJsonlWithFiles(specJsonlPath)
     for (const entry of specEntries) {
@@ -212,7 +191,6 @@ function getDebugContext(ctx, taskDir) {
     }
   }
 
-  // 2. Codex review output (if exists)
   const codex = ctx.readProjectFile(join(taskDir, "codex-review-output.txt"))
   if (codex) {
     parts.push(`=== ${taskDir}/codex-review-output.txt (Codex Review Results) ===\n${codex}`)
@@ -240,11 +218,9 @@ function getResearchContext(ctx, taskDir) {
 
       for (const entry of entries) {
         const entryPath = join(specFull, entry.name)
-        // Check if this is a direct spec layer (has index.md)
         if (existsSync(join(entryPath, "index.md"))) {
           structureLines.push(`├── ${entry.name}/`)
         } else {
-          // Check for nested package dirs (monorepo)
           try {
             const nested = readdirSync(entryPath, { withFileTypes: true })
               .filter(d => d.isDirectory() && existsSync(join(entryPath, d.name, "index.md")))
@@ -448,117 +424,91 @@ ${originalPrompt}
   return templates[agentType] || originalPrompt
 }
 
-export default async ({ directory }) => {
-  const ctx = new TrellisContext(directory)
-  debugLog("inject", "Plugin loaded, directory:", directory)
-
-  return {
-    // ==========================================================================
-    // ⚠️ KNOWN LIMITATION: OpenCode project-level plugins cannot intercept subagents
-    //
-    // This hook will NOT be triggered because:
-    // 1. Project-level plugins (.opencode/plugin/) don't support tool.execute.before
-    // 2. Only global plugins (npm packages) have full hook permissions
-    // 3. This is a known OpenCode architecture limitation (see Issue #5894)
-    //
-    // SOLUTION: Trellis + OpenCode users must install oh-my-opencode (omo)
-    // - omo is a global plugin with full hook permissions
-    // - omo reads .claude/settings.json and executes Python hooks
-    // - .claude/hooks/inject-subagent-context.py handles the actual injection
-    //
-    // References:
-    // - https://github.com/sst/opencode/issues/5894 (plugin hooks don't intercept subagent)
-    // - https://github.com/sst/opencode/issues/2588 (subagent inherit context)
-    // ==========================================================================
-    "tool.execute.before": async (input, output) => {
-      try {
-        debugLog("inject", "tool.execute.before called, tool:", input?.tool)
-
-        // Only handle Task tool
-        const toolName = input?.tool?.toLowerCase()
-        if (toolName !== "task") {
-          return
-        }
+export default {
+  id: "trellis.inject-subagent-context",
+  server: async ({ directory }) => {
+    const ctx = new TrellisContext(directory)
+    debugLog("inject", "Plugin loaded, directory:", directory)
 
-        const args = output?.args || {}
-        const subagentType = args.subagent_type
-        const originalPrompt = args.prompt || ""
+    return {
+      "tool.execute.before": async (input, output) => {
+        try {
+          debugLog("inject", "tool.execute.before called, tool:", input?.tool)
 
-        debugLog("inject", "Task tool called, subagent_type:", subagentType)
+          const toolName = input?.tool?.toLowerCase()
+          if (toolName !== "task") {
+            return
+          }
 
-        // Only handle supported agent types
-        if (!AGENTS_ALL.includes(subagentType)) {
-          debugLog("inject", "Skipping - unsupported subagent_type")
-          return
-        }
+          const args = output?.args
+          if (!args) return
 
-        // Check if we should skip (omo will handle)
-        if (ctx.shouldSkipHook("inject-subagent-context")) {
-          debugLog("inject", "Skipping - omo will handle via .claude/hooks/")
-          return
-        }
+          const subagentType = args.subagent_type
+          const originalPrompt = args.prompt || ""
 
-        // Read current task
-        const taskDir = ctx.getCurrentTask()
+          debugLog("inject", "Task tool called, subagent_type:", subagentType)
 
-        // Agents requiring task directory
-        if (AGENTS_REQUIRE_TASK.includes(subagentType)) {
-          if (!taskDir) {
-            debugLog("inject", "Skipping - no current task")
-            return
-          }
-          const taskDirFull = join(directory, taskDir)
-          if (!existsSync(taskDirFull)) {
-            debugLog("inject", "Skipping - task directory not found")
+          if (!AGENTS_ALL.includes(subagentType)) {
+            debugLog("inject", "Skipping - unsupported subagent_type")
             return
           }
 
-          // Update current_phase in task.json
-          updateCurrentPhase(ctx, taskDir, subagentType)
-        }
+          // Read current task
+          const taskDir = ctx.getCurrentTask()
 
-        // Check for [finish] marker
-        const isFinish = originalPrompt.toLowerCase().includes("[finish]")
-
-        // Get context based on agent type
-        let context = ""
-        switch (subagentType) {
-          case "implement":
-            context = getImplementContext(ctx, taskDir)
-            break
-          case "check":
-            // Use finish context for [finish] phase (lighter, focused on final verification)
-            // Use check context for regular check (full specs for self-fix loop)
-            context = isFinish
-              ? getFinishContext(ctx, taskDir)
-              : getCheckContext(ctx, taskDir)
-            break
-          case "debug":
-            context = getDebugContext(ctx, taskDir)
-            break
-          case "research":
-            context = getResearchContext(ctx, taskDir)
-            break
-        }
+          // Agents requiring task directory
+          if (AGENTS_REQUIRE_TASK.includes(subagentType)) {
+            if (!taskDir) {
+              debugLog("inject", "Skipping - no current task")
+              return
+            }
+            const taskDirFull = join(directory, taskDir)
+            if (!existsSync(taskDirFull)) {
+              debugLog("inject", "Skipping - task directory not found")
+              return
+            }
 
-        if (!context) {
-          debugLog("inject", "No context to inject")
-          return
-        }
+            updateCurrentPhase(ctx, taskDir, subagentType)
+          }
 
-        // Build enhanced prompt
-        const newPrompt = buildPrompt(subagentType, originalPrompt, context, isFinish)
+          // Check for [finish] marker
+          const isFinish = originalPrompt.toLowerCase().includes("[finish]")
+
+          // Get context based on agent type
+          let context = ""
+          switch (subagentType) {
+            case "implement":
+              context = getImplementContext(ctx, taskDir)
+              break
+            case "check":
+              context = isFinish
+                ? getFinishContext(ctx, taskDir)
+                : getCheckContext(ctx, taskDir)
+              break
+            case "debug":
+              context = getDebugContext(ctx, taskDir)
+              break
+            case "research":
+              context = getResearchContext(ctx, taskDir)
+              break
+          }
 
-        // Update the tool input
-        output.args = {
-          ...args,
-          prompt: newPrompt
-        }
+          if (!context) {
+            debugLog("inject", "No context to inject")
+            return
+          }
+
+          const newPrompt = buildPrompt(subagentType, originalPrompt, context, isFinish)
 
-        debugLog("inject", "Injected context for", subagentType, "prompt length:", newPrompt.length)
+          // Mutate args in-place — whole-object replacement does NOT work for the task tool
+          // because the runtime holds a local reference to the same args object.
+          args.prompt = newPrompt
 
-      } catch (error) {
-        debugLog("inject", "Error in tool.execute.before:", error.message, error.stack)
+          debugLog("inject", "Injected context for", subagentType, "prompt length:", newPrompt.length)
+
+        } catch (error) {
+          debugLog("inject", "Error in tool.execute.before:", error.message, error.stack)
+        }
       }
     }
   }