mnotes-cli 1.6.0 → 1.7.1

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/login.d.ts

@@ -4,6 +4,8 @@ export interface MnotesConfig {
     apiKey: string;
     serverUrl: string;
     workspaceId?: string;
+    /** Map of absolute directory path → workspace ID */
+    workspaces?: Record<string, string>;
 }
 export declare function configPath(): string;
 /**

package/dist/commands/login.js

@@ -62,10 +62,15 @@ function readConfig() {
         const raw = fs.readFileSync(configPath(), "utf-8");
         const parsed = JSON.parse(raw);
         if (typeof parsed.apiKey === "string" && typeof parsed.serverUrl === "string") {
+            let workspaces;
+            if (typeof parsed.workspaces === "object" && parsed.workspaces !== null && !Array.isArray(parsed.workspaces)) {
+                workspaces = parsed.workspaces;
+            }
             return {
                 apiKey: parsed.apiKey,
                 serverUrl: parsed.serverUrl,
                 workspaceId: typeof parsed.workspaceId === "string" ? parsed.workspaceId : undefined,
+                workspaces,
             };
         }
         return null;

package/dist/commands/workspace.js

@@ -45,6 +45,26 @@ function ask(rl, question) {
         });
     });
 }
+/** Save a directory → workspace mapping in config. */
+function saveDirectoryMapping(dir, workspaceId) {
+    const stored = (0, login_1.readConfig)();
+    if (!stored) {
+        process.stderr.write("Error: not logged in. Run `mnotes login` first.\n");
+        process.exit(1);
+    }
+    const workspaces = stored.workspaces ?? {};
+    workspaces[dir] = workspaceId;
+    (0, login_1.writeConfig)({ ...stored, workspaces });
+}
+/** Remove a directory → workspace mapping from config. */
+function removeDirectoryMapping(dir) {
+    const stored = (0, login_1.readConfig)();
+    if (!stored?.workspaces?.[dir])
+        return false;
+    delete stored.workspaces[dir];
+    (0, login_1.writeConfig)(stored);
+    return true;
+}
 function registerWorkspaceCommand(program) {
     const ws = program
         .command("workspace")
@@ -62,20 +82,25 @@ function registerWorkspaceCommand(program) {
             return;
         }
         const stored = (0, login_1.readConfig)();
-        const selectedId = stored?.workspaceId;
+        const cwd = process.cwd();
+        const dirMapped = stored?.workspaces?.[cwd];
+        const globalDefault = stored?.workspaceId;
         for (const w of workspaces) {
             const markers = [];
             if (w.isDefault)
                 markers.push("default");
-            if (w.id === selectedId)
-                markers.push("selected");
+            if (w.id === dirMapped)
+                markers.push("linked");
+            else if (w.id === globalDefault)
+                markers.push("global");
             const suffix = markers.length > 0 ? `  (${markers.join(", ")})` : "";
             console.log(`  ${w.name} [${w.slug}]${suffix}`);
         }
     });
     ws.command("select")
-        .description("Select default workspace (saved to config)")
-        .action(async () => {
+        .description("Select workspace for current directory (saved to config)")
+        .option("--global", "Set as global default instead of per-directory")
+        .action(async (opts) => {
         const globalOpts = program.opts();
         const config = (0, config_1.resolveConfig)(globalOpts);
         const client = (0, client_1.createClient)(config.baseUrl, config.apiKey);
@@ -86,7 +111,8 @@ function registerWorkspaceCommand(program) {
             return;
         }
         const stored = (0, login_1.readConfig)();
-        const selectedId = stored?.workspaceId;
+        const cwd = process.cwd();
+        const currentId = stored?.workspaces?.[cwd] || stored?.workspaceId;
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stderr,
@@ -95,7 +121,7 @@ function registerWorkspaceCommand(program) {
             process.stderr.write("\nWorkspaces:\n");
             for (let i = 0; i < workspaces.length; i++) {
                 const w = workspaces[i];
-                const marker = w.id === selectedId ? " *" : "";
+                const marker = w.id === currentId ? " *" : "";
                 process.stderr.write(`  ${i + 1}. ${w.name} [${w.slug}]${marker}\n`);
             }
             const answer = await ask(rl, `\nSelect workspace [1-${workspaces.length}]: `);
@@ -105,52 +131,138 @@ function registerWorkspaceCommand(program) {
                 process.exit(1);
             }
             const selected = workspaces[choice - 1];
-            const existing = stored ?? { apiKey: config.apiKey, serverUrl: config.baseUrl };
-            (0, login_1.writeConfig)({ ...existing, workspaceId: selected.id });
-            console.log(`Selected workspace: ${selected.name} [${selected.slug}]`);
+            if (opts.global) {
+                const existing = stored ?? { apiKey: config.apiKey, serverUrl: config.baseUrl };
+                (0, login_1.writeConfig)({ ...existing, workspaceId: selected.id });
+                console.log(`Global default workspace: ${selected.name} [${selected.slug}]`);
+            }
+            else {
+                saveDirectoryMapping(cwd, selected.id);
+                console.log(`Linked ${cwd} → ${selected.name} [${selected.slug}]`);
+            }
         }
         finally {
             rl.close();
         }
     });
-    ws.command("create <name>")
+    ws.command("link")
+        .description("Link current directory to a workspace")
+        .argument("[workspace-id]", "Workspace ID or slug (interactive if omitted)")
+        .action(async (workspaceIdOrSlug) => {
+        const globalOpts = program.opts();
+        const config = (0, config_1.resolveConfig)(globalOpts);
+        const client = (0, client_1.createClient)(config.baseUrl, config.apiKey);
+        const res = await client.listWorkspaces();
+        const workspaces = res.data;
+        if (workspaces.length === 0) {
+            console.log("No workspaces found. Create one with: mnotes workspace create <name>");
+            return;
+        }
+        const cwd = process.cwd();
+        let selected;
+        if (workspaceIdOrSlug) {
+            selected = workspaces.find((w) => w.id === workspaceIdOrSlug || w.slug === workspaceIdOrSlug);
+            if (!selected) {
+                process.stderr.write(`Error: workspace "${workspaceIdOrSlug}" not found.\n`);
+                process.exit(1);
+            }
+        }
+        else {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stderr,
+            });
+            try {
+                process.stderr.write("\nWorkspaces:\n");
+                for (let i = 0; i < workspaces.length; i++) {
+                    const w = workspaces[i];
+                    process.stderr.write(`  ${i + 1}. ${w.name} [${w.slug}]\n`);
+                }
+                const answer = await ask(rl, `\nLink to workspace [1-${workspaces.length}]: `);
+                const choice = parseInt(answer, 10);
+                if (choice < 1 || choice > workspaces.length || isNaN(choice)) {
+                    process.stderr.write("Invalid selection.\n");
+                    process.exit(1);
+                }
+                selected = workspaces[choice - 1];
+            }
+            finally {
+                rl.close();
+            }
+        }
+        saveDirectoryMapping(cwd, selected.id);
+        console.log(`Linked ${cwd} → ${selected.name} [${selected.slug}]`);
+    });
+    ws.command("unlink")
+        .description("Remove workspace mapping for current directory")
+        .action(async () => {
+        const cwd = process.cwd();
+        const removed = removeDirectoryMapping(cwd);
+        if (removed) {
+            console.log(`Unlinked ${cwd}`);
+        }
+        else {
+            console.log(`No workspace linked to ${cwd}`);
+        }
+    });
+    ws.command("create")
         .description("Create a new workspace")
+        .argument("<name>", "Workspace name")
         .action(async (name) => {
         const globalOpts = program.opts();
         const config = (0, config_1.resolveConfig)(globalOpts);
         const client = (0, client_1.createClient)(config.baseUrl, config.apiKey);
         const res = await client.createWorkspace(name);
         console.log(`Created workspace: ${res.data.name} [${res.data.slug}]`);
-        const stored = (0, login_1.readConfig)();
-        if (!stored?.workspaceId) {
-            const existing = stored ?? { apiKey: config.apiKey, serverUrl: config.baseUrl };
-            (0, login_1.writeConfig)({ ...existing, workspaceId: res.data.id });
-            console.log("Auto-selected as default workspace.");
-        }
+        // Auto-link to current directory
+        const cwd = process.cwd();
+        saveDirectoryMapping(cwd, res.data.id);
+        console.log(`Linked ${cwd} → ${res.data.name}`);
     });
     ws.command("current")
-        .description("Show currently selected workspace")
+        .description("Show workspace for current directory")
         .action(async () => {
         const stored = (0, login_1.readConfig)();
-        if (stored?.workspaceId) {
-            const config = (0, config_1.resolveConfig)(program.opts());
-            const client = (0, client_1.createClient)(config.baseUrl, config.apiKey);
-            try {
-                const res = await client.listWorkspaces();
-                const current = res.data.find((w) => w.id === stored.workspaceId);
-                if (current) {
-                    console.log(`Current workspace: ${current.name} [${current.slug}]`);
-                }
-                else {
-                    console.log(`Current workspace ID: ${stored.workspaceId} (not found on server)`);
-                }
+        const cwd = process.cwd();
+        // Check directory mapping first
+        const dirMapped = stored?.workspaces?.[cwd];
+        const effectiveId = dirMapped || stored?.workspaceId;
+        const source = dirMapped ? "linked" : stored?.workspaceId ? "global" : null;
+        if (!effectiveId) {
+            console.log(`No workspace for ${cwd}`);
+            console.log("Run: mnotes workspace select");
+            return;
+        }
+        const config = (0, config_1.resolveConfig)(program.opts());
+        const client = (0, client_1.createClient)(config.baseUrl, config.apiKey);
+        try {
+            const res = await client.listWorkspaces();
+            const current = res.data.find((w) => w.id === effectiveId);
+            if (current) {
+                console.log(`${current.name} [${current.slug}] (${source})`);
             }
-            catch {
-                console.log(`Current workspace ID: ${stored.workspaceId}`);
+            else {
+                console.log(`${effectiveId} (${source}, not found on server)`);
             }
         }
-        else {
-            console.log("No workspace selected. Run: mnotes workspace select");
+        catch {
+            console.log(`${effectiveId} (${source})`);
+        }
+    });
+    ws.command("mappings")
+        .description("Show all directory → workspace mappings")
+        .action(async () => {
+        const stored = (0, login_1.readConfig)();
+        const workspaces = stored?.workspaces;
+        if (!workspaces || Object.keys(workspaces).length === 0) {
+            console.log("No directory mappings. Use: mnotes workspace link");
+            return;
+        }
+        for (const [dir, wsId] of Object.entries(workspaces)) {
+            console.log(`  ${dir} → ${wsId}`);
+        }
+        if (stored?.workspaceId) {
+            console.log(`\n  Global default: ${stored.workspaceId}`);
         }
     });
 }

package/dist/config.js

@@ -2,6 +2,34 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveConfig = resolveConfig;
 const login_1 = require("./commands/login");
+/**
+ * Resolve workspace ID from (in priority order):
+ * 1. Explicit flag/option
+ * 2. MNOTES_WORKSPACE_ID env var
+ * 3. Per-directory mapping in config (cwd → workspaceId)
+ * 4. Global default workspaceId in config
+ */
+function resolveWorkspaceId(explicit, stored) {
+    if (explicit)
+        return explicit;
+    if (process.env.MNOTES_WORKSPACE_ID)
+        return process.env.MNOTES_WORKSPACE_ID;
+    // Check per-directory mapping
+    if (stored?.workspaces) {
+        const cwd = process.cwd();
+        // Exact match first, then walk up parent directories
+        let dir = cwd;
+        while (true) {
+            if (stored.workspaces[dir])
+                return stored.workspaces[dir];
+            const parent = require("path").dirname(dir);
+            if (parent === dir)
+                break; // reached root
+            dir = parent;
+        }
+    }
+    return stored?.workspaceId;
+}
 function resolveConfig(opts) {
     const stored = (0, login_1.readConfig)();
     const apiKey = opts.apiKey || process.env.MNOTES_API_KEY || stored?.apiKey;
@@ -10,6 +38,6 @@ function resolveConfig(opts) {
         process.exit(1);
     }
     const baseUrl = opts.url || process.env.MNOTES_URL || stored?.serverUrl || "https://mnotes.framework.by";
-    const workspaceId = opts.workspaceId || process.env.MNOTES_WORKSPACE_ID || stored?.workspaceId;
+    const workspaceId = resolveWorkspaceId(opts.workspaceId, stored ?? undefined);
     return { apiKey, baseUrl, workspaceId };
 }

package/package.json

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