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

package/lib-win/release.js

@@ -0,0 +1,143 @@
+// xgem Windows engine release command — port of lib/release.sh.
+
+const fs = require('node:fs');
+const { spawnSync } = require('node:child_process');
+const { logInfo, logSuccess, logWarn, die } = require('./logger');
+const { prompt, confirm } = require('./utils');
+const { defaultRemote } = require('./git');
+
+const VERSION_FILES = ['package.json', 'pubspec.yaml', 'Cargo.toml', 'pyproject.toml'];
+
+function detectVersionFiles() {
+    return VERSION_FILES.filter((f) => fs.existsSync(f));
+}
+
+function readVersion(file) {
+    const content = fs.readFileSync(file, 'utf8');
+    if (file === 'package.json') {
+        const m = content.match(/"version"\s*:\s*"([^"]+)"/);
+        return m ? m[1] : '';
+    }
+    if (file === 'pubspec.yaml') {
+        const m = content.match(/^version:\s*(\S+)/m);
+        return m ? m[1] : '';
+    }
+    const m = content.match(/^version\s*=\s*"([^"]+)"/m);
+    return m ? m[1] : '';
+}
+
+function writeVersion(file, newVersion) {
+    const content = fs.readFileSync(file, 'utf8');
+    let updated;
+    if (file === 'package.json') {
+        updated = content.replace(/"version"\s*:\s*"[^"]+"/, `"version": "${newVersion}"`);
+    } else if (file === 'pubspec.yaml') {
+        updated = content.replace(/^version:.*/m, `version: ${newVersion}`);
+    } else {
+        updated = content.replace(/^version\s*=\s*"[^"]+"/m, `version = "${newVersion}"`);
+    }
+    fs.writeFileSync(file, updated);
+}
+
+function bumpVersion(version, kind) {
+    const plusIdx = version.indexOf('+');
+    const core = plusIdx === -1 ? version : version.slice(0, plusIdx);
+    const suffix = plusIdx === -1 ? '' : version.slice(plusIdx);
+
+    const m = core.match(/^(\d+)\.(\d+)\.(\d+)$/);
+    if (!m) return '';
+    let [major, minor, patch] = m.slice(1).map(Number);
+    if (kind === 'major') { major += 1; minor = 0; patch = 0; }
+    else if (kind === 'minor') { minor += 1; patch = 0; }
+    else { patch += 1; }
+    return `${major}.${minor}.${patch}${suffix}`;
+}
+
+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 writeChangelog(version, lastTag) {
+    const range = lastTag ? `${lastTag}..HEAD` : 'HEAD';
+    const commits = gitCapture(['log', '--format=%s', range]).split(/\r?\n/).filter(Boolean);
+    const features = commits.filter((c) => c.startsWith('feat'));
+    const fixes = commits.filter((c) => c.startsWith('fix'));
+    const other = commits.filter((c) => !c.startsWith('feat') && !c.startsWith('fix'));
+
+    let section = `## v${version} - ${new Date().toISOString().slice(0, 10)}\n`;
+    if (features.length) section += `\n### Features\n${features.map((c) => `- ${c}`).join('\n')}\n`;
+    if (fixes.length) section += `\n### Fixes\n${fixes.map((c) => `- ${c}`).join('\n')}\n`;
+    if (other.length) section += `\n### Other\n${other.map((c) => `- ${c}`).join('\n')}\n`;
+
+    const existing = fs.existsSync('CHANGELOG.md')
+        ? fs.readFileSync('CHANGELOG.md', 'utf8').split('\n').slice(1).join('\n')
+        : '';
+    fs.writeFileSync('CHANGELOG.md', `# Changelog\n\n${section}\n${existing}`);
+}
+
+async function cmdRelease(bumpKind) {
+    const versionFiles = detectVersionFiles();
+    if (versionFiles.length === 0) {
+        die('No recognized version file (package.json/pubspec.yaml/Cargo.toml/pyproject.toml) found here.');
+    }
+
+    let file = versionFiles[0];
+    if (versionFiles.length > 1) {
+        console.log('Multiple version files found:');
+        versionFiles.forEach((f, i) => console.log(`${i + 1}) ${f}`));
+        const choice = await prompt(`Which is the canonical one to bump? [1-${versionFiles.length}]`);
+        const idx = parseInt(choice, 10) - 1;
+        if (Number.isNaN(idx) || idx < 0 || idx >= versionFiles.length) die('Invalid selection.');
+        file = versionFiles[idx];
+    }
+
+    const current = readVersion(file);
+    if (!current) die(`Could not read a version from ${file}.`);
+    logInfo(`Current version in ${file}: ${current}`);
+
+    if (bumpKind && !['major', 'minor', 'patch'].includes(bumpKind)) {
+        die(`Unknown bump kind '${bumpKind}'. Usage: xgem release [major|minor|patch]`);
+    }
+    if (!bumpKind) {
+        bumpKind = (await prompt('Bump [major/minor/patch]', 'patch')) || 'patch';
+    }
+
+    let newVersion = bumpVersion(current, bumpKind);
+    if (!newVersion) {
+        logWarn(`'${current}' isn't a plain X.Y.Z version — can't bump it automatically.`);
+        newVersion = await prompt('Enter the new version directly');
+        if (!newVersion) die('A new version is required.');
+    }
+
+    logInfo(`${current} -> ${newVersion}`);
+    if (!(await confirm('Write this version, update CHANGELOG.md, commit, and tag?'))) {
+        logInfo('Cancelled.');
+        return;
+    }
+
+    writeVersion(file, newVersion);
+
+    const lastTag = gitCapture(['describe', '--tags', '--abbrev=0']);
+    writeChangelog(newVersion, lastTag);
+
+    git(['add', file, 'CHANGELOG.md']);
+    if (git(['commit', '-m', `chore(release): v${newVersion}`]).status !== 0) die('Commit failed.');
+    if (git(['tag', '-a', `v${newVersion}`, '-m', `v${newVersion}`]).status !== 0) die('Tag failed.');
+    logSuccess(`Committed and tagged v${newVersion}.`);
+
+    const remote = defaultRemote();
+    if (remote && (await confirm(`Push commit and tag to '${remote}'?`))) {
+        const currentBranch = gitCapture(['branch', '--show-current']);
+        const pushed = git(['push', remote, currentBranch]).status === 0
+            && git(['push', remote, `v${newVersion}`]).status === 0;
+        if (pushed) logSuccess(`Pushed v${newVersion} to '${remote}'.`);
+        else die('Push failed — the commit and tag are safe locally.');
+    }
+}
+
+module.exports = { cmdRelease };

package/lib-win/scaffold.js

@@ -6,6 +6,7 @@ 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 { prompt } = require('./utils');
 
 const ALL_FRAMEWORKS = ['flutter', 'node', 'python', 'react', 'vue', 'angular', 'next', 'go', 'rust', 'docker'];
 
@@ -99,4 +100,43 @@ function getRemainingFrameworks(configDir) {
     return ALL_FRAMEWORKS.filter((fw) => !fs.existsSync(path.join(configDir, fw)));
 }
 
-module.exports = { ALL_FRAMEWORKS, frameworkScripts, injectTemplates, runScript, getRemainingFrameworks };
+// Some teams want the generated scripts checked in so collaborators get the
+// same automation; others want them private/local-only. Ask instead of
+// always gitignoring.
+async function updateGitignore(configDir) {
+    const gitignorePath = '.gitignore';
+    const ignoreChoice = (await prompt(`Should ${configDir}/ be ignored by git (private to you), or tracked so collaborators get the same scripts? [ignore/track]`, 'ignore')).toLowerCase();
+
+    if (ignoreChoice.startsWith('t')) {
+        if (fs.existsSync(gitignorePath)) {
+            const lines = fs.readFileSync(gitignorePath, 'utf8').split(/\r?\n/).filter((l) => l !== `${configDir}/`);
+            fs.writeFileSync(gitignorePath, lines.join('\n'));
+            logInfo(`Removed existing ${configDir}/ entry from .gitignore since you chose to track it.`);
+        }
+        logSuccess(`${configDir}/ will be tracked in git.`);
+        return;
+    }
+
+    if (fs.existsSync(gitignorePath)) {
+        const content = fs.readFileSync(gitignorePath, 'utf8');
+        if (!content.includes(`${configDir}/`)) {
+            fs.appendFileSync(gitignorePath, `\n${configDir}/\n`);
+            logSuccess('Added automation tracking to .gitignore');
+        }
+    } else {
+        fs.writeFileSync(gitignorePath, `${configDir}/\n`);
+        logSuccess('Created .gitignore and hidden tracking layer folder references.');
+    }
+}
+
+// bookkeeping(fw, configDir) — creates configDir/fw's scripts and updates
+// .gitignore. Called from both `xgem init` and `xgem bootstrap` so a
+// project scaffolded either way ends up in the same state.
+async function bookkeeping(fw, configDir) {
+    fs.mkdirSync(configDir, { recursive: true });
+    injectTemplates(fw, configDir);
+    logSuccess(`Successfully appended standard scripts for: ${configDir}/${fw}`);
+    await updateGitignore(configDir);
+}
+
+module.exports = { ALL_FRAMEWORKS, frameworkScripts, injectTemplates, runScript, getRemainingFrameworks, updateGitignore, bookkeeping };

package/lib-win/status.js

@@ -0,0 +1,53 @@
+// xgem status — port of lib/status.sh: a one-screen dashboard across every
+// project xgem has ever scaffolded.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { logInfo } = require('./logger');
+const { registryList } = require('./registry');
+
+function gitCaptureIn(cwd, args) {
+    const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
+    return result.status === 0 ? (result.stdout || '').trim() : '';
+}
+
+function statusRow(projectPath, configDir) {
+    const branch = gitCaptureIn(projectPath, ['branch', '--show-current']) || '-';
+    const porcelain = gitCaptureIn(projectPath, ['status', '--porcelain']);
+    const dirty = porcelain ? porcelain.split(/\r?\n/).filter(Boolean).length : 0;
+
+    const counts = gitCaptureIn(projectPath, ['rev-list', '--left-right', '--count', '@{u}...HEAD']);
+    let aheadBehind = '-';
+    if (counts) {
+        const [behind, ahead] = counts.split(/\s+/);
+        aheadBehind = `-${behind} +${ahead}`;
+    }
+
+    const configPath = path.join(projectPath, configDir);
+    const frameworks = fs.existsSync(configPath)
+        ? fs.readdirSync(configPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).join(',') || '-'
+        : '-';
+
+    return { projectPath, branch, dirty, aheadBehind, frameworks };
+}
+
+function pad(str, width) {
+    return str.length >= width ? str : str + ' '.repeat(width - str.length);
+}
+
+async function cmdStatus(configDir) {
+    const projects = registryList(configDir);
+    if (projects.length === 0) {
+        logInfo("No xgem-tracked projects found yet — run 'xgem init' in a project to start tracking it.");
+        return;
+    }
+
+    console.log(`${pad('PROJECT', 45)} ${pad('BRANCH', 20)} ${pad('DIRTY', 6)} ${pad('AHEAD/BEHIND', 12)} FRAMEWORKS`);
+    for (const p of projects) {
+        const row = statusRow(p, configDir);
+        console.log(`${pad(row.projectPath, 45)} ${pad(row.branch, 20)} ${pad(String(row.dirty), 6)} ${pad(row.aheadBehind, 12)} ${row.frameworks}`);
+    }
+}
+
+module.exports = { cmdStatus };

package/lib-win/utils.js

@@ -32,6 +32,11 @@ function getVersion(name, args = ['--version']) {
     return out ? out.trim() : null;
 }
 
+// openUrl(url) — best-effort browser open on Windows.
+function openUrl(url) {
+    spawnSync('cmd', ['/c', 'start', '""', url], { stdio: 'ignore' });
+}
+
 // 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) {
@@ -64,4 +69,4 @@ function prompt(question, defaultValue = '') {
     });
 }
 
-module.exports = { detectArch, hasCmd, requireCmd, getVersion, confirm, prompt };
+module.exports = { detectArch, hasCmd, requireCmd, getVersion, confirm, prompt, openUrl };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xgem-cli",
-  "version": "2.0.0-alpha.12",
+  "version": "2.0.0-alpha.14",
   "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.js"