claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/cli/simple-commands/memory.js

@@ -1,345 +1,281 @@
 // memory.js - Memory management commands
-import { printSuccess, printError, printWarning, printInfo } from '../utils.js';
-import { promises as fs } from 'fs';
-import { cwd, exit, existsSync } from '../node-compat.js';
-import { getUnifiedMemory } from '../../memory/unified-memory-manager.js';
-
+import { printSuccess, printError, printWarning } from "../utils.js";
+import { promises as fs } from "fs";
 export async function memoryCommand(subArgs, flags) {
-  const memorySubcommand = subArgs[0];
-  const memoryStore = './memory/memory-store.json';
-
-  // Extract namespace from flags or subArgs
-  const namespace = flags?.namespace || flags?.ns || getNamespaceFromArgs(subArgs) || 'default';
-
-  // Helper to load memory data
-  async function loadMemory() {
-    try {
-      const content = await fs.readFile(memoryStore, 'utf8');
-      return JSON.parse(content);
-    } catch {
-      return {};
+    const memorySubcommand = subArgs[0];
+    const memoryStore = './memory/memory-store.json';
+    // Extract namespace from flags or subArgs
+    const namespace = flags?.namespace || flags?.ns || getNamespaceFromArgs(subArgs) || 'default';
+    // Helper to load memory data
+    async function loadMemory() {
+        try {
+            const content = await fs.readFile(memoryStore, 'utf8');
+            return JSON.parse(content);
+        } catch  {
+            return {};
+        }
+    }
+    // Helper to save memory data
+    async function saveMemory(data) {
+        await fs.mkdir('./memory', {
+            recursive: true
+        });
+        await fs.writeFile(memoryStore, JSON.stringify(data, null, 2, 'utf8'));
+    }
+    switch(memorySubcommand){
+        case 'store':
+            await storeMemory(subArgs, loadMemory, saveMemory, namespace);
+            break;
+        case 'query':
+            await queryMemory(subArgs, loadMemory, namespace);
+            break;
+        case 'stats':
+            await showMemoryStats(loadMemory);
+            break;
+        case 'export':
+            await exportMemory(subArgs, loadMemory, namespace);
+            break;
+        case 'import':
+            await importMemory(subArgs, saveMemory, loadMemory);
+            break;
+        case 'clear':
+            await clearMemory(subArgs, saveMemory, namespace);
+            break;
+        case 'list':
+            await listNamespaces(loadMemory);
+            break;
+        default:
+            showMemoryHelp();
     }
-  }
-
-  // Helper to save memory data
-  async function saveMemory(data) {
-    await fs.mkdir('./memory', { recursive: true });
-    await fs.writeFile(memoryStore, JSON.stringify(data, null, 2, 'utf8'));
-  }
-
-  switch (memorySubcommand) {
-    case 'store':
-      await storeMemory(subArgs, loadMemory, saveMemory, namespace);
-      break;
-
-    case 'query':
-      await queryMemory(subArgs, loadMemory, namespace);
-      break;
-
-    case 'stats':
-      await showMemoryStats(loadMemory);
-      break;
-
-    case 'export':
-      await exportMemory(subArgs, loadMemory, namespace);
-      break;
-
-    case 'import':
-      await importMemory(subArgs, saveMemory, loadMemory);
-      break;
-
-    case 'clear':
-      await clearMemory(subArgs, saveMemory, namespace);
-      break;
-
-    case 'list':
-      await listNamespaces(loadMemory);
-      break;
-
-    default:
-      showMemoryHelp();
-  }
 }
-
 async function storeMemory(subArgs, loadMemory, saveMemory, namespace) {
-  const key = subArgs[1];
-  const value = subArgs.slice(2).join(' ');
-
-  if (!key || !value) {
-    printError('Usage: memory store <key> <value> [--namespace <ns>]');
-    return;
-  }
-
-  try {
-    const data = await loadMemory();
-
-    if (!data[namespace]) {
-      data[namespace] = [];
+    const key = subArgs[1];
+    const value = subArgs.slice(2).join(' ');
+    if (!key || !value) {
+        printError('Usage: memory store <key> <value> [--namespace <ns>]');
+        return;
     }
-
-    // Remove existing entry with same key
-    data[namespace] = data[namespace].filter((e) => e.key !== key);
-
-    // Add new entry
-    data[namespace].push({
-      key,
-      value,
-      namespace,
-      timestamp: Date.now(),
-    });
-
-    await saveMemory(data);
-    printSuccess('Stored successfully');
-    console.log(`📝 Key: ${key}`);
-    console.log(`📦 Namespace: ${namespace}`);
-    console.log(`💾 Size: ${new TextEncoder().encode(value).length} bytes`);
-  } catch (err) {
-    printError(`Failed to store: ${err.message}`);
-  }
-}
-
-async function queryMemory(subArgs, loadMemory, namespace) {
-  const search = subArgs.slice(1).join(' ');
-
-  if (!search) {
-    printError('Usage: memory query <search> [--namespace <ns>]');
-    return;
-  }
-
-  try {
-    const data = await loadMemory();
-    const results = [];
-
-    for (const [ns, entries] of Object.entries(data)) {
-      if (namespace && ns !== namespace) continue;
-
-      for (const entry of entries) {
-        if (entry.key.includes(search) || entry.value.includes(search)) {
-          results.push(entry);
+    try {
+        const data = await loadMemory();
+        if (!data[namespace]) {
+            data[namespace] = [];
         }
-      }
-    }
-
-    if (results.length === 0) {
-      printWarning('No results found');
-      return;
+        // Remove existing entry with same key
+        data[namespace] = data[namespace].filter((e)=>e.key !== key);
+        // Add new entry
+        data[namespace].push({
+            key,
+            value,
+            namespace,
+            timestamp: Date.now()
+        });
+        await saveMemory(data);
+        printSuccess('Stored successfully');
+        console.log(`📝 Key: ${key}`);
+        console.log(`📦 Namespace: ${namespace}`);
+        console.log(`💾 Size: ${new TextEncoder().encode(value).length} bytes`);
+    } catch (err) {
+        printError(`Failed to store: ${err.message}`);
     }
-
-    printSuccess(`Found ${results.length} results:`);
-
-    // Sort by timestamp (newest first)
-    results.sort((a, b) => b.timestamp - a.timestamp);
-
-    for (const entry of results.slice(0, 10)) {
-      console.log(`\n📌 ${entry.key}`);
-      console.log(`   Namespace: ${entry.namespace}`);
-      console.log(
-        `   Value: ${entry.value.substring(0, 100)}${entry.value.length > 100 ? '...' : ''}`,
-      );
-      console.log(`   Stored: ${new Date(entry.timestamp).toLocaleString()}`);
+}
+async function queryMemory(subArgs, loadMemory, namespace) {
+    const search = subArgs.slice(1).join(' ');
+    if (!search) {
+        printError('Usage: memory query <search> [--namespace <ns>]');
+        return;
     }
-
-    if (results.length > 10) {
-      console.log(`\n... and ${results.length - 10} more results`);
+    try {
+        const data = await loadMemory();
+        const results = [];
+        for (const [ns, entries] of Object.entries(data)){
+            if (namespace && ns !== namespace) continue;
+            for (const entry of entries){
+                if (entry.key.includes(search) || entry.value.includes(search)) {
+                    results.push(entry);
+                }
+            }
+        }
+        if (results.length === 0) {
+            printWarning('No results found');
+            return;
+        }
+        printSuccess(`Found ${results.length} results:`);
+        // Sort by timestamp (newest first)
+        results.sort((a, b)=>b.timestamp - a.timestamp);
+        for (const entry of results.slice(0, 10)){
+            console.log(`\n📌 ${entry.key}`);
+            console.log(`   Namespace: ${entry.namespace}`);
+            console.log(`   Value: ${entry.value.substring(0, 100)}${entry.value.length > 100 ? '...' : ''}`);
+            console.log(`   Stored: ${new Date(entry.timestamp).toLocaleString()}`);
+        }
+        if (results.length > 10) {
+            console.log(`\n... and ${results.length - 10} more results`);
+        }
+    } catch (err) {
+        printError(`Failed to query: ${err.message}`);
     }
-  } catch (err) {
-    printError(`Failed to query: ${err.message}`);
-  }
 }
-
 async function showMemoryStats(loadMemory) {
-  try {
-    const data = await loadMemory();
-    let totalEntries = 0;
-    const namespaceStats = {};
-
-    for (const [namespace, entries] of Object.entries(data)) {
-      namespaceStats[namespace] = entries.length;
-      totalEntries += entries.length;
-    }
-
-    printSuccess('Memory Bank Statistics:');
-    console.log(`   Total Entries: ${totalEntries}`);
-    console.log(`   Namespaces: ${Object.keys(data).length}`);
-    console.log(
-      `   Size: ${(new TextEncoder().encode(JSON.stringify(data)).length / 1024).toFixed(2)} KB`,
-    );
-
-    if (Object.keys(data).length > 0) {
-      console.log('\n📁 Namespace Breakdown:');
-      for (const [namespace, count] of Object.entries(namespaceStats)) {
-        console.log(`   ${namespace}: ${count} entries`);
-      }
+    try {
+        const data = await loadMemory();
+        let totalEntries = 0;
+        const namespaceStats = {};
+        for (const [namespace, entries] of Object.entries(data)){
+            namespaceStats[namespace] = entries.length;
+            totalEntries += entries.length;
+        }
+        printSuccess('Memory Bank Statistics:');
+        console.log(`   Total Entries: ${totalEntries}`);
+        console.log(`   Namespaces: ${Object.keys(data).length}`);
+        console.log(`   Size: ${(new TextEncoder().encode(JSON.stringify(data)).length / 1024).toFixed(2)} KB`);
+        if (Object.keys(data).length > 0) {
+            console.log('\n📁 Namespace Breakdown:');
+            for (const [namespace, count] of Object.entries(namespaceStats)){
+                console.log(`   ${namespace}: ${count} entries`);
+            }
+        }
+    } catch (err) {
+        printError(`Failed to get stats: ${err.message}`);
     }
-  } catch (err) {
-    printError(`Failed to get stats: ${err.message}`);
-  }
 }
-
 async function exportMemory(subArgs, loadMemory, namespace) {
-  const filename = subArgs[1] || `memory-export-${Date.now()}.json`;
-
-  try {
-    const data = await loadMemory();
-
-    let exportData = data;
-    if (namespace) {
-      exportData = { [namespace]: data[namespace] || [] };
-    }
-
-    await fs.writeFile(filename, JSON.stringify(exportData, null, 2, 'utf8'));
-    printSuccess(`Memory exported to ${filename}`);
-
-    let totalEntries = 0;
-    for (const entries of Object.values(exportData)) {
-      totalEntries += entries.length;
+    const filename = subArgs[1] || `memory-export-${Date.now()}.json`;
+    try {
+        const data = await loadMemory();
+        let exportData = data;
+        if (namespace) {
+            exportData = {
+                [namespace]: data[namespace] || []
+            };
+        }
+        await fs.writeFile(filename, JSON.stringify(exportData, null, 2, 'utf8'));
+        printSuccess(`Memory exported to ${filename}`);
+        let totalEntries = 0;
+        for (const entries of Object.values(exportData)){
+            totalEntries += entries.length;
+        }
+        console.log(`📦 Exported ${totalEntries} entries from ${Object.keys(exportData).length} namespace(s)`);
+    } catch (err) {
+        printError(`Failed to export memory: ${err.message}`);
     }
-    console.log(
-      `📦 Exported ${totalEntries} entries from ${Object.keys(exportData).length} namespace(s)`,
-    );
-  } catch (err) {
-    printError(`Failed to export memory: ${err.message}`);
-  }
 }
-
 async function importMemory(subArgs, saveMemory, loadMemory) {
-  const filename = subArgs[1];
-
-  if (!filename) {
-    printError('Usage: memory import <filename>');
-    return;
-  }
-
-  try {
-    const importContent = await fs.readFile(filename, 'utf8');
-    const importData = JSON.parse(importContent);
-
-    // Load existing memory
-    const existingData = await loadMemory();
-
-    // Merge imported data
-    let totalImported = 0;
-    for (const [namespace, entries] of Object.entries(importData)) {
-      if (!existingData[namespace]) {
-        existingData[namespace] = [];
-      }
-
-      // Add entries that don't already exist (by key)
-      const existingKeys = new Set(existingData[namespace].map((e) => e.key));
-      const newEntries = entries.filter((e) => !existingKeys.has(e.key));
-
-      existingData[namespace].push(...newEntries);
-      totalImported += newEntries.length;
+    const filename = subArgs[1];
+    if (!filename) {
+        printError('Usage: memory import <filename>');
+        return;
+    }
+    try {
+        const importContent = await fs.readFile(filename, 'utf8');
+        const importData = JSON.parse(importContent);
+        // Load existing memory
+        const existingData = await loadMemory();
+        // Merge imported data
+        let totalImported = 0;
+        for (const [namespace, entries] of Object.entries(importData)){
+            if (!existingData[namespace]) {
+                existingData[namespace] = [];
+            }
+            // Add entries that don't already exist (by key)
+            const existingKeys = new Set(existingData[namespace].map((e)=>e.key));
+            const newEntries = entries.filter((e)=>!existingKeys.has(e.key));
+            existingData[namespace].push(...newEntries);
+            totalImported += newEntries.length;
+        }
+        await saveMemory(existingData);
+        printSuccess(`Imported ${totalImported} new entries from ${filename}`);
+    } catch (err) {
+        printError(`Failed to import memory: ${err.message}`);
     }
-
-    await saveMemory(existingData);
-    printSuccess(`Imported ${totalImported} new entries from ${filename}`);
-  } catch (err) {
-    printError(`Failed to import memory: ${err.message}`);
-  }
 }
-
 async function clearMemory(subArgs, saveMemory, namespace) {
-  if (!namespace || namespace === 'default') {
-    const nsFromArgs = getNamespaceFromArgs(subArgs);
-    if (!nsFromArgs) {
-      printError('Usage: memory clear --namespace <namespace>');
-      printWarning('This will clear all entries in the specified namespace');
-      return;
-    }
-    namespace = nsFromArgs;
-  }
-
-  try {
-    // Helper to load memory data
-    async function loadMemory() {
-      try {
-        const content = await fs.readFile('./memory/memory-store.json', 'utf8');
-        return JSON.parse(content);
-      } catch {
-        return {};
-      }
+    if (!namespace || namespace === 'default') {
+        const nsFromArgs = getNamespaceFromArgs(subArgs);
+        if (!nsFromArgs) {
+            printError('Usage: memory clear --namespace <namespace>');
+            printWarning('This will clear all entries in the specified namespace');
+            return;
+        }
+        namespace = nsFromArgs;
     }
-
-    const data = await loadMemory();
-
-    if (!data[namespace]) {
-      printWarning(`Namespace '${namespace}' does not exist`);
-      return;
+    try {
+        // Helper to load memory data
+        async function loadMemory() {
+            try {
+                const content = await fs.readFile('./memory/memory-store.json', 'utf8');
+                return JSON.parse(content);
+            } catch  {
+                return {};
+            }
+        }
+        const data = await loadMemory();
+        if (!data[namespace]) {
+            printWarning(`Namespace '${namespace}' does not exist`);
+            return;
+        }
+        const entryCount = data[namespace].length;
+        delete data[namespace];
+        await saveMemory(data);
+        printSuccess(`Cleared ${entryCount} entries from namespace '${namespace}'`);
+    } catch (err) {
+        printError(`Failed to clear memory: ${err.message}`);
     }
-
-    const entryCount = data[namespace].length;
-    delete data[namespace];
-
-    await saveMemory(data);
-    printSuccess(`Cleared ${entryCount} entries from namespace '${namespace}'`);
-  } catch (err) {
-    printError(`Failed to clear memory: ${err.message}`);
-  }
 }
-
 async function listNamespaces(loadMemory) {
-  try {
-    const data = await loadMemory();
-    const namespaces = Object.keys(data);
-
-    if (namespaces.length === 0) {
-      printWarning('No namespaces found');
-      return;
-    }
-
-    printSuccess('Available namespaces:');
-    for (const namespace of namespaces) {
-      const count = data[namespace].length;
-      console.log(`  ${namespace} (${count} entries)`);
+    try {
+        const data = await loadMemory();
+        const namespaces = Object.keys(data);
+        if (namespaces.length === 0) {
+            printWarning('No namespaces found');
+            return;
+        }
+        printSuccess('Available namespaces:');
+        for (const namespace of namespaces){
+            const count = data[namespace].length;
+            console.log(`  ${namespace} (${count} entries)`);
+        }
+    } catch (err) {
+        printError(`Failed to list namespaces: ${err.message}`);
     }
-  } catch (err) {
-    printError(`Failed to list namespaces: ${err.message}`);
-  }
 }
-
 function getNamespaceFromArgs(subArgs) {
-  const namespaceIndex = subArgs.indexOf('--namespace');
-  if (namespaceIndex !== -1 && namespaceIndex + 1 < subArgs.length) {
-    return subArgs[namespaceIndex + 1];
-  }
-
-  const nsIndex = subArgs.indexOf('--ns');
-  if (nsIndex !== -1 && nsIndex + 1 < subArgs.length) {
-    return subArgs[nsIndex + 1];
-  }
-
-  return null;
+    const namespaceIndex = subArgs.indexOf('--namespace');
+    if (namespaceIndex !== -1 && namespaceIndex + 1 < subArgs.length) {
+        return subArgs[namespaceIndex + 1];
+    }
+    const nsIndex = subArgs.indexOf('--ns');
+    if (nsIndex !== -1 && nsIndex + 1 < subArgs.length) {
+        return subArgs[nsIndex + 1];
+    }
+    return null;
 }
-
 // Helper to load memory data (needed for import function)
 async function loadMemory() {
-  try {
-    const content = await fs.readFile('./memory/memory-store.json', 'utf8');
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
+    try {
+        const content = await fs.readFile('./memory/memory-store.json', 'utf8');
+        return JSON.parse(content);
+    } catch  {
+        return {};
+    }
 }
-
 function showMemoryHelp() {
-  console.log('Memory commands:');
-  console.log('  store <key> <value>    Store a key-value pair');
-  console.log('  query <search>         Search for entries');
-  console.log('  stats                  Show memory statistics');
-  console.log('  export [filename]      Export memory to file');
-  console.log('  import <filename>      Import memory from file');
-  console.log('  clear --namespace <ns> Clear a namespace');
-  console.log('  list                   List all namespaces');
-  console.log();
-  console.log('Options:');
-  console.log('  --namespace <ns>       Specify namespace for operations');
-  console.log('  --ns <ns>              Short form of --namespace');
-  console.log();
-  console.log('Examples:');
-  console.log('  memory store previous_work "Research findings from yesterday"');
-  console.log('  memory query research --namespace sparc');
-  console.log('  memory export backup.json --namespace default');
-  console.log('  memory import project-memory.json');
-  console.log('  memory stats');
+    console.log('Memory commands:');
+    console.log('  store <key> <value>    Store a key-value pair');
+    console.log('  query <search>         Search for entries');
+    console.log('  stats                  Show memory statistics');
+    console.log('  export [filename]      Export memory to file');
+    console.log('  import <filename>      Import memory from file');
+    console.log('  clear --namespace <ns> Clear a namespace');
+    console.log('  list                   List all namespaces');
+    console.log();
+    console.log('Options:');
+    console.log('  --namespace <ns>       Specify namespace for operations');
+    console.log('  --ns <ns>              Short form of --namespace');
+    console.log();
+    console.log('Examples:');
+    console.log('  memory store previous_work "Research findings from yesterday"');
+    console.log('  memory query research --namespace sparc');
+    console.log('  memory export backup.json --namespace default');
+    console.log('  memory import project-memory.json');
+    console.log('  memory stats');
 }