@polderlabs/bizar 6.2.4 → 6.3.0

package/{plugins/bizar/src/memory-vault.ts → packages/sdk/src/memory/index.ts}

@@ -1,27 +1,26 @@
 /**
- * memory-vault.ts
+ * Bizar Memory Vault — Claude Code-native re-export of the
+ * Obsidian-compatible memory vault. This is the same implementation that
+ * previously lived at plugins/bizar/src/memory-vault.ts; it's framework-
+ * agnostic so we lifted it into the SDK so that:
  *
- * v6.0.0 — In-process Bizar Memory vault reader/writer. The plugin can
- * read and write memory notes directly from disk, without going through
- * the dashboard's HTTP API.
+ *  - The Claude Code MCP server (packages/sdk/src/mcp/server.ts) reads
+ *    and writes memory in-process.
+ *  - The bizar-dash dashboard imports the same code so the on-disk vault
+ *    stays the single source of truth.
  *
  * Vault location: $BIZAR_MEMORY_VAULT or ~/.bizar_memory/ (default).
  * Legacy: ~/.local/share/bizar/memory/ (still readable if it exists).
- *
- * Note format: Obsidian-compatible markdown with YAML frontmatter.
- *
- *   ---
- *   key: value
- *   ---
- *   # Body
- *
- * This is a focused subset of the dashboard's full MarkdownMemoryStore
- * (which includes git, schema validation, secrets scanning, semantic
- * search via lightrag). The plugin needs read/write/list/search; for
- * the heavier features, the dashboard is the source of truth.
  */
 
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
 import { join, relative, sep } from "node:path";
 import { homedir } from "node:os";
 
@@ -60,7 +59,6 @@ export function parseFrontmatter(raw: string): { frontmatter: Record<string, unk
     let value: string | string[] = m[2] as string;
     value = value.trim();
     if (value.startsWith("[") && value.endsWith("]")) {
-      // YAML flow sequence: [a, b, c]
       value = value.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
     } else if (value === "true") value = "true";
     else if (value === "false") value = "false";
@@ -82,7 +80,6 @@ export function serializeFrontmatter(frontmatter: Record<string, unknown>, body:
 
 /** Read a single note. Returns null if not found. */
 export function readNote(vaultRoot: string, relPath: string): MemoryNote | null {
-  // Path safety: reject .. and absolute
   const safe = relPath.replace(/\\/g, "/").replace(/^\/+/, "");
   if (safe.includes("..") || safe.startsWith(".")) return null;
   const fp = join(vaultRoot, safe);
@@ -113,7 +110,7 @@ export function writeNote(
 }
 
 /** List notes matching a prefix. */
-export function listNotes(vaultRoot: string, prefix: string = "", limit: number = 100): MemoryNote[] {
+export function listNotes(vaultRoot: string, prefix = "", limit = 100): MemoryNote[] {
   if (!existsSync(vaultRoot)) return [];
   const out: MemoryNote[] = [];
   walk(vaultRoot, vaultRoot, out, limit, prefix);
@@ -141,7 +138,7 @@ function walk(root: string, dir: string, out: MemoryNote[], limit: number, prefi
 }
 
 /** Full-text search over note bodies + frontmatter. */
-export function searchNotes(vaultRoot: string, query: string, limit: number = 20): MemoryNote[] {
+export function searchNotes(vaultRoot: string, query: string, limit = 20): MemoryNote[] {
   const q = query.toLowerCase();
   const notes = listNotes(vaultRoot, "", 1000);
   const out: { note: MemoryNote; score: number }[] = [];

package/packages/sdk/tests/sdk.test.mjs

@@ -0,0 +1,148 @@
+/**
+ * SDK smoke tests — exercise the public surface.
+ *
+ * Run via:  npm run test:sdk
+ *          (or: node --test packages/sdk/tests/sdk.test.mjs)
+ *
+ * Uses vitest. The suite covers:
+ *   - dist artefacts present after build:sdk
+ *   - package.json exports map
+ *   - SDK module surfaces (memory, fingerprint, dangerous-patterns, mcp)
+ *   - dangerous-pattern behaviour (rm -rf / denied)
+ *   - fingerprint stability
+ *   - frontmatter round-trip
+ */
+
+import { describe, test, expect } from "vitest";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = fileURLToPath(new URL(".", import.meta.url));
+const distDir = join(here, "..", "dist");
+const pkgPath = join(here, "..", "package.json");
+
+describe("SDK build", () => {
+  test("all dist artefacts present", () => {
+    for (const f of [
+      "index.js", "index.d.ts",
+      "dangerous-patterns.js", "dangerous-patterns.d.ts",
+      "fingerprint.js", "fingerprint.d.ts",
+      "memory/index.js", "memory/index.d.ts",
+      "mcp/server.js", "mcp/server.d.ts",
+      "mcp/bin.js", "mcp/bin.d.ts",
+    ]) {
+      expect(existsSync(join(distDir, f))).toBe(true);
+    }
+  });
+
+  test("package.json exports map declares memory, mcp, dangerous-patterns", async () => {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    expect(pkg.name).toBe("@polderlabs/bizar-sdk");
+    expect(pkg.exports["."]).toBeTruthy();
+    expect(pkg.exports["./memory"]).toBeTruthy();
+    expect(pkg.exports["./mcp"]).toBeTruthy();
+    expect(pkg.exports["./dangerous-patterns"]).toBeTruthy();
+  });
+});
+
+describe("SDK module surface", () => {
+  test("dangerous-patterns module exports the expected API", async () => {
+    const mod = await import("../dist/dangerous-patterns.js");
+    expect(typeof mod.checkDangerous).toBe("function");
+    expect(typeof mod.listDangerousPatterns).toBe("function");
+    expect(typeof mod.getDangerousPatternStats).toBe("function");
+  });
+
+  test("fingerprint module exports a function", async () => {
+    const mod = await import("../dist/fingerprint.js");
+    expect(typeof mod.fingerprint).toBe("function");
+  });
+
+  test("memory module exports vault helpers", async () => {
+    const mod = await import("../dist/memory/index.js");
+    expect(typeof mod.readNote).toBe("function");
+    expect(typeof mod.writeNote).toBe("function");
+    expect(typeof mod.listNotes).toBe("function");
+    expect(typeof mod.searchNotes).toBe("function");
+    expect(typeof mod.parseFrontmatter).toBe("function");
+    expect(typeof mod.serializeFrontmatter).toBe("function");
+    expect(typeof mod.resolveVaultRoot).toBe("function");
+    expect(typeof mod.DEFAULT_MEMORY_VAULT).toBe("string");
+  });
+
+  test("MCP server module exposes ≥13 BIZAR_TOOLS", async () => {
+    const mod = await import("../dist/mcp/server.js");
+    expect(Array.isArray(mod.BIZAR_TOOLS)).toBe(true);
+    expect(mod.BIZAR_TOOLS.length).toBeGreaterThanOrEqual(13);
+    expect(typeof mod.createBizarMcpServer).toBe("function");
+    expect(typeof mod.createBizarMcpServerConfig).toBe("function");
+    expect(typeof mod.defineTool).toBe("function");
+    expect(typeof mod.getBizarMcpToolSummary).toBe("function");
+
+    const expectedNames = new Set([
+      "memory_read", "memory_write", "memory_list", "memory_search",
+      "plan_action", "open_kb",
+      "loop_list", "loop_status", "loop_start", "loop_stop",
+      "graph_query", "graph_path", "danger_check",
+    ]);
+    const have = new Set(mod.BIZAR_TOOLS.map((t) => t.name));
+    for (const n of expectedNames) {
+      expect(have.has(n)).toBe(true);
+    }
+  });
+});
+
+describe("dangerous-patterns behaviour", () => {
+  test("denies rm -rf /", async () => {
+    const { checkDangerous } = await import("../dist/dangerous-patterns.js");
+    const result = checkDangerous("rm -rf /");
+    expect(result.decision).toBe("deny");
+    expect(typeof result.reason).toBe("string");
+    expect(result.reason.length).toBeGreaterThan(0);
+  });
+
+  test("allows echo", async () => {
+    const { checkDangerous } = await import("../dist/dangerous-patterns.js");
+    const result = checkDangerous("echo hello world");
+    expect(result.decision).toBe("allow");
+  });
+});
+
+describe("fingerprint stability", () => {
+  test("same input produces same fingerprint", async () => {
+    const { fingerprint } = await import("../dist/fingerprint.js");
+    const a = fingerprint("Bash", { command: "ls -la /tmp" });
+    const b = fingerprint("Bash", { command: "ls -la /tmp" });
+    expect(a).toBe(b);
+    expect(typeof a).toBe("string");
+    expect(a.length).toBeGreaterThanOrEqual(16);
+  });
+
+  test("different tools produce different fingerprints", async () => {
+    const { fingerprint } = await import("../dist/fingerprint.js");
+    const a = fingerprint("Bash", { command: "ls" });
+    const b = fingerprint("Edit", { command: "ls" });
+    expect(a).not.toBe(b);
+  });
+});
+
+describe("frontmatter round-trip", () => {
+  test("parses simple values", async () => {
+    const { parseFrontmatter } = await import("../dist/memory/index.js");
+    const md = "---\ntitle: Test\ncount: 3\n---\nHello world";
+    const parsed = parseFrontmatter(md);
+    expect(parsed.frontmatter.title).toBe("Test");
+    expect(parsed.frontmatter.count).toBe("3");
+    expect(parsed.body.trim()).toBe("Hello world");
+  });
+
+  test("serialize + parse preserves array form", async () => {
+    const { parseFrontmatter, serializeFrontmatter } = await import("../dist/memory/index.js");
+    const md = serializeFrontmatter({ title: "Test", tags: ["a", "b"] }, "\nbody");
+    expect(md.startsWith("---")).toBe(true);
+    const parsed = parseFrontmatter(md);
+    expect(parsed.frontmatter.title).toBe("Test");
+    expect(md.includes("tags: [a, b]")).toBe(true);
+  });
+});

package/packages/sdk/vitest.config.ts

@@ -2,7 +2,7 @@ import { defineConfig } from "vitest/config";
 
 export default defineConfig({
   test: {
-    include: ["tests/**/*.test.ts"],
+    include: ["tests/**/*.test.ts", "tests/**/*.test.mjs"],
     environment: "node",
     globals: false,
   },