mnotes-cli 1.7.1 → 1.9.0

package/dist/client.d.ts

@@ -72,6 +72,31 @@ export declare function createClient(baseUrl: string, apiKey: string): {
             isDefault: boolean;
         }>;
     }>;
+    queryGraph(opts?: {
+        workspaceId?: string;
+        query?: string;
+        nodeType?: string;
+        neighbors?: string;
+        depth?: number;
+        limit?: number;
+    }): Promise<{
+        data: {
+            nodes: Array<{
+                id: string;
+                noteId: string | null;
+                label: string;
+                nodeType: string;
+                depth?: number;
+            }>;
+            edges: Array<{
+                id: string;
+                sourceId: string;
+                targetId: string;
+                edgeType: string;
+                weight: number;
+            }>;
+        };
+    }>;
     createWorkspace(name: string): Promise<{
         data: {
             id: string;

package/dist/client.js

@@ -51,6 +51,23 @@ function createClient(baseUrl, apiKey) {
         async listWorkspaces() {
             return request("GET", "/api/v1/workspaces");
         },
+        async queryGraph(opts) {
+            const params = new URLSearchParams();
+            if (opts?.workspaceId)
+                params.set("workspaceId", opts.workspaceId);
+            if (opts?.query)
+                params.set("query", opts.query);
+            if (opts?.nodeType)
+                params.set("nodeType", opts.nodeType);
+            if (opts?.neighbors)
+                params.set("neighbors", opts.neighbors);
+            if (opts?.depth)
+                params.set("depth", String(opts.depth));
+            if (opts?.limit)
+                params.set("limit", String(opts.limit));
+            const qs = params.toString();
+            return request("GET", `/api/v1/graph${qs ? `?${qs}` : ""}`);
+        },
         async createWorkspace(name) {
             return request("POST", "/api/v1/workspaces", { name });
         },

package/dist/commands/recall-knowledge.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerRecallKnowledgeCommand(program: Command): void;

package/dist/commands/recall-knowledge.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRecallKnowledgeCommand = registerRecallKnowledgeCommand;
+const config_1 = require("../config");
+const client_1 = require("../client");
+const output_1 = require("../output");
+function registerRecallKnowledgeCommand(program) {
+    program
+        .command("recall_knowledge")
+        .description("Query the knowledge graph (read-only)")
+        .option("--query <text>", "Filter nodes by label (case-insensitive)")
+        .option("--type <type>", "Filter by node type: note, tag, concept")
+        .option("--neighbors <nodeId>", "Show neighbors of a specific node")
+        .option("--depth <n>", "Neighbor traversal depth (1-3, default 1)", "1")
+        .option("--limit <n>", "Max nodes to return (default 50)", "50")
+        .option("--workspace-id <id>", "Workspace ID")
+        .action(async (opts) => {
+        const globalOpts = program.opts();
+        const config = (0, config_1.resolveConfig)(globalOpts);
+        const client = (0, client_1.createClient)(config.baseUrl, config.apiKey);
+        const result = await client.queryGraph({
+            workspaceId: opts.workspaceId || config.workspaceId,
+            query: opts.query,
+            nodeType: opts.type,
+            neighbors: opts.neighbors,
+            depth: opts.depth ? parseInt(opts.depth, 10) : undefined,
+            limit: opts.limit ? parseInt(opts.limit, 10) : undefined,
+        });
+        if (globalOpts.json) {
+            (0, output_1.printJson)(result.data);
+        }
+        else {
+            (0, output_1.printGraph)(result.data.nodes, result.data.edges);
+        }
+    });
+}

package/dist/index.js

@@ -11,6 +11,7 @@ const delete_1 = require("./commands/delete");
 const connect_1 = require("./commands/connect");
 const login_1 = require("./commands/login");
 const workspace_1 = require("./commands/workspace");
+const recall_knowledge_1 = require("./commands/recall-knowledge");
 const program = new commander_1.Command();
 program
     .name("mnotes")
@@ -28,6 +29,7 @@ program
 (0, connect_1.registerConnectCommand)(program);
 (0, login_1.registerLoginCommand)(program);
 (0, workspace_1.registerWorkspaceCommand)(program);
+(0, recall_knowledge_1.registerRecallKnowledgeCommand)(program);
 program.parseAsync(process.argv).catch((err) => {
     process.stderr.write(`Error: ${err.message}\n`);
     process.exit(1);

package/dist/output.d.ts

@@ -14,4 +14,17 @@ export declare function printSearchResults(results: Array<{
     title: string;
     snippet?: string;
 }>): void;
+export declare function printGraph(nodes: Array<{
+    id: string;
+    noteId: string | null;
+    label: string;
+    nodeType: string;
+    depth?: number;
+}>, edges: Array<{
+    id: string;
+    sourceId: string;
+    targetId: string;
+    edgeType: string;
+    weight: number;
+}>): void;
 export declare function printSuccess(msg: string): void;

package/dist/output.js

@@ -4,6 +4,7 @@ exports.printJson = printJson;
 exports.printNoteList = printNoteList;
 exports.printNote = printNote;
 exports.printSearchResults = printSearchResults;
+exports.printGraph = printGraph;
 exports.printSuccess = printSuccess;
 function printJson(data) {
     console.log(JSON.stringify(data, null, 2));
@@ -42,6 +43,34 @@ function printSearchResults(results) {
         }
     }
 }
+function printGraph(nodes, edges) {
+    if (nodes.length === 0) {
+        process.stderr.write("Knowledge graph is empty.\n");
+        return;
+    }
+    const idWidth = Math.max(4, ...nodes.map((n) => n.id.length));
+    const typeWidth = Math.max(4, ...nodes.map((n) => n.nodeType.length));
+    const labelWidth = Math.min(50, Math.max(5, ...nodes.map((n) => n.label.length)));
+    console.log(`${"ID".padEnd(idWidth)}  ${"TYPE".padEnd(typeWidth)}  LABEL`);
+    for (const node of nodes) {
+        const label = node.label.length > labelWidth
+            ? node.label.substring(0, labelWidth - 1) + "…"
+            : node.label;
+        const depthSuffix = node.depth !== undefined && node.depth > 0 ? `  (depth ${node.depth})` : "";
+        console.log(`${node.id.padEnd(idWidth)}  ${node.nodeType.padEnd(typeWidth)}  ${label}${depthSuffix}`);
+    }
+    if (edges.length > 0) {
+        console.log("");
+        console.log(`Edges (${edges.length}):`);
+        for (const edge of edges) {
+            const srcLabel = nodes.find((n) => n.id === edge.sourceId)?.label ?? edge.sourceId;
+            const tgtLabel = nodes.find((n) => n.id === edge.targetId)?.label ?? edge.targetId;
+            console.log(`  ${srcLabel} --[${edge.edgeType}]--> ${tgtLabel}`);
+        }
+    }
+    console.log("");
+    console.log(`${nodes.length} node(s), ${edges.length} edge(s)`);
+}
 function printSuccess(msg) {
     process.stderr.write(`${msg}\n`);
 }

package/dist/templates/claude-code.js

@@ -65,6 +65,46 @@ m-notes is not just a knowledge base — it's a full note-taking system. **Use n
 
 **When in doubt, create a note.** Notes are searchable, linkable, and visible in the UI.
 
+## Knowledge Graph — Build Structured Memory
+
+Beyond flat knowledge entries, you have a **knowledge graph** for structured relationships between concepts. Use it to map how things connect — architecture components, dependencies, decisions, and patterns.
+
+### When to Build the Graph
+- **Session start**: If the graph is empty, call \`populate_graph\` to initialize from existing notes and wikilinks.
+- **Architecture decisions**: Create concept nodes for components, link them with "related" or "parent" edges.
+- **Dependency discovery**: Create nodes for packages, link to the components that use them.
+- **Bug investigations**: Link bug nodes to the components and patterns involved.
+- **Any time you see a relationship**: If A relates to B, create an edge. The graph gets more valuable over time.
+
+### Graph Tools
+| Tool | When to use |
+|------|------------|
+| \`populate_graph\` | Initialize graph from existing notes (idempotent, safe to re-run) |
+| \`create_node\` | Create a concept, tag, or note-linked node |
+| \`create_edge\` | Link two nodes (types: wikilink, related, parent, tagged, custom) |
+| \`query_graph\` | Search the graph by node type, label, or connectivity |
+| \`get_neighbors\` | Explore nodes connected to a specific node |
+| \`query_note_graph\` | Get the connection subgraph around a note |
+
+### Node Types
+- **note** — linked to an existing note (set \`noteId\`)
+- **tag** — represents a tag or category
+- **concept** — free-form concept (architecture component, pattern, decision)
+
+### Edge Types
+- **wikilink** — note links to another note
+- **related** — general relationship
+- **parent** — hierarchical (component contains sub-component)
+- **tagged** — node is tagged with a category
+- **custom** — any other relationship (describe in metadata)
+
+### Example: Mapping Architecture
+\`\`\`
+create_node({ label: "Auth Module", nodeType: "concept", workspaceId: "..." })
+create_node({ label: "PostgreSQL", nodeType: "concept", workspaceId: "..." })
+create_edge({ sourceId: authNodeId, targetId: pgNodeId, edgeType: "related", workspaceId: "..." })
+\`\`\`
+
 ## MCP Tools Reference
 
 ### Session & Context
@@ -104,5 +144,15 @@ m-notes is not just a knowledge base — it's a full note-taking system. **Use n
 | \`move_note\` | Move note to a different folder |
 | \`context_fetch\` | Search notes by query |
 
+### Knowledge Graph
+| Tool | When to use |
+|------|------------|
+| \`populate_graph\` | Initialize graph from notes (run once at start) |
+| \`create_node\` | Add a concept, tag, or note-linked node |
+| \`create_edge\` | Link two nodes with a typed relationship |
+| \`query_graph\` | Search graph by type, label, or connectivity |
+| \`get_neighbors\` | Explore connections from a node |
+| \`query_note_graph\` | Get subgraph around a specific note |
+
 All tools require \`workspaceId: "${opts.workspaceId}"\`.`;
 }

package/dist/templates/codex.js

@@ -31,6 +31,22 @@ Store discoveries, decisions, and patterns via \`knowledge_store\`:
 ### Session End
 Call \`session_log\` with workspaceId "${opts.workspaceId}", a summary, decisions, and actions.
 
+## Knowledge Graph
+
+Build structured relationships between concepts as you work. The graph maps how architecture components, dependencies, decisions, and patterns connect.
+
+### When to Build
+- Session start: call \`populate_graph\` if graph is empty (idempotent)
+- When you discover relationships between components, patterns, or decisions: create nodes and edges
+- Architecture decisions: create concept nodes, link with "related" or "parent" edges
+
+### Node types: note, tag, concept
+### Edge types: wikilink, related, parent, tagged, custom
+
+Example:
+  create_node({ label: "Auth Module", nodeType: "concept", workspaceId: "${opts.workspaceId}" })
+  create_edge({ sourceId: "...", targetId: "...", edgeType: "related", workspaceId: "${opts.workspaceId}" })
+
 ## Available MCP Tools
 - project_context_load -- load project context at session start
 - session_context_resume -- resume from previous session
@@ -39,5 +55,10 @@ Call \`session_log\` with workspaceId "${opts.workspaceId}", a summary, decision
 - bulk_knowledge_recall -- recall by tag patterns
 - knowledge_snapshot -- export all knowledge
 - session_log -- log session summary
-- context_fetch -- search notes by query`;
+- context_fetch -- search notes by query
+- populate_graph -- initialize knowledge graph from notes
+- create_node -- add a concept/tag/note node to the graph
+- create_edge -- link two nodes with a typed relationship
+- query_graph -- search graph by type, label, or connectivity
+- get_neighbors -- explore connections from a node`;
 }

package/dist/templates/openclaw.js

@@ -31,10 +31,35 @@ Call recall_knowledge with:
 - \`bug/{id}\` -- bug investigations
 - \`pattern/{name}\` -- code patterns
 
+## Knowledge Graph
+
+Build structured relationships as you work:
+\`\`\`
+Call populate_graph with:
+  - workspaceId: "${opts.workspaceId}"
+(initializes graph from existing notes — run once)
+
+Call create_node with:
+  - label: "<concept name>"
+  - nodeType: "concept" (or "note", "tag")
+  - workspaceId: "${opts.workspaceId}"
+
+Call create_edge with:
+  - sourceId: "<node id>"
+  - targetId: "<node id>"
+  - edgeType: "related" (or "parent", "tagged", "custom")
+  - workspaceId: "${opts.workspaceId}"
+\`\`\`
+
 ## Available MCP Tools
 - \`knowledge_store\` -- Store knowledge entries
 - \`recall_knowledge\` -- Semantic search for knowledge
 - \`bulk_knowledge_recall\` -- Recall by tag patterns
 - \`knowledge_snapshot\` -- Export all knowledge
-- \`context_fetch\` -- Search notes by query`;
+- \`context_fetch\` -- Search notes by query
+- \`populate_graph\` -- Initialize knowledge graph from notes
+- \`create_node\` -- Add concept/tag/note node to the graph
+- \`create_edge\` -- Link two nodes with a typed relationship
+- \`query_graph\` -- Search graph by type, label, or connectivity
+- \`get_neighbors\` -- Explore connections from a node`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mnotes-cli",
-  "version": "1.7.1",
+  "version": "1.9.0",
   "description": "CLI for m-notes AI knowledge base — manage notes, search, and CRUD from the terminal",
   "bin": {
     "mnotes": "./dist/index.js"