@stackmemoryai/stackmemory 0.4.2 → 0.5.1

package/dist/plugins/ralph/use-cases/test-generator.js

@@ -0,0 +1,201 @@
+import { SimpleRalphPlugin } from "../simple-ralph-plugin.js";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { execSync } from "child_process";
+class TestGenerator {
+  ralphPlugin;
+  constructor(ralphPlugin) {
+    this.ralphPlugin = ralphPlugin;
+  }
+  /**
+   * Generate tests iteratively until coverage target is met
+   */
+  async generateTests(request) {
+    const coverageTarget = request.coverageTarget || 80;
+    const task = {
+      id: `testgen-${Date.now()}`,
+      description: `Generate ${request.framework} tests for ${request.targetFile}`,
+      acceptanceCriteria: [
+        "All tests pass",
+        `Test coverage >= ${coverageTarget}%`,
+        "No test duplication",
+        "Tests are maintainable and clear"
+      ],
+      maxIterations: 7
+    };
+    if (request.includeEdgeCases) {
+      task.acceptanceCriteria.push("Edge cases covered");
+      task.acceptanceCriteria.push("Error conditions tested");
+    }
+    if (request.includeIntegrationTests) {
+      task.acceptanceCriteria.push("Integration tests included");
+    }
+    const result = await this.ralphPlugin.runTask(task);
+    const analysis = await this.analyzeGeneratedTests(request.targetFile, request.framework);
+    return {
+      testFiles: analysis.files,
+      coverage: analysis.coverage,
+      testCount: analysis.testCount,
+      passRate: analysis.passRate,
+      iterations: result.iterations
+    };
+  }
+  /**
+   * Analyze generated tests
+   */
+  async analyzeGeneratedTests(targetFile, framework) {
+    const analysis = {
+      files: [],
+      coverage: 0,
+      testCount: 0,
+      passRate: 0
+    };
+    try {
+      const testDir = path.dirname(targetFile);
+      const baseName = path.basename(targetFile, path.extname(targetFile));
+      const testPatterns = [
+        `${baseName}.test.*`,
+        `${baseName}.spec.*`,
+        `test_${baseName}.*`,
+        `${baseName}_test.*`
+      ];
+      for (const pattern of testPatterns) {
+        const files = await this.findFiles(testDir, pattern);
+        analysis.files.push(...files);
+      }
+      analysis.coverage = await this.runCoverageAnalysis(framework);
+      const testResults = await this.runTests(framework);
+      analysis.testCount = testResults.total;
+      analysis.passRate = testResults.passed / testResults.total * 100;
+    } catch (error) {
+      console.error("Error analyzing tests:", error);
+    }
+    return analysis;
+  }
+  /**
+   * Find files matching pattern
+   */
+  async findFiles(dir, pattern) {
+    const files = [];
+    try {
+      const entries = await fs.readdir(dir);
+      for (const entry of entries) {
+        if (this.matchesPattern(entry, pattern)) {
+          files.push(path.join(dir, entry));
+        }
+      }
+    } catch (error) {
+      console.error("Error finding files:", error);
+    }
+    return files;
+  }
+  /**
+   * Simple pattern matching
+   */
+  matchesPattern(filename, pattern) {
+    const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+    return regex.test(filename);
+  }
+  /**
+   * Run coverage analysis
+   */
+  async runCoverageAnalysis(framework) {
+    try {
+      let command = "";
+      switch (framework) {
+        case "jest":
+          command = "npx jest --coverage --silent";
+          break;
+        case "vitest":
+          command = "npx vitest run --coverage --silent";
+          break;
+        case "mocha":
+          command = "npx nyc mocha";
+          break;
+        case "pytest":
+          command = "pytest --cov --cov-report=json";
+          break;
+      }
+      if (command) {
+        const output = execSync(command, { encoding: "utf-8", stdio: "pipe" });
+        const match = output.match(/(\d+(?:\.\d+)?)\s*%/);
+        if (match) {
+          return parseFloat(match[1]);
+        }
+      }
+    } catch (error) {
+      console.error("Coverage analysis failed:", error);
+    }
+    return 0;
+  }
+  /**
+   * Run tests and get results
+   */
+  async runTests(framework) {
+    try {
+      let command = "";
+      switch (framework) {
+        case "jest":
+          command = "npx jest --json";
+          break;
+        case "vitest":
+          command = "npx vitest run --reporter=json";
+          break;
+        case "mocha":
+          command = "npx mocha --reporter json";
+          break;
+        case "pytest":
+          command = "pytest --json-report";
+          break;
+      }
+      if (command) {
+        const output = execSync(command, { encoding: "utf-8", stdio: "pipe" });
+        try {
+          const json = JSON.parse(output);
+          return {
+            total: json.numTotalTests || json.tests || 0,
+            passed: json.numPassedTests || json.passes || 0
+          };
+        } catch {
+          const totalMatch = output.match(/(\d+)\s+tests?/i);
+          const passedMatch = output.match(/(\d+)\s+pass/i);
+          return {
+            total: totalMatch ? parseInt(totalMatch[1]) : 0,
+            passed: passedMatch ? parseInt(passedMatch[1]) : 0
+          };
+        }
+      }
+    } catch (error) {
+      console.error("Test execution failed:", error);
+    }
+    return { total: 0, passed: 0 };
+  }
+}
+async function generateTestsForModule() {
+  const ralphPlugin = new SimpleRalphPlugin();
+  await ralphPlugin.initialize({
+    eventBus: {},
+    config: { name: "simple-ralph", version: "2.0.0", enabled: true },
+    dataDir: ".ralph",
+    getRepository: () => null,
+    registerRepository: () => {
+    }
+  });
+  const generator = new TestGenerator(ralphPlugin);
+  const result = await generator.generateTests({
+    targetFile: "./src/utils/validator.ts",
+    framework: "jest",
+    coverageTarget: 90,
+    includeEdgeCases: true,
+    includeIntegrationTests: false,
+    mockStrategy: "partial"
+  });
+  console.log(`Generated ${result.testCount} tests with ${result.coverage}% coverage`);
+  console.log(`Pass rate: ${result.passRate}%`);
+  console.log(`Completed in ${result.iterations} iterations`);
+}
+export {
+  TestGenerator,
+  generateTestsForModule
+};
+//# sourceMappingURL=test-generator.js.map

package/dist/plugins/ralph/use-cases/test-generator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/plugins/ralph/use-cases/test-generator.ts"],
+  "sourcesContent": ["/**\n * Test Generator - Iteratively generate comprehensive test suites\n * Focuses on achieving high coverage and catching edge cases\n */\n\nimport { SimpleRalphPlugin, SimpleTask } from '../simple-ralph-plugin.js';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { execSync } from 'child_process';\n\nexport interface TestGenRequest {\n  targetFile: string;\n  framework: 'jest' | 'mocha' | 'vitest' | 'pytest';\n  coverageTarget?: number;\n  includeEdgeCases?: boolean;\n  includeIntegrationTests?: boolean;\n  mockStrategy?: 'full' | 'partial' | 'none';\n}\n\nexport interface GeneratedTests {\n  testFiles: string[];\n  coverage: number;\n  testCount: number;\n  passRate: number;\n  iterations: number;\n}\n\nexport class TestGenerator {\n  private ralphPlugin: SimpleRalphPlugin;\n\n  constructor(ralphPlugin: SimpleRalphPlugin) {\n    this.ralphPlugin = ralphPlugin;\n  }\n\n  /**\n   * Generate tests iteratively until coverage target is met\n   */\n  async generateTests(request: TestGenRequest): Promise<GeneratedTests> {\n    const coverageTarget = request.coverageTarget || 80;\n\n    const task: SimpleTask = {\n      id: `testgen-${Date.now()}`,\n      description: `Generate ${request.framework} tests for ${request.targetFile}`,\n      acceptanceCriteria: [\n        'All tests pass',\n        `Test coverage >= ${coverageTarget}%`,\n        'No test duplication',\n        'Tests are maintainable and clear'\n      ],\n      maxIterations: 7\n    };\n\n    // Add edge case criteria if requested\n    if (request.includeEdgeCases) {\n      task.acceptanceCriteria.push('Edge cases covered');\n      task.acceptanceCriteria.push('Error conditions tested');\n    }\n\n    if (request.includeIntegrationTests) {\n      task.acceptanceCriteria.push('Integration tests included');\n    }\n\n    // Run iterative test generation\n    const result = await this.ralphPlugin.runTask(task);\n\n    // Analyze generated tests\n    const analysis = await this.analyzeGeneratedTests(request.targetFile, request.framework);\n\n    return {\n      testFiles: analysis.files,\n      coverage: analysis.coverage,\n      testCount: analysis.testCount,\n      passRate: analysis.passRate,\n      iterations: result.iterations\n    };\n  }\n\n  /**\n   * Analyze generated tests\n   */\n  private async analyzeGeneratedTests(\n    targetFile: string, \n    framework: string\n  ): Promise<{\n    files: string[];\n    coverage: number;\n    testCount: number;\n    passRate: number;\n  }> {\n    const analysis = {\n      files: [] as string[],\n      coverage: 0,\n      testCount: 0,\n      passRate: 0\n    };\n\n    try {\n      // Find test files\n      const testDir = path.dirname(targetFile);\n      const baseName = path.basename(targetFile, path.extname(targetFile));\n      \n      const testPatterns = [\n        `${baseName}.test.*`,\n        `${baseName}.spec.*`,\n        `test_${baseName}.*`,\n        `${baseName}_test.*`\n      ];\n\n      for (const pattern of testPatterns) {\n        const files = await this.findFiles(testDir, pattern);\n        analysis.files.push(...files);\n      }\n\n      // Run coverage analysis\n      analysis.coverage = await this.runCoverageAnalysis(framework);\n      \n      // Count tests and check pass rate\n      const testResults = await this.runTests(framework);\n      analysis.testCount = testResults.total;\n      analysis.passRate = testResults.passed / testResults.total * 100;\n\n    } catch (error) {\n      console.error('Error analyzing tests:', error);\n    }\n\n    return analysis;\n  }\n\n  /**\n   * Find files matching pattern\n   */\n  private async findFiles(dir: string, pattern: string): Promise<string[]> {\n    const files: string[] = [];\n    try {\n      const entries = await fs.readdir(dir);\n      for (const entry of entries) {\n        if (this.matchesPattern(entry, pattern)) {\n          files.push(path.join(dir, entry));\n        }\n      }\n    } catch (error) {\n      console.error('Error finding files:', error);\n    }\n    return files;\n  }\n\n  /**\n   * Simple pattern matching\n   */\n  private matchesPattern(filename: string, pattern: string): boolean {\n    const regex = new RegExp(pattern.replace(/\\*/g, '.*'));\n    return regex.test(filename);\n  }\n\n  /**\n   * Run coverage analysis\n   */\n  private async runCoverageAnalysis(framework: string): Promise<number> {\n    try {\n      let command = '';\n      switch (framework) {\n        case 'jest':\n          command = 'npx jest --coverage --silent';\n          break;\n        case 'vitest':\n          command = 'npx vitest run --coverage --silent';\n          break;\n        case 'mocha':\n          command = 'npx nyc mocha';\n          break;\n        case 'pytest':\n          command = 'pytest --cov --cov-report=json';\n          break;\n      }\n\n      if (command) {\n        const output = execSync(command, { encoding: 'utf-8', stdio: 'pipe' });\n        \n        // Parse coverage from output (simplified)\n        const match = output.match(/(\\d+(?:\\.\\d+)?)\\s*%/);\n        if (match) {\n          return parseFloat(match[1]);\n        }\n      }\n    } catch (error) {\n      console.error('Coverage analysis failed:', error);\n    }\n    \n    return 0;\n  }\n\n  /**\n   * Run tests and get results\n   */\n  private async runTests(framework: string): Promise<{ total: number; passed: number }> {\n    try {\n      let command = '';\n      switch (framework) {\n        case 'jest':\n          command = 'npx jest --json';\n          break;\n        case 'vitest':\n          command = 'npx vitest run --reporter=json';\n          break;\n        case 'mocha':\n          command = 'npx mocha --reporter json';\n          break;\n        case 'pytest':\n          command = 'pytest --json-report';\n          break;\n      }\n\n      if (command) {\n        const output = execSync(command, { encoding: 'utf-8', stdio: 'pipe' });\n        \n        try {\n          const json = JSON.parse(output);\n          // Parse based on framework (simplified)\n          return {\n            total: json.numTotalTests || json.tests || 0,\n            passed: json.numPassedTests || json.passes || 0\n          };\n        } catch {\n          // Fallback to regex parsing\n          const totalMatch = output.match(/(\\d+)\\s+tests?/i);\n          const passedMatch = output.match(/(\\d+)\\s+pass/i);\n          \n          return {\n            total: totalMatch ? parseInt(totalMatch[1]) : 0,\n            passed: passedMatch ? parseInt(passedMatch[1]) : 0\n          };\n        }\n      }\n    } catch (error) {\n      console.error('Test execution failed:', error);\n    }\n    \n    return { total: 0, passed: 0 };\n  }\n}\n\n// Example: Generate tests for a TypeScript module\nexport async function generateTestsForModule(): Promise<void> {\n  const ralphPlugin = new SimpleRalphPlugin();\n  await ralphPlugin.initialize({\n    eventBus: {} as any,\n    config: { name: 'simple-ralph', version: '2.0.0', enabled: true },\n    dataDir: '.ralph',\n    getRepository: () => null as any,\n    registerRepository: () => {}\n  });\n\n  const generator = new TestGenerator(ralphPlugin);\n  \n  const result = await generator.generateTests({\n    targetFile: './src/utils/validator.ts',\n    framework: 'jest',\n    coverageTarget: 90,\n    includeEdgeCases: true,\n    includeIntegrationTests: false,\n    mockStrategy: 'partial'\n  });\n\n  console.log(`Generated ${result.testCount} tests with ${result.coverage}% coverage`);\n  console.log(`Pass rate: ${result.passRate}%`);\n  console.log(`Completed in ${result.iterations} iterations`);\n}"],
+  "mappings": "AAKA,SAAS,yBAAqC;AAC9C,YAAY,QAAQ;AACpB,YAAY,UAAU;AACtB,SAAS,gBAAgB;AAmBlB,MAAM,cAAc;AAAA,EACjB;AAAA,EAER,YAAY,aAAgC;AAC1C,SAAK,cAAc;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,cAAc,SAAkD;AACpE,UAAM,iBAAiB,QAAQ,kBAAkB;AAEjD,UAAM,OAAmB;AAAA,MACvB,IAAI,WAAW,KAAK,IAAI,CAAC;AAAA,MACzB,aAAa,YAAY,QAAQ,SAAS,cAAc,QAAQ,UAAU;AAAA,MAC1E,oBAAoB;AAAA,QAClB;AAAA,QACA,oBAAoB,cAAc;AAAA,QAClC;AAAA,QACA;AAAA,MACF;AAAA,MACA,eAAe;AAAA,IACjB;AAGA,QAAI,QAAQ,kBAAkB;AAC5B,WAAK,mBAAmB,KAAK,oBAAoB;AACjD,WAAK,mBAAmB,KAAK,yBAAyB;AAAA,IACxD;AAEA,QAAI,QAAQ,yBAAyB;AACnC,WAAK,mBAAmB,KAAK,4BAA4B;AAAA,IAC3D;AAGA,UAAM,SAAS,MAAM,KAAK,YAAY,QAAQ,IAAI;AAGlD,UAAM,WAAW,MAAM,KAAK,sBAAsB,QAAQ,YAAY,QAAQ,SAAS;AAEvF,WAAO;AAAA,MACL,WAAW,SAAS;AAAA,MACpB,UAAU,SAAS;AAAA,MACnB,WAAW,SAAS;AAAA,MACpB,UAAU,SAAS;AAAA,MACnB,YAAY,OAAO;AAAA,IACrB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,MAAc,sBACZ,YACA,WAMC;AACD,UAAM,WAAW;AAAA,MACf,OAAO,CAAC;AAAA,MACR,UAAU;AAAA,MACV,WAAW;AAAA,MACX,UAAU;AAAA,IACZ;AAEA,QAAI;AAEF,YAAM,UAAU,KAAK,QAAQ,UAAU;AACvC,YAAM,WAAW,KAAK,SAAS,YAAY,KAAK,QAAQ,UAAU,CAAC;AAEnE,YAAM,eAAe;AAAA,QACnB,GAAG,QAAQ;AAAA,QACX,GAAG,QAAQ;AAAA,QACX,QAAQ,QAAQ;AAAA,QAChB,GAAG,QAAQ;AAAA,MACb;AAEA,iBAAW,WAAW,cAAc;AAClC,cAAM,QAAQ,MAAM,KAAK,UAAU,SAAS,OAAO;AACnD,iBAAS,MAAM,KAAK,GAAG,KAAK;AAAA,MAC9B;AAGA,eAAS,WAAW,MAAM,KAAK,oBAAoB,SAAS;AAG5D,YAAM,cAAc,MAAM,KAAK,SAAS,SAAS;AACjD,eAAS,YAAY,YAAY;AACjC,eAAS,WAAW,YAAY,SAAS,YAAY,QAAQ;AAAA,IAE/D,SAAS,OAAO;AACd,cAAQ,MAAM,0BAA0B,KAAK;AAAA,IAC/C;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAc,UAAU,KAAa,SAAoC;AACvE,UAAM,QAAkB,CAAC;AACzB,QAAI;AACF,YAAM,UAAU,MAAM,GAAG,QAAQ,GAAG;AACpC,iBAAW,SAAS,SAAS;AAC3B,YAAI,KAAK,eAAe,OAAO,OAAO,GAAG;AACvC,gBAAM,KAAK,KAAK,KAAK,KAAK,KAAK,CAAC;AAAA,QAClC;AAAA,MACF;AAAA,IACF,SAAS,OAAO;AACd,cAAQ,MAAM,wBAAwB,KAAK;AAAA,IAC7C;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKQ,eAAe,UAAkB,SAA0B;AACjE,UAAM,QAAQ,IAAI,OAAO,QAAQ,QAAQ,OAAO,IAAI,CAAC;AACrD,WAAO,MAAM,KAAK,QAAQ;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA,EAKA,MAAc,oBAAoB,WAAoC;AACpE,QAAI;AACF,UAAI,UAAU;AACd,cAAQ,WAAW;AAAA,QACjB,KAAK;AACH,oBAAU;AACV;AAAA,QACF,KAAK;AACH,oBAAU;AACV;AAAA,QACF,KAAK;AACH,oBAAU;AACV;AAAA,QACF,KAAK;AACH,oBAAU;AACV;AAAA,MACJ;AAEA,UAAI,SAAS;AACX,cAAM,SAAS,SAAS,SAAS,EAAE,UAAU,SAAS,OAAO,OAAO,CAAC;AAGrE,cAAM,QAAQ,OAAO,MAAM,qBAAqB;AAChD,YAAI,OAAO;AACT,iBAAO,WAAW,MAAM,CAAC,CAAC;AAAA,QAC5B;AAAA,MACF;AAAA,IACF,SAAS,OAAO;AACd,cAAQ,MAAM,6BAA6B,KAAK;AAAA,IAClD;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAc,SAAS,WAA+D;AACpF,QAAI;AACF,UAAI,UAAU;AACd,cAAQ,WAAW;AAAA,QACjB,KAAK;AACH,oBAAU;AACV;AAAA,QACF,KAAK;AACH,oBAAU;AACV;AAAA,QACF,KAAK;AACH,oBAAU;AACV;AAAA,QACF,KAAK;AACH,oBAAU;AACV;AAAA,MACJ;AAEA,UAAI,SAAS;AACX,cAAM,SAAS,SAAS,SAAS,EAAE,UAAU,SAAS,OAAO,OAAO,CAAC;AAErE,YAAI;AACF,gBAAM,OAAO,KAAK,MAAM,MAAM;AAE9B,iBAAO;AAAA,YACL,OAAO,KAAK,iBAAiB,KAAK,SAAS;AAAA,YAC3C,QAAQ,KAAK,kBAAkB,KAAK,UAAU;AAAA,UAChD;AAAA,QACF,QAAQ;AAEN,gBAAM,aAAa,OAAO,MAAM,iBAAiB;AACjD,gBAAM,cAAc,OAAO,MAAM,eAAe;AAEhD,iBAAO;AAAA,YACL,OAAO,aAAa,SAAS,WAAW,CAAC,CAAC,IAAI;AAAA,YAC9C,QAAQ,cAAc,SAAS,YAAY,CAAC,CAAC,IAAI;AAAA,UACnD;AAAA,QACF;AAAA,MACF;AAAA,IACF,SAAS,OAAO;AACd,cAAQ,MAAM,0BAA0B,KAAK;AAAA,IAC/C;AAEA,WAAO,EAAE,OAAO,GAAG,QAAQ,EAAE;AAAA,EAC/B;AACF;AAGA,eAAsB,yBAAwC;AAC5D,QAAM,cAAc,IAAI,kBAAkB;AAC1C,QAAM,YAAY,WAAW;AAAA,IAC3B,UAAU,CAAC;AAAA,IACX,QAAQ,EAAE,MAAM,gBAAgB,SAAS,SAAS,SAAS,KAAK;AAAA,IAChE,SAAS;AAAA,IACT,eAAe,MAAM;AAAA,IACrB,oBAAoB,MAAM;AAAA,IAAC;AAAA,EAC7B,CAAC;AAED,QAAM,YAAY,IAAI,cAAc,WAAW;AAE/C,QAAM,SAAS,MAAM,UAAU,cAAc;AAAA,IAC3C,YAAY;AAAA,IACZ,WAAW;AAAA,IACX,gBAAgB;AAAA,IAChB,kBAAkB;AAAA,IAClB,yBAAyB;AAAA,IACzB,cAAc;AAAA,EAChB,CAAC;AAED,UAAQ,IAAI,aAAa,OAAO,SAAS,eAAe,OAAO,QAAQ,YAAY;AACnF,UAAQ,IAAI,cAAc,OAAO,QAAQ,GAAG;AAC5C,UAAQ,IAAI,gBAAgB,OAAO,UAAU,aAAa;AAC5D;",
+  "names": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "0.4.2",
+  "version": "0.5.1",
   "description": "Lossless memory runtime for AI coding tools - organizes context as a call stack instead of linear chat logs, with team collaboration and infinite retention",
   "engines": {
     "node": ">=20.0.0",
@@ -86,11 +86,9 @@
     "@linear/sdk": "^68.1.0",
     "@modelcontextprotocol/sdk": "^0.5.0",
     "@stackmemoryai/stackmemory": "^0.3.19",
-    "@types/bcryptjs": "^2.4.6",
     "@types/blessed": "^0.1.27",
     "@types/inquirer": "^9.0.9",
     "@types/pg": "^8.16.0",
-    "bcryptjs": "^3.0.3",
     "better-sqlite3": "^9.2.2",
     "chalk": "^5.3.0",
     "chromadb": "^3.2.2",
@@ -105,17 +103,12 @@
     "helmet": "^8.1.0",
     "ignore": "^7.0.5",
     "inquirer": "^9.3.8",
-    "ioredis": "^5.8.2",
-    "jsonwebtoken": "^9.0.3",
-    "jwks-rsa": "^3.2.0",
     "msgpackr": "^1.10.1",
     "ngrok": "^5.0.0-beta.2",
     "open": "^11.0.0",
     "ora": "^9.0.0",
     "pg": "^8.17.1",
-    "puppeteer": "^24.34.0",
     "rate-limiter-flexible": "^9.0.1",
-    "redis": "^5.10.0",
     "shell-escape": "^0.2.0",
     "socket.io": "^4.6.0",
     "socket.io-client": "^4.6.0",

package/scripts/simple-swarm-demo.ts

@@ -0,0 +1,114 @@
+#!/usr/bin/env npx tsx
+
+/**
+ * Simple Ralph Swarm Demo - Minimal database dependencies
+ * Demonstrates basic swarm coordination without complex SessionManager setup
+ */
+
+import 'dotenv/config';
+import { SwarmCoordinator } from '../src/integrations/ralph/swarm/swarm-coordinator.js';
+import { SwarmRegistry } from '../src/integrations/ralph/monitoring/swarm-registry.js';
+import { logger } from '../src/core/monitoring/logger.js';
+
+async function runSimpleSwarm() {
+  try {
+    console.log('🦾 Starting Simple Ralph Swarm Demo...');
+
+    // Initialize registry
+    const registry = SwarmRegistry.getInstance();
+
+    // Create a basic swarm coordinator without complex dependencies
+    const coordinator = new SwarmCoordinator({
+      maxAgents: 2,
+      timeout: 30000,
+      enableGitWorkflow: false, // Disable git workflow to avoid branch conflicts
+      enableStackMemoryBridge: false, // Disable StackMemory integration temporarily
+    });
+
+    // Initialize coordinator
+    await coordinator.initialize();
+
+    console.log('✅ Swarm coordinator initialized');
+
+    // Define a simple task
+    const task = {
+      id: 'simple-demo-task',
+      description:
+        'Demonstrate basic swarm functionality without database dependencies',
+      type: 'demonstration' as const,
+      priority: 'medium' as const,
+      estimatedDuration: 30000,
+      requirements: [
+        'Show swarm initialization',
+        'Demonstrate agent coordination',
+        'Validate basic functionality',
+      ],
+    };
+
+    console.log('📋 Task defined:', task.description);
+
+    // Register the swarm
+    const swarmId = registry.registerSwarm(
+      coordinator,
+      'Simple Demo Swarm - No Database Dependencies'
+    );
+
+    console.log('🆔 Swarm registered:', swarmId);
+
+    // Launch with minimal configuration
+    const result = await coordinator.launchSwarm(
+      task.description,
+      [
+        {
+          role: 'developer',
+          specialization: 'basic-functionality',
+        },
+      ],
+      {
+        enableRalphBridge: false, // Disable Ralph bridge to avoid database issues
+        enableGitWorkflow: false, // Already disabled in coordinator init
+      }
+    );
+
+    console.log('🚀 Swarm launched successfully!');
+    console.log('📊 Result:', {
+      swarmId: result.swarmId,
+      agentCount: result.agents?.length || 0,
+      status: result.status,
+    });
+
+    // Show registry status
+    const activeSwarms = registry.listActiveSwarms();
+    console.log('📈 Active swarms:', activeSwarms.length);
+
+    // Simulate some work
+    console.log('⏳ Simulating swarm work for 5 seconds...');
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+
+    // Stop the swarm
+    console.log('🛑 Stopping swarm...');
+    await coordinator.stopSwarm();
+
+    console.log('');
+    console.log('🎉 Simple swarm demo completed successfully!');
+    console.log('');
+    console.log('✅ Demonstrated:');
+    console.log('   - Basic swarm coordinator initialization');
+    console.log('   - Swarm registry management');
+    console.log('   - Agent configuration without database dependencies');
+    console.log('   - Simple task execution workflow');
+    console.log('');
+    console.log('🔧 This approach bypasses:');
+    console.log('   - Complex SessionManager database setup');
+    console.log('   - StackMemory FrameManager initialization');
+    console.log('   - Git workflow branch conflicts');
+    console.log('   - Ralph-StackMemory bridge complications');
+  } catch (error: unknown) {
+    console.error('❌ Simple swarm demo failed:', (error as Error).message);
+    logger.error('Simple swarm demo error', error as Error);
+    process.exit(1);
+  }
+}
+
+// Run the demo
+runSimpleSwarm();

package/scripts/test-ralph-iterations.ts

@@ -0,0 +1,164 @@
+#!/usr/bin/env npx tsx
+
+/**
+ * Test script to verify Ralph loop can iterate beyond 5 iterations
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { existsSync } from 'fs';
+
+const RALPH_DIR = '.ralph';
+const MAX_TEST_ITERATIONS = 10; // Test up to 10 iterations
+
+interface RalphLoopState {
+  loopId?: string;
+  task: string;
+  criteria?: string;
+  iteration: number;
+  status: string;
+  startTime: number;
+}
+
+async function ensureDirectory(dir: string): Promise<void> {
+  if (!existsSync(dir)) {
+    await fs.mkdir(dir, { recursive: true });
+  }
+}
+
+async function saveLoopState(state: RalphLoopState): Promise<void> {
+  // Save state.json
+  await fs.writeFile(
+    path.join(RALPH_DIR, 'state.json'),
+    JSON.stringify(state, null, 2)
+  );
+
+  // Synchronize iteration.txt with current iteration
+  await fs.writeFile(
+    path.join(RALPH_DIR, 'iteration.txt'),
+    state.iteration.toString()
+  );
+
+  console.log(`✅ Saved state for iteration ${state.iteration}`);
+}
+
+async function simulateIteration(iterationNum: number): Promise<void> {
+  const historyDir = path.join(
+    RALPH_DIR,
+    'history',
+    `iteration-${iterationNum.toString().padStart(3, '0')}`
+  );
+  await ensureDirectory(historyDir);
+
+  // Create artifacts for this iteration
+  const artifacts = {
+    analysis: {
+      filesCount: Math.floor(Math.random() * 10) + 1,
+      testsPass: Math.floor(Math.random() * 20),
+      testsFail: Math.floor(Math.random() * 5),
+      lastChange: `Iteration ${iterationNum} changes`,
+    },
+    plan: {
+      summary: `Work for iteration ${iterationNum}`,
+      steps: [
+        `Task ${iterationNum}-1`,
+        `Task ${iterationNum}-2`,
+        `Task ${iterationNum}-3`,
+      ],
+      priority: 'high',
+    },
+    changes: [
+      {
+        step: `Task ${iterationNum}-1`,
+        timestamp: Date.now(),
+        result: 'completed',
+      },
+    ],
+    validation: {
+      testsPass: true,
+      lintClean: true,
+      errors: [],
+    },
+  };
+
+  await fs.writeFile(
+    path.join(historyDir, 'artifacts.json'),
+    JSON.stringify(artifacts, null, 2)
+  );
+
+  console.log(`📝 Created artifacts for iteration ${iterationNum}`);
+}
+
+async function runIterationTest(): Promise<void> {
+  console.log('🎭 Starting Ralph iteration test...');
+  console.log(`🎯 Goal: Test ${MAX_TEST_ITERATIONS} iterations\n`);
+
+  // Ensure directories exist
+  await ensureDirectory(RALPH_DIR);
+  await ensureDirectory(path.join(RALPH_DIR, 'history'));
+
+  // Initialize state
+  const initialState: RalphLoopState = {
+    task: 'Test multiple iterations beyond 5',
+    iteration: 0,
+    status: 'initialized',
+    startTime: Date.now(),
+  };
+
+  await saveLoopState(initialState);
+
+  // Run iterations
+  for (let i = 0; i < MAX_TEST_ITERATIONS; i++) {
+    console.log(`\n--- Iteration ${i} ---`);
+
+    // Simulate iteration work
+    await simulateIteration(i);
+
+    // Update state
+    const state: RalphLoopState = {
+      task: 'Test multiple iterations beyond 5',
+      iteration: i + 1,
+      status: 'running',
+      startTime: initialState.startTime,
+    };
+
+    await saveLoopState(state);
+
+    // Check if we're past the old limit
+    if (i === 5) {
+      console.log('\n🎉 Successfully passed iteration 5!');
+    }
+
+    // Small delay to simulate work
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  console.log('\n✅ Test completed successfully!');
+  console.log(`📊 Final iteration count: ${MAX_TEST_ITERATIONS}`);
+
+  // Verify final state
+  const finalIteration = await fs.readFile(
+    path.join(RALPH_DIR, 'iteration.txt'),
+    'utf8'
+  );
+
+  const finalState = JSON.parse(
+    await fs.readFile(path.join(RALPH_DIR, 'state.json'), 'utf8')
+  );
+
+  console.log(`\n📋 Final verification:`);
+  console.log(`   iteration.txt: ${finalIteration}`);
+  console.log(`   state.json iteration: ${finalState.iteration}`);
+
+  if (parseInt(finalIteration) === MAX_TEST_ITERATIONS) {
+    console.log('\n🎊 SUCCESS: Ralph loop can iterate beyond 5 iterations!');
+  } else {
+    console.error('\n❌ FAILURE: Iteration count mismatch');
+  }
+}
+
+// Run the test
+runIterationTest().catch((error) => {
+  console.error('❌ Test failed:', error);
+  process.exit(1);
+});