mindlore 0.2.1 → 0.3.1

package/hooks/lib/mindlore-common.cjs

@@ -14,16 +14,52 @@ const MINDLORE_DIR = '.mindlore';
 const DB_NAME = 'mindlore.db';
 const SKIP_FILES = new Set(['INDEX.md', 'SCHEMA.md', 'log.md']);
 
+/**
+ * Compute global .mindlore/ path at call time.
+ * Separate function so os.homedir() is evaluated lazily (testable).
+ */
+function globalDir() {
+  return path.join(os.homedir(), MINDLORE_DIR);
+}
+
+// Convenience export — snapshot at load time for simple references.
+const GLOBAL_MINDLORE_DIR = globalDir();
+
 function findMindloreDir() {
   const projectDir = path.join(process.cwd(), MINDLORE_DIR);
   if (fs.existsSync(projectDir)) return projectDir;
 
-  const globalDir = path.join(os.homedir(), MINDLORE_DIR);
-  if (fs.existsSync(globalDir)) return globalDir;
+  const gDir = globalDir();
+  if (fs.existsSync(gDir)) return gDir;
 
   return null;
 }
 
+/**
+ * Always returns a .mindlore/ path — project if exists, otherwise global.
+ * Unlike findMindloreDir, never returns null.
+ */
+function getActiveMindloreDir() {
+  const projectDir = path.join(process.cwd(), MINDLORE_DIR);
+  if (fs.existsSync(projectDir)) return projectDir;
+  return globalDir();
+}
+
+/**
+ * Return all existing mindlore DB paths (project first, global second).
+ * Used for layered search: project results ranked higher.
+ */
+function getAllDbs() {
+  const dbs = [];
+  const projectDb = path.join(process.cwd(), MINDLORE_DIR, DB_NAME);
+  const gDb = path.join(globalDir(), DB_NAME);
+
+  if (fs.existsSync(projectDb)) dbs.push(projectDb);
+  if (fs.existsSync(gDb) && gDb !== projectDb) dbs.push(gDb);
+
+  return dbs;
+}
+
 function getLatestDelta(diaryDir) {
   if (!fs.existsSync(diaryDir)) return null;
 
@@ -91,17 +127,37 @@ function extractFtsMetadata(meta, body, filePath, baseDir) {
     tags = Array.isArray(meta.tags) ? meta.tags.join(', ') : String(meta.tags);
   }
   const quality = meta.quality !== undefined && meta.quality !== null ? meta.quality : null;
-  return { slug, description, type, category, title, tags, quality };
+  const dateCaptured = meta.date_captured || meta.date || null;
+  return { slug, description, type, category, title, tags, quality, dateCaptured };
 }
 
 /**
  * Shared SQL constants to prevent drift across indexing paths.
  */
 const SQL_FTS_CREATE =
-  "CREATE VIRTUAL TABLE IF NOT EXISTS mindlore_fts USING fts5(path UNINDEXED, slug, description, type UNINDEXED, category, title, content, tags, quality UNINDEXED, tokenize='porter unicode61')";
+  "CREATE VIRTUAL TABLE IF NOT EXISTS mindlore_fts USING fts5(path UNINDEXED, slug, description, type UNINDEXED, category, title, content, tags, quality UNINDEXED, date_captured UNINDEXED, tokenize='porter unicode61')";
 
 const SQL_FTS_INSERT =
-  'INSERT INTO mindlore_fts (path, slug, description, type, category, title, content, tags, quality) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)';
+  'INSERT INTO mindlore_fts (path, slug, description, type, category, title, content, tags, quality, date_captured) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)';
+
+/**
+ * Insert a row into FTS5 using an object parameter (replaces positional args).
+ */
+function insertFtsRow(db, entry) {
+  const stmt = db.prepare(SQL_FTS_INSERT);
+  stmt.run(
+    entry.path || '',
+    entry.slug || '',
+    entry.description || '',
+    entry.type || '',
+    entry.category || '',
+    entry.title || '',
+    entry.content || '',
+    entry.tags || '',
+    entry.quality || null,
+    entry.dateCaptured || null,
+  );
+}
 
 /**
  * Extract headings (h1-h3) from markdown content.
@@ -177,11 +233,36 @@ function readHookStdin(fields) {
   return input;
 }
 
+/**
+ * Read .mindlore/config.json and return parsed object.
+ * Returns null if file doesn't exist or is invalid JSON.
+ */
+function readConfig(mindloreDir) {
+  if (!mindloreDir) return null;
+  const configPath = path.join(mindloreDir, 'config.json');
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch (_err) {
+    return null;
+  }
+}
+
+const DEFAULT_MODELS = {
+  ingest: 'haiku',
+  evolve: 'sonnet',
+  explore: 'sonnet',
+  default: 'haiku',
+};
+
 module.exports = {
   MINDLORE_DIR,
+  GLOBAL_MINDLORE_DIR,
+  globalDir,
   DB_NAME,
   SKIP_FILES,
   findMindloreDir,
+  getActiveMindloreDir,
+  getAllDbs,
   getLatestDelta,
   sha256,
   parseFrontmatter,
@@ -189,8 +270,11 @@ module.exports = {
   readHookStdin,
   SQL_FTS_CREATE,
   SQL_FTS_INSERT,
+  insertFtsRow,
   extractHeadings,
   requireDatabase,
   openDatabase,
   getAllMdFiles,
+  readConfig,
+  DEFAULT_MODELS,
 };

package/hooks/lib/types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Type declarations for mindlore-common.cjs hook functions.
+ * Use with JSDoc @type imports in .cjs hook files.
+ */
+
+export interface FtsMetadata {
+  slug: string;
+  description: string;
+  type: string;
+  category: string;
+  title: string;
+  tags: string;
+  quality: string | null;
+  dateCaptured: string | null;
+}
+
+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;
+}
+
+export interface ParsedFrontmatter {
+  meta: Record<string, string | string[]>;
+  body: string;
+}
+
+export interface MindloreCommon {
+  MINDLORE_DIR: string;
+  GLOBAL_MINDLORE_DIR: string;
+  DB_NAME: string;
+  SKIP_FILES: Set<string>;
+  globalDir(): string;
+  findMindloreDir(): string | null;
+  getActiveMindloreDir(): string;
+  getAllDbs(): string[];
+  getLatestDelta(diaryDir: string): string | null;
+  sha256(content: string): string;
+  parseFrontmatter(content: string): ParsedFrontmatter;
+  extractFtsMetadata(meta: Record<string, string>, body: string, filePath: string, baseDir: string): FtsMetadata;
+  insertFtsRow(db: import('better-sqlite3').Database, entry: FtsEntry): void;
+  readHookStdin(fields: string[]): string;
+  extractHeadings(content: string, max: number): string[];
+  requireDatabase(): typeof import('better-sqlite3') | null;
+  openDatabase(dbPath: string, opts?: { readonly?: boolean }): import('better-sqlite3').Database | null;
+  getAllMdFiles(dir: string, skip?: Set<string>): string[];
+  SQL_FTS_CREATE: string;
+  SQL_FTS_INSERT: string;
+}

package/hooks/mindlore-cwd-changed.cjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-cwd-changed — CwdChanged hook
+ *
+ * Fires when user changes working directory.
+ * CwdChanged has NO inject to Claude — stdout is swallowed, stderr shown to user.
+ *
+ * Side effects:
+ *   1. Detect scope (project .mindlore/ vs global ~/.mindlore/)
+ *   2. Write scope state to .mindlore/diary/_scope.json for session-focus to read
+ *   3. Show user-facing message via stderr
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { findMindloreDir, globalDir } = require('./lib/mindlore-common.cjs');
+
+function main() {
+  const cwd = process.cwd();
+  const activeDir = findMindloreDir();
+  const scope = !activeDir ? 'none' : activeDir.startsWith(globalDir()) ? 'global' : 'project';
+
+  if (activeDir) {
+    const diaryDir = path.join(activeDir, 'diary');
+    if (!fs.existsSync(diaryDir)) {
+      fs.mkdirSync(diaryDir, { recursive: true });
+    }
+
+    // Dirty-check: skip write if scope hasn't changed
+    const scopePath = path.join(diaryDir, '_scope.json');
+    if (fs.existsSync(scopePath)) {
+      try {
+        const existing = JSON.parse(fs.readFileSync(scopePath, 'utf8'));
+        if (existing.cwd === cwd && existing.scope === scope) return;
+      } catch (_err) {
+        // corrupt file — overwrite
+      }
+    }
+
+    fs.writeFileSync(scopePath, JSON.stringify({
+      scope,
+      dir: activeDir,
+      cwd,
+      timestamp: new Date().toISOString(),
+    }, null, 2), 'utf8');
+  }
+
+  if (scope === 'none') {
+    process.stderr.write(`[Mindlore] Bu projede mindlore kurulu degil. npx mindlore init calistirin.\n`);
+  } else {
+    process.stderr.write(`[Mindlore scope: ${scope}] ${activeDir}\n`);
+  }
+}
+
+main();

package/hooks/mindlore-dont-repeat.cjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-dont-repeat — PreToolUse hook (matcher: "Write|Edit")
+ *
+ * Checks code being written against negative rules (DON'T, NEVER, AVOID, YAPMA, etc.)
+ * found in LESSONS files and Mindlore learnings/.
+ *
+ * Sources checked (in order):
+ *   1. ~/.claude/lessons/global.md (global rules)
+ *   2. ./LESSONS.md (project-level rules, if exists)
+ *   3. .mindlore/learnings/*.md (Mindlore learnings, if exists)
+ *
+ * Advisory only (exit 0) — does not block, injects additionalContext warning.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { findMindloreDir } = require('./lib/mindlore-common.cjs');
+
+/**
+ * File-persisted pattern cache — survives across process invocations.
+ * Cache file: .mindlore/diary/_pattern-cache.json
+ * Each entry keyed by source file path, stores mtimeMs + extracted patterns.
+ * On hit: stat only, no readFile+parse. On miss: read, parse, update cache.
+ */
+
+let cacheDirty = false;
+
+function readCache(cachePath) {
+  if (!cachePath) return {};
+  try {
+    return JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+  } catch (_err) {
+    return {};
+  }
+}
+
+function writeCache(cachePath, cache) {
+  if (!cachePath || !cacheDirty) return;
+  try {
+    fs.writeFileSync(cachePath, JSON.stringify(cache), 'utf8');
+  } catch (_err) { /* write failure is non-fatal */ }
+}
+
+function loadPatterns(filePath, cache) {
+  try {
+    const stat = fs.statSync(filePath);
+    const mtimeMs = stat.mtimeMs;
+    const cached = cache[filePath];
+    if (cached && cached.mtimeMs === mtimeMs) return cached.patterns;
+
+    const patterns = extractNegativePatterns(fs.readFileSync(filePath, 'utf8'));
+    cache[filePath] = { mtimeMs, patterns };
+    cacheDirty = true;
+    return patterns;
+  } catch (_err) {
+    return [];
+  }
+}
+
+function extractNegativePatterns(content) {
+  const patterns = [];
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    // Multi-language: TR (YAPMA, KRITIK) + EN (DON'T, NEVER, AVOID, DO NOT)
+    const isNegativeRule = /^-\s*(YAPMA|KRITIK|DON'?T|NEVER|AVOID|DO NOT):/i.test(trimmed);
+    if (!isNegativeRule) continue;
+
+    // Extract backtick-quoted code patterns: `pattern`
+    const backtickMatches = trimmed.match(/`([^`]+)`/g);
+    if (backtickMatches) {
+      for (const match of backtickMatches) {
+        const pattern = match.slice(1, -1).trim();
+        // Skip short/generic patterns — too many false positives
+        if (pattern.length < 8) continue;
+        if (/^[^a-zA-Z0-9]+$/.test(pattern)) continue;
+        // Skip single words (too generic: "node", "bash", "any")
+        if (/^\w+$/.test(pattern) && pattern.length < 12) continue;
+        // Skip file extensions and paths
+        if (/^\.\w{1,5}$/.test(pattern)) continue;
+        if (pattern.startsWith('/') || pattern.startsWith('~')) continue;
+        if (pattern.includes('.md') || pattern.includes('.json')) continue;
+        // Skip common false-positive patterns
+        if (/^(node|bash|npm|git|process|require|import|export|const|let|var)$/i.test(pattern)) continue;
+
+        patterns.push({
+          pattern,
+          rule: trimmed.substring(0, 120),
+        });
+      }
+    }
+
+    // Extract "quoted strings" as patterns
+    const quoteMatches = trimmed.match(/"([^"]+)"/g);
+    if (quoteMatches) {
+      for (const match of quoteMatches) {
+        const quoted = match.slice(1, -1).trim();
+        if (quoted.length < 4) continue;
+        patterns.push({
+          pattern: quoted,
+          rule: trimmed.substring(0, 120),
+        });
+      }
+    }
+  }
+
+  return patterns;
+}
+
+function checkContent(content, patterns) {
+  const matches = [];
+  for (const p of patterns) {
+    try {
+      const escaped = p.pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const regex = new RegExp(escaped, 'i');
+      if (regex.test(content)) {
+        matches.push(p);
+      }
+    } catch { /* skip invalid patterns */ }
+  }
+  return matches;
+}
+
+function main() {
+  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 toolName = data.tool_name || '';
+
+      if (!['Write', 'Edit'].includes(toolName)) {
+        return process.exit(0);
+      }
+
+      const toolInput = data.tool_input || {};
+      const filePath = toolInput.file_path || '';
+
+      // Skip non-code files
+      if (!filePath) return process.exit(0);
+      const ext = path.extname(filePath).toLowerCase();
+      const codeExts = ['.ts', '.tsx', '.js', '.jsx', '.cjs', '.mjs', '.py', '.go', '.rs', '.java', '.c', '.cpp', '.h', '.sh', '.yaml', '.yml'];
+      if (!codeExts.includes(ext)) return process.exit(0);
+
+      // Skip rule files themselves
+      const basename = path.basename(filePath);
+      if (basename === 'LESSONS.md' || basename === 'global.md' || basename === 'CLAUDE.md') {
+        return process.exit(0);
+      }
+
+      // Collect content being written (skip old_string — that's code being removed, not added)
+      const allContent = [
+        toolInput.content || '',
+        toolInput.new_string || '',
+      ].join('\n');
+
+      if (allContent.trim().length < 10) return process.exit(0);
+
+      // Load patterns from all sources (file-persisted mtime cache)
+      const mindloreDir = findMindloreDir();
+      const cachePath = mindloreDir ? path.join(mindloreDir, 'diary', '_pattern-cache.json') : null;
+      const cache = readCache(cachePath);
+      const allPatterns = [];
+      const cwd = process.cwd();
+
+      // 1. Global lessons
+      allPatterns.push(...loadPatterns(path.join(os.homedir(), '.claude', 'lessons', 'global.md'), cache));
+
+      // 2. Project LESSONS.md
+      allPatterns.push(...loadPatterns(path.join(cwd, 'LESSONS.md'), cache));
+
+      // 3. Mindlore learnings/ directory
+      if (mindloreDir) {
+        const learningsDir = path.join(mindloreDir, 'learnings');
+        try {
+          const files = fs.readdirSync(learningsDir).filter(f => f.endsWith('.md'));
+          for (const file of files) {
+            allPatterns.push(...loadPatterns(path.join(learningsDir, file), cache));
+          }
+        } catch (_err) { /* learnings/ doesn't exist yet */ }
+      }
+
+      writeCache(cachePath, cache);
+
+      if (allPatterns.length === 0) return process.exit(0);
+
+      // Check content against patterns
+      const matches = checkContent(allContent, allPatterns);
+      if (matches.length === 0) return process.exit(0);
+
+      // Build warning — max 3 matches shown
+      const shown = matches.slice(0, 3);
+      const warning = shown.map(m =>
+        `  - Pattern: \`${m.pattern}\` → ${m.rule}`
+      ).join('\n');
+      const extra = matches.length > 3 ? `\n  ... and ${matches.length - 3} more` : '';
+
+      const msg = `[Mindlore: ${matches.length} dont-repeat rule violation detected]\n${warning}${extra}`;
+
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          additionalContext: msg
+        }
+      }));
+    } catch {
+      // Silent fail
+    }
+    process.exit(0);
+  });
+}
+
+main();

package/hooks/mindlore-fts5-sync.cjs

@@ -13,7 +13,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { MINDLORE_DIR, DB_NAME, sha256, openDatabase, getAllMdFiles, parseFrontmatter, extractFtsMetadata, SQL_FTS_INSERT, readHookStdin } = require('./lib/mindlore-common.cjs');
+const { MINDLORE_DIR, DB_NAME, sha256, openDatabase, getAllMdFiles, parseFrontmatter, extractFtsMetadata, insertFtsRow, readHookStdin } = require('./lib/mindlore-common.cjs');
 
 function main() {
   const filePath = readHookStdin(['path', 'file_path']);
@@ -35,11 +35,10 @@ function main() {
   if (!db) return;
 
   const mdFiles = getAllMdFiles(baseDir);
-  let synced = 0;
+
 
   const getHash = db.prepare('SELECT content_hash FROM file_hashes WHERE path = ?');
   const deleteFts = db.prepare('DELETE FROM mindlore_fts WHERE path = ?');
-  const insertFts = db.prepare(SQL_FTS_INSERT);
   const upsertHash = db.prepare(`
     INSERT INTO file_hashes (path, content_hash, last_indexed)
     VALUES (?, ?, ?)
@@ -60,11 +59,10 @@ function main() {
         if (existing && existing.content_hash === hash) continue;
 
         const { meta, body } = parseFrontmatter(content);
-        const { slug, description, type, category, title, tags, quality } = extractFtsMetadata(meta, body, file, baseDir);
+        const { slug, description, type, category, title, tags, quality, dateCaptured } = extractFtsMetadata(meta, body, file, baseDir);
         deleteFts.run(file);
-        insertFts.run(file, slug, description, type, category, title, body, tags, quality);
+        insertFtsRow(db, { path: file, slug, description, type, category, title, content: body, tags, quality, dateCaptured });
         upsertHash.run(file, hash, now);
-        synced++;
       }
     });
     transaction();
@@ -72,9 +70,8 @@ function main() {
     db.close();
   }
 
-  if (synced > 0) {
-    process.stdout.write(`[Mindlore FTS5 Sync: ${synced} files re-indexed]\n`);
-  }
+  // FileChanged event stdout'u yutulur — log gerekiyorsa dosyaya yaz
+  // process.stdout.write kaldırıldı (kimse görmüyor)
 }
 
 main();

package/hooks/mindlore-index.cjs

@@ -10,7 +10,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { MINDLORE_DIR, DB_NAME, SKIP_FILES, sha256, openDatabase, parseFrontmatter, extractFtsMetadata, SQL_FTS_INSERT, readHookStdin } = require('./lib/mindlore-common.cjs');
+const { MINDLORE_DIR, DB_NAME, SKIP_FILES, sha256, openDatabase, parseFrontmatter, extractFtsMetadata, insertFtsRow, readHookStdin } = require('./lib/mindlore-common.cjs');
 
 function main() {
   const filePath = readHookStdin(['path', 'file_path']);
@@ -58,11 +58,11 @@ function main() {
 
     // Parse frontmatter for rich FTS5 columns
     const { meta, body } = parseFrontmatter(content);
-    const { slug, description, type, category, title, tags, quality } = extractFtsMetadata(meta, body, filePath, baseDir);
+    const { slug, description, type, category, title, tags, quality, dateCaptured } = extractFtsMetadata(meta, body, filePath, baseDir);
 
     // Update FTS5
     db.prepare('DELETE FROM mindlore_fts WHERE path = ?').run(filePath);
-    db.prepare(SQL_FTS_INSERT).run(filePath, slug, description, type, category, title, body, tags, quality);
+    insertFtsRow(db, { path: filePath, slug, description, type, category, title, content: body, tags, quality, dateCaptured });
 
     // Update hash
     db.prepare(

package/hooks/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 } = 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));
+}
+
+main();