mnotes-cli 1.9.0 → 1.9.1

package/dist/client.d.ts

@@ -72,6 +72,26 @@ export declare function createClient(baseUrl: string, apiKey: string): {
             isDefault: boolean;
         }>;
     }>;
+    recallKnowledge(opts: {
+        query: string;
+        workspaceId?: string;
+        tags?: string[];
+        limit?: number;
+    }): Promise<{
+        data: {
+            results: Array<{
+                id: string;
+                title: string;
+                key: string | null;
+                excerpt: string;
+                importance: number | null;
+                tags: string[];
+                semanticScore: number;
+                freshnessScore: number;
+                finalScore: number;
+            }>;
+        };
+    }>;
     queryGraph(opts?: {
         workspaceId?: string;
         query?: string;

package/dist/client.js

@@ -51,6 +51,14 @@ function createClient(baseUrl, apiKey) {
         async listWorkspaces() {
             return request("GET", "/api/v1/workspaces");
         },
+        async recallKnowledge(opts) {
+            return request("POST", "/api/v1/knowledge/recall", {
+                query: opts.query,
+                workspaceId: opts.workspaceId,
+                tags: opts.tags,
+                limit: opts.limit,
+            });
+        },
         async queryGraph(opts) {
             const params = new URLSearchParams();
             if (opts?.workspaceId)

package/dist/commands/recall-knowledge.js

@@ -7,30 +7,55 @@ 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")
+        .description("Query knowledge entries via semantic search (read-only)")
+        .option("--query <text>", "Search query (required for semantic recall)")
+        .option("--tags <tags>", "Filter by tags (comma-separated)")
+        .option("--limit <n>", "Max results (default 10)", "10")
+        .option("--graph", "Query the knowledge graph (GraphNode/GraphEdge) instead of semantic recall")
+        .option("--type <type>", "Node type filter (graph mode only): note, tag, concept")
+        .option("--neighbors <nodeId>", "Show neighbors of a node (graph mode only)")
+        .option("--depth <n>", "Neighbor traversal depth 1-3 (graph mode only)", "1")
         .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,
+        const workspaceId = opts.workspaceId || config.workspaceId;
+        // Graph mode
+        if (opts.graph) {
+            const result = await client.queryGraph({
+                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);
+            }
+            return;
+        }
+        // Semantic recall mode (default)
+        if (!opts.query) {
+            process.stderr.write("Error: --query is required for semantic recall. Use --graph for graph queries without a query.\n");
+            process.exit(1);
+        }
+        const tags = opts.tags ? opts.tags.split(",").map((t) => t.trim()) : undefined;
+        const result = await client.recallKnowledge({
             query: opts.query,
-            nodeType: opts.type,
-            neighbors: opts.neighbors,
-            depth: opts.depth ? parseInt(opts.depth, 10) : undefined,
+            workspaceId,
+            tags,
             limit: opts.limit ? parseInt(opts.limit, 10) : undefined,
         });
         if (globalOpts.json) {
-            (0, output_1.printJson)(result.data);
+            (0, output_1.printJson)(result.data.results);
         }
         else {
-            (0, output_1.printGraph)(result.data.nodes, result.data.edges);
+            (0, output_1.printKnowledgeResults)(result.data.results);
         }
     });
 }

package/dist/output.d.ts

@@ -14,6 +14,17 @@ export declare function printSearchResults(results: Array<{
     title: string;
     snippet?: string;
 }>): void;
+export declare function printKnowledgeResults(results: Array<{
+    id: string;
+    title: string;
+    key: string | null;
+    excerpt: string;
+    importance: number | null;
+    tags: string[];
+    semanticScore: number;
+    freshnessScore: number;
+    finalScore: number;
+}>): void;
 export declare function printGraph(nodes: Array<{
     id: string;
     noteId: string | null;

package/dist/output.js

@@ -4,6 +4,7 @@ exports.printJson = printJson;
 exports.printNoteList = printNoteList;
 exports.printNote = printNote;
 exports.printSearchResults = printSearchResults;
+exports.printKnowledgeResults = printKnowledgeResults;
 exports.printGraph = printGraph;
 exports.printSuccess = printSuccess;
 function printJson(data) {
@@ -43,6 +44,28 @@ function printSearchResults(results) {
         }
     }
 }
+function printKnowledgeResults(results) {
+    if (results.length === 0) {
+        process.stderr.write("No knowledge entries found.\n");
+        return;
+    }
+    for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const score = (r.finalScore * 100).toFixed(0);
+        const key = r.key ? ` [${r.key}]` : "";
+        const tags = r.tags.length > 0 ? ` (${r.tags.join(", ")})` : "";
+        const importance = r.importance !== null ? ` imp:${r.importance}` : "";
+        console.log(`${i + 1}. ${r.title}${key}  ${score}%${importance}${tags}`);
+        if (r.excerpt) {
+            const lines = r.excerpt.split("\n").slice(0, 3).join("\n   ");
+            console.log(`   ${lines}`);
+        }
+        if (i < results.length - 1)
+            console.log("");
+    }
+    console.log("");
+    console.log(`${results.length} result(s)`);
+}
 function printGraph(nodes, edges) {
     if (nodes.length === 0) {
         process.stderr.write("Knowledge graph is empty.\n");

package/package.json

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