membot 0.2.1 → 0.3.1

package/.claude/skills/membot.md

@@ -29,6 +29,7 @@ membot search "<question>"          # hybrid search (semantic + keyword)
 membot add ./README.md                            # single file
 membot add ./docs                                 # recursive directory walk
 membot add "docs/**/*.md"                         # glob
+membot add a.md b.md "docs/**/*.md"               # any number of args; each resolved independently
 membot add https://example.com/spec.pdf           # URL (auto-converted to markdown)
 membot add "inline:Decision: use X because Y"     # literal text
 membot add ./docs --refresh-frequency 24h         # auto-refresh every day
@@ -74,7 +75,8 @@ Inline writes create a new `(logical_path, version_id)` row just like file inges
 membot refresh <logical_path>          # re-read source; new version only if bytes changed
 membot refresh                         # refresh all rows whose schedule has elapsed
 membot mv old/path new/path            # rename (history preserved under both)
-membot rm <logical_path>               # tombstone (history still queryable)
+membot rm <paths...>                   # tombstone one or more paths/globs (history still queryable)
+membot rm "docs/**/*.md" notes/old.md  # globs match logical_paths in the DB; literals + globs can mix
 membot prune --before <iso-ts>         # drop non-current versions older than cutoff (irreversible)
 ```
 
@@ -108,7 +110,7 @@ Tombstones hide a path from `ls` / `tree` / `search` but `versions` and `read --
 
 | Command                               | Purpose                                                                        |
 | ------------------------------------- | ------------------------------------------------------------------------------ |
-| `membot add <source>`                 | Ingest file, directory, glob, URL, or `inline:<text>`. Skips unchanged sources; pass `--force` to re-ingest |
+| `membot add <sources...>`             | Ingest one or more files, directories, globs, URLs, or `inline:<text>`. Skips unchanged sources; pass `--force` to re-ingest |
 | `membot ls [prefix]`                  | List current files (size, mime, refresh status)                                |
 | `membot tree [prefix]`                | Render the synthesised logical-path tree (`--max-depth`, `--max-items` cap output) |
 | `membot read <path>`                  | Read current markdown surrogate (or `--bytes` for original)                    |
@@ -118,7 +120,7 @@ Tombstones hide a path from `ls` / `tree` / `search` but `versions` and `read --
 | `membot versions <path>`              | List every version newest-first with version_id and change notes               |
 | `membot diff <path> --a <ts>`         | Unified diff between two versions                                              |
 | `membot mv <old> <new>`               | Rename a logical_path (history preserved)                                      |
-| `membot rm <path>`                    | Tombstone a logical_path (history still queryable)                             |
+| `membot rm <paths...>`                | Tombstone one or more logical_paths or globs (e.g. `"docs/**/*.md"`); history kept |
 | `membot refresh [path]`               | Re-read source; create new version only if bytes changed                       |
 | `membot prune --before <ts>`          | Permanently drop non-current versions older than cutoff (irreversible)         |
 | `membot serve`                        | Start MCP server (stdio default, `--http <port>` for HTTP)                     |

package/.cursor/rules/membot.mdc

@@ -29,6 +29,7 @@ membot search "<question>"          # hybrid search (semantic + keyword)
 membot add ./README.md                            # single file
 membot add ./docs                                 # recursive directory walk
 membot add "docs/**/*.md"                         # glob
+membot add a.md b.md "docs/**/*.md"               # any number of args; each resolved independently
 membot add https://example.com/spec.pdf           # URL (auto-converted to markdown)
 membot add "inline:Decision: use X because Y"     # literal text
 membot add ./docs --refresh-frequency 24h         # auto-refresh every day
@@ -74,7 +75,8 @@ Inline writes create a new `(logical_path, version_id)` row just like file inges
 membot refresh <logical_path>          # re-read source; new version only if bytes changed
 membot refresh                         # refresh all rows whose schedule has elapsed
 membot mv old/path new/path            # rename (history preserved under both)
-membot rm <logical_path>               # tombstone (history still queryable)
+membot rm <paths...>                   # tombstone one or more paths/globs (history still queryable)
+membot rm "docs/**/*.md" notes/old.md  # globs match logical_paths in the DB; literals + globs can mix
 membot prune --before <iso-ts>         # drop non-current versions older than cutoff (irreversible)
 ```
 
@@ -108,7 +110,7 @@ Tombstones hide a path from `ls` / `tree` / `search` but `versions` and `read --
 
 | Command                               | Purpose                                                                        |
 | ------------------------------------- | ------------------------------------------------------------------------------ |
-| `membot add <source>`                 | Ingest file, directory, glob, URL, or `inline:<text>`. Skips unchanged sources; pass `--force` to re-ingest |
+| `membot add <sources...>`             | Ingest one or more files, directories, globs, URLs, or `inline:<text>`. Skips unchanged sources; pass `--force` to re-ingest |
 | `membot ls [prefix]`                  | List current files (size, mime, refresh status)                                |
 | `membot tree [prefix]`                | Render the synthesised logical-path tree (`--max-depth`, `--max-items` cap output) |
 | `membot read <path>`                  | Read current markdown surrogate (or `--bytes` for original)                    |
@@ -118,7 +120,7 @@ Tombstones hide a path from `ls` / `tree` / `search` but `versions` and `read --
 | `membot versions <path>`              | List every version newest-first with version_id and change notes               |
 | `membot diff <path> --a <ts>`         | Unified diff between two versions                                              |
 | `membot mv <old> <new>`               | Rename a logical_path (history preserved)                                      |
-| `membot rm <path>`                    | Tombstone a logical_path (history still queryable)                             |
+| `membot rm <paths...>`                | Tombstone one or more logical_paths or globs (e.g. `"docs/**/*.md"`); history kept |
 | `membot refresh [path]`               | Re-read source; create new version only if bytes changed                       |
 | `membot prune --before <ts>`          | Permanently drop non-current versions older than cutoff (irreversible)         |
 | `membot serve`                        | Start MCP server (stdio default, `--http <port>` for HTTP)                     |

package/README.md

@@ -25,12 +25,13 @@ This pulls in DuckDB's per-platform native bindings alongside membot. The build
 ## Quick start
 
 ```bash
-membot add ./docs                        # ingest a directory recursively
-membot add https://example.com/spec.pdf  # ingest a URL (auto-converted to markdown)
-membot ls                                # list current files
-membot search "how does refresh work?"   # hybrid search
-membot read docs/refresh.md              # read the markdown surrogate
-membot serve                             # expose the same operations as MCP tools (stdio)
+membot add ./docs                                # ingest a directory recursively
+membot add https://example.com/spec.pdf          # ingest a URL (auto-converted to markdown)
+membot add a.md b.md "docs/**/*.md"              # any number of files / globs in one call
+membot ls                                        # list current files
+membot search "how does refresh work?"           # hybrid search
+membot read docs/refresh.md                      # read the markdown surrogate
+membot serve                                     # expose the same operations as MCP tools (stdio)
 ```
 
 ## Use with Claude Code or Cursor
@@ -50,7 +51,7 @@ The skill files describe the discover → ingest → search → read → write w
 
 | Command                         | Description                                                                       |
 | ------------------------------- | --------------------------------------------------------------------------------- |
-| `membot add <source>`           | Ingest a file, directory, glob, URL, or `inline:<text>`. Default `logical_path` mirrors the source (absolute path for local files, `remotes/{host}/{path}` for URLs) so files with the same basename in different projects don't collide. Pass `-p <path>` to override or, on a directory walk, to set a prefix. Skips on unchanged source bytes; pass `--force` to re-ingest. |
+| `membot add <sources...>`       | Ingest one or more files, directories, globs, URLs, or `inline:<text>`. Default `logical_path` mirrors the source (absolute path for local files, `remotes/{host}/{path}` for URLs) so files with the same basename in different projects don't collide. Pass `-p <path>` to override or set a prefix. Skips unchanged source bytes; pass `--force` to re-ingest. |
 | `membot ls [prefix]`            | List current files (size, mime, refresh status)                                   |
 | `membot tree [prefix]`          | Render the synthesised logical-path tree (`--max-depth`, `--max-items` cap output) |
 | `membot read <path>`            | Read the markdown surrogate (or `--bytes` for original bytes, base64)             |
@@ -60,7 +61,7 @@ The skill files describe the discover → ingest → search → read → write w
 | `membot diff <path> <a> [b]`    | Unified diff between two versions                                                 |
 | `membot write <path>`           | Write inline agent-authored markdown as a new version                             |
 | `membot mv <from> <to>`         | Rename a logical_path (history preserved under both)                              |
-| `membot rm <path>`              | Tombstone a logical_path (history still queryable)                                |
+| `membot rm <paths...>`          | Tombstone one or more logical_paths or globs (e.g. `"docs/**/*.md"`); history kept |
 | `membot refresh [path]`         | Re-read source; new version only if bytes changed                                 |
 | `membot prune --before <ts>`    | Permanently drop non-current versions older than cutoff (irreversible)            |
 | `membot serve`                  | Run the MCP server (stdio default; `--http <port>` for HTTP)                      |

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "membot",
-	"version": "0.2.1",
+	"version": "0.3.1",
 	"description": "Versioned context store with hybrid search for AI agents. Stdio + HTTP MCP server and CLI.",
 	"type": "module",
 	"exports": {

package/src/mount/zod-to-cli.ts

@@ -22,11 +22,22 @@ export function applySchemaToCommand<S extends z.ZodObject>(
 	const shape = schema.shape;
 	const positionalOrder = options.positional ?? [];
 
-	for (const fieldName of positionalOrder) {
+	for (let i = 0; i < positionalOrder.length; i++) {
+		const fieldName = positionalOrder[i];
+		if (fieldName === undefined) continue;
 		const fieldSchema = shape[fieldName];
 		if (!fieldSchema) continue;
 		const required = !isOptional(fieldSchema);
-		const label = required ? `<${fieldName}>` : `[${fieldName}]`;
+		const variadic = unwrap(fieldSchema) instanceof z.ZodArray;
+		if (variadic && i !== positionalOrder.length - 1) {
+			throw new HelpfulError({
+				kind: "internal_error",
+				message: `variadic positional \`${fieldName}\` must be the last positional argument`,
+				hint: "Reorder the operation's `cli.positional` so the array-typed field comes last.",
+			});
+		}
+		const inner = variadic ? `${fieldName}...` : fieldName;
+		const label = required ? `<${inner}>` : `[${inner}]`;
 		cmd.argument(label, describeOf(fieldSchema));
 	}
 

package/src/operations/add.ts

@@ -8,23 +8,33 @@ const FetcherKindEnum = z.enum(["http", "mcpx", "local", "inline"]);
 export const addOperation = defineOperation({
 	name: "membot_add",
 	cliName: "add",
-	description: `Ingest one or many sources into the store. \`source\` accepts:
+	description: `Ingest one or many sources into the store. Each \`sources\` arg accepts:
   - a local file path
   - a local directory (recursive walk, symlinks followed)
   - a glob pattern (e.g. "docs/**/*.md")
   - a URL (fetched via mcpx if configured, otherwise plain HTTP)
   - "inline:<text>" literal
-PDF, DOCX, HTML, images, and other binaries are converted to markdown — native libraries first, vision/OCR for images, LLM fallback for messy or scanned input. Original bytes are kept in the blobs table; \`membot_read bytes=true\` returns them. Setting \`refresh_frequency\` enables automatic refresh from the daemon. By default, re-ingesting an unchanged source (same source_sha256 as the current version) is a no-op and reports \`status: "unchanged"\`; pass \`force=true\` to always create a new version. Each newly-ingested file becomes a new version under its own logical_path; existing versions stay queryable via membot_versions. Directory/glob ingests stream one file at a time — partial failures do not abort the rest; the response lists per-entry status.
+Pass any number of args; each is resolved independently and the matched entries are concatenated into one response. PDF, DOCX, HTML, images, and other binaries are converted to markdown — native libraries first, vision/OCR for images, LLM fallback for messy or scanned input. Original bytes are kept in the blobs table; \`membot_read bytes=true\` returns them. Setting \`refresh_frequency\` enables automatic refresh from the daemon. By default, re-ingesting an unchanged source (same source_sha256 as the current version) is a no-op and reports \`status: "unchanged"\`; pass \`force=true\` to always create a new version. Each newly-ingested file becomes a new version under its own logical_path; existing versions stay queryable via membot_versions. Directory/glob ingests stream one file at a time — partial failures do not abort the rest; the response lists per-entry status.
 
 When \`logical_path\` is omitted, it is derived from the source so files with the same basename in different projects do not collide:
   - Local sources use the entry's absolute filesystem path with the leading "/" stripped (e.g. "/Users/me/projA/README.md" → "Users/me/projA/README.md").
   - URLs use "remotes/{host}/{path}" with slashes preserved (e.g. "https://github.com/u/p/blob/main/README.md" → "remotes/github.com/u/p/blob/main/README.md"). Query strings and fragments are dropped from the logical_path; the full URL is still stored on the row for refresh.
   - "inline:<text>" defaults to "inline/{timestamp}.md".
 
-Pass \`logical_path\` to override. For a directory or glob walk it is treated as a PREFIX — each entry is placed at "{prefix}/{path-relative-to-walk-base}". Re-running \`membot_add\` on the same source resolves to the same logical_path; if bytes are unchanged the call is a no-op (status \`unchanged\`), otherwise a new version is created.`,
+Pass \`logical_path\` to override. For a multi-source / directory / glob walk it is treated as a PREFIX — each entry is placed at "{prefix}/{path-relative-to-walk-base}". Re-running \`membot_add\` on the same source resolves to the same logical_path; if bytes are unchanged the call is a no-op (status \`unchanged\`), otherwise a new version is created.`,
 	inputSchema: z.object({
-		source: z.string().describe("Local path, directory, glob, URL, or `inline:<text>` literal"),
-		logical_path: z.string().optional().describe("Destination logical_path (single source) or prefix (directory/glob)"),
+		sources: z
+			.array(z.string())
+			.min(1)
+			.describe(
+				"One or more sources. Each arg is independently resolved as a local path, directory, glob, URL, or `inline:<text>` literal.",
+			),
+		logical_path: z
+			.string()
+			.optional()
+			.describe(
+				"Destination logical_path (single source resolving to a single entry) or prefix (multi-arg / directory / glob)",
+			),
 		include: z
 			.string()
 			.optional()
@@ -67,7 +77,7 @@ Pass \`logical_path\` to override. For a directory or glob walk it is treated as
 		failed: z.number(),
 	}),
 	cli: {
-		positional: ["source"],
+		positional: ["sources"],
 		aliases: { logical_path: "-p", refresh_frequency: "-r", change_note: "-m", force: "-f" },
 	},
 	console_formatter: (result) => {
@@ -85,5 +95,23 @@ Pass \`logical_path\` to override. For a directory or glob walk it is treated as
 		if (result.failed > 0) parts.push(colors.red(`failed ${result.failed}`));
 		return `${lines.join("\n")}\n${parts.join(", ")}`;
 	},
-	handler: async (input, ctx) => ingest(input, ctx),
+	handler: async (input, ctx) => {
+		const { sources, ...rest } = input;
+		const aggregated = {
+			ingested: [] as Awaited<ReturnType<typeof ingest>>["ingested"],
+			total: 0,
+			ok: 0,
+			unchanged: 0,
+			failed: 0,
+		};
+		for (const source of sources) {
+			const r = await ingest({ ...rest, source }, ctx);
+			aggregated.ingested.push(...r.ingested);
+			aggregated.total += r.total;
+			aggregated.ok += r.ok;
+			aggregated.unchanged += r.unchanged;
+			aggregated.failed += r.failed;
+		}
+		return aggregated;
+	},
 });

package/src/operations/remove.ts

@@ -1,6 +1,8 @@
+import picomatch from "picomatch";
 import { z } from "zod";
-import { getCurrent, tombstone } from "../db/files.ts";
-import { HelpfulError } from "../errors.ts";
+import { listAllCurrentPaths, tombstone } from "../db/files.ts";
+import { asHelpful, HelpfulError } from "../errors.ts";
+import { isGlob } from "../ingest/source-resolver.ts";
 import { colors } from "../output/formatter.ts";
 import { defineOperation } from "./types.ts";
 
@@ -8,28 +10,85 @@ export const removeOperation = defineOperation({
 	name: "membot_delete",
 	cliName: "rm",
 	bashEquivalent: "rm",
-	description: `Tombstone a logical_path so it no longer appears in membot_list / membot_tree / membot_search. Old versions remain queryable via membot_versions and membot_read with an explicit version. Use membot_prune to permanently drop history.`,
+	description: `Tombstone one or more logical_paths so they no longer appear in membot_list / membot_tree / membot_search. Each \`paths\` arg is independently treated as either a literal logical_path or a glob pattern (e.g. "docs/**/*.md"); globs are matched against current logical_paths in the DB, not the filesystem. The union of matches is deduplicated, then tombstoned one at a time — partial failures are reported per-entry without aborting the rest. An input arg that matches zero current files is an error (the response includes which arg). Old versions remain queryable via membot_versions and membot_read with an explicit version. Use membot_prune to permanently drop history.`,
 	inputSchema: z.object({
-		logical_path: z.string().describe("Path to tombstone"),
+		paths: z
+			.array(z.string())
+			.min(1)
+			.describe(
+				'One or more logical_paths or glob patterns (e.g. "docs/**/*.md"). Each arg is matched independently against current logical_paths in the DB.',
+			),
 		change_note: z.string().optional().describe("Why this is being deleted"),
 	}),
 	outputSchema: z.object({
-		logical_path: z.string(),
-		tombstone_version_id: z.string(),
+		removed: z.array(
+			z.object({
+				logical_path: z.string(),
+				version_id: z.string().nullable(),
+				status: z.enum(["ok", "failed"]),
+				error: z.string().optional(),
+			}),
+		),
+		total: z.number(),
+		ok: z.number(),
+		failed: z.number(),
 	}),
-	cli: { positional: ["logical_path"], aliases: { change_note: "-m" } },
-	console_formatter: (result) =>
-		`${colors.green("✓")} tombstoned ${colors.cyan(result.logical_path)} ${colors.dim(`@ ${result.tombstone_version_id}`)}`,
+	cli: { positional: ["paths"], aliases: { change_note: "-m" } },
+	console_formatter: (result) => {
+		const lines = result.removed.map((e) =>
+			e.status === "ok"
+				? `${colors.green("✓")} tombstoned ${colors.cyan(e.logical_path)} ${colors.dim(`@ ${e.version_id}`)}`
+				: `${colors.red("✗")} ${e.logical_path} ${colors.dim(e.error ?? "")}`,
+		);
+		const summary = result.failed
+			? `${colors.green(`removed ${result.ok}`)}, ${colors.red(`failed ${result.failed}`)}`
+			: colors.green(`removed ${result.ok}`);
+		return `${lines.join("\n")}\n${summary}`;
+	},
 	handler: async (input, ctx) => {
-		const cur = await getCurrent(ctx.db, input.logical_path);
-		if (!cur) {
-			throw new HelpfulError({
-				kind: "not_found",
-				message: `${input.logical_path} doesn't exist (or is already tombstoned)`,
-				hint: `Run \`membot ls\` to see active paths, or \`membot versions ${input.logical_path}\` to see history.`,
-			});
+		const currentPaths = await listAllCurrentPaths(ctx.db);
+		const currentSet = new Set(currentPaths);
+		const targets = new Set<string>();
+
+		for (const arg of input.paths) {
+			const matches: string[] = [];
+			if (isGlob(arg)) {
+				const isMatch = picomatch(arg, { dot: true });
+				for (const p of currentPaths) {
+					if (isMatch(p)) matches.push(p);
+				}
+			} else if (currentSet.has(arg)) {
+				matches.push(arg);
+			}
+			if (matches.length === 0) {
+				throw new HelpfulError({
+					kind: "not_found",
+					message: `no current files match \`${arg}\``,
+					hint: "Run `membot ls` to see active paths, or pass a different glob.",
+				});
+			}
+			for (const m of matches) targets.add(m);
 		}
-		const v = await tombstone(ctx.db, input.logical_path, input.change_note ?? "deleted");
-		return { logical_path: input.logical_path, tombstone_version_id: v };
+
+		const note = input.change_note ?? "deleted";
+		const removed: { logical_path: string; version_id: string | null; status: "ok" | "failed"; error?: string }[] = [];
+		for (const path of targets) {
+			try {
+				const versionId = await tombstone(ctx.db, path, note);
+				removed.push({ logical_path: path, version_id: versionId, status: "ok" });
+			} catch (err) {
+				const helpful = asHelpful(err, `while tombstoning ${path}`, "Re-run with --verbose to see the cause.");
+				removed.push({
+					logical_path: path,
+					version_id: null,
+					status: "failed",
+					error: helpful.message,
+				});
+			}
+		}
+
+		const ok = removed.filter((r) => r.status === "ok").length;
+		const failed = removed.length - ok;
+		return { removed, total: removed.length, ok, failed };
 	},
 });

package/src/operations/search.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { HelpfulError } from "../errors.ts";
 import { embedSingle } from "../ingest/embedder.ts";
 import { colors } from "../output/formatter.ts";
 import { fuseRRF } from "../search/hybrid.ts";
@@ -52,6 +53,14 @@ export const searchOperation = defineOperation({
 		const query = input.query ?? input.pattern ?? "";
 		const pattern = input.pattern ?? input.query ?? "";
 
+		if (!query.trim() && !pattern.trim()) {
+			throw new HelpfulError({
+				kind: "input_error",
+				message: "search requires a query or pattern",
+				hint: 'Pass a natural-language query (e.g. `membot search "oauth flow"`) or a keyword pattern (e.g. `membot search --pattern OAuth`).',
+			});
+		}
+
 		const semanticHits =
 			input.mode === "keyword" || !query.trim()
 				? []