lore-memory 0.3.0 → 0.5.0

package/bin/lore.js

@@ -8,7 +8,7 @@ const program = new Command();
 program
   .name('lore')
   .description('Persistent project memory for developers')
-  .version('0.1.0')
+  .version(require('../package.json').version)
   .action(async () => {
     // Only launch the interactive menu if strictly NO arguments were provided
     if (process.argv.length !== 2) return;
@@ -39,6 +39,7 @@ program
           { name: '👀 Review pending drafts (lore drafts)', value: 'drafts' },
           { name: '📊 View project health (lore score)', value: 'score' },
           { name: '🔍 Search knowledge base (lore search)', value: 'search' },
+          { name: '🪄 Generate AI Prompt (lore prompt)', value: 'prompt' },
           { name: '🌐 Open Local Web Dashboard (lore ui)', value: 'ui' },
           { name: '⚙️  Start background watcher (lore watch --daemon)', value: 'watch --daemon' },
           new inquirer.Separator(),
@@ -52,6 +53,18 @@ program
       process.exit(0);
     } else if (action === 'help') {
       program.outputHelp();
+    } else if (action === 'prompt') {
+      const { query } = await inquirer.prompt([{
+        type: 'input',
+        name: 'query',
+        message: 'What are you trying to build or refactor? (e.g. "Add a login page")'
+      }]);
+      console.log();
+      if (query.trim()) {
+        try {
+          execSync(`node ${__filename} prompt "${query.replace(/"/g, '\\"')}"`, { stdio: 'inherit' });
+        } catch (e) { }
+      }
     } else {
       console.log();
       try {
@@ -135,7 +148,7 @@ program
   .action(require('../src/commands/stale'));
 
 program
-  .command('search <query>')
+  .command('search [query...]')
   .description('Search all entries for a keyword')
   .action(require('../src/commands/search'));
 
@@ -151,8 +164,9 @@ program
 
 program
   .command('serve')
-  .description('Start the Lore MCP server (stdio) for use with Claude Code')
+  .description('Start the Lore MCP server (stdio) and UI dashboard for use with Claude Code')
   .option('-q, --quiet', 'Suppress startup messages (use when piped into MCP client)')
+  .option('-p, --port <port>', 'Port for the UI dashboard', '3333')
   .action(require('../src/commands/serve'));
 
 program
@@ -202,4 +216,11 @@ program
   .option('-p, --port <port>', 'Port to run the UI server on', '3333')
   .action(require('../src/commands/ui'));
 
+program
+  .command('prompt [query...]')
+  .description('Generate a perfectly formatted LLM context prompt from project memory')
+  .option('-t, --threshold <number>', 'Relevance threshold (0.0 to 1.0)', '0.4')
+  .option('-l, --limit <number>', 'Max number of entries to include', '10')
+  .action(require('../src/commands/prompt'));
+
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lore-memory",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Persistent project memory for developers. Captures decisions, invariants, gotchas, and graveyard entries — automatically and manually — and injects them into AI coding sessions.",
   "main": "bin/lore.js",
   "bin": {

package/src/commands/init.js

@@ -6,20 +6,6 @@ const yaml = require('js-yaml');
 const chalk = require('chalk');
 const { LORE_DIR, emptyIndex } = require('../lib/index');
 
-const HOOK_CONTENT = `#!/bin/bash
-LINECOUNT=$(git diff HEAD~1 --shortstat 2>/dev/null | grep -o '[0-9]* insertion' | grep -o '[0-9]*' || echo 0)
-if [ "\${LINECOUNT:-0}" -gt 50 ]; then
-  # Only prompt if running in an interactive terminal
-  if [ -t 1 ] || [ -t 0 ]; then
-    echo "📖 Lore: Significant change detected. Log it? (y/n)"
-    read -r answer </dev/tty
-    if [ "$answer" = "y" ]; then
-      lore log </dev/tty
-    fi
-  fi
-fi
-`;
-
 async function init() {
   try {
     const dirs = ['decisions', 'invariants', 'graveyard', 'gotchas', 'modules', 'sessions', 'drafts'];
@@ -44,6 +30,7 @@ async function init() {
         },
         mcp: {
           tokenBudget: 4000,
+          confirmEntries: true,
         },
         watchMode: false,
         watchIgnore: ['node_modules', 'dist', '.git', 'coverage'],
@@ -64,16 +51,6 @@ async function init() {
       );
     }
 
-    const hookDir = path.join('.git', 'hooks');
-    if (fs.existsSync(hookDir)) {
-      const hookPath = path.join(hookDir, 'post-commit');
-      await fs.writeFile(hookPath, HOOK_CONTENT);
-      await fs.chmod(hookPath, '755');
-      console.log(chalk.green('✓ Git post-commit hook installed'));
-    } else {
-      console.log(chalk.yellow('⚠ Not a git repo — hook not installed'));
-    }
-
     console.log(chalk.green(`✓ Lore initialized at ${LORE_DIR}/`));
     console.log(chalk.cyan('  Run: lore mine .       to scan codebase for lore-worthy comments'));
     console.log(chalk.cyan('  Run: lore log          to create your first entry manually'));
@@ -95,7 +72,7 @@ async function init() {
         console.log(chalk.dim('\n  Scanning codebase for lore-worthy comments...'));
         try {
           const { mineDirectory } = require('../watcher/comments');
-          const count = mineDirectory(process.cwd(), process.cwd());
+          const count = await mineDirectory(process.cwd(), process.cwd());
           if (count > 0) {
             console.log(chalk.cyan(`  Found ${count} draft entr${count === 1 ? 'y' : 'ies'} — run: lore drafts`));
           }

package/src/commands/log.js

@@ -4,7 +4,7 @@ const chalk = require('chalk');
 const inquirer = require('inquirer');
 const { readIndex, writeIndex, addEntryToIndex } = require('../lib/index');
 const { requireInit } = require('../lib/guard');
-const { writeEntry, generateId } = require('../lib/entries');
+const { writeEntry, generateId, findDuplicate } = require('../lib/entries');
 const { getRecentFiles } = require('../lib/git');
 
 async function log(options) {
@@ -103,6 +103,32 @@ async function log(options) {
       process.exit(1);
     }
 
+    // Deduplication check
+    const duplicate = findDuplicate(index, type, title);
+    if (duplicate) {
+      const matchLabel = duplicate.match === 'exact' ? 'Exact duplicate' : 'Similar entry';
+      console.log(chalk.yellow(`\n⚠ ${matchLabel} found: ${chalk.bold(duplicate.entry.id)}`));
+      console.log(chalk.dim(`  Title: "${duplicate.entry.title}"\n`));
+
+      // In inline mode (flags), just warn and exit
+      if (options.type && options.title && options.context) {
+        console.log(chalk.yellow('Skipping to avoid duplicate. Use a different title or edit the existing entry.'));
+        return;
+      }
+
+      // In interactive mode, ask user
+      const { proceed } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'proceed',
+        message: 'Create entry anyway?',
+        default: false,
+      }]);
+      if (!proceed) {
+        console.log(chalk.dim('Aborted.'));
+        return;
+      }
+    }
+
     const id = generateId(type, title);
     const entry = {
       id,

package/src/commands/onboard.js

@@ -58,8 +58,9 @@ function onboard(options) {
       for (const e of byType.decision.slice(0, 5)) {
         console.log(chalk.white(`  • ${e.title}`));
         if (e.context) {
-          const summary = e.context.split('\n')[0].slice(0, 80);
-          console.log(chalk.dim(`    ${summary}${e.context.length > 80 ? '…' : ''}`));
+          const firstLine = e.context.split('\n')[0];
+          const summary = firstLine.slice(0, 80);
+          console.log(chalk.dim(`    ${summary}${firstLine.length > 80 ? '…' : ''}`));
         }
       }
       if (byType.decision.length > 5) {

package/src/commands/prompt.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const chalk = require('chalk');
+const { requireInit } = require('../lib/guard');
+const { findSimilar } = require('../lib/embeddings');
+const { readIndex } = require('../lib/index');
+const { readEntry } = require('../lib/entries');
+const { formatPromptContext } = require('../lib/format');
+
+async function promptCmd(queryArgs, options) {
+    requireInit();
+
+    const queryInfo = Array.isArray(queryArgs) ? queryArgs.join(' ') : (queryArgs || '');
+
+    if (!queryInfo || queryInfo.trim().length === 0) {
+        console.error(chalk.red('\nError: You must provide a query to generate a prompt.'));
+        console.log(chalk.yellow('Example: lore prompt "I want to refactor the database"'));
+        process.exit(1);
+    }
+
+    const query = queryInfo;
+
+    try {
+        const threshold = parseFloat(options.threshold) || 0.4;
+        const limit = parseInt(options.limit, 10) || 10;
+
+        const index = readIndex();
+        const allIds = Object.keys(index.entries);
+
+        let results = [];
+        try {
+            const similar = await findSimilar(query, allIds, limit);
+            for (const { id, score } of similar) {
+                if (score >= threshold) {
+                    const entry = readEntry(index.entries[id]);
+                    if (entry) results.push(entry);
+                }
+            }
+        } catch (e) {
+            console.error(chalk.yellow(`⚠️ Warning: Semantic search failed (${e.message}). Ensure Ollama is running.\nFallback text search will be used.`));
+            // Basic text fallback
+            const q = query.toLowerCase();
+            for (const id of allIds) {
+                const entry = readEntry(index.entries[id]);
+                if (!entry) continue;
+                const searchable = [entry.title, entry.context].join(' ').toLowerCase();
+                if (searchable.includes(q)) results.push(entry);
+            }
+        }
+
+        // The exact LLM-ready markdown string
+        const markdownPrompt = formatPromptContext(query, results);
+
+        // Print strictly to stdout without extra CLI fluff so it can be piped seamlessly
+        console.log(markdownPrompt);
+
+    } catch (e) {
+        console.error(chalk.red(`\nFailed to generate prompt: ${e.message}\n`));
+        process.exit(1);
+    }
+}
+
+module.exports = promptCmd;

package/src/commands/search.js

@@ -6,9 +6,16 @@ const { readEntry } = require('../lib/entries');
 const { printEntry } = require('../lib/format');
 const { requireInit } = require('../lib/guard');
 
-function search(query) {
+function search(queryArgs) {
   requireInit();
   try {
+    const query = Array.isArray(queryArgs) ? queryArgs.join(' ') : (queryArgs || '');
+
+    if (!query || query.trim().length === 0) {
+      console.error(chalk.red('\nError: You must provide a search query.'));
+      process.exit(1);
+    }
+
     const index = readIndex();
     const q = query.toLowerCase();
     const matches = [];

package/src/commands/serve.js

@@ -2,16 +2,36 @@
 
 const chalk = require('chalk');
 const { requireInit } = require('../lib/guard');
+const { getServerStatus } = require('../mcp/status');
 
 async function serve(options) {
   requireInit();
+
+  // Prevent double-start
+  const existing = getServerStatus();
+  if (existing) {
+    process.stderr.write(chalk.yellow(`\n⚠ Lore MCP server is already running (PID: ${existing.pid}, started: ${existing.startedAt})\n`));
+    process.stderr.write(chalk.dim(`  Tools: ${existing.tools.join(', ')}\n\n`));
+    process.exit(1);
+  }
+
   try {
+    // Start the MCP server (communicates via stdio)
     const { startServer } = require('../mcp/server');
     if (!options.quiet) {
       process.stderr.write(chalk.green('📖 Lore MCP server starting on stdio\n'));
       process.stderr.write(chalk.cyan('   Add to Claude Code settings: { "command": "lore serve", "args": [] }\n'));
     }
     await startServer();
+
+    // Also start the UI dashboard in the same process
+    const uiPort = options.port || 3333;
+    try {
+      const { startDashboard } = require('./ui');
+      startDashboard(uiPort);
+    } catch (e) {
+      process.stderr.write(chalk.yellow(`⚠ Could not start UI dashboard: ${e.message}\n`));
+    }
   } catch (e) {
     process.stderr.write(chalk.red(`Failed to start server: ${e.message}\n`));
     process.exit(1);
@@ -19,3 +39,4 @@ async function serve(options) {
 }
 
 module.exports = serve;
+

package/src/commands/stale.js

@@ -12,7 +12,7 @@ function stale() {
     const index = readIndex();
     let found = false;
 
-    for (const [id, entryPath] of Object.entries(index.entries)) {
+    for (const entryPath of Object.values(index.entries)) {
       const entry = readEntry(entryPath);
       if (!entry) continue;
 

package/src/commands/ui.js

@@ -8,6 +8,7 @@ const { readIndex, LORE_DIR } = require('../lib/index');
 const { readEntry } = require('../lib/entries');
 const { computeScore } = require('../lib/scorer');
 const { listDrafts, acceptDraft, deleteDraft } = require('../lib/drafts');
+const { getServerStatus } = require('../mcp/status');
 
 // Only load 'open' dynamically to avoid overhead on other CLI commands if not needed
 async function openBrowser(url) {
@@ -15,11 +16,9 @@ async function openBrowser(url) {
     await open(url);
 }
 
-function ui(options) {
-    requireInit();
-
+function createApp(portNum) {
     const app = express();
-    const PORT = options.port || 3333;
+    const PORT = portNum || 3333;
 
     app.use(express.json());
 
@@ -56,6 +55,18 @@ function ui(options) {
         }
     });
 
+    app.get('/api/mcp-status', (req, res) => {
+        try {
+            const status = getServerStatus();
+            res.json({
+                active: !!status,
+                ...(status || {}),
+            });
+        } catch (e) {
+            res.json({ active: false });
+        }
+    });
+
     app.get('/api/entries', (req, res) => {
         try {
             const index = readIndex();
@@ -166,6 +177,23 @@ function ui(options) {
             process.exit(1);
         }
     });
+
+    return server;
+}
+
+/**
+ * Start just the dashboard Express server (called from serve.js).
+ * @param {number} port
+ * @returns {object} Express server instance
+ */
+function startDashboard(port) {
+    return createApp(port || 3333);
+}
+
+function ui(options) {
+    requireInit();
+    createApp(options.port || 3333);
 }
 
 module.exports = ui;
+module.exports.startDashboard = startDashboard;

package/src/lib/config.js

@@ -14,6 +14,7 @@ const DEFAULTS = {
   },
   mcp: {
     tokenBudget: 4000,
+    confirmEntries: true,
   },
 };
 

package/src/lib/drafts.js

@@ -44,41 +44,82 @@ function listDrafts() {
 }
 
 /**
- * Promote a draft to a real Lore entry.
+ * Promote a draft to a real Lore entry, or apply it as an update to an existing entry.
  * @param {string} draftId
- * @returns {object} the created entry
+ * @returns {object} the created or updated entry
  */
 function acceptDraft(draftId) {
   const draftPath = path.join(DRAFTS_DIR(), `${draftId}.json`);
   const draft = fs.readJsonSync(draftPath);
 
-  const type = draft.suggestedType || 'decision';
-  const title = draft.suggestedTitle || 'Untitled';
-  const id = generateId(type, title);
-
-  const entry = {
-    id,
-    type,
-    title,
-    context: draft.evidence || '',
-    files: draft.files || [],
-    tags: draft.tags || [],
-    alternatives: [],
-    tradeoffs: '',
-    date: new Date().toISOString(),
-  };
-
-  writeEntry(entry);
-  const index = readIndex();
-  addEntryToIndex(index, entry);
-  writeIndex(index);
-
-  // Auto-embed if Ollama available
-  try {
-    const { generateEmbedding, storeEmbedding } = require('./embeddings');
-    const text = [title, entry.context, ...entry.tags].join(' ');
-    generateEmbedding(text).then(vec => storeEmbedding(id, vec)).catch(() => {});
-  } catch (e) {}
+  let entry;
+
+  if (draft.updatesEntryId) {
+    // This draft is an update to an existing entry — modify in place
+    const index = readIndex();
+    const existingPath = index.entries[draft.updatesEntryId];
+    if (!existingPath) {
+      throw new Error(`Original entry "${draft.updatesEntryId}" not found. It may have been deleted.`);
+    }
+
+    const { readEntry: readExisting } = require('./entries');
+    entry = readExisting(existingPath);
+    if (!entry) {
+      throw new Error(`Failed to read original entry "${draft.updatesEntryId}".`);
+    }
+
+    // Apply updates from draft — only override fields that have meaningful values
+    if (draft.suggestedTitle && draft.suggestedTitle !== entry.title) entry.title = draft.suggestedTitle;
+    if (draft.evidence && !draft.evidence.startsWith('[UPDATE to ')) entry.context = draft.evidence;
+    else if (draft.evidence) {
+      // Strip the "[UPDATE to xxx] " prefix from the context
+      entry.context = draft.evidence.replace(/^\[UPDATE to [^\]]+\]\s*/, '');
+    }
+    if (draft.files && draft.files.length > 0) entry.files = draft.files;
+    if (draft.tags && draft.tags.length > 0) entry.tags = draft.tags;
+    if (draft.alternatives && draft.alternatives.length > 0) entry.alternatives = draft.alternatives;
+    if (draft.tradeoffs) entry.tradeoffs = draft.tradeoffs;
+    entry.lastUpdated = new Date().toISOString();
+
+    writeEntry(entry);
+    writeIndex(index);
+
+    // Re-embed
+    try {
+      const { generateEmbedding, storeEmbedding } = require('./embeddings');
+      const text = [entry.title, entry.context, ...(entry.alternatives || []), entry.tradeoffs || '', ...(entry.tags || [])].join(' ');
+      generateEmbedding(text).then(vec => storeEmbedding(entry.id, vec)).catch(() => {});
+    } catch (e) {}
+  } else {
+    // Standard draft → new entry
+    const type = draft.suggestedType || 'decision';
+    const title = draft.suggestedTitle || 'Untitled';
+    const id = generateId(type, title);
+
+    entry = {
+      id,
+      type,
+      title,
+      context: draft.evidence || '',
+      files: draft.files || [],
+      tags: draft.tags || [],
+      alternatives: draft.alternatives || [],
+      tradeoffs: draft.tradeoffs || '',
+      date: new Date().toISOString(),
+    };
+
+    writeEntry(entry);
+    const index = readIndex();
+    addEntryToIndex(index, entry);
+    writeIndex(index);
+
+    // Auto-embed if Ollama available
+    try {
+      const { generateEmbedding, storeEmbedding } = require('./embeddings');
+      const text = [title, entry.context, ...entry.alternatives, entry.tradeoffs, ...entry.tags].join(' ');
+      generateEmbedding(text).then(vec => storeEmbedding(id, vec)).catch(() => {});
+    } catch (e) {}
+  }
 
   fs.removeSync(draftPath);
   return entry;

package/src/lib/entries.js

@@ -50,10 +50,71 @@ function readAllEntries(index) {
   return entries;
 }
 
+/**
+ * Check if a similar entry or draft already exists.
+ * @param {object} index - The lore index
+ * @param {string} type - Entry type
+ * @param {string} title - Entry title
+ * @returns {{ match: 'exact'|'fuzzy', entry: object, source: 'entry'|'draft' }|null}
+ */
+function findDuplicate(index, type, title) {
+  const normalizedTitle = title.toLowerCase().trim();
+  const titleWords = new Set(normalizedTitle.split(/\s+/).filter(w => w.length > 2));
+
+  function checkTitle(candidateTitle) {
+    const candidate = (candidateTitle || '').toLowerCase().trim();
+
+    // Exact match (case-insensitive)
+    if (candidate === normalizedTitle) return 'exact';
+
+    // Fuzzy match: ≥60% word overlap
+    if (titleWords.size > 0) {
+      const candidateWords = new Set(candidate.split(/\s+/).filter(w => w.length > 2));
+      if (candidateWords.size === 0) return null;
+
+      let overlap = 0;
+      for (const w of titleWords) {
+        if (candidateWords.has(w)) overlap++;
+      }
+
+      const similarity = overlap / Math.max(titleWords.size, candidateWords.size);
+      if (similarity >= 0.6) return 'fuzzy';
+    }
+
+    return null;
+  }
+
+  // Check approved entries
+  for (const entryPath of Object.values(index.entries)) {
+    const entry = readEntry(entryPath);
+    if (!entry || entry.type !== type) continue;
+
+    const match = checkTitle(entry.title);
+    if (match) return { match, entry, source: 'entry' };
+  }
+
+  // Check pending drafts
+  try {
+    const { listDrafts } = require('./drafts');
+    const drafts = listDrafts();
+    for (const draft of drafts) {
+      if (draft.suggestedType !== type) continue;
+
+      const match = checkTitle(draft.suggestedTitle);
+      if (match) return { match, entry: { id: draft.draftId, title: draft.suggestedTitle, type: draft.suggestedType }, source: 'draft' };
+    }
+  } catch (e) {
+    // drafts module not available — skip
+  }
+
+  return null;
+}
+
 module.exports = {
   getEntryPath,
   readEntry,
   writeEntry,
   generateId,
   readAllEntries,
+  findDuplicate,
 };

package/src/lib/format.js

@@ -41,7 +41,7 @@ function printEntry(entry) {
   content += `${titleColor(typeLabel)} ${titleColor(entry.title)} ${chalk.gray('(' + entry.date + ')')}\n\n`;
 
   // Wrap context text roughly
-  const contextWords = entry.context.split(' ');
+  const contextWords = (entry.context || '').split(' ');
   let currentLine = '';
   for (const word of contextWords) {
     if (currentLine.length + word.length > 70) {
@@ -71,4 +71,47 @@ function printEntry(entry) {
   drawBox(content.trim(), colorFn, entry.id);
 }
 
-module.exports = { printEntry };
+function formatPromptContext(query, entries) {
+  if (!entries || entries.length === 0) {
+    return `# Project Context: Lore\nThe user is asking about: "${query}"\n\nNo specific historical rules or decisions were found in the project memory for this topic.`;
+  }
+
+  const invariants = entries.filter(e => e.type === 'invariant');
+  const gotchas = entries.filter(e => e.type === 'gotcha');
+  const decisions = entries.filter(e => e.type === 'decision');
+  const graveyard = entries.filter(e => e.type === 'graveyard');
+
+  let output = `# Project Context: Lore\nThe user is asking: "${query}"\n\nPlease adhere strictly to the following project architectural rules extracted from project memory:\n`;
+
+  if (invariants.length > 0) {
+    output += `\n## Invariants (CRITICAL: DO NOT BREAK)\n`;
+    for (const e of invariants) {
+      output += `- [${e.id}]: ${(e.context || '').trim().replace(/\n/g, ' ')}\n`;
+    }
+  }
+
+  if (gotchas.length > 0) {
+    output += `\n## Gotchas (WARNING: KNOWN TRAPS)\n`;
+    for (const e of gotchas) {
+      output += `- [${e.id}]: ${(e.context || '').trim().replace(/\n/g, ' ')}\n`;
+    }
+  }
+
+  if (decisions.length > 0) {
+    output += `\n## Relevant Decisions\n`;
+    for (const e of decisions) {
+      output += `- [${e.id}]: ${e.title} - ${(e.context || '').trim().replace(/\n/g, ' ')}\n`;
+    }
+  }
+
+  if (graveyard.length > 0) {
+    output += `\n## Graveyard (DO NOT SUGGEST OR USE)\n`;
+    for (const e of graveyard) {
+      output += `- [${e.id}]: ${(e.context || '').trim().replace(/\n/g, ' ')}\n`;
+    }
+  }
+
+  return output.trim();
+}
+
+module.exports = { printEntry, formatPromptContext };

package/src/lib/relevance.js

@@ -21,19 +21,21 @@ function scoreEntry(entry, context) {
   let score = 0;
 
   // Direct file match
+  let exactMatchFound = false;
   if (context.filepath && entry.files && entry.files.length > 0) {
     const normalizedQuery = context.filepath.replace(/^\.\//, '');
     for (const f of entry.files) {
       const normalizedFile = f.replace(/^\.\//, '');
       if (normalizedFile === normalizedQuery) {
         score += WEIGHTS.directFileMatch;
+        exactMatchFound = true;
         break;
       }
     }
   }
 
   // Parent dir match
-  if (context.filepath && entry.files && entry.files.length > 0) {
+  if (!exactMatchFound && context.filepath && entry.files && entry.files.length > 0) {
     const queryDir = path.dirname(context.filepath.replace(/^\.\//, ''));
     for (const f of entry.files) {
       const fileDir = path.dirname(f.replace(/^\.\//, ''));