ralph-mem 0.1.0

package/dist/chunk-kga64hvg.js

@@ -0,0 +1,90 @@
+import {
+  createDBClient
+} from "./chunk-41rc1bhg.js";
+
+// src/core/search.ts
+function escapeFtsQuery(query) {
+  const escaped = query.replace(/"/g, '""').trim();
+  if (!escaped)
+    return "";
+  const words = escaped.split(/\s+/).filter((w) => w.length > 0);
+  if (words.length === 0)
+    return "";
+  return words.map((w) => `"${w}"*`).join(" OR ");
+}
+function createSearchEngine(dbPathOrClient) {
+  const client = typeof dbPathOrClient === "string" ? createDBClient(dbPathOrClient) : dbPathOrClient;
+  return {
+    search(query, options = {}) {
+      const { limit = 10, layer = 1, since, types, projectPath } = options;
+      const escapedQuery = escapeFtsQuery(query);
+      if (!escapedQuery)
+        return [];
+      const whereClauses = [];
+      const params = [];
+      if (since) {
+        whereClauses.push("o.created_at >= ?");
+        params.push(since.toISOString());
+      }
+      if (types && types.length > 0) {
+        const placeholders = types.map(() => "?").join(", ");
+        whereClauses.push(`o.type IN (${placeholders})`);
+        params.push(...types);
+      }
+      if (projectPath) {
+        whereClauses.push("s.project_path = ?");
+        params.push(projectPath);
+      }
+      const whereClause = whereClauses.length > 0 ? `AND ${whereClauses.join(" AND ")}` : "";
+      const sql = `
+        SELECT
+          o.id,
+          o.session_id,
+          o.type,
+          o.tool_name,
+          o.content,
+          o.importance,
+          o.created_at,
+          s.project_path,
+          bm25(observations_fts) as score
+        FROM observations_fts fts
+        JOIN observations o ON fts.rowid = o.rowid
+        JOIN sessions s ON o.session_id = s.id
+        WHERE observations_fts MATCH ?
+        ${whereClause}
+        ORDER BY score
+        LIMIT ?
+      `;
+      params.unshift(escapedQuery);
+      params.push(limit);
+      const rows = client.db.prepare(sql).all(...params);
+      return rows.map((row) => {
+        const normalizedScore = Math.abs(row.score);
+        const result = {
+          id: row.id,
+          score: normalizedScore
+        };
+        result.summary = row.content.slice(0, 100) + (row.content.length > 100 ? "..." : "");
+        if (layer >= 2) {
+          result.createdAt = new Date(row.created_at);
+          result.sessionId = row.session_id;
+          result.type = row.type;
+          result.toolName = row.tool_name ?? undefined;
+        }
+        if (layer >= 3) {
+          result.content = row.content;
+          result.metadata = {
+            importance: row.importance,
+            projectPath: row.project_path
+          };
+        }
+        return result;
+      });
+    },
+    close() {
+      client.close();
+    }
+  };
+}
+
+export { createSearchEngine };

package/dist/chunk-ns0dgdnb.js

@@ -0,0 +1,21 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __toESM, __commonJS, __require };

package/dist/chunk-v8anyhk1.js

@@ -0,0 +1,103 @@
+import {
+  createDBClient
+} from "./chunk-41rc1bhg.js";
+
+// src/core/store.ts
+function toSession(dbSession) {
+  return {
+    id: dbSession.id,
+    projectPath: dbSession.project_path,
+    startedAt: new Date(dbSession.started_at),
+    endedAt: dbSession.ended_at ? new Date(dbSession.ended_at) : null,
+    summary: dbSession.summary,
+    tokenCount: dbSession.token_count
+  };
+}
+function toObservation(dbObs) {
+  return {
+    id: dbObs.id,
+    sessionId: dbObs.session_id,
+    type: dbObs.type,
+    toolName: dbObs.tool_name,
+    content: dbObs.content,
+    importance: dbObs.importance,
+    createdAt: new Date(dbObs.created_at)
+  };
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function createMemoryStore(dbPathOrClient) {
+  const client = typeof dbPathOrClient === "string" ? createDBClient(dbPathOrClient) : dbPathOrClient;
+  let currentSessionId = null;
+  let tokenCount = 0;
+  return {
+    createSession(projectPath) {
+      const dbSession = client.createSession({ project_path: projectPath });
+      currentSessionId = dbSession.id;
+      tokenCount = 0;
+      return toSession(dbSession);
+    },
+    getCurrentSession() {
+      if (!currentSessionId)
+        return null;
+      const dbSession = client.getSession(currentSessionId);
+      if (!dbSession) {
+        currentSessionId = null;
+        return null;
+      }
+      return toSession(dbSession);
+    },
+    endSession(summary) {
+      if (!currentSessionId)
+        return;
+      client.updateSession(currentSessionId, { token_count: tokenCount });
+      client.endSession(currentSessionId, summary);
+      currentSessionId = null;
+      tokenCount = 0;
+    },
+    addObservation(obs) {
+      if (!currentSessionId) {
+        throw new Error("No active session. Call createSession first.");
+      }
+      const dbObs = client.createObservation({
+        session_id: currentSessionId,
+        type: obs.type,
+        tool_name: obs.toolName,
+        content: obs.content,
+        importance: obs.importance
+      });
+      tokenCount += estimateTokens(obs.content);
+      return toObservation(dbObs);
+    },
+    getObservation(id) {
+      const dbObs = client.getObservation(id);
+      return dbObs ? toObservation(dbObs) : null;
+    },
+    getRecentObservations(limit = 50) {
+      if (!currentSessionId)
+        return [];
+      const dbObservations = client.listObservations(currentSessionId, limit);
+      return dbObservations.map(toObservation);
+    },
+    summarizeAndDelete(before) {
+      const beforeISO = before.toISOString();
+      const oldObservations = client.db.prepare(`
+        SELECT id FROM observations
+        WHERE created_at < ?
+      `).all(beforeISO);
+      for (const obs of oldObservations) {
+        client.deleteObservation(obs.id);
+      }
+      return oldObservations.length;
+    },
+    getTokenCount() {
+      return tokenCount;
+    },
+    close() {
+      client.close();
+    }
+  };
+}
+
+export { estimateTokens, createMemoryStore };

package/dist/chunk-w40c0y00.js

@@ -0,0 +1,36 @@
+// src/core/db/paths.ts
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { mkdirSync, existsSync } from "fs";
+function getGlobalConfigDir() {
+  const configDir = join(homedir(), ".config", "ralph-mem");
+  return configDir;
+}
+function getProjectDataDir(projectPath) {
+  return join(resolve(projectPath), ".ralph-mem");
+}
+function getProjectDBPath(projectPath) {
+  return join(getProjectDataDir(projectPath), "memory.db");
+}
+function getSnapshotsDir(projectPath) {
+  return join(getProjectDataDir(projectPath), "snapshots");
+}
+function getBackupsDir(projectPath) {
+  return join(getProjectDataDir(projectPath), "backups");
+}
+function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+function ensureProjectDirs(projectPath) {
+  const dataDir = getProjectDataDir(projectPath);
+  const snapshotsDir = getSnapshotsDir(projectPath);
+  const backupsDir = getBackupsDir(projectPath);
+  ensureDir(dataDir);
+  ensureDir(snapshotsDir);
+  ensureDir(backupsDir);
+  return { dataDir, snapshotsDir, backupsDir };
+}
+
+export { getGlobalConfigDir, getProjectDataDir, getProjectDBPath, ensureProjectDirs };

package/dist/hooks/post-tool-use.js

@@ -0,0 +1,155 @@
+import {
+  loadConfig
+} from "../chunk-c3a91ngd.js";
+import {
+  createDBClient
+} from "../chunk-41rc1bhg.js";
+import {
+  ensureProjectDirs,
+  getProjectDBPath
+} from "../chunk-w40c0y00.js";
+import"../chunk-ns0dgdnb.js";
+
+// src/hooks/post-tool-use.ts
+var RECORDABLE_TOOLS = new Set([
+  "Edit",
+  "Write",
+  "Bash",
+  "NotebookEdit",
+  "MultiEdit"
+]);
+var READ_ONLY_TOOLS = new Set([
+  "Read",
+  "Glob",
+  "Grep",
+  "LS",
+  "WebFetch",
+  "WebSearch"
+]);
+function shouldRecordTool(toolName) {
+  if (RECORDABLE_TOOLS.has(toolName)) {
+    return true;
+  }
+  if (READ_ONLY_TOOLS.has(toolName)) {
+    return false;
+  }
+  return true;
+}
+function getObservationType(toolName, success) {
+  if (!success) {
+    return "error";
+  }
+  if (toolName === "Bash") {
+    return "bash";
+  }
+  return "tool_use";
+}
+function calculateImportance(context) {
+  if (!context.success) {
+    return 1;
+  }
+  const output = String(context.toolOutput || "").toLowerCase();
+  if (context.toolName === "Bash" && (output.includes("test") || output.includes("passed") || output.includes("failed"))) {
+    return 0.9;
+  }
+  if (context.toolName === "Edit" || context.toolName === "Write" || context.toolName === "NotebookEdit") {
+    return 0.7;
+  }
+  return 0.5;
+}
+function formatOutput(output, maxLength = 2000) {
+  const str = typeof output === "string" ? output : JSON.stringify(output);
+  if (str.length <= maxLength) {
+    return str;
+  }
+  return `${str.slice(0, maxLength)}... [truncated]`;
+}
+function shouldExclude(content, patterns) {
+  for (const pattern of patterns) {
+    const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
+    const regex = new RegExp(regexPattern, "i");
+    if (regex.test(content)) {
+      return true;
+    }
+  }
+  return false;
+}
+function maskSensitiveData(content) {
+  let masked = content;
+  masked = masked.replace(/([a-zA-Z_]*(?:api|key|token|secret|password)[a-zA-Z_]*[\s:=]+)['"]?([a-zA-Z0-9_\-]{20,})['"]?/gi, "$1[MASKED]");
+  masked = masked.replace(/Bearer\s+[a-zA-Z0-9_\-\.]+/gi, "Bearer [MASKED]");
+  masked = masked.replace(/^([A-Z_]+_(?:KEY|SECRET|TOKEN|PASSWORD))\s*=\s*.+$/gm, "$1=[MASKED]");
+  return masked;
+}
+async function postToolUseHook(context, options) {
+  const { toolName, sessionId, projectPath, success } = context;
+  if (!shouldRecordTool(toolName)) {
+    return {
+      observationId: null,
+      recorded: false,
+      type: null,
+      importance: 0
+    };
+  }
+  const config = options?.config ? { ...loadConfig(projectPath), ...options.config } : loadConfig(projectPath);
+  let content = formatOutput(context.toolOutput);
+  if (context.error) {
+    content = `Error: ${context.error}
+${content}`;
+  }
+  if (shouldExclude(content, config.privacy.exclude_patterns)) {
+    return {
+      observationId: null,
+      recorded: false,
+      type: null,
+      importance: 0
+    };
+  }
+  content = maskSensitiveData(content);
+  const type = getObservationType(toolName, success);
+  const importance = calculateImportance(context);
+  ensureProjectDirs(projectPath);
+  const dbPath = getProjectDBPath(projectPath);
+  const client = options?.client ?? createDBClient(dbPath);
+  const session = client.getSession(sessionId);
+  if (!session || session.ended_at) {
+    if (!options?.client) {
+      client.close();
+    }
+    return {
+      observationId: null,
+      recorded: false,
+      type: null,
+      importance: 0
+    };
+  }
+  const observation = client.createObservation({
+    session_id: sessionId,
+    type,
+    tool_name: toolName,
+    content,
+    importance,
+    loop_run_id: context.loopContext?.runId,
+    iteration: context.loopContext?.iteration
+  });
+  if (!options?.client) {
+    client.close();
+  }
+  return {
+    observationId: observation.id,
+    recorded: true,
+    type,
+    importance
+  };
+}
+export {
+  shouldRecordTool,
+  shouldExclude,
+  postToolUseHook,
+  maskSensitiveData,
+  getObservationType,
+  formatOutput,
+  calculateImportance
+};
+
+export { postToolUseHook };

package/dist/hooks/session-end.js

@@ -0,0 +1,89 @@
+import {
+  createMemoryStore
+} from "../chunk-v8anyhk1.js";
+import {
+  createDBClient
+} from "../chunk-41rc1bhg.js";
+import {
+  ensureProjectDirs,
+  getProjectDBPath
+} from "../chunk-w40c0y00.js";
+import"../chunk-ns0dgdnb.js";
+
+// src/hooks/session-end.ts
+function generateSummary(observations) {
+  if (observations.length === 0) {
+    return { summary: "세션에서 기록된 작업이 없습니다.", toolStats: {} };
+  }
+  const typeCounts = {};
+  const toolStats = {};
+  for (const obs of observations) {
+    typeCounts[obs.type] = (typeCounts[obs.type] || 0) + 1;
+    if (obs.tool_name) {
+      toolStats[obs.tool_name] = (toolStats[obs.tool_name] || 0) + 1;
+    }
+  }
+  const parts = [];
+  const toolEntries = Object.entries(toolStats);
+  if (toolEntries.length > 0) {
+    const topTools = toolEntries.sort((a, b) => b[1] - a[1]).slice(0, 3).map(([name, count]) => `${name}(${count})`).join(", ");
+    parts.push(`주요 도구: ${topTools}`);
+  }
+  if (typeCounts.error && typeCounts.error > 0) {
+    parts.push(`에러 ${typeCounts.error}건 발생`);
+  }
+  if (typeCounts.success && typeCounts.success > 0) {
+    parts.push(`성공 ${typeCounts.success}건`);
+  }
+  const notes = observations.filter((o) => o.type === "note");
+  if (notes.length > 0) {
+    const lastNote = notes[notes.length - 1];
+    const notePreview = lastNote.content.slice(0, 50) + (lastNote.content.length > 50 ? "..." : "");
+    parts.push(`마지막 메모: ${notePreview}`);
+  }
+  const summary = parts.length > 0 ? parts.join(". ") : `작업 ${observations.length}건 처리`;
+  return { summary, toolStats };
+}
+async function sessionEndHook(context, options) {
+  const { sessionId, projectPath, reason = "user" } = context;
+  ensureProjectDirs(projectPath);
+  const dbPath = getProjectDBPath(projectPath);
+  const client = options?.client ?? createDBClient(dbPath);
+  const store = options?.store ?? createMemoryStore(client);
+  const session = client.getSession(sessionId);
+  if (!session) {
+    return {
+      summary: "",
+      observationCount: 0,
+      tokenCount: 0,
+      toolStats: {}
+    };
+  }
+  if (session.ended_at) {
+    return {
+      summary: session.summary || "",
+      observationCount: 0,
+      tokenCount: session.token_count,
+      toolStats: {}
+    };
+  }
+  const observations = client.listObservations(sessionId, 1000);
+  const { summary, toolStats } = generateSummary(observations);
+  const finalSummary = reason !== "user" ? `[${reason}] ${summary}` : summary;
+  client.endSession(sessionId, finalSummary);
+  const updatedSession = client.getSession(sessionId);
+  if (!options?.client) {
+    client.close();
+  }
+  return {
+    summary: finalSummary,
+    observationCount: observations.length,
+    tokenCount: updatedSession?.token_count ?? 0,
+    toolStats
+  };
+}
+export {
+  sessionEndHook,
+  generateSummary
+};
+export { sessionEndHook };

package/dist/hooks/session-start.js

@@ -0,0 +1,95 @@
+import {
+  loadConfig
+} from "../chunk-c3a91ngd.js";
+import {
+  createMemoryStore,
+  estimateTokens
+} from "../chunk-v8anyhk1.js";
+import {
+  createDBClient
+} from "../chunk-41rc1bhg.js";
+import {
+  ensureProjectDirs,
+  getProjectDBPath
+} from "../chunk-w40c0y00.js";
+import"../chunk-ns0dgdnb.js";
+
+// src/hooks/session-start.ts
+import { copyFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+function backupDatabase(projectPath) {
+  const dbPath = getProjectDBPath(projectPath);
+  if (!existsSync(dbPath)) {
+    return;
+  }
+  const dirs = ensureProjectDirs(projectPath);
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupPath = join(dirs.backupsDir, `memory-${timestamp}.db`);
+  copyFileSync(dbPath, backupPath);
+  return backupPath;
+}
+function formatSessionContext(sessions, maxTokens) {
+  if (sessions.length === 0) {
+    return { context: "", tokenCount: 0 };
+  }
+  const lines = ["\uD83D\uDCDD 이전 세션 컨텍스트:"];
+  let tokenCount = estimateTokens(lines[0]);
+  for (const session of sessions) {
+    if (!session.summary)
+      continue;
+    const date = new Date(session.started_at).toLocaleDateString("ko-KR", {
+      month: "numeric",
+      day: "numeric"
+    });
+    const line = `- [${date}] ${session.summary}`;
+    const lineTokens = estimateTokens(line);
+    if (tokenCount + lineTokens > maxTokens) {
+      break;
+    }
+    lines.push(line);
+    tokenCount += lineTokens;
+  }
+  if (lines.length === 1) {
+    return { context: "", tokenCount: 0 };
+  }
+  return {
+    context: lines.join(`
+`),
+    tokenCount
+  };
+}
+async function sessionStartHook(context, options) {
+  const { projectPath } = context;
+  const config = options?.config ? { ...loadConfig(projectPath), ...options.config } : loadConfig(projectPath);
+  const backupPath = backupDatabase(projectPath);
+  const dbPath = getProjectDBPath(projectPath);
+  ensureProjectDirs(projectPath);
+  const client = options?.client ?? createDBClient(dbPath);
+  const store = options?.store ?? createMemoryStore(client);
+  const previousSessions = client.listSessions(projectPath, 10);
+  const session = store.createSession(projectPath);
+  let injectedContext = "";
+  let tokenCount = 0;
+  if (config.memory.auto_inject) {
+    const sessionsWithSummary = previousSessions.filter((s) => s.summary);
+    const formatted = formatSessionContext(sessionsWithSummary, config.memory.max_inject_tokens);
+    injectedContext = formatted.context;
+    tokenCount = formatted.tokenCount;
+  }
+  if (!options?.client) {}
+  return {
+    sessionId: session.id,
+    injectedContext,
+    tokenCount,
+    metadata: {
+      previousSessions: previousSessions.length,
+      backupPath
+    }
+  };
+}
+export {
+  sessionStartHook,
+  formatSessionContext,
+  backupDatabase
+};
+export { sessionStartHook };