@bachbntdev/devcmd 0.0.0-stage → 2.7.1

package/dev

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 bachbnt
+
+const MIN_NODE_VERSION = '20.12.0';
+
+function compareVersions(current, required) {
+  const currentParts = current.split('.').map(Number);
+  const requiredParts = required.split('.').map(Number);
+  for (let index = 0; index < 3; index += 1) {
+    const currentPart = currentParts[index] || 0;
+    const requiredPart = requiredParts[index] || 0;
+    if (currentPart > requiredPart) return 1;
+    if (currentPart < requiredPart) return -1;
+  }
+  return 0;
+}
+
+if (compareVersions(process.versions.node, MIN_NODE_VERSION) < 0) {
+  console.error(`DevCmd requires Node.js ${MIN_NODE_VERSION} or newer. Current Node.js: ${process.version}`);
+  process.exit(1);
+}
+
+const { main } = require('./src/cli');
+
+main(process.argv.slice(2)).then(
+  (exitCode) => {
+    process.exitCode = exitCode;
+  },
+  (error) => {
+    console.error(`DevCmd failed: ${error.message}`);
+    process.exitCode = 1;
+  }
+);

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@bachbntdev/devcmd",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.7.1",
+  "description": "DevCmd project scaffolding, lifecycle, and development environment CLI with an MCP server for AI agents",
+  "bin": {
+    "dev": "./dev",
+    "devcmd": "./dev"
+  },
+  "files": [
+    "dev",
+    "src"
+  ],
+  "scripts": {
+    "install-local": "./scripts/install-local.sh",
+    "install-remote": "./scripts/install-remote.sh",
+    "release": "./scripts/release.sh",
+    "test": "node --test",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "cli",
+    "scaffolding",
+    "development",
+    "monorepo",
+    "mcp",
+    "devtools"
+  ],
+  "author": "bachbnt",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bachbnt/dev-cmd.git"
+  },
+  "homepage": "https://github.com/bachbnt/dev-cmd#readme",
+  "bugs": {
+    "url": "https://github.com/bachbnt/dev-cmd/issues"
+  },
+  "engines": {
+    "node": ">=20.12.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.5.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "picocolors": "^1.1.1"
+  }
+}

package/src/cli.js

@@ -0,0 +1,217 @@
+// Copyright (c) 2026 bachbnt
+
+const { BRAND, PACKAGE_MANAGERS, VERSION, frameworkDefinitions } = require('./config');
+const { loadConfig } = require('./config/user');
+const { getCompletion } = require('./commands/completion');
+const { handleClone } = require('./handlers/clone');
+const { handleMcp } = require('./handlers/mcp');
+const { handleDeviceCommand, handleDeviceList } = require('./handlers/devices');
+const { handleAgain, handleHistory, rebuildHistoryCommands } = require('./handlers/history');
+const { runJson } = require('./handlers/json');
+const { handleInspect, handleLifecycle } = require('./handlers/lifecycle');
+const { handleDocker, handleEnv } = require('./handlers/tools');
+const { handleParallel, handleTask, handleTrust } = require('./handlers/workflow');
+const { LIFECYCLE_COMMANDS } = require('./constants');
+const { applyConfigDefaults, handleInit, handleScaffold } = require('./handlers/scaffold');
+const {
+  handleConfig,
+  handleDoctor,
+  handleInfo,
+  handleOpeners,
+  handleProjects,
+  handleRecipes,
+  handleUpdate,
+} = require('./handlers/system');
+const { describeFailure, executeCommands } = require('./runtime/execute');
+const { parseArgs, validateCommandFlags } = require('./utils/args');
+const { getRecipeDefinitions, loadRecipeRegistry } = require('./recipes');
+const { loadOpenerRegistry } = require('./openers');
+
+function printHelp(pc, definitions = frameworkDefinitions, openerRegistry) {
+  console.log(
+    `\n${pc.bgCyan(pc.black(` ${BRAND} v${VERSION} `))} ${pc.bold('Development toolkit by bachbnt')}\n`
+  );
+  console.log(pc.bold('Usage:'));
+  console.log('  dev <command> [target] [options]\n');
+  console.log(pc.bold('Frameworks:'));
+  console.log(`  ${pc.green('init'.padEnd(20))} ${pc.dim('Create a new project interactively')}`);
+  for (const [name, definition] of Object.entries(definitions)) {
+    console.log(`  ${pc.green(name.padEnd(20))} ${pc.dim(definition.description)}`);
+  }
+  console.log(`\n${pc.bold('Project Lifecycle:')}`);
+  console.log(`  ${pc.magenta('doctor'.padEnd(16))} ${pc.dim('Check development tools')}`);
+  console.log(`  ${pc.magenta('inspect'.padEnd(16))} ${pc.dim('Show detected project and lifecycle commands')}`);
+  for (const action of LIFECYCLE_COMMANDS) {
+    const label = action.charAt(0).toUpperCase() + action.slice(1);
+    console.log(`  ${pc.magenta(action.padEnd(16))} ${pc.dim(`${label} the detected project`)}`);
+  }
+  console.log(`  ${pc.magenta('task'.padEnd(16))} ${pc.dim('List or run project tasks (package.json scripts, .devcmd.json)')}`);
+  console.log(`  ${pc.magenta('parallel'.padEnd(16))} ${pc.dim('Run a lifecycle action in several projects at once')}`);
+  console.log(`  ${pc.magenta('trust'.padEnd(16))} ${pc.dim('Review and trust the project .devcmd.json profile')}`);
+  console.log(`  ${pc.magenta('env'.padEnd(16))} ${pc.dim('Create .env from .env.example, or check for missing variables')}`);
+  console.log(`  ${pc.magenta('docker'.padEnd(16))} ${pc.dim('Run Docker Compose: up, down, build, ps, logs, restart')}`);
+  console.log(`  ${pc.magenta('projects'.padEnd(16))} ${pc.dim('Show recently used projects')}`);
+  console.log(`  ${pc.magenta('recipes'.padEnd(16))} ${pc.dim('List or validate framework recipes')}`);
+  console.log(`  ${pc.magenta('openers'.padEnd(16))} ${pc.dim('List or validate project openers')}`);
+  console.log(`  ${pc.magenta('config'.padEnd(16))} ${pc.dim('Show or update DevCmd defaults')}`);
+  console.log(`  ${pc.magenta('completion'.padEnd(16))} ${pc.dim('Generate bash or zsh completion')}`);
+  console.log(`\n${pc.bold('Tools:')}`);
+  console.log(`  ${pc.magenta('clone'.padEnd(16))} ${pc.dim('Clone a repository and install dependencies')}`);
+  console.log(`  ${pc.magenta('update'.padEnd(16))} ${pc.dim('Update DevCmd to the latest version')}`);
+  console.log(`  ${pc.magenta('mcp'.padEnd(16))} ${pc.dim('Start the DevCmd MCP server (stdio transport)')}`);
+  console.log(`\n${pc.bold('Openers:')}`);
+  for (const opener of openerRegistry?.values() || []) {
+    const aliases = opener.aliases?.length ? ` (${opener.aliases.join(', ')})` : '';
+    const source = opener.source === 'user' ? ' [user]' : '';
+    console.log(
+      `  ${pc.cyan(opener.name.padEnd(20))} ${pc.dim(`${opener.description}${aliases}${source}`)}`
+    );
+  }
+  console.log(`\n${pc.bold('Devices:')}`);
+  console.log(`  ${pc.blue('devices'.padEnd(16))} ${pc.dim('List Android and iOS devices')}`);
+  console.log(`  ${pc.blue('android'.padEnd(16))} ${pc.dim('Boot Android emulator')}`);
+  console.log(`  ${pc.blue('ios'.padEnd(16))} ${pc.dim('Boot or manage iOS simulators')}`);
+  console.log(`\n${pc.bold('History:')}`);
+  console.log(`  ${pc.cyan('history'.padEnd(16))} ${pc.dim('Show recent successful commands [--clear] [--project <path>]')}`);
+  console.log(`  ${pc.cyan('again'.padEnd(16))} ${pc.dim('Run a recent command again [n]')}`);
+  console.log(`\n${pc.bold('Options:')}`);
+  const printOption = (flags, description) => {
+    console.log(`  ${flags.padEnd(31)} ${pc.dim(description)}`);
+  };
+  printOption('--dry-run', 'Print without executing');
+  printOption('--typescript, --javascript', 'Select project language');
+  printOption(
+    PACKAGE_MANAGERS.map((manager) => `--${manager}`).join(', '),
+    'Select package manager'
+  );
+  printOption('--git, --no-git', 'Toggle Git initialization');
+  printOption('--eslint, --no-eslint', 'Toggle ESLint where supported');
+  printOption('--no-install', 'Scaffold without installing dependencies');
+  printOption('--python <executable>', 'Select Python executable');
+  printOption('--set <name=value>', 'Set a custom recipe input');
+  printOption('--editor <executable>', 'Override editor for dev open');
+  printOption('--with <opener>', 'Select an opener for dev open');
+  printOption('--list', 'List available openers');
+  printOption('--filter <workspace>', 'Target one monorepo workspace (run, test, build, ...)');
+  printOption('--fix', 'Apply automatic fixes (lint only)');
+  printOption('--json', 'Print machine-readable JSON (inspect, doctor, ...)');
+  printOption('--search <text>', 'Filter history by text (history only)');
+  printOption('--yes, -y', 'Skip confirmation (trust only)');
+  printOption('--cold-boot', 'Cold boot Android emulator');
+  printOption('--shutdown-all', 'Shutdown all iOS simulators');
+  printOption('--clear', 'Clear history (history only)');
+  printOption('--project <path>', 'Filter history by project path (history only)');
+  console.log('');
+}
+
+const COMMAND_HANDLERS = new Map([
+  ['config', handleConfig],
+  ['doctor', handleDoctor],
+  ['projects', handleProjects],
+  ['recipes', handleRecipes],
+  ['openers', handleOpeners],
+  ['inspect', handleInspect],
+  ['info', handleInfo],
+  ['history', handleHistory],
+  ['again', handleAgain],
+  ['init', handleInit],
+  ['update', handleUpdate],
+  ['clone', handleClone],
+  ['mcp', handleMcp],
+  ['task', handleTask],
+  ['parallel', handleParallel],
+  ['trust', handleTrust],
+  ['env', handleEnv],
+  ['docker', handleDocker],
+  ['devices', handleDeviceList],
+  ['android', handleDeviceCommand],
+  ['ios', handleDeviceCommand],
+]);
+for (const cmd of LIFECYCLE_COMMANDS) COMMAND_HANDLERS.set(cmd, handleLifecycle);
+
+async function dispatch(context) {
+  const { command } = context;
+  const definitions = context.frameworkDefinitions || frameworkDefinitions;
+  const handler = COMMAND_HANDLERS.get(command);
+  if (handler) return handler(context);
+  if (definitions[command]) return handleScaffold(context);
+  throw new Error(`Unsupported command: ${command}. Run dev help to see available commands.`);
+}
+
+async function main(argv) {
+  const p = await import('@clack/prompts');
+  const pc = (await import('picocolors')).default;
+  let parsed;
+  let recipeRegistry;
+  let definitions;
+  let openerRegistry;
+
+  try {
+    parsed = parseArgs(argv);
+  } catch (error) {
+    p.log.error(error.message);
+    return 1;
+  }
+
+  const { command, options, positionals } = parsed;
+  try {
+    const validatingRecipe = command === 'recipes' && positionals[0] === 'validate';
+    recipeRegistry = loadRecipeRegistry({ includeUser: !validatingRecipe });
+    definitions = getRecipeDefinitions(recipeRegistry);
+    const validatingOpener = command === 'openers' && positionals[0] === 'validate';
+    openerRegistry = loadOpenerRegistry({ includeUser: !validatingOpener });
+  } catch (error) {
+    p.log.error(error.message);
+    return 1;
+  }
+  if (!command || ['help', '-h', '--help'].includes(command)) {
+    printHelp(pc, definitions, openerRegistry);
+    return command ? 0 : 1;
+  }
+
+  if (command === 'completion') {
+    try {
+      process.stdout.write(getCompletion(
+        positionals[0] || process.env.SHELL?.split('/').pop() || 'zsh',
+        definitions,
+        openerRegistry
+      ));
+      return 0;
+    } catch (error) {
+      p.log.error(error.message);
+      return 1;
+    }
+  }
+
+  try {
+    validateCommandFlags(command, options, definitions);
+    const config = loadConfig();
+    if (options.json) return runJson({ command, options, positionals, config, recipeRegistry, openerRegistry });
+    if (command !== 'mcp') p.intro(`${pc.bgCyan(pc.black(` ${BRAND} `))} ${pc.bold(command)}`);
+    return await dispatch({
+      p,
+      pc,
+      command,
+      options,
+      positionals,
+      config,
+      frameworkDefinitions: definitions,
+      recipeRegistry,
+      openerRegistry,
+    });
+  } catch (error) {
+    p.log.error(error.message);
+    return 1;
+  }
+}
+
+module.exports = {
+  applyConfigDefaults,
+  describeFailure,
+  dispatch,
+  executeCommands,
+  handleLifecycle,
+  main,
+  printHelp,
+  rebuildHistoryCommands,
+};

package/src/commands/completion.js

@@ -0,0 +1,97 @@
+// Copyright (c) 2026 bachbnt
+
+const { frameworkDefinitions } = require('../config');
+
+const { LIFECYCLE_COMMANDS } = require('../constants');
+
+const SYSTEM_COMMANDS = [
+  'doctor',
+  'inspect',
+  ...LIFECYCLE_COMMANDS,
+  'task',
+  'parallel',
+  'trust',
+  'env',
+  'docker',
+  'devices',
+  'android',
+  'ios',
+  'history',
+  'again',
+  'projects',
+  'recipes',
+  'openers',
+  'config',
+  'completion',
+  'help',
+];
+const COMMANDS = [...Object.keys(frameworkDefinitions), ...SYSTEM_COMMANDS];
+
+const OPTIONS = [
+  '--dry-run', '--typescript', '--javascript', '--npm', '--pnpm', '--yarn',
+  '--git', '--no-git', '--eslint', '--no-eslint', '--no-install', '--python', '--editor',
+  '--cold-boot', '--shutdown-all', '--set', '--with', '--list',
+  '--filter', '--fix', '--json', '--search', '--yes',
+];
+
+function commandNames(definitions = frameworkDefinitions) {
+  return [...Object.keys(definitions), ...SYSTEM_COMMANDS];
+}
+
+function openerNames(registry) {
+  if (!registry) return [];
+  return [...registry.values()].flatMap((opener) => [opener.name, ...(opener.aliases || [])]);
+}
+
+function bashCompletion(definitions, openerRegistry) {
+  const commands = commandNames(definitions);
+  const candidates = [...OPTIONS, ...openerNames(openerRegistry)];
+  return `_devcmd_completion() {
+  local current
+  current="\${COMP_WORDS[COMP_CWORD]}"
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "${commands.join(' ')}" -- "\${current}") )
+  else
+    COMPREPLY=( $(compgen -W "${candidates.join(' ')}" -- "\${current}") )
+  fi
+}
+complete -F _devcmd_completion dev devcmd
+`;
+}
+
+function zshCompletion(definitions, openerRegistry) {
+  const commands = commandNames(definitions);
+  const candidates = [...OPTIONS, ...openerNames(openerRegistry)];
+  return `#compdef dev devcmd
+
+_devcmd() {
+  local -a commands options
+  commands=(${commands.map((command) => `'${command}'`).join(' ')})
+  options=(${candidates.map((option) => `'${option}'`).join(' ')})
+
+  if (( CURRENT == 2 )); then
+    _describe 'command' commands
+  else
+    _describe 'option' options
+    _files
+  fi
+}
+
+compdef _devcmd dev devcmd
+`;
+}
+
+function getCompletion(shell, definitions = frameworkDefinitions, openerRegistry) {
+  if (shell === 'bash') return bashCompletion(definitions, openerRegistry);
+  if (shell === 'zsh') return zshCompletion(definitions, openerRegistry);
+  throw new Error('Completion supports: bash, zsh.');
+}
+
+module.exports = {
+  COMMANDS,
+  OPTIONS,
+  SYSTEM_COMMANDS,
+  commandNames,
+  getCompletion,
+  openerNames,
+};

package/src/commands/devices.js

@@ -0,0 +1,26 @@
+// Copyright (c) 2026 bachbnt
+
+const { createCommand } = require('../runner/command');
+
+function buildAndroidCommands(target, options = {}) {
+  const args = ['-avd', target];
+  if (options.coldBoot) args.push('-no-snapshot-load');
+  return [createCommand('emulator', args)];
+}
+
+function buildIOSBootCommands(target) {
+  return [
+    createCommand('open', ['-a', 'Simulator']),
+    createCommand('xcrun', ['simctl', 'boot', target]),
+  ];
+}
+
+function buildIOSShutdownCommands() {
+  return [createCommand('xcrun', ['simctl', 'shutdown', 'all'])];
+}
+
+module.exports = {
+  buildAndroidCommands,
+  buildIOSBootCommands,
+  buildIOSShutdownCommands,
+};

package/src/commands/docker.js

@@ -0,0 +1,35 @@
+// Copyright (c) 2026 bachbnt
+
+const fs = require('fs');
+const path = require('path');
+const { createCommand } = require('../runner/command');
+
+const COMPOSE_FILES = ['compose.yaml', 'compose.yml', 'docker-compose.yaml', 'docker-compose.yml'];
+const DOCKER_ACTIONS = {
+  up: ['up', '-d'],
+  down: ['down'],
+  build: ['build'],
+  ps: ['ps'],
+  logs: ['logs', '--follow', '--tail', '100'],
+  restart: ['restart'],
+};
+
+function findComposeFile(root, fsImpl = fs) {
+  return COMPOSE_FILES.find((name) => fsImpl.existsSync(path.join(root, name)));
+}
+
+function buildDockerCommands(action, root, fsImpl = fs) {
+  if (!Object.hasOwn(DOCKER_ACTIONS, action)) {
+    throw new Error(`Usage: dev docker <${Object.keys(DOCKER_ACTIONS).join('|')}> [path]`);
+  }
+  const file = findComposeFile(root, fsImpl);
+  if (!file) throw new Error(`No Compose file was found in ${root}. Expected: ${COMPOSE_FILES.join(', ')}.`);
+  return [createCommand('docker', ['compose', '--file', file, ...DOCKER_ACTIONS[action]], { cwd: root })];
+}
+
+module.exports = {
+  COMPOSE_FILES,
+  DOCKER_ACTIONS,
+  buildDockerCommands,
+  findComposeFile,
+};

package/src/commands/env.js

@@ -0,0 +1,52 @@
+// Copyright (c) 2026 bachbnt
+
+const fs = require('fs');
+const path = require('path');
+
+const TEMPLATE_FILES = ['.env.example', '.env.sample', '.env.template'];
+const ENV_FILE = '.env';
+
+function parseEnvKeys(content) {
+  const keys = [];
+  for (const line of content.split(/\r?\n/)) {
+    const match = line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+    if (match) keys.push(match[1]);
+  }
+  return keys;
+}
+
+function findTemplate(root, fsImpl = fs) {
+  return TEMPLATE_FILES.find((name) => fsImpl.existsSync(path.join(root, name)));
+}
+
+function initEnv(root, fsImpl = fs) {
+  const template = findTemplate(root, fsImpl);
+  if (!template) throw new Error(`No ${TEMPLATE_FILES.join(', ')} file was found in ${root}.`);
+  const target = path.join(root, ENV_FILE);
+  if (fsImpl.existsSync(target)) return { created: false, template, file: target };
+  fsImpl.copyFileSync(path.join(root, template), target, fs.constants.COPYFILE_EXCL);
+  return { created: true, template, file: target };
+}
+
+function checkEnv(root, fsImpl = fs) {
+  const template = findTemplate(root, fsImpl);
+  if (!template) throw new Error(`No ${TEMPLATE_FILES.join(', ')} file was found in ${root}.`);
+  const target = path.join(root, ENV_FILE);
+  if (!fsImpl.existsSync(target)) {
+    throw new Error(`${ENV_FILE} does not exist. Run: dev env`);
+  }
+  const expected = parseEnvKeys(fsImpl.readFileSync(path.join(root, template), 'utf8'));
+  const actual = new Set(parseEnvKeys(fsImpl.readFileSync(target, 'utf8')));
+  const missing = expected.filter((key) => !actual.has(key));
+  const known = new Set(expected);
+  const extra = [...actual].filter((key) => !known.has(key));
+  return { template, missing, extra, ok: missing.length === 0 };
+}
+
+module.exports = {
+  TEMPLATE_FILES,
+  checkEnv,
+  findTemplate,
+  initEnv,
+  parseEnvKeys,
+};

package/src/commands/frameworks.js

@@ -0,0 +1,36 @@
+// Copyright (c) 2026 bachbnt
+
+const {
+  buildRecipeCommands,
+  builtInRegistry,
+  getRecipeRequirements,
+} = require('../recipes');
+
+function getRecipe(command, registry = builtInRegistry) {
+  const recipe = registry.get(command);
+  if (!recipe) throw new Error(`Unsupported framework: ${command}`);
+  return recipe;
+}
+
+function buildFrameworkCommands(command, target, options = {}, registry = builtInRegistry) {
+  return buildRecipeCommands(getRecipe(command, registry), target, options);
+}
+
+function buildPythonCommands(framework, target, options = {}, registry = builtInRegistry) {
+  if (!['django', 'fastapi', 'flask'].includes(framework)) {
+    throw new Error(`Unsupported Python framework: ${framework}`);
+  }
+  return buildFrameworkCommands(framework, target, options, registry);
+}
+
+function getFrameworkRequirements(command, options = {}, registry = builtInRegistry, target = 'project') {
+  return getRecipeRequirements(getRecipe(command, registry), target, options);
+}
+
+module.exports = {
+  buildFrameworkCommands,
+  buildPythonCommands,
+  builtInRegistry,
+  getFrameworkRequirements,
+  getRecipe,
+};

package/src/commands/history.js

@@ -0,0 +1,59 @@
+// Copyright (c) 2026 bachbnt
+
+const fs = require('fs');
+const path = require('path');
+const { HISTORY_FILE } = require('../config');
+const { formatSequence, isCommandSequence } = require('../runner/command');
+
+function readHistory(options = {}) {
+  const file = options.file || HISTORY_FILE;
+  const fsImpl = options.fsImpl || fs;
+  try {
+    const history = JSON.parse(fsImpl.readFileSync(file, 'utf8'));
+    return Array.isArray(history) ? history : [];
+  } catch (error) {
+    return [];
+  }
+}
+
+function saveHistory(entry, options = {}) {
+  const file = options.file || HISTORY_FILE;
+  const fsImpl = options.fsImpl || fs;
+  const history = readHistory({ file, fsImpl });
+  history.unshift(entry);
+  fsImpl.mkdirSync(path.dirname(file), { recursive: true });
+  fsImpl.writeFileSync(file, `${JSON.stringify(history.slice(0, 50), null, 2)}\n`);
+}
+
+function createHistoryEntry(metadata, commands) {
+  return {
+    ...metadata,
+    commands,
+    commandLine: formatSequence(commands),
+    executedAt: new Date().toISOString(),
+  };
+}
+
+function filterHistory(history, filters = {}) {
+  const project = filters.project ? path.resolve(filters.project) : undefined;
+  const search = filters.search?.toLowerCase();
+  return history.filter((entry) => {
+    if (project && entry.projectPath !== project) return false;
+    if (!search) return true;
+    return [entry.command, entry.projectName, entry.commandLine, entry.projectType]
+      .some((value) => typeof value === 'string' && value.toLowerCase().includes(search));
+  });
+}
+
+function getHistoryDisplay(entry) {
+  if (isCommandSequence(entry.commands)) return formatSequence(entry.commands);
+  return entry.commandLine || 'Unknown command';
+}
+
+module.exports = {
+  createHistoryEntry,
+  filterHistory,
+  getHistoryDisplay,
+  readHistory,
+  saveHistory,
+};

package/src/commands/inspect.js

@@ -0,0 +1,48 @@
+// Copyright (c) 2026 bachbnt
+
+const { buildLifecycleCommands, buildOpenCommands } = require('./lifecycle');
+const { formatSequence } = require('../runner/command');
+const { LIFECYCLE_COMMANDS } = require('../constants');
+const { isTrusted } = require('../projects/profile');
+const { listTasks } = require('./lifecycle');
+
+function inspectAction(action, project, config, openerRegistry, options = {}) {
+  try {
+    const commands = action === 'open'
+      ? buildOpenCommands(project, undefined, config, openerRegistry)
+      : buildLifecycleCommands(action, project, { config, trustFile: options.trustFile });
+    return {
+      action,
+      available: true,
+      command: formatSequence(commands),
+      commands,
+    };
+  } catch (error) {
+    return { action, available: false, reason: error.message };
+  }
+}
+
+function inspectProject(project, config, openerRegistry, options = {}) {
+  return {
+    name: project.name,
+    type: project.type,
+    root: project.root,
+    packageManager: project.packageManager,
+    xcode: project.xcode,
+    recipeSource: project.recipe?.source,
+    profile: project.profile
+      ? { file: project.profile.file, trusted: isTrusted(project.profile, options) }
+      : undefined,
+    workspaces: (project.workspaces || []).map(({ name, dir }) => ({ name, dir })),
+    tasks: listTasks(project),
+    actions: LIFECYCLE_COMMANDS.map(
+      (action) => inspectAction(action, project, config, openerRegistry, options)
+    ),
+  };
+}
+
+module.exports = {
+  INSPECT_ACTIONS: LIFECYCLE_COMMANDS,
+  inspectAction,
+  inspectProject,
+};