mnotes-cli 1.7.0 → 1.8.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/connect/index.js

@@ -40,6 +40,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const config_utils_1 = require("./config-utils");
 const workspace_prompt_1 = require("./workspace-prompt");
+const config_1 = require("../../config");
 const claude_code_1 = require("../../templates/claude-code");
 const codex_1 = require("../../templates/codex");
 const openclaw_1 = require("../../templates/openclaw");
@@ -91,11 +92,11 @@ function printConnectionStatus() {
  * prompts interactively after validating the connection.
  */
 async function resolveWorkspace(opts) {
-    // AC-5: --workspace flag works as before
-    const fromFlag = opts.workspace || process.env.MNOTES_WORKSPACE_ID;
-    if (fromFlag)
-        return fromFlag;
-    // AC-1/AC-2/AC-3/AC-4: Interactive workspace selection/creation
+    // Check flag, env, dir map, global config
+    const fromConfig = (0, config_1.resolveConfig)({ workspaceId: opts.workspace });
+    if (fromConfig.workspaceId)
+        return fromConfig.workspaceId;
+    // Nothing stored — interactive selection/creation
     const resolved = await (0, workspace_prompt_1.resolveWorkspaceInteractively)(opts.url, opts.apiKey);
     return resolved.id;
 }
@@ -110,12 +111,9 @@ function normalizeBaseUrl(raw) {
     return raw.replace(/\/+$/, "").replace(/\/api\/mcp$/i, "");
 }
 async function handleClaudeCode(opts) {
-    const url = normalizeBaseUrl(opts.url || process.env.MNOTES_URL || "https://mnotes.framework.by");
-    const apiKey = opts.apiKey || process.env.MNOTES_API_KEY;
-    if (!apiKey) {
-        process.stderr.write("Error: API key required. Use --api-key or set MNOTES_API_KEY\n");
-        process.exit(1);
-    }
+    const config = (0, config_1.resolveConfig)(opts);
+    const url = normalizeBaseUrl(config.baseUrl);
+    const apiKey = config.apiKey;
     const validation = await (0, config_utils_1.validateConnection)(url, apiKey);
     if (!validation.ok) {
         process.stderr.write(`Error: Cannot connect to ${url}: ${validation.error}\n`);
@@ -179,12 +177,9 @@ function printScaffoldResults(results) {
  * Handles the `codex` integration target.
  */
 async function handleCodex(opts) {
-    const url = normalizeBaseUrl(opts.url || process.env.MNOTES_URL || "https://mnotes.framework.by");
-    const apiKey = opts.apiKey || process.env.MNOTES_API_KEY;
-    if (!apiKey) {
-        process.stderr.write("Error: API key required. Use --api-key or set MNOTES_API_KEY\n");
-        process.exit(1);
-    }
+    const config = (0, config_1.resolveConfig)(opts);
+    const url = normalizeBaseUrl(config.baseUrl);
+    const apiKey = config.apiKey;
     const validation = await (0, config_utils_1.validateConnection)(url, apiKey);
     if (!validation.ok) {
         process.stderr.write(`Error: Cannot connect to ${url}: ${validation.error}\n`);
@@ -216,13 +211,10 @@ async function handleCodex(opts) {
  * Handles the `openclaw` integration target.
  */
 async function handleOpenClaw(opts) {
-    const url = normalizeBaseUrl(opts.url || process.env.MNOTES_URL || "https://mnotes.framework.by");
-    const apiKey = opts.apiKey || process.env.MNOTES_API_KEY;
+    const config = (0, config_1.resolveConfig)(opts);
+    const url = normalizeBaseUrl(config.baseUrl);
+    const apiKey = config.apiKey;
     const configPath = opts.configPath || path.join(process.env.HOME || "~", ".openclaw", "mcp.json");
-    if (!apiKey) {
-        process.stderr.write("Error: API key required. Use --api-key or set MNOTES_API_KEY\n");
-        process.exit(1);
-    }
     const validation = await (0, config_utils_1.validateConnection)(url, apiKey);
     if (!validation.ok) {
         process.stderr.write(`Error: Cannot connect to ${url}: ${validation.error}\n`);

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/package.json

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