@hexabot-ai/cli 3.0.0-alpha.3

package/dist/commands/dev.js

@@ -0,0 +1,72 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import * as path from 'path';
+import chalk from 'chalk';
+import { loadProjectConfig, updateProjectConfig } from '../core/config.js';
+import { dockerCompose, generateComposeFiles, resolveComposeFile, } from '../core/docker.js';
+import { bootstrapEnvFile, resolveEnvExample } from '../core/env.js';
+import { detectPackageManager, normalizePackageManager, runPackageScript, } from '../core/package-manager.js';
+import { checkDocker } from '../core/prerequisites.js';
+import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
+import { parseServices } from '../utils/services.js';
+export const registerDevCommand = (program) => {
+    program
+        .command('dev')
+        .description('Run the current Hexabot project in development mode')
+        .option('--docker', 'Run using Docker')
+        .option('--services <list>', 'Comma-separated services or profiles to enable')
+        .option('-d, --detach', 'Detach Docker containers (Docker mode only)')
+        .option('--env <file>', 'Env file to use for local dev (default: .env)')
+        .option('--no-env-bootstrap', 'Skip env bootstrapping')
+        .option('--pm <npm|pnpm|yarn|bun>', 'Override package manager')
+        .action(async (options) => {
+        await runDev(options);
+    });
+};
+export const runDev = async (options = {}) => {
+    const projectRoot = path.resolve(options.cwd || process.cwd());
+    assertHexabotProject(projectRoot);
+    const config = loadProjectConfig(projectRoot);
+    const normalizedPm = normalizePackageManager(options.pm);
+    const pm = normalizedPm || config.packageManager || detectPackageManager(projectRoot);
+    if (config.packageManager !== pm) {
+        updateProjectConfig(projectRoot, { packageManager: pm });
+    }
+    const shouldBootstrap = options.envBootstrap !== false;
+    if (shouldBootstrap) {
+        if (options.docker) {
+            bootstrapEnvFile(projectRoot, config.env.dockerExample, config.env.docker);
+        }
+        else {
+            const envFile = options.env || config.env.local;
+            const envExample = resolveEnvExample(projectRoot, envFile, config.env.localExample);
+            bootstrapEnvFile(projectRoot, envExample, envFile);
+        }
+    }
+    if (options.docker) {
+        await runDockerDev(projectRoot, options, config);
+    }
+    else {
+        runPackageScript(pm, config.devScript, projectRoot);
+    }
+};
+const runDockerDev = async (projectRoot, options, config) => {
+    checkDocker({ silent: true });
+    ensureDockerFolder(projectRoot);
+    const servicesInput = parseServices(options.services || '');
+    const services = servicesInput.length
+        ? servicesInput
+        : config.docker.defaultServices;
+    const composeFile = resolveComposeFile(projectRoot, config.docker.composeFile);
+    const composeArgs = generateComposeFiles(composeFile, services, 'dev');
+    const upArgs = ['up', '--build'];
+    if (options.detach) {
+        upArgs.push('-d');
+    }
+    const composeCommand = `${composeArgs} ${upArgs.join(' ')}`.trim();
+    console.log(chalk.blue(`Starting Docker services${services.length ? ` (${services.join(', ')})` : ''}`));
+    dockerCompose(composeCommand);
+};

package/dist/commands/docker.js

@@ -0,0 +1,119 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import * as path from 'path';
+import { loadProjectConfig } from '../core/config.js';
+import { dockerCompose, generateComposeFiles, resolveComposeFile, } from '../core/docker.js';
+import { bootstrapEnvFile } from '../core/env.js';
+import { checkDocker } from '../core/prerequisites.js';
+import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
+import { parseServices } from '../utils/services.js';
+import { runStart } from './start.js';
+export const registerDockerCommand = (program) => {
+    const dockerCommand = program.command('docker').description('Docker helpers');
+    dockerCommand
+        .command('up')
+        .description('Start Docker services')
+        .option('--services <list>', 'Comma-separated services/profiles')
+        .option('-d, --detach', 'Run containers in the background')
+        .option('--build', 'Build images before starting')
+        .action((options) => runDockerCommand('up', options));
+    dockerCommand
+        .command('down')
+        .description('Stop Docker services')
+        .option('--services <list>', 'Comma-separated services/profiles')
+        .option('--volumes', 'Remove volumes')
+        .action((options) => runDockerCommand('down', options));
+    dockerCommand
+        .command('logs [service]')
+        .description('View Docker logs')
+        .option('-f, --follow', 'Follow logs')
+        .option('--since <time>', 'Only show logs since time (e.g. 1h)')
+        .action((service, options) => runDockerLogs(service, options));
+    dockerCommand
+        .command('ps')
+        .description('List running services')
+        .action(() => runDockerPs());
+    dockerCommand
+        .command('start')
+        .description('Start Docker services in production mode')
+        .option('--services <list>', 'Comma-separated services/profiles')
+        .option('-d, --detach', 'Run containers in the background')
+        .option('--build', 'Build images before starting')
+        .option('--env-bootstrap', 'Generate env files from *.example if missing')
+        .action(async (options) => {
+        await runStart({
+            docker: true,
+            services: options.services,
+            detach: options.detach,
+            build: options.build,
+            envBootstrap: options.envBootstrap,
+        });
+    });
+};
+const runDockerCommand = (lifecycle, options) => {
+    const projectRoot = path.resolve(process.cwd());
+    assertHexabotProject(projectRoot);
+    checkDocker({ silent: true });
+    const config = loadProjectConfig(projectRoot);
+    ensureDockerFolder(projectRoot);
+    const services = resolveServices(options.services, config);
+    const composeFile = resolveComposeFile(projectRoot, config.docker.composeFile);
+    const composeArgs = generateComposeFiles(composeFile, services, lifecycle === 'up' ? 'dev' : undefined);
+    if (lifecycle === 'up') {
+        bootstrapEnvFile(projectRoot, config.env.dockerExample, config.env.docker, {
+            quiet: true,
+        });
+        const commandArgs = ['up'];
+        if (options.build) {
+            commandArgs.push('--build');
+        }
+        if (options.detach) {
+            commandArgs.push('-d');
+        }
+        dockerCompose(`${composeArgs} ${commandArgs.join(' ')}`.trim());
+    }
+    else {
+        const commandArgs = ['down'];
+        if (options.volumes) {
+            commandArgs.push('-v');
+        }
+        dockerCompose(`${composeArgs} ${commandArgs.join(' ')}`.trim());
+    }
+};
+const runDockerLogs = (service, options) => {
+    const projectRoot = path.resolve(process.cwd());
+    assertHexabotProject(projectRoot);
+    checkDocker({ silent: true });
+    const config = loadProjectConfig(projectRoot);
+    ensureDockerFolder(projectRoot);
+    const composeFile = resolveComposeFile(projectRoot, config.docker.composeFile);
+    const composeArgs = generateComposeFiles(composeFile, config.docker.defaultServices, 'dev');
+    const args = ['logs'];
+    if (options.follow) {
+        args.push('-f');
+    }
+    if (options.since) {
+        args.push(`--since ${options.since}`);
+    }
+    if (service) {
+        args.push(service);
+    }
+    dockerCompose(`${composeArgs} ${args.join(' ')}`.trim());
+};
+const runDockerPs = () => {
+    const projectRoot = path.resolve(process.cwd());
+    assertHexabotProject(projectRoot);
+    checkDocker({ silent: true });
+    const config = loadProjectConfig(projectRoot);
+    ensureDockerFolder(projectRoot);
+    const composeFile = resolveComposeFile(projectRoot, config.docker.composeFile);
+    const composeArgs = generateComposeFiles(composeFile, config.docker.defaultServices, 'dev');
+    dockerCompose(`${composeArgs} ps`);
+};
+const resolveServices = (servicesInput, config) => {
+    const provided = parseServices(servicesInput || '');
+    return provided.length ? provided : config.docker.defaultServices;
+};

package/dist/commands/env.js

@@ -0,0 +1,44 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import * as path from 'path';
+import chalk from 'chalk';
+import { loadProjectConfig } from '../core/config.js';
+import { bootstrapEnvFile, listEnvStatus } from '../core/env.js';
+import { assertHexabotProject } from '../core/project.js';
+export const registerEnvCommand = (program) => {
+    const envCommand = program.command('env').description('Manage env files');
+    envCommand
+        .command('init')
+        .description('Copy *.example env files')
+        .option('--docker', 'Initialize Docker env file')
+        .option('--force', 'Overwrite existing env files')
+        .action((options) => {
+        const projectRoot = path.resolve(process.cwd());
+        assertHexabotProject(projectRoot);
+        const config = loadProjectConfig(projectRoot);
+        if (options.docker) {
+            bootstrapEnvFile(projectRoot, config.env.dockerExample, config.env.docker, { force: options.force });
+        }
+        else {
+            bootstrapEnvFile(projectRoot, config.env.localExample, config.env.local, {
+                force: options.force,
+            });
+        }
+    });
+    envCommand
+        .command('list')
+        .description('Show env file status')
+        .action(() => {
+        const projectRoot = path.resolve(process.cwd());
+        assertHexabotProject(projectRoot);
+        const config = loadProjectConfig(projectRoot);
+        const statuses = listEnvStatus(projectRoot, config);
+        statuses.forEach((status) => {
+            const symbol = status.exists ? chalk.green('✓') : chalk.red('✗');
+            console.log(`${symbol} ${status.file}`);
+        });
+    });
+};

package/dist/commands/migrate.js

@@ -0,0 +1,22 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { dockerExec } from '../core/docker.js';
+import { checkDocker } from '../core/prerequisites.js';
+import { ensureDockerFolder } from '../core/project.js';
+export const registerMigrateCommand = (program) => {
+    program
+        .command('migrate [args...]')
+        .description('Run database migrations')
+        .action((args = []) => {
+        checkDocker({ silent: true });
+        ensureDockerFolder();
+        const migrateArgs = args.join(' ').trim();
+        const command = migrateArgs
+            ? `npm run migrate ${migrateArgs}`
+            : 'npm run migrate';
+        dockerExec('api', command, '--user $(id -u):$(id -g)');
+    });
+};

package/dist/commands/start.js

@@ -0,0 +1,76 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import * as path from 'path';
+import chalk from 'chalk';
+import { loadProjectConfig, updateProjectConfig } from '../core/config.js';
+import { dockerCompose, generateComposeFiles, resolveComposeFile, } from '../core/docker.js';
+import { bootstrapEnvFile, resolveEnvExample } from '../core/env.js';
+import { detectPackageManager, normalizePackageManager, runPackageScript, } from '../core/package-manager.js';
+import { checkDocker } from '../core/prerequisites.js';
+import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
+import { parseServices } from '../utils/services.js';
+export const registerStartCommand = (program) => {
+    program
+        .command('start')
+        .description('Run the project in production mode')
+        .option('--docker', 'Run using Docker (production stack)')
+        .option('--services <list>', 'Comma-separated services/profiles to enable')
+        .option('-d, --detach', 'Detach Docker containers')
+        .option('--build', 'Build Docker images before starting')
+        .option('--env <file>', 'Env file to use (default: .env)')
+        .option('--env-bootstrap', 'Generate env files from *.example if missing')
+        .option('--pm <npm|pnpm|yarn|bun>', 'Override package manager')
+        .action(async (options) => {
+        await runStart(options);
+    });
+};
+export const runStart = async (options = {}) => {
+    const projectRoot = path.resolve(options.cwd || process.cwd());
+    assertHexabotProject(projectRoot);
+    const config = loadProjectConfig(projectRoot);
+    const normalizedPm = normalizePackageManager(options.pm);
+    const pm = normalizedPm || config.packageManager || detectPackageManager(projectRoot);
+    if (config.packageManager !== pm) {
+        updateProjectConfig(projectRoot, { packageManager: pm });
+    }
+    const shouldBootstrap = Boolean(options.envBootstrap);
+    if (shouldBootstrap) {
+        if (options.docker) {
+            bootstrapEnvFile(projectRoot, config.env.dockerExample, config.env.docker);
+        }
+        else {
+            const envFile = options.env || config.env.local;
+            const envExample = resolveEnvExample(projectRoot, envFile, config.env.localExample);
+            bootstrapEnvFile(projectRoot, envExample, envFile);
+        }
+    }
+    if (options.docker) {
+        await runDockerStart(projectRoot, options, config);
+    }
+    else {
+        runPackageScript(pm, config.startScript, projectRoot);
+    }
+};
+const runDockerStart = async (projectRoot, options, config) => {
+    checkDocker({ silent: true });
+    ensureDockerFolder(projectRoot);
+    const servicesInput = parseServices(options.services || '');
+    const services = servicesInput.length
+        ? servicesInput
+        : config.docker.defaultServices;
+    const composeFile = resolveComposeFile(projectRoot, config.docker.composeFile);
+    const composeArgs = generateComposeFiles(composeFile, services, 'prod');
+    const upArgs = ['up'];
+    if (options.build) {
+        upArgs.push('--build');
+    }
+    if (options.detach) {
+        upArgs.push('-d');
+    }
+    const composeCommand = `${composeArgs} ${upArgs.join(' ')}`.trim();
+    console.log(chalk.blue(`Starting Docker services in production mode${services.length ? ` (${services.join(', ')})` : ''}`));
+    dockerCompose(composeCommand);
+};

package/dist/core/__tests__/config.test.js

@@ -0,0 +1,88 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ensureProjectConfig, loadProjectConfig, resolveConfigPath, updateProjectConfig, } from '../config.js';
+describe('project config helpers', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hexabot-config-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('loads default values when the config file is missing', () => {
+        const config = loadProjectConfig(tempDir);
+        expect(config).toMatchObject({
+            devScript: 'dev',
+            startScript: 'start',
+            docker: {
+                composeFile: 'docker/docker-compose.yml',
+                defaultServices: [],
+            },
+            env: {
+                local: '.env',
+                localExample: '.env.example',
+                docker: '.env.docker',
+                dockerExample: '.env.docker.example',
+            },
+        });
+    });
+    it('merges overrides from the config file', () => {
+        const override = {
+            devScript: 'custom-dev',
+            docker: {
+                composeFile: 'docker/compose.override.yml',
+                defaultServices: ['api', 'postgres'],
+            },
+            env: {
+                local: '.env.dev',
+                localExample: '.env.example',
+                docker: '.env.docker',
+                dockerExample: '.env.docker.example',
+            },
+        };
+        fs.writeFileSync(resolveConfigPath(tempDir), JSON.stringify(override));
+        const config = loadProjectConfig(tempDir);
+        expect(config.devScript).toBe('custom-dev');
+        expect(config.docker).toMatchObject({
+            composeFile: 'docker/compose.override.yml',
+            defaultServices: ['api', 'postgres'],
+        });
+        expect(config.env.local).toBe('.env.dev');
+        expect(config.env.localExample).toBe('.env.example');
+    });
+    it('creates a config file when ensuring one with overrides', () => {
+        const overrides = {
+            packageManager: 'pnpm',
+            env: {
+                local: '.env.dev',
+                localExample: '.env.example',
+                docker: '.env.docker',
+                dockerExample: '.env.docker.example',
+            },
+        };
+        const config = ensureProjectConfig(tempDir, overrides);
+        expect(config.packageManager).toBe('pnpm');
+        expect(JSON.parse(fs.readFileSync(resolveConfigPath(tempDir), 'utf-8'))).toMatchObject({
+            packageManager: 'pnpm',
+            env: expect.objectContaining({ local: '.env.dev' }),
+        });
+    });
+    it('updates existing config files by merging overrides', () => {
+        fs.writeFileSync(resolveConfigPath(tempDir), JSON.stringify({ startScript: 'serve' }));
+        const updated = updateProjectConfig(tempDir, {
+            docker: {
+                composeFile: 'docker/docker-compose.yml',
+                defaultServices: ['api'],
+            },
+        });
+        expect(updated.startScript).toBe('serve');
+        expect(updated.docker.defaultServices).toEqual(['api']);
+        expect(updated.env.local).toBe('.env');
+    });
+});

package/dist/core/__tests__/docker.test.js

@@ -0,0 +1,43 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { jest } from '@jest/globals';
+import { generateComposeFiles } from '../docker.js';
+describe('generateComposeFiles', () => {
+    let tempDir;
+    let composeFile;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hexabot-docker-'));
+        composeFile = path.join(tempDir, 'docker-compose.yml');
+        fs.writeFileSync(composeFile, '');
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('builds the compose file list for provided services', () => {
+        const apiFile = path.join(tempDir, 'docker-compose.api.yml');
+        const dbFile = path.join(tempDir, 'docker-compose.db.yml');
+        fs.writeFileSync(apiFile, '');
+        fs.writeFileSync(dbFile, '');
+        const result = generateComposeFiles(composeFile, ['api', 'db']);
+        expect(result).toBe(`-f ${composeFile} ` + `-f ${apiFile} ` + `-f ${dbFile}`);
+    });
+    it('includes mode specific service and main files when they exist', () => {
+        const apiFile = path.join(tempDir, 'docker-compose.api.yml');
+        const serviceModeFile = path.join(tempDir, 'docker-compose.api.dev.yml');
+        const mainModeFile = path.join(tempDir, 'docker-compose.dev.yml');
+        fs.writeFileSync(apiFile, '');
+        fs.writeFileSync(serviceModeFile, '');
+        fs.writeFileSync(mainModeFile, '');
+        const result = generateComposeFiles(composeFile, ['api'], 'dev');
+        expect(result).toBe(`-f ${composeFile} ` +
+            `-f ${apiFile} ` +
+            `-f ${serviceModeFile} -f ${mainModeFile}`);
+    });
+});

package/dist/core/__tests__/env.test.js

@@ -0,0 +1,71 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { jest } from '@jest/globals';
+import { bootstrapEnvFile, listEnvStatus, resolveEnvExample } from '../env.js';
+describe('env helpers', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hexabot-env-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+        jest.restoreAllMocks();
+    });
+    it('copies the example env file when the target is missing', () => {
+        const example = '.env.example';
+        const target = '.env';
+        fs.writeFileSync(path.join(tempDir, example), 'KEY=value');
+        const result = bootstrapEnvFile(tempDir, example, target);
+        expect(result).toBe(true);
+        expect(fs.readFileSync(path.join(tempDir, target), 'utf-8')).toBe('KEY=value');
+    });
+    it('skips copying when the target exists unless forced', () => {
+        const example = '.env.example';
+        const target = '.env';
+        fs.writeFileSync(path.join(tempDir, example), 'NEW=value');
+        fs.writeFileSync(path.join(tempDir, target), 'OLD=value');
+        const logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        const skipped = bootstrapEnvFile(tempDir, example, target, {
+            quiet: false,
+        });
+        expect(skipped).toBe(false);
+        expect(fs.readFileSync(path.join(tempDir, target), 'utf-8')).toBe('OLD=value');
+        expect(logSpy).toHaveBeenCalled();
+        const forced = bootstrapEnvFile(tempDir, example, target, { force: true });
+        expect(forced).toBe(true);
+        expect(fs.readFileSync(path.join(tempDir, target), 'utf-8')).toBe('NEW=value');
+    });
+    it('lists env file statuses using the provided config', () => {
+        const config = {
+            env: {
+                local: '.env',
+                localExample: '.env.example',
+                docker: '.env.docker',
+                dockerExample: '.env.docker.example',
+            },
+        };
+        fs.writeFileSync(path.join(tempDir, '.env.example'), '');
+        fs.writeFileSync(path.join(tempDir, '.env'), '');
+        const statuses = listEnvStatus(tempDir, config);
+        expect(statuses).toEqual([
+            expect.objectContaining({ file: '.env.example', exists: true }),
+            expect.objectContaining({ file: '.env', exists: true }),
+            expect.objectContaining({ file: '.env.docker.example', exists: false }),
+            expect.objectContaining({ file: '.env.docker', exists: false }),
+        ]);
+    });
+    it('resolves env example files relative to the project root', () => {
+        const envFile = '.env.local';
+        const defaultExample = '.env.example';
+        const examplePath = path.join(tempDir, `${envFile}.example`);
+        fs.writeFileSync(examplePath, '');
+        expect(resolveEnvExample(tempDir, envFile, defaultExample)).toBe(`${envFile}.example`);
+        expect(resolveEnvExample(tempDir, '.missing', defaultExample)).toBe(defaultExample);
+    });
+});

package/dist/core/__tests__/package-manager.test.js

@@ -0,0 +1,95 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { jest } from '@jest/globals';
+const readPackageJson = jest.fn();
+const execSync = jest.fn();
+jest.unstable_mockModule('../project.js', () => ({
+    readPackageJson,
+}));
+jest.unstable_mockModule('child_process', () => ({
+    execSync,
+}));
+let normalizePackageManager;
+let detectPackageManager;
+let runPackageScript;
+let installDependencies;
+beforeAll(async () => {
+    ({
+        normalizePackageManager,
+        detectPackageManager,
+        runPackageScript,
+        installDependencies,
+    } = await import('../package-manager.js'));
+});
+afterEach(() => {
+    jest.resetAllMocks();
+});
+describe('normalizePackageManager', () => {
+    it('returns normalized package manager names', () => {
+        expect(normalizePackageManager('PNPM')).toBe('pnpm');
+        expect(normalizePackageManager(undefined)).toBeUndefined();
+    });
+    it('exits when the package manager is unsupported', () => {
+        const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => {
+            throw new Error('exit:1');
+        }));
+        jest.spyOn(console, 'error').mockImplementation(() => { });
+        expect(() => normalizePackageManager('foo')).toThrow('exit:1');
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+});
+describe('detectPackageManager', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hexabot-pm-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('detects the package manager based on lockfiles', () => {
+        fs.writeFileSync(path.join(tempDir, 'pnpm-lock.yaml'), '');
+        expect(detectPackageManager(tempDir)).toBe('pnpm');
+    });
+    it('falls back to npm when no lockfiles are found', () => {
+        expect(detectPackageManager(tempDir)).toBe('npm');
+    });
+});
+describe('installDependencies & runPackageScript', () => {
+    const projectRoot = '/tmp/project';
+    beforeEach(() => {
+        readPackageJson.mockReturnValue({
+            scripts: {
+                build: 'tsc',
+            },
+        });
+    });
+    it('runs installation commands for the chosen package manager', () => {
+        installDependencies('yarn', projectRoot);
+        expect(execSync).toHaveBeenCalledWith('yarn install', {
+            cwd: projectRoot,
+            stdio: 'inherit',
+        });
+    });
+    it('runs package scripts after ensuring the script exists', () => {
+        runPackageScript('pnpm', 'build', projectRoot, ['--watch']);
+        expect(execSync).toHaveBeenCalledWith('pnpm run build -- --watch', {
+            cwd: projectRoot,
+            stdio: 'inherit',
+        });
+    });
+    it('exits when the script is missing from package.json', () => {
+        readPackageJson.mockReturnValue({ scripts: {} });
+        const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => {
+            throw new Error('exit:1');
+        }));
+        jest.spyOn(console, 'error').mockImplementation(() => { });
+        expect(() => runPackageScript('npm', 'dev', projectRoot)).toThrow('exit:1');
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+});