opencode-branch-memory-manager 0.1.0

package/.opencode/package-lock.json

@@ -0,0 +1,82 @@
+{
+  "name": "opencode-branch-memory-plugin",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "opencode-branch-memory-plugin",
+      "version": "1.0.0",
+      "dependencies": {
+        "chokidar": "^4.0.0",
+        "zod": "^3.22.0"
+      },
+      "devDependencies": {
+        "@opencode-ai/plugin": "latest"
+      }
+    },
+    "node_modules/@opencode-ai/plugin": {
+      "version": "1.0.220",
+      "resolved": "https://registry.npmjs.org/@opencode-ai/plugin/-/plugin-1.0.220.tgz",
+      "integrity": "sha512-PlhuyWCjVqAgvM+4HO/syri+JXnypGp0owLkKjF7H285IU8V1geNY2RRSv17hAGp2C0gwwmZNyA63VEUbiJVCQ==",
+      "dev": true,
+      "dependencies": {
+        "@opencode-ai/sdk": "1.0.220",
+        "zod": "4.1.8"
+      }
+    },
+    "node_modules/@opencode-ai/plugin/node_modules/zod": {
+      "version": "4.1.8",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.1.8.tgz",
+      "integrity": "sha512-5R1P+WwQqmmMIEACyzSvo4JXHY5WiAFHRMg+zBZKgKS+Q1viRa0C1hmUKtHltoIFKtIdki3pRxkmpP74jnNYHQ==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@opencode-ai/sdk": {
+      "version": "1.0.220",
+      "resolved": "https://registry.npmjs.org/@opencode-ai/sdk/-/sdk-1.0.220.tgz",
+      "integrity": "sha512-OllJJ+SjTSzbccGAat2uj5Vka56B2bxm+9SkFpFV0BXquaJA21KRdt1TgJOQnnzo6A/Zlwbx+ecmJ+Xai01JZA==",
+      "dev": true
+    },
+    "node_modules/chokidar": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
+      "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
+      "license": "MIT",
+      "dependencies": {
+        "readdirp": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 14.16.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
+      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.18.0"
+      },
+      "funding": {
+        "type": "individual",
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}

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

@@ -0,0 +1,149 @@
+import type { Plugin } from '@opencode-ai/plugin'
+import { ContextStorage, GitOperations, ContextCollector, ConfigManager } 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)
+
+  // Check if we're in a git repository
+  const isGitRepo = await GitOperations.isGitRepo()
+  if (!isGitRepo) {
+    console.log('⚠️  Not in a git repository, branch memory disabled')
+    return {}
+  }
+
+  const storage = new ContextStorage(ConfigManager.getStorageDir(directory))
+  const collector = new ContextCollector(await ConfigManager.load())
+
+  // 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 now = Date.now()
+
+      if (now - lastAutoSave > AUTO_SAVE_THROTTLE) {
+        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'),
+              reason
+            )
+
+            await storage.saveContext(currentBranch, context)
+            lastAutoSave = now
+            console.log(`💾 Auto-saved context for branch '${currentBranch}' (${reason})`)
+          }
+        } catch (error) {
+          console.error('Auto-save failed:', error)
+        }
+      }
+    }
+  }
+
+  // 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}'`)
+        }
+
+        // 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`)
+        }
+      }
+    } catch (error) {
+      console.error('Error monitoring branch:', error)
+    }
+  }
+
+  // Start branch monitoring interval
+  const branchMonitorInterval = setInterval(monitorBranch, 2000)
+
+  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 branch = await GitOperations.getCurrentBranch()
+
+      if (branch && config.contextLoading === 'auto') {
+        const branchContext = await storage.loadContext(branch)
+        if (branchContext) {
+          console.log(`📥 Found context for branch '${branch}'`)
+          console.log('   Use @branch-memory_load to restore it')
+        }
+      }
+    },
+
+    // Hook: Auto-save before tool execution
+    'tool.execute.before': async (input: any, output: any) => {
+      await autoSave('tool execution')
+    },
+
+    // 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 now = Date.now()
+        // Only auto-save periodically (every 60 seconds)
+        if (now - lastAutoSave > 60000) {
+          await autoSave('session update')
+        }
+      }
+    },
+
+    // Hook: Cleanup on plugin unload
+    unload: () => {
+      console.log('🧠 Branch Memory Plugin shutting down...')
+
+      // Clear the branch monitor interval
+      clearInterval(branchMonitorInterval)
+
+      // Save one last time before shutdown
+      autoSave('plugin unload').catch((error) => {
+        console.error('Final save failed:', error)
+      })
+
+      console.log('✅ Plugin stopped')
+    },
+  }
+}

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

@@ -0,0 +1,254 @@
+import { tool, type ToolDefinition } from "@opencode-ai/plugin";
+import {
+  ContextStorage,
+  GitOperations,
+  ContextCollector,
+  ConfigManager,
+  ContextInjector,
+} from "../branch-memory/index.js";
+import type { ToolContext } from "@opencode-ai/plugin";
+
+/**
+ * Save current session context for current git branch with optional filters
+ */
+export const save: ToolDefinition = tool({
+  description:
+    "Save current session context for current git branch with optional filters",
+  args: {
+    includeMessages: tool.schema
+      .boolean()
+      .optional()
+      .describe("Include conversation messages"),
+    includeTodos: tool.schema
+      .boolean()
+      .optional()
+      .describe("Include todo items"),
+    includeFiles: tool.schema
+      .boolean()
+      .optional()
+      .describe("Include file references"),
+    description: tool.schema
+      .string()
+      .optional()
+      .describe("Description of what you are saving"),
+  },
+  async execute(args, context: ToolContext) {
+    try {
+      ConfigManager.setProjectPath(process.cwd());
+      const config = await ConfigManager.load();
+
+      const currentBranch = await GitOperations.getCurrentBranch();
+
+      if (!currentBranch) {
+        return "⚠️  Not on a git branch, context not saved";
+      }
+
+      const collector = new ContextCollector(config);
+      const branchContext = await collector.collectContext(
+        args.includeMessages ??
+          config.context.defaultInclude.includes("messages"),
+        args.includeTodos ?? config.context.defaultInclude.includes("todos"),
+        args.includeFiles ?? config.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}
+  ├─ Todos: ${branchContext.metadata.todoCount}
+  ├─ Files: ${branchContext.metadata.fileCount}
+  └─ Size: ${(branchContext.metadata.size / 1024).toFixed(1)}KB`;
+    } catch (error) {
+      console.error("Error saving context:", error);
+      return `❌ Failed to save context: ${error instanceof Error ? error.message : "Unknown error"}`;
+    }
+  },
+});
+
+/**
+ * Load branch-specific context into current session
+ */
+export const load: ToolDefinition = tool({
+  description: "Load branch-specific context into current session",
+  args: {
+    branch: tool.schema
+      .string()
+      .optional()
+      .describe("Branch name (default: current branch)"),
+  },
+  async execute(args, context: ToolContext) {
+    try {
+      ConfigManager.setProjectPath(process.cwd());
+
+      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}'`;
+      }
+
+      const injector = new ContextInjector(context);
+      await injector.injectContext(branchContext);
+
+      return `✅ Loaded context for branch '${targetBranch}'
+  ├─ Saved: ${branchContext.savedAt.substring(0, 10)}...
+  ├─ Messages: ${branchContext.metadata.messageCount}
+  ├─ Todos: ${branchContext.metadata.todoCount}
+  └─ Files: ${branchContext.metadata.fileCount}`;
+    } catch (error) {
+      console.error("Error loading context:", error);
+      return `❌ Failed to load context: ${error instanceof Error ? error.message : "Unknown error"}`;
+    }
+  },
+});
+
+/**
+ * Show branch memory status and available contexts
+ */
+export const status: ToolDefinition = tool({
+  description: "Show branch memory status and available contexts",
+  args: {},
+  async execute(args, context: ToolContext) {
+    try {
+      ConfigManager.setProjectPath(process.cwd());
+
+      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";
+      output += "\n═════════════════════\n";
+
+      if (currentBranch) {
+        output += `Current branch: ${currentBranch}\n\n`;
+
+        const branchContext = await storage.loadContext(currentBranch);
+        if (branchContext) {
+          output += `Current context:\n`;
+          output += `  📝 Messages: ${branchContext.metadata.messageCount}\n`;
+          output += `  ✅ Todos: ${branchContext.metadata.todoCount}\n`;
+          output += `  📁 Files: ${branchContext.metadata.fileCount}\n`;
+          output += `  💾 Size: ${(branchContext.metadata.size / 1024).toFixed(1)}KB\n`;
+          output += `  ⏰ Saved: ${branchContext.savedAt}\n`;
+          if (branchContext.data.description) {
+            output += `  📄 Description: ${branchContext.data.description}\n`;
+          }
+        } else {
+          output += `Current branch has no saved context\n`;
+        }
+      } else {
+        output += `Not in a git repository\n`;
+      }
+
+      if (branches.length > 0) {
+        output += "\nAvailable contexts:\n";
+        for (const branch of branches) {
+          const meta = await storage.getMetadata(branch);
+          const marker = branch === currentBranch ? "→ " : "  ";
+          output += `${marker}${branch} (${meta.size}, ${meta.modified.substring(0, 10)}...)\n`;
+        }
+      } else {
+        output += "\nNo saved contexts found\n";
+      }
+
+      output += "═════════════════════\n";
+
+      return output;
+    } catch (error) {
+      console.error("Error getting status:", error);
+      return `❌ Failed to get status: ${error instanceof Error ? error.message : "Unknown error"}`;
+    }
+  },
+});
+
+/**
+ * Delete saved context for a branch
+ */
+export const deleteContext: ToolDefinition = tool({
+  description: "Delete saved context for a branch",
+  args: {
+    branch: tool.schema.string().describe("Branch name to delete context for"),
+  },
+  async execute(args, context: ToolContext) {
+    try {
+      ConfigManager.setProjectPath(process.cwd());
+
+      const storage = new ContextStorage(
+        ConfigManager.getStorageDir(process.cwd()),
+      );
+      await storage.deleteContext(args.branch);
+
+      return `✅ Deleted context for branch '${args.branch}'`;
+    } catch (error) {
+      console.error("Error deleting context:", error);
+      return `❌ Failed to delete context: ${error instanceof Error ? error.message : "Unknown error"}`;
+    }
+  },
+});
+
+/**
+ * List all branches with saved contexts
+ */
+export const list: ToolDefinition = tool({
+  description: "List all branches with saved contexts",
+  args: {
+    verbose: tool.schema
+      .boolean()
+      .optional()
+      .describe("Show detailed information"),
+  },
+  async execute(args, context: ToolContext) {
+    try {
+      ConfigManager.setProjectPath(process.cwd());
+
+      const storage = new ContextStorage(
+        ConfigManager.getStorageDir(process.cwd()),
+      );
+      const branches = await storage.listBranches();
+
+      if (branches.length === 0) {
+        return "No saved contexts found";
+      }
+
+      let output = "\n📋 Branches with saved contexts\n";
+      output += "═════════════════════\n";
+
+      for (const branch of branches) {
+        const meta = await storage.getMetadata(branch);
+        output += `\n${branch}\n`;
+        output += `  💾 Size: ${meta.size}\n`;
+        output += `  ⏰ Modified: ${meta.modified}\n`;
+
+        if (args.verbose) {
+          output += `  📝 Messages: ${meta.messageCount}\n`;
+          output += `  ✅ Todos: ${meta.todoCount}\n`;
+          output += `  📁 Files: ${meta.fileCount}\n`;
+        }
+      }
+
+      output += "\n═════════════════════\n";
+      output += `\nTotal: ${branches.length} branch(es)\n`;
+
+      return output;
+    } catch (error) {
+      console.error("Error listing contexts:", error);
+      return `❌ Failed to list contexts: ${error instanceof Error ? error.message : "Unknown error"}`;
+    }
+  },
+});

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OpenCode Branch Memory Manager Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.