@polderlabs/bizar 6.2.4 → 6.3.0

package/plugins/bizar/src/tools/graph-query.ts

@@ -1,278 +0,0 @@
-/**
- * graph-query.ts — v6.0.0 knowledge graph query tool.
- *
- * Exposes `.bizar/graph/graph.json` (the project knowledge graph built
- * by `graphify`) to agents as a queryable tool surface.
- *
- * Patterns from:
- *   - Hermes Agent `tools/graph_query.py`
- *   - OpenFang `crates/openfang-runtime/src/tool_runner.rs:2105-2140`
- *     (the `tool_knowledge_query` reference)
- *
- * Three queries:
- *   - `bizar_graph_query`  — search for a node by label or substring
- *   - `bizar_graph_path`   — shortest path between two nodes
- *   - `bizar_graph_explain` — natural-language summary of a node
- *
- * The graph lives at `<worktree>/.bizar/graph/graph.json`. If the file
- * doesn't exist, the tool returns an empty result (graceful fallback).
- */
-
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { createTool, type AgentTool } from "@cline/sdk";
-import { z } from "zod";
-
-import type { Logger } from "../logger.js";
-
-export const BIZAR_GRAPH_QUERY_TOOL_NAME = "bizar_graph_query";
-export const BIZAR_GRAPH_PATH_TOOL_NAME = "bizar_graph_path";
-export const BIZAR_GRAPH_EXPLAIN_TOOL_NAME = "bizar_graph_explain";
-
-export interface GraphQueryDeps {
-  worktree: string;
-  logger: Logger;
-}
-
-interface GraphNode {
-  id: string;
-  label?: string;
-  file_type?: string;
-  source_file?: string;
-  source_location?: string;
-  [k: string]: unknown;
-}
-
-interface GraphEdge {
-  source: string;
-  target: string;
-  relation?: string;
-  [k: string]: unknown;
-}
-
-interface GraphData {
-  directed?: boolean;
-  multigraph?: boolean;
-  graph?: Record<string, unknown>;
-  nodes?: GraphNode[];
-  edges?: GraphEdge[];
-}
-
-const MAX_NODES = 50;
-const MAX_NEIGHBORS = 20;
-
-function loadGraph(worktree: string): GraphData | null {
-  const path = join(worktree, ".bizar", "graph", "graph.json");
-  if (!existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf8")) as GraphData;
-  } catch {
-    return null;
-  }
-}
-
-/** Case-insensitive substring match against node id + label. */
-function nodeMatches(node: GraphNode, query: string): boolean {
-  const q = query.toLowerCase();
-  if (node.id.toLowerCase().includes(q)) return true;
-  if (node.label && node.label.toLowerCase().includes(q)) return true;
-  if (node.source_file && node.source_file.toLowerCase().includes(q)) return true;
-  return false;
-}
-
-/** BFS to find the shortest path from source to target (undirected). */
-function bfsPath(graph: GraphData, from: string, to: string): string[] | null {
-  if (from === to) return [from];
-  const adjacency = new Map<string, Set<string>>();
-  for (const n of graph.nodes ?? []) {
-    if (!adjacency.has(n.id)) adjacency.set(n.id, new Set());
-  }
-  for (const e of graph.edges ?? []) {
-    adjacency.get(e.source)?.add(e.target);
-    if (!graph.directed) adjacency.get(e.target)?.add(e.source);
-  }
-  const visited = new Set<string>([from]);
-  const queue: Array<{ node: string; path: string[] }> = [{ node: from, path: [from] }];
-  while (queue.length > 0) {
-    const { node, path } = queue.shift()!;
-    const neighbors = adjacency.get(node) ?? new Set();
-    for (const nb of neighbors) {
-      if (nb === to) return [...path, nb];
-      if (!visited.has(nb)) {
-        visited.add(nb);
-        queue.push({ node: nb, path: [...path, nb] });
-      }
-    }
-  }
-  return null;
-}
-
-// ── query ────────────────────────────────────────────────────────────────
-export type BizarGraphQueryInput = z.infer<typeof bizarGraphQuerySchema>;
-export type BizarGraphQueryOutput =
-  | { ok: true; count: number; nodes: GraphNode[]; totalNodes: number }
-  | { ok: false; error: string; message: string };
-
-const bizarGraphQuerySchema = z.object({
-  query: z.string().min(1).describe("Substring to search for (matches node id, label, source file)."),
-  file_type: z.string().optional().describe("Optional filter by file_type (e.g. 'code', 'doc')."),
-  limit: z.number().int().positive().optional().describe("Max results to return (default 20, max 50)."),
-});
-
-export function createGraphQueryTool(
-  deps: GraphQueryDeps,
-): AgentTool<BizarGraphQueryInput, BizarGraphQueryOutput> {
-  return createTool({
-    name: BIZAR_GRAPH_QUERY_TOOL_NAME,
-    description:
-      "Query the project knowledge graph for nodes matching a substring. " +
-      "Searches node id, label, and source file. Returns up to N matching nodes. " +
-      "The graph is built by `graphify` and lives at .bizar/graph/graph.json.",
-    inputSchema: bizarGraphQuerySchema.shape,
-    execute: async (input) => {
-      const graph = loadGraph(deps.worktree);
-      if (!graph) {
-        return { ok: false as const, error: "no_graph", message: "No knowledge graph found at .bizar/graph/graph.json. Run `graphify` to build it." };
-      }
-      const nodes = graph.nodes ?? [];
-      const limit = Math.min(input.limit ?? 20, MAX_NODES);
-      const fileType = input.file_type;
-      const matches: GraphNode[] = [];
-      for (const n of nodes) {
-        if (fileType && n.file_type !== fileType) continue;
-        if (nodeMatches(n, input.query)) {
-          matches.push(n);
-          if (matches.length >= limit) break;
-        }
-      }
-      return { ok: true as const, count: matches.length, nodes: matches, totalNodes: nodes.length };
-    },
-  });
-}
-
-// ── path ─────────────────────────────────────────────────────────────────
-export type BizarGraphPathInput = z.infer<typeof bizarGraphPathSchema>;
-export type BizarGraphPathOutput =
-  | { ok: true; from: string; to: string; path: string[]; nodes: GraphNode[]; hops: number }
-  | { ok: false; error: string; message: string };
-
-const bizarGraphPathSchema = z.object({
-  from: z.string().min(1).describe("Source node id or label substring."),
-  to: z.string().min(1).describe("Target node id or label substring."),
-});
-
-export function createGraphPathTool(
-  deps: GraphQueryDeps,
-): AgentTool<BizarGraphPathInput, BizarGraphPathOutput> {
-  return createTool({
-    name: BIZAR_GRAPH_PATH_TOOL_NAME,
-    description:
-      "Find the shortest path between two nodes in the project knowledge graph. " +
-      "Accepts substrings for from/to (resolves to the first matching node). " +
-      "Returns the path as an array of node ids and the resolved node details.",
-    inputSchema: bizarGraphPathSchema.shape,
-    execute: async (input) => {
-      const graph = loadGraph(deps.worktree);
-      if (!graph) {
-        return { ok: false as const, error: "no_graph", message: "No knowledge graph found at .bizar/graph/graph.json. Run `graphify` to build it." };
-      }
-      const nodes = graph.nodes ?? [];
-      // Resolve from/to to first matching node id
-      const resolveNode = (q: string): GraphNode | null => {
-        // 1. Exact id match (preferred)
-        for (const n of nodes) if (n.id === q) return n;
-        // 2. Exact label match
-        for (const n of nodes) if (n.label === q) return n;
-        // 3. Substring match (last resort)
-        for (const n of nodes) if (nodeMatches(n, q)) return n;
-        return null;
-      };
-      const fromNode = resolveNode(input.from);
-      const toNode = resolveNode(input.to);
-      if (!fromNode) {
-        return { ok: false as const, error: "from_not_found", message: `No node matches '${input.from}'` };
-      }
-      if (!toNode) {
-        return { ok: false as const, error: "to_not_found", message: `No node matches '${input.to}'` };
-      }
-      const path = bfsPath(graph, fromNode.id, toNode.id);
-      if (!path) {
-        return { ok: false as const, error: "no_path", message: `No path from '${fromNode.id}' to '${toNode.id}' (graph may have no edges between them)` };
-      }
-      // Hydrate the path with node details
-      const idToNode = new Map(nodes.map((n) => [n.id, n]));
-      const pathNodes: GraphNode[] = [];
-      for (const id of path) {
-        const n = idToNode.get(id);
-        if (n) pathNodes.push(n);
-      }
-      return {
-        ok: true as const,
-        from: fromNode.id,
-        to: toNode.id,
-        path,
-        nodes: pathNodes,
-        hops: path.length - 1,
-      };
-    },
-  });
-}
-
-// ── explain ──────────────────────────────────────────────────────────────
-export type BizarGraphExplainInput = z.infer<typeof bizarGraphExplainSchema>;
-export type BizarGraphExplainOutput =
-  | {
-      ok: true;
-      node: GraphNode;
-      neighbors: Array<{ node: GraphNode; relation?: string }>;
-      neighborCount: number;
-    }
-  | { ok: false; error: string; message: string };
-
-const bizarGraphExplainSchema = z.object({
-  node: z.string().min(1).describe("Node id or label substring to explain."),
-  maxNeighbors: z.number().int().positive().optional().describe("Max neighbors to show (default 10, max 20)."),
-});
-
-export function createGraphExplainTool(
-  deps: GraphQueryDeps,
-): AgentTool<BizarGraphExplainInput, BizarGraphExplainOutput> {
-  return createTool({
-    name: BIZAR_GRAPH_EXPLAIN_TOOL_NAME,
-    description:
-      "Explain a node in the project knowledge graph — what it is, where " +
-      "it's defined, and its immediate neighbors (in/out edges). Accepts " +
-      "substring matching for the node id or label.",
-    inputSchema: bizarGraphExplainSchema.shape,
-    execute: async (input) => {
-      const graph = loadGraph(deps.worktree);
-      if (!graph) {
-        return { ok: false as const, error: "no_graph", message: "No knowledge graph found at .bizar/graph/graph.json. Run `graphify` to build it." };
-      }
-      const nodes = graph.nodes ?? [];
-      const target = nodes.find((n) => n.id === input.node || n.label === input.node)
-        ?? nodes.find((n) => nodeMatches(n, input.node));
-      if (!target) {
-        return { ok: false as const, error: "not_found", message: `No node matches '${input.node}'` };
-      }
-      const max = Math.min(input.maxNeighbors ?? 10, MAX_NEIGHBORS);
-      const neighbors: Array<{ node: GraphNode; relation?: string }> = [];
-      for (const e of graph.edges ?? []) {
-        if (e.source === target.id) {
-          const n = nodes.find((x) => x.id === e.target);
-          if (n) neighbors.push({ node: n, relation: e.relation });
-        } else if (!graph.directed && e.target === target.id) {
-          const n = nodes.find((x) => x.id === e.source);
-          if (n) neighbors.push({ node: n, relation: e.relation });
-        }
-        if (neighbors.length >= max) break;
-      }
-      return {
-        ok: true as const,
-        node: target,
-        neighbors,
-        neighborCount: neighbors.length,
-      };
-    },
-  });
-}

package/plugins/bizar/src/tools/loop-engineering.ts

@@ -1,193 +0,0 @@
-/**
- * plugins/bizar/src/tools/loop-engineering.ts
- *
- * Tools for the /loop command. Each tool is a thin wrapper around
- * `loop-engineering.ts` which manages loop state on disk at ~/.bizar/loops/.
- */
-
-import { createTool, type AgentTool } from "@cline/sdk";
-import { z } from "zod";
-
-import type { Logger } from "../logger.js";
-import {
-  startLoop as leStartLoop,
-  loadLoop,
-  listLoops,
-  stopLoop as leStopLoop,
-  deleteLoop as leDeleteLoop,
-  buildNextIteration,
-  type LoopPattern,
-} from "../loop-engineering.js";
-
-export const BIZAR_LOOP_START_TOOL_NAME = "bizar_loop_start";
-export const BIZAR_LOOP_STATUS_TOOL_NAME = "bizar_loop_status";
-export const BIZAR_LOOP_STOP_TOOL_NAME = "bizar_loop_stop";
-export const BIZAR_LOOP_LIST_TOOL_NAME = "bizar_loop_list";
-export const BIZAR_LOOP_DELETE_TOOL_NAME = "bizar_loop_delete";
-
-export interface LoopToolDeps {
-  logger: Logger;
-}
-
-// ── Loop-start ────────────────────────────────────────────────────────
-const loopStartSchema = z.object({
-  pattern: z.enum(["ralph", "repl", "cron", "plan-execute"]),
-  task: z.string(),
-  interval: z.number().int().positive().optional(),
-  maxIterations: z.number().int().positive().optional(),
-  stopMarker: z.string().optional(),
-  subtasks: z.array(z.string()).optional(),
-});
-
-export function createLoopStartTool(deps: LoopToolDeps): AgentTool {
-  return createTool({
-    name: BIZAR_LOOP_START_TOOL_NAME,
-    description:
-      "Start a continuous loop. Patterns: ralph (until [STOP] marker), " +
-      "repl (interactive), cron (interval-based), plan-execute (iterate subtasks).",
-    inputSchema: loopStartSchema.shape,
-    execute: async (args) => {
-      const input = loopStartSchema.parse(args);
-      const { ok, loop } = leStartLoop({
-        pattern: input.pattern as LoopPattern,
-        task: input.task,
-        context: {
-          maxIterations: input.maxIterations ?? 10,
-          intervalSeconds: input.interval,
-          stopMarker: input.stopMarker,
-          subtasks: input.subtasks,
-        },
-      });
-      const next = buildNextIteration(loop);
-      deps.logger.info?.(`[loop] started ${loop.id} (${loop.pattern})`);
-      return {
-        ok,
-        loopId: loop.id,
-        pattern: loop.pattern,
-        task: loop.task,
-        maxIterations: loop.context.maxIterations,
-        nextPrompt: next.prompt,
-        stopMarker: next.stopMarker,
-      };
-    },
-  });
-}
-
-// ── Loop-status ───────────────────────────────────────────────────────
-const loopStatusSchema = z.object({
-  loopId: z.string(),
-  verbose: z.boolean().optional(),
-});
-
-export function createLoopStatusTool(_deps: LoopToolDeps): AgentTool {
-  return createTool({
-    name: BIZAR_LOOP_STATUS_TOOL_NAME,
-    description: "Show the status and iteration log of a loop.",
-    inputSchema: loopStatusSchema.shape,
-    execute: async (args) => {
-      const input = loopStatusSchema.parse(args);
-      const loop = loadLoop(input.loopId);
-      if (!loop) return { ok: false, error: `loop not found: ${input.loopId}` };
-      return {
-        ok: true,
-        loopId: loop.id,
-        pattern: loop.pattern,
-        task: loop.task,
-        status: loop.status,
-        iterationCount: loop.iterations.length,
-        maxIterations: loop.context.maxIterations,
-        createdAt: loop.createdAt,
-        updatedAt: loop.updatedAt,
-        iterations: input.verbose ? loop.iterations : loop.iterations.slice(-3),
-      };
-    },
-  });
-}
-
-// ── Loop-stop ─────────────────────────────────────────────────────────
-const loopStopSchema = z.object({
-  loopId: z.string(),
-  reason: z.string().optional(),
-});
-
-export function createLoopStopTool(_deps: LoopToolDeps): AgentTool {
-  return createTool({
-    name: BIZAR_LOOP_STOP_TOOL_NAME,
-    description: "Stop a running loop.",
-    inputSchema: loopStopSchema.shape,
-    execute: async (args) => {
-      const input = loopStopSchema.parse(args);
-      const loop = leStopLoop(input.loopId, input.reason);
-      if (!loop) return { ok: false, error: `loop not found: ${input.loopId}` };
-      return { ok: true, loopId: loop.id, status: loop.status };
-    },
-  });
-}
-
-// ── Loop-list ─────────────────────────────────────────────────────────
-const loopListSchema = z.object({
-  status: z.enum(["running", "stopped", "done"]).optional(),
-  pattern: z.enum(["ralph", "repl", "cron", "plan-execute"]).optional(),
-  limit: z.number().int().positive().optional(),
-});
-
-export function createLoopListTool(_deps: LoopToolDeps): AgentTool {
-  return createTool({
-    name: BIZAR_LOOP_LIST_TOOL_NAME,
-    description: "List all loops on disk.",
-    inputSchema: loopListSchema.shape,
-    execute: async (args) => {
-      const input = loopListSchema.parse(args);
-      const loops = listLoops({
-        status: input.status as "running" | "stopped" | "done" | undefined,
-        pattern: input.pattern as LoopPattern | undefined,
-      });
-      const sliced = input.limit ? loops.slice(0, input.limit) : loops;
-      return {
-        ok: true,
-        count: sliced.length,
-        loops: sliced.map((l) => ({
-          id: l.id,
-          pattern: l.pattern,
-          task: l.task.slice(0, 80),
-          status: l.status,
-          iterationCount: l.iterations.length,
-          createdAt: l.createdAt,
-        })),
-      };
-    },
-  });
-}
-
-// ── Loop-delete ───────────────────────────────────────────────────────
-const loopDeleteSchema = z.object({ loopId: z.string() });
-
-export function createLoopDeleteTool(_deps: LoopToolDeps): AgentTool {
-  return createTool({
-    name: BIZAR_LOOP_DELETE_TOOL_NAME,
-    description: "Delete a loop from disk.",
-    inputSchema: loopDeleteSchema.shape,
-    execute: async (args) => {
-      const input = loopDeleteSchema.parse(args);
-      const ok = leDeleteLoop(input.loopId);
-      if (!ok) return { ok: false, error: `loop not found: ${input.loopId}` };
-      return { ok: true, loopId: input.loopId };
-    },
-  });
-}
-
-/**
- * Bundle all 5 loop tools for the plugin's setup() entry.
- */
-export function createLoopTools(deps: LoopToolDeps): AgentTool[] {
-  return [
-    createLoopStartTool(deps),
-    createLoopStatusTool(deps),
-    createLoopStopTool(deps),
-    createLoopListTool(deps),
-    createLoopDeleteTool(deps),
-  ];
-}
-
-// Re-export.
-export { startLoop, loadLoop, listLoops, stopLoop, deleteLoop, buildNextIteration } from "../loop-engineering.js";

package/plugins/bizar/src/tools/memory-list.ts

@@ -1,43 +0,0 @@
-/**
- * plugins/bizar/src/tools/memory-list.ts
- *
- * `bizar_memory_list` tool — list notes in the Bizar Memory vault.
- *
- * v6.0.0 — In-process (reads vault directory directly).
- */
-
-import { createTool, type AgentTool } from "@cline/sdk";
-import { z } from "zod";
-
-import type { Logger } from "../logger.js";
-import { resolveVaultRoot, listNotes, type MemoryNote } from "../memory-vault.js";
-
-export const BIZAR_MEMORY_LIST_TOOL_NAME = "bizar_memory_list";
-
-export interface MemoryListDeps { worktree: string; logger: Logger; }
-
-export type BizarMemoryListInput = z.infer<typeof bizarMemoryListSchema>;
-export type BizarMemoryListOutput =
-  | { ok: true; notes: Array<{ path: string; frontmatter: Record<string, unknown>; mtime: number; size: number }> }
-  | { ok: false; error: string; message: string };
-
-const bizarMemoryListSchema = z.object({
-  limit: z.number().int().positive().optional().describe("Max number of notes to return (default 100)."),
-  prefix: z.string().optional().describe("Only return notes whose path starts with this prefix."),
-});
-
-export function createMemoryListTool(deps: MemoryListDeps): AgentTool<BizarMemoryListInput, BizarMemoryListOutput> {
-  return createTool({
-    name: BIZAR_MEMORY_LIST_TOOL_NAME,
-    description: "List notes in the Bizar Memory vault. Available to all agents.",
-    inputSchema: bizarMemoryListSchema.shape,
-    execute: async (input) => {
-      const limit = input.limit ?? 100;
-      const notes = listNotes(resolveVaultRoot(), input.prefix ?? "", limit);
-      return {
-        ok: true as const,
-        notes: notes.map((n: MemoryNote) => ({ path: n.relPath, frontmatter: n.frontmatter, mtime: n.mtime, size: n.size })),
-      };
-    },
-  });
-}

package/plugins/bizar/src/tools/memory-read.ts

@@ -1,69 +0,0 @@
-/**
- * plugins/bizar/src/tools/memory-read.ts
- *
- * `bizar_memory_read` tool — read a single note from the Bizar Memory vault.
- *
- * v6.0.0 — Reads directly from the in-process memory vault (no dashboard
- * HTTP). Falls back to the legacy vault location if it exists.
- *
- * Cline SDK port (Phase 2):
- *   - Uses `createTool` from `@cline/sdk` directly.
- *   - Adds `name: BIZAR_MEMORY_READ_TOOL_NAME`.
- *   - `inputSchema` is `z.object(...).shape` over the same fields.
- *   - Returns structured `{ ok, path, content, frontmatter, mtime, size }`.
- */
-
-import { createTool, type AgentTool } from "@cline/sdk";
-import { z } from "zod";
-
-import type { Logger } from "../logger.js";
-import { resolveVaultRoot, LEGACY_MEMORY_VAULT, readNote, type MemoryNote } from "../memory-vault.js";
-
-export const BIZAR_MEMORY_READ_TOOL_NAME = "bizar_memory_read";
-
-export interface MemoryReadDeps {
-  worktree: string;
-  logger: Logger;
-}
-
-export type BizarMemoryReadInput = z.infer<typeof bizarMemoryReadSchema>;
-export type BizarMemoryReadOutput =
-  | { ok: true; path: string; content: string; frontmatter: Record<string, unknown>; mtime: number; size: number }
-  | { ok: false; error: string; message: string; path: string };
-
-const bizarMemoryReadSchema = z.object({
-  path: z.string().min(1).describe("Vault-relative path of the note to read (e.g. 'decisions/foo.md')."),
-});
-
-export function createMemoryReadTool(deps: MemoryReadDeps): AgentTool<BizarMemoryReadInput, BizarMemoryReadOutput> {
-  return createTool({
-    name: BIZAR_MEMORY_READ_TOOL_NAME,
-    description:
-      "Read a single note from the Bizar Memory vault. " +
-      "The path is relative to the vault root (e.g. 'decisions/foo.md'). " +
-      "Returns { path, content, frontmatter, mtime } or { error } on failure. " +
-      "Available to all agents.",
-    inputSchema: bizarMemoryReadSchema.shape,
-    execute: async (input) => {
-      const vaultRoot = resolveVaultRoot();
-      const note = readFromVault(vaultRoot, input.path) ?? (vaultRoot !== LEGACY_MEMORY_VAULT ? readFromVault(LEGACY_MEMORY_VAULT, input.path) : null);
-      if (!note) {
-        return { ok: false as const, error: "not_found", message: `Note not found at path: ${input.path}`, path: input.path };
-      }
-      return {
-        ok: true as const,
-        path: note.relPath,
-        content: note.body,
-        frontmatter: note.frontmatter,
-        mtime: note.mtime,
-        size: note.size,
-      };
-    },
-  });
-}
-
-function readFromVault(vaultRoot: string, relPath: string): MemoryNote | null {
-  const safe = relPath.replace(/\\/g, "/").replace(/^\/+/, "");
-  if (safe.includes("..") || safe.startsWith(".")) return null;
-  return readNote(vaultRoot, safe);
-}

package/plugins/bizar/src/tools/memory-search.ts

@@ -1,47 +0,0 @@
-/**
- * plugins/bizar/src/tools/memory-search.ts
- *
- * `bizar_memory_search` tool — full-text search over the Bizar Memory vault.
- *
- * v6.0.0 — In-process (uses the vault's built-in full-text search).
- * The dashboard's semantic / lightrag search is the source of truth
- * for higher-quality results, but FTS works without it.
- */
-
-import { createTool, type AgentTool } from "@cline/sdk";
-import { z } from "zod";
-
-import type { Logger } from "../logger.js";
-import { resolveVaultRoot, searchNotes } from "../memory-vault.js";
-
-export const BIZAR_MEMORY_SEARCH_TOOL_NAME = "bizar_memory_search";
-
-export interface MemorySearchDeps { worktree: string; logger: Logger; }
-
-export type BizarMemorySearchInput = z.infer<typeof bizarMemorySearchSchema>;
-export type BizarMemorySearchOutput =
-  | { ok: true; query: string; results: Array<{ path: string; frontmatter: Record<string, unknown>; snippet: string }> }
-  | { ok: false; error: string; message: string };
-
-const bizarMemorySearchSchema = z.object({
-  query: z.string().min(1).describe("Search query (substring match against note body + frontmatter)."),
-  limit: z.number().int().positive().optional().describe("Max results (default 20)."),
-  mode: z.enum(["semantic", "fts"]).optional().describe("Search mode (default 'fts'; 'semantic' falls back to fts without a dashboard)."),
-});
-
-export function createMemorySearchTool(deps: MemorySearchDeps): AgentTool<BizarMemorySearchInput, BizarMemorySearchOutput> {
-  return createTool({
-    name: BIZAR_MEMORY_SEARCH_TOOL_NAME,
-    description: "Search the Bizar Memory vault. Returns matching notes with snippets. Available to all agents.",
-    inputSchema: bizarMemorySearchSchema.shape,
-    execute: async (input) => {
-      const limit = input.limit ?? 20;
-      const notes = searchNotes(resolveVaultRoot(), input.query, limit);
-      return {
-        ok: true as const,
-        query: input.query,
-        results: notes.map((n) => ({ path: n.relPath, frontmatter: n.frontmatter, snippet: n.body.slice(0, 300) })),
-      };
-    },
-  });
-}

package/plugins/bizar/src/tools/memory-write.ts

@@ -1,54 +0,0 @@
-/**
- * plugins/bizar/src/tools/memory-write.ts
- *
- * `bizar_memory_write` tool — write a note to the Bizar Memory vault.
- *
- * v6.0.0 — In-process (writes to vault directory directly).
- */
-
-import { createTool, type AgentTool } from "@cline/sdk";
-import { z } from "zod";
-
-import type { Logger } from "../logger.js";
-import { resolveVaultRoot, writeNote } from "../memory-vault.js";
-
-export const BIZAR_MEMORY_WRITE_TOOL_NAME = "bizar_memory_write";
-
-export interface MemoryWriteDeps { worktree: string; logger: Logger; }
-
-export type BizarMemoryWriteInput = z.infer<typeof bizarMemoryWriteSchema>;
-export type BizarMemoryWriteOutput =
-  | { ok: true; path: string; mtime: number; size: number }
-  | { ok: false; error: string; message: string; path: string };
-
-const bizarMemoryWriteSchema = z.object({
-  path: z.string().min(1).describe("Vault-relative path of the note to write (e.g. 'decisions/foo.md')."),
-  content: z.string().describe("Markdown body of the note (the part after the frontmatter)."),
-  frontmatter: z.record(z.string(), z.unknown()).optional().describe("YAML frontmatter as a JSON object."),
-  type: z.string().optional().describe("Optional note type tag."),
-});
-
-export function createMemoryWriteTool(deps: MemoryWriteDeps): AgentTool<BizarMemoryWriteInput, BizarMemoryWriteOutput> {
-  return createTool({
-    name: BIZAR_MEMORY_WRITE_TOOL_NAME,
-    description: "Write a note to the Bizar Memory vault. Available to all agents.",
-    inputSchema: bizarMemoryWriteSchema.shape,
-    execute: async (input) => {
-      const vaultRoot = resolveVaultRoot();
-      const safe = input.path.replace(/\\/g, "/").replace(/^\/+/, "");
-      if (safe.includes("..") || safe.startsWith(".")) {
-        return { ok: false as const, error: "invalid_path", message: "Path must be a simple relative vault path (no '..' or absolute paths).", path: input.path };
-      }
-      const fm = { ...(input.frontmatter ?? {}) } as Record<string, unknown>;
-      if (input.type && !fm.type) fm.type = input.type;
-      try {
-        const note = writeNote(vaultRoot, safe, fm, input.content);
-        return { ok: true as const, path: note.relPath, mtime: note.mtime, size: note.size };
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        deps.logger.warn(`bizar: memory-write(${safe}) failed: ${msg}`);
-        return { ok: false as const, error: "write_failed", message: msg, path: safe };
-      }
-    },
-  });
-}