@hir4ta/mneme 0.22.0 → 0.22.3

package/servers/db-server.ts

@@ -76,45 +76,8 @@ const LIST_LIMIT_MIN = 1;
 const LIST_LIMIT_MAX = 200;
 const INTERACTION_OFFSET_MIN = 0;
 const QUERY_MAX_LENGTH = 500;
-const UNIT_LIMIT_MAX = 500;
 const SEARCH_EVAL_DEFAULT_LIMIT = 5;
 
-type UnitStatus = "pending" | "approved" | "rejected";
-type UnitType = "decision" | "pattern" | "rule";
-type RuleKind = "policy" | "pitfall" | "playbook";
-
-interface Unit {
-  id: string;
-  type: UnitType;
-  kind: RuleKind;
-  title: string;
-  summary: string;
-  tags: string[];
-  sourceId: string;
-  sourceType: UnitType;
-  sourceRefs: Array<{ type: UnitType; id: string }>;
-  status: UnitStatus;
-  createdAt: string;
-  updatedAt: string;
-  reviewedAt?: string;
-  reviewedBy?: string;
-}
-
-interface UnitsFile {
-  schemaVersion: number;
-  updatedAt: string;
-  items: Unit[];
-}
-
-interface AuditEntry {
-  timestamp: string;
-  actor?: string;
-  entity: "session" | "decision" | "pattern" | "rule" | "unit";
-  action: "create" | "update" | "delete";
-  targetId: string;
-  detail?: Record<string, unknown>;
-}
-
 interface RuleDoc {
   items?: Array<Record<string, unknown>>;
   rules?: Array<Record<string, unknown>>;
@@ -170,25 +133,6 @@ function listJsonFiles(dir: string): string[] {
   });
 }
 
-function readUnits(): UnitsFile {
-  const unitsPath = path.join(getMnemeDir(), "units", "units.json");
-  const parsed = readJsonFile<UnitsFile>(unitsPath);
-  if (!parsed || !Array.isArray(parsed.items)) {
-    return {
-      schemaVersion: 1,
-      updatedAt: new Date().toISOString(),
-      items: [],
-    };
-  }
-  return parsed;
-}
-
-function writeUnits(doc: UnitsFile): void {
-  const unitsPath = path.join(getMnemeDir(), "units", "units.json");
-  fs.mkdirSync(path.dirname(unitsPath), { recursive: true });
-  fs.writeFileSync(unitsPath, JSON.stringify(doc, null, 2));
-}
-
 function readRuleItems(
   ruleType: "dev-rules" | "review-guidelines",
 ): Array<Record<string, unknown>> {
@@ -198,42 +142,6 @@ function readRuleItems(
   return Array.isArray(items) ? items : [];
 }
 
-function readAuditEntries(
-  options: { from?: string; to?: string; entity?: string } = {},
-): AuditEntry[] {
-  const auditDir = path.join(getMnemeDir(), "audit");
-  if (!fs.existsSync(auditDir)) return [];
-
-  const files = fs
-    .readdirSync(auditDir)
-    .filter((name) => name.endsWith(".jsonl"))
-    .sort();
-  const fromTime = options.from ? new Date(options.from).getTime() : null;
-  const toTime = options.to ? new Date(options.to).getTime() : null;
-
-  const entries: AuditEntry[] = [];
-  for (const name of files) {
-    const fullPath = path.join(auditDir, name);
-    const lines = fs.readFileSync(fullPath, "utf-8").split("\n");
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      try {
-        const parsed = JSON.parse(line) as AuditEntry;
-        const ts = new Date(parsed.timestamp).getTime();
-        if (fromTime !== null && ts < fromTime) continue;
-        if (toTime !== null && ts > toTime) continue;
-        if (options.entity && parsed.entity !== options.entity) continue;
-        entries.push(parsed);
-      } catch {
-        // skip malformed lines
-      }
-    }
-  }
-  return entries.sort(
-    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime(),
-  );
-}
-
 function readSessionsById(): Map<string, Record<string, unknown>> {
   const sessionsDir = path.join(getMnemeDir(), "sessions");
   const map = new Map<string, Record<string, unknown>>();
@@ -246,107 +154,6 @@ function readSessionsById(): Map<string, Record<string, unknown>> {
   return map;
 }
 
-function inferUnitPriority(unit: Unit): "p0" | "p1" | "p2" {
-  if (unit.sourceType === "rule") {
-    const [ruleFile, ruleId] = unit.sourceId.split(":", 2);
-    if (
-      (ruleFile === "dev-rules" || ruleFile === "review-guidelines") &&
-      ruleId
-    ) {
-      const rule = readRuleItems(ruleFile).find((item) => item.id === ruleId);
-      const priority =
-        typeof rule?.priority === "string" ? rule.priority.toLowerCase() : "";
-      if (priority === "p0" || priority === "p1" || priority === "p2") {
-        return priority;
-      }
-    }
-  }
-  const text =
-    `${unit.title} ${unit.summary} ${unit.tags.join(" ")}`.toLowerCase();
-  if (
-    /(security|auth|token|secret|password|injection|xss|csrf|compliance|outage|data[- ]?loss)/.test(
-      text,
-    )
-  ) {
-    return "p0";
-  }
-  if (/(crash|error|correct|reliab|timeout|retry|integrity)/.test(text)) {
-    return "p1";
-  }
-  return "p2";
-}
-
-function extractChangedFilesFromDiff(diffText: string): string[] {
-  const files = new Set<string>();
-  const lines = diffText.split("\n");
-  for (const line of lines) {
-    if (!line.startsWith("diff --git ")) continue;
-    const parts = line.split(" ");
-    if (parts.length >= 4) {
-      const bPath = parts[3].replace(/^b\//, "");
-      if (bPath) files.add(bPath);
-    }
-  }
-  return Array.from(files);
-}
-
-function scoreUnitAgainstDiff(
-  unit: Unit,
-  diffText: string,
-  changedFiles: string[],
-): { score: number; reasons: string[] } {
-  const reasons: string[] = [];
-  let score = 0;
-  const corpus = `${unit.title} ${unit.summary}`.toLowerCase();
-  const diffLower = diffText.toLowerCase();
-
-  for (const tag of unit.tags) {
-    if (!tag) continue;
-    const tagLower = tag.toLowerCase();
-    if (diffLower.includes(tagLower)) {
-      score += 3;
-      reasons.push(`tag:${tag}`);
-    }
-  }
-
-  const keywords = corpus
-    .split(/[^a-zA-Z0-9_-]+/)
-    .filter((token) => token.length >= 5)
-    .slice(0, 20);
-  for (const token of keywords) {
-    if (diffLower.includes(token)) {
-      score += 1;
-      reasons.push(`keyword:${token}`);
-    }
-  }
-
-  for (const filePath of changedFiles) {
-    const lower = filePath.toLowerCase();
-    if (corpus.includes("test") && lower.includes("test")) {
-      score += 1;
-      reasons.push("path:test");
-    }
-    if (
-      (corpus.includes("api") || unit.tags.includes("api")) &&
-      (lower.includes("api") || lower.includes("route"))
-    ) {
-      score += 1;
-      reasons.push("path:api");
-    }
-    if (
-      (corpus.includes("db") || corpus.includes("sql")) &&
-      (lower.includes("db") ||
-        lower.includes("prisma") ||
-        lower.includes("migration"))
-    ) {
-      score += 1;
-      reasons.push("path:db");
-    }
-  }
-
-  return { score, reasons: Array.from(new Set(reasons)) };
-}
-
 // Database connection (lazy initialization)
 let db: DatabaseSyncType | null = null;
 
@@ -1009,6 +816,17 @@ async function saveInteractions(
     id: `int-${String(idx + 1).padStart(3, "0")}`,
   }));
 
+  // Guard: don't delete existing data when there's nothing to insert
+  if (finalInteractions.length === 0) {
+    return {
+      success: true,
+      savedCount: 0,
+      mergedFromBackup: backupInteractions.length,
+      message:
+        "No interactions to save (transcript may have no text user messages). Existing data preserved.",
+    };
+  }
+
   // Delete existing interactions for this session
   try {
     const deleteStmt = database.prepare(
@@ -1227,26 +1045,6 @@ function runSearchBenchmark(limit = SEARCH_EVAL_DEFAULT_LIMIT): {
   };
 }
 
-function buildUnitGraph(units: Unit[]) {
-  const approved = units.filter((unit) => unit.status === "approved");
-  const edges: Array<{ source: string; target: string; weight: number }> = [];
-  for (let i = 0; i < approved.length; i++) {
-    for (let j = i + 1; j < approved.length; j++) {
-      const shared = approved[i].tags.filter((tag) =>
-        approved[j].tags.includes(tag),
-      );
-      if (shared.length > 0) {
-        edges.push({
-          source: approved[i].id,
-          target: approved[j].id,
-          weight: shared.length,
-        });
-      }
-    }
-  }
-  return { nodes: approved, edges };
-}
-
 // MCP Server setup
 const server = new McpServer({
   name: "mneme-db",
@@ -1422,160 +1220,177 @@ server.registerTool(
   },
 );
 
-// Tool: mneme_mark_session_committed
+// Tool: mneme_update_session_summary
 server.registerTool(
-  "mneme_mark_session_committed",
+  "mneme_update_session_summary",
   {
     description:
-      "Mark a session as committed (saved with /mneme:save). " +
-      "This prevents the session's interactions from being deleted on SessionEnd. " +
-      "Call this after successfully saving session data.",
+      "Update session JSON file with summary data. " +
+      "MUST be called during /mneme:save Phase 3 to persist session metadata. " +
+      "Creates the session file if it does not exist (e.g. when SessionStart hook was skipped).",
     inputSchema: {
       claudeSessionId: z
         .string()
         .min(8)
         .describe("Full Claude Code session UUID (36 chars)"),
+      title: z.string().describe("Session title"),
+      summary: z
+        .object({
+          goal: z.string().describe("What the session aimed to accomplish"),
+          outcome: z.string().describe("What was actually accomplished"),
+          description: z
+            .string()
+            .optional()
+            .describe("Detailed description of the session"),
+        })
+        .describe("Session summary object"),
+      tags: z
+        .array(z.string())
+        .optional()
+        .describe("Semantic tags for the session"),
+      sessionType: z
+        .string()
+        .optional()
+        .describe(
+          "Session type (e.g. implementation, research, bugfix, refactor)",
+        ),
     },
   },
-  async ({ claudeSessionId }) => {
+  async ({ claudeSessionId, title, summary, tags, sessionType }) => {
     if (!claudeSessionId.trim()) {
       return fail("claudeSessionId must not be empty.");
     }
-    const success = markSessionCommitted(claudeSessionId);
-    return {
-      ...ok(JSON.stringify({ success, claudeSessionId }, null, 2)),
-      isError: !success,
-    };
-  },
-);
 
-// Tool: mneme_unit_queue_list_pending
-server.registerTool(
-  "mneme_unit_queue_list_pending",
-  {
-    description:
-      "List pending units in the approval queue. Use this in save/review flows to surface actionable approvals.",
-    inputSchema: {
-      limit: z
-        .number()
-        .int()
-        .min(LIST_LIMIT_MIN)
-        .max(UNIT_LIMIT_MAX)
-        .optional()
-        .describe(
-          `Maximum items (${LIST_LIMIT_MIN}-${UNIT_LIMIT_MAX}, default: 100)`,
-        ),
-    },
-  },
-  async ({ limit }) => {
-    const units = readUnits()
-      .items.filter((item) => item.status === "pending")
-      .sort(
-        (a, b) =>
-          new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime(),
-      )
-      .slice(0, limit ?? 100);
-    return ok(
-      JSON.stringify(
-        {
-          count: units.length,
-          items: units,
+    const projectPath = getProjectPath();
+    const sessionsDir = path.join(projectPath, ".mneme", "sessions");
+    const shortId = claudeSessionId.slice(0, 8);
+
+    // Find existing session file
+    let sessionFile: string | null = null;
+    const searchDir = (dir: string): string | null => {
+      if (!fs.existsSync(dir)) return null;
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          const result = searchDir(fullPath);
+          if (result) return result;
+        } else if (entry.name === `${shortId}.json`) {
+          return fullPath;
+        }
+      }
+      return null;
+    };
+    sessionFile = searchDir(sessionsDir);
+
+    // Create session file if not found (SessionStart hook may not have run)
+    if (!sessionFile) {
+      const now = new Date();
+      const yearMonth = path.join(
+        sessionsDir,
+        String(now.getFullYear()),
+        String(now.getMonth() + 1).padStart(2, "0"),
+      );
+      if (!fs.existsSync(yearMonth)) {
+        fs.mkdirSync(yearMonth, { recursive: true });
+      }
+      sessionFile = path.join(yearMonth, `${shortId}.json`);
+      // Write minimal session JSON
+      const initial = {
+        id: shortId,
+        sessionId: claudeSessionId,
+        createdAt: now.toISOString(),
+        title: "",
+        tags: [],
+        context: {
+          projectDir: projectPath,
+          projectName: path.basename(projectPath),
         },
-        null,
-        2,
-      ),
-    );
-  },
-);
-
-// Tool: mneme_unit_queue_update_status
-server.registerTool(
-  "mneme_unit_queue_update_status",
-  {
-    description:
-      "Update unit status (approve/reject/pending) in bulk or single item.",
-    inputSchema: {
-      unitIds: z.array(z.string().min(1)).min(1).describe("Target unit IDs"),
-      status: z
-        .enum(["pending", "approved", "rejected"])
-        .describe("New status"),
-      reviewedBy: z.string().optional().describe("Reviewer name (optional)"),
-    },
-  },
-  async ({ unitIds, status, reviewedBy }) => {
-    const doc = readUnits();
-    const target = new Set(unitIds);
-    const now = new Date().toISOString();
-    let updated = 0;
-    doc.items = doc.items.map((item) => {
-      if (!target.has(item.id)) return item;
-      updated += 1;
-      return {
-        ...item,
-        status,
-        reviewedAt: now,
-        reviewedBy,
-        updatedAt: now,
+        metrics: {
+          userMessages: 0,
+          assistantResponses: 0,
+          thinkingBlocks: 0,
+          toolUsage: [],
+        },
+        files: [],
+        status: null,
       };
-    });
-    doc.updatedAt = now;
-    writeUnits(doc);
-    return ok(
-      JSON.stringify(
-        { updated, status, requested: unitIds.length, updatedAt: now },
-        null,
-        2,
-      ),
-    );
-  },
-);
+      fs.writeFileSync(sessionFile, JSON.stringify(initial, null, 2));
+    }
 
-// Tool: mneme_unit_apply_suggest_for_diff
-server.registerTool(
-  "mneme_unit_apply_suggest_for_diff",
-  {
-    description:
-      "Suggest top approved units for a given git diff text. Intended for automatic review integration.",
-    inputSchema: {
-      diff: z.string().min(1).describe("Unified diff text"),
-      limit: z
-        .number()
-        .int()
-        .min(LIST_LIMIT_MIN)
-        .max(50)
-        .optional()
-        .describe("Maximum suggested units (default: 10)"),
-    },
-  },
-  async ({ diff, limit }) => {
-    const changedFiles = extractChangedFilesFromDiff(diff);
-    const approved = readUnits().items.filter(
-      (item) => item.status === "approved",
-    );
-    const scored = approved
-      .map((unit) => {
-        const { score, reasons } = scoreUnitAgainstDiff(
-          unit,
-          diff,
-          changedFiles,
-        );
-        return { unit, score, reasons };
-      })
-      .filter((item) => item.score > 0)
-      .sort((a, b) => b.score - a.score)
-      .slice(0, limit ?? 10);
+    // Read, update, write
+    const data = readJsonFile<Record<string, unknown>>(sessionFile) ?? {};
+    data.title = title;
+    data.summary = summary;
+    data.updatedAt = new Date().toISOString();
+    if (tags) data.tags = tags;
+    if (sessionType) data.sessionType = sessionType;
+
+    // Enrich with transcript metrics/files if available
+    const transcriptPath = getTranscriptPath(claudeSessionId);
+    if (transcriptPath) {
+      try {
+        const parsed = await parseTranscript(transcriptPath);
+        data.metrics = {
+          userMessages: parsed.metrics.userMessages,
+          assistantResponses: parsed.metrics.assistantResponses,
+          thinkingBlocks: parsed.metrics.thinkingBlocks,
+          toolUsage: parsed.toolUsage,
+        };
+        if (parsed.files.length > 0) {
+          data.files = parsed.files;
+        }
+      } catch {
+        // Transcript parse failed, keep existing values
+      }
+    }
+
+    // Enrich context if minimal (missing repository info)
+    const ctx = data.context as Record<string, unknown> | undefined;
+    if (ctx && !ctx.repository) {
+      try {
+        const { execSync } = await import("node:child_process");
+        const cwd = (ctx.projectDir as string) || projectPath;
+        const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+          encoding: "utf8",
+          cwd,
+        }).trim();
+        if (branch) ctx.branch = branch;
+        const remoteUrl = execSync("git remote get-url origin", {
+          encoding: "utf8",
+          cwd,
+        }).trim();
+        const repoMatch = remoteUrl.match(/[:/]([^/]+\/[^/]+?)(\.git)?$/);
+        if (repoMatch) ctx.repository = repoMatch[1].replace(/\.git$/, "");
+        const userName = execSync("git config user.name", {
+          encoding: "utf8",
+          cwd,
+        }).trim();
+        const userEmail = execSync("git config user.email", {
+          encoding: "utf8",
+          cwd,
+        }).trim();
+        if (userName)
+          ctx.user = {
+            name: userName,
+            ...(userEmail ? { email: userEmail } : {}),
+          };
+      } catch {
+        // Not a git repo or git not available
+      }
+    }
+
+    fs.writeFileSync(sessionFile, JSON.stringify(data, null, 2));
+
+    // Auto-commit: mark session as committed after successful summary write
+    // This ensures committed flag is set even if mneme_mark_session_committed is not called explicitly
+    markSessionCommitted(claudeSessionId);
 
     return ok(
       JSON.stringify(
         {
-          changedFiles,
-          suggestions: scored.map((item) => ({
-            id: item.unit.id,
-            title: item.unit.title,
-            score: item.score,
-            reasons: item.reasons,
-            source: `${item.unit.sourceType}:${item.unit.sourceId}`,
-          })),
+          success: true,
+          sessionFile: sessionFile.replace(projectPath, "."),
+          shortId,
         },
         null,
         2,
@@ -1584,35 +1399,30 @@ server.registerTool(
   },
 );
 
-// Tool: mneme_unit_apply_explain_match
+// Tool: mneme_mark_session_committed
 server.registerTool(
-  "mneme_unit_apply_explain_match",
+  "mneme_mark_session_committed",
   {
-    description: "Explain why a specific unit matches a diff.",
+    description:
+      "Mark a session as committed (saved with /mneme:save). " +
+      "This prevents the session's interactions from being deleted on SessionEnd. " +
+      "Call this after successfully saving session data.",
     inputSchema: {
-      unitId: z.string().min(1).describe("Unit ID"),
-      diff: z.string().min(1).describe("Unified diff text"),
+      claudeSessionId: z
+        .string()
+        .min(8)
+        .describe("Full Claude Code session UUID (36 chars)"),
     },
   },
-  async ({ unitId, diff }) => {
-    const unit = readUnits().items.find((item) => item.id === unitId);
-    if (!unit) return fail(`Unit not found: ${unitId}`);
-    const changedFiles = extractChangedFilesFromDiff(diff);
-    const scored = scoreUnitAgainstDiff(unit, diff, changedFiles);
-    return ok(
-      JSON.stringify(
-        {
-          unitId,
-          title: unit.title,
-          score: scored.score,
-          reasons: scored.reasons,
-          priority: inferUnitPriority(unit),
-          changedFiles,
-        },
-        null,
-        2,
-      ),
-    );
+  async ({ claudeSessionId }) => {
+    if (!claudeSessionId.trim()) {
+      return fail("claudeSessionId must not be empty.");
+    }
+    const success = markSessionCommitted(claudeSessionId);
+    return {
+      ...ok(JSON.stringify({ success, claudeSessionId }, null, 2)),
+      isError: !success,
+    };
   },
 );
 
@@ -1815,83 +1625,6 @@ server.registerTool(
   },
 );
 
-// Tool: mneme_graph_insights
-server.registerTool(
-  "mneme_graph_insights",
-  {
-    description:
-      "Compute graph insights from approved units: central units, tag communities, orphan units.",
-    inputSchema: {
-      limit: z
-        .number()
-        .int()
-        .min(LIST_LIMIT_MIN)
-        .max(100)
-        .optional()
-        .describe("Limit for ranked outputs (default: 10)"),
-    },
-  },
-  async ({ limit }) => {
-    const k = limit ?? 10;
-    const units = readUnits().items.filter(
-      (item) => item.status === "approved",
-    );
-    const graph = buildUnitGraph(units);
-    const degree = new Map<string, number>();
-    for (const unit of graph.nodes) degree.set(unit.id, 0);
-    for (const edge of graph.edges) {
-      degree.set(edge.source, (degree.get(edge.source) || 0) + 1);
-      degree.set(edge.target, (degree.get(edge.target) || 0) + 1);
-    }
-
-    const topCentral = graph.nodes
-      .map((unit) => ({
-        id: unit.id,
-        title: unit.title,
-        degree: degree.get(unit.id) || 0,
-      }))
-      .sort((a, b) => b.degree - a.degree)
-      .slice(0, k);
-
-    const tagCounts = new Map<string, number>();
-    for (const unit of graph.nodes) {
-      for (const tag of unit.tags) {
-        tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
-      }
-    }
-    const communities = Array.from(tagCounts.entries())
-      .map(([tag, count]) => ({
-        tag,
-        count,
-      }))
-      .sort((a, b) => b.count - a.count)
-      .slice(0, k);
-
-    const orphans = graph.nodes
-      .filter((unit) => (degree.get(unit.id) || 0) === 0)
-      .map((unit) => ({
-        id: unit.id,
-        title: unit.title,
-        tags: unit.tags,
-      }))
-      .slice(0, k);
-
-    return ok(
-      JSON.stringify(
-        {
-          approvedUnits: graph.nodes.length,
-          edges: graph.edges.length,
-          topCentral,
-          tagCommunities: communities,
-          orphanUnits: orphans,
-        },
-        null,
-        2,
-      ),
-    );
-  },
-);
-
 // Tool: mneme_search_eval
 server.registerTool(
   "mneme_search_eval",
@@ -1954,74 +1687,6 @@ server.registerTool(
   },
 );
 
-// Tool: mneme_audit_query
-server.registerTool(
-  "mneme_audit_query",
-  {
-    description: "Query unit-related audit logs and summarize change history.",
-    inputSchema: {
-      from: z.string().optional().describe("Start ISO date/time"),
-      to: z.string().optional().describe("End ISO date/time"),
-      targetId: z.string().optional().describe("Filter by target unit ID"),
-      summaryMode: z
-        .enum(["changes", "actors", "target"])
-        .optional()
-        .describe(
-          "changes=list, actors=aggregate by actor, target=single target history",
-        ),
-    },
-  },
-  async ({ from, to, targetId, summaryMode }) => {
-    const entries = readAuditEntries({ from, to, entity: "unit" }).filter(
-      (entry) => (targetId ? entry.targetId === targetId : true),
-    );
-
-    if ((summaryMode || "changes") === "actors") {
-      const byActor = new Map<string, number>();
-      for (const entry of entries) {
-        const actor = entry.actor || "unknown";
-        byActor.set(actor, (byActor.get(actor) || 0) + 1);
-      }
-      return ok(
-        JSON.stringify(
-          {
-            total: entries.length,
-            actors: Array.from(byActor.entries())
-              .map(([actor, count]) => ({ actor, count }))
-              .sort((a, b) => b.count - a.count),
-          },
-          null,
-          2,
-        ),
-      );
-    }
-
-    if ((summaryMode || "changes") === "target" && targetId) {
-      return ok(
-        JSON.stringify(
-          {
-            targetId,
-            history: entries,
-          },
-          null,
-          2,
-        ),
-      );
-    }
-
-    return ok(
-      JSON.stringify(
-        {
-          total: entries.length,
-          changes: entries,
-        },
-        null,
-        2,
-      ),
-    );
-  },
-);
-
 // Start server
 async function main() {
   const transport = new StdioServerTransport();