bmalph 1.0.0 → 2.2.1

package/dist/commands/status.js

@@ -1,53 +1,122 @@
 import chalk from "chalk";
 import { readConfig } from "../utils/config.js";
-import { readState, readRalphStatus, getPhaseLabel } from "../utils/state.js";
-import { isInitialized } from "../installer.js";
-export async function statusCommand() {
-    try {
-        await runStatus();
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(chalk.red(`Error: ${message}`));
-        process.exit(1);
-    }
+import { readState, readRalphStatus, getPhaseLabel, getPhaseInfo } from "../utils/state.js";
+import { withErrorHandling } from "../utils/errors.js";
+export async function statusCommand(options) {
+    await withErrorHandling(() => runStatus(options));
 }
-async function runStatus() {
-    const projectDir = process.cwd();
-    if (!(await isInitialized(projectDir))) {
-        console.log(chalk.red("bmalph is not initialized. Run 'bmalph init' first."));
+export async function runStatus(options) {
+    const projectDir = options.projectDir;
+    // Check if project is initialized
+    const config = await readConfig(projectDir);
+    if (!config) {
+        console.log(chalk.red("Project not initialized. Run: bmalph init"));
         return;
     }
-    const config = await readConfig(projectDir);
+    // Read current state
     const state = await readState(projectDir);
-    const ralph = await readRalphStatus(projectDir);
     const phase = state?.currentPhase ?? 1;
     const status = state?.status ?? "planning";
-    const lastUpdated = state?.lastUpdated;
-    console.log(chalk.bold("Project:") + ` ${config.name}`);
-    console.log(chalk.bold("Phase:") + `   ${phase} — ${getPhaseLabel(phase)}`);
-    console.log(chalk.bold("Status:") + `  ${status}`);
-    if (lastUpdated) {
-        const ago = formatTimeAgo(lastUpdated);
-        console.log(chalk.bold("Updated:") + ` ${ago}`);
-    }
-    console.log("");
-    console.log(chalk.bold("Ralph:") + `   ${ralph.status}`);
-    if (ralph.status !== "not_started") {
-        console.log(chalk.dim(`         iterations: ${ralph.loopCount}, tasks: ${ralph.tasksCompleted}/${ralph.tasksTotal}`));
+    const phaseName = getPhaseLabel(phase);
+    const phaseInfo = getPhaseInfo(phase);
+    // Read Ralph status if in implementation phase
+    let ralphStatus = null;
+    if (phase === 4) {
+        ralphStatus = await readRalphStatus(projectDir);
+    }
+    // Determine next action
+    const nextAction = getNextAction(phase, status, ralphStatus);
+    if (options.json) {
+        const output = {
+            phase,
+            phaseName,
+            status,
+        };
+        if (ralphStatus) {
+            output.ralph = {
+                loopCount: ralphStatus.loopCount,
+                status: ralphStatus.status,
+                tasksCompleted: ralphStatus.tasksCompleted,
+                tasksTotal: ralphStatus.tasksTotal,
+            };
+        }
+        if (nextAction) {
+            output.nextAction = nextAction;
+        }
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    // Human-readable output
+    console.log(chalk.bold("bmalph status\n"));
+    console.log(`  ${chalk.cyan("Phase:")} ${phase} - ${phaseName}`);
+    console.log(`  ${chalk.cyan("Agent:")} ${phaseInfo.agent}`);
+    console.log(`  ${chalk.cyan("Status:")} ${formatStatus(status)}`);
+    if (phase === 4 && ralphStatus) {
+        console.log("");
+        console.log(chalk.bold("  Ralph Loop"));
+        console.log(`    ${chalk.cyan("Status:")} ${formatRalphStatus(ralphStatus.status)}`);
+        console.log(`    ${chalk.cyan("Loop count:")} ${ralphStatus.loopCount}`);
+        console.log(`    ${chalk.cyan("Tasks:")} ${ralphStatus.tasksCompleted}/${ralphStatus.tasksTotal}`);
+    }
+    else if (phase === 4) {
+        console.log("");
+        console.log(chalk.bold("  Ralph Loop"));
+        console.log(`    ${chalk.cyan("Status:")} ${chalk.dim("not started")}`);
+    }
+    if (nextAction) {
+        console.log("");
+        console.log(`  ${chalk.cyan("Next:")} ${nextAction}`);
+    }
+}
+function formatStatus(status) {
+    switch (status) {
+        case "planning":
+            return chalk.blue("planning");
+        case "implementing":
+            return chalk.yellow("implementing");
+        case "completed":
+            return chalk.green("completed");
+        default:
+            return status;
     }
 }
-function formatTimeAgo(iso) {
-    const diff = Date.now() - new Date(iso).getTime();
-    const seconds = Math.floor(diff / 1000);
-    if (seconds < 60)
-        return "just now";
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60)
-        return `${minutes} minute${minutes === 1 ? "" : "s"} ago`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24)
-        return `${hours} hour${hours === 1 ? "" : "s"} ago`;
-    const days = Math.floor(hours / 24);
-    return `${days} day${days === 1 ? "" : "s"} ago`;
+function formatRalphStatus(status) {
+    switch (status) {
+        case "running":
+            return chalk.yellow("running");
+        case "blocked":
+            return chalk.red("blocked");
+        case "completed":
+            return chalk.green("completed");
+        case "not_started":
+            return chalk.dim("not started");
+        default:
+            return status;
+    }
+}
+function getNextAction(phase, status, ralphStatus) {
+    if (status === "completed") {
+        return null;
+    }
+    switch (phase) {
+        case 1:
+            return "Run /analyst to start analysis";
+        case 2:
+            return "Run /pm to create PRD";
+        case 3:
+            return "Run /bmalph-implement when ready for implementation";
+        case 4:
+            if (!ralphStatus || ralphStatus.status === "not_started") {
+                return "Start Ralph loop with: bash .ralph/ralph_loop.sh";
+            }
+            if (ralphStatus.status === "blocked") {
+                return "Review Ralph logs: bmalph doctor";
+            }
+            if (ralphStatus.status === "running") {
+                return "Ralph is running. Check logs in .ralph/logs/";
+            }
+            return null;
+        default:
+            return null;
+    }
 }

package/dist/commands/upgrade.d.ts

@@ -1 +1,7 @@
-export declare function upgradeCommand(): Promise<void>;
+interface UpgradeOptions {
+    dryRun?: boolean;
+    force?: boolean;
+    projectDir: string;
+}
+export declare function upgradeCommand(options: UpgradeOptions): Promise<void>;
+export {};

package/dist/commands/upgrade.js

@@ -1,24 +1,55 @@
 import chalk from "chalk";
-import { isInitialized, copyBundledAssets, mergeClaudeMd } from "../installer.js";
-export async function upgradeCommand() {
-    try {
-        await runUpgrade();
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(chalk.red(`Error: ${message}`));
-        process.exit(1);
-    }
+import inquirer from "inquirer";
+import { isInitialized, copyBundledAssets, mergeClaudeMd, previewUpgrade, getBundledVersions, } from "../installer.js";
+import { readConfig, writeConfig } from "../utils/config.js";
+import { formatDryRunSummary } from "../utils/dryrun.js";
+import { withErrorHandling } from "../utils/errors.js";
+export async function upgradeCommand(options) {
+    await withErrorHandling(() => runUpgrade(options));
 }
-async function runUpgrade() {
-    const projectDir = process.cwd();
+async function runUpgrade(options) {
+    const projectDir = options.projectDir;
     if (!(await isInitialized(projectDir))) {
         console.log(chalk.red("bmalph is not initialized. Run 'bmalph init' first."));
         return;
     }
+    // Handle dry-run mode
+    if (options.dryRun) {
+        const preview = await previewUpgrade(projectDir);
+        const actions = [
+            ...preview.wouldUpdate.map((p) => ({ type: "modify", path: p })),
+            ...preview.wouldCreate.map((p) => ({ type: "create", path: p })),
+        ];
+        console.log(formatDryRunSummary(actions));
+        return;
+    }
+    // Confirm unless --force or non-interactive
+    if (!options.force) {
+        if (!process.stdin.isTTY) {
+            throw new Error("Non-interactive mode requires --force flag for upgrade");
+        }
+        const { confirm } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: "This will overwrite managed files. Continue?",
+                default: false,
+            },
+        ]);
+        if (!confirm) {
+            console.log("Aborted.");
+            return;
+        }
+    }
     console.log(chalk.blue("Upgrading bundled assets..."));
     const result = await copyBundledAssets(projectDir);
     await mergeClaudeMd(projectDir);
+    // Update upstreamVersions in config to match bundled versions
+    const config = await readConfig(projectDir);
+    if (config) {
+        config.upstreamVersions = getBundledVersions();
+        await writeConfig(projectDir, config);
+    }
     console.log(chalk.green("\nUpdated:"));
     for (const path of result.updatedPaths) {
         console.log(`  ${path}`);

package/dist/installer.d.ts

@@ -1,11 +1,28 @@
 export declare function getPackageVersion(): string;
-export declare function getBmadDir(): string;
-export declare function getRalphDir(): string;
+export interface BundledVersions {
+    bmadCommit: string;
+}
+export declare function getBundledVersions(): BundledVersions;
+export declare function getBundledBmadDir(): string;
+export declare function getBundledRalphDir(): string;
 export declare function getSlashCommandsDir(): string;
 export interface UpgradeResult {
     updatedPaths: string[];
 }
+export interface PreviewInstallResult {
+    wouldCreate: string[];
+    wouldModify: string[];
+    wouldSkip: string[];
+}
+export interface PreviewUpgradeResult {
+    wouldUpdate: string[];
+    wouldCreate: string[];
+    wouldPreserve: string[];
+}
 export declare function copyBundledAssets(projectDir: string): Promise<UpgradeResult>;
 export declare function installProject(projectDir: string): Promise<void>;
+export declare function generateManifests(projectDir: string): Promise<void>;
 export declare function mergeClaudeMd(projectDir: string): Promise<void>;
 export declare function isInitialized(projectDir: string): Promise<boolean>;
+export declare function previewInstall(projectDir: string): Promise<PreviewInstallResult>;
+export declare function previewUpgrade(projectDir: string): Promise<PreviewUpgradeResult>;