lore-memory 0.3.0 → 0.5.0

package/src/mcp/server.js

@@ -10,15 +10,17 @@ const {
 const why = require('./tools/why');
 const search = require('./tools/search');
 const log = require('./tools/log');
+const update = require('./tools/update');
 const stale = require('./tools/stale');
 const overview = require('./tools/overview');
 const drafts = require('./tools/drafts');
+const { announceStartup } = require('./status');
 
-const TOOLS = [why, search, log, stale, overview, drafts];
+const TOOLS = [why, search, log, update, stale, overview, drafts];
 
 async function startServer() {
   const server = new Server(
-    { name: 'lore', version: '0.3.0' },
+    { name: 'lore', version: '0.4.0' },
     { capabilities: { tools: {} } }
   );
 
@@ -45,8 +47,12 @@ async function startServer() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
 
+  announceStartup(TOOLS);
+
   // Keep process alive
   process.stdin.resume();
 }
 
 module.exports = { startServer };
+
+

package/src/mcp/status.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+
+const LORE_DIR = path.join(process.cwd(), '.lore');
+const PID_FILE = path.join(LORE_DIR, 'mcp.pid');
+
+/**
+ * Write a status file so other tools can detect if the MCP server is running.
+ */
+function writePidFile(tools) {
+  try {
+    fs.ensureDirSync(LORE_DIR);
+    fs.writeJsonSync(PID_FILE, {
+      pid: process.pid,
+      startedAt: new Date().toISOString(),
+      tools: tools.map(t => t.toolDefinition.name),
+    }, { spaces: 2 });
+  } catch (e) {
+    // Non-fatal
+  }
+}
+
+/**
+ * Remove the status file on shutdown.
+ */
+function removePidFile() {
+  try { fs.removeSync(PID_FILE); } catch (e) {}
+}
+
+/**
+ * Print startup banner to stderr (safe — MCP only reads stdout).
+ * Register cleanup handlers.
+ */
+function announceStartup(tools) {
+  writePidFile(tools);
+
+  const toolNames = tools.map(t => t.toolDefinition.name).join(', ');
+  process.stderr.write(`\n📖 Lore MCP server active (PID: ${process.pid})\n`);
+  process.stderr.write(`   ${tools.length} tools available: ${toolNames}\n`);
+  process.stderr.write(`   Serving project: ${path.basename(process.cwd())}\n\n`);
+
+  process.on('SIGINT', () => { removePidFile(); process.exit(0); });
+  process.on('SIGTERM', () => { removePidFile(); process.exit(0); });
+  process.on('exit', removePidFile);
+}
+
+/**
+ * Check if the MCP server is currently running.
+ * @returns {{ pid: number, startedAt: string, tools: string[] }|null}
+ */
+function getServerStatus() {
+  try {
+    if (!fs.existsSync(PID_FILE)) return null;
+    const info = fs.readJsonSync(PID_FILE);
+
+    // Verify the process is actually alive
+    try {
+      process.kill(info.pid, 0); // Signal 0 = just check if process exists
+      return info;
+    } catch (e) {
+      // Process is dead, clean up stale PID file
+      removePidFile();
+      return null;
+    }
+  } catch (e) {
+    return null;
+  }
+}
+
+module.exports = { announceStartup, getServerStatus };

package/src/mcp/tools/log.js

@@ -1,11 +1,13 @@
 'use strict';
 
 const { readIndex, writeIndex, addEntryToIndex } = require('../../lib/index');
-const { generateId, writeEntry } = require('../../lib/entries');
+const { generateId, writeEntry, findDuplicate } = require('../../lib/entries');
+const { readConfig } = require('../../lib/config');
+const { saveDraft } = require('../../lib/drafts');
 
 const toolDefinition = {
   name: 'lore_log',
-  description: 'Create a new Lore entry to record an architectural decision, invariant, gotcha, or graveyard item. Use this when you make a significant technical decision that future developers (or AI) should know about.',
+  description: 'Create a new Lore entry to record an architectural decision, invariant, gotcha, or graveyard item. Use this when you make a significant technical decision that future developers (or AI) should know about. Note: entries may be saved as drafts pending human review depending on project configuration.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -50,6 +52,40 @@ async function handler(args) {
   const { type, title, context, files = [], tags = [], alternatives = [], tradeoffs = '' } = args;
 
   try {
+    const index = readIndex();
+
+    // Deduplication check
+    const duplicate = findDuplicate(index, type, title);
+    if (duplicate) {
+      const matchLabel = duplicate.match === 'exact' ? 'Exact duplicate' : 'Similar entry';
+      return {
+        content: [{ type: 'text', text: `${matchLabel} already exists: "${duplicate.entry.title}" (${duplicate.entry.id}). No new entry created.` }],
+      };
+    }
+
+    const config = readConfig();
+    const requireConfirmation = config.mcp && config.mcp.confirmEntries !== false;
+
+    if (requireConfirmation) {
+      // Route to drafts for human review
+      const draftId = saveDraft({
+        suggestedType: type,
+        suggestedTitle: title,
+        evidence: context,
+        files,
+        tags,
+        alternatives,
+        tradeoffs,
+        confidence: 0.9,
+        source: 'mcp-log',
+      });
+
+      return {
+        content: [{ type: 'text', text: `Draft created for human review: "${title}" (${draftId}). The developer can approve it with: lore drafts` }],
+      };
+    }
+
+    // Direct entry creation (confirmEntries is explicitly false)
     const id = generateId(type, title);
     const entry = {
       id,
@@ -64,8 +100,6 @@ async function handler(args) {
     };
 
     writeEntry(entry);
-
-    const index = readIndex();
     addEntryToIndex(index, entry);
     writeIndex(index);
 
@@ -91,3 +125,4 @@ async function handler(args) {
 }
 
 module.exports = { toolDefinition, handler };
+

package/src/mcp/tools/search.js

@@ -89,11 +89,10 @@ async function handler(args) {
       };
     }
 
-    const formatted = matches.map(e => formatEntry(e)).join('\n\n---\n\n');
     const budgeted = enforceBudget(matches, budget);
 
     return {
-      content: [{ type: 'text', text: budgeted || formatted }],
+      content: [{ type: 'text', text: budgeted || `Matches found, but they exceed the ${budget} token budget.` }],
     };
   } catch (e) {
     return {

package/src/mcp/tools/update.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const { readIndex, writeIndex } = require('../../lib/index');
+const { readEntry, writeEntry } = require('../../lib/entries');
+const { saveDraft } = require('../../lib/drafts');
+const { readConfig } = require('../../lib/config');
+
+const toolDefinition = {
+  name: 'lore_update',
+  description: 'Update an existing Lore entry. Use this when a previous decision, invariant, gotcha, or graveyard item needs to be revised because the context has changed. Updates may be saved as drafts pending human review depending on project configuration.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      id: {
+        type: 'string',
+        description: 'The ID of the existing entry to update (e.g. "decision-use-postgres-1709876543")',
+      },
+      context: {
+        type: 'string',
+        description: 'Updated context/explanation. If provided, replaces the existing context.',
+      },
+      title: {
+        type: 'string',
+        description: 'Updated title. If provided, replaces the existing title.',
+      },
+      files: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Updated list of related files. If provided, replaces the existing file list.',
+      },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Updated tags. If provided, replaces existing tags.',
+      },
+      alternatives: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Updated alternatives considered.',
+      },
+      tradeoffs: {
+        type: 'string',
+        description: 'Updated tradeoffs.',
+      },
+    },
+    required: ['id'],
+  },
+};
+
+async function handler(args) {
+  const { id, context, title, files, tags, alternatives, tradeoffs } = args;
+
+  try {
+    const index = readIndex();
+    const entryPath = index.entries[id];
+
+    if (!entryPath) {
+      return {
+        content: [{ type: 'text', text: `Entry not found: "${id}". Use lore_search to find the correct entry ID.` }],
+        isError: true,
+      };
+    }
+
+    const entry = readEntry(entryPath);
+    if (!entry) {
+      return {
+        content: [{ type: 'text', text: `Failed to read entry: "${id}".` }],
+        isError: true,
+      };
+    }
+
+    const config = readConfig();
+    const requireConfirmation = config.mcp && config.mcp.confirmEntries !== false;
+
+    // Build a summary of what's changing
+    const changes = [];
+    if (title !== undefined && title !== entry.title) changes.push(`title: "${entry.title}" → "${title}"`);
+    if (context !== undefined && context !== entry.context) changes.push('context updated');
+    if (files !== undefined) changes.push(`files: [${files.join(', ')}]`);
+    if (tags !== undefined) changes.push(`tags: [${tags.join(', ')}]`);
+    if (alternatives !== undefined) changes.push(`alternatives: [${alternatives.join(', ')}]`);
+    if (tradeoffs !== undefined) changes.push('tradeoffs updated');
+
+    if (changes.length === 0) {
+      return {
+        content: [{ type: 'text', text: `No changes provided for entry "${id}".` }],
+      };
+    }
+
+    if (requireConfirmation) {
+      // Route update through drafts for human review
+      const draftId = saveDraft({
+        suggestedType: entry.type,
+        suggestedTitle: title || entry.title,
+        evidence: `[UPDATE to ${id}] ${context || entry.context}`,
+        files: files || entry.files,
+        tags: tags || entry.tags,
+        alternatives: alternatives || entry.alternatives,
+        tradeoffs: tradeoffs !== undefined ? tradeoffs : entry.tradeoffs,
+        confidence: 0.95,
+        source: 'mcp-update',
+        updatesEntryId: id,
+      });
+
+      return {
+        content: [{ type: 'text', text: `Update drafted for human review (${draftId}). Changes: ${changes.join('; ')}. The developer can approve it with: lore drafts` }],
+      };
+    }
+
+    // Direct update (confirmEntries is explicitly false)
+    if (title !== undefined) entry.title = title;
+    if (context !== undefined) entry.context = context;
+    if (files !== undefined) entry.files = files;
+    if (tags !== undefined) entry.tags = tags;
+    if (alternatives !== undefined) entry.alternatives = alternatives;
+    if (tradeoffs !== undefined) entry.tradeoffs = tradeoffs;
+    entry.lastUpdated = new Date().toISOString();
+
+    writeEntry(entry);
+    writeIndex(index);
+
+    // Re-embed
+    try {
+      const { generateEmbedding, storeEmbedding } = require('../../lib/embeddings');
+      const text = [entry.title, entry.context, ...(entry.alternatives || []), entry.tradeoffs || '', ...(entry.tags || [])].join(' ');
+      const vector = await generateEmbedding(text);
+      storeEmbedding(id, vector);
+    } catch (e) {
+      // Ollama not available — skip
+    }
+
+    return {
+      content: [{ type: 'text', text: `Updated entry "${id}". Changes: ${changes.join('; ')}` }],
+    };
+  } catch (e) {
+    return {
+      content: [{ type: 'text', text: `Error updating entry: ${e.message}` }],
+      isError: true,
+    };
+  }
+}
+
+module.exports = { toolDefinition, handler };

package/src/watcher/comments.js

@@ -3,7 +3,9 @@
 const fs = require('fs-extra');
 const path = require('path');
 const { detectType, extractTitle, scoreComment } = require('../lib/nlp');
-const { saveDraft } = require('../lib/drafts');
+const { saveDraft, listDrafts } = require('../lib/drafts');
+const { readIndex } = require('../lib/index');
+const { readEntry } = require('../lib/entries');
 
 /**
  * Extract raw comment strings from source code.
@@ -57,7 +59,11 @@ async function mineFile(absFilePath, projectRoot) {
   const comments = extractComments(code, absFilePath);
   const created = [];
 
-  // Deduplicate: skip if we have a recent draft from same file with very similar title
+  const existingDrafts = listDrafts();
+  const index = readIndex();
+  const existingEntries = Object.values(index.entries).map(p => readEntry(p)).filter(Boolean);
+
+  // Deduplicate: skip if we have a recent draft or entry from same file with same title
   for (const comment of comments) {
     const score = scoreComment(comment);
     if (score < 0.5) continue;
@@ -66,6 +72,11 @@ async function mineFile(absFilePath, projectRoot) {
     const title = extractTitle(comment);
     if (!title || title.length < 3) continue;
 
+    const isDuplicateDraft = existingDrafts.some(d => d.suggestedTitle === title && (d.files || []).includes(relativePath));
+    const isDuplicateEntry = existingEntries.some(e => e.title === title && (e.files || []).includes(relativePath));
+
+    if (isDuplicateDraft || isDuplicateEntry) continue;
+
     const draft = {
       draftId: `draft-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
       suggestedType: type,