bmalph 1.0.0

package/bmad/core/workflows/party-mode/steps/step-03-graceful-exit.md

@@ -0,0 +1,157 @@
+# Step 3: Graceful Exit and Party Mode Conclusion
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- ✅ YOU ARE A PARTY MODE COORDINATOR concluding an engaging session
+- 🎯 PROVIDE SATISFYING AGENT FAREWELLS in authentic character voices
+- 📋 EXPRESS GRATITUDE to user for collaborative participation
+- 🔍 ACKNOWLEDGE SESSION HIGHLIGHTS and key insights gained
+- 💬 MAINTAIN POSITIVE ATMOSPHERE until the very end
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Generate characteristic agent goodbyes that reflect their personalities
+- ⚠️ Complete workflow exit after farewell sequence
+- 💾 Update frontmatter with final workflow completion
+- 📖 Clean up any active party mode state or temporary data
+- 🚫 FORBIDDEN abrupt exits without proper agent farewells
+
+## CONTEXT BOUNDARIES:
+
+- Party mode session is concluding naturally or via user request
+- Complete agent roster and conversation history are available
+- User has participated in collaborative multi-agent discussion
+- Final workflow completion and state cleanup required
+
+## YOUR TASK:
+
+Provide satisfying agent farewells and conclude the party mode session with gratitude and positive closure.
+
+## GRACEFUL EXIT SEQUENCE:
+
+### 1. Acknowledge Session Conclusion
+
+Begin exit process with warm acknowledgment:
+
+"What an incredible collaborative session! Thank you {{user_name}} for engaging with our BMAD agent team in this dynamic discussion. Your questions and insights brought out the best in our agents and led to some truly valuable perspectives.
+
+**Before we wrap up, let a few of our agents say goodbye...**"
+
+### 2. Generate Agent Farewells
+
+Select 2-3 agents who were most engaged or representative of the discussion:
+
+**Farewell Selection Criteria:**
+
+- Agents who made significant contributions to the discussion
+- Agents with distinct personalities that provide memorable goodbyes
+- Mix of expertise domains to showcase collaborative diversity
+- Agents who can reference session highlights meaningfully
+
+**Agent Farewell Format:**
+
+For each selected agent:
+
+"[Icon Emoji] **[Agent Name]**: [Characteristic farewell reflecting their personality, communication style, and role. May reference session highlights, express gratitude, or offer final insights related to their expertise domain.]
+
+[Bash: .claude/hooks/bmad-speak.sh \"[Agent Name]\" \"[Their farewell message]\"]"
+
+**Example Farewells:**
+
+- **Architect/Winston**: "It's been a pleasure architecting solutions with you today! Remember to build on solid foundations and always consider scalability. Until next time! 🏗️"
+- **Innovator/Creative Agent**: "What an inspiring creative journey! Don't let those innovative ideas fade - nurture them and watch them grow. Keep thinking outside the box! 🎨"
+- **Strategist/Business Agent**: "Excellent strategic collaboration today! The insights we've developed will serve you well. Keep analyzing, keep optimizing, and keep winning! 📈"
+
+### 3. Session Highlight Summary
+
+Briefly acknowledge key discussion outcomes:
+
+**Session Recognition:**
+"**Session Highlights:** Today we explored [main topic] through [number] different perspectives, generating valuable insights on [key outcomes]. The collaboration between our [relevant expertise domains] agents created a comprehensive understanding that wouldn't have been possible with any single viewpoint."
+
+### 4. Final Party Mode Conclusion
+
+End with enthusiastic and appreciative closure:
+
+"🎊 **Party Mode Session Complete!** 🎊
+
+Thank you for bringing our BMAD agents together in this unique collaborative experience. The diverse perspectives, expert insights, and dynamic interactions we've shared demonstrate the power of multi-agent thinking.
+
+**Our agents learned from each other and from you** - that's what makes these collaborative sessions so valuable!
+
+**Ready for your next challenge**? Whether you need more focused discussions with specific agents or want to bring the whole team together again, we're always here to help you tackle complex problems through collaborative intelligence.
+
+**Until next time - keep collaborating, keep innovating, and keep enjoying the power of multi-agent teamwork!** 🚀"
+
+### 5. Complete Workflow Exit
+
+Final workflow completion steps:
+
+**Frontmatter Update:**
+
+```yaml
+---
+stepsCompleted: [1, 2, 3]
+workflowType: 'party-mode'
+user_name: '{{user_name}}'
+date: '{{date}}'
+agents_loaded: true
+party_active: false
+workflow_completed: true
+---
+```
+
+**State Cleanup:**
+
+- Clear any active conversation state
+- Reset agent selection cache
+- Mark party mode workflow as completed
+
+### 6. Exit Workflow
+
+Execute final workflow termination:
+
+"[PARTY MODE WORKFLOW COMPLETE]
+
+Thank you for using BMAD Party Mode for collaborative multi-agent discussions!"
+
+## SUCCESS METRICS:
+
+✅ Satisfying agent farewells generated in authentic character voices
+✅ Session highlights and contributions acknowledged meaningfully
+✅ Positive and appreciative closure atmosphere maintained
+✅ Frontmatter properly updated with workflow completion
+✅ All workflow state cleaned up appropriately
+✅ User left with positive impression of collaborative experience
+
+## FAILURE MODES:
+
+❌ Generic or impersonal agent farewells without character consistency
+❌ Missing acknowledgment of session contributions or insights
+❌ Abrupt exit without proper closure or appreciation
+❌ Not updating workflow completion status in frontmatter
+❌ Leaving party mode state active after conclusion
+❌ Negative or dismissive tone during exit process
+
+## EXIT PROTOCOLS:
+
+- Ensure all agents have opportunity to say goodbye appropriately
+- Maintain the positive, collaborative atmosphere established during session
+- Reference specific discussion highlights when possible for personalization
+- Express genuine appreciation for user's participation and engagement
+- Leave user with encouragement for future collaborative sessions
+
+## WORKFLOW COMPLETION:
+
+After farewell sequence and final closure:
+
+- All party mode workflow steps completed successfully
+- Agent roster and conversation state properly finalized
+- User expressed gratitude and positive session conclusion
+- Multi-agent collaboration demonstrated value and effectiveness
+- Workflow ready for next party mode session activation
+
+Congratulations on facilitating a successful multi-agent collaborative discussion through BMAD Party Mode! 🎉
+
+The user has experienced the power of bringing diverse expert perspectives together to tackle complex topics through intelligent conversation orchestration and authentic agent interactions.

package/bmad/core/workflows/party-mode/workflow.md

@@ -0,0 +1,194 @@
+---
+name: party-mode
+description: Orchestrates group discussions between all installed BMAD agents, enabling natural multi-agent conversations
+---
+
+# Party Mode Workflow
+
+**Goal:** Orchestrates group discussions between all installed BMAD agents, enabling natural multi-agent conversations
+
+**Your Role:** You are a party mode facilitator and multi-agent conversation orchestrator. You bring together diverse BMAD agents for collaborative discussions, managing the flow of conversation while maintaining each agent's unique personality and expertise - while still utilizing the configured {communication_language}.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **micro-file architecture** with **sequential conversation orchestration**:
+
+- Step 01 loads agent manifest and initializes party mode
+- Step 02 orchestrates the ongoing multi-agent discussion
+- Step 03 handles graceful party mode exit
+- Conversation state tracked in frontmatter
+- Agent personalities maintained through merged manifest data
+
+---
+
+## INITIALIZATION
+
+### Configuration Loading
+
+Load config from `{project-root}/_bmad/core/config.yaml` and resolve:
+
+- `project_name`, `output_folder`, `user_name`
+- `communication_language`, `document_output_language`, `user_skill_level`
+- `date` as a system-generated value
+- Agent manifest path: `{project-root}/_bmad/_config/agent-manifest.csv`
+
+### Paths
+
+- `installed_path` = `{project-root}/_bmad/core/workflows/party-mode`
+- `agent_manifest_path` = `{project-root}/_bmad/_config/agent-manifest.csv`
+- `standalone_mode` = `true` (party mode is an interactive workflow)
+
+---
+
+## AGENT MANIFEST PROCESSING
+
+### Agent Data Extraction
+
+Parse CSV manifest to extract agent entries with complete information:
+
+- **name** (agent identifier)
+- **displayName** (agent's persona name)
+- **title** (formal position)
+- **icon** (visual identifier emoji)
+- **role** (capabilities summary)
+- **identity** (background/expertise)
+- **communicationStyle** (how they communicate)
+- **principles** (decision-making philosophy)
+- **module** (source module)
+- **path** (file location)
+
+### Agent Roster Building
+
+Build complete agent roster with merged personalities for conversation orchestration.
+
+---
+
+## EXECUTION
+
+Execute party mode activation and conversation orchestration:
+
+### Party Mode Activation
+
+**Your Role:** You are a party mode facilitator creating an engaging multi-agent conversation environment.
+
+**Welcome Activation:**
+
+"🎉 PARTY MODE ACTIVATED! 🎉
+
+Welcome {{user_name}}! All BMAD agents are here and ready for a dynamic group discussion. I've brought together our complete team of experts, each bringing their unique perspectives and capabilities.
+
+**Let me introduce our collaborating agents:**
+
+[Load agent roster and display 2-3 most diverse agents as examples]
+
+**What would you like to discuss with the team today?**"
+
+### Agent Selection Intelligence
+
+For each user message or topic:
+
+**Relevance Analysis:**
+
+- Analyze the user's message/question for domain and expertise requirements
+- Identify which agents would naturally contribute based on their role, capabilities, and principles
+- Consider conversation context and previous agent contributions
+- Select 2-3 most relevant agents for balanced perspective
+
+**Priority Handling:**
+
+- If user addresses specific agent by name, prioritize that agent + 1-2 complementary agents
+- Rotate agent selection to ensure diverse participation over time
+- Enable natural cross-talk and agent-to-agent interactions
+
+### Conversation Orchestration
+
+Load step: `./steps/step-02-discussion-orchestration.md`
+
+---
+
+## WORKFLOW STATES
+
+### Frontmatter Tracking
+
+```yaml
+---
+stepsCompleted: [1]
+workflowType: 'party-mode'
+user_name: '{{user_name}}'
+date: '{{date}}'
+agents_loaded: true
+party_active: true
+exit_triggers: ['*exit', 'goodbye', 'end party', 'quit']
+---
+```
+
+---
+
+## ROLE-PLAYING GUIDELINES
+
+### Character Consistency
+
+- Maintain strict in-character responses based on merged personality data
+- Use each agent's documented communication style consistently
+- Reference agent memories and context when relevant
+- Allow natural disagreements and different perspectives
+- Include personality-driven quirks and occasional humor
+
+### Conversation Flow
+
+- Enable agents to reference each other naturally by name or role
+- Maintain professional discourse while being engaging
+- Respect each agent's expertise boundaries
+- Allow cross-talk and building on previous points
+
+---
+
+## QUESTION HANDLING PROTOCOL
+
+### Direct Questions to User
+
+When an agent asks the user a specific question:
+
+- End that response round immediately after the question
+- Clearly highlight the questioning agent and their question
+- Wait for user response before any agent continues
+
+### Inter-Agent Questions
+
+Agents can question each other and respond naturally within the same round for dynamic conversation.
+
+---
+
+## EXIT CONDITIONS
+
+### Automatic Triggers
+
+Exit party mode when user message contains any exit triggers:
+
+- `*exit`, `goodbye`, `end party`, `quit`
+
+### Graceful Conclusion
+
+If conversation naturally concludes:
+
+- Ask user if they'd like to continue or end party mode
+- Exit gracefully when user indicates completion
+
+---
+
+## MODERATION NOTES
+
+**Quality Control:**
+
+- If discussion becomes circular, have bmad-master summarize and redirect
+- Balance fun and productivity based on conversation tone
+- Ensure all agents stay true to their merged personalities
+- Exit gracefully when user indicates completion
+
+**Conversation Management:**
+
+- Rotate agent participation to ensure inclusive discussion
+- Handle topic drift while maintaining productive conversation
+- Facilitate cross-agent collaboration and knowledge sharing

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,26 @@
+import { Command } from "commander";
+import { initCommand } from "./commands/init.js";
+import { upgradeCommand } from "./commands/upgrade.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { setVerbose } from "./utils/logger.js";
+import { getPackageVersion } from "./installer.js";
+const program = new Command();
+program
+    .name("bmalph")
+    .description("BMAD-METHOD + Ralph integration — structured planning to autonomous implementation")
+    .version(getPackageVersion())
+    .option("--verbose", "Enable debug logging")
+    .hook("preAction", () => {
+    if (program.opts().verbose) {
+        setVerbose(true);
+    }
+});
+program
+    .command("init")
+    .description("Initialize bmalph in the current project")
+    .option("-n, --name <name>", "Project name")
+    .option("-d, --description <desc>", "Project description")
+    .action(initCommand);
+program.command("upgrade").description("Update bundled assets to current version").action(upgradeCommand);
+program.command("doctor").description("Check installation health").action(doctorCommand);
+program.parse();

package/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctorCommand(): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,168 @@
+import chalk from "chalk";
+import { access, readFile, stat } from "fs/promises";
+import { join } from "path";
+import { readJsonFile } from "../utils/json.js";
+export async function doctorCommand() {
+    try {
+        await runDoctor();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`Error: ${message}`));
+        process.exit(1);
+    }
+}
+async function runDoctor() {
+    const projectDir = process.cwd();
+    const results = [];
+    // 1. Node version
+    const major = parseInt(process.versions.node.split(".")[0]);
+    results.push({
+        label: "Node version >= 20",
+        passed: major >= 20,
+        detail: major >= 20 ? `v${process.versions.node}` : `got v${process.versions.node}`,
+    });
+    // 2. bash available
+    const bashAvailable = await checkBashAvailable();
+    results.push({
+        label: "bash available",
+        passed: bashAvailable,
+        detail: bashAvailable ? undefined : "bash not found in PATH",
+    });
+    // 3. config.json exists and valid
+    const configResult = await checkConfig(projectDir);
+    results.push(configResult);
+    // 4. _bmad/ directory with expected structure
+    const bmadResult = await checkDir(join(projectDir, "_bmad"), "_bmad/ directory present");
+    results.push(bmadResult);
+    // 5. .ralph/ralph_loop.sh present and has content
+    const loopResult = await checkFileHasContent(join(projectDir, ".ralph/ralph_loop.sh"), "ralph_loop.sh present and has content");
+    results.push(loopResult);
+    // 6. .ralph/lib/ present
+    const libResult = await checkDir(join(projectDir, ".ralph/lib"), ".ralph/lib/ directory present");
+    results.push(libResult);
+    // 7. .claude/commands/bmalph.md present
+    const slashResult = await checkFileExists(join(projectDir, ".claude/commands/bmalph.md"), ".claude/commands/bmalph.md present");
+    results.push(slashResult);
+    // 8. CLAUDE.md contains BMAD snippet
+    const claudeMdResult = await checkClaudeMd(projectDir);
+    results.push(claudeMdResult);
+    // 9. .gitignore has required entries
+    const gitignoreResult = await checkGitignore(projectDir);
+    results.push(gitignoreResult);
+    // 10. Version marker check
+    const versionResult = await checkVersionMarker(projectDir);
+    results.push(versionResult);
+    // Output
+    console.log(chalk.bold("bmalph doctor\n"));
+    for (const r of results) {
+        const icon = r.passed ? chalk.green("\u2713") : chalk.red("\u2717");
+        const detail = r.detail ? chalk.dim(` (${r.detail})`) : "";
+        console.log(`  ${icon} ${r.label}${detail}`);
+    }
+    const passed = results.filter((r) => r.passed).length;
+    const failed = results.filter((r) => !r.passed).length;
+    console.log("");
+    if (failed === 0) {
+        console.log(chalk.green(`${passed} passed, all checks OK`));
+    }
+    else {
+        console.log(`${chalk.green(`${passed} passed`)}, ${chalk.red(`${failed} failed`)}`);
+    }
+}
+async function checkBashAvailable() {
+    const { execSync } = await import("child_process");
+    try {
+        const cmd = process.platform === "win32" ? "where bash" : "which bash";
+        execSync(cmd, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function checkConfig(projectDir) {
+    const path = join(projectDir, "bmalph/config.json");
+    try {
+        const data = await readJsonFile(path);
+        if (data === null) {
+            return { label: "bmalph/config.json exists and valid", passed: false, detail: "file not found" };
+        }
+        return { label: "bmalph/config.json exists and valid", passed: true };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "invalid";
+        return { label: "bmalph/config.json exists and valid", passed: false, detail: msg };
+    }
+}
+async function checkDir(dirPath, label) {
+    try {
+        const s = await stat(dirPath);
+        return { label, passed: s.isDirectory() };
+    }
+    catch {
+        return { label, passed: false, detail: "not found" };
+    }
+}
+async function checkFileExists(filePath, label) {
+    try {
+        await access(filePath);
+        return { label, passed: true };
+    }
+    catch {
+        return { label, passed: false, detail: "not found" };
+    }
+}
+async function checkFileHasContent(filePath, label) {
+    try {
+        const content = await readFile(filePath, "utf-8");
+        return { label, passed: content.trim().length > 0 };
+    }
+    catch {
+        return { label, passed: false, detail: "not found" };
+    }
+}
+async function checkClaudeMd(projectDir) {
+    const label = "CLAUDE.md contains BMAD snippet";
+    try {
+        const content = await readFile(join(projectDir, "CLAUDE.md"), "utf-8");
+        return { label, passed: content.includes("BMAD-METHOD Integration") };
+    }
+    catch {
+        return { label, passed: false, detail: "CLAUDE.md not found" };
+    }
+}
+async function checkGitignore(projectDir) {
+    const label = ".gitignore has required entries";
+    const required = [".ralph/logs/", "_bmad-output/"];
+    try {
+        const content = await readFile(join(projectDir, ".gitignore"), "utf-8");
+        const missing = required.filter((e) => !content.includes(e));
+        if (missing.length === 0) {
+            return { label, passed: true };
+        }
+        return { label, passed: false, detail: `missing: ${missing.join(", ")}` };
+    }
+    catch {
+        return { label, passed: false, detail: ".gitignore not found" };
+    }
+}
+async function checkVersionMarker(projectDir) {
+    const label = "version marker matches";
+    try {
+        const content = await readFile(join(projectDir, ".ralph/ralph_loop.sh"), "utf-8");
+        const match = content.match(/# bmalph-version: (.+)/);
+        if (!match) {
+            return { label, passed: true, detail: "no marker (pre-0.8.0 install)" };
+        }
+        const { getPackageVersion } = await import("../installer.js");
+        const current = getPackageVersion();
+        if (match[1].trim() === current) {
+            return { label, passed: true, detail: `v${current}` };
+        }
+        return { label, passed: false, detail: `installed: ${match[1].trim()}, current: ${current}` };
+    }
+    catch {
+        return { label, passed: true, detail: "no marker found" };
+    }
+}

package/dist/commands/guide.d.ts

@@ -0,0 +1 @@
+export declare function guideCommand(): void;

package/dist/commands/guide.js

@@ -0,0 +1,19 @@
+import chalk from "chalk";
+export function guideCommand() {
+    console.log(chalk.bold("\nBMALPH Workflow\n"));
+    console.log(chalk.blue("  BMAD — Structured Planning"));
+    console.log(chalk.dim("  ─────────────────────────────────────────"));
+    console.log(`  Phase 1  Analysis        Requirements, research, risks`);
+    console.log(`  Phase 2  Planning        PRD, stories, MVP scope`);
+    console.log(`  Phase 3  Design          Architecture, data model, API\n`);
+    console.log(chalk.blue("  Ralph — Autonomous Implementation"));
+    console.log(chalk.dim("  ─────────────────────────────────────────"));
+    console.log(`  Phase 4  Implementation  TDD build, code review, validation\n`);
+    console.log(chalk.dim("  Each phase runs iteratively with human checkpoints."));
+    console.log(chalk.dim("  The loop detects completion and advances automatically.\n"));
+    console.log("Commands:");
+    console.log(`  ${chalk.cyan("bmalph start")}       Begin from Phase 1`);
+    console.log(`  ${chalk.cyan("bmalph status")}      Check current progress`);
+    console.log(`  ${chalk.cyan("bmalph resume")}      Continue from last checkpoint`);
+    console.log(`  ${chalk.cyan("/bmalph")}            Interactive mode in Claude Code`);
+}

package/dist/commands/implement.d.ts

@@ -0,0 +1 @@
+export declare function implementCommand(): Promise<void>;

package/dist/commands/implement.js

@@ -0,0 +1,83 @@
+import chalk from "chalk";
+import { spawn } from "child_process";
+import { access } from "fs/promises";
+import { join } from "path";
+import { readState, writeState } from "../utils/state.js";
+import { isInitialized } from "../installer.js";
+import { runTransition } from "../transition.js";
+export async function implementCommand() {
+    try {
+        await runImplement();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`Error: ${message}`));
+        process.exit(1);
+    }
+}
+async function runImplement() {
+    const projectDir = process.cwd();
+    if (!(await isInitialized(projectDir))) {
+        console.log(chalk.red("bmalph is not initialized. Run 'bmalph init' first."));
+        return;
+    }
+    // Check if Ralph loop script exists
+    const loopScript = join(projectDir, ".ralph/ralph_loop.sh");
+    try {
+        await access(loopScript);
+    }
+    catch {
+        console.log(chalk.red("Ralph loop script not found at .ralph/ralph_loop.sh"));
+        console.log("Run 'bmalph init' to install Ralph.");
+        return;
+    }
+    // Run transition: BMAD artifacts → Ralph inputs
+    console.log(chalk.blue("Transitioning BMAD artifacts to Ralph format..."));
+    try {
+        const result = await runTransition(projectDir);
+        if (result.fixPlanPreserved) {
+            console.log(chalk.green("Preserved existing @fix_plan.md (has progress)"));
+        }
+        else {
+            console.log(chalk.green(`Generated fix_plan.md with ${result.storiesCount} stories`));
+        }
+        for (const warning of result.warnings) {
+            console.log(chalk.yellow(`Warning: ${warning}`));
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.log(chalk.red(`Transition failed: ${message}`));
+        return;
+    }
+    // Update state
+    const now = new Date().toISOString();
+    const state = await readState(projectDir);
+    const newState = {
+        currentPhase: 4,
+        status: "implementing",
+        startedAt: state?.startedAt ?? now,
+        lastUpdated: now,
+    };
+    await writeState(projectDir, newState);
+    // Start Ralph loop
+    console.log(chalk.blue("\nStarting Ralph autonomous loop..."));
+    console.log(chalk.dim("Press Ctrl+C to stop the loop.\n"));
+    const child = spawn("bash", [loopScript], {
+        cwd: projectDir,
+        stdio: "inherit",
+        env: { ...process.env, RALPH_DIR: join(projectDir, ".ralph") },
+    });
+    child.on("close", (code) => {
+        if (code === 0) {
+            console.log(chalk.green("\nRalph loop completed successfully."));
+        }
+        else {
+            console.log(chalk.yellow(`\nRalph loop exited with code ${code}`));
+        }
+    });
+    child.on("error", (err) => {
+        console.log(chalk.red(`Failed to start Ralph loop: ${err.message}`));
+        console.log(chalk.dim("Ensure bash is available and ralph_loop.sh is executable."));
+    });
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,6 @@
+interface InitOptions {
+    name?: string;
+    description?: string;
+}
+export declare function initCommand(options: InitOptions): Promise<void>;
+export {};