appiq-solution 1.3.3 → 1.4.3

package/#Tools/APPIQ-METHOD/tools/flattener/main.js

@@ -0,0 +1,570 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const fs = require('fs-extra');
+const path = require('node:path');
+const { glob } = require('glob');
+const { minimatch } = require('minimatch');
+
+/**
+ * Recursively discover all files in a directory
+ * @param {string} rootDir - The root directory to scan
+ * @returns {Promise<string[]>} Array of file paths
+ */
+async function discoverFiles(rootDir) {
+  try {
+    const gitignorePath = path.join(rootDir, '.gitignore');
+    const gitignorePatterns = await parseGitignore(gitignorePath);
+
+    // Common gitignore patterns that should always be ignored
+    const commonIgnorePatterns = [
+      // Version control
+      '.git/**',
+      '.svn/**',
+      '.hg/**',
+      '.bzr/**',
+
+      // Dependencies
+      'node_modules/**',
+      'bower_components/**',
+      'vendor/**',
+      'packages/**',
+
+      // Build outputs
+      'build/**',
+      'dist/**',
+      'out/**',
+      'target/**',
+      'bin/**',
+      'obj/**',
+      'release/**',
+      'debug/**',
+
+      // Environment and config
+      '.env',
+      '.env.*',
+      '*.env',
+      '.config',
+
+      // Logs
+      'logs/**',
+      '*.log',
+      'npm-debug.log*',
+      'yarn-debug.log*',
+      'yarn-error.log*',
+      'lerna-debug.log*',
+
+      // Coverage and testing
+      'coverage/**',
+      '.nyc_output/**',
+      '.coverage/**',
+      'test-results/**',
+      'junit.xml',
+
+      // Cache directories
+      '.cache/**',
+      '.tmp/**',
+      '.temp/**',
+      'tmp/**',
+      'temp/**',
+      '.sass-cache/**',
+      '.eslintcache',
+      '.stylelintcache',
+
+      // OS generated files
+      '.DS_Store',
+      '.DS_Store?',
+      '._*',
+      '.Spotlight-V100',
+      '.Trashes',
+      'ehthumbs.db',
+      'Thumbs.db',
+      'desktop.ini',
+
+      // IDE and editor files
+      '.vscode/**',
+      '.idea/**',
+      '*.swp',
+      '*.swo',
+      '*~',
+      '.project',
+      '.classpath',
+      '.settings/**',
+      '*.sublime-project',
+      '*.sublime-workspace',
+
+      // Package manager files
+      'package-lock.json',
+      'yarn.lock',
+      'pnpm-lock.yaml',
+      'composer.lock',
+      'Pipfile.lock',
+
+      // Runtime and compiled files
+      '*.pyc',
+      '*.pyo',
+      '*.pyd',
+      '__pycache__/**',
+      '*.class',
+      '*.jar',
+      '*.war',
+      '*.ear',
+      '*.o',
+      '*.so',
+      '*.dll',
+      '*.exe',
+
+      // Documentation build
+      '_site/**',
+      '.jekyll-cache/**',
+      '.jekyll-metadata',
+
+      // Flattener specific outputs
+      'flattened-codebase.xml',
+      'repomix-output.xml'
+    ];
+
+    const combinedIgnores = [
+      ...gitignorePatterns,
+      ...commonIgnorePatterns
+    ];
+
+    // Use glob to recursively find all files, excluding common ignore patterns
+    const files = await glob('**/*', {
+      cwd: rootDir,
+      nodir: true, // Only files, not directories
+      dot: true,   // Include hidden files
+      follow: false, // Don't follow symbolic links
+      ignore: combinedIgnores
+    });
+
+    return files.map(file => path.resolve(rootDir, file));
+  } catch (error) {
+    console.error('Error discovering files:', error.message);
+    return [];
+  }
+}
+
+/**
+ * Parse .gitignore file and return ignore patterns
+ * @param {string} gitignorePath - Path to .gitignore file
+ * @returns {Promise<string[]>} Array of ignore patterns
+ */
+async function parseGitignore(gitignorePath) {
+  try {
+    if (!await fs.pathExists(gitignorePath)) {
+      return [];
+    }
+
+    const content = await fs.readFile(gitignorePath, 'utf8');
+    return content
+      .split('\n')
+      .map(line => line.trim())
+      .filter(line => line && !line.startsWith('#')) // Remove empty lines and comments
+      .map(pattern => {
+        // Convert gitignore patterns to glob patterns
+        if (pattern.endsWith('/')) {
+          return pattern + '**';
+        }
+        return pattern;
+      });
+  } catch (error) {
+    console.error('Error parsing .gitignore:', error.message);
+    return [];
+  }
+}
+
+/**
+ * Check if a file is binary using file command and heuristics
+ * @param {string} filePath - Path to the file
+ * @returns {Promise<boolean>} True if file is binary
+ */
+async function isBinaryFile(filePath) {
+  try {
+    // First check by file extension
+    const binaryExtensions = [
+      '.jpg', '.jpeg', '.png', '.gif', '.bmp', '.ico', '.svg',
+      '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+      '.zip', '.tar', '.gz', '.rar', '.7z',
+      '.exe', '.dll', '.so', '.dylib',
+      '.mp3', '.mp4', '.avi', '.mov', '.wav',
+      '.ttf', '.otf', '.woff', '.woff2',
+      '.bin', '.dat', '.db', '.sqlite'
+    ];
+
+    const ext = path.extname(filePath).toLowerCase();
+    if (binaryExtensions.includes(ext)) {
+      return true;
+    }
+
+    // For files without clear extensions, try to read a small sample
+    const stats = await fs.stat(filePath);
+    if (stats.size === 0) {
+      return false; // Empty files are considered text
+    }
+
+    // Read first 1024 bytes to check for null bytes
+    const sampleSize = Math.min(1024, stats.size);
+    const buffer = await fs.readFile(filePath, { encoding: null, flag: 'r' });
+    const sample = buffer.slice(0, sampleSize);
+    // If we find null bytes, it's likely binary
+    return sample.includes(0);
+  } catch (error) {
+    console.warn(`Warning: Could not determine if file is binary: ${filePath} - ${error.message}`);
+    return false; // Default to text if we can't determine
+  }
+}
+
+/**
+ * Read and aggregate content from text files
+ * @param {string[]} files - Array of file paths
+ * @param {string} rootDir - The root directory
+ * @param {Object} spinner - Optional spinner instance for progress display
+ * @returns {Promise<Object>} Object containing file contents and metadata
+ */
+async function aggregateFileContents(files, rootDir, spinner = null) {
+  const results = {
+    textFiles: [],
+    binaryFiles: [],
+    errors: [],
+    totalFiles: files.length,
+    processedFiles: 0
+  };
+
+  for (const filePath of files) {
+    try {
+      const relativePath = path.relative(rootDir, filePath);
+
+      // Update progress indicator
+      if (spinner) {
+        spinner.text = `Processing file ${results.processedFiles + 1}/${results.totalFiles}: ${relativePath}`;
+      }
+
+      const isBinary = await isBinaryFile(filePath);
+
+      if (isBinary) {
+        results.binaryFiles.push({
+          path: relativePath,
+          absolutePath: filePath,
+          size: (await fs.stat(filePath)).size
+        });
+      } else {
+        // Read text file content
+        const content = await fs.readFile(filePath, 'utf8');
+        results.textFiles.push({
+          path: relativePath,
+          absolutePath: filePath,
+          content: content,
+          size: content.length,
+          lines: content.split('\n').length
+        });
+      }
+
+      results.processedFiles++;
+    } catch (error) {
+      const relativePath = path.relative(rootDir, filePath);
+      const errorInfo = {
+        path: relativePath,
+        absolutePath: filePath,
+        error: error.message
+      };
+
+      results.errors.push(errorInfo);
+
+      // Log warning without interfering with spinner
+      if (spinner) {
+        spinner.warn(`Warning: Could not read file ${relativePath}: ${error.message}`);
+      } else {
+        console.warn(`Warning: Could not read file ${relativePath}: ${error.message}`);
+      }
+
+      results.processedFiles++;
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Generate XML output with aggregated file contents using streaming
+ * @param {Object} aggregatedContent - The aggregated content object
+ * @param {string} outputPath - The output file path
+ * @returns {Promise<void>} Promise that resolves when writing is complete
+ */
+async function generateXMLOutput(aggregatedContent, outputPath) {
+  const { textFiles } = aggregatedContent;
+
+  // Create write stream for efficient memory usage
+  const writeStream = fs.createWriteStream(outputPath, { encoding: 'utf8' });
+
+  return new Promise((resolve, reject) => {
+    writeStream.on('error', reject);
+    writeStream.on('finish', resolve);
+
+    // Write XML header
+    writeStream.write('<?xml version="1.0" encoding="UTF-8"?>\n');
+    writeStream.write('<files>\n');
+
+    // Process files one by one to minimize memory usage
+    let fileIndex = 0;
+
+    const writeNextFile = () => {
+      if (fileIndex >= textFiles.length) {
+        // All files processed, close XML and stream
+        writeStream.write('</files>\n');
+        writeStream.end();
+        return;
+      }
+
+      const file = textFiles[fileIndex];
+      fileIndex++;
+
+      // Write file opening tag
+      writeStream.write(`  <file path="${escapeXml(file.path)}">`);
+
+      // Use CDATA for code content, handling CDATA end sequences properly
+      if (file.content?.trim()) {
+        const indentedContent = indentFileContent(file.content);
+        if (file.content.includes(']]>')) {
+          // If content contains ]]>, split it and wrap each part in CDATA
+          writeStream.write(splitAndWrapCDATA(indentedContent));
+        } else {
+          writeStream.write(`<![CDATA[\n${indentedContent}\n    ]]>`);
+        }
+      } else if (file.content) {
+        // Handle empty or whitespace-only content
+        const indentedContent = indentFileContent(file.content);
+        writeStream.write(`<![CDATA[\n${indentedContent}\n    ]]>`);
+      }
+
+      // Write file closing tag
+      writeStream.write('</file>\n');
+
+      // Continue with next file on next tick to avoid stack overflow
+      setImmediate(writeNextFile);
+    };
+
+    // Start processing files
+    writeNextFile();
+  });
+}
+
+/**
+ * Escape XML special characters for attributes
+ * @param {string} str - String to escape
+ * @returns {string} Escaped string
+ */
+function escapeXml(str) {
+  if (typeof str !== 'string') {
+    return String(str);
+  }
+  return str
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+/**
+ * Indent file content with 4 spaces for each line
+ * @param {string} content - Content to indent
+ * @returns {string} Indented content
+ */
+function indentFileContent(content) {
+  if (typeof content !== 'string') {
+    return String(content);
+  }
+
+  // Split content into lines and add 4 spaces of indentation to each line
+  return content.split('\n').map(line => `    ${line}`).join('\n');
+}
+
+/**
+ * Split content containing ]]> and wrap each part in CDATA
+ * @param {string} content - Content to process
+ * @returns {string} Content with properly wrapped CDATA sections
+ */
+function splitAndWrapCDATA(content) {
+  if (typeof content !== 'string') {
+    return String(content);
+  }
+
+  // Replace ]]> with ]]]]><![CDATA[> to escape it within CDATA
+  const escapedContent = content.replace(/]]>/g, ']]]]><![CDATA[>');
+  return `<![CDATA[
+${escapedContent}
+    ]]>`;
+}
+
+/**
+ * Calculate statistics for the processed files
+ * @param {Object} aggregatedContent - The aggregated content object
+ * @param {number} xmlFileSize - The size of the generated XML file in bytes
+ * @returns {Object} Statistics object
+ */
+function calculateStatistics(aggregatedContent, xmlFileSize) {
+  const { textFiles, binaryFiles, errors } = aggregatedContent;
+
+  // Calculate total file size in bytes
+  const totalTextSize = textFiles.reduce((sum, file) => sum + file.size, 0);
+  const totalBinarySize = binaryFiles.reduce((sum, file) => sum + file.size, 0);
+  const totalSize = totalTextSize + totalBinarySize;
+
+  // Calculate total lines of code
+  const totalLines = textFiles.reduce((sum, file) => sum + file.lines, 0);
+
+  // Estimate token count (rough approximation: 1 token ≈ 4 characters)
+  const estimatedTokens = Math.ceil(xmlFileSize / 4);
+
+  // Format file size
+  const formatSize = (bytes) => {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  };
+
+  return {
+    totalFiles: textFiles.length + binaryFiles.length,
+    textFiles: textFiles.length,
+    binaryFiles: binaryFiles.length,
+    errorFiles: errors.length,
+    totalSize: formatSize(totalSize),
+    xmlSize: formatSize(xmlFileSize),
+    totalLines,
+    estimatedTokens: estimatedTokens.toLocaleString()
+  };
+}
+
+/**
+ * Filter files based on .gitignore patterns
+ * @param {string[]} files - Array of file paths
+ * @param {string} rootDir - The root directory
+ * @returns {Promise<string[]>} Filtered array of file paths
+ */
+async function filterFiles(files, rootDir) {
+  const gitignorePath = path.join(rootDir, '.gitignore');
+  const ignorePatterns = await parseGitignore(gitignorePath);
+
+  if (ignorePatterns.length === 0) {
+    return files;
+  }
+
+  // Convert absolute paths to relative for pattern matching
+  const relativeFiles = files.map(file => path.relative(rootDir, file));
+
+  // Separate positive and negative patterns
+  const positivePatterns = ignorePatterns.filter(p => !p.startsWith('!'));
+  const negativePatterns = ignorePatterns.filter(p => p.startsWith('!')).map(p => p.slice(1));
+
+  // Filter out files that match ignore patterns
+  const filteredRelative = [];
+
+  for (const file of relativeFiles) {
+    let shouldIgnore = false;
+
+    // First check positive patterns (ignore these files)
+    for (const pattern of positivePatterns) {
+      if (minimatch(file, pattern)) {
+        shouldIgnore = true;
+        break;
+      }
+    }
+
+    // Then check negative patterns (don't ignore these files even if they match positive patterns)
+    if (shouldIgnore) {
+      for (const pattern of negativePatterns) {
+        if (minimatch(file, pattern)) {
+          shouldIgnore = false;
+          break;
+        }
+      }
+    }
+
+    if (!shouldIgnore) {
+      filteredRelative.push(file);
+    }
+  }
+
+  // Convert back to absolute paths
+  return filteredRelative.map(file => path.resolve(rootDir, file));
+}
+
+const program = new Command();
+
+program
+  .name('bmad-flatten')
+  .description('BMad-Method codebase flattener tool')
+  .version('1.0.0')
+  .option('-i, --input <path>', 'Input directory to flatten', process.cwd())
+  .option('-o, --output <path>', 'Output file path', 'flattened-codebase.xml')
+  .action(async (options) => {
+    const inputDir = path.resolve(options.input);
+    const outputPath = path.resolve(options.output);
+    
+    console.log(`Flattening codebase from: ${inputDir}`);
+    console.log(`Output file: ${outputPath}`);
+
+    try {
+      // Verify input directory exists
+      if (!await fs.pathExists(inputDir)) {
+        console.error(`❌ Error: Input directory does not exist: ${inputDir}`);
+        process.exit(1);
+      }
+
+      // Import ora dynamically
+      const { default: ora } = await import('ora');
+
+      // Start file discovery with spinner
+      const discoverySpinner = ora('🔍 Discovering files...').start();
+      const files = await discoverFiles(inputDir);
+      const filteredFiles = await filterFiles(files, inputDir);
+      discoverySpinner.succeed(`📁 Found ${filteredFiles.length} files to include`);
+
+      // Process files with progress tracking
+      console.log('Reading file contents');
+      const processingSpinner = ora('📄 Processing files...').start();
+      const aggregatedContent = await aggregateFileContents(filteredFiles, inputDir, processingSpinner);
+      processingSpinner.succeed(`✅ Processed ${aggregatedContent.processedFiles}/${filteredFiles.length} files`);
+
+      // Log processing results for test validation
+      console.log(`Processed ${aggregatedContent.processedFiles}/${filteredFiles.length} files`);
+      if (aggregatedContent.errors.length > 0) {
+        console.log(`Errors: ${aggregatedContent.errors.length}`);
+      }
+      console.log(`Text files: ${aggregatedContent.textFiles.length}`);
+      if (aggregatedContent.binaryFiles.length > 0) {
+        console.log(`Binary files: ${aggregatedContent.binaryFiles.length}`);
+      }
+
+      // Generate XML output using streaming
+      const xmlSpinner = ora('🔧 Generating XML output...').start();
+      await generateXMLOutput(aggregatedContent, outputPath);
+      xmlSpinner.succeed('📝 XML generation completed');
+
+      // Calculate and display statistics
+      const outputStats = await fs.stat(outputPath);
+      const stats = calculateStatistics(aggregatedContent, outputStats.size);
+
+      // Display completion summary
+      console.log('\n📊 Completion Summary:');
+      console.log(`✅ Successfully processed ${filteredFiles.length} files into ${path.basename(outputPath)}`);
+      console.log(`📁 Output file: ${outputPath}`);
+      console.log(`📏 Total source size: ${stats.totalSize}`);
+      console.log(`📄 Generated XML size: ${stats.xmlSize}`);
+      console.log(`📝 Total lines of code: ${stats.totalLines.toLocaleString()}`);
+      console.log(`🔢 Estimated tokens: ${stats.estimatedTokens}`);
+      console.log(`📊 File breakdown: ${stats.textFiles} text, ${stats.binaryFiles} binary, ${stats.errorFiles} errors`);
+
+    } catch (error) {
+      console.error('❌ Critical error:', error.message);
+      console.error('An unexpected error occurred.');
+      process.exit(1);
+    }
+  });
+
+if (require.main === module) {
+  program.parse();
+}
+
+module.exports = program;

package/#Tools/APPIQ-METHOD/tools/installer/bin/bmad.js

@@ -33,20 +33,7 @@ try {
 
 program
   .version(version)
-  .description('BMad Method installer - Universal AI agent framework for any domain')
-  .action(async () => {
-    // Default action when no command is provided - start interactive installation
-    try {
-      const answers = await promptInstallation();
-      if (!answers._alreadyInstalled) {
-        await installer.install(answers);
-        process.exit(0);
-      }
-    } catch (error) {
-      console.error(chalk.red('Installation failed:'), error.message);
-      process.exit(1);
-    }
-  });
+  .description('BMad Method installer - Universal AI agent framework for any domain');
 
 program
   .command('install')
@@ -123,6 +110,20 @@ program
     }
   });
 
+program
+  .command('flatten')
+  .description('Flatten codebase to XML format')
+  .option('-i, --input <path>', 'Input directory to flatten', process.cwd())
+  .option('-o, --output <path>', 'Output file path', 'flattened-codebase.xml')
+  .action(async (options) => {
+    try {
+      await installer.flatten(options);
+    } catch (error) {
+      console.error(chalk.red('Flatten failed:'), error.message);
+      process.exit(1);
+    }
+  });
+
 async function promptInstallation() {
   
   // Display ASCII logo

package/#Tools/APPIQ-METHOD/tools/installer/lib/installer.js

@@ -497,7 +497,7 @@ class Installer {
       case "reinstall":
         // For reinstall, don't check for modifications - just overwrite
         return await this.performReinstall(config, installDir, spinner);
-      case "expansions":
+      case "expansions": {
         // Ask which expansion packs to install
         const availableExpansionPacks = await resourceLocator.getExpansionPacks();
         
@@ -534,6 +534,7 @@ class Installer {
           console.log(chalk.green(`  - ${packId} → .${packId}/`));
         }
         return;
+      }
       case "cancel":
         console.log("Installation cancelled.");
         return;
@@ -865,6 +866,8 @@ class Installer {
       }).join(", ");
       console.log(chalk.green(`✓ IDE rules and configurations set up for: ${ideNames}`));
     }
+    
+
 
     // Information about web bundles
     if (!config.includeWebBundles) {
@@ -1428,7 +1431,7 @@ class Installer {
         return config.selectedWebBundleTeams ? 
           `teams: ${config.selectedWebBundleTeams.join(', ')}` : 
           'selected teams';
-      case 'custom':
+      case 'custom': {
         const parts = [];
         if (config.selectedWebBundleTeams && config.selectedWebBundleTeams.length > 0) {
           parts.push(`teams: ${config.selectedWebBundleTeams.join(', ')}`);
@@ -1437,6 +1440,7 @@ class Installer {
           parts.push('individual agents');
         }
         return parts.length > 0 ? parts.join(' + ') : 'custom selection';
+      }
       default:
         return 'selected bundles';
     }
@@ -1741,6 +1745,28 @@ class Installer {
 
     return null;
   }
+
+  async flatten(options) {
+    const { spawn } = require('child_process');
+    const flattenerPath = path.join(__dirname, '..', '..', 'flattener', 'main.js');
+    
+    const args = [];
+    if (options.input) {
+      args.push('--input', options.input);
+    }
+    if (options.output) {
+      args.push('--output', options.output);
+    }
+    
+    const child = spawn('node', [flattenerPath, ...args], {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+    
+    child.on('exit', (code) => {
+      process.exit(code);
+    });
+  }
 }
 
 module.exports = new Installer();