bmalph 1.0.0 → 2.2.1

package/dist/transition/specs-changelog.js

@@ -0,0 +1,75 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { debug } from "../utils/logger.js";
+import { formatError } from "../utils/errors.js";
+import { getFilesRecursive } from "../utils/file-system.js";
+import { DIFF_LINE_PREVIEW_LENGTH } from "../utils/constants.js";
+function getFirstDiffLine(oldContent, newContent) {
+    const oldLines = oldContent.split("\n");
+    const newLines = newContent.split("\n");
+    for (let i = 0; i < Math.max(oldLines.length, newLines.length); i++) {
+        const oldLine = oldLines[i] || "";
+        const newLine = newLines[i] || "";
+        if (oldLine !== newLine) {
+            // Return a truncated version of the changed line
+            const line = newLine.trim().slice(0, DIFF_LINE_PREVIEW_LENGTH);
+            return line || "(line changed)";
+        }
+    }
+    return "";
+}
+export async function generateSpecsChangelog(oldSpecsDir, newSourceDir) {
+    const changes = [];
+    // Get file lists (already uses forward slashes)
+    const oldFiles = await getFilesRecursive(oldSpecsDir);
+    const newFiles = await getFilesRecursive(newSourceDir);
+    const oldSet = new Set(oldFiles);
+    const newSet = new Set(newFiles);
+    // Check for added/modified files
+    for (const file of newFiles) {
+        if (!oldSet.has(file)) {
+            changes.push({ file, status: "added" });
+        }
+        else {
+            // Compare content
+            const oldContent = await readFile(join(oldSpecsDir, file), "utf-8").catch((err) => {
+                debug(`Could not read old spec file ${file}: ${formatError(err)}`);
+                return "";
+            });
+            const newContent = await readFile(join(newSourceDir, file), "utf-8");
+            if (oldContent !== newContent) {
+                changes.push({
+                    file,
+                    status: "modified",
+                    summary: getFirstDiffLine(oldContent, newContent),
+                });
+            }
+        }
+    }
+    // Check for removed files
+    for (const file of oldFiles) {
+        if (!newSet.has(file)) {
+            changes.push({ file, status: "removed" });
+        }
+    }
+    return changes;
+}
+export function formatChangelog(changes, timestamp) {
+    if (changes.length === 0) {
+        return `# Specs Changelog\n\nNo changes detected.\n`;
+    }
+    let md = `# Specs Changelog\n\nLast updated: ${timestamp}\n\n`;
+    const added = changes.filter((c) => c.status === "added");
+    const modified = changes.filter((c) => c.status === "modified");
+    const removed = changes.filter((c) => c.status === "removed");
+    if (added.length) {
+        md += `## Added\n${added.map((c) => `- ${c.file}`).join("\n")}\n\n`;
+    }
+    if (modified.length) {
+        md += `## Modified\n${modified.map((c) => `- ${c.file}${c.summary ? ` (${c.summary})` : ""}`).join("\n")}\n\n`;
+    }
+    if (removed.length) {
+        md += `## Removed\n${removed.map((c) => `- ${c.file}`).join("\n")}\n\n`;
+    }
+    return md;
+}

package/dist/transition/specs-index.d.ts

@@ -0,0 +1,22 @@
+import type { SpecFileType, Priority, SpecsIndex } from "./types.js";
+/**
+ * Detects the type of a spec file based on its filename.
+ */
+export declare function detectSpecFileType(filename: string, _content: string): SpecFileType;
+/**
+ * Determines the reading priority for a spec file based on its type.
+ */
+export declare function determinePriority(type: SpecFileType, _size: number): Priority;
+/**
+ * Extracts a one-line description from file content.
+ * Prefers the first heading, falls back to first non-empty line.
+ */
+export declare function extractDescription(content: string, maxLength?: number): string;
+/**
+ * Generates a specs index from a specs directory.
+ */
+export declare function generateSpecsIndex(specsDir: string): Promise<SpecsIndex>;
+/**
+ * Formats a specs index as markdown.
+ */
+export declare function formatSpecsIndexMd(index: SpecsIndex): string;

package/dist/transition/specs-index.js

@@ -0,0 +1,157 @@
+import { getMarkdownFilesWithContent } from "../utils/file-system.js";
+import { LARGE_FILE_THRESHOLD_BYTES, DEFAULT_SNIPPET_MAX_LENGTH } from "../utils/constants.js";
+/**
+ * Detects the type of a spec file based on its filename.
+ */
+export function detectSpecFileType(filename, _content) {
+    const lower = filename.toLowerCase();
+    if (lower.includes("prd"))
+        return "prd";
+    if (lower.includes("arch"))
+        return "architecture";
+    // Check stories/epic BEFORE brainstorm (Bug #5: brainstorm-stories.md should be "stories")
+    if (/stor(y|ies)/i.test(lower) || lower.includes("epic"))
+        return "stories";
+    if (lower.includes("brainstorm"))
+        return "brainstorm";
+    if (lower.includes("ux"))
+        return "ux";
+    if (/\btest/i.test(lower))
+        return "test-design";
+    if (lower.includes("readiness"))
+        return "readiness";
+    if (lower.includes("sprint"))
+        return "sprint";
+    return "other";
+}
+/**
+ * Determines the reading priority for a spec file based on its type.
+ */
+export function determinePriority(type, _size) {
+    switch (type) {
+        case "prd":
+        case "architecture":
+        case "stories":
+            return "critical";
+        case "test-design":
+        case "readiness":
+            return "high";
+        case "ux":
+        case "sprint":
+            return "medium";
+        case "brainstorm":
+        case "other":
+        default:
+            return "low";
+    }
+}
+/**
+ * Extracts a one-line description from file content.
+ * Prefers the first heading, falls back to first non-empty line.
+ */
+export function extractDescription(content, maxLength = DEFAULT_SNIPPET_MAX_LENGTH) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return "";
+    // Try to find a heading (# or ##)
+    const headingMatch = /^#{1,2}\s+(.+)$/m.exec(trimmed);
+    if (headingMatch) {
+        let heading = headingMatch[1];
+        // Remove markdown formatting
+        heading = heading.replace(/\*\*([^*]+)\*\*/g, "$1");
+        heading = heading.replace(/\*([^*]+)\*/g, "$1");
+        heading = heading.replace(/`([^`]+)`/g, "$1");
+        heading = heading.trim();
+        if (heading.length > maxLength) {
+            return heading.slice(0, maxLength - 3) + "...";
+        }
+        return heading;
+    }
+    // Fall back to first non-empty line
+    const firstLine = trimmed.split("\n")[0].trim();
+    if (firstLine.length > maxLength) {
+        return firstLine.slice(0, maxLength - 3) + "...";
+    }
+    return firstLine;
+}
+/**
+ * Generates a specs index from a specs directory.
+ */
+export async function generateSpecsIndex(specsDir) {
+    const files = await getMarkdownFilesWithContent(specsDir);
+    const metadata = files.map((file) => {
+        const type = detectSpecFileType(file.path, file.content);
+        const priority = determinePriority(type, file.size);
+        const description = extractDescription(file.content);
+        return {
+            path: file.path,
+            size: file.size,
+            type,
+            priority,
+            description,
+        };
+    });
+    // Sort by priority order: critical -> high -> medium -> low
+    const priorityOrder = {
+        critical: 0,
+        high: 1,
+        medium: 2,
+        low: 3,
+    };
+    metadata.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+    const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+    return {
+        generatedAt: new Date().toISOString(),
+        totalFiles: files.length,
+        totalSizeKb: Math.round(totalSize / 1024),
+        files: metadata,
+    };
+}
+/**
+ * Formats a specs index as markdown.
+ */
+export function formatSpecsIndexMd(index) {
+    const lines = [
+        "# Specs Index",
+        "",
+        `Generated: ${index.generatedAt}`,
+        `Total: ${index.totalFiles} files (${index.totalSizeKb} KB)`,
+        "",
+        "## Reading Order",
+        "",
+    ];
+    const priorityConfig = [
+        { key: "critical", heading: "Critical (Always Read First)", description: "" },
+        { key: "high", heading: "High Priority (Read for Implementation)", description: "" },
+        { key: "medium", heading: "Medium Priority (Reference as Needed)", description: "" },
+        { key: "low", heading: "Low Priority (Optional)", description: "" },
+    ];
+    let fileNumber = 1;
+    for (const { key, heading } of priorityConfig) {
+        const filesInPriority = index.files.filter((f) => f.priority === key);
+        if (filesInPriority.length === 0)
+            continue;
+        lines.push(`### ${heading}`);
+        for (const file of filesInPriority) {
+            const sizeKb = Math.round(file.size / 1024);
+            const isLarge = file.size >= LARGE_FILE_THRESHOLD_BYTES;
+            let line = `${fileNumber}. **${file.path}** (${sizeKb} KB)`;
+            if (isLarge) {
+                line += " [LARGE]";
+            }
+            lines.push(line);
+            // Add description
+            if (file.description) {
+                if (isLarge) {
+                    lines.push(`   ${file.description} - scan headers, read relevant sections`);
+                }
+                else {
+                    lines.push(`   ${file.description}`);
+                }
+            }
+            lines.push("");
+            fileNumber++;
+        }
+    }
+    return lines.join("\n");
+}

package/dist/transition/story-parsing.d.ts

@@ -0,0 +1,7 @@
+import type { Story } from "./types.js";
+export interface ParseStoriesResult {
+    stories: Story[];
+    warnings: string[];
+}
+export declare function parseStories(content: string): Story[];
+export declare function parseStoriesWithWarnings(content: string): ParseStoriesResult;

package/dist/transition/story-parsing.js

@@ -0,0 +1,124 @@
+// Cached regex patterns for performance (compiled once at module load)
+const GIVEN_LINE_PATTERN = /^\*?\*?Given\*?\*?\s/;
+const GWT_LINE_PATTERN = /^\*?\*?(Given|When|Then)\*?\*?\s/;
+const BOLD_PATTERN = /\*\*/g;
+const EPIC_HEADER_PATTERN = /^##\s+Epic\s+\d+:\s+(.+)/;
+const HEADING_PATTERN = /^#{2,3}\s/;
+const STORY_HEADER_PATTERN = /^###\s+Story\s+([\d.]+):\s+(.+)/;
+const STORY_ID_PATTERN = /^\d+\.\d+$/;
+const AC_HEADING_PATTERN = /^\*?\*?Acceptance Criteria\*?\*?:?/i;
+function isGivenLine(line) {
+    return GIVEN_LINE_PATTERN.test(line.trim());
+}
+function isGwtLine(line) {
+    return GWT_LINE_PATTERN.test(line.trim());
+}
+function stripBold(text) {
+    return text.replace(BOLD_PATTERN, "");
+}
+function parseAcBlocks(lines) {
+    const criteria = [];
+    let current = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (isGivenLine(trimmed)) {
+            // Start new criterion block
+            if (current.length > 0) {
+                criteria.push(current.map(stripBold).join(", "));
+            }
+            current = [trimmed];
+        }
+        else if (isGwtLine(trimmed)) {
+            current.push(trimmed);
+        }
+    }
+    if (current.length > 0) {
+        criteria.push(current.map(stripBold).join(", "));
+    }
+    return criteria;
+}
+export function parseStories(content) {
+    return parseStoriesWithWarnings(content).stories;
+}
+export function parseStoriesWithWarnings(content) {
+    const stories = [];
+    const warnings = [];
+    let currentEpic = "";
+    let currentEpicDescription = "";
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Match Epic headers: ## Epic N: Title
+        const epicMatch = line?.match(EPIC_HEADER_PATTERN);
+        if (epicMatch) {
+            currentEpic = epicMatch[1].trim();
+            // Collect all non-empty lines between epic header and first story/next heading
+            const descLines = [];
+            for (let j = i + 1; j < lines.length; j++) {
+                if (HEADING_PATTERN.test(lines[j]))
+                    break;
+                const trimmed = lines[j].trim();
+                if (trimmed)
+                    descLines.push(trimmed);
+            }
+            currentEpicDescription = descLines.join(" ");
+            continue;
+        }
+        // Match Story headers: ### Story N.M: Title
+        const storyMatch = line?.match(STORY_HEADER_PATTERN);
+        if (storyMatch) {
+            const id = storyMatch[1];
+            const title = storyMatch[2].trim();
+            // Validate story ID format (should be like "1.1", "2.3", etc.)
+            if (!STORY_ID_PATTERN.test(id)) {
+                warnings.push(`Story "${title}" has malformed ID "${id}" (expected format: N.M)`);
+            }
+            // Collect all body lines until next heading
+            const bodyLines = [];
+            for (let j = i + 1; j < lines.length; j++) {
+                if (HEADING_PATTERN.test(lines[j]))
+                    break;
+                bodyLines.push(lines[j]);
+            }
+            // Find where AC starts: either "**Acceptance Criteria:**" heading or first Given line
+            let acStartIndex = bodyLines.findIndex((l) => AC_HEADING_PATTERN.test(l.trim()));
+            if (acStartIndex === -1) {
+                // Look for first Given/When/Then line as AC start
+                acStartIndex = bodyLines.findIndex((l) => isGivenLine(l));
+            }
+            // Description: all non-empty lines before AC
+            const descSource = acStartIndex > -1 ? bodyLines.slice(0, acStartIndex) : bodyLines;
+            const descLines = [];
+            for (const dl of descSource) {
+                if (dl.trim())
+                    descLines.push(dl.trim());
+            }
+            // Acceptance criteria: lines from AC start onward
+            const acLines = acStartIndex > -1 ? bodyLines.slice(acStartIndex) : [];
+            const acceptanceCriteria = parseAcBlocks(acLines);
+            // Warn about stories with missing acceptance criteria
+            if (acceptanceCriteria.length === 0) {
+                warnings.push(`Story ${id}: "${title}" has no acceptance criteria`);
+            }
+            // Warn about stories without a description
+            if (descLines.length === 0) {
+                warnings.push(`Story ${id}: "${title}" has no description`);
+            }
+            // Warn about stories not assigned to an epic
+            if (!currentEpic) {
+                warnings.push(`Story ${id}: "${title}" is not under an epic`);
+            }
+            stories.push({
+                epic: currentEpic,
+                epicDescription: currentEpicDescription,
+                id,
+                title,
+                description: descLines.join(" "),
+                acceptanceCriteria,
+            });
+        }
+    }
+    return { stories, warnings };
+}

package/dist/transition/tech-stack.d.ts

@@ -0,0 +1,3 @@
+import type { TechStack } from "./types.js";
+export declare function detectTechStack(content: string): TechStack | null;
+export declare function customizeAgentMd(template: string, stack: TechStack): string;

package/dist/transition/tech-stack.js

@@ -0,0 +1,79 @@
+export function detectTechStack(content) {
+    // Find tech stack section
+    const stackMatch = content.match(/^##\s+(?:Tech(?:nology)?\s+Stack|Stack)/im);
+    if (!stackMatch)
+        return null;
+    const startIndex = stackMatch.index;
+    // Extract section content until next ## heading or end
+    const rest = content.slice(startIndex);
+    const nextHeading = rest.slice(1).search(/^##\s/m);
+    const sectionContent = nextHeading > -1 ? rest.slice(0, nextHeading + 1) : rest;
+    // Detect language/runtime
+    const isNode = /\bnode(?:\.js)?\b/i.test(sectionContent) ||
+        /\btypescript\b/i.test(sectionContent) ||
+        /\bnpm\b/i.test(sectionContent);
+    const isPython = /\bpython\b/i.test(sectionContent) || /\bpip\b/i.test(sectionContent);
+    const isRust = /\brust\b/i.test(sectionContent) || /\bcargo\b/i.test(sectionContent);
+    const isGo = /\bgo\s+(mod|build|test|run|get|install|fmt|vet)\b/i.test(sectionContent) ||
+        /\bgolang\b/i.test(sectionContent);
+    if (isNode) {
+        // Detect specific test runner
+        let testCmd = "npm test";
+        if (/\bvitest\b/i.test(sectionContent))
+            testCmd = "npx vitest run";
+        else if (/\bjest\b/i.test(sectionContent))
+            testCmd = "npx jest";
+        else if (/\bmocha\b/i.test(sectionContent))
+            testCmd = "npx mocha";
+        // Detect build command
+        let buildCmd = "npm run build";
+        if (/\btsc\b/i.test(sectionContent))
+            buildCmd = "npx tsc";
+        return { setup: "npm install", test: testCmd, build: buildCmd, dev: "npm run dev" };
+    }
+    if (isPython) {
+        let testCmd = "python -m pytest";
+        if (/\bpytest\b/i.test(sectionContent))
+            testCmd = "pytest";
+        else if (/\bunittest\b/i.test(sectionContent))
+            testCmd = "python -m unittest discover";
+        return {
+            setup: "pip install -r requirements.txt",
+            test: testCmd,
+            build: "python -m build",
+            dev: "python -m uvicorn main:app --reload",
+        };
+    }
+    if (isRust) {
+        return {
+            setup: "cargo build",
+            test: "cargo test",
+            build: "cargo build --release",
+            dev: "cargo run",
+        };
+    }
+    if (isGo) {
+        return {
+            setup: "go mod download",
+            test: "go test ./...",
+            build: "go build ./...",
+            dev: "go run .",
+        };
+    }
+    return null;
+}
+export function customizeAgentMd(template, stack) {
+    const sections = [
+        { heading: "Project Setup", command: stack.setup },
+        { heading: "Running Tests", command: stack.test },
+        { heading: "Build Commands", command: stack.build },
+        { heading: "Development Server", command: stack.dev },
+    ];
+    let result = template;
+    for (const { heading, command } of sections) {
+        // Replace code block content after the section heading
+        const pattern = new RegExp(`(## ${heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\n)\`\`\`bash\\n[\\s\\S]*?\`\`\``, "m");
+        result = result.replace(pattern, `$1\`\`\`bash\n${command}\n\`\`\``);
+    }
+    return result;
+}

package/dist/transition/types.d.ts

@@ -0,0 +1,60 @@
+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 interface TechStack {
+    setup: string;
+    test: string;
+    build: string;
+    dev: string;
+}
+export interface FixPlanItem {
+    id: string;
+    completed: boolean;
+}
+export interface FixPlanItemWithTitle extends FixPlanItem {
+    title?: string;
+}
+export interface TruncationInfo {
+    field: string;
+    originalLength: number;
+    truncatedTo: number;
+}
+export interface SpecsChange {
+    file: string;
+    status: "added" | "modified" | "removed";
+    summary?: string;
+}
+export type SpecFileType = "prd" | "architecture" | "stories" | "ux" | "test-design" | "readiness" | "sprint" | "brainstorm" | "other";
+export type Priority = "critical" | "high" | "medium" | "low";
+export interface SpecFileMetadata {
+    path: string;
+    size: number;
+    type: SpecFileType;
+    priority: Priority;
+    description: string;
+}
+export interface SpecsIndex {
+    generatedAt: string;
+    totalFiles: number;
+    totalSizeKb: number;
+    files: SpecFileMetadata[];
+}
+export interface TransitionResult {
+    storiesCount: number;
+    warnings: string[];
+    fixPlanPreserved: boolean;
+}

package/dist/transition/types.js

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

package/dist/utils/config.d.ts

@@ -1,7 +1,11 @@
+export interface UpstreamVersions {
+    bmadCommit: string;
+}
 export interface BmalphConfig {
     name: string;
     description: string;
     createdAt: string;
+    upstreamVersions?: UpstreamVersions;
 }
 export declare function readConfig(projectDir: string): Promise<BmalphConfig | null>;
 export declare function writeConfig(projectDir: string, config: BmalphConfig): Promise<void>;

package/dist/utils/config.js

@@ -1,14 +1,24 @@
-import { writeFile } from "fs/promises";
+import { mkdir } from "fs/promises";
 import { join } from "path";
 import { readJsonFile } from "./json.js";
 import { validateConfig } from "./validate.js";
-const CONFIG_FILE = "bmalph/config.json";
+import { CONFIG_FILE } from "./constants.js";
+import { atomicWriteFile } from "./file-system.js";
+import { warn } from "./logger.js";
+import { formatError } from "./errors.js";
 export async function readConfig(projectDir) {
     const data = await readJsonFile(join(projectDir, CONFIG_FILE));
     if (data === null)
         return null;
-    return validateConfig(data);
+    try {
+        return validateConfig(data);
+    }
+    catch (err) {
+        warn(`Config file is corrupted, treating as missing: ${formatError(err)}`);
+        return null;
+    }
 }
 export async function writeConfig(projectDir, config) {
-    await writeFile(join(projectDir, CONFIG_FILE), JSON.stringify(config, null, 2) + "\n");
+    await mkdir(join(projectDir, "bmalph"), { recursive: true });
+    await atomicWriteFile(join(projectDir, CONFIG_FILE), JSON.stringify(config, null, 2) + "\n");
 }

package/dist/utils/constants.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Centralized constants for bmalph.
+ *
+ * Path constants define the standard directory names used throughout
+ * the bmalph project for BMAD, Ralph, and Claude Code integration.
+ *
+ * Numeric thresholds are used for validation, file processing, and health checks.
+ */
+/** Maximum allowed project name length */
+export declare const MAX_PROJECT_NAME_LENGTH = 100;
+/** File size threshold for "large file" warnings (50 KB) */
+export declare const LARGE_FILE_THRESHOLD_BYTES = 50000;
+/** Default max length for extracted content snippets */
+export declare const DEFAULT_SNIPPET_MAX_LENGTH = 60;
+/** Max length for section extraction from documents (increased to preserve full BMAD specs) */
+export declare const SECTION_EXTRACT_MAX_LENGTH = 5000;
+/** Max characters for diff line preview */
+export declare const DIFF_LINE_PREVIEW_LENGTH = 50;
+/** Session age warning threshold (24 hours in milliseconds) */
+export declare const SESSION_AGE_WARNING_MS: number;
+/** API call usage warning threshold (percentage) */
+export declare const API_USAGE_WARNING_PERCENT = 90;
+/** Ralph working directory (contains loop, specs, logs) */
+export declare const RALPH_DIR = ".ralph";
+/** BMAD agents and workflows directory */
+export declare const BMAD_DIR = "_bmad";
+/** bmalph state directory (config, phase tracking) */
+export declare const BMALPH_DIR = "bmalph";
+/** BMAD output directory (planning artifacts) */
+export declare const BMAD_OUTPUT_DIR = "_bmad-output";
+/** Ralph logs directory */
+export declare const RALPH_LOGS_DIR = ".ralph/logs";
+/** Ralph specs directory (copied from _bmad-output) */
+export declare const RALPH_SPECS_DIR = ".ralph/specs";
+/** Claude Code slash commands directory */
+export declare const CLAUDE_COMMANDS_DIR = ".claude/commands";
+/** bmalph state subdirectory (inside BMALPH_DIR) */
+export declare const STATE_DIR = "bmalph/state";
+/** bmalph config file path */
+export declare const CONFIG_FILE = "bmalph/config.json";
+/** Ralph status file path */
+export declare const RALPH_STATUS_FILE = ".ralph/status.json";
+/**
+ * Get absolute path to Ralph directory for a project.
+ */
+export declare function getRalphDir(projectDir: string): string;
+/**
+ * Get absolute path to BMAD directory for a project.
+ */
+export declare function getBmadDir(projectDir: string): string;
+/**
+ * Get absolute path to bmalph state directory for a project.
+ */
+export declare function getBmalphDir(projectDir: string): string;
+/**
+ * Get absolute path to BMAD output directory for a project.
+ */
+export declare function getBmadOutputDir(projectDir: string): string;
+/**
+ * Get absolute path to Ralph logs directory for a project.
+ */
+export declare function getRalphLogsDir(projectDir: string): string;
+/**
+ * Get absolute path to Ralph specs directory for a project.
+ */
+export declare function getRalphSpecsDir(projectDir: string): string;
+/**
+ * Get absolute path to Claude commands directory for a project.
+ */
+export declare function getClaudeCommandsDir(projectDir: string): string;