opencode-branch-memory-manager 0.1.3 → 0.1.5

package/.opencode/branch-memory/collector.ts

@@ -6,9 +6,11 @@ import { GitOperations } from "./git.js";
  */
 export class ContextCollector {
   private config: PluginConfig;
+  private client?: any;
 
-  constructor(config: PluginConfig) {
+  constructor(config: PluginConfig, client?: any) {
     this.config = config;
+    this.client = client;
   }
 
   /**
@@ -73,9 +75,28 @@ export class ContextCollector {
    * @returns Array of messages
    */
   private async collectMessages(): Promise<BranchContext["data"]["messages"]> {
-    // Placeholder for SDK integration
-    // When OpenCode SDK is available, this will fetch recent messages
-    return [];
+    if (!this.client) {
+      console.warn('Client not available, skipping message collection');
+      return [];
+    }
+
+    try {
+      // Use OpenCode SDK to fetch session messages
+      // Note: The actual API may differ - this is based on common patterns
+      const messages = await this.client.session?.getMessages?.() || [];
+
+      // Limit to maxMessages from config
+      const limited = messages.slice(-this.config.context.maxMessages);
+
+      return limited.map((msg: any) => ({
+        role: msg.role || 'user',
+        content: msg.content || '',
+        timestamp: msg.timestamp || new Date().toISOString()
+      }));
+    } catch (error) {
+      console.error('Failed to collect messages:', error);
+      return [];
+    }
   }
 
   /**
@@ -83,8 +104,27 @@ export class ContextCollector {
    * @returns Array of todos
    */
   private async collectTodos(): Promise<BranchContext["data"]["todos"]> {
-    // Placeholder for SDK integration
-    // When OpenCode SDK is available, this will fetch todo items
-    return [];
+    if (!this.client) {
+      console.warn('Client not available, skipping todo collection');
+      return [];
+    }
+
+    try {
+      // Use OpenCode SDK to fetch session todos
+      // Note: The actual API may differ - this is based on common patterns
+      const todos = await this.client.session?.getTodos?.() || [];
+
+      // Limit to maxTodos from config
+      const limited = todos.slice(0, this.config.context.maxTodos);
+
+      return limited.map((todo: any) => ({
+        id: todo.id || String(Date.now()),
+        content: todo.content || '',
+        status: todo.status || 'pending'
+      }));
+    } catch (error) {
+      console.error('Failed to collect todos:', error);
+      return [];
+    }
   }
 }

package/.opencode/branch-memory/config.ts

@@ -11,7 +11,9 @@ const DEFAULT_CONFIG: PluginConfig = {
     enabled: true,
     onMessageChange: true,
     onBranchChange: true,
-    onToolExecute: true
+    onToolExecute: true,
+    throttleMs: 5000,
+    periodicIntervalMs: 60000
   },
   contextLoading: 'auto',
   context: {
@@ -34,28 +36,28 @@ const DEFAULT_CONFIG: PluginConfig = {
  * Configuration manager for branch memory plugin
  */
 export class ConfigManager {
-  private static configPath: string
-  private static projectPath: string
-  
+  private configPath: string
+  private projectPath: string
+
   /**
-   * Set the project path for configuration
+   * Create a new ConfigManager instance
    * @param projectPath - The root directory of the project
    */
-  static setProjectPath(projectPath: string): void {
+  constructor(projectPath: string) {
     this.projectPath = projectPath
     this.configPath = path.join(projectPath, '.opencode', 'config', 'branch-memory.json')
   }
-  
+
   /**
    * Load configuration from project directory, falling back to defaults
    * @returns Configuration object
    */
-  static async load(): Promise<PluginConfig> {
+  async load(): Promise<PluginConfig> {
     if (existsSync(this.configPath)) {
       try {
         const content = await fs.readFile(this.configPath, 'utf8')
         const userConfig = JSON.parse(content) as Partial<PluginConfig>
-        
+
         // Deep merge user config with defaults
         return this.deepMerge(DEFAULT_CONFIG, userConfig) as PluginConfig
       } catch (error) {
@@ -65,31 +67,30 @@ export class ConfigManager {
     }
     return { ...DEFAULT_CONFIG }
   }
-  
+
   /**
    * Get default configuration
    * @returns Default configuration object
    */
-  static getDefault(): PluginConfig {
+  getDefault(): PluginConfig {
     return JSON.parse(JSON.stringify(DEFAULT_CONFIG)) as PluginConfig
   }
-  
+
   /**
    * Get storage directory path
-   * @param projectPath - The root directory of the project
    * @returns Path to storage directory
    */
-  static getStorageDir(projectPath: string): string {
-    return path.join(projectPath, '.opencode', 'branch-memory')
+  getStorageDir(): string {
+    return path.join(this.projectPath, '.opencode', 'branch-memory')
   }
-  
+
   /**
    * Save configuration to project directory
    * @param config - Configuration object to save
    */
-  static async save(config: PluginConfig): Promise<void> {
+  async save(config: PluginConfig): Promise<void> {
     const configDir = path.dirname(this.configPath)
-    
+
     try {
       await fs.mkdir(configDir, { recursive: true })
       await fs.writeFile(this.configPath, JSON.stringify(config, null, 2), 'utf8')
@@ -98,20 +99,20 @@ export class ConfigManager {
       throw error
     }
   }
-  
+
   /**
    * Deep merge two objects
    * @param target - Target object (defaults)
    * @param source - Source object (user config)
    * @returns Merged object
    */
-  private static deepMerge<T>(target: T, source: Partial<T>): T {
+  private deepMerge<T>(target: T, source: Partial<T>): T {
     const result = { ...target }
-    
+
     for (const key in source) {
       const sourceValue = source[key]
       const targetValue = result[key]
-      
+
       if (sourceValue !== undefined) {
         if (typeof sourceValue === 'object' && sourceValue !== null && !Array.isArray(sourceValue) &&
             typeof targetValue === 'object' && targetValue !== null && !Array.isArray(targetValue)) {
@@ -121,7 +122,7 @@ export class ConfigManager {
         }
       }
     }
-    
+
     return result
   }
 }

package/.opencode/branch-memory/git.ts

@@ -95,7 +95,7 @@ export class GitOperations {
   }
 
   static async getAllBranches(): Promise<string[]> {
-    const result = await this.runGitCommand('branch', "--format='%(refname:short)'")
+    const result = await this.runGitCommand('branch', '--format=%(refname:short)')
     
     if (result.exitCode !== 0) {
       return []

package/.opencode/branch-memory/injector.ts

@@ -16,15 +16,43 @@ export class ContextInjector {
    * @param branchContext - Branch context to inject
    */
   async injectContext(branchContext: BranchContext): Promise<void> {
-    const summary = this.formatContextSummary(branchContext)
-    
-    // Inject context without triggering AI response
-    // This would use the OpenCode SDK client.session.prompt() with noReply: true
-    // For now, log the injection
-    console.log('\n📥 Context injected for branch:', branchContext.branch)
-    console.log('─'.repeat(50))
-    console.log(summary)
-    console.log('─'.repeat(50))
+    if (!this.context || !this.hasContextData(branchContext)) {
+      return;
+    }
+
+    const summary = this.formatContextSummary(branchContext);
+
+    try {
+      // Inject context as a system message that doesn't trigger response
+      // Using the OpenCode SDK client to add context to the session
+      const client = (this.context as any).client;
+
+      if (client?.session?.addMessage) {
+        await client.session.addMessage({
+          role: 'system',
+          content: summary,
+          silent: true  // Don't trigger AI response
+        });
+        console.log('✅ Context injected for branch:', branchContext.branch);
+      } else if (client?.session?.prompt) {
+        // Fallback: use prompt with noReply flag
+        await client.session.prompt(summary, { noReply: true });
+        console.log('✅ Context injected for branch:', branchContext.branch);
+      } else {
+        // Fallback to console output if SDK methods not available
+        console.log('\n📥 Context Summary (SDK not available):');
+        console.log('─'.repeat(50));
+        console.log(summary);
+        console.log('─'.repeat(50));
+      }
+    } catch (error) {
+      console.error('Failed to inject context:', error);
+      // Fall back to console output
+      console.log('\n📥 Context Summary (injection failed):');
+      console.log('─'.repeat(50));
+      console.log(summary);
+      console.log('─'.repeat(50));
+    }
   }
   
   /**

package/.opencode/branch-memory/monitor.ts

@@ -22,7 +22,10 @@ export class BranchMonitor {
       newBranch: string,
     ) => void,
     private config: PluginConfig,
-  ) {}
+  ) {
+    // Register the callback so it gets called on branch changes
+    this.changeCallbacks.push(this.onBranchChange);
+  }
 
   /**
    * Start monitoring git branch changes

package/.opencode/branch-memory/storage.ts

@@ -1,16 +1,18 @@
 import * as fs from 'fs/promises'
 import * as path from 'path'
 import { existsSync } from 'fs'
-import type { BranchContext } from './types.js'
+import type { BranchContext, PluginConfig } from './types.js'
 
 /**
  * Context storage manager for branch-specific contexts
  */
 export class ContextStorage {
   private storageDir: string
-  
-  constructor(storageDir: string) {
+  private maxBackups: number
+
+  constructor(storageDir: string, config?: PluginConfig) {
     this.storageDir = storageDir
+    this.maxBackups = config?.storage?.maxBackups ?? 5
   }
   
   /**
@@ -162,7 +164,7 @@ export class ContextStorage {
           return { name: f, timestamp: match ? parseInt(match[1], 10) : 0 }
         })
         .sort((a, b) => b.timestamp - a.timestamp)
-        .slice(5) // Keep last 5
+        .slice(this.maxBackups) // Keep last maxBackups
       
       for (const backup of backups) {
         await fs.unlink(path.join(this.storageDir, backup.name)).catch(() => {})

package/.opencode/branch-memory/types.ts

@@ -49,6 +49,8 @@ export interface PluginConfig {
     onMessageChange: boolean
     onBranchChange: boolean
     onToolExecute: boolean
+    throttleMs: number
+    periodicIntervalMs: number
   }
   contextLoading: 'auto' | 'ask' | 'manual'
   context: {