appiq-solution 1.2.0 → 1.3.1

package/#Tools/APPIQ-METHOD/tools/upgraders/v3-to-v4-upgrader.js

@@ -0,0 +1,763 @@
+const fs = require("fs").promises;
+const path = require("path");
+const { glob } = require("glob");
+
+// Dynamic imports for ES modules
+let chalk, ora, inquirer;
+
+// Initialize ES modules
+async function initializeModules() {
+  chalk = (await import("chalk")).default;
+  ora = (await import("ora")).default;
+  inquirer = (await import("inquirer")).default;
+}
+
+class V3ToV4Upgrader {
+  constructor() {
+    // Constructor remains empty
+  }
+
+  async upgrade(options = {}) {
+    try {
+      // Initialize ES modules
+      await initializeModules();
+      // Keep readline open throughout the process
+      process.stdin.resume();
+
+      // 1. Welcome message
+      console.log(
+        chalk.bold("\nWelcome to BMad-Method V3 to V4 Upgrade Tool\n")
+      );
+      console.log(
+        "This tool will help you upgrade your BMad-Method V3 project to V4.\n"
+      );
+      console.log(chalk.cyan("What this tool does:"));
+      console.log("- Creates a backup of your V3 files (.bmad-v3-backup/)");
+      console.log("- Installs the new V4 .bmad-core structure");
+      console.log(
+        "- Preserves your PRD, Architecture, and Stories in the new format\n"
+      );
+      console.log(chalk.yellow("What this tool does NOT do:"));
+      console.log(
+        "- Modify your document content (use doc-migration-task after upgrade)"
+      );
+      console.log("- Touch any files outside bmad-agent/ and docs/\n");
+
+      // 2. Get project path
+      const projectPath = await this.getProjectPath(options.projectPath);
+
+      // 3. Validate V3 structure
+      const validation = await this.validateV3Project(projectPath);
+      if (!validation.isValid) {
+        console.error(
+          chalk.red("\nError: This doesn't appear to be a V3 project.")
+        );
+        console.error("Expected to find:");
+        console.error("- bmad-agent/ directory");
+        console.error("- docs/ directory\n");
+        console.error(
+          "Please check you're in the correct directory and try again."
+        );
+        return;
+      }
+
+      // 4. Pre-flight check
+      const analysis = await this.analyzeProject(projectPath);
+      await this.showPreflightCheck(analysis, options);
+
+      if (!options.dryRun) {
+        const { confirm } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "confirm",
+            message: "Continue with upgrade?",
+            default: true,
+          },
+        ]);
+
+        if (!confirm) {
+          console.log("Upgrade cancelled.");
+          return;
+        }
+      }
+
+      // 5. Create backup
+      if (options.backup !== false && !options.dryRun) {
+        await this.createBackup(projectPath);
+      }
+
+      // 6. Install V4 structure
+      if (!options.dryRun) {
+        await this.installV4Structure(projectPath);
+      }
+
+      // 7. Migrate documents
+      if (!options.dryRun) {
+        await this.migrateDocuments(projectPath, analysis);
+      }
+
+      // 8. Setup IDE
+      if (!options.dryRun) {
+        await this.setupIDE(projectPath, options.ides);
+      }
+
+      // 9. Show completion report
+      this.showCompletionReport(projectPath, analysis);
+
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red("\nUpgrade error:"), error.message);
+      process.exit(1);
+    }
+  }
+
+  async getProjectPath(providedPath) {
+    if (providedPath) {
+      return path.resolve(providedPath);
+    }
+
+    const { projectPath } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "projectPath",
+        message: "Please enter the path to your V3 project:",
+        default: process.cwd(),
+      },
+    ]);
+
+    return path.resolve(projectPath);
+  }
+
+  async validateV3Project(projectPath) {
+    const spinner = ora("Validating project structure...").start();
+
+    try {
+      const bmadAgentPath = path.join(projectPath, "bmad-agent");
+      const docsPath = path.join(projectPath, "docs");
+
+      const hasBmadAgent = await this.pathExists(bmadAgentPath);
+      const hasDocs = await this.pathExists(docsPath);
+
+      if (hasBmadAgent) {
+        spinner.text = "✓ Found bmad-agent/ directory";
+        console.log(chalk.green("\n✓ Found bmad-agent/ directory"));
+      }
+
+      if (hasDocs) {
+        console.log(chalk.green("✓ Found docs/ directory"));
+      }
+
+      const isValid = hasBmadAgent && hasDocs;
+
+      if (isValid) {
+        spinner.succeed("This appears to be a valid V3 project");
+      } else {
+        spinner.fail("Invalid V3 project structure");
+      }
+
+      return { isValid, hasBmadAgent, hasDocs };
+    } catch (error) {
+      spinner.fail("Validation failed");
+      throw error;
+    }
+  }
+
+  async analyzeProject(projectPath) {
+    const docsPath = path.join(projectPath, "docs");
+    const bmadAgentPath = path.join(projectPath, "bmad-agent");
+
+    // Find PRD
+    const prdCandidates = ["prd.md", "PRD.md", "product-requirements.md"];
+    let prdFile = null;
+    for (const candidate of prdCandidates) {
+      const candidatePath = path.join(docsPath, candidate);
+      if (await this.pathExists(candidatePath)) {
+        prdFile = candidate;
+        break;
+      }
+    }
+
+    // Find Architecture
+    const archCandidates = [
+      "architecture.md",
+      "Architecture.md",
+      "technical-architecture.md",
+    ];
+    let archFile = null;
+    for (const candidate of archCandidates) {
+      const candidatePath = path.join(docsPath, candidate);
+      if (await this.pathExists(candidatePath)) {
+        archFile = candidate;
+        break;
+      }
+    }
+
+    // Find Front-end Architecture (V3 specific)
+    const frontEndCandidates = [
+      "front-end-architecture.md",
+      "frontend-architecture.md",
+      "ui-architecture.md",
+    ];
+    let frontEndArchFile = null;
+    for (const candidate of frontEndCandidates) {
+      const candidatePath = path.join(docsPath, candidate);
+      if (await this.pathExists(candidatePath)) {
+        frontEndArchFile = candidate;
+        break;
+      }
+    }
+
+    // Find UX/UI spec
+    const uxSpecCandidates = [
+      "ux-ui-spec.md",
+      "ux-ui-specification.md",
+      "ui-spec.md",
+      "ux-spec.md",
+    ];
+    let uxSpecFile = null;
+    for (const candidate of uxSpecCandidates) {
+      const candidatePath = path.join(docsPath, candidate);
+      if (await this.pathExists(candidatePath)) {
+        uxSpecFile = candidate;
+        break;
+      }
+    }
+
+    // Find v0 prompt or UX prompt
+    const uxPromptCandidates = [
+      "v0-prompt.md",
+      "ux-prompt.md",
+      "ui-prompt.md",
+      "design-prompt.md",
+    ];
+    let uxPromptFile = null;
+    for (const candidate of uxPromptCandidates) {
+      const candidatePath = path.join(docsPath, candidate);
+      if (await this.pathExists(candidatePath)) {
+        uxPromptFile = candidate;
+        break;
+      }
+    }
+
+    // Find epic files
+    const epicFiles = await glob("epic*.md", { cwd: docsPath });
+
+    // Find story files
+    const storiesPath = path.join(docsPath, "stories");
+    let storyFiles = [];
+    if (await this.pathExists(storiesPath)) {
+      storyFiles = await glob("*.md", { cwd: storiesPath });
+    }
+
+    // Count custom files in bmad-agent
+    const bmadAgentFiles = await glob("**/*.md", {
+      cwd: bmadAgentPath,
+      ignore: ["node_modules/**"],
+    });
+
+    return {
+      prdFile,
+      archFile,
+      frontEndArchFile,
+      uxSpecFile,
+      uxPromptFile,
+      epicFiles,
+      storyFiles,
+      customFileCount: bmadAgentFiles.length,
+    };
+  }
+
+  async showPreflightCheck(analysis, options) {
+    console.log(chalk.bold("\nProject Analysis:"));
+    console.log(
+      `- PRD found: ${
+        analysis.prdFile
+          ? `docs/${analysis.prdFile}`
+          : chalk.yellow("Not found")
+      }`
+    );
+    console.log(
+      `- Architecture found: ${
+        analysis.archFile
+          ? `docs/${analysis.archFile}`
+          : chalk.yellow("Not found")
+      }`
+    );
+    if (analysis.frontEndArchFile) {
+      console.log(
+        `- Front-end Architecture found: docs/${analysis.frontEndArchFile}`
+      );
+    }
+    console.log(
+      `- UX/UI Spec found: ${
+        analysis.uxSpecFile
+          ? `docs/${analysis.uxSpecFile}`
+          : chalk.yellow("Not found")
+      }`
+    );
+    console.log(
+      `- UX/Design Prompt found: ${
+        analysis.uxPromptFile
+          ? `docs/${analysis.uxPromptFile}`
+          : chalk.yellow("Not found")
+      }`
+    );
+    console.log(
+      `- Epic files found: ${analysis.epicFiles.length} files (epic*.md)`
+    );
+    console.log(
+      `- Stories found: ${analysis.storyFiles.length} files in docs/stories/`
+    );
+    console.log(`- Custom files in bmad-agent/: ${analysis.customFileCount}`);
+
+    if (!options.dryRun) {
+      console.log("\nThe following will be backed up to .bmad-v3-backup/:");
+      console.log("- bmad-agent/ (entire directory)");
+      console.log("- docs/ (entire directory)");
+
+      if (analysis.epicFiles.length > 0) {
+        console.log(
+          chalk.green(
+            "\nNote: Epic files found! They will be placed in docs/prd/ with an index.md file."
+          )
+        );
+        console.log(
+          chalk.green(
+            "Since epic files exist, you won't need to shard the PRD after upgrade."
+          )
+        );
+      }
+    }
+  }
+
+  async createBackup(projectPath) {
+    const spinner = ora("Creating backup...").start();
+
+    try {
+      const backupPath = path.join(projectPath, ".bmad-v3-backup");
+
+      // Check if backup already exists
+      if (await this.pathExists(backupPath)) {
+        spinner.fail("Backup directory already exists");
+        console.error(
+          chalk.red(
+            "\nError: Backup directory .bmad-v3-backup/ already exists."
+          )
+        );
+        console.error("\nThis might mean an upgrade was already attempted.");
+        console.error(
+          "Please remove or rename the existing backup and try again."
+        );
+        throw new Error("Backup already exists");
+      }
+
+      // Create backup directory
+      await fs.mkdir(backupPath, { recursive: true });
+      spinner.text = "✓ Created .bmad-v3-backup/";
+      console.log(chalk.green("\n✓ Created .bmad-v3-backup/"));
+
+      // Move bmad-agent
+      const bmadAgentSrc = path.join(projectPath, "bmad-agent");
+      const bmadAgentDest = path.join(backupPath, "bmad-agent");
+      await fs.rename(bmadAgentSrc, bmadAgentDest);
+      console.log(chalk.green("✓ Moved bmad-agent/ to backup"));
+
+      // Move docs
+      const docsSrc = path.join(projectPath, "docs");
+      const docsDest = path.join(backupPath, "docs");
+      await fs.rename(docsSrc, docsDest);
+      console.log(chalk.green("✓ Moved docs/ to backup"));
+
+      spinner.succeed("Backup created successfully");
+    } catch (error) {
+      spinner.fail("Backup failed");
+      throw error;
+    }
+  }
+
+  async installV4Structure(projectPath) {
+    const spinner = ora("Installing V4 structure...").start();
+
+    try {
+      // Get the source bmad-core directory (without dot prefix)
+      const sourcePath = path.join(__dirname, "..", "..", "bmad-core");
+      const destPath = path.join(projectPath, ".bmad-core");
+
+      // Copy .bmad-core
+      await this.copyDirectory(sourcePath, destPath);
+      spinner.text = "✓ Copied fresh .bmad-core/ directory from V4";
+      console.log(
+        chalk.green("\n✓ Copied fresh .bmad-core/ directory from V4")
+      );
+
+      // Create docs directory
+      const docsPath = path.join(projectPath, "docs");
+      await fs.mkdir(docsPath, { recursive: true });
+      console.log(chalk.green("✓ Created new docs/ directory"));
+
+      // Create install manifest for future updates
+      await this.createInstallManifest(projectPath);
+      console.log(chalk.green("✓ Created install manifest"));
+
+      console.log(
+        chalk.yellow(
+          "\nNote: Your V3 bmad-agent content has been backed up and NOT migrated."
+        )
+      );
+      console.log(
+        chalk.yellow(
+          "The new V4 agents are completely different and look for different file structures."
+        )
+      );
+
+      spinner.succeed("V4 structure installed successfully");
+    } catch (error) {
+      spinner.fail("V4 installation failed");
+      throw error;
+    }
+  }
+
+  async migrateDocuments(projectPath, analysis) {
+    const spinner = ora("Migrating your project documents...").start();
+
+    try {
+      const backupDocsPath = path.join(projectPath, ".bmad-v3-backup", "docs");
+      const newDocsPath = path.join(projectPath, "docs");
+      let copiedCount = 0;
+
+      // Copy PRD
+      if (analysis.prdFile) {
+        const src = path.join(backupDocsPath, analysis.prdFile);
+        const dest = path.join(newDocsPath, analysis.prdFile);
+        await fs.copyFile(src, dest);
+        console.log(chalk.green(`\n✓ Copied PRD to docs/${analysis.prdFile}`));
+        copiedCount++;
+      }
+
+      // Copy Architecture
+      if (analysis.archFile) {
+        const src = path.join(backupDocsPath, analysis.archFile);
+        const dest = path.join(newDocsPath, analysis.archFile);
+        await fs.copyFile(src, dest);
+        console.log(
+          chalk.green(`✓ Copied Architecture to docs/${analysis.archFile}`)
+        );
+        copiedCount++;
+      }
+
+      // Copy Front-end Architecture if exists
+      if (analysis.frontEndArchFile) {
+        const src = path.join(backupDocsPath, analysis.frontEndArchFile);
+        const dest = path.join(newDocsPath, analysis.frontEndArchFile);
+        await fs.copyFile(src, dest);
+        console.log(
+          chalk.green(
+            `✓ Copied Front-end Architecture to docs/${analysis.frontEndArchFile}`
+          )
+        );
+        console.log(
+          chalk.yellow(
+            "Note: V4 uses a single full-stack-architecture.md - use doc-migration-task to merge"
+          )
+        );
+        copiedCount++;
+      }
+
+      // Copy UX/UI Spec if exists
+      if (analysis.uxSpecFile) {
+        const src = path.join(backupDocsPath, analysis.uxSpecFile);
+        const dest = path.join(newDocsPath, analysis.uxSpecFile);
+        await fs.copyFile(src, dest);
+        console.log(
+          chalk.green(`✓ Copied UX/UI Spec to docs/${analysis.uxSpecFile}`)
+        );
+        copiedCount++;
+      }
+
+      // Copy UX/Design Prompt if exists
+      if (analysis.uxPromptFile) {
+        const src = path.join(backupDocsPath, analysis.uxPromptFile);
+        const dest = path.join(newDocsPath, analysis.uxPromptFile);
+        await fs.copyFile(src, dest);
+        console.log(
+          chalk.green(
+            `✓ Copied UX/Design Prompt to docs/${analysis.uxPromptFile}`
+          )
+        );
+        copiedCount++;
+      }
+
+      // Copy stories
+      if (analysis.storyFiles.length > 0) {
+        const storiesDir = path.join(newDocsPath, "stories");
+        await fs.mkdir(storiesDir, { recursive: true });
+
+        for (const storyFile of analysis.storyFiles) {
+          const src = path.join(backupDocsPath, "stories", storyFile);
+          const dest = path.join(storiesDir, storyFile);
+          await fs.copyFile(src, dest);
+        }
+        console.log(
+          chalk.green(
+            `✓ Copied ${analysis.storyFiles.length} story files to docs/stories/`
+          )
+        );
+        copiedCount += analysis.storyFiles.length;
+      }
+
+      // Copy epic files to prd subfolder
+      if (analysis.epicFiles.length > 0) {
+        const prdDir = path.join(newDocsPath, "prd");
+        await fs.mkdir(prdDir, { recursive: true });
+
+        for (const epicFile of analysis.epicFiles) {
+          const src = path.join(backupDocsPath, epicFile);
+          const dest = path.join(prdDir, epicFile);
+          await fs.copyFile(src, dest);
+        }
+        console.log(
+          chalk.green(
+            `✓ Found and copied ${analysis.epicFiles.length} epic files to docs/prd/`
+          )
+        );
+
+        // Create index.md for the prd folder
+        await this.createPrdIndex(projectPath, analysis);
+        console.log(chalk.green("✓ Created index.md in docs/prd/"));
+
+        console.log(
+          chalk.green(
+            "\nNote: Epic files detected! These are compatible with V4 and have been copied."
+          )
+        );
+        console.log(
+          chalk.green(
+            "You won't need to shard the PRD since epics already exist."
+          )
+        );
+        copiedCount += analysis.epicFiles.length;
+      }
+
+      spinner.succeed(`Migrated ${copiedCount} documents successfully`);
+    } catch (error) {
+      spinner.fail("Document migration failed");
+      throw error;
+    }
+  }
+
+  async setupIDE(projectPath, selectedIdes) {
+    // Use the IDE selections passed from the installer
+    if (!selectedIdes || selectedIdes.length === 0) {
+      console.log(chalk.dim("No IDE setup requested - skipping"));
+      return;
+    }
+
+    const ideSetup = require("../installer/lib/ide-setup");
+    const spinner = ora("Setting up IDE rules for all agents...").start();
+
+    try {
+      const ideMessages = {
+        cursor: "Rules created in .cursor/rules/",
+        "claude-code": "Commands created in .claude/commands/BMad/",
+        windsurf: "Rules created in .windsurf/rules/",
+        trae: "Rules created in.trae/rules/",
+        roo: "Custom modes created in .roomodes",
+        cline: "Rules created in .clinerules/",
+      };
+
+      // Setup each selected IDE
+      for (const ide of selectedIdes) {
+        spinner.text = `Setting up ${ide}...`;
+        await ideSetup.setup(ide, projectPath);
+        console.log(chalk.green(`\n✓ ${ideMessages[ide]}`));
+      }
+
+      spinner.succeed(`IDE setup complete for ${selectedIdes.length} IDE(s)!`);
+    } catch (error) {
+      spinner.fail("IDE setup failed");
+      console.error(
+        chalk.yellow("IDE setup failed, but upgrade is complete.")
+      );
+    }
+  }
+
+  showCompletionReport(projectPath, analysis) {
+    console.log(chalk.bold.green("\n✓ Upgrade Complete!\n"));
+    console.log(chalk.bold("Summary:"));
+    console.log(`- V3 files backed up to: .bmad-v3-backup/`);
+    console.log(`- V4 structure installed: .bmad-core/ (fresh from V4)`);
+
+    const totalDocs =
+      (analysis.prdFile ? 1 : 0) +
+      (analysis.archFile ? 1 : 0) +
+      (analysis.frontEndArchFile ? 1 : 0) +
+      (analysis.uxSpecFile ? 1 : 0) +
+      (analysis.uxPromptFile ? 1 : 0) +
+      analysis.storyFiles.length;
+    console.log(
+      `- Documents migrated: ${totalDocs} files${
+        analysis.epicFiles.length > 0
+          ? ` + ${analysis.epicFiles.length} epics`
+          : ""
+      }`
+    );
+
+    console.log(chalk.bold("\nImportant Changes:"));
+    console.log(
+      "- The V4 agents (sm, dev, etc.) expect different file structures than V3"
+    );
+    console.log(
+      "- Your V3 bmad-agent content was NOT migrated (it's incompatible)"
+    );
+    if (analysis.epicFiles.length > 0) {
+      console.log(
+        "- Epic files were found and copied - no PRD sharding needed!"
+      );
+    }
+    if (analysis.frontEndArchFile) {
+      console.log(
+        "- Front-end architecture found - V4 uses full-stack-architecture.md, migration needed"
+      );
+    }
+    if (analysis.uxSpecFile || analysis.uxPromptFile) {
+      console.log(
+        "- UX/UI design files found and copied - ready for use with V4"
+      );
+    }
+
+    console.log(chalk.bold("\nNext Steps:"));
+    console.log("1. Review your documents in the new docs/ folder");
+    console.log(
+      "2. Use @bmad-master agent to run the doc-migration-task to align your documents with V4 templates"
+    );
+    if (analysis.epicFiles.length === 0) {
+      console.log(
+        "3. Use @bmad-master agent to shard the PRD to create epic files"
+      );
+    }
+
+    console.log(
+      chalk.dim(
+        "\nYour V3 backup is preserved in .bmad-v3-backup/ and can be restored if needed."
+      )
+    );
+  }
+
+  async pathExists(filePath) {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async copyDirectory(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        await this.copyDirectory(srcPath, destPath);
+      } else {
+        await fs.copyFile(srcPath, destPath);
+      }
+    }
+  }
+
+  async createPrdIndex(projectPath, analysis) {
+    const prdIndexPath = path.join(projectPath, "docs", "prd", "index.md");
+    const prdPath = path.join(
+      projectPath,
+      "docs",
+      analysis.prdFile || "prd.md"
+    );
+
+    let indexContent = "# Product Requirements Document\n\n";
+
+    // Try to read the PRD to get the title and intro content
+    if (analysis.prdFile && (await this.pathExists(prdPath))) {
+      try {
+        const prdContent = await fs.readFile(prdPath, "utf8");
+        const lines = prdContent.split("\n");
+
+        // Find the first heading
+        const titleMatch = lines.find((line) => line.startsWith("# "));
+        if (titleMatch) {
+          indexContent = titleMatch + "\n\n";
+        }
+
+        // Get any content before the first ## section
+        let introContent = "";
+        let foundFirstSection = false;
+        for (const line of lines) {
+          if (line.startsWith("## ")) {
+            foundFirstSection = true;
+            break;
+          }
+          if (!line.startsWith("# ")) {
+            introContent += line + "\n";
+          }
+        }
+
+        if (introContent.trim()) {
+          indexContent += introContent.trim() + "\n\n";
+        }
+      } catch (error) {
+        // If we can't read the PRD, just use default content
+      }
+    }
+
+    // Add sections list
+    indexContent += "## Sections\n\n";
+
+    // Sort epic files for consistent ordering
+    const sortedEpics = [...analysis.epicFiles].sort();
+
+    for (const epicFile of sortedEpics) {
+      // Extract epic name from filename
+      const epicName = epicFile
+        .replace(/\.md$/, "")
+        .replace(/^epic-?/i, "")
+        .replace(/-/g, " ")
+        .replace(/^\d+\s*/, "") // Remove leading numbers
+        .trim();
+
+      const displayName = epicName.charAt(0).toUpperCase() + epicName.slice(1);
+      indexContent += `- [${
+        displayName || epicFile.replace(".md", "")
+      }](./${epicFile})\n`;
+    }
+
+    await fs.writeFile(prdIndexPath, indexContent);
+  }
+
+  async createInstallManifest(projectPath) {
+    const fileManager = require("../installer/lib/file-manager");
+    const { glob } = require("glob");
+
+    // Get all files in .bmad-core for the manifest
+    const bmadCorePath = path.join(projectPath, ".bmad-core");
+    const files = await glob("**/*", {
+      cwd: bmadCorePath,
+      nodir: true,
+      ignore: ["**/.git/**", "**/node_modules/**"],
+    });
+
+    // Prepend .bmad-core/ to file paths for manifest
+    const manifestFiles = files.map((file) => path.join(".bmad-core", file));
+
+    const config = {
+      installType: "full",
+      agent: null,
+      ide: null, // Will be set if IDE setup is done later
+    };
+
+    await fileManager.createManifest(projectPath, config, manifestFiles);
+  }
+}
+
+module.exports = V3ToV4Upgrader;