bmad-plus 0.8.0 → 0.9.1

package/tools/cli/lib/memory-init.js

@@ -0,0 +1,113 @@
+/**
+ * BMAD+ Memory Initialization Module
+ * Extracted from install.js — initializes brain with existing brain detection.
+ *
+ * Author: Laurent Rochetta
+ */
+
+const path = require('node:path');
+const fs = require('node:fs');
+const os = require('node:os');
+const fsExtra = require('fs-extra');
+const clack = require('@clack/prompts');
+
+/**
+ * Initialize the memory pack: create project memory files, detect or create global brain.
+ *
+ * @param {object} opts
+ * @param {string} opts.projectDir     - Target project directory
+ * @param {string} opts.bmadSrc        - Path to src/bmad-plus/
+ * @param {string} opts.userName       - User display name
+ * @param {string} opts.commLang       - Communication language
+ * @param {string[]} opts.selectedPacks - Array of pack IDs being installed
+ * @param {object} opts.i              - i18n translations object
+ * @returns {void}
+ */
+function initMemory({ projectDir, bmadSrc, userName, commLang, selectedPacks }) {
+  const memoryDir = path.join(projectDir, '.agents', 'memory');
+  const sessionsDir = path.join(memoryDir, 'sessions');
+  const globalBrainDir = path.join(os.homedir(), '.bmad-plus', 'brain', 'projects');
+  const templateDir = path.join(bmadSrc, 'packs', 'pack-memory', 'templates');
+
+  // Create project memory (never overwrite existing)
+  fsExtra.ensureDirSync(sessionsDir);
+  const memoryFiles = ['decisions.md', 'lessons.md', 'patterns.md', 'context.md'];
+  for (const mf of memoryFiles) {
+    const dest = path.join(memoryDir, mf);
+    if (!fs.existsSync(dest)) {
+      const src = path.join(templateDir, mf);
+      if (fs.existsSync(src)) {
+        let content = fs.readFileSync(src, 'utf8');
+        content = content.replace(/\{\{date\}\}/g, new Date().toISOString().slice(0, 10));
+        content = content.replace(/\{\{project_name\}\}/g, path.basename(projectDir));
+        content = content.replace(/\{\{project_path\}\}/g, projectDir);
+        fs.writeFileSync(dest, content, 'utf8');
+      }
+    }
+  }
+
+  // Detect existing brain directories
+  const brainCandidates = [
+    path.join(os.homedir(), '.bmad-plus', 'brain'),
+    path.join(projectDir, '_brain'),
+    path.join(os.homedir(), '.claude', 'memory'),
+  ];
+  const existingBrain = brainCandidates.find(p => fs.existsSync(p));
+
+  if (existingBrain) {
+    clack.log.info(`🧠 Existing brain detected: ${existingBrain}`);
+    // Write brain link pointer
+    fs.writeFileSync(
+      path.join(memoryDir, '.brain-link'),
+      JSON.stringify({ linked_brain: existingBrain, linked_at: new Date().toISOString() }, null, 2),
+      'utf8'
+    );
+  } else {
+    // Create fresh global brain
+    fsExtra.ensureDirSync(globalBrainDir);
+    const identitySrc = path.join(templateDir, 'identity.yaml');
+    const identityDest = path.join(os.homedir(), '.bmad-plus', 'brain', 'identity.yaml');
+    if (fs.existsSync(identitySrc) && !fs.existsSync(identityDest)) {
+      let content = fs.readFileSync(identitySrc, 'utf8');
+      content = content.replace(/\{\{user_name\}\}/g, userName);
+      content = content.replace(/\{\{language\}\}/g, commLang);
+      content = content.replace(/\{\{date\}\}/g, new Date().toISOString().slice(0, 10));
+      fs.writeFileSync(identityDest, content, 'utf8');
+    }
+    // Copy global memory templates
+    for (const gf of ['decisions.md', 'lessons.md', 'patterns.md']) {
+      const dest = path.join(os.homedir(), '.bmad-plus', 'brain', gf);
+      if (!fs.existsSync(dest)) {
+        const src = path.join(templateDir, gf);
+        if (fs.existsSync(src)) {
+          let content = fs.readFileSync(src, 'utf8');
+          content = content.replace(/\{\{date\}\}/g, new Date().toISOString().slice(0, 10));
+          content = content.replace(/\{\{project_name\}\}/g, 'Global Brain');
+          fs.writeFileSync(dest, content, 'utf8');
+        }
+      }
+    }
+    clack.log.info(`🧠 Global brain created: ${path.join(os.homedir(), '.bmad-plus', 'brain')}`);
+  }
+
+  // Index this project in global brain
+  const crypto = require('node:crypto');
+  const projHash = crypto.createHash('sha256').update(projectDir).digest('hex').slice(0, 8);
+  const projMeta = {
+    path: projectDir,
+    name: path.basename(projectDir),
+    hash: projHash,
+    status: 'active',
+    bmad_installed: true,
+    packs_installed: selectedPacks,
+    last_scanned: new Date().toISOString().slice(0, 10),
+  };
+  fsExtra.ensureDirSync(globalBrainDir);
+  fs.writeFileSync(
+    path.join(globalBrainDir, `${projHash}.yaml`),
+    Object.entries(projMeta).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join('\n'),
+    'utf8'
+  );
+}
+
+module.exports = { initMemory };

package/tools/cli/lib/pack-copy.js

@@ -0,0 +1,84 @@
+/**
+ * BMAD+ Shared Pack-Copy Module
+ * Extracted duplicate file-copy loops from install.js and update.js.
+ *
+ * Author: Laurent Rochetta
+ */
+
+const path = require('node:path');
+const fs = require('node:fs');
+const fsExtra = require('fs-extra');
+
+/**
+ * Copy files for a single pack definition into the target directories.
+ *
+ * @param {object} opts
+ * @param {string} opts.bmadSrc      - Path to src/bmad-plus/
+ * @param {string} opts.targetAgentsDir - Destination for agents / skills
+ * @param {string} opts.targetDataDir   - Destination for data files
+ * @param {string} opts.projectRoot    - Project root (for external package resolution)
+ * @param {object} opts.pack           - Pack definition from PACKS
+ * @returns {{ copiedAgents: number, copiedSkills: number, copiedFiles: number }}
+ */
+function copyPackFiles({ bmadSrc, targetAgentsDir, targetDataDir, projectRoot, pack }) {
+  let copiedAgents = 0;
+  let copiedSkills = 0;
+  let copiedFiles = 0;
+
+  if (!pack) return { copiedAgents, copiedSkills, copiedFiles };
+
+  // Copy agents
+  for (const agent of (pack.agents || [])) {
+    const src = path.join(bmadSrc, 'agents', agent);
+    const dest = path.join(targetAgentsDir, agent);
+    if (fs.existsSync(src)) {
+      fsExtra.copySync(src, dest, { overwrite: true });
+      copiedAgents++;
+    }
+  }
+
+  // Copy skills
+  for (const skill of (pack.skills || [])) {
+    const src = path.join(bmadSrc, 'skills', skill);
+    const dest = path.join(targetAgentsDir, skill);
+    if (fs.existsSync(src)) {
+      fsExtra.copySync(src, dest, { overwrite: true });
+      copiedSkills++;
+    }
+  }
+
+  // Copy data files
+  for (const dataFile of (pack.data || [])) {
+    const src = path.join(bmadSrc, 'data', dataFile);
+    const dest = path.join(targetDataDir, dataFile);
+    if (fs.existsSync(src)) {
+      fsExtra.copySync(src, dest, { overwrite: true });
+      copiedFiles++;
+    }
+  }
+
+  // Copy external package (e.g. OSINT)
+  if (pack.externalPackage) {
+    const extSrc = path.join(projectRoot, pack.externalPackage, 'skills');
+    if (fs.existsSync(extSrc)) {
+      fsExtra.copySync(extSrc, targetAgentsDir, { overwrite: true });
+      copiedSkills++;
+    }
+  }
+
+  // Copy pack directory (SEO, Backup, Animated, Shield, etc.)
+  if (pack.packDir) {
+    const srcParent = pack.packSrcDir || 'agents';
+    const packSrc = path.join(bmadSrc, srcParent, pack.packDir);
+    const packDest = path.join(targetAgentsDir, pack.packDir);
+    if (fs.existsSync(packSrc)) {
+      fsExtra.copySync(packSrc, packDest, { overwrite: true });
+      copiedAgents++;
+      copiedFiles++;
+    }
+  }
+
+  return { copiedAgents, copiedSkills, copiedFiles };
+}
+
+module.exports = { copyPackFiles };

package/tools/cli/lib/packs.js

@@ -0,0 +1,114 @@
+/**
+ * BMAD+ Shared PACKS Module
+ * Single source of truth for pack definitions, expected agents, and pack ordering.
+ *
+ * Author: Laurent Rochetta
+ */
+
+const PACKS = {
+  core: {
+    name: 'Core',
+    icon: 'b',
+    agents: ['agent-strategist', 'agent-architect-dev', 'agent-quality', 'agent-orchestrator'],
+    skills: ['bmad-plus-autopilot', 'bmad-plus-parallel', 'bmad-plus-sync'],
+    data: ['role-triggers.yaml'],
+    packDir: 'pack-core',
+    packSrcDir: 'packs',
+    required: true,
+    desc: 'Core agents & skills',
+  },
+  osint: {
+    name: 'OSINT',
+    icon: 'j',
+    agents: ['agent-shadow'],
+    skills: [],
+    externalPackage: 'osint-agent-package',
+    packDir: 'pack-osint',
+    packSrcDir: 'packs',
+    desc: 'OSINT & investigation',
+  },
+  maker: {
+    name: 'Maker',
+    icon: 'f',
+    agents: ['agent-maker'],
+    skills: [],
+    data: [],
+    packDir: 'pack-maker',
+    packSrcDir: 'packs',
+    desc: 'Agent creation toolkit',
+  },
+  shield: {
+    name: 'Shield',
+    icon: 'm',
+    agents: ['shield-orchestrator'],
+    skills: [],
+    packDir: 'pack-shield',
+    packSrcDir: 'packs',
+    desc: 'GRC compliance (25+ frameworks)',
+  },
+  seo: {
+    name: 'SEO',
+    icon: 'k',
+    agents: ['seo-scout', 'seo-chief', 'seo-judge'],
+    skills: [],
+    packDir: 'pack-seo',
+    packSrcDir: 'packs',
+    desc: 'SEO audit & optimization',
+  },
+  memory: {
+    name: 'Memory',
+    icon: 'x',
+    agents: ['zecher'],
+    skills: [],
+    packDir: 'pack-memory',
+    packSrcDir: 'packs',
+    desc: 'Persistent cross-session memory',
+  },
+  'dev-studio': {
+    name: 'Dev Studio',
+    icon: 'v',
+    agents: ['dev-studio-orchestrator'],
+    skills: ['dev-studio'],
+    packDir: 'pack-dev-studio',
+    packSrcDir: 'packs',
+    desc: 'SDLC automation (6 agents, 56+ skills)',
+  },
+  backup: {
+    name: 'Backup',
+    icon: 'y',
+    agents: ['backup-agent'],
+    skills: [],
+    packDir: 'pack-backup',
+    packSrcDir: 'packs',
+    desc: 'Backup & restore',
+  },
+  animated: {
+    name: 'Animated',
+    icon: 'z',
+    agents: ['animated-website-agent'],
+    skills: [],
+    packDir: 'pack-animated',
+    packSrcDir: 'packs',
+    desc: 'Animated website agents',
+  },
+};
+
+const PACK_ORDER = ['core', 'osint', 'maker', 'shield', 'seo', 'memory', 'dev-studio', 'backup', 'animated'];
+
+/**
+ * Maps each pack to the list of directory names expected under .agents/skills/
+ * after installation. Each entry contains agent directory names AND/OR pack directory names.
+ */
+const EXPECTED_AGENTS = {
+  core:       { agents: ['agent-strategist', 'agent-architect-dev', 'agent-quality', 'agent-orchestrator'], packDir: null },
+  osint:      { agents: ['agent-shadow'],                                                                    packDir: null },
+  maker:      { agents: ['agent-maker'],                                                                     packDir: null },
+  shield:     { agents: ['shield-orchestrator'],                                                             packDir: 'pack-shield' },
+  seo:        { agents: ['seo-scout', 'seo-chief', 'seo-judge'],                                             packDir: 'pack-seo' },
+  memory:     { agents: ['zecher'],                                                                          packDir: 'pack-memory' },
+  'dev-studio':  { agents: ['dev-studio-orchestrator'],                                                       packDir: 'pack-dev-studio' },
+  backup:     { agents: ['backup-agent'],                                                                    packDir: 'pack-backup' },
+  animated:   { agents: ['animated-website-agent'],                                                          packDir: 'pack-animated' },
+};
+
+module.exports = { PACKS, PACK_ORDER, EXPECTED_AGENTS };

package/tools/cli/lib/stack-detect.js

@@ -0,0 +1,102 @@
+/**
+ * BMAD+ Stack Detection — Shared Module
+ * Unified project stack detection for autoconfig and scan commands.
+ * Merges patterns from both original implementations.
+ */
+
+const path = require('node:path');
+const fs = require('node:fs');
+
+// ── Project Detection Markers (for scan.js) ──
+
+const PROJECT_MARKERS = [
+  { file: 'package.json', stack: 'Node.js', detect: (dir) => {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps['next']) return 'Next.js';
+      if (deps['nuxt']) return 'Nuxt';
+      if (deps['react']) return 'React';
+      if (deps['vue']) return 'Vue.js';
+      if (deps['svelte']) return 'Svelte';
+      if (deps['express']) return 'Express';
+      if (deps['fastify']) return 'Fastify';
+      if (deps['electron']) return 'Electron';
+      if (deps['tauri']) return 'Tauri';
+      return 'Node.js';
+    } catch {
+      return 'Node.js';
+    }
+  }},
+  { file: 'Cargo.toml', stack: 'Rust' },
+  { file: 'pyproject.toml', stack: 'Python' },
+  { file: 'requirements.txt', stack: 'Python' },
+  { file: 'go.mod', stack: 'Go' },
+  { file: 'composer.json', stack: 'PHP' },
+  { file: 'Gemfile', stack: 'Ruby' },
+  { file: 'pom.xml', stack: 'Java' },
+  { file: 'build.gradle', stack: 'Java/Kotlin' },
+];
+
+// ── Full Stack Detection (for autoconfig.js) ──
+
+function detectStack(dir) {
+  const result = {
+    language: null,
+    framework: null,
+    runtime: null,
+    packageManager: null,
+    hasTypeScript: false,
+  };
+
+  // Package.json analysis
+  const pkgPath = path.join(dir, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      result.runtime = 'Node.js';
+      result.language = deps['typescript'] || fs.existsSync(path.join(dir, 'tsconfig.json')) ? 'TypeScript' : 'JavaScript';
+      result.hasTypeScript = result.language === 'TypeScript';
+
+      // Framework detection
+      if (deps['next']) result.framework = 'Next.js';
+      else if (deps['nuxt']) result.framework = 'Nuxt';
+      else if (deps['@angular/core']) result.framework = 'Angular';
+      else if (deps['react']) result.framework = 'React';
+      else if (deps['vue']) result.framework = 'Vue.js';
+      else if (deps['svelte']) result.framework = 'Svelte';
+      else if (deps['express']) result.framework = 'Express';
+      else if (deps['fastify']) result.framework = 'Fastify';
+      else if (deps['hono']) result.framework = 'Hono';
+      else if (deps['electron']) result.framework = 'Electron';
+      else if (deps['tauri']) result.framework = 'Tauri';
+      else if (deps['react-native']) result.framework = 'React Native';
+
+      // Package manager
+      if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml'))) result.packageManager = 'pnpm';
+      else if (fs.existsSync(path.join(dir, 'yarn.lock'))) result.packageManager = 'yarn';
+      else if (fs.existsSync(path.join(dir, 'bun.lockb'))) result.packageManager = 'bun';
+      else result.packageManager = 'npm';
+    } catch (e) {
+      console.warn('stack-detect: Failed to parse package.json in detectStack', e.message);
+    }
+  }
+
+  // Other languages
+  if (!result.runtime) {
+    if (fs.existsSync(path.join(dir, 'Cargo.toml'))) { result.language = 'Rust'; result.runtime = 'Rust'; }
+    else if (fs.existsSync(path.join(dir, 'pyproject.toml')) || fs.existsSync(path.join(dir, 'requirements.txt'))) { result.language = 'Python'; result.runtime = 'Python'; }
+    else if (fs.existsSync(path.join(dir, 'go.mod'))) { result.language = 'Go'; result.runtime = 'Go'; }
+    else if (fs.existsSync(path.join(dir, 'composer.json'))) { result.language = 'PHP'; result.runtime = 'PHP'; }
+    else if (fs.existsSync(path.join(dir, 'Gemfile'))) { result.language = 'Ruby'; result.runtime = 'Ruby'; }
+    else if (fs.existsSync(path.join(dir, 'pom.xml')) || fs.existsSync(path.join(dir, 'build.gradle'))) { result.language = 'Java'; result.runtime = 'JVM'; }
+  }
+
+  return result;
+}
+
+module.exports = {
+  detectStack,
+  PROJECT_MARKERS,
+};

package/tools/cli/lib/validate.js

@@ -0,0 +1,45 @@
+/**
+ * BMAD+ User Input Validation Utilities
+ * Extracted from install.js for modularity and reuse.
+ */
+
+// Shell metacharacters that are dangerous in user-provided names
+const SHELL_META = /[;&|`$(){}[\]!#~<>*?\\\n\r]/;
+
+/**
+ * Validate and sanitize a user name.
+ * Rules:
+ *  - Must not be empty
+ *  - Must not exceed 100 characters
+ *  - Must not contain shell metacharacters
+ *
+ * @param {string} rawName - Raw user-provided name
+ * @param {string} fallback - Fallback name if validation fails
+ * @returns {{ name: string, warnings: string[] }} Sanitized name and any warnings
+ */
+function validateUserName(rawName, fallback) {
+  const warnings = [];
+
+  if (!rawName || rawName.trim().length === 0) {
+    warnings.push('Name cannot be empty. Using default.');
+    return { name: fallback, warnings };
+  }
+
+  if (rawName.length > 100) {
+    warnings.push('Name too long (>100 chars). Truncating.');
+    return { name: rawName.slice(0, 100), warnings };
+  }
+
+  if (SHELL_META.test(rawName)) {
+    const sanitized = rawName.replace(SHELL_META, '').trim() || 'Developer';
+    warnings.push('Name contains shell metacharacters. Using sanitized version.');
+    return { name: sanitized, warnings };
+  }
+
+  return { name: rawName, warnings };
+}
+
+module.exports = {
+  validateUserName,
+  SHELL_META,
+};