mindlore 0.2.1 → 0.3.0

package/hooks/mindlore-post-read.cjs

@@ -0,0 +1,97 @@
+#!/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.
+ *
+ * Does NOT output anything (pure bookkeeping).
+ * PostToolUse stdout goes to debug log only — no inject needed.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { findMindloreDir } = 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.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');
+    } catch {
+      // Silent fail
+    }
+    process.exit(0);
+  });
+}
+
+main();

package/hooks/mindlore-read-guard.cjs

@@ -4,7 +4,7 @@
 /**
  * mindlore-read-guard — PreToolUse hook (if: "Read")
  *
- * OpenWolf repeated-read pattern: detects files read multiple times
+ * Repeated-read detection: detects files read multiple times
  * in the same session and emits a soft warning.
  * Does NOT block (exit 0) — advisory only.
  *
@@ -46,8 +46,24 @@ function main() {
   }
 
   const normalizedPath = path.resolve(filePath);
-  const count = (reads[normalizedPath] || 0) + 1;
-  reads[normalizedPath] = count;
+  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');
@@ -55,7 +71,14 @@ function main() {
   // Warn on repeated reads (2nd+ time)
   if (count > 1) {
     const basename = path.basename(filePath);
-    process.stdout.write(`[Mindlore: ${basename} bu session'da ${count}. kez okunuyor. Değişiklik yoksa tekrar okumayı atlayabilirsin.]\n`);
+    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.]`
+      }
+    }));
   }
 }
 

package/hooks/mindlore-search.cjs

@@ -10,7 +10,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { findMindloreDir, DB_NAME, requireDatabase, extractHeadings, readHookStdin } = require('./lib/mindlore-common.cjs');
+const { getAllDbs, requireDatabase, extractHeadings, readHookStdin } = require('./lib/mindlore-common.cjs');
 
 const MAX_RESULTS = 3;
 const MIN_QUERY_WORDS = 3;
@@ -59,30 +59,20 @@ function extractKeywords(text) {
   return [...new Set(words)].slice(0, 8);
 }
 
-function main() {
-  const userMessage = readHookStdin(['prompt', 'content', 'message', 'query']);
-  if (!userMessage || userMessage.length < MIN_QUERY_WORDS) return;
-
-  const baseDir = findMindloreDir();
-  if (!baseDir) return;
-
-  const dbPath = path.join(baseDir, DB_NAME);
-  if (!fs.existsSync(dbPath)) return;
-
-  const keywords = extractKeywords(userMessage);
-  if (keywords.length < MIN_QUERY_WORDS) return;
-
-  const Database = requireDatabase();
-  if (!Database) return;
-
+/**
+ * Search a single DB and return scored results with their baseDir.
+ */
+function searchDb(dbPath, keywords, Database) {
+  const baseDir = path.dirname(dbPath);
   const db = new Database(dbPath, { readonly: true });
+  const results = [];
 
   try {
-    // Per-keyword scoring (like old knowledge-search.cjs)
-    // Count how many keywords match each document
     const allPaths = db.prepare('SELECT DISTINCT path FROM mindlore_fts').all();
-    const scores = [];
     const matchStmt = db.prepare('SELECT rank FROM mindlore_fts WHERE path = ? AND mindlore_fts MATCH ?');
+    const metaStmt = db.prepare(
+      'SELECT slug, description, category, title, tags FROM mindlore_fts WHERE path = ?'
+    );
 
     for (const row of allPaths) {
       let hits = 0;
@@ -101,50 +91,81 @@ function main() {
       }
 
       if (hits >= MIN_KEYWORD_HITS) {
-        scores.push({ path: row.path, hits, totalRank });
+        const meta = metaStmt.get(row.path) || {};
+        results.push({ path: row.path, hits, totalRank, baseDir, meta });
       }
     }
+  } catch (_err) {
+    // FTS5 query error — silently skip
+  } finally {
+    db.close();
+  }
 
-    // Sort: most keyword hits first, then best rank
-    scores.sort((a, b) => b.hits - a.hits || a.totalRank - b.totalRank);
-    const relevant = scores.slice(0, MAX_RESULTS);
+  return results;
+}
 
-    if (relevant.length === 0) return;
+function main() {
+  const userMessage = readHookStdin(['prompt', 'content', 'message', 'query']);
+  if (!userMessage || userMessage.length < MIN_QUERY_WORDS) return;
 
-    // Build rich inject output
-    const metaStmt = db.prepare(
-      'SELECT slug, description, category, title, tags FROM mindlore_fts WHERE path = ?'
-    );
+  const dbPaths = getAllDbs();
+  if (dbPaths.length === 0) return;
 
-    const output = [];
-    for (const r of relevant) {
-      const meta = metaStmt.get(r.path) || {};
-      const relativePath = path.relative(baseDir, r.path).replace(/\\/g, '/');
+  const keywords = extractKeywords(userMessage);
+  if (keywords.length < MIN_QUERY_WORDS) return;
 
-      let headings = [];
-      if (fs.existsSync(r.path)) {
-        const content = fs.readFileSync(r.path, 'utf8');
-        headings = extractHeadings(content, 5);
-      }
+  const Database = requireDatabase();
+  if (!Database) return;
 
-      const category = meta.category || path.dirname(relativePath).split('/')[0];
-      const title = meta.title || meta.slug || path.basename(r.path, '.md');
-      const description = meta.description || '';
+  // Layered search: project DB first, global DB second
+  // Project results appear first in output (higher priority)
+  const allScores = [];
+  for (const dbPath of dbPaths) {
+    allScores.push(...searchDb(dbPath, keywords, Database));
+  }
 
-      const headingStr = headings.length > 0 ? `\nBasliklar: ${headings.join(', ')}` : '';
-      const tagsStr = meta.tags ? `\nTags: ${meta.tags}` : '';
-      output.push(
-        `[Mindlore: ${category}/${title}] ${description}\nDosya: ${relativePath}${tagsStr}${headingStr}`
-      );
+  // Sort: most keyword hits first, then best rank
+  allScores.sort((a, b) => b.hits - a.hits || a.totalRank - b.totalRank);
+
+  // Deduplicate by full path (project version wins — appears first in sort)
+  const seen = new Set();
+  const unique = [];
+  for (const r of allScores) {
+    const normalized = path.resolve(r.path);
+    if (!seen.has(normalized)) {
+      seen.add(normalized);
+      unique.push(r);
     }
+  }
 
-    if (output.length > 0) {
-      process.stdout.write(output.join('\n\n') + '\n');
+  const relevant = unique.slice(0, MAX_RESULTS);
+  if (relevant.length === 0) return;
+
+  // Build rich inject output
+  const output = [];
+  for (const r of relevant) {
+    const meta = r.meta || {};
+    const relativePath = path.relative(r.baseDir, r.path).replace(/\\/g, '/');
+
+    let headings = [];
+    if (fs.existsSync(r.path)) {
+      const content = fs.readFileSync(r.path, 'utf8');
+      headings = extractHeadings(content, 5);
     }
-  } catch (_err) {
-    // FTS5 query error — silently skip
-  } finally {
-    db.close();
+
+    const category = meta.category || path.dirname(relativePath).split('/')[0];
+    const title = meta.title || meta.slug || path.basename(r.path, '.md');
+    const description = meta.description || '';
+
+    const headingStr = headings.length > 0 ? `\nBasliklar: ${headings.join(', ')}` : '';
+    const tagsStr = meta.tags ? `\nTags: ${meta.tags}` : '';
+    output.push(
+      `[Mindlore: ${category}/${title}] ${description}\nDosya: ${relativePath}${tagsStr}${headingStr}`
+    );
+  }
+
+  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 } = require('./lib/mindlore-common.cjs');
+const { findMindloreDir, globalDir } = require('./lib/mindlore-common.cjs');
 
 function formatDate(date) {
   const y = date.getFullYear();
@@ -129,6 +129,48 @@ function main() {
     const logEntry = `| ${now.toISOString().slice(0, 10)} | session-end | delta-${dateStr}.md |\n`;
     fs.appendFileSync(logPath, logEntry, 'utf8');
   }
+
+  // Git auto-commit + push for global ~/.mindlore/ only
+  syncGlobalRepo();
+}
+
+/**
+ * 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.
+ * Push failure is graceful (offline support).
+ */
+function syncGlobalRepo() {
+  const gDir = globalDir();
+  const gitDir = path.join(gDir, '.git');
+  if (!fs.existsSync(gitDir)) return;
+
+  try {
+    // Check for changes
+    const status = execSync('git status --porcelain', {
+      cwd: gDir,
+      encoding: 'utf8',
+      timeout: 5000,
+    }).trim();
+
+    if (!status) return; // nothing to commit
+
+    execSync('git add -A', { cwd: gDir, timeout: 5000, stdio: 'pipe' });
+    const now = new Date().toISOString().slice(0, 19);
+    execSync(`git commit -m "mindlore auto-sync ${now}"`, {
+      cwd: gDir,
+      timeout: 10000,
+      stdio: 'pipe',
+    });
+
+    // Push — graceful fail if no remote or offline
+    try {
+      execSync('git push', { cwd: gDir, timeout: 15000, stdio: 'pipe' });
+    } catch (_pushErr) {
+      // Offline or no remote — silently continue
+    }
+  } catch (_err) {
+    // Git not available or commit failed — silently continue
+  }
 }
 
 main();

package/hooks/mindlore-session-focus.cjs

@@ -34,6 +34,20 @@ function main() {
     output.push(`[Mindlore Delta: ${deltaName}]\n${deltaContent}`);
   }
 
+  // Version check: compare .version (installed) vs .pkg-version (package)
+  // 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 */ }
+
   if (output.length > 0) {
     process.stdout.write(output.join('\n\n') + '\n');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindlore",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "AI-native knowledge system for Claude Code",
   "type": "commonjs",
   "bin": {
@@ -42,7 +42,8 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "better-sqlite3": "^11.0.0"
+    "better-sqlite3": "^11.0.0",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "mindlore",
   "description": "AI-native knowledge system for Claude Code. Persistent, searchable, evolving knowledge base with FTS5.",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "skills": [
     {
       "name": "mindlore-ingest",
@@ -27,6 +27,16 @@
       "name": "mindlore-decide",
       "path": "skills/mindlore-decide/SKILL.md",
       "description": "Record and list decisions with context, alternatives, rationale"
+    },
+    {
+      "name": "mindlore-evolve",
+      "path": "skills/mindlore-evolve/SKILL.md",
+      "description": "Knowledge schema co-evolution — scan domains+sources, suggest updates"
+    },
+    {
+      "name": "mindlore-explore",
+      "path": "skills/mindlore-explore/SKILL.md",
+      "description": "Discover unexpected connections between knowledge sources"
     }
   ],
   "hooks": [
@@ -66,6 +76,19 @@
       "event": "PreToolUse",
       "script": "hooks/mindlore-read-guard.cjs",
       "if": "Read"
+    },
+    {
+      "event": "CwdChanged",
+      "script": "hooks/mindlore-cwd-changed.cjs"
+    },
+    {
+      "event": "PostToolUse",
+      "script": "hooks/mindlore-post-read.cjs"
+    },
+    {
+      "event": "PreToolUse",
+      "script": "hooks/mindlore-dont-repeat.cjs",
+      "if": "Write|Edit"
     }
   ]
 }

package/skills/mindlore-decide/SKILL.md

@@ -2,6 +2,14 @@
 
 Record and list decisions in the `.mindlore/decisions/` directory.
 
+## Scope
+
+Determine target using `getActiveMindloreDir()` logic:
+- If CWD has `.mindlore/` → write to project scope
+- Otherwise → write to global `~/.mindlore/`
+- List mode: shows decisions from active scope (use `--all` for both)
+- Never hardcode `.mindlore/` path — always resolve dynamically
+
 ## Trigger
 
 User says `/mindlore-decide record` or `/mindlore-decide list`.

package/skills/mindlore-evolve/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: mindlore-evolve
+description: Knowledge schema co-evolution — scan domains+sources, detect inconsistencies, suggest updates
+effort: medium
+allowed-tools: [Read, Write, Edit, Bash, Grep, Glob]
+---
+
+# /mindlore-evolve
+
+Knowledge schema co-evolution. Karpathy's 4th operation (ingest/query/health/**evolve**).
+
+## Scope
+
+Determine target using `getActiveMindloreDir()` logic:
+- Default (no flag): scan project `.mindlore/`
+- `--global`: scan `~/.mindlore/`
+- Never hardcode `.mindlore/` path — always resolve dynamically
+
+## Trigger
+
+User says `/mindlore-evolve`, "knowledge evolve", "bilgi sistemi evrimle", "sema guncelle".
+
+## Modes
+
+### scan (default)
+
+Scan all domains and sources for inconsistencies.
+
+**Flow:**
+1. Read INDEX.md to get domain and source file lists
+2. Read all domain files (from `domains/`)
+3. Read all source files (from `sources/`)
+4. Detect issues:
+   - **Orphan files:** .md files in content directories not listed in INDEX.md
+   - **Missing references:** Source exists but no domain mentions it
+   - **Stale domains:** Source updated more recently than referencing domain
+   - **Tag inconsistencies:** Tags in frontmatter don't match content
+   - **Missing cross-references:** Related sources not linked
+5. Report findings as a table:
+
+```
+| # | Type | File | Issue | Suggested Fix |
+|---|------|------|-------|---------------|
+| 1 | orphan | sources/old.md | Not in INDEX.md | Add to INDEX or delete |
+| 2 | missing-ref | sources/react-hooks.md | No domain reference | Add to domains/frontend.md |
+```
+
+6. If `--dry-run`: stop here, no change suggestions
+
+### apply
+
+Apply suggested changes with user approval.
+
+**Flow:**
+1. Run scan first (reuse findings)
+2. For each finding, show proposed change (diff format)
+3. Wait for user approval before each change
+4. Apply approved changes
+5. Update INDEX.md with new entries
+6. Append EVOLVE entry to log.md
+7. Max 2 domain updates per run (prevent scope creep)
+
+**Rules:**
+- NEVER make automatic changes — always require user approval
+- Show diff preview before applying
+- After changes, run `node dist/scripts/mindlore-fts5-index.js` for FTS5 sync
+- Log every change to log.md with timestamp
+
+## Output Format
+
+```
+Mindlore Evolve — Scan Results
+
+Scope: project (.mindlore/)
+Files scanned: 12 sources, 5 domains
+Issues found: 3
+
+[table of findings]
+
+Run `/mindlore-evolve apply` to fix with approval.
+```

package/skills/mindlore-explore/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: mindlore-explore
+description: Discover unexpected connections between sources — undirected knowledge exploration
+effort: medium
+allowed-tools: [Read, Write, Edit, Bash, Grep, Glob]
+---
+
+# /mindlore-explore
+
+Discover unexpected connections between knowledge sources. Undirected exploration — unlike query (directed search).
+
+## Scope
+
+Determine target using `getActiveMindloreDir()` logic:
+- Default (no flag): explore project `.mindlore/`
+- `--global`: explore `~/.mindlore/` + project cross-reference (most valuable mode)
+- Never hardcode `.mindlore/` path — always resolve dynamically
+
+## Trigger
+
+User says `/mindlore-explore`, "knowledge explore", "baglanti kesfet", "cross-reference bul".
+
+## Flow
+
+1. Read all source and domain files from active scope
+2. Cross-match by tag + content:
+   - Files sharing tags but not referencing each other
+   - Sources covering similar topics from different angles
+   - Sources that could bridge between domains
+3. Rank connections by strength:
+   - **high**: 3+ shared tags + content overlap
+   - **medium**: 2 shared tags or significant content similarity
+   - **low**: 1 shared tag + weak content match
+4. Show findings to user
+5. On approval, write to `connections/` directory
+
+## Connection File Format
+
+Written to `connections/` with frontmatter:
+
+```markdown
+---
+type: connection
+slug: connection-source-a-source-b
+date_created: 2026-04-12
+sources: [source-a.md, source-b.md]
+domains: [domain-x.md]
+strength: high
+tags: [shared-tag-1, shared-tag-2]
+---
+
+## Connection
+
+[Why these sources are related — LLM explanation]
+
+## Action Suggestion
+
+[What could be done — domain update, new analysis, etc.]
+```
+
+## Rules
+
+- Check for duplicate connections before writing (same source pair)
+- Show findings before writing — user approval required
+- Update INDEX.md with new connections entry
+- Append EXPLORE entry to log.md
+- Strength is LLM-assessed based on tag overlap + content similarity
+
+## Output Format
+
+```
+Mindlore Explore — Discovered Connections
+
+Scope: project (.mindlore/)
+Sources scanned: 12
+Connections found: 3 (2 new, 1 existing)
+
+| # | Sources | Strength | Why |
+|---|---------|----------|-----|
+| 1 | react-hooks.md + agent-orchestration.md | medium | Both discuss state management patterns |
+| 2 | karpathy-kb.md + search-retrieval.md | high | FTS5 + knowledge architecture overlap |
+
+Write connections? (y/n)
+```

package/skills/mindlore-health/SKILL.md

@@ -9,6 +9,14 @@ allowed-tools: [Bash, Read]
 
 Run the 16-point structural health check on the `.mindlore/` knowledge base.
 
+## Scope
+
+Determine target using `getActiveMindloreDir()` logic:
+- Default (no flag): check project `.mindlore/`, fall back to global
+- `--global`: check only `~/.mindlore/`
+- `--all`: check both project + global scopes, report each separately
+- Never hardcode `.mindlore/` path — always resolve dynamically
+
 ## Trigger
 
 User says "health check", "mindlore health", "bilgi sistemi kontrol", "saglik kontrolu".