ex-brain 0.4.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ex-brain",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "CLI personal knowledge base powered by seekdb",
   "module": "src/cli.ts",
   "type": "module",

package/src/commands/graph-cmd.ts

@@ -11,6 +11,20 @@ interface GraphNode {
   group: string;
 }
 
+/**
+ * Normalize a type value.  Slug-like values (no `/` in the original slug,
+ * contain `_`, or start with digits) are mapped to "article" so the filter
+ * panel doesn't list every individual document as its own type.
+ */
+function normalizeType(rawType: string, slug: string): string {
+  // If the raw type equals the slug's basename, it was inferred from a flat slug
+  const baseName = slug.includes("/") ? slug.split("/").pop()! : slug;
+  if (rawType === baseName || /^\d/.test(rawType) || rawType.startsWith("rm_")) {
+    return "article";
+  }
+  return rawType;
+}
+
 interface GraphEdge {
   from: string;
   to: string;
@@ -43,7 +57,8 @@ async function getGraphData(repo: BrainRepository): Promise<GraphData> {
   
   // Create nodes from pages
   for (const page of pages) {
-    const type = page.type || "other";
+    const rawType = page.type || "other";
+    const type = normalizeType(rawType, page.slug);
     typeCounts[type] = (typeCounts[type] || 0) + 1;
     
     nodes.push({
@@ -693,6 +708,10 @@ function getGraphHtml(): string {
         const response = await fetch('/api/graph');
         graphData = await response.json();
         
+        // Precompute node type map for O(1) edge visibility check
+        nodeTypeMap = new Map();
+        graphData.nodes.forEach(n => nodeTypeMap.set(n.id, n.type));
+        
         updateStats();
         renderFilters();
         renderNodeList();
@@ -837,22 +856,29 @@ function getGraphHtml(): string {
       });
     }
 
+    // Node type lookup for O(1) edge visibility check
+    let nodeTypeMap = new Map();
+
     function updateNetworkVisibility() {
       if (!nodes) return;
       
-      graphData.nodes.forEach(node => {
-        const visible = activeTypes.has(node.type);
-        nodes.update({ id: node.id, hidden: !visible });
-      });
+      // Batch update nodes
+      const nodeUpdates = graphData.nodes.map(node => ({
+        id: node.id,
+        hidden: !activeTypes.has(node.type),
+      }));
+      nodes.update(nodeUpdates);
       
-      // Also hide edges connected to hidden nodes
-      graphData.edges.forEach(edge => {
-        const fromNode = graphData.nodes.find(n => n.id === edge.from);
-        const toNode = graphData.nodes.find(n => n.id === edge.to);
-        const visible = fromNode && toNode && 
-          activeTypes.has(fromNode.type) && activeTypes.has(toNode.type);
-        edges.update({ id: edge.from + '->' + edge.to, hidden: !visible });
+      // Batch update edges with O(1) lookup
+      const edgeUpdates = graphData.edges.map(edge => {
+        const fromType = nodeTypeMap.get(edge.from);
+        const toType = nodeTypeMap.get(edge.to);
+        return {
+          id: edge.from + '->' + edge.to,
+          hidden: !activeTypes.has(fromType) || !activeTypes.has(toType),
+        };
       });
+      edges.update(edgeUpdates);
     }
 
     async function selectNode(slug) {

package/src/commands/put-cmd.ts

@@ -498,10 +498,12 @@ Examples:
     )
     .action(async (opts: Record<string, string | undefined>) => {
       await withRepo(program, async (repo) => {
+        const rawLimit = Number(opts.limit ?? 50);
+        const limit = (Number.isFinite(rawLimit) && rawLimit > 0) ? rawLimit : 50;
         const rows = await repo.listPages({
           type: opts.type,
           tag: opts.tag,
-          limit: Number(opts.limit),
+          limit,
         });
 
         // When --fields is set, show one page per line with tab-separated values
@@ -516,9 +518,16 @@ Examples:
             });
             console.log(vals.join("\t"));
           }
+          // Show count for tabular output too
+          if (!isJson(program) && rows.length >= limit) {
+            process.stderr.write(`\nShowing ${rows.length} page(s) (use --limit to show more)\n`);
+          }
           return;
         }
 
+        if (!isJson(program) && rows.length >= limit) {
+          process.stderr.write(`Showing ${rows.length} page(s) (use --limit to show more)\n`);
+        }
         print(program, rows);
       });
     });

package/src/repositories/brain-repo.ts

@@ -125,7 +125,11 @@ export class BrainRepository {
     limit?: number;
   }): Promise<PageRecord[]> {
     try {
-      const limit = filters.limit ?? 50;
+      // Safe default: use 50 if limit is missing, NaN, non-finite, or <= 0
+      const rawLimit = filters.limit;
+      const limit = (typeof rawLimit === 'number' && Number.isFinite(rawLimit) && rawLimit > 0)
+        ? rawLimit
+        : 50;
       const params: unknown[] = [];
       let sql = `SELECT p.slug, p.type, p.title, p.compiled_truth, p.timeline, p.frontmatter, p.created_at, p.updated_at
                  FROM pages p`;

package/src/slug-utils.ts

@@ -17,8 +17,19 @@ export function slugToTitle(slug: string): string {
     .join(" ");
 }
 
+/**
+ * Infer page type from slug path.
+ * - Slugs with a path prefix (e.g. "notes/my-post") → use the prefix as type
+ * - Flat slugs without "/" (e.g. "26_05_20_xxx" or "rm_hui_yi_ji_yao_0325") → default to "article"
+ * - Fallback to "other" if empty
+ */
 export function inferTypeFromSlug(slug: string): string {
-  return slug.split("/")[0] ?? "other";
+  const segments = slug.split("/");
+  if (segments.length > 1 && segments[0]) {
+    return segments[0];
+  }
+  // Flat slug — treat as a generic article/note
+  return "article";
 }
 
 /**