ralph-mem 0.1.0

package/dist/skills/mem-search.js

@@ -0,0 +1,303 @@
+import {
+  createSearchEngine
+} from "../chunk-kga64hvg.js";
+import {
+  createDBClient
+} from "../chunk-41rc1bhg.js";
+import {
+  ensureProjectDirs,
+  getProjectDBPath
+} from "../chunk-w40c0y00.js";
+import"../chunk-ns0dgdnb.js";
+
+// src/skills/mem-search.ts
+function parseSince(since) {
+  const relativeMatch = since.match(/^(\d+)d$/);
+  if (relativeMatch) {
+    const days = Number.parseInt(relativeMatch[1], 10);
+    const date2 = new Date;
+    date2.setDate(date2.getDate() - days);
+    return date2;
+  }
+  const date = new Date(since);
+  if (!Number.isNaN(date.getTime())) {
+    return date;
+  }
+  return null;
+}
+function parseType(type) {
+  const validTypes = [
+    "note",
+    "tool_use",
+    "bash",
+    "error",
+    "success"
+  ];
+  const types = type.split(",").map((t) => t.trim().toLowerCase());
+  return types.filter((t) => validTypes.includes(t));
+}
+function formatTable(results) {
+  if (results.length === 0) {
+    return "검색 결과가 없습니다.";
+  }
+  const lines = [];
+  lines.push("┌────────────────┬───────┬─────────────────────────────────────┐");
+  lines.push("│ ID             │ 점수  │ 요약                                │");
+  lines.push("├────────────────┼───────┼─────────────────────────────────────┤");
+  for (const result of results) {
+    const id = result.id.slice(0, 14).padEnd(14);
+    const score = result.score.toFixed(2).padStart(5);
+    const summary = (result.summary || "(없음)").slice(0, 35).padEnd(35);
+    lines.push(`│ ${id} │ ${score} │ ${summary} │`);
+  }
+  lines.push("└────────────────┴───────┴─────────────────────────────────────┘");
+  return lines.join(`
+`);
+}
+function formatTimeline(results) {
+  if (results.length === 0) {
+    return "검색 결과가 없습니다.";
+  }
+  const lines = [];
+  for (const result of results) {
+    const date = result.createdAt ? result.createdAt.toLocaleDateString("ko-KR", {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    }) : "날짜 없음";
+    const type = result.type || "unknown";
+    const tool = result.toolName ? ` (${result.toolName})` : "";
+    lines.push(`\uD83D\uDCCC ${result.id}`);
+    lines.push(`   날짜: ${date}`);
+    lines.push(`   유형: ${type}${tool}`);
+    lines.push(`   점수: ${result.score.toFixed(2)}`);
+    lines.push(`   요약: ${result.summary || "(없음)"}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function formatDetail(result) {
+  const lines = [];
+  lines.push(`\uD83D\uDCC4 ${result.id} 상세`);
+  lines.push("");
+  if (result.createdAt) {
+    const date = result.createdAt.toLocaleDateString("ko-KR", {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+    lines.push(`세션: ${date}`);
+  }
+  if (result.sessionId) {
+    lines.push(`세션 ID: ${result.sessionId}`);
+  }
+  lines.push(`유형: ${result.type || "unknown"}`);
+  if (result.toolName) {
+    lines.push(`도구: ${result.toolName}`);
+  }
+  lines.push(`점수: ${result.score.toFixed(4)}`);
+  if (result.metadata) {
+    lines.push(`중요도: ${result.metadata.importance || 0.5}`);
+    if (result.metadata.projectPath) {
+      lines.push(`프로젝트: ${result.metadata.projectPath}`);
+    }
+  }
+  lines.push("");
+  lines.push("내용:");
+  lines.push("─".repeat(60));
+  lines.push(result.content || result.summary || "(내용 없음)");
+  lines.push("─".repeat(60));
+  return lines.join(`
+`);
+}
+function formatDetails(results) {
+  if (results.length === 0) {
+    return "검색 결과가 없습니다.";
+  }
+  return results.map(formatDetail).join(`
+
+`);
+}
+async function memSearchSkill(input, options) {
+  const { query, projectPath, layer = 1, limit = 10, since, type, id } = input;
+  ensureProjectDirs(projectPath);
+  const dbPath = getProjectDBPath(projectPath);
+  const client = options?.client ?? createDBClient(dbPath);
+  const engine = options?.engine ?? createSearchEngine(client);
+  if (id) {
+    const observation = client.getObservation(id);
+    if (!options?.client) {
+      client.close();
+    }
+    if (!observation) {
+      return {
+        results: [],
+        totalCount: 0,
+        layer: 3,
+        formatted: `ID '${id}'를 찾을 수 없습니다.`
+      };
+    }
+    const result = {
+      id: observation.id,
+      score: 1,
+      summary: observation.content.slice(0, 100),
+      createdAt: new Date(observation.created_at),
+      sessionId: observation.session_id,
+      type: observation.type,
+      toolName: observation.tool_name ?? undefined,
+      content: observation.content,
+      metadata: {
+        importance: observation.importance
+      }
+    };
+    return {
+      results: [result],
+      totalCount: 1,
+      layer: 3,
+      formatted: formatDetail(result)
+    };
+  }
+  const searchOptions = {
+    limit,
+    layer,
+    projectPath
+  };
+  if (since) {
+    const sinceDate = parseSince(since);
+    if (sinceDate) {
+      searchOptions.since = sinceDate;
+    }
+  }
+  if (type) {
+    const types = parseType(type);
+    if (types.length > 0) {
+      searchOptions.types = types;
+    }
+  }
+  let results = [];
+  try {
+    results = engine.search(query, searchOptions);
+  } catch {
+    if (!options?.client) {
+      client.close();
+    }
+    return {
+      results: [],
+      totalCount: 0,
+      layer,
+      formatted: "검색 중 오류가 발생했습니다."
+    };
+  }
+  if (!options?.client) {
+    client.close();
+  }
+  let formatted;
+  if (layer === 1) {
+    formatted = `\uD83D\uDD0D 검색 결과: "${query}" (${results.length}건)
+
+${formatTable(results)}`;
+  } else if (layer === 2) {
+    formatted = `\uD83D\uDD0D 검색 결과: "${query}" (${results.length}건)
+
+${formatTimeline(results)}`;
+  } else {
+    formatted = `\uD83D\uDD0D 검색 결과: "${query}" (${results.length}건)
+
+${formatDetails(results)}`;
+  }
+  return {
+    results,
+    totalCount: results.length,
+    layer,
+    formatted
+  };
+}
+function parseArgs(argsString, projectPath) {
+  const args = {
+    query: "",
+    projectPath
+  };
+  const tokens = [];
+  let current = "";
+  let inQuotes = false;
+  for (const char of argsString) {
+    if (char === '"' || char === "'") {
+      inQuotes = !inQuotes;
+    } 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 === "--layer" && i + 1 < tokens.length) {
+      const layerNum = Number.parseInt(tokens[i + 1], 10);
+      if (layerNum >= 1 && layerNum <= 3) {
+        args.layer = layerNum;
+      }
+      i += 2;
+    } else if (token === "--limit" && i + 1 < tokens.length) {
+      args.limit = Number.parseInt(tokens[i + 1], 10);
+      i += 2;
+    } else if (token === "--since" && i + 1 < tokens.length) {
+      args.since = tokens[i + 1];
+      i += 2;
+    } else if (token === "--type" && i + 1 < tokens.length) {
+      args.type = tokens[i + 1];
+      i += 2;
+    } else if (token.startsWith("obs-")) {
+      args.id = token;
+      args.layer = 3;
+      i++;
+    } else if (!token.startsWith("--")) {
+      args.query = args.query ? `${args.query} ${token}` : token;
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return args;
+}
+async function executeMemSearch(argsString, projectPath, options) {
+  const input = parseArgs(argsString, projectPath);
+  if (!input.query && !input.id) {
+    return `사용법: /mem-search <query> [options]
+
+옵션:
+  --layer <1|2|3>  상세 수준 (기본: 1)
+  --since <7d|30d|YYYY-MM-DD>  기간 필터
+  --type <error|success|bash|tool_use|note>  유형 필터
+  --limit <n>  결과 수 제한
+
+예시:
+  /mem-search "JWT authentication"
+  /mem-search --layer 3 obs-a1b2c3d4
+  /mem-search "database" --since 7d --type error`;
+  }
+  const result = await memSearchSkill(input, options);
+  return result.formatted;
+}
+export {
+  parseType,
+  parseSince,
+  parseArgs,
+  memSearchSkill,
+  formatTimeline,
+  formatTable,
+  formatDetails,
+  formatDetail,
+  executeMemSearch
+};
+
+export { memSearchSkill };

package/dist/skills/mem-status.js

@@ -0,0 +1,200 @@
+import {
+  getProjectDBPath
+} from "../chunk-w40c0y00.js";
+import"../chunk-ns0dgdnb.js";
+
+// src/skills/mem-status.ts
+import { existsSync, statSync } from "node:fs";
+
+// src/utils/tokens.ts
+var CHARS_PER_TOKEN_EN = 4;
+var CHARS_PER_TOKEN_KO = 1.5;
+var CHARS_PER_TOKEN_CODE = 3.5;
+function isKorean(char) {
+  const code = char.charCodeAt(0);
+  return code >= 44032 && code <= 55203 || code >= 4352 && code <= 4607 || code >= 12592 && code <= 12687;
+}
+function isCodeLike(text) {
+  const codePatterns = [
+    /\bfunction\b/,
+    /\bconst\b/,
+    /\blet\b/,
+    /\bvar\b/,
+    /\bclass\b/,
+    /\bimport\b/,
+    /\bexport\b/,
+    /\breturn\b/,
+    /\bif\s*\(/,
+    /\bfor\s*\(/,
+    /\bwhile\s*\(/,
+    /=>/,
+    /\{\s*$/m,
+    /^\s*\}/m,
+    /\[\s*$/m,
+    /^\s*\]/m,
+    /;\s*$/m
+  ];
+  let matches = 0;
+  for (const pattern of codePatterns) {
+    if (pattern.test(text)) {
+      matches++;
+    }
+  }
+  return matches >= 3;
+}
+function estimateTokens(text) {
+  if (!text)
+    return 0;
+  if (isCodeLike(text)) {
+    return Math.ceil(text.length / CHARS_PER_TOKEN_CODE);
+  }
+  let koreanChars = 0;
+  let otherChars = 0;
+  for (const char of text) {
+    if (isKorean(char)) {
+      koreanChars++;
+    } else {
+      otherChars++;
+    }
+  }
+  const koreanTokens = Math.ceil(koreanChars / CHARS_PER_TOKEN_KO);
+  const otherTokens = Math.ceil(otherChars / CHARS_PER_TOKEN_EN);
+  return koreanTokens + otherTokens;
+}
+function countTokens(text) {
+  return estimateTokens(text);
+}
+
+// src/skills/mem-status.ts
+function getDBSize(projectPath) {
+  try {
+    const dbPath = getProjectDBPath(projectPath);
+    if (!existsSync(dbPath)) {
+      return 0;
+    }
+    const stats = statSync(dbPath);
+    return Number((stats.size / (1024 * 1024)).toFixed(2));
+  } catch {
+    return 0;
+  }
+}
+function getRecentSessionCount(client, days) {
+  const cutoff = new Date;
+  cutoff.setDate(cutoff.getDate() - days);
+  const cutoffStr = cutoff.toISOString();
+  const result = client.db.prepare("SELECT COUNT(*) as count FROM sessions WHERE started_at >= ?").get(cutoffStr);
+  return result.count;
+}
+function getSessionTokenUsage(client, sessionId) {
+  const observations = client.listObservations(sessionId);
+  let totalTokens = 0;
+  for (const obs of observations) {
+    const content = obs.content_compressed || obs.content;
+    totalTokens += countTokens(content);
+  }
+  return totalTokens;
+}
+function getLoopStats(client, sessionId) {
+  const runs = client.listLoopRuns(sessionId, 100);
+  const total = runs.length;
+  if (total === 0) {
+    return { total: 0, successRate: 0 };
+  }
+  const successful = runs.filter((r) => r.status === "success").length;
+  const successRate = Math.round(successful / total * 100);
+  return { total, successRate };
+}
+function isLoopActive(client, sessionId) {
+  const runs = client.listLoopRuns(sessionId, 1);
+  return runs.length > 0 && runs[0].status === "running";
+}
+function getMemStatus(context) {
+  const { projectPath, sessionId, client, contextBudget = 1e5 } = context;
+  const allSessions = client.db.prepare("SELECT COUNT(*) as count FROM sessions").get();
+  const recentSessions = getRecentSessionCount(client, 30);
+  const allObservations = client.db.prepare("SELECT COUNT(*) as count FROM observations").get();
+  const dbSizeMB = getDBSize(projectPath);
+  const currentTokens = getSessionTokenUsage(client, sessionId);
+  const budgetPercent = Math.round(currentTokens / contextBudget * 100);
+  const loopStats = getLoopStats(client, sessionId);
+  const loopActive = isLoopActive(client, sessionId);
+  const configPath = `${projectPath}/.ralph-mem/config.yaml`;
+  return {
+    sessions: {
+      total: allSessions.count,
+      recent: recentSessions
+    },
+    observations: {
+      total: allObservations.count
+    },
+    storage: {
+      dbSizeMB
+    },
+    tokens: {
+      currentSession: currentTokens,
+      budgetUsed: currentTokens,
+      budgetPercent
+    },
+    loop: {
+      isActive: loopActive,
+      totalRuns: loopStats.total,
+      successRate: loopStats.successRate
+    },
+    configPath: existsSync(configPath) ? configPath : null
+  };
+}
+function formatNumber(n) {
+  return n.toLocaleString();
+}
+function formatMemStatus(status) {
+  const loopStatus = status.loop.isActive ? "실행 중" : "비활성";
+  return `\uD83D\uDCCA ralph-mem 상태
+
+메모리:
+├─ 세션: ${status.sessions.total}개 (최근 30일: ${status.sessions.recent}개)
+├─ 관찰: ${formatNumber(status.observations.total)}개
+└─ 용량: ${status.storage.dbSizeMB} MB
+
+토큰:
+├─ 현재 세션: ${formatNumber(status.tokens.currentSession)} tokens
+├─ Budget: ${formatNumber(status.tokens.budgetUsed)} tokens (${status.tokens.budgetPercent}%)
+└─ 사용률: ${status.tokens.budgetPercent}%
+
+Loop:
+├─ 현재: ${loopStatus}
+├─ 총 실행: ${status.loop.totalRuns}회
+└─ 성공률: ${status.loop.successRate}%
+
+설정: ${status.configPath || "(없음)"}`;
+}
+async function executeMemStatus(context) {
+  const status = getMemStatus(context);
+  return formatMemStatus(status);
+}
+function createMemStatusSkill(context) {
+  return {
+    name: "/mem-status",
+    async execute() {
+      return executeMemStatus(context);
+    },
+    getStatus() {
+      return getMemStatus(context);
+    }
+  };
+}
+async function memStatusSkill(_input) {
+  return {
+    sessionCount: 0,
+    observationCount: 0,
+    totalTokens: 0
+  };
+}
+export {
+  memStatusSkill,
+  getMemStatus,
+  formatMemStatus,
+  executeMemStatus,
+  createMemStatusSkill
+};
+
+export { memStatusSkill };