claude-flow-novice 1.3.0 → 1.3.2

package/scripts/utils/fix-cliffy-imports.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+/**
+ * Script to fix Cliffy imports by creating a compatibility layer
+ * This allows using Deno's Cliffy modules in Node.js
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Create Cliffy compatibility modules
+const cliffyModules = {
+  '@cliffy/command': `
+export class Command {
+  constructor() {
+    this._name = '';
+    this._version = '';
+    this._description = '';
+    this._options = [];
+    this._commands = new Map();
+    this._action = null;
+  }
+
+  name(name) {
+    this._name = name;
+    return this;
+  }
+
+  version(version) {
+    this._version = version;
+    return this;
+  }
+
+  description(description) {
+    this._description = description;
+    return this;
+  }
+
+  arguments(args) {
+    this._arguments = args;
+    return this;
+  }
+
+  option(flags, description, options) {
+    this._options.push({ flags, description, options });
+    return this;
+  }
+
+  action(fn) {
+    this._action = fn;
+    return this;
+  }
+
+  command(name, command) {
+    if (command) {
+      this._commands.set(name, command);
+    }
+    return command || new Command();
+  }
+
+  async parse(args) {
+    // Simple parse implementation
+    const parsed = { options: {}, args: [] };
+    return parsed;
+  }
+
+  help() {
+    console.log(\`Command: \${this._name}\`);
+    console.log(\`Version: \${this._version}\`);
+    console.log(\`Description: \${this._description}\`);
+  }
+
+  showHelp() {
+    this.help();
+  }
+}
+`,
+  '@cliffy/table': `
+export class Table {
+  constructor() {
+    this._headers = [];
+    this._rows = [];
+    this._options = {};
+  }
+
+  static from(data) {
+    const table = new Table();
+    if (Array.isArray(data) && data.length > 0) {
+      if (typeof data[0] === 'object') {
+        table._headers = Object.keys(data[0]);
+        table._rows = data.map(row => Object.values(row));
+      } else {
+        table._rows = data;
+      }
+    }
+    return table;
+  }
+
+  header(headers) {
+    this._headers = headers;
+    return this;
+  }
+
+  body(rows) {
+    this._rows = rows;
+    return this;
+  }
+
+  push(...rows) {
+    this._rows.push(...rows);
+    return this;
+  }
+
+  padding(padding) {
+    this._options.padding = padding;
+    return this;
+  }
+
+  indent(indent) {
+    this._options.indent = indent;
+    return this;
+  }
+
+  border(border) {
+    this._options.border = border;
+    return this;
+  }
+
+  toString() {
+    // Simple table rendering
+    let result = '';
+    if (this._headers.length) {
+      result += this._headers.join(' | ') + '\\n';
+      result += '-'.repeat(this._headers.join(' | ').length) + '\\n';
+    }
+    for (const row of this._rows) {
+      result += row.join(' | ') + '\\n';
+    }
+    return result;
+  }
+
+  render() {
+    console.log(this.toString());
+  }
+}
+`,
+  '@cliffy/ansi/colors': `
+const colorize = (code) => (text) => \`\\x1b[\${code}m\${text}\\x1b[0m\`;
+
+export const red = colorize('31');
+export const green = colorize('32');
+export const yellow = colorize('33');
+export const blue = colorize('34');
+export const magenta = colorize('35');
+export const cyan = colorize('36');
+export const white = colorize('37');
+export const gray = colorize('90');
+export const bold = colorize('1');
+export const dim = colorize('2');
+export const italic = colorize('3');
+export const underline = colorize('4');
+export const inverse = colorize('7');
+export const hidden = colorize('8');
+export const strikethrough = colorize('9');
+export const bgRed = colorize('41');
+export const bgGreen = colorize('42');
+export const bgYellow = colorize('43');
+export const bgBlue = colorize('44');
+export const bgMagenta = colorize('45');
+export const bgCyan = colorize('46');
+export const bgWhite = colorize('47');
+
+export const colors = {
+  red, green, yellow, blue, magenta, cyan, white, gray,
+  bold, dim, italic, underline, inverse, hidden, strikethrough,
+  bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite
+};
+`,
+  '@cliffy/prompt': `
+export const prompt = async (questions) => {
+  const answers = {};
+  for (const q of questions) {
+    console.log(q.message);
+    // Simplified implementation
+    answers[q.name] = q.default || '';
+  }
+  return answers;
+};
+
+export const confirm = async (options) => {
+  console.log(options.message);
+  return options.default !== false;
+};
+
+export const input = async (options) => {
+  console.log(options.message);
+  return options.default || '';
+};
+
+export const number = async (options) => {
+  console.log(options.message);
+  return options.default || 0;
+};
+
+export const secret = async (options) => {
+  console.log(options.message);
+  return options.default || '';
+};
+
+export const select = async (options) => {
+  console.log(options.message);
+  return options.options?.[0] || options.default || '';
+};
+
+export const checkbox = async (options) => {
+  console.log(options.message);
+  return options.default || [];
+};
+
+// Add class exports
+export class Select {
+  constructor(options) {
+    this.options = options;
+  }
+  async prompt() {
+    return select(this.options);
+  }
+}
+
+export class Input {
+  constructor(options) {
+    this.options = options;
+  }
+  async prompt() {
+    return input(this.options);
+  }
+}
+
+export class Confirm {
+  constructor(options) {
+    this.options = options;
+  }
+  async prompt() {
+    return confirm(this.options);
+  }
+}
+
+export class Number {
+  constructor(options) {
+    this.options = options;
+  }
+  async prompt() {
+    return number(this.options);
+  }
+}
+`
+};
+
+async function createCliffyModules() {
+  const nodeModulesDir = path.join(__dirname, '..', 'node_modules');
+  const cliffyDir = path.join(nodeModulesDir, '@cliffy');
+
+  // Create @cliffy directory
+  await fs.mkdir(cliffyDir, { recursive: true });
+
+  // Create each module
+  for (const [modulePath, content] of Object.entries(cliffyModules)) {
+    const parts = modulePath.split('/');
+    const moduleName = parts[1];
+    const subPath = parts[2];
+
+    const moduleDir = path.join(cliffyDir, moduleName);
+    await fs.mkdir(moduleDir, { recursive: true });
+
+    if (subPath) {
+      // Create subdirectory for nested modules
+      const fullPath = path.join(moduleDir, subPath + '.js');
+      const dirPath = path.dirname(fullPath);
+      await fs.mkdir(dirPath, { recursive: true });
+      await fs.writeFile(fullPath, content.trim());
+    } else {
+      // Create main module file
+      await fs.writeFile(path.join(moduleDir, 'index.js'), content.trim());
+    }
+
+    // Create package.json for the module
+    const packageJson = {
+      name: modulePath,
+      version: '0.22.2',
+      main: subPath ? `${subPath}.js` : 'index.js',
+      type: 'module'
+    };
+    await fs.writeFile(
+      path.join(moduleDir, 'package.json'),
+      JSON.stringify(packageJson, null, 2)
+    );
+  }
+
+  console.log('✅ Created Cliffy compatibility modules');
+}
+
+// Run the script
+createCliffyModules().catch(console.error);

package/scripts/utils/fix-duplicate-imports.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+/**
+ * Script to fix duplicate imports in the codebase
+ */
+
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+async function removeDuplicateImports(filePath) {
+  try {
+    let content = await fs.readFile(filePath, 'utf-8');
+    let modified = false;
+
+    // Remove duplicate error handler imports
+    const errorHandlerRegex = /import\s+{\s*getErrorMessage\s*}\s+from\s+['"].*?error-handler\.js['"];\s*\n/g;
+    const matches = content.match(errorHandlerRegex);
+    
+    if (matches && matches.length > 1) {
+      // Keep only the first import
+      let firstFound = false;
+      content = content.replace(errorHandlerRegex, (match) => {
+        if (!firstFound) {
+          firstFound = true;
+          return match;
+        }
+        modified = true;
+        return '';
+      });
+    }
+
+    // Remove duplicate fs imports
+    const fsImportRegex = /import\s+{\s*promises\s+as\s+fs\s*}\s+from\s+['"]node:fs['"];\s*\n/g;
+    const fsMatches = content.match(fsImportRegex);
+    
+    if (fsMatches && fsMatches.length > 1) {
+      // Keep only the first import
+      let firstFound = false;
+      content = content.replace(fsImportRegex, (match) => {
+        if (!firstFound) {
+          firstFound = true;
+          return match;
+        }
+        modified = true;
+        return '';
+      });
+    }
+
+    // Fix duplicate type imports
+    const typeImportRegex = /import\s+type\s+{\s*([^}]+)\s*}\s+from\s+['"]([^'"]+)['"];\s*\n/g;
+    const typeImports = new Map();
+    
+    content = content.replace(typeImportRegex, (match, types, from) => {
+      const key = from;
+      if (typeImports.has(key)) {
+        // Merge with existing import
+        const existing = typeImports.get(key);
+        const newTypes = types.split(',').map(t => t.trim());
+        const existingTypes = existing.split(',').map(t => t.trim());
+        const allTypes = [...new Set([...existingTypes, ...newTypes])];
+        typeImports.set(key, allTypes.join(', '));
+        modified = true;
+        return '';
+      } else {
+        typeImports.set(key, types);
+        return match;
+      }
+    });
+
+    if (modified) {
+      await fs.writeFile(filePath, content);
+      console.log(`✅ Fixed duplicate imports in: ${filePath}`);
+    }
+  } catch (error) {
+    console.error(`❌ Error processing ${filePath}:`, error.message);
+  }
+}
+
+async function findTypeScriptFiles(dir) {
+  const files = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    
+    if (entry.isDirectory() && !entry.name.includes('node_modules') && !entry.name.includes('dist')) {
+      files.push(...await findTypeScriptFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith('.ts')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+async function main() {
+  const srcDir = join(dirname(__dirname), 'src');
+  const files = await findTypeScriptFiles(srcDir);
+  
+  console.log(`Found ${files.length} TypeScript files to check...`);
+  
+  for (const file of files) {
+    await removeDuplicateImports(file);
+  }
+  
+  console.log('✅ Duplicate import fixes complete!');
+}
+
+main().catch(console.error);

package/scripts/utils/fix-error-handling.cjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+
+// Find all TypeScript files
+const files = glob.sync('src/**/*.ts', { 
+  ignore: ['src/**/*.test.ts', 'src/**/*.spec.ts'] 
+});
+
+let totalFixed = 0;
+
+files.forEach(file => {
+  let content = fs.readFileSync(file, 'utf8');
+  let modified = false;
+
+  // Fix error handling patterns
+  const patterns = [
+    // Fix unknown error types in catch blocks
+    {
+      regex: /catch\s*\(\s*error\s*\)\s*{([^}]+error\.message)/g,
+      replacement: 'catch (error) {$1'
+    },
+    // Fix error.message access
+    {
+      regex: /(\$\{|`)error\.message/g,
+      replacement: '$1(error instanceof Error ? error.message : String(error))'
+    },
+    // Fix standalone error.message
+    {
+      regex: /([^`$])error\.message/g,
+      replacement: '$1(error instanceof Error ? error.message : String(error))'
+    },
+    // Fix error type annotations
+    {
+      regex: /catch\s*\(\s*error:\s*any\s*\)/g,
+      replacement: 'catch (error)'
+    },
+    // Fix error type in functions
+    {
+      regex: /\(error:\s*unknown\)/g,
+      replacement: '(error)'
+    }
+  ];
+
+  patterns.forEach(pattern => {
+    const before = content;
+    content = content.replace(pattern.regex, pattern.replacement);
+    if (before !== content) {
+      modified = true;
+    }
+  });
+
+  if (modified) {
+    // Add error handler import if needed
+    if (!content.includes("from '../utils/error-handler'") && 
+        !content.includes("from '../../utils/error-handler'") &&
+        content.includes('error instanceof Error')) {
+      const importPath = file.includes('cli/commands') ? '../../utils/error-handler' : '../utils/error-handler';
+      content = `import { getErrorMessage } from '${importPath}';\n` + content;
+    }
+
+    fs.writeFileSync(file, content);
+    totalFixed++;
+    console.log(`Fixed: ${file}`);
+  }
+});
+
+console.log(`\nTotal files fixed: ${totalFixed}`);

package/scripts/utils/fix-import-paths.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+/**
+ * Script to fix incorrect import paths in the codebase
+ */
+
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+async function fixImportPaths(filePath) {
+  try {
+    let content = await fs.readFile(filePath, 'utf-8');
+    let modified = false;
+
+    // Fix error-handler import paths in CLI commands
+    if (filePath.includes('/cli/commands/')) {
+      const wrongPath = '../utils/error-handler.js';
+      const correctPath = '../../utils/error-handler.js';
+      
+      if (content.includes(wrongPath)) {
+        content = content.replace(new RegExp(wrongPath, 'g'), correctPath);
+        modified = true;
+      }
+    }
+
+    // Fix type imports that should be value imports
+    const typeImportFixes = [
+      // EventEmitter should be a value import
+      {
+        from: "import type { EventEmitter } from 'events';",
+        to: "import { EventEmitter } from 'events';"
+      },
+      {
+        from: "import type { EventEmitter } from 'node:events';",
+        to: "import { EventEmitter } from 'node:events';"
+      },
+      // Command should be a value import for Cliffy
+      {
+        from: "import type { Command } from '@cliffy/command';",
+        to: "import { Command } from '@cliffy/command';"
+      },
+      // Logger should be a value import
+      {
+        from: "import type { Logger } from '../../core/logger.js';",
+        to: "import { Logger } from '../../core/logger.js';"
+      },
+      {
+        from: "import type { AdvancedMemoryManager } from '../../memory/advanced-memory-manager.js';",
+        to: "import { AdvancedMemoryManager } from '../../memory/advanced-memory-manager.js';"
+      }
+    ];
+
+    for (const fix of typeImportFixes) {
+      if (content.includes(fix.from)) {
+        content = content.replace(fix.from, fix.to);
+        modified = true;
+      }
+    }
+
+    if (modified) {
+      await fs.writeFile(filePath, content);
+      console.log(`✅ Fixed import paths in: ${filePath}`);
+    }
+  } catch (error) {
+    console.error(`❌ Error processing ${filePath}:`, error.message);
+  }
+}
+
+async function findTypeScriptFiles(dir) {
+  const files = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    
+    if (entry.isDirectory() && !entry.name.includes('node_modules') && !entry.name.includes('dist')) {
+      files.push(...await findTypeScriptFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith('.ts')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+async function main() {
+  const srcDir = join(dirname(__dirname), 'src');
+  const files = await findTypeScriptFiles(srcDir);
+  
+  console.log(`Found ${files.length} TypeScript files to check for import path issues...`);
+  
+  for (const file of files) {
+    await fixImportPaths(file);
+  }
+  
+  console.log('✅ Import path fixes complete!');
+}
+
+main().catch(console.error);

package/scripts/utils/fix-imports.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+/**
+ * Script to fix import issues in the codebase
+ */
+
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const replacements = [
+  // Cliffy imports to Commander/Inquirer
+  {
+    from: /import\s*{\s*Command\s*}\s*from\s*['"]@cliffy\/command['"]/g,
+    to: "import { Command } from 'commander'"
+  },
+  {
+    from: /import\s*{\s*Table\s*}\s*from\s*['"]@cliffy\/table['"]/g,
+    to: "import Table from 'cli-table3'"
+  },
+  {
+    from: /import\s*\*?\s*as\s*colors\s*from\s*['"]@cliffy\/ansi\/colors['"]/g,
+    to: "import chalk from 'chalk'"
+  },
+  {
+    from: /import\s*{\s*colors\s*}\s*from\s*['"]@cliffy\/ansi\/colors['"]/g,
+    to: "import chalk from 'chalk'"
+  },
+  {
+    from: /import\s*{\s*Select,\s*Input,\s*Confirm,\s*Number\s*}\s*from\s*['"]@cliffy\/prompt['"]/g,
+    to: "import inquirer from 'inquirer'"
+  },
+  // Fix colors usage
+  {
+    from: /colors\.(green|red|yellow|blue|gray|cyan|magenta|white|black|bold|dim)/g,
+    to: "chalk.$1"
+  },
+  // Fix duplicate fs imports
+  {
+    from: /import\s*{\s*promises\s*as\s*fs\s*}\s*from\s*['"]node:fs['"];?\s*\n(?:.*\n)*?import\s*{\s*promises\s*as\s*fs\s*}\s*from\s*['"]node:fs['"];?/g,
+    to: "import { promises as fs } from 'node:fs';"
+  },
+  // Fix showHelp() calls
+  {
+    from: /\.showHelp\(\)/g,
+    to: ".outputHelp()"
+  },
+  // Fix Table.push usage
+  {
+    from: /table\.push\(/g,
+    to: "table.push("
+  },
+  // Fix missing error handler imports
+  {
+    from: /^((?!import.*getErrorMessage)[\s\S])*?import/m,
+    to: "import { getErrorMessage } from '../utils/error-handler.js';\n$&"
+  }
+];
+
+async function processFile(filePath) {
+  try {
+    let content = await fs.readFile(filePath, 'utf-8');
+    let modified = false;
+
+    for (const replacement of replacements) {
+      const before = content;
+      content = content.replace(replacement.from, replacement.to);
+      if (content !== before) {
+        modified = true;
+      }
+    }
+
+    if (modified) {
+      await fs.writeFile(filePath, content);
+      console.log(`✅ Fixed imports in: ${filePath}`);
+    }
+  } catch (error) {
+    console.error(`❌ Error processing ${filePath}:`, error.message);
+  }
+}
+
+async function findTypeScriptFiles(dir) {
+  const files = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    
+    if (entry.isDirectory() && !entry.name.includes('node_modules') && !entry.name.includes('dist')) {
+      files.push(...await findTypeScriptFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith('.ts')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+async function main() {
+  const srcDir = join(dirname(__dirname), 'src');
+  const files = await findTypeScriptFiles(srcDir);
+  
+  console.log(`Found ${files.length} TypeScript files to process...`);
+  
+  for (const file of files) {
+    await processFile(file);
+  }
+  
+  console.log('✅ Import fixes complete!');
+}
+
+main().catch(console.error);