mindlore 0.7.0 → 0.7.2

package/hooks/src/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/src/lib/secure-io.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+const fs = require('fs');
+
+function safeMkdir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true, mode: 0o700 });
+}
+
+function safeWriteFile(filePath, data) {
+  fs.writeFileSync(filePath, data, { encoding: 'utf8', mode: 0o600 });
+}
+
+function safeWriteJson(filePath, obj) {
+  safeWriteFile(filePath, JSON.stringify(obj, null, 2) + '\n');
+}
+
+module.exports = { safeMkdir, safeWriteFile, safeWriteJson };

package/hooks/src/lib/types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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;
+  project?: 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;
+  getProjectName(): string;
+}

package/hooks/src/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 (global ~/.mindlore/ or none)
+ *   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, hookLog, withTelemetry } = 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`);
+  }
+}
+
+withTelemetry('mindlore-cwd-changed', main).catch(err => { hookLog('cwd-changed', 'error', err?.message ?? String(err)); });

package/hooks/src/mindlore-decision-detector.cjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-decision-detector — UserPromptSubmit hook
+ *
+ * Detects decision signals in user messages (TR + EN).
+ * Outputs a suggestion to record the decision via /mindlore-decide.
+ * Does NOT block (exit 0) — advisory only.
+ */
+
+const { findMindloreDir, readHookStdin, hookLog, withTelemetry } = require('./lib/mindlore-common.cjs');
+
+const SIGNALS_TR = [
+  'karar verdik', 'karar verildi', 'kararlastirdik', 'kararlaştırdık',
+  'şunu seçtik', 'sunu sectik', 'bunu yapmayalım', 'bunu yapmayalim',
+  'yerine', 'tercih ettik', 'onaylandi', 'onaylandı', 'kesinleşti', 'kesinlesti',
+  'vazgeçtik', 'vazgectik', 'iptal ettik',
+];
+
+const SIGNALS_EN = [
+  'decided', 'decision made', "let's go with", 'lets go with',
+  "we'll use", 'well use', 'approved', 'settled on',
+  'going with', 'chosen', 'finalized', 'rejected',
+];
+
+function detectDecision(text) {
+  const lower = text.toLowerCase();
+  for (const signal of SIGNALS_TR) {
+    if (lower.includes(signal)) return signal;
+  }
+  for (const signal of SIGNALS_EN) {
+    if (lower.includes(signal)) return signal;
+  }
+  return null;
+}
+
+function main() {
+  const baseDir = findMindloreDir();
+  if (!baseDir) return;
+
+  const userText = readHookStdin(['prompt', 'content', 'message']);
+  if (!userText || userText.length < 10) return;
+
+  const signal = detectDecision(userText);
+  if (signal) {
+    process.stdout.write(`[Mindlore: Karar sinyali tespit edildi ("${signal}") — /mindlore-decide record ile kaydetmek ister misin?]\n`);
+  }
+}
+
+withTelemetry('mindlore-decision-detector', main).catch(err => {
+  hookLog('mindlore-decision-detector', 'error', err?.message ?? String(err));
+  process.exit(0);
+});

package/hooks/src/mindlore-dont-repeat.cjs

@@ -0,0 +1,243 @@
+#!/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, getProjectName, hookLog, withTelemetrySync } = 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;
+}
+
+let _lessonsEnforcementCached = null;
+function hasLessonsEnforcementHook() {
+  if (_lessonsEnforcementCached !== null) return _lessonsEnforcementCached;
+  try {
+    const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    const hooks = settings.hooks || {};
+    const preToolUse = hooks.PreToolUse || [];
+    _lessonsEnforcementCached = preToolUse.some(entry => {
+      const cmds = (entry.hooks || []).map(h => h.command || '').concat(entry.command || '');
+      return cmds.some(c => c.includes('lessons-enforcement'));
+    });
+  } catch (_err) {
+    _lessonsEnforcementCached = false;
+  }
+  return _lessonsEnforcementCached;
+}
+
+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);
+
+      // Full dedup: lessons-enforcement hook scans identical sources — skip entirely
+      if (hasLessonsEnforcementHook()) 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-${getProjectName()}.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);
+  });
+}
+
+try { withTelemetrySync('mindlore-dont-repeat', main); } catch (err) { hookLog('dont-repeat', 'error', err?.message ?? String(err)); }

package/hooks/src/mindlore-fts5-sync.cjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-fts5-sync — FileChanged hook (incremental re-index)
+ *
+ * Handles bulk file changes by checking all .mindlore/ .md files
+ * against their content hashes and re-indexing only changed ones.
+ *
+ * Lightweight complement to mindlore-index.cjs which handles single files.
+ * This hook catches cases where multiple files change at once (e.g., git pull).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { DB_NAME, sha256, openDatabase, getAllMdFiles, parseFrontmatter, extractFtsMetadata, insertFtsRow, readHookStdin, getActiveMindloreDir, getProjectName, resolveProject, hookLog, withTelemetry, SQL_FTS_SESSIONS_INSERT, isSessionCategory, isInsideMindloreDir } = require('./lib/mindlore-common.cjs');
+
+function main() {
+  const filePath = readHookStdin(['path', 'file_path']);
+
+  if (!filePath) return;
+  const resolved = path.resolve(filePath);
+  if (!isInsideMindloreDir(resolved)) return;
+
+  // Skip if this is a single .md file change — mindlore-index.cjs handles those.
+  // This hook is for bulk changes (git pull, manual batch edits).
+  if (filePath.endsWith('.md')) return;
+
+  const baseDir = getActiveMindloreDir();
+  if (!fs.existsSync(baseDir)) return;
+
+  const dbPath = path.join(baseDir, DB_NAME);
+  if (!fs.existsSync(dbPath)) return;
+
+  const db = openDatabase(dbPath);
+  if (!db) return;
+
+  const mdFiles = getAllMdFiles(baseDir);
+
+  const allHashes = new Map();
+  for (const row of db.prepare('SELECT path, content_hash FROM file_hashes').all()) {
+    allHashes.set(row.path, row.content_hash);
+  }
+
+  const deleteFts = db.prepare('DELETE FROM mindlore_fts WHERE path = ?');
+  const deleteFtsSessions = db.prepare('DELETE FROM mindlore_fts_sessions WHERE path = ?');
+  const insertFtsSessions = db.prepare(SQL_FTS_SESSIONS_INSERT);
+  const upsertHash = 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
+  `);
+
+  const now = new Date().toISOString();
+
+  try {
+    const project = getProjectName();
+
+    const changedFiles = [];
+    for (const file of mdFiles) {
+      const content = fs.readFileSync(file, 'utf8').replace(/\r\n/g, '\n');
+      const hash = sha256(content);
+
+      const existingHash = allHashes.get(file);
+      if (existingHash === hash) continue;
+
+      const { meta, body } = parseFrontmatter(content);
+      const { slug, description, type, category, title, tags, quality, dateCaptured, project: ftsProject } = extractFtsMetadata(meta, body, file, baseDir);
+      const resolvedProject = resolveProject(ftsProject, file, project);
+      changedFiles.push({ file, hash, slug, description, type, category, title, tags, quality, dateCaptured, resolvedProject, body });
+    }
+
+    // No file I/O inside — minimize lock hold time
+    const transaction = db.transaction(() => {
+      for (const item of changedFiles) {
+        deleteFts.run(item.file);
+        deleteFtsSessions.run(item.file);
+        if (isSessionCategory(item.category)) {
+          insertFtsSessions.run(item.file, item.slug, item.description, item.type, item.category, item.title, item.body, item.tags, item.quality ?? null, item.dateCaptured ?? null, item.resolvedProject);
+        } else {
+          insertFtsRow(db, { path: item.file, slug: item.slug, description: item.description, type: item.type, category: item.category, title: item.title, content: item.body, tags: item.tags, quality: item.quality, dateCaptured: item.dateCaptured, project: item.resolvedProject });
+        }
+        upsertHash.run(item.file, item.hash, now);
+      }
+    });
+    transaction();
+  } finally {
+    db.close();
+  }
+
+}
+
+withTelemetry('mindlore-fts5-sync', main).catch(err => {
+  hookLog('mindlore-fts5-sync', 'error', err?.message ?? String(err));
+  process.exit(0);
+});