feat-forge 1.0.1

package/dist/foundation/ForgeConfigFile.js

@@ -0,0 +1,391 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Type } from 'class-transformer';
+import { IsOptional, IsString, IsNotEmpty, IsArray, ValidateNested, ArrayNotEmpty, IsBoolean, IsInt, Min } from 'class-validator';
+export class ForgeFoldersOptions {
+    /**
+     * Folder for feature specs within each repo.
+     */
+    specs = '.specs';
+    /**
+     * Folder for git worktrees. Default: 'worktrees'
+     * Can be empty to put them in the root of the repo, but that can get messy so we default to a separate folder
+     */
+    worktrees = 'worktrees';
+    /**
+     * Folder for active spec/branch tracking. Default: '.active-spec'
+     */
+    activeSpec = '.active-spec';
+    /**
+     * Folder for spec files templates. Default: '.template'
+     */
+    template = '.template';
+    /**
+     * Folder for repo's agents when agentsInEachRepo is active. Default: '.forge-agents'
+     */
+    repoAgents = '.forge-agents';
+    /**
+     * Folder for archived feature specs within each repo. Default: '.archives'
+     */
+    archive = '.archives';
+    /**
+     * Folder for repository configuration, bootstrap and hook scripts. Default: '.forge'
+     */
+    repoConfig = '.forge';
+}
+__decorate([
+    IsOptional(),
+    IsString(),
+    IsNotEmpty(),
+    __metadata("design:type", String)
+], ForgeFoldersOptions.prototype, "specs", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    __metadata("design:type", String)
+], ForgeFoldersOptions.prototype, "worktrees", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    IsNotEmpty(),
+    __metadata("design:type", String)
+], ForgeFoldersOptions.prototype, "activeSpec", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    IsNotEmpty(),
+    __metadata("design:type", String)
+], ForgeFoldersOptions.prototype, "template", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    IsNotEmpty(),
+    __metadata("design:type", String)
+], ForgeFoldersOptions.prototype, "repoAgents", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    IsNotEmpty(),
+    __metadata("design:type", String)
+], ForgeFoldersOptions.prototype, "archive", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    IsNotEmpty(),
+    __metadata("design:type", String)
+], ForgeFoldersOptions.prototype, "repoConfig", void 0);
+export class ForgeFilesOptions {
+    /**
+     * File name for storing the current mode of a feature. Default: '.forge-mode'
+     */
+    forgeMode = '.forge-mode';
+}
+__decorate([
+    IsOptional(),
+    IsString(),
+    IsNotEmpty(),
+    __metadata("design:type", String)
+], ForgeFilesOptions.prototype, "forgeMode", void 0);
+export class ForgeGitOptions {
+    /**
+     * Prefix for feature branches. Default: 'feature/'
+     */
+    featureBranchPrefix = 'feature/';
+    /**
+     * Prefix for fix branches. Default: 'fix/'
+     */
+    fixBranchPrefix = 'fix/';
+    /**
+     * Prefix for release branches. Default: 'release/'
+     */
+    releaseBranchPrefix = 'release/';
+    /**
+     * These branches will have a special status and will be protected from deletion.
+     * Default: ['main', 'master', 'develop', 'dev']
+     */
+    protectedBranches = ['main', 'master', 'develop', 'dev'];
+}
+__decorate([
+    IsOptional(),
+    IsString(),
+    __metadata("design:type", String)
+], ForgeGitOptions.prototype, "featureBranchPrefix", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    __metadata("design:type", String)
+], ForgeGitOptions.prototype, "fixBranchPrefix", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    __metadata("design:type", String)
+], ForgeGitOptions.prototype, "releaseBranchPrefix", void 0);
+__decorate([
+    IsOptional(),
+    IsArray(),
+    IsString({ each: true }),
+    __metadata("design:type", Array)
+], ForgeGitOptions.prototype, "protectedBranches", void 0);
+export class ForgeProcessOptions {
+    /**
+     * Do we ensure that .gitignore includes the .active-spec folder in all repos to avoid accidentally committing active branch pointers? Default: true
+     * You might want to set this to false if you want to commit the active spec pointers for some reason, but be careful not to accidentally commit them.
+     */
+    manageGitIgnore = true;
+    /**
+     * Do we put an .active-spec folder in each repo on branch start.
+     *
+     * Typical use cases :
+     *  - You want to open the repo itself in an IDE and have the active spec visible here
+     *  - You want to execute Agents only in the context of the repo, while maintaining access to current spec
+     *
+     * Important : You probably want to set agentsInEachRepo to true if you set this to true.
+     */
+    activeSpecInEachRepo = true;
+    /**
+     * Do we put agent instruction files in each repo on branch start, or only in the branch context?
+     *
+     * Typical use cases for putting them in each repo:
+     *  - You want to open the repo itself in an IDE and have the agent instructions visible here
+     *  - You want to execute Agents only in the context of the repo, while maintaining access to current instructions
+     *
+     * Important : You probably want to set activeSpecInEachRepo to true if you set this to true.
+     */
+    agentsInEachRepo = true;
+    /**
+     * Prefix for npm scripts in package.json. Default: 'feat-forge'
+     * Example: with prefix 'feat-forge', scripts would be 'feat-forge:bootstrap', 'feat-forge:hooks:postBranchStart'
+     */
+    npmScriptPrefix = 'feat-forge';
+}
+__decorate([
+    IsOptional(),
+    IsBoolean(),
+    __metadata("design:type", Boolean)
+], ForgeProcessOptions.prototype, "manageGitIgnore", void 0);
+__decorate([
+    IsOptional(),
+    IsBoolean(),
+    __metadata("design:type", Boolean)
+], ForgeProcessOptions.prototype, "activeSpecInEachRepo", void 0);
+__decorate([
+    IsOptional(),
+    IsBoolean(),
+    __metadata("design:type", Boolean)
+], ForgeProcessOptions.prototype, "agentsInEachRepo", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    IsNotEmpty(),
+    __metadata("design:type", String)
+], ForgeProcessOptions.prototype, "npmScriptPrefix", void 0);
+export class ForgeProxyOptions {
+    /**
+     * Whether the proxy is enabled or not. Default: true
+     *
+     * Active by default, but you can disable it if you don't need to use the proxy features (like URL rewriting in .envrc)
+     * and want to save system resources by not running the proxy server at all.
+     */
+    enabled = true;
+    /**
+     * Base port for service port allocation. Default: 3000
+     */
+    servicesBasePort = 3000;
+    /**
+     * Number of ports allocated per branch. Default: 100
+     */
+    branchRangeSize = 100;
+    /**
+     * Port for the proxy server. Default: 8080
+     */
+    port = 8080;
+    envrc = '.envrc';
+    /**
+     * Whether to put a source_up command in the .envrc file to load parent .envrc files
+     */
+    envrc_source_up = true;
+    environmentVariablePrefix = 'FEAT_FORGE_';
+}
+__decorate([
+    IsOptional(),
+    IsBoolean(),
+    __metadata("design:type", Boolean)
+], ForgeProxyOptions.prototype, "enabled", void 0);
+__decorate([
+    IsOptional(),
+    IsInt(),
+    Min(1),
+    __metadata("design:type", Number)
+], ForgeProxyOptions.prototype, "servicesBasePort", void 0);
+__decorate([
+    IsOptional(),
+    IsInt(),
+    Min(1),
+    __metadata("design:type", Number)
+], ForgeProxyOptions.prototype, "branchRangeSize", void 0);
+__decorate([
+    IsOptional(),
+    IsInt(),
+    Min(1),
+    __metadata("design:type", Number)
+], ForgeProxyOptions.prototype, "port", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    IsNotEmpty(),
+    __metadata("design:type", String)
+], ForgeProxyOptions.prototype, "envrc", void 0);
+__decorate([
+    IsOptional(),
+    IsBoolean(),
+    __metadata("design:type", Boolean)
+], ForgeProxyOptions.prototype, "envrc_source_up", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    IsNotEmpty(),
+    __metadata("design:type", String)
+], ForgeProxyOptions.prototype, "environmentVariablePrefix", void 0);
+export class ForgeOptions {
+    process = new ForgeProcessOptions();
+    folders = new ForgeFoldersOptions();
+    files = new ForgeFilesOptions();
+    git = new ForgeGitOptions();
+    proxy = new ForgeProxyOptions();
+}
+__decorate([
+    IsOptional(),
+    ValidateNested(),
+    Type(() => ForgeProcessOptions),
+    __metadata("design:type", ForgeProcessOptions)
+], ForgeOptions.prototype, "process", void 0);
+__decorate([
+    IsOptional(),
+    ValidateNested(),
+    Type(() => ForgeFoldersOptions),
+    __metadata("design:type", ForgeFoldersOptions)
+], ForgeOptions.prototype, "folders", void 0);
+__decorate([
+    IsOptional(),
+    ValidateNested(),
+    Type(() => ForgeFilesOptions),
+    __metadata("design:type", ForgeFilesOptions)
+], ForgeOptions.prototype, "files", void 0);
+__decorate([
+    IsOptional(),
+    ValidateNested(),
+    Type(() => ForgeGitOptions),
+    __metadata("design:type", ForgeGitOptions)
+], ForgeOptions.prototype, "git", void 0);
+__decorate([
+    IsOptional(),
+    ValidateNested(),
+    Type(() => ForgeProxyOptions),
+    __metadata("design:type", ForgeProxyOptions)
+], ForgeOptions.prototype, "proxy", void 0);
+/**
+ * Type for the .feat-forge.json configuration file
+ */
+export class ForgeConfigFile {
+    /**
+     * Optional root directory for all repositories. If not set, repos paths are relative to the config file location. Can be absolute or relative.
+     * Useful for monorepos or when you want to keep the config file in a separate folder.
+     */
+    rootDir;
+    /**
+     * List of repositories to manage. Can be a simple string (repo path) or an object with more options.
+     * If multiple repos are defined, one must be marked as "main" (or it will take the first one) -> this is the repo where the feature branches will be created and where the active feature will be tracked.
+     * If only one repo is defined, it will be considered the main repo by default.
+     */
+    repositories;
+    /**
+     * List of spec files to create in each spec folder for a branch. Default: ['SPEC.md', 'TODO.md']
+     *
+     * Important: Template file must be named accordingly (e.g. .specs/.template/FOOBAR.md for FOOBAR.md) if you want to use custom templates for these files.
+     * Note: You can specificy any type of file here (txt, json, etc.)
+     */
+    specFiles;
+    /**
+     * List of modes for the forge.
+     *
+     * Each mode can have a specific agent template file and description.
+     * The first one (or the one mode marked as default) will be the default mode for new branches.
+     */
+    modes;
+    agents;
+    ides;
+    options;
+}
+__decorate([
+    IsOptional(),
+    IsString(),
+    __metadata("design:type", String)
+], ForgeConfigFile.prototype, "rootDir", void 0);
+__decorate([
+    IsArray(),
+    ArrayNotEmpty(),
+    __metadata("design:type", Array)
+], ForgeConfigFile.prototype, "repositories", void 0);
+__decorate([
+    IsOptional(),
+    IsArray(),
+    IsNotEmpty({ each: true }),
+    IsString({ each: true }),
+    __metadata("design:type", Array)
+], ForgeConfigFile.prototype, "specFiles", void 0);
+__decorate([
+    IsOptional(),
+    IsArray(),
+    Type(() => ModeConfigEntry),
+    __metadata("design:type", Array)
+], ForgeConfigFile.prototype, "modes", void 0);
+__decorate([
+    IsOptional(),
+    IsArray(),
+    __metadata("design:type", Array)
+], ForgeConfigFile.prototype, "agents", void 0);
+__decorate([
+    IsOptional(),
+    IsArray(),
+    __metadata("design:type", Array)
+], ForgeConfigFile.prototype, "ides", void 0);
+__decorate([
+    IsOptional(),
+    ValidateNested(),
+    Type(() => ForgeOptions),
+    __metadata("design:type", Object)
+], ForgeConfigFile.prototype, "options", void 0);
+export class ModeConfigEntry {
+    name;
+    description;
+    agentFile;
+    default = false;
+}
+__decorate([
+    IsOptional(),
+    IsNotEmpty(),
+    IsString(),
+    __metadata("design:type", String)
+], ModeConfigEntry.prototype, "name", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    __metadata("design:type", String)
+], ModeConfigEntry.prototype, "description", void 0);
+__decorate([
+    IsNotEmpty(),
+    IsString(),
+    __metadata("design:type", String)
+], ModeConfigEntry.prototype, "agentFile", void 0);
+__decorate([
+    IsOptional(),
+    IsBoolean(),
+    __metadata("design:type", Boolean)
+], ModeConfigEntry.prototype, "default", void 0);

package/dist/foundation/ForgeContext.js

@@ -0,0 +1,169 @@
+import { rm } from 'fs/promises';
+import { copyFilesRecursively, ensureDir, pathExists } from '../lib/fs.js';
+import { SOURCE_TEMPLATE_AGENT_PATH } from '../lib/templates.js';
+import { BranchContext } from './BranchContext.js';
+import { ForgeModeNotDefinedError } from './errors/index.js';
+import { PathHelper } from './PathHelper.js';
+import { RootRepository } from './Repository.js';
+export class ForgeContext {
+    config;
+    rootDir;
+    repositories;
+    agents;
+    ides;
+    paths;
+    constructor(rootDir, config) {
+        this.rootDir = config.rootDir || rootDir;
+        this.config = config;
+        this.repositories = config.repositories.map((repoInfos) => new RootRepository(this, repoInfos));
+        this.agents = config.agents;
+        this.ides = config.ides;
+        this.paths = new PathHelper(this);
+    }
+    get options() {
+        return this.config.options;
+    }
+    get mainRepo() {
+        return this.repositories.find((repo) => repo.main);
+    }
+    get mainRepoName() {
+        return this.mainRepo.name;
+    }
+    get secondaryRepos() {
+        return this.repositories.filter((repo) => !repo.main);
+    }
+    getRepo(repoName) {
+        return this.repositories.find((r) => r.name === repoName);
+    }
+    makeBranchContext(branchName) {
+        const branchRootPath = this.paths.getBranchRootPath(branchName);
+        return new BranchContext(this, branchName, branchRootPath, [], false);
+    }
+    async loadBranchContext(branchName) {
+        const branchRootPath = this.paths.getBranchRootPath(branchName);
+        return BranchContext.loadFromPath(this, branchName, branchRootPath);
+    }
+    async loadActiveBranchesContexts(startDir = this.paths.worktreesRoot, prefix = []) {
+        if (!(await pathExists(startDir))) {
+            return [];
+        }
+        const branchContexts = [];
+        const mainRepoBranches = await this.mainRepo.getBranches();
+        // Test logic
+        await Promise.all(mainRepoBranches.map(async (branchName) => {
+            if (await this.branchRootExists(branchName)) {
+                branchContexts.push(await this.loadBranchContext(branchName));
+            }
+        }));
+        return branchContexts;
+    }
+    async isBranchActive(branchName) {
+        return this.branchRootExists(branchName);
+    }
+    async getBranchContext(branchName) {
+        if (!(await this.isBranchActive(branchName))) {
+            return this.makeBranchContext(branchName);
+        }
+        return this.loadBranchContext(branchName);
+    }
+    async branchRootExists(branchName) {
+        const branchRootPath = this.paths.getBranchRootPath(branchName);
+        return pathExists(branchRootPath);
+    }
+    getFeatureBranchName(featureSlug) {
+        return `${this.options.git.featureBranchPrefix}${featureSlug}`;
+    }
+    getFixBranchName(fixSlug) {
+        return `${this.options.git.fixBranchPrefix}${fixSlug}`;
+    }
+    getReleaseBranchName(releaseSlug) {
+        return `${this.options.git.releaseBranchPrefix}${releaseSlug}`;
+    }
+    async hasBranch(branchName) {
+        // only check on mainRepo
+        return this.mainRepo.hasBranch(branchName);
+    }
+    async hasFeatureBranch(featureSlug) {
+        // only check on mainRepo
+        const branchName = this.getFeatureBranchName(featureSlug);
+        return this.mainRepo.hasBranch(branchName);
+    }
+    async hasFixBranch(fixSlug) {
+        // only check on mainRepo
+        const branchName = this.getFixBranchName(fixSlug);
+        return this.mainRepo.hasBranch(branchName);
+    }
+    async hasReleaseBranch(releaseSlug) {
+        // only check on mainRepo
+        const branchName = this.getReleaseBranchName(releaseSlug);
+        return this.mainRepo.hasBranch(branchName);
+    }
+    async hasFeatureBranchOnAllRepositories(featureSlug) {
+        const branchName = this.getFeatureBranchName(featureSlug);
+        return Promise.all(this.repositories.map((repo) => repo.hasBranch(branchName))).then((results) => results.every(Boolean));
+    }
+    async hasFixBranchOnAllRepositories(fixSlug) {
+        const branchName = this.getFixBranchName(fixSlug);
+        return Promise.all(this.repositories.map((repo) => repo.hasBranch(branchName))).then((results) => results.every(Boolean));
+    }
+    async hasReleaseBranchOnAllRepositories(releaseSlug) {
+        const branchName = this.getReleaseBranchName(releaseSlug);
+        return Promise.all(this.repositories.map((repo) => repo.hasBranch(branchName))).then((results) => results.every(Boolean));
+    }
+    getDefaultMode() {
+        return this.config.modes.find((mode) => mode.default);
+    }
+    hasMode(modeName) {
+        return this.config.modes.findIndex((mode) => mode.name === modeName) >= 0;
+    }
+    modeExistsOrThrow(modeName) {
+        if (!this.hasMode(modeName)) {
+            throw new ForgeModeNotDefinedError(`Mode '${modeName}' not found in configuration. Please add it to your configuration file before using it.`);
+        }
+        return true;
+    }
+    getMode(modeName) {
+        this.modeExistsOrThrow(modeName);
+        return this.config.modes.find((mode) => mode.name === modeName);
+    }
+    /**
+     * Create agent template files in the main repository.
+     * They will be used as source templates for the agent context files that will be created on any branch.
+     *
+     * Typical use case :
+     *  - You want to customize the default agent templates provided by FeatForge for all developers working on the project
+     *  - You want to stabilize the agent templates used in the project (not using FeatForge internal version)
+     *
+     * Note : They can be superceded by user-defined templates if placed in the local project .feat-forge folder, so a developer can still customize them locally if needed without affecting the rest of the team.
+     */
+    async installAgentTemplateLocally(targetRepository, options = {}) {
+        const { deleteExisting = false, dryRun = true, overwrite = false } = options;
+        const templateAgentDir = targetRepository.getAgentTemplatePath();
+        if (deleteExisting) {
+            if (!dryRun) {
+                await rm(templateAgentDir, { recursive: true, force: true });
+            }
+        }
+        await ensureDir(templateAgentDir);
+        // basically copy every files in the TEMPLATE_AGENT_PATH folder (with subdirectories)  to templateAgentDir
+        const fileChanges = await copyFilesRecursively(SOURCE_TEMPLATE_AGENT_PATH, templateAgentDir, { overwrite, dryRun });
+        return fileChanges;
+    }
+    async ensureBranch(branchName, baseBranch) {
+        let totalChanges = 0;
+        for (const repo of this.repositories) {
+            totalChanges += await repo.createBranch(branchName, baseBranch);
+        }
+        return totalChanges;
+    }
+    /**
+     * Look for any worktree that matches the branch but whose path does not exist (orphaned worktree), and remove it.
+     */
+    async cleanOrphanedWorktrees(branchName) {
+        // We look at all context repositories to find any worktree that matches the branch but
+        // whose path does not exist (orphaned worktree), and we remove it.
+        for (const repo of this.repositories) {
+            await repo.cleanOrphanedWorktree(branchName);
+        }
+    }
+}

package/dist/foundation/NpmHelper.js

@@ -0,0 +1,131 @@
+import { execa } from 'execa';
+import { readFile } from 'fs/promises';
+import path from 'path';
+import { pathExists } from '../lib/fs.js';
+import { paramsToEnv } from '../lib/env.js';
+/**
+ * Helper class to manage npm scripts for forge repositories
+ * Provides methods for discovering and executing npm scripts with the configured prefix
+ */
+export class NpmHelper {
+    forgeContext;
+    repository;
+    packageManager;
+    constructor(forgeContext, repository) {
+        this.forgeContext = forgeContext;
+        this.repository = repository;
+    }
+    /**
+     * Initialize the package manager detection
+     * Must be called before executing any scripts
+     */
+    async initialize() {
+        if (this.packageManager)
+            return;
+        if (await pathExists(path.join(this.repository.path, 'pnpm-lock.yaml'))) {
+            this.packageManager = 'pnpm';
+        }
+        else if (await pathExists(path.join(this.repository.path, 'yarn.lock'))) {
+            this.packageManager = 'yarn';
+        }
+        else {
+            this.packageManager = 'npm';
+        }
+    }
+    /**
+     * Read and parse package.json from the repository
+     */
+    async readPackageJson() {
+        if (process.env.VITEST)
+            return null; // Skip reading package.json during tests to avoid filesystem dependencies
+        const packageJsonPath = path.join(this.repository.path, 'package.json');
+        if (!(await pathExists(packageJsonPath))) {
+            return null;
+        }
+        try {
+            const content = await readFile(packageJsonPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            console.error(`Failed to read package.json at ${packageJsonPath}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Discover npm scripts matching the configured prefix
+     * Returns script names like 'feat-forge:bootstrap', 'feat-forge:hooks:postBranchStart', etc.
+     */
+    async discoverNpmScripts(subPart, allowMany = false) {
+        const packageJson = await this.readPackageJson();
+        if (!packageJson || !packageJson.scripts) {
+            return [];
+        }
+        const prefix = this.forgeContext.options.process.npmScriptPrefix;
+        const search = `${prefix}:${subPart ? subPart : ''}`;
+        return Object.keys(packageJson.scripts)
+            .filter((scriptName) => scriptName === search || (allowMany && scriptName.startsWith(search + '_')))
+            .sort();
+    }
+    /**
+     * Execute an npm script in the repository
+     * Uses the package manager detected during initialization
+     */
+    async executeNpmScript(scriptName, params) {
+        const packageJson = await this.readPackageJson();
+        if (!packageJson || !packageJson.scripts || !packageJson.scripts[scriptName]) {
+            return false;
+        }
+        console.log(`🔄 Executing npm script: ${scriptName}`);
+        await this.initialize();
+        try {
+            const hookEnv = paramsToEnv(params);
+            await execa(this.packageManager, ['run', scriptName], {
+                cwd: this.repository.path,
+                stdio: 'inherit',
+                env: {
+                    ...process.env,
+                    ...hookEnv,
+                },
+            });
+            console.log(`✅ ${this.packageManager} script ${scriptName} completed successfully`);
+            return true;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`❌ ${this.packageManager} script ${scriptName} failed: ${message}`);
+            throw error;
+        }
+    }
+    async executeNpmScripts(scriptNames, params) {
+        if (scriptNames.length === 0) {
+            return [];
+        }
+        await this.initialize();
+        const executedScripts = [];
+        for (const scriptName of scriptNames) {
+            try {
+                await this.executeNpmScript(scriptName, params);
+                executedScripts.push(scriptName);
+            }
+            catch (error) {
+                throw new Error(`${this.packageManager} script ${scriptName} failed in ${this.repository.name}`);
+            }
+        }
+        return executedScripts;
+    }
+    /**
+     * Execute the npm bootstrap script if it exists
+     * Looks for a script named prefix:bootstrap (e.g., 'feat-forge:bootstrap')
+     */
+    async executeNpmBootstrapScript(params) {
+        return this.executeNpmScripts(await this.discoverNpmScripts('bootstrap', false), params);
+    }
+    /**
+     * Execute npm scripts for a specific event
+     * Discovers and executes scripts matching the pattern prefix:hooks:eventType
+     * (e.g., 'feat-forge:hooks:postBranchStart')
+     */
+    async executeNpmScriptsForEvent(eventType, params) {
+        return this.executeNpmScripts(await this.discoverNpmScripts('hooks:' + eventType, true), params);
+    }
+}