mindlore 0.0.1

package/hooks/mindlore-pre-compact.cjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-pre-compact — PreCompact hook
+ *
+ * Before context compaction:
+ * 1. Write a delta snapshot to diary/ (if not already written this session)
+ * 2. Ensure FTS5 index is up to date
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { findMindloreDir } = require('./lib/mindlore-common.cjs');
+
+function main() {
+  const baseDir = findMindloreDir();
+  if (!baseDir) return;
+
+  // Trigger FTS5 sync via the index script
+  const indexScript = path.join(__dirname, '..', 'scripts', 'mindlore-fts5-index.cjs');
+  if (fs.existsSync(indexScript)) {
+    try {
+      const { execSync } = require('child_process');
+      execSync(`node "${indexScript}" "${baseDir}"`, {
+        timeout: 10000,
+        stdio: 'pipe',
+      });
+    } catch (_err) {
+      // Non-fatal — index might fail if better-sqlite3 not available
+    }
+  }
+
+  // Write a pre-compact marker to diary
+  const diaryDir = path.join(baseDir, 'diary');
+  if (!fs.existsSync(diaryDir)) return;
+
+  const logPath = path.join(baseDir, 'log.md');
+  if (fs.existsSync(logPath)) {
+    const now = new Date().toISOString();
+    const entry = `| ${now.slice(0, 10)} | pre-compact | FTS5 flush before compaction |\n`;
+    fs.appendFileSync(logPath, entry, 'utf8');
+  }
+
+  process.stderr.write('[Mindlore: pre-compact FTS5 flush complete]\n');
+}
+
+main();

package/hooks/mindlore-search.cjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-search — UserPromptSubmit hook
+ *
+ * Extracts keywords from user prompt, searches FTS5, injects top 3 results.
+ * Results: file path + first 2 headings via stderr additionalContext.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { findMindloreDir, DB_NAME, requireDatabase } = require('./lib/mindlore-common.cjs');
+
+const MAX_RESULTS = 3;
+const MIN_QUERY_LENGTH = 3;
+
+function extractKeywords(text) {
+  // Remove common stop words and short words
+  const stopWords = new Set([
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+    'should', 'may', 'might', 'can', 'shall', 'to', 'of', 'in', 'for',
+    'on', 'with', 'at', 'by', 'from', 'as', 'into', 'about', 'between',
+    'through', 'after', 'before', 'above', 'below', 'up', 'down', 'out',
+    'and', 'but', 'or', 'nor', 'not', 'so', 'yet', 'both', 'either',
+    'neither', 'each', 'every', 'all', 'any', 'few', 'more', 'most',
+    'other', 'some', 'such', 'no', 'only', 'own', 'same', 'than', 'too',
+    'very', 'just', 'also', 'now', 'then', 'here', 'there', 'when',
+    'where', 'why', 'how', 'what', 'which', 'who', 'whom', 'this',
+    'that', 'these', 'those', 'it', 'its', 'my', 'your', 'his', 'her',
+    'our', 'their', 'me', 'him', 'us', 'them', 'i', 'you', 'he', 'she',
+    'we', 'they', 'bu', 'su', 'bir', 'de', 'da', 've', 'ile', 'icin',
+    'var', 'mi', 'ne', 'nasil', 'nedir', 'evet', 'hayir',
+  ]);
+
+  const words = text
+    .toLowerCase()
+    .replace(/[^a-z0-9\u00e7\u011f\u0131\u00f6\u015f\u00fc\s-]/g, ' ')
+    .split(/\s+/)
+    .filter((w) => w.length >= MIN_QUERY_LENGTH && !stopWords.has(w));
+
+  // Deduplicate and limit
+  return [...new Set(words)].slice(0, 5);
+}
+
+function extractHeadings(content, max) {
+  const headings = [];
+  for (const line of content.split('\n')) {
+    if (line.startsWith('#')) {
+      headings.push(line.replace(/^#+\s*/, '').trim());
+      if (headings.length >= max) break;
+    }
+  }
+  return headings;
+}
+
+function main() {
+  // Read user prompt from stdin
+  let input = '';
+  try {
+    input = fs.readFileSync(0, 'utf8');
+  } catch (_err) {
+    return;
+  }
+
+  let userMessage = '';
+  try {
+    const parsed = JSON.parse(input);
+    userMessage = parsed.content || parsed.message || parsed.query || input;
+  } catch (_err) {
+    userMessage = input;
+  }
+
+  if (!userMessage || userMessage.length < MIN_QUERY_LENGTH) 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 === 0) return;
+
+  const Database = requireDatabase();
+  if (!Database) return;
+
+  const db = new Database(dbPath, { readonly: true });
+
+  try {
+    // Build FTS5 query — OR between keywords
+    const ftsQuery = keywords.join(' OR ');
+
+    const results = db
+      .prepare(
+        `SELECT path, rank
+         FROM mindlore_fts
+         WHERE mindlore_fts MATCH ?
+         ORDER BY rank
+         LIMIT ?`
+      )
+      .all(ftsQuery, MAX_RESULTS);
+
+    if (results.length === 0) return;
+
+    const output = [];
+    for (const r of results) {
+      const relativePath = path.relative(baseDir, r.path);
+      let headings = [];
+
+      if (fs.existsSync(r.path)) {
+        const content = fs.readFileSync(r.path, 'utf8');
+        headings = extractHeadings(content, 2);
+      }
+
+      const headingStr = headings.length > 0 ? ` — ${headings.join(', ')}` : '';
+      output.push(`${relativePath}${headingStr}`);
+    }
+
+    if (output.length > 0) {
+      process.stderr.write(
+        `[Mindlore Search: ${keywords.join(', ')}]\n${output.join('\n')}\n`
+      );
+    }
+  } catch (_err) {
+    // FTS5 query error — silently skip
+  } finally {
+    db.close();
+  }
+}
+
+main();

package/hooks/mindlore-session-end.cjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-session-end — SessionEnd hook
+ *
+ * Writes a basic delta file to diary/ with session timestamp.
+ * v0.1: minimal delta (timestamp + marker)
+ * v0.2: structured delta with stats, decisions, learnings
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { findMindloreDir } = require('./lib/mindlore-common.cjs');
+
+function formatDate(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, '0');
+  const d = String(date.getDate()).padStart(2, '0');
+  const h = String(date.getHours()).padStart(2, '0');
+  const min = String(date.getMinutes()).padStart(2, '0');
+  return `${y}-${m}-${d}-${h}${min}`;
+}
+
+function main() {
+  const baseDir = findMindloreDir();
+  if (!baseDir) return;
+
+  const diaryDir = path.join(baseDir, 'diary');
+  if (!fs.existsSync(diaryDir)) {
+    fs.mkdirSync(diaryDir, { recursive: true });
+  }
+
+  const now = new Date();
+  const dateStr = formatDate(now);
+  const deltaPath = path.join(diaryDir, `delta-${dateStr}.md`);
+
+  // Don't overwrite existing delta (idempotent)
+  if (fs.existsSync(deltaPath)) return;
+
+  const content = [
+    '---',
+    `slug: delta-${dateStr}`,
+    'type: diary',
+    `date: ${now.toISOString().slice(0, 10)}`,
+    '---',
+    '',
+    `# Session Delta — ${dateStr}`,
+    '',
+    `Session ended: ${now.toISOString()}`,
+    '',
+    '## Changes',
+    '',
+    '_No structured changes tracked in v0.1. Upgrade to v0.2 for detailed deltas._',
+    '',
+  ].join('\n');
+
+  fs.writeFileSync(deltaPath, content, 'utf8');
+
+  // Append to log.md
+  const logPath = path.join(baseDir, 'log.md');
+  if (fs.existsSync(logPath)) {
+    const logEntry = `| ${now.toISOString().slice(0, 10)} | session-end | delta-${dateStr}.md |\n`;
+    fs.appendFileSync(logPath, logEntry, 'utf8');
+  }
+}
+
+main();

package/hooks/mindlore-session-focus.cjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-session-focus — SessionStart hook
+ *
+ * Injects last delta file content + INDEX.md into session context.
+ * Fires once at session start via stderr additionalContext.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { findMindloreDir, getLatestDelta } = require('./lib/mindlore-common.cjs');
+
+function main() {
+  const baseDir = findMindloreDir();
+  if (!baseDir) return; // No .mindlore/ found, silently skip
+
+  const output = [];
+
+  // Inject INDEX.md
+  const indexPath = path.join(baseDir, 'INDEX.md');
+  if (fs.existsSync(indexPath)) {
+    const content = fs.readFileSync(indexPath, 'utf8').trim();
+    output.push(`[Mindlore INDEX]\n${content}`);
+  }
+
+  // Inject latest delta
+  const diaryDir = path.join(baseDir, 'diary');
+  const latestDelta = getLatestDelta(diaryDir);
+  if (latestDelta) {
+    const deltaContent = fs.readFileSync(latestDelta, 'utf8').trim();
+    const deltaName = path.basename(latestDelta);
+    output.push(`[Mindlore Delta: ${deltaName}]\n${deltaContent}`);
+  }
+
+  if (output.length > 0) {
+    process.stderr.write(output.join('\n\n') + '\n');
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "mindlore",
+  "version": "0.0.1",
+  "description": "AI-native knowledge system for Claude Code",
+  "type": "commonjs",
+  "bin": {
+    "mindlore": "scripts/init.cjs"
+  },
+  "scripts": {
+    "test": "jest --config jest.config.cjs",
+    "lint": "eslint -c eslint.config.cjs scripts/ hooks/ tests/",
+    "health": "node scripts/mindlore-health-check.cjs",
+    "index": "node scripts/mindlore-fts5-index.cjs",
+    "search": "node scripts/mindlore-fts5-search.cjs"
+  },
+  "keywords": [
+    "claude-code",
+    "knowledge-base",
+    "second-brain",
+    "ai-native",
+    "fts5",
+    "karpathy",
+    "llm",
+    "wiki"
+  ],
+  "author": "omrfc",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mindlore/mindlore.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mindlore/mindlore/issues"
+  },
+  "homepage": "https://github.com/mindlore/mindlore#readme",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.0.0"
+  },
+  "devDependencies": {
+    "eslint": "^9.0.0",
+    "jest": "^29.7.0",
+    "globals": "^15.0.0"
+  },
+  "files": [
+    "scripts/",
+    "hooks/",
+    "skills/",
+    "templates/",
+    "SCHEMA.md",
+    "plugin.json"
+  ]
+}

package/plugin.json

@@ -0,0 +1,47 @@
+{
+  "name": "mindlore",
+  "description": "AI-native knowledge system for Claude Code. Persistent, searchable, evolving knowledge base with FTS5.",
+  "version": "0.0.1",
+  "skills": [
+    {
+      "name": "mindlore-ingest",
+      "path": "skills/mindlore-ingest/SKILL.md",
+      "description": "Add new knowledge sources (URL, text, file, PDF, GitHub repo)"
+    },
+    {
+      "name": "mindlore-health",
+      "path": "skills/mindlore-health/SKILL.md",
+      "description": "Run 16-point structural health check on .mindlore/ knowledge base"
+    }
+  ],
+  "hooks": [
+    {
+      "event": "SessionStart",
+      "script": "hooks/mindlore-session-focus.cjs"
+    },
+    {
+      "event": "UserPromptSubmit",
+      "script": "hooks/mindlore-search.cjs"
+    },
+    {
+      "event": "FileChanged",
+      "script": "hooks/mindlore-index.cjs"
+    },
+    {
+      "event": "FileChanged",
+      "script": "hooks/mindlore-fts5-sync.cjs"
+    },
+    {
+      "event": "SessionEnd",
+      "script": "hooks/mindlore-session-end.cjs"
+    },
+    {
+      "event": "PreCompact",
+      "script": "hooks/mindlore-pre-compact.cjs"
+    },
+    {
+      "event": "PostCompact",
+      "script": "hooks/mindlore-post-compact.cjs"
+    }
+  ]
+}