xgem-cli 2.0.0-alpha.1 → 2.0.0-alpha.10

package/lib/scaffold.sh

@@ -11,14 +11,14 @@
 #
 # Depends on lib/logger.sh and XGEM_HOME (set by bin/xgem).
 
-ALL_FRAMEWORKS=(flutter node python react vue angular go rust docker swift)
+ALL_FRAMEWORKS=(flutter node python react vue angular next go rust docker swift)
 
 framework_scripts() {
     case "$1" in
         flutter) echo "hard-clean build build-runner" ;;
         node)    echo "hard-clean build start" ;;
         python)  echo "hard-clean install" ;;
-        react|vue|angular) echo "hard-clean build dev" ;;
+        react|vue|angular|next) echo "hard-clean build dev" ;;
         go)      echo "hard-clean build" ;;
         rust)    echo "hard-clean build" ;;
         docker)  echo "hard-clean build-up" ;;
@@ -30,8 +30,8 @@ framework_scripts() {
 _scaffold_template_dir() {
     local framework=$1
     case "$framework" in
-        react|vue|angular) echo "$XGEM_HOME/templates/webframework" ;;
-        *)                 echo "$XGEM_HOME/templates/$framework" ;;
+        react|vue|angular|next) echo "$XGEM_HOME/templates/webframework" ;;
+        *)                      echo "$XGEM_HOME/templates/$framework" ;;
     esac
 }
 

package/lib/version.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 # xgem version info.
 
-XGEM_VERSION="2.0.0-alpha"
+XGEM_VERSION="2.0.0-alpha.10"
 
 print_version() {
     echo "xgem $XGEM_VERSION"

package/lib-win/doctor.js

@@ -0,0 +1,44 @@
+// xgem Windows engine doctor — mirrors lib/doctor.sh's general report.
+// No iOS/SwiftPM engine exists here (see flutter.js) since Xcode has no
+// Windows equivalent; `doctor ios` explains that instead of pretending.
+
+const { getVersion, detectArch } = require('./utils');
+const { paint } = require('./logger');
+
+function printGeneral() {
+    console.log(paint('cyan', '=== xgem doctor (Windows) ==='));
+    console.log(`OS:              win32`);
+    console.log(`Arch:            ${detectArch()}`);
+    console.log(`git:             ${getVersion('git') || 'not found'}`);
+    console.log(`flutter:         ${getVersion('flutter') || 'not found'}`);
+    console.log(`dart:            ${getVersion('dart') || 'not found'}`);
+    console.log(`node:            ${getVersion('node') || 'not found'}`);
+    console.log(`python:          ${getVersion('python') || getVersion('python3') || 'not found'}`);
+    console.log(`go:              ${getVersion('go', ['version']) || 'not found'}`);
+    console.log(`cargo:           ${getVersion('cargo') || 'not found'}`);
+    console.log(`docker:          ${getVersion('docker') || 'not found'}`);
+}
+
+function printIos() {
+    console.log(paint('cyan', '=== xgem doctor ios (Windows) ==='));
+    console.log(paint('yellow', 'iOS/macOS builds are not available on Windows — Xcode has no Windows equivalent.'));
+    console.log('Use WSL2 with a Mac, or a real Mac, for Flutter iOS builds.');
+    const flutterVersion = getVersion('flutter');
+    if (flutterVersion) {
+        console.log(`\nflutter is installed here (${flutterVersion}) and can still build Android/Windows targets:`);
+        console.log('  xgem run flutter build   (choose APK or Windows)');
+    }
+}
+
+function cmdDoctor(target) {
+    if (target === 'ios') {
+        printIos();
+    } else if (!target) {
+        printGeneral();
+    } else {
+        const { die } = require('./logger');
+        die(`Unknown doctor target '${target}'. Usage: xgem doctor [ios]`);
+    }
+}
+
+module.exports = { cmdDoctor, printGeneral, printIos };

package/lib-win/flutter.js

@@ -0,0 +1,101 @@
+// xgem Windows engine flutter commands. hard-clean/build-runner have no
+// platform-specific dependency and work as-is. build only offers targets
+// that are actually buildable from a Windows host (APK, Windows desktop) —
+// iOS/macOS need Xcode (a Mac), and Flutter can't cross-compile Linux
+// desktop from Windows either, so those fail fast with a clear message
+// instead of attempting anything.
+
+const fs = require('node:fs');
+const { spawnSync } = require('node:child_process');
+const { logInfo, logSuccess, logError, die } = require('./logger');
+const { prompt, requireCmd } = require('./utils');
+
+function flutter(args) {
+    return spawnSync('flutter', args, { stdio: 'inherit' });
+}
+
+async function cmdHardClean() {
+    requireCmd('flutter', 'Install Flutter: https://docs.flutter.dev/get-started/install/windows');
+    logInfo('Cleaning Flutter project...');
+    fs.rmSync('pubspec.lock', { force: true });
+    flutter(['clean']);
+    logInfo('Getting Flutter packages...');
+    flutter(['pub', 'get']);
+    logInfo('Running Flutter...');
+    flutter(['run', '-v']);
+}
+
+async function cmdBuildRunner() {
+    requireCmd('flutter', 'Install Flutter: https://docs.flutter.dev/get-started/install/windows');
+    logInfo('Running Flutter Build Runner...');
+    const verboseChoice = ((await prompt('Run in verbose mode? (Y/n)')) || 'Y').toLowerCase();
+    const args = ['pub', 'run', 'build_runner', 'build', '--delete-conflicting-outputs'];
+    if (verboseChoice === 'y') args.push('-v');
+    logInfo(`Executing: flutter ${args.join(' ')}`);
+    flutter(args);
+}
+
+function pubspecVersion() {
+    if (!fs.existsSync('pubspec.yaml')) return null;
+    const content = fs.readFileSync('pubspec.yaml', 'utf8');
+    const match = content.match(/^version:\s*(\S+)/m);
+    return match ? match[1] : null;
+}
+
+async function cmdBuild() {
+    requireCmd('flutter', 'Install Flutter: https://docs.flutter.dev/get-started/install/windows');
+    console.log('--- Flutter Build Orchestrator (Windows) ---');
+
+    let currentName = '';
+    let currentNum = '';
+    const currentFull = pubspecVersion();
+    if (currentFull) {
+        [currentName, currentNum = '1'] = currentFull.split('+');
+        logInfo(`Current pubspec.yaml version: ${currentFull}`);
+    }
+
+    const buildName = (await prompt('Enter build version name', currentName || '1.0.0'));
+    const buildNumber = (await prompt('Enter build number', currentNum || '1'));
+    const isRelease = ((await prompt('Is this a release build? (Y/n)', 'y'))).toLowerCase();
+
+    if (fs.existsSync('pubspec.yaml')) {
+        const newVersion = `${buildName}+${buildNumber}`;
+        logSuccess(`Updating pubspec.yaml to version: ${newVersion}`);
+        const content = fs.readFileSync('pubspec.yaml', 'utf8');
+        fs.writeFileSync('pubspec.yaml', content.replace(/^version:.*/m, `version: ${newVersion}`));
+    }
+
+    console.log('\nSelect Target Platform:');
+    console.log('1) APK (Android)');
+    console.log('2) App Bundle (Android, .aab — required for Play Store uploads)');
+    console.log('3) Windows');
+    console.log('(iOS/macOS require a Mac; Linux desktop can\'t be cross-built from Windows.)');
+    const platformChoice = await prompt('Choose [1-3]');
+
+    const mode = (isRelease === 'n') ? '--debug' : '--release';
+    const buildArgs = [`--build-name=${buildName}`, `--build-number=${buildNumber}`];
+
+    if (platformChoice === '1') {
+        logInfo(`Building APK (${mode})...`);
+        flutter(['build', 'apk', mode, ...buildArgs]);
+    } else if (platformChoice === '2') {
+        logInfo(`Building App Bundle (${mode})...`);
+        flutter(['build', 'appbundle', mode, ...buildArgs]);
+    } else if (platformChoice === '3') {
+        logInfo(`Building Windows desktop app (${mode})...`);
+        flutter(['build', 'windows', mode, ...buildArgs]);
+    } else {
+        die(`'${platformChoice}' isn't buildable from Windows. iOS/macOS need a Mac (xgem doctor ios explains more); Linux desktop needs a Linux host.`);
+    }
+}
+
+async function cmdFlutter(script) {
+    switch (script) {
+        case 'hard-clean': return cmdHardClean();
+        case 'build': return cmdBuild();
+        case 'build-runner': return cmdBuildRunner();
+        default: die(`No native flutter command for '${script}'.`);
+    }
+}
+
+module.exports = { cmdFlutter };

package/lib-win/git.js

@@ -0,0 +1,241 @@
+// xgem Windows engine git workflow — port of lib/git.sh (cmt/init/rm-remote/rm-branch).
+// git.exe behaves the same on Windows, so this is a straight port; the
+// commit-exit-code check and origin-preference fix already in lib/git.sh
+// carry over here too.
+
+const { spawnSync } = require('node:child_process');
+const { logInfo, logSuccess, logWarn, logError, die } = require('./logger');
+const { prompt } = require('./utils');
+
+function git(args, opts = {}) {
+    return spawnSync('git', args, { stdio: 'inherit', ...opts });
+}
+
+function gitCapture(args) {
+    const result = spawnSync('git', args, { encoding: 'utf8' });
+    return (result.stdout || '').trim();
+}
+
+function remoteExists(name) {
+    return gitCapture(['remote']).split(/\r?\n/).includes(name);
+}
+
+async function cmdCmt(commitMsg) {
+    if (!commitMsg) die('Missing commit message!');
+
+    logInfo('Checking repository status...');
+    git(['status', '-s']);
+    console.log('');
+
+    const addChoice = (await prompt('Do you want to add ALL files (a) or INDIVIDUAL files (i)? [a/i]')).toLowerCase();
+    if (addChoice === 'a') {
+        git(['add', '.']);
+        logSuccess('All files staged.');
+    } else if (addChoice === 'i') {
+        const files = await prompt('Enter specific file paths to add (space separated)');
+        const fileList = files.split(/\s+/).filter(Boolean);
+        if (fileList.length === 0) die('No files given.');
+        git(['add', ...fileList]);
+        logSuccess('Selected files staged.');
+    } else {
+        die('Invalid choice. Operation aborted.');
+    }
+
+    const hasStaged = spawnSync('git', ['diff', '--cached', '--quiet']).status !== 0;
+    if (!hasStaged) {
+        logWarn("Nothing staged to commit — checking whether there's anything already committed to sync.");
+    } else {
+        logInfo('Committing changes...');
+        const commitResult = git(['commit', '-m', commitMsg]);
+        if (commitResult.status !== 0) {
+            die('Commit failed. Aborting before pull/push.');
+        }
+    }
+
+    const currentBranch = gitCapture(['branch', '--show-current']);
+    const remoteName = remoteExists('origin') ? 'origin' : gitCapture(['remote']).split(/\r?\n/)[0];
+
+    if (!remoteName) {
+        logWarn('No remote configured — sync was skipped.');
+        return;
+    }
+
+    // A pull needs something to pull FROM. If this branch has never been
+    // pushed before, there's no remote ref, and `git pull --rebase` fails
+    // with "couldn't find remote ref <branch>" — not a connection problem
+    // or a conflict, just a brand-new branch. Check for that case first.
+    const lsRemoteStatus = spawnSync('git', ['ls-remote', '--exit-code', '--heads', remoteName, currentBranch]).status;
+
+    if (lsRemoteStatus === 2) {
+        logInfo(`'${currentBranch}' doesn't exist on '${remoteName}' yet — pushing to create it...`);
+        if (git(['push', '-u', remoteName, currentBranch]).status === 0) {
+            logSuccess('Git workflow complete! Branch created and pushed.');
+        } else {
+            die('Push operation failed.');
+        }
+        return;
+    } else if (lsRemoteStatus !== 0) {
+        logError(`Could not reach '${remoteName}' to check for '${currentBranch}' — this looks like a real connection problem.`);
+        logWarn(`Your commit is safe locally. Re-run 'xgem git cmt' once connectivity is restored, or push manually: git push ${remoteName} ${currentBranch}`);
+        process.exit(1);
+    }
+
+    const aheadCount = gitCapture(['rev-list', '--count', `${remoteName}/${currentBranch}..${currentBranch}`]);
+    if (aheadCount === '0') {
+        logSuccess(`Already up to date with '${remoteName}/${currentBranch}' — nothing to push.`);
+        return;
+    }
+
+    logInfo(`Pulling updates from remote '${remoteName}' on '${currentBranch}' via rebase...`);
+    const pullResult = git(['pull', '--rebase', remoteName, currentBranch]);
+    if (pullResult.status !== 0) {
+        const gitDir = gitCapture(['rev-parse', '--git-dir']);
+        const path = require('node:path');
+        const fs = require('node:fs');
+        const inConflict = fs.existsSync(path.join(gitDir, 'rebase-merge')) || fs.existsSync(path.join(gitDir, 'rebase-apply'));
+        if (inConflict) {
+            logError('MERGE CONFLICT DETECTED!');
+            logWarn('Execution paused. Resolve conflicts to proceed.');
+        } else {
+            logError(`Could not sync with '${remoteName}' — this looks like a connection problem, not a merge conflict (see the git error above).`);
+            logWarn(`Your commit is safe locally. Re-run 'xgem git cmt' once connectivity is restored, or push manually: git push ${remoteName} ${currentBranch}`);
+        }
+        process.exit(1);
+    }
+
+    logSuccess('Clean sync pull achieved. Pushing to upstream target...');
+    const pushResult = git(['push', remoteName, currentBranch]);
+    if (pushResult.status === 0) {
+        logSuccess('Git workflow complete! Code cleanly committed and synchronized.');
+    } else {
+        die('Push operation failed.');
+    }
+}
+
+async function cmdInit() {
+    logInfo('Initializing local Git repository...');
+    git(['init']);
+
+    let remoteName = 'origin';
+    const remoteUrl = await prompt('Enter remote repository URL');
+    if (remoteUrl) {
+        const userRemoteName = await prompt('Enter remote name (default: origin)');
+        if (userRemoteName) remoteName = userRemoteName;
+
+        if (remoteExists(remoteName)) {
+            git(['remote', 'set-url', remoteName, remoteUrl]);
+            logSuccess(`Remote '${remoteName}' already existed. URL updated.`);
+        } else {
+            git(['remote', 'add', remoteName, remoteUrl]);
+            logSuccess(`Remote '${remoteName}' successfully added.`);
+        }
+    }
+
+    const branchName = (await prompt('Enter branch name (default: main)')) || 'main';
+    git(['branch', '-M', branchName]);
+
+    git(['add', '.']);
+    git(['commit', '-m', 'initial changes']);
+    logSuccess('Local baseline configuration setup completed.');
+}
+
+async function cmdRmRemote() {
+    logInfo('Current configured remotes:');
+    git(['remote', '-v']);
+    console.log('');
+
+    const remoteName = (await prompt('Enter the short remote name to remove (e.g. origin)')) || 'origin';
+    if (remoteExists(remoteName)) {
+        git(['remote', 'remove', remoteName]);
+        logSuccess(`Successfully removed remote reference configuration: ${remoteName}`);
+    } else {
+        die(`Remote tracking short-name '${remoteName}' does not exist.`);
+    }
+}
+
+async function cmdRmBranch() {
+    const targetBranch = await prompt('Enter the name of the branch you want to target');
+    if (!targetBranch) die('Branch name cannot be empty.');
+
+    const whereChoice = (await prompt('Where do you want to delete this branch? (l = local only, r = remote only, b = both) [l/r/b]')).toLowerCase();
+    console.log('');
+
+    if (whereChoice === 'l' || whereChoice === 'b') {
+        const currentBranch = gitCapture(['branch', '--show-current']);
+        if (currentBranch === targetBranch) {
+            logWarn(`You are currently sitting on '${targetBranch}'. Switching to safe branch...`);
+            for (const fallback of ['main', 'master', 'dev']) {
+                if (git(['checkout', fallback], { stdio: 'ignore' }).status === 0) break;
+            }
+        }
+
+        logInfo(`Force deleting local branch '${targetBranch}'...`);
+        if (git(['branch', '-D', targetBranch]).status === 0) {
+            logSuccess('Successfully deleted local copy of branch.');
+        } else {
+            logWarn('Local branch could not be dropped (it may already be gone).');
+        }
+    }
+
+    if (whereChoice === 'r' || whereChoice === 'b') {
+        const remoteTarget = (await prompt("Enter remote identifier (short-name like 'origin')")) || 'origin';
+        logInfo(`Sending deletion request for remote branch '${targetBranch}' to server...`);
+        if (git(['push', remoteTarget, '--delete', targetBranch]).status === 0) {
+            logSuccess(`Successfully wiped out remote branch '${targetBranch}' from server.`);
+        } else {
+            die('Server rejected the branch drop execution request.');
+        }
+    }
+}
+
+// Lists local branches, lets the user pick one (or create a new one),
+// checks it out, and remembers it as this repo's default. cmt always
+// operates on whatever's actually checked out — this command's job is the
+// checkout + remembering, not changing how cmt picks its branch.
+async function cmdBranch() {
+    const branches = gitCapture(['branch', '--format=%(refname:short)']).split(/\r?\n/).filter(Boolean);
+    if (branches.length === 0) die('No local branches found.');
+
+    const currentBranch = gitCapture(['branch', '--show-current']);
+
+    console.log('Available branches:');
+    branches.forEach((b, i) => {
+        console.log(`${i + 1}) ${b}${b === currentBranch ? ' (current)' : ''}`);
+    });
+    const createOption = branches.length + 1;
+    console.log(`${createOption}) Create new branch`);
+
+    const choice = await prompt(`Select [1-${createOption}]`);
+
+    if (choice === String(createOption)) {
+        const newBranch = await prompt('Enter new branch name');
+        if (!newBranch) die('Branch name cannot be empty.');
+        if (git(['checkout', '-b', newBranch]).status !== 0) die(`Could not create branch '${newBranch}'.`);
+        git(['config', '--local', 'xgem.default-branch', newBranch]);
+        logSuccess(`Created and switched to '${newBranch}', set as default for this repo.`);
+        return;
+    }
+
+    const idx = parseInt(choice, 10) - 1;
+    if (Number.isNaN(idx) || idx < 0 || idx >= branches.length) die('Invalid selection.');
+
+    const selected = branches[idx];
+    if (selected !== currentBranch) {
+        if (git(['checkout', selected]).status !== 0) die(`Could not switch to branch '${selected}'.`);
+    }
+    git(['config', '--local', 'xgem.default-branch', selected]);
+    logSuccess(`Switched to '${selected}' and set as default for this repo.`);
+}
+
+async function cmdGit(sub, arg) {
+    switch (sub) {
+        case 'cmt': return cmdCmt(arg);
+        case 'init': return cmdInit();
+        case 'branch': return cmdBranch();
+        case 'rm-remote': return cmdRmRemote();
+        case 'rm-branch': return cmdRmBranch();
+        default: die(`Unknown git subcommand '${sub}'. Usage: xgem git <cmt|init|branch|rm-remote|rm-branch>`);
+    }
+}
+
+module.exports = { cmdGit };

package/lib-win/logger.js

@@ -0,0 +1,35 @@
+// xgem Windows engine logger — mirrors lib/logger.sh's levels/colors.
+// Manual ANSI codes (no dependency): Windows 10+ cmd.exe and PowerShell
+// both support ANSI escapes natively, and we skip color entirely when
+// stdout isn't a TTY (e.g. piped output).
+
+const isTTY = process.stdout.isTTY === true;
+
+const colors = {
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[1;34m',
+    cyan: '\x1b[1;36m',
+    gray: '\x1b[90m',
+    reset: '\x1b[0m',
+};
+
+function paint(color, text) {
+    return isTTY ? `${colors[color]}${text}${colors.reset}` : text;
+}
+
+const VERBOSE = process.env.XGEM_VERBOSE === '1';
+
+function logInfo(msg) { console.log(`${paint('blue', '[INFO]')} ${msg}`); }
+function logSuccess(msg) { console.log(`${paint('green', '[ OK ]')} ${msg}`); }
+function logWarn(msg) { console.error(`${paint('yellow', '[WARN]')} ${msg}`); }
+function logError(msg) { console.error(`${paint('red', '[FAIL]')} ${msg}`); }
+function logDebug(msg) { if (VERBOSE) console.error(`${paint('gray', `[DBG ] ${msg}`)}`); }
+
+function die(msg, code = 1) {
+    logError(msg);
+    process.exit(code);
+}
+
+module.exports = { paint, logInfo, logSuccess, logWarn, logError, logDebug, die, isTTY };

package/lib-win/scaffold.js

@@ -0,0 +1,80 @@
+// xgem Windows engine generic scaffold — mirrors lib/scaffold.sh, but
+// writes/runs .mjs templates instead of .sh. `swift` is intentionally
+// omitted: there's no meaningful Windows Swift toolchain story.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { logInfo, logSuccess, logWarn, logError, die } = require('./logger');
+
+const ALL_FRAMEWORKS = ['flutter', 'node', 'python', 'react', 'vue', 'angular', 'next', 'go', 'rust', 'docker'];
+
+const FRAMEWORK_SCRIPTS = {
+    flutter: ['hard-clean', 'build', 'build-runner'],
+    node: ['hard-clean', 'build', 'start'],
+    python: ['hard-clean', 'install'],
+    react: ['hard-clean', 'build', 'dev'],
+    vue: ['hard-clean', 'build', 'dev'],
+    angular: ['hard-clean', 'build', 'dev'],
+    next: ['hard-clean', 'build', 'dev'],
+    go: ['hard-clean', 'build'],
+    rust: ['hard-clean', 'build'],
+    docker: ['hard-clean', 'build-up'],
+};
+
+function frameworkScripts(fw) {
+    return FRAMEWORK_SCRIPTS[fw] || null;
+}
+
+function templateDir(fw) {
+    const templatesRoot = path.join(__dirname, '..', 'templates-win');
+    if (fw === 'react' || fw === 'vue' || fw === 'angular' || fw === 'next') {
+        return path.join(templatesRoot, 'webframework');
+    }
+    return path.join(templatesRoot, fw);
+}
+
+function injectTemplates(fw, configDir) {
+    const scripts = frameworkScripts(fw);
+    if (!scripts) die(`Unknown framework '${fw}'.`);
+
+    const srcDir = templateDir(fw);
+    const destDir = path.join(configDir, fw);
+    fs.mkdirSync(destDir, { recursive: true });
+
+    for (const script of scripts) {
+        const src = path.join(srcDir, `${script}.mjs.tmpl`);
+        const dest = path.join(destDir, `${script}.mjs`);
+        if (!fs.existsSync(src)) {
+            logWarn(`Missing template ${src}, skipping.`);
+            continue;
+        }
+        const content = fs.readFileSync(src, 'utf8').replace(/__FRAMEWORK__/g, fw);
+        fs.writeFileSync(dest, content);
+    }
+}
+
+function runScript(fw, script, configDir) {
+    const target = path.join(configDir, fw, `${script}.mjs`);
+    if (fs.existsSync(target)) {
+        logInfo(`Running script '${script}' for ${fw}...`);
+        const result = spawnSync(process.execPath, [target], { stdio: 'inherit' });
+        process.exitCode = result.status ?? 0;
+    } else {
+        logError(`Script not found at ${target}`);
+        const fwDir = path.join(configDir, fw);
+        if (fs.existsSync(fwDir)) {
+            console.log(`Available scripts in '${fw}':`);
+            for (const f of fs.readdirSync(fwDir)) {
+                console.log(`  - ${f.replace(/\.mjs$/, '')}`);
+            }
+        }
+        process.exitCode = 1;
+    }
+}
+
+function getRemainingFrameworks(configDir) {
+    return ALL_FRAMEWORKS.filter((fw) => !fs.existsSync(path.join(configDir, fw)));
+}
+
+module.exports = { ALL_FRAMEWORKS, frameworkScripts, injectTemplates, runScript, getRemainingFrameworks };

package/lib-win/utils.js

@@ -0,0 +1,67 @@
+// xgem Windows engine utilities — mirrors lib/utils.sh.
+
+const { spawnSync } = require('node:child_process');
+const readline = require('node:readline');
+const { logInfo, logDebug } = require('./logger');
+
+function detectArch() {
+    return process.arch === 'x64' ? 'x64' : process.arch;
+}
+
+// hasCmd(name) -> boolean, checked via `where` (a Windows builtin) so it
+// works regardless of whether the tool itself supports --version.
+function hasCmd(name) {
+    const result = spawnSync('where', [name], { stdio: 'ignore', shell: false });
+    return result.status === 0;
+}
+
+function requireCmd(name, hint) {
+    if (!hasCmd(name)) {
+        const { die } = require('./logger');
+        die(hint ? `'${name}' is required but not found. ${hint}` : `'${name}' is required but not found in PATH.`);
+    }
+}
+
+// getVersion(name, args) -> first line of stdout, or null if the command
+// isn't present / errors out.
+function getVersion(name, args = ['--version']) {
+    if (!hasCmd(name)) return null;
+    const result = spawnSync(name, args, { encoding: 'utf8' });
+    if (result.error || result.status !== 0) return null;
+    const out = (result.stdout || result.stderr || '').split(/\r?\n/)[0];
+    return out ? out.trim() : null;
+}
+
+// confirm(prompt) -> Promise<boolean>. Honors XGEM_YES (auto-approve) and
+// XGEM_DRY_RUN (always decline, just like lib/utils.sh's confirm()).
+function confirm(prompt) {
+    if (process.env.XGEM_DRY_RUN === '1') {
+        logInfo(`(dry-run) would prompt: ${prompt}`);
+        return Promise.resolve(false);
+    }
+    if (process.env.XGEM_YES === '1') {
+        logDebug(`auto-confirmed (--yes): ${prompt}`);
+        return Promise.resolve(true);
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(`${prompt} [y/N]: `, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === 'y');
+        });
+    });
+}
+
+// prompt(question, defaultValue) -> Promise<string>
+function prompt(question, defaultValue = '') {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const suffix = defaultValue ? ` [${defaultValue}]` : '';
+    return new Promise((resolve) => {
+        rl.question(`${question}${suffix}: `, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultValue);
+        });
+    });
+}
+
+module.exports = { detectArch, hasCmd, requireCmd, getVersion, confirm, prompt };

package/package.json

@@ -1,22 +1,23 @@
 {
   "name": "xgem-cli",
-  "version": "2.0.0-alpha.1",
-  "description": "Framework-aware automation CLI: scaffolds and runs clean/build/dev scripts per project type, an environment doctor, a SwiftPM-aware iOS build engine, and a git workflow helper.",
+  "version": "2.0.0-alpha.10",
+  "description": "Framework-aware automation CLI: scaffolds and runs clean/build/dev scripts per project type, an environment doctor, a SwiftPM-aware iOS build engine, and a git workflow helper. Runs natively on macOS, Linux, and Windows.",
   "bin": {
-    "xgem": "bin/xgem"
+    "xgem": "bin/xgem.js"
   },
   "files": [
     "bin/xgem",
+    "bin/xgem.js",
     "lib",
+    "lib-win",
     "templates",
-    "scripts/check-platform.js"
+    "templates-win"
   ],
   "engines": {
-    "node": ">=14"
+    "node": ">=18"
   },
   "scripts": {
-    "preinstall": "node scripts/check-platform.js",
-    "test": "bash -n bin/xgem && for f in lib/*.sh; do bash -n \"$f\"; done"
+    "test": "bash -n bin/xgem && for f in lib/*.sh; do bash -n \"$f\"; done && for f in bin/xgem.js lib-win/*.js; do node --check \"$f\"; done"
   },
   "keywords": [
     "cli",

package/templates-win/docker/build-up.mjs.tmpl

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { execSync } from 'node:child_process';
+execSync('docker-compose up --build -d', { stdio: 'inherit' });

package/templates-win/docker/hard-clean.mjs.tmpl

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { execSync } from 'node:child_process';
+console.log('Pruning unused Docker assets and volumes...');
+execSync('docker system prune -a --volumes -f', { stdio: 'inherit' });

package/templates-win/flutter/build-runner.mjs.tmpl

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+const r = spawnSync('xgem', ['run', 'flutter', 'build-runner'], { stdio: 'inherit', shell: true });
+process.exit(r.status ?? 0);

package/templates-win/flutter/build.mjs.tmpl

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+const r = spawnSync('xgem', ['run', 'flutter', 'build'], { stdio: 'inherit', shell: true });
+process.exit(r.status ?? 0);