@stackmemoryai/stackmemory 0.3.26 → 0.4.1

package/dist/integrations/ralph/recovery/crash-recovery.js

@@ -0,0 +1,458 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { logger } from "../../../core/monitoring/logger.js";
+class CrashRecoverySystem {
+  checkpoints = /* @__PURE__ */ new Map();
+  crashReports = [];
+  recoveryStrategies = [];
+  swarmCoordinator;
+  checkpointInterval;
+  recoveryDir;
+  constructor(swarmCoordinator, recoveryDir = ".swarm/recovery") {
+    this.swarmCoordinator = swarmCoordinator;
+    this.recoveryDir = recoveryDir;
+    this.setupRecoveryStrategies();
+  }
+  /**
+   * Initialize crash recovery system
+   */
+  async initialize() {
+    await this.ensureRecoveryDirectory();
+    await this.loadExistingCheckpoints();
+    this.startPeriodicCheckpoints();
+    process.on("unhandledRejection", (reason, promise) => {
+      this.handleCrash(new Error(`Unhandled Rejection: ${reason}`), {
+        type: "unhandled_rejection",
+        promise: promise.toString()
+      });
+    });
+    process.on("uncaughtException", (error) => {
+      this.handleCrash(error, { type: "uncaught_exception" });
+    });
+    logger.info("Crash recovery system initialized");
+  }
+  /**
+   * Create recovery checkpoint
+   */
+  async createCheckpoint(swarmId, reason = "periodic") {
+    try {
+      const swarmState = this.swarmCoordinator.swarmState;
+      const agents = Array.from(
+        this.swarmCoordinator.activeAgents.values()
+      );
+      const checkpoint = {
+        id: this.generateId(),
+        swarmId,
+        timestamp: Date.now(),
+        swarmState: { ...swarmState },
+        agents: agents.map((agent) => ({ ...agent })),
+        tasks: swarmState.tasks || [],
+        errorLog: this.crashReports.slice(-10),
+        // Last 10 errors
+        gitState: await this.captureGitState()
+      };
+      const checkpointPath = path.join(
+        this.recoveryDir,
+        `checkpoint-${checkpoint.id}.json`
+      );
+      await fs.writeFile(checkpointPath, JSON.stringify(checkpoint, null, 2));
+      this.checkpoints.set(checkpoint.id, checkpoint);
+      logger.info(
+        `Created checkpoint ${checkpoint.id} for swarm ${swarmId} (${reason})`
+      );
+      return checkpoint.id;
+    } catch (error) {
+      logger.error("Failed to create checkpoint:", error);
+      throw error;
+    }
+  }
+  /**
+   * Handle crash or error
+   */
+  async handleCrash(error, context = {}) {
+    const report = {
+      id: this.generateId(),
+      timestamp: Date.now(),
+      agentId: context.agentId,
+      errorType: this.classifyError(error, context),
+      error,
+      context,
+      recoveryAction: "",
+      severity: this.assessSeverity(error, context),
+      resolved: false
+    };
+    this.crashReports.push(report);
+    logger.error(`Crash detected [${report.id}]:`, error);
+    const recovered = await this.attemptRecovery(report);
+    if (recovered) {
+      report.resolved = true;
+      report.recoveryAction = "auto_recovered";
+      logger.info(`Successfully recovered from crash ${report.id}`);
+    } else {
+      logger.error(`Failed to recover from crash ${report.id}`);
+      if (report.severity === "critical") {
+        await this.escalateCriticalFailure(report);
+      }
+    }
+    await this.saveCrashReport(report);
+  }
+  /**
+   * Restore from checkpoint
+   */
+  async restoreFromCheckpoint(checkpointId) {
+    try {
+      const checkpoint = this.checkpoints.get(checkpointId);
+      if (!checkpoint) {
+        logger.error(`Checkpoint ${checkpointId} not found`);
+        return false;
+      }
+      logger.info(`Restoring from checkpoint ${checkpointId}`);
+      await this.restoreGitState(checkpoint.gitState);
+      if (checkpoint.databaseBackup) {
+        await this.restoreDatabase(checkpoint.databaseBackup);
+      }
+      await this.restoreSwarmState(checkpoint);
+      logger.info(`Successfully restored from checkpoint ${checkpointId}`);
+      return true;
+    } catch (error) {
+      logger.error(
+        `Failed to restore from checkpoint ${checkpointId}:`,
+        error
+      );
+      return false;
+    }
+  }
+  /**
+   * Get recovery recommendations
+   */
+  getRecoveryRecommendations() {
+    const recent = Date.now() - 36e5;
+    const recentCheckpoints = Array.from(this.checkpoints.values()).filter((cp) => cp.timestamp > recent).sort((a, b) => b.timestamp - a.timestamp).slice(0, 5);
+    const errorCounts = /* @__PURE__ */ new Map();
+    const errorTimes = /* @__PURE__ */ new Map();
+    for (const report of this.crashReports.filter(
+      (r) => r.timestamp > recent
+    )) {
+      errorCounts.set(
+        report.errorType,
+        (errorCounts.get(report.errorType) || 0) + 1
+      );
+      errorTimes.set(
+        report.errorType,
+        Math.max(errorTimes.get(report.errorType) || 0, report.timestamp)
+      );
+    }
+    const frequentErrors = Array.from(errorCounts.entries()).map(([type, count]) => ({
+      type,
+      count,
+      lastOccurrence: errorTimes.get(type) || 0
+    })).sort((a, b) => b.count - a.count);
+    const criticalErrors = this.crashReports.filter(
+      (r) => r.severity === "critical" && r.timestamp > recent && !r.resolved
+    );
+    const systemHealth = criticalErrors.length > 0 ? "critical" : frequentErrors.length > 3 ? "degraded" : "good";
+    return {
+      recentCheckpoints,
+      frequentErrors,
+      recoveryActions: this.generateRecoveryActions(frequentErrors),
+      systemHealth
+    };
+  }
+  /**
+   * Auto-recovery from common failures
+   */
+  async attemptAutoRecovery(swarmId) {
+    logger.info(`Attempting auto-recovery for swarm ${swarmId}`);
+    try {
+      const recentCheckpoint = this.findRecentCheckpoint(swarmId);
+      if (recentCheckpoint) {
+        logger.info(`Found recent checkpoint: ${recentCheckpoint.id}`);
+        return await this.restoreFromCheckpoint(recentCheckpoint.id);
+      }
+      await this.swarmCoordinator.forceCleanup();
+      await this.clearProblematicState();
+      logger.info("Restarting swarm with minimal configuration");
+      return true;
+    } catch (error) {
+      logger.error("Auto-recovery failed:", error);
+      return false;
+    }
+  }
+  async attemptRecovery(report) {
+    for (const strategy of this.recoveryStrategies) {
+      if (strategy.condition(report.error, report.context)) {
+        logger.info(`Applying recovery strategy: ${strategy.errorType}`);
+        let retries = 0;
+        while (retries < strategy.maxRetries) {
+          try {
+            const success = await strategy.action(report, this);
+            if (success) {
+              report.recoveryAction = strategy.errorType;
+              return true;
+            }
+          } catch (error) {
+            logger.warn(
+              `Recovery attempt ${retries + 1} failed:`,
+              error
+            );
+          }
+          retries++;
+          if (retries < strategy.maxRetries) {
+            await this.sleep(strategy.backoffMs * Math.pow(2, retries));
+          }
+        }
+      }
+    }
+    return false;
+  }
+  classifyError(error, context) {
+    const message = error.message.toLowerCase();
+    if (message.includes("database") || message.includes("sqlite")) {
+      return "database_failure";
+    } else if (message.includes("git") || message.includes("branch")) {
+      return "git_conflict";
+    } else if (message.includes("timeout") || context.timeout) {
+      return "agent_timeout";
+    } else if (message.includes("memory") || message.includes("heap")) {
+      return "memory_overflow";
+    } else if (message.includes("network") || message.includes("connect")) {
+      return "network_error";
+    }
+    return "database_failure";
+  }
+  assessSeverity(error, context) {
+    if (context.type === "uncaught_exception") return "critical";
+    if (error.message.includes("unhandled")) return "high";
+    if (error.message.includes("database")) return "medium";
+    return "low";
+  }
+  setupRecoveryStrategies() {
+    this.recoveryStrategies = [
+      {
+        errorType: "database_failure",
+        condition: (error) => error.message.includes("database") || error.message.includes("sqlite"),
+        action: async (report, recovery) => {
+          logger.info("Attempting database recovery");
+          try {
+            await recovery.clearProblematicState();
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        maxRetries: 3,
+        backoffMs: 1e3
+      },
+      {
+        errorType: "git_conflict",
+        condition: (error) => error.message.includes("git") || error.message.includes("branch"),
+        action: async (report, recovery) => {
+          logger.info("Attempting git conflict resolution");
+          try {
+            const { execSync } = await import("child_process");
+            execSync("git checkout main", { stdio: "ignore" });
+            execSync("git reset --hard HEAD", { stdio: "ignore" });
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        maxRetries: 2,
+        backoffMs: 500
+      },
+      {
+        errorType: "agent_timeout",
+        condition: (error, context) => error.message.includes("timeout") || context.timeout,
+        action: async (report, recovery) => {
+          logger.info("Attempting agent timeout recovery");
+          await recovery.swarmCoordinator.forceCleanup();
+          return true;
+        },
+        maxRetries: 1,
+        backoffMs: 2e3
+      },
+      {
+        errorType: "memory_overflow",
+        condition: (error) => error.message.includes("memory") || error.message.includes("heap"),
+        action: async (report, recovery) => {
+          logger.info("Attempting memory recovery");
+          if (global.gc) global.gc();
+          await recovery.cleanupOldCheckpoints(5);
+          return true;
+        },
+        maxRetries: 1,
+        backoffMs: 5e3
+      }
+    ];
+  }
+  async captureGitState() {
+    try {
+      const { execSync } = await import("child_process");
+      const currentBranch = execSync("git branch --show-current", {
+        encoding: "utf8"
+      }).trim();
+      const statusOutput = execSync("git status --porcelain", {
+        encoding: "utf8"
+      });
+      const uncommittedChanges = statusOutput.trim().split("\n").filter(Boolean);
+      const branchesOutput = execSync("git branch", { encoding: "utf8" });
+      const activeBranches = branchesOutput.split("\n").map((line) => line.trim().replace(/^\*?\s*/, "")).filter(Boolean);
+      return {
+        currentBranch,
+        uncommittedChanges,
+        activeBranches
+      };
+    } catch (error) {
+      logger.warn("Failed to capture git state:", error);
+      return {
+        currentBranch: "unknown",
+        uncommittedChanges: [],
+        activeBranches: []
+      };
+    }
+  }
+  async restoreGitState(gitState) {
+    try {
+      const { execSync } = await import("child_process");
+      execSync(`git checkout ${gitState.currentBranch}`, { stdio: "ignore" });
+      logger.info(`Restored git branch: ${gitState.currentBranch}`);
+    } catch (error) {
+      logger.warn("Failed to restore git state:", error);
+    }
+  }
+  async restoreDatabase(backupPath) {
+    logger.info(`Restoring database from ${backupPath}`);
+  }
+  async restoreSwarmState(checkpoint) {
+    logger.info(`Restoring swarm state from checkpoint ${checkpoint.id}`);
+  }
+  findRecentCheckpoint(swarmId) {
+    const recent = Date.now() - 18e5;
+    return Array.from(this.checkpoints.values()).filter((cp) => cp.swarmId === swarmId && cp.timestamp > recent).sort((a, b) => b.timestamp - a.timestamp)[0] || null;
+  }
+  async clearProblematicState() {
+    try {
+      await this.cleanupTempFiles();
+      logger.info("Cleared problematic state");
+    } catch (error) {
+      logger.error("Failed to clear problematic state:", error);
+    }
+  }
+  async cleanupTempFiles() {
+  }
+  async cleanupOldCheckpoints(keepCount) {
+    const sorted = Array.from(this.checkpoints.values()).sort(
+      (a, b) => b.timestamp - a.timestamp
+    );
+    const toDelete = sorted.slice(keepCount);
+    for (const checkpoint of toDelete) {
+      try {
+        const checkpointPath = path.join(
+          this.recoveryDir,
+          `checkpoint-${checkpoint.id}.json`
+        );
+        await fs.unlink(checkpointPath);
+        this.checkpoints.delete(checkpoint.id);
+      } catch (error) {
+        logger.warn(
+          `Failed to delete checkpoint ${checkpoint.id}:`,
+          error
+        );
+      }
+    }
+    logger.info(`Cleaned up ${toDelete.length} old checkpoints`);
+  }
+  async escalateCriticalFailure(report) {
+    logger.error(`CRITICAL FAILURE [${report.id}]: ${report.error.message}`);
+    try {
+      const swarmState = this.swarmCoordinator.swarmState;
+      if (swarmState?.id) {
+        await this.createCheckpoint(swarmState.id, "critical_failure");
+      }
+    } catch {
+      logger.error("Failed to create emergency checkpoint");
+    }
+    await this.swarmCoordinator.forceCleanup();
+  }
+  generateRecoveryActions(frequentErrors) {
+    const actions = [];
+    for (const { type, count } of frequentErrors) {
+      if (count > 3) {
+        switch (type) {
+          case "database_failure":
+            actions.push("Consider upgrading database configuration");
+            break;
+          case "git_conflict":
+            actions.push("Review git workflow and branch strategy");
+            break;
+          case "agent_timeout":
+            actions.push(
+              "Increase agent timeout limits or reduce task complexity"
+            );
+            break;
+          case "memory_overflow":
+            actions.push("Monitor memory usage and consider increasing limits");
+            break;
+        }
+      }
+    }
+    return actions;
+  }
+  startPeriodicCheckpoints() {
+    this.checkpointInterval = setInterval(async () => {
+      const swarmState = this.swarmCoordinator.swarmState;
+      if (swarmState?.id && swarmState.status === "active") {
+        await this.createCheckpoint(swarmState.id, "periodic");
+      }
+    }, 3e5);
+  }
+  async ensureRecoveryDirectory() {
+    try {
+      await fs.mkdir(this.recoveryDir, { recursive: true });
+    } catch (error) {
+      logger.error("Failed to create recovery directory:", error);
+    }
+  }
+  async loadExistingCheckpoints() {
+    try {
+      const files = await fs.readdir(this.recoveryDir);
+      for (const file of files) {
+        if (file.startsWith("checkpoint-") && file.endsWith(".json")) {
+          try {
+            const content = await fs.readFile(
+              path.join(this.recoveryDir, file),
+              "utf8"
+            );
+            const checkpoint = JSON.parse(content);
+            this.checkpoints.set(checkpoint.id, checkpoint);
+          } catch (error) {
+            logger.warn(`Failed to load checkpoint ${file}:`, error);
+          }
+        }
+      }
+      logger.info(`Loaded ${this.checkpoints.size} existing checkpoints`);
+    } catch (error) {
+      logger.warn("Failed to load existing checkpoints:", error);
+    }
+  }
+  async saveCrashReport(report) {
+    try {
+      const reportPath = path.join(this.recoveryDir, `crash-${report.id}.json`);
+      await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
+    } catch (error) {
+      logger.error("Failed to save crash report:", error);
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  generateId() {
+    return `recovery_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+}
+var crash_recovery_default = CrashRecoverySystem;
+export {
+  CrashRecoverySystem,
+  crash_recovery_default as default
+};
+//# sourceMappingURL=crash-recovery.js.map

package/dist/integrations/ralph/recovery/crash-recovery.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/integrations/ralph/recovery/crash-recovery.ts"],
+  "sourcesContent": ["/**\n * Crash Recovery System for Ralph Swarms\n * Handles failures, provides auto-recovery, and maintains swarm resilience\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { logger } from '../../../core/monitoring/logger.js';\nimport { SwarmCoordinator } from '../swarm/swarm-coordinator.js';\nimport { Agent, SwarmState } from '../types.js';\n\nexport interface RecoveryCheckpoint {\n  id: string;\n  swarmId: string;\n  timestamp: number;\n  swarmState: SwarmState;\n  agents: Agent[];\n  tasks: any[];\n  errorLog: CrashReport[];\n  databaseBackup?: string;\n  gitState: {\n    currentBranch: string;\n    uncommittedChanges: string[];\n    activeBranches: string[];\n  };\n}\n\nexport interface CrashReport {\n  id: string;\n  timestamp: number;\n  agentId?: string;\n  errorType:\n    | 'database_failure'\n    | 'git_conflict'\n    | 'agent_timeout'\n    | 'memory_overflow'\n    | 'network_error';\n  error: Error;\n  context: any;\n  recoveryAction: string;\n  severity: 'low' | 'medium' | 'high' | 'critical';\n  resolved: boolean;\n}\n\nexport interface RecoveryStrategy {\n  errorType: string;\n  condition: (error: Error, context: any) => boolean;\n  action: (\n    report: CrashReport,\n    recovery: CrashRecoverySystem\n  ) => Promise<boolean>;\n  maxRetries: number;\n  backoffMs: number;\n}\n\nexport class CrashRecoverySystem {\n  private checkpoints: Map<string, RecoveryCheckpoint> = new Map();\n  private crashReports: CrashReport[] = [];\n  private recoveryStrategies: RecoveryStrategy[] = [];\n  private swarmCoordinator: SwarmCoordinator;\n  private checkpointInterval?: NodeJS.Timeout;\n  private recoveryDir: string;\n\n  constructor(\n    swarmCoordinator: SwarmCoordinator,\n    recoveryDir: string = '.swarm/recovery'\n  ) {\n    this.swarmCoordinator = swarmCoordinator;\n    this.recoveryDir = recoveryDir;\n    this.setupRecoveryStrategies();\n  }\n\n  /**\n   * Initialize crash recovery system\n   */\n  async initialize(): Promise<void> {\n    await this.ensureRecoveryDirectory();\n    await this.loadExistingCheckpoints();\n    this.startPeriodicCheckpoints();\n\n    // Set up global error handlers\n    process.on('unhandledRejection', (reason, promise) => {\n      this.handleCrash(new Error(`Unhandled Rejection: ${reason}`), {\n        type: 'unhandled_rejection',\n        promise: promise.toString(),\n      });\n    });\n\n    process.on('uncaughtException', (error) => {\n      this.handleCrash(error, { type: 'uncaught_exception' });\n    });\n\n    logger.info('Crash recovery system initialized');\n  }\n\n  /**\n   * Create recovery checkpoint\n   */\n  async createCheckpoint(\n    swarmId: string,\n    reason: string = 'periodic'\n  ): Promise<string> {\n    try {\n      const swarmState = (this.swarmCoordinator as any).swarmState;\n      const agents = Array.from(\n        (this.swarmCoordinator as any).activeAgents.values()\n      );\n\n      const checkpoint: RecoveryCheckpoint = {\n        id: this.generateId(),\n        swarmId,\n        timestamp: Date.now(),\n        swarmState: { ...swarmState },\n        agents: agents.map((agent) => ({ ...agent })),\n        tasks: swarmState.tasks || [],\n        errorLog: this.crashReports.slice(-10), // Last 10 errors\n        gitState: await this.captureGitState(),\n      };\n\n      // Save to disk\n      const checkpointPath = path.join(\n        this.recoveryDir,\n        `checkpoint-${checkpoint.id}.json`\n      );\n      await fs.writeFile(checkpointPath, JSON.stringify(checkpoint, null, 2));\n\n      this.checkpoints.set(checkpoint.id, checkpoint);\n\n      logger.info(\n        `Created checkpoint ${checkpoint.id} for swarm ${swarmId} (${reason})`\n      );\n      return checkpoint.id;\n    } catch (error) {\n      logger.error('Failed to create checkpoint:', error as Error);\n      throw error;\n    }\n  }\n\n  /**\n   * Handle crash or error\n   */\n  async handleCrash(error: Error, context: any = {}): Promise<void> {\n    const report: CrashReport = {\n      id: this.generateId(),\n      timestamp: Date.now(),\n      agentId: context.agentId,\n      errorType: this.classifyError(error, context),\n      error,\n      context,\n      recoveryAction: '',\n      severity: this.assessSeverity(error, context),\n      resolved: false,\n    };\n\n    this.crashReports.push(report);\n    logger.error(`Crash detected [${report.id}]:`, error);\n\n    // Attempt automatic recovery\n    const recovered = await this.attemptRecovery(report);\n\n    if (recovered) {\n      report.resolved = true;\n      report.recoveryAction = 'auto_recovered';\n      logger.info(`Successfully recovered from crash ${report.id}`);\n    } else {\n      logger.error(`Failed to recover from crash ${report.id}`);\n\n      if (report.severity === 'critical') {\n        await this.escalateCriticalFailure(report);\n      }\n    }\n\n    // Save crash report\n    await this.saveCrashReport(report);\n  }\n\n  /**\n   * Restore from checkpoint\n   */\n  async restoreFromCheckpoint(checkpointId: string): Promise<boolean> {\n    try {\n      const checkpoint = this.checkpoints.get(checkpointId);\n      if (!checkpoint) {\n        logger.error(`Checkpoint ${checkpointId} not found`);\n        return false;\n      }\n\n      logger.info(`Restoring from checkpoint ${checkpointId}`);\n\n      // Restore git state\n      await this.restoreGitState(checkpoint.gitState);\n\n      // Restore database if backup exists\n      if (checkpoint.databaseBackup) {\n        await this.restoreDatabase(checkpoint.databaseBackup);\n      }\n\n      // Restore swarm state\n      await this.restoreSwarmState(checkpoint);\n\n      logger.info(`Successfully restored from checkpoint ${checkpointId}`);\n      return true;\n    } catch (error) {\n      logger.error(\n        `Failed to restore from checkpoint ${checkpointId}:`,\n        error as Error\n      );\n      return false;\n    }\n  }\n\n  /**\n   * Get recovery recommendations\n   */\n  getRecoveryRecommendations(): {\n    recentCheckpoints: RecoveryCheckpoint[];\n    frequentErrors: Array<{\n      type: string;\n      count: number;\n      lastOccurrence: number;\n    }>;\n    recoveryActions: string[];\n    systemHealth: 'good' | 'degraded' | 'critical';\n  } {\n    const recent = Date.now() - 3600000; // Last hour\n    const recentCheckpoints = Array.from(this.checkpoints.values())\n      .filter((cp) => cp.timestamp > recent)\n      .sort((a, b) => b.timestamp - a.timestamp)\n      .slice(0, 5);\n\n    const errorCounts = new Map<string, number>();\n    const errorTimes = new Map<string, number>();\n\n    for (const report of this.crashReports.filter(\n      (r) => r.timestamp > recent\n    )) {\n      errorCounts.set(\n        report.errorType,\n        (errorCounts.get(report.errorType) || 0) + 1\n      );\n      errorTimes.set(\n        report.errorType,\n        Math.max(errorTimes.get(report.errorType) || 0, report.timestamp)\n      );\n    }\n\n    const frequentErrors = Array.from(errorCounts.entries())\n      .map(([type, count]) => ({\n        type,\n        count,\n        lastOccurrence: errorTimes.get(type) || 0,\n      }))\n      .sort((a, b) => b.count - a.count);\n\n    const criticalErrors = this.crashReports.filter(\n      (r) => r.severity === 'critical' && r.timestamp > recent && !r.resolved\n    );\n\n    const systemHealth =\n      criticalErrors.length > 0\n        ? 'critical'\n        : frequentErrors.length > 3\n          ? 'degraded'\n          : 'good';\n\n    return {\n      recentCheckpoints,\n      frequentErrors,\n      recoveryActions: this.generateRecoveryActions(frequentErrors),\n      systemHealth,\n    };\n  }\n\n  /**\n   * Auto-recovery from common failures\n   */\n  async attemptAutoRecovery(swarmId: string): Promise<boolean> {\n    logger.info(`Attempting auto-recovery for swarm ${swarmId}`);\n\n    try {\n      // 1. Check for recent checkpoint\n      const recentCheckpoint = this.findRecentCheckpoint(swarmId);\n      if (recentCheckpoint) {\n        logger.info(`Found recent checkpoint: ${recentCheckpoint.id}`);\n        return await this.restoreFromCheckpoint(recentCheckpoint.id);\n      }\n\n      // 2. Attempt graceful restart\n      await this.swarmCoordinator.forceCleanup();\n\n      // 3. Clear problematic state\n      await this.clearProblematicState();\n\n      // 4. Restart with minimal configuration\n      logger.info('Restarting swarm with minimal configuration');\n      return true;\n    } catch (error) {\n      logger.error('Auto-recovery failed:', error as Error);\n      return false;\n    }\n  }\n\n  private async attemptRecovery(report: CrashReport): Promise<boolean> {\n    // Find appropriate recovery strategy\n    for (const strategy of this.recoveryStrategies) {\n      if (strategy.condition(report.error, report.context)) {\n        logger.info(`Applying recovery strategy: ${strategy.errorType}`);\n\n        let retries = 0;\n        while (retries < strategy.maxRetries) {\n          try {\n            const success = await strategy.action(report, this);\n            if (success) {\n              report.recoveryAction = strategy.errorType;\n              return true;\n            }\n          } catch (error) {\n            logger.warn(\n              `Recovery attempt ${retries + 1} failed:`,\n              error as Error\n            );\n          }\n\n          retries++;\n          if (retries < strategy.maxRetries) {\n            await this.sleep(strategy.backoffMs * Math.pow(2, retries));\n          }\n        }\n      }\n    }\n\n    return false;\n  }\n\n  private classifyError(error: Error, context: any): CrashReport['errorType'] {\n    const message = error.message.toLowerCase();\n\n    if (message.includes('database') || message.includes('sqlite')) {\n      return 'database_failure';\n    } else if (message.includes('git') || message.includes('branch')) {\n      return 'git_conflict';\n    } else if (message.includes('timeout') || context.timeout) {\n      return 'agent_timeout';\n    } else if (message.includes('memory') || message.includes('heap')) {\n      return 'memory_overflow';\n    } else if (message.includes('network') || message.includes('connect')) {\n      return 'network_error';\n    }\n\n    return 'database_failure'; // Default\n  }\n\n  private assessSeverity(error: Error, context: any): CrashReport['severity'] {\n    if (context.type === 'uncaught_exception') return 'critical';\n    if (error.message.includes('unhandled')) return 'high';\n    if (error.message.includes('database')) return 'medium';\n    return 'low';\n  }\n\n  private setupRecoveryStrategies(): void {\n    this.recoveryStrategies = [\n      {\n        errorType: 'database_failure',\n        condition: (error) =>\n          error.message.includes('database') ||\n          error.message.includes('sqlite'),\n        action: async (report, recovery) => {\n          // Reinitialize database connection\n          logger.info('Attempting database recovery');\n\n          // Create new database adapter\n          try {\n            await recovery.clearProblematicState();\n            return true;\n          } catch {\n            return false;\n          }\n        },\n        maxRetries: 3,\n        backoffMs: 1000,\n      },\n      {\n        errorType: 'git_conflict',\n        condition: (error) =>\n          error.message.includes('git') || error.message.includes('branch'),\n        action: async (report, recovery) => {\n          logger.info('Attempting git conflict resolution');\n\n          try {\n            // Force cleanup git state\n            const { execSync } = await import('child_process');\n            execSync('git checkout main', { stdio: 'ignore' });\n            execSync('git reset --hard HEAD', { stdio: 'ignore' });\n            return true;\n          } catch {\n            return false;\n          }\n        },\n        maxRetries: 2,\n        backoffMs: 500,\n      },\n      {\n        errorType: 'agent_timeout',\n        condition: (error, context) =>\n          error.message.includes('timeout') || context.timeout,\n        action: async (report, recovery) => {\n          logger.info('Attempting agent timeout recovery');\n\n          // Force cleanup stuck agents\n          await recovery.swarmCoordinator.forceCleanup();\n          return true;\n        },\n        maxRetries: 1,\n        backoffMs: 2000,\n      },\n      {\n        errorType: 'memory_overflow',\n        condition: (error) =>\n          error.message.includes('memory') || error.message.includes('heap'),\n        action: async (report, recovery) => {\n          logger.info('Attempting memory recovery');\n\n          // Force garbage collection\n          if (global.gc) global.gc();\n\n          // Cleanup old checkpoints\n          await recovery.cleanupOldCheckpoints(5);\n          return true;\n        },\n        maxRetries: 1,\n        backoffMs: 5000,\n      },\n    ];\n  }\n\n  private async captureGitState(): Promise<RecoveryCheckpoint['gitState']> {\n    try {\n      const { execSync } = await import('child_process');\n\n      const currentBranch = execSync('git branch --show-current', {\n        encoding: 'utf8',\n      }).trim();\n      const statusOutput = execSync('git status --porcelain', {\n        encoding: 'utf8',\n      });\n      const uncommittedChanges = statusOutput\n        .trim()\n        .split('\\n')\n        .filter(Boolean);\n      const branchesOutput = execSync('git branch', { encoding: 'utf8' });\n      const activeBranches = branchesOutput\n        .split('\\n')\n        .map((line) => line.trim().replace(/^\\*?\\s*/, ''))\n        .filter(Boolean);\n\n      return {\n        currentBranch,\n        uncommittedChanges,\n        activeBranches,\n      };\n    } catch (error) {\n      logger.warn('Failed to capture git state:', error as Error);\n      return {\n        currentBranch: 'unknown',\n        uncommittedChanges: [],\n        activeBranches: [],\n      };\n    }\n  }\n\n  private async restoreGitState(\n    gitState: RecoveryCheckpoint['gitState']\n  ): Promise<void> {\n    try {\n      const { execSync } = await import('child_process');\n      execSync(`git checkout ${gitState.currentBranch}`, { stdio: 'ignore' });\n      logger.info(`Restored git branch: ${gitState.currentBranch}`);\n    } catch (error) {\n      logger.warn('Failed to restore git state:', error as Error);\n    }\n  }\n\n  private async restoreDatabase(backupPath: string): Promise<void> {\n    // Implementation would restore database from backup\n    logger.info(`Restoring database from ${backupPath}`);\n  }\n\n  private async restoreSwarmState(\n    checkpoint: RecoveryCheckpoint\n  ): Promise<void> {\n    // Implementation would restore swarm coordinator state\n    logger.info(`Restoring swarm state from checkpoint ${checkpoint.id}`);\n  }\n\n  private findRecentCheckpoint(swarmId: string): RecoveryCheckpoint | null {\n    const recent = Date.now() - 1800000; // 30 minutes\n\n    return (\n      Array.from(this.checkpoints.values())\n        .filter((cp) => cp.swarmId === swarmId && cp.timestamp > recent)\n        .sort((a, b) => b.timestamp - a.timestamp)[0] || null\n    );\n  }\n\n  private async clearProblematicState(): Promise<void> {\n    try {\n      // Clear temporary files\n      await this.cleanupTempFiles();\n\n      // Reset any stuck locks\n      // Implementation specific cleanup\n\n      logger.info('Cleared problematic state');\n    } catch (error) {\n      logger.error('Failed to clear problematic state:', error as Error);\n    }\n  }\n\n  private async cleanupTempFiles(): Promise<void> {\n    // Cleanup implementation\n  }\n\n  private async cleanupOldCheckpoints(keepCount: number): Promise<void> {\n    const sorted = Array.from(this.checkpoints.values()).sort(\n      (a, b) => b.timestamp - a.timestamp\n    );\n\n    const toDelete = sorted.slice(keepCount);\n\n    for (const checkpoint of toDelete) {\n      try {\n        const checkpointPath = path.join(\n          this.recoveryDir,\n          `checkpoint-${checkpoint.id}.json`\n        );\n        await fs.unlink(checkpointPath);\n        this.checkpoints.delete(checkpoint.id);\n      } catch (error) {\n        logger.warn(\n          `Failed to delete checkpoint ${checkpoint.id}:`,\n          error as Error\n        );\n      }\n    }\n\n    logger.info(`Cleaned up ${toDelete.length} old checkpoints`);\n  }\n\n  private async escalateCriticalFailure(report: CrashReport): Promise<void> {\n    logger.error(`CRITICAL FAILURE [${report.id}]: ${report.error.message}`);\n\n    // Create emergency checkpoint\n    try {\n      const swarmState = (this.swarmCoordinator as any).swarmState;\n      if (swarmState?.id) {\n        await this.createCheckpoint(swarmState.id, 'critical_failure');\n      }\n    } catch {\n      logger.error('Failed to create emergency checkpoint');\n    }\n\n    // Graceful shutdown\n    await this.swarmCoordinator.forceCleanup();\n  }\n\n  private generateRecoveryActions(\n    frequentErrors: Array<{ type: string; count: number }>\n  ): string[] {\n    const actions: string[] = [];\n\n    for (const { type, count } of frequentErrors) {\n      if (count > 3) {\n        switch (type) {\n          case 'database_failure':\n            actions.push('Consider upgrading database configuration');\n            break;\n          case 'git_conflict':\n            actions.push('Review git workflow and branch strategy');\n            break;\n          case 'agent_timeout':\n            actions.push(\n              'Increase agent timeout limits or reduce task complexity'\n            );\n            break;\n          case 'memory_overflow':\n            actions.push('Monitor memory usage and consider increasing limits');\n            break;\n        }\n      }\n    }\n\n    return actions;\n  }\n\n  private startPeriodicCheckpoints(): void {\n    this.checkpointInterval = setInterval(async () => {\n      const swarmState = (this.swarmCoordinator as any).swarmState;\n      if (swarmState?.id && swarmState.status === 'active') {\n        await this.createCheckpoint(swarmState.id, 'periodic');\n      }\n    }, 300000); // Every 5 minutes\n  }\n\n  private async ensureRecoveryDirectory(): Promise<void> {\n    try {\n      await fs.mkdir(this.recoveryDir, { recursive: true });\n    } catch (error) {\n      logger.error('Failed to create recovery directory:', error as Error);\n    }\n  }\n\n  private async loadExistingCheckpoints(): Promise<void> {\n    try {\n      const files = await fs.readdir(this.recoveryDir);\n\n      for (const file of files) {\n        if (file.startsWith('checkpoint-') && file.endsWith('.json')) {\n          try {\n            const content = await fs.readFile(\n              path.join(this.recoveryDir, file),\n              'utf8'\n            );\n            const checkpoint: RecoveryCheckpoint = JSON.parse(content);\n            this.checkpoints.set(checkpoint.id, checkpoint);\n          } catch (error) {\n            logger.warn(`Failed to load checkpoint ${file}:`, error as Error);\n          }\n        }\n      }\n\n      logger.info(`Loaded ${this.checkpoints.size} existing checkpoints`);\n    } catch (error) {\n      logger.warn('Failed to load existing checkpoints:', error as Error);\n    }\n  }\n\n  private async saveCrashReport(report: CrashReport): Promise<void> {\n    try {\n      const reportPath = path.join(this.recoveryDir, `crash-${report.id}.json`);\n      await fs.writeFile(reportPath, JSON.stringify(report, null, 2));\n    } catch (error) {\n      logger.error('Failed to save crash report:', error as Error);\n    }\n  }\n\n  private sleep(ms: number): Promise<void> {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n  }\n\n  private generateId(): string {\n    return `recovery_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;\n  }\n}\n\nexport default CrashRecoverySystem;\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/integrations/ralph/swarm/git-workflow-manager.js

@@ -1,12 +1,5 @@
 import { execSync } from "child_process";
 import { logger } from "../../../core/monitoring/logger.js";
-class GitWorkflowError extends Error {
-  constructor(message, context) {
-    super(message);
-    this.context = context;
-    this.name = "GitWorkflowError";
-  }
-}
 class GitWorkflowManager {
   config;
   agentBranches = /* @__PURE__ */ new Map();
@@ -162,12 +155,7 @@ class GitWorkflowManager {
   }
   // Private helper methods
   getCurrentBranch() {
-    try {
-      return execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf8" }).trim();
-    } catch (error) {
-      logger.warn("Failed to get current branch", error);
-      return "main";
-    }
+    return execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf8" }).trim();
   }
   getMainBranch() {
     try {
@@ -175,7 +163,6 @@ class GitWorkflowManager {
       if (branches.includes("origin/main")) return "main";
       if (branches.includes("origin/master")) return "master";
     } catch (error) {
-      logger.debug("Could not detect main branch from remotes", error);
     }
     return this.getCurrentBranch();
   }
@@ -192,46 +179,10 @@ class GitWorkflowManager {
     }
   }
   createBranch(branchName) {
-    try {
-      try {
-        const currentBranch = execSync("git branch --show-current", { encoding: "utf8" }).trim();
-        if (currentBranch === branchName) {
-          try {
-            execSync("git checkout main", { encoding: "utf8" });
-          } catch {
-            execSync("git checkout master", { encoding: "utf8" });
-          }
-        }
-        try {
-          const worktrees = execSync("git worktree list --porcelain", { encoding: "utf8" });
-          const lines = worktrees.split("\n");
-          for (let i = 0; i < lines.length; i++) {
-            if (lines[i].startsWith("branch ") && lines[i].includes(branchName)) {
-              const worktreetPath = lines[i - 1].replace("worktree ", "");
-              execSync(`git worktree remove --force "${worktreetPath}"`, { encoding: "utf8" });
-              logger.info(`Removed worktree at ${worktreetPath} for branch ${branchName}`);
-            }
-          }
-        } catch (worktreeError) {
-          logger.warn("Failed to check/remove worktrees", worktreeError);
-        }
-        execSync(`git branch -D ${branchName}`, { encoding: "utf8" });
-        logger.info(`Deleted existing branch ${branchName} for fresh start`);
-      } catch {
-      }
-      execSync(`git checkout -b ${branchName}`, { encoding: "utf8" });
-    } catch (error) {
-      logger.error(`Failed to create branch ${branchName}`, error);
-      throw new GitWorkflowError(`Failed to create branch: ${branchName}`, { branchName });
-    }
+    execSync(`git checkout -b ${branchName}`, { encoding: "utf8" });
   }
   checkoutBranch(branchName) {
-    try {
-      execSync(`git checkout ${branchName}`, { encoding: "utf8" });
-    } catch (error) {
-      logger.error(`Failed to checkout branch ${branchName}`, error);
-      throw new GitWorkflowError(`Failed to checkout branch: ${branchName}`, { branchName });
-    }
+    execSync(`git checkout ${branchName}`, { encoding: "utf8" });
   }
   branchExists(branchName) {
     try {
@@ -268,13 +219,8 @@ class GitWorkflowManager {
     }
   }
   hasUncommittedChanges() {
-    try {
-      const status = execSync("git status --porcelain", { encoding: "utf8" });
-      return status.trim().length > 0;
-    } catch (error) {
-      logger.warn("Failed to check git status", error);
-      return false;
-    }
+    const status = execSync("git status --porcelain", { encoding: "utf8" });
+    return status.trim().length > 0;
   }
   hasRemote() {
     try {
@@ -295,16 +241,10 @@ class GitWorkflowManager {
     }
   }
   isAgentFile(file, agent) {
-    if (!file || !agent?.role || !agent?.id) {
-      return false;
-    }
     return file.includes(agent.role) || file.includes(agent.id);
   }
   generateCommitMessage(agent, task) {
-    const role = agent?.role || "agent";
-    const title = task?.title || "task";
-    const iteration = agent?.performance?.tasksCompleted || 1;
-    return `[${role}] ${title} - Iteration ${iteration}`;
+    return `[${agent.role}] ${task.title} - Iteration ${agent.performance?.tasksCompleted || 1}`;
   }
   scheduleAutoCommit(agent, task) {
     const intervalMs = this.config.commitFrequency * 60 * 1e3;
@@ -363,7 +303,6 @@ Generated by Swarm Coordinator
 }
 const gitWorkflowManager = new GitWorkflowManager();
 export {
-  GitWorkflowError,
   GitWorkflowManager,
   gitWorkflowManager
 };