mnotes-cli 1.5.1 → 1.7.0

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/dist/index.js

@@ -15,7 +15,7 @@ const program = new commander_1.Command();
 program
     .name("mnotes")
     .description("CLI for m-notes AI knowledge base")
-    .version(process.env.npm_package_version ?? "1.2.0")
+    .version(require("../package.json").version)
     .option("--api-key <key>", "API key (or set MNOTES_API_KEY)")
     .option("--url <url>", "Base URL (or set MNOTES_URL)")
     .option("--json", "Output as JSON");

package/dist/templates/claude-code.js

@@ -38,17 +38,70 @@ Recall knowledge **before acting**. Specifically:
 - At session start → \`project_context_load\` loads everything relevant
 - When the user asks about past work → \`session_context_resume\`
 
+## Notes — Your Working Documents
+
+m-notes is not just a knowledge base — it's a full note-taking system. **Use notes actively** to create and maintain living documents:
+
+### When to Create Notes
+- **Meeting notes** → \`create_note\` after any planning discussion or decision
+- **Investigation logs** → create a note when debugging, append findings as you go with \`append_to_note\`
+- **Design docs** → write architecture or design decisions as full notes, not just knowledge entries
+- **Task summaries** → after completing a story/task, create a note summarizing what was done
+- **Checklists and plans** → create notes with markdown checklists for multi-step work
+- **Daily notes** → use \`daily_note\` to create/get today's note for quick captures
+
+### When to Edit Notes
+- **Append progress** → use \`append_to_note\` to add to existing notes as work progresses
+- **Update docs** → when code changes invalidate existing notes, update them with \`update_note\`
+- **Tag and organize** → use \`manage_tags\` and folder tools to keep notes findable
+
+### Note vs Knowledge Entry
+| Use a **note** when... | Use **knowledge_store** when... |
+|---|---|
+| Content is long-form (paragraphs, lists, docs) | Content is a single fact or decision |
+| Document will be updated over time | Entry is a permanent record |
+| Needs folder organization | Needs key/tag retrieval |
+| Meeting notes, plans, investigations | Architecture decisions, gotchas, patterns |
+
+**When in doubt, create a note.** Notes are searchable, linkable, and visible in the UI.
+
 ## MCP Tools Reference
 
+### Session & Context
 | Tool | When to use |
 |------|------------|
 | \`project_context_load\` | Session start — loads project context |
 | \`session_context_resume\` | Resume from previous session |
-| \`knowledge_store\` | Store any knowledge entry (key, content, tags) |
+| \`session_log\` | Log session summary at end |
+
+### Knowledge (quick structured entries)
+| Tool | When to use |
+|------|------------|
+| \`knowledge_store\` | Store a knowledge entry (key, content, tags) |
 | \`recall_knowledge\` | Semantic search across stored knowledge |
 | \`bulk_knowledge_recall\` | Recall by tag patterns (e.g., all \`arch/*\`) |
 | \`knowledge_snapshot\` | Export all knowledge at once |
-| \`session_log\` | Log session summary at end |
+
+### Notes (full documents)
+| Tool | When to use |
+|------|------------|
+| \`create_note\` | Create a new note (title, content, folderId) |
+| \`update_note\` | Replace note content |
+| \`append_to_note\` | Add content to an existing note |
+| \`get_note\` | Read a note by ID |
+| \`get_note_by_title\` | Find a note by title |
+| \`search_notes\` | Full-text or semantic search |
+| \`list_notes\` | List notes in a folder |
+| \`daily_note\` | Create or get today's daily note |
+| \`manage_tags\` | Add/remove tags on notes |
+| \`pin_note\` / \`toggle_star\` | Pin or star important notes |
+
+### Organization
+| Tool | When to use |
+|------|------------|
+| \`list_folders\` | List folders in workspace |
+| \`create_folder\` | Create a new folder |
+| \`move_note\` | Move note to a different folder |
 | \`context_fetch\` | Search notes by query |
 
 All tools require \`workspaceId: "${opts.workspaceId}"\`.`;

package/package.json

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