@hir4ta/mneme 0.24.0 → 0.24.1

package/hooks/user-prompt-submit.sh

@@ -53,8 +53,18 @@ if [ -z "$search_script" ]; then
   exit 0
 fi
 
+# Detect changed files for file-based session recommendation
+changed_files=""
+if command -v git >/dev/null 2>&1 && git -C "$cwd" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  changed_files=$(cd "$cwd" && {
+    git diff --name-only HEAD 2>/dev/null
+    git diff --name-only --cached 2>/dev/null
+  } | sort -u | head -20 | paste -sd "," - 2>/dev/null || echo "")
+fi
+
 search_output=$(invoke_node "$search_script" \
-  --query "$prompt" --project "$cwd" --limit 5 2>/dev/null || echo "")
+  --query "$prompt" --project "$cwd" --limit 5 \
+  ${changed_files:+--files "$changed_files"} 2>/dev/null || echo "")
 
 if [ -z "$search_output" ]; then
   exit 0
@@ -75,11 +85,32 @@ context_lines=$(echo "$search_output" | jq -r '
   | join("\n")
 ')
 
-if [ -n "$context_lines" ] && [ "$context_lines" != "null" ]; then
+# Format file-based session recommendations
+file_rec_lines=$(echo "$search_output" | jq -r '
+  .fileRecommendations // []
+  | .[:3]
+  | map("[session:\(.sessionId)] \(.title) | files: \(.matchedFiles | join(", "))")
+  | join("\n")
+')
+
+if [ -n "$context_lines" ] && [ "$context_lines" != "null" ] || \
+   [ -n "$file_rec_lines" ] && [ "$file_rec_lines" != "null" ]; then
+  context_parts=""
+  if [ -n "$context_lines" ] && [ "$context_lines" != "null" ]; then
+    context_parts="Related context found (sessions/units):
+${context_lines}"
+  fi
+  if [ -n "$file_rec_lines" ] && [ "$file_rec_lines" != "null" ]; then
+    if [ -n "$context_parts" ]; then
+      context_parts="${context_parts}
+"
+    fi
+    context_parts="${context_parts}Related sessions (editing same files):
+${file_rec_lines}"
+  fi
   context_message="<mneme-context>
-Related context found (sessions/units):
-${context_lines}
-Use /mneme:search for details.
+${context_parts}
+To explore deeper: use /mneme:search with specific technical terms, error messages, or file paths.
 </mneme-context>"
 fi
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hir4ta/mneme",
-  "version": "0.24.0",
+  "version": "0.24.1",
   "description": "Long-term memory plugin for Claude Code - automated session saving, recording technical decisions, and web dashboard",
   "keywords": [
     "claude",

package/servers/db/save.ts

@@ -39,7 +39,7 @@ export async function saveInteractions(
   }
 
   const projectPath = getProjectPath();
-  const sessionId = mnemeSessionId || claudeSessionId.slice(0, 8);
+  const sessionId = mnemeSessionId || claudeSessionId;
 
   let owner = "unknown";
   try {
@@ -251,7 +251,7 @@ export function markSessionCommitted(claudeSessionId: string): boolean {
       stmt.run(claudeSessionId);
     } else {
       const projectPath = getProjectPath();
-      const sessionId = claudeSessionId.slice(0, 8);
+      const sessionId = claudeSessionId;
       const insertStmt = database.prepare(`
         INSERT INTO session_save_state (claude_session_id, mneme_session_id, project_path, is_committed)
         VALUES (?, ?, ?, 1)

package/servers/db/session-summary.ts

@@ -39,11 +39,13 @@ interface SessionSummaryParams {
     title?: string;
     description?: string;
   }>;
+  filesModified?: Array<{ path: string; action: string }>;
+  technologies?: string[];
 }
 
 async function updateSessionSummary(
   params: SessionSummaryParams,
-): Promise<{ success: boolean; sessionFile: string; shortId: string }> {
+): Promise<{ success: boolean; sessionFile: string; sessionId: string }> {
   const {
     claudeSessionId,
     title,
@@ -55,27 +57,35 @@ async function updateSessionSummary(
     errors,
     handoff,
     references,
+    filesModified,
+    technologies,
   } = params;
 
   const projectPath = getProjectPath();
   const sessionsDir = path.join(projectPath, ".mneme", "sessions");
-  const shortId = claudeSessionId.slice(0, 8);
 
   let sessionFile: string | null = null;
-  const searchDir = (dir: string): string | null => {
+  const searchDirFor = (dir: string, fileName: 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);
+        const result = searchDirFor(fullPath, fileName);
         if (result) return result;
-      } else if (entry.name === `${shortId}.json`) {
+      } else if (entry.name === fileName) {
         return fullPath;
       }
     }
     return null;
   };
-  sessionFile = searchDir(sessionsDir);
+  // Try full UUID first, then fallback to 8-char for old sessions
+  sessionFile = searchDirFor(sessionsDir, `${claudeSessionId}.json`);
+  if (!sessionFile && claudeSessionId.length > 8) {
+    sessionFile = searchDirFor(
+      sessionsDir,
+      `${claudeSessionId.slice(0, 8)}.json`,
+    );
+  }
 
   if (sessionFile) {
     const existingData = readJsonFile<{ sessionId?: string }>(sessionFile);
@@ -92,9 +102,9 @@ async function updateSessionSummary(
       String(now.getMonth() + 1).padStart(2, "0"),
     );
     if (!fs.existsSync(yearMonth)) fs.mkdirSync(yearMonth, { recursive: true });
-    sessionFile = path.join(yearMonth, `${shortId}.json`);
+    sessionFile = path.join(yearMonth, `${claudeSessionId}.json`);
     const initial = {
-      id: shortId,
+      id: claudeSessionId,
       sessionId: claudeSessionId,
       createdAt: now.toISOString(),
       title: "",
@@ -126,6 +136,9 @@ async function updateSessionSummary(
   if (errors && errors.length > 0) data.errors = errors;
   if (handoff) data.handoff = handoff;
   if (references && references.length > 0) data.references = references;
+  if (filesModified && filesModified.length > 0)
+    data.filesModified = filesModified;
+  if (technologies && technologies.length > 0) data.technologies = technologies;
 
   const transcriptPath = getTranscriptPath(claudeSessionId);
   if (transcriptPath) {
@@ -173,7 +186,7 @@ async function updateSessionSummary(
   return {
     success: true,
     sessionFile: sessionFile.replace(projectPath, "."),
-    shortId,
+    sessionId: claudeSessionId,
   };
 }
 
@@ -283,6 +296,21 @@ export function registerSessionSummaryTool(server: McpServer) {
           )
           .optional()
           .describe("Documents and resources referenced during session"),
+        filesModified: z
+          .array(
+            z.object({
+              path: z.string().describe("File path relative to project root"),
+              action: z
+                .string()
+                .describe("Action: create, edit, delete, rename"),
+            }),
+          )
+          .optional()
+          .describe("Files modified during this session"),
+        technologies: z
+          .array(z.string())
+          .optional()
+          .describe("Technologies and frameworks used"),
       },
     },
     async (params) => {

package/servers/db/tools.ts

@@ -57,11 +57,12 @@ export function registerExtendedTools(server: McpServer) {
     },
     async ({ sessionId, includeChain }) => {
       const sessions = readSessionsById();
-      const shortId = sessionId.slice(0, 8);
-      const root = sessions.get(shortId);
-      if (!root) return fail(`Session not found: ${shortId}`);
+      // Dual-key lookup: try as-is first (supports both full UUID and 8-char)
+      const root = sessions.get(sessionId);
+      if (!root) return fail(`Session not found: ${sessionId}`);
 
-      const chain: string[] = [shortId];
+      const rootId = typeof root.id === "string" ? root.id : sessionId;
+      const chain: string[] = [rootId];
       if (includeChain !== false) {
         let current = root;
         let guard = 0;
@@ -104,7 +105,7 @@ export function registerExtendedTools(server: McpServer) {
       return ok(
         JSON.stringify(
           {
-            rootSessionId: shortId,
+            rootSessionId: rootId,
             dbAvailable,
             chainLength: timeline.length,
             timeline,

package/servers/db/utils.ts

@@ -57,6 +57,12 @@ export function readSessionsById(): Map<string, Record<string, unknown>> {
     const id = typeof parsed?.id === "string" ? parsed.id : "";
     if (!id) continue;
     map.set(id, parsed);
+    // Also index by full sessionId for dual-key lookup (old sessions have 8-char id)
+    const sessionId =
+      typeof parsed?.sessionId === "string" ? parsed.sessionId : "";
+    if (sessionId && sessionId !== id) {
+      map.set(sessionId, parsed);
+    }
   }
   return map;
 }

package/servers/db/validate-sources.ts

@@ -0,0 +1,361 @@
+/**
+ * Source artifact validation for mneme MCP Database Server.
+ * Validates decisions, patterns, and rules in .mneme/ directory.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ok } from "./types.js";
+import { getMnemeDir, listJsonFiles } from "./utils.js";
+
+interface ValidationIssue {
+  file: string;
+  message: string;
+}
+
+interface ValidationResult {
+  valid: boolean;
+  issueCount: number;
+  issues: ValidationIssue[];
+}
+
+const RULE_PRIORITIES = new Set(["p0", "p1", "p2"]);
+const PATTERN_TYPES = new Set(["good", "bad", "error-solution"]);
+
+function readJson(filePath: string): Record<string, unknown> {
+  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+
+function hasText(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function hasNonEmptyTags(value: unknown): boolean {
+  return (
+    Array.isArray(value) &&
+    value.length > 0 &&
+    value.every((item) => hasText(item))
+  );
+}
+
+function validateDecisions(mnemeDir: string, issues: ValidationIssue[]): void {
+  const files = listJsonFiles(path.join(mnemeDir, "decisions"));
+  for (const file of files) {
+    let parsed: Record<string, unknown>;
+    try {
+      parsed = readJson(file);
+    } catch (error) {
+      issues.push({ file, message: `Invalid JSON (${String(error)})` });
+      continue;
+    }
+
+    if (!hasText(parsed.id)) issues.push({ file, message: "Missing id" });
+    if (!hasText(parsed.title)) issues.push({ file, message: "Missing title" });
+    if (!hasText(parsed.decision))
+      issues.push({ file, message: "Missing decision" });
+    if (!hasText(parsed.reasoning))
+      issues.push({ file, message: "Missing reasoning" });
+    if (!hasNonEmptyTags(parsed.tags))
+      issues.push({ file, message: "Missing tags (at least one required)" });
+  }
+}
+
+function validatePatterns(mnemeDir: string, issues: ValidationIssue[]): void {
+  const files = listJsonFiles(path.join(mnemeDir, "patterns"));
+  for (const file of files) {
+    let parsed: Record<string, unknown>;
+    try {
+      parsed = readJson(file);
+    } catch (error) {
+      issues.push({ file, message: `Invalid JSON (${String(error)})` });
+      continue;
+    }
+
+    const items = Array.isArray(parsed.items)
+      ? parsed.items
+      : Array.isArray(parsed.patterns)
+        ? parsed.patterns
+        : null;
+
+    if (!items) {
+      issues.push({ file, message: "Missing items/patterns array" });
+      continue;
+    }
+
+    for (const [index, item] of items.entries()) {
+      const pointer = `${file}#${index}`;
+      if (!hasText(item.id))
+        issues.push({ file: pointer, message: "Missing id" });
+      if (!hasText(item.type) || !PATTERN_TYPES.has(item.type)) {
+        issues.push({
+          file: pointer,
+          message: "Invalid type (good|bad|error-solution required)",
+        });
+      }
+      if (item.type === "error-solution") {
+        if (!hasText(item.errorPattern))
+          issues.push({
+            file: pointer,
+            message: "error-solution pattern missing errorPattern",
+          });
+        if (!hasText(item.solution))
+          issues.push({
+            file: pointer,
+            message: "error-solution pattern missing solution",
+          });
+      }
+      if (!hasText(item.title) && !hasText(item.description))
+        issues.push({ file: pointer, message: "Missing title/description" });
+      if (!hasNonEmptyTags(item.tags))
+        issues.push({
+          file: pointer,
+          message: "Missing tags (at least one required)",
+        });
+    }
+  }
+}
+
+function validateRuleFile(
+  file: string,
+  expectedType: string,
+  issues: ValidationIssue[],
+): void {
+  if (!fs.existsSync(file)) return;
+
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = readJson(file);
+  } catch (error) {
+    issues.push({ file, message: `Invalid JSON (${String(error)})` });
+    return;
+  }
+
+  const items = Array.isArray(parsed.items)
+    ? parsed.items
+    : Array.isArray(parsed.rules)
+      ? parsed.rules
+      : null;
+
+  if (!items) {
+    issues.push({ file, message: "Missing items/rules array" });
+    return;
+  }
+
+  if (hasText(parsed.ruleType) && parsed.ruleType !== expectedType) {
+    issues.push({
+      file,
+      message: `ruleType mismatch (${parsed.ruleType} != ${expectedType})`,
+    });
+  }
+
+  for (const [index, item] of items.entries()) {
+    const pointer = `${file}#${index}`;
+    if (!hasText(item.id))
+      issues.push({ file: pointer, message: "Missing id" });
+    if (!hasText(item.key))
+      issues.push({ file: pointer, message: "Missing key" });
+    const text = item.text ?? item.rule ?? item.title;
+    if (!hasText(text))
+      issues.push({ file: pointer, message: "Missing text/rule/title" });
+    if (!hasText(item.category))
+      issues.push({ file: pointer, message: "Missing category" });
+    if (!hasNonEmptyTags(item.tags))
+      issues.push({
+        file: pointer,
+        message: "Missing tags (at least one required)",
+      });
+
+    const status = hasText(item.status) ? item.status : "active";
+    if (status === "active") {
+      if (!hasText(item.priority) || !RULE_PRIORITIES.has(item.priority))
+        issues.push({
+          file: pointer,
+          message: "Missing/invalid priority for active rule (p0|p1|p2)",
+        });
+      if (!hasText(item.rationale))
+        issues.push({
+          file: pointer,
+          message: "Missing rationale for active rule",
+        });
+    }
+  }
+}
+
+function validateRules(mnemeDir: string, issues: ValidationIssue[]): void {
+  validateRuleFile(
+    path.join(mnemeDir, "rules", "dev-rules.json"),
+    "dev-rules",
+    issues,
+  );
+  validateRuleFile(
+    path.join(mnemeDir, "rules", "review-guidelines.json"),
+    "review-guidelines",
+    issues,
+  );
+}
+
+function validateIdUniqueness(
+  mnemeDir: string,
+  issues: ValidationIssue[],
+): void {
+  const idMap = new Map<string, string[]>();
+
+  const track = (id: string, location: string) => {
+    const existing = idMap.get(id) || [];
+    existing.push(location);
+    idMap.set(id, existing);
+  };
+
+  for (const file of listJsonFiles(path.join(mnemeDir, "decisions"))) {
+    try {
+      const parsed = readJson(file);
+      if (hasText(parsed.id)) track(parsed.id, file);
+    } catch {
+      /* skip */
+    }
+  }
+
+  for (const file of listJsonFiles(path.join(mnemeDir, "patterns"))) {
+    try {
+      const parsed = readJson(file);
+      const items =
+        (parsed.items as unknown[]) || (parsed.patterns as unknown[]) || [];
+      for (const item of items as Array<Record<string, unknown>>) {
+        if (hasText(item.id)) track(item.id, `${file}#${item.id}`);
+      }
+    } catch {
+      /* skip */
+    }
+  }
+
+  for (const ruleFile of ["dev-rules", "review-guidelines"]) {
+    const file = path.join(mnemeDir, "rules", `${ruleFile}.json`);
+    if (!fs.existsSync(file)) continue;
+    try {
+      const parsed = readJson(file);
+      const items =
+        (parsed.items as unknown[]) || (parsed.rules as unknown[]) || [];
+      for (const item of items as Array<Record<string, unknown>>) {
+        if (hasText(item.id)) track(item.id, `${file}#${item.id}`);
+      }
+    } catch {
+      /* skip */
+    }
+  }
+
+  for (const [id, files] of idMap) {
+    if (files.length > 1) {
+      issues.push({
+        file: files.join(", "),
+        message: `Duplicate ID "${id}" found in ${files.length} locations`,
+      });
+    }
+  }
+}
+
+function validateTagExistence(
+  mnemeDir: string,
+  issues: ValidationIssue[],
+): void {
+  const tagsPath = path.join(mnemeDir, "tags.json");
+  if (!fs.existsSync(tagsPath)) return;
+
+  let masterTags: Record<string, unknown>;
+  try {
+    masterTags = readJson(tagsPath);
+  } catch {
+    return;
+  }
+
+  const tags = masterTags.tags as Array<Record<string, unknown>> | undefined;
+  const validTagIds = new Set(
+    (tags || []).map((t) => t.id).filter((id) => typeof id === "string"),
+  );
+  if (validTagIds.size === 0) return;
+
+  const checkTags = (fileTags: unknown[], location: string) => {
+    for (const tag of fileTags) {
+      if (typeof tag === "string" && !validTagIds.has(tag)) {
+        issues.push({
+          file: location,
+          message: `Unknown tag "${tag}" (not in tags.json)`,
+        });
+      }
+    }
+  };
+
+  for (const file of listJsonFiles(path.join(mnemeDir, "decisions"))) {
+    try {
+      const parsed = readJson(file);
+      if (Array.isArray(parsed.tags)) checkTags(parsed.tags, file);
+    } catch {
+      /* skip */
+    }
+  }
+
+  for (const file of listJsonFiles(path.join(mnemeDir, "patterns"))) {
+    try {
+      const parsed = readJson(file);
+      const items =
+        (parsed.items as unknown[]) || (parsed.patterns as unknown[]) || [];
+      for (const item of items as Array<Record<string, unknown>>) {
+        if (Array.isArray(item.tags))
+          checkTags(item.tags, `${file}#${item.id || "?"}`);
+      }
+    } catch {
+      /* skip */
+    }
+  }
+
+  for (const ruleFile of ["dev-rules", "review-guidelines"]) {
+    const file = path.join(mnemeDir, "rules", `${ruleFile}.json`);
+    if (!fs.existsSync(file)) continue;
+    try {
+      const parsed = readJson(file);
+      const items =
+        (parsed.items as unknown[]) || (parsed.rules as unknown[]) || [];
+      for (const item of items as Array<Record<string, unknown>>) {
+        if (Array.isArray(item.tags))
+          checkTags(item.tags, `${file}#${item.id || "?"}`);
+      }
+    } catch {
+      /* skip */
+    }
+  }
+}
+
+export function validateSources(mnemeDir: string): ValidationResult {
+  if (!fs.existsSync(mnemeDir)) {
+    return { valid: true, issueCount: 0, issues: [] };
+  }
+
+  const issues: ValidationIssue[] = [];
+  validateDecisions(mnemeDir, issues);
+  validatePatterns(mnemeDir, issues);
+  validateRules(mnemeDir, issues);
+  validateIdUniqueness(mnemeDir, issues);
+  validateTagExistence(mnemeDir, issues);
+
+  return {
+    valid: issues.length === 0,
+    issueCount: issues.length,
+    issues,
+  };
+}
+
+export function registerValidateSourcesTool(server: McpServer): void {
+  server.registerTool(
+    "mneme_validate_sources",
+    {
+      description:
+        "Validate source artifacts (decisions, patterns, rules) for required fields and consistency.",
+      inputSchema: {},
+    },
+    async () => {
+      const mnemeDir = getMnemeDir();
+      const result = validateSources(mnemeDir);
+      return ok(JSON.stringify(result, null, 2));
+    },
+  );
+}

package/servers/db-server.ts

@@ -33,6 +33,7 @@ import {
   QUERY_MAX_LENGTH,
 } from "./db/types.js";
 import { getDb } from "./db/utils.js";
+import { registerValidateSourcesTool } from "./db/validate-sources.js";
 
 const server = new McpServer({
   name: "mneme-db",
@@ -185,6 +186,7 @@ server.registerTool(
 // Register extended tools
 registerSessionSummaryTool(server);
 registerExtendedTools(server);
+registerValidateSourcesTool(server);
 
 async function main() {
   const transport = new StdioServerTransport();

package/skills/harvest/SKILL.md

@@ -83,8 +83,8 @@ Use explicit section markers and XML-style tags for hard constraints:
 4. Deduplicate/conflict-check against existing sources.
 5. Save source artifacts with `prSource` metadata.
 6. Run source validation gate:
-   - `npm run validate:sources`
-   - If failed: fix artifacts and rerun.
+   - Call MCP tool `mneme_validate_sources`
+   - If failed (`valid: false`): fix artifacts and rerun.
 7. Regenerate units from sources.
 8. Show pending units for approval.
 
@@ -94,6 +94,6 @@ Use explicit section markers and XML-style tags for hard constraints:
 - extracted source item counts by type
 - duplicate/conflict summary
 - priority distribution (`p0/p1/p2` for added/updated rules)
-- validation result (`validate:sources`)
+- validation result (`mneme_validate_sources`)
 - regenerated units count
 - pending units count