@uxmaltech/collab-cli 0.1.0

package/dist/lib/canon-resolver.js

@@ -0,0 +1,262 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCanonsBaseDir = getCanonsBaseDir;
+exports.isCanonsAvailable = isCanonsAvailable;
+exports.syncCanons = syncCanons;
+exports.resolveCanonFile = resolveCanonFile;
+exports.copyCanonContent = copyCanonContent;
+exports.isBusinessCanonConfigured = isBusinessCanonConfigured;
+exports.getBusinessCanonDir = getBusinessCanonDir;
+exports.syncBusinessCanon = syncBusinessCanon;
+exports.copyBusinessCanonContent = copyBusinessCanonContent;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const CANON_REPO_NAME = 'collab-architecture';
+const CANONS_SUBDIR = 'canons';
+const CANON_REPO_URL = 'https://github.com/uxmaltech/collab-architecture.git';
+const CANON_BRANCH = 'main';
+const ALLOWED_PREFIX = 'prompts/';
+/**
+ * Returns the base directory for the collab-architecture canon repo.
+ * Respects the COLLAB_HOME environment variable, defaulting to ~/.collab.
+ */
+function getCanonsBaseDir() {
+    const collabHome = process.env.COLLAB_HOME ?? node_path_1.default.join(node_os_1.default.homedir(), '.collab');
+    return node_path_1.default.join(collabHome, CANONS_SUBDIR, CANON_REPO_NAME);
+}
+/**
+ * Checks whether the canons directory exists and contains prompts.
+ */
+function isCanonsAvailable() {
+    const dir = getCanonsBaseDir();
+    return node_fs_1.default.existsSync(node_path_1.default.join(dir, 'prompts'));
+}
+/**
+ * Clones or pulls the collab-architecture canons repository.
+ * Returns true on success, false on failure.
+ */
+function syncCanons(log) {
+    const canonsDir = getCanonsBaseDir();
+    const parentDir = node_path_1.default.dirname(canonsDir);
+    const print = log ?? console.log;
+    try {
+        if (node_fs_1.default.existsSync(node_path_1.default.join(canonsDir, '.git'))) {
+            print(`Updating canons in ${canonsDir}...`);
+            (0, node_child_process_1.execFileSync)('git', ['-C', canonsDir, 'fetch', 'origin', CANON_BRANCH], {
+                stdio: ['ignore', 'pipe', 'inherit'],
+            });
+            (0, node_child_process_1.execFileSync)('git', ['-C', canonsDir, 'checkout', CANON_BRANCH], {
+                stdio: ['ignore', 'pipe', 'inherit'],
+            });
+            (0, node_child_process_1.execFileSync)('git', ['-C', canonsDir, 'reset', '--hard', `origin/${CANON_BRANCH}`], {
+                stdio: ['ignore', 'pipe', 'inherit'],
+            });
+        }
+        else {
+            print(`Cloning canons into ${canonsDir}...`);
+            node_fs_1.default.mkdirSync(parentDir, { recursive: true });
+            (0, node_child_process_1.execFileSync)('git', ['clone', '--branch', CANON_BRANCH, '--single-branch', CANON_REPO_URL, canonsDir], { stdio: ['ignore', 'inherit', 'inherit'] });
+        }
+        return true;
+    }
+    catch (err) {
+        print(`Failed to sync canons: ${String(err)}`);
+        return false;
+    }
+}
+/**
+ * Reads a prompt file from the canons directory.
+ * Only files under prompts/ are allowed — canon content is never read directly.
+ * Returns the file content as a string, or null if the file does not exist.
+ */
+function resolveCanonFile(relativePath) {
+    if (!relativePath.startsWith(ALLOWED_PREFIX)) {
+        throw new Error(`Canon resolver only allows reading from '${ALLOWED_PREFIX}'. ` +
+            `Requested: '${relativePath}'. Canon content must never be copied to projects.`);
+    }
+    const filePath = node_path_1.default.join(getCanonsBaseDir(), relativePath);
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return null;
+    }
+    return node_fs_1.default.readFileSync(filePath, 'utf8');
+}
+/** Directories and root files to copy from canon repo to target. */
+const CANON_COPY_DIRS = [
+    'domains',
+    'knowledge',
+    'contracts',
+    'governance',
+    'graph',
+    'schema',
+    'prompts',
+    'embeddings',
+    'evolution',
+];
+const CANON_COPY_ROOT_FILES = ['AGENTS.md', 'README.md'];
+/**
+ * Counts files recursively inside a directory.
+ */
+function countFiles(dir) {
+    if (!node_fs_1.default.existsSync(dir)) {
+        return 0;
+    }
+    let count = 0;
+    const entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isFile()) {
+            count++;
+        }
+        else if (entry.isDirectory()) {
+            count += countFiles(node_path_1.default.join(dir, entry.name));
+        }
+    }
+    return count;
+}
+/**
+ * Copies the full collab-architecture canon content to a target directory.
+ * This is used by the file-only pipeline to create `docs/architecture/uxmaltech/`.
+ *
+ * Copies: domains/, knowledge/, contracts/, governance/, graph/, schema/,
+ * prompts/, embeddings/, evolution/, AGENTS.md, README.md
+ *
+ * Returns the number of files copied.
+ */
+function copyCanonContent(targetDir, log) {
+    const sourceDir = getCanonsBaseDir();
+    const print = log ?? (() => { });
+    if (!node_fs_1.default.existsSync(sourceDir)) {
+        throw new Error(`Canon source not found at ${sourceDir}. Run syncCanons() first.`);
+    }
+    node_fs_1.default.mkdirSync(targetDir, { recursive: true });
+    let totalFiles = 0;
+    for (const dir of CANON_COPY_DIRS) {
+        const src = node_path_1.default.join(sourceDir, dir);
+        const dest = node_path_1.default.join(targetDir, dir);
+        if (!node_fs_1.default.existsSync(src)) {
+            continue;
+        }
+        node_fs_1.default.cpSync(src, dest, { recursive: true });
+        const fileCount = countFiles(dest);
+        totalFiles += fileCount;
+        print(`  Copied ${dir}/ (${fileCount} files)`);
+    }
+    for (const file of CANON_COPY_ROOT_FILES) {
+        const src = node_path_1.default.join(sourceDir, file);
+        const dest = node_path_1.default.join(targetDir, file);
+        if (!node_fs_1.default.existsSync(src)) {
+            continue;
+        }
+        node_fs_1.default.copyFileSync(src, dest);
+        totalFiles++;
+        print(`  Copied ${file}`);
+    }
+    return totalFiles;
+}
+// ────────────────────────────────────────────────────────────────
+// Business canon support
+// ────────────────────────────────────────────────────────────────
+/**
+ * Returns true if the config has a business canon configured.
+ */
+function isBusinessCanonConfigured(config) {
+    return !!config.canons?.business?.repo;
+}
+/**
+ * Returns the local directory where the business canon is cloned.
+ */
+function getBusinessCanonDir(config) {
+    const canon = config.canons?.business;
+    if (!canon) {
+        throw new Error('No business canon configured.');
+    }
+    const repoName = canon.repo.split('/').pop() ?? canon.repo;
+    const collabHome = process.env.COLLAB_HOME ?? node_path_1.default.join(node_os_1.default.homedir(), '.collab');
+    return node_path_1.default.join(collabHome, CANONS_SUBDIR, repoName);
+}
+/**
+ * Clones or pulls the business canon repository.
+ * Uses the workspace GitHub token if available, otherwise falls back to default git credentials.
+ */
+function syncBusinessCanon(config, log, token) {
+    const canon = config.canons?.business;
+    if (!canon) {
+        return false;
+    }
+    const canonsDir = getBusinessCanonDir(config);
+    const parentDir = node_path_1.default.dirname(canonsDir);
+    const print = log ?? console.log;
+    const branch = canon.branch || 'main';
+    // Build repo URL — inject token for private repo access if available
+    let repoUrl;
+    if (token) {
+        repoUrl = `https://x-access-token:${token}@github.com/${canon.repo}.git`;
+    }
+    else {
+        repoUrl = `https://github.com/${canon.repo}.git`;
+    }
+    try {
+        if (node_fs_1.default.existsSync(node_path_1.default.join(canonsDir, '.git'))) {
+            print(`Updating business canon in ${canonsDir}...`);
+            (0, node_child_process_1.execFileSync)('git', ['-C', canonsDir, 'fetch', 'origin', branch], {
+                stdio: ['ignore', 'pipe', 'inherit'],
+            });
+            (0, node_child_process_1.execFileSync)('git', ['-C', canonsDir, 'checkout', branch], {
+                stdio: ['ignore', 'pipe', 'inherit'],
+            });
+            (0, node_child_process_1.execFileSync)('git', ['-C', canonsDir, 'reset', '--hard', `origin/${branch}`], {
+                stdio: ['ignore', 'pipe', 'inherit'],
+            });
+        }
+        else {
+            print(`Cloning business canon into ${canonsDir}...`);
+            node_fs_1.default.mkdirSync(parentDir, { recursive: true });
+            (0, node_child_process_1.execFileSync)('git', ['clone', '--branch', branch, '--single-branch', repoUrl, canonsDir], { stdio: ['ignore', 'inherit', 'inherit'] });
+        }
+        return true;
+    }
+    catch (err) {
+        print(`Failed to sync business canon: ${String(err)}`);
+        return false;
+    }
+}
+/**
+ * Copies the business canon content to a target directory.
+ * Copies all directories and root files found in the canon.
+ */
+function copyBusinessCanonContent(config, targetDir, log) {
+    const sourceDir = getBusinessCanonDir(config);
+    const print = log ?? (() => { });
+    if (!node_fs_1.default.existsSync(sourceDir)) {
+        throw new Error(`Business canon source not found at ${sourceDir}. Run syncBusinessCanon() first.`);
+    }
+    node_fs_1.default.mkdirSync(targetDir, { recursive: true });
+    let totalFiles = 0;
+    // Copy same directories as framework canon (where they exist)
+    for (const dir of CANON_COPY_DIRS) {
+        const src = node_path_1.default.join(sourceDir, dir);
+        const dest = node_path_1.default.join(targetDir, dir);
+        if (!node_fs_1.default.existsSync(src)) {
+            continue;
+        }
+        node_fs_1.default.cpSync(src, dest, { recursive: true });
+        const fileCount = countFiles(dest);
+        totalFiles += fileCount;
+        print(`  Copied ${dir}/ (${fileCount} files)`);
+    }
+    for (const file of CANON_COPY_ROOT_FILES) {
+        const src = node_path_1.default.join(sourceDir, file);
+        const dest = node_path_1.default.join(targetDir, file);
+        if (!node_fs_1.default.existsSync(src)) {
+            continue;
+        }
+        node_fs_1.default.copyFileSync(src, dest);
+        totalFiles++;
+        print(`  Copied ${file}`);
+    }
+    return totalFiles;
+}

package/dist/lib/canon-scaffold.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCanonScaffold = generateCanonScaffold;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const canon_1 = require("../templates/canon");
+/**
+ * Defines the complete canonical architecture scaffold tree.
+ * Each entry maps a relative file path to its template content.
+ */
+function buildScaffoldEntries() {
+    return [
+        // Governance
+        { relativePath: 'governance/what-enters-the-canon.md', content: canon_1.whatEntersTheCanonTemplate },
+        { relativePath: 'governance/implementation-process.md', content: canon_1.implementationProcessTemplate },
+        { relativePath: 'governance/schema-versioning.md', content: canon_1.schemaVersioningTemplate },
+        { relativePath: 'governance/confidence-levels.md', content: canon_1.confidenceLevelsTemplate },
+        { relativePath: 'governance/review-process.md', content: canon_1.reviewProcessTemplate },
+        // Knowledge
+        { relativePath: 'knowledge/axioms/README.md', content: canon_1.knowledgeAxiomsReadme },
+        { relativePath: 'knowledge/decisions/README.md', content: canon_1.knowledgeDecisionsReadme },
+        { relativePath: 'knowledge/conventions/README.md', content: canon_1.knowledgeConventionsReadme },
+        { relativePath: 'knowledge/anti-patterns/README.md', content: canon_1.knowledgeAntiPatternsReadme },
+        // Domains
+        { relativePath: 'domains/README.md', content: canon_1.domainReadme },
+        // Contracts
+        { relativePath: 'contracts/README.md', content: canon_1.contractsReadme },
+        // Evolution
+        { relativePath: 'evolution/changelog.md', content: canon_1.changelogTemplate },
+        { relativePath: 'evolution/upgrade-guide.md', content: canon_1.upgradeGuideTemplate },
+        { relativePath: 'evolution/deprecated.md', content: canon_1.deprecatedTemplate },
+    ];
+}
+function generateCanonScaffold(ctx) {
+    const archDir = ctx.config.architectureDir;
+    const entries = buildScaffoldEntries();
+    let created = 0;
+    let skipped = 0;
+    for (const entry of entries) {
+        const target = node_path_1.default.join(archDir, entry.relativePath);
+        // Never overwrite existing files — the user may have customized them.
+        if (!ctx.executor.dryRun && node_fs_1.default.existsSync(target)) {
+            ctx.logger.debug(`Scaffold file already exists, skipping: ${entry.relativePath}`);
+            skipped++;
+            continue;
+        }
+        ctx.executor.ensureDirectory(node_path_1.default.dirname(target));
+        ctx.executor.writeFile(target, entry.content, {
+            description: `scaffold ${entry.relativePath}`,
+        });
+        created++;
+    }
+    ctx.logger.info(`Canon scaffold: ${created} file(s) created, ${skipped} existing file(s) preserved.`);
+}

package/dist/lib/cli-detection.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkGhAuth = checkGhAuth;
+exports.detectProviderCli = detectProviderCli;
+exports.detectAllClis = detectAllClis;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+/** CLI commands for each provider. */
+const CLI_COMMANDS = {
+    codex: 'codex',
+    claude: 'claude',
+    gemini: 'gemini',
+    copilot: 'gh',
+};
+/**
+ * Tries to run `<command> --version` and returns the trimmed stdout.
+ * Returns null if the command is not found or fails.
+ */
+function probeVersion(command) {
+    try {
+        const output = (0, node_child_process_1.execSync)(`${command} --version`, {
+            encoding: 'utf8',
+            timeout: 5_000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return output.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Checks if a command exists on the system PATH.
+ */
+function commandExists(command) {
+    try {
+        const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+        (0, node_child_process_1.execSync)(`${whichCmd} ${command}`, {
+            encoding: 'utf8',
+            timeout: 3_000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Config file paths for each provider CLI (relative to home dir). */
+const CLI_CONFIG_PATHS = {
+    codex: '.codex/config.toml',
+    claude: '.claude.json',
+    gemini: '.gemini/settings.json',
+    copilot: '',
+};
+/**
+ * Reads the configured model from a provider's CLI config file.
+ * Returns null if the config doesn't exist or can't be parsed.
+ */
+function readCliConfigModel(provider) {
+    try {
+        const configRelPath = CLI_CONFIG_PATHS[provider];
+        if (!configRelPath) {
+            return null;
+        }
+        const homeDir = node_os_1.default.homedir();
+        const configPath = node_path_1.default.join(homeDir, configRelPath);
+        if (!node_fs_1.default.existsSync(configPath)) {
+            return null;
+        }
+        const content = node_fs_1.default.readFileSync(configPath, 'utf8');
+        if (provider === 'codex') {
+            // TOML: look for top-level `model = "..."` line
+            const match = content.match(/^\s*model\s*=\s*"([^"]+)"/m);
+            return match?.[1] ?? null;
+        }
+        // JSON-based configs (claude, gemini)
+        const parsed = JSON.parse(content);
+        return parsed.model ?? parsed.defaultModel ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Checks whether `gh auth status` reports an authenticated session.
+ */
+function checkGhAuth() {
+    try {
+        (0, node_child_process_1.execSync)('gh auth status', {
+            encoding: 'utf8',
+            timeout: 5_000,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Detects whether the official CLI for a provider is installed.
+ * Also reads the CLI config to detect the currently configured model.
+ *
+ * - codex   → `codex` (OpenAI Codex CLI)
+ * - claude  → `claude` (Claude Code CLI)
+ * - gemini  → `gemini` (Google Gemini CLI)
+ * - copilot → `gh` (GitHub CLI with auth)
+ */
+function detectProviderCli(provider) {
+    const command = CLI_COMMANDS[provider];
+    const available = commandExists(command);
+    if (!available) {
+        return { command, available: false };
+    }
+    // Copilot requires gh auth — not just gh installed
+    if (provider === 'copilot') {
+        const authenticated = checkGhAuth();
+        if (!authenticated) {
+            return { command, available: false };
+        }
+        const version = probeVersion(command);
+        return { command, available: true, version: version ?? undefined };
+    }
+    const version = probeVersion(command);
+    const configuredModel = readCliConfigModel(provider);
+    return {
+        command,
+        available: true,
+        version: version ?? undefined,
+        configuredModel: configuredModel ?? undefined,
+    };
+}
+/**
+ * Detects all provider CLIs at once. Returns a record keyed by provider.
+ */
+function detectAllClis() {
+    return {
+        codex: detectProviderCli('codex'),
+        claude: detectProviderCli('claude'),
+        gemini: detectProviderCli('gemini'),
+        copilot: detectProviderCli('copilot'),
+    };
+}

package/dist/lib/command-context.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommandContext = createCommandContext;
+const config_1 = require("./config");
+const executor_1 = require("./executor");
+const logger_1 = require("./logger");
+/**
+ * Builds a {@link CommandContext} from a Commander action's `command` ref.
+ * Reads global options, resolves the workspace, and wires up logging.
+ */
+function createCommandContext(command) {
+    const options = command.optsWithGlobals();
+    const cwd = options.cwd ? options.cwd : process.cwd();
+    const logger = (0, logger_1.createLogger)({ verbose: options.verbose, quiet: options.quiet });
+    const dryRun = Boolean(options.dryRun);
+    return {
+        cwd,
+        logger,
+        config: (0, config_1.loadCollabConfig)(cwd),
+        executor: new executor_1.Executor(logger, { dryRun, cwd }),
+        dryRun,
+    };
+}

package/dist/lib/compose-defaults.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPOSE_ENV_ORDER = exports.COMPOSE_ENV_DEFAULTS = void 0;
+exports.scopedComposeDefaults = scopedComposeDefaults;
+exports.COMPOSE_ENV_DEFAULTS = {
+    COLLAB_NETWORK: 'collab-network',
+    QDRANT_HOST: '127.0.0.1',
+    QDRANT_IMAGE: 'qdrant/qdrant:v1.13.4',
+    QDRANT_PORT: '6333',
+    QDRANT_VOLUME: 'collab-qdrant-data',
+    NEBULA_HOST: '127.0.0.1',
+    NEBULA_VERSION: 'v3.6.0',
+    NEBULA_METAD_PORT: '9559',
+    NEBULA_METAD_HTTP_PORT: '19559',
+    NEBULA_STORAGED_PORT: '9779',
+    NEBULA_STORAGED_HTTP_PORT: '19779',
+    NEBULA_GRAPHD_PORT: '9669',
+    NEBULA_GRAPHD_HTTP_PORT: '19669',
+    NEBULA_METAD_VOLUME: 'collab-nebula-metad0',
+    NEBULA_STORAGED_VOLUME: 'collab-nebula-storaged0',
+    MCP_HOST: '127.0.0.1',
+    MCP_IMAGE: 'ghcr.io/uxmaltech/collab-architecture-mcp:latest',
+    MCP_PORT: '7337',
+    MCP_CONTAINER_PORT: '7337',
+    MCP_VOLUME: 'collab-mcp-data',
+    MCP_ENV: 'local',
+    MCP_API_KEYS: '',
+    MCP_TECHNICAL_SCOPES: 'uxmaltech',
+};
+exports.COMPOSE_ENV_ORDER = Object.keys(exports.COMPOSE_ENV_DEFAULTS);
+/**
+ * Returns compose env defaults with workspace-scoped resource names.
+ * Prefixes network, volume, and project names with the workspace name
+ * to avoid collisions between workspaces running simultaneously.
+ */
+function scopedComposeDefaults(workspaceName) {
+    const slug = workspaceName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    const prefix = slug ? `collab-${slug}` : 'collab';
+    return {
+        ...exports.COMPOSE_ENV_DEFAULTS,
+        COLLAB_NETWORK: `${prefix}-network`,
+        QDRANT_VOLUME: `${prefix}-qdrant-data`,
+        NEBULA_METAD_VOLUME: `${prefix}-nebula-metad0`,
+        NEBULA_STORAGED_VOLUME: `${prefix}-nebula-storaged0`,
+        MCP_VOLUME: `${prefix}-mcp-data`,
+    };
+}

package/dist/lib/compose-env.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureComposeEnvFile = ensureComposeEnvFile;
+const compose_defaults_1 = require("./compose-defaults");
+const env_file_1 = require("./env-file");
+function ensureComposeEnvFile(envFilePath, logger, executor, overrides, defaults = compose_defaults_1.COMPOSE_ENV_DEFAULTS) {
+    const existing = (0, env_file_1.readEnvFile)(envFilePath);
+    const merged = (0, env_file_1.mergeEnvWithDefaults)(existing, defaults);
+    if (overrides) {
+        for (const [key, value] of Object.entries(overrides)) {
+            merged[key] = value;
+        }
+    }
+    (0, env_file_1.writeEnvFile)(envFilePath, merged, compose_defaults_1.COMPOSE_ENV_ORDER, executor);
+    if (Object.keys(existing).length === 0) {
+        logger.info(executor?.dryRun ? `[dry-run] Would create env file: ${envFilePath}` : `Created env file: ${envFilePath}`);
+    }
+    else {
+        logger.debug(executor?.dryRun
+            ? `[dry-run] Would update env file while preserving overrides: ${envFilePath}`
+            : `Updated env file while preserving overrides: ${envFilePath}`);
+    }
+    return merged;
+}

package/dist/lib/compose-paths.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComposeFilePaths = getComposeFilePaths;
+exports.fileExists = fileExists;
+exports.selectInfraComposeFile = selectInfraComposeFile;
+exports.selectMcpComposeFile = selectMcpComposeFile;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function getComposeFilePaths(config, outputDirectory) {
+    const targetDirectory = outputDirectory
+        ? node_path_1.default.resolve(config.workspaceDir, outputDirectory)
+        : config.workspaceDir;
+    return {
+        consolidated: node_path_1.default.resolve(targetDirectory, config.compose.consolidatedFile),
+        infra: node_path_1.default.resolve(targetDirectory, config.compose.infraFile),
+        mcp: node_path_1.default.resolve(targetDirectory, config.compose.mcpFile),
+    };
+}
+function fileExists(filePath) {
+    return node_fs_1.default.existsSync(filePath);
+}
+function selectInfraComposeFile(paths) {
+    if (fileExists(paths.infra)) {
+        return { file: paths.infra, source: 'split' };
+    }
+    return { file: paths.consolidated, source: 'consolidated' };
+}
+function selectMcpComposeFile(paths) {
+    if (fileExists(paths.mcp)) {
+        return { file: paths.mcp, source: 'split' };
+    }
+    return { file: paths.consolidated, source: 'consolidated' };
+}