claude-flow-novice 1.3.0 → 1.3.2

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

@@ -0,0 +1,345 @@
+// 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';
+
+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 {};
+    }
+  }
+
+  // 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] = [];
+    }
+
+    // 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);
+        }
+      }
+    }
+
+    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}`);
+  }
+}
+
+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`);
+      }
+    }
+  } 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;
+    }
+    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;
+    }
+
+    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 {};
+      }
+    }
+
+    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}`);
+  }
+}
+
+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)`);
+    }
+  } 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;
+}
+
+// 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 {};
+  }
+}
+
+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');
+}

package/src/cli/simple-commands/migrate-hooks.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+/**
+ * CLI command wrapper for migrate-hooks script
+ */
+
+import { execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { promises as fs } from 'fs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function migrateHooksCommand(flags, args) {
+  console.log('🔄 Claude Flow Hooks Migration\n');
+
+  try {
+    // Find the migration script
+    const scriptPath = path.join(__dirname, '../../../scripts/migrate-hooks.js');
+
+    // Check if script exists
+    try {
+      await fs.access(scriptPath);
+    } catch {
+      console.error('❌ Migration script not found. Please ensure you have the latest version.');
+      process.exit(1);
+    }
+
+    // Build command with any additional arguments
+    const command = ['node', scriptPath];
+    if (args.length > 0) {
+      command.push(...args);
+    }
+
+    // Execute the migration script
+    execSync(command.join(' '), {
+      stdio: 'inherit',
+      cwd: process.cwd(),
+    });
+  } catch (error) {
+    console.error('❌ Migration failed:', error.message);
+    process.exit(1);
+  }
+}
+
+// Export the command configuration
+export const migrateHooksCommandConfig = {
+  handler: migrateHooksCommand,
+  description: 'Migrate settings.json hooks to Claude Code 1.0.51+ format',
+  usage: 'migrate-hooks [settings-file]',
+  examples: [
+    'claude-flow migrate-hooks                    # Migrate all found settings.json files',
+    'claude-flow migrate-hooks .claude/settings.json  # Migrate specific file',
+  ],
+  details: `
+Migrates old hooks format to new Claude Code 1.0.51+ format:
+  • Converts object-based hooks to array-based format
+  • Creates backup before making changes
+  • Removes unsupported fields (mcpServers, features, performance)
+  • Searches common locations if no file specified
+
+The migration is safe and creates backups of original files.`,
+};