mindlore 0.7.5 → 0.7.7

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

@@ -1,20 +1,11 @@
 #!/usr/bin/env node
 'use strict';
 
-/**
- * mindlore-read-guard — PreToolUse hook (if: "Read")
- *
- * Repeated-read detection: detects files read multiple times
- * in the same session and emits a soft warning.
- * Does NOT block (exit 0) — advisory only.
- *
- * Storage: .mindlore/diary/_session-reads.json
- * Cleanup: session-end hook writes stats to delta then deletes the file.
- */
-
 const fs = require('fs');
 const path = require('path');
 const { findMindloreDir, readHookStdin, getProjectName, hookLog, extractSkeleton, withTelemetrySync } = require('./lib/mindlore-common.cjs');
+const { safeMkdir, safeWriteFile } = require('./lib/secure-io.cjs');
+const { runReadGuard } = require('../../dist/scripts/lib/read-guard-core.js');
 
 function main() {
   const baseDir = findMindloreDir();
@@ -23,64 +14,33 @@ function main() {
   const filePath = readHookStdin(['file_path', 'path']);
   if (!filePath) return;
 
-  // Only track CWD-relative files, skip .mindlore/ internals
   const cwd = process.cwd();
   const resolved = path.resolve(filePath);
   if (!resolved.startsWith(cwd)) return;
   if (resolved.startsWith(path.resolve(baseDir))) return;
 
-  // Load or create session reads tracker
   const diaryDir = path.join(baseDir, 'diary');
-  if (!fs.existsSync(diaryDir)) {
-    fs.mkdirSync(diaryDir, { recursive: true });
-  }
+  safeMkdir(diaryDir);
 
   const readsPath = path.join(diaryDir, `_session-reads-${getProjectName()}.json`);
   let reads = {};
-  if (fs.existsSync(readsPath)) {
-    try {
-      reads = JSON.parse(fs.readFileSync(readsPath, 'utf8'));
-    } catch (_err) {
-      reads = {};
-    }
+  try {
+    reads = JSON.parse(fs.readFileSync(readsPath, 'utf8'));
+  } catch (err) {
+    if (err.code !== 'ENOENT') hookLog('read-guard', 'warn', `read error: ${err.message}`);
+    reads = {};
   }
 
-  const normalizedPath = path.resolve(filePath);
-  const existing = reads[normalizedPath];
-
-  // Support both old format (number) and new format (object with tokens)
-  let count, tokens;
-  if (typeof existing === 'number') {
-    count = existing + 1;
-    tokens = 0;
-    reads[normalizedPath] = { count, tokens: 0, chars: 0 };
-  } else if (existing && typeof existing === 'object') {
-    count = (existing.count || 0) + 1;
-    tokens = existing.tokens || 0;
-    existing.count = count;
-    reads[normalizedPath] = existing;
-  } else {
-    count = 1;
-    tokens = 0;
-    reads[normalizedPath] = { count, tokens: 0, chars: 0 };
-  }
-
-  // Write updated reads
-  fs.writeFileSync(readsPath, JSON.stringify(reads, null, 2), 'utf8');
-
-  const basename = path.basename(filePath);
-  const tokenInfo = tokens > 0 ? ` (~${tokens} token)` : '';
+  const decision = runReadGuard({ filePath: resolved, basename: path.basename(filePath) }, reads);
+  reads[resolved] = decision.updatedReadsEntry;
+  safeWriteFile(readsPath, JSON.stringify(reads, null, 2));
 
-  // Block on 3+ repeated reads (exit 2 = block tool call)
-  if (count >= 3) {
-    const totalWaste = tokens > 0 ? ` Toplam israf: ~${tokens * (count - 1)} token.` : '';
-    process.stderr.write(`[Mindlore BLOCK] ${basename}${tokenInfo} bu session'da ${count}. kez okunuyor.${totalWaste} Edit icin gerekiyorsa once degisikligini yap, sonra tekrar oku. Analiz icin ctx_execute_file kullan.`);
+  if (decision.block) {
+    process.stderr.write(decision.warning);
     process.exit(2);
   }
 
-  // Warn on 2nd read (exit 0 = allow but warn)
-  if (count > 1) {
-    const totalWaste = tokens > 0 ? ` Toplam tekrar: ~${tokens * (count - 1)} token.` : '';
+  if (decision.additionalContext) {
     let skeletonSection = '';
     try {
       const ext = path.extname(filePath).slice(1);
@@ -96,7 +56,7 @@ function main() {
     process.stdout.write(JSON.stringify({
       hookSpecificOutput: {
         hookEventName: 'PreToolUse',
-        additionalContext: `[Mindlore: ${basename}${tokenInfo} bu session'da ${count}. kez okunuyor.${totalWaste} Bir sonraki okuma engellenecek — Edit gerekiyorsa simdi yap.]${skeletonSection}`
+        additionalContext: decision.additionalContext + skeletonSection
       }
     }));
   }

package/hooks/src/mindlore-search.cjs

@@ -12,6 +12,7 @@
 const fs = require('fs');
 const path = require('path');
 const { getAllDbs, openDatabase, extractHeadings, readConfig, hookLog, incrementRecallCount, withTelemetry } = require('./lib/mindlore-common.cjs');
+const { safeMkdir, safeWriteFile } = require('./lib/secure-io.cjs');
 
 const MAX_RESULTS = 3;
 const MIN_QUERY_WORDS = 3;
@@ -30,22 +31,42 @@ try {
   // search-cache not built yet
 }
 
+let TokenEstimatorMod;
+try {
+  TokenEstimatorMod = require('../dist/scripts/lib/transcript-token-estimator.js');
+} catch (_err) {
+  // estimator not built yet
+}
+
 function parseStdin() {
   try {
     const raw = fs.readFileSync(0, 'utf8').trim();
-    if (!raw) return { userMessage: '', sessionId: 'unknown' };
+    if (!raw) return { userMessage: '', sessionId: 'unknown', transcriptPath: undefined };
     const parsed = JSON.parse(raw);
     const userMessage = parsed.prompt || parsed.content || parsed.message || parsed.query || raw;
     const sessionId = parsed.session_id || 'unknown';
-    return { userMessage, sessionId };
+    const transcriptPath = parsed.transcript_path || parsed.transcriptPath;
+    return { userMessage, sessionId, transcriptPath };
   } catch (_err) {
-    return { userMessage: '', sessionId: 'unknown' };
+    return { userMessage: '', sessionId: 'unknown', transcriptPath: undefined };
+  }
+}
+
+function getBaseMax(transcriptPath) {
+  if (TokenEstimatorMod) {
+    try {
+      return TokenEstimatorMod.adaptiveResultCount(transcriptPath);
+    } catch (_err) {
+      // fall through to default
+    }
   }
+  return MAX_RESULTS;
 }
 
 function main() {
-  const { userMessage, sessionId } = parseStdin();
+  const { userMessage, sessionId, transcriptPath } = parseStdin();
   if (!userMessage || userMessage.length < MIN_QUERY_WORDS) return;
+  const baseMax = getBaseMax(transcriptPath);
   let searchMs = 0;
 
   const dbPaths = getAllDbs();
@@ -61,18 +82,26 @@ function main() {
   const synonyms = (config && config.synonyms) ? config.synonyms : {};
 
   const allResults = [];
+  // Track tightest throttle cap across DBs — applied to the final result slice
+  // so cache hits (which return previously-stored arrays) still respect throttle
+  // state in subsequent calls of the same session.
+  let sessionEffectiveMax = baseMax;
   for (const dbPath of dbPaths) {
     const db = openDatabase(dbPath);
     if (!db) continue;
     try {
       // Cache + throttle
       let cache;
-      let effectiveMax = MAX_RESULTS;
+      let effectiveMax = baseMax;
       if (SearchCacheMod) {
         cache = new SearchCacheMod.SearchCache(db, { ttlMs: 300000 });
         const throttle = new SearchCacheMod.SearchThrottle(db);
         const callCount = throttle.incrementCallCount(sessionId);
-        effectiveMax = throttle.getMaxResults(callCount);
+        // Throttle is baseMax-aware: when callCount <= 10 it returns baseMax,
+        // so adaptive expansion (up to 5 in low-context sessions) is honored.
+        // Above 10 calls it clamps to 1, above 20 to 0 (skip).
+        effectiveMax = throttle.getMaxResults(callCount, baseMax);
+        if (effectiveMax < sessionEffectiveMax) sessionEffectiveMax = effectiveMax;
         if (effectiveMax === 0) {
           hookLog('search', 'info', `Throttled (call #${callCount})`);
           db.close();
@@ -81,7 +110,7 @@ function main() {
         const cached = cache.get(userMessage);
         if (cached) {
           const baseDir = path.dirname(dbPath);
-          for (const r of cached) allResults.push({ ...r, baseDir });
+          for (const r of cached.slice(0, effectiveMax)) allResults.push({ ...r, baseDir });
           db.close();
           continue;
         }
@@ -129,7 +158,7 @@ function main() {
 
   // Sort by score descending, take top N
   unique.sort((a, b) => b.score - a.score);
-  const relevant = unique.slice(0, MAX_RESULTS);
+  const relevant = unique.slice(0, sessionEffectiveMax);
   if (relevant.length === 0) return;
 
   // Token budget from config
@@ -172,7 +201,7 @@ function main() {
     if (outputStr.length > OFFLOAD_THRESHOLD) {
       const baseDir = path.dirname(dbPaths[0]);
       const tmpDir = path.join(baseDir, 'tmp');
-      fs.mkdirSync(tmpDir, { recursive: true });
+      safeMkdir(tmpDir);
 
       try {
         const oneHourAgo = Date.now() - 3600000;
@@ -188,7 +217,7 @@ function main() {
       } catch { /* cleanup is best-effort */ }
       const fileName = `search-${Date.now()}.md`;
       const filePath = path.join(tmpDir, fileName);
-      fs.writeFileSync(filePath, outputStr, 'utf8');
+      safeWriteFile(filePath, outputStr);
 
       const summary = outputStr.slice(0, 500).replace(/\n/g, ' ').trim();
       outputStr = `[Mindlore Search: ${outputStr.length} chars offloaded to ${filePath}]\n` +

package/hooks/src/mindlore-session-end.cjs

@@ -13,7 +13,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execFileSync, spawn } = require('child_process');
-const { safeWriteFile, safeWriteJson } = require('../dist/scripts/lib/secure-io.js');
+const { safeMkdir, safeWriteFile, safeWriteJson } = require('./lib/secure-io.cjs');
 const { findMindloreDir, globalDir, getProjectName, openDatabase, ensureEpisodesTable, hasEpisodesTable, insertBareEpisode, insertFtsRow, hookLog, SHARED_EXPORT_DIRS, resolveWin32Bin, withTelemetry, getUnpromotedRawFiles, cleanupExpiredInjectLog } = require('./lib/mindlore-common.cjs');
 
 const EXPORT_DIRS = SHARED_EXPORT_DIRS;
@@ -151,9 +151,7 @@ function main() {
   if (!baseDir) return;
 
   const diaryDir = path.join(baseDir, 'diary');
-  if (!fs.existsSync(diaryDir)) {
-    fs.mkdirSync(diaryDir, { recursive: true });
-  }
+  safeMkdir(diaryDir);
 
   const now = new Date();
   const dateStr = formatDate(now);
@@ -323,7 +321,7 @@ function writeBareEpisode(baseDir, project, commits, changedFiles, reads) {
  */
 function writeEpisodeFile(baseDir, project, commits, changedFiles, reads) {
   const projDir = path.join(baseDir, 'diary', project || 'unknown');
-  if (!fs.existsSync(projDir)) fs.mkdirSync(projDir, { recursive: true });
+  safeMkdir(projDir);
 
   const now = process.env.MINDLORE_EPISODE_TS ? new Date(process.env.MINDLORE_EPISODE_TS) : new Date();
   const ts = formatDate(now);
@@ -406,7 +404,7 @@ function exportMdFile(srcPath, destPath, convertFn) {
   }
   let content = fs.readFileSync(srcPath, 'utf8');
   content = convertFn(content);
-  fs.writeFileSync(destPath, content, 'utf8');
+  safeWriteFile(destPath, content);
   return true;
 }
 
@@ -434,7 +432,7 @@ function syncObsidian(baseDir) {
 
     function walkAndExport(srcDir, destDir) {
       if (!fs.existsSync(srcDir)) return;
-      fs.mkdirSync(destDir, { recursive: true });
+      safeMkdir(destDir);
       for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
         if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue;
         const srcPath = path.join(srcDir, entry.name);
@@ -454,7 +452,7 @@ function syncObsidian(baseDir) {
     for (const rootFile of ['INDEX.md', 'log.md']) {
       const srcPath = path.join(baseDir, rootFile);
       if (!fs.existsSync(srcPath)) continue;
-      fs.mkdirSync(destBase, { recursive: true });
+      safeMkdir(destBase);
       if (exportMdFile(srcPath, path.join(destBase, rootFile), convertFn)) exported++;
     }
 

package/hooks/src/mindlore-session-focus.cjs

@@ -12,7 +12,7 @@ const fs = require('fs');
 const path = require('path');
 const { findMindloreDir, readConfig, openDatabase, hasEpisodesTable, querySupersededChains, formatSupersededChains, hookLog, getProjectName, parseFrontmatter, withTelemetry, withTimeoutDb, listSnapshots, isCorruptionError, recoverCorruptDb, getNominationCounts, resolveMindloreHome } = require('./lib/mindlore-common.cjs');
 const { loadLearningsBlock } = require('./lib/learnings-loader.cjs');
-const { shouldNudgeReflect } = require('../lib/reflect-trigger.cjs');
+const { shouldNudgeReflect, buildNudgeMessage } = require('../lib/reflect-trigger.cjs');
 
 function truncateSection(content, sectionRegex, keepCount, label) {
   const match = content.match(sectionRegex);
@@ -138,10 +138,16 @@ function main() {
   // Inject INDEX.md
   const tIndex = Date.now();
   const indexPath = path.join(baseDir, 'INDEX.md');
-  if (fs.existsSync(indexPath)) {
-    const content = fs.readFileSync(indexPath, 'utf8').trim();
-    sourceChars += content.length;
-    output.push(`[Mindlore INDEX]\n${content}`);
+  let indexContent;
+  try {
+    indexContent = fs.readFileSync(indexPath, 'utf8').trim();
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+    indexContent = null;
+  }
+  if (indexContent !== null) {
+    sourceChars += indexContent.length;
+    output.push(`[Mindlore INDEX]\n${indexContent}`);
   }
   timings.index_read = Date.now() - tIndex;
 
@@ -181,15 +187,13 @@ function main() {
   // Both are flat strings written by init — no JSON parse needed on session start
   const versionPath = path.join(baseDir, '.version');
   const pkgVersionPath = path.join(baseDir, '.pkg-version');
-  try {
-    if (fs.existsSync(versionPath) && fs.existsSync(pkgVersionPath)) {
-      const installed = fs.readFileSync(versionPath, 'utf8').trim();
-      const pkgVersion = fs.readFileSync(pkgVersionPath, 'utf8').trim();
-      if (pkgVersion && pkgVersion !== installed) {
-        output.push(`[Mindlore: Guncelleme mevcut (${installed} → ${pkgVersion}). \`npx mindlore init\` calistirin.]`);
-      }
-    }
-  } catch (_err) { /* skip */ }
+  let installed;
+  try { installed = fs.readFileSync(versionPath, 'utf8').trim(); } catch (err) { if (err.code !== 'ENOENT') throw err; }
+  let pkgVersion;
+  try { pkgVersion = fs.readFileSync(pkgVersionPath, 'utf8').trim(); } catch (err) { if (err.code !== 'ENOENT') throw err; }
+  if (installed !== undefined && pkgVersion !== undefined && pkgVersion !== installed) {
+    output.push(`[Mindlore: Guncelleme mevcut (${installed} → ${pkgVersion}). \`npx mindlore init\` calistirin.]`);
+  }
   timings.version_check = Date.now() - tVersion;
 
   // v0.5.4: Consolidated session payload (replaces scattered episodes/activity/alerts injection)
@@ -220,14 +224,18 @@ function main() {
 
         // Auto-reflect nudge (7-day threshold + 24h cooldown)
         try {
-          const reflectRow = db.prepare(
-            "SELECT value FROM skill_memory WHERE skill_name = 'mindlore-reflect' AND key = 'last_reflect_date'"
-          ).get();
-          const nudgeRow = db.prepare(
-            "SELECT value FROM skill_memory WHERE skill_name = 'mindlore-reflect' AND key = 'last_nudge_date'"
-          ).get();
+          const rows = db.prepare(
+            "SELECT key, value FROM skill_memory WHERE skill_name = 'mindlore-reflect' AND key IN ('last_reflect_date', 'last_nudge_date')"
+          ).all();
+          const byKey = Object.fromEntries(rows.map(r => [r.key, r.value]));
+          const reflectRow = byKey['last_reflect_date'] ? { value: byKey['last_reflect_date'] } : undefined;
+          const nudgeRow = byKey['last_nudge_date'] ? { value: byKey['last_nudge_date'] } : undefined;
           if (shouldNudgeReflect(reflectRow?.value ?? null, nudgeRow?.value ?? null, new Date())) {
-            output.push('[Mindlore] 7+ gün reflect yapılmadı — `/mindlore-reflect` çalıştır');
+            const daysSince = reflectRow?.value ? Math.floor((Date.now() - new Date(reflectRow.value).getTime()) / 86400000) : 999;
+            const episodeCount = hasEpisodesTable(db) ? db.prepare("SELECT count(*) AS c FROM episodes").get()?.c ?? 0 : 0;
+            const diaryDirPath = path.join(baseDir, 'diary');
+            const diaryCount = fs.existsSync(diaryDirPath) ? fs.readdirSync(diaryDirPath).length : 0;
+            output.push(buildNudgeMessage({ daysSince, episodeCount, diaryCount }));
             const nowIso = new Date().toISOString();
             db.prepare(`
               INSERT INTO skill_memory (skill_name, key, value, updated_at)