bmalph 1.0.0

package/dist/commands/init.js

@@ -0,0 +1,67 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { writeConfig } from "../utils/config.js";
+import { installProject, mergeClaudeMd, isInitialized } from "../installer.js";
+export async function initCommand(options) {
+    try {
+        await runInit(options);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`Error: ${message}`));
+        process.exit(1);
+    }
+}
+async function runInit(options) {
+    const projectDir = process.cwd();
+    if (await isInitialized(projectDir)) {
+        console.log(chalk.yellow("bmalph is already initialized in this project."));
+        console.log("Use 'bmalph reset --hard' to reinitialize.");
+        return;
+    }
+    let name = options.name;
+    let description = options.description;
+    if (!name || !description) {
+        const answers = await inquirer.prompt([
+            ...(name
+                ? []
+                : [
+                    {
+                        type: "input",
+                        name: "name",
+                        message: "Project name:",
+                        default: projectDir.split(/[/\\]/).pop(),
+                    },
+                ]),
+            ...(description
+                ? []
+                : [
+                    {
+                        type: "input",
+                        name: "description",
+                        message: "Project description:",
+                    },
+                ]),
+        ]);
+        name = name ?? answers.name;
+        description = description ?? answers.description;
+    }
+    console.log(chalk.blue("\nInstalling BMAD + Ralph..."));
+    await installProject(projectDir);
+    const config = {
+        name: name,
+        description: description ?? "",
+        createdAt: new Date().toISOString(),
+    };
+    await writeConfig(projectDir, config);
+    await mergeClaudeMd(projectDir);
+    console.log(chalk.green("\nbmalph initialized successfully!"));
+    console.log(`\n  Project: ${chalk.bold(config.name)}`);
+    console.log(`\nInstalled:`);
+    console.log(`  _bmad/             BMAD agents and workflows`);
+    console.log(`  .ralph/            Ralph loop and templates`);
+    console.log(`  .claude/commands/  Slash command (/bmalph)`);
+    console.log(`  bmalph/            State management`);
+    console.log(`\nNext step:`);
+    console.log(`  Use ${chalk.cyan("/bmalph")} in Claude Code to see your current phase and commands.`);
+}

package/dist/commands/plan.d.ts

@@ -0,0 +1,5 @@
+interface PlanOptions {
+    phase?: string;
+}
+export declare function planCommand(options: PlanOptions): Promise<void>;
+export {};

package/dist/commands/plan.js

@@ -0,0 +1,44 @@
+import chalk from "chalk";
+import { readState, writeState, getPhaseInfo } from "../utils/state.js";
+import { isInitialized } from "../installer.js";
+export async function planCommand(options) {
+    const projectDir = process.cwd();
+    if (!(await isInitialized(projectDir))) {
+        console.log(chalk.red("bmalph is not initialized. Run 'bmalph init' first."));
+        return;
+    }
+    const phase = options.phase ? parseInt(options.phase, 10) : undefined;
+    if (phase !== undefined && (phase < 1 || phase > 3)) {
+        console.log(chalk.red("Phase must be 1, 2, or 3. Use 'bmalph implement' for phase 4."));
+        return;
+    }
+    const state = await readState(projectDir);
+    const activePhase = phase ?? state?.currentPhase ?? 1;
+    // Update state
+    const now = new Date().toISOString();
+    const newState = {
+        currentPhase: activePhase,
+        status: "planning",
+        startedAt: state?.startedAt ?? now,
+        lastUpdated: now,
+    };
+    await writeState(projectDir, newState);
+    const info = getPhaseInfo(activePhase);
+    console.log(chalk.bold(`\nPhase ${activePhase}: ${info.name}`));
+    console.log(chalk.dim(`Agent: ${info.agent}`));
+    console.log("");
+    if (info.commands.length === 0) {
+        console.log("No commands for this phase. Use 'bmalph implement' instead.");
+        return;
+    }
+    console.log("Available commands:");
+    console.log("");
+    for (const cmd of info.commands) {
+        const required = cmd.required ? chalk.yellow(" (required)") : "";
+        console.log(`  ${chalk.cyan(cmd.code.padEnd(4))} ${cmd.name}${required}`);
+        console.log(`       ${chalk.dim(cmd.description)}`);
+    }
+    console.log("");
+    console.log(chalk.dim("Load the BMAD master agent, then invoke these commands in Claude Code."));
+    console.log(chalk.dim(`When done, advance with: bmalph plan --phase ${activePhase + 1}`));
+}

package/dist/commands/reset.d.ts

@@ -0,0 +1,5 @@
+interface ResetOptions {
+    hard?: boolean;
+}
+export declare function resetCommand(options: ResetOptions): Promise<void>;
+export {};

package/dist/commands/reset.js

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import { rm } from "fs/promises";
+import { join } from "path";
+import { isInitialized } from "../installer.js";
+export async function resetCommand(options) {
+    try {
+        await runReset(options);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`Error: ${message}`));
+        process.exit(1);
+    }
+}
+async function runReset(options) {
+    const projectDir = process.cwd();
+    if (!(await isInitialized(projectDir))) {
+        console.log(chalk.yellow("bmalph is not initialized in this project."));
+        return;
+    }
+    // Always reset state
+    await rm(join(projectDir, "bmalph/state"), { recursive: true, force: true });
+    console.log(chalk.green("State reset."));
+    if (options.hard) {
+        await rm(join(projectDir, "_bmad"), { recursive: true, force: true });
+        await rm(join(projectDir, ".ralph"), { recursive: true, force: true });
+        await rm(join(projectDir, "_bmad-output"), { recursive: true, force: true });
+        await rm(join(projectDir, "bmalph"), { recursive: true, force: true });
+        console.log(chalk.green("Artifacts removed (_bmad/, .ralph/, _bmad-output/, bmalph/)."));
+        console.log("Run 'bmalph init' to reinitialize.");
+    }
+    else {
+        console.log(chalk.dim("Use --hard to also remove _bmad/, .ralph/, and artifacts."));
+    }
+}

package/dist/commands/resume.d.ts

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

package/dist/commands/resume.js

@@ -0,0 +1,44 @@
+import { spawn } from "child_process";
+import { join } from "path";
+import chalk from "chalk";
+import { readPhaseState, getPhaseInfo } from "../utils/state.js";
+import { isInitialized } from "../installer.js";
+export async function resumeCommand() {
+    const projectDir = process.cwd();
+    if (!(await isInitialized(projectDir))) {
+        console.log(chalk.red("bmalph is not initialized. Run 'bmalph init' first."));
+        process.exit(1);
+    }
+    const state = await readPhaseState(projectDir);
+    if (!state) {
+        console.log(chalk.yellow("No state found. Use 'bmalph start' to begin."));
+        process.exit(1);
+    }
+    if (state.status === "completed") {
+        console.log(chalk.green("All phases completed. Nothing to resume."));
+        return;
+    }
+    const phaseInfo = getPhaseInfo(state.currentPhase);
+    console.log(chalk.blue(`\nResuming Phase ${state.currentPhase} — ${phaseInfo.name} (iteration ${state.iteration})`));
+    console.log(`  Agent: ${chalk.bold(phaseInfo.agent)}`);
+    console.log(`  Goal: ${phaseInfo.goal}`);
+    console.log(`  Outputs: ${phaseInfo.outputs.join(", ")}`);
+    console.log(chalk.dim("\nPress Ctrl+C to interrupt.\n"));
+    const scriptPath = join(projectDir, "bmalph/bmalph.sh");
+    const child = spawn("bash", [scriptPath, String(state.currentPhase)], {
+        cwd: projectDir,
+        stdio: "inherit",
+        env: { ...process.env, BMALPH_PROJECT_DIR: projectDir },
+    });
+    child.on("close", (code) => {
+        if (code === 0) {
+            console.log(chalk.green("\nbmalph loop completed."));
+        }
+        else if (code === 130) {
+            console.log(chalk.yellow("\nbmalph loop interrupted."));
+        }
+        else {
+            console.log(chalk.red(`\nbmalph loop exited with code ${code}.`));
+        }
+    });
+}

package/dist/commands/start.d.ts

@@ -0,0 +1,5 @@
+interface StartOptions {
+    phase?: string;
+}
+export declare function startCommand(options: StartOptions): Promise<void>;
+export {};

package/dist/commands/start.js

@@ -0,0 +1,54 @@
+import { spawn } from "child_process";
+import { join } from "path";
+import chalk from "chalk";
+import { readConfig } from "../utils/config.js";
+import { writePhaseState, getPhaseInfo } from "../utils/state.js";
+import { isInitialized } from "../installer.js";
+export async function startCommand(options) {
+    const projectDir = process.cwd();
+    if (!(await isInitialized(projectDir))) {
+        console.log(chalk.red("bmalph is not initialized. Run 'bmalph init' first."));
+        process.exit(1);
+    }
+    const config = await readConfig(projectDir);
+    if (!config) {
+        console.log(chalk.red("Could not read config. Run 'bmalph init' to reinitialize."));
+        process.exit(1);
+    }
+    const startPhase = options.phase ? parseInt(options.phase, 10) : 1;
+    if (startPhase < 1 || startPhase > 4) {
+        console.log(chalk.red("Phase must be between 1 and 4."));
+        process.exit(1);
+    }
+    const state = {
+        currentPhase: startPhase,
+        iteration: 0,
+        status: "running",
+        startedAt: new Date().toISOString(),
+        lastUpdated: new Date().toISOString(),
+    };
+    await writePhaseState(projectDir, state);
+    const phaseInfo = getPhaseInfo(startPhase);
+    console.log(chalk.blue(`\nStarting Phase ${startPhase} — ${phaseInfo.name}`));
+    console.log(`  Agent: ${chalk.bold(phaseInfo.agent)}`);
+    console.log(`  Goal: ${phaseInfo.goal}`);
+    console.log(`  Outputs: ${phaseInfo.outputs.join(", ")}`);
+    console.log(chalk.dim("\nPress Ctrl+C to interrupt.\n"));
+    const scriptPath = join(projectDir, "bmalph/bmalph.sh");
+    const child = spawn("bash", [scriptPath, String(startPhase)], {
+        cwd: projectDir,
+        stdio: "inherit",
+        env: { ...process.env, BMALPH_PROJECT_DIR: projectDir },
+    });
+    child.on("close", (code) => {
+        if (code === 0) {
+            console.log(chalk.green("\nbmalph loop completed."));
+        }
+        else if (code === 130) {
+            console.log(chalk.yellow("\nbmalph loop interrupted by user."));
+        }
+        else {
+            console.log(chalk.red(`\nbmalph loop exited with code ${code}.`));
+        }
+    });
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,53 @@
+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);
+    }
+}
+async function runStatus() {
+    const projectDir = process.cwd();
+    if (!(await isInitialized(projectDir))) {
+        console.log(chalk.red("bmalph is not initialized. Run 'bmalph init' first."));
+        return;
+    }
+    const config = await readConfig(projectDir);
+    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}`));
+    }
+}
+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`;
+}

package/dist/commands/upgrade.d.ts

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

package/dist/commands/upgrade.js

@@ -0,0 +1,34 @@
+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);
+    }
+}
+async function runUpgrade() {
+    const projectDir = process.cwd();
+    if (!(await isInitialized(projectDir))) {
+        console.log(chalk.red("bmalph is not initialized. Run 'bmalph init' first."));
+        return;
+    }
+    console.log(chalk.blue("Upgrading bundled assets..."));
+    const result = await copyBundledAssets(projectDir);
+    await mergeClaudeMd(projectDir);
+    console.log(chalk.green("\nUpdated:"));
+    for (const path of result.updatedPaths) {
+        console.log(`  ${path}`);
+    }
+    console.log(chalk.dim("\nPreserved:"));
+    console.log("  bmalph/config.json");
+    console.log("  bmalph/state/");
+    console.log("  .ralph/logs/");
+    console.log("  .ralph/@fix_plan.md");
+    console.log("  .ralph/docs/");
+    console.log("  .ralph/specs/");
+    console.log(chalk.green("\nUpgrade complete."));
+}

package/dist/installer.d.ts

@@ -0,0 +1,11 @@
+export declare function getPackageVersion(): string;
+export declare function getBmadDir(): string;
+export declare function getRalphDir(): string;
+export declare function getSlashCommandsDir(): string;
+export interface UpgradeResult {
+    updatedPaths: string[];
+}
+export declare function copyBundledAssets(projectDir: string): Promise<UpgradeResult>;
+export declare function installProject(projectDir: string): Promise<void>;
+export declare function mergeClaudeMd(projectDir: string): Promise<void>;
+export declare function isInitialized(projectDir: string): Promise<boolean>;

package/dist/installer.js

@@ -0,0 +1,219 @@
+import { cp, mkdir, readFile, readdir, writeFile, access } from "fs/promises";
+import { readFileSync } from "fs";
+import { join, basename, dirname } from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export function getPackageVersion() {
+    const pkgPath = join(__dirname, "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.version;
+}
+export function getBmadDir() {
+    return join(__dirname, "..", "bmad");
+}
+export function getRalphDir() {
+    return join(__dirname, "..", "ralph");
+}
+export function getSlashCommandsDir() {
+    return join(__dirname, "..", "slash-commands");
+}
+export async function copyBundledAssets(projectDir) {
+    const bmadDir = getBmadDir();
+    const ralphDir = getRalphDir();
+    const slashCommandsDir = getSlashCommandsDir();
+    // Validate source directories exist
+    try {
+        await access(bmadDir);
+    }
+    catch {
+        throw new Error(`BMAD source directory not found at ${bmadDir}. Package may be corrupted.`);
+    }
+    try {
+        await access(ralphDir);
+    }
+    catch {
+        throw new Error(`Ralph source directory not found at ${ralphDir}. Package may be corrupted.`);
+    }
+    try {
+        await access(slashCommandsDir);
+    }
+    catch {
+        throw new Error(`Slash commands directory not found at ${slashCommandsDir}. Package may be corrupted.`);
+    }
+    // Copy BMAD files → _bmad/
+    await cp(bmadDir, join(projectDir, "_bmad"), { recursive: true });
+    // Generate combined manifest from module-help.csv files
+    await generateManifests(projectDir);
+    // Generate _bmad/config.yaml
+    const projectName = await deriveProjectName(projectDir);
+    await writeFile(join(projectDir, "_bmad/config.yaml"), `# BMAD Configuration - Generated by bmalph
+platform: claude-code
+project_name: ${projectName}
+output_folder: _bmad-output
+user_name: BMad
+communication_language: English
+document_output_language: English
+user_skill_level: intermediate
+planning_artifacts: _bmad-output/planning-artifacts
+implementation_artifacts: _bmad-output/implementation-artifacts
+project_knowledge: docs
+modules:
+  - bmm
+`);
+    // Copy Ralph templates → .ralph/
+    await mkdir(join(projectDir, ".ralph"), { recursive: true });
+    await cp(join(ralphDir, "templates/PROMPT.md"), join(projectDir, ".ralph/PROMPT.md"));
+    await cp(join(ralphDir, "templates/AGENT.md"), join(projectDir, ".ralph/@AGENT.md"));
+    // Copy Ralph loop and lib → .ralph/
+    // Add version marker to ralph_loop.sh
+    const loopContent = await readFile(join(ralphDir, "ralph_loop.sh"), "utf-8");
+    const markerLine = `# bmalph-version: ${getPackageVersion()}`;
+    const markedContent = loopContent.includes("# bmalph-version:")
+        ? loopContent.replace(/# bmalph-version: .+/, markerLine)
+        : loopContent.replace(/^(#!.+\r?\n)/, `$1${markerLine}\n`);
+    await writeFile(join(projectDir, ".ralph/ralph_loop.sh"), markedContent);
+    await cp(join(ralphDir, "lib"), join(projectDir, ".ralph/lib"), { recursive: true });
+    // Install all slash commands → .claude/commands/
+    await mkdir(join(projectDir, ".claude/commands"), { recursive: true });
+    const slashFiles = await readdir(slashCommandsDir);
+    for (const file of slashFiles) {
+        if (file.endsWith(".md")) {
+            await cp(join(slashCommandsDir, file), join(projectDir, ".claude/commands", file));
+        }
+    }
+    // Update .gitignore
+    await updateGitignore(projectDir);
+    return {
+        updatedPaths: [
+            "_bmad/",
+            ".ralph/ralph_loop.sh",
+            ".ralph/lib/",
+            ".ralph/PROMPT.md",
+            ".ralph/@AGENT.md",
+            ".claude/commands/",
+            ".gitignore",
+        ],
+    };
+}
+export async function installProject(projectDir) {
+    // Create user directories (not overwritten by upgrade)
+    await mkdir(join(projectDir, "bmalph/state"), { recursive: true });
+    await mkdir(join(projectDir, ".ralph/specs"), { recursive: true });
+    await mkdir(join(projectDir, ".ralph/logs"), { recursive: true });
+    await mkdir(join(projectDir, ".ralph/docs/generated"), { recursive: true });
+    await copyBundledAssets(projectDir);
+}
+async function deriveProjectName(projectDir) {
+    try {
+        const configPath = join(projectDir, "bmalph/config.json");
+        const raw = await readFile(configPath, "utf-8");
+        const config = JSON.parse(raw);
+        if (config.name)
+            return config.name;
+    }
+    catch {
+        // config.json doesn't exist or is invalid — fall through
+    }
+    return basename(projectDir);
+}
+async function generateManifests(projectDir) {
+    const configDir = join(projectDir, "_bmad/_config");
+    await mkdir(configDir, { recursive: true });
+    const coreHelpPath = join(projectDir, "_bmad/core/module-help.csv");
+    const bmmHelpPath = join(projectDir, "_bmad/bmm/module-help.csv");
+    const coreContent = await readFile(coreHelpPath, "utf-8");
+    const bmmContent = await readFile(bmmHelpPath, "utf-8");
+    // Extract header from core (first line) and data lines from both
+    const coreLines = coreContent.trimEnd().split(/\r?\n/);
+    const bmmLines = bmmContent.trimEnd().split(/\r?\n/);
+    const header = coreLines[0];
+    const coreData = coreLines.slice(1).filter((l) => l.trim());
+    const bmmData = bmmLines.slice(1).filter((l) => l.trim());
+    const combined = [header, ...coreData, ...bmmData].join("\n") + "\n";
+    await writeFile(join(configDir, "task-manifest.csv"), combined);
+    await writeFile(join(configDir, "workflow-manifest.csv"), combined);
+    await writeFile(join(configDir, "bmad-help.csv"), combined);
+}
+async function updateGitignore(projectDir) {
+    const gitignorePath = join(projectDir, ".gitignore");
+    let existing = "";
+    try {
+        existing = await readFile(gitignorePath, "utf-8");
+    }
+    catch {
+        // File doesn't exist, start fresh
+    }
+    const entries = [".ralph/logs/", "_bmad-output/"];
+    const newEntries = entries.filter((e) => !existing.includes(e));
+    if (newEntries.length === 0)
+        return;
+    const suffix = existing.length > 0 && !existing.endsWith("\n")
+        ? "\n" + newEntries.join("\n") + "\n"
+        : newEntries.join("\n") + "\n";
+    await writeFile(gitignorePath, existing + suffix);
+}
+export async function mergeClaudeMd(projectDir) {
+    const claudeMdPath = join(projectDir, "CLAUDE.md");
+    const snippet = `
+## BMAD-METHOD Integration
+
+Use \`/bmalph\` to navigate phases. Use \`/bmad-help\` to discover all commands. Use \`/bmalph-status\` for a quick overview.
+
+### Phases
+
+| Phase | Focus | Key Commands |
+|-------|-------|-------------|
+| 1. Analysis | Understand the problem | \`/create-brief\`, \`/brainstorm-project\`, \`/market-research\` |
+| 2. Planning | Define the solution | \`/create-prd\`, \`/create-ux\` |
+| 3. Solutioning | Design the architecture | \`/create-architecture\`, \`/create-epics-stories\`, \`/implementation-readiness\` |
+| 4. Implementation | Build it | \`/sprint-planning\`, \`/create-story\`, then \`/bmalph-implement\` for Ralph |
+
+### Workflow
+
+1. Work through Phases 1-3 using BMAD agents and workflows (interactive, command-driven)
+2. Run \`/bmalph-implement\` to transition planning artifacts into Ralph format, then start Ralph
+
+### Management Commands
+
+| Command | Description |
+|---------|-------------|
+| \`/bmalph-status\` | Show current phase, Ralph progress, version info |
+| \`/bmalph-implement\` | Transition planning artifacts → prepare Ralph loop |
+| \`/bmalph-upgrade\` | Update bundled assets to match current bmalph version |
+| \`/bmalph-doctor\` | Check project health and report issues |
+| \`/bmalph-reset\` | Reset state (soft or hard reset with confirmation) |
+
+### Available Agents
+
+| Command | Agent | Role |
+|---------|-------|------|
+| \`/analyst\` | Analyst | Research, briefs, discovery |
+| \`/architect\` | Architect | Technical design, architecture |
+| \`/pm\` | Product Manager | PRDs, epics, stories |
+| \`/sm\` | Scrum Master | Sprint planning, status, coordination |
+| \`/dev\` | Developer | Implementation, coding |
+| \`/ux-designer\` | UX Designer | User experience, wireframes |
+| \`/tea\` | Test Engineer | Test design, validation |
+`;
+    let existing = "";
+    try {
+        existing = await readFile(claudeMdPath, "utf-8");
+    }
+    catch {
+        // File doesn't exist, that's fine
+    }
+    if (existing.includes("## BMAD-METHOD Integration")) {
+        return; // Already merged
+    }
+    await writeFile(claudeMdPath, existing + snippet);
+}
+export async function isInitialized(projectDir) {
+    try {
+        await access(join(projectDir, "bmalph/config.json"));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/transition.d.ts

@@ -0,0 +1,52 @@
+export interface ProjectContext {
+    projectGoals: string;
+    successMetrics: string;
+    architectureConstraints: string;
+    technicalRisks: string;
+    scopeBoundaries: string;
+    targetUsers: string;
+    nonFunctionalRequirements: string;
+}
+export interface Story {
+    epic: string;
+    epicDescription: string;
+    id: string;
+    title: string;
+    description: string;
+    acceptanceCriteria: string[];
+}
+export declare function findArtifactsDir(projectDir: string): Promise<string | null>;
+export declare function parseStories(content: string): Story[];
+export declare function generateFixPlan(stories: Story[]): string;
+export declare function generatePrompt(projectName: string): string;
+export interface TechStack {
+    setup: string;
+    test: string;
+    build: string;
+    dev: string;
+}
+export declare function detectTechStack(content: string): TechStack | null;
+export declare function customizeAgentMd(template: string, stack: TechStack): string;
+export declare function hasFixPlanProgress(content: string): boolean;
+export interface FixPlanItem {
+    id: string;
+    completed: boolean;
+}
+export declare function parseFixPlan(content: string): FixPlanItem[];
+export declare function mergeFixPlanProgress(newFixPlan: string, completedIds: Set<string>): string;
+export interface SpecsChange {
+    file: string;
+    status: "added" | "modified" | "removed";
+    summary?: string;
+}
+export declare function generateSpecsChangelog(oldSpecsDir: string, newSourceDir: string): Promise<SpecsChange[]>;
+export declare function formatChangelog(changes: SpecsChange[], timestamp: string): string;
+export declare function extractSection(content: string, headingPattern: RegExp, maxLength?: number): string;
+export declare function extractProjectContext(artifacts: Map<string, string>): ProjectContext;
+export declare function generateProjectContextMd(context: ProjectContext, projectName: string): string;
+export declare function validateArtifacts(files: string[], artifactsDir: string): Promise<string[]>;
+export declare function runTransition(projectDir: string): Promise<{
+    storiesCount: number;
+    warnings: string[];
+    fixPlanPreserved: boolean;
+}>;