membot 0.2.0 → 0.2.1

package/.claude/skills/membot.md

@@ -110,7 +110,7 @@ Tombstones hide a path from `ls` / `tree` / `search` but `versions` and `read --
 | ------------------------------------- | ------------------------------------------------------------------------------ |
 | `membot add <source>`                 | Ingest file, directory, glob, URL, 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                                       |
+| `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)                    |
 | `membot write <path> --content <txt>` | Write inline agent-authored markdown as a new version                          |
 | `membot search <query>`               | Hybrid search (semantic + BM25); add `--include-history` to search older versions |

package/.cursor/rules/membot.mdc

@@ -110,7 +110,7 @@ Tombstones hide a path from `ls` / `tree` / `search` but `versions` and `read --
 | ------------------------------------- | ------------------------------------------------------------------------------ |
 | `membot add <source>`                 | Ingest file, directory, glob, URL, 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                                       |
+| `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)                    |
 | `membot write <path> --content <txt>` | Write inline agent-authored markdown as a new version                          |
 | `membot search <query>`               | Hybrid search (semantic + BM25); add `--include-history` to search older versions |

package/README.md

@@ -52,7 +52,7 @@ The skill files describe the discover → ingest → search → read → write w
 | ------------------------------- | --------------------------------------------------------------------------------- |
 | `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 ls [prefix]`            | List current files (size, mime, refresh status)                                   |
-| `membot tree [prefix]`          | Render the synthesised logical-path tree                                          |
+| `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)             |
 | `membot search <query>`         | Hybrid search (semantic + BM25); `--include-history` searches older versions      |
 | `membot info <path>`            | Inspect metadata (source, fetcher, schedule, digests) without content             |

package/package.json

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

package/src/operations/tree.ts

@@ -8,6 +8,7 @@ interface TreeNode {
 	full_path: string;
 	is_file: boolean;
 	children?: TreeNode[];
+	children_truncated?: number;
 }
 
 export const treeOperation = defineOperation({
@@ -18,6 +19,10 @@ export const treeOperation = defineOperation({
 	inputSchema: z.object({
 		prefix: z.string().optional().describe("Only show paths starting with this prefix"),
 		max_depth: z.number().default(4).describe("How many path segments deep to render"),
+		max_items: z
+			.number()
+			.default(20)
+			.describe("Max children to render at each level; remainder is summarised as '+N more'"),
 	}),
 	outputSchema: z.object({
 		root: z.string(),
@@ -27,21 +32,30 @@ export const treeOperation = defineOperation({
 				full_path: z.string(),
 				is_file: z.boolean(),
 				children: z.array(z.unknown()).optional(),
+				children_truncated: z.number().optional(),
 			}),
 		),
+		truncated: z.number().optional(),
 	}),
 	cli: { positional: ["prefix"] },
 	console_formatter: (result) => {
 		const lines: string[] = [colors.bold(result.root)];
 		const nodes = result.tree as TreeNode[];
-		renderNodes(nodes, "", lines);
+		const topTruncated = (result as { truncated?: number }).truncated ?? 0;
+		renderNodes(nodes, "", lines, topTruncated);
 		if (lines.length === 1) lines.push(colors.dim("(empty)"));
 		return lines.join("\n");
 	},
 	handler: async (input, ctx) => {
 		const allPaths = await listAllCurrentPaths(ctx.db);
 		const filtered = input.prefix ? allPaths.filter((p) => p.startsWith(input.prefix!)) : allPaths;
-		return { root: input.prefix ?? "/", tree: buildTree(filtered, input.max_depth) };
+		const tree = buildTree(filtered, input.max_depth);
+		const truncated = truncateTree(tree, input.max_items);
+		return {
+			root: input.prefix ?? "/",
+			tree,
+			...(truncated > 0 ? { truncated } : {}),
+		};
 	},
 });
 
@@ -50,9 +64,10 @@ export const treeOperation = defineOperation({
  * Splits each path into segments and groups by common prefix. Segments
  * deeper than `maxDepth` are folded into the deepest visible ancestor —
  * that ancestor is marked `is_file=true` so the renderer surfaces it as a
- * leaf even though longer paths exist underneath.
+ * leaf even though longer paths exist underneath. Children are sorted by
+ * name within each level so downstream truncation is deterministic.
  */
-function buildTree(paths: string[], maxDepth: number): TreeNode[] {
+export function buildTree(paths: string[], maxDepth: number): TreeNode[] {
 	interface MutableNode {
 		name: string;
 		full_path: string;
@@ -90,19 +105,43 @@ function buildTree(paths: string[], maxDepth: number): TreeNode[] {
 	return finalize(root);
 }
 
+/**
+ * Trim each child list (and the root list) to `maxItems`, mutating in place.
+ * Returns the number of root entries dropped; per-node drops are recorded on
+ * `node.children_truncated`. Input is assumed pre-sorted (by `buildTree`) so
+ * "first N" is stable.
+ */
+export function truncateTree(nodes: TreeNode[], maxItems: number): number {
+	for (const node of nodes) {
+		if (node.children?.length) {
+			const dropped = truncateTree(node.children, maxItems);
+			if (dropped > 0) node.children_truncated = dropped;
+		}
+	}
+	if (nodes.length > maxItems) {
+		const dropped = nodes.length - maxItems;
+		nodes.length = maxItems;
+		return dropped;
+	}
+	return 0;
+}
+
 /**
  * Walk a tree and append `├── name` / `└── name` lines with proper continuation
- * prefixes. Directories are rendered in cyan-bold; files in plain text.
+ * prefixes. Directories are rendered in cyan-bold; files in plain text. When a
+ * level was truncated, a dim trailing `+N more` line is appended at that level.
  */
-function renderNodes(nodes: TreeNode[], prefix: string, out: string[]): void {
-	const sorted = [...nodes].sort((a, b) => a.name.localeCompare(b.name));
-	sorted.forEach((node, i) => {
-		const last = i === sorted.length - 1;
+function renderNodes(nodes: TreeNode[], prefix: string, out: string[], truncatedCount = 0): void {
+	nodes.forEach((node, i) => {
+		const last = i === nodes.length - 1 && truncatedCount === 0;
 		const branch = last ? "└── " : "├── ";
 		const label = node.is_file && !node.children?.length ? node.name : colors.cyan(colors.bold(node.name));
 		out.push(`${prefix}${branch}${label}`);
 		if (node.children?.length) {
-			renderNodes(node.children, prefix + (last ? "    " : "│   "), out);
+			renderNodes(node.children, prefix + (last ? "    " : "│   "), out, node.children_truncated ?? 0);
 		}
 	});
+	if (truncatedCount > 0) {
+		out.push(`${prefix}└── ${colors.dim(`+${truncatedCount} more`)}`);
+	}
 }