mindlore 0.0.1 → 0.2.0

package/scripts/mindlore-fts5-search.cjs

@@ -13,6 +13,7 @@ const fs = require('fs');
 const path = require('path');
 
 const { DB_NAME } = require('./lib/constants.cjs');
+const { openDatabase } = require('../hooks/lib/mindlore-common.cjs');
 const MAX_RESULTS = 3;
 
 // ── Helpers ────────────────────────────────────────────────────────────
@@ -46,16 +47,12 @@ function main() {
     process.exit(1);
   }
 
-  let Database;
-  try {
-    Database = require('better-sqlite3');
-  } catch (_err) {
+  const db = openDatabase(dbPath, { readonly: true });
+  if (!db) {
     console.error('  better-sqlite3 not installed.');
     process.exit(1);
   }
 
-  const db = new Database(dbPath, { readonly: true });
-
   try {
     // Sanitize query for FTS5 (escape special chars)
     const sanitized = query.replace(/['"(){}[\]*:^~!]/g, ' ').trim();

package/scripts/mindlore-health-check.cjs

@@ -15,35 +15,19 @@ const path = require('path');
 // ── Constants ──────────────────────────────────────────────────────────
 
 const { DIRECTORIES, TYPE_TO_DIR } = require('./lib/constants.cjs');
+const { parseFrontmatter: _parseFm, getAllMdFiles: _getAllMd } = require('../hooks/lib/mindlore-common.cjs');
 
 // ── Helpers ────────────────────────────────────────────────────────────
 
+// Wrapper: shared parseFrontmatter returns { meta, body }, health-check expects flat object or null
 function parseFrontmatter(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) return null;
-
-  const fm = {};
-  const lines = match[1].split('\n');
-  for (const line of lines) {
-    const colonIdx = line.indexOf(':');
-    if (colonIdx === -1) continue;
-    const key = line.slice(0, colonIdx).trim();
-    let value = line.slice(colonIdx + 1).trim();
-    // Handle arrays
-    if (value.startsWith('[') && value.endsWith(']')) {
-      value = value
-        .slice(1, -1)
-        .split(',')
-        .map((s) => s.trim());
-    }
-    fm[key] = value;
-  }
-  return fm;
+  const { meta } = _parseFm(content);
+  return Object.keys(meta).length > 0 ? meta : null;
 }
 
 // Health check needs ALL .md files (no skip), so pass empty set
 function getAllMdFiles(dir) {
-  return require('../hooks/lib/mindlore-common.cjs').getAllMdFiles(dir, new Set());
+  return _getAllMd(dir, new Set());
 }
 
 // ── Checks ─────────────────────────────────────────────────────────────
@@ -116,10 +100,10 @@ class HealthChecker {
       }
       const content = fs.readFileSync(indexPath, 'utf8');
       const lines = content.trim().split('\n');
-      if (lines.length > 30) {
+      if (lines.length > 60) {
         return {
           warn: true,
-          detail: `${lines.length} lines (should be ~15-20, consider trimming)`,
+          detail: `${lines.length} lines (should be ~15-60, consider trimming)`,
         };
       }
       return { ok: true, detail: `${lines.length} lines` };
@@ -147,9 +131,31 @@ class HealthChecker {
         const hashResult = db
           .prepare('SELECT count(*) as cnt FROM file_hashes')
           .get();
+
+        // Verify 9-column schema (slug, description, type, category, title, content, tags, quality + path)
+        let schemaVersion = 0;
+        try {
+          db.prepare('SELECT tags, quality FROM mindlore_fts LIMIT 0').run();
+          schemaVersion = 9;
+        } catch (_err) {
+          try {
+            db.prepare('SELECT slug, description, category, title FROM mindlore_fts LIMIT 0').run();
+            schemaVersion = 7;
+          } catch (_err2) {
+            schemaVersion = 2;
+          }
+        }
+
+        if (schemaVersion < 9) {
+          return {
+            warn: true,
+            detail: `${result.cnt} indexed, ${hashResult.cnt} hashes — ${schemaVersion}-col schema (run: npx mindlore init to upgrade to 9-col)`,
+          };
+        }
+
         return {
           ok: true,
-          detail: `${result.cnt} indexed, ${hashResult.cnt} hashes`,
+          detail: `${result.cnt} indexed, ${hashResult.cnt} hashes, 9-col schema`,
         };
       } catch (err) {
         return { ok: false, detail: `FTS5 error: ${err.message}` };
@@ -263,11 +269,72 @@ class HealthChecker {
           detail: `${mdFiles.length} files validated`,
         };
       }
-      return {
-        ok: wrongDir > 0 ? false : undefined,
-        warn: wrongDir === 0,
-        detail: issues.join(', '),
-      };
+      if (wrongDir > 0) {
+        return { ok: false, detail: issues.join(', ') };
+      }
+      return { warn: true, detail: issues.join(', ') };
+    });
+  }
+
+  // Check 17: Stale deltas (30+ days without archived: true)
+  checkStaleDeltas() {
+    this.check('Stale deltas', () => {
+      const diaryDir = path.join(this.baseDir, 'diary');
+      if (!fs.existsSync(diaryDir)) return { ok: true, detail: 'no diary dir' };
+
+      const now = Date.now();
+      const thirtyDays = 30 * 24 * 60 * 60 * 1000;
+      let stale = 0;
+
+      const files = fs.readdirSync(diaryDir).filter((f) => f.startsWith('delta-') && f.endsWith('.md'));
+      for (const file of files) {
+        const fullPath = path.join(diaryDir, file);
+        const content = fs.readFileSync(fullPath, 'utf8').replace(/\r\n/g, '\n');
+        const fm = parseFrontmatter(content);
+        if (fm && fm.archived === 'true') continue;
+
+        const stat = fs.statSync(fullPath);
+        if (now - stat.mtimeMs > thirtyDays) stale++;
+      }
+
+      if (stale === 0) return { ok: true, detail: `${files.length} deltas, none stale` };
+      return { warn: true, detail: `${stale} deltas older than 30 days without archived flag — run /mindlore-log reflect` };
+    });
+  }
+
+  // Check 18: Conflicting analyses (same tags, different confidence)
+  checkConflictingAnalyses() {
+    this.check('Conflicting analyses', () => {
+      const analysesDir = path.join(this.baseDir, 'analyses');
+      if (!fs.existsSync(analysesDir)) return { ok: true, detail: 'no analyses dir' };
+
+      const files = fs.readdirSync(analysesDir).filter((f) => f.endsWith('.md'));
+      if (files.length < 2) return { ok: true, detail: `${files.length} analyses, no conflict possible` };
+
+      const tagMap = {};
+      for (const file of files) {
+        const content = fs.readFileSync(path.join(analysesDir, file), 'utf8').replace(/\r\n/g, '\n');
+        const fm = parseFrontmatter(content);
+        if (!fm || !fm.tags || !fm.confidence) continue;
+
+        const tags = Array.isArray(fm.tags) ? fm.tags : String(fm.tags).split(',').map((t) => t.trim());
+        for (const tag of tags) {
+          if (!tagMap[tag]) tagMap[tag] = [];
+          tagMap[tag].push({ file, confidence: fm.confidence });
+        }
+      }
+
+      const conflicts = [];
+      for (const [tag, entries] of Object.entries(tagMap)) {
+        if (entries.length < 2) continue;
+        const confidences = new Set(entries.map((e) => e.confidence));
+        if (confidences.size > 1) {
+          conflicts.push(`${tag}: ${entries.map((e) => `${e.file}(${e.confidence})`).join(' vs ')}`);
+        }
+      }
+
+      if (conflicts.length === 0) return { ok: true, detail: `${files.length} analyses, no conflicts` };
+      return { warn: true, detail: `${conflicts.length} tag conflicts: ${conflicts.slice(0, 2).join('; ')}` };
     });
   }
 
@@ -280,6 +347,8 @@ class HealthChecker {
     this.checkDatabase();
     this.checkOrphans();
     this.checkFrontmatter();
+    this.checkStaleDeltas();
+    this.checkConflictingAnalyses();
     return this;
   }
 

package/scripts/uninstall.cjs

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore uninstall — Remove Mindlore hooks, skills, and optionally project data.
+ *
+ * Usage: npx mindlore uninstall [--all]
+ *
+ * --all: also remove .mindlore/ project data (without flag, only hooks + skills)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { homedir } = require('./lib/constants.cjs');
+
+function log(msg) {
+  console.log(`  ${msg}`);
+}
+
+// ── Remove hooks from settings.json ────────────────────────────────────
+
+function removeHooks() {
+  const settingsPath = path.join(homedir(), '.claude', 'settings.json');
+
+  if (!fs.existsSync(settingsPath)) {
+    log('No settings.json found, skipping hooks');
+    return 0;
+  }
+
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch (_err) {
+    log('Could not parse settings.json, skipping hooks');
+    return 0;
+  }
+
+  if (!settings.hooks) return 0;
+
+  let removed = 0;
+  for (const event of Object.keys(settings.hooks)) {
+    const entries = settings.hooks[event];
+    if (!Array.isArray(entries)) continue;
+
+    const filtered = entries.filter((entry) => {
+      const hooks = entry.hooks || [];
+      const hasMindlore = hooks.some(
+        (h) => (h.command || '').includes('mindlore-')
+      );
+      // Also check flat format (legacy)
+      const flatMindlore = (entry.command || '').includes('mindlore-');
+
+      if (hasMindlore || flatMindlore) {
+        removed++;
+        return false;
+      }
+      return true;
+    });
+
+    settings.hooks[event] = filtered;
+
+    // Clean up empty arrays
+    if (settings.hooks[event].length === 0) {
+      delete settings.hooks[event];
+    }
+  }
+
+  if (removed > 0) {
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+  }
+
+  return removed;
+}
+
+// ── Remove skills from ~/.claude/skills/ ───────────────────────────────
+
+function removeSkills() {
+  const skillsDir = path.join(homedir(), '.claude', 'skills');
+  if (!fs.existsSync(skillsDir)) return 0;
+
+  const mindloreSkills = fs
+    .readdirSync(skillsDir)
+    .filter((d) => d.startsWith('mindlore-'));
+
+  let removed = 0;
+  for (const skill of mindloreSkills) {
+    const skillPath = path.join(skillsDir, skill);
+    fs.rmSync(skillPath, { recursive: true, force: true });
+    removed++;
+  }
+
+  return removed;
+}
+
+// ── Remove SCHEMA.md from projectDocFiles ──────────────────────────────
+
+function removeFromProjectDocs() {
+  const projectSettingsPath = path.join(process.cwd(), '.claude', 'settings.json');
+  if (!fs.existsSync(projectSettingsPath)) return false;
+
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(projectSettingsPath, 'utf8'));
+  } catch (_err) {
+    return false;
+  }
+
+  if (!settings.projectDocFiles) return false;
+
+  const before = settings.projectDocFiles.length;
+  settings.projectDocFiles = settings.projectDocFiles.filter(
+    (p) => !p.includes('mindlore')
+  );
+
+  if (settings.projectDocFiles.length < before) {
+    fs.writeFileSync(
+      projectSettingsPath,
+      JSON.stringify(settings, null, 2),
+      'utf8'
+    );
+    return true;
+  }
+  return false;
+}
+
+// ── Remove .mindlore/ project data ─────────────────────────────────────
+
+function removeProjectData() {
+  const mindloreDir = path.join(process.cwd(), '.mindlore');
+  if (!fs.existsSync(mindloreDir)) {
+    log('No .mindlore/ directory in current project');
+    return false;
+  }
+
+  fs.rmSync(mindloreDir, { recursive: true, force: true });
+  return true;
+}
+
+// ── Main ───────────────────────────────────────────────────────────────
+
+function main() {
+  const args = process.argv.slice(2);
+  const removeAll = args.includes('--all');
+
+  console.log('\n  Mindlore — Uninstall\n');
+
+  // Hooks
+  const hooksRemoved = removeHooks();
+  log(
+    hooksRemoved > 0
+      ? `Removed ${hooksRemoved} hooks from ~/.claude/settings.json`
+      : 'No hooks found'
+  );
+
+  // Skills
+  const skillsRemoved = removeSkills();
+  log(
+    skillsRemoved > 0
+      ? `Removed ${skillsRemoved} skills from ~/.claude/skills/`
+      : 'No skills found'
+  );
+
+  // Project doc files
+  const docsRemoved = removeFromProjectDocs();
+  log(
+    docsRemoved
+      ? 'Removed SCHEMA.md from project settings'
+      : 'No project doc references found'
+  );
+
+  // Project data (only with --all)
+  if (removeAll) {
+    const dataRemoved = removeProjectData();
+    log(
+      dataRemoved
+        ? 'Removed .mindlore/ project data'
+        : 'No .mindlore/ directory found'
+    );
+  } else {
+    log('.mindlore/ project data kept (use --all to remove)');
+  }
+
+  console.log('\n  Done! Mindlore has been uninstalled.\n');
+}
+
+main();

package/skills/mindlore-decide/SKILL.md

@@ -0,0 +1,71 @@
+# Skill: Mindlore Decide
+
+Record and list decisions in the `.mindlore/decisions/` directory.
+
+## Trigger
+
+User says `/mindlore-decide record` or `/mindlore-decide list`.
+
+## Modes
+
+### record
+
+Record a new decision.
+
+**Flow:**
+1. Ask user (or extract from context): What was decided? What alternatives were considered? Why this choice?
+2. Generate slug from decision title (kebab-case, max 5 words)
+3. Check if a previous decision on same topic exists → set `supersedes` field
+4. Write to `.mindlore/decisions/{slug}.md` with frontmatter:
+
+```yaml
+---
+slug: use-fts5-over-vector
+type: decision
+title: Use FTS5 over vector search for v0.1
+tags: [search, fts5, architecture]
+date: 2026-04-11
+supersedes: null
+status: active
+description: Chose FTS5 keyword search as primary engine, vector deferred to v0.4
+---
+```
+
+5. Body structure:
+```markdown
+# {title}
+
+## Context
+Why this decision was needed.
+
+## Alternatives Considered
+1. **Option A** — pros/cons
+2. **Option B** — pros/cons
+
+## Decision
+What was chosen and why.
+
+## Consequences
+What this means going forward.
+```
+
+6. Append to `log.md`: `| {date} | decide | {slug}.md |`
+7. FTS5 auto-indexes via FileChanged hook
+
+### list
+
+List active decisions.
+
+**Flow:**
+1. Read all `.md` files in `.mindlore/decisions/`
+2. Parse frontmatter, filter `status: active`
+3. Display as table: slug, title, date, tags
+4. Show supersedes chain if any (A → B → C)
+
+## Rules
+
+- Slug must be unique in decisions/
+- `supersedes` field points to the slug of the replaced decision
+- When a decision is superseded, update old one: `status: superseded`
+- Tags should match domain topics for FTS5 discoverability
+- Keep decision body concise — context + alternatives + choice + consequences

package/skills/mindlore-ingest/SKILL.md

@@ -94,9 +94,20 @@ Only update the stats line: increment source count and total count.
 N source, N analysis, N total
 ```
 
-## Post-Ingest Verification
+## Post-Ingest Quality Gate
 
-After ingest, run health check:
+After every ingest, verify all 6 checkpoints before reporting success:
+
+1. **raw/ file exists** — immutable capture written with frontmatter (slug, type, source_url)
+2. **sources/ summary exists** — processed summary with full frontmatter (slug, type, title, tags, quality, description)
+3. **INDEX.md updated** — stats line incremented, Recent section has new entry
+4. **Domain updated** — if relevant domain exists, new finding added (max 1 domain per ingest)
+5. **log.md entry** — append `| {date} | ingest | {slug}.md |`
+6. **FTS5 indexed** — FileChanged hook auto-triggers, but verify: `node scripts/mindlore-fts5-search.cjs "{keyword}"` returns the new file
+
+If any checkpoint fails, fix it before reporting "ingest complete". Do NOT skip steps.
+
+Optional: run full health check for structural integrity:
 ```bash
 node scripts/mindlore-health-check.cjs
 ```

package/skills/mindlore-log/SKILL.md

@@ -0,0 +1,79 @@
+# Skill: Mindlore Log
+
+Session logging, pattern extraction, and wiki updates.
+
+## Trigger
+
+`/mindlore-log <mode>` where mode is `log`, `reflect`, `status`, or `save`.
+
+## Modes
+
+### log
+
+Write a manual diary entry.
+
+**Flow:**
+1. User provides note/observation (or extract from conversation context)
+2. Generate slug: `note-YYYY-MM-DD-HHmm`
+3. Write to `.mindlore/diary/{slug}.md`:
+
+```yaml
+---
+slug: note-2026-04-11-1530
+type: diary
+date: 2026-04-11
+---
+```
+
+4. Body: user's note as-is
+5. Append to `log.md`: `| {date} | log | {slug}.md |`
+
+### reflect
+
+Scan old deltas, extract patterns, write to learnings/.
+
+**Flow (v0.2 — basic):**
+1. Read all non-archived delta files in `diary/` (no `archived: true` frontmatter)
+2. Present summary to user: "Found N unprocessed deltas spanning DATE1 to DATE2"
+3. For each delta, extract: repeated topics, recurring decisions, common file changes
+4. Propose learnings to user: "I found these patterns: ..."
+5. User approves → write to `learnings/{topic}.md` (append if exists, create if not)
+6. Format: `YAPMA:` / `BEST PRACTICE:` / `KRITIK:` prefixed rules
+7. Mark processed deltas: add `archived: true` to their frontmatter
+8. Append to `log.md`: `| {date} | reflect | {N} deltas processed, {M} learnings written |`
+
+**Important:** Do NOT auto-extract patterns. Present findings, user approves. This is v0.2 basic mode — automated pattern extraction deferred to v0.2.1.
+
+### status
+
+Show recent session summary.
+
+**Flow:**
+1. Read last 5 delta files from `diary/` (sorted by date, newest first)
+2. For each delta, extract: date, commits count, changed files count
+3. Display as compact table
+4. Show any open items (from delta "Yarım Kalan" sections if present)
+5. Show total: "N sessions, M commits, K unique files changed"
+
+### save
+
+Structured delta + log.md append + domain wiki update.
+
+**Flow:**
+1. Gather current session context:
+   - Recent git commits (last 5)
+   - Changed files
+   - Decisions made (if decision-detector captured any)
+2. Write structured delta to `diary/delta-YYYY-MM-DD-HHmm.md` (same format as session-end hook)
+3. Append to `log.md`
+4. Ask user: "Which domain pages should be updated with this session's findings?"
+5. If user specifies domains → update those `.mindlore/domains/{slug}.md` pages with new findings
+6. Max 2 domain updates per save (prevent sprawl)
+
+## Rules
+
+- Diary files are session-scoped (temporary), learnings are permanent
+- reflect marks deltas as `archived: true` — they stay in diary/ but are not processed again
+- Health check warns on deltas older than 30 days without `archived: true`
+- learnings/ files are topic-based (one per topic), append-only
+- save mode is the manual equivalent of what session-end hook does automatically

package/skills/mindlore-query/SKILL.md

@@ -0,0 +1,125 @@
+# Skill: Mindlore Query
+
+Search, ask, analyze, and retrieve knowledge from `.mindlore/`.
+
+## Trigger
+
+`/mindlore-query <mode> [query]` where mode is `search`, `ask`, `stats`, or `brief`.
+
+## Modes
+
+### search
+
+FTS5 keyword search with direct 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
+
+**Output format:**
+```
+| # | Category | Title | Description | Score |
+|---|----------|-------|-------------|-------|
+| 1 | sources  | React Hooks | useEffect cleanup patterns | -2.34 |
+```
+
+### ask
+
+Compounding query pipeline — knowledge grows with each answer.
+
+**Flow:**
+1. Parse user question
+2. FTS5 search → find relevant files (sources + domains + analyses + insights — previous answers INCLUDED)
+3. Read top 3-5 relevant files using ctx_execute_file if context-mode available, else Read
+4. Synthesize answer from found knowledge
+5. Cite sources: `[kaynak: sources/x.md]` format
+6. Ask user: "Bu cevabı kaydetmemi ister misin?"
+7. If yes → determine target:
+   - Short answer (<200 lines, 1-2 sources) → `insights/{slug}.md`
+   - Large synthesis (200+ lines, 3+ sources) → `analyses/{slug}.md`
+8. Write with frontmatter:
+
+```yaml
+---
+slug: react-hooks-cleanup-comparison
+type: insight
+title: React Hooks Cleanup Comparison
+tags: [react, hooks, useEffect]
+confidence: high
+sources_used: [react-hooks, typescript-generics]
+description: Comparison of cleanup patterns in useEffect vs useLayoutEffect
+---
+```
+
+9. FTS5 auto-indexes via FileChanged hook → next query finds this answer
+10. Update relevant domain page (max 1) with backlink if applicable
+11. Append to `log.md`: `| {date} | query-ask | {slug}.md |`
+
+**Compounding effect:** Step 2 searches ALL of `.mindlore/` including previous `insights/` and `analyses/`. Each saved answer enriches the next query.
+
+**Error compounding prevention:**
+- `confidence` field is REQUIRED on writebacks (high/medium/low)
+- `sources_used` lists exact slugs — traceability
+- Health check flags conflicting analyses on same topic (different confidence)
+- User approval is the quality gate — low-quality answers are not saved
+
+### stats
+
+Knowledge base statistics.
+
+**Flow:**
+1. Count files per directory (9 directories)
+2. Count FTS5 entries and file_hashes entries
+3. Find most recent ingest (latest file by modified date per directory)
+4. Count tags frequency (parse all frontmatter, aggregate tags)
+5. Display summary:
+
+```
+Mindlore Stats
+─────────────
+Total files: 47 (FTS5: 47 indexed)
+ - sources:     18
+ - domains:      5
+ - analyses:     6
+ - insights:     3
+ - connections:  2
+ - learnings:    4
+ - diary:        8
+ - decisions:    1
+ - raw:          0
+
+Top tags: security (12), hooks (8), fts5 (6), testing (5)
+Last ingest: 2026-04-11 (sources/react-hooks.md)
+DB size: 1.2 MB
+```
+
+### brief
+
+Quick context on a topic — token-efficient (~50 tokens output).
+
+**Flow:**
+1. FTS5 search for topic
+2. If domain page exists → read first 3 lines of body (after frontmatter)
+3. If no domain → read description field from top FTS5 match
+4. Return: title + description + "Read full: {path}" pointer
+5. Do NOT read full file — this mode is for quick "do I need to open this?" decisions
+
+**Output format:**
+```
+[Mindlore Brief: Security]
+SSH hardening, firewall rules, audit checks. 5 sources, 2 analyses linked.
+→ Read full: .mindlore/domains/security.md
+```
+
+## Rules
+
+- All modes respect the SCHEMA.md writeback rules (Section 6: Wiki vs Diary)
+- search and brief are read-only — no writes
+- ask writes only with user approval
+- stats is read-only
+- Token strategy: prefer ctx_execute_file (if context-mode installed), fallback to Read
+- Tags filter: `--tags security` works in search and ask modes
+- Max results: search=5, ask=3-5 (for synthesis), brief=1