@uxmaltech/collab-cli 0.1.0

package/dist/lib/compose-renderer.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateComposeFiles = generateComposeFiles;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const compose_env_1 = require("./compose-env");
+const compose_paths_1 = require("./compose-paths");
+const hash_1 = require("./hash");
+const state_1 = require("./state");
+const compose_defaults_1 = require("./compose-defaults");
+const consolidated_1 = require("../templates/consolidated");
+const infra_1 = require("../templates/infra");
+const mcp_1 = require("../templates/mcp");
+const GENERATED_HEADER = '# Generated by collab-cli. Do not edit manually unless you accept drift warnings.\n\n';
+function resolveEnvFilePath(config, envFile) {
+    return envFile ? node_path_1.default.resolve(config.workspaceDir, envFile) : config.envFile;
+}
+function renderContent(mode) {
+    if (mode === 'consolidated') {
+        return [
+            {
+                filePath: '',
+                content: `${GENERATED_HEADER}${consolidated_1.consolidatedTemplate}`,
+            },
+        ];
+    }
+    return [
+        {
+            filePath: '',
+            content: `${GENERATED_HEADER}${infra_1.infraTemplate}`,
+        },
+        {
+            filePath: '',
+            content: `${GENERATED_HEADER}${mcp_1.mcpTemplate}`,
+        },
+    ];
+}
+function assignOutputPaths(files, config, mode, outputDirectory, outputFile) {
+    const composePaths = (0, compose_paths_1.getComposeFilePaths)(config, outputDirectory);
+    if (mode === 'consolidated') {
+        const filePath = outputFile
+            ? node_path_1.default.resolve(config.workspaceDir, outputFile)
+            : composePaths.consolidated;
+        return [
+            {
+                filePath,
+                content: files[0].content,
+            },
+        ];
+    }
+    return [
+        {
+            filePath: composePaths.infra,
+            content: files[0].content,
+        },
+        {
+            filePath: composePaths.mcp,
+            content: files[1].content,
+        },
+    ];
+}
+function scopeFromRepo(repo, fallback) {
+    const normalized = repo.trim().replace(/\/+$/, '').replace(/\.git$/, '');
+    const scope = normalized.split('/').filter(Boolean).pop();
+    return scope && scope.length > 0 ? scope : fallback;
+}
+function computeEnvOverrides(config) {
+    const baseScope = 'uxmaltech';
+    const businessRepo = config.canons?.business?.repo;
+    if (!businessRepo) {
+        return { MCP_TECHNICAL_SCOPES: baseScope };
+    }
+    const businessScope = scopeFromRepo(businessRepo, baseScope);
+    return {
+        MCP_TECHNICAL_SCOPES: businessScope === baseScope ? baseScope : `${baseScope},${businessScope}`,
+    };
+}
+function generateComposeFiles(options) {
+    const envFilePath = resolveEnvFilePath(options.config, options.envFile);
+    const overrides = computeEnvOverrides(options.config);
+    const defaults = options.config.workspace?.name
+        ? (0, compose_defaults_1.scopedComposeDefaults)(options.config.workspace.name)
+        : compose_defaults_1.COMPOSE_ENV_DEFAULTS;
+    const env = (0, compose_env_1.ensureComposeEnvFile)(envFilePath, options.logger, options.executor, overrides, defaults);
+    const rendered = renderContent(options.mode);
+    const files = assignOutputPaths(rendered, options.config, options.mode, options.outputDirectory, options.outputFile);
+    const state = (0, state_1.loadState)(options.config);
+    const driftWarnings = [];
+    for (const file of files) {
+        options.executor.ensureDirectory(node_path_1.default.dirname(file.filePath));
+        const stateKey = (0, state_1.toStateKey)(options.config, file.filePath);
+        const previous = state.generatedFiles[stateKey];
+        if (previous && node_fs_1.default.existsSync(file.filePath)) {
+            const existingContent = node_fs_1.default.readFileSync(file.filePath, 'utf8');
+            const existingHash = (0, hash_1.sha256)(existingContent);
+            if (existingHash !== previous.hash) {
+                driftWarnings.push(`Manual edits detected in ${file.filePath}; file will be regenerated from templates.`);
+            }
+        }
+        options.executor.writeFile(file.filePath, file.content, { description: 'write compose file' });
+        state.generatedFiles[stateKey] = {
+            hash: (0, hash_1.sha256)(file.content),
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    (0, state_1.saveState)(options.config, state, options.executor);
+    // Pre-create external Docker resources (network + volumes) so that
+    // `docker compose up` succeeds even when run from a different project
+    // directory.  These are no-ops when the resources already exist.
+    ensureExternalDockerResources(env, options.executor);
+    return {
+        files,
+        envFilePath,
+        env,
+        driftWarnings,
+    };
+}
+function ensureExternalDockerResources(env, executor) {
+    const network = env.COLLAB_NETWORK || compose_defaults_1.COMPOSE_ENV_DEFAULTS.COLLAB_NETWORK;
+    const volumes = [
+        env.QDRANT_VOLUME || compose_defaults_1.COMPOSE_ENV_DEFAULTS.QDRANT_VOLUME,
+        env.NEBULA_METAD_VOLUME || compose_defaults_1.COMPOSE_ENV_DEFAULTS.NEBULA_METAD_VOLUME,
+        env.NEBULA_STORAGED_VOLUME || compose_defaults_1.COMPOSE_ENV_DEFAULTS.NEBULA_STORAGED_VOLUME,
+        env.MCP_VOLUME || compose_defaults_1.COMPOSE_ENV_DEFAULTS.MCP_VOLUME,
+    ];
+    // check: false — these are idempotent; "already exists" is not an error
+    executor.run('docker', ['network', 'create', network], { verboseOnly: true, check: false });
+    for (const vol of volumes) {
+        executor.run('docker', ['volume', 'create', vol], { verboseOnly: true, check: false });
+    }
+}

package/dist/lib/compose-validator.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateComposeFiles = validateComposeFiles;
+exports.assertComposeFilesValid = assertComposeFilesValid;
+const errors_1 = require("./errors");
+const docker_compose_1 = require("./docker-compose");
+const preconditions_1 = require("./preconditions");
+function compactError(raw) {
+    const lines = raw
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter((line) => line.length > 0);
+    return lines.slice(0, 12).join('\n');
+}
+function validateComposeFiles(filePaths, cwd, executor) {
+    if (executor.dryRun) {
+        for (const filePath of filePaths) {
+            executor.run('docker', ['compose', '-f', filePath, 'config'], {
+                cwd,
+                check: false,
+            });
+        }
+        return [];
+    }
+    for (const filePath of filePaths) {
+        (0, preconditions_1.ensureFileExists)(filePath, 'Compose file');
+    }
+    (0, preconditions_1.ensureCommandAvailable)('docker', { dryRun: executor.dryRun });
+    const errors = [];
+    for (const filePath of filePaths) {
+        const result = (0, docker_compose_1.runDockerCompose)({
+            executor,
+            files: [filePath],
+            arguments: ['config'],
+            cwd,
+            check: false,
+        });
+        if (result.status !== 0) {
+            errors.push({
+                filePath,
+                message: compactError(result.stderr || result.stdout),
+            });
+        }
+    }
+    return errors;
+}
+function assertComposeFilesValid(filePaths, cwd, executor) {
+    const errors = validateComposeFiles(filePaths, cwd, executor);
+    if (errors.length === 0) {
+        return;
+    }
+    const formatted = errors
+        .map((item) => `- ${item.filePath}\n${item.message || '(no error details available)'}`)
+        .join('\n\n');
+    throw new errors_1.CliError(`Compose validation failed:\n${formatted}`);
+}

package/dist/lib/config.js

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultCollabConfig = defaultCollabConfig;
+exports.loadCollabConfig = loadCollabConfig;
+exports.ensureCollabDirectory = ensureCollabDirectory;
+exports.serializeUserConfig = serializeUserConfig;
+exports.isWorkspaceMode = isWorkspaceMode;
+exports.resolveRepoConfigs = resolveRepoConfigs;
+exports.discoverRepos = discoverRepos;
+exports.isWorkspaceRoot = isWorkspaceRoot;
+exports.deriveWorkspaceName = deriveWorkspaceName;
+exports.detectWorkspaceLayout = detectWorkspaceLayout;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const mode_1 = require("./mode");
+const DEFAULT_COMPOSE_PATHS = {
+    consolidatedFile: 'docker-compose.yml',
+    infraFile: 'docker-compose.infra.yml',
+    mcpFile: 'docker-compose.mcp.yml',
+};
+function defaultCollabConfig(cwd = process.cwd()) {
+    const workspaceDir = node_path_1.default.resolve(cwd);
+    const collabDir = node_path_1.default.join(workspaceDir, '.collab');
+    const architectureDir = node_path_1.default.join(workspaceDir, 'docs', 'architecture');
+    return {
+        workspaceDir,
+        collabDir,
+        configFile: node_path_1.default.join(collabDir, 'config.json'),
+        stateFile: node_path_1.default.join(collabDir, 'state.json'),
+        envFile: node_path_1.default.join(workspaceDir, '.env'),
+        mode: mode_1.DEFAULT_MODE,
+        compose: { ...DEFAULT_COMPOSE_PATHS },
+        architectureDir,
+        uxmaltechDir: node_path_1.default.join(architectureDir, 'uxmaltech'),
+        repoDir: node_path_1.default.join(architectureDir, 'repo'),
+        aiDir: node_path_1.default.join(workspaceDir, 'docs', 'ai'),
+    };
+}
+function readRawConfig(configFile) {
+    if (!node_fs_1.default.existsSync(configFile)) {
+        return {};
+    }
+    const raw = node_fs_1.default.readFileSync(configFile, 'utf8');
+    const parsed = JSON.parse(raw);
+    return parsed;
+}
+function loadCollabConfig(cwd = process.cwd()) {
+    const defaults = defaultCollabConfig(cwd);
+    const raw = readRawConfig(defaults.configFile);
+    const architectureDir = raw.architectureDir
+        ? node_path_1.default.resolve(defaults.workspaceDir, raw.architectureDir)
+        : defaults.architectureDir;
+    const workspace = migrateWorkspaceConfig(raw.workspace, defaults.workspaceDir);
+    return {
+        ...defaults,
+        mode: (0, mode_1.parseMode)(raw.mode, defaults.mode),
+        envFile: raw.envFile ? node_path_1.default.resolve(defaults.workspaceDir, raw.envFile) : defaults.envFile,
+        compose: {
+            consolidatedFile: raw.compose?.consolidatedFile ?? defaults.compose.consolidatedFile,
+            infraFile: raw.compose?.infraFile ?? defaults.compose.infraFile,
+            mcpFile: raw.compose?.mcpFile ?? defaults.compose.mcpFile,
+            projectName: raw.compose?.projectName ?? (workspace ? `collab-${workspace.name}` : undefined),
+        },
+        architectureDir,
+        uxmaltechDir: node_path_1.default.join(architectureDir, 'uxmaltech'),
+        repoDir: node_path_1.default.join(architectureDir, 'repo'),
+        aiDir: node_path_1.default.join(defaults.workspaceDir, 'docs', 'ai'),
+        assistants: raw.assistants,
+        workspace,
+        canons: raw.canons,
+    };
+}
+function ensureCollabDirectory(config) {
+    node_fs_1.default.mkdirSync(config.collabDir, { recursive: true });
+}
+function serializeUserConfig(config) {
+    const data = {
+        mode: config.mode,
+        compose: config.compose,
+        envFile: node_path_1.default.relative(config.workspaceDir, config.envFile),
+    };
+    if (config.assistants) {
+        data.assistants = config.assistants;
+    }
+    if (config.workspace) {
+        data.workspace = config.workspace;
+    }
+    if (config.canons) {
+        data.canons = config.canons;
+    }
+    return JSON.stringify(data, null, 2);
+}
+// ────────────────────────────────────────────────────────────────
+// Workspace helpers
+// ────────────────────────────────────────────────────────────────
+function isWorkspaceMode(config) {
+    return config.workspace !== undefined && config.workspace.repos.length > 0;
+}
+function resolveRepoConfigs(config) {
+    if (!config.workspace) {
+        return [];
+    }
+    return config.workspace.repos.map((repoName) => {
+        const repoDir = node_path_1.default.join(config.workspaceDir, repoName);
+        return {
+            name: repoName,
+            repoDir,
+            architectureRepoDir: node_path_1.default.join(repoDir, 'docs', 'architecture', 'repo'),
+            aiDir: node_path_1.default.join(repoDir, 'docs', 'ai'),
+        };
+    });
+}
+/**
+ * Detects subdirectories of `workspaceDir` that contain a `.git` directory.
+ * Returns sorted directory names (not full paths).
+ */
+function discoverRepos(workspaceDir) {
+    const entries = node_fs_1.default.readdirSync(workspaceDir, { withFileTypes: true });
+    const repos = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith('.'))
+            continue;
+        const gitDir = node_path_1.default.join(workspaceDir, entry.name, '.git');
+        if (node_fs_1.default.existsSync(gitDir)) {
+            repos.push(entry.name);
+        }
+    }
+    return repos.sort();
+}
+/**
+ * Returns true when the directory looks like a workspace root:
+ * no `.git/` of its own and at least one child git repo.
+ */
+function isWorkspaceRoot(dir) {
+    const hasOwnGit = node_fs_1.default.existsSync(node_path_1.default.join(dir, '.git'));
+    if (hasOwnGit)
+        return false;
+    return discoverRepos(dir).length >= 1;
+}
+/**
+ * Derives a slugified workspace name from a directory path.
+ */
+function deriveWorkspaceName(dir) {
+    return node_path_1.default.basename(node_path_1.default.resolve(dir))
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '') || 'workspace';
+}
+/**
+ * Detects the workspace layout of a directory.
+ *
+ * - If the directory is itself a git repo → mono-repo with repos=["."]
+ * - If it has ≥2 child git repos → multi-repo
+ * - If it has exactly 1 child git repo → mono-repo
+ * - If it has 0 child git repos → null (caller decides)
+ */
+function detectWorkspaceLayout(dir) {
+    // Case 1: current directory IS a git repo
+    if (node_fs_1.default.existsSync(node_path_1.default.join(dir, '.git'))) {
+        return { type: 'mono-repo', repos: ['.'] };
+    }
+    // Case 2: scan for child repos
+    const childRepos = discoverRepos(dir);
+    if (childRepos.length >= 2) {
+        return { type: 'multi-repo', repos: childRepos };
+    }
+    if (childRepos.length === 1) {
+        return { type: 'mono-repo', repos: childRepos };
+    }
+    // No repos found — caller must decide
+    return null;
+}
+/**
+ * Migrates an older workspace config (repos-only) to the full format
+ * with name and type fields. Returns undefined if no workspace data.
+ */
+function migrateWorkspaceConfig(raw, workspaceDir) {
+    if (!raw || !Array.isArray(raw.repos)) {
+        return undefined;
+    }
+    const repos = raw.repos.filter((r) => typeof r === 'string' && r.length > 0);
+    if (repos.length === 0) {
+        return undefined;
+    }
+    return {
+        name: raw.name || deriveWorkspaceName(workspaceDir),
+        type: raw.type || (repos.length >= 2 ? 'multi-repo' : 'mono-repo'),
+        repos,
+    };
+}

package/dist/lib/credentials.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCredentialsPath = getCredentialsPath;
+exports.saveApiKey = saveApiKey;
+exports.loadApiKey = loadApiKey;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function getCredentialsPath(config) {
+    return node_path_1.default.join(config.collabDir, 'credentials.json');
+}
+/**
+ * Saves an API key for a provider to the credentials file.
+ */
+function saveApiKey(config, provider, apiKey) {
+    const credPath = getCredentialsPath(config);
+    const credDir = node_path_1.default.dirname(credPath);
+    // Ensure .collab directory exists
+    node_fs_1.default.mkdirSync(credDir, { recursive: true });
+    // Load existing credentials
+    const existing = loadAllCredentials(config);
+    existing[provider] = apiKey;
+    // Write with restricted permissions
+    node_fs_1.default.writeFileSync(credPath, JSON.stringify(existing, null, 2), {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+    // Ensure permissions on directory and file
+    try {
+        node_fs_1.default.chmodSync(credDir, 0o700);
+        node_fs_1.default.chmodSync(credPath, 0o600);
+    }
+    catch {
+        // Non-critical: permissions may not be applicable on all platforms
+    }
+}
+/**
+ * Loads the API key for a single provider from the credentials file.
+ * Returns null if not found.
+ */
+function loadApiKey(config, provider) {
+    const all = loadAllCredentials(config);
+    return all[provider] ?? null;
+}
+/**
+ * Loads all stored credentials. Returns an empty object if the file
+ * does not exist or cannot be parsed.
+ */
+function loadAllCredentials(config) {
+    const credPath = getCredentialsPath(config);
+    if (!node_fs_1.default.existsSync(credPath)) {
+        return {};
+    }
+    try {
+        const raw = node_fs_1.default.readFileSync(credPath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}

package/dist/lib/docker-checks.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDockerDaemon = checkDockerDaemon;
+exports.checkDockerImages = checkDockerImages;
+const shell_1 = require("./shell");
+/**
+ * Checks whether the Docker daemon is running and returns its server version.
+ */
+function checkDockerDaemon(executor) {
+    const dockerPath = (0, shell_1.resolveCommandPath)('docker');
+    if (!dockerPath) {
+        return { ok: false, error: 'docker command not found in PATH' };
+    }
+    if (executor.dryRun) {
+        return { ok: true, version: 'dry-run' };
+    }
+    const result = executor.run('docker', ['info', '--format', '{{.ServerVersion}}'], {
+        check: false,
+        verboseOnly: true,
+    });
+    if (result.status === 0 && result.stdout.trim()) {
+        return { ok: true, version: result.stdout.trim() };
+    }
+    const stderr = result.stderr.trim();
+    if (/cannot connect to.*docker daemon|is the docker daemon running/i.test(stderr)) {
+        return { ok: false, error: 'Docker daemon is not running. Start Docker Desktop or run: sudo systemctl start docker' };
+    }
+    return { ok: false, error: stderr || 'Docker daemon check failed' };
+}
+/**
+ * Checks whether Docker images are locally available.
+ *
+ * Uses `docker image inspect` to check local presence only — avoids
+ * network calls that may fail behind firewalls or require authentication.
+ */
+function checkDockerImages(executor, images) {
+    const dockerPath = (0, shell_1.resolveCommandPath)('docker');
+    if (!dockerPath) {
+        return images.map((image) => ({
+            image,
+            ok: false,
+            error: 'docker command not found',
+        }));
+    }
+    return images.map((image) => {
+        if (executor.dryRun) {
+            return { image, ok: true };
+        }
+        const result = executor.run('docker', ['image', 'inspect', image, '--format', '{{.Id}}'], {
+            check: false,
+            verboseOnly: true,
+        });
+        if (result.status === 0 && result.stdout.trim()) {
+            return { image, ok: true };
+        }
+        const stderr = result.stderr.trim();
+        // Distinguish daemon/auth errors from genuine "image not found"
+        if (/cannot connect to.*docker daemon|is the docker daemon running/i.test(stderr)) {
+            return {
+                image,
+                ok: false,
+                error: 'Docker daemon is not running. Start Docker Desktop or run: sudo systemctl start docker',
+            };
+        }
+        return {
+            image,
+            ok: false,
+            error: /no such image|not found/i.test(stderr)
+                ? `Image not found locally. Pull with: docker pull ${image}`
+                : (stderr || `docker image inspect failed for ${image}`),
+        };
+    });
+}

package/dist/lib/docker-compose.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDockerCompose = runDockerCompose;
+const process_1 = require("./process");
+function composeArgs(files, args, projectName) {
+    const projectArgs = projectName ? ['-p', projectName] : [];
+    const fileArgs = files.flatMap((filePath) => ['-f', filePath]);
+    return ['compose', ...projectArgs, ...fileArgs, ...args];
+}
+function runDockerCompose(command) {
+    return (0, process_1.runProcess)(command.executor, 'docker', composeArgs(command.files, command.arguments, command.projectName), {
+        cwd: command.cwd,
+        check: command.check,
+    });
+}

package/dist/lib/docker-status.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * Docker Compose container status parsing and display.
+ * Parses `docker compose ps --format json` output, merges with health
+ * check results, and renders a formatted status table.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVICE_LABELS = void 0;
+exports.parseComposePs = parseComposePs;
+exports.buildServiceStatusList = buildServiceStatusList;
+exports.printStatusTable = printStatusTable;
+const ansi_1 = require("./ansi");
+/** Human-readable labels for known Docker Compose services. */
+exports.SERVICE_LABELS = {
+    qdrant: 'Qdrant (Vector DB)',
+    metad0: 'NebulaGraph metad',
+    storaged0: 'NebulaGraph storaged',
+    graphd: 'NebulaGraph graphd',
+    mcp: 'MCP Server',
+};
+/** Safely extracts a string value from a parsed JSON field. */
+function str(value) {
+    return typeof value === 'string' ? value : '';
+}
+/**
+ * Parses the stdout of `docker compose ps --format json`.
+ * Docker Compose V2 outputs one JSON object per line.
+ * Skips malformed lines gracefully.
+ */
+function parseComposePs(stdout) {
+    if (!stdout.trim()) {
+        return [];
+    }
+    const lines = stdout.trim().split('\n');
+    const containers = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        try {
+            const raw = JSON.parse(trimmed);
+            containers.push({
+                name: str(raw['Name']) || str(raw['name']),
+                service: str(raw['Service']) || str(raw['service']),
+                state: str(raw['State']) || str(raw['state']),
+                status: str(raw['Status']) || str(raw['status']),
+                ports: str(raw['Ports']) || str(raw['ports']),
+                health: str(raw['Health']) || str(raw['health']),
+            });
+        }
+        catch {
+            // Skip malformed JSON lines
+        }
+    }
+    return containers;
+}
+/**
+ * Simplifies Docker port mappings for display.
+ * Converts "0.0.0.0:6333->6333/tcp" to "6333/tcp".
+ */
+function formatPorts(raw) {
+    if (!raw) {
+        return '';
+    }
+    return raw
+        .split(', ')
+        .map((mapping) => {
+        const arrow = mapping.indexOf('->');
+        return arrow !== -1 ? mapping.slice(arrow + 2) : mapping;
+    })
+        .join(', ');
+}
+/**
+ * Merges container info with health check results into a unified status list.
+ * Services without running containers are shown as "Not running".
+ * Health check results are matched by name to the service name.
+ */
+function buildServiceStatusList(services, containers, healthResults) {
+    const containerMap = new Map();
+    for (const c of containers) {
+        containerMap.set(c.service, c);
+    }
+    const healthMap = new Map();
+    for (const h of healthResults) {
+        healthMap.set(h.name, h);
+    }
+    return services.map((service) => {
+        const container = containerMap.get(service);
+        const health = healthMap.get(service);
+        const label = exports.SERVICE_LABELS[service] ?? service;
+        if (!container) {
+            return {
+                service,
+                label,
+                running: false,
+                status: 'Not running',
+                ports: '',
+                healthOk: health ? health.ok : null,
+                healthDetail: health?.detail ?? '',
+            };
+        }
+        const running = container.state === 'running';
+        return {
+            service,
+            label,
+            container: container.name,
+            running,
+            status: container.status || container.state,
+            ports: formatPorts(container.ports),
+            healthOk: health ? health.ok : null,
+            healthDetail: health?.detail ?? '',
+        };
+    });
+}
+/**
+ * Renders a formatted status table to the terminal.
+ * Each service shows its status, ports, and health check result.
+ * A summary line at the bottom shows the overall running count.
+ */
+function printStatusTable(logger, title, services, composePath) {
+    const line = (0, ansi_1.dim)('\u2500'.repeat(48));
+    logger.result('');
+    logger.result(`  ${line}`);
+    logger.result(`  ${(0, ansi_1.bold)(title)}`);
+    logger.result(`  ${line}`);
+    for (const svc of services) {
+        logger.result('');
+        logger.result(`  ${(0, ansi_1.bold)(svc.label)}`);
+        const statusMarker = svc.running ? (0, ansi_1.green)(ansi_1.CHECK) : (0, ansi_1.red)(ansi_1.CROSS);
+        logger.result(`    Status:  ${statusMarker} ${svc.status}`);
+        if (svc.ports) {
+            logger.result(`    Ports:   ${svc.ports}`);
+        }
+        if (svc.healthOk !== null) {
+            const healthMarker = svc.healthOk ? (0, ansi_1.green)(ansi_1.CHECK) : (0, ansi_1.red)(ansi_1.CROSS);
+            logger.result(`    Health:  ${healthMarker} ${svc.healthDetail}`);
+        }
+    }
+    // Summary
+    logger.result('');
+    logger.result(`  ${line}`);
+    const running = services.filter((s) => s.running).length;
+    const total = services.length;
+    const allUp = running === total;
+    const summaryMarker = allUp ? (0, ansi_1.green)(ansi_1.CHECK) : (0, ansi_1.red)(ansi_1.CROSS);
+    const summaryText = `${running}/${total} services running`;
+    const composeNote = composePath ? ` | Compose: ${composePath}` : '';
+    logger.result(`  ${summaryMarker} ${summaryText}${(0, ansi_1.dim)(composeNote)}`);
+    logger.result('');
+}