mindlore 0.6.9 → 0.7.1

package/hooks/src/mindlore-index.cjs

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-index — FileChanged hook
+ *
+ * When a .md file in .mindlore/ changes, update its FTS5 entry.
+ * Reads changed file path from stdin (CC FileChanged event).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { safeMkdir, safeWriteFile } = require('../dist/scripts/lib/secure-io.js');
+const { DB_NAME, SKIP_FILES, sha256, openDatabase, parseFrontmatter, extractFtsMetadata, insertFtsRow, readHookStdin, getProjectName, resolveProject, globalDir, hookLog, withTelemetry, isInsideMindloreDir, extractMindloreBaseDir } = require('./lib/mindlore-common.cjs');
+
+function invalidateSearchCache(db) {
+  try { db.exec('DELETE FROM search_cache'); } catch (_) { /* table may not exist */ }
+}
+
+function main() {
+  const filePath = readHookStdin(['path', 'file_path']);
+  if (!filePath) return;
+
+  // Only process .md files inside .mindlore/ (resolved path check prevents traversal)
+  if (!filePath.endsWith('.md')) return;
+  const resolvedFile = path.resolve(filePath);
+  if (!isInsideMindloreDir(resolvedFile)) {
+    // CC memory path (~/.claude/projects/*/memory/*.md) — index to global mindlore DB
+    const isCcMemory = resolvedFile.includes(path.sep + '.claude' + path.sep + 'projects' + path.sep)
+      && resolvedFile.includes(path.sep + 'memory' + path.sep)
+      && resolvedFile.endsWith('.md');
+    if (!isCcMemory) return;
+
+    // CC memory path — index to global mindlore DB
+    indexCcMemory(resolvedFile);
+    return;
+  }
+
+  const fileName = path.basename(filePath);
+
+  const baseDir = extractMindloreBaseDir(resolvedFile);
+  if (!baseDir) return;
+  const dbPath = path.join(baseDir, DB_NAME);
+
+  if (!fs.existsSync(dbPath)) return;
+
+  // Catch-up scan: when INDEX.md or log.md triggers, index recently-modified files
+  if (['INDEX.md', 'log.md'].includes(fileName)) {
+    catchUpScan(baseDir, dbPath);
+    return;
+  }
+
+  if (SKIP_FILES.has(fileName)) return;
+
+  if (!fs.existsSync(filePath)) {
+    // File was deleted — remove from index
+    const db = openDatabase(dbPath);
+    if (!db) return;
+    try {
+      db.prepare('DELETE FROM mindlore_fts WHERE path = ?').run(filePath);
+      db.prepare('DELETE FROM file_hashes WHERE path = ?').run(filePath);
+      invalidateSearchCache(db);
+    } finally {
+      db.close();
+    }
+    return;
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+  const hash = sha256(content);
+
+  const db = openDatabase(dbPath);
+  if (!db) return;
+
+  try {
+    // Check if content changed
+    const existing = db
+      .prepare('SELECT content_hash FROM file_hashes WHERE path = ?')
+      .get(filePath);
+
+    if (existing && existing.content_hash === hash) return; // Unchanged
+
+    // Parse frontmatter for rich FTS5 columns
+    const { meta, body } = parseFrontmatter(content);
+    const { slug, description, type, category, title, tags, quality, dateCaptured, project: ftsProject } = extractFtsMetadata(meta, body, filePath, baseDir);
+
+    // Update FTS5 + hash atomically
+    const updateIndex = db.transaction(() => {
+      db.prepare('DELETE FROM mindlore_fts WHERE path = ?').run(filePath);
+      insertFtsRow(db, { path: filePath, slug, description, type, category, title, content: body, tags, quality, dateCaptured, project: resolveProject(ftsProject, filePath, getProjectName()) });
+      db.prepare(
+        `INSERT INTO file_hashes (path, content_hash, last_indexed)
+         VALUES (?, ?, ?)
+         ON CONFLICT(path) DO UPDATE SET
+           content_hash = excluded.content_hash,
+           last_indexed = excluded.last_indexed`
+      ).run(filePath, hash, new Date().toISOString());
+    });
+    updateIndex();
+    invalidateSearchCache(db);
+  } finally {
+    db.close();
+  }
+}
+
+function indexCcMemory(filePath) {
+  const CC_MEMORY_CATEGORY = 'cc-memory';
+  // CC memory constants live in TS (scripts/lib/constants.ts) — CJS hooks can't require TS directly
+  const globalBase = globalDir();
+  const dbPath = path.join(globalBase, DB_NAME);
+
+  const content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+  if (!content.trim()) return;
+
+  // Privacy filter — redact secrets before DB write
+  let cleaned = content;
+  try {
+    const { redactSecrets } = require('../dist/scripts/lib/privacy-filter.js');
+    cleaned = redactSecrets(content);
+  } catch (_err) {
+    // privacy-filter not built — use raw content
+  }
+
+  // SHA256 dedup
+  const hash = sha256(cleaned);
+  const db = openDatabase(dbPath);
+  if (!db) return;
+
+  try {
+    const existing = db.prepare('SELECT content_hash FROM file_hashes WHERE path = ?').get(filePath);
+    if (existing && existing.content_hash === hash) {
+      return; // unchanged — finally handles db.close()
+    }
+
+    const { meta, body } = parseFrontmatter(cleaned);
+    const memType = String(meta.type || 'unknown');
+
+    // Extract project scope from path: ~/.claude/projects/C--Users-X-proj/memory/
+    const projMatch = filePath.match(/projects[/\\]([^/\\]+)[/\\]memory/);
+    const projectScope = projMatch ? projMatch[1] : null;
+
+    const ftsData = extractFtsMetadata(meta, body, filePath, globalBase);
+
+    // Update FTS5 + hash atomically
+    const updateIndex = db.transaction(() => {
+      db.prepare('DELETE FROM mindlore_fts WHERE path = ?').run(filePath);
+      insertFtsRow(db, {
+        path: filePath,
+        ...ftsData,
+        category: CC_MEMORY_CATEGORY,
+        type: memType,
+        project: projectScope,
+      });
+      db.prepare(
+        `INSERT INTO file_hashes (path, content_hash, last_indexed, source_type, project_scope)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(path) DO UPDATE SET
+           content_hash = excluded.content_hash,
+           last_indexed = excluded.last_indexed,
+           source_type = excluded.source_type,
+           project_scope = excluded.project_scope`
+      ).run(filePath, hash, new Date().toISOString(), CC_MEMORY_CATEGORY, projectScope);
+    });
+    updateIndex();
+
+    // Copy to ~/.mindlore/memory/{project}/ for git-sync + obsidian
+    const memoryDir = path.join(globalBase, 'memory', projectScope || '_global');
+    safeMkdir(memoryDir);
+    const destPath = path.join(memoryDir, path.basename(filePath));
+    safeWriteFile(destPath, cleaned);
+  } finally {
+    db.close();
+  }
+}
+
+function catchUpScan(baseDir, dbPath) {
+  const CATCH_UP_DIRS = ['raw', 'sources', 'analyses', 'diary'];
+  const fiveMinAgo = Date.now() - 5 * 60 * 1000;
+
+  const db = openDatabase(dbPath);
+  if (!db) return;
+
+  try {
+    let indexed = 0;
+    for (const dir of CATCH_UP_DIRS) {
+      const dirPath = path.join(baseDir, dir);
+      if (!fs.existsSync(dirPath)) continue;
+
+      const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.md'));
+      for (const file of files) {
+        const filePath = path.join(dirPath, file);
+        const stat = fs.statSync(filePath);
+        if (stat.mtimeMs < fiveMinAgo) continue;
+
+        const content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+        const hash = sha256(content);
+
+        const existing = db.prepare('SELECT content_hash FROM file_hashes WHERE path = ?').get(filePath);
+        if (existing && existing.content_hash === hash) continue;
+
+        const { meta, body } = parseFrontmatter(content);
+        const ftsData = extractFtsMetadata(meta, body, filePath, baseDir);
+
+        const update = db.transaction(() => {
+          db.prepare('DELETE FROM mindlore_fts WHERE path = ?').run(filePath);
+          insertFtsRow(db, { path: filePath, ...ftsData, project: resolveProject(ftsData.project, filePath, getProjectName()) });
+          db.prepare(
+            `INSERT INTO file_hashes (path, content_hash, last_indexed)
+             VALUES (?, ?, ?)
+             ON CONFLICT(path) DO UPDATE SET
+               content_hash = excluded.content_hash,
+               last_indexed = excluded.last_indexed`
+          ).run(filePath, hash, new Date().toISOString());
+        });
+        update();
+        indexed++;
+      }
+    }
+    if (indexed > 0) {
+      hookLog(`catch-up: ${indexed} file(s) indexed`);
+    }
+  } finally {
+    db.close();
+  }
+}
+
+withTelemetry('mindlore-index', main).catch(err => {
+  hookLog('mindlore-index', 'error', err?.message ?? String(err));
+  process.exit(0);
+});

package/hooks/src/mindlore-model-router.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+/**
+ * mindlore-model-router — PreToolUse (Agent) hook
+ * Overrides model for [mindlore:SKILL] marked Agent spawns.
+ */
+
+const fs = require('fs');
+const { findMindloreDir, readConfig, DEFAULT_MODELS, hookLog, withTelemetrySync } = require('./lib/mindlore-common.cjs');
+
+const SKILL_KEYS = Object.keys(DEFAULT_MODELS).filter((k) => k !== 'default');
+const MARKER_REGEX = new RegExp(`\\[mindlore:(${SKILL_KEYS.join('|')})\\]`);
+
+function main() {
+  const mindloreDir = findMindloreDir();
+  if (!mindloreDir) return;
+
+  let input;
+  try {
+    const raw = fs.readFileSync(0, 'utf8').trim();
+    if (!raw) return;
+    input = JSON.parse(raw);
+  } catch (_err) {
+    return;
+  }
+
+  const toolName = input.tool_name || '';
+  if (toolName !== 'Agent') return;
+
+  const toolInput = input.tool_input || {};
+  const prompt = toolInput.prompt || '';
+  const match = prompt.match(MARKER_REGEX);
+  if (!match) return;
+
+  const skill = match[1];
+
+  // Resolve model: config.json → config default → hardcoded
+  const config = readConfig(mindloreDir);
+  const models = (config && config.models) || {};
+  const model = models[skill] || models.default || DEFAULT_MODELS[skill] || DEFAULT_MODELS.default;
+
+  const updatedInput = { ...toolInput, model: model };
+
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      updatedInput: updatedInput,
+    },
+  };
+
+  process.stdout.write(JSON.stringify(output));
+}
+
+try { withTelemetrySync('mindlore-model-router', main); } catch (err) { hookLog('model-router', 'error', err?.message ?? String(err)); }

package/hooks/src/mindlore-post-compact.cjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-post-compact — PostCompact hook
+ *
+ * After context compaction, re-inject session context:
+ * 1. Read INDEX.md
+ * 2. Read latest delta
+ * 3. Inject via stdout (same as session-focus)
+ *
+ * This ensures the agent has knowledge context after compaction.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { findMindloreDir, getLatestDelta, readConfig, hookLog, withTelemetry } = require('./lib/mindlore-common.cjs');
+
+function main() {
+  const baseDir = findMindloreDir();
+  if (!baseDir) return;
+
+  const output = [];
+
+  // Re-inject INDEX.md
+  const indexPath = path.join(baseDir, 'INDEX.md');
+  if (fs.existsSync(indexPath)) {
+    const content = fs.readFileSync(indexPath, 'utf8').trim();
+    output.push(`[Mindlore INDEX (post-compact)]\n${content}`);
+  }
+
+  const diaryDir = path.join(baseDir, 'diary');
+
+  const latestDelta = getLatestDelta(diaryDir);
+  if (latestDelta) {
+    const deltaContent = fs.readFileSync(latestDelta, 'utf8').trim();
+    const deltaName = path.basename(latestDelta);
+    output.push(`[Mindlore Delta (post-compact): ${deltaName}]\n${deltaContent}`);
+  }
+
+  try {
+    const snapshots = fs.readdirSync(diaryDir)
+      .filter(f => f.startsWith('compaction-snapshot-'))
+      .sort();
+    if (snapshots.length > 0) {
+      const latestSnapshot = snapshots[snapshots.length - 1];
+      const snapshotContent = fs.readFileSync(
+        path.join(diaryDir, latestSnapshot), 'utf8'
+      ).trim();
+      output.push(`[Mindlore Compaction Resume]\n${snapshotContent}`);
+    }
+  } catch (_err) { /* snapshot best-effort */ }
+
+  if (output.length > 0) {
+    const config = readConfig(baseDir);
+    const budgetConfig = config?.tokenBudget ?? {};
+    const maxInjectChars = (budgetConfig.sessionInject || 2000) * 4;
+    let joined = output.join('\n\n');
+    if (joined.length > maxInjectChars) {
+      joined = joined.slice(0, maxInjectChars) + '\n[...truncated by token budget]';
+    }
+    process.stdout.write(joined + '\n');
+  }
+}
+
+withTelemetry('mindlore-post-compact', main).catch(err => {
+  hookLog('mindlore-post-compact', 'error', err?.message ?? String(err));
+  process.exit(0);
+});

package/hooks/src/mindlore-post-read.cjs

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-post-read — PostToolUse hook (matcher: "Read")
+ *
+ * After a file is read, estimate its token count
+ * and store in _session-reads.json for the read-guard to reference.
+ *
+ * Outputs token estimate via additionalContext JSON.
+ * Also stores token info in _session-reads.json for read-guard.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { findMindloreDir, getProjectName, hookLog, withTelemetry } = require('./lib/mindlore-common.cjs');
+
+const CODE_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx', '.py', '.rs', '.go', '.java', '.c', '.cpp', '.h', '.css', '.scss', '.sql', '.sh', '.yaml', '.yml', '.json', '.toml', '.xml', '.cjs', '.mjs']);
+const PROSE_EXTS = new Set(['.md', '.txt', '.rst', '.adoc']);
+
+function estimateTokens(charCount, ext) {
+  const ratio = CODE_EXTS.has(ext) ? 3.5 : PROSE_EXTS.has(ext) ? 4.0 : 3.75;
+  return Math.ceil(charCount / ratio);
+}
+
+function main() {
+  const baseDir = findMindloreDir();
+  if (!baseDir) return;
+
+  let input = '';
+  const stdinTimeout = setTimeout(() => process.exit(0), 3000);
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('error', () => process.exit(0));
+  process.stdin.on('data', chunk => input += chunk);
+  process.stdin.on('end', () => {
+    clearTimeout(stdinTimeout);
+    try {
+      const data = JSON.parse(input || '{}');
+      const toolInput = data.tool_input || {};
+      const toolOutput = data.tool_output || {};
+
+      const filePath = toolInput.file_path || toolInput.path || '';
+      if (!filePath) return process.exit(0);
+
+      // Skip .mindlore/ internals
+      const resolved = path.resolve(filePath);
+      if (resolved.startsWith(path.resolve(baseDir))) return process.exit(0);
+
+      // Get content length from tool output or read file
+      let charCount = 0;
+      if (toolOutput.content) {
+        charCount = typeof toolOutput.content === 'string'
+          ? toolOutput.content.length
+          : JSON.stringify(toolOutput.content).length;
+      } else {
+        // Fallback: read file size
+        try {
+          const stat = fs.statSync(resolved);
+          charCount = stat.size;
+        } catch { return process.exit(0); }
+      }
+
+      if (charCount === 0) return process.exit(0);
+
+      const ext = path.extname(filePath).toLowerCase();
+      const tokens = estimateTokens(charCount, ext);
+
+      // Update _session-reads.json with token info
+      const diaryDir = path.join(baseDir, 'diary');
+      const readsPath = path.join(diaryDir, `_session-reads-${getProjectName()}.json`);
+      let reads = {};
+      if (fs.existsSync(readsPath)) {
+        try { reads = JSON.parse(fs.readFileSync(readsPath, 'utf8')); } catch { reads = {}; }
+      }
+
+      const normalizedPath = path.resolve(filePath);
+      const key = normalizedPath;
+
+      if (typeof reads[key] === 'number') {
+        // Upgrade from old format (just count) to new format (object)
+        reads[key] = { count: reads[key], tokens, chars: charCount };
+      } else if (reads[key] && typeof reads[key] === 'object') {
+        reads[key].tokens = tokens;
+        reads[key].chars = charCount;
+      } else {
+        reads[key] = { count: 1, tokens, chars: charCount };
+      }
+
+      fs.writeFileSync(readsPath, JSON.stringify(reads, null, 2), 'utf8');
+
+      // Output token estimate to Claude via additionalContext
+      const basename = path.basename(filePath);
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PostToolUse',
+          additionalContext: `[Mindlore: ${basename} — ~${tokens} token (${charCount} char). Edit etmeyeceksen ctx_execute_file kullan.]`
+        }
+      }));
+    } catch {
+      // Silent fail
+    }
+    process.exit(0);
+  });
+}
+
+withTelemetry('mindlore-post-read', main).catch(err => { hookLog('post-read', 'error', err?.message ?? String(err)); });

package/hooks/src/mindlore-pre-compact.cjs

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-pre-compact — PreCompact hook
+ *
+ * Before context compaction:
+ * 1. Ensure FTS5 index is up to date
+ * 2. Write pre-compact episode to episodes/ and append log entry
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { findMindloreDir, openDatabase, hookLog, withTelemetry, listSnapshots } = require('./lib/mindlore-common.cjs');
+
+function collectRecentEpisodes(baseDir) {
+  try {
+    const dbPath = path.join(baseDir, 'mindlore.db');
+    const db = openDatabase(dbPath, { readonly: true });
+    if (!db) return [];
+    try {
+      const episodes = db.prepare(
+        "SELECT kind, summary FROM episodes WHERE created_at > datetime('now', '-4 hours') ORDER BY created_at DESC LIMIT 20"
+      ).all();
+      if (episodes.length === 0) return [];
+      const grouped = {};
+      for (const ep of episodes) {
+        const kind = ep.kind || 'other';
+        if (!grouped[kind]) grouped[kind] = [];
+        grouped[kind].push(ep.summary);
+      }
+      const lines = ['## Session Episodes'];
+      for (const [kind, items] of Object.entries(grouped)) {
+        lines.push(`### ${kind}`);
+        for (const item of items) lines.push(`- ${item}`);
+      }
+      return lines;
+    } finally {
+      db.close();
+    }
+  } catch (_err) {
+    return [];
+  }
+}
+
+function collectGitDiff() {
+  try {
+    const { execFileSync } = require('child_process');
+    let diffStat = '';
+    try {
+      diffStat = execFileSync('git', ['diff', '--stat', 'HEAD'], { encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    } catch { diffStat = ''; }
+    if (diffStat) return ['## Changed Files (uncommitted)', '```', diffStat, '```'];
+    return [];
+  } catch (_err) {
+    return [];
+  }
+}
+
+function getActivePlan() {
+  try {
+    const plansDir = path.join(process.cwd(), '.claude', 'plans');
+    if (!fs.existsSync(plansDir)) return [];
+    const plans = fs.readdirSync(plansDir).filter(f => f.endsWith('.md'));
+    if (plans.length === 0) return [];
+    const latestPlan = plans.sort().pop();
+    return [`## Active Plan: ${latestPlan}`];
+  } catch (_err) {
+    return [];
+  }
+}
+
+function main() {
+  const baseDir = findMindloreDir();
+  if (!baseDir) return;
+
+  // Trigger FTS5 sync via the index script
+  const indexScript = path.join(__dirname, '..', 'scripts', 'mindlore-fts5-index.cjs');
+  if (fs.existsSync(indexScript)) {
+    try {
+      const { spawnSync } = require('child_process');
+      spawnSync('node', [indexScript, baseDir], {
+        timeout: 10000,
+        stdio: 'pipe',
+        windowsHide: true,
+      });
+    } catch (_err) {
+      // Non-fatal — index might fail if better-sqlite3 not available
+    }
+  }
+
+  const now = new Date();
+  const iso = now.toISOString();
+  const ts = iso.replace(/[:.]/g, '-');
+
+  const episodesDir = path.join(baseDir, 'episodes');
+  try {
+    const episodePath = path.join(episodesDir, `pre-compact-${ts}.md`);
+    const content = [
+      '---',
+      'type: episode',
+      'subtype: pre-compact',
+      `date: ${iso.slice(0, 10)}`,
+      `project: ${path.basename(process.cwd())}`,
+      '---',
+      '',
+      `Pre-compact snapshot at ${iso}.`,
+      `Working directory: ${process.cwd()}`,
+    ].join('\n');
+    fs.writeFileSync(episodePath, content, 'utf8');
+  } catch (_err) { /* episodes dir may not exist */ }
+
+  // Append log entry
+  const logPath = path.join(baseDir, 'log.md');
+  try {
+    const entry = `| ${iso.slice(0, 10)} | pre-compact | FTS5 flush before compaction |\n`;
+    fs.appendFileSync(logPath, entry, 'utf8');
+  } catch (_err) { /* log file may not exist */ }
+
+  // Build compaction snapshot (#17)
+  const diaryDir = path.join(baseDir, 'diary');
+  try {
+    const sections = [];
+    sections.push(...collectRecentEpisodes(baseDir));
+    sections.push(...collectGitDiff());
+    sections.push(...getActivePlan());
+
+    if (sections.length > 0) {
+      const snapshotContent = [
+        '---',
+        'type: compaction-snapshot',
+        `date: ${iso.slice(0, 10)}`,
+        `project: ${path.basename(process.cwd())}`,
+        '---',
+        '',
+        ...sections,
+      ].join('\n');
+      fs.writeFileSync(path.join(diaryDir, `compaction-snapshot-${ts}.md`), snapshotContent);
+    }
+
+    const snapshots = listSnapshots(diaryDir).filter(f => f.startsWith('compaction-'));
+    while (snapshots.length > 5) {
+      const oldest = snapshots.shift();
+      if (oldest) fs.unlinkSync(path.join(diaryDir, oldest));
+    }
+  } catch (_err) { /* snapshot is best-effort */ }
+
+  process.stdout.write('[Mindlore: pre-compact FTS5 flush complete]\n');
+}
+
+withTelemetry('mindlore-pre-compact', main).catch(err => {
+  hookLog('mindlore-pre-compact', 'error', err?.message ?? String(err));
+  process.exit(0);
+});