mindlore 0.3.4 → 0.4.0

package/hooks/lib/mindlore-common.d.cts

@@ -0,0 +1,72 @@
+import type BetterSqlite3 from 'better-sqlite3';
+type Database = BetterSqlite3.Database;
+
+export const MINDLORE_DIR: string;
+export const GLOBAL_MINDLORE_DIR: string;
+export const DB_NAME: string;
+export const SKIP_FILES: Set<string>;
+export const SQL_FTS_CREATE: string;
+export const SQL_FTS_INSERT: string;
+export const DEFAULT_MODELS: Record<string, string>;
+
+export function globalDir(): string;
+export function findMindloreDir(): string | null;
+export function getActiveMindloreDir(): string | null;
+export function getAllDbs(): string[];
+export function getProjectName(): string;
+export function getLatestDelta(diaryDir: string): string | null;
+export function sha256(content: string): string;
+
+export interface FrontmatterResult {
+  meta: Record<string, unknown>;
+  body: string;
+}
+export function parseFrontmatter(content: string): FrontmatterResult;
+
+export interface FtsMetadata {
+  slug: string;
+  description: string;
+  type: string;
+  category: string;
+  title: string;
+  tags: string;
+  quality: string | null;
+  dateCaptured: string | null;
+}
+export function extractFtsMetadata(
+  meta: Record<string, unknown>,
+  body: string,
+  filePath: string,
+  baseDir: string,
+): FtsMetadata;
+
+export function readHookStdin(fields: string[]): string;
+
+export interface FtsEntry {
+  path: string;
+  slug: string;
+  description: string;
+  type: string;
+  category: string;
+  title: string;
+  content: string;
+  tags: string;
+  quality: string | null;
+  dateCaptured: string | null;
+  project: string;
+}
+export function insertFtsRow(db: Database, entry: FtsEntry): void;
+
+export function extractHeadings(content: string, max?: number): string[];
+export function requireDatabase(): typeof import('better-sqlite3');
+export function openDatabase(dbPath: string, opts?: { readonly?: boolean }): Database | null;
+export function getAllMdFiles(dir: string, skip?: Set<string>): string[];
+
+export interface MindloreConfig {
+  version?: string;
+  created?: string;
+  models?: Record<string, string>;
+  [key: string]: unknown;
+}
+export function readConfig(mindloreDir: string): MindloreConfig | null;
+export function detectSchemaVersion(db: unknown): number;

package/hooks/mindlore-post-read.cjs

@@ -7,8 +7,8 @@
  * After a file is read, estimate its token count
  * and store in _session-reads.json for the read-guard to reference.
  *
- * Does NOT output anything (pure bookkeeping).
- * PostToolUse stdout goes to debug log only — no inject needed.
+ * Outputs token estimate via additionalContext JSON.
+ * Also stores token info in _session-reads.json for read-guard.
  */
 
 const fs = require('fs');
@@ -87,6 +87,15 @@ function main() {
       }
 
       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
     }

package/hooks/mindlore-read-guard.cjs

@@ -68,15 +68,23 @@ function main() {
   // Write updated reads
   fs.writeFileSync(readsPath, JSON.stringify(reads, null, 2), 'utf8');
 
-  // Warn on repeated reads (2nd+ time)
+  const basename = path.basename(filePath);
+  const tokenInfo = tokens > 0 ? ` (~${tokens} token)` : '';
+
+  // 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.`);
+    process.exit(2);
+  }
+
+  // Warn on 2nd read (exit 0 = allow but warn)
   if (count > 1) {
-    const basename = path.basename(filePath);
-    const tokenInfo = tokens > 0 ? ` (~${tokens} token)` : '';
     const totalWaste = tokens > 0 ? ` Toplam tekrar: ~${tokens * (count - 1)} token.` : '';
     process.stdout.write(JSON.stringify({
       hookSpecificOutput: {
         hookEventName: 'PreToolUse',
-        additionalContext: `[Mindlore: ${basename}${tokenInfo} bu session'da ${count}. kez okunuyor.${totalWaste} Değişiklik yoksa tekrar okumayı atlayabilirsin.]`
+        additionalContext: `[Mindlore: ${basename}${tokenInfo} bu session'da ${count}. kez okunuyor.${totalWaste} Bir sonraki okuma engellenecek — Edit gerekiyorsa simdi yap.]`
       }
     }));
   }

package/hooks/mindlore-search.cjs

@@ -104,6 +104,27 @@ function searchDb(dbPath, keywords, Database) {
   return results;
 }
 
+/**
+ * Search episodes via FTS5 mirror (type = 'episode').
+ * Reuses an already-open DB handle — no extra sqlite3_open.
+ */
+function searchEpisodesFts(db, keywords) {
+  try {
+    const ftsQuery = keywords.map(kw => '"' + kw + '"').join(' OR ');
+    const rows = db.prepare(
+      "SELECT title, category, slug, tags FROM mindlore_fts WHERE type = 'episode' AND mindlore_fts MATCH ? LIMIT 2"
+    ).all(ftsQuery);
+
+    return rows.map(r => {
+      const tags = r.tags || '';
+      const kind = tags.split(',')[0]?.trim() || 'episode';
+      return `[episode] ${kind}: ${r.title || r.slug}`;
+    });
+  } catch (_err) {
+    return [];
+  }
+}
+
 function main() {
   const userMessage = readHookStdin(['prompt', 'content', 'message', 'query']);
   if (!userMessage || userMessage.length < MIN_QUERY_WORDS) return;
@@ -162,6 +183,21 @@ function main() {
     );
   }
 
+  // v0.4.0: Search episode mirrors in FTS5 (reuses searchDb's DB path, no extra open)
+  if (relevant.length < MAX_RESULTS) {
+    for (const dbPath of dbPaths) {
+      try {
+        const db = new Database(dbPath, { readonly: true });
+        const episodeResults = searchEpisodesFts(db, keywords);
+        db.close();
+        if (episodeResults.length > 0) {
+          output.push(`[Mindlore Episodes]\n${episodeResults.join('\n')}`);
+          break;
+        }
+      } catch (_err) { /* skip */ }
+    }
+  }
+
   if (output.length > 0) {
     process.stdout.write(output.join('\n\n') + '\n');
   }

package/hooks/mindlore-session-end.cjs

@@ -12,7 +12,7 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
-const { findMindloreDir, globalDir, getProjectName } = require('./lib/mindlore-common.cjs');
+const { findMindloreDir, globalDir, getProjectName, openDatabase, ensureEpisodesTable, hasEpisodesTable, insertBareEpisode, insertFtsRow } = require('./lib/mindlore-common.cjs');
 
 function formatDate(date) {
   const y = date.getFullYear();
@@ -23,29 +23,33 @@ function formatDate(date) {
   return `${y}-${m}-${d}-${h}${min}`;
 }
 
-function getRecentGitChanges() {
+/**
+ * Get recent commits and changed files in a single git call.
+ * Returns { commits: string[], changedFiles: string[] }
+ */
+function getRecentGitInfo() {
   try {
-    const raw = execSync('git diff --name-only HEAD~5..HEAD 2>/dev/null', {
+    // --name-only includes file names after each commit entry
+    const raw = execSync('git log --oneline -5 --name-only 2>/dev/null', {
       encoding: 'utf8',
       timeout: 5000,
     }).trim();
-    if (!raw) return [];
-    return raw.split('\n').filter(Boolean).slice(0, 20);
-  } catch (_err) {
-    return [];
-  }
-}
+    if (!raw) return { commits: [], changedFiles: [] };
 
-function getRecentCommits() {
-  try {
-    const raw = execSync('git log --oneline -5 2>/dev/null', {
-      encoding: 'utf8',
-      timeout: 5000,
-    }).trim();
-    if (!raw) return [];
-    return raw.split('\n').filter(Boolean);
+    const commits = [];
+    const fileSet = new Set();
+    for (const line of raw.split('\n')) {
+      if (!line) continue;
+      // Commit lines start with a short hash (7+ hex chars)
+      if (/^[0-9a-f]{7,}\s/.test(line)) {
+        commits.push(line);
+      } else {
+        fileSet.add(line);
+      }
+    }
+    return { commits, changedFiles: [...fileSet].slice(0, 20) };
   } catch (_err) {
-    return [];
+    return { commits: [], changedFiles: [] };
   }
 }
 
@@ -55,7 +59,11 @@ function getSessionReads(baseDir) {
   try {
     const data = JSON.parse(fs.readFileSync(readsPath, 'utf8'));
     const count = Object.keys(data).length;
-    const repeats = Object.values(data).filter((v) => v > 1).length;
+    const repeats = Object.values(data).filter((v) => {
+      if (typeof v === 'number') return v > 1;
+      if (v && typeof v === 'object') return (v.count || 0) > 1;
+      return false;
+    }).length;
     // Clean up session file
     fs.unlinkSync(readsPath);
     return { count, repeats };
@@ -80,9 +88,8 @@ function main() {
   // Don't overwrite existing delta (idempotent)
   if (fs.existsSync(deltaPath)) return;
 
-  // Gather structured data
-  const commits = getRecentCommits();
-  const changedFiles = getRecentGitChanges();
+  // Gather structured data (single git call)
+  const { commits, changedFiles } = getRecentGitInfo();
   const reads = getSessionReads(baseDir);
 
   const project = getProjectName();
@@ -133,10 +140,86 @@ function main() {
     fs.appendFileSync(logPath, logEntry, 'utf8');
   }
 
+  // v0.4.0: Write bare episode to episodes table
+  writeBareEpisode(baseDir, project, commits, changedFiles, reads);
+
   // Git auto-commit + push for global ~/.mindlore/ only
   syncGlobalRepo();
 }
 
+/**
+ * Write a bare session episode to the episodes table.
+ * Deterministic — no LLM needed. Captures commits, files, read stats.
+ */
+function writeBareEpisode(baseDir, project, commits, changedFiles, reads) {
+  try {
+    const dbPath = path.join(baseDir, 'mindlore.db');
+    const db = openDatabase(dbPath);
+    if (!db) return;
+
+    if (!hasEpisodesTable(db)) {
+      ensureEpisodesTable(db);
+    }
+
+    const commitList = commits.length > 0 ? commits.join(', ') : 'no commits';
+    const fileCount = changedFiles.length;
+    const summary = `Session: ${commitList} (${fileCount} files)`;
+
+    const bodyParts = [];
+    if (commits.length > 0) {
+      bodyParts.push('## Commits\n' + commits.map(c => `- ${c}`).join('\n'));
+    }
+    if (changedFiles.length > 0) {
+      bodyParts.push('## Changed Files\n' + changedFiles.map(f => `- ${f}`).join('\n'));
+    }
+    if (reads) {
+      bodyParts.push(`## Read Stats\n- ${reads.count} files read, ${reads.repeats} repeated`);
+    }
+
+    const entities = changedFiles.slice(0, 10);
+    const body = bodyParts.join('\n\n') || null;
+    const truncatedSummary = summary.slice(0, 300);
+
+    // Atomic: episode + FTS5 mirror in single transaction
+    const writeBoth = db.transaction(() => {
+      const epId = insertBareEpisode(db, {
+        kind: 'session',
+        scope: 'project',
+        project: project,
+        summary: truncatedSummary,
+        body: body,
+        tags: 'session',
+        entities: entities.length > 0 ? entities : null,
+        source: 'hook',
+      });
+
+      // FTS5 mirror — episode searchable via mindlore-search hook
+      try {
+        insertFtsRow(db, {
+          path: `episodes/${epId}`,
+          slug: `ep-${epId}`,
+          description: truncatedSummary,
+          type: 'episode',
+          category: 'episodes',
+          title: truncatedSummary.slice(0, 100),
+          content: [truncatedSummary, body ?? ''].join('\n').trim(),
+          tags: 'session',
+          quality: null,
+          dateCaptured: new Date().toISOString().slice(0, 10),
+          project: project,
+        });
+      } catch (_ftsErr) {
+        // FTS5 mirror optional — don't break the transaction
+      }
+    });
+    writeBoth();
+
+    db.close();
+  } catch (_err) {
+    // Graceful fail — never break session end
+  }
+}
+
 /**
  * Auto-commit and push ~/.mindlore/ if it has a .git directory.
  * Only runs for the global scope — project .mindlore/ is in the project's own git.

package/hooks/mindlore-session-focus.cjs

@@ -10,7 +10,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { findMindloreDir, readConfig } = require('./lib/mindlore-common.cjs');
+const { findMindloreDir, readConfig, openDatabase, hasEpisodesTable, queryRecentEpisodes } = require('./lib/mindlore-common.cjs');
 
 function main() {
   const baseDir = findMindloreDir();
@@ -63,6 +63,33 @@ function main() {
     }
   } catch (_err) { /* skip */ }
 
+  // v0.4.0: Inject recent episodes
+  try {
+    const dbPath = path.join(baseDir, 'mindlore.db');
+    const db = openDatabase(dbPath, { readonly: true });
+    if (db) {
+      try {
+        if (hasEpisodesTable(db)) {
+          const config = readConfig(baseDir);
+          const maxEpisodes = config?.session_focus?.max_episodes ?? 3;
+          const project = path.basename(process.cwd());
+          const episodes = queryRecentEpisodes(db, { project, limit: maxEpisodes });
+
+          if (episodes.length > 0) {
+            const lines = episodes.map(ep => {
+              const date = (ep.created_at || '').slice(0, 10);
+              const summary = String(ep.summary || '').slice(0, 100);
+              return `- [${date}] ${ep.kind}: ${summary}`;
+            });
+            output.push(`[Mindlore Episodes]\n${lines.join('\n')}`);
+          }
+        }
+      } finally {
+        db.close();
+      }
+    }
+  } catch (_err) { /* graceful skip */ }
+
   if (output.length > 0) {
     process.stdout.write(output.join('\n\n') + '\n');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindlore",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "AI-native knowledge system for Claude Code",
   "type": "commonjs",
   "bin": {

package/skills/mindlore-log/SKILL.md

@@ -12,7 +12,7 @@ Determine target using `getActiveMindloreDir()` logic:
 
 ## Trigger
 
-`/mindlore-log <mode>` where mode is `log`, `reflect`, `status`, or `save`.
+`/mindlore-log <mode>` where mode is `log`, `diary`, `reflect`, `status`, or `save`.
 
 ## Modes
 
@@ -36,30 +36,90 @@ date: 2026-04-11
 4. Body: user's note as-is
 5. Append to `log.md`: `| {date} | log | {slug}.md |`
 
+### diary
+
+LLM-driven session analysis → enriched episodes in the episodes table.
+
+**Trigger:** User runs `/mindlore-log diary` or Stop hook asks "Diary analizi yapayım mı?"
+
+**Model:** `[mindlore:diary]` marker → sonnet (analysis needed)
+
+**Flow:**
+1. Open `~/.mindlore/mindlore.db`, ensure episodes table exists
+2. Find the latest bare session episode for current project: `WHERE kind = 'session' AND project = ? AND source = 'hook' ORDER BY created_at DESC LIMIT 1`
+3. Gather context:
+   - The bare episode's body (commits, files, read stats)
+   - Git log last 10 commits
+   - Decision-detector captures (if any in session)
+4. LLM analyzes and extracts structured episodes:
+   - **Decisions** → `kind: 'decision'` — architectural/tool/format choices
+   - **Discoveries** → `kind: 'discovery'` — assumption vs reality findings
+   - **Frictions** → `kind: 'friction'` — tool errors, blockers, recurring issues
+   - **Learnings** → `kind: 'learning'` — reusable knowledge
+   - **Preferences** → `kind: 'preference'` — user behavioral preferences
+   - **Events** → `kind: 'event'` — releases, incidents, milestones
+5. **Deduplication rule:** Each finding belongs to exactly ONE kind. Priority: `decision > discovery > friction > learning > preference > event`. Never write the same finding to multiple kinds.
+6. Present to user, get approval
+7. Write approved episodes to DB:
+   - `source: 'diary'`
+   - `parent_id: {bare_session_episode_id}` — links enriched episodes to source session
+   - `scope: 'project'` (default) or `'global'` if cross-project
+8. Optionally mirror to FTS5 for text search
+9. Append to `log.md`: `| {date} | diary | {N} episodes extracted from session |`
+
+**Rules:**
+- NEVER write episodes without user approval
+- parent_id always points to the source session episode
+- Each episode gets its own summary (max 100 chars) and body (markdown, unbounded)
+- entities field: JSON array of relevant file paths (max 10)
+
 ### reflect
 
-LLM-driven pattern extraction from diary deltas → persistent learnings.
+LLM-driven pattern extraction from episodes → persistent learnings.
 
-**Flow (v0.3 — LLM-driven):**
-1. Read last N non-archived delta files in `diary/` (no `archived: true` frontmatter)
-2. Present summary: "Found N unprocessed deltas spanning DATE1 to DATE2"
-3. LLM analyzes deltas for repeating patterns:
-   - Recurring topics/themes across sessions
-   - Repeated decisions (same choice made multiple times)
-   - Common mistakes or friction points
+**Flow (v0.4 — episodes-powered):**
+1. Read active episodes: `WHERE status = 'active' AND source IN ('hook', 'diary')`
+2. Optionally filter by time: `--days 7` (default 7), `--days 30`
+3. Present summary: "Found N episodes spanning DATE1 to DATE2"
+4. LLM analyzes episodes (not deltas) for patterns:
+   - Repeated decisions (same choice 2+ times)
+   - Recurring frictions (same blocker/error)
+   - Discovery patterns (assumptions that keep breaking)
    - Workflow patterns that worked well
-4. Categorize found patterns by topic (git, testing, architecture, etc.)
-5. Present findings to user with proposed learnings
-6. User approves → write to `learnings/{topic}.md` (append if exists, create if not)
+5. **Structured report output:**
+
+```
+── Reflect Raporu (son {days} gün, {N} episode) ──
+
+Friction ({count}):
+  - {summary} — {repeat_count}x tekrar
+
+Discoveries ({count}):
+  - {summary}
+
+Decisions ({count}):
+  - {summary}
+
+Patterns:
+  - "{pattern_description}" → kural adayı
+
+Önerilen:
+  [ ] {rule} ({repeat_count}x, {confidence} confidence)
+```
+
+6. User approves → write to `learnings/{topic}.md`
 7. Format: `YAPMA:` / `BEST PRACTICE:` / `KRITIK:` prefixed rules
 8. Update relevant domain page if pattern relates to an existing domain
-9. Mark processed deltas: add `archived: true` to their frontmatter
-10. Append to `log.md`: `| {date} | reflect | {N} deltas processed, {M} learnings written |`
+9. Mark processed episodes: future reflect skips already-processed timeranges
+10. Append to `log.md`: `| {date} | reflect | {N} episodes processed, {M} learnings written |`
+
+**Fallback:** Also reads non-archived delta files if episodes table is empty (backward compat with v0.3 deltas).
 
 **Rules:**
 - NEVER write learnings without user approval
 - Group related patterns into existing topic files (don't create one file per pattern)
 - Reflect scans both project + global diary/ in `--all` mode
+- Deduplication: same pattern found in both episodes and deltas → episodes win
 
 ### status
 

package/skills/mindlore-query/SKILL.md

@@ -18,14 +18,17 @@ Determine search scope using `getActiveMindloreDir()` / `getAllDbs()` logic:
 
 ### search
 
-FTS5 keyword search with direct results.
+FTS5 keyword search + episodes recall with unified results.
 
 **Flow:**
 1. Parse user query into keywords (strip stop words)
-2. Run FTS5 MATCH on `mindlore_fts` table
-3. Return top 5 results (configurable) with: path, title, description, category, rank score
-4. Display as table with snippet preview
-5. If `--tags <tag>` flag provided: `WHERE tags MATCH '<tag>'` filter
+2. Run FTS5 MATCH on `mindlore_fts` table (knowledge: "ne biliyorum")
+3. Run LIKE search on `episodes` table (memory: "ne oldu, ne karar aldım")
+4. Merge results: FTS5 results first, then matching episodes
+5. Return top 5 knowledge results + top 3 episode results
+6. Display knowledge as table with snippet preview, episodes as timeline
+7. If `--tags <tag>` flag provided: `WHERE tags MATCH '<tag>'` filter (FTS5 only)
+8. If `--episodes-only` flag: skip FTS5, show only episode matches
 
 **Output format:**
 ```

package/templates/config.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.3.4",
+  "version": "0.4.0",
   "models": {
     "ingest": "haiku",
     "evolve": "sonnet",
@@ -8,5 +8,8 @@
   },
   "reflect": {
     "threshold": 5
+  },
+  "session_focus": {
+    "max_episodes": 3
   }
 }