wicked-brain 0.1.2 → 0.3.2

package/install.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// wicked-brain installer — detects CLIs and installs skills
+// wicked-brain installer — detects CLIs and installs skills + agents
 
 import { existsSync, mkdirSync, cpSync, readdirSync } from "node:fs";
 import { join, resolve } from "node:path";
@@ -12,11 +12,13 @@ const skillsSource = join(__dirname, "skills");
 const home = homedir();
 
 const CLI_TARGETS = [
-  { name: "claude", dir: join(home, ".claude", "skills") },
-  { name: "gemini", dir: join(home, ".gemini", "skills") },
-  { name: "copilot", dir: join(home, ".github", "skills") },
-  { name: "codex", dir: join(home, ".codex", "skills") },
-  { name: "cursor", dir: join(home, ".cursor", "skills") },
+  { name: "claude", dir: join(home, ".claude", "skills"), agentDir: join(home, ".claude", "agents"), platform: "claude" },
+  { name: "gemini", dir: join(home, ".gemini", "skills"), agentDir: join(home, ".gemini", "agents"), platform: "gemini" },
+  { name: "copilot", dir: join(home, ".github", "skills"), agentDir: join(home, ".github", "agents"), platform: "copilot" },
+  { name: "codex", dir: join(home, ".codex", "skills"), agentDir: join(home, ".codex", "agents"), platform: "codex" },
+  { name: "cursor", dir: join(home, ".cursor", "skills"), agentDir: join(home, ".cursor", "agents"), platform: "cursor" },
+  { name: "kiro", dir: join(home, ".kiro", "skills"), agentDir: join(home, ".kiro", "agents"), platform: "kiro" },
+  { name: "antigravity", dir: join(home, ".antigravity", "skills"), agentDir: join(home, ".antigravity", "rules"), platform: "antigravity" },
 ];
 
 // Detect which CLIs are installed by checking if parent dir exists
@@ -28,7 +30,7 @@ const detected = CLI_TARGETS.filter((t) => {
 console.log("wicked-brain installer\n");
 
 if (detected.length === 0) {
-  console.log("No supported AI CLIs detected. Supported: claude, gemini, copilot, codex, cursor");
+  console.log("No supported AI CLIs detected. Supported: claude, gemini, copilot, codex, cursor, kiro, antigravity");
   console.log("Install skills manually by copying the skills/ directory.");
   process.exit(1);
 }
@@ -36,7 +38,8 @@ if (detected.length === 0) {
 console.log(`Detected CLIs: ${detected.map((d) => d.name).join(", ")}\n`);
 
 // Allow filtering via --cli flag
-const cliArg = argv.find((a) => a.startsWith("--cli="));
+const args = argv.slice(2);
+const cliArg = args.find((a) => a.startsWith("--cli="));
 const cliFilter = cliArg ? cliArg.split("=")[1].split(",") : null;
 const targets = cliFilter
   ? detected.filter((d) => cliFilter.includes(d.name))
@@ -58,6 +61,52 @@ for (const target of targets) {
   console.log(`  ${skillDirs.length} skills installed`);
 }
 
+// Copy platform-specific agents
+const agentsSource = join(__dirname, "skills", "wicked-brain-agent", "platform");
+
+for (const target of targets) {
+  const platformDir = join(agentsSource, target.platform);
+  if (!existsSync(platformDir)) {
+    console.log(`  No agent definitions for ${target.name}, skipping agents`);
+    continue;
+  }
+
+  if (!target.agentDir) continue;
+
+  mkdirSync(target.agentDir, { recursive: true });
+  const agentFiles = readdirSync(platformDir);
+  let agentCount = 0;
+
+  for (const file of agentFiles) {
+    const src = join(platformDir, file);
+    const dest = join(target.agentDir, file);
+    cpSync(src, dest, { force: true });
+    agentCount++;
+  }
+
+  console.log(`  Installed ${agentCount} agents to ${target.agentDir}`);
+}
+
+// Optional hook installation (--hooks flag)
+const installHooks = args.includes("--hooks");
+
+if (installHooks) {
+  console.log("\nInstalling hooks...");
+  const hooksSource = join(__dirname, "skills", "wicked-brain-agent", "hooks");
+
+  for (const target of targets) {
+    const hookFile = join(hooksSource, `${target.platform}-hooks.json`);
+    if (!existsSync(hookFile)) {
+      console.log(`  No hook template for ${target.name}, skipping`);
+      continue;
+    }
+    // Note: hook installation is platform-specific and may need merging
+    // with existing hooks. For now, just report what would be installed.
+    console.log(`  Hook template available for ${target.name}: ${hookFile}`);
+    console.log(`  To install: merge into your ${target.name} hook config manually`);
+  }
+}
+
 // Server binary is bundled — npx wicked-brain-server works automatically
 // Skills reference it as: npx wicked-brain-server --brain {path} --port {port}
 console.log("\nServer: bundled (use 'npx wicked-brain-server' to start)");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-brain",
-  "version": "0.1.2",
+  "version": "0.3.2",
   "type": "module",
   "description": "Digital brain as skills for AI coding CLIs — no vector DB, no embeddings, no infrastructure",
   "keywords": [

package/server/bin/wicked-brain-server.mjs

@@ -5,6 +5,7 @@ import { join, resolve } from "node:path";
 import { argv, pid, exit } from "node:process";
 import { FileWatcher } from "../lib/file-watcher.mjs";
 import { SqliteSearch } from "../lib/sqlite-search.mjs";
+import { LspClient } from "../lib/lsp-client.mjs";
 
 // Parse args
 const args = argv.slice(2);
@@ -26,25 +27,32 @@ try {
   console.error(`Warning: Could not read brain.json at ${configPath}`);
 }
 
+// Ensure required directories exist
+mkdirSync(join(brainPath, "_meta"), { recursive: true });
+mkdirSync(join(brainPath, "memory"), { recursive: true });
+
 // Initialize SQLite
 const dbPath = join(brainPath, ".brain.db");
-mkdirSync(join(brainPath, "_meta"), { recursive: true });
 const db = new SqliteSearch(dbPath, brainId);
 
 // PID file
 const pidPath = join(brainPath, "_meta", "server.pid");
 writeFileSync(pidPath, String(pid));
 
+// LSP client
+const lsp = new LspClient(brainPath, db);
+
 // Graceful shutdown
-function shutdown() {
+async function shutdown() {
   console.log("Shutting down...");
   try { unlinkSync(pidPath); } catch {}
   watcher.stop();
+  await lsp.shutdown();
   db.close();
   exit(0);
 }
-process.on("SIGTERM", shutdown);
-process.on("SIGINT", shutdown);
+process.on("SIGTERM", () => shutdown());
+process.on("SIGINT", () => shutdown());
 
 // Action dispatch
 const actions = {
@@ -57,6 +65,21 @@ const actions = {
   backlinks: (p) => ({ links: db.backlinks(p.id) }),
   forward_links: (p) => ({ links: db.forwardLinks(p.id) }),
   stats: () => db.stats(),
+  candidates: (p) => ({ candidates: db.candidates(p) }),
+  access_log: (p) => db.accessLog(p.id),
+  recent_memories: (p) => ({ memories: db.recentMemories(p) }),
+  contradictions: () => ({ links: db.contradictions() }),
+  // LSP actions
+  "lsp-health": () => lsp.health(),
+  "lsp-symbols": (p) => lsp.symbols(p),
+  "lsp-definition": (p) => lsp.definition(p),
+  "lsp-references": (p) => lsp.references(p),
+  "lsp-hover": (p) => lsp.hover(p),
+  "lsp-implementation": (p) => lsp.implementation(p),
+  "lsp-workspace-symbols": (p) => lsp.workspaceSymbols(p),
+  "lsp-call-hierarchy-in": (p) => lsp.callHierarchyIn(p),
+  "lsp-call-hierarchy-out": (p) => lsp.callHierarchyOut(p),
+  "lsp-diagnostics": (p) => lsp.diagnostics(p),
 };
 
 // HTTP server
@@ -77,9 +100,21 @@ const server = createServer((req, res) => {
         res.end(JSON.stringify({ error: `Unknown action: ${action}` }));
         return;
       }
+      // Handle both sync and async results
       const result = handler(params);
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify(result ?? { ok: true }));
+      Promise.resolve(result)
+        .then(r => {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(r ?? { ok: true }));
+        })
+        .catch(err => {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: err.message,
+            language: err.language,
+            install: err.install,
+          }));
+        });
     } catch (err) {
       res.writeHead(500, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: err.message }));
@@ -87,7 +122,19 @@ const server = createServer((req, res) => {
   });
 });
 
-const watcher = new FileWatcher(brainPath, db, brainId);
+// Read project directories from config
+let projects = [];
+try {
+  const metaConfig = JSON.parse(readFileSync(join(brainPath, "_meta", "config.json"), "utf-8"));
+  projects = metaConfig.projects || [];
+} catch {}
+
+const watcher = new FileWatcher(brainPath, db, brainId, projects);
+
+// Wire file changes to LSP client for didOpen/didChange/didClose
+watcher.onFileChange((relPath, absPath, content, eventType) => {
+  lsp.handleFileChange(relPath, absPath, content, eventType);
+});
 
 server.listen(port, () => {
   console.log(`wicked-brain-server running on port ${port} (brain: ${brainId}, pid: ${pid})`);

package/server/lib/file-watcher.mjs

@@ -1,4 +1,4 @@
-import { watch, readFileSync, existsSync, readdirSync } from "node:fs";
+import { watch, readFileSync, existsSync, readdirSync, statSync } from "node:fs";
 import { join, relative } from "node:path";
 import { createHash } from "node:crypto";
 
@@ -6,6 +6,13 @@ function normalizePath(p) {
   return p.replace(/\\/g, "/");
 }
 
+const IGNORE_DIRS = new Set([
+  "node_modules", ".git", "__pycache__", ".venv", "venv",
+  "target", "dist", "build", ".next", ".nuxt", "coverage",
+  ".idea", ".vscode", ".vs", "bin", "obj", ".cache",
+  ".gradle", ".mvn", ".terraform"
+]);
+
 export class FileWatcher {
   #brainPath;
   #db;
@@ -14,20 +21,28 @@ export class FileWatcher {
   #watchers = [];
   #debounceTimers = new Map();
   #pollInterval = null;
+  #onChangeCallbacks = [];
+  #projects = [];
 
-  constructor(brainPath, db, brainId) {
+  constructor(brainPath, db, brainId, projects = []) {
     this.#brainPath = brainPath;
     this.#db = db;
     this.#brainId = brainId;
+    this.#projects = projects;
+  }
+
+  onFileChange(callback) {
+    this.#onChangeCallbacks.push(callback);
   }
 
   start() {
     // Build initial hash map
     this.#scanAndHash("chunks");
     this.#scanAndHash("wiki");
+    this.#scanAndHash("memory");
 
     // Watch directories
-    for (const dir of ["chunks", "wiki"]) {
+    for (const dir of ["chunks", "wiki", "memory"]) {
       const absDir = join(this.#brainPath, dir);
       if (!existsSync(absDir)) continue;
 
@@ -43,11 +58,29 @@ export class FileWatcher {
       }
     }
 
+    // Watch registered project directories
+    for (const project of this.#projects) {
+      if (!existsSync(project.path)) continue;
+      this.#scanAndHashProject(project);
+      try {
+        const watcher = watch(project.path, { recursive: true }, (eventType, filename) => {
+          if (!filename) return;
+          const parts = filename.split(/[/\\]/);
+          if (parts.some(p => IGNORE_DIRS.has(p))) return;
+          const relPath = normalizePath(`projects/${project.name}/${filename}`);
+          this.#debounce(relPath, () => this.#handleProjectChange(project, filename));
+        });
+        this.#watchers.push(watcher);
+      } catch {
+        // recursive watch not supported — polling fallback already handles this
+      }
+    }
+
     // If no watchers were set up (Linux), use polling fallback
     if (this.#watchers.length === 0) {
       this.#startPolling();
     } else {
-      console.log(`File watcher active on chunks/ and wiki/`);
+      console.log(`File watcher active on chunks/, wiki/, and memory/`);
     }
   }
 
@@ -72,10 +105,39 @@ export class FileWatcher {
     });
   }
 
+  #scanAndHashProject(project) {
+    let indexed = 0;
+    this.#walkDir(project.path, (absPath) => {
+      if (!this.#isCodeFile(absPath)) return;
+      try {
+        const stat = statSync(absPath);
+        if (stat.size > FileWatcher.#MAX_FILE_SIZE) return;
+      } catch { return; }
+      const relPath = normalizePath(`projects/${project.name}/${relative(project.path, absPath)}`);
+      try {
+        const content = readFileSync(absPath, "utf-8");
+        const hash = this.#hash(content);
+        this.#hashes.set(relPath, hash);
+        // Index project files on first scan (brain dirs are pre-indexed, project dirs are not)
+        this.#db.index({
+          id: relPath,
+          path: relPath,
+          content,
+          brain_id: this.#brainId,
+        });
+        indexed++;
+      } catch { /* binary or unreadable — skip */ }
+    });
+    console.log(`[watcher] Scanned project ${project.name}: ${indexed} files indexed`);
+  }
+
   #walkDir(dir, callback) {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const full = join(dir, entry.name);
-      if (entry.isDirectory()) this.#walkDir(full, callback);
+      if (entry.isDirectory()) {
+        if (IGNORE_DIRS.has(entry.name)) continue;
+        this.#walkDir(full, callback);
+      }
       else if (entry.isFile()) callback(full);
     }
   }
@@ -89,6 +151,9 @@ export class FileWatcher {
         this.#hashes.delete(relPath);
         this.#db.remove(relPath);
         console.log(`[watcher] Removed from index: ${relPath}`);
+        for (const cb of this.#onChangeCallbacks) {
+          try { cb(relPath, absPath, null, "delete"); } catch {}
+        }
       }
       return;
     }
@@ -108,15 +173,96 @@ export class FileWatcher {
         brain_id: this.#brainId,
       });
       console.log(`[watcher] Reindexed: ${relPath}`);
+      for (const cb of this.#onChangeCallbacks) {
+        try { cb(relPath, absPath, content, "change"); } catch {}
+      }
     } catch {
       // File might be mid-write, ignore
     }
   }
 
+  #handleProjectChange(project, filename) {
+    const absPath = join(project.path, filename);
+    const relPath = normalizePath(`projects/${project.name}/${filename}`);
+
+    if (!existsSync(absPath)) {
+      if (this.#hashes.has(relPath)) {
+        this.#hashes.delete(relPath);
+        this.#db.remove(relPath);
+        console.log(`[watcher] Removed from index: ${relPath}`);
+        for (const cb of this.#onChangeCallbacks) {
+          try { cb(relPath, absPath, null, "delete"); } catch {}
+        }
+      }
+      return;
+    }
+
+    if (!this.#isCodeFile(absPath)) return;
+    try {
+      const stat = statSync(absPath);
+      if (stat.size > FileWatcher.#MAX_FILE_SIZE) return;
+    } catch { return; }
+
+    try {
+      const content = readFileSync(absPath, "utf-8");
+      const newHash = this.#hash(content);
+      const oldHash = this.#hashes.get(relPath);
+      if (newHash === oldHash) return;
+
+      this.#hashes.set(relPath, newHash);
+      this.#db.index({
+        id: relPath,
+        path: relPath,
+        content,
+        brain_id: this.#brainId,
+      });
+      console.log(`[watcher] Reindexed: ${relPath}`);
+      for (const cb of this.#onChangeCallbacks) {
+        try { cb(relPath, absPath, content, "change"); } catch {}
+      }
+    } catch {}
+  }
+
+  /** Max file size to index (1MB). Skips binaries and large generated files. */
+  static #MAX_FILE_SIZE = 1048576;
+
+  /** Text file extensions safe to read and index. */
+  static #CODE_EXTENSIONS = new Set([
+    // Web
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".mts", ".cjs",
+    ".html", ".htm", ".css", ".scss", ".less", ".sass",
+    ".vue", ".svelte", ".astro",
+    // Backend
+    ".py", ".go", ".rs", ".java", ".cs", ".rb", ".php",
+    ".kt", ".kts", ".scala", ".sc", ".ex", ".exs", ".erl",
+    // Systems
+    ".c", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".zig", ".nim", ".d",
+    ".hs", ".lhs", ".ml", ".mli",
+    // Scripting
+    ".lua", ".pl", ".pm", ".r", ".R", ".jl", ".sh", ".bash", ".zsh",
+    // Data / Config
+    ".sql", ".graphql", ".gql", ".tf", ".yaml", ".yml",
+    ".toml", ".json", ".jsonc", ".xml", ".csv",
+    // Mobile
+    ".swift", ".dart",
+    // Other
+    ".clj", ".cljs", ".cljc", ".edn", ".fs", ".fsx", ".fsi",
+    ".gleam", ".sol", ".prisma", ".proto",
+    // Docs
+    ".md", ".markdown", ".tex", ".txt", ".rst",
+  ]);
+
+  #isCodeFile(absPath) {
+    const dot = absPath.lastIndexOf(".");
+    if (dot === -1) return false;
+    const ext = absPath.slice(dot).toLowerCase();
+    return FileWatcher.#CODE_EXTENSIONS.has(ext);
+  }
+
   #startPolling() {
     console.log("File watcher using polling mode (recursive watch not available)");
     this.#pollInterval = setInterval(() => {
-      for (const dir of ["chunks", "wiki"]) {
+      for (const dir of ["chunks", "wiki", "memory"]) {
         const absDir = join(this.#brainPath, dir);
         if (!existsSync(absDir)) continue;
         this.#walkDir(absDir, (absPath) => {