feat-forge 1.0.1

package/dist/commands/EnvCommands.js

@@ -0,0 +1,56 @@
+import { AbstractCommands } from './AbstractCommands.js';
+import { BranchContext } from '../foundation/BranchContext.js';
+import { generateEnvrcFile, loadGeneratedServicesFile } from '../lib/services.js';
+import { readTextFile, pathExists } from '../lib/fs.js';
+import path from 'path';
+export class EnvCommands extends AbstractCommands {
+    constructor(context) {
+        super(context);
+    }
+    /**
+     * Generate .envrc from existing generated.services.json
+     */
+    async update(branchName) {
+        // Load branch context
+        const branchContext = branchName
+            ? await this.context.loadBranchContext(branchName)
+            : await BranchContext.findNearestBranchContext(this.context);
+        const generatedServicesPath = path.join(branchContext.path, 'generated.services.json');
+        if (!(await pathExists(generatedServicesPath))) {
+            console.log('❌ No generated.services.json found. Run "forge services scan" first.');
+            return;
+        }
+        const generatedServicesFile = await loadGeneratedServicesFile(branchContext);
+        // Read generated services
+        await this.generateEnvrcFile(branchContext, generatedServicesFile.services);
+    }
+    /**
+     * Display current .envrc and port allocation info
+     */
+    async show(branchName) {
+        // Load branch context
+        const branchContext = branchName
+            ? await this.context.loadBranchContext(branchName)
+            : await BranchContext.findNearestBranchContext(this.context);
+        const envrcPath = path.join(branchContext.path, '.envrc');
+        console.log(`📋 Environment configuration for branch "${branchContext.branchName}"`);
+        console.log('');
+        // Check if .envrc exists
+        if (!(await pathExists(envrcPath))) {
+            console.log('❌ No .envrc found. Run "forge env update" first.');
+            return;
+        }
+        // Read and display .envrc
+        const envrcContent = await readTextFile(envrcPath);
+        console.log('=== .envrc content ===');
+        console.log(envrcContent);
+        console.log('');
+    }
+    async generateEnvrcFile(branchContext, services) {
+        console.log(`🔄 Generating .envrc for branch "${branchContext.branchName}"...`);
+        const env = await generateEnvrcFile(this.context, branchContext, services);
+        console.log(`   ✅ .envrc: ${env.path}`);
+        console.log('');
+        return env;
+    }
+}

package/dist/commands/FeatureCommands.js

@@ -0,0 +1,4 @@
+import { SubBranchCommands } from './SubBranchCommands.js';
+export class FeatureCommands extends SubBranchCommands {
+    prefix = this.context.options.git.featureBranchPrefix;
+}

package/dist/commands/FixCommands.js

@@ -0,0 +1,4 @@
+import { SubBranchCommands } from './SubBranchCommands.js';
+export class FixCommands extends SubBranchCommands {
+    prefix = this.context.options.git.fixBranchPrefix;
+}

package/dist/commands/InitCommands.js

@@ -0,0 +1,380 @@
+import { ForgeConfigError } from '../foundation/errors/index.js';
+import { AIAgentName } from '../foundation/types/AIAgentName.js';
+import { IDEName } from '../foundation/types/IDEName.js';
+import { FEAT_FORGE_CONFIG_FILE } from '../lib/constants.js';
+import { pathExists, writeConfigSafely } from '../lib/fs.js';
+import { promptCheckbox, promptChoice, promptConfirm, promptText } from '../lib/prompt.js';
+import { findAncestorForgeConfig, scanGitRepos } from '../lib/scanner.js';
+import { stat } from 'fs/promises';
+import path from 'path';
+// Constants for UI strings
+const DEFAULT_LABEL = ' (default)';
+const FEATURES_FOLDER = '.features';
+const VSCODE_FOLDER = '.vscode';
+const IDEA_FOLDER = '.idea';
+export class InitCommands {
+    // ============================================================================
+    // PUBLIC COMMAND METHODS
+    // ============================================================================
+    /**
+     * Create a .feat-forge.json in the current working directory.
+     * Supports both interactive and non-interactive modes via options.
+     *
+     * @param options - Configuration options for init behavior
+     */
+    async init(options = {}) {
+        const workingDir = options.path ? path.resolve(options.path) : process.cwd();
+        const targetPath = path.join(workingDir, FEAT_FORGE_CONFIG_FILE);
+        const isInteractive = !options.nonInteractive && !options.yes;
+        const isQuiet = options.quiet || false;
+        // Validate environment and check for conflicts
+        await this.validateInitEnvironment(targetPath, workingDir, options.force || false, isInteractive);
+        // Gather repository paths
+        const repoPaths = await this.gatherRepositoryPaths(workingDir, options.repositories, isInteractive, options.nonInteractive || false, options.yes || false);
+        // Validate repository paths exist
+        await this.validateRepositoryPaths(repoPaths, workingDir);
+        // Build configuration
+        const configFile = await this.buildConfiguration(repoPaths, workingDir, options.rootDir, options.agents, options.ides, isInteractive, options.yes || false);
+        // Confirm and write configuration
+        await this.confirmAndWriteConfig(configFile, targetPath, isInteractive, isQuiet);
+        if (!isQuiet) {
+            console.log(`✓ Initialized ${FEAT_FORGE_CONFIG_FILE} at ${targetPath}`);
+        }
+    }
+    // ============================================================================
+    // PRIVATE HELPER METHODS
+    // ============================================================================
+    /**
+     * Validate that the environment is suitable for initialization.
+     * Checks for ancestor configs and handles existing config files.
+     */
+    async validateInitEnvironment(targetPath, workingDir, force, isInteractive) {
+        // Check for ancestor configuration
+        const ancestor = await findAncestorForgeConfig(workingDir);
+        if (ancestor) {
+            throw new ForgeConfigError(`An ancestor configuration already exists at ${ancestor}. Aborting init.`);
+        }
+        // Handle existing config file
+        if (await pathExists(targetPath)) {
+            if (force) {
+                // Force mode: will create backup via writeConfigSafely
+                return;
+            }
+            if (!isInteractive) {
+                throw new ForgeConfigError(`Configuration already exists at ${targetPath}. Use --force to overwrite.`);
+            }
+            const overwrite = await promptConfirm(`Configuration already exists at ${targetPath}. Overwrite?`);
+            if (!overwrite) {
+                console.log('Initialization cancelled.');
+                process.exit(0);
+            }
+        }
+    }
+    /**
+     * Gather repository paths through scanning and user interaction.
+     */
+    async gatherRepositoryPaths(workingDir, repositoriesFlag, isInteractive = true, nonInteractive = false, useDefaults = false) {
+        // If repositories provided via flag, use those
+        if (repositoriesFlag) {
+            return this.parseStringOrJSON(repositoriesFlag);
+        }
+        // In non-interactive mode without repositories flag, must fail
+        if (nonInteractive) {
+            throw new ForgeConfigError('Missing required --repositories flag in non-interactive mode. ' + 'Provide as comma-separated list or JSON array.');
+        }
+        const repos = await scanGitRepos(workingDir);
+        // Handle no repositories found
+        if (repos.length === 0) {
+            return await this.handleNoRepositoriesFound(isInteractive);
+        }
+        const repoPaths = repos.map((r) => this.makeRelativePath(r.path, workingDir));
+        // In --yes mode, use discovered repositories automatically
+        if (useDefaults) {
+            console.log('Discovered repositories:');
+            repoPaths.forEach((r) => console.log(` - ${r}`));
+            return repoPaths;
+        }
+        // Present discovered repositories to user with checkbox selection
+        console.log('Discovered repositories:');
+        repoPaths.forEach((r) => console.log(` - ${r}`));
+        const choices = repoPaths.map((r) => ({
+            name: r,
+            value: r,
+            checked: true,
+        }));
+        choices.push({
+            name: 'Add custom path...',
+            value: '__custom__',
+            checked: false,
+        });
+        const selected = await promptCheckbox('Select repositories to include in the config:', choices);
+        // Handle custom path addition
+        if (selected.includes('__custom__')) {
+            const customPath = await promptText('Enter custom repository path (relative to this folder):');
+            if (customPath && customPath.trim()) {
+                selected.splice(selected.indexOf('__custom__'), 1);
+                selected.push(customPath.trim());
+            }
+            else {
+                selected.splice(selected.indexOf('__custom__'), 1);
+            }
+        }
+        return selected.length > 0 ? selected : ['.'];
+    }
+    /**
+     * Handle the case when no git repositories are found.
+     */
+    async handleNoRepositoriesFound(isInteractive) {
+        if (!isInteractive) {
+            // Non-interactive: default to current directory
+            return ['.'];
+        }
+        const useCwd = await promptConfirm('No git repositories found. Use current directory as repository?');
+        if (useCwd) {
+            return ['.'];
+        }
+        const manual = await promptText('Enter repository path to add (relative to this folder):');
+        return [manual || '.'];
+    }
+    /**
+     * Build the complete configuration object.
+     */
+    async buildConfiguration(repoPaths, workingDir, rootDirFlag, agentsFlag, idesFlag, isInteractive = true, useDefaults = false) {
+        const repositories = await this.selectMainRepository(repoPaths, workingDir, isInteractive, useDefaults);
+        const agents = await this.configureAgents(agentsFlag, isInteractive, useDefaults);
+        const ides = await this.configureIDEs(workingDir, idesFlag, isInteractive, useDefaults);
+        return {
+            rootDir: rootDirFlag || '.',
+            repositories,
+            agents,
+            ides,
+        };
+    }
+    /**
+     * Display configuration summary and confirm before writing.
+     */
+    async confirmAndWriteConfig(configFile, targetPath, isInteractive, isQuiet) {
+        if (!isQuiet) {
+            console.log('\n=== Configuration Summary ===');
+            console.log(JSON.stringify(configFile, null, 4));
+            console.log('=============================\n');
+        }
+        if (isInteractive) {
+            const confirmed = await promptConfirm('Write this configuration to .feat-forge.json?');
+            if (!confirmed) {
+                console.log('Initialization cancelled.');
+                process.exit(0);
+            }
+        }
+        const contents = JSON.stringify(configFile, null, 4);
+        await writeConfigSafely(targetPath, `${contents}\n`);
+    }
+    /**
+     * Convert an absolute path to a relative path from working directory.
+     * Returns '.' if the path is the current directory.
+     */
+    makeRelativePath(absolutePath, workingDir) {
+        return path.relative(workingDir, absolutePath) || '.';
+    }
+    /**
+     * Parse comma-separated input string into trimmed array.
+     */
+    parseCommaSeparated(input) {
+        return input
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }
+    /**
+     * Parse string input that could be comma-separated or JSON array.
+     */
+    parseStringOrJSON(input) {
+        const trimmed = input.trim();
+        // Try to parse as JSON array first
+        if (trimmed.startsWith('[')) {
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (Array.isArray(parsed)) {
+                    return parsed.map(String).filter(Boolean);
+                }
+            }
+            catch {
+                throw new ForgeConfigError(`Invalid JSON array: ${trimmed}`);
+            }
+        }
+        // Otherwise treat as comma-separated
+        return this.parseCommaSeparated(trimmed);
+    }
+    /**
+     * Validate that repository paths exist and are directories.
+     */
+    async validateRepositoryPaths(repoPaths, workingDir) {
+        for (const repoPath of repoPaths) {
+            const fullPath = path.join(workingDir, repoPath);
+            if (!(await pathExists(fullPath))) {
+                throw new ForgeConfigError(`Repository path does not exist: ${repoPath}`);
+            }
+            try {
+                const stats = await stat(fullPath);
+                if (!stats.isDirectory()) {
+                    throw new ForgeConfigError(`Repository path is not a directory: ${repoPath}`);
+                }
+            }
+            catch (error) {
+                throw new ForgeConfigError(`Cannot access repository path: ${repoPath}`);
+            }
+        }
+    }
+    /**
+     * Select the main repository from the list of repository paths.
+     * Auto-selects if one has a .features folder, otherwise prompts the user.
+     */
+    async selectMainRepository(repoPaths, workingDir, isInteractive, useDefaults) {
+        // Handle empty or single repository cases
+        if (repoPaths.length === 0) {
+            return [];
+        }
+        if (repoPaths.length === 1) {
+            return [{ path: repoPaths[0], main: true }];
+        }
+        // Determine main repository from multiple options
+        const mainRepoPath = await this.determineMainRepository(repoPaths, workingDir, isInteractive, useDefaults);
+        // Build repository config entries with main flag
+        return repoPaths.map((rp) => ({
+            path: rp,
+            main: rp === mainRepoPath,
+        }));
+    }
+    /**
+     * Determine which repository should be marked as main.
+     * Auto-selects if exactly one has .features folder, otherwise prompts.
+     */
+    async determineMainRepository(repoPaths, workingDir, isInteractive, useDefaults) {
+        const reposWithFeatures = await this.findRepositoriesWithFeatures(repoPaths, workingDir);
+        // Auto-select if exactly one repo has .features folder
+        if (reposWithFeatures.length === 1) {
+            const mainRepo = reposWithFeatures[0];
+            console.log(`Auto-selected '${mainRepo}' as main repository (has ${FEATURES_FOLDER} folder).`);
+            return mainRepo;
+        }
+        // If using defaults or non-interactive, pick first repo
+        if (!isInteractive || useDefaults) {
+            return repoPaths[0];
+        }
+        // Multiple repos with .features - let user choose
+        if (reposWithFeatures.length > 1) {
+            console.log(`\nMultiple repositories have ${FEATURES_FOLDER} folders. Select the main repository:`);
+            return await this.promptForMainRepository(reposWithFeatures, false);
+        }
+        // No repos with .features - prompt with first as default
+        console.log('\nMultiple repositories found. Select the main repository:');
+        return await this.promptForMainRepository(repoPaths, true);
+    }
+    /**
+     * Find which repositories contain a .features folder.
+     */
+    async findRepositoriesWithFeatures(repoPaths, workingDir) {
+        const reposWithFeatures = [];
+        for (const repoPath of repoPaths) {
+            const fullPath = path.join(workingDir, repoPath);
+            const featuresPath = path.join(fullPath, FEATURES_FOLDER);
+            if (await pathExists(featuresPath)) {
+                reposWithFeatures.push(repoPath);
+            }
+        }
+        return reposWithFeatures;
+    }
+    /**
+     * Prompt user to select main repository from list.
+     * @param repos - List of repository paths to choose from
+     * @param markFirstAsDefault - Whether to mark the first option as default
+     */
+    async promptForMainRepository(repos, markFirstAsDefault) {
+        const choices = repos.map((rp, idx) => ({
+            value: String(idx + 1),
+            name: `${rp}${markFirstAsDefault && idx === 0 ? DEFAULT_LABEL : ''}`,
+        }));
+        const selection = await promptChoice('Choose main repository:', choices);
+        const selectedChoice = choices.find((c) => c.value === selection);
+        if (selectedChoice) {
+            return selectedChoice.name.replace(DEFAULT_LABEL, '');
+        }
+        // Fallback to first repository if selection failed
+        return repos[0];
+    }
+    /**
+     * Configure agents for the project.
+     * Suggests default agents and allows user to customize via checkboxes.
+     */
+    async configureAgents(agentsFlag, isInteractive = true, useDefaults = false) {
+        // If agents provided via flag, use those
+        if (agentsFlag) {
+            const agentNames = this.parseStringOrJSON(agentsFlag);
+            return agentNames.length > 0 ? agentNames : undefined;
+        }
+        // If using defaults mode, return default agents
+        if (useDefaults) {
+            return [AIAgentName.COPILOT];
+        }
+        // Non-interactive: use ForgeConfig defaults (undefined)
+        if (!isInteractive) {
+            return undefined;
+        }
+        console.log('\n--- Agent Configuration ---');
+        // Build checkbox choices for all available agents
+        const availableAgents = Object.values(AIAgentName);
+        const choices = availableAgents.map((agent) => ({
+            name: agent,
+            value: agent,
+            checked: agent === AIAgentName.COPILOT, // Pre-check COPILOT as default
+        }));
+        const selected = await promptCheckbox('Select agents to enable:', choices);
+        return selected.length > 0 ? selected : undefined;
+    }
+    /**
+     * Configure IDEs for the project.
+     * Detects .vscode or .idea folders and allows selection via checkboxes.
+     */
+    async configureIDEs(workingDir, idesFlag, isInteractive = true, useDefaults = false) {
+        // If IDEs provided via flag, use those
+        if (idesFlag) {
+            const ideNames = this.parseStringOrJSON(idesFlag);
+            return ideNames.length > 0 ? ideNames : undefined;
+        }
+        const detectedIDEs = await this.detectIDEs(workingDir);
+        // If using defaults mode, use detected IDEs or undefined
+        if (useDefaults) {
+            return detectedIDEs.length > 0 ? detectedIDEs : undefined;
+        }
+        // Non-interactive: use detected IDEs or undefined
+        if (!isInteractive) {
+            return detectedIDEs.length > 0 ? detectedIDEs : undefined;
+        }
+        console.log('\n--- IDE Configuration ---');
+        // Build checkbox choices for available IDEs
+        const availableIDEs = [IDEName.VSCODE]; // Only VSCode is currently supported
+        const choices = availableIDEs.map((ide) => ({
+            name: ide,
+            value: ide,
+            checked: detectedIDEs.includes(ide), // Pre-check detected IDEs
+        }));
+        const selected = await promptCheckbox('Select IDEs to configure:', choices);
+        return selected.length > 0 ? selected : undefined;
+    }
+    /**
+     * Detect IDE folders in the working directory.
+     */
+    async detectIDEs(workingDir) {
+        const vscodeExists = await pathExists(path.join(workingDir, VSCODE_FOLDER));
+        const ideaExists = await pathExists(path.join(workingDir, IDEA_FOLDER));
+        const detectedIDEs = [];
+        if (vscodeExists) {
+            detectedIDEs.push(IDEName.VSCODE);
+            console.log(`Detected: VSCode (${VSCODE_FOLDER} folder found)`);
+        }
+        if (ideaExists) {
+            console.log(`Note: ${IDEA_FOLDER} folder found, but IntelliJ IDEA is not yet supported in this version.`);
+        }
+        return detectedIDEs;
+    }
+}

package/dist/commands/MaintenanceCommands.js

@@ -0,0 +1,39 @@
+import { AbstractCommands } from './AbstractCommands.js';
+import { promptConfirm } from '../lib/prompt.js';
+export class MaintenanceCommands extends AbstractCommands {
+    /**
+     * (Re)Write agent template files in the .specs/.template/.forge-agents/ directory of the main repository.
+     * This is useful if you want to fix the agent's files in the project.
+     */
+    async installAgentTemplateLocally(options = {}) {
+        const deleteExisting = Boolean(options.deleteExisting);
+        const dryRun = Boolean(options.dryRun);
+        const commit = options.commit === undefined ? undefined : Boolean(options.commit);
+        const overwrite = Boolean(options.overwrite);
+        console.log(`Install agent templates locally (deleteExisting=${deleteExisting}, dryRun=${dryRun}, commit=${commit}, overwrite=${overwrite})...`);
+        const changed = await this.context.installAgentTemplateLocally(this.context.mainRepo, { deleteExisting, dryRun, overwrite });
+        if (changed.length === 0) {
+            console.log('No agent template files were modified.');
+            return;
+        }
+        console.log(`Modified ${changed.length} file(s):`);
+        for (const f of changed) {
+            console.log(`  - ${f}`);
+        }
+        if (dryRun) {
+            console.log('\nDry run: no files were written.');
+        }
+        else {
+            const doCommit = commit === undefined ? await promptConfirm('Do you want to commit the changes to the repository?') : commit;
+            if (doCommit) {
+                if (changed.length > 0 && !dryRun && doCommit) {
+                    await this.context.mainRepo.commit(`chore: add feat-forge agent templates ${overwrite ? ' (overwriting existing templates)' : ''}`, changed);
+                }
+                console.log('\nFiles were written and committed.');
+            }
+            else {
+                console.log('\nFiles were written but not committed (use --commit to commit).');
+            }
+        }
+    }
+}

package/dist/commands/ModeCommands.js

@@ -0,0 +1,15 @@
+import { BranchContext } from '../foundation/BranchContext.js';
+import { AbstractCommands } from './AbstractCommands.js';
+export class ModeCommands extends AbstractCommands {
+    // ============================================================================
+    // PUBLIC COMMAND METHODS
+    // ============================================================================
+    /**
+     * Set the current mode and refresh agent adapters for the active feature.
+     */
+    async setMode(mode) {
+        const branchContext = await BranchContext.findNearestBranchContext(this.context);
+        await branchContext.setMode(mode);
+        await branchContext.refreshAgentContextFiles(mode);
+    }
+}

package/dist/commands/ProxyCommands.js

@@ -0,0 +1,14 @@
+import { Proxy } from '../foundation/Proxy.js';
+import { AbstractCommands } from './AbstractCommands.js';
+export class ProxyCommands extends AbstractCommands {
+    async start(options) {
+        if (options.port) {
+            console.warn(`⚠️  Specifying a custom port with --port may result in problems if services communicates with each other through the proxy port/url declared in the .envrc files.
+It is recommended to set the desired port in the configuration file instead.`);
+        }
+        const proxy = new Proxy(this.context);
+        await proxy.start({
+            port: options.port ? parseInt(options.port, 10) : undefined,
+        });
+    }
+}

package/dist/commands/ReleaseCommands.js

@@ -0,0 +1,4 @@
+import { SubBranchCommands } from './SubBranchCommands.js';
+export class ReleaseCommands extends SubBranchCommands {
+    prefix = this.context.options.git.releaseBranchPrefix;
+}

package/dist/commands/ServicesCommands.js

@@ -0,0 +1,95 @@
+import { BranchContext } from '../foundation/BranchContext.js';
+import { PortAllocator } from '../foundation/PortAllocator.js';
+import { generateBranchServicesFile, getServiceOutputs, loadGeneratedServicesFile, scanReposServices, } from '../lib/services.js';
+import { AbstractCommands } from './AbstractCommands.js';
+import { EnvCommands } from './EnvCommands.js';
+import { ForgeNotInActiveBranchError } from '../foundation/errors/index.js';
+export class ServicesCommands extends AbstractCommands {
+    // ============================================================================
+    // PUBLIC COMMAND METHODS
+    // ============================================================================
+    /**
+     * Scan repositories for services and generate configuration files
+     */
+    async scan(branchName) {
+        // Load branch context (use current branch if not specified)
+        let branches = [];
+        try {
+            const branchContext = branchName
+                ? await this.context.loadBranchContext(branchName)
+                : await BranchContext.findNearestBranchContext(this.context);
+            branches = [branchContext];
+        }
+        catch (err) {
+            if (err instanceof ForgeNotInActiveBranchError) {
+                branches.push(...(await this.context.loadActiveBranchesContexts()));
+            }
+            else {
+                throw err;
+            }
+        }
+        // Load port allocator
+        const portAllocator = await PortAllocator.load(this.context);
+        for (const branchContext of branches) {
+            // Scan for services in all repositories
+            console.log('-----------------------------------------------------------------------');
+            console.log(`🔍 Scanning for services in branch "${branchContext.branchName}"...`);
+            const reposServices = await scanReposServices(branchContext);
+            if (reposServices.some((repo) => repo.services.length > 0)) {
+                console.log(`✅ Found services in ${reposServices.length} repository(ies)`);
+            }
+            else {
+                console.log('⚠️ No services found in any repositories');
+                continue;
+            }
+            console.log('🔄 Allocating ports for discovered services...');
+            // Allocate ports for all repositories
+            portAllocator.allocatePorts(branchContext.branchName, reposServices);
+            // Save port allocations
+            await portAllocator.save();
+            console.log('   ✅ Port allocation completed');
+            console.log('');
+            // Generate and write generated.services.json
+            console.log('🔄 Generating generated.services.json with port assignments...');
+            const generated = await generateBranchServicesFile(branchContext, portAllocator);
+            console.log(`   ✅ generated.services.json: ${generated.path}`);
+            console.log('');
+            // Generate and write .envrc
+            await new EnvCommands(this.context).generateEnvrcFile(branchContext, generated.services);
+            // Display summary
+            this.showServiceSummary(branchContext, generated.services);
+            console.log('');
+        }
+    }
+    /**
+     * List discovered services with their allocated ports
+     */
+    async list(format) {
+        // Load current branch context
+        const branchContext = await BranchContext.findNearestBranchContext(this.context);
+        // Load generated services file
+        const generatedServicesFile = await loadGeneratedServicesFile(branchContext);
+        if (format === 'json') {
+            // Output as JSON
+            console.log(JSON.stringify(generatedServicesFile, null, 2));
+        }
+        else {
+            // Default log format
+            this.showServiceSummary(branchContext, generatedServicesFile.services);
+        }
+    }
+    // ============================================================================
+    // PRIVATE UTILITY METHODS
+    // ============================================================================
+    showServiceSummary(branchContext, services) {
+        console.log('Services Summary:');
+        for (const service of services) {
+            const { name, port, url, proxyUrl } = getServiceOutputs(this.context, branchContext, service);
+            console.log(`    🚀 ${name}: (PORT:${port})`);
+            console.log(`        🌐 url: ${url}`);
+            if (this.context.options.proxy.enabled) {
+                console.log(`        🔀 proxy-url: ${proxyUrl}`);
+            }
+        }
+    }
+}

package/dist/commands/SubBranchCommands.js

@@ -0,0 +1,49 @@
+import { AbstractCommands } from './AbstractCommands.js';
+import { BranchCommands } from './BranchCommands.js';
+export class SubBranchCommands extends AbstractCommands {
+    branchCommands = new BranchCommands(this.context);
+    // ============================================================================
+    // PUBLIC COMMAND METHODS
+    // ============================================================================
+    async create(rawSlug) {
+        rawSlug = this.toSubBranchSlug(rawSlug);
+        return this.branchCommands.create(rawSlug);
+    }
+    async start(rawSlug) {
+        rawSlug = this.toSubBranchSlug(rawSlug);
+        return this.branchCommands.start(rawSlug);
+    }
+    async list() {
+        return this.branchCommands.list(this.prefix);
+    }
+    async resync(rawSlug) {
+        rawSlug = this.toSubBranchSlug(rawSlug);
+        return this.branchCommands.resync(rawSlug);
+    }
+    async stop(rawSlug) {
+        rawSlug = this.toSubBranchSlug(rawSlug);
+        return this.branchCommands.stop(rawSlug);
+    }
+    async archive(rawSlug) {
+        rawSlug = this.toSubBranchSlug(rawSlug);
+        return this.branchCommands.archive(rawSlug);
+    }
+    async open(rawSlug) {
+        rawSlug = rawSlug ? this.toSubBranchSlug(rawSlug) : undefined;
+        return this.branchCommands.open(rawSlug);
+    }
+    async merge(rawSlug) {
+        rawSlug = this.toSubBranchSlug(rawSlug);
+        return this.branchCommands.merge(rawSlug);
+    }
+    async rebase(rawSlug) {
+        rawSlug = this.toSubBranchSlug(rawSlug);
+        return this.branchCommands.rebase(rawSlug);
+    }
+    // ============================================================================
+    // PRIVATE METHODS
+    // ============================================================================
+    toSubBranchSlug(rawSlug) {
+        return `${this.prefix}${rawSlug}`;
+    }
+}

package/dist/commands/types/InitOptions.js

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