@uxmaltech/collab-cli 0.1.0

package/dist/commands/mcp/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMcpCommand = registerMcpCommand;
+const start_1 = require("./start");
+const status_1 = require("./status");
+const stop_1 = require("./stop");
+function registerMcpCommand(program) {
+    const mcp = program
+        .command('mcp')
+        .description('Manage MCP runtime lifecycle')
+        .addHelpText('after', `
+Examples:
+  collab mcp start
+  collab mcp stop
+  collab mcp status
+`);
+    (0, start_1.registerMcpStartCommand)(mcp);
+    (0, stop_1.registerMcpStopCommand)(mcp);
+    (0, status_1.registerMcpStatusCommand)(mcp);
+}

package/dist/commands/mcp/shared.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.resolveMcpComposeFile = resolveMcpComposeFile;
+exports.runMcpCompose = runMcpCompose;
+const node_path_1 = __importDefault(require("node:path"));
+const compose_paths_1 = require("../../lib/compose-paths");
+const docker_compose_1 = require("../../lib/docker-compose");
+const errors_1 = require("../../lib/errors");
+const preconditions_1 = require("../../lib/preconditions");
+const service_health_1 = require("../../lib/service-health");
+/**
+ * Resolves the compose file to use for the MCP service.
+ * Prefers an explicit `--file` flag, then falls back to compose-paths resolution.
+ */
+function resolveMcpComposeFile(config, outputDirectory, explicitFile) {
+    if (explicitFile) {
+        const filePath = node_path_1.default.resolve(config.workspaceDir, explicitFile);
+        return { filePath, source: 'split' };
+    }
+    const paths = (0, compose_paths_1.getComposeFilePaths)(config, outputDirectory);
+    const selected = (0, compose_paths_1.selectMcpComposeFile)(paths);
+    return {
+        filePath: selected.file,
+        source: selected.source,
+    };
+}
+/**
+ * Runs a docker compose action for the MCP service.
+ * When the action is `'up'`, waits for health checks to pass.
+ */
+async function runMcpCompose(logger, executor, config, selection, action, options = {}) {
+    (0, preconditions_1.ensureCommandAvailable)('docker', { dryRun: executor.dryRun });
+    if (!executor.dryRun) {
+        (0, preconditions_1.ensureFileExists)(selection.filePath, 'Compose file');
+    }
+    const args = action === 'up' ? ['up', '-d'] : action === 'stop' ? ['stop'] : ['ps'];
+    const serviceScope = selection.source === 'consolidated' ? ['mcp'] : [];
+    (0, docker_compose_1.runDockerCompose)({
+        executor,
+        files: [selection.filePath],
+        arguments: [...args, ...serviceScope],
+        cwd: config.workspaceDir,
+        projectName: config.compose.projectName,
+    });
+    if (action !== 'up') {
+        return;
+    }
+    const env = (0, service_health_1.loadRuntimeEnv)(config);
+    const health = await (0, service_health_1.waitForMcpHealth)(env, (0, service_health_1.dryRunHealthOptions)(executor, options.health ?? {}));
+    (0, service_health_1.logServiceHealth)(logger, 'mcp health', health);
+    if (!health.ok) {
+        throw new errors_1.CliError('MCP service did not become healthy in time.');
+    }
+}

package/dist/commands/mcp/start.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMcpStartCommand = registerMcpStartCommand;
+const command_context_1 = require("../../lib/command-context");
+const ecosystem_1 = require("../../lib/ecosystem");
+const parsers_1 = require("../../lib/parsers");
+const shared_1 = require("./shared");
+function healthOptions(options) {
+    return {
+        timeoutMs: (0, parsers_1.parsePositiveInt)('--timeout-ms', options.timeoutMs, 5_000),
+        retries: (0, parsers_1.parsePositiveInt)('--retries', options.retries, 15),
+        retryDelayMs: (0, parsers_1.parsePositiveInt)('--retry-delay-ms', options.retryDelayMs, 2_000),
+    };
+}
+function registerMcpStartCommand(program) {
+    program
+        .command('start')
+        .description('Start MCP runtime service and verify health endpoint')
+        .option('--file <path>', 'Compose file to use')
+        .option('--output-dir <directory>', 'Directory used to locate generated compose files')
+        .option('--timeout-ms <ms>', 'Per-check timeout in milliseconds', '5000')
+        .option('--retries <count>', 'Health check retries', '15')
+        .option('--retry-delay-ms <ms>', 'Delay between retries in milliseconds', '2000')
+        .addHelpText('after', `
+Examples:
+  collab mcp start
+  collab mcp start --file docker-compose.mcp.yml --timeout-ms 3000 --retries 20
+`)
+        .action(async (options, command) => {
+        const context = (0, command_context_1.createCommandContext)(command);
+        const selection = (0, shared_1.resolveMcpComposeFile)(context.config, options.outputDir, options.file);
+        await (0, shared_1.runMcpCompose)(context.logger, context.executor, context.config, selection, 'up', {
+            health: healthOptions(options),
+        });
+        const compatibility = await (0, ecosystem_1.checkEcosystemCompatibility)(context.config, {
+            dryRun: context.executor.dryRun,
+        });
+        for (const item of compatibility) {
+            if (!item.ok) {
+                context.logger.warn(`${item.id}: ${item.detail}${item.fix ? ` | fix: ${item.fix}` : ''}`);
+            }
+        }
+        context.logger.result(`MCP service started using ${selection.filePath}`);
+    });
+}

package/dist/commands/mcp/status.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMcpStatusCommand = registerMcpStatusCommand;
+const command_context_1 = require("../../lib/command-context");
+const docker_compose_1 = require("../../lib/docker-compose");
+const docker_status_1 = require("../../lib/docker-status");
+const health_checker_1 = require("../../lib/health-checker");
+const preconditions_1 = require("../../lib/preconditions");
+const service_health_1 = require("../../lib/service-health");
+const shared_1 = require("./shared");
+/** Fast health check options for status display (no retries). */
+const QUICK_HEALTH_OPTIONS = { timeoutMs: 2_000, retries: 1, retryDelayMs: 0 };
+const MCP_SERVICES = ['mcp'];
+function registerMcpStatusCommand(program) {
+    program
+        .command('status')
+        .description('Show MCP runtime service status')
+        .option('--file <path>', 'Compose file to use')
+        .option('--output-dir <directory>', 'Directory used to locate generated compose files')
+        .addHelpText('after', `
+Examples:
+  collab mcp status
+  collab mcp status --file docker-compose.mcp.yml
+`)
+        .action(async (options, command) => {
+        const context = (0, command_context_1.createCommandContext)(command);
+        const selection = (0, shared_1.resolveMcpComposeFile)(context.config, options.outputDir, options.file);
+        (0, preconditions_1.ensureCommandAvailable)('docker', { dryRun: context.executor.dryRun });
+        if (!context.executor.dryRun) {
+            (0, preconditions_1.ensureFileExists)(selection.filePath, 'Compose file');
+        }
+        // Query container status via docker compose ps --format json
+        const serviceScope = selection.source === 'consolidated' ? ['mcp'] : [];
+        let containers = [];
+        try {
+            const result = (0, docker_compose_1.runDockerCompose)({
+                executor: context.executor,
+                files: [selection.filePath],
+                arguments: ['ps', '--format', 'json', ...serviceScope],
+                cwd: context.config.workspaceDir,
+                projectName: context.config.compose.projectName,
+                check: false,
+            });
+            containers = (0, docker_status_1.parseComposePs)(result.stdout);
+        }
+        catch {
+            // docker compose ps failed — treat as no running containers
+        }
+        // Run quick health check (skip in dry-run mode)
+        const env = (0, service_health_1.loadRuntimeEnv)(context.config);
+        const mcpHost = env['MCP_HOST'] || '127.0.0.1';
+        const mcpPort = Number(env['MCP_PORT']) || 7337;
+        const healthChecks = context.executor.dryRun
+            ? []
+            : await Promise.all([
+                (0, health_checker_1.checkHttpHealth)('mcp', `http://${mcpHost}:${mcpPort}/health`, QUICK_HEALTH_OPTIONS),
+            ]);
+        // Build and display status table
+        const services = (0, docker_status_1.buildServiceStatusList)([...MCP_SERVICES], containers, healthChecks);
+        (0, docker_status_1.printStatusTable)(context.logger, 'MCP Service', services, selection.filePath);
+    });
+}

package/dist/commands/mcp/stop.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMcpStopCommand = registerMcpStopCommand;
+const command_context_1 = require("../../lib/command-context");
+const shared_1 = require("./shared");
+function registerMcpStopCommand(program) {
+    program
+        .command('stop')
+        .description('Stop MCP runtime service')
+        .option('--file <path>', 'Compose file to use')
+        .option('--output-dir <directory>', 'Directory used to locate generated compose files')
+        .addHelpText('after', `
+Examples:
+  collab mcp stop
+  collab mcp stop --file docker-compose.yml
+`)
+        .action(async (options, command) => {
+        const context = (0, command_context_1.createCommandContext)(command);
+        const selection = (0, shared_1.resolveMcpComposeFile)(context.config, options.outputDir, options.file);
+        await (0, shared_1.runMcpCompose)(context.logger, context.executor, context.config, selection, 'stop');
+        context.logger.result(`MCP service stopped using ${selection.filePath}`);
+    });
+}

package/dist/commands/seed.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSeedCommand = registerSeedCommand;
+const node_path_1 = __importDefault(require("node:path"));
+const command_context_1 = require("../lib/command-context");
+const docker_compose_1 = require("../lib/docker-compose");
+const compose_paths_1 = require("../lib/compose-paths");
+const preconditions_1 = require("../lib/preconditions");
+function registerSeedCommand(program) {
+    program
+        .command('seed')
+        .description('Run a baseline infrastructure readiness check before seeding data')
+        .option('--file <path>', 'Compose file to use')
+        .option('--output-dir <directory>', 'Directory used to locate generated compose files')
+        .option('--dry-run', 'Print the seed preflight command without executing it')
+        .addHelpText('after', `
+Examples:
+  collab seed --dry-run
+  collab seed --file docker-compose.infra.yml
+`)
+        .action((options, command) => {
+        const context = (0, command_context_1.createCommandContext)(command);
+        const composePaths = (0, compose_paths_1.getComposeFilePaths)(context.config, options.outputDir);
+        const selected = options.file
+            ? { file: node_path_1.default.resolve(context.config.workspaceDir, options.file), source: 'split' }
+            : (0, compose_paths_1.selectInfraComposeFile)(composePaths);
+        const composeFile = options.file
+            ? node_path_1.default.resolve(context.config.workspaceDir, options.file)
+            : selected.file;
+        const isDryRun = context.executor.dryRun;
+        if (!isDryRun) {
+            (0, preconditions_1.ensureFileExists)(composeFile, 'Compose file');
+        }
+        if (isDryRun) {
+            const projectArgs = context.config.compose.projectName
+                ? ['-p', context.config.compose.projectName]
+                : [];
+            context.logger.command(['docker', 'compose', ...projectArgs, '-f', composeFile, 'ps']);
+            context.logger.result('Seed preflight command rendered (dry-run).');
+            return;
+        }
+        (0, preconditions_1.ensureCommandAvailable)('docker', { dryRun: isDryRun });
+        (0, docker_compose_1.runDockerCompose)({
+            executor: context.executor,
+            files: [composeFile],
+            arguments: ['ps'],
+            cwd: context.config.workspaceDir,
+            projectName: context.config.compose.projectName,
+        });
+        context.logger.result('Seed preflight passed. Infrastructure is reachable; run domain seeding workflow next.');
+    });
+}

package/dist/commands/uninstall.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUninstallCommand = registerUninstallCommand;
+const ansi_1 = require("../lib/ansi");
+const errors_1 = require("../lib/errors");
+const npm_operations_1 = require("../lib/npm-operations");
+const prompt_1 = require("../lib/prompt");
+function registerUninstallCommand(program) {
+    program
+        .command('uninstall')
+        .description('Uninstall collab-cli from the system')
+        .option('--yes', 'Skip confirmation prompt')
+        .addHelpText('after', `
+Examples:
+  collab uninstall          # Uninstall with confirmation prompt
+  collab uninstall --yes    # Uninstall without confirmation
+`)
+        .action(async (options) => {
+        const npmPath = (0, npm_operations_1.requireNpm)();
+        if (!npmPath) {
+            throw new errors_1.CliError('npm not found in PATH. Cannot uninstall.');
+        }
+        if (!options.yes) {
+            const accepted = await (0, prompt_1.promptBoolean)('Are you sure you want to uninstall collab-cli?', false);
+            if (!accepted) {
+                process.stdout.write('Uninstall cancelled.\n');
+                return;
+            }
+        }
+        process.stdout.write('Uninstalling collab-cli...\n');
+        if (!(0, npm_operations_1.npmGlobalUninstall)(npmPath)) {
+            throw new errors_1.CliError('Uninstall failed.');
+        }
+        process.stdout.write((0, ansi_1.green)(`${ansi_1.CHECK} collab-cli has been uninstalled successfully.\n`));
+    });
+}

package/dist/commands/up.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUpCommand = registerUpCommand;
+const command_context_1 = require("../lib/command-context");
+const ecosystem_1 = require("../lib/ecosystem");
+const mode_1 = require("../lib/mode");
+const orchestrator_1 = require("../lib/orchestrator");
+const parsers_1 = require("../lib/parsers");
+const shared_1 = require("./infra/shared");
+const shared_2 = require("./mcp/shared");
+function registerUpCommand(program) {
+    program
+        .command('up')
+        .description('Run full startup pipeline (infra -> MCP)')
+        .option('--mode <mode>', 'Execution mode: file-only|indexed')
+        .option('--file <path>', 'Compose file used for infra and mcp commands')
+        .option('--output-dir <directory>', 'Directory used to locate generated compose files')
+        .option('--timeout-ms <ms>', 'Per-check timeout in milliseconds', '5000')
+        .option('--retries <count>', 'Health check retries', '15')
+        .option('--retry-delay-ms <ms>', 'Delay between retries in milliseconds', '2000')
+        .option('--resume', 'Resume from last incomplete stage for this workflow')
+        .addHelpText('after', `
+Examples:
+  collab up
+  collab up --mode indexed --timeout-ms 3000 --retries 20
+  collab up --resume
+`)
+        .action(async (options, command) => {
+        const context = (0, command_context_1.createCommandContext)(command);
+        const mode = (0, mode_1.parseMode)(options.mode, context.config.mode);
+        if (mode === 'file-only') {
+            context.logger.result('Mode file-only: skipping infra and MCP startup pipeline.');
+            return;
+        }
+        const health = (0, parsers_1.parseHealthOptions)(options);
+        await (0, orchestrator_1.runOrchestration)({
+            workflowId: 'up',
+            config: context.config,
+            executor: context.executor,
+            logger: context.logger,
+            resume: options.resume,
+        }, [
+            {
+                id: 'infra-up',
+                title: 'Start infrastructure services',
+                recovery: [
+                    'Run collab infra status to inspect service state.',
+                    'Run collab up --resume after fixing infra issues.',
+                ],
+                run: async () => {
+                    const selection = (0, shared_1.resolveInfraComposeFile)(context.config, options.outputDir, options.file);
+                    await (0, shared_1.runInfraCompose)(context.logger, context.executor, context.config, selection, 'up', { health });
+                },
+            },
+            {
+                id: 'mcp-up',
+                title: 'Start MCP service',
+                recovery: [
+                    'Run collab mcp status to inspect service state.',
+                    'Run collab up --resume after fixing MCP issues.',
+                ],
+                run: async () => {
+                    const selection = (0, shared_2.resolveMcpComposeFile)(context.config, options.outputDir, options.file);
+                    await (0, shared_2.runMcpCompose)(context.logger, context.executor, context.config, selection, 'up', { health });
+                },
+            },
+        ]);
+        const compatibility = await (0, ecosystem_1.checkEcosystemCompatibility)(context.config, {
+            dryRun: context.executor.dryRun,
+        });
+        for (const item of compatibility) {
+            if (!item.ok) {
+                context.logger.warn(`${item.id}: ${item.detail}${item.fix ? ` | fix: ${item.fix}` : ''}`);
+            }
+        }
+        context.logger.result('Full startup pipeline completed successfully.');
+    });
+}

package/dist/commands/update-canons.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUpdateCanonsCommand = registerUpdateCanonsCommand;
+const node_child_process_1 = require("node:child_process");
+const command_context_1 = require("../lib/command-context");
+const canon_resolver_1 = require("../lib/canon-resolver");
+const errors_1 = require("../lib/errors");
+const github_auth_1 = require("../lib/github-auth");
+/** Git log format used to display the latest commit info after sync. */
+const COMMIT_FORMAT = '%h (%ci)';
+function registerUpdateCanonsCommand(program) {
+    program
+        .command('update-canons')
+        .description('Download or update collab-architecture and business canons from GitHub')
+        .action((_options, command) => {
+        const context = (0, command_context_1.createCommandContext)(command);
+        // ── Framework canon ──────────────────────────────────────
+        const ok = (0, canon_resolver_1.syncCanons)((msg) => context.logger.info(msg));
+        if (!ok) {
+            throw new errors_1.CliError('Failed to sync framework canon.');
+        }
+        const canonsDir = (0, canon_resolver_1.getCanonsBaseDir)();
+        try {
+            const commitInfo = (0, node_child_process_1.execFileSync)('git', ['-C', canonsDir, 'log', '-1', `--format=${COMMIT_FORMAT}`], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+            context.logger.info(`Framework canon up to date: ${commitInfo}`);
+        }
+        catch {
+            context.logger.info('Framework canon updated successfully.');
+        }
+        // ── Business canon ───────────────────────────────────────
+        if ((0, canon_resolver_1.isBusinessCanonConfigured)(context.config)) {
+            const auth = (0, github_auth_1.loadGitHubAuth)(context.config.collabDir);
+            const token = auth?.token;
+            const bizOk = (0, canon_resolver_1.syncBusinessCanon)(context.config, (msg) => context.logger.info(msg), token);
+            if (!bizOk) {
+                throw new errors_1.CliError('Failed to sync business canon.');
+            }
+            const bizDir = (0, canon_resolver_1.getBusinessCanonDir)(context.config);
+            try {
+                const bizCommitInfo = (0, node_child_process_1.execFileSync)('git', ['-C', bizDir, 'log', '-1', `--format=${COMMIT_FORMAT}`], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+                context.logger.info(`Business canon up to date: ${bizCommitInfo}`);
+            }
+            catch {
+                context.logger.info('Business canon updated successfully.');
+            }
+        }
+    });
+}

package/dist/commands/upgrade.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUpgradeCommand = registerUpgradeCommand;
+const semver_1 = __importDefault(require("semver"));
+const ansi_1 = require("../lib/ansi");
+const errors_1 = require("../lib/errors");
+const npm_operations_1 = require("../lib/npm-operations");
+const update_checker_1 = require("../lib/update-checker");
+const version_1 = require("../lib/version");
+function registerUpgradeCommand(program) {
+    program
+        .command('upgrade')
+        .description('Check for and install the latest version of collab-cli')
+        .option('--check', 'Only check for updates without installing')
+        .addHelpText('after', `
+Examples:
+  collab upgrade            # Upgrade to the latest version
+  collab upgrade --check    # Check for updates without installing
+`)
+        .action(async (options) => {
+        const currentVersion = (0, version_1.readCliVersion)();
+        process.stdout.write(`Current version: ${currentVersion}\n`);
+        process.stdout.write('Checking for updates...\n');
+        const latestVersion = await (0, update_checker_1.fetchLatestVersion)();
+        if (!latestVersion) {
+            throw new errors_1.CliError('Unable to reach npm registry. Check your internet connection.');
+        }
+        const updateAvailable = semver_1.default.gt(latestVersion, currentVersion);
+        if (!updateAvailable) {
+            process.stdout.write((0, ansi_1.green)(`${ansi_1.CHECK} collab-cli is up to date (v${currentVersion})\n`));
+            await (0, update_checker_1.checkForUpdate)();
+            return;
+        }
+        process.stdout.write((0, ansi_1.yellow)(`Update available: ${currentVersion} → ${latestVersion}\n`));
+        if (options.check) {
+            process.stdout.write(`Run ${(0, ansi_1.green)('collab upgrade')} to install the update.\n`);
+            return;
+        }
+        // ── Perform the upgrade ────────────────────────────────────
+        const npmPath = (0, npm_operations_1.requireNpm)();
+        if (!npmPath) {
+            throw new errors_1.CliError('npm not found in PATH. Install Node.js/npm first.');
+        }
+        process.stdout.write(`Upgrading collab-cli: ${currentVersion} → ${latestVersion}...\n`);
+        if (!(0, npm_operations_1.npmGlobalInstall)(npmPath, latestVersion)) {
+            throw new errors_1.CliError('Upgrade failed.');
+        }
+        process.stdout.write((0, ansi_1.green)(`${ansi_1.CHECK} Successfully upgraded to v${latestVersion}\n`));
+        await (0, update_checker_1.checkForUpdate)();
+    });
+}

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+const errors_1 = require("./lib/errors");
+void (0, cli_1.run)().catch((error) => {
+    if (error instanceof errors_1.CliError) {
+        console.error(error.message);
+        process.exitCode = error.exitCode;
+        return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
+});