lore-memory 0.2.0 → 0.4.0

package/bin/lore.js

@@ -8,8 +8,11 @@ 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;
+
     const inquirer = require('inquirer');
     const chalk = require('chalk');
     const { execSync } = require('child_process');
@@ -36,6 +39,8 @@ 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(),
           { name: '❓ Show Help', value: 'help' },
@@ -48,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 {
@@ -131,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'));
 
@@ -192,4 +209,17 @@ program
   .option('--build', 'Rebuild the full graph from source')
   .action(require('../src/commands/graph'));
 
+program
+  .command('ui')
+  .description('Start the local Lore web dashboard')
+  .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.2.0",
+  "version": "0.4.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": {
@@ -43,11 +43,13 @@
     "chalk": "^4",
     "chokidar": "^3.6.0",
     "commander": "^11",
+    "express": "^5.2.1",
     "fs-extra": "^11",
     "glob": "^10.5.0",
     "inquirer": "^8",
     "js-yaml": "^4",
     "natural": "^6.12.0",
-    "ollama": "^0.6.3"
+    "ollama": "^0.6.3",
+    "open": "^11.0.0"
   }
 }

package/src/commands/init.js

@@ -67,9 +67,26 @@ 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'));
+      let writeHook = true;
+
+      if (fs.existsSync(hookPath)) {
+        const existingHook = await fs.readFile(hookPath, 'utf8');
+        if (existingHook.includes('Lore: Significant change detected')) {
+          writeHook = false;
+          console.log(chalk.dim('✓ Git post-commit hook already installed'));
+        } else {
+          // Append to existing hook
+          await fs.appendFile(hookPath, '\n' + HOOK_CONTENT.replace('#!/bin/bash\n', ''));
+          console.log(chalk.green('✓ Lore appended to existing Git post-commit hook'));
+          writeHook = false;
+        }
+      }
+
+      if (writeHook) {
+        await fs.writeFile(hookPath, HOOK_CONTENT);
+        await fs.chmod(hookPath, '0755');
+        console.log(chalk.green('✓ Git post-commit hook installed'));
+      }
     } else {
       console.log(chalk.yellow('⚠ Not a git repo — hook not installed'));
     }
@@ -95,7 +112,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/mine.js

@@ -6,7 +6,7 @@ const fs = require('fs-extra');
 const { mineFile, mineDirectory } = require('../watcher/comments');
 const { requireInit } = require('../lib/guard');
 
-function mine(targetPath) {
+async function mine(targetPath) {
   requireInit();
   const projectRoot = process.cwd();
   const target = targetPath || '.';
@@ -18,10 +18,11 @@ function mine(targetPath) {
 
     if (stat.isDirectory()) {
       console.log(chalk.cyan(`📖 Mining comments in ${target} ...`));
-      count = mineDirectory(abs, projectRoot);
+      count = await mineDirectory(abs, projectRoot);
     } else {
       console.log(chalk.cyan(`📖 Mining comments in ${target} ...`));
-      count = mineFile(abs, projectRoot).length;
+      const drafts = await mineFile(abs, projectRoot);
+      count = drafts.length;
     }
 
     if (count === 0) {

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/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

@@ -0,0 +1,171 @@
+'use strict';
+
+const express = require('express');
+const path = require('path');
+const chalk = require('chalk');
+const { requireInit } = require('../lib/guard');
+const { readIndex, LORE_DIR } = require('../lib/index');
+const { readEntry } = require('../lib/entries');
+const { computeScore } = require('../lib/scorer');
+const { listDrafts, acceptDraft, deleteDraft } = require('../lib/drafts');
+
+// Only load 'open' dynamically to avoid overhead on other CLI commands if not needed
+async function openBrowser(url) {
+    const open = (await import('open')).default;
+    await open(url);
+}
+
+function ui(options) {
+    requireInit();
+
+    const app = express();
+    const PORT = options.port || 3333;
+
+    app.use(express.json());
+
+    // CORS for local dev
+    app.use((req, res, next) => {
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
+        res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, DELETE');
+        next();
+    });
+
+    // API Endpoints
+
+    app.get('/api/stats', (req, res) => {
+        try {
+            const scoreData = computeScore();
+            const drafts = listDrafts();
+
+            const index = readIndex();
+            const counts = { decision: 0, invariant: 0, graveyard: 0, gotcha: 0 };
+            for (const entryPath of Object.values(index.entries)) {
+                const entry = readEntry(entryPath);
+                if (entry && counts[entry.type] !== undefined) counts[entry.type]++;
+            }
+
+            res.json({
+                score: scoreData,
+                counts,
+                draftCount: drafts.length,
+                totalEntries: Object.keys(index.entries).length
+            });
+        } catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    app.get('/api/entries', (req, res) => {
+        try {
+            const index = readIndex();
+            const entries = [];
+            for (const entryPath of Object.values(index.entries)) {
+                const entry = readEntry(entryPath);
+                if (entry) entries.push(entry);
+            }
+            // Sort newest first
+            entries.sort((a, b) => new Date(b.date) - new Date(a.date));
+            res.json(entries);
+        } catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    app.get('/api/drafts', (req, res) => {
+        try {
+            const drafts = listDrafts();
+            res.json(drafts);
+        } catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    app.post('/api/drafts/:id/accept', (req, res) => {
+        try {
+            const entry = acceptDraft(req.params.id);
+            res.json({ success: true, entry });
+        } catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    app.delete('/api/drafts/:id', (req, res) => {
+        try {
+            deleteDraft(req.params.id);
+            res.json({ success: true });
+        } catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    app.get('/api/graph', (req, res) => {
+        try {
+            const { loadGraph, saveGraph } = require('../lib/graph');
+            let g = loadGraph();
+
+            if (Object.keys(g.imports).length === 0) {
+                const { buildFullGraph } = require('../watcher/graph');
+                g = buildFullGraph(process.cwd());
+                saveGraph(g);
+            }
+
+            const nodesSet = new Set();
+            const edges = [];
+            for (const [file, deps] of Object.entries(g.imports)) {
+                nodesSet.add(file);
+                for (const dep of deps) {
+                    nodesSet.add(dep);
+                    edges.push({ from: file, to: dep });
+                }
+            }
+
+            const nodes = Array.from(nodesSet).map(id => ({ id, label: id }));
+            res.json({ nodes, edges });
+        } catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    // Handle unmapped API routes with 404 JSON (instead of serving index.html)
+    app.use('/api', (req, res) => {
+        res.status(404).json({ error: 'API route not found' });
+    });
+
+    // Serve the frontend application
+    const uiPath = path.join(__dirname, '..', 'ui', 'public');
+    app.use(express.static(uiPath));
+
+    // Catch-all to serve index.html for SPA routing
+    app.use((req, res) => {
+        res.sendFile(path.join(uiPath, 'index.html'));
+    });
+
+    const server = app.listen(PORT, () => {
+        const url = `http://localhost:${PORT}`;
+        console.log(chalk.green(`\n🚀 Lore UI Dashboard running at ${chalk.bold(url)}\n`));
+        console.log(chalk.cyan(`  Press Ctrl+C to stop the server.`));
+
+        // Use native exec to open browser to avoid ESM import issues with 'open'
+        const { exec } = require('child_process');
+        const startPath = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+        exec(`${startPath} ${url}`, (err) => {
+            if (err) {
+                console.log(chalk.dim(`  (Could not open browser automatically. Please visit ${url} manually)`));
+            }
+        });
+    });
+
+    server.on('error', (e) => {
+        if (e.code === 'EADDRINUSE') {
+            console.error(chalk.red(`\nPort ${PORT} is already in use by another process.`));
+            console.error(chalk.yellow(`Use 'lore ui --port <number>' to specify a different port.\n`));
+            process.exit(1);
+        } else {
+            console.error(chalk.red(`\nFailed to start server: ${e.message}\n`));
+            process.exit(1);
+        }
+    });
+}
+
+module.exports = ui;

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(/^\.\//, ''));

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 {