ralph-mem 0.1.0

package/dist/hooks/user-prompt-submit.js

@@ -0,0 +1,234 @@
+import {
+  loadConfig
+} from "../chunk-c3a91ngd.js";
+import {
+  estimateTokens
+} from "../chunk-v8anyhk1.js";
+import {
+  createSearchEngine
+} from "../chunk-kga64hvg.js";
+import {
+  createDBClient
+} from "../chunk-41rc1bhg.js";
+import {
+  ensureProjectDirs,
+  getProjectDBPath
+} from "../chunk-w40c0y00.js";
+import"../chunk-ns0dgdnb.js";
+
+// src/hooks/user-prompt-submit.ts
+var STOPWORDS = new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "has",
+  "he",
+  "in",
+  "is",
+  "it",
+  "its",
+  "of",
+  "on",
+  "or",
+  "that",
+  "the",
+  "to",
+  "was",
+  "were",
+  "will",
+  "with",
+  "this",
+  "they",
+  "but",
+  "have",
+  "not",
+  "what",
+  "when",
+  "where",
+  "who",
+  "which",
+  "why",
+  "how",
+  "all",
+  "each",
+  "she",
+  "do",
+  "if",
+  "my",
+  "their",
+  "then",
+  "so",
+  "than",
+  "too",
+  "very",
+  "can",
+  "just",
+  "should",
+  "now",
+  "i",
+  "you",
+  "we",
+  "me",
+  "은",
+  "는",
+  "이",
+  "가",
+  "을",
+  "를",
+  "의",
+  "에",
+  "에서",
+  "으로",
+  "로",
+  "와",
+  "과",
+  "도",
+  "만",
+  "까지",
+  "부터",
+  "처럼",
+  "같이",
+  "please",
+  "help",
+  "show",
+  "tell",
+  "explain",
+  "find",
+  "get",
+  "make",
+  "create",
+  "해줘",
+  "해주세요",
+  "알려줘",
+  "보여줘"
+]);
+function extractKeywords(prompt) {
+  const tokens = prompt.toLowerCase().split(/[\s,.;:!?()[\]{}'"]+/).filter((t) => t.length >= 2);
+  const keywords = tokens.filter((t) => !STOPWORDS.has(t));
+  return [...new Set(keywords)].slice(0, 5);
+}
+function formatNotification(results) {
+  if (results.length === 0) {
+    return "";
+  }
+  const lines = ["\uD83D\uDD0D 관련 메모리 발견:"];
+  for (const result of results.slice(0, 3)) {
+    const date = result.createdAt ? result.createdAt.toLocaleDateString("ko-KR", {
+      month: "numeric",
+      day: "numeric"
+    }) : "";
+    const score = result.score.toFixed(2);
+    const summary = result.summary || "(요약 없음)";
+    lines.push(`- ${summary.slice(0, 40)}${summary.length > 40 ? "..." : ""} (${date}, 관련도: ${score})`);
+  }
+  if (results.length > 3) {
+    lines.push(`  외 ${results.length - 3}건...`);
+  }
+  lines.push("상세 조회: /mem-search --layer 3 <id>");
+  return lines.join(`
+`);
+}
+function formatContext(results, maxTokens) {
+  if (results.length === 0) {
+    return { context: "", tokenCount: 0 };
+  }
+  const lines = ["\uD83D\uDCDD 관련 기억:"];
+  let tokenCount = estimateTokens(lines[0]);
+  for (const result of results) {
+    const date = result.createdAt ? result.createdAt.toLocaleDateString("ko-KR", {
+      month: "numeric",
+      day: "numeric"
+    }) : "";
+    const content = result.content || result.summary || "";
+    const preview = content.slice(0, 200) + (content.length > 200 ? "..." : "");
+    const line = `- [${date}] ${preview}`;
+    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 userPromptSubmitHook(context, options) {
+  const { prompt, projectPath } = context;
+  const keywords = extractKeywords(prompt);
+  if (keywords.length === 0) {
+    return {
+      notification: "",
+      injectedContext: "",
+      tokenCount: 0,
+      relatedMemories: []
+    };
+  }
+  const config = options?.config ? { ...loadConfig(projectPath), ...options.config } : loadConfig(projectPath);
+  ensureProjectDirs(projectPath);
+  const dbPath = getProjectDBPath(projectPath);
+  const client = options?.client ?? createDBClient(dbPath);
+  const engine = options?.engine ?? createSearchEngine(client);
+  const searchQuery = keywords.join(" ");
+  const searchOptions = {
+    limit: config.search.default_limit,
+    layer: 2,
+    projectPath
+  };
+  let results = [];
+  try {
+    results = engine.search(searchQuery, searchOptions);
+  } catch {
+    if (!options?.client) {
+      client.close();
+    }
+    return {
+      notification: "",
+      injectedContext: "",
+      tokenCount: 0,
+      relatedMemories: []
+    };
+  }
+  const notification = formatNotification(results);
+  let injectedContext = "";
+  let tokenCount = 0;
+  if (config.memory.auto_inject && results.length > 0) {
+    const fullResults = engine.search(searchQuery, {
+      ...searchOptions,
+      layer: 3,
+      limit: 5
+    });
+    const formatted = formatContext(fullResults, config.memory.max_inject_tokens);
+    injectedContext = formatted.context;
+    tokenCount = formatted.tokenCount;
+  }
+  if (!options?.client) {
+    client.close();
+  }
+  return {
+    notification,
+    injectedContext,
+    tokenCount,
+    relatedMemories: results
+  };
+}
+export {
+  userPromptSubmitHook,
+  formatNotification,
+  formatContext,
+  extractKeywords
+};
+
+export { userPromptSubmitHook };

package/dist/index.js

@@ -0,0 +1,64 @@
+import {
+  ralphSkill
+} from "./skills/ralph.js";
+import {
+  memStatusSkill
+} from "./skills/mem-status.js";
+import {
+  userPromptSubmitHook
+} from "./hooks/user-prompt-submit.js";
+import {
+  postToolUseHook
+} from "./hooks/post-tool-use.js";
+import {
+  sessionStartHook
+} from "./hooks/session-start.js";
+import"./chunk-c3a91ngd.js";
+import {
+  sessionEndHook
+} from "./hooks/session-end.js";
+import {
+  createMemoryStore,
+  estimateTokens
+} from "./chunk-v8anyhk1.js";
+import {
+  memForgetSkill
+} from "./skills/mem-forget.js";
+import {
+  memInjectSkill
+} from "./skills/mem-inject.js";
+import {
+  memSearchSkill
+} from "./skills/mem-search.js";
+import {
+  createSearchEngine
+} from "./chunk-kga64hvg.js";
+import"./chunk-41rc1bhg.js";
+import"./chunk-w40c0y00.js";
+import"./chunk-ns0dgdnb.js";
+
+// src/index.ts
+var VERSION = "0.1.0";
+async function activate() {
+  console.log(`ralph-mem v${VERSION} activated`);
+}
+async function deactivate() {
+  console.log("ralph-mem deactivated");
+}
+export {
+  userPromptSubmitHook,
+  sessionStartHook,
+  sessionEndHook,
+  ralphSkill,
+  postToolUseHook,
+  memStatusSkill,
+  memSearchSkill,
+  memInjectSkill,
+  memForgetSkill,
+  estimateTokens,
+  deactivate,
+  createSearchEngine,
+  createMemoryStore,
+  activate,
+  VERSION
+};

package/dist/skills/mem-forget.js

@@ -0,0 +1,192 @@
+import"../chunk-ns0dgdnb.js";
+
+// src/skills/mem-forget.ts
+function parseBefore(before) {
+  const isoDate = new Date(before);
+  if (!Number.isNaN(isoDate.getTime())) {
+    return isoDate;
+  }
+  const match = before.match(/^(\d+)d$/);
+  if (match) {
+    const days = Number.parseInt(match[1], 10);
+    const date = new Date;
+    date.setDate(date.getDate() - days);
+    return date;
+  }
+  return null;
+}
+function parseMemForgetArgs(argsString) {
+  const args = {};
+  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 === "--session" && i + 1 < tokens.length) {
+      args.sessionId = tokens[i + 1];
+      i += 2;
+    } else if (token === "--before" && i + 1 < tokens.length) {
+      args.before = tokens[i + 1];
+      i += 2;
+    } else if (token === "--confirm") {
+      args.confirm = true;
+      i++;
+    } else if (!token.startsWith("--") && !args.id) {
+      args.id = token;
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return args;
+}
+function formatPreviewMessage(targets) {
+  if (targets.length === 0) {
+    return "삭제 대상 없음";
+  }
+  const lines = targets.slice(0, 5).map((t) => {
+    const content = t.content.length > 40 ? `${t.content.slice(0, 37)}...` : t.content;
+    return `- ${t.id}: ${content}`;
+  });
+  if (targets.length > 5) {
+    lines.push(`... 외 ${targets.length - 5}개`);
+  }
+  return `⚠️ 삭제 대상:
+${lines.join(`
+`)}
+
+삭제하려면: /mem-forget ${targets[0].id} --confirm`;
+}
+function formatSuccessMessage(deletedCount) {
+  return `✅ 삭제됨: ${deletedCount}개 observation`;
+}
+function getTargets(client, args, currentSessionId) {
+  if (args.id) {
+    const obs = client.getObservation(args.id);
+    return obs ? [obs] : [];
+  }
+  if (args.sessionId) {
+    return client.listObservations(args.sessionId, 1000);
+  }
+  if (args.before) {
+    const date = parseBefore(args.before);
+    if (!date) {
+      return [];
+    }
+    const dateStr = date.toISOString();
+    const rows = client.db.prepare(`
+				SELECT * FROM observations
+				WHERE session_id = ? AND created_at < ?
+				ORDER BY created_at ASC
+			`).all(currentSessionId, dateStr);
+    return rows;
+  }
+  return [];
+}
+function deleteObservations(client, ids) {
+  if (ids.length === 0)
+    return 0;
+  let deleted = 0;
+  for (const id of ids) {
+    const result = client.db.prepare("DELETE FROM observations WHERE id = ?").run(id);
+    deleted += result.changes;
+  }
+  return deleted;
+}
+function forgetMemory(context, args) {
+  const { sessionId, client } = context;
+  if (!args.id && !args.sessionId && !args.before) {
+    return {
+      success: false,
+      deletedCount: 0,
+      message: "",
+      error: "삭제 대상을 지정해주세요. 사용법: /mem-forget <id> 또는 --before <일수>d"
+    };
+  }
+  const targets = getTargets(client, args, sessionId);
+  if (targets.length === 0) {
+    return {
+      success: false,
+      deletedCount: 0,
+      message: "삭제 대상 없음"
+    };
+  }
+  if (!args.confirm) {
+    const targetSummary = targets.map((t) => ({
+      id: t.id,
+      content: t.content
+    }));
+    return {
+      success: false,
+      deletedCount: 0,
+      targets: targetSummary,
+      message: formatPreviewMessage(targetSummary),
+      requiresConfirmation: true
+    };
+  }
+  const ids = targets.map((t) => t.id);
+  const deletedCount = deleteObservations(client, ids);
+  return {
+    success: true,
+    deletedCount,
+    message: formatSuccessMessage(deletedCount)
+  };
+}
+function createMemForgetSkill(context) {
+  return {
+    name: "/mem-forget",
+    execute(args) {
+      return forgetMemory(context, args);
+    },
+    parseArgs(argsString) {
+      return parseMemForgetArgs(argsString);
+    }
+  };
+}
+async function executeMemForget(argsString, context) {
+  const args = parseMemForgetArgs(argsString);
+  const result = forgetMemory(context, args);
+  if (result.error) {
+    return `❌ ${result.error}`;
+  }
+  return result.message;
+}
+async function memForgetSkill(_input) {
+  return {
+    success: false,
+    deletedCount: 0,
+    message: "Use createMemForgetSkill() for full functionality"
+  };
+}
+export {
+  parseMemForgetArgs,
+  memForgetSkill,
+  formatSuccessMessage,
+  formatPreviewMessage,
+  forgetMemory,
+  executeMemForget,
+  createMemForgetSkill
+};
+
+export { memForgetSkill };

package/dist/skills/mem-inject.js

@@ -0,0 +1,130 @@
+import"../chunk-ns0dgdnb.js";
+
+// src/skills/mem-inject.ts
+var DEFAULT_IMPORTANCE = 0.7;
+function parseMemInjectArgs(argsString) {
+  const args = {
+    content: ""
+  };
+  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 === "--importance" && i + 1 < tokens.length) {
+      const value = Number.parseFloat(tokens[i + 1]);
+      if (!Number.isNaN(value) && value >= 0 && value <= 1) {
+        args.importance = value;
+      }
+      i += 2;
+    } else if (token === "--type" && i + 1 < tokens.length) {
+      const typeValue = tokens[i + 1].toLowerCase();
+      if (typeValue === "note" || typeValue === "context") {
+        args.type = typeValue;
+      }
+      i += 2;
+    } else if (!token.startsWith("--") && !args.content) {
+      args.content = token;
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return args;
+}
+function formatInjectSuccess(observationId, content, importance) {
+  const displayContent = content.length > 100 ? `${content.slice(0, 97)}...` : content;
+  return `✅ 메모리에 추가됨
+
+ID: ${observationId}
+내용: ${displayContent}
+중요도: ${importance}`;
+}
+function injectMemory(context, args) {
+  const { sessionId, client } = context;
+  if (!args.content || args.content.trim() === "") {
+    return {
+      success: false,
+      message: "",
+      error: '내용이 필요합니다. 사용법: /mem-inject "내용"'
+    };
+  }
+  const importance = args.importance ?? DEFAULT_IMPORTANCE;
+  const type = "note";
+  try {
+    const observation = client.createObservation({
+      session_id: sessionId,
+      type,
+      content: args.content.trim(),
+      importance
+    });
+    const message = formatInjectSuccess(observation.id, observation.content, importance);
+    return {
+      success: true,
+      observationId: observation.id,
+      message
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: "",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function createMemInjectSkill(context) {
+  return {
+    name: "/mem-inject",
+    execute(args) {
+      return injectMemory(context, args);
+    },
+    parseArgs(argsString) {
+      return parseMemInjectArgs(argsString);
+    }
+  };
+}
+async function executeMemInject(argsString, context) {
+  const args = parseMemInjectArgs(argsString);
+  const result = injectMemory(context, args);
+  if (!result.success) {
+    return `❌ ${result.error}`;
+  }
+  return result.message;
+}
+async function memInjectSkill(_input) {
+  return {
+    success: false,
+    message: "Use createMemInjectSkill() for full functionality"
+  };
+}
+export {
+  parseMemInjectArgs,
+  memInjectSkill,
+  injectMemory,
+  formatInjectSuccess,
+  executeMemInject,
+  createMemInjectSkill
+};
+
+export { memInjectSkill };