monomind 1.15.7 → 1.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.15.7",
+  "version": "1.16.0",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/dist/src/commands/memory.js

@@ -1213,9 +1213,9 @@ const exportCommand = {
         {
             name: 'format',
             short: 'f',
-            description: 'Export format (json, csv, binary)',
+            description: 'Export format (json, csv, binary, okf)',
             type: 'string',
-            choices: ['json', 'csv', 'binary'],
+            choices: ['json', 'csv', 'binary', 'okf'],
             default: 'json'
         },
         {
@@ -1233,7 +1233,8 @@ const exportCommand = {
     ],
     examples: [
         { command: 'monomind memory export -o ./backup.json', description: 'Export all to JSON' },
-        { command: 'monomind memory export -o ./data.csv -f csv', description: 'Export to CSV' }
+        { command: 'monomind memory export -o ./data.csv -f csv', description: 'Export to CSV' },
+        { command: 'monomind memory export -o ./knowledge -f okf', description: 'Export as OKF bundle (directory of .md files)' }
     ],
     action: async (ctx) => {
         const outputPath = ctx.flags.output;
@@ -1243,6 +1244,44 @@ const exportCommand = {
             return { success: false, exitCode: 1 };
         }
         output.printInfo(`Exporting memory to ${outputPath}...`);
+        // OKF bundle: native export — directory of .md files with YAML frontmatter
+        if (format === 'okf') {
+            try {
+                const fs = await import('fs');
+                const path = await import('path');
+                const { listEntries, getEntry } = await import('../memory/memory-initializer.js');
+                const namespace = ctx.flags.namespace;
+                const listed = await listEntries({ namespace, limit: 10000 });
+                if (!listed.success) {
+                    output.printError(`Failed to list entries: ${listed.error}`);
+                    return { success: false, exitCode: 1 };
+                }
+                let written = 0;
+                for (const entry of listed.entries) {
+                    const got = await getEntry({ key: entry.key, namespace: entry.namespace });
+                    if (!got.found || !got.entry)
+                        continue;
+                    const { key, namespace: ns, content, tags, createdAt } = got.entry;
+                    const safeKey = key.replace(/[/\\:*?"<>|]/g, '-');
+                    const dir = path.join(outputPath, ns);
+                    fs.mkdirSync(dir, { recursive: true });
+                    const yamlEscape = (s) => s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+                    const tagsLine = tags.length > 0 ? `tags: [${tags.join(', ')}]\n` : '';
+                    const md = `---\ntype: Memory\nkey: "${yamlEscape(key)}"\nnamespace: "${yamlEscape(ns)}"\n${tagsLine}timestamp: ${createdAt}\n---\n\n${content}`;
+                    fs.writeFileSync(path.join(dir, `${safeKey}.md`), md, 'utf-8');
+                    written++;
+                }
+                output.printSuccess(`Exported ${written} entries to ${outputPath}`);
+                if (listed.total > 10000) {
+                    output.printInfo(`Note: only first 10000 of ${listed.total} entries exported`);
+                }
+                return { success: true, data: { written, outputPath } };
+            }
+            catch (error) {
+                output.printError(`OKF export error: ${String(error)}`);
+                return { success: false, exitCode: 1 };
+            }
+        }
         try {
             const result = await callMCPTool('memory_export', {
                 outputPath,
@@ -1307,6 +1346,77 @@ const importCommand = {
             return { success: false, exitCode: 1 };
         }
         output.printInfo(`Importing memory from ${inputPath}...`);
+        // OKF bundle: native import — detect directory of .md files with YAML frontmatter
+        const fsCheck = await import('fs');
+        const isDir = fsCheck.existsSync(inputPath) && fsCheck.statSync(inputPath).isDirectory();
+        if (isDir) {
+            try {
+                const fs = await import('fs');
+                const path = await import('path');
+                const { storeEntry } = await import('../memory/memory-initializer.js');
+                function parseOkfFrontmatter(raw) {
+                    if (!raw.startsWith('---\n'))
+                        return { meta: {}, body: raw };
+                    const end = raw.indexOf('\n---\n', 4);
+                    if (end === -1)
+                        return { meta: {}, body: raw };
+                    const meta = {};
+                    for (const line of raw.slice(4, end).split('\n')) {
+                        const colon = line.indexOf(':');
+                        if (colon <= 0)
+                            continue;
+                        const k = line.slice(0, colon).trim();
+                        const rawV = line.slice(colon + 1).trim();
+                        const isQuoted = rawV.startsWith('"') && rawV.endsWith('"') && rawV.length >= 2;
+                        const v = isQuoted ? rawV.slice(1, -1).replace(/\\(["\\])/g, '$1') : rawV;
+                        if (v.startsWith('[') && v.endsWith(']')) {
+                            meta[k] = v.slice(1, -1).split(',').map(s => s.trim()).filter(Boolean);
+                        }
+                        else {
+                            meta[k] = v;
+                        }
+                    }
+                    return { meta, body: raw.slice(end + 5) };
+                }
+                function findMdFiles(dir) {
+                    const results = [];
+                    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                        const full = path.join(dir, entry.name);
+                        if (entry.isDirectory())
+                            results.push(...findMdFiles(full));
+                        else if (entry.name.endsWith('.md'))
+                            results.push(full);
+                    }
+                    return results;
+                }
+                const overrideNs = ctx.flags.namespace;
+                const merge = ctx.flags.merge ?? true;
+                const files = findMdFiles(inputPath);
+                let imported = 0, skipped = 0;
+                const start = Date.now();
+                for (const file of files) {
+                    const raw = fs.readFileSync(file, 'utf-8');
+                    const { meta, body } = parseOkfFrontmatter(raw);
+                    const key = meta['key'] || path.basename(file, '.md');
+                    const ns = overrideNs || meta['namespace'] || path.basename(path.dirname(file));
+                    const tags = Array.isArray(meta['tags']) ? meta['tags'] : meta['tags'] ? [meta['tags']] : [];
+                    const result = await storeEntry({ key, value: body.trim(), namespace: ns, tags, upsert: !merge });
+                    if (result.success)
+                        imported++;
+                    else
+                        skipped++;
+                }
+                output.printSuccess(`Imported ${imported} entries from ${inputPath}`);
+                if (skipped > 0)
+                    output.printInfo(`Skipped ${skipped} entries (duplicates or errors)`);
+                output.printInfo(`Duration: ${Date.now() - start}ms`);
+                return { success: true, data: { imported, skipped } };
+            }
+            catch (error) {
+                output.printError(`OKF import error: ${String(error)}`);
+                return { success: false, exitCode: 1 };
+            }
+        }
         try {
             const result = await callMCPTool('memory_import', {
                 inputPath,

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.15.7",
+  "version": "1.16.0",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",