opencode-branch-memory-manager 0.1.0

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

@@ -0,0 +1,90 @@
+import type { BranchContext, PluginConfig } from "./types.js";
+import { GitOperations } from "./git.js";
+
+/**
+ * Collects context data from various sources
+ */
+export class ContextCollector {
+  private config: PluginConfig;
+
+  constructor(config: PluginConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Collect context from available sources
+   * @param includeMessages - Include conversation messages
+   * @param includeTodos - Include todo items
+   * @param includeFiles - Include file references
+   * @param description - Description of what's being saved
+   * @returns Complete context object
+   */
+  async collectContext(
+    includeMessages: boolean = true,
+    includeTodos: boolean = true,
+    includeFiles: boolean = true,
+    description: string = "",
+  ): Promise<BranchContext> {
+    const currentBranch = await GitOperations.getCurrentBranch();
+
+    if (!currentBranch) {
+      throw new Error("Not on a git branch");
+    }
+
+    const data: BranchContext["data"] = {
+      description: description || "",
+    };
+
+    // Collect messages (placeholder - will use OpenCode SDK when available)
+    if (includeMessages) {
+      data.messages = await this.collectMessages();
+    }
+
+    // Collect todos (placeholder - will use OpenCode SDK when available)
+    if (includeTodos) {
+      data.todos = await this.collectTodos();
+    }
+
+    // Collect modified files from git
+    if (includeFiles) {
+      data.files = await GitOperations.getModifiedFiles();
+    }
+
+    // Calculate metadata
+    const context: BranchContext = {
+      branch: currentBranch,
+      savedAt: new Date().toISOString(),
+      metadata: {
+        version: "1.0.0",
+        platform: process.platform,
+        size: JSON.stringify(data).length,
+        messageCount: data.messages?.length || 0,
+        todoCount: data.todos?.length || 0,
+        fileCount: data.files?.length || 0,
+      },
+      data,
+    };
+
+    return context;
+  }
+
+  /**
+   * Collect conversation messages
+   * @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 [];
+  }
+
+  /**
+   * Collect todo items
+   * @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 [];
+  }
+}

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

@@ -0,0 +1,127 @@
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import { existsSync } from 'fs'
+import type { PluginConfig } from './types.js'
+
+/**
+ * Default configuration for the branch memory plugin
+ */
+const DEFAULT_CONFIG: PluginConfig = {
+  autoSave: {
+    enabled: true,
+    onMessageChange: true,
+    onBranchChange: true,
+    onToolExecute: true
+  },
+  contextLoading: 'auto',
+  context: {
+    defaultInclude: ['messages', 'todos', 'files'],
+    maxMessages: 50,
+    maxTodos: 20,
+    compression: false
+  },
+  storage: {
+    maxBackups: 5,
+    retentionDays: 90
+  },
+  monitoring: {
+    method: 'both',
+    pollingInterval: 1000
+  }
+}
+
+/**
+ * Configuration manager for branch memory plugin
+ */
+export class ConfigManager {
+  private static configPath: string
+  private static projectPath: string
+  
+  /**
+   * Set the project path for configuration
+   * @param projectPath - The root directory of the project
+   */
+  static setProjectPath(projectPath: string): void {
+    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> {
+    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) {
+        console.warn('Failed to load config, using defaults:', error instanceof Error ? error.message : error)
+        return { ...DEFAULT_CONFIG }
+      }
+    }
+    return { ...DEFAULT_CONFIG }
+  }
+  
+  /**
+   * Get default configuration
+   * @returns Default configuration object
+   */
+  static 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')
+  }
+  
+  /**
+   * Save configuration to project directory
+   * @param config - Configuration object to save
+   */
+  static 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')
+    } catch (error) {
+      console.error('Failed to save configuration:', error)
+      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 {
+    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)) {
+          result[key] = this.deepMerge(targetValue as any, sourceValue as any) as any
+        } else {
+          result[key] = sourceValue as any
+        }
+      }
+    }
+    
+    return result
+  }
+}

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

@@ -0,0 +1,169 @@
+import { spawn } from 'child_process'
+
+/**
+ * Git operations for branch memory manager
+ */
+export class GitOperations {
+  private static async runGitCommand(...args: string[]): Promise<{
+    stdout: string
+    stderr: string
+    exitCode: number
+  }> {
+    return new Promise((resolve, reject) => {
+      const git = spawn('git', args, {
+        cwd: process.cwd(),
+        stdio: ['pipe', 'pipe', 'pipe']
+      })
+      
+      let stdout = ''
+      let stderr = ''
+      
+      git.stdout.on('data', (data) => {
+        stdout += data.toString()
+      })
+      
+      git.stderr.on('data', (data) => {
+        stderr += data.toString()
+      })
+      
+      git.on('close', (code) => {
+        resolve({
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+          exitCode: code ?? 0
+        })
+      })
+      
+      git.on('error', (err) => {
+        resolve({
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+          exitCode: 1
+        })
+      })
+    })
+  }
+
+  static async getCurrentBranch(): Promise<string | null> {
+    const result = await this.runGitCommand('symbolic-ref', '--short', 'HEAD')
+    
+    if (result.exitCode !== 0 || result.stderr.length > 0) {
+      return null
+    }
+    
+    const branch = result.stdout
+    
+    if (branch === 'HEAD' || branch === '') {
+      return null
+    }
+    
+    return branch
+  }
+
+  static async getGitDir(): Promise<string | null> {
+    const result = await this.runGitCommand('rev-parse', '--git-dir')
+    
+    if (result.exitCode !== 0 || result.stderr.length > 0) {
+      return null
+    }
+    
+    return result.stdout
+  }
+
+  static async isGitRepo(): Promise<boolean> {
+    const gitDir = await this.getGitDir()
+    return gitDir !== null
+  }
+
+  static async isBareRepo(): Promise<boolean> {
+    const result = await this.runGitCommand('rev-parse', '--is-bare-repository')
+    return result.stdout === 'true' && result.exitCode === 0
+  }
+
+  static async getModifiedFiles(): Promise<string[]> {
+    const result = await this.runGitCommand('diff', '--name-only')
+    
+    if (result.exitCode !== 0) {
+      return []
+    }
+    
+    if (result.stdout.length === 0) {
+      return []
+    }
+    
+    return result.stdout.split('\n').filter(f => f.length > 0)
+  }
+
+  static async getAllBranches(): Promise<string[]> {
+    const result = await this.runGitCommand('branch', "--format='%(refname:short)'")
+    
+    if (result.exitCode !== 0) {
+      return []
+    }
+    
+    if (result.stdout.length === 0) {
+      return []
+    }
+    
+    return result.stdout.split('\n').filter(f => f.length > 0)
+  }
+
+  static sanitizeBranchName(branch: string): string {
+    return branch
+      .replace(/[\/\\:*?"<>|]/g, '_')
+      .replace(/\s+/g, '-')
+      .replace(/[\u0000-\u001F\u007F-\u009F]/g, '')
+      .replace(/[\uE000-\uF8FF\uFFF0-\uFFFF]/g, '')
+      .substring(0, 255)
+      .trim()
+  }
+
+  static async getCurrentCommit(): Promise<string | null> {
+    const result = await this.runGitCommand('rev-parse', 'HEAD')
+    
+    if (result.exitCode !== 0 || result.stderr.length > 0) {
+      return null
+    }
+    
+    return result.stdout
+  }
+
+  static async isGitAvailable(): Promise<boolean> {
+    const result = await this.runGitCommand('--version')
+    return result.exitCode === 0
+  }
+
+  static async getRemoteUrl(): Promise<string | null> {
+    const branch = await this.getCurrentBranch()
+    if (!branch) {
+      return null
+    }
+    
+    const remoteResult = await this.runGitCommand('config', `branch.${branch}.remote`)
+    if (remoteResult.exitCode !== 0) {
+      return null
+    }
+    
+    const remote = remoteResult.stdout
+    if (remote.length === 0) {
+      return null
+    }
+    
+    const urlResult = await this.runGitCommand('remote', 'get-url', remote)
+    if (urlResult.exitCode !== 0) {
+      return null
+    }
+    
+    return urlResult.stdout
+  }
+
+  static async hasUncommittedChanges(): Promise<boolean> {
+    const result = await this.runGitCommand('status', '--porcelain')
+    
+    if (result.exitCode !== 0) {
+      return false
+    }
+    
+    return result.stdout.length > 0
+  }
+}

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

@@ -0,0 +1,7 @@
+export { ContextStorage } from "./storage.js";
+export { GitOperations } from "./git.js";
+export { ContextCollector } from "./collector.js";
+export { ContextInjector } from "./injector.js";
+export { BranchMonitor } from "./monitor.js";
+export { ConfigManager } from "./config.js";
+export type { BranchContext, PluginConfig, Message, Todo } from "./types.js";

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

@@ -0,0 +1,108 @@
+import type { ToolContext } from '@opencode-ai/plugin'
+import type { BranchContext } from './types.js'
+
+/**
+ * Injects context into OpenCode sessions
+ */
+export class ContextInjector {
+  private context: ToolContext
+  
+  constructor(context: ToolContext) {
+    this.context = context
+  }
+  
+  /**
+   * Inject context into current session without triggering AI response
+   * @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))
+  }
+  
+  /**
+   * Ask user if they want to load context (interactive mode)
+   * @param branchContext - Branch context to load
+   * @returns User's decision
+   */
+  async askUserAboutContextLoading(
+    branchContext: BranchContext
+  ): Promise<boolean> {
+    const summary = this.formatContextSummary(branchContext)
+    
+    console.log('\n📥 Context available for branch:', branchContext.branch)
+    console.log('─'.repeat(50))
+    console.log(summary)
+    console.log('─'.repeat(50))
+    console.log('Load this context? (y/n)')
+    
+    // For now, auto-return true (would use TUI API in production)
+    // In real implementation, this would use OpenCode TUI to prompt user
+    return true
+  }
+  
+  /**
+   * Format context as human-readable summary
+   * @param context - Branch context to format
+   * @returns Formatted summary string
+   */
+  private formatContextSummary(context: BranchContext): string {
+    const lines = [
+      `# Branch Context Loaded: ${context.branch}`,
+      `Restored from: ${context.savedAt}`,
+      ''
+    ]
+    
+    if (context.data.description) {
+      lines.push('## Description')
+      lines.push(context.data.description)
+      lines.push('')
+    }
+    
+    if (context.data.messages && context.data.messages.length > 0) {
+      lines.push(`## Recent Messages (${context.data.messages.length})`)
+      lines.push('... [Conversation history loaded] ...')
+      lines.push('')
+    }
+    
+    if (context.data.todos && context.data.todos.length > 0) {
+      lines.push(`## Todo Items (${context.data.todos.length})`)
+      for (const todo of context.data.todos) {
+        const checkbox = todo.status === 'completed' ? 'x' : ' '
+        lines.push(`- [${checkbox}] ${todo.content}`)
+      }
+      lines.push('')
+    }
+    
+    if (context.data.files && context.data.files.length > 0) {
+      lines.push(`## Modified Files (${context.data.files.length})`)
+      for (const file of context.data.files) {
+        lines.push(`- ${file}`)
+      }
+      lines.push('')
+    }
+    
+    return lines.join('\n')
+  }
+  
+  /**
+   * Check if there is context data to inject
+   * @param context - Branch context to check
+   * @returns True if context has data
+   */
+  hasContextData(context: BranchContext): boolean {
+    return !!(
+      context.data.description ||
+      (context.data.messages && context.data.messages.length > 0) ||
+      (context.data.todos && context.data.todos.length > 0) ||
+      (context.data.files && context.data.files.length > 0)
+    )
+  }
+}