@hexabot-ai/cli 3.6.0 → 3.7.0-beta.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -4,14 +4,11 @@
4
4
  * Full terms: see LICENSE.md.
5
5
  */
6
6
  import * as path from 'path';
7
- import chalk from 'chalk';
8
- import { loadProjectConfig, updateProjectConfig } from '../core/config.js';
9
- import { dockerCompose, generateComposeFiles, resolveComposeEnvFile, resolveComposeFile, } from '../core/docker.js';
10
- import { bootstrapEnvFile, resolveEnvExample } from '../core/env.js';
11
- import { detectPackageManager, normalizePackageManager, runPackageScript, } from '../core/package-manager.js';
12
- import { checkDocker } from '../core/prerequisites.js';
13
- import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
14
- import { parseServices } from '../utils/services.js';
7
+ import { runProjectCompose } from '../core/compose.js';
8
+ import { loadProjectConfig } from '../core/config.js';
9
+ import { runPackageScript } from '../core/package-manager.js';
10
+ import { bootstrapProjectEnv, resolveProjectPackageManager, } from '../core/project-run.js';
11
+ import { assertHexabotProject } from '../core/project.js';
15
12
  export const registerDevCommand = (program) => {
16
13
  program
17
14
  .command('dev')
@@ -30,44 +27,23 @@ export const runDev = async (options = {}) => {
30
27
  const projectRoot = path.resolve(options.cwd || process.cwd());
31
28
  assertHexabotProject(projectRoot);
32
29
  const config = loadProjectConfig(projectRoot);
33
- const normalizedPm = normalizePackageManager(options.pm);
34
- const pm = normalizedPm || config.packageManager || detectPackageManager(projectRoot);
35
- if (config.packageManager !== pm) {
36
- updateProjectConfig(projectRoot, { packageManager: pm });
37
- }
38
- const shouldBootstrap = options.envBootstrap !== false;
39
- if (shouldBootstrap) {
40
- if (options.docker) {
41
- bootstrapEnvFile(projectRoot, config.env.dockerExample, config.env.docker);
42
- }
43
- else {
44
- const envFile = options.env || config.env.local;
45
- const envExample = resolveEnvExample(projectRoot, envFile, config.env.localExample);
46
- bootstrapEnvFile(projectRoot, envExample, envFile);
47
- }
30
+ const pm = resolveProjectPackageManager(projectRoot, config, options.pm);
31
+ if (options.envBootstrap !== false) {
32
+ bootstrapProjectEnv(projectRoot, config, options);
48
33
  }
49
34
  if (options.docker) {
50
- await runDockerDev(projectRoot, options, config);
35
+ const upArgs = ['up', '--build'];
36
+ if (options.detach) {
37
+ upArgs.push('-d');
38
+ }
39
+ runProjectCompose(projectRoot, config, {
40
+ services: options.services,
41
+ mode: 'dev',
42
+ args: upArgs,
43
+ action: 'Starting Docker services',
44
+ });
51
45
  }
52
46
  else {
53
47
  runPackageScript(pm, config.devScript, projectRoot);
54
48
  }
55
49
  };
56
- const runDockerDev = async (projectRoot, options, config) => {
57
- checkDocker({ silent: true });
58
- ensureDockerFolder(projectRoot);
59
- const servicesInput = parseServices(options.services || '');
60
- const services = servicesInput.length
61
- ? servicesInput
62
- : config.docker.defaultServices;
63
- const composeFile = resolveComposeFile(projectRoot, config.docker.composeFile);
64
- const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
65
- const composeArgs = generateComposeFiles(composeFile, services, 'dev');
66
- const upArgs = ['up', '--build'];
67
- if (options.detach) {
68
- upArgs.push('-d');
69
- }
70
- const composeCommand = `${composeArgs} ${upArgs.join(' ')}`.trim();
71
- console.log(chalk.blue(`Starting Docker services${services.length ? ` (${services.join(', ')})` : ''}`));
72
- dockerCompose(composeCommand, { envFile });
73
- };
@@ -4,14 +4,11 @@
4
4
  * Full terms: see LICENSE.md.
5
5
  */
6
6
  import * as path from 'path';
7
- import chalk from 'chalk';
8
- import { loadProjectConfig, updateProjectConfig } from '../core/config.js';
9
- import { dockerCompose, generateComposeFiles, resolveComposeEnvFile, resolveComposeFile, } from '../core/docker.js';
10
- import { bootstrapEnvFile, resolveEnvExample } from '../core/env.js';
11
- import { detectPackageManager, normalizePackageManager, runPackageScript, } from '../core/package-manager.js';
12
- import { checkDocker } from '../core/prerequisites.js';
13
- import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
14
- import { parseServices } from '../utils/services.js';
7
+ import { runProjectCompose } from '../core/compose.js';
8
+ import { loadProjectConfig } from '../core/config.js';
9
+ import { runPackageScript } from '../core/package-manager.js';
10
+ import { bootstrapProjectEnv, resolveProjectPackageManager, } from '../core/project-run.js';
11
+ import { assertHexabotProject } from '../core/project.js';
15
12
  export const registerStartCommand = (program) => {
16
13
  program
17
14
  .command('start')
@@ -31,47 +28,26 @@ export const runStart = async (options = {}) => {
31
28
  const projectRoot = path.resolve(options.cwd || process.cwd());
32
29
  assertHexabotProject(projectRoot);
33
30
  const config = loadProjectConfig(projectRoot);
34
- const normalizedPm = normalizePackageManager(options.pm);
35
- const pm = normalizedPm || config.packageManager || detectPackageManager(projectRoot);
36
- if (config.packageManager !== pm) {
37
- updateProjectConfig(projectRoot, { packageManager: pm });
31
+ const pm = resolveProjectPackageManager(projectRoot, config, options.pm);
32
+ if (options.envBootstrap) {
33
+ bootstrapProjectEnv(projectRoot, config, options);
38
34
  }
39
- const shouldBootstrap = Boolean(options.envBootstrap);
40
- if (shouldBootstrap) {
41
- if (options.docker) {
42
- bootstrapEnvFile(projectRoot, config.env.dockerExample, config.env.docker);
35
+ if (options.docker) {
36
+ const upArgs = ['up'];
37
+ if (options.build) {
38
+ upArgs.push('--build');
43
39
  }
44
- else {
45
- const envFile = options.env || config.env.local;
46
- const envExample = resolveEnvExample(projectRoot, envFile, config.env.localExample);
47
- bootstrapEnvFile(projectRoot, envExample, envFile);
40
+ if (options.detach) {
41
+ upArgs.push('-d');
48
42
  }
49
- }
50
- if (options.docker) {
51
- await runDockerStart(projectRoot, options, config);
43
+ runProjectCompose(projectRoot, config, {
44
+ services: options.services,
45
+ mode: 'prod',
46
+ args: upArgs,
47
+ action: 'Starting Docker services in production mode',
48
+ });
52
49
  }
53
50
  else {
54
51
  runPackageScript(pm, config.startScript, projectRoot);
55
52
  }
56
53
  };
57
- const runDockerStart = async (projectRoot, options, config) => {
58
- checkDocker({ silent: true });
59
- ensureDockerFolder(projectRoot);
60
- const servicesInput = parseServices(options.services || '');
61
- const services = servicesInput.length
62
- ? servicesInput
63
- : config.docker.defaultServices;
64
- const composeFile = resolveComposeFile(projectRoot, config.docker.composeFile);
65
- const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
66
- const composeArgs = generateComposeFiles(composeFile, services, 'prod');
67
- const upArgs = ['up'];
68
- if (options.build) {
69
- upArgs.push('--build');
70
- }
71
- if (options.detach) {
72
- upArgs.push('-d');
73
- }
74
- const composeCommand = `${composeArgs} ${upArgs.join(' ')}`.trim();
75
- console.log(chalk.blue(`Starting Docker services in production mode${services.length ? ` (${services.join(', ')})` : ''}`));
76
- dockerCompose(composeCommand, { envFile });
77
- };
@@ -5,11 +5,9 @@
5
5
  */
6
6
  import * as path from 'path';
7
7
  import chalk from 'chalk';
8
+ import { runProjectCompose } from '../core/compose.js';
8
9
  import { loadProjectConfig } from '../core/config.js';
9
- import { dockerCompose, generateComposeFiles, resolveComposeEnvFile, resolveComposeFile, } from '../core/docker.js';
10
- import { checkDocker } from '../core/prerequisites.js';
11
- import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
12
- import { parseServices } from '../utils/services.js';
10
+ import { assertHexabotProject } from '../core/project.js';
13
11
  export const registerStopCommand = (program) => {
14
12
  program
15
13
  .command('stop')
@@ -31,18 +29,6 @@ export const runStop = async (options = {}) => {
31
29
  process.exit(1);
32
30
  }
33
31
  const config = loadProjectConfig(projectRoot);
34
- await runDockerStop(projectRoot, options, config);
35
- };
36
- const runDockerStop = async (projectRoot, options, config) => {
37
- checkDocker({ silent: true });
38
- ensureDockerFolder(projectRoot);
39
- const servicesInput = parseServices(options.services || '');
40
- const services = servicesInput.length
41
- ? servicesInput
42
- : config.docker.defaultServices;
43
- const composeFile = resolveComposeFile(projectRoot, config.docker.composeFile);
44
- const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
45
- const composeArgs = generateComposeFiles(composeFile, services);
46
32
  const downArgs = ['down'];
47
33
  if (options.volumes) {
48
34
  downArgs.push('--volumes');
@@ -50,7 +36,9 @@ const runDockerStop = async (projectRoot, options, config) => {
50
36
  if (options.removeOrphans) {
51
37
  downArgs.push('--remove-orphans');
52
38
  }
53
- const composeCommand = `${composeArgs} ${downArgs.join(' ')}`.trim();
54
- console.log(chalk.blue(`Stopping Docker services${services.length ? ` (${services.join(', ')})` : ''}`));
55
- dockerCompose(composeCommand, { envFile });
39
+ runProjectCompose(projectRoot, config, {
40
+ services: options.services,
41
+ args: downArgs,
42
+ action: 'Stopping Docker services',
43
+ });
56
44
  };
@@ -0,0 +1,30 @@
1
+ /*
2
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
3
+ * Copyright (c) 2026 Hexastack.
4
+ * Full terms: see LICENSE.md.
5
+ */
6
+ import chalk from 'chalk';
7
+ import { parseServices } from '../utils/services.js';
8
+ import { dockerCompose, generateComposeFiles, resolveComposeEnvFile, resolveComposeFile, } from './docker.js';
9
+ import { checkDocker } from './prerequisites.js';
10
+ import { ensureDockerFolder } from './project.js';
11
+ /**
12
+ * Runs `docker compose <args>` over the project's compose files for the
13
+ * requested services, or the configured default services.
14
+ */
15
+ export const runProjectCompose = (projectRoot, config, { services: servicesOption, mode, args, action, }) => {
16
+ checkDocker({ silent: true });
17
+ ensureDockerFolder(projectRoot);
18
+ const servicesInput = parseServices(servicesOption || '');
19
+ const services = servicesInput.length
20
+ ? servicesInput
21
+ : config.docker.defaultServices;
22
+ const composeFile = resolveComposeFile(projectRoot, config.docker.composeFile);
23
+ const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
24
+ const composeArgs = mode
25
+ ? generateComposeFiles(composeFile, services, mode)
26
+ : generateComposeFiles(composeFile, services);
27
+ const composeCommand = `${composeArgs} ${args.join(' ')}`.trim();
28
+ console.log(chalk.blue(`${action}${services.length ? ` (${services.join(', ')})` : ''}`));
29
+ dockerCompose(composeCommand, { envFile });
30
+ };
@@ -52,7 +52,7 @@ export const ensureProjectConfig = (projectRoot = process.cwd(), overrides = {})
52
52
  }
53
53
  return loadProjectConfig(projectRoot);
54
54
  };
55
- export const writeProjectConfig = (config, projectRoot = process.cwd()) => {
55
+ const writeProjectConfig = (config, projectRoot = process.cwd()) => {
56
56
  const configPath = resolveConfigPath(projectRoot);
57
57
  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
58
58
  };
@@ -0,0 +1,31 @@
1
+ /*
2
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
3
+ * Copyright (c) 2026 Hexastack.
4
+ * Full terms: see LICENSE.md.
5
+ */
6
+ import { updateProjectConfig } from './config.js';
7
+ import { bootstrapEnvFile, resolveEnvExample } from './env.js';
8
+ import { detectPackageManager, normalizePackageManager, } from './package-manager.js';
9
+ /**
10
+ * Picks the package manager (`--pm`, then the project config, then the
11
+ * lockfile) and records it in the project config.
12
+ */
13
+ export const resolveProjectPackageManager = (projectRoot, config, pmOption) => {
14
+ const pm = normalizePackageManager(pmOption) ||
15
+ config.packageManager ||
16
+ detectPackageManager(projectRoot);
17
+ if (config.packageManager !== pm) {
18
+ updateProjectConfig(projectRoot, { packageManager: pm });
19
+ }
20
+ return pm;
21
+ };
22
+ /** Creates the Docker or local env file from its example when it is missing. */
23
+ export const bootstrapProjectEnv = (projectRoot, config, options) => {
24
+ if (options.docker) {
25
+ bootstrapEnvFile(projectRoot, config.env.dockerExample, config.env.docker);
26
+ return;
27
+ }
28
+ const envFile = options.env || config.env.local;
29
+ const envExample = resolveEnvExample(projectRoot, envFile, config.env.localExample);
30
+ bootstrapEnvFile(projectRoot, envExample, envFile);
31
+ };
@@ -8,9 +8,6 @@ import * as path from 'path';
8
8
  import chalk from 'chalk';
9
9
  const DOCKER_FOLDER_NAME = 'docker';
10
10
  const HEXABOT_PACKAGE = '@hexabot-ai/api';
11
- export const resolveProjectRoot = (cwd = process.cwd()) => {
12
- return path.resolve(cwd);
13
- };
14
11
  export const readPackageJson = (projectRoot = process.cwd()) => {
15
12
  try {
16
13
  const packageJsonPath = path.join(projectRoot, 'package.json');
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@hexabot-ai/cli",
3
- "version": "3.6.0",
3
+ "version": "3.7.0-beta.0",
4
4
  "description": "Official Hexabot CLI for creating and managing AI chatbot/agent projects built with Hexabot.",
5
5
  "main": "dist/index.js",
6
6
  "type": "module",
@@ -25,6 +25,7 @@
25
25
  "figlet": "^1.12.0"
26
26
  },
27
27
  "devDependencies": {
28
+ "@eslint/eslintrc": "^3.3.1",
28
29
  "@jest/globals": "^30.4.1",
29
30
  "@types/figlet": "^1.5.8",
30
31
  "@types/jest": "^30.0.0",
@@ -37,6 +38,7 @@
37
38
  "eslint-plugin-header": "^3.1.1",
38
39
  "eslint-plugin-import": "^2.32.0",
39
40
  "eslint-plugin-prettier": "^5.5.4",
41
+ "globals": "^14.0.0",
40
42
  "jest": "^30.2.0",
41
43
  "lint-staged": "^15.3.0",
42
44
  "prettier": "^3.6.2",
@@ -6,25 +6,16 @@
6
6
 
7
7
  import * as path from 'path';
8
8
 
9
- import chalk from 'chalk';
10
9
  import { Command } from 'commander';
11
10
 
12
- import { loadProjectConfig, updateProjectConfig } from '../core/config.js';
11
+ import { runProjectCompose } from '../core/compose.js';
12
+ import { loadProjectConfig } from '../core/config.js';
13
+ import { runPackageScript } from '../core/package-manager.js';
13
14
  import {
14
- dockerCompose,
15
- generateComposeFiles,
16
- resolveComposeEnvFile,
17
- resolveComposeFile,
18
- } from '../core/docker.js';
19
- import { bootstrapEnvFile, resolveEnvExample } from '../core/env.js';
20
- import {
21
- detectPackageManager,
22
- normalizePackageManager,
23
- runPackageScript,
24
- } from '../core/package-manager.js';
25
- import { checkDocker } from '../core/prerequisites.js';
26
- import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
27
- import { parseServices } from '../utils/services.js';
15
+ bootstrapProjectEnv,
16
+ resolveProjectPackageManager,
17
+ } from '../core/project-run.js';
18
+ import { assertHexabotProject } from '../core/project.js';
28
19
 
29
20
  export interface DevOptions {
30
21
  docker?: boolean;
@@ -58,67 +49,25 @@ export const runDev = async (options: DevOptions = {}) => {
58
49
  const projectRoot = path.resolve(options.cwd || process.cwd());
59
50
  assertHexabotProject(projectRoot);
60
51
  const config = loadProjectConfig(projectRoot);
61
- const normalizedPm = normalizePackageManager(options.pm);
62
- const pm =
63
- normalizedPm || config.packageManager || detectPackageManager(projectRoot);
52
+ const pm = resolveProjectPackageManager(projectRoot, config, options.pm);
64
53
 
65
- if (config.packageManager !== pm) {
66
- updateProjectConfig(projectRoot, { packageManager: pm });
54
+ if (options.envBootstrap !== false) {
55
+ bootstrapProjectEnv(projectRoot, config, options);
67
56
  }
68
57
 
69
- const shouldBootstrap = options.envBootstrap !== false;
70
- if (shouldBootstrap) {
71
- if (options.docker) {
72
- bootstrapEnvFile(
73
- projectRoot,
74
- config.env.dockerExample,
75
- config.env.docker,
76
- );
77
- } else {
78
- const envFile = options.env || config.env.local;
79
- const envExample = resolveEnvExample(
80
- projectRoot,
81
- envFile,
82
- config.env.localExample,
83
- );
84
- bootstrapEnvFile(projectRoot, envExample, envFile);
58
+ if (options.docker) {
59
+ const upArgs = ['up', '--build'];
60
+ if (options.detach) {
61
+ upArgs.push('-d');
85
62
  }
86
- }
87
63
 
88
- if (options.docker) {
89
- await runDockerDev(projectRoot, options, config);
64
+ runProjectCompose(projectRoot, config, {
65
+ services: options.services,
66
+ mode: 'dev',
67
+ args: upArgs,
68
+ action: 'Starting Docker services',
69
+ });
90
70
  } else {
91
71
  runPackageScript(pm, config.devScript, projectRoot);
92
72
  }
93
73
  };
94
-
95
- const runDockerDev = async (
96
- projectRoot: string,
97
- options: DevOptions,
98
- config: ReturnType<typeof loadProjectConfig>,
99
- ) => {
100
- checkDocker({ silent: true });
101
- ensureDockerFolder(projectRoot);
102
- const servicesInput = parseServices(options.services || '');
103
- const services = servicesInput.length
104
- ? servicesInput
105
- : config.docker.defaultServices;
106
- const composeFile = resolveComposeFile(
107
- projectRoot,
108
- config.docker.composeFile,
109
- );
110
- const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
111
- const composeArgs = generateComposeFiles(composeFile, services, 'dev');
112
- const upArgs = ['up', '--build'];
113
- if (options.detach) {
114
- upArgs.push('-d');
115
- }
116
-
117
- const composeCommand = `${composeArgs} ${upArgs.join(' ')}`.trim();
118
- console.log(
119
- chalk.blue(
120
- `Starting Docker services${services.length ? ` (${services.join(', ')})` : ''}`,
121
- ),
122
- );
123
- dockerCompose(composeCommand, { envFile });
124
- };
@@ -6,25 +6,16 @@
6
6
 
7
7
  import * as path from 'path';
8
8
 
9
- import chalk from 'chalk';
10
9
  import { Command } from 'commander';
11
10
 
12
- import { loadProjectConfig, updateProjectConfig } from '../core/config.js';
11
+ import { runProjectCompose } from '../core/compose.js';
12
+ import { loadProjectConfig } from '../core/config.js';
13
+ import { runPackageScript } from '../core/package-manager.js';
13
14
  import {
14
- dockerCompose,
15
- generateComposeFiles,
16
- resolveComposeEnvFile,
17
- resolveComposeFile,
18
- } from '../core/docker.js';
19
- import { bootstrapEnvFile, resolveEnvExample } from '../core/env.js';
20
- import {
21
- detectPackageManager,
22
- normalizePackageManager,
23
- runPackageScript,
24
- } from '../core/package-manager.js';
25
- import { checkDocker } from '../core/prerequisites.js';
26
- import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
27
- import { parseServices } from '../utils/services.js';
15
+ bootstrapProjectEnv,
16
+ resolveProjectPackageManager,
17
+ } from '../core/project-run.js';
18
+ import { assertHexabotProject } from '../core/project.js';
28
19
 
29
20
  export interface StartOptions {
30
21
  docker?: boolean;
@@ -57,72 +48,28 @@ export const runStart = async (options: StartOptions = {}) => {
57
48
  const projectRoot = path.resolve(options.cwd || process.cwd());
58
49
  assertHexabotProject(projectRoot);
59
50
  const config = loadProjectConfig(projectRoot);
60
- const normalizedPm = normalizePackageManager(options.pm);
61
- const pm =
62
- normalizedPm || config.packageManager || detectPackageManager(projectRoot);
51
+ const pm = resolveProjectPackageManager(projectRoot, config, options.pm);
63
52
 
64
- if (config.packageManager !== pm) {
65
- updateProjectConfig(projectRoot, { packageManager: pm });
53
+ if (options.envBootstrap) {
54
+ bootstrapProjectEnv(projectRoot, config, options);
66
55
  }
67
56
 
68
- const shouldBootstrap = Boolean(options.envBootstrap);
69
- if (shouldBootstrap) {
70
- if (options.docker) {
71
- bootstrapEnvFile(
72
- projectRoot,
73
- config.env.dockerExample,
74
- config.env.docker,
75
- );
76
- } else {
77
- const envFile = options.env || config.env.local;
78
- const envExample = resolveEnvExample(
79
- projectRoot,
80
- envFile,
81
- config.env.localExample,
82
- );
83
- bootstrapEnvFile(projectRoot, envExample, envFile);
57
+ if (options.docker) {
58
+ const upArgs = ['up'];
59
+ if (options.build) {
60
+ upArgs.push('--build');
61
+ }
62
+ if (options.detach) {
63
+ upArgs.push('-d');
84
64
  }
85
- }
86
65
 
87
- if (options.docker) {
88
- await runDockerStart(projectRoot, options, config);
66
+ runProjectCompose(projectRoot, config, {
67
+ services: options.services,
68
+ mode: 'prod',
69
+ args: upArgs,
70
+ action: 'Starting Docker services in production mode',
71
+ });
89
72
  } else {
90
73
  runPackageScript(pm, config.startScript, projectRoot);
91
74
  }
92
75
  };
93
-
94
- const runDockerStart = async (
95
- projectRoot: string,
96
- options: StartOptions,
97
- config: ReturnType<typeof loadProjectConfig>,
98
- ) => {
99
- checkDocker({ silent: true });
100
- ensureDockerFolder(projectRoot);
101
- const servicesInput = parseServices(options.services || '');
102
- const services = servicesInput.length
103
- ? servicesInput
104
- : config.docker.defaultServices;
105
- const composeFile = resolveComposeFile(
106
- projectRoot,
107
- config.docker.composeFile,
108
- );
109
- const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
110
- const composeArgs = generateComposeFiles(composeFile, services, 'prod');
111
- const upArgs = ['up'];
112
- if (options.build) {
113
- upArgs.push('--build');
114
- }
115
- if (options.detach) {
116
- upArgs.push('-d');
117
- }
118
-
119
- const composeCommand = `${composeArgs} ${upArgs.join(' ')}`.trim();
120
- console.log(
121
- chalk.blue(
122
- `Starting Docker services in production mode${
123
- services.length ? ` (${services.join(', ')})` : ''
124
- }`,
125
- ),
126
- );
127
- dockerCompose(composeCommand, { envFile });
128
- };
@@ -9,16 +9,9 @@ import * as path from 'path';
9
9
  import chalk from 'chalk';
10
10
  import { Command } from 'commander';
11
11
 
12
+ import { runProjectCompose } from '../core/compose.js';
12
13
  import { loadProjectConfig } from '../core/config.js';
13
- import {
14
- dockerCompose,
15
- generateComposeFiles,
16
- resolveComposeEnvFile,
17
- resolveComposeFile,
18
- } from '../core/docker.js';
19
- import { checkDocker } from '../core/prerequisites.js';
20
- import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
21
- import { parseServices } from '../utils/services.js';
14
+ import { assertHexabotProject } from '../core/project.js';
22
15
 
23
16
  export interface StopOptions {
24
17
  docker?: boolean;
@@ -56,26 +49,6 @@ export const runStop = async (options: StopOptions = {}) => {
56
49
  }
57
50
 
58
51
  const config = loadProjectConfig(projectRoot);
59
- await runDockerStop(projectRoot, options, config);
60
- };
61
-
62
- const runDockerStop = async (
63
- projectRoot: string,
64
- options: StopOptions,
65
- config: ReturnType<typeof loadProjectConfig>,
66
- ) => {
67
- checkDocker({ silent: true });
68
- ensureDockerFolder(projectRoot);
69
- const servicesInput = parseServices(options.services || '');
70
- const services = servicesInput.length
71
- ? servicesInput
72
- : config.docker.defaultServices;
73
- const composeFile = resolveComposeFile(
74
- projectRoot,
75
- config.docker.composeFile,
76
- );
77
- const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
78
- const composeArgs = generateComposeFiles(composeFile, services);
79
52
  const downArgs = ['down'];
80
53
  if (options.volumes) {
81
54
  downArgs.push('--volumes');
@@ -84,13 +57,9 @@ const runDockerStop = async (
84
57
  downArgs.push('--remove-orphans');
85
58
  }
86
59
 
87
- const composeCommand = `${composeArgs} ${downArgs.join(' ')}`.trim();
88
- console.log(
89
- chalk.blue(
90
- `Stopping Docker services${
91
- services.length ? ` (${services.join(', ')})` : ''
92
- }`,
93
- ),
94
- );
95
- dockerCompose(composeCommand, { envFile });
60
+ runProjectCompose(projectRoot, config, {
61
+ services: options.services,
62
+ args: downArgs,
63
+ action: 'Stopping Docker services',
64
+ });
96
65
  };
@@ -0,0 +1,63 @@
1
+ /*
2
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
3
+ * Copyright (c) 2026 Hexastack.
4
+ * Full terms: see LICENSE.md.
5
+ */
6
+
7
+ import chalk from 'chalk';
8
+
9
+ import { parseServices } from '../utils/services.js';
10
+
11
+ import type { HexabotConfig } from './config.js';
12
+ import {
13
+ dockerCompose,
14
+ generateComposeFiles,
15
+ resolveComposeEnvFile,
16
+ resolveComposeFile,
17
+ type ComposeMode,
18
+ } from './docker.js';
19
+ import { checkDocker } from './prerequisites.js';
20
+ import { ensureDockerFolder } from './project.js';
21
+
22
+ /**
23
+ * Runs `docker compose <args>` over the project's compose files for the
24
+ * requested services, or the configured default services.
25
+ */
26
+ export const runProjectCompose = (
27
+ projectRoot: string,
28
+ config: HexabotConfig,
29
+ {
30
+ services: servicesOption,
31
+ mode,
32
+ args,
33
+ action,
34
+ }: {
35
+ services?: string;
36
+ mode?: ComposeMode;
37
+ args: string[];
38
+ /** Log prefix, e.g. "Starting Docker services". */
39
+ action: string;
40
+ },
41
+ ) => {
42
+ checkDocker({ silent: true });
43
+ ensureDockerFolder(projectRoot);
44
+ const servicesInput = parseServices(servicesOption || '');
45
+ const services = servicesInput.length
46
+ ? servicesInput
47
+ : config.docker.defaultServices;
48
+ const composeFile = resolveComposeFile(
49
+ projectRoot,
50
+ config.docker.composeFile,
51
+ );
52
+ const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
53
+ const composeArgs = mode
54
+ ? generateComposeFiles(composeFile, services, mode)
55
+ : generateComposeFiles(composeFile, services);
56
+ const composeCommand = `${composeArgs} ${args.join(' ')}`.trim();
57
+ console.log(
58
+ chalk.blue(
59
+ `${action}${services.length ? ` (${services.join(', ')})` : ''}`,
60
+ ),
61
+ );
62
+ dockerCompose(composeCommand, { envFile });
63
+ };
@@ -89,7 +89,7 @@ export const ensureProjectConfig = (
89
89
  return loadProjectConfig(projectRoot);
90
90
  };
91
91
 
92
- export const writeProjectConfig = (
92
+ const writeProjectConfig = (
93
93
  config: HexabotConfig,
94
94
  projectRoot = process.cwd(),
95
95
  ) => {
@@ -0,0 +1,54 @@
1
+ /*
2
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
3
+ * Copyright (c) 2026 Hexastack.
4
+ * Full terms: see LICENSE.md.
5
+ */
6
+
7
+ import { updateProjectConfig, type HexabotConfig } from './config.js';
8
+ import { bootstrapEnvFile, resolveEnvExample } from './env.js';
9
+ import {
10
+ detectPackageManager,
11
+ normalizePackageManager,
12
+ } from './package-manager.js';
13
+
14
+ /**
15
+ * Picks the package manager (`--pm`, then the project config, then the
16
+ * lockfile) and records it in the project config.
17
+ */
18
+ export const resolveProjectPackageManager = (
19
+ projectRoot: string,
20
+ config: HexabotConfig,
21
+ pmOption?: string,
22
+ ) => {
23
+ const pm =
24
+ normalizePackageManager(pmOption) ||
25
+ config.packageManager ||
26
+ detectPackageManager(projectRoot);
27
+
28
+ if (config.packageManager !== pm) {
29
+ updateProjectConfig(projectRoot, { packageManager: pm });
30
+ }
31
+
32
+ return pm;
33
+ };
34
+
35
+ /** Creates the Docker or local env file from its example when it is missing. */
36
+ export const bootstrapProjectEnv = (
37
+ projectRoot: string,
38
+ config: HexabotConfig,
39
+ options: { docker?: boolean; env?: string },
40
+ ) => {
41
+ if (options.docker) {
42
+ bootstrapEnvFile(projectRoot, config.env.dockerExample, config.env.docker);
43
+
44
+ return;
45
+ }
46
+
47
+ const envFile = options.env || config.env.local;
48
+ const envExample = resolveEnvExample(
49
+ projectRoot,
50
+ envFile,
51
+ config.env.localExample,
52
+ );
53
+ bootstrapEnvFile(projectRoot, envExample, envFile);
54
+ };
@@ -19,10 +19,6 @@ export interface PackageJson {
19
19
  devDependencies?: Record<string, string>;
20
20
  }
21
21
 
22
- export const resolveProjectRoot = (cwd = process.cwd()) => {
23
- return path.resolve(cwd);
24
- };
25
-
26
22
  export const readPackageJson = (
27
23
  projectRoot = process.cwd(),
28
24
  ): PackageJson | null => {