@stackmemoryai/stackmemory 0.5.57 → 0.5.59

package/dist/src/cli/commands/ralph.js

@@ -0,0 +1,909 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Command } from "commander";
+import { logger } from "../../core/monitoring/logger.js";
+import { RalphLoop } from "../../../scripts/ralph-loop-implementation.js";
+import { stackMemoryContextLoader } from "../../integrations/ralph/context/stackmemory-context-loader.js";
+import { patternLearner } from "../../integrations/ralph/learning/pattern-learner.js";
+import { multiLoopOrchestrator } from "../../integrations/ralph/orchestration/multi-loop-orchestrator.js";
+import { swarmCoordinator } from "../../integrations/ralph/swarm/swarm-coordinator.js";
+import { ralphDebugger } from "../../integrations/ralph/visualization/ralph-debugger.js";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { trace } from "../../core/trace/index.js";
+import { SystemError, ErrorCode } from "../../core/errors/index.js";
+function createRalphCommand() {
+  const ralph = new Command("ralph").description(
+    "Ralph Wiggum Loop integration with StackMemory"
+  );
+  ralph.command("init").description("Initialize a new Ralph Wiggum loop").argument("<task>", "Task description").option(
+    "-c, --criteria <criteria>",
+    "Completion criteria (comma separated)"
+  ).option("--max-iterations <n>", "Maximum iterations", "50").option("--use-context", "Load relevant context from StackMemory").option(
+    "--learn-from-similar",
+    "Apply patterns from similar completed tasks"
+  ).action(async (task, options) => {
+    return trace.command("ralph-init", { task, ...options }, async () => {
+      try {
+        console.log("\u{1F3AD} Initializing Ralph Wiggum loop...");
+        const loop = new RalphLoop({
+          baseDir: ".ralph",
+          maxIterations: parseInt(options.maxIterations),
+          verbose: true
+        });
+        const criteria = options.criteria ? options.criteria.split(",").map((c) => `- ${c.trim()}`).join("\n") : "- All tests pass\n- Code works correctly\n- No lint errors";
+        let enhancedTask = task;
+        if (options.useContext || options.learnFromSimilar) {
+          try {
+            await stackMemoryContextLoader.initialize();
+            const contextResponse = await stackMemoryContextLoader.loadInitialContext({
+              task,
+              usePatterns: true,
+              useSimilarTasks: options.learnFromSimilar,
+              maxTokens: 3e3
+            });
+            if (contextResponse.context) {
+              enhancedTask = `${task}
+
+${contextResponse.context}`;
+              console.log(
+                `\u{1F4DA} Loaded context from ${contextResponse.sources.length} sources`
+              );
+              console.log(
+                `\u{1F3AF} Context tokens: ${contextResponse.metadata.totalTokens}`
+              );
+            }
+          } catch (error) {
+            console.log(
+              `\u26A0\uFE0F  Context loading failed: ${error.message}`
+            );
+            console.log("Proceeding without context...");
+          }
+        }
+        await loop.initialize(enhancedTask, criteria);
+        console.log("\u2705 Ralph loop initialized!");
+        console.log(`\u{1F4CB} Task: ${task}`);
+        console.log(`\u{1F3AF} Max iterations: ${options.maxIterations}`);
+        console.log(`\u{1F4C1} Loop directory: .ralph/`);
+        console.log("\nNext steps:");
+        console.log("  stackmemory ralph run     # Start the loop");
+        console.log("  stackmemory ralph status  # Check status");
+      } catch (error) {
+        logger.error("Failed to initialize Ralph loop", error);
+        console.error("\u274C Initialization failed:", error.message);
+        process.exit(1);
+      }
+    });
+  });
+  ralph.command("run").description("Run the Ralph Wiggum loop").option("--verbose", "Verbose output").option("--pause-on-error", "Pause on validation errors").action(async (options) => {
+    return trace.command("ralph-run", options, async () => {
+      try {
+        if (!existsSync(".ralph")) {
+          console.error(
+            '\u274C No Ralph loop found. Run "stackmemory ralph init" first.'
+          );
+          return;
+        }
+        console.log("\u{1F3AD} Starting Ralph Wiggum loop...");
+        const loop = new RalphLoop({
+          baseDir: ".ralph",
+          verbose: options.verbose
+        });
+        await loop.run();
+      } catch (error) {
+        logger.error("Failed to run Ralph loop", error);
+        console.error("\u274C Loop execution failed:", error.message);
+        process.exit(1);
+      }
+    });
+  });
+  ralph.command("status").description("Show current Ralph loop status").option("--detailed", "Show detailed iteration history").action(async (options) => {
+    return trace.command("ralph-status", options, async () => {
+      try {
+        if (!existsSync(".ralph")) {
+          console.log("\u274C No Ralph loop found in current directory");
+          return;
+        }
+        const task = readFileSync(".ralph/task.md", "utf8");
+        const iteration = parseInt(
+          readFileSync(".ralph/iteration.txt", "utf8") || "0"
+        );
+        const isComplete = existsSync(".ralph/work-complete.txt");
+        const feedback = existsSync(".ralph/feedback.txt") ? readFileSync(".ralph/feedback.txt", "utf8") : "";
+        console.log("\u{1F3AD} Ralph Loop Status:");
+        console.log(`   Task: ${task.substring(0, 80)}...`);
+        console.log(`   Iteration: ${iteration}`);
+        console.log(
+          `   Status: ${isComplete ? "\u2705 COMPLETE" : "\u{1F504} IN PROGRESS"}`
+        );
+        if (feedback) {
+          console.log(`   Last feedback: ${feedback.substring(0, 100)}...`);
+        }
+        if (options.detailed && existsSync(".ralph/progress.jsonl")) {
+          console.log("\n\u{1F4CA} Iteration History:");
+          const progressLines = readFileSync(".ralph/progress.jsonl", "utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line));
+          progressLines.forEach((p) => {
+            const progress = p;
+            const status = progress.validation?.testsPass ? "\u2705" : "\u274C";
+            console.log(
+              `     ${progress.iteration}: ${status} ${progress.changes} changes, ${progress.errors} errors`
+            );
+          });
+        }
+      } catch (error) {
+        logger.error("Failed to get Ralph status", error);
+        console.error("\u274C Status check failed:", error.message);
+      }
+    });
+  });
+  ralph.command("resume").description("Resume a crashed or paused Ralph loop").option("--from-stackmemory", "Restore from StackMemory backup").action(async (options) => {
+    return trace.command("ralph-resume", options, async () => {
+      try {
+        console.log("\u{1F504} Resuming Ralph loop...");
+        const loop = new RalphLoop({ baseDir: ".ralph", verbose: true });
+        if (options.fromStackmemory) {
+          console.log("\u{1F4DA} StackMemory restore feature coming soon...");
+        }
+        await loop.run();
+      } catch (error) {
+        logger.error("Failed to resume Ralph loop", error);
+        console.error("\u274C Resume failed:", error.message);
+        process.exit(1);
+      }
+    });
+  });
+  ralph.command("stop").description("Stop the current Ralph loop").option("--save-progress", "Save current progress to StackMemory").action(async (options) => {
+    return trace.command("ralph-stop", options, async () => {
+      try {
+        if (!existsSync(".ralph")) {
+          console.log("\u274C No active Ralph loop found");
+          return;
+        }
+        console.log("\u{1F6D1} Stopping Ralph loop...");
+        if (options.saveProgress) {
+          console.log("\u{1F4BE} StackMemory progress save feature coming soon...");
+        }
+        writeFileSync(".ralph/stop-signal.txt", (/* @__PURE__ */ new Date()).toISOString());
+        console.log("\u2705 Stop signal sent");
+      } catch (error) {
+        logger.error("Failed to stop Ralph loop", error);
+        console.error("\u274C Stop failed:", error.message);
+      }
+    });
+  });
+  ralph.command("clean").description("Clean up Ralph loop artifacts").option("--keep-history", "Keep iteration history").action(async (options) => {
+    return trace.command("ralph-clean", options, async () => {
+      try {
+        if (!options.keepHistory && existsSync(".ralph/history")) {
+          const { execSync } = await import("child_process");
+          execSync("rm -rf .ralph/history");
+        }
+        if (existsSync(".ralph/work-complete.txt")) {
+          const fs = await import("fs");
+          fs.unlinkSync(".ralph/work-complete.txt");
+        }
+        console.log("\u{1F9F9} Ralph loop artifacts cleaned");
+      } catch (error) {
+        logger.error("Failed to clean Ralph artifacts", error);
+        console.error("\u274C Cleanup failed:", error.message);
+      }
+    });
+  });
+  ralph.command("debug").description("Debug Ralph loop state and diagnostics").option("--reconcile", "Force state reconciliation").option("--validate-context", "Validate context budget").action(async (options) => {
+    return trace.command("ralph-debug", options, async () => {
+      try {
+        console.log("\u{1F50D} Ralph Loop Debug Information:");
+        if (options.reconcile) {
+          console.log("\u{1F527} State reconciliation feature coming soon...");
+        }
+        if (options.validateContext) {
+          console.log("\u{1F4CA} Context validation feature coming soon...");
+        }
+        if (existsSync(".ralph")) {
+          console.log("\n\u{1F4C1} Ralph directory structure:");
+          const { execSync } = await import("child_process");
+          try {
+            const tree = execSync("find .ralph -type f | head -20", {
+              encoding: "utf8"
+            });
+            console.log(tree);
+          } catch {
+            console.log("   (Unable to show directory tree)");
+          }
+        }
+      } catch (error) {
+        logger.error("Ralph debug failed", error);
+        console.error("\u274C Debug failed:", error.message);
+      }
+    });
+  });
+  ralph.command("swarm").description("Launch a swarm of specialized agents").argument("<project>", "Project description").option(
+    "--agents <agents>",
+    "Comma-separated list of agent roles (architect,developer,tester,etc)",
+    "developer,tester"
+  ).option("--max-agents <n>", "Maximum number of agents", "5").action(async (project, options) => {
+    return trace.command("ralph-swarm", { project, ...options }, async () => {
+      try {
+        console.log("\u{1F9BE} Launching Ralph swarm...");
+        await swarmCoordinator.initialize();
+        const agentRoles = options.agents.split(",").map((r) => r.trim());
+        const agentSpecs = agentRoles.map((role) => ({
+          role,
+          conflictResolution: "defer_to_expertise",
+          collaborationPreferences: []
+        }));
+        const swarmId = await swarmCoordinator.launchSwarm(
+          project,
+          agentSpecs
+        );
+        console.log(`\u2705 Swarm launched with ID: ${swarmId}`);
+        console.log(`\u{1F465} ${agentSpecs.length} agents working on: ${project}`);
+        console.log("\nNext steps:");
+        console.log(
+          "  stackmemory ralph swarm-status <swarmId>  # Check progress"
+        );
+        console.log(
+          "  stackmemory ralph swarm-stop <swarmId>    # Stop swarm"
+        );
+      } catch (error) {
+        logger.error("Swarm launch failed", error);
+        console.error("\u274C Swarm launch failed:", error.message);
+      }
+    });
+  });
+  ralph.command("swarm-status").description("Check status of all active swarms or a specific swarm").argument("[swarmId]", "Optional specific swarm ID to check").option("--detailed", "Show detailed agent information").action(async (swarmId, options) => {
+    return trace.command(
+      "ralph-swarm-status",
+      { swarmId, ...options },
+      async () => {
+        try {
+          await swarmCoordinator.initialize();
+          if (swarmId) {
+            const status = swarmCoordinator.getSwarmStatus(swarmId);
+            if (!status) {
+              console.log(`\u274C Swarm ${swarmId} not found`);
+              return;
+            }
+            console.log(`\u{1F9BE} Swarm Status: ${swarmId}`);
+            console.log(`   Status: ${status.state}`);
+            console.log(`   Agents: ${status.activeAgents} active`);
+            console.log(
+              `   Started: ${new Date(status.startTime).toLocaleString()}`
+            );
+            if (options.detailed && status.agents) {
+              console.log("\n\u{1F465} Agent Details:");
+              status.agents.forEach((agent) => {
+                console.log(
+                  `   - ${agent.role}: ${agent.status} (${agent.task})`
+                );
+              });
+            }
+          } else {
+            const activeSwarms = swarmCoordinator.getAllActiveSwarms();
+            if (activeSwarms.length === 0) {
+              console.log("\u{1F4CA} No active swarms");
+              return;
+            }
+            console.log(`\u{1F4CA} Active Swarms: ${activeSwarms.length}`);
+            activeSwarms.forEach((swarm) => {
+              console.log(`
+\u{1F194} ${swarm.id}`);
+              console.log(
+                `   Description: ${swarm.description?.substring(0, 60)}...`
+              );
+              console.log(`   Agents: ${swarm.agentCount}`);
+              console.log(`   Status: ${swarm.status}`);
+              console.log(
+                `   Running for: ${Math.round((Date.now() - swarm.startTime) / 1e3)}s`
+              );
+            });
+            console.log("\nCommands:");
+            console.log(
+              "  stackmemory ralph swarm-status <id>  # Check specific swarm"
+            );
+            console.log(
+              "  stackmemory ralph swarm-killall      # Stop all swarms"
+            );
+          }
+        } catch (error) {
+          logger.error("Failed to get swarm status", error);
+          console.error("\u274C Status check failed:", error.message);
+        }
+      }
+    );
+  });
+  ralph.command("oracle-worker").description(
+    "Launch Oracle/Worker pattern swarm for cost-effective execution"
+  ).argument("<project>", "Project description for Oracle planning").option(
+    "--oracle <model>",
+    "Oracle model (default: claude-3-opus)",
+    "claude-3-opus-20240229"
+  ).option(
+    "--workers <models>",
+    "Comma-separated worker models",
+    "claude-3-haiku-20240307"
+  ).option("--budget <amount>", "Cost budget in USD", "10.0").option("--max-workers <count>", "Maximum worker agents", "5").option("--hints <hints>", "Comma-separated planning hints").action(async (project, options) => {
+    return trace.command(
+      "ralph-oracle-worker",
+      { project, ...options },
+      async () => {
+        try {
+          console.log("\u{1F9E0} Launching Oracle/Worker swarm...");
+          console.log(`\u{1F4CB} Project: ${project}`);
+          console.log(`\u{1F4B0} Budget: $${options.budget}`);
+          const { OracleWorkerCoordinator, defaultModelConfigs } = await import("../../../integrations/ralph/patterns/oracle-worker-pattern.js");
+          const workerModels = options.workers.split(",").map((model) => {
+            const found = defaultModelConfigs.worker.find(
+              (w) => w.model.includes(model.trim())
+            );
+            return found || defaultModelConfigs.worker[0];
+          });
+          const coordinator = new OracleWorkerCoordinator({
+            oracle: defaultModelConfigs.oracle[0],
+            workers: workerModels,
+            reviewers: defaultModelConfigs.reviewer,
+            maxWorkers: parseInt(options.maxWorkers),
+            coordinationInterval: 3e4,
+            costBudget: parseFloat(options.budget)
+          });
+          await coordinator.initialize();
+          const hints = options.hints ? options.hints.split(",").map((h) => h.trim()) : void 0;
+          const swarmId = await coordinator.launchOracleWorkerSwarm(
+            project,
+            hints
+          );
+          console.log(`\u2705 Oracle/Worker swarm launched: ${swarmId}`);
+          console.log("\n\u{1F4CA} Pattern Benefits:");
+          console.log("  \u2022 Oracle handles strategic planning & review");
+          console.log("  \u2022 Workers execute parallelizable tasks");
+          console.log("  \u2022 Cost-optimized model selection");
+          console.log("  \u2022 Scalable multi-agent coordination");
+          console.log("\nNext steps:");
+          console.log(
+            `  stackmemory ralph swarm-status ${swarmId}  # Check progress`
+          );
+          console.log(
+            `  stackmemory ralph swarm-stop ${swarmId}    # Stop swarm`
+          );
+        } catch (error) {
+          logger.error("Oracle/Worker swarm failed", error);
+          console.error(`\u274C Oracle/Worker failed: ${error.message}`);
+          throw error;
+        }
+      }
+    );
+  });
+  ralph.command("claude-swarm").description("Launch swarm using Claude Code specialized agents").argument("<project>", "Project description for Claude Code agents").option(
+    "--oracle <agent>",
+    "Oracle agent (default: staff-architect)",
+    "staff-architect"
+  ).option(
+    "--workers <agents>",
+    "Comma-separated worker agents",
+    "general-purpose,code-reviewer"
+  ).option(
+    "--reviewers <agents>",
+    "Comma-separated reviewer agents",
+    "code-reviewer"
+  ).option("--budget <amount>", "Cost budget in USD", "10.0").option(
+    "--complexity <level>",
+    "Project complexity (low|medium|high|very_high)",
+    "medium"
+  ).option("--list-agents", "List available Claude Code agents").action(async (project, options) => {
+    return trace.command(
+      "ralph-claude-swarm",
+      { project, ...options },
+      async () => {
+        try {
+          const { ClaudeCodeAgentBridge, CLAUDE_CODE_AGENTS } = await import("../../integrations/claude-code/agent-bridge.js");
+          if (options.listAgents) {
+            console.log("\n\u{1F916} Available Claude Code Agents:\n");
+            const oracles = Object.values(CLAUDE_CODE_AGENTS).filter(
+              (a) => a.type === "oracle"
+            );
+            const workers = Object.values(CLAUDE_CODE_AGENTS).filter(
+              (a) => a.type === "worker"
+            );
+            const reviewers = Object.values(CLAUDE_CODE_AGENTS).filter(
+              (a) => a.type === "reviewer"
+            );
+            console.log("\u{1F9E0} ORACLE AGENTS (Strategic Planning):");
+            oracles.forEach((agent) => {
+              console.log(`  ${agent.name}: ${agent.description}`);
+              console.log(
+                `    Capabilities: ${agent.capabilities.slice(0, 3).join(", ")}...`
+              );
+            });
+            console.log("\n\u26A1 WORKER AGENTS (Task Execution):");
+            workers.forEach((agent) => {
+              console.log(`  ${agent.name}: ${agent.description}`);
+              console.log(
+                `    Capabilities: ${agent.capabilities.slice(0, 3).join(", ")}...`
+              );
+            });
+            console.log("\n\u{1F50D} REVIEWER AGENTS (Quality Assurance):");
+            reviewers.forEach((agent) => {
+              console.log(`  ${agent.name}: ${agent.description}`);
+              console.log(
+                `    Capabilities: ${agent.capabilities.slice(0, 3).join(", ")}...`
+              );
+            });
+            console.log("\nUsage Examples:");
+            console.log(
+              '  stackmemory ralph claude-swarm "Build REST API" --oracle staff-architect --workers general-purpose,debugger'
+            );
+            console.log(
+              '  stackmemory ralph claude-swarm "Add user auth" --complexity high --workers general-purpose,qa-workflow-validator'
+            );
+            return;
+          }
+          console.log("\u{1F9E0} Launching Claude Code Agent Swarm...");
+          console.log(`\u{1F4CB} Project: ${project}`);
+          console.log(`\u{1F3AF} Oracle: ${options.oracle}`);
+          console.log(`\u26A1 Workers: ${options.workers}`);
+          console.log(`\u{1F50D} Reviewers: ${options.reviewers}`);
+          console.log(`\u{1F4B0} Budget: $${options.budget}`);
+          console.log(`\u{1F4CA} Complexity: ${options.complexity}`);
+          const bridge = new ClaudeCodeAgentBridge();
+          await bridge.initialize();
+          const workerAgents = options.workers.split(",").map((s) => s.trim());
+          const reviewerAgents = options.reviewers.split(",").map((s) => s.trim());
+          const swarmId = await bridge.launchClaudeCodeSwarm(project, {
+            oracleAgent: options.oracle,
+            workerAgents,
+            reviewerAgents,
+            budget: parseFloat(options.budget),
+            complexity: options.complexity
+          });
+          console.log(`\u2705 Claude Code swarm launched: ${swarmId}`);
+          console.log("\n\u{1F4CA} Claude Code Benefits:");
+          console.log("  \u2022 Specialized agents with proven capabilities");
+          console.log("  \u2022 Seamless integration with Claude Code tools");
+          console.log("  \u2022 Optimal agent selection for each task type");
+          console.log("  \u2022 Built-in quality assurance and review processes");
+          console.log("\nActive Agents:");
+          console.log(`  \u{1F9E0} Oracle: ${options.oracle} (strategic planning)`);
+          workerAgents.forEach((agent) => {
+            const agentConfig = CLAUDE_CODE_AGENTS[agent];
+            console.log(
+              `  \u26A1 Worker: ${agent} (${agentConfig?.specializations.join(", ") || "execution"})`
+            );
+          });
+          reviewerAgents.forEach((agent) => {
+            const agentConfig = CLAUDE_CODE_AGENTS[agent];
+            console.log(
+              `  \u{1F50D} Reviewer: ${agent} (${agentConfig?.specializations.join(", ") || "review"})`
+            );
+          });
+          console.log("\nNext steps:");
+          console.log(
+            `  stackmemory ralph swarm-status ${swarmId}     # Check progress`
+          );
+          console.log(
+            `  stackmemory ralph swarm-stop ${swarmId}       # Stop swarm`
+          );
+          console.log(
+            "  stackmemory ralph claude-swarm --list-agents  # See all available agents"
+          );
+        } catch (error) {
+          logger.error("Claude Code swarm failed", error);
+          console.error(`\u274C Claude Code swarm failed: ${error.message}`);
+          throw error;
+        }
+      }
+    );
+  });
+  ralph.command("swarm-killall").description("Stop all active swarms and cleanup resources").option("--force", "Force kill without saving state").action(async (options) => {
+    return trace.command("ralph-swarm-killall", options, async () => {
+      try {
+        await swarmCoordinator.initialize();
+        const activeSwarms = swarmCoordinator.getAllActiveSwarms();
+        if (activeSwarms.length === 0) {
+          console.log("\u{1F4CA} No active swarms to stop");
+          return;
+        }
+        console.log(`\u{1F6D1} Stopping ${activeSwarms.length} active swarm(s)...`);
+        let stoppedCount = 0;
+        let failedCount = 0;
+        for (const swarm of activeSwarms) {
+          try {
+            console.log(`   Stopping ${swarm.id}...`);
+            if (options.force) {
+              await swarmCoordinator.forceStopSwarm(swarm.id);
+            } else {
+              await swarmCoordinator.stopSwarm(swarm.id);
+            }
+            stoppedCount++;
+            console.log(`   \u2705 Stopped ${swarm.id}`);
+          } catch (error) {
+            failedCount++;
+            console.error(
+              `   \u274C Failed to stop ${swarm.id}: ${error.message}`
+            );
+          }
+        }
+        try {
+          const { execSync } = await import("child_process");
+          const branches = execSync('git branch | grep "swarm/"', {
+            encoding: "utf8"
+          }).split("\n").filter(Boolean).map((b) => b.trim());
+          if (branches.length > 0) {
+            console.log(
+              `
+\u{1F500} Cleaning up ${branches.length} swarm branches...`
+            );
+            for (const branch of branches) {
+              try {
+                execSync(`git branch -D ${branch}`, { stdio: "ignore" });
+                console.log(`   Deleted ${branch}`);
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+        console.log(`
+\u{1F4CA} Summary:`);
+        console.log(`   \u2705 Stopped: ${stoppedCount} swarms`);
+        if (failedCount > 0) {
+          console.log(`   \u274C Failed: ${failedCount} swarms`);
+        }
+        await swarmCoordinator.cleanup();
+        console.log("\u{1F9F9} Cleanup completed");
+      } catch (error) {
+        logger.error("Swarm killall failed", error);
+        console.error("\u274C Killall failed:", error.message);
+      }
+    });
+  });
+  ralph.command("orchestrate").description("Orchestrate multiple Ralph loops for complex tasks").argument("<description>", "Complex task description").option("--criteria <criteria>", "Success criteria (comma separated)").option("--max-loops <n>", "Maximum parallel loops", "3").option("--sequential", "Force sequential execution").action(async (description, options) => {
+    return trace.command(
+      "ralph-orchestrate",
+      { description, ...options },
+      async () => {
+        try {
+          console.log("\u{1F3AD} Orchestrating complex task...");
+          await multiLoopOrchestrator.initialize();
+          const criteria = options.criteria ? options.criteria.split(",").map((c) => c.trim()) : [
+            "Task completed successfully",
+            "All components working",
+            "Tests pass"
+          ];
+          const result = await multiLoopOrchestrator.orchestrateComplexTask(
+            description,
+            criteria,
+            {
+              maxLoops: parseInt(options.maxLoops),
+              forceSequential: options.sequential
+            }
+          );
+          console.log("\u2705 Orchestration completed!");
+          console.log(
+            `\u{1F4CA} Results: ${result.completedLoops.length} successful, ${result.failedLoops.length} failed`
+          );
+          console.log(
+            `\u23F1\uFE0F  Total duration: ${Math.round(result.totalDuration / 1e3)}s`
+          );
+          if (result.insights.length > 0) {
+            console.log("\n\u{1F4A1} Insights:");
+            result.insights.forEach(
+              (insight) => console.log(`   \u2022 ${insight}`)
+            );
+          }
+        } catch (error) {
+          logger.error("Orchestration failed", error);
+          console.error("\u274C Orchestration failed:", error.message);
+        }
+      }
+    );
+  });
+  ralph.command("learn").description("Learn patterns from completed loops").option("--task-type <type>", "Learn patterns for specific task type").action(async (options) => {
+    return trace.command("ralph-learn", options, async () => {
+      try {
+        console.log("\u{1F9E0} Learning patterns from completed loops...");
+        await patternLearner.initialize();
+        const patterns = options.taskType ? await patternLearner.learnForTaskType(options.taskType) : await patternLearner.learnFromCompletedLoops();
+        console.log(`\u2705 Learned ${patterns.length} patterns`);
+        if (patterns.length > 0) {
+          console.log("\n\u{1F4CA} Top patterns:");
+          patterns.slice(0, 5).forEach((pattern) => {
+            console.log(
+              `   \u2022 ${pattern.pattern} (${Math.round(pattern.confidence * 100)}% confidence)`
+            );
+          });
+        }
+      } catch (error) {
+        logger.error("Pattern learning failed", error);
+        console.error(
+          "\u274C Pattern learning failed:",
+          error.message
+        );
+      }
+    });
+  });
+  ralph.command("debug-enhanced").description("Advanced debugging with visualization").option("--loop-id <id>", "Specific loop to debug").option("--generate-report", "Generate comprehensive debug report").option("--timeline", "Generate timeline visualization").action(async (options) => {
+    return trace.command("ralph-debug-enhanced", options, async () => {
+      try {
+        if (!existsSync(".ralph") && !options.loopId) {
+          console.log(
+            "\u274C No Ralph loop found. Run a loop first or specify --loop-id"
+          );
+          return;
+        }
+        console.log("\u{1F50D} Starting enhanced debugging...");
+        await ralphDebugger.initialize();
+        const loopId = options.loopId || "current";
+        await ralphDebugger.startDebugSession(loopId, ".ralph");
+        if (options.generateReport) {
+          const report = await ralphDebugger.generateDebugReport(loopId);
+          console.log(`\u{1F4CB} Debug report generated: ${report.exportPath}`);
+        }
+        if (options.timeline) {
+          const timelinePath = await ralphDebugger.generateLoopTimeline(loopId);
+          console.log(`\u{1F4CA} Timeline visualization: ${timelinePath}`);
+        }
+        console.log("\u{1F50D} Debug analysis complete");
+      } catch (error) {
+        logger.error("Enhanced debugging failed", error);
+        console.error("\u274C Debug failed:", error.message);
+      }
+    });
+  });
+  ralph.command("swarm-test").description("Comprehensive testing and validation for swarm functionality").option("--quick", "Run quick validation tests only").option("--stress", "Run stress tests with multiple parallel swarms").option("--error-injection", "Test error handling with deliberate failures").option("--cleanup-test", "Test cleanup mechanisms").option("--git-test", "Test git workflow integration").option("--report", "Generate detailed test report").action(async (options) => {
+    return trace.command("ralph-swarm-test", options, async () => {
+      try {
+        console.log("\u{1F9EA} Starting swarm testing and validation...");
+        await swarmCoordinator.initialize();
+        const testResults = [];
+        let passedTests = 0;
+        let totalTests = 0;
+        if (options.quick || !options.stress) {
+          console.log("\n\u26A1 Running quick validation tests...");
+          totalTests++;
+          try {
+            await swarmCoordinator.launchSwarm(
+              "Test: Basic functionality validation",
+              [{ role: "developer" }]
+            );
+            await swarmCoordinator.forceCleanup();
+            console.log("  \u2705 Basic swarm initialization");
+            passedTests++;
+            testResults.push({
+              test: "basic_init",
+              status: "passed",
+              duration: 0
+            });
+          } catch (error) {
+            console.log(
+              "  \u274C Basic swarm initialization failed:",
+              error.message
+            );
+            testResults.push({
+              test: "basic_init",
+              status: "failed",
+              error: error.message
+            });
+          }
+          totalTests++;
+          try {
+            const usage = swarmCoordinator.getResourceUsage();
+            console.log(
+              `  \u2705 Resource monitoring: ${usage.activeAgents} agents, ${usage.memoryEstimate}MB`
+            );
+            passedTests++;
+            testResults.push({
+              test: "resource_monitoring",
+              status: "passed",
+              data: usage
+            });
+          } catch (error) {
+            console.log(
+              "  \u274C Resource monitoring failed:",
+              error.message
+            );
+            testResults.push({
+              test: "resource_monitoring",
+              status: "failed",
+              error: error.message
+            });
+          }
+        }
+        if (options.stress) {
+          console.log("\n\u{1F525} Running stress tests...");
+          totalTests++;
+          try {
+            const stressPromises = [];
+            for (let i = 0; i < 3; i++) {
+              stressPromises.push(
+                swarmCoordinator.launchSwarm(`Stress test swarm ${i}`, [
+                  { role: "developer" },
+                  { role: "tester" }
+                ])
+              );
+            }
+            await Promise.all(stressPromises);
+            await swarmCoordinator.forceCleanup();
+            console.log("  \u2705 Parallel swarm stress test");
+            passedTests++;
+            testResults.push({ test: "stress_parallel", status: "passed" });
+          } catch (error) {
+            console.log("  \u274C Stress test failed:", error.message);
+            testResults.push({
+              test: "stress_parallel",
+              status: "failed",
+              error: error.message
+            });
+          }
+        }
+        if (options.errorInjection) {
+          console.log("\n\u{1F4A5} Testing error handling...");
+          totalTests++;
+          try {
+            try {
+              await swarmCoordinator.launchSwarm(
+                "Error test: Invalid agents",
+                []
+                // Empty agents array
+              );
+            } catch {
+              console.log("  \u2705 Properly handled empty agents array");
+              passedTests++;
+              testResults.push({ test: "error_handling", status: "passed" });
+            }
+          } catch (error) {
+            console.log(
+              "  \u274C Error handling test failed:",
+              error.message
+            );
+            testResults.push({
+              test: "error_handling",
+              status: "failed",
+              error: error.message
+            });
+          }
+        }
+        if (options.cleanupTest) {
+          console.log("\n\u{1F9F9} Testing cleanup mechanisms...");
+          totalTests++;
+          try {
+            await swarmCoordinator.launchSwarm("Cleanup test swarm", [
+              { role: "developer" }
+            ]);
+            await swarmCoordinator.forceCleanup();
+            const usage = swarmCoordinator.getResourceUsage();
+            if (usage.activeAgents === 0) {
+              console.log("  \u2705 Cleanup mechanism works correctly");
+              passedTests++;
+              testResults.push({ test: "cleanup", status: "passed" });
+            } else {
+              throw new SystemError(
+                `Cleanup failed: ${usage.activeAgents} agents still active`,
+                ErrorCode.RESOURCE_EXHAUSTED,
+                { activeAgents: usage.activeAgents, test: "cleanup" }
+              );
+            }
+          } catch (error) {
+            console.log(
+              "  \u274C Cleanup test failed:",
+              error.message
+            );
+            testResults.push({
+              test: "cleanup",
+              status: "failed",
+              error: error.message
+            });
+          }
+        }
+        if (options.gitTest) {
+          console.log("\n\u{1F500} Testing git workflow integration...");
+          totalTests++;
+          try {
+            const gitStatus = swarmCoordinator["gitWorkflowManager"].getGitStatus();
+            console.log(
+              `  \u2705 Git workflow status: ${gitStatus.enabled ? "enabled" : "disabled"}`
+            );
+            passedTests++;
+            testResults.push({
+              test: "git_workflow",
+              status: "passed",
+              data: gitStatus
+            });
+          } catch (error) {
+            console.log(
+              "  \u274C Git workflow test failed:",
+              error.message
+            );
+            testResults.push({
+              test: "git_workflow",
+              status: "failed",
+              error: error.message
+            });
+          }
+        }
+        console.log("\n\u{1F4CA} Test Results Summary:");
+        console.log(`   Total tests: ${totalTests}`);
+        console.log(`   Passed: ${passedTests} \u2705`);
+        console.log(`   Failed: ${totalTests - passedTests} \u274C`);
+        console.log(
+          `   Success rate: ${Math.round(passedTests / totalTests * 100)}%`
+        );
+        if (options.report) {
+          const reportPath = ".swarm/test-report.json";
+          const fs = await import("fs");
+          const reportData = {
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            summary: {
+              totalTests,
+              passedTests,
+              failedTests: totalTests - passedTests,
+              successRate: passedTests / totalTests * 100
+            },
+            testResults,
+            systemInfo: {
+              nodeVersion: process.version,
+              platform: process.platform,
+              arch: process.arch
+            }
+          };
+          fs.writeFileSync(reportPath, JSON.stringify(reportData, null, 2));
+          console.log(`\u{1F4CB} Detailed report saved to: ${reportPath}`);
+        }
+        if (passedTests === totalTests) {
+          console.log(
+            "\n\u{1F389} All tests passed! Swarm functionality is working correctly."
+          );
+        } else {
+          console.log(
+            "\n\u26A0\uFE0F  Some tests failed. Check the errors above for details."
+          );
+          process.exit(1);
+        }
+      } catch (error) {
+        logger.error("Swarm testing failed", error);
+        console.error("\u274C Test suite failed:", error.message);
+        process.exit(1);
+      }
+    });
+  });
+  ralph.command("tui").description("Launch TUI monitor for active swarms").option("--swarm-id <id>", "Monitor specific swarm ID").option("--simple", "Use simple text mode instead of full TUI").option("--force-tui", "Force full TUI even with compatibility issues").action(async (options) => {
+    try {
+      const isGhostty = process.env.TERM_PROGRAM === "ghostty" || process.env.TERM?.includes("ghostty");
+      const isBasicTerm = process.env.TERM === "dumb" || process.env.TERM === "unknown";
+      const hasCompatibilityIssues = isGhostty || isBasicTerm;
+      const useSimpleMode = options.simple || hasCompatibilityIssues && !options.forceTui;
+      if (useSimpleMode) {
+        console.log("\u{1F9BE} Starting Simple Swarm Monitor (Text Mode)");
+        if (hasCompatibilityIssues && !options.simple) {
+          console.log(
+            `\u26A0\uFE0F  Detected ${isGhostty ? "Ghostty" : "basic"} terminal - using text mode for compatibility`
+          );
+          console.log(
+            "   Use --force-tui to override, or --simple to explicitly use text mode"
+          );
+        }
+        const { SimpleSwarmMonitor } = await import("../../features/tui/simple-monitor.js");
+        const monitor = new SimpleSwarmMonitor();
+        monitor.start();
+      } else {
+        console.log("\u{1F9BE} Starting Full TUI Monitor");
+        const { SwarmTUI } = await import("../../features/tui/swarm-monitor.js");
+        const tui = new SwarmTUI();
+        await tui.initialize(void 0, options.swarmId);
+        tui.start();
+      }
+    } catch (error) {
+      logger.error("TUI launch failed", error);
+      console.error("\u274C TUI failed:", error.message);
+      console.log("\u{1F4A1} Try: stackmemory ralph tui --simple");
+      process.exit(1);
+    }
+  });
+  return ralph;
+}
+var ralph_default = createRalphCommand;
+export {
+  createRalphCommand,
+  ralph_default as default
+};
+//# sourceMappingURL=ralph.js.map