lore-memory 0.1.1 → 0.3.0

package/bin/lore.js

@@ -9,7 +9,98 @@ program
   .name('lore')
   .description('Persistent project memory for developers')
   .version('0.1.0')
-  .action(() => program.outputHelp());
+  .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');
+
+    const LORE_LOGO = `
+    ██╗      ██████╗ ██████╗ ███████╗
+    ██║     ██╔═══██╗██╔══██╗██╔════╝
+    ██║     ██║   ██║██████╔╝█████╗  
+    ██║     ██║   ██║██╔══██╗██╔══╝  
+    ███████╗╚██████╔╝██║  ██║███████╗
+    ╚══════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝
+    `;
+
+    console.log(chalk.cyan(LORE_LOGO));
+    console.log(chalk.dim('    Project Memory for Developers\n'));
+
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          { name: '📝 Log new knowledge (lore log)', value: 'log' },
+          { 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: '🌐 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' },
+          { name: '❌ Exit', value: 'exit' }
+        ],
+      },
+    ]);
+
+    if (action === 'exit') {
+      process.exit(0);
+    } else if (action === 'help') {
+      program.outputHelp();
+    } else {
+      console.log();
+      try {
+        execSync(`node ${__filename} ${action}`, { stdio: 'inherit' });
+      } catch (e) { }
+    }
+  });
+
+// Fuzzy matching for unknown commands
+program.on('command:*', function (operands) {
+  const chalk = require('chalk');
+  console.error(chalk.red(`error: unknown command '${operands[0]}'`));
+  const availableCommands = program.commands.map(cmd => cmd.name());
+
+  // Simple Levenshtein distance check for did-you-mean
+  let closest = null;
+  let minDistance = 3; // only suggest if distance < 3
+
+  for (const cmd of availableCommands) {
+    let distance = 0;
+    const a = operands[0];
+    const b = cmd;
+    const matrix = Array(b.length + 1).fill(null).map(() => Array(a.length + 1).fill(null));
+    for (let i = 0; i <= a.length; i += 1) { matrix[0][i] = i; }
+    for (let j = 0; j <= b.length; j += 1) { matrix[j][0] = j; }
+    for (let j = 1; j <= b.length; j += 1) {
+      for (let i = 1; i <= a.length; i += 1) {
+        const indicator = a[i - 1] === b[j - 1] ? 0 : 1;
+        matrix[j][i] = Math.min(
+          matrix[j][i - 1] + 1,
+          matrix[j - 1][i] + 1,
+          matrix[j - 1][i - 1] + indicator
+        );
+      }
+    }
+    distance = matrix[b.length][a.length];
+
+    if (distance < minDistance) {
+      minDistance = distance;
+      closest = cmd;
+    }
+  }
+
+  if (closest) {
+    console.log();
+    console.log(chalk.yellow(`Did you mean ${chalk.bold('lore ' + closest)}?`));
+  }
+  process.exitCode = 1;
+});
 
 program
   .command('init')
@@ -105,4 +196,10 @@ 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.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lore-memory",
-  "version": "0.1.1",
+  "version": "0.3.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/drafts.js

@@ -38,8 +38,7 @@ async function drafts(options) {
 
   console.log(chalk.cyan(`\n📖 ${pending.length} pending draft${pending.length === 1 ? '' : 's'}\n`));
 
-  for (let i = 0; i < pending.length; i++) {
-    const draft = pending[i];
+  const choices = pending.map((draft, i) => {
     const conf = Math.round((draft.confidence || 0) * 100);
     const typeColor = {
       decision: chalk.blue,
@@ -48,97 +47,74 @@ async function drafts(options) {
       graveyard: chalk.dim,
     }[draft.suggestedType] || chalk.white;
 
-    console.log(chalk.cyan(`[${i + 1}/${pending.length}] SUGGESTED: ${typeColor(draft.suggestedType.toUpperCase())}  (confidence: ${conf}%)`));
-    console.log(`  ${chalk.bold('Title:')}    ${draft.suggestedTitle}`);
-    console.log(`  ${chalk.bold('Evidence:')} ${draft.evidence}`);
-    if (draft.files && draft.files.length > 0) {
-      console.log(`  ${chalk.bold('Files:')}    ${draft.files.join(', ')}`);
+    // Create a nicely formatted display string
+    const title = draft.suggestedTitle.length > 50 ? draft.suggestedTitle.slice(0, 47) + '...' : draft.suggestedTitle;
+    const display = `${typeColor(draft.suggestedType.toUpperCase().padEnd(9))} | ${title.padEnd(50)} | Conf: ${conf}%`;
+
+    return {
+      name: display,
+      value: draft,
+      checked: conf >= 80 // Pre-check high confidence ones
+    };
+  });
+
+  let selectedDrafts;
+  try {
+    const ans = await inquirer.prompt([{
+      type: 'checkbox',
+      name: 'selected',
+      message: 'Select drafts to ACCEPT (unselected drafts will be kept pending):',
+      choices: choices,
+      pageSize: 15
+    }]);
+    selectedDrafts = ans.selected;
+  } catch (e) {
+    console.log(chalk.yellow('\nAborted.'));
+    return;
+  }
+
+  if (selectedDrafts.length === 0) {
+    console.log(chalk.yellow('\nNo drafts selected. Keeping all drafts pending.'));
+  } else {
+    console.log(chalk.cyan(`\nAccepting ${selectedDrafts.length} drafts...`));
+    for (const draft of selectedDrafts) {
+      const entry = acceptDraft(draft.draftId);
+      console.log(chalk.green(`  ✓ ${draft.suggestedTitle} -> Saved as ${entry.id}`));
     }
-    console.log();
+  }
 
-    let done = false;
-    while (!done) {
-      let action;
-      try {
-        const ans = await inquirer.prompt([{
-          type: 'list',
-          name: 'action',
-          message: 'Action:',
-          choices: [
-            { name: '[a] Accept', value: 'accept' },
-            { name: '[e] Edit then save', value: 'edit' },
-            { name: '[s] Skip', value: 'skip' },
-            { name: '[d] Delete', value: 'delete' },
-            { name: '[q] Quit', value: 'quit' },
-          ],
-        }]);
-        action = ans.action;
-      } catch (e) {
-        console.log(chalk.yellow('\nAborted.'));
-        return;
-      }
+  // Ask about deletions for remaining
+  const remainingDrafts = pending.filter(p => !selectedDrafts.find(s => s.draftId === p.draftId));
+
+  if (remainingDrafts.length > 0) {
+    console.log();
+    let deleteSelection;
+    try {
+      const deleteAns = await inquirer.prompt([{
+        type: 'checkbox',
+        name: 'deletes',
+        message: 'Select drafts to permanently DELETE:',
+        choices: remainingDrafts.map(draft => ({
+          name: `${draft.suggestedType.toUpperCase().padEnd(9)} | ${draft.suggestedTitle}`,
+          value: draft
+        })),
+        pageSize: 10
+      }]);
+      deleteSelection = deleteAns.deletes;
+    } catch (e) {
+      return;
+    }
 
-      if (action === 'accept') {
-        const entry = acceptDraft(draft.draftId);
-        console.log(chalk.green(`  ✓ Saved as ${entry.id}`));
-        done = true;
-      } else if (action === 'edit') {
-        let edited;
-        try {
-          edited = await inquirer.prompt([
-            {
-              type: 'list',
-              name: 'type',
-              message: 'Type:',
-              choices: ['decision', 'invariant', 'gotcha', 'graveyard'],
-              default: draft.suggestedType,
-            },
-            {
-              type: 'input',
-              name: 'title',
-              message: 'Title:',
-              default: draft.suggestedTitle,
-            },
-            {
-              type: 'input',
-              name: 'context',
-              message: 'Context:',
-              default: draft.evidence,
-            },
-          ]);
-        } catch (e) {
-          console.log(chalk.yellow('\nAborted.'));
-          return;
-        }
-
-        // Update draft on disk, then accept
-        const draftPath = path.join(LORE_DIR, 'drafts', `${draft.draftId}.json`);
-        fs.writeJsonSync(draftPath, {
-          ...draft,
-          suggestedType: edited.type,
-          suggestedTitle: edited.title,
-          evidence: edited.context,
-        }, { spaces: 2 });
-
-        const entry = acceptDraft(draft.draftId);
-        console.log(chalk.green(`  ✓ Saved as ${entry.id}`));
-        done = true;
-      } else if (action === 'skip') {
-        console.log(chalk.dim('  Skipped'));
-        done = true;
-      } else if (action === 'delete') {
+    if (deleteSelection.length > 0) {
+      console.log(chalk.yellow(`\nDeleting ${deleteSelection.length} drafts...`));
+      for (const draft of deleteSelection) {
         deleteDraft(draft.draftId);
-        console.log(chalk.dim('  Deleted'));
-        done = true;
-      } else if (action === 'quit') {
-        console.log(chalk.cyan('\n  Remaining drafts saved. Run: lore drafts'));
-        return;
+        console.log(chalk.dim(`  ✗ Deleted: ${draft.suggestedTitle}`));
       }
     }
-    console.log();
   }
 
-  console.log(chalk.green('✓ All drafts reviewed'));
+  console.log(chalk.green('\n✓ Draft review complete'));
 }
 
 module.exports = drafts;

package/src/commands/init.js

@@ -9,10 +9,13 @@ 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
-  echo "📖 Lore: Significant change detected. Log it? (y/n)"
-  read -r answer </dev/tty
-  if [ "$answer" = "y" ]; then
-    lore log </dev/tty
+  # 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
 `;

package/src/commands/log.js

@@ -108,7 +108,7 @@ async function log(options) {
       id,
       type,
       title,
-      date: new Date().toISOString().split('T')[0],
+      date: new Date().toISOString(),
       files,
       context,
       alternatives: alternatives.filter(Boolean),

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

@@ -2,22 +2,73 @@
 
 const chalk = require('chalk');
 
+function drawBox(content, colorFn, title) {
+  const lines = content.split('\n');
+  const maxLen = Math.max(
+    ...lines.map(l => l.replace(/\x1B\[[0-9;]*m/g, '').length),
+    title ? title.length + 4 : 0
+  );
+
+  const width = Math.min(80, Math.max(40, maxLen + 2)); // keep between 40 and 80 width
+
+  const top = title
+    ? `╭─ ${title} ${'─'.repeat(Math.max(0, width - title.length - 4))}╮`
+    : `╭${'─'.repeat(width)}╮`;
+
+  console.log(colorFn(top));
+
+  for (const line of lines) {
+    const cleanLen = line.replace(/\x1B\[[0-9;]*m/g, '').length;
+    const padding = ' '.repeat(Math.max(0, width - cleanLen - 2));
+    console.log(colorFn('│ ') + line + padding + colorFn(' │'));
+  }
+
+  console.log(colorFn(`╰${'─'.repeat(width)}╯\n`));
+}
+
 function printEntry(entry) {
+  let content = '';
+
+  let colorFn = chalk.white;
+  let titleColor = chalk.bold.white;
+
+  if (entry.type === 'decision') { colorFn = chalk.cyan; titleColor = chalk.bold.cyan; }
+  else if (entry.type === 'invariant') { colorFn = chalk.red; titleColor = chalk.bold.red; }
+  else if (entry.type === 'gotcha') { colorFn = chalk.yellow; titleColor = chalk.bold.yellow; }
+  else if (entry.type === 'graveyard') { colorFn = chalk.gray; titleColor = chalk.bold.gray; }
+
   const typeLabel = `[${entry.type.toUpperCase()}]`;
-  console.log(chalk.bold(`${typeLabel} ${entry.title}`) + chalk.gray(` (${entry.date})`));
-  console.log(`  → ${entry.context}`);
+  content += `${titleColor(typeLabel)} ${titleColor(entry.title)} ${chalk.gray('(' + entry.date + ')')}\n\n`;
+
+  // Wrap context text roughly
+  const contextWords = entry.context.split(' ');
+  let currentLine = '';
+  for (const word of contextWords) {
+    if (currentLine.length + word.length > 70) {
+      content += chalk.white(currentLine) + '\n';
+      currentLine = word + ' ';
+    } else {
+      currentLine += word + ' ';
+    }
+  }
+  if (currentLine) content += chalk.white(currentLine) + '\n';
 
   if (entry.alternatives && entry.alternatives.length > 0) {
+    content += '\n' + chalk.yellow('Alternatives Considered:\n');
     for (const alt of entry.alternatives) {
-      console.log(chalk.yellow(`  → Rejected: ${alt}`));
+      content += chalk.yellow(`  → ${alt}\n`);
     }
   }
 
   if (entry.tradeoffs) {
-    console.log(chalk.gray(`  → Tradeoffs: ${entry.tradeoffs}`));
+    content += '\n' + chalk.magenta(`Tradeoffs: ${entry.tradeoffs}\n`);
+  }
+
+  if (entry.files && entry.files.length > 0) {
+    content += '\n' + chalk.dim(`Files: ${entry.files.join(', ')}\n`);
   }
 
-  console.log();
+  drawBox(content.trim(), colorFn, entry.id);
 }
 
 module.exports = { printEntry };

package/src/mcp/tools/overview.js

@@ -45,6 +45,11 @@ async function handler(args) {
       }
     }
 
+    // Sort entries newest-first
+    for (const type of Object.keys(byType)) {
+      byType[type].sort((a, b) => new Date(b.date || 0) - new Date(a.date || 0));
+    }
+
     const lines = [];
     const projectName = config.project || 'this project';
 

package/src/mcp/tools/search.js

@@ -49,10 +49,20 @@ async function handler(args) {
       ].join(' ').toLowerCase();
 
       if (searchable.includes(q)) {
-        matches.push(entry);
+        // Calculate a basic relevance score for text search:
+        // 1. Term frequency of query
+        const tf = (searchable.match(new RegExp(q, 'g')) || []).length;
+        // 2. Bonus for newer entries
+        const ageDays = (Date.now() - new Date(entry.date || 0)) / (1000 * 60 * 60 * 24);
+        const recencyBonus = Math.max(0, 5 - (ageDays / 30)); // up to +5 points for newest
+
+        matches.push(Object.assign({}, entry, { _score: tf + recencyBonus }));
       }
     }
 
+    // Sort matches by relevance score descending
+    matches.sort((a, b) => (b._score || 0) - (a._score || 0));
+
     // Try semantic search if text search found nothing and embeddings exist
     if (matches.length === 0) {
       try {