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

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,279 @@
+// 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 path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { logInfo, logSuccess, logWarn, logError, die } = require('./logger');
+const { prompt, hasCmd } = require('./utils');
+
+function git(args, opts = {}) {
+    return spawnSync('git', args, { stdio: 'inherit', ...opts });
+}
+
+function gh(args, opts = {}) {
+    return spawnSync('gh', args, { stdio: 'inherit', ...opts });
+}
+
+function ghAuthenticated() {
+    return spawnSync('gh', ['auth', 'status'], { stdio: 'ignore' }).status === 0;
+}
+
+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 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 manualRemoteSetup(defaultRemoteName) {
+    let remoteName = defaultRemoteName;
+    const remoteUrl = await prompt('Enter remote repository URL (or leave blank to skip)');
+    if (!remoteUrl) return;
+
+    const userRemoteName = await prompt(`Enter remote name (default: ${remoteName})`);
+    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.`);
+    }
+}
+
+async function cmdInit() {
+    logInfo('Initializing local Git repository...');
+    git(['init']);
+
+    const branchName = (await prompt('Enter branch name (default: main)')) || 'main';
+    git(['branch', '-M', branchName]);
+
+    git(['add', '.']);
+    git(['commit', '-m', 'initial changes']);
+
+    // Real GitHub repo creation, not just wiring a remote to a URL you
+    // already had to go create by hand — the whole point of `xgem git
+    // init` over plain `git init`. Falls back to the manual-URL flow if
+    // `gh` isn't installed/authenticated.
+    if (hasCmd('gh') && ghAuthenticated()) {
+        const createChoice = (await prompt('Create a new GitHub repository for this project right now? (Y/n)')) || 'y';
+        if (createChoice.toLowerCase() === 'y') {
+            const cwdName = path.basename(process.cwd());
+            const repoName = (await prompt(`Repository name (default: ${cwdName})`)) || cwdName;
+            const visibility = ((await prompt('Public or private? [public/private] (default: private)')) || 'private').toLowerCase();
+            const visFlag = visibility.startsWith('pub') ? '--public' : '--private';
+
+            const result = gh(['repo', 'create', repoName, visFlag, '--source=.', '--remote=origin', '--push']);
+            if (result.status === 0) {
+                logSuccess(`Created GitHub repo '${repoName}' and pushed '${branchName}' to it.`);
+            } else {
+                logError('gh repo create failed — falling back to manual remote setup.');
+                await manualRemoteSetup('origin');
+            }
+            logSuccess('Local baseline configuration setup completed.');
+            return;
+        }
+    } else if (hasCmd('gh')) {
+        logWarn("GitHub CLI (gh) is installed but not authenticated — run 'gh auth login' to enable one-step repo creation next time.");
+    }
+
+    await manualRemoteSetup('origin');
+    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,102 @@
+// 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'],
+};
+
+const WEB_FRAMEWORKS = ['node', 'react', 'vue', 'angular', 'next'];
+
+// Only offer lint/test automation when the current directory's
+// package.json actually declares those scripts, instead of always
+// generating scripts that fail with "Missing script" on projects that
+// don't have them.
+function packageJsonHasScript(scriptName) {
+    try {
+        const pkg = JSON.parse(require('node:fs').readFileSync('package.json', 'utf8'));
+        return Boolean(pkg.scripts && pkg.scripts[scriptName]);
+    } catch {
+        return false;
+    }
+}
+
+function frameworkScripts(fw) {
+    const base = FRAMEWORK_SCRIPTS[fw];
+    if (!base) return null;
+    if (!WEB_FRAMEWORKS.includes(fw)) return base;
+
+    const scripts = [...base];
+    if (packageJsonHasScript('lint')) scripts.push('lint');
+    if (packageJsonHasScript('test')) scripts.push('test');
+    return scripts;
+}
+
+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.12",
+  "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/node/build.sh.tmpl

@@ -1,3 +1,11 @@
 #!/bin/bash
 echo -e "\033[1;34mBuilding Node project...\033[0m"
-npm run build
+if [ -f pnpm-lock.yaml ]; then
+    pnpm run build
+elif [ -f yarn.lock ]; then
+    yarn build
+elif [ -f bun.lockb ] || [ -f bun.lock ]; then
+    bun run build
+else
+    npm run build
+fi

package/templates/node/hard-clean.sh.tmpl

@@ -1,3 +1,35 @@
 #!/bin/bash
-echo -e "\033[1;33mNuking node_modules and resetting package locks...\033[0m"
-rm -rf node_modules package-lock.json yarn.lock && npm install
+# Detect the package manager actually in use instead of assuming npm —
+# blindly deleting yarn.lock/pnpm-lock.yaml on a project that uses them
+# and running `npm install` instead corrupts the project by introducing a
+# conflicting lockfile.
+PKG_MANAGER=npm
+if [ -f pnpm-lock.yaml ]; then
+    PKG_MANAGER=pnpm
+elif [ -f yarn.lock ]; then
+    PKG_MANAGER=yarn
+elif [ -f bun.lockb ] || [ -f bun.lock ]; then
+    PKG_MANAGER=bun
+elif [ -f package.json ]; then
+    declared=$(grep -o '"packageManager"[[:space:]]*:[[:space:]]*"[a-z]*' package.json 2>/dev/null | grep -oE '[a-z]+$')
+    case "$declared" in npm|yarn|pnpm|bun) PKG_MANAGER=$declared ;; esac
+fi
+
+if [ -f .nvmrc ] && command -v node >/dev/null 2>&1; then
+    wanted=$(tr -d 'v[:space:]' < .nvmrc)
+    have=$(node -v | tr -d 'v')
+    case "$have" in
+        "$wanted"*) ;;
+        *) echo -e "\033[33mWarning: .nvmrc wants Node $wanted, but 'node -v' reports $have.\033[0m" ;;
+    esac
+fi
+
+echo -e "\033[1;33mNuking node_modules and resetting package locks (package manager: $PKG_MANAGER)...\033[0m"
+rm -rf node_modules
+
+case "$PKG_MANAGER" in
+    yarn) rm -f yarn.lock; yarn install ;;
+    pnpm) rm -f pnpm-lock.yaml; pnpm install ;;
+    bun)  rm -f bun.lockb bun.lock; bun install ;;
+    *)    rm -f package-lock.json; npm install ;;
+esac