@bachbntdev/devcmd 0.0.0-stage → 2.7.1

package/src/openers/schema.js

@@ -0,0 +1,81 @@
+// Copyright (c) 2026 bachbnt
+
+const path = require('node:path');
+
+const NAME_PATTERN = /^[a-z][a-z0-9_]*$/;
+const PLATFORMS = new Set(['darwin', 'linux', 'win32']);
+const TARGETS = new Set(['project', 'android', 'xcode']);
+const FORBIDDEN_NAMES = new Set(['recent', 'list', 'validate']);
+const FORBIDDEN_SHELLS = new Set(['sh', 'bash', 'zsh', 'fish', 'cmd', 'cmd.exe', 'powershell', 'pwsh']);
+
+function assertObject(value, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`${label} must be an object.`);
+  }
+}
+
+function validateName(value, label) {
+  if (!NAME_PATTERN.test(value || '') || FORBIDDEN_NAMES.has(value)) {
+    throw new Error(`${label} must use lowercase letters, numbers, and underscores and must not be reserved.`);
+  }
+}
+
+function validateCommand(command, label) {
+  assertObject(command, label);
+  if (Object.keys(command).some((key) => !['executable', 'args', 'cwd'].includes(key))) {
+    throw new Error(`${label} contains unsupported fields.`);
+  }
+  if (typeof command.executable !== 'string' || !command.executable.trim()) {
+    throw new Error(`${label}.executable must be a non-empty string.`);
+  }
+  if (command.executable.includes('{')) {
+    throw new Error(`${label}.executable cannot contain placeholders.`);
+  }
+  if (FORBIDDEN_SHELLS.has(path.basename(command.executable).toLowerCase())) {
+    throw new Error(`${label} cannot use a shell executable.`);
+  }
+  if (!Array.isArray(command.args) || command.args.some((arg) => typeof arg !== 'string')) {
+    throw new Error(`${label}.args must be an array of strings.`);
+  }
+  if (command.cwd !== undefined && typeof command.cwd !== 'string') {
+    throw new Error(`${label}.cwd must be a string.`);
+  }
+}
+
+function validateOpener(opener) {
+  assertObject(opener, 'Opener');
+  const allowed = ['name', 'aliases', 'description', 'target', 'platforms'];
+  const unknown = Object.keys(opener).filter((key) => !allowed.includes(key));
+  if (unknown.length > 0) throw new Error(`Opener contains unsupported fields: ${unknown.join(', ')}`);
+
+  validateName(opener.name, 'Opener name');
+  if (opener.aliases !== undefined) {
+    if (!Array.isArray(opener.aliases) || opener.aliases.length === 0) {
+      throw new Error(`Opener ${opener.name} aliases must be a non-empty array.`);
+    }
+    const aliases = new Set();
+    for (const alias of opener.aliases) {
+      validateName(alias, `Opener ${opener.name} alias`);
+      if (alias === opener.name || aliases.has(alias)) {
+        throw new Error(`Opener ${opener.name} contains a duplicate alias: ${alias}`);
+      }
+      aliases.add(alias);
+    }
+  }
+  if (typeof opener.description !== 'string' || !opener.description.trim()) {
+    throw new Error(`Opener ${opener.name} requires a description.`);
+  }
+  if (!TARGETS.has(opener.target || 'project')) {
+    throw new Error(`Opener ${opener.name} target must be one of: ${[...TARGETS].join(', ')}`);
+  }
+  assertObject(opener.platforms, `Opener ${opener.name} platforms`);
+  const entries = Object.entries(opener.platforms);
+  if (entries.length === 0) throw new Error(`Opener ${opener.name} requires at least one platform.`);
+  for (const [platform, command] of entries) {
+    if (!PLATFORMS.has(platform)) throw new Error(`Opener ${opener.name} has unsupported platform: ${platform}`);
+    validateCommand(command, `Opener ${opener.name} platform ${platform}`);
+  }
+  return opener;
+}
+
+module.exports = { validateOpener };

package/src/projects/adapters/android.js

@@ -0,0 +1,24 @@
+// Copyright (c) 2026 bachbnt
+
+const { createCommand } = require('../../runner/command');
+const { unsupported } = require('./common');
+
+function gradle(project, tasks) {
+  const executable = process.platform === 'win32' ? 'gradlew.bat' : './gradlew';
+  return createCommand(executable, tasks, { cwd: project.root });
+}
+
+function build(action, project) {
+  if (action === 'install' || action === 'run') return [gradle(project, ['installDebug'])];
+  if (action === 'test') return [gradle(project, ['test'])];
+  if (action === 'build') return [gradle(project, ['assembleDebug'])];
+  if (action === 'clean') return [gradle(project, ['clean'])];
+  if (action === 'check') return [gradle(project, ['lint', 'test'])];
+  return unsupported(action, project);
+}
+
+module.exports = {
+  build,
+  id: 'android',
+  matches: (project) => project.type === 'android',
+};

package/src/projects/adapters/common.js

@@ -0,0 +1,24 @@
+// Copyright (c) 2026 bachbnt
+
+const path = require('path');
+const { createCommand } = require('../../runner/command');
+
+function internalCleaner(project) {
+  const cleaner = path.join(__dirname, '..', '..', 'generators', 'clean-project.js');
+  return [createCommand(process.execPath, [cleaner, project.root, project.type])];
+}
+
+function internalResetter(project) {
+  const resetter = path.join(__dirname, '..', '..', 'generators', 'reset-project.js');
+  return [createCommand(process.execPath, [resetter, project.root, project.type])];
+}
+
+function unsupported(action, project) {
+  throw new Error(`dev ${action} is not supported for detected project type: ${project.type}.`);
+}
+
+module.exports = {
+  internalCleaner,
+  internalResetter,
+  unsupported,
+};

package/src/projects/adapters/flutter.js

@@ -0,0 +1,29 @@
+// Copyright (c) 2026 bachbnt
+
+const { createCommand } = require('../../runner/command');
+const { unsupported } = require('./common');
+
+function command(project, args) {
+  return createCommand('flutter', args, { cwd: project.root });
+}
+
+function build(action, project) {
+  if (action === 'install') return [command(project, ['pub', 'get'])];
+  if (action === 'run') return [command(project, ['run'])];
+  if (action === 'test') return [command(project, ['test'])];
+  if (action === 'build') return [command(project, ['build', 'apk'])];
+  if (action === 'reset') return [command(project, ['clean']), command(project, ['pub', 'get'])];
+  if (action === 'clean') return [command(project, ['clean'])];
+  if (action === 'lint') return [command(project, ['analyze'])];
+  if (action === 'format') return [createCommand('dart', ['format', '.'], { cwd: project.root })];
+  if (action === 'outdated') return [command(project, ['pub', 'outdated'])];
+  if (action === 'upgrade') return [command(project, ['pub', 'upgrade'])];
+  if (action === 'check') return [command(project, ['analyze']), command(project, ['test'])];
+  return unsupported(action, project);
+}
+
+module.exports = {
+  build,
+  id: 'flutter',
+  matches: (project) => project.type === 'flutter',
+};

package/src/projects/adapters/index.js

@@ -0,0 +1,30 @@
+// Copyright (c) 2026 bachbnt
+
+const node = require('./node');
+const python = require('./python');
+const flutter = require('./flutter');
+const android = require('./android');
+const ios = require('./ios');
+const recipe = require('./recipe');
+
+const adapters = [node, python, flutter, android, ios];
+
+function getProjectAdapter(project) {
+  if (project.recipe?.lifecycle?.adapter) {
+    const configured = adapters.find((candidate) => candidate.id === project.recipe.lifecycle.adapter);
+    if (!configured) {
+      throw new Error(`Unknown lifecycle adapter: ${project.recipe.lifecycle.adapter}.`);
+    }
+    return configured;
+  }
+  if (recipe.matches(project)) return recipe;
+  const adapter = adapters.find((candidate) => candidate.matches(project));
+  if (!adapter) throw new Error(`No lifecycle adapter is available for project type: ${project.type}.`);
+  return adapter;
+}
+
+module.exports = {
+  adapters,
+  getProjectAdapter,
+  recipe,
+};

package/src/projects/adapters/ios.js

@@ -0,0 +1,35 @@
+// Copyright (c) 2026 bachbnt
+
+const { createCommand } = require('../../runner/command');
+const { unsupported } = require('./common');
+
+function baseArgs(project) {
+  return project.xcode.kind === 'workspace'
+    ? ['-workspace', project.xcode.file]
+    : ['-project', project.xcode.file];
+}
+
+function xcodebuild(project, action) {
+  return createCommand('xcodebuild', [...baseArgs(project), action], { cwd: project.root });
+}
+
+function build(action, project) {
+  if (action === 'install') {
+    return [createCommand('xcodebuild', [...baseArgs(project), '-resolvePackageDependencies'], { cwd: project.root })];
+  }
+  if (action === 'reset') {
+    return [xcodebuild(project, 'clean'), createCommand('xcodebuild', [...baseArgs(project), '-resolvePackageDependencies'], { cwd: project.root })];
+  }
+  if (['build', 'test', 'clean'].includes(action)) return [xcodebuild(project, action)];
+  if (action === 'check') return [xcodebuild(project, 'analyze'), xcodebuild(project, 'build')];
+  if (action === 'run') {
+    throw new Error('Automatic iOS run requires a scheme and destination. Use dev open ios for now.');
+  }
+  return unsupported(action, project);
+}
+
+module.exports = {
+  build,
+  id: 'ios',
+  matches: (project) => project.type === 'ios',
+};

package/src/projects/adapters/node.js

@@ -0,0 +1,112 @@
+// Copyright (c) 2026 bachbnt
+
+const fs = require('fs');
+const path = require('path');
+const { createCommand } = require('../../runner/command');
+const { resolveWorkspace } = require('../workspaces');
+const { internalCleaner, internalResetter, unsupported } = require('./common');
+
+function runScript(project, script, workspace) {
+  const manager = project.packageManager;
+  if (workspace && manager === 'pnpm') {
+    return createCommand(manager, ['--filter', workspace.name, 'run', script], { cwd: project.root });
+  }
+  if (workspace && manager === 'yarn') {
+    return createCommand(manager, ['workspace', workspace.name, 'run', script], { cwd: project.root });
+  }
+  if (workspace) {
+    return createCommand(manager, ['run', script, '--workspace', workspace.name], { cwd: project.root });
+  }
+  return createCommand(manager, ['run', script], { cwd: project.root });
+}
+
+function scriptsOf(project, workspace) {
+  return (workspace?.packageJson || project.packageJson)?.scripts || {};
+}
+
+function findScript(project, names, workspace) {
+  const scripts = scriptsOf(project, workspace);
+  return names.find((name) => scripts[name]);
+}
+
+function requireScript(project, names, action, workspace) {
+  const script = findScript(project, names, workspace);
+  if (!script) {
+    const where = workspace ? ` in workspace ${workspace.name}` : '';
+    throw new Error(
+      `No package.json script is available for dev ${action}${where}. Expected: ${names.join(' or ')}.`
+    );
+  }
+  return script;
+}
+
+function packageManagerCommand(project, args) {
+  return [createCommand(project.packageManager, args, { cwd: project.root })];
+}
+
+function yarnBerry(project) {
+  return fs.existsSync(path.join(project.root, '.yarnrc.yml'));
+}
+
+function scriptCommands(project, script, filter) {
+  const workspace = filter ? resolveWorkspace(project, filter) : undefined;
+  if (!scriptsOf(project, workspace)[script]) {
+    const where = workspace ? ` in workspace ${workspace.name}` : '';
+    throw new Error(`Unknown task: ${script}${where}. Run dev task to list available tasks.`);
+  }
+  return [runScript(project, script, workspace)];
+}
+
+const FILTERABLE_ACTIONS = new Set(['run', 'test', 'build', 'check', 'lint', 'format']);
+
+function build(action, project, context = {}) {
+  if (context.filter && !FILTERABLE_ACTIONS.has(action)) {
+    throw new Error(`--filter is not supported by dev ${action}.`);
+  }
+  const workspace = context.filter ? resolveWorkspace(project, context.filter) : undefined;
+  const manager = project.packageManager;
+
+  if (action === 'install') return packageManagerCommand(project, ['install']);
+  if (action === 'run') return [runScript(project, requireScript(project, ['dev', 'start'], action, workspace), workspace)];
+  if (action === 'test') return [runScript(project, requireScript(project, ['test'], action, workspace), workspace)];
+  if (action === 'build') return [runScript(project, requireScript(project, ['build'], action, workspace), workspace)];
+  if (action === 'format') return [runScript(project, requireScript(project, ['format'], action, workspace), workspace)];
+  if (action === 'lint') {
+    const names = context.fix ? ['lint:fix'] : ['lint'];
+    return [runScript(project, requireScript(project, names, action, workspace), workspace)];
+  }
+  if (action === 'reset') {
+    return [...internalResetter(project), createCommand(manager, ['install'], { cwd: project.root })];
+  }
+  if (action === 'clean') {
+    return project.packageJson.scripts?.clean ? [runScript(project, 'clean')] : internalCleaner(project);
+  }
+  if (action === 'check') {
+    const scripts = ['lint', 'typecheck', 'test', 'build'].filter(
+      (script) => scriptsOf(project, workspace)[script]
+    );
+    if (scripts.length === 0) {
+      throw new Error('No quality scripts were found. Add one of: lint, typecheck, test, build.');
+    }
+    return scripts.map((script) => runScript(project, script, workspace));
+  }
+  if (action === 'outdated') return packageManagerCommand(project, ['outdated']);
+  if (action === 'upgrade') {
+    return packageManagerCommand(project, [manager === 'yarn' ? 'upgrade' : 'update']);
+  }
+  if (action === 'audit') {
+    return packageManagerCommand(
+      project,
+      manager === 'yarn' && yarnBerry(project) ? ['npm', 'audit'] : ['audit']
+    );
+  }
+  return unsupported(action, project);
+}
+
+module.exports = {
+  build,
+  findScript,
+  id: 'node',
+  scriptCommands,
+  matches: (project) => Boolean(project.packageJson),
+};

package/src/projects/adapters/python.js

@@ -0,0 +1,90 @@
+// Copyright (c) 2026 bachbnt
+
+const fs = require('fs');
+const path = require('path');
+const { createCommand } = require('../../runner/command');
+const { internalCleaner, internalResetter, unsupported } = require('./common');
+
+const TYPES = ['python', 'django', 'fastapi', 'flask'];
+
+function venvPython(project) {
+  const relative = process.platform === 'win32'
+    ? path.join('.venv', 'Scripts', 'python.exe')
+    : path.join('.venv', 'bin', 'python');
+  return path.join(project.root, relative);
+}
+
+function pyprojectContent(project) {
+  try {
+    return fs.readFileSync(path.join(project.root, 'pyproject.toml'), 'utf8').toLowerCase();
+  } catch (error) {
+    return '';
+  }
+}
+
+function build(action, project, context) {
+  const config = context.config;
+  const venvExecutable = venvPython(project);
+  const venvExists = fs.existsSync(venvExecutable);
+  const python = venvExists ? venvExecutable : config.python;
+
+  if (action === 'install') {
+    const commands = [];
+    if (!venvExists) {
+      commands.push(createCommand(config.python, ['-m', 'venv', '.venv'], { cwd: project.root }));
+    }
+    commands.push(createCommand(venvExecutable, ['-m', 'pip', 'install', '-e', '.[dev]'], { cwd: project.root }));
+    return commands;
+  }
+  if (action === 'run' && project.type === 'django') {
+    return [createCommand(python, ['manage.py', 'runserver'], { cwd: project.root })];
+  }
+  if (action === 'run' && project.type === 'fastapi') {
+    return [createCommand(python, ['-m', 'fastapi', 'dev', 'app/main.py'], { cwd: project.root })];
+  }
+  if (action === 'run' && project.type === 'flask') {
+    return [createCommand(python, ['-m', 'flask', '--app', 'app', 'run', '--debug'], { cwd: project.root })];
+  }
+  if (action === 'test') return [createCommand(python, ['-m', 'pytest'], { cwd: project.root })];
+  if (action === 'lint') {
+    const args = ['-m', 'ruff', 'check', ...(context.fix ? ['--fix'] : []), '.'];
+    return [createCommand(python, args, { cwd: project.root })];
+  }
+  if (action === 'format') return [createCommand(python, ['-m', 'ruff', 'format', '.'], { cwd: project.root })];
+  if (action === 'outdated') {
+    return [createCommand(python, ['-m', 'pip', 'list', '--outdated'], { cwd: project.root })];
+  }
+  if (action === 'upgrade') {
+    return [createCommand(python, ['-m', 'pip', 'install', '--upgrade', '-e', '.[dev]'], { cwd: project.root })];
+  }
+  if (action === 'audit') return [createCommand(python, ['-m', 'pip_audit'], { cwd: project.root })];
+  if (action === 'build') return [createCommand(python, ['-m', 'build'], { cwd: project.root })];
+  if (action === 'reset') {
+    return [
+      ...internalResetter(project),
+      createCommand(config.python, ['-m', 'venv', '.venv'], { cwd: project.root }),
+      createCommand(venvPython(project), ['-m', 'pip', 'install', '-e', '.[dev]'], { cwd: project.root }),
+    ];
+  }
+  if (action === 'clean') return internalCleaner(project);
+  if (action === 'check') {
+    const commands = [];
+    const pyproject = pyprojectContent(project);
+    if (/\bruff\b/.test(pyproject)) {
+      commands.push(createCommand(python, ['-m', 'ruff', 'check', '.'], { cwd: project.root }));
+    }
+    commands.push(
+      createCommand(python, ['-m', 'pytest'], { cwd: project.root }),
+      createCommand(python, ['-m', 'build'], { cwd: project.root })
+    );
+    return commands;
+  }
+  return unsupported(action, project);
+}
+
+module.exports = {
+  build,
+  id: 'python',
+  matches: (project) => TYPES.includes(project.type),
+  venvPython,
+};

package/src/projects/adapters/recipe.js

@@ -0,0 +1,13 @@
+// Copyright (c) 2026 bachbnt
+
+const { buildRecipeLifecycleCommands } = require('../../recipes');
+
+function build(action, project, context) {
+  return buildRecipeLifecycleCommands(project.recipe, action, project, context);
+}
+
+module.exports = {
+  build,
+  id: 'recipe',
+  matches: (project) => Boolean(project.recipe?.lifecycle && !project.recipe.lifecycle.adapter),
+};

package/src/projects/detect.js

@@ -0,0 +1,187 @@
+// Copyright (c) 2026 bachbnt
+
+const fs = require('fs');
+const path = require('path');
+const { builtInRegistry } = require('../recipes');
+const { loadProfile } = require('./profile');
+const { findWorkspaces } = require('./workspaces');
+
+function exists(root, name, fsImpl = fs) {
+  return fsImpl.existsSync(path.join(root, name));
+}
+
+function readJson(file, fsImpl = fs) {
+  try {
+    return JSON.parse(fsImpl.readFileSync(file, 'utf8'));
+  } catch (error) {
+    throw new Error(`Invalid JSON in ${file}: ${error.message}`);
+  }
+}
+
+function detectPackageManager(root, packageJson = {}, fsImpl = fs) {
+  if (exists(root, 'pnpm-lock.yaml', fsImpl)) return 'pnpm';
+  if (exists(root, 'yarn.lock', fsImpl)) return 'yarn';
+  if (exists(root, 'package-lock.json', fsImpl)) return 'npm';
+  const declared = packageJson.packageManager?.split('@')[0];
+  return ['npm', 'pnpm', 'yarn'].includes(declared) ? declared : 'npm';
+}
+
+function detectNodeType(packageJson) {
+  const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+  if (dependencies.next) return 'next';
+  if (dependencies.nuxt) return 'nuxt';
+  if (dependencies['@nestjs/core']) return 'nest';
+  if (dependencies.expo) return 'react_native';
+  if (dependencies['react-native']) return 'react_native_cli';
+  if (dependencies.vue) return 'vue';
+  if (dependencies.react) return 'react';
+  if (dependencies.express) return 'express';
+  return 'node';
+}
+
+function readText(root, file, fsImpl = fs) {
+  try {
+    return fsImpl.readFileSync(path.join(root, file), 'utf8').toLowerCase();
+  } catch (error) {
+    return undefined;
+  }
+}
+
+function recipeRuleMatches(root, rule, packageJson, fsImpl = fs) {
+  if (rule.files && !rule.files.every((file) => exists(root, file, fsImpl))) return false;
+  if (rule.dependencies) {
+    if (!packageJson) return false;
+    const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    if (!rule.dependencies.every((name) => dependencies[name])) return false;
+  }
+  if (rule.contains && !Object.entries(rule.contains).every(([file, text]) => {
+    const content = readText(root, file, fsImpl);
+    return content !== undefined && content.includes(text.toLowerCase());
+  })) return false;
+  return true;
+}
+
+function detectRecipeAtRoot(root, registry, packageJson, fsImpl = fs) {
+  const candidates = [...registry.values()]
+    .filter((recipe) => recipe.detect)
+    .sort((left, right) => (right.detect.priority || 0) - (left.detect.priority || 0));
+  return candidates.find((recipe) =>
+    recipe.detect.rules.some((rule) => recipeRuleMatches(root, rule, packageJson, fsImpl))
+  );
+}
+
+function readPyproject(root, fsImpl = fs) {
+  try {
+    return fsImpl.readFileSync(path.join(root, 'pyproject.toml'), 'utf8').toLowerCase();
+  } catch (error) {
+    return '';
+  }
+}
+
+function findXcodeContainer(root, fsImpl = fs) {
+  try {
+    const entries = fsImpl.readdirSync(root);
+    const workspace = entries.find((entry) => entry.endsWith('.xcworkspace'));
+    if (workspace) return { kind: 'workspace', file: workspace };
+    const project = entries.find((entry) => entry.endsWith('.xcodeproj'));
+    if (project) return { kind: 'project', file: project };
+  } catch (error) {
+    return undefined;
+  }
+  return undefined;
+}
+
+function detectBase(root, fsImpl = fs, registry = builtInRegistry) {
+  const packageJson = exists(root, 'package.json', fsImpl)
+    ? readJson(path.join(root, 'package.json'), fsImpl)
+    : undefined;
+  const recipe = detectRecipeAtRoot(root, registry, packageJson, fsImpl);
+  if (recipe) {
+    return {
+      type: recipe.name,
+      name: packageJson?.name || path.basename(root),
+      root,
+      packageJson,
+      workspaces: packageJson ? findWorkspaces(root, packageJson, fsImpl) : [],
+      packageManager: packageJson ? detectPackageManager(root, packageJson, fsImpl) : undefined,
+      recipe,
+    };
+  }
+
+  if (packageJson) {
+    const type = detectNodeType(packageJson);
+    return {
+      type,
+      name: packageJson.name || path.basename(root),
+      root,
+      packageJson,
+      workspaces: findWorkspaces(root, packageJson, fsImpl),
+      packageManager: detectPackageManager(root, packageJson, fsImpl),
+      recipe: registry.get(type),
+    };
+  }
+
+  if (exists(root, 'pubspec.yaml', fsImpl)) {
+    return { type: 'flutter', name: path.basename(root), root, recipe: registry.get('flutter') };
+  }
+
+  if (exists(root, 'gradlew', fsImpl) || exists(root, 'gradlew.bat', fsImpl)) {
+    return { type: 'android', name: path.basename(root), root };
+  }
+
+  const xcode = findXcodeContainer(root, fsImpl);
+  if (xcode) return { type: 'ios', name: path.basename(root), root, xcode };
+
+  if (exists(root, 'manage.py', fsImpl)) {
+    return { type: 'django', name: path.basename(root), root, recipe: registry.get('django') };
+  }
+
+  if (exists(root, 'pyproject.toml', fsImpl)) {
+    const pyproject = readPyproject(root, fsImpl);
+    let type = 'python';
+    if (/\bfastapi(?:\[|[<>=\s"])/.test(pyproject)) type = 'fastapi';
+    else if (/\bflask(?:[<>=\s"])/.test(pyproject)) type = 'flask';
+    else if (/\bdjango(?:[<>=\s"])/.test(pyproject)) type = 'django';
+    return { type, name: path.basename(root), root, recipe: registry.get(type) };
+  }
+
+  return undefined;
+}
+
+function detectAtRoot(root, fsImpl = fs, registry = builtInRegistry) {
+  const project = detectBase(root, fsImpl, registry);
+  const profile = loadProfile(root, fsImpl);
+  if (!profile) return project;
+  if (project) return { ...project, profile };
+  return { type: 'custom', name: profile.name || path.basename(root), root, profile };
+}
+
+function detectProject(start = process.cwd(), options = {}) {
+  const fsImpl = options.fsImpl || fs;
+  const registry = options.registry || builtInRegistry;
+  let current = path.resolve(start);
+  try {
+    if (!fsImpl.statSync(current).isDirectory()) current = path.dirname(current);
+  } catch (error) {
+    throw new Error(`Project path does not exist: ${current}`);
+  }
+
+  while (true) {
+    const project = detectAtRoot(current, fsImpl, registry);
+    if (project) return project;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  throw new Error(`No supported project was detected from: ${path.resolve(start)}`);
+}
+
+module.exports = {
+  detectAtRoot,
+  detectRecipeAtRoot,
+  detectNodeType,
+  detectPackageManager,
+  detectProject,
+  findXcodeContainer,
+  recipeRuleMatches,
+};