@bachbntdev/devcmd 0.0.0-stage → 2.7.1

package/src/handlers/clone.js

@@ -0,0 +1,73 @@
+// Copyright (c) 2026 bachbnt
+
+const path = require('path');
+const { buildLifecycleCommands } = require('../commands/lifecycle');
+const { detectProject } = require('../projects/detect');
+const { executeCommands } = require('../runtime/execute');
+const { runSequence } = require('../runner/process');
+
+function parseRepo(input) {
+  if (/^https?:\/\//.test(input) || /^git@/.test(input)) {
+    const name = input.split('/').pop().replace(/\.git$/, '');
+    return { url: input, name };
+  }
+  if (/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(input)) {
+    const name = input.split('/')[1];
+    return { url: `https://github.com/${input}`, name };
+  }
+  throw new Error(`Invalid repository: ${input}. Use owner/repo or a full URL.`);
+}
+
+async function handleClone(context) {
+  const { p, pc, positionals, options, config } = context;
+  if (positionals.length === 0 || positionals.length > 2) {
+    throw new Error('Usage: dev clone <repo> [directory]');
+  }
+
+  const { url, name } = parseRepo(positionals[0]);
+  const targetDir = path.resolve(positionals[1] || name);
+  const cloneCommand = { executable: 'git', args: ['clone', url, targetDir] };
+
+  p.log.step(`Cloning: ${pc.yellow(url)}`);
+  if (options.dryRun) {
+    p.log.step(`Dry run: git clone ${url} ${targetDir}`);
+    p.outro('No command was executed.');
+    return 0;
+  }
+
+  const cloneResult = await runSequence([cloneCommand]);
+  if (!cloneResult.ok) {
+    p.outro(`${pc.red('✖')} Clone failed.`);
+    return cloneResult.exitCode;
+  }
+
+  let project;
+  try {
+    project = detectProject(targetDir, { registry: context.recipeRegistry });
+  } catch (error) {
+    p.log.warn(`Cloned successfully, but project detection failed: ${error.message}`);
+    p.outro(`${pc.green('✔')} Cloned to ${targetDir}`);
+    return 0;
+  }
+
+  p.log.step(`Detected: ${pc.cyan(project.type)}`);
+
+  let installCommands;
+  try {
+    installCommands = buildLifecycleCommands('install', project, { config });
+  } catch (error) {
+    p.log.warn(`Cloned successfully, but install is not supported: ${error.message}`);
+    p.outro(`${pc.green('✔')} Cloned to ${targetDir}`);
+    return 0;
+  }
+
+  return executeCommands(p, pc, installCommands, {
+    command: 'install',
+    projectName: project.name,
+    projectPath: project.root,
+    projectType: project.type,
+    config,
+  }, options);
+}
+
+module.exports = { handleClone, parseRepo };

package/src/handlers/devices.js

@@ -0,0 +1,78 @@
+// Copyright (c) 2026 bachbnt
+
+const { DEFAULT_DEVICES } = require('../config');
+const { buildAndroidCommands, buildIOSBootCommands, buildIOSShutdownCommands } = require('../commands/devices');
+const { formatDevice, getAndroidDevices, getIOSDevices } = require('../devices');
+const { executeCommands } = require('../runtime/execute');
+
+function handleDeviceList(context) {
+  const { p, pc } = context;
+  const android = getAndroidDevices();
+  const ios = getIOSDevices();
+  p.note([
+    pc.bold('Android'),
+    ...(android.length ? android.map((device) => `  ${formatDevice(device)}`) : ['  No devices found']),
+    '',
+    pc.bold('iOS'),
+    ...(ios.length ? ios.map((device) => `  ${formatDevice(device)}`) : ['  No devices found']),
+  ].join('\n'), 'Available devices');
+  p.outro(`${android.length + ios.length} device(s) found.`);
+  return 0;
+}
+
+async function handleDeviceCommand(context) {
+  const { p, pc, command, options } = context;
+  if (command === 'ios' && options.shutdownAll) {
+    return executeCommands(p, pc, buildIOSShutdownCommands(), { command: 'ios', action: 'shutdown-all' }, {
+      ...options,
+      requirements: ['xcrun'],
+    });
+  }
+
+  const availableDevices = command === 'android' ? getAndroidDevices() : getIOSDevices();
+  let target = options.target;
+  if (!target && availableDevices.length > 0) {
+    const preferred = availableDevices.find((device) => device.name === DEFAULT_DEVICES[command]);
+    const selected = await p.select({
+      message: 'Select a device:',
+      options: availableDevices.map((device) => ({
+        value: device.id,
+        label: formatDevice(device),
+        hint: preferred?.id === device.id ? 'default' : '',
+      })),
+      initialValue: preferred?.id || availableDevices[0].id,
+    });
+    if (p.isCancel(selected)) {
+      p.cancel('Operation cancelled.');
+      return 130;
+    }
+    target = selected;
+  }
+  if (!target) {
+    const result = await p.text({
+      message: 'No device was detected. Enter a device name or identifier:',
+      placeholder: DEFAULT_DEVICES[command],
+      defaultValue: DEFAULT_DEVICES[command],
+      validate: (value) => (!value ? 'Device name is required.' : undefined),
+    });
+    if (p.isCancel(result)) {
+      p.cancel('Operation cancelled.');
+      return 130;
+    }
+    target = result;
+  }
+  if (command === 'ios') {
+    const match = availableDevices.find((device) => device.id === target || device.name === target);
+    target = match?.id || target;
+  }
+  const commands = command === 'android' ? buildAndroidCommands(target, options) : buildIOSBootCommands(target);
+  return executeCommands(p, pc, commands, { command, target, options }, {
+    ...options,
+    requirements: command === 'android' ? ['emulator'] : ['open', 'xcrun'],
+  });
+}
+
+module.exports = {
+  handleDeviceCommand,
+  handleDeviceList,
+};

package/src/handlers/history.js

@@ -0,0 +1,75 @@
+// Copyright (c) 2026 bachbnt
+
+const fs = require('fs');
+const { HISTORY_FILE, frameworkDefinitions } = require('../config');
+const { buildAndroidCommands, buildIOSBootCommands, buildIOSShutdownCommands } = require('../commands/devices');
+const { buildFrameworkCommands, builtInRegistry } = require('../commands/frameworks');
+const { filterHistory, getHistoryDisplay, readHistory } = require('../commands/history');
+const { isCommandSequence } = require('../runner/command');
+const { executeCommands } = require('../runtime/execute');
+
+function rebuildHistoryCommands(entry, registry = builtInRegistry, definitions = frameworkDefinitions) {
+  if (isCommandSequence(entry.commands)) return entry.commands;
+  if (definitions[entry.command] && entry.target) {
+    return buildFrameworkCommands(entry.command, entry.target, entry.options || {}, registry);
+  }
+  if (entry.command === 'android' && entry.target) return buildAndroidCommands(entry.target, entry.options || {});
+  if (entry.command === 'ios' && entry.action === 'shutdown-all') return buildIOSShutdownCommands();
+  if (entry.command === 'ios' && entry.target) return buildIOSBootCommands(entry.target);
+  throw new Error('This legacy history entry cannot be replayed safely. Run the command again directly.');
+}
+
+function handleHistory(context) {
+  const { p, options } = context;
+
+  if (options.clear) {
+    try { fs.unlinkSync(HISTORY_FILE); } catch {}
+    p.outro('History cleared.');
+    return 0;
+  }
+
+  const history = filterHistory(readHistory(), options).slice(0, 10);
+
+  if (history.length === 0) {
+    p.outro(options.project || options.search
+      ? 'No history entries match the filter.'
+      : 'No successful commands in history yet.');
+    return 0;
+  }
+  p.note(
+    history.map((entry, index) => `${index + 1}. ${getHistoryDisplay(entry)}\n   ${entry.executedAt}`).join('\n'),
+    'Recent commands'
+  );
+  p.outro(`History file: ${HISTORY_FILE}`);
+  return 0;
+}
+
+function handleAgain(context) {
+  const { p, pc, positionals, options } = context;
+  const index = positionals[0] !== undefined ? parseInt(positionals[0], 10) : 1;
+  if (isNaN(index) || index < 1) {
+    throw new Error('Usage: dev again [n] — n must be a positive integer.');
+  }
+  const history = readHistory();
+  const entry = history[index - 1];
+  if (!entry) {
+    throw new Error(`No command at position ${index}. History has ${history.length} entries.`);
+  }
+  return executeCommands(
+    p,
+    pc,
+    rebuildHistoryCommands(
+      entry,
+      context.recipeRegistry || builtInRegistry,
+      context.frameworkDefinitions || frameworkDefinitions
+    ),
+    { command: 'again', source: entry.command },
+    options
+  );
+}
+
+module.exports = {
+  handleAgain,
+  handleHistory,
+  rebuildHistoryCommands,
+};

package/src/handlers/json.js

@@ -0,0 +1,68 @@
+// Copyright (c) 2026 bachbnt
+
+const { filterHistory, readHistory } = require('../commands/history');
+const { inspectProject } = require('../commands/inspect');
+const { getAndroidDevices, getIOSDevices } = require('../devices');
+const { detectProject } = require('../projects/detect');
+const { getExistingProjects } = require('../projects/recent');
+const { checkTools } = require('../runner/check');
+
+function describeRegistry(registry) {
+  return [...registry.values()].map((entry) => ({
+    name: entry.name,
+    description: entry.description,
+    source: entry.source,
+    ...(entry.aliases?.length ? { aliases: entry.aliases } : {}),
+  }));
+}
+
+function collectJson(context) {
+  const { command, positionals, options, config } = context;
+  if (command === 'inspect') {
+    if (positionals.length > 1) throw new Error('Usage: dev inspect [path] --json');
+    const project = detectProject(positionals[0] || process.cwd(), { registry: context.recipeRegistry });
+    return { data: inspectProject(project, config, context.openerRegistry), exitCode: 0 };
+  }
+  if (command === 'doctor') {
+    const tools = checkTools(config).map(({ name, executable, required, found, path, version, hint }) => ({
+      name, executable, required: Boolean(required), found, path, version, hint,
+    }));
+    const ready = tools.every((tool) => !tool.required || tool.found);
+    return { data: { ready, tools }, exitCode: ready ? 0 : 1 };
+  }
+  if (command === 'projects') return { data: getExistingProjects(), exitCode: 0 };
+  if (command === 'history') {
+    const entries = filterHistory(readHistory(), options).map((entry) => ({
+      command: entry.command,
+      projectName: entry.projectName,
+      projectPath: entry.projectPath,
+      projectType: entry.projectType,
+      commandLine: entry.commandLine,
+      executedAt: entry.executedAt,
+    }));
+    return { data: entries, exitCode: 0 };
+  }
+  if (command === 'recipes') return { data: describeRegistry(context.recipeRegistry), exitCode: 0 };
+  if (command === 'openers') return { data: describeRegistry(context.openerRegistry), exitCode: 0 };
+  if (command === 'devices') {
+    return { data: { android: getAndroidDevices(), ios: getIOSDevices() }, exitCode: 0 };
+  }
+  if (command === 'config') return { data: config, exitCode: 0 };
+  throw new Error(`--json is not supported by ${command}.`);
+}
+
+function runJson(context) {
+  try {
+    const { data, exitCode } = collectJson(context);
+    process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+    return exitCode;
+  } catch (error) {
+    process.stderr.write(`${JSON.stringify({ error: error.message })}\n`);
+    return 1;
+  }
+}
+
+module.exports = {
+  collectJson,
+  runJson,
+};

package/src/handlers/lifecycle.js

@@ -0,0 +1,119 @@
+// Copyright (c) 2026 bachbnt
+
+const { buildLifecycleCommands, buildOpenCommands } = require('../commands/lifecycle');
+const { inspectProject } = require('../commands/inspect');
+const { detectProject } = require('../projects/detect');
+const { getExistingProjects } = require('../projects/recent');
+const { executeCommands } = require('../runtime/execute');
+const { builtInOpenerRegistry, resolveOpener } = require('../openers');
+const { LIFECYCLE_COMMANDS } = require('../constants');
+
+function resolveLifecycleTarget(
+  command,
+  positionals,
+  options = {},
+  openerRegistry = builtInOpenerRegistry
+) {
+  if (command === 'open' && options.list) {
+    if (positionals.length > 0) throw new Error('Usage: dev open --list');
+    return { listOpeners: true };
+  }
+  if (command === 'open' && positionals[0] === 'recent') {
+    if (positionals.length > 1) throw new Error('Usage: dev open recent');
+    const recent = getExistingProjects()[0];
+    if (!recent) throw new Error('No recent project is available.');
+    return { projectPath: recent.path };
+  }
+  if (command === 'open') {
+    if (options.opener) {
+      if (positionals.length > 1) throw new Error('Usage: dev open [path] --with <opener>');
+      return { openerName: options.opener, projectPath: positionals[0] || process.cwd() };
+    }
+    const opener = resolveOpener(openerRegistry, positionals[0]);
+    if (opener) {
+      if (positionals.length > 2) throw new Error(`Usage: dev open ${positionals[0]} [path]`);
+      return { openerName: positionals[0], projectPath: positionals[1] || process.cwd() };
+    }
+  }
+  if (positionals.length > 1) throw new Error(`Usage: dev ${command} [path]`);
+  return { projectPath: positionals[0] || process.cwd() };
+}
+
+async function handleLifecycle(context) {
+  const { p, pc, command, positionals, options, config } = context;
+  const { projectPath, openerName, listOpeners } = resolveLifecycleTarget(
+    command,
+    positionals,
+    options,
+    context.openerRegistry
+  );
+  if (listOpeners) {
+    const lines = [...context.openerRegistry.values()].map((opener) => {
+      const aliases = opener.aliases?.length ? ` aliases: ${opener.aliases.join(', ')}` : '';
+      return `${opener.name.padEnd(20)} [${opener.source}] ${opener.description}${aliases}`;
+    });
+    p.note(lines.join('\n'), 'Available openers');
+    p.outro('Use: dev open <opener> [path]');
+    return 0;
+  }
+  if (options.editor && openerName) {
+    throw new Error('--editor cannot be combined with a named opener.');
+  }
+  const project = detectProject(projectPath, { registry: context.recipeRegistry });
+  const commands = command === 'open'
+    ? buildOpenCommands(project, openerName, config, context.openerRegistry, { editor: options.editor })
+    : buildLifecycleCommands(command, project, { config, filter: options.filter, fix: options.fix });
+
+  return executeCommands(p, pc, commands, {
+    command,
+    projectName: project.name,
+    projectPath: project.root,
+    projectType: project.type,
+    config,
+  }, options);
+}
+
+function handleInspect(context) {
+  const { p, positionals, config } = context;
+  if (positionals.length > 1) throw new Error('Usage: dev inspect [path]');
+  const inspection = inspectProject(
+    detectProject(positionals[0] || process.cwd(), { registry: context.recipeRegistry }),
+    config,
+    context.openerRegistry
+  );
+  const lines = [
+    `Name: ${inspection.name}`,
+    `Type: ${inspection.type}`,
+    `Root: ${inspection.root}`,
+  ];
+  if (inspection.packageManager) lines.push(`Package manager: ${inspection.packageManager}`);
+  if (inspection.xcode) lines.push(`Xcode: ${inspection.xcode.kind} ${inspection.xcode.file}`);
+  if (inspection.recipeSource) lines.push(`Recipe: ${inspection.recipeSource}`);
+  if (inspection.profile) {
+    lines.push(`Profile: ${inspection.profile.file} (${inspection.profile.trusted ? 'trusted' : 'untrusted, run dev trust'})`);
+  }
+  if (inspection.workspaces.length) {
+    lines.push(`Workspaces: ${inspection.workspaces.map((workspace) => workspace.name).join(', ')}`);
+  }
+  if (inspection.tasks.length) {
+    lines.push(`Tasks: ${inspection.tasks.map((task) => task.name).join(', ')}`);
+  }
+  lines.push('');
+  for (const action of inspection.actions) {
+    lines.push(
+      action.available
+        ? `${action.action.padEnd(8)} ${action.command}`
+        : `${action.action.padEnd(8)} unavailable: ${action.reason}`
+    );
+  }
+  p.note(lines.join('\n'), 'Detected project');
+  p.outro('Inspection complete.');
+  return 0;
+}
+
+module.exports = {
+  LIFECYCLE_COMMANDS,
+  handleInspect,
+  handleLifecycle,
+  resolveLifecycleTarget,
+};

package/src/handlers/mcp.js

@@ -0,0 +1,10 @@
+// Copyright (c) 2026 bachbnt
+
+const { startMcpServer } = require('../mcp/server');
+
+async function handleMcp() {
+  await startMcpServer();
+  return 0;
+}
+
+module.exports = { handleMcp };

package/src/handlers/scaffold.js

@@ -0,0 +1,166 @@
+// Copyright (c) 2026 bachbnt
+
+const path = require('path');
+const { PACKAGE_MANAGERS, frameworkDefinitions } = require('../config');
+const {
+  buildFrameworkCommands,
+  builtInRegistry,
+  getFrameworkRequirements,
+  getRecipe,
+} = require('../commands/frameworks');
+const { executeCommands } = require('../runtime/execute');
+const { validateFrameworkOptions, validateProjectName } = require('../utils/args');
+
+function applyConfigDefaults(command, options, config, definitions = frameworkDefinitions) {
+  const capabilities = definitions[command].capabilities;
+  if (capabilities.packageManager && !options.packageManager) {
+    const supported = Array.isArray(capabilities.packageManager)
+      ? capabilities.packageManager
+      : PACKAGE_MANAGERS;
+    options.packageManager = supported.includes(config.packageManager)
+      ? config.packageManager
+      : supported[0];
+  }
+  if (capabilities.git && options.git === undefined) options.git = config.initializeGit;
+  if (capabilities.python && !options.python) options.python = config.python;
+}
+
+async function promptFrameworkOptions(
+  p,
+  command,
+  options,
+  config,
+  definitions = frameworkDefinitions,
+  recipe = builtInRegistry.get(command)
+) {
+  const capabilities = definitions[command].capabilities;
+  const unwrap = (value) => (p.isCancel(value) ? undefined : value);
+
+  if (capabilities.language && options.typescript === undefined) {
+    options.typescript = unwrap(await p.confirm({ message: 'Use TypeScript?', initialValue: true }));
+    if (options.typescript === undefined) return false;
+  }
+  if (capabilities.packageManager && !options.packageManager) {
+    const supported = Array.isArray(capabilities.packageManager)
+      ? capabilities.packageManager
+      : PACKAGE_MANAGERS;
+    options.packageManager = unwrap(await p.select({
+      message: 'Select a package manager:',
+      options: supported.map((value) => ({ value, label: value })),
+      initialValue: supported.includes(config.packageManager) ? config.packageManager : supported[0],
+    }));
+    if (!options.packageManager) return false;
+  }
+  if (capabilities.git && options.git === undefined) {
+    options.git = unwrap(await p.confirm({
+      message: 'Initialize a Git repository?',
+      initialValue: config.initializeGit,
+    }));
+    if (options.git === undefined) return false;
+  }
+  if (capabilities.eslint && options.eslint === undefined) {
+    options.eslint = unwrap(await p.confirm({ message: 'Include ESLint?', initialValue: true }));
+    if (options.eslint === undefined) return false;
+  }
+  options.values ||= {};
+  for (const [name, input] of Object.entries(recipe?.inputs || {})) {
+    if (options.values[name] !== undefined || input.default !== undefined || !input.required) continue;
+    const value = unwrap(await p.text({
+      message: input.description || `Enter ${name}:`,
+      validate(candidate) {
+        if (!candidate?.trim()) return `${name} is required.`;
+        return undefined;
+      },
+    }));
+    if (!value) return false;
+    options.values[name] = value;
+  }
+  return true;
+}
+
+async function handleScaffold(context) {
+  const { p, pc, command, positionals, options, config } = context;
+  const definitions = context.frameworkDefinitions || frameworkDefinitions;
+  const recipeRegistry = context.recipeRegistry || builtInRegistry;
+  const recipe = getRecipe(command, recipeRegistry);
+  if (positionals.length > 1) throw new Error(`Unexpected argument: ${positionals[1]}`);
+
+  const interactive = !options.target;
+  let target = options.target;
+  if (!target) {
+    const result = await p.text({
+      message: 'What is your project name?',
+      placeholder: 'my-awesome-app',
+      validate(value) {
+        try {
+          validateProjectName(value);
+        } catch (error) {
+          return error.message;
+        }
+      },
+    });
+    if (p.isCancel(result)) {
+      p.cancel('Operation cancelled.');
+      return 130;
+    }
+    target = result;
+  }
+
+  validateProjectName(target);
+  if (interactive && !(await promptFrameworkOptions(
+    p,
+    command,
+    options,
+    config,
+    definitions,
+    recipe
+  ))) {
+    p.cancel('Operation cancelled.');
+    return 130;
+  }
+  applyConfigDefaults(command, options, config, definitions);
+  validateFrameworkOptions(command, options, definitions);
+
+  const commands = buildFrameworkCommands(command, target, options, recipeRegistry);
+  return executeCommands(p, pc, commands, {
+    command,
+    target,
+    options,
+    projectName: target,
+    projectPath: path.resolve(target),
+    projectType: command,
+    recipeSource: recipe.source,
+    config,
+  }, {
+    ...options,
+    requirements: getFrameworkRequirements(command, options, recipeRegistry, target),
+  });
+}
+
+async function handleInit(context) {
+  const { p } = context;
+  const definitions = context.frameworkDefinitions || frameworkDefinitions;
+
+  const framework = await p.select({
+    message: 'Select a framework:',
+    options: Object.entries(definitions).map(([value, def]) => ({
+      value,
+      label: value,
+      hint: def.description,
+    })),
+  });
+
+  if (p.isCancel(framework)) {
+    p.cancel('Operation cancelled.');
+    return 130;
+  }
+
+  return handleScaffold({ ...context, command: framework });
+}
+
+module.exports = {
+  applyConfigDefaults,
+  handleInit,
+  handleScaffold,
+  promptFrameworkOptions,
+};