lore-memory 0.1.0

package/src/watcher/signals.js

@@ -0,0 +1,217 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+const { detectType, extractTitle } = require('../lib/nlp');
+const { saveDraft } = require('../lib/drafts');
+const { LORE_DIR } = require('../lib/index');
+
+function makeDraft(overrides) {
+  return {
+    draftId: `draft-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+    suggestedType: 'decision',
+    suggestedTitle: '',
+    evidence: '',
+    files: [],
+    confidence: 0.6,
+    createdAt: new Date().toISOString(),
+    status: 'pending',
+    source: 'signal',
+    ...overrides,
+  };
+}
+
+function onFileDeletion(filepath, projectRoot) {
+  const relativePath = path.relative(projectRoot, filepath).replace(/\\/g, '/');
+
+  // Try to check line count via git
+  let lines = 0;
+  try {
+    const out = execSync(`git show HEAD:"${relativePath}" 2>/dev/null | wc -l`, {
+      encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    lines = parseInt(out.trim(), 10) || 0;
+  } catch (e) {}
+
+  if (lines > 0 && lines < 100) return null;
+
+  const name = path.basename(relativePath, path.extname(relativePath));
+  const draft = makeDraft({
+    suggestedType: 'graveyard',
+    suggestedTitle: `Removed ${name}`,
+    evidence: `File deleted: ${relativePath}`,
+    files: [relativePath],
+    confidence: 0.6,
+  });
+  saveDraft(draft);
+  return draft;
+}
+
+function onDirectoryDeletion(dirpath, projectRoot) {
+  const relativePath = path.relative(projectRoot, dirpath).replace(/\\/g, '/');
+  const name = path.basename(relativePath);
+  const draft = makeDraft({
+    suggestedType: 'graveyard',
+    suggestedTitle: `Removed ${name} module`,
+    evidence: `Directory deleted: ${relativePath}`,
+    files: [relativePath + '/'],
+    confidence: 0.6,
+  });
+  saveDraft(draft);
+  return draft;
+}
+
+function onNewFile(filepath, projectRoot) {
+  const relativePath = path.relative(projectRoot, filepath).replace(/\\/g, '/');
+  const name = path.basename(relativePath);
+  const lower = name.toLowerCase();
+
+  const configRe = /^(\.env|config\.|settings\.|\.eslintrc|\.prettierrc|\.babelrc|jest\.config|webpack\.config|vite\.config|tsconfig)/;
+  if (configRe.test(lower)) {
+    const draft = makeDraft({
+      suggestedType: 'decision',
+      suggestedTitle: `Added ${name}`,
+      evidence: `New config file detected: ${relativePath}`,
+      files: [relativePath],
+      confidence: 0.6,
+    });
+    saveDraft(draft);
+    return draft;
+  }
+
+  const adapterRe = /(adapter|provider|connector|driver|handler|strategy|middleware)\.(js|ts|jsx|tsx)$/;
+  if (adapterRe.test(lower)) {
+    const base = name.replace(/\.(js|ts|jsx|tsx)$/, '');
+    const draft = makeDraft({
+      suggestedType: 'decision',
+      suggestedTitle: `Added ${base}`,
+      evidence: `New adapter/provider file added: ${relativePath}`,
+      files: [relativePath],
+      confidence: 0.6,
+    });
+    saveDraft(draft);
+    return draft;
+  }
+
+  return null;
+}
+
+function onPackageJsonChange(filepath, projectRoot) {
+  const relativePath = path.relative(projectRoot, filepath).replace(/\\/g, '/');
+  if (!relativePath.endsWith('package.json')) return [];
+
+  let prev = {};
+  let curr = {};
+  try {
+    const prevRaw = execSync(`git show HEAD:"${relativePath}"`, {
+      encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    prev = JSON.parse(prevRaw);
+  } catch (e) {}
+
+  try { curr = fs.readJsonSync(filepath); } catch (e) { return []; }
+
+  const prevDeps = Object.assign({}, prev.dependencies || {}, prev.devDependencies || {});
+  const currDeps = Object.assign({}, curr.dependencies || {}, curr.devDependencies || {});
+
+  const drafts = [];
+  for (const pkg of Object.keys(currDeps)) {
+    if (!prevDeps[pkg]) {
+      drafts.push(makeDraft({
+        suggestedType: 'decision',
+        suggestedTitle: `Added ${pkg} dependency`,
+        evidence: `New package added to package.json: ${pkg}@${currDeps[pkg]}`,
+        files: [relativePath],
+        confidence: 0.6,
+      }));
+    }
+  }
+  for (const pkg of Object.keys(prevDeps)) {
+    if (!currDeps[pkg]) {
+      drafts.push(makeDraft({
+        suggestedType: 'graveyard',
+        suggestedTitle: `Removed ${pkg} dependency`,
+        evidence: `Package removed from package.json: ${pkg}`,
+        files: [relativePath],
+        confidence: 0.6,
+      }));
+    }
+  }
+
+  for (const d of drafts) saveDraft(d);
+  return drafts;
+}
+
+function onCommitMessage(message, projectRoot) {
+  const lower = message.toLowerCase();
+  const signals = [
+    { re: /\b(replac|switch(ed|ing)|migrat)\b/, type: 'decision', confidence: 0.8 },
+    { re: /\b(remov|delet|drop(ped|ping))\b/, type: 'graveyard', confidence: 0.8 },
+    { re: /\b(revert|undo|rollback)\b/, type: 'graveyard', confidence: 0.8 },
+    { re: /\b(never|always|must|shall)\b/, type: 'invariant', confidence: 0.8 },
+  ];
+
+  for (const { re, type, confidence } of signals) {
+    if (re.test(lower)) {
+      const title = extractTitle(message) || message.slice(0, 50);
+      const draft = makeDraft({
+        suggestedType: type,
+        suggestedTitle: title,
+        evidence: `Commit message: "${message}"`,
+        files: [],
+        confidence,
+        source: 'commit-signal',
+      });
+      saveDraft(draft);
+      return [draft];
+    }
+  }
+  return [];
+}
+
+// Track repeated edits to detect gotcha-worthy files
+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) {}
+  if (!state.edits) state.edits = {};
+
+  const now = Date.now();
+  const weekAgo = now - 7 * 24 * 60 * 60 * 1000;
+
+  if (!state.edits[relativePath]) state.edits[relativePath] = [];
+  state.edits[relativePath].push(now);
+  state.edits[relativePath] = state.edits[relativePath].filter(t => t > weekAgo);
+
+  try { fs.writeJsonSync(statePath, state, { spaces: 2 }); } catch (e) {}
+
+  if (state.edits[relativePath].length >= 5) {
+    const name = path.basename(relativePath);
+    const draft = makeDraft({
+      suggestedType: 'gotcha',
+      suggestedTitle: `Frequent edits to ${name}`,
+      evidence: `${relativePath} edited ${state.edits[relativePath].length}× this week — may be a tricky area`,
+      files: [relativePath],
+      confidence: 0.4,
+      source: 'repeated-edit',
+    });
+    saveDraft(draft);
+    // Reset to avoid spam
+    state.edits[relativePath] = [];
+    try { fs.writeJsonSync(statePath, state, { spaces: 2 }); } catch (e) {}
+    return draft;
+  }
+  return null;
+}
+
+module.exports = {
+  onFileDeletion,
+  onDirectoryDeletion,
+  onNewFile,
+  onPackageJsonChange,
+  onCommitMessage,
+  trackFileEdit,
+};

package/src/watcher/staleness.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs-extra');
+const { readIndex } = require('../lib/index');
+const { readEntry } = require('../lib/entries');
+
+/**
+ * Pattern-based staleness checks — no Ollama needed.
+ * @param {object} entry
+ * @param {string} changedFile - relative path of changed file
+ * @param {string} changedCode - current content of changed file
+ * @returns {string[]} array of reason strings
+ */
+function checkPatternStaleness(entry, changedFile, changedCode) {
+  const reasons = [];
+  const context = (entry.context || '').toLowerCase();
+  const filename = path.basename(changedFile).toLowerCase();
+  const code = (changedCode || '').toLowerCase();
+
+  // Performance invariant + external HTTP added
+  if (entry.type === 'invariant' && /\d+ms/.test(context)) {
+    if (/fetch\(|axios\.|http\.get|https\.get|request\(/.test(code)) {
+      reasons.push('External HTTP call added to a performance-critical path');
+    }
+  }
+
+  // Decision about polling + websocket import
+  if (context.includes('polling') && /websocket|ws\.|socket\.io/.test(code)) {
+    reasons.push('Architecture may have shifted — is this decision still valid?');
+  }
+
+  // Decision mentions websocket + new websocket file added
+  if (context.includes('websocket') && filename.includes('websocket')) {
+    reasons.push('Your infra constraint may have changed');
+  }
+
+  // Graveyard entry for a package that may be re-added
+  if (entry.type === 'graveyard' && changedFile.endsWith('package.json')) {
+    const titleLower = entry.title.toLowerCase();
+    // Extract package name from graveyard title
+    const match = titleLower.match(/removed?\s+([\w-@/]+)\s+dep/);
+    if (match && code.includes(match[1])) {
+      reasons.push('This abandoned approach may have been re-introduced');
+    }
+  }
+
+  return reasons;
+}
+
+/**
+ * Semantic staleness check using embeddings.
+ * @param {object} entry
+ * @param {string} diff - summary of changes (function names + imports)
+ * @returns {Promise<string[]>}
+ */
+async function checkSemanticStaleness(entry, diff) {
+  try {
+    const { generateEmbedding, cosineSimilarity, getEmbedding } = require('../lib/embeddings');
+    const entryVec = getEmbedding(entry.id);
+    if (!entryVec) return [];
+
+    const diffVec = await generateEmbedding(diff);
+    const sim = cosineSimilarity(diffVec, entryVec);
+
+    if (sim > 0.6 && (entry.type === 'invariant' || entry.type === 'decision')) {
+      return [`Diff is semantically related to this ${entry.type} (${(sim * 100).toFixed(0)}% similarity)`];
+    }
+  } catch (e) {
+    // Ollama not available
+  }
+  return [];
+}
+
+/**
+ * Check all entries linked to a changed file for staleness signals.
+ * @param {string} changedFile - absolute path
+ * @param {string} projectRoot
+ * @param {string} changedCode
+ * @param {string|null} diff - optional diff text for semantic check
+ * @returns {Promise<Array<{entry, reasons}>>}
+ */
+async function checkFileStaleness(changedFile, projectRoot, changedCode, diff) {
+  const index = readIndex();
+  const relativePath = path.relative(projectRoot, path.resolve(changedFile)).replace(/\\/g, '/');
+
+  const entryIds = new Set();
+  if (index.files[relativePath]) index.files[relativePath].forEach(id => entryIds.add(id));
+
+  const results = [];
+  for (const id of entryIds) {
+    const entry = readEntry(index.entries[id]);
+    if (!entry) continue;
+
+    const patternReasons = checkPatternStaleness(entry, relativePath, changedCode);
+    const semanticReasons = diff ? await checkSemanticStaleness(entry, diff) : [];
+    const reasons = [...patternReasons, ...semanticReasons];
+    if (reasons.length > 0) results.push({ entry, reasons });
+  }
+
+  return results;
+}
+
+module.exports = { checkFileStaleness, checkPatternStaleness, checkSemanticStaleness };