opencode-branch-memory-manager 0.1.2 → 0.1.4

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/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: {

package/.opencode/dist/branch-memory.js

@@ -12336,8 +12336,10 @@ import { existsSync } from "fs";
 
 class ContextStorage {
   storageDir;
-  constructor(storageDir) {
+  maxBackups;
+  constructor(storageDir, config2) {
     this.storageDir = storageDir;
+    this.maxBackups = config2?.storage?.maxBackups ?? 5;
   }
   getBranchFile(branch) {
     return path.join(this.storageDir, `${this.sanitizeBranchName(branch)}.json`);
@@ -12415,7 +12417,7 @@ class ContextStorage {
       const backups = files.filter((f) => f.startsWith(`${safeBranch}.backup.`) && f.endsWith(".json")).map((f) => {
         const match = f.match(/\.backup\.(\d+)\.json$/);
         return { name: f, timestamp: match ? parseInt(match[1], 10) : 0 };
-      }).sort((a, b) => b.timestamp - a.timestamp).slice(5);
+      }).sort((a, b) => b.timestamp - a.timestamp).slice(this.maxBackups);
       for (const backup of backups) {
         await fs.unlink(path.join(this.storageDir, backup.name)).catch(() => {});
       }
@@ -12595,7 +12597,7 @@ class GitOperations {
 `).filter((f) => f.length > 0);
   }
   static async getAllBranches() {
-    const result = await this.runGitCommand("branch", "--format='%(refname:short)'");
+    const result = await this.runGitCommand("branch", "--format=%(refname:short)");
     if (result.exitCode !== 0) {
       return [];
     }
@@ -12649,8 +12651,10 @@ class GitOperations {
 // .opencode/branch-memory/collector.ts
 class ContextCollector {
   config;
-  constructor(config2) {
+  client;
+  constructor(config2, client) {
     this.config = config2;
+    this.client = client;
   }
   async collectContext(includeMessages = true, includeTodos = true, includeFiles = true, description = "") {
     const currentBranch = await GitOperations.getCurrentBranch();
@@ -12685,10 +12689,40 @@ class ContextCollector {
     return context;
   }
   async collectMessages() {
-    return [];
+    if (!this.client) {
+      console.warn("Client not available, skipping message collection");
+      return [];
+    }
+    try {
+      const messages = await this.client.session?.getMessages?.() || [];
+      const limited = messages.slice(-this.config.context.maxMessages);
+      return limited.map((msg) => ({
+        role: msg.role || "user",
+        content: msg.content || "",
+        timestamp: msg.timestamp || new Date().toISOString()
+      }));
+    } catch (error45) {
+      console.error("Failed to collect messages:", error45);
+      return [];
+    }
   }
   async collectTodos() {
-    return [];
+    if (!this.client) {
+      console.warn("Client not available, skipping todo collection");
+      return [];
+    }
+    try {
+      const todos = await this.client.session?.getTodos?.() || [];
+      const limited = todos.slice(0, this.config.context.maxTodos);
+      return limited.map((todo) => ({
+        id: todo.id || String(Date.now()),
+        content: todo.content || "",
+        status: todo.status || "pending"
+      }));
+    } catch (error45) {
+      console.error("Failed to collect todos:", error45);
+      return [];
+    }
   }
 }
 // .opencode/branch-memory/injector.ts
@@ -12698,12 +12732,37 @@ class ContextInjector {
     this.context = context;
   }
   async injectContext(branchContext) {
+    if (!this.context || !this.hasContextData(branchContext)) {
+      return;
+    }
     const summary = this.formatContextSummary(branchContext);
-    console.log(`
-\uD83D\uDCE5 Context injected for branch:`, branchContext.branch);
-    console.log("─".repeat(50));
-    console.log(summary);
-    console.log("─".repeat(50));
+    try {
+      const client = this.context.client;
+      if (client?.session?.addMessage) {
+        await client.session.addMessage({
+          role: "system",
+          content: summary,
+          silent: true
+        });
+        console.log("✅ Context injected for branch:", branchContext.branch);
+      } else if (client?.session?.prompt) {
+        await client.session.prompt(summary, { noReply: true });
+        console.log("✅ Context injected for branch:", branchContext.branch);
+      } else {
+        console.log(`
+\uD83D\uDCE5 Context Summary (SDK not available):`);
+        console.log("─".repeat(50));
+        console.log(summary);
+        console.log("─".repeat(50));
+      }
+    } catch (error45) {
+      console.error("Failed to inject context:", error45);
+      console.log(`
+\uD83D\uDCE5 Context Summary (injection failed):`);
+      console.log("─".repeat(50));
+      console.log(summary);
+      console.log("─".repeat(50));
+    }
   }
   async askUserAboutContextLoading(branchContext) {
     const summary = this.formatContextSummary(branchContext);
@@ -12762,7 +12821,9 @@ var DEFAULT_CONFIG = {
     enabled: true,
     onMessageChange: true,
     onBranchChange: true,
-    onToolExecute: true
+    onToolExecute: true,
+    throttleMs: 5000,
+    periodicIntervalMs: 60000
   },
   contextLoading: "auto",
   context: {
@@ -12782,13 +12843,13 @@ var DEFAULT_CONFIG = {
 };
 
 class ConfigManager {
-  static configPath;
-  static projectPath;
-  static setProjectPath(projectPath) {
+  configPath;
+  projectPath;
+  constructor(projectPath) {
     this.projectPath = projectPath;
     this.configPath = path2.join(projectPath, ".opencode", "config", "branch-memory.json");
   }
-  static async load() {
+  async load() {
     if (existsSync2(this.configPath)) {
       try {
         const content = await fs2.readFile(this.configPath, "utf8");
@@ -12801,13 +12862,13 @@ class ConfigManager {
     }
     return { ...DEFAULT_CONFIG };
   }
-  static getDefault() {
+  getDefault() {
     return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
   }
-  static getStorageDir(projectPath) {
-    return path2.join(projectPath, ".opencode", "branch-memory");
+  getStorageDir() {
+    return path2.join(this.projectPath, ".opencode", "branch-memory");
   }
-  static async save(config2) {
+  async save(config2) {
     const configDir = path2.dirname(this.configPath);
     try {
       await fs2.mkdir(configDir, { recursive: true });
@@ -12817,7 +12878,7 @@ class ConfigManager {
       throw error45;
     }
   }
-  static deepMerge(target, source) {
+  deepMerge(target, source) {
     const result = { ...target };
     for (const key in source) {
       const sourceValue = source[key];
@@ -12834,6 +12895,12 @@ class ConfigManager {
   }
 }
 // .opencode/tool/branch-memory.ts
+async function initializeContext() {
+  const configManager = new ConfigManager(process.cwd());
+  const config2 = await configManager.load();
+  const storage = new ContextStorage(configManager.getStorageDir(), config2);
+  return { configManager, config: config2, storage };
+}
 var save = tool({
   description: "Save current session context for current git branch with optional filters",
   args: {
@@ -12844,15 +12911,13 @@ var save = tool({
   },
   async execute(args, context) {
     try {
-      ConfigManager.setProjectPath(process.cwd());
-      const config2 = await ConfigManager.load();
+      const { config: config2, storage } = await initializeContext();
       const currentBranch = await GitOperations.getCurrentBranch();
       if (!currentBranch) {
         return "⚠️  Not on a git branch, context not saved";
       }
       const collector = new ContextCollector(config2);
       const branchContext = await collector.collectContext(args.includeMessages ?? config2.context.defaultInclude.includes("messages"), args.includeTodos ?? config2.context.defaultInclude.includes("todos"), args.includeFiles ?? config2.context.defaultInclude.includes("files"), args.description || "");
-      const storage = new ContextStorage(ConfigManager.getStorageDir(process.cwd()));
       await storage.saveContext(currentBranch, branchContext);
       return `✅ Saved context for branch '${currentBranch}'
   ├─ Messages: ${branchContext.metadata.messageCount}
@@ -12872,13 +12937,12 @@ var load = tool({
   },
   async execute(args, context) {
     try {
-      ConfigManager.setProjectPath(process.cwd());
+      const { storage } = await initializeContext();
       const git = GitOperations;
       const targetBranch = args.branch || await git.getCurrentBranch();
       if (!targetBranch) {
         return "⚠️  Not on a git branch";
       }
-      const storage = new ContextStorage(ConfigManager.getStorageDir(process.cwd()));
       const branchContext = await storage.loadContext(targetBranch);
       if (!branchContext) {
         return `⚠️  No context found for branch '${targetBranch}'`;
@@ -12901,10 +12965,9 @@ var status = tool({
   args: {},
   async execute(args, context) {
     try {
-      ConfigManager.setProjectPath(process.cwd());
+      const { storage } = await initializeContext();
       const git = GitOperations;
       const currentBranch = await git.getCurrentBranch();
-      const storage = new ContextStorage(ConfigManager.getStorageDir(process.cwd()));
       const branches = await storage.listBranches();
       let output = `
 \uD83D\uDCCA Branch Memory Status`;
@@ -12972,8 +13035,7 @@ var deleteContext = tool({
   },
   async execute(args, context) {
     try {
-      ConfigManager.setProjectPath(process.cwd());
-      const storage = new ContextStorage(ConfigManager.getStorageDir(process.cwd()));
+      const { storage } = await initializeContext();
       await storage.deleteContext(args.branch);
       return `✅ Deleted context for branch '${args.branch}'`;
     } catch (error45) {
@@ -12989,8 +13051,7 @@ var list = tool({
   },
   async execute(args, context) {
     try {
-      ConfigManager.setProjectPath(process.cwd());
-      const storage = new ContextStorage(ConfigManager.getStorageDir(process.cwd()));
+      const { storage } = await initializeContext();
       const branches = await storage.listBranches();
       if (branches.length === 0) {
         return "No saved contexts found";

package/.opencode/marketplace.json

@@ -0,0 +1,31 @@
+{
+  "name": "branch-memory-tools",
+  "owner": {
+    "name": "Davidcreador",
+    "email": "contact@davidcreador.com"
+  },
+  "metadata": {
+    "description": "OpenCode plugins for branch memory management",
+    "version": "1.0.0"
+  },
+  "plugins": [
+    {
+      "name": "branch-memory-manager",
+      "source": ".",
+      "description": "Automatically manages branch-specific context with auto-save and auto-load. Never lose your development context when switching git branches.",
+      "version": "0.1.3",
+      "author": {
+        "name": "Davidcreador"
+      },
+      "license": "MIT",
+      "keywords": [
+        "branch",
+        "context",
+        "git",
+        "auto-save",
+        "memory",
+        "workflow"
+      ]
+    }
+  ]
+}

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

@@ -1,11 +1,11 @@
 import type { Plugin } from '@opencode-ai/plugin'
-import { ContextStorage, GitOperations, ContextCollector, ConfigManager } from '../branch-memory/index.js'
+import { ContextStorage, GitOperations, ContextCollector, ConfigManager, BranchMonitor } from '../branch-memory/index.js'
 
 export const BranchMemoryPlugin: Plugin = async ({ project, client, $, directory, worktree }) => {
   console.log('🧠 Branch Memory Plugin initializing...')
 
   // Load configuration
-  ConfigManager.setProjectPath(directory)
+  const configManager = new ConfigManager(directory)
 
   // Check if we're in a git repository
   const isGitRepo = await GitOperations.isGitRepo()
@@ -14,28 +14,28 @@ export const BranchMemoryPlugin: Plugin = async ({ project, client, $, directory
     return {}
   }
 
-  const storage = new ContextStorage(ConfigManager.getStorageDir(directory))
-  const collector = new ContextCollector(await ConfigManager.load())
+  const config = await configManager.load()
+  const storage = new ContextStorage(configManager.getStorageDir(), config)
+  const collector = new ContextCollector(config, client)
 
   // Track last auto-save time to avoid too frequent saves
   let lastAutoSave = 0
-  const AUTO_SAVE_THROTTLE = 5000 // 5 seconds
 
   // Auto-save function with throttling
   const autoSave = async (reason: string) => {
-    const config = await ConfigManager.load()
-    if (config.autoSave.enabled) {
+    const currentConfig = await configManager.load()
+    if (currentConfig.autoSave.enabled) {
       const now = Date.now()
 
-      if (now - lastAutoSave > AUTO_SAVE_THROTTLE) {
+      if (now - lastAutoSave > currentConfig.autoSave.throttleMs) {
         try {
           const currentBranch = await GitOperations.getCurrentBranch()
 
           if (currentBranch) {
             const context = await collector.collectContext(
-              config.context.defaultInclude.includes('messages'),
-              config.context.defaultInclude.includes('todos'),
-              config.context.defaultInclude.includes('files'),
+              currentConfig.context.defaultInclude.includes('messages'),
+              currentConfig.context.defaultInclude.includes('todos'),
+              currentConfig.context.defaultInclude.includes('files'),
               reason
             )
 
@@ -50,62 +50,53 @@ export const BranchMemoryPlugin: Plugin = async ({ project, client, $, directory
     }
   }
 
-  // Track current branch for monitoring
-  let currentBranch: string | null = null
-
-  // Monitor git branch changes
-  const monitorBranch = async () => {
-    try {
-      const newBranch = await GitOperations.getCurrentBranch()
-
-      if (newBranch && newBranch !== currentBranch) {
-        const oldBranchName = currentBranch
-        currentBranch = newBranch
-        const config = await ConfigManager.load()
-
-        console.log(`🔄 Branch changed: ${oldBranchName || '(none)'} → ${newBranch}`)
-
-        // Auto-save old branch context
-        if (oldBranchName && config.autoSave.onBranchChange) {
-          await storage.saveContext(oldBranchName, await collector.collectContext(
-            config.context.defaultInclude.includes('messages'),
-            config.context.defaultInclude.includes('todos'),
-            config.context.defaultInclude.includes('files'),
-            'branch change'
-          ))
-          console.log(`💾 Saved context for old branch '${oldBranchName}'`)
-        }
+  // Initialize branch monitor with callback
+  const branchMonitor = new BranchMonitor(
+    async (oldBranch, newBranch) => {
+      console.log(`🔄 Branch changed: ${oldBranch || '(none)'} → ${newBranch}`)
+
+      const currentConfig = await configManager.load()
+
+      // Auto-save old branch context
+      if (oldBranch && currentConfig.autoSave.onBranchChange) {
+        const context = await collector.collectContext(
+          currentConfig.context.defaultInclude.includes('messages'),
+          currentConfig.context.defaultInclude.includes('todos'),
+          currentConfig.context.defaultInclude.includes('files'),
+          'branch change'
+        )
+        await storage.saveContext(oldBranch, context)
+        console.log(`💾 Saved context for old branch '${oldBranch}'`)
+      }
 
-        // Auto-load new branch context
-        if (config.contextLoading === 'auto') {
-          const branchContext = await storage.loadContext(newBranch)
-          if (branchContext) {
-            console.log(`📥 Found context for branch '${newBranch}'`)
-            console.log('   Use @branch-memory_load to restore it')
-          } else {
-            console.log(`ℹ️  No saved context for branch '${newBranch}'`)
-          }
-        } else if (config.contextLoading === 'ask') {
-          console.log(`ℹ️  Context available for branch '${newBranch}'`)
-          console.log(`   Use @branch-memory_load to restore it`)
+      // Auto-load new branch context
+      if (currentConfig.contextLoading === 'auto') {
+        const branchContext = await storage.loadContext(newBranch)
+        if (branchContext) {
+          console.log(`📥 Found context for branch '${newBranch}'`)
+          console.log('   Use @branch-memory_load to restore it')
+        } else {
+          console.log(`ℹ️  No saved context for branch '${newBranch}'`)
         }
+      } else if (currentConfig.contextLoading === 'ask') {
+        console.log(`ℹ️  Context available for branch '${newBranch}'`)
+        console.log(`   Use @branch-memory_load to restore it`)
       }
-    } catch (error) {
-      console.error('Error monitoring branch:', error)
-    }
-  }
+    },
+    config
+  )
 
-  // Start branch monitoring interval
-  const branchMonitorInterval = setInterval(monitorBranch, 2000)
+  // Start branch monitoring
+  await branchMonitor.start()
 
   return {
     // Hook: Auto-load context when session is created
     'session.created': async (input: any, output: any) => {
       console.log('🚀 Session created - checking for saved context...')
-      const config = await ConfigManager.load()
+      const currentConfig = await configManager.load()
       const branch = await GitOperations.getCurrentBranch()
 
-      if (branch && config.contextLoading === 'auto') {
+      if (branch && currentConfig.contextLoading === 'auto') {
         const branchContext = await storage.loadContext(branch)
         if (branchContext) {
           console.log(`📥 Found context for branch '${branch}'`)
@@ -121,11 +112,11 @@ export const BranchMemoryPlugin: Plugin = async ({ project, client, $, directory
 
     // Hook: Auto-save when session is updated (periodic checkpoints)
     'session.updated': async (input: any, output: any) => {
-      const config = await ConfigManager.load()
-      if (config.autoSave.enabled) {
+      const currentConfig = await configManager.load()
+      if (currentConfig.autoSave.enabled) {
         const now = Date.now()
-        // Only auto-save periodically (every 60 seconds)
-        if (now - lastAutoSave > 60000) {
+        // Only auto-save periodically
+        if (now - lastAutoSave > currentConfig.autoSave.periodicIntervalMs) {
           await autoSave('session update')
         }
       }
@@ -135,8 +126,8 @@ export const BranchMemoryPlugin: Plugin = async ({ project, client, $, directory
     unload: () => {
       console.log('🧠 Branch Memory Plugin shutting down...')
 
-      // Clear the branch monitor interval
-      clearInterval(branchMonitorInterval)
+      // Stop branch monitoring
+      branchMonitor.stop()
 
       // Save one last time before shutdown
       autoSave('plugin unload').catch((error) => {

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

@@ -7,6 +7,22 @@ import {
   ContextInjector,
 } from "../branch-memory/index.js";
 import type { ToolContext } from "@opencode-ai/plugin";
+import type { PluginConfig } from "../branch-memory/types.js";
+
+/**
+ * Shared initialization helper for all tools
+ * Reduces code duplication across tool implementations
+ */
+async function initializeContext(): Promise<{
+  configManager: ConfigManager;
+  config: PluginConfig;
+  storage: ContextStorage;
+}> {
+  const configManager = new ConfigManager(process.cwd());
+  const config = await configManager.load();
+  const storage = new ContextStorage(configManager.getStorageDir(), config);
+  return { configManager, config, storage };
+}
 
 /**
  * Save current session context for current git branch with optional filters
@@ -34,8 +50,7 @@ export const save: ToolDefinition = tool({
   },
   async execute(args, context: ToolContext) {
     try {
-      ConfigManager.setProjectPath(process.cwd());
-      const config = await ConfigManager.load();
+      const { config, storage } = await initializeContext();
 
       const currentBranch = await GitOperations.getCurrentBranch();
 
@@ -52,9 +67,6 @@ export const save: ToolDefinition = tool({
         args.description || "",
       );
 
-      const storage = new ContextStorage(
-        ConfigManager.getStorageDir(process.cwd()),
-      );
       await storage.saveContext(currentBranch, branchContext);
 
       return `✅ Saved context for branch '${currentBranch}'
@@ -82,7 +94,7 @@ export const load: ToolDefinition = tool({
   },
   async execute(args, context: ToolContext) {
     try {
-      ConfigManager.setProjectPath(process.cwd());
+      const { storage } = await initializeContext();
 
       const git = GitOperations;
       const targetBranch = args.branch || (await git.getCurrentBranch());
@@ -91,9 +103,6 @@ export const load: ToolDefinition = tool({
         return "⚠️  Not on a git branch";
       }
 
-      const storage = new ContextStorage(
-        ConfigManager.getStorageDir(process.cwd()),
-      );
       const branchContext = await storage.loadContext(targetBranch);
 
       if (!branchContext) {
@@ -123,13 +132,10 @@ export const status: ToolDefinition = tool({
   args: {},
   async execute(args, context: ToolContext) {
     try {
-      ConfigManager.setProjectPath(process.cwd());
+      const { storage } = await initializeContext();
 
       const git = GitOperations;
       const currentBranch = await git.getCurrentBranch();
-      const storage = new ContextStorage(
-        ConfigManager.getStorageDir(process.cwd()),
-      );
       const branches = await storage.listBranches();
 
       let output = "\n📊 Branch Memory Status";
@@ -187,11 +193,8 @@ export const deleteContext: ToolDefinition = tool({
   },
   async execute(args, context: ToolContext) {
     try {
-      ConfigManager.setProjectPath(process.cwd());
+      const { storage } = await initializeContext();
 
-      const storage = new ContextStorage(
-        ConfigManager.getStorageDir(process.cwd()),
-      );
       await storage.deleteContext(args.branch);
 
       return `✅ Deleted context for branch '${args.branch}'`;
@@ -215,11 +218,8 @@ export const list: ToolDefinition = tool({
   },
   async execute(args, context: ToolContext) {
     try {
-      ConfigManager.setProjectPath(process.cwd());
+      const { storage } = await initializeContext();
 
-      const storage = new ContextStorage(
-        ConfigManager.getStorageDir(process.cwd()),
-      );
       const branches = await storage.listBranches();
 
       if (branches.length === 0) {

package/README.md

@@ -18,41 +18,74 @@ Automatically manages branch-specific context for OpenCode so you never lose you
 
 ### Installation
 
-#### Option 1: npm Package (Recommended)
+The plugin supports **three installation methods** to fit different workflows:
 
-**macOS/Linux:**
-```bash
-bunx install @davecodes/opencode-branch-memory-manager
-```
-
-**Windows (PowerShell):**
-```powershell
-bunx install @davecodes/opencode-branch-memory-manager
-```
+#### Method 1: NPM Package (Recommended for Individual Users)
 
-The plugin and tools will be automatically loaded when you run `opencode`. Add to your `opencode.json`:
+Add the plugin to your `opencode.json`:
 
-  ```json
+```json
 {
   "plugin": ["opencode-branch-memory-manager"]
 }
 ```
 
+OpenCode will automatically install the package from npm when you run `opencode`.
+
+**Manual installation:**
+```bash
+bunx install opencode-branch-memory-manager
+```
+
 **Note:** This will add the plugin without removing any existing plugins you have.
 
-#### Option 2: Local Installation
+#### Method 2: Direct Git Clone (For Development/Testing)
+
+Clone the repository directly into your project:
 
-**macOS/Linux:**
 ```bash
-curl -fsSL https://raw.githubusercontent.com/Davidcreador/opencode-branch-memory-manager/main/install.sh | bash
+# Navigate to your project's .opencode directory
+cd .opencode
+
+# Clone the plugin
+git clone https://github.com/Davidcreador/opencode-branch-memory-manager.git
+
+# Install dependencies and build
+cd opencode-branch-memory-manager
+bun install
+bun run build:local
+```
+
+The plugin will be automatically loaded when you run `opencode` from your project.
+
+#### Method 3: Marketplace (For Teams/Organizations)
+
+For team or organizational distribution, you can set up a marketplace:
+
+**1. Add the marketplace to your `.opencode/settings.json`:**
+```json
+{
+  "extraKnownMarketplaces": {
+    "your-org": {
+      "source": {
+        "source": "github",
+        "repo": "your-org/opencode-plugins"
+      }
+    }
+  }
+}
 ```
 
-**Windows (PowerShell):**
-```powershell
-irm https://raw.githubusercontent.com/Davidcreador/opencode-branch-memory-manager/main/install.ps1 | iex
+**2. Enable the plugin:**
+```json
+{
+  "enabledPlugins": {
+    "branch-memory-manager@your-org": true
+  }
+}
 ```
 
-The plugin and tools will be automatically loaded when you run `opencode`. No configuration needed.
+The plugin will be installed from your organization's marketplace.
 
 ### Getting Started
 
@@ -466,6 +499,33 @@ bun run typecheck
 bun test
 ```
 
+## 🛠️ Local Development
+
+For development, testing, and local usage, you can install directly without npm:
+
+```bash
+# 1. Install dependencies
+bun install
+
+# 2. Build
+bun run build
+
+# 3. The .opencode/ directory is ready to use
+# The build creates .opencode/dist/ with all plugin files
+```
+
+The `.opencode/` directory structure is now ready:
+```
+.opencode/
+├── dist/
+│   └── branch-memory.js       # Bundled plugin + tools
+├── config/
+│   └── branch-memory.json      # Configuration
+└── package.json                  # Dependencies
+```
+
+**Note:** For development, you can work directly in `src/` and run `npm run build:local` to test the `.opencode/` version.
+
 ## 📦 Publishing to npm
 
 1. Update version in `package.json`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-branch-memory-manager",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Automatically manages branch-specific context for OpenCode with auto-save, auto-load, and git workflow integration",
   "author": "Davidcreador",
   "license": "MIT",
@@ -16,7 +16,8 @@
     "url": "https://github.com/Davidcreador/opencode-branch-memory-manager/issues"
   },
   "files": [
-    ".opencode"
+    ".opencode",
+    "dist"
   ],
   "scripts": {
     "build": "npm run build:local",
@@ -39,6 +40,17 @@
     "auto-save",
     "workspace"
   ],
+  "opencode": {
+    "type": "plugin",
+    "entrypoint": ".opencode/plugin/branch-memory-plugin.ts",
+    "tools": [
+      "@branch-memory_save",
+      "@branch-memory_load",
+      "@branch-memory_status",
+      "@branch-memory_list",
+      "@branch-memory_deleteContext"
+    ]
+  },
   "dependencies": {
     "chokidar": "^4.0.0",
     "zod": "^3.22.0"