wicked-brain 0.8.2 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-brain",
-  "version": "0.8.2",
+  "version": "0.9.1",
   "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

@@ -194,6 +194,7 @@ const actions = {
   link_health: () => db.linkHealth(),
   tag_frequency: () => ({ tags: db.tagFrequency() }),
   search_misses: (p) => ({ misses: db.searchMisses(p) }),
+  wiki_list: (p) => db.wikiList(p),
   // LSP actions
   "lsp-health": () => lsp.health(),
   "lsp-symbols": (p) => lsp.symbols(p),

package/server/lib/sqlite-search.mjs

@@ -12,6 +12,19 @@ function extractBodyExcerpt(content, maxLen = 300) {
   return body.trim().slice(0, maxLen);
 }
 
+/**
+ * Derives the source type from a document path.
+ * - Paths starting with "wiki/" → "wiki"
+ * - Paths starting with "memory/" or "memories/" → "memory"
+ * - Everything else → "chunk"
+ */
+export function deriveSourceType(path) {
+  const normalized = (path ?? "").replace(/\\/g, "/");
+  if (normalized.startsWith("wiki/")) return "wiki";
+  if (normalized.startsWith("memory/") || normalized.startsWith("memories/")) return "memory";
+  return "chunk";
+}
+
 function escapeFtsQuery(query) {
   return query
     .trim()
@@ -357,10 +370,11 @@ export class SqliteSearch {
 
     const rows = rawRows.slice(offset, offset + limit).map((row) => {
       const body_excerpt = extractBodyExcerpt(row.raw_content ?? "");
+      const source_type = deriveSourceType(row.path);
       delete row.raw_content;
       delete row.composite_score;
       delete row.boosted_score;
-      return { ...row, body_excerpt };
+      return { ...row, source_type, body_excerpt };
     });
 
     const countRow = this.#db
@@ -427,7 +441,7 @@ export class SqliteSearch {
               LIMIT ?
             `)
             .all(escaped, limit);
-          allResults.push(...rows);
+          allResults.push(...rows.map((r) => ({ ...r, source_type: deriveSourceType(r.path) })));
         } finally {
           this.#db.prepare(`DETACH DATABASE ${attached}`).run();
         }
@@ -872,6 +886,83 @@ export class SqliteSearch {
     return row || null;
   }
 
+  /**
+   * List wiki articles with metadata (no full content).
+   * Optional FTS5 keyword filter.
+   * @param {object} opts
+   * @param {string|null} [opts.query] - Optional FTS5 query to filter articles
+   * @param {number} [opts.limit=50]
+   * @returns {{ articles: Array<{ path: string, title: string|null, description: string|null, tags: string[], word_count: number }> }}
+   */
+  wikiList({ query = null, limit = 50 } = {}) {
+    let rows;
+
+    if (query) {
+      const escaped = escapeFtsQuery(query);
+      if (!escaped) return { articles: [] };
+
+      rows = this.#db.prepare(`
+        SELECT d.path, d.frontmatter, d.content
+        FROM documents_fts f
+        JOIN documents d ON d.id = f.id
+        WHERE documents_fts MATCH ?
+          AND d.path LIKE 'wiki/%'
+        ORDER BY rank
+        LIMIT ?
+      `).all(escaped, limit);
+    } else {
+      rows = this.#db.prepare(`
+        SELECT path, frontmatter, content
+        FROM documents
+        WHERE path LIKE 'wiki/%'
+        ORDER BY path
+        LIMIT ?
+      `).all(limit);
+    }
+
+    const articles = rows.map((row) => {
+      const fm = row.frontmatter || SqliteSearch.#extractFrontmatter(row.content) || "";
+      const title = this.#extractFrontmatterField(fm, "title") || null;
+      const description = this.#extractFrontmatterField(fm, "description") || null;
+      const tags = this.#parseTags(fm);
+      const word_count = (row.content || "").split(/\s+/).filter(Boolean).length;
+      return { path: row.path, title, description, tags, word_count };
+    });
+
+    return { articles };
+  }
+
+  /**
+   * Parse tags from frontmatter string.
+   * Supports space-separated inline, JSON array, and YAML block list formats.
+   */
+  #parseTags(fm) {
+    if (!fm) return [];
+
+    // Inline: tags: tag1 tag2 tag3  or  tags: ["tag1","tag2"]
+    const inlineMatch = fm.match(/^tags:[ \t]+(\S.*)$/m);
+    if (inlineMatch) {
+      const raw = inlineMatch[1].trim();
+      if (raw.startsWith("[")) {
+        try {
+          return JSON.parse(raw).map(String);
+        } catch {
+          return raw.replace(/[\[\]"]/g, "").split(/[\s,]+/).filter(Boolean);
+        }
+      }
+      return raw.split(/\s+/).filter(Boolean);
+    }
+
+    // YAML block list
+    const blockMatch = fm.match(/^tags:\s*\n((?:\s+-\s+.+\n?)+)/m);
+    if (blockMatch) {
+      const listLines = blockMatch[1].match(/^\s+-\s+(.+)$/gm) || [];
+      return listLines.map((line) => line.replace(/^\s+-\s+/, "").trim()).filter(Boolean);
+    }
+
+    return [];
+  }
+
   close() {
     this.#db.close();
   }

package/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-brain-server",
-  "version": "0.8.2",
+  "version": "0.9.1",
   "type": "module",
   "description": "SQLite FTS5 search server for wicked-brain digital knowledge bases",
   "keywords": [

package/skills/wicked-brain-configure/SKILL.md

@@ -88,11 +88,20 @@ Digital brain: {brain_id} | {total} indexed items | {chunks} chunks, {wiki} wiki
 
 - **Search/explore**: use `wicked-brain:search` — replaces Grep, Glob, and Agent(Explore) for any open-ended search
 - **Answer questions**: use `wicked-brain:query` — replaces Agent(Explore) for conceptual questions
+- **Wiki catalog**: use `wicked-brain:read` at depth 0/1 to browse wiki articles progressively
 - **Surface context**: call `wicked-brain:agent` (context) at the start of any new topic
 - **Capture learnings**: call `wicked-brain:agent` (session-teardown) at session end
 - **Store a decision/pattern/gotcha**: call `wicked-brain:memory` (store mode)
 - **Available agents**: consolidate, context, session-teardown, onboard (via `wicked-brain:agent`)
 
+### Search result source types
+
+Brain search/query results include `source_type` and `path` fields:
+
+- **`wiki`** — Synthesized knowledge. Read deeper with `wicked-brain:read {path} depth=2`.
+- **`chunk`** — Raw indexed content. The search excerpt is usually sufficient.
+- **`memory`** — Experiential learnings. Compact; excerpt is usually enough.
+
 ### Rules (follow strictly)
 
 - **ALWAYS check the brain BEFORE using Grep, Glob, Read, or Agent(Explore)** — for any find, search, explore, explain, or "what is/how does" request
@@ -103,6 +112,7 @@ Digital brain: {brain_id} | {total} indexed items | {chunks} chunks, {wiki} wiki
 - Do NOT read brain files directly — always go through skills and agents
 - Always pass `session_id` with search/query calls for access tracking
 - Capture non-obvious decisions, patterns, and gotchas with `wicked-brain:memory`
+- When search results include `source_type: wiki`, follow up with `wicked-brain:read` at depth 1-2
 ```
 
 ### Step 4: Emit bus event