@bachbntdev/devcmd 0.0.0-stage → 2.7.1

package/src/commands/lifecycle.js

@@ -0,0 +1,70 @@
+// Copyright (c) 2026 bachbnt
+
+const { getProjectAdapter } = require('../projects/adapters');
+const { scriptCommands } = require('../projects/adapters/node');
+const { buildProfileLifecycle, buildProfileTask } = require('../projects/profile');
+const { createCommand } = require('../runner/command');
+const { buildRecipeLifecycleCommands } = require('../recipes');
+const { buildOpenerCommands, builtInOpenerRegistry, resolveOpener } = require('../openers');
+const { unsupported } = require('../projects/adapters/common');
+
+function buildLifecycleCommands(action, project, options = {}) {
+  const custom = buildProfileLifecycle(project, action, options);
+  if (custom) return custom;
+  if (project.type === 'custom') return unsupported(action, project);
+  const adapter = getProjectAdapter(project);
+  if (options.filter && adapter.id !== 'node') {
+    throw new Error('--filter requires a Node.js workspace project.');
+  }
+  if (options.fix && action !== 'lint') {
+    throw new Error('--fix is only supported by the lint command.');
+  }
+  return adapter.build(action, project, options);
+}
+
+function listTasks(project) {
+  const tasks = new Map();
+  for (const [name, definition] of Object.entries(project.profile?.tasks || {})) {
+    tasks.set(name, { name, source: 'profile', description: definition.description });
+  }
+  for (const name of Object.keys(project.packageJson?.scripts || {})) {
+    if (!tasks.has(name)) tasks.set(name, { name, source: 'package.json' });
+  }
+  return [...tasks.values()];
+}
+
+function buildTaskCommands(project, name, options = {}) {
+  const custom = buildProfileTask(project, name, options);
+  if (custom) return custom;
+  if (project.packageJson && getProjectAdapter(project).id === 'node') {
+    return scriptCommands(project, name, options.filter);
+  }
+  throw new Error(`Unknown task: ${name}. Run dev task to list available tasks.`);
+}
+
+function buildOpenCommands(
+  project,
+  openerName,
+  config,
+  openerRegistry = builtInOpenerRegistry,
+  options = {}
+) {
+  if (!openerName && options.editor) return [createCommand(options.editor, [project.root])];
+  if (!openerName && !config.opener && config.editor) {
+    return [createCommand(config.editor, [project.root])];
+  }
+  if (!openerName && project.recipe?.lifecycle?.open && !project.recipe.lifecycle.adapter) {
+    return buildRecipeLifecycleCommands(project.recipe, 'open', project, { config });
+  }
+  const requested = openerName || config.opener || 'vscode';
+  const opener = resolveOpener(openerRegistry, requested);
+  if (!opener) throw new Error(`Unknown opener: ${requested}. Run dev open --list.`);
+  return buildOpenerCommands(opener, project, options);
+}
+
+module.exports = {
+  buildLifecycleCommands,
+  buildOpenCommands,
+  buildTaskCommands,
+  listTasks,
+};

package/src/config/index.js

@@ -0,0 +1,35 @@
+// Copyright (c) 2026 bachbnt
+
+const os = require('os');
+const path = require('path');
+const { version } = require('../../package.json');
+const { builtInRegistry, getRecipeDefinitions } = require('../recipes');
+
+const BRAND = 'DevCmd';
+const CONFIG_FILE = path.join(os.homedir(), '.devcmd', 'config.json');
+const HISTORY_FILE = path.join(os.homedir(), '.devcmd', 'history.json');
+const OPENERS_DIR = path.join(os.homedir(), '.devcmd', 'openers');
+const PROJECTS_FILE = path.join(os.homedir(), '.devcmd', 'projects.json');
+const RECIPES_DIR = path.join(os.homedir(), '.devcmd', 'recipes');
+const TRUST_FILE = path.join(os.homedir(), '.devcmd', 'trusted.json');
+const PACKAGE_MANAGERS = ['npm', 'pnpm', 'yarn'];
+const DEFAULT_DEVICES = {
+  android: 'Pixel_9_Pro_Fold',
+  ios: 'iPhone 17 Pro',
+};
+
+const frameworkDefinitions = getRecipeDefinitions(builtInRegistry);
+
+module.exports = {
+  BRAND,
+  CONFIG_FILE,
+  DEFAULT_DEVICES,
+  HISTORY_FILE,
+  OPENERS_DIR,
+  PACKAGE_MANAGERS,
+  PROJECTS_FILE,
+  RECIPES_DIR,
+  TRUST_FILE,
+  VERSION: version,
+  frameworkDefinitions,
+};

package/src/config/user.js

@@ -0,0 +1,101 @@
+// Copyright (c) 2026 bachbnt
+
+const fs = require('fs');
+const path = require('path');
+const { CONFIG_FILE, PACKAGE_MANAGERS } = require('./index');
+
+const DEFAULT_CONFIG = {
+  packageManager: 'npm',
+  initializeGit: true,
+  python: process.platform === 'win32' ? 'python' : 'python3',
+  opener: 'vscode',
+  notify: 0,
+};
+
+const CONFIG_KEYS = [...Object.keys(DEFAULT_CONFIG), 'editor'];
+
+function readJson(file, fsImpl = fs) {
+  try {
+    return JSON.parse(fsImpl.readFileSync(file, 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') return {};
+    throw new Error(`Unable to read config ${file}: ${error.message}`);
+  }
+}
+
+function validateConfig(config) {
+  if (!PACKAGE_MANAGERS.includes(config.packageManager)) {
+    throw new Error(`packageManager must be one of: ${PACKAGE_MANAGERS.join(', ')}`);
+  }
+  if (typeof config.initializeGit !== 'boolean') {
+    throw new Error('initializeGit must be true or false.');
+  }
+  if (typeof config.python !== 'string' || !config.python.trim()) {
+    throw new Error('python must be a non-empty executable name or path.');
+  }
+  if (config.opener !== undefined && (typeof config.opener !== 'string' || !config.opener.trim())) {
+    throw new Error('opener must be a non-empty opener name.');
+  }
+  if (config.editor !== undefined && (typeof config.editor !== 'string' || !config.editor.trim())) {
+    throw new Error('editor must be a non-empty application or executable name.');
+  }
+  if (config.notify !== undefined && (!Number.isInteger(config.notify) || config.notify < 0)) {
+    throw new Error('notify must be a non-negative integer (seconds).');
+  }
+  return config;
+}
+
+function loadConfig(options = {}) {
+  const file = options.file || CONFIG_FILE;
+  const fsImpl = options.fsImpl || fs;
+  const saved = readJson(file, fsImpl);
+  const config = { ...DEFAULT_CONFIG, ...saved };
+  if (saved.editor && saved.opener === undefined) delete config.opener;
+  return validateConfig(config);
+}
+
+function parseConfigValue(key, value) {
+  if (!CONFIG_KEYS.includes(key)) {
+    throw new Error(`Unknown config key: ${key}. Available keys: ${CONFIG_KEYS.join(', ')}`);
+  }
+  if (key === 'initializeGit') {
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+    throw new Error('initializeGit must be true or false.');
+  }
+  if (key === 'notify') {
+    const seconds = Number(value);
+    if (!Number.isInteger(seconds) || seconds < 0) {
+      throw new Error('notify must be a non-negative integer (seconds). Use 0 to disable.');
+    }
+    return seconds;
+  }
+  return value;
+}
+
+function saveConfig(config, options = {}) {
+  const file = options.file || CONFIG_FILE;
+  const fsImpl = options.fsImpl || fs;
+  const validated = validateConfig({ ...config });
+  fsImpl.mkdirSync(path.dirname(file), { recursive: true });
+  fsImpl.writeFileSync(file, `${JSON.stringify(validated, null, 2)}\n`);
+  return validated;
+}
+
+function setConfigValue(key, value, options = {}) {
+  const config = loadConfig(options);
+  if (key === 'editor') delete config.opener;
+  if (key === 'opener') delete config.editor;
+  config[key] = parseConfigValue(key, value);
+  return saveConfig(config, options);
+}
+
+module.exports = {
+  CONFIG_KEYS,
+  DEFAULT_CONFIG,
+  loadConfig,
+  parseConfigValue,
+  saveConfig,
+  setConfigValue,
+  validateConfig,
+};

package/src/constants.js

@@ -0,0 +1,23 @@
+// Copyright (c) 2026 bachbnt
+
+const LIFECYCLE_COMMANDS = [
+  'install', 'run', 'test', 'build', 'check', 'lint', 'format',
+  'outdated', 'upgrade', 'audit', 'clean', 'reset', 'open',
+];
+const SYSTEM_COMMANDS = [
+  'config', 'doctor', 'projects', 'recipes', 'openers', 'inspect', 'info', 'history', 'again',
+  'init', 'update', 'clone', 'mcp', 'completion', 'task', 'parallel', 'env', 'docker', 'trust',
+];
+const DEVICE_COMMANDS = ['devices', 'android', 'ios'];
+const FILTER_COMMANDS = ['run', 'test', 'build', 'check', 'lint', 'format', 'task'];
+const JSON_COMMANDS = [
+  'inspect', 'doctor', 'projects', 'history', 'recipes', 'openers', 'devices', 'config',
+];
+
+module.exports = {
+  DEVICE_COMMANDS,
+  FILTER_COMMANDS,
+  JSON_COMMANDS,
+  LIFECYCLE_COMMANDS,
+  SYSTEM_COMMANDS,
+};

package/src/devices/android.js

@@ -0,0 +1,89 @@
+// Copyright (c) 2026 bachbnt
+
+const childProcess = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function executeFile(executable, args, executeFileSync = childProcess.execFileSync) {
+  return executeFileSync(executable, args, {
+    encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'ignore'],
+  });
+}
+
+function parseAdbDevices(output) {
+  return output
+    .split('\n')
+    .slice(1)
+    .map((line) => line.trim().split(/\s+/))
+    .filter((parts) => parts.length === 2 && parts[1] === 'device')
+    .map((parts) => parts[0])
+    .filter((serial) => serial.startsWith('emulator-'));
+}
+
+function parseAvdNames(output) {
+  return output.split('\n').map((name) => name.trim()).filter(Boolean);
+}
+
+function parseAndroidRuntime(config) {
+  const image = config.match(/^image\.sysdir\.1\s*=\s*(.+)$/m)?.[1]?.trim();
+  return image ? image.replace(/^system-images\//, '').replace(/\/$/, '') : 'Android';
+}
+
+function getRunningAndroidDevices(options = {}) {
+  const executeFileSync = options.executeFileSync || childProcess.execFileSync;
+  const running = new Map();
+  try {
+    const serials = parseAdbDevices(executeFile('adb', ['devices'], executeFileSync));
+    for (const serial of serials) {
+      try {
+        const name = executeFile('adb', ['-s', serial, 'emu', 'avd', 'name'], executeFileSync)
+          .split('\n')[0]
+          .trim();
+        if (name) running.set(name, serial);
+      } catch (error) {
+        // The emulator may disappear while the list is being collected.
+      }
+    }
+  } catch (error) {
+    return running;
+  }
+  return running;
+}
+
+function getAndroidDevices(options = {}) {
+  const executeFileSync = options.executeFileSync || childProcess.execFileSync;
+  const readFileSync = options.readFileSync || fs.readFileSync;
+  const homeDirectory = options.homeDirectory || os.homedir();
+
+  try {
+    const running = getRunningAndroidDevices({ executeFileSync });
+    const names = parseAvdNames(executeFile('emulator', ['-list-avds'], executeFileSync));
+    return names.map((name) => {
+      let runtime = 'Android';
+      try {
+        const configPath = path.join(homeDirectory, '.android', 'avd', `${name}.avd`, 'config.ini');
+        runtime = parseAndroidRuntime(readFileSync(configPath, 'utf8'));
+      } catch (error) {
+        // Keep the generic runtime when the AVD config is unavailable.
+      }
+      return {
+        id: name,
+        name,
+        runtime,
+        status: running.has(name) ? 'Booted' : 'Shutdown',
+      };
+    });
+  } catch (error) {
+    return [];
+  }
+}
+
+module.exports = {
+  getAndroidDevices,
+  getRunningAndroidDevices,
+  parseAdbDevices,
+  parseAndroidRuntime,
+  parseAvdNames,
+};

package/src/devices/index.js

@@ -0,0 +1,14 @@
+// Copyright (c) 2026 bachbnt
+
+const { getAndroidDevices } = require('./android');
+const { getIOSDevices } = require('./ios');
+
+function formatDevice(device) {
+  return `${device.name} | ${device.runtime} | ${device.status}`;
+}
+
+module.exports = {
+  formatDevice,
+  getAndroidDevices,
+  getIOSDevices,
+};

package/src/devices/ios.js

@@ -0,0 +1,47 @@
+// Copyright (c) 2026 bachbnt
+
+const childProcess = require('child_process');
+
+function parseRuntime(runtime) {
+  return runtime
+    .replace(/^com\.apple\.CoreSimulator\.SimRuntime\./, '')
+    .replace(/-/g, ' ')
+    .replace(/(?<=\d) (?=\d)/g, '.');
+}
+
+function parseIOSDevices(output) {
+  const data = typeof output === 'string' ? JSON.parse(output) : output;
+  const result = [];
+  for (const [runtime, devices] of Object.entries(data.devices || {})) {
+    for (const device of devices) {
+      if (device.isAvailable && device.name) {
+        result.push({
+          id: device.udid,
+          name: device.name,
+          runtime: parseRuntime(runtime),
+          status: device.state || 'Shutdown',
+        });
+      }
+    }
+  }
+  return result;
+}
+
+function getIOSDevices(options = {}) {
+  const executeFileSync = options.executeFileSync || childProcess.execFileSync;
+  try {
+    const output = executeFileSync('xcrun', ['simctl', 'list', 'devices', 'available', '-j'], {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore'],
+    });
+    return parseIOSDevices(output);
+  } catch (error) {
+    return [];
+  }
+}
+
+module.exports = {
+  getIOSDevices,
+  parseIOSDevices,
+  parseRuntime,
+};

package/src/generators/clean-project.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 bachbnt
+
+const fs = require('fs');
+const path = require('path');
+
+const root = path.resolve(process.argv[2] || '.');
+const type = process.argv[3] || 'unknown';
+
+const CLEAN_TARGETS = {
+  node: ['dist', 'build', 'coverage', '.cache'],
+  react: ['dist', 'build', 'coverage', '.cache'],
+  vue: ['dist', 'coverage', '.cache'],
+  next: ['.next', 'out', 'coverage'],
+  nuxt: ['.nuxt', '.output', 'dist', 'coverage'],
+  nest: ['dist', 'coverage'],
+  express: ['dist', 'coverage'],
+  react_native: ['.expo', 'dist', 'coverage'],
+  react_native_cli: ['android/app/build', 'ios/build', 'coverage'],
+  python: ['build', 'dist', '.pytest_cache', '.mypy_cache', '.ruff_cache', '.tox', '.coverage'],
+  django: ['build', 'dist', '.pytest_cache', '.mypy_cache', '.ruff_cache', '.tox', '.coverage'],
+  fastapi: ['build', 'dist', '.pytest_cache', '.mypy_cache', '.ruff_cache', '.tox', '.coverage'],
+  flask: ['build', 'dist', '.pytest_cache', '.mypy_cache', '.ruff_cache', '.tox', '.coverage'],
+};
+
+const PYTHON_CACHE_DIRECTORIES = new Set(['__pycache__', '.pytest_cache', '.mypy_cache', '.ruff_cache']);
+const PYTHON_SKIP_DIRECTORIES = new Set(['.git', '.venv', '.tox', 'node_modules']);
+
+function removePythonCaches(directory) {
+  let entries;
+  try {
+    entries = fs.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(directory, entry.name);
+    if (entry.isDirectory() && PYTHON_CACHE_DIRECTORIES.has(entry.name)) {
+      fs.rmSync(fullPath, { recursive: true, force: true });
+    } else if (entry.isDirectory() && !PYTHON_SKIP_DIRECTORIES.has(entry.name)) {
+      removePythonCaches(fullPath);
+    } else if (entry.isFile() && /\.py[co]$/.test(entry.name)) {
+      fs.rmSync(fullPath, { force: true });
+    }
+  }
+}
+
+for (const target of CLEAN_TARGETS[type] || CLEAN_TARGETS.node) {
+  fs.rmSync(path.join(root, target), { recursive: true, force: true });
+}
+
+if (['python', 'django', 'fastapi', 'flask'].includes(type)) removePythonCaches(root);

package/src/generators/python-project.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 bachbnt
+
+const fs = require('fs');
+const path = require('path');
+
+const framework = process.argv[2];
+const target = process.argv[3];
+const supported = ['django', 'fastapi', 'flask'];
+
+function write(relativePath, content) {
+  const file = path.join(target, relativePath);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content);
+}
+
+function pyproject(name, dependencies, options = {}) {
+  const devDependencies = ['pytest>=8,<10', 'build>=1.2,<2.0', ...(options.devDependencies || [])];
+  const pytestOptions = options.pytestOptions || '';
+  return `[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "${name}"
+version = "0.1.0"
+description = "${framework} project created by DevCmd"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+${dependencies.map((dependency) => `  "${dependency}",`).join('\n')}
+]
+
+[project.optional-dependencies]
+dev = [
+${devDependencies.map((dependency) => `  "${dependency}",`).join('\n')}
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+${pytestOptions}
+`;
+}
+
+function createBase() {
+  if (fs.existsSync(target)) {
+    throw new Error(`Target already exists: ${target}`);
+  }
+  fs.mkdirSync(target, { recursive: true });
+  write('.gitignore', `.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.coverage
+.env
+dist/
+build/
+*.egg-info/
+`);
+}
+
+function createDjango() {
+  write(
+    'pyproject.toml',
+    pyproject(target, ['Django>=5.2,<7.0'], {
+      devDependencies: ['pytest-django>=4.11,<5.0'],
+      pytestOptions: 'DJANGO_SETTINGS_MODULE = "config.settings"',
+    })
+  );
+  write('README.md', `# ${target}
+
+## Development
+
+\`\`\`bash
+source .venv/bin/activate
+python manage.py migrate
+python manage.py runserver
+\`\`\`
+
+Run tests with \`python manage.py test\` or \`pytest\`.
+`);
+  write('tests/test_project.py', `from django.conf import settings
+
+
+def test_django_project_is_configured() -> None:
+    assert settings.ROOT_URLCONF == "config.urls"
+`);
+}
+
+function createFastAPI() {
+  write('pyproject.toml', pyproject(target, ['fastapi[standard]>=0.115,<1.0', 'httpx>=0.27,<1.0']));
+  write('README.md', `# ${target}
+
+## Development
+
+\`\`\`bash
+source .venv/bin/activate
+fastapi dev app/main.py
+\`\`\`
+
+Run tests with \`pytest\`.
+`);
+  write('app/__init__.py', '');
+  write('app/main.py', `from fastapi import FastAPI
+
+app = FastAPI(title="${target}")
+
+
+@app.get("/")
+async def root() -> dict[str, str]:
+    return {"message": "Hello from ${target}"}
+`);
+  write('tests/test_main.py', `from fastapi.testclient import TestClient
+
+from app.main import app
+
+
+client = TestClient(app)
+
+
+def test_root() -> None:
+    response = client.get("/")
+    assert response.status_code == 200
+    assert response.json() == {"message": "Hello from ${target}"}
+`);
+}
+
+function createFlask() {
+  write('pyproject.toml', pyproject(target, ['Flask>=3.1,<4.0']));
+  write('README.md', `# ${target}
+
+## Development
+
+\`\`\`bash
+source .venv/bin/activate
+flask --app app run --debug
+\`\`\`
+
+Run tests with \`pytest\`.
+`);
+  write('app/__init__.py', `from flask import Flask
+
+
+def create_app() -> Flask:
+    app = Flask(__name__)
+
+    @app.get("/")
+    def index() -> dict[str, str]:
+        return {"message": "Hello from ${target}"}
+
+    return app
+`);
+  write('tests/test_app.py', `from app import create_app
+
+
+def test_index() -> None:
+    client = create_app().test_client()
+    response = client.get("/")
+    assert response.status_code == 200
+    assert response.get_json() == {"message": "Hello from ${target}"}
+`);
+}
+
+try {
+  if (!supported.includes(framework) || !target) {
+    throw new Error(`Usage: python-project.js <${supported.join('|')}> <target>`);
+  }
+  createBase();
+  if (framework === 'django') createDjango();
+  if (framework === 'fastapi') createFastAPI();
+  if (framework === 'flask') createFlask();
+} catch (error) {
+  console.error(`Unable to create ${framework || 'Python'} project: ${error.message}`);
+  process.exitCode = 1;
+}

package/src/generators/reset-project.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 bachbnt
+
+const fs = require('fs');
+const path = require('path');
+
+const root = path.resolve(process.argv[2] || '.');
+const type = process.argv[3] || 'unknown';
+
+const PYTHON_TYPES = new Set(['python', 'django', 'fastapi', 'flask']);
+
+const target = PYTHON_TYPES.has(type)
+  ? path.join(root, '.venv')
+  : path.join(root, 'node_modules');
+
+fs.rmSync(target, { recursive: true, force: true });