mindlore 0.0.1

package/scripts/init.cjs

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore init — Initialize .mindlore/ knowledge base in current project.
+ *
+ * Usage: npx mindlore init [--recommended]
+ *
+ * Idempotent: running again does not destroy existing data.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ── Constants ──────────────────────────────────────────────────────────
+
+const { MINDLORE_DIR, DB_NAME, DIRECTORIES } = require('./lib/constants.cjs');
+
+const TEMPLATE_FILES = ['INDEX.md', 'log.md'];
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+function log(msg) {
+  console.log(`  ${msg}`);
+}
+
+function resolvePackageRoot() {
+  // When installed globally via npm, __dirname is inside the package
+  // Look for templates/ relative to this script
+  return path.resolve(__dirname, '..');
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+    return true;
+  }
+  return false;
+}
+
+// ── Step 1: Create .mindlore/ directories ──────────────────────────────
+
+function createDirectories(baseDir) {
+  let created = 0;
+  for (const dir of DIRECTORIES) {
+    if (ensureDir(path.join(baseDir, dir))) {
+      created++;
+    }
+  }
+  return created;
+}
+
+// ── Step 2: Copy template files ────────────────────────────────────────
+
+function copyTemplates(baseDir, packageRoot) {
+  const templatesDir = path.join(packageRoot, 'templates');
+  let copied = 0;
+
+  for (const file of TEMPLATE_FILES) {
+    const dest = path.join(baseDir, file);
+    if (!fs.existsSync(dest)) {
+      const src = path.join(templatesDir, file);
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, dest);
+        copied++;
+      } else {
+        log(`WARNING: template not found: ${src}`);
+      }
+    }
+  }
+
+  // Copy SCHEMA.md
+  const schemaSrc = path.join(packageRoot, 'SCHEMA.md');
+  const schemaDest = path.join(baseDir, 'SCHEMA.md');
+  if (!fs.existsSync(schemaDest)) {
+    if (fs.existsSync(schemaSrc)) {
+      fs.copyFileSync(schemaSrc, schemaDest);
+      copied++;
+    }
+  }
+
+  return copied;
+}
+
+// ── Step 3: Create FTS5 database ───────────────────────────────────────
+
+function createDatabase(baseDir) {
+  const dbPath = path.join(baseDir, DB_NAME);
+  if (fs.existsSync(dbPath)) {
+    log('Database already exists, skipping');
+    return false;
+  }
+
+  let Database;
+  try {
+    Database = require('better-sqlite3');
+  } catch (_err) {
+    log('WARNING: better-sqlite3 not installed. Run: npm install better-sqlite3');
+    log('Database creation skipped — run mindlore init again after installing.');
+    return false;
+  }
+
+  const db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+
+  db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS mindlore_fts
+    USING fts5(path, content, tokenize='unicode61');
+  `);
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS file_hashes (
+      path TEXT PRIMARY KEY,
+      content_hash TEXT NOT NULL,
+      last_indexed TEXT NOT NULL
+    );
+  `);
+
+  db.close();
+  return true;
+}
+
+// ── Step 4: Merge hooks into settings.json ─────────────────────────────
+
+function mergeHooks(packageRoot) {
+  const settingsPath = path.join(
+    require('./lib/constants.cjs').homedir(),
+    '.claude',
+    'settings.json'
+  );
+
+  if (!fs.existsSync(settingsPath)) {
+    log('WARNING: ~/.claude/settings.json not found. Hooks not registered.');
+    log('Create it manually or install Claude Code first.');
+    return false;
+  }
+
+  let settings;
+  try {
+    const raw = fs.readFileSync(settingsPath, 'utf8');
+    settings = JSON.parse(raw);
+  } catch (_err) {
+    log('WARNING: Could not parse settings.json. Hooks not registered.');
+    return false;
+  }
+
+  // Read plugin.json for hook definitions
+  const pluginPath = path.join(packageRoot, 'plugin.json');
+  if (!fs.existsSync(pluginPath)) {
+    log('WARNING: plugin.json not found. Hooks not registered.');
+    return false;
+  }
+
+  const plugin = JSON.parse(fs.readFileSync(pluginPath, 'utf8'));
+  if (!plugin.hooks || plugin.hooks.length === 0) {
+    return false;
+  }
+
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  let added = 0;
+  for (const hook of plugin.hooks) {
+    const event = hook.event;
+    if (!settings.hooks[event]) {
+      settings.hooks[event] = [];
+    }
+
+    // Check if this hook already exists (by script path containing 'mindlore-')
+    const hookScript = path.join(packageRoot, hook.script);
+    const hookName = path.basename(hook.script, '.cjs');
+
+    const exists = settings.hooks[event].some((entry) => {
+      // CC format: each entry is { hooks: [{ type, command }] }
+      if (entry.hooks && Array.isArray(entry.hooks)) {
+        return entry.hooks.some((h) => (h.command || '').includes(hookName));
+      }
+      // Legacy flat format check
+      return (entry.command || '').includes(hookName);
+    });
+
+    if (!exists) {
+      settings.hooks[event].push({
+        hooks: [
+          {
+            type: 'command',
+            command: `node "${hookScript}"`,
+          },
+        ],
+      });
+      added++;
+    }
+  }
+
+  if (added > 0) {
+    // Backup before writing
+    const backupPath = settingsPath + '.mindlore-backup';
+    if (!fs.existsSync(backupPath)) {
+      fs.copyFileSync(settingsPath, backupPath);
+    }
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+  }
+
+  return added;
+}
+
+// ── Step 5: Add SCHEMA.md to projectDocFiles ───────────────────────────
+
+function addSchemaToProjectDocs() {
+  const projectSettingsDir = path.join(process.cwd(), '.claude');
+  const projectSettingsPath = path.join(projectSettingsDir, 'settings.json');
+
+  let settings = {};
+  if (fs.existsSync(projectSettingsPath)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(projectSettingsPath, 'utf8'));
+    } catch (_err) {
+      settings = {};
+    }
+  } else {
+    ensureDir(projectSettingsDir);
+  }
+
+  if (!settings.projectDocFiles) {
+    settings.projectDocFiles = [];
+  }
+
+  const schemaPath = path.join(MINDLORE_DIR, 'SCHEMA.md');
+  if (!settings.projectDocFiles.includes(schemaPath)) {
+    settings.projectDocFiles.push(schemaPath);
+    fs.writeFileSync(
+      projectSettingsPath,
+      JSON.stringify(settings, null, 2),
+      'utf8'
+    );
+    return true;
+  }
+  return false;
+}
+
+// ── Step 6: Add .mindlore/ to .gitignore ───────────────────────────────
+
+function addToGitignore() {
+  const gitignorePath = path.join(process.cwd(), '.gitignore');
+  const entry = '.mindlore/';
+
+  if (fs.existsSync(gitignorePath)) {
+    const content = fs.readFileSync(gitignorePath, 'utf8');
+    if (content.includes(entry)) {
+      return false;
+    }
+    fs.appendFileSync(gitignorePath, `\n${entry}\n`, 'utf8');
+  } else {
+    fs.writeFileSync(gitignorePath, `${entry}\n`, 'utf8');
+  }
+  return true;
+}
+
+// ── Main ───────────────────────────────────────────────────────────────
+
+function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (command && command !== 'init') {
+    console.log(`Unknown command: ${command}`);
+    console.log('Usage: npx mindlore init [--recommended]');
+    process.exit(1);
+  }
+
+  const isRecommended = args.includes('--recommended');
+  const packageRoot = resolvePackageRoot();
+  const baseDir = path.join(process.cwd(), MINDLORE_DIR);
+
+  console.log('\n  Mindlore — AI-native knowledge system\n');
+
+  // Step 1: Directories
+  const dirsCreated = createDirectories(baseDir);
+  log(
+    dirsCreated > 0
+      ? `Created ${dirsCreated} directories in ${MINDLORE_DIR}/`
+      : 'All directories already exist'
+  );
+
+  // Step 2: Templates
+  const filesCopied = copyTemplates(baseDir, packageRoot);
+  log(
+    filesCopied > 0
+      ? `Copied ${filesCopied} template files`
+      : 'All templates already in place'
+  );
+
+  // Step 3: Database
+  const dbCreated = createDatabase(baseDir);
+  log(dbCreated ? 'Created FTS5 database' : 'Database already exists');
+
+  // Step 4: Hooks
+  const hooksAdded = mergeHooks(packageRoot);
+  if (typeof hooksAdded === 'number' && hooksAdded > 0) {
+    log(`Registered ${hooksAdded} hooks in ~/.claude/settings.json`);
+  } else {
+    log('Hooks already registered (or settings.json not found)');
+  }
+
+  // Step 5: SCHEMA.md in projectDocFiles
+  const schemaAdded = addSchemaToProjectDocs();
+  log(
+    schemaAdded
+      ? 'Added SCHEMA.md to project settings'
+      : 'SCHEMA.md already in project settings'
+  );
+
+  // Step 6: .gitignore
+  const gitignoreAdded = addToGitignore();
+  log(
+    gitignoreAdded
+      ? 'Added .mindlore/ to .gitignore'
+      : '.mindlore/ already in .gitignore'
+  );
+
+  // Recommended profile tips
+  if (isRecommended) {
+    console.log('\n  Recommended setup:');
+    log('Install markitdown for better web/doc extraction:');
+    log('  pip install markitdown');
+    log('');
+    log('Install context-mode for token savings:');
+    log('  See: https://github.com/context-mode/context-mode');
+  }
+
+  console.log('\n  Done! Start with: /mindlore-ingest\n');
+}
+
+main();

package/scripts/lib/constants.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+/**
+ * Shared constants and utilities for mindlore scripts.
+ */
+
+const os = require('os');
+
+const MINDLORE_DIR = '.mindlore';
+const DB_NAME = 'mindlore.db';
+
+const DIRECTORIES = [
+  'raw',
+  'sources',
+  'domains',
+  'analyses',
+  'insights',
+  'connections',
+  'learnings',
+  'diary',
+  'decisions',
+];
+
+const SKIP_FILES = new Set(['INDEX.md', 'SCHEMA.md', 'log.md']);
+
+const TYPE_TO_DIR = {
+  raw: 'raw',
+  source: 'sources',
+  domain: 'domains',
+  analysis: 'analyses',
+  insight: 'insights',
+  connection: 'connections',
+  learning: 'learnings',
+  decision: 'decisions',
+  diary: 'diary',
+};
+
+function homedir() {
+  return os.homedir();
+}
+
+module.exports = {
+  MINDLORE_DIR,
+  DB_NAME,
+  DIRECTORIES,
+  SKIP_FILES,
+  TYPE_TO_DIR,
+  homedir,
+};

package/scripts/mindlore-fts5-index.cjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-fts5-index — Full re-index of .mindlore/ into FTS5 database.
+ *
+ * Scans all .md files, computes SHA256 content-hash, skips unchanged files.
+ * Usage: node scripts/mindlore-fts5-index.cjs [path-to-mindlore-dir]
+ */
+
+const fs = require('fs');
+const path = require('path');
+// ── Constants ──────────────────────────────────────────────────────────
+
+const { DB_NAME } = require('./lib/constants.cjs');
+const { sha256, getAllMdFiles } = require('../hooks/lib/mindlore-common.cjs');
+
+// ── Main ───────────────────────────────────────────────────────────────
+
+function main() {
+  const baseDir = process.argv[2] || path.join(process.cwd(), '.mindlore');
+  const dbPath = path.join(baseDir, DB_NAME);
+
+  if (!fs.existsSync(dbPath)) {
+    console.error('  Database not found. Run: npx mindlore init');
+    process.exit(1);
+  }
+
+  let Database;
+  try {
+    Database = require('better-sqlite3');
+  } catch (_err) {
+    console.error('  better-sqlite3 not installed. Run: npm install better-sqlite3');
+    process.exit(1);
+  }
+
+  const db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+
+  // Prepare statements
+  const getHash = db.prepare('SELECT content_hash FROM file_hashes WHERE path = ?');
+  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 deleteFts = db.prepare('DELETE FROM mindlore_fts WHERE path = ?');
+  const insertFts = db.prepare('INSERT INTO mindlore_fts (path, content) VALUES (?, ?)');
+
+  // Get all .md files
+  const mdFiles = getAllMdFiles(baseDir);
+  let indexed = 0;
+  let skipped = 0;
+  let errors = 0;
+
+  const now = new Date().toISOString();
+
+  const transaction = db.transaction(() => {
+    for (const filePath of mdFiles) {
+      try {
+        const content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+        const hash = sha256(content);
+
+        // Check if content changed
+        const existing = getHash.get(filePath);
+        if (existing && existing.content_hash === hash) {
+          skipped++;
+          continue;
+        }
+
+        // Update FTS5
+        deleteFts.run(filePath);
+        insertFts.run(filePath, content);
+
+        // Update hash
+        upsertHash.run(filePath, hash, now);
+        indexed++;
+      } catch (err) {
+        console.error(`  Error indexing ${path.basename(filePath)}: ${err.message}`);
+        errors++;
+      }
+    }
+  });
+
+  transaction();
+
+  // Clean up entries for deleted files
+  const allIndexed = db.prepare('SELECT path FROM file_hashes').all();
+  const existingPaths = new Set(mdFiles);
+  let removed = 0;
+
+  const deleteHash = db.prepare('DELETE FROM file_hashes WHERE path = ?');
+  const cleanupTransaction = db.transaction(() => {
+    for (const row of allIndexed) {
+      if (!existingPaths.has(row.path)) {
+        deleteFts.run(row.path);
+        deleteHash.run(row.path);
+        removed++;
+      }
+    }
+  });
+
+  cleanupTransaction();
+  db.close();
+
+  console.log(
+    `\n  FTS5 Index: ${indexed} indexed, ${skipped} unchanged, ${removed} removed, ${errors} errors\n`
+  );
+
+  process.exit(errors > 0 ? 1 : 0);
+}
+
+main();

package/scripts/mindlore-fts5-search.cjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mindlore-fts5-search — Search .mindlore/ knowledge base via FTS5.
+ *
+ * Usage: node scripts/mindlore-fts5-search.cjs "query" [path-to-mindlore-dir]
+ *
+ * Returns top 3 results ranked by BM25 with file path and snippet.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { DB_NAME } = require('./lib/constants.cjs');
+const MAX_RESULTS = 3;
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+function extractHeadings(content, maxHeadings) {
+  const lines = content.split('\n');
+  const headings = [];
+  for (const line of lines) {
+    if (line.startsWith('#')) {
+      headings.push(line.replace(/^#+\s*/, '').trim());
+      if (headings.length >= maxHeadings) break;
+    }
+  }
+  return headings;
+}
+
+// ── Main ───────────────────────────────────────────────────────────────
+
+function main() {
+  const query = process.argv[2];
+  if (!query) {
+    console.error('Usage: node mindlore-fts5-search.cjs "query" [mindlore-dir]');
+    process.exit(1);
+  }
+
+  const baseDir = process.argv[3] || path.join(process.cwd(), '.mindlore');
+  const dbPath = path.join(baseDir, DB_NAME);
+
+  if (!fs.existsSync(dbPath)) {
+    console.error('  Database not found. Run: npx mindlore init && npm run index');
+    process.exit(1);
+  }
+
+  let Database;
+  try {
+    Database = require('better-sqlite3');
+  } catch (_err) {
+    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();
+    if (!sanitized) {
+      console.log('  No valid search terms.');
+      process.exit(0);
+    }
+
+    const results = db
+      .prepare(
+        `SELECT path, snippet(mindlore_fts, 1, '>>>', '<<<', '...', 40) as snippet,
+                rank
+         FROM mindlore_fts
+         WHERE mindlore_fts MATCH ?
+         ORDER BY rank
+         LIMIT ?`
+      )
+      .all(sanitized, MAX_RESULTS);
+
+    if (results.length === 0) {
+      console.log(`  No results for: "${query}"`);
+      process.exit(0);
+    }
+
+    console.log(`\n  Mindlore Search: "${query}" (${results.length} results)\n`);
+
+    for (let i = 0; i < results.length; i++) {
+      const r = results[i];
+      const relativePath = path.relative(baseDir, r.path);
+      const fileName = path.basename(r.path, '.md');
+
+      // Try to get headings from the actual file
+      let headings = [];
+      if (fs.existsSync(r.path)) {
+        const content = fs.readFileSync(r.path, 'utf8');
+        headings = extractHeadings(content, 2);
+      }
+
+      console.log(`  ${i + 1}. ${relativePath}`);
+      if (headings.length > 0) {
+        console.log(`     ${headings.join(' > ')}`);
+      }
+      console.log(`     ${r.snippet || fileName}`);
+      console.log('');
+    }
+  } catch (err) {
+    // FTS5 query syntax error — try simpler query
+    if (err.message.includes('fts5')) {
+      const words = query.split(/\s+/).filter((w) => w.length >= 2);
+      if (words.length > 0) {
+        console.error(`  Search syntax error. Try simpler terms: ${words.join(' ')}`);
+      } else {
+        console.error(`  Search error: ${err.message}`);
+      }
+    } else {
+      console.error(`  Error: ${err.message}`);
+    }
+    process.exit(1);
+  } finally {
+    db.close();
+  }
+}
+
+main();