scaffy-tool 0.1.1

package/core/detector.js

@@ -0,0 +1,198 @@
+const { execSync } = require('child_process');
+const os = require('os');
+const semver = require('semver');
+const chalk = require('chalk');
+
+const getOS = () => {
+  const platform = os.platform();
+  if (platform === 'darwin') return 'mac';
+  if (platform === 'win32') return 'windows';
+  return 'linux';
+};
+
+const runCommand = command => {
+  try {
+    return {
+      success: true,
+      output: execSync(command, {
+        stdio: 'pipe',
+        timeout: 5000,
+      }).toString(),
+    };
+  } catch (error) {
+    return {
+      success: false,
+      output: '',
+    };
+  }
+};
+
+const parseVersionFromOutput = (output, parseVersion) => {
+  if (!parseVersion || !output) return null;
+  const match = output.match(new RegExp(parseVersion));
+  return match ? match[1] : null;
+};
+
+const satisfiesMinVersion = (installedVersion, minVersion) => {
+  if (!installedVersion || !minVersion) return true;
+  const clean = semver.coerce(installedVersion);
+  if (!clean) return true;
+  return semver.gte(clean, minVersion);
+};
+
+const buildToolResult = (tool, installed, versionOk, extra = {}) => ({
+  tool,
+  installed,
+  versionOk,
+  ...extra,
+});
+
+const checkTool = requirement => {
+  const { tool, checkCommand, parseVersion, minVersion } = requirement;
+
+  const { success, output } = runCommand(checkCommand);
+
+  if (!success) {
+    return buildToolResult(tool, false, false);
+  }
+
+  if (!parseVersion || !minVersion) {
+    return buildToolResult(tool, true, true);
+  }
+
+  const installedVersion = parseVersionFromOutput(output, parseVersion);
+
+  if (!installedVersion) {
+    return buildToolResult(tool, true, true);
+  }
+
+  const versionOk = satisfiesMinVersion(installedVersion, minVersion);
+
+  return buildToolResult(tool, true, versionOk, {
+    installedVersion,
+    ...(!versionOk && { requiredVersion: minVersion }),
+  });
+};
+
+const checkAll = requirements => {
+  const results = requirements.map(req => ({
+    ...checkTool(req),
+    installGuide: req.installGuide,
+  }));
+
+  const allPassed = results.every(r => r.installed && r.versionOk);
+
+  return { allPassed, results };
+};
+
+const formatToolStatus = result => {
+  if (result.installed && result.versionOk) {
+    return chalk.green(`  ✅ ${result.tool}`) + chalk.gray(' — found');
+  }
+
+  if (result.installed && !result.versionOk) {
+    return (
+      chalk.yellow(`  ⚠️  ${result.tool}`) +
+      chalk.gray(
+        ` — v${result.installedVersion} found,` +
+          ` v${result.requiredVersion}+ required`
+      )
+    );
+  }
+
+  return chalk.red(`  ❌ ${result.tool}`) + chalk.gray(' — not found');
+};
+
+const formatInstallGuide = (guide, currentOS) => {
+  if (!guide) return [];
+
+  const lines = [];
+
+  if (guide[currentOS]) {
+    lines.push(chalk.cyan(`     💻 Install: `) + chalk.white(guide[currentOS]));
+  }
+
+  if (guide.docs) {
+    lines.push(chalk.cyan(`     📖 Docs: `) + chalk.underline(guide.docs));
+  }
+
+  return lines;
+};
+
+const formatResult = currentOS => result => {
+  const lines = [formatToolStatus(result)];
+
+  const needsGuide = !result.installed || !result.versionOk;
+
+  if (needsGuide) {
+    lines.push(...formatInstallGuide(result.installGuide, currentOS));
+  }
+
+  return lines.join('\n');
+};
+
+const formatFailureMessage = () =>
+  chalk.red(`
+    ──────────────────────────────────────────
+    ❌ Requirements not met.
+       Please install missing tools and retry.
+       Nothing was created. Your system is clean.
+    ──────────────────────────────────────────\n`);
+
+const formatSuccessMessage = () =>
+  chalk.green('\n  ✅ All requirements met!\n');
+
+const report = requirements => {
+  console.log(chalk.bold('\n🔍 Checking requirements...\n'));
+
+  const { allPassed, results } = checkAll(requirements);
+  const currentOS = getOS();
+
+  results.map(formatResult(currentOS)).forEach(line => console.log(line));
+
+  console.log(allPassed ? formatSuccessMessage() : formatFailureMessage());
+
+  return allPassed;
+};
+
+const detectAvailableChoices = async choices => {
+  if (!choices || choices.length === 0) return [];
+
+  const results = await Promise.all(
+    choices.map(async choice => {
+      try {
+        const { success, output } = runCommand(choice.checkCommand);
+
+        if (!success || !output || output.toString().trim() === '') {
+          return { ...choice, installed: false };
+        }
+
+        return { ...choice, installed: true };
+      } catch {
+        return { ...choice, installed: false };
+      }
+    })
+  );
+
+  const available = results.filter(c => c.installed);
+  return available.length > 0
+    ? available
+    : [{ ...choices[0], installed: false }];
+};
+
+module.exports = {
+  getOS,
+  runCommand,
+  parseVersionFromOutput,
+  satisfiesMinVersion,
+  buildToolResult,
+  checkTool,
+  checkAll,
+  formatToolStatus,
+  formatInstallGuide,
+  formatResult,
+  formatFailureMessage,
+  formatSuccessMessage,
+  report,
+  detectAvailableChoices,
+};

package/core/executor.js

@@ -0,0 +1,105 @@
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+const run = command =>
+  new Promise((resolve, reject) => {
+    console.log(chalk.gray(`\n  $ ${command}\n`));
+
+    const [cmd, ...args] = command.split(' ');
+
+    const child = spawn(cmd, args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    child.on('close', code => {
+      if (code !== 0) {
+        reject(new Error(`Command failed with exit code ${code}: ${command}`));
+      } else {
+        resolve();
+      }
+    });
+
+    child.on('error', err => {
+      reject(new Error(`Failed to run command: ${command}\n${err.message}`));
+    });
+  });
+
+const runInProject = (projectName, command) => {
+  console.log(chalk.gray(`\n  $ cd ${projectName} && ${command}\n`));
+
+  return new Promise((resolve, reject) => {
+    const [cmd, ...args] = command.split(' ');
+
+    const child = spawn(cmd, args, {
+      stdio: 'inherit',
+      shell: true,
+      cwd: path.join(process.cwd(), projectName),
+    });
+
+    child.on('close', code => {
+      if (code !== 0) {
+        reject(new Error(`Command failed with exit code ${code}: ${command}`));
+      } else {
+        resolve();
+      }
+    });
+
+    child.on('error', err => {
+      reject(new Error(`Failed to run command: ${command}\n${err.message}`));
+    });
+  });
+};
+
+const setEnv = (projectName, vars) => {
+  const envPath = path.join(process.cwd(), projectName, '.env');
+
+  if (!fs.existsSync(envPath)) {
+    throw new Error(`.env file not found in ${projectName}`);
+  }
+
+  let content = fs.readFileSync(envPath, 'utf8');
+
+  Object.entries(vars).forEach(([key, value]) => {
+    const regex = new RegExp(`^${key}=.*`, 'm');
+    if (regex.test(content)) {
+      content = content.replace(regex, `${key}=${value}`);
+    } else {
+      content += `\n${key}=${value}`;
+    }
+  });
+
+  fs.writeFileSync(envPath, content);
+};
+
+const appendToFile = (filePath, content) => {
+  const fullPath = path.join(process.cwd(), filePath);
+  const dir = path.dirname(fullPath);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.appendFileSync(fullPath, content);
+};
+
+const createFile = (filePath, content = '') => {
+  const fullPath = path.join(process.cwd(), filePath);
+  const dir = path.dirname(fullPath);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.writeFileSync(fullPath, content);
+};
+
+module.exports = {
+  run,
+  runInProject,
+  setEnv,
+  appendToFile,
+  createFile,
+};

package/core/interviewer.js

@@ -0,0 +1,140 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { getFrameworks, findFramework } = require('./registry');
+
+const baseQuestions = framework => [
+  {
+    type: 'input',
+    name: 'projectName',
+    message: 'Project name?',
+    default: `my-${framework.name.toLowerCase()}-app`,
+    validate: input => {
+      if (!input.trim()) {
+        return 'Project name is required';
+      }
+      if (!/^[a-z0-9-_]+$/.test(input)) {
+        return 'Use only lowercase letters, numbers, - and _';
+      }
+      return true;
+    },
+  },
+];
+
+const buildQuestions = (framework, pluginQuestions) => [
+  ...baseQuestions(framework),
+  ...pluginQuestions,
+];
+
+const buildFrameworkChoices = () =>
+  getFrameworks().map(f => ({
+    name:
+      `${f.name} ${chalk.gray(`(${f.language})`)} ` +
+      chalk.cyan(`— latest: ${f.latest}`),
+    value: f,
+  }));
+
+const buildVersionChoices = framework =>
+  framework.versions.map(v => ({
+    name: v === framework.latest ? `${v} ${chalk.cyan('(latest ⭐)')}` : v,
+    value: v,
+  }));
+
+const askFramework = async () => {
+  const { framework } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'framework',
+      message: 'Which framework?',
+      choices: buildFrameworkChoices(),
+    },
+  ]);
+  return framework;
+};
+
+const askVersion = async framework => {
+  if (framework.versions.length === 1) {
+    return framework.latest;
+  }
+
+  const { version } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'version',
+      message: 'Which version?',
+      choices: buildVersionChoices(framework),
+    },
+  ]);
+
+  return version;
+};
+
+const askDirectFramework = async query => {
+  const framework = findFramework(query);
+
+  if (!framework) {
+    console.log(chalk.red(`\n❌ Framework "${query}" not found.\n`));
+    console.log(
+      chalk.gray('  Run scaffy list to see all available frameworks.\n')
+    );
+    return null;
+  }
+
+  return framework;
+};
+
+const askFrameworkQuestions = async (framework, plugin) => {
+  console.log(chalk.bold(`\n🚀 Setting up ${framework.name}\n`));
+
+  const pluginQuestions =
+    typeof plugin.questions === 'function'
+      ? await plugin.questions()
+      : plugin.questions;
+
+  const questions = buildQuestions(framework, pluginQuestions);
+
+  const answers = await inquirer.prompt(questions);
+  return answers;
+};
+
+const handlePromptError = err => {
+  if (err.isTtyError) {
+    console.log(chalk.red('\n❌ Terminal not supported\n'));
+  } else {
+    console.log(chalk.yellow('\n👋 Scaffolding cancelled\n'));
+  }
+  process.exit(0);
+};
+
+const runInterview = async (framework, plugin) => {
+  try {
+    const version = await askVersion(framework);
+    const answers = await askFrameworkQuestions(framework, plugin);
+    return { version, answers };
+  } catch (err) {
+    handlePromptError(err);
+  }
+};
+
+const runInteractiveMode = async () => {
+  try {
+    const framework = await askFramework();
+    const version = await askVersion(framework);
+    return { framework, version };
+  } catch (err) {
+    handlePromptError(err);
+  }
+};
+
+module.exports = {
+  baseQuestions,
+  buildQuestions,
+  buildFrameworkChoices,
+  buildVersionChoices,
+  askFramework,
+  askVersion,
+  askDirectFramework,
+  askFrameworkQuestions,
+  handlePromptError,
+  runInterview,
+  runInteractiveMode,
+};

package/core/plugin-validator.js

@@ -0,0 +1,2 @@
+// TODO: Coming in Sprint 1
+module.exports = {};

package/core/registry.js

@@ -0,0 +1,128 @@
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+
+const REGISTRY_PATH = path.join(__dirname, '..', 'registry');
+const INDEX_PATH = path.join(REGISTRY_PATH, 'index.json');
+
+const loadIndex = () => {
+  try {
+    const raw = fs.readFileSync(INDEX_PATH, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+
+const getFrameworks = () => {
+  const index = loadIndex();
+  if (!index) {
+    console.log(chalk.red('❌ Failed to load registry/index.json'));
+    return [];
+  }
+  return index.frameworks;
+};
+
+const findFramework = query => {
+  const q = query.toLowerCase().trim();
+
+  return (
+    getFrameworks().find(
+      f =>
+        f.name.toLowerCase() === q || f.alias.some(a => a.toLowerCase() === q)
+    ) || null
+  );
+};
+
+const searchFrameworks = query => {
+  const q = query.toLowerCase().trim();
+
+  return getFrameworks().filter(
+    f =>
+      f.name.toLowerCase().includes(q) ||
+      f.language.toLowerCase().includes(q) ||
+      f.alias.some(a => a.toLowerCase().includes(q))
+  );
+};
+
+const groupByLanguage = frameworks =>
+  frameworks.reduce(
+    (acc, f) => ({
+      ...acc,
+      [f.language]: [...(acc[f.language] || []), f],
+    }),
+    {}
+  );
+
+const validatePluginFiles = (pluginPath, version) => {
+  const versionPath = path.join(pluginPath, version);
+
+  const requiredFiles = [
+    { path: path.join(pluginPath, 'plugin.json'), name: 'plugin.json' },
+    { path: path.join(versionPath, 'questions.js'), name: 'questions.js' },
+    { path: path.join(versionPath, 'scaffold.js'), name: 'scaffold.js' },
+  ];
+
+  const missing = requiredFiles
+    .filter(f => !fs.existsSync(f.path))
+    .map(f => f.name);
+
+  return {
+    valid: missing.length === 0,
+    missing,
+  };
+};
+
+const loadPlugin = (framework, version) => {
+  const pluginPath = path.join(REGISTRY_PATH, framework.path);
+  const versionPath = path.join(pluginPath, version);
+
+  const { valid, missing } = validatePluginFiles(pluginPath, version);
+
+  if (!valid) {
+    throw new Error(
+      `Missing files for ${framework.name} ${version}: ` + missing.join(', ')
+    );
+  }
+
+  return {
+    meta: require(path.join(pluginPath, 'plugin.json')),
+    questions: require(path.join(versionPath, 'questions.js')),
+    scaffold: require(path.join(versionPath, 'scaffold.js')),
+  };
+};
+
+const formatFrameworkLine = f =>
+  chalk.white(`    • ${f.name}`) +
+  chalk.gray(` (${f.alias.join(', ')}) — latest: ${f.latest}`);
+
+const displayFrameworks = () => {
+  const frameworks = getFrameworks();
+
+  if (frameworks.length === 0) {
+    console.log(chalk.red('\n❌ No frameworks found\n'));
+    return;
+  }
+
+  const grouped = groupByLanguage(frameworks);
+
+  console.log(chalk.bold('\n📦 Available Frameworks:\n'));
+
+  Object.entries(grouped).forEach(([lang, list]) => {
+    console.log(chalk.cyan(`  ${lang.toUpperCase()}`));
+    list.forEach(f => console.log(formatFrameworkLine(f)));
+    console.log('');
+  });
+};
+
+module.exports = {
+  loadIndex,
+  getFrameworks,
+  findFramework,
+  searchFrameworks,
+  groupByLanguage,
+  validatePluginFiles,
+  loadPlugin,
+  formatFrameworkLine,
+  displayFrameworks,
+};

package/core/utils.js

@@ -0,0 +1,63 @@
+const chalk = require('chalk');
+
+const log = message => {
+  console.log(chalk.white(`  ${message}`));
+};
+
+// ─── Success Message ───────────────────────────────────
+const success = message => {
+  console.log(chalk.green(`\n  ${message}\n`));
+};
+
+// ─── Warning Message ───────────────────────────────────
+const warn = message => {
+  console.log(chalk.yellow(`  ⚠️  ${message}`));
+};
+
+// ─── Error Message ─────────────────────────────────────
+const error = message => {
+  console.log(chalk.red(`  ❌ ${message}`));
+};
+
+// ─── Section Title ─────────────────────────────────────
+const title = message => {
+  console.log(chalk.cyan.bold(`\n  ── ${message} ──\n`));
+};
+
+// ─── Divider Line ──────────────────────────────────────
+const divider = () => {
+  console.log(chalk.gray('  ──────────────────────────────────────────'));
+};
+
+// ─── Step Indicator ────────────────────────────────────
+const step = (number, message) => {
+  console.log(chalk.cyan(`  [${number}]`) + chalk.white(` ${message}`));
+};
+
+// ─── Build Utils Object For Plugins ───────────────────
+const buildPluginUtils = executor => ({
+  run: executor.run,
+  runInProject: executor.runInProject,
+  setEnv: executor.setEnv,
+  appendToFile: executor.appendToFile,
+  createFile: executor.createFile,
+  log,
+  success,
+  warn,
+  error,
+  title,
+  step,
+  divider,
+});
+
+// ─── Exports ───────────────────────────────────────────
+module.exports = {
+  log,
+  success,
+  warn,
+  error,
+  title,
+  divider,
+  step,
+  buildPluginUtils,
+};