@stackmemoryai/stackmemory 0.3.24 → 0.3.25

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

@@ -0,0 +1,309 @@
+import { execSync } from "child_process";
+import { logger } from "../../../core/monitoring/logger.js";
+class GitWorkflowManager {
+  config;
+  agentBranches = /* @__PURE__ */ new Map();
+  baselineBranch;
+  mainBranch;
+  constructor(config) {
+    this.config = {
+      enableGitWorkflow: true,
+      branchStrategy: "agent",
+      autoCommit: true,
+      commitFrequency: 5,
+      mergStrategy: "squash",
+      requirePR: false,
+      ...config
+    };
+    try {
+      this.baselineBranch = this.getCurrentBranch();
+      this.mainBranch = this.getMainBranch();
+    } catch (error) {
+      logger.warn("Git not initialized, workflow features disabled");
+      this.config.enableGitWorkflow = false;
+    }
+  }
+  /**
+   * Initialize git workflow for an agent
+   */
+  async initializeAgentWorkflow(agent, task) {
+    if (!this.config.enableGitWorkflow) return;
+    const branchName = this.generateBranchName(agent, task);
+    try {
+      this.createBranch(branchName);
+      this.agentBranches.set(agent.id, branchName);
+      logger.info(`Created git branch for agent ${agent.role}: ${branchName}`);
+      if (this.config.autoCommit) {
+        this.scheduleAutoCommit(agent, task);
+      }
+    } catch (error) {
+      logger.error(`Failed to initialize git workflow for agent ${agent.role}`, error);
+    }
+  }
+  /**
+   * Commit agent work
+   */
+  async commitAgentWork(agent, task, message) {
+    if (!this.config.enableGitWorkflow) return;
+    const branchName = this.agentBranches.get(agent.id);
+    if (!branchName) {
+      logger.warn(`No branch found for agent ${agent.id}`);
+      return;
+    }
+    try {
+      this.checkoutBranch(branchName);
+      const hasChanges = this.hasUncommittedChanges();
+      if (!hasChanges) {
+        logger.debug(`No changes to commit for agent ${agent.role}`);
+        return;
+      }
+      execSync("git add -A", { encoding: "utf8" });
+      const commitMessage = message || this.generateCommitMessage(agent, task);
+      execSync(`git commit -m "${commitMessage}"`, { encoding: "utf8" });
+      logger.info(`Agent ${agent.role} committed: ${commitMessage}`);
+      if (this.hasRemote()) {
+        try {
+          execSync(`git push origin ${branchName}`, { encoding: "utf8" });
+          logger.info(`Pushed branch ${branchName} to remote`);
+        } catch (error) {
+          logger.warn(`Could not push to remote: ${error}`);
+        }
+      }
+    } catch (error) {
+      logger.error(`Failed to commit agent work`, error);
+    }
+  }
+  /**
+   * Merge agent work back to baseline
+   */
+  async mergeAgentWork(agent, task) {
+    if (!this.config.enableGitWorkflow) return;
+    const branchName = this.agentBranches.get(agent.id);
+    if (!branchName) {
+      logger.warn(`No branch found for agent ${agent.id}`);
+      return;
+    }
+    try {
+      this.checkoutBranch(this.baselineBranch);
+      if (this.config.requirePR) {
+        await this.createPullRequest(agent, task, branchName);
+      } else {
+        this.mergeBranch(branchName);
+        logger.info(`Merged agent ${agent.role} work from ${branchName}`);
+      }
+      this.deleteBranch(branchName);
+      this.agentBranches.delete(agent.id);
+    } catch (error) {
+      logger.error(`Failed to merge agent work`, error);
+    }
+  }
+  /**
+   * Coordinate merges between multiple agents
+   */
+  async coordinateMerges(agents) {
+    if (!this.config.enableGitWorkflow) return;
+    logger.info("Coordinating merges from all agents");
+    const integrationBranch = `swarm-integration-${Date.now()}`;
+    this.createBranch(integrationBranch);
+    for (const agent of agents) {
+      const branchName = this.agentBranches.get(agent.id);
+      if (branchName && this.branchExists(branchName)) {
+        try {
+          this.mergeBranch(branchName);
+          logger.info(`Integrated ${agent.role} work`);
+        } catch (error) {
+          logger.error(`Failed to integrate ${agent.role} work: ${error}`);
+        }
+      }
+    }
+    const testsPass = await this.runIntegrationTests();
+    if (testsPass) {
+      this.checkoutBranch(this.baselineBranch);
+      this.mergeBranch(integrationBranch);
+      logger.info("Successfully integrated all agent work");
+    } else {
+      logger.warn("Integration tests failed, keeping changes in branch: " + integrationBranch);
+    }
+  }
+  /**
+   * Handle merge conflicts
+   */
+  async resolveConflicts(agent) {
+    const conflicts = this.getConflictedFiles();
+    if (conflicts.length === 0) return;
+    logger.warn(`Agent ${agent.role} encountering merge conflicts: ${conflicts.join(", ")}`);
+    for (const file of conflicts) {
+      try {
+        if (this.isAgentFile(file, agent)) {
+          execSync(`git checkout --ours ${file}`, { encoding: "utf8" });
+          execSync(`git add ${file}`, { encoding: "utf8" });
+        } else {
+          execSync(`git checkout --theirs ${file}`, { encoding: "utf8" });
+          execSync(`git add ${file}`, { encoding: "utf8" });
+        }
+      } catch (error) {
+        logger.error(`Could not auto-resolve conflict in ${file}`);
+      }
+    }
+    const remainingConflicts = this.getConflictedFiles();
+    if (remainingConflicts.length === 0) {
+      execSync("git commit --no-edit", { encoding: "utf8" });
+      logger.info("All conflicts resolved automatically");
+    } else {
+      logger.error(`Manual intervention needed for: ${remainingConflicts.join(", ")}`);
+    }
+  }
+  // Private helper methods
+  getCurrentBranch() {
+    return execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf8" }).trim();
+  }
+  getMainBranch() {
+    try {
+      const branches = execSync("git branch -r", { encoding: "utf8" });
+      if (branches.includes("origin/main")) return "main";
+      if (branches.includes("origin/master")) return "master";
+    } catch (error) {
+    }
+    return this.getCurrentBranch();
+  }
+  generateBranchName(agent, task) {
+    const sanitizedTitle = task.title.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").substring(0, 30);
+    switch (this.config.branchStrategy) {
+      case "feature":
+        return `feature/${sanitizedTitle}`;
+      case "task":
+        return `task/${task.id}`;
+      case "agent":
+      default:
+        return `swarm/${agent.role}-${sanitizedTitle}`;
+    }
+  }
+  createBranch(branchName) {
+    execSync(`git checkout -b ${branchName}`, { encoding: "utf8" });
+  }
+  checkoutBranch(branchName) {
+    execSync(`git checkout ${branchName}`, { encoding: "utf8" });
+  }
+  branchExists(branchName) {
+    try {
+      execSync(`git rev-parse --verify ${branchName}`, {
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  deleteBranch(branchName) {
+    try {
+      execSync(`git branch -d ${branchName}`, { encoding: "utf8" });
+    } catch (error) {
+      execSync(`git branch -D ${branchName}`, { encoding: "utf8" });
+    }
+  }
+  mergeBranch(branchName) {
+    const strategy = this.config.mergStrategy;
+    switch (strategy) {
+      case "squash":
+        execSync(`git merge --squash ${branchName}`, { encoding: "utf8" });
+        execSync('git commit -m "Squashed agent changes"', { encoding: "utf8" });
+        break;
+      case "rebase":
+        execSync(`git rebase ${branchName}`, { encoding: "utf8" });
+        break;
+      case "merge":
+      default:
+        execSync(`git merge ${branchName}`, { encoding: "utf8" });
+        break;
+    }
+  }
+  hasUncommittedChanges() {
+    const status = execSync("git status --porcelain", { encoding: "utf8" });
+    return status.trim().length > 0;
+  }
+  hasRemote() {
+    try {
+      execSync("git remote get-url origin", { encoding: "utf8" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getConflictedFiles() {
+    try {
+      const conflicts = execSync("git diff --name-only --diff-filter=U", {
+        encoding: "utf8"
+      });
+      return conflicts.trim().split("\n").filter((f) => f.length > 0);
+    } catch {
+      return [];
+    }
+  }
+  isAgentFile(file, agent) {
+    return file.includes(agent.role) || file.includes(agent.id);
+  }
+  generateCommitMessage(agent, task) {
+    return `[${agent.role}] ${task.title} - Iteration ${agent.performance?.tasksCompleted || 1}`;
+  }
+  scheduleAutoCommit(agent, task) {
+    const intervalMs = this.config.commitFrequency * 60 * 1e3;
+    setInterval(async () => {
+      await this.commitAgentWork(agent, task, `[${agent.role}] Auto-commit: ${task.title}`);
+    }, intervalMs);
+  }
+  async createPullRequest(agent, task, branchName) {
+    try {
+      const title = `[Swarm ${agent.role}] ${task.title}`;
+      const body = `
+## Agent: ${agent.role}
+## Task: ${task.title}
+
+### Acceptance Criteria:
+${task.acceptanceCriteria.map((c) => `- ${c}`).join("\n")}
+
+### Status:
+- Tasks Completed: ${agent.performance?.tasksCompleted || 0}
+- Success Rate: ${agent.performance?.successRate || 0}%
+
+Generated by Swarm Coordinator
+      `;
+      execSync(`gh pr create --title "${title}" --body "${body}" --base ${this.baselineBranch}`, {
+        encoding: "utf8"
+      });
+      logger.info(`Created PR for agent ${agent.role}`);
+    } catch (error) {
+      logger.warn(`Could not create PR: ${error}`);
+    }
+  }
+  async runIntegrationTests() {
+    try {
+      execSync("npm test", { encoding: "utf8" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get status of all agent branches
+   */
+  getGitStatus() {
+    const status = {
+      enabled: this.config.enableGitWorkflow,
+      currentBranch: this.getCurrentBranch(),
+      agentBranches: Array.from(this.agentBranches.entries()).map(([agentId, branch]) => ({
+        agentId,
+        branch,
+        exists: this.branchExists(branch)
+      })),
+      hasUncommittedChanges: this.hasUncommittedChanges()
+    };
+    return status;
+  }
+}
+const gitWorkflowManager = new GitWorkflowManager();
+export {
+  GitWorkflowManager,
+  gitWorkflowManager
+};
+//# sourceMappingURL=git-workflow-manager.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/integrations/ralph/swarm/git-workflow-manager.ts"],
+  "sourcesContent": ["/**\n * Git Workflow Manager for Swarm Agents\n * Manages git operations, branching, and commits for each agent\n */\n\nimport { execSync } from 'child_process';\nimport { logger } from '../../../core/monitoring/logger.js';\nimport { Agent, SwarmTask } from '../types.js';\n\nexport interface GitConfig {\n  enableGitWorkflow: boolean;\n  branchStrategy: 'feature' | 'agent' | 'task';\n  autoCommit: boolean;\n  commitFrequency: number; // minutes\n  mergStrategy: 'squash' | 'merge' | 'rebase';\n  requirePR: boolean;\n}\n\nexport class GitWorkflowManager {\n  private config: GitConfig;\n  private agentBranches: Map<string, string> = new Map();\n  private baselineBranch: string;\n  private mainBranch: string;\n\n  constructor(config?: Partial<GitConfig>) {\n    this.config = {\n      enableGitWorkflow: true,\n      branchStrategy: 'agent',\n      autoCommit: true,\n      commitFrequency: 5,\n      mergStrategy: 'squash',\n      requirePR: false,\n      ...config\n    };\n\n    // Get current branch as baseline\n    try {\n      this.baselineBranch = this.getCurrentBranch();\n      this.mainBranch = this.getMainBranch();\n    } catch (error) {\n      logger.warn('Git not initialized, workflow features disabled');\n      this.config.enableGitWorkflow = false;\n    }\n  }\n\n  /**\n   * Initialize git workflow for an agent\n   */\n  async initializeAgentWorkflow(agent: Agent, task: SwarmTask): Promise<void> {\n    if (!this.config.enableGitWorkflow) return;\n\n    const branchName = this.generateBranchName(agent, task);\n    \n    try {\n      // Create and checkout new branch\n      this.createBranch(branchName);\n      this.agentBranches.set(agent.id, branchName);\n      \n      logger.info(`Created git branch for agent ${agent.role}: ${branchName}`);\n\n      // Set up commit timer if auto-commit enabled\n      if (this.config.autoCommit) {\n        this.scheduleAutoCommit(agent, task);\n      }\n    } catch (error: unknown) {\n      logger.error(`Failed to initialize git workflow for agent ${agent.role}`, error as Error);\n    }\n  }\n\n  /**\n   * Commit agent work\n   */\n  async commitAgentWork(\n    agent: Agent, \n    task: SwarmTask,\n    message?: string\n  ): Promise<void> {\n    if (!this.config.enableGitWorkflow) return;\n\n    const branchName = this.agentBranches.get(agent.id);\n    if (!branchName) {\n      logger.warn(`No branch found for agent ${agent.id}`);\n      return;\n    }\n\n    try {\n      // Ensure we're on the agent's branch\n      this.checkoutBranch(branchName);\n\n      // Check for changes\n      const hasChanges = this.hasUncommittedChanges();\n      if (!hasChanges) {\n        logger.debug(`No changes to commit for agent ${agent.role}`);\n        return;\n      }\n\n      // Stage all changes\n      execSync('git add -A', { encoding: 'utf8' });\n\n      // Generate commit message\n      const commitMessage = message || this.generateCommitMessage(agent, task);\n      \n      // Commit changes\n      execSync(`git commit -m \"${commitMessage}\"`, { encoding: 'utf8' });\n      \n      logger.info(`Agent ${agent.role} committed: ${commitMessage}`);\n\n      // Push if remote exists\n      if (this.hasRemote()) {\n        try {\n          execSync(`git push origin ${branchName}`, { encoding: 'utf8' });\n          logger.info(`Pushed branch ${branchName} to remote`);\n        } catch (error) {\n          logger.warn(`Could not push to remote: ${error}`);\n        }\n      }\n    } catch (error: unknown) {\n      logger.error(`Failed to commit agent work`, error as Error);\n    }\n  }\n\n  /**\n   * Merge agent work back to baseline\n   */\n  async mergeAgentWork(agent: Agent, task: SwarmTask): Promise<void> {\n    if (!this.config.enableGitWorkflow) return;\n\n    const branchName = this.agentBranches.get(agent.id);\n    if (!branchName) {\n      logger.warn(`No branch found for agent ${agent.id}`);\n      return;\n    }\n\n    try {\n      // Switch to baseline branch\n      this.checkoutBranch(this.baselineBranch);\n\n      if (this.config.requirePR) {\n        // Create pull request\n        await this.createPullRequest(agent, task, branchName);\n      } else {\n        // Direct merge based on strategy\n        this.mergeBranch(branchName);\n        logger.info(`Merged agent ${agent.role} work from ${branchName}`);\n      }\n\n      // Clean up branch\n      this.deleteBranch(branchName);\n      this.agentBranches.delete(agent.id);\n\n    } catch (error: unknown) {\n      logger.error(`Failed to merge agent work`, error as Error);\n    }\n  }\n\n  /**\n   * Coordinate merges between multiple agents\n   */\n  async coordinateMerges(agents: Agent[]): Promise<void> {\n    if (!this.config.enableGitWorkflow) return;\n\n    logger.info('Coordinating merges from all agents');\n\n    // Create integration branch\n    const integrationBranch = `swarm-integration-${Date.now()}`;\n    this.createBranch(integrationBranch);\n\n    // Merge each agent's work\n    for (const agent of agents) {\n      const branchName = this.agentBranches.get(agent.id);\n      if (branchName && this.branchExists(branchName)) {\n        try {\n          this.mergeBranch(branchName);\n          logger.info(`Integrated ${agent.role} work`);\n        } catch (error) {\n          logger.error(`Failed to integrate ${agent.role} work: ${error}`);\n        }\n      }\n    }\n\n    // Run tests on integration branch\n    const testsPass = await this.runIntegrationTests();\n    \n    if (testsPass) {\n      // Merge to baseline\n      this.checkoutBranch(this.baselineBranch);\n      this.mergeBranch(integrationBranch);\n      logger.info('Successfully integrated all agent work');\n    } else {\n      logger.warn('Integration tests failed, keeping changes in branch: ' + integrationBranch);\n    }\n  }\n\n  /**\n   * Handle merge conflicts\n   */\n  async resolveConflicts(agent: Agent): Promise<void> {\n    const conflicts = this.getConflictedFiles();\n    \n    if (conflicts.length === 0) return;\n\n    logger.warn(`Agent ${agent.role} encountering merge conflicts: ${conflicts.join(', ')}`);\n\n    // Strategy 1: Try to auto-resolve\n    for (const file of conflicts) {\n      try {\n        // Accept current changes for agent's own files\n        if (this.isAgentFile(file, agent)) {\n          execSync(`git checkout --ours ${file}`, { encoding: 'utf8' });\n          execSync(`git add ${file}`, { encoding: 'utf8' });\n        } else {\n          // Accept incoming changes for other files\n          execSync(`git checkout --theirs ${file}`, { encoding: 'utf8' });\n          execSync(`git add ${file}`, { encoding: 'utf8' });\n        }\n      } catch (error) {\n        logger.error(`Could not auto-resolve conflict in ${file}`);\n      }\n    }\n\n    // Complete merge if all conflicts resolved\n    const remainingConflicts = this.getConflictedFiles();\n    if (remainingConflicts.length === 0) {\n      execSync('git commit --no-edit', { encoding: 'utf8' });\n      logger.info('All conflicts resolved automatically');\n    } else {\n      logger.error(`Manual intervention needed for: ${remainingConflicts.join(', ')}`);\n    }\n  }\n\n  // Private helper methods\n  private getCurrentBranch(): string {\n    return execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8' }).trim();\n  }\n\n  private getMainBranch(): string {\n    try {\n      // Try to detect main branch\n      const branches = execSync('git branch -r', { encoding: 'utf8' });\n      if (branches.includes('origin/main')) return 'main';\n      if (branches.includes('origin/master')) return 'master';\n    } catch (error) {\n      // Fallback to current branch\n    }\n    return this.getCurrentBranch();\n  }\n\n  private generateBranchName(agent: Agent, task: SwarmTask): string {\n    const sanitizedTitle = task.title.toLowerCase()\n      .replace(/\\s+/g, '-')\n      .replace(/[^a-z0-9-]/g, '')\n      .substring(0, 30);\n\n    switch (this.config.branchStrategy) {\n      case 'feature':\n        return `feature/${sanitizedTitle}`;\n      case 'task':\n        return `task/${task.id}`;\n      case 'agent':\n      default:\n        return `swarm/${agent.role}-${sanitizedTitle}`;\n    }\n  }\n\n  private createBranch(branchName: string): void {\n    execSync(`git checkout -b ${branchName}`, { encoding: 'utf8' });\n  }\n\n  private checkoutBranch(branchName: string): void {\n    execSync(`git checkout ${branchName}`, { encoding: 'utf8' });\n  }\n\n  private branchExists(branchName: string): boolean {\n    try {\n      execSync(`git rev-parse --verify ${branchName}`, { \n        encoding: 'utf8',\n        stdio: 'pipe'\n      });\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  private deleteBranch(branchName: string): void {\n    try {\n      execSync(`git branch -d ${branchName}`, { encoding: 'utf8' });\n    } catch (error) {\n      // Force delete if needed\n      execSync(`git branch -D ${branchName}`, { encoding: 'utf8' });\n    }\n  }\n\n  private mergeBranch(branchName: string): void {\n    const strategy = this.config.mergStrategy;\n    \n    switch (strategy) {\n      case 'squash':\n        execSync(`git merge --squash ${branchName}`, { encoding: 'utf8' });\n        execSync('git commit -m \"Squashed agent changes\"', { encoding: 'utf8' });\n        break;\n      case 'rebase':\n        execSync(`git rebase ${branchName}`, { encoding: 'utf8' });\n        break;\n      case 'merge':\n      default:\n        execSync(`git merge ${branchName}`, { encoding: 'utf8' });\n        break;\n    }\n  }\n\n  private hasUncommittedChanges(): boolean {\n    const status = execSync('git status --porcelain', { encoding: 'utf8' });\n    return status.trim().length > 0;\n  }\n\n  private hasRemote(): boolean {\n    try {\n      execSync('git remote get-url origin', { encoding: 'utf8' });\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  private getConflictedFiles(): string[] {\n    try {\n      const conflicts = execSync('git diff --name-only --diff-filter=U', { \n        encoding: 'utf8' \n      });\n      return conflicts.trim().split('\\n').filter(f => f.length > 0);\n    } catch {\n      return [];\n    }\n  }\n\n  private isAgentFile(file: string, agent: Agent): boolean {\n    // Simple heuristic: check if file is in agent's working directory\n    return file.includes(agent.role) || file.includes(agent.id);\n  }\n\n  private generateCommitMessage(agent: Agent, task: SwarmTask): string {\n    return `[${agent.role}] ${task.title} - Iteration ${agent.performance?.tasksCompleted || 1}`;\n  }\n\n  private scheduleAutoCommit(agent: Agent, task: SwarmTask): void {\n    const intervalMs = this.config.commitFrequency * 60 * 1000;\n    \n    setInterval(async () => {\n      await this.commitAgentWork(agent, task, `[${agent.role}] Auto-commit: ${task.title}`);\n    }, intervalMs);\n  }\n\n  private async createPullRequest(agent: Agent, task: SwarmTask, branchName: string): Promise<void> {\n    try {\n      const title = `[Swarm ${agent.role}] ${task.title}`;\n      const body = `\n## Agent: ${agent.role}\n## Task: ${task.title}\n\n### Acceptance Criteria:\n${task.acceptanceCriteria.map(c => `- ${c}`).join('\\n')}\n\n### Status:\n- Tasks Completed: ${agent.performance?.tasksCompleted || 0}\n- Success Rate: ${agent.performance?.successRate || 0}%\n\nGenerated by Swarm Coordinator\n      `;\n\n      execSync(`gh pr create --title \"${title}\" --body \"${body}\" --base ${this.baselineBranch}`, {\n        encoding: 'utf8'\n      });\n      \n      logger.info(`Created PR for agent ${agent.role}`);\n    } catch (error) {\n      logger.warn(`Could not create PR: ${error}`);\n    }\n  }\n\n  private async runIntegrationTests(): Promise<boolean> {\n    try {\n      // Try to run tests\n      execSync('npm test', { encoding: 'utf8' });\n      return true;\n    } catch {\n      // Tests failed or not available\n      return false;\n    }\n  }\n\n  /**\n   * Get status of all agent branches\n   */\n  getGitStatus(): object {\n    const status: any = {\n      enabled: this.config.enableGitWorkflow,\n      currentBranch: this.getCurrentBranch(),\n      agentBranches: Array.from(this.agentBranches.entries()).map(([agentId, branch]) => ({\n        agentId,\n        branch,\n        exists: this.branchExists(branch)\n      })),\n      hasUncommittedChanges: this.hasUncommittedChanges()\n    };\n\n    return status;\n  }\n}\n\nexport const gitWorkflowManager = new GitWorkflowManager();"],
+  "mappings": "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",
+  "names": []
+}

package/dist/integrations/ralph/swarm/swarm-coordinator.js

@@ -1,9 +1,12 @@
 import { v4 as uuidv4 } from "uuid";
+import * as fs from "fs/promises";
+import * as path from "path";
 import { logger } from "../../../core/monitoring/logger.js";
 import { FrameManager } from "../../../core/context/frame-manager.js";
 import { sessionManager } from "../../../core/session/index.js";
 import { sharedContextLayer } from "../../../core/context/shared-context-layer.js";
 import { RalphStackMemoryBridge } from "../bridge/ralph-stackmemory-bridge.js";
+import { GitWorkflowManager } from "./git-workflow-manager.js";
 class SwarmCoordinator {
   frameManager;
   activeAgents = /* @__PURE__ */ new Map();
@@ -11,6 +14,7 @@ class SwarmCoordinator {
   config;
   coordinationTimer;
   plannerWakeupQueue = /* @__PURE__ */ new Map();
+  gitWorkflowManager;
   constructor(config) {
     this.config = {
       maxAgents: 10,
@@ -42,6 +46,13 @@ class SwarmCoordinator {
         coordination_overhead: 0
       }
     };
+    this.gitWorkflowManager = new GitWorkflowManager({
+      enableGitWorkflow: true,
+      branchStrategy: "agent",
+      autoCommit: true,
+      commitFrequency: 5,
+      mergStrategy: "squash"
+    });
     logger.info("Swarm coordinator initialized", this.config);
   }
   async initialize() {
@@ -256,6 +267,7 @@ class SwarmCoordinator {
     logger.info(`Agent ${agent.role} starting task: ${task.title}`);
     try {
       agent.status = "active";
+      await this.gitWorkflowManager.initializeAgentWorkflow(agent, task);
       const ralph = new RalphStackMemoryBridge({
         baseDir: path.join(agent.workingDirectory, task.id),
         maxIterations: this.calculateMaxIterations(task),
@@ -268,7 +280,9 @@ class SwarmCoordinator {
       });
       this.setupAgentCoordination(agent, ralph, assignment);
       await ralph.run();
+      await this.gitWorkflowManager.commitAgentWork(agent, task);
       this.updateAgentPerformance(agent, true);
+      await this.gitWorkflowManager.mergeAgentWork(agent, task);
       await this.notifyTaskCompletion(agent, task, true);
       agent.status = "idle";
       logger.info(`Agent ${agent.role} completed task: ${task.title}`);
@@ -477,6 +491,161 @@ You are a PROJECT COORDINATOR. Your role is to:
     }];
   }
   // Implement remaining helper methods...
+  async setupAgentEnvironment(agent) {
+    try {
+      await fs.mkdir(agent.workingDirectory, { recursive: true });
+      logger.debug(`Created working directory for agent ${agent.id}: ${agent.workingDirectory}`);
+    } catch (error) {
+      logger.warn(`Could not create working directory for agent ${agent.id}`, error);
+    }
+  }
+  async configureAgentPrompts(agent) {
+    logger.debug(`Configured prompts for agent ${agent.role}`);
+  }
+  topologicalSort(tasks) {
+    const sorted = [];
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const visit = (task) => {
+      if (visited.has(task.id)) return;
+      if (visiting.has(task.id)) {
+        logger.warn(`Circular dependency detected for task: ${task.id}`);
+        return;
+      }
+      visiting.add(task.id);
+      for (const depId of task.dependencies) {
+        const depTask = tasks.find((t) => t.id === depId);
+        if (depTask) visit(depTask);
+      }
+      visiting.delete(task.id);
+      visited.add(task.id);
+      sorted.push(task);
+    };
+    tasks.forEach(visit);
+    return sorted;
+  }
+  agentCanHandle(agent, role) {
+    return agent.role === role || agent.capabilities.includes(role);
+  }
+  selectOptimalAgent(agents, task) {
+    return agents.reduce((best, current) => {
+      const bestLoad = best.currentTask ? 1 : 0;
+      const currentLoad = current.currentTask ? 1 : 0;
+      return currentLoad < bestLoad ? current : best;
+    });
+  }
+  estimateTaskDuration(task) {
+    const durations = {
+      low: 6e4,
+      // 1 minute
+      medium: 3e5,
+      // 5 minutes
+      high: 9e5
+      // 15 minutes
+    };
+    return durations[task.estimatedEffort] || 3e5;
+  }
+  findCollaborators(agent, task, agents) {
+    return agents.filter((a) => a.id !== agent.id && a.currentTask).map((a) => a.id).slice(0, 2);
+  }
+  findReviewers(agent, task, agents) {
+    return agents.filter((a) => a.role === "reviewer" && a.id !== agent.id).map((a) => a.id);
+  }
+  calculateMaxIterations(task) {
+    const iterations = {
+      low: 5,
+      medium: 10,
+      high: 20
+    };
+    return iterations[task.estimatedEffort] || 10;
+  }
+  async getSwarmContext(task) {
+    const relatedTasks = Array.from(this.activeAgents.values()).filter((a) => a.currentTask).map((a) => `- Agent ${a.role} is working on task ${a.currentTask}`).join("\n");
+    return relatedTasks || "No other agents currently active";
+  }
+  getCoordinationInstructions(agent) {
+    return `
+- Save progress to shared context regularly
+- Check for updates from collaborators
+- Request help if blocked for more than 2 iterations
+- Report completion immediately`;
+  }
+  setupAgentCoordination(agent, ralph, assignment) {
+    logger.debug(`Setting up coordination for agent ${agent.id}`);
+  }
+  updateAgentPerformance(agent, success) {
+    agent.performance.tasksCompleted++;
+    if (!success) {
+      agent.performance.successRate = agent.performance.successRate * (agent.performance.tasksCompleted - 1) / agent.performance.tasksCompleted;
+    }
+  }
+  async notifyTaskCompletion(agent, task, success) {
+    const event = {
+      type: "task_completion",
+      agentId: agent.id,
+      timestamp: Date.now(),
+      data: {
+        taskId: task.id,
+        success,
+        agent: agent.role
+      }
+    };
+    this.swarmState.coordination?.events.push(event);
+    logger.info(`Task ${task.id} completed by agent ${agent.role}: ${success ? "SUCCESS" : "FAILED"}`);
+  }
+  async handleTaskFailure(agent, task, error) {
+    logger.error(`Agent ${agent.role} failed task ${task.id}`, error);
+    if (this.swarmState.coordination) {
+      this.swarmState.coordination.conflicts.push({
+        type: "task_failure",
+        agents: [agent.id],
+        timestamp: Date.now(),
+        description: error.message
+      });
+    }
+  }
+  async detectTunnelVision(agent) {
+    return false;
+  }
+  async provideAlternativeApproach(agent) {
+    logger.info(`Providing alternative approach to agent ${agent.role}`);
+  }
+  async detectExcessiveRuntime(agent) {
+    if (!agent.performance.lastFreshStart) return false;
+    return Date.now() - agent.performance.lastFreshStart > 36e5;
+  }
+  async requestCheckpoint(agent) {
+    logger.info(`Requesting checkpoint from agent ${agent.role}`);
+  }
+  async triggerFreshStart(agent) {
+    logger.info(`Triggering fresh start for agent ${agent.role}`);
+    agent.performance.lastFreshStart = Date.now();
+    agent.performance.driftDetected = false;
+  }
+  async resolveActiveConflicts() {
+    if (this.swarmState.coordination?.conflicts.length) {
+      logger.debug(`Resolving ${this.swarmState.coordination.conflicts.length} conflicts`);
+    }
+  }
+  async rebalanceWorkload() {
+    const activeAgents = Array.from(this.activeAgents.values()).filter((a) => a.status === "active");
+    if (activeAgents.length > 0) {
+      logger.debug(`Rebalancing workload among ${activeAgents.length} active agents`);
+    }
+  }
+  async triggerFreshStartsIfNeeded() {
+    for (const agent of this.activeAgents.values()) {
+      if (agent.performance.driftDetected) {
+        await this.triggerFreshStart(agent);
+      }
+    }
+  }
+  updateSwarmMetrics() {
+    if (!this.swarmState.performance) return;
+    const activeCount = Array.from(this.activeAgents.values()).filter((a) => a.status === "active").length;
+    this.swarmState.performance.throughput = this.swarmState.completedTaskCount / ((Date.now() - this.swarmState.startTime) / 1e3);
+    this.swarmState.performance.efficiency = activeCount > 0 ? this.swarmState.completedTaskCount / activeCount : 0;
+  }
   [Symbol.toStringTag] = "SwarmCoordinator";
 }
 const swarmCoordinator = new SwarmCoordinator();