ralph-mem 0.1.0

package/dist/skills/ralph.js

@@ -0,0 +1,654 @@
+import {
+  loadConfig
+} from "../chunk-c3a91ngd.js";
+import {
+  createDBClient
+} from "../chunk-41rc1bhg.js";
+import {
+  ensureProjectDirs,
+  getProjectDBPath,
+  getProjectDataDir
+} from "../chunk-w40c0y00.js";
+import"../chunk-ns0dgdnb.js";
+
+// src/features/ralph/engine.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createLoopEngine(projectPath, sessionId, options) {
+  const config = options?.config ? { ...loadConfig(projectPath), ...options.config } : loadConfig(projectPath);
+  ensureProjectDirs(projectPath);
+  const dbPath = getProjectDBPath(projectPath);
+  const client = options?.client ?? createDBClient(dbPath);
+  let currentLoopRun = null;
+  let stopRequested = false;
+  let iterationCallback = null;
+  let completeCallback = null;
+  let iterationStartCallback = null;
+  let iterationEndCallback = null;
+  let currentIteration = 0;
+  function endLoopRun(status) {
+    if (!currentLoopRun)
+      return;
+    const now = new Date().toISOString();
+    client.updateLoopRun(currentLoopRun.id, {
+      status,
+      ended_at: now
+    });
+    currentLoopRun = client.getLoopRun(currentLoopRun.id);
+  }
+  function createLoopSummary(loopRunId, task, result) {
+    const statusText = result.reason === "success" ? "성공" : result.reason === "max_iterations" ? "최대 반복 도달" : result.reason === "stopped" ? "중단됨" : "오류";
+    const content = `Ralph Loop 완료
+태스크: ${task}
+상태: ${statusText}
+반복: ${result.iterations}회
+${result.error ? `오류: ${result.error}` : ""}`.trim();
+    client.createObservation({
+      session_id: sessionId,
+      type: result.success ? "success" : "note",
+      content,
+      importance: result.success ? 0.9 : 0.7,
+      loop_run_id: loopRunId,
+      iteration: result.iterations
+    });
+  }
+  return {
+    isRunning() {
+      return currentLoopRun !== null && currentLoopRun.status === "running";
+    },
+    getCurrentRun() {
+      if (!currentLoopRun)
+        return null;
+      return client.getLoopRun(currentLoopRun.id);
+    },
+    getLoopContext() {
+      if (!currentLoopRun || currentLoopRun.status !== "running") {
+        return null;
+      }
+      return {
+        runId: currentLoopRun.id,
+        iteration: currentIteration
+      };
+    },
+    async start(task, loopOptions) {
+      const activeRun = client.getActiveLoopRun(sessionId);
+      if (activeRun) {
+        throw new Error(`Loop already running: ${activeRun.id}. Stop it first with stop().`);
+      }
+      stopRequested = false;
+      const criteria = loopOptions?.criteria ?? config.ralph.success_criteria;
+      const maxIterations = loopOptions?.maxIterations ?? config.ralph.max_iterations;
+      const cooldownMs = loopOptions?.cooldownMs ?? config.ralph.cooldown_ms;
+      currentLoopRun = client.createLoopRun({
+        session_id: sessionId,
+        task,
+        criteria: JSON.stringify(criteria),
+        max_iterations: maxIterations
+      });
+      const loopRunId = currentLoopRun.id;
+      let iteration = 0;
+      let lastError;
+      try {
+        while (iteration < maxIterations) {
+          if (stopRequested) {
+            endLoopRun("stopped");
+            const result2 = {
+              success: false,
+              iterations: iteration,
+              reason: "stopped",
+              loopRunId
+            };
+            createLoopSummary(loopRunId, task, result2);
+            if (completeCallback)
+              completeCallback(result2);
+            return result2;
+          }
+          iteration++;
+          currentIteration = iteration;
+          client.updateLoopRun(loopRunId, { iterations: iteration });
+          const iterationContext = {
+            iteration,
+            task,
+            loopRunId
+          };
+          if (iterationStartCallback) {
+            iterationStartCallback(iterationContext);
+          }
+          if (!iterationCallback) {
+            throw new Error("No iteration callback set. Call onIteration() before start().");
+          }
+          const iterationResult = await iterationCallback(iterationContext);
+          if (iterationEndCallback) {
+            iterationEndCallback(iterationContext, iterationResult);
+          }
+          if (iterationResult.success) {
+            endLoopRun("success");
+            const result2 = {
+              success: true,
+              iterations: iteration,
+              reason: "success",
+              loopRunId
+            };
+            createLoopSummary(loopRunId, task, result2);
+            if (completeCallback)
+              completeCallback(result2);
+            return result2;
+          }
+          if (iterationResult.error) {
+            lastError = iterationResult.error;
+          }
+          if (iteration < maxIterations && !stopRequested) {
+            await sleep(cooldownMs);
+          }
+        }
+        endLoopRun("failed");
+        const result = {
+          success: false,
+          iterations: iteration,
+          reason: "max_iterations",
+          loopRunId,
+          error: lastError
+        };
+        createLoopSummary(loopRunId, task, result);
+        if (completeCallback)
+          completeCallback(result);
+        return result;
+      } catch (error) {
+        endLoopRun("failed");
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const result = {
+          success: false,
+          iterations: iteration,
+          reason: "error",
+          loopRunId,
+          error: errorMessage
+        };
+        createLoopSummary(loopRunId, task, result);
+        if (completeCallback)
+          completeCallback(result);
+        return result;
+      }
+    },
+    async stop() {
+      stopRequested = true;
+      if (currentLoopRun && currentLoopRun.status === "running") {
+        endLoopRun("stopped");
+      }
+    },
+    onIteration(callback) {
+      iterationCallback = callback;
+    },
+    onComplete(callback) {
+      completeCallback = callback;
+    },
+    onIterationStart(callback) {
+      iterationStartCallback = callback;
+    },
+    onIterationEnd(callback) {
+      iterationEndCallback = callback;
+    },
+    close() {
+      if (!options?.client) {
+        client.close();
+      }
+    }
+  };
+}
+
+// src/features/ralph/snapshot.ts
+import { execSync } from "node:child_process";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join } from "node:path";
+function getModifiedFiles(projectPath) {
+  try {
+    const gitDir = join(projectPath, ".git");
+    if (!existsSync(gitDir)) {
+      return [];
+    }
+    const staged = execSync("git diff --cached --name-only", {
+      cwd: projectPath,
+      encoding: "utf-8"
+    }).trim();
+    const unstaged = execSync("git diff --name-only", {
+      cwd: projectPath,
+      encoding: "utf-8"
+    }).trim();
+    const untracked = execSync("git ls-files --others --exclude-standard", {
+      cwd: projectPath,
+      encoding: "utf-8"
+    }).trim();
+    const files = new Set;
+    for (const line of staged.split(`
+`)) {
+      if (line.trim())
+        files.add(line.trim());
+    }
+    for (const line of unstaged.split(`
+`)) {
+      if (line.trim())
+        files.add(line.trim());
+    }
+    for (const line of untracked.split(`
+`)) {
+      if (line.trim())
+        files.add(line.trim());
+    }
+    return Array.from(files).filter((file) => existsSync(join(projectPath, file)));
+  } catch {
+    return [];
+  }
+}
+function getSnapshotsDir(projectPath) {
+  return join(getProjectDataDir(projectPath), "snapshots");
+}
+function createSnapshotManager(projectPath) {
+  const snapshotsDir = getSnapshotsDir(projectPath);
+  return {
+    async create(runId) {
+      const snapshotPath = join(snapshotsDir, runId);
+      mkdirSync(snapshotPath, { recursive: true });
+      const modifiedFiles = getModifiedFiles(projectPath);
+      for (const file of modifiedFiles) {
+        const srcPath = join(projectPath, file);
+        const destPath = join(snapshotPath, file);
+        mkdirSync(dirname(destPath), { recursive: true });
+        copyFileSync(srcPath, destPath);
+      }
+      const metadata = {
+        runId,
+        createdAt: new Date().toISOString(),
+        files: modifiedFiles
+      };
+      writeFileSync(join(snapshotPath, ".snapshot-meta.json"), JSON.stringify(metadata, null, 2));
+      return snapshotPath;
+    },
+    async restore(snapshotPath) {
+      if (!existsSync(snapshotPath)) {
+        throw new Error(`Snapshot not found: ${snapshotPath}`);
+      }
+      const metaPath = join(snapshotPath, ".snapshot-meta.json");
+      if (!existsSync(metaPath)) {
+        throw new Error(`Invalid snapshot: missing metadata at ${snapshotPath}`);
+      }
+      const metadata = JSON.parse(readFileSync(metaPath, "utf-8"));
+      const files = metadata.files || [];
+      for (const file of files) {
+        const srcPath = join(snapshotPath, file);
+        const destPath = join(projectPath, file);
+        if (existsSync(srcPath)) {
+          mkdirSync(dirname(destPath), { recursive: true });
+          copyFileSync(srcPath, destPath);
+        }
+      }
+    },
+    async delete(snapshotPath) {
+      if (existsSync(snapshotPath)) {
+        rmSync(snapshotPath, { recursive: true });
+      }
+    },
+    async list() {
+      if (!existsSync(snapshotsDir)) {
+        return [];
+      }
+      const entries = readdirSync(snapshotsDir);
+      const snapshots = [];
+      for (const entry of entries) {
+        const snapshotPath = join(snapshotsDir, entry);
+        const metaPath = join(snapshotPath, ".snapshot-meta.json");
+        if (existsSync(metaPath)) {
+          try {
+            const metadata = JSON.parse(readFileSync(metaPath, "utf-8"));
+            const files = metadata.files || [];
+            snapshots.push({
+              runId: metadata.runId || entry,
+              path: snapshotPath,
+              createdAt: new Date(metadata.createdAt),
+              fileCount: files.length
+            });
+          } catch {}
+        }
+      }
+      return snapshots.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    },
+    async cleanup(maxAge) {
+      const snapshots = await this.list();
+      const cutoff = Date.now() - maxAge;
+      let deletedCount = 0;
+      for (const snapshot of snapshots) {
+        if (snapshot.createdAt.getTime() < cutoff) {
+          await this.delete(snapshot.path);
+          deletedCount++;
+        }
+      }
+      return deletedCount;
+    }
+  };
+}
+async function restoreRunSnapshot(projectPath, runId) {
+  const manager = createSnapshotManager(projectPath);
+  const snapshotPath = join(getSnapshotsDir(projectPath), runId);
+  return manager.restore(snapshotPath);
+}
+
+// src/skills/ralph.ts
+var CRITERIA_COMMANDS = {
+  test_pass: "npm test",
+  build_success: "npm run build",
+  lint_clean: "npm run lint",
+  type_check: "npx tsc --noEmit",
+  custom: "(custom)"
+};
+function parseStartArgs(argsString) {
+  const args = {
+    task: ""
+  };
+  const tokens = [];
+  let current = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  for (const char of argsString) {
+    if ((char === '"' || char === "'") && !inQuotes) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (char === quoteChar && inQuotes) {
+      inQuotes = false;
+      quoteChar = "";
+    } else if (char === " " && !inQuotes) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  let i = 0;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token === "--criteria" && i + 1 < tokens.length) {
+      const criteriaType = tokens[i + 1].toLowerCase();
+      if (isValidCriteriaType(criteriaType)) {
+        args.criteria = criteriaType;
+      }
+      i += 2;
+    } else if (token === "--max-iterations" && i + 1 < tokens.length) {
+      args.maxIterations = Number.parseInt(tokens[i + 1], 10);
+      i += 2;
+    } else if (token === "--cooldown" && i + 1 < tokens.length) {
+      args.cooldownMs = Number.parseInt(tokens[i + 1], 10);
+      i += 2;
+    } else if (token === "--no-snapshot") {
+      args.noSnapshot = true;
+      i++;
+    } else if (!token.startsWith("--") && !args.task) {
+      args.task = token;
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return args;
+}
+function isValidCriteriaType(type) {
+  return [
+    "test_pass",
+    "build_success",
+    "lint_clean",
+    "type_check",
+    "custom"
+  ].includes(type);
+}
+function formatStartMessage(loopRunId, task, criteria, maxIterations) {
+  const command = CRITERIA_COMMANDS[criteria];
+  return `\uD83D\uDE80 Ralph Loop 시작
+
+태스크: ${task}
+기준: ${criteria} (${command})
+최대 반복: ${maxIterations}
+
+Loop ID: ${loopRunId}
+중단: /ralph stop`;
+}
+function formatStopMessage(loopRunId, reason, rolledBack) {
+  const rollbackMsg = rolledBack ? `
+파일이 롤백되었습니다.` : "";
+  return `⏹️ Ralph Loop 중단
+
+Loop ID: ${loopRunId}
+이유: ${reason}${rollbackMsg}`;
+}
+function formatStatusMessage(isRunning, run) {
+  if (!isRunning || !run) {
+    return `\uD83D\uDCCA Ralph Loop 상태: 실행 중인 Loop 없음
+
+시작: /ralph start "태스크 설명"`;
+  }
+  const elapsed = Math.floor((Date.now() - run.startedAt.getTime()) / 1000);
+  const minutes = Math.floor(elapsed / 60);
+  const seconds = elapsed % 60;
+  return `\uD83D\uDCCA Ralph Loop 상태: 실행 중
+
+Loop ID: ${run.id}
+태스크: ${run.task}
+반복: ${run.iterations}/${run.maxIterations}
+경과: ${minutes}분 ${seconds}초
+
+중단: /ralph stop`;
+}
+function formatHistoryMessage(history) {
+  if (history.length === 0) {
+    return "\uD83D\uDCCB Ralph Loop 이력: 이력 없음";
+  }
+  const rows = history.map((entry) => {
+    const taskShort = entry.task.length > 20 ? `${entry.task.slice(0, 17)}...` : entry.task;
+    return `│ ${entry.id.padEnd(14)} │ ${taskShort.padEnd(20)} │ ${entry.status.padEnd(7)} │ ${String(entry.iterations).padStart(4)} │`;
+  });
+  return `\uD83D\uDCCB 최근 Ralph Loop 이력
+
+┌────────────────┬──────────────────────┬─────────┬──────┐
+│ ID             │ 태스크               │ 상태    │ 반복 │
+├────────────────┼──────────────────────┼─────────┼──────┤
+${rows.join(`
+`)}
+└────────────────┴──────────────────────┴─────────┴──────┘`;
+}
+function createRalphSkill(context) {
+  const { projectPath, sessionId } = context;
+  const config = context.config ?? loadConfig(projectPath);
+  let engine = context.engine;
+  const currentSnapshotPath = null;
+  function getOrCreateEngine() {
+    if (!engine) {
+      engine = createLoopEngine(projectPath, sessionId, {
+        client: context.client,
+        config
+      });
+    }
+    return engine;
+  }
+  return {
+    async start(args) {
+      if (!args.task) {
+        return {
+          success: false,
+          message: "",
+          error: '태스크 설명이 필요합니다. 사용법: /ralph start "태스크 설명"'
+        };
+      }
+      const eng = getOrCreateEngine();
+      if (eng.isRunning()) {
+        const currentRun = eng.getCurrentRun();
+        return {
+          success: false,
+          message: "",
+          error: `이미 Loop가 실행 중입니다. (ID: ${currentRun?.id})
+중단: /ralph stop`
+        };
+      }
+      const criteriaType = args.criteria ?? "test_pass";
+      const criteria = [{ type: criteriaType }];
+      const maxIterations = args.maxIterations ?? config.ralph?.max_iterations ?? 10;
+      const cooldownMs = args.cooldownMs ?? config.ralph?.cooldown_ms ?? 1000;
+      if (!args.noSnapshot) {
+        try {} catch {}
+      }
+      try {
+        const loopRun = eng.getCurrentRun();
+        const message = formatStartMessage(loopRun?.id ?? "pending", args.task, criteriaType, maxIterations);
+        return {
+          success: true,
+          loopRunId: loopRun?.id,
+          message
+        };
+      } catch (error) {
+        return {
+          success: false,
+          message: "",
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    },
+    async stop(args = {}) {
+      const eng = getOrCreateEngine();
+      if (!eng.isRunning()) {
+        return {
+          success: false,
+          message: "",
+          error: "실행 중인 Loop가 없습니다."
+        };
+      }
+      const currentRun = eng.getCurrentRun();
+      const loopRunId = currentRun?.id ?? "unknown";
+      try {
+        await eng.stop();
+        let rolledBack = false;
+        if (args.rollback && currentSnapshotPath) {
+          try {
+            await restoreRunSnapshot(projectPath, loopRunId);
+            rolledBack = true;
+          } catch {}
+        }
+        const message = formatStopMessage(loopRunId, "사용자 중단", rolledBack);
+        return {
+          success: true,
+          message
+        };
+      } catch (error) {
+        return {
+          success: false,
+          message: "",
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    },
+    async status(args = {}) {
+      const eng = getOrCreateEngine();
+      const isRunning = eng.isRunning();
+      const currentRun = eng.getCurrentRun();
+      let run;
+      if (currentRun) {
+        run = {
+          id: currentRun.id,
+          task: currentRun.task,
+          iterations: currentRun.iterations,
+          maxIterations: currentRun.max_iterations,
+          startedAt: new Date(currentRun.started_at)
+        };
+      }
+      let history;
+      if (args.history && context.client) {
+        const loopRuns = context.client.listLoopRuns(sessionId, 10);
+        history = loopRuns.map((lr) => ({
+          id: lr.id,
+          task: lr.task,
+          status: lr.status,
+          iterations: lr.iterations,
+          startedAt: new Date(lr.started_at),
+          endedAt: lr.ended_at ? new Date(lr.ended_at) : undefined
+        }));
+      }
+      const message = args.history && history ? formatHistoryMessage(history) : formatStatusMessage(isRunning, run);
+      return {
+        isRunning,
+        currentRun: run,
+        history,
+        message
+      };
+    },
+    getEngine() {
+      return getOrCreateEngine();
+    },
+    close() {
+      if (engine) {
+        engine.close();
+      }
+    }
+  };
+}
+async function executeRalphCommand(command, argsString, context) {
+  const skill = createRalphSkill(context);
+  try {
+    switch (command.toLowerCase()) {
+      case "start": {
+        const args = parseStartArgs(argsString);
+        const result = await skill.start(args);
+        if (!result.success) {
+          return `❌ ${result.error}`;
+        }
+        return result.message;
+      }
+      case "stop": {
+        const rollback = argsString.includes("--rollback");
+        const result = await skill.stop({ rollback });
+        if (!result.success) {
+          return `❌ ${result.error}`;
+        }
+        return result.message;
+      }
+      case "status": {
+        const history = argsString.includes("--history");
+        const result = await skill.status({ history });
+        return result.message;
+      }
+      default:
+        return `❌ 알 수 없는 명령: ${command}
+
+사용 가능한 명령:
+  /ralph start "태스크" [--criteria type] [--max-iterations n]
+  /ralph stop [--rollback]
+  /ralph status [--history]`;
+    }
+  } finally {
+    skill.close();
+  }
+}
+async function ralphSkill(_input) {
+  return {
+    success: false,
+    message: "Use createRalphSkill() for full functionality"
+  };
+}
+export {
+  ralphSkill,
+  parseStartArgs,
+  formatStopMessage,
+  formatStatusMessage,
+  formatStartMessage,
+  formatHistoryMessage,
+  executeRalphCommand,
+  createRalphSkill
+};
+
+export { ralphSkill };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "ralph-mem",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Persistent context management plugin for Claude Code with Ralph Loop",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "plugin.json",
+    "prompts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/roboco-io/ralph-mem.git"
+  },
+  "bugs": {
+    "url": "https://github.com/roboco-io/ralph-mem/issues"
+  },
+  "homepage": "https://github.com/roboco-io/ralph-mem#readme",
+  "scripts": {
+    "dev": "bun run --watch src/index.ts",
+    "build": "bun run scripts/build.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "bunx @biomejs/biome check src/",
+    "lint:fix": "bunx @biomejs/biome check --write src/",
+    "typecheck": "tsc --noEmit",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@xenova/transformers": "^2.17.2",
+    "better-sqlite3": "^12.6.2",
+    "js-yaml": "^4.1.1",
+    "nanoid": "^5.0.7"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/bun": "^1.1.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^2.0.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "typescript": "^5.6.0",
+    "vitest": "^2.0.0"
+  },
+  "keywords": [
+    "claude-code",
+    "plugin",
+    "memory",
+    "context",
+    "ralph-loop"
+  ],
+  "author": "",
+  "license": "MIT",
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "bunx @biomejs/biome check --write"
+    ]
+  }
+}