lore-memory 0.1.1 → 0.2.0

package/bin/lore.js

@@ -9,7 +9,94 @@ program
   .name('lore')
   .description('Persistent project memory for developers')
   .version('0.1.0')
-  .action(() => program.outputHelp());
+  .action(async () => {
+    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: '⚙️  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')

package/package.json

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

package/src/watcher/comments.js

@@ -47,11 +47,11 @@ function extractComments(code, filePath) {
  * Saves passing comments as drafts.
  * @param {string} absFilePath
  * @param {string} projectRoot
- * @returns {object[]} created drafts
+ * @returns {Promise<object[]>} created drafts
  */
-function mineFile(absFilePath, projectRoot) {
+async function mineFile(absFilePath, projectRoot) {
   let code = '';
-  try { code = fs.readFileSync(absFilePath, 'utf8'); } catch (e) { return []; }
+  try { code = await fs.readFile(absFilePath, 'utf8'); } catch (e) { return []; }
 
   const relativePath = path.relative(projectRoot, absFilePath).replace(/\\/g, '/');
   const comments = extractComments(code, absFilePath);

package/src/watcher/index.js

@@ -29,9 +29,9 @@ function startWatcher(options = {}) {
 
   const log = options.logFile
     ? (msg) => {
-        const plain = msg.replace(/\x1B\[[0-9;]*m/g, '');
-        fs.appendFileSync(options.logFile, `${new Date().toISOString()} ${plain}\n`);
-      }
+      const plain = msg.replace(/\x1B\[[0-9;]*m/g, '');
+      fs.appendFileSync(options.logFile, `${new Date().toISOString()} ${plain}\n`);
+    }
     : (msg) => console.log(msg);
 
   if (!options.quiet) {
@@ -56,46 +56,46 @@ function startWatcher(options = {}) {
     awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 },
   });
 
-  watcher.on('unlink', (relPath) => {
+  watcher.on('unlink', async (relPath) => {
     const abs = path.join(projectRoot, relPath);
-    const draft = signals.onFileDeletion(abs, projectRoot);
+    const draft = await signals.onFileDeletion(abs, projectRoot);
     if (draft) recordDraft(draft, abs);
   });
 
-  watcher.on('unlinkDir', (relPath) => {
+  watcher.on('unlinkDir', async (relPath) => {
     const abs = path.join(projectRoot, relPath);
-    const draft = signals.onDirectoryDeletion(abs, projectRoot);
+    const draft = await signals.onDirectoryDeletion(abs, projectRoot);
     if (draft) recordDraft(draft, abs);
   });
 
-  watcher.on('add', (relPath) => {
+  watcher.on('add', async (relPath) => {
     const abs = path.join(projectRoot, relPath);
-    const draft = signals.onNewFile(abs, projectRoot);
+    const draft = await signals.onNewFile(abs, projectRoot);
     if (draft) recordDraft(draft, abs);
   });
 
-  watcher.on('change', (relPath) => {
+  watcher.on('change', async (relPath) => {
     const abs = path.join(projectRoot, relPath);
 
     // Repeated edit tracking
-    const editDraft = signals.trackFileEdit(abs, projectRoot);
+    const editDraft = await signals.trackFileEdit(abs, projectRoot);
     if (editDraft) recordDraft(editDraft, abs);
 
     // package.json changes
     if (relPath.endsWith('package.json')) {
-      const pkgDrafts = signals.onPackageJsonChange(abs, projectRoot);
+      const pkgDrafts = await signals.onPackageJsonChange(abs, projectRoot);
       for (const d of pkgDrafts) recordDraft(d, abs);
     }
 
     // Comment mining + graph update for source files
     if (/\.(js|ts|jsx|tsx|py|go|rs)$/.test(relPath)) {
-      const commentDrafts = mineFile(abs, projectRoot);
+      const commentDrafts = await mineFile(abs, projectRoot);
       if (commentDrafts.length > 0) {
         draftCount += commentDrafts.length;
         log(`${chalk.dim(`[${timestamp()}]`)} Mined ${commentDrafts.length} comment${commentDrafts.length === 1 ? '' : 's'} from ${chalk.yellow(relPath)} — queued for review`);
       }
 
-      try { updateGraphForFile(abs, projectRoot); } catch (e) {}
+      try { updateGraphForFile(abs, projectRoot); } catch (e) { }
     }
   });
 
@@ -104,15 +104,15 @@ function startWatcher(options = {}) {
   let gitWatcher = null;
   if (fs.existsSync(path.join(projectRoot, '.git'))) {
     gitWatcher = chokidar.watch(commitMsgPath, { persistent: true, ignoreInitial: true });
-    gitWatcher.on('change', () => {
+    gitWatcher.on('change', async () => {
       try {
-        const message = fs.readFileSync(commitMsgPath, 'utf8').trim();
-        const drafts = signals.onCommitMessage(message, projectRoot);
+        const message = await fs.readFile(commitMsgPath, 'utf8');
+        const drafts = await signals.onCommitMessage(message.trim(), projectRoot);
         for (const d of drafts) {
           draftCount++;
           log(`${chalk.dim(`[${timestamp()}]`)} Commit signal: "${message.slice(0, 60)}" — queued for review`);
         }
-      } catch (e) {}
+      } catch (e) { }
     });
   }
 

package/src/watcher/signals.js

@@ -22,7 +22,7 @@ function makeDraft(overrides) {
   };
 }
 
-function onFileDeletion(filepath, projectRoot) {
+async function onFileDeletion(filepath, projectRoot) {
   const relativePath = path.relative(projectRoot, filepath).replace(/\\/g, '/');
 
   // Try to check line count via git
@@ -32,7 +32,7 @@ function onFileDeletion(filepath, projectRoot) {
       encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
     });
     lines = parseInt(out.trim(), 10) || 0;
-  } catch (e) {}
+  } catch (e) { }
 
   if (lines > 0 && lines < 100) return null;
 
@@ -48,7 +48,7 @@ function onFileDeletion(filepath, projectRoot) {
   return draft;
 }
 
-function onDirectoryDeletion(dirpath, projectRoot) {
+async function onDirectoryDeletion(dirpath, projectRoot) {
   const relativePath = path.relative(projectRoot, dirpath).replace(/\\/g, '/');
   const name = path.basename(relativePath);
   const draft = makeDraft({
@@ -62,7 +62,7 @@ function onDirectoryDeletion(dirpath, projectRoot) {
   return draft;
 }
 
-function onNewFile(filepath, projectRoot) {
+async function onNewFile(filepath, projectRoot) {
   const relativePath = path.relative(projectRoot, filepath).replace(/\\/g, '/');
   const name = path.basename(relativePath);
   const lower = name.toLowerCase();
@@ -97,7 +97,7 @@ function onNewFile(filepath, projectRoot) {
   return null;
 }
 
-function onPackageJsonChange(filepath, projectRoot) {
+async function onPackageJsonChange(filepath, projectRoot) {
   const relativePath = path.relative(projectRoot, filepath).replace(/\\/g, '/');
   if (!relativePath.endsWith('package.json')) return [];
 
@@ -108,9 +108,9 @@ function onPackageJsonChange(filepath, projectRoot) {
       encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
     });
     prev = JSON.parse(prevRaw);
-  } catch (e) {}
+  } catch (e) { }
 
-  try { curr = fs.readJsonSync(filepath); } catch (e) { return []; }
+  try { curr = await fs.readJson(filepath); } catch (e) { return []; }
 
   const prevDeps = Object.assign({}, prev.dependencies || {}, prev.devDependencies || {});
   const currDeps = Object.assign({}, curr.dependencies || {}, curr.devDependencies || {});
@@ -143,7 +143,7 @@ function onPackageJsonChange(filepath, projectRoot) {
   return drafts;
 }
 
-function onCommitMessage(message, projectRoot) {
+async function onCommitMessage(message, projectRoot) {
   const lower = message.toLowerCase();
   const signals = [
     { re: /\b(replac|switch(ed|ing)|migrat)\b/, type: 'decision', confidence: 0.8 },
@@ -171,12 +171,12 @@ function onCommitMessage(message, projectRoot) {
 }
 
 // Track repeated edits to detect gotcha-worthy files
-function trackFileEdit(filepath, projectRoot) {
+async function trackFileEdit(filepath, projectRoot) {
   const relativePath = path.relative(projectRoot, filepath).replace(/\\/g, '/');
   const statePath = path.join(LORE_DIR, 'watch-state.json');
 
   let state = { edits: {} };
-  try { state = fs.readJsonSync(statePath); } catch (e) {}
+  try { state = await fs.readJson(statePath); } catch (e) { }
   if (!state.edits) state.edits = {};
 
   const now = Date.now();
@@ -186,7 +186,7 @@ function trackFileEdit(filepath, projectRoot) {
   state.edits[relativePath].push(now);
   state.edits[relativePath] = state.edits[relativePath].filter(t => t > weekAgo);
 
-  try { fs.writeJsonSync(statePath, state, { spaces: 2 }); } catch (e) {}
+  try { await fs.writeJson(statePath, state, { spaces: 2 }); } catch (e) { }
 
   if (state.edits[relativePath].length >= 5) {
     const name = path.basename(relativePath);
@@ -201,7 +201,7 @@ function trackFileEdit(filepath, projectRoot) {
     saveDraft(draft);
     // Reset to avoid spam
     state.edits[relativePath] = [];
-    try { fs.writeJsonSync(statePath, state, { spaces: 2 }); } catch (e) {}
+    try { await fs.writeJson(statePath, state, { spaces: 2 }); } catch (e) { }
     return draft;
   }
   return null;