opencode-branch-memory-manager 0.1.0

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

@@ -0,0 +1,230 @@
+import chokidar from "chokidar";
+import type { FSWatcher } from "chokidar";
+import type { PluginConfig } from "./types.js";
+import { GitOperations } from "./git.js";
+
+/**
+ * Monitors git branch changes
+ */
+export class BranchMonitor {
+  private watcher?: FSWatcher;
+  private pollingInterval?: NodeJS.Timeout;
+  private currentBranch?: string;
+  private lastPoll?: number;
+  private changeCallbacks: Array<
+    (oldBranch: string | undefined, newBranch: string) => void
+  > = [];
+  private isMonitoring = false;
+
+  constructor(
+    private onBranchChange: (
+      oldBranch: string | undefined,
+      newBranch: string,
+    ) => void,
+    private config: PluginConfig,
+  ) {}
+
+  /**
+   * Start monitoring git branch changes
+   */
+  async start(): Promise<void> {
+    if (this.isMonitoring) {
+      return;
+    }
+
+    const gitDir = await GitOperations.getGitDir();
+
+    if (!gitDir) {
+      console.warn("Not in a git repository, branch monitoring disabled");
+      return;
+    }
+
+    // Get current branch
+    const branch = await GitOperations.getCurrentBranch();
+    this.currentBranch = branch || undefined;
+
+    if (!this.currentBranch) {
+      console.warn("Not on a git branch, branch monitoring disabled");
+      return;
+    }
+
+    // Start watcher
+    if (
+      this.config.monitoring.method === "watcher" ||
+      this.config.monitoring.method === "both"
+    ) {
+      this.startWatcher(gitDir);
+    }
+
+    // Start polling as fallback
+    if (
+      this.config.monitoring.method === "polling" ||
+      this.config.monitoring.method === "both"
+    ) {
+      this.startPolling();
+    }
+
+    this.isMonitoring = true;
+    console.log(`✓ Branch monitoring started for: ${this.currentBranch}`);
+    console.log(`  Method: ${this.config.monitoring.method}`);
+    console.log(
+      `  Polling interval: ${this.config.monitoring.pollingInterval}ms`,
+    );
+  }
+
+  /**
+   * Start file watcher on .git/HEAD
+   * @param gitDir - Path to .git directory
+   */
+  private startWatcher(gitDir: string): void {
+    try {
+      const headFile = `${gitDir}/HEAD`;
+
+      this.watcher = chokidar.watch(headFile, {
+        ignoreInitial: true,
+        persistent: true,
+        awaitWriteFinish: { stabilityThreshold: 100 },
+        usePolling: false, // Use native file system events
+      });
+
+      this.watcher.on("change", async () => {
+        // Debounce file changes (rapid changes within 100ms)
+        await this.checkBranchChange();
+      });
+
+      this.watcher.on("error", (error: unknown) => {
+        console.error("Watcher error:", error);
+
+        // Fall back to polling if watcher fails
+        if (this.config.monitoring.method === "watcher") {
+          console.info("Watcher failed, falling back to polling");
+          this.stopWatcher();
+          this.startPolling();
+        }
+      });
+
+      console.log(`✓ File watcher started: ${headFile}`);
+    } catch (error) {
+      console.error("Failed to start watcher:", error);
+    }
+  }
+
+  /**
+   * Start polling for branch changes
+   */
+  private startPolling(): void {
+    const interval = this.config.monitoring.pollingInterval || 1000;
+
+    this.pollingInterval = setInterval(async () => {
+      await this.checkBranchChange();
+    }, interval);
+
+    console.log(`✓ Polling started (interval: ${interval}ms)`);
+  }
+
+  /**
+   * Stop monitoring
+   */
+  stop(): void {
+    this.stopWatcher();
+    this.stopPolling();
+    this.isMonitoring = false;
+    console.log("✓ Branch monitoring stopped");
+  }
+
+  /**
+   * Stop file watcher
+   */
+  private stopWatcher(): void {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = undefined;
+    }
+  }
+
+  /**
+   * Stop polling
+   */
+  private stopPolling(): void {
+    if (this.pollingInterval) {
+      clearInterval(this.pollingInterval);
+      this.pollingInterval = undefined;
+    }
+  }
+
+  /**
+   * Check for branch change
+   */
+  private async checkBranchChange(): Promise<void> {
+    try {
+      const newBranch = await GitOperations.getCurrentBranch();
+
+      if (newBranch && newBranch !== this.currentBranch) {
+        const oldBranch = this.currentBranch;
+        this.currentBranch = newBranch;
+
+        console.log(
+          `🔄 Branch changed: ${oldBranch || "(none)"} → ${newBranch}`,
+        );
+
+        // Call all registered callbacks
+        for (const callback of this.changeCallbacks) {
+          try {
+            await callback(oldBranch, newBranch);
+          } catch (error) {
+            console.error("Error in branch change callback:", error);
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error checking branch:", error);
+    }
+  }
+
+  /**
+   * Register a callback for branch changes
+   * @param callback - Function to call on branch change
+   */
+  onChange(
+    callback: (oldBranch: string | undefined, newBranch: string) => void,
+  ): void {
+    this.changeCallbacks.push(callback);
+  }
+
+  /**
+   * Unregister a callback
+   * @param callback - Function to remove
+   */
+  offChange(
+    callback: (oldBranch: string | undefined, newBranch: string) => void,
+  ): void {
+    const index = this.changeCallbacks.indexOf(callback);
+    if (index > -1) {
+      this.changeCallbacks.splice(index, 1);
+    }
+  }
+
+  /**
+   * Get current monitored branch
+   * @returns Current branch name or undefined
+   */
+  getCurrentBranch(): string | undefined {
+    return this.currentBranch;
+  }
+
+  /**
+   * Check if monitoring is active
+   * @returns True if monitoring
+   */
+  isActive(): boolean {
+    return this.isMonitoring;
+  }
+
+  /**
+   * Test helper: Manually trigger branch change check
+   * @internal For testing purposes only
+   */
+  async _testTriggerCheck(): Promise<void> {
+    await this.checkBranchChange();
+  }
+}

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

@@ -0,0 +1,322 @@
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import { existsSync } from 'fs'
+import type { BranchContext } from './types.js'
+
+/**
+ * Context storage manager for branch-specific contexts
+ */
+export class ContextStorage {
+  private storageDir: string
+  
+  constructor(storageDir: string) {
+    this.storageDir = storageDir
+  }
+  
+  /**
+   * Get the file path for a branch
+   * @param branch - Branch name
+   * @returns Full path to branch context file
+   */
+  private getBranchFile(branch: string): string {
+    return path.join(this.storageDir, `${this.sanitizeBranchName(branch)}.json`)
+  }
+  
+  /**
+   * Get the backup file path for a branch
+   * @param branch - Branch name
+   * @param timestamp - Timestamp for backup filename
+   * @returns Full path to backup file
+   */
+  private getBackupFile(branch: string, timestamp: number): string {
+    const safeBranch = this.sanitizeBranchName(branch)
+    return path.join(this.storageDir, `${safeBranch}.backup.${timestamp}.json`)
+  }
+  
+  /**
+   * Sanitize branch name for safe filename usage
+   * @param branch - Branch name to sanitize
+   * @returns Sanitized branch name
+   */
+  private sanitizeBranchName(branch: string): string {
+    return branch
+      .replace(/[\/\\:*?"<>|]/g, '_')
+      .replace(/\s+/g, '-')
+      .substring(0, 255)
+  }
+  
+  /**
+   * Ensure storage directory exists
+   */
+  async ensureStorageDir(): Promise<void> {
+    try {
+      await fs.mkdir(this.storageDir, { recursive: true })
+    } catch (error) {
+      console.error('Failed to create storage directory:', error)
+      throw error
+    }
+  }
+  
+  /**
+   * Save context for a branch with automatic backup
+   * @param branch - Branch name
+   * @param context - Branch context to save
+   */
+  async saveContext(branch: string, context: BranchContext): Promise<void> {
+    await this.ensureStorageDir()
+    
+    const filePath = this.getBranchFile(branch)
+    // Use unique temp file to avoid race conditions in concurrent saves
+    const tempFile = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).substring(2, 9)}`
+    
+    try {
+      // Create backup if file exists
+      if (existsSync(filePath)) {
+        await this.createBackup(branch, filePath)
+      }
+      
+      // Write to temp file first (atomic operation)
+      await fs.writeFile(tempFile, JSON.stringify(context, null, 2), 'utf8')
+      
+      // Atomic rename (guaranteed on all platforms)
+      await fs.rename(tempFile, filePath)
+    } catch (error) {
+      // Cleanup temp file on failure
+      try {
+        await fs.unlink(tempFile).catch(() => {})
+      } catch {}
+      throw error
+    }
+  }
+  
+  /**
+   * Load context for a branch with validation
+   * @param branch - Branch name
+   * @returns Branch context or null if not found
+   */
+  async loadContext(branch: string): Promise<BranchContext | null> {
+    const filePath = this.getBranchFile(branch)
+    
+    if (!existsSync(filePath)) {
+      return null
+    }
+    
+    try {
+      const content = await fs.readFile(filePath, 'utf8')
+      const data = JSON.parse(content) as BranchContext
+      
+      // Validate version compatibility
+      if (data.metadata?.version !== '1.0.0') {
+        console.warn(`Context version mismatch for branch '${branch}': ${data.metadata?.version}`)
+      }
+      
+      return data
+    } catch (error) {
+      console.error(`Failed to load context for branch '${branch}':`, error)
+      
+      // Try to restore from backup
+      const backup = await this.restoreFromBackup(branch)
+      if (backup) {
+        console.info(`Restored from backup for branch '${branch}'`)
+        return backup
+      }
+      
+      return null
+    }
+  }
+  
+  /**
+   * Create backup of existing context file
+   * @param branch - Branch name
+   * @param filePath - Path to existing file
+   */
+  private async createBackup(branch: string, filePath: string): Promise<void> {
+    try {
+      // Check if file still exists (might have been deleted by concurrent operation)
+      if (!existsSync(filePath)) {
+        return
+      }
+      
+      const backupFile = this.getBackupFile(branch, Date.now())
+      await fs.copyFile(filePath, backupFile)
+      
+      // Clean old backups (keep last 5)
+      await this.cleanOldBackups(branch)
+    } catch (error) {
+      console.warn('Failed to create backup:', error)
+    }
+  }
+  
+  /**
+   * Clean old backups, keeping only the last maxBackups
+   * @param branch - Branch name
+   */
+  private async cleanOldBackups(branch: string): Promise<void> {
+    try {
+      const files = await fs.readdir(this.storageDir)
+      const safeBranch = this.sanitizeBranchName(branch)
+      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) // Keep last 5
+      
+      for (const backup of backups) {
+        await fs.unlink(path.join(this.storageDir, backup.name)).catch(() => {})
+      }
+    } catch (error) {
+      console.warn('Failed to clean old backups:', error)
+    }
+  }
+  
+  /**
+   * Restore context from backup files
+   * @param branch - Branch name
+   * @returns Restored context or null if no valid backup found
+   */
+  private async restoreFromBackup(branch: string): Promise<BranchContext | null> {
+    try {
+      const files = await fs.readdir(this.storageDir)
+      const safeBranch = this.sanitizeBranchName(branch)
+      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)
+      
+      for (const backup of backups) {
+        try {
+          const content = await fs.readFile(
+            path.join(this.storageDir, backup.name),
+            'utf8'
+          )
+          return JSON.parse(content) as BranchContext
+        } catch {
+          // Try next backup
+          continue
+        }
+      }
+    } catch (error) {
+      console.error('Failed to restore from backup:', error)
+    }
+    return null
+  }
+  
+  /**
+   * List all branches with saved contexts
+   * @returns Array of branch names
+   */
+  async listBranches(): Promise<string[]> {
+    try {
+      await this.ensureStorageDir()
+      const files = await fs.readdir(this.storageDir)
+      const branches: string[] = []
+      
+      for (const file of files) {
+        if (file.endsWith('.json') && !file.includes('.backup.')) {
+          try {
+            const filePath = path.join(this.storageDir, file)
+            const content = await fs.readFile(filePath, 'utf8')
+            const data = JSON.parse(content) as BranchContext
+            branches.push(data.branch)
+          } catch {
+            // Skip invalid files
+            continue
+          }
+        }
+      }
+      
+      return branches
+    } catch (error) {
+      console.error('Failed to list branches:', error)
+      return []
+    }
+  }
+  
+  /**
+   * Get metadata for a branch's saved context
+   * @param branch - Branch name
+   * @returns Metadata object
+   */
+  async getMetadata(branch: string): Promise<{
+    size: string
+    modified: string
+    messageCount: number
+    todoCount: number
+    fileCount: number
+  }> {
+    const filePath = this.getBranchFile(branch)
+    
+    if (!existsSync(filePath)) {
+      return {
+        size: '0KB',
+        modified: 'Never',
+        messageCount: 0,
+        todoCount: 0,
+        fileCount: 0
+      }
+    }
+    
+    try {
+      const content = await fs.readFile(filePath, 'utf8')
+      const data = JSON.parse(content) as BranchContext
+      
+      // Use metadata.size if available, otherwise calculate from file
+      let size: string
+      if (data.metadata?.size !== undefined) {
+        size = `${(data.metadata.size / 1024).toFixed(1)}KB`
+      } else {
+        const stats = await fs.stat(filePath)
+        size = `${(stats.size / 1024).toFixed(1)}KB`
+      }
+      
+      return {
+        size,
+        modified: data.savedAt || new Date().toISOString(),
+        messageCount: data.metadata?.messageCount || 0,
+        todoCount: data.metadata?.todoCount || 0,
+        fileCount: data.metadata?.fileCount || 0
+      }
+    } catch (error) {
+      console.error('Failed to get metadata:', error)
+      return {
+        size: 'Error',
+        modified: 'Error',
+        messageCount: 0,
+        todoCount: 0,
+        fileCount: 0
+      }
+    }
+  }
+  
+  /**
+   * Delete context for a branch including all backups
+   * @param branch - Branch name
+   */
+  async deleteContext(branch: string): Promise<void> {
+    const filePath = this.getBranchFile(branch)
+    
+    // Delete main context file
+    if (existsSync(filePath)) {
+      await fs.unlink(filePath).catch(() => {})
+    }
+    
+    // Delete all backups
+    try {
+      const files = await fs.readdir(this.storageDir)
+      const safeBranch = this.sanitizeBranchName(branch)
+      const backups = files.filter(f => f.startsWith(`${safeBranch}.backup.`) && f.endsWith('.json'))
+      
+      for (const backup of backups) {
+        await fs.unlink(path.join(this.storageDir, backup)).catch(() => {})
+      }
+    } catch (error) {
+      console.error('Failed to delete backups:', error)
+    }
+  }
+}

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

@@ -0,0 +1,68 @@
+/**
+ * Branch context data structure
+ */
+export interface BranchContext {
+  branch: string
+  savedAt: string
+  metadata: {
+    version: string
+    platform: string
+    size: number
+    messageCount: number
+    todoCount: number
+    fileCount: number
+  }
+  data: {
+    messages?: Message[]
+    todos?: Todo[]
+    files?: string[]
+    summary?: string
+    description?: string
+    [key: string]: unknown  // Allow additional dynamic properties
+  }
+}
+
+/**
+ * Message data structure
+ */
+export interface Message {
+  role: 'user' | 'assistant'
+  content: string
+  timestamp: string
+}
+
+/**
+ * Todo item data structure
+ */
+export interface Todo {
+  id: string
+  content: string
+  status: 'pending' | 'in_progress' | 'completed'
+}
+
+/**
+ * Plugin configuration
+ */
+export interface PluginConfig {
+  autoSave: {
+    enabled: boolean
+    onMessageChange: boolean
+    onBranchChange: boolean
+    onToolExecute: boolean
+  }
+  contextLoading: 'auto' | 'ask' | 'manual'
+  context: {
+    defaultInclude: ('messages' | 'todos' | 'files')[]
+    maxMessages: number
+    maxTodos: number
+    compression: boolean
+  }
+  storage: {
+    maxBackups: number
+    retentionDays: number
+  }
+  monitoring: {
+    method: 'watcher' | 'polling' | 'both'
+    pollingInterval: number
+  }
+}