feat-forge 1.0.1

package/dist/foundation/Repository.js

@@ -0,0 +1,431 @@
+import { branchNameAsPath } from '../lib/branch.js';
+import { executeBootstrapScript } from '../lib/bootstrap.js';
+import { HookEvent, executeHooksForEvent } from '../lib/hooks.js';
+import { NpmHelper } from '../foundation/NpmHelper.js';
+import { DirtyAction, promptConfirm, promptDirtyActions } from '../lib/prompt.js';
+import { copyFile, rm, symlink } from 'fs/promises';
+import path from 'path';
+import { ensureDir, pathExists } from '../lib/fs.js';
+import { checkoutBranch, createBranch, getBranches, getCurrentBranch, getGitStatusPorcelain, getGitWorktrees, gitBranchExists, runGit, } from '../lib/git.js';
+import { ForgeExpectMainRepositoryError } from './errors/index.js';
+export class Repository {
+    name;
+    path;
+    main;
+    context;
+    constructor(context, repoInfos) {
+        this.context = context;
+        this.name = repoInfos.name;
+        this.path = path.resolve(this.context.rootDir, repoInfos.path);
+        this.main = repoInfos.main;
+    }
+    isMainRepository() {
+        return this.main;
+    }
+    mustBeMainRepository() {
+        if (!this.isMainRepository()) {
+            throw new ForgeExpectMainRepositoryError('This operation is only available for the main repository.');
+        }
+    }
+    get folders() {
+        return this.context.options.folders;
+    }
+    get files() {
+        return this.context.options.files;
+    }
+    get specsPath() {
+        return path.join(this.path, this.folders.specs);
+    }
+    get specsArchivePath() {
+        return path.join(this.specsPath, this.folders.archive);
+    }
+    get templatePath() {
+        return path.join(this.specsPath, this.folders.template);
+    }
+    get activeSpecPath() {
+        return path.join(this.path, this.folders.activeSpec);
+    }
+    get agentsPath() {
+        return path.join(this.path, this.folders.repoAgents);
+    }
+    get repoConfigPath() {
+        return path.join(this.path, this.folders.repoConfig);
+    }
+    getSpecPath(branchName, ...segments) {
+        return path.join(this.specsPath, branchNameAsPath(branchName), ...segments);
+    }
+    getAgentPath(...segments) {
+        return path.join(this.agentsPath, ...segments);
+    }
+    getTemplatePath(...segments) {
+        return path.join(this.templatePath, ...segments);
+    }
+    getAgentTemplatePath(...segments) {
+        return this.getTemplatePath(this.folders.repoAgents, ...segments);
+    }
+    getRepoConfigPath(...segments) {
+        return path.join(this.repoConfigPath, ...segments);
+    }
+    async hasBranch(branchName) {
+        return gitBranchExists(this.path, branchName);
+    }
+    async hasBranchWithPrefix(prefix) {
+        const branches = await getBranches(this.path, prefix);
+        return branches.length > 0;
+    }
+    async hasFeatureBranch(featureSlug) {
+        const featureBranchName = this.context.getFeatureBranchName(featureSlug);
+        return this.hasBranch(featureBranchName);
+    }
+    async hasFixBranch(fixSlug) {
+        const fixBranchName = this.context.getFixBranchName(fixSlug);
+        return this.hasBranch(fixBranchName);
+    }
+    async hasReleaseBranch(releaseSlug) {
+        const releaseBranchName = this.context.getReleaseBranchName(releaseSlug);
+        return this.hasBranch(releaseBranchName);
+    }
+    async createBranch(branchName, baseBranch) {
+        if (!(await this.hasBranch(branchName))) {
+            await createBranch(this.path, branchName, baseBranch);
+            return 1;
+        }
+        return 0;
+    }
+    async createFeatureBranch(featureSlug) {
+        const featureBranchName = this.context.getFeatureBranchName(featureSlug);
+        return this.createBranch(featureBranchName);
+    }
+    async createFixBranch(fixSlug) {
+        const fixBranchName = this.context.getFixBranchName(fixSlug);
+        return this.createBranch(fixBranchName);
+    }
+    async createReleaseBranch(releaseSlug) {
+        const releaseBranchName = this.context.getReleaseBranchName(releaseSlug);
+        return this.createBranch(releaseBranchName);
+    }
+    async getCurrentBranch() {
+        return getCurrentBranch(this.path);
+    }
+    async setBranch(branchName) {
+        await checkoutBranch(this.path, branchName);
+    }
+    async setFeatureBranch(featureSlug) {
+        const featureBranchName = this.context.getFeatureBranchName(featureSlug);
+        await this.setBranch(featureBranchName);
+    }
+    async setFixBranch(fixSlug) {
+        const fixBranchName = this.context.getFixBranchName(fixSlug);
+        await this.setBranch(fixBranchName);
+    }
+    async setReleaseBranch(releaseSlug) {
+        const releaseBranchName = this.context.getReleaseBranchName(releaseSlug);
+        await this.setBranch(releaseBranchName);
+    }
+    async deleteBranch(branchName) {
+        await runGit(this.path, ['branch', '-D', branchName]);
+    }
+    async getBranches() {
+        return getBranches(this.path);
+    }
+    async getGitStatus() {
+        return getGitStatusPorcelain(this.path);
+    }
+    async isDirty() {
+        const status = await this.getGitStatus();
+        return status.length > 0;
+    }
+    async getStatus(branchName) {
+        const branch = await this.getCurrentBranch();
+        const dirty = await this.isDirty();
+        const onExpectedBranch = branch === branchName;
+        return { branch, dirty, onExpectedBranch };
+    }
+    async commit(message, files = ['.']) {
+        await runGit(this.path, ['add', ...files]);
+        await runGit(this.path, ['commit', '-m', message]);
+    }
+    async promptDirtyActions() {
+        if (!(await this.isDirty())) {
+            return true;
+        }
+        console.log(`Repository ${this.name} at ${this.path} has uncommitted changes.`);
+        // Prompt user for action
+        const { action, commitMessage } = await promptDirtyActions();
+        switch (action) {
+            case DirtyAction.Commit:
+                await runGit(this.path, ['add', '-A']);
+                await runGit(this.path, ['commit', '-m', commitMessage]);
+                // Verify worktree is now clean
+                if (await this.isDirty()) {
+                    throw new Error(`Worktree still dirty after commit: ${this.path}`);
+                }
+                return true;
+            case DirtyAction.Cancel:
+                return false;
+            case DirtyAction.Discard:
+                return await promptConfirm('This will discard local changes. Proceed?');
+        }
+    }
+    /**
+     * Execute hooks for a specific event type in this repository.
+     * Executes both npm scripts (feat-forge:hooks:eventType) and shell scripts (.forge/hooks/eventType.sh).
+     * Hooks are discovered and executed in alphabetical order for predictable and consistent execution.
+     *
+     * Supports:
+     * - npm scripts: feat-forge:hooks:postBranchStart, feat-forge:hooks:postBranchStart_01, etc.
+     * - shell scripts: .forge/hooks/postBranchStart.sh, postBranchStart_01.sh, etc.
+     *
+     * @param eventType - Type of event (HookEvent enum value)
+     * @param params - Optional parameters to pass to hooks as environment variables (FORGE_HOOK_PARAM_NAME)
+     * @returns Array of hook names that were executed (both npm and shell script names)
+     * @throws Error if any hook fails
+     */
+    async executeHook(eventType, params) {
+        const repoConfigFolderPath = this.folders.repoConfig;
+        const npmHelper = new NpmHelper(this.context, this);
+        const executedHooks = [];
+        // Execute npm scripts for this event
+        const npmScripts = await npmHelper.executeNpmScriptsForEvent(eventType, params);
+        executedHooks.push(...npmScripts);
+        // Execute shell scripts for this event
+        const shellScripts = await executeHooksForEvent(this.path, repoConfigFolderPath, eventType, params);
+        executedHooks.push(...shellScripts);
+        return executedHooks;
+    }
+}
+export class RootRepository extends Repository {
+    copyFiles;
+    constructor(context, repoInfos) {
+        super(context, repoInfos);
+        this.copyFiles = repoInfos.copyFiles ?? [];
+    }
+    async copyFilesToWorktree(worktree) {
+        for (const file of this.copyFiles) {
+            const src = path.join(this.path, file);
+            const dest = path.join(worktree.path, file);
+            if (!(await pathExists(src)))
+                continue;
+            if (await pathExists(dest))
+                continue;
+            await ensureDir(path.dirname(dest));
+            console.log(`Copying file from root repository to worktree: ${src} -> ${dest}`);
+            await copyFile(src, dest);
+        }
+    }
+    getWorktreePath(branchName, temporary) {
+        return temporary
+            ? this.getTempWorktreePath(branchName, temporary)
+            : this.context.paths.getPathInBranchRoot(branchName, this.name);
+    }
+    getTempWorktreePath(branchName, type) {
+        return this.context.paths.getTempWorktreePathForRepo(type, branchName, this.name);
+    }
+    async hasWorktree(branchName, temporary) {
+        const worktreePath = temporary ? this.getTempWorktreePath(branchName, temporary) : this.getWorktreePath(branchName);
+        return await pathExists(worktreePath);
+    }
+    async addWorktree(branchName, temporary) {
+        const worktreePath = temporary ? this.getTempWorktreePath(branchName, temporary) : this.getWorktreePath(branchName);
+        // Check if worktree unexpectedly exists
+        if (await pathExists(worktreePath)) {
+            throw new Error(`Worktree already exists at ${worktreePath}.\\n` +
+                `If you have manually deleted worktree folders, run 'forge feature stop ${branchName}' to clean up.`);
+        }
+        if (await this.hasBranch(branchName)) {
+            await runGit(this.path, ['worktree', 'add', worktreePath, branchName]);
+        }
+        else {
+            await runGit(this.path, ['worktree', 'add', '-b', branchName, worktreePath]);
+        }
+        return this.getWorktree(branchName, temporary);
+    }
+    async getTemporaryWorktree(branchName, type) {
+        if (!(await this.hasBranch(branchName))) {
+            throw new Error(`Feature branch ${branchName} does not exist in repository ${this.name}`);
+        }
+        return this.addWorktree(branchName, type);
+    }
+    async getWorktree(branchName, temporary) {
+        if (!(await this.hasWorktree(branchName, temporary))) {
+            throw new Error(`Worktree for feature ${branchName} does not exist in repository ${this.name}`);
+        }
+        return new WorktreeRepository(this.context, { name: this.name, path: this.getWorktreePath(branchName, temporary), main: this.main }, this, !!temporary);
+    }
+    async removeWorktree(worktreeRepository, options) {
+        const worktreePath = worktreeRepository.path;
+        const worktreePathExists = await pathExists(worktreePath);
+        if (worktreePathExists || options?.forceOnEmpty) {
+            await runGit(this.path, ['worktree', 'remove', '--force', worktreePath]);
+            if (worktreePathExists)
+                await rm(worktreePath, { recursive: true, force: true });
+        }
+        else {
+            console.log(`Worktree path does not exist, skipping removal: ${worktreePath}`);
+        }
+    }
+    async listGitWorktrees() {
+        const rawWorktrees = await getGitWorktrees(this.path);
+        const worktrees = [];
+        for (const wt of rawWorktrees) {
+            const isTemporary = wt.path.startsWith(this.context.paths.tempFolderRoot);
+            const wtRepo = new WorktreeRepository(this.context, { name: this.name, path: wt.path, main: this.main }, this, isTemporary);
+            worktrees.push(wtRepo);
+        }
+        return worktrees;
+    }
+    async cleanOrphanedWorktree(branchName) {
+        const repoAllWorktrees = await this.listGitWorktrees();
+        for (const wt of repoAllWorktrees) {
+            if (!(await pathExists(wt.path))) {
+                if ((await wt.getCurrentBranch()) === branchName) {
+                    console.log(`Try cleaning up orphaned worktree at ${wt.path} for branch ${branchName}`);
+                    try {
+                        await this.removeWorktree(wt, { forceOnEmpty: true });
+                    }
+                    catch (error) {
+                        console.warn(`  Could not remove orphaned worktree: ${error}`);
+                    }
+                }
+                else {
+                    console.log(`  Skipping orphaned worktree at ${wt.path} since it's not on the feature branch ${branchName}`);
+                }
+            }
+        }
+    }
+    async merge(sourceBranch, targetBranch) {
+        console.log(`\n=== Merging "${sourceBranch}" into "${targetBranch}" on repo "${this.name}" ===`);
+        try {
+            await this.executeHook(HookEvent.PRE_MERGE, { sourceBranch, targetBranch });
+            // check if target branch is opened as a worktree - if so we must use the worktreeRepository to merge
+            let mergeRepoPath = this.path;
+            let mergeRepo = this;
+            const repoAllWorktrees = await this.listGitWorktrees();
+            const targetWorktree = repoAllWorktrees.find((wt) => wt.path === this.getWorktreePath(targetBranch));
+            if (targetWorktree) {
+                console.log(`Target branch "${targetBranch}" is currently checked out in worktree at ${targetWorktree.path}. Merging there.`);
+                mergeRepoPath = targetWorktree.path;
+                mergeRepo = targetWorktree;
+            }
+            else {
+                if ((await this.getCurrentBranch()) !== targetBranch) {
+                    // Checkout target branch
+                    console.log(`RootRepo not on target branch. Checking out "${targetBranch}"...`);
+                    await checkoutBranch(mergeRepoPath, targetBranch);
+                }
+            }
+            // Perform merge with --no-ff to preserve feature branch history
+            try {
+                console.log(`Merging "${sourceBranch}"...`);
+                await runGit(mergeRepoPath, ['merge', '--no-ff', sourceBranch]);
+                console.log(`✅ Merge successful for repo: ${this.name}`);
+                await mergeRepo.executeHook(HookEvent.POST_MERGE, { sourceBranch, targetBranch });
+                return { repo: this.name, success: true, hasConflicts: false };
+            }
+            catch (error) {
+                // Check if it's a merge conflict (detected by special status indicators)
+                const status = await getGitStatusPorcelain(mergeRepoPath);
+                if (status.includes('UU ') || status.includes('AA ') || status.includes('DD ')) {
+                    console.log(`⚠️  Merge conflicts detected in ${this.name}`);
+                    console.log(`Please resolve conflicts manually in: ${mergeRepoPath}`);
+                    return { repo: this.name, success: false, hasConflicts: true };
+                }
+                else {
+                    // Re-throw if it's not a merge conflict
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error merging ${this.name}:`, error);
+            return { repo: this.name, success: false, hasConflicts: false };
+        }
+    }
+}
+export class WorktreeRepository extends Repository {
+    rootRepository;
+    temporary;
+    constructor(context, repoInfos, rootRepository, temporary = false) {
+        super(context, repoInfos);
+        this.rootRepository = rootRepository;
+        this.temporary = temporary;
+    }
+    remove() {
+        return this.rootRepository.removeWorktree(this);
+    }
+    async setActiveSpec(branchContext) {
+        if (this.isMainRepository()) {
+            const specPath = this.getSpecPath(branchContext.branchName);
+            const mainActivePath = this.activeSpecPath;
+            await rm(mainActivePath, { force: true });
+            await symlink(path.relative(path.dirname(mainActivePath), specPath), mainActivePath);
+        }
+        else {
+            const mainActivePath = branchContext.mainRepo.activeSpecPath;
+            const secondaryActivePath = this.activeSpecPath;
+            await rm(secondaryActivePath, { force: true });
+            // Create relative path from secondary to main's .active-spec
+            await symlink(path.relative(path.dirname(secondaryActivePath), mainActivePath), secondaryActivePath);
+        }
+        await this.executeHook(HookEvent.POST_SET_ACTIVE_SPECS, { branch: branchContext.branchName });
+    }
+    /**
+     * Rebase the worktree's current branch (which should be the feature branch) onto the specified base branch.
+     */
+    async rebase(specsBranch, baseBranch) {
+        try {
+            await this.executeHook(HookEvent.PRE_REBASE, { branch: specsBranch, baseBranch });
+            if (await this.isDirty()) {
+                console.log(`⚠️  Worktree repository ${this.name} has uncommitted changes. Please commit or stash them before rebasing.`);
+                return { repo: this.name, success: false, hasConflicts: false };
+            }
+            // Make sure we're on the feature branch in the worktree
+            const currentBranch = await this.getCurrentBranch();
+            if (currentBranch !== specsBranch) {
+                console.log(`Checking out ${specsBranch}...`);
+                await checkoutBranch(this.path, specsBranch);
+            }
+            // Perform rebase
+            console.log(`Rebasing ${specsBranch} onto ${baseBranch}...`);
+            try {
+                await runGit(this.path, ['rebase', baseBranch]);
+                console.log(`✅ Rebase successful for ${this.name}`);
+                await this.executeHook(HookEvent.POST_REBASE, { branch: specsBranch, baseBranch });
+                return { repo: this.name, success: true, hasConflicts: false };
+            }
+            catch (error) {
+                // Check if it's a rebase conflict
+                const status = await this.getGitStatus();
+                if (status.includes('UU ') || status.includes('AA ') || status.includes('DD ')) {
+                    console.log(`⚠️  Rebase conflicts detected in worktree repository: ${this.name}`);
+                    console.log(`Please resolve conflicts manually in: ${this.path}`);
+                    console.log(`After resolving, run: git rebase --continue`);
+                    console.log(`To abort, run: git rebase --abort`);
+                    return { repo: this.name, success: false, hasConflicts: true };
+                }
+                else {
+                    // Re-throw if it's not a rebase conflict
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error rebasing ${this.name}:`, error);
+            return { repo: this.name, success: false, hasConflicts: false };
+        }
+    }
+    /**
+     * Execute the bootstrap script in this repository.
+     * Executes both npm script (feat-forge:bootstrap) and shell script (bootstrap.sh/.bat).
+     *
+     * @throws Error if any bootstrap script fails
+     */
+    async executeBootstrapScript() {
+        const repoConfigFolderPath = this.folders.repoConfig;
+        const npmHelper = new NpmHelper(this.context, this);
+        // Try npm bootstrap script first
+        await npmHelper.executeNpmBootstrapScript();
+        // Try shell bootstrap script after npm
+        await executeBootstrapScript(this.path, repoConfigFolderPath);
+    }
+}

package/dist/foundation/errors/ForgeError.js

@@ -0,0 +1,9 @@
+export class ForgeError extends Error {
+    static extend(error, message) {
+        const forgeError = new this(`${message ? message + '\n' : ''}${error.message}`);
+        if (error.stack) {
+            forgeError.stack = error.stack;
+        }
+        return forgeError;
+    }
+}

package/dist/foundation/errors/_error.config.js

@@ -0,0 +1,12 @@
+export const FORGE_ERRORS = {
+    ForgeExpectMainRepositoryError: 'Expected to be used with the main repository, but was not.',
+    ForgeConfigError: 'There was an error with the Forge configuration.',
+    ForgeBadStateError: 'The system is in a bad state to perform the requested operation.',
+    ForgeModeNotDefinedError: 'The specified mode is not defined in the configuration.',
+    ForgePortAllocationsLoadError: 'Failed to load port allocations file.',
+    ForgePortRangeExhaustedError: 'Port range exhausted for this branch.',
+    ForgeServicesScanError: 'Failed to scan services from a repository.',
+    ForgeServicesValidationError: 'Service definition is invalid.',
+    ForgePortNotAssignedError: 'No port was assigned for a service.',
+    ForgeNotInActiveBranchError: 'No active branch found in this folder. Execute the command in an active branch context.',
+};

package/dist/foundation/errors/generated/ForgeBadStateError.js

@@ -0,0 +1,11 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Run 'pnpm generate:errors' to regenerate
+// Edit .errors.config.ts to add/remove errors
+import { ForgeError } from '../ForgeError.js';
+import { FORGE_ERRORS } from '../_error.config.js';
+export class ForgeBadStateError extends ForgeError {
+    constructor(message) {
+        super(message || FORGE_ERRORS.ForgeBadStateError);
+        this.name = 'ForgeBadStateError';
+    }
+}

package/dist/foundation/errors/generated/ForgeConfigError.js

@@ -0,0 +1,11 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Run 'pnpm generate:errors' to regenerate
+// Edit .errors.config.ts to add/remove errors
+import { ForgeError } from '../ForgeError.js';
+import { FORGE_ERRORS } from '../_error.config.js';
+export class ForgeConfigError extends ForgeError {
+    constructor(message) {
+        super(message || FORGE_ERRORS.ForgeConfigError);
+        this.name = 'ForgeConfigError';
+    }
+}

package/dist/foundation/errors/generated/ForgeExpectMainRepositoryError.js

@@ -0,0 +1,11 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Run 'pnpm generate:errors' to regenerate
+// Edit .errors.config.ts to add/remove errors
+import { ForgeError } from '../ForgeError.js';
+import { FORGE_ERRORS } from '../_error.config.js';
+export class ForgeExpectMainRepositoryError extends ForgeError {
+    constructor(message) {
+        super(message || FORGE_ERRORS.ForgeExpectMainRepositoryError);
+        this.name = 'ForgeExpectMainRepositoryError';
+    }
+}

package/dist/foundation/errors/generated/ForgeModeNotDefinedError.js

@@ -0,0 +1,11 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Run 'pnpm generate:errors' to regenerate
+// Edit .errors.config.ts to add/remove errors
+import { ForgeError } from '../ForgeError.js';
+import { FORGE_ERRORS } from '../_error.config.js';
+export class ForgeModeNotDefinedError extends ForgeError {
+    constructor(message) {
+        super(message || FORGE_ERRORS.ForgeModeNotDefinedError);
+        this.name = 'ForgeModeNotDefinedError';
+    }
+}

package/dist/foundation/errors/generated/ForgeNotInActiveBranchError.js

@@ -0,0 +1,11 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Run 'pnpm generate:errors' to regenerate
+// Edit .errors.config.ts to add/remove errors
+import { ForgeError } from '../ForgeError.js';
+import { FORGE_ERRORS } from '../_error.config.js';
+export class ForgeNotInActiveBranchError extends ForgeError {
+    constructor(message) {
+        super(message || FORGE_ERRORS.ForgeNotInActiveBranchError);
+        this.name = 'ForgeNotInActiveBranchError';
+    }
+}

package/dist/foundation/errors/generated/ForgePortAllocationsLoadError.js

@@ -0,0 +1,11 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Run 'pnpm generate:errors' to regenerate
+// Edit .errors.config.ts to add/remove errors
+import { ForgeError } from '../ForgeError.js';
+import { FORGE_ERRORS } from '../_error.config.js';
+export class ForgePortAllocationsLoadError extends ForgeError {
+    constructor(message) {
+        super(message || FORGE_ERRORS.ForgePortAllocationsLoadError);
+        this.name = 'ForgePortAllocationsLoadError';
+    }
+}

package/dist/foundation/errors/generated/ForgePortNotAssignedError.js

@@ -0,0 +1,11 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Run 'pnpm generate:errors' to regenerate
+// Edit .errors.config.ts to add/remove errors
+import { ForgeError } from '../ForgeError.js';
+import { FORGE_ERRORS } from '../_error.config.js';
+export class ForgePortNotAssignedError extends ForgeError {
+    constructor(message) {
+        super(message || FORGE_ERRORS.ForgePortNotAssignedError);
+        this.name = 'ForgePortNotAssignedError';
+    }
+}

package/dist/foundation/errors/generated/ForgePortRangeExhaustedError.js

@@ -0,0 +1,11 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Run 'pnpm generate:errors' to regenerate
+// Edit .errors.config.ts to add/remove errors
+import { ForgeError } from '../ForgeError.js';
+import { FORGE_ERRORS } from '../_error.config.js';
+export class ForgePortRangeExhaustedError extends ForgeError {
+    constructor(message) {
+        super(message || FORGE_ERRORS.ForgePortRangeExhaustedError);
+        this.name = 'ForgePortRangeExhaustedError';
+    }
+}

package/dist/foundation/errors/generated/ForgeServicesScanError.js

@@ -0,0 +1,11 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Run 'pnpm generate:errors' to regenerate
+// Edit .errors.config.ts to add/remove errors
+import { ForgeError } from '../ForgeError.js';
+import { FORGE_ERRORS } from '../_error.config.js';
+export class ForgeServicesScanError extends ForgeError {
+    constructor(message) {
+        super(message || FORGE_ERRORS.ForgeServicesScanError);
+        this.name = 'ForgeServicesScanError';
+    }
+}

package/dist/foundation/errors/generated/ForgeServicesValidationError.js

@@ -0,0 +1,11 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Run 'pnpm generate:errors' to regenerate
+// Edit .errors.config.ts to add/remove errors
+import { ForgeError } from '../ForgeError.js';
+import { FORGE_ERRORS } from '../_error.config.js';
+export class ForgeServicesValidationError extends ForgeError {
+    constructor(message) {
+        super(message || FORGE_ERRORS.ForgeServicesValidationError);
+        this.name = 'ForgeServicesValidationError';
+    }
+}

package/dist/foundation/errors/index.js

@@ -0,0 +1,13 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Run 'pnpm generate:errors' to regenerate
+// Edit .errors.config.ts to add/remove errors
+export { ForgeExpectMainRepositoryError } from './generated/ForgeExpectMainRepositoryError.js';
+export { ForgeConfigError } from './generated/ForgeConfigError.js';
+export { ForgeBadStateError } from './generated/ForgeBadStateError.js';
+export { ForgeModeNotDefinedError } from './generated/ForgeModeNotDefinedError.js';
+export { ForgePortAllocationsLoadError } from './generated/ForgePortAllocationsLoadError.js';
+export { ForgePortRangeExhaustedError } from './generated/ForgePortRangeExhaustedError.js';
+export { ForgeServicesScanError } from './generated/ForgeServicesScanError.js';
+export { ForgeServicesValidationError } from './generated/ForgeServicesValidationError.js';
+export { ForgePortNotAssignedError } from './generated/ForgePortNotAssignedError.js';
+export { ForgeNotInActiveBranchError } from './generated/ForgeNotInActiveBranchError.js';

package/dist/foundation/types/AIAgent.js

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

package/dist/foundation/types/AIAgentName.js

@@ -0,0 +1,11 @@
+/**
+ * Known agent types that have special behaviors
+ */
+export var AIAgentName;
+(function (AIAgentName) {
+    AIAgentName["CODEX"] = "Codex";
+    AIAgentName["CLAUDE"] = "Claude";
+    AIAgentName["COPILOT"] = "Copilot";
+    AIAgentName["CURSOR"] = "Cursor";
+    AIAgentName["GEMINI"] = "Gemini";
+})(AIAgentName || (AIAgentName = {}));

package/dist/foundation/types/DeepPartial.js

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

package/dist/foundation/types/IDE.js

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

package/dist/foundation/types/IDEName.js

@@ -0,0 +1,7 @@
+/**
+ * Known IDE types that we can configure automatically
+ */
+export var IDEName;
+(function (IDEName) {
+    IDEName["VSCODE"] = "VSCode";
+})(IDEName || (IDEName = {}));

package/dist/foundation/types/ModeConfig.js

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

package/dist/foundation/types/RepositoryInfos.js

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