wicked-brain 0.4.8 → 0.4.9

package/package.json

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

@@ -96,6 +96,7 @@ const actions = {
   backlinks: (p) => ({ links: db.backlinks(p.id) }),
   forward_links: (p) => ({ links: db.forwardLinks(p.id) }),
   stats: () => db.stats(),
+  memory_stats: () => db.memoryStats(),
   candidates: (p) => ({ candidates: db.candidates(p) }),
   symbols: async (p) => {
     // Prefer LSP workspace symbols (structured, language-aware)

package/server/lib/sqlite-search.mjs

@@ -421,7 +421,51 @@ export class SqliteSearch {
       // in-memory or inaccessible
     }
 
-    return { total, chunks, wiki, memory, last_indexed, db_size };
+    return {
+      total,
+      chunks,
+      wiki,
+      memory,
+      memory_breakdown: this.memoryStats(),
+      last_indexed,
+      db_size,
+    };
+  }
+
+  /**
+   * Breakdown of memory documents by type, tier, and age.
+   * Parses frontmatter from `memory/%` rows. Missing fields count as "unknown".
+   * Age buckets: <1d, 1-7d, 7-30d, 30-90d, >90d.
+   */
+  memoryStats() {
+    const rows = this.#db.prepare(`
+      SELECT frontmatter, indexed_at FROM documents WHERE path LIKE 'memory/%'
+    `).all();
+
+    const by_type = {};
+    const by_tier = {};
+    const by_age = { "<1d": 0, "1-7d": 0, "7-30d": 0, "30-90d": 0, ">90d": 0 };
+    const now = Date.now();
+    const DAY = 86400000;
+
+    for (const row of rows) {
+      const fm = row.frontmatter || "";
+      const typeMatch = fm.match(/^type:\s*(\S+)/m);
+      const tierMatch = fm.match(/^tier:\s*(\S+)/m);
+      const type = typeMatch ? typeMatch[1].replace(/["']/g, "") : "unknown";
+      const tier = tierMatch ? tierMatch[1].replace(/["']/g, "") : "unknown";
+      by_type[type] = (by_type[type] ?? 0) + 1;
+      by_tier[tier] = (by_tier[tier] ?? 0) + 1;
+
+      const age = now - (row.indexed_at ?? now);
+      if (age < DAY) by_age["<1d"]++;
+      else if (age < 7 * DAY) by_age["1-7d"]++;
+      else if (age < 30 * DAY) by_age["7-30d"]++;
+      else if (age < 90 * DAY) by_age["30-90d"]++;
+      else by_age[">90d"]++;
+    }
+
+    return { total: rows.length, by_type, by_tier, by_age };
   }
 
   health() {

package/server/package.json

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

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

@@ -0,0 +1,93 @@
+---
+name: wicked-brain:forget
+description: |
+  Archive or delete a memory (or any indexed document) by id or path.
+  Removes the document from the FTS index and renames the file with an
+  `.archived-{timestamp}` suffix so the data is recoverable.
+
+  Use when: "forget this memory", "archive this", "drop this decision",
+  "remove from brain", "brain forget".
+---
+
+# wicked-brain:forget
+
+Archive or hard-delete a memory by id or path. Wraps the server `remove` action
+and the archive-rename convention used by wicked-brain:agent dispatch consolidate.
+
+## Cross-Platform Notes
+
+- Uses `curl` for server API calls (Windows 10+, macOS, Linux)
+- Uses agent-native Read/Bash tools for file ops — no Unix-only shell features
+- Paths always use forward slashes
+
+## Config
+
+Read `_meta/config.json` for brain path and server port.
+If it doesn't exist, trigger wicked-brain:init.
+
+## Parameters
+
+- **id** (required if `path` not given): document id as returned by search
+- **path** (required if `id` not given): path relative to the brain root (e.g. `memory/jwt-decision.md`)
+- **mode** (optional, default `archive`): `archive` (rename file + remove from index, recoverable) or `delete` (rename + remove + final deletion is still left to the user — this skill never unlinks files)
+- **reason** (optional): short string recorded in the log for auditability
+
+This skill never hard-deletes a file. `delete` mode still renames with
+`.archived-{timestamp}` — actual `rm` is a human decision.
+
+## Process
+
+### Step 1: Resolve id and path
+
+If only `id` is given, find the path by calling search or reading the id (ids
+are of the form `{path}` or `{path}::{fragment}` in this brain). If only `path`
+is given, the id is normally the same string for top-level documents.
+
+### Step 2: Confirm the document exists
+
+Read the file at `{brain_path}/{path}` to verify it is present and (if it is a
+memory) inspect its frontmatter so the log entry can record type/tier.
+
+### Step 3: Remove from index
+
+```bash
+curl -s -X POST http://localhost:{port}/api \
+  -H "Content-Type: application/json" \
+  -d '{"action":"remove","params":{"id":"{id}"}}'
+```
+
+### Step 4: Archive the file
+
+Rename the file in-place with an `.archived-{unix-ms}` suffix.
+
+macOS / Linux:
+```bash
+mv "{brain_path}/{path}" "{brain_path}/{path}.archived-$(date +%s)"
+```
+
+Windows (PowerShell):
+```powershell
+Rename-Item "{brain_path}/{path}" "{path}.archived-$([DateTimeOffset]::UtcNow.ToUnixTimeSeconds())"
+```
+
+Prefer the agent-native Bash tool on the current platform; both forms produce a
+recoverable archive marker.
+
+### Step 5: Log the forget event
+
+Append to `{brain_path}/_meta/log.jsonl`:
+
+```json
+{"ts":"{ISO}","op":"memory_forget","path":"{path}","id":"{id}","mode":"{mode}","reason":"{reason}","author":"agent:forget"}
+```
+
+### Step 6: Report
+
+Report: path, id, previous frontmatter type/tier (if memory), archive filename,
+and whether index removal succeeded. Always surface the archive path so the
+user can restore it by renaming back.
+
+## Recovery
+
+To restore an archived memory, rename the `.archived-{ts}` file back to its
+original name. The file watcher will pick it up and re-index automatically.

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

@@ -0,0 +1,90 @@
+---
+name: wicked-brain:review
+description: |
+  Browse stored memories with filters on type, tier, and recency. Read-only —
+  use wicked-brain:forget to archive or wicked-brain:agent dispatch consolidate
+  to promote.
+
+  Use when: "review my memories", "browse decisions", "what have I stored",
+  "list recent gotchas", "brain review".
+---
+
+# wicked-brain:review
+
+Filtered browse over the memory store. Combines the server `memory_stats` and
+`recent_memories` actions with agent-side frontmatter filtering to render a
+compact, navigable list.
+
+## Cross-Platform Notes
+
+- Uses `curl` for server API calls (Windows 10+, macOS, Linux)
+- File reads use the agent-native Read tool
+- Paths always use forward slashes
+
+## Config
+
+Read `_meta/config.json` for brain path and server port.
+If it doesn't exist, trigger wicked-brain:init.
+
+## Parameters
+
+- **filter_type** (optional): `decision`, `pattern`, `preference`, `gotcha`, or `discovery`
+- **filter_tier** (optional): `working`, `episodic`, or `semantic`
+- **days** (optional, default 30): only include memories indexed within this many days
+- **limit** (optional, default 20): max results
+- **depth** (optional, default 0): 0=frontmatter only, 1=+summary line, 2=full content
+
+## Process
+
+### Step 1: Fetch breakdown
+
+Start with the aggregate view so the user can see the landscape before the list:
+
+```bash
+curl -s -X POST http://localhost:{port}/api \
+  -H "Content-Type: application/json" \
+  -d '{"action":"memory_stats"}'
+```
+
+Render `total`, `by_type`, `by_tier`, `by_age` as a one-line header.
+
+### Step 2: Fetch candidates
+
+```bash
+curl -s -X POST http://localhost:{port}/api \
+  -H "Content-Type: application/json" \
+  -d '{"action":"recent_memories","params":{"days":{days},"limit":{limit * 3}}}'
+```
+
+Over-fetch by 3x so agent-side type/tier filtering still returns a useful page.
+
+### Step 3: Filter
+
+For each returned memory, parse its frontmatter. Drop any memory whose `type`
+or `tier` does not match `filter_type` / `filter_tier` when those parameters
+are set. Stop once `limit` matches are collected.
+
+### Step 4: Render
+
+For each matching memory, render at the requested depth:
+
+- **Depth 0**: `{path} — type={type} tier={tier} importance={importance} age={age}`
+- **Depth 1**: depth 0 line + first 3 lines of content
+- **Depth 2**: depth 0 line + full content
+
+Age is derived from `indexed_at` relative to now (`Xd` / `Xh`).
+
+### Step 5: Suggest next actions
+
+After the list, suggest one of:
+- `wicked-brain:forget path=…` to archive a specific entry
+- `wicked-brain:agent dispatch consolidate` to promote patterns and drop expired entries
+- `wicked-brain:retag` if many entries have thin `contains:` arrays
+
+## Notes
+
+- Review is read-only. It never mutates the index or files.
+- For semantic search (content keywords) use `wicked-brain:search` or the
+  `recall` mode of `wicked-brain:memory` — review is for browsing by metadata.
+- If no filters are given and `days=30`, this is effectively "show me what I
+  have been remembering lately, grouped by type and tier".