xgem-cli 2.0.0-alpha.10 → 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'];
 
@@ -22,8 +23,30 @@ const FRAMEWORK_SCRIPTS = {
     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) {
-    return FRAMEWORK_SCRIPTS[fw] || null;
+    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) {
@@ -77,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.10",
+  "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"

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

package/templates/node/lint.sh.tmpl

@@ -0,0 +1,10 @@
+#!/bin/bash
+if [ -f pnpm-lock.yaml ]; then
+    pnpm run lint
+elif [ -f yarn.lock ]; then
+    yarn lint
+elif [ -f bun.lockb ] || [ -f bun.lock ]; then
+    bun run lint
+else
+    npm run lint
+fi

package/templates/node/start.sh.tmpl

@@ -1,2 +1,10 @@
 #!/bin/bash
-npm run start
+if [ -f pnpm-lock.yaml ]; then
+    pnpm run start
+elif [ -f yarn.lock ]; then
+    yarn start
+elif [ -f bun.lockb ] || [ -f bun.lock ]; then
+    bun run start
+else
+    npm run start
+fi

package/templates/node/test.sh.tmpl

@@ -0,0 +1,10 @@
+#!/bin/bash
+if [ -f pnpm-lock.yaml ]; then
+    pnpm run test
+elif [ -f yarn.lock ]; then
+    yarn test
+elif [ -f bun.lockb ] || [ -f bun.lock ]; then
+    bun run test
+else
+    npm run test
+fi

package/templates/webframework/build.sh.tmpl

@@ -1,2 +1,11 @@
 #!/bin/bash
-npm run build
+# Use whatever package manager this project actually uses.
+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/webframework/dev.sh.tmpl

@@ -1,2 +1,10 @@
 #!/bin/bash
-npm run dev
+if [ -f pnpm-lock.yaml ]; then
+    pnpm run dev
+elif [ -f yarn.lock ]; then
+    yarn dev
+elif [ -f bun.lockb ] || [ -f bun.lock ]; then
+    bun run dev
+else
+    npm run dev
+fi

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

@@ -1,3 +1,36 @@
 #!/bin/bash
-echo -e "\033[1;33mResetting __FRAMEWORK__ dependencies...\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
+
+# Warn (don't block) on a Node version mismatch against .nvmrc, if present.
+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;33mResetting __FRAMEWORK__ dependencies (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

package/templates/webframework/lint.sh.tmpl

@@ -0,0 +1,10 @@
+#!/bin/bash
+if [ -f pnpm-lock.yaml ]; then
+    pnpm run lint
+elif [ -f yarn.lock ]; then
+    yarn lint
+elif [ -f bun.lockb ] || [ -f bun.lock ]; then
+    bun run lint
+else
+    npm run lint
+fi

package/templates/webframework/test.sh.tmpl

@@ -0,0 +1,10 @@
+#!/bin/bash
+if [ -f pnpm-lock.yaml ]; then
+    pnpm run test
+elif [ -f yarn.lock ]; then
+    yarn test
+elif [ -f bun.lockb ] || [ -f bun.lock ]; then
+    bun run test
+else
+    npm run test
+fi

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

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
 import { execSync } from 'node:child_process';
-console.log('Building Node project...');
-execSync('npm run build', { stdio: 'inherit' });
+import { existsSync } from 'node:fs';
+
+let cmd = 'npm run build';
+if (existsSync('pnpm-lock.yaml')) cmd = 'pnpm run build';
+else if (existsSync('yarn.lock')) cmd = 'yarn build';
+else if (existsSync('bun.lockb') || existsSync('bun.lock')) cmd = 'bun run build';
+
+execSync(cmd, { stdio: 'inherit' });

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

@@ -1,9 +1,28 @@
 #!/usr/bin/env node
 import { execSync } from 'node:child_process';
-import { rmSync } from 'node:fs';
+import { existsSync, rmSync, readFileSync } from 'node:fs';
 
-console.log('Nuking node_modules and resetting package locks...');
+function detectPkgManager() {
+    if (existsSync('pnpm-lock.yaml')) return 'pnpm';
+    if (existsSync('yarn.lock')) return 'yarn';
+    if (existsSync('bun.lockb') || existsSync('bun.lock')) return 'bun';
+    if (existsSync('package.json')) {
+        try {
+            const pkg = JSON.parse(readFileSync('package.json', 'utf8'));
+            if (['npm', 'yarn', 'pnpm', 'bun'].includes(pkg.packageManager?.split('@')[0])) {
+                return pkg.packageManager.split('@')[0];
+            }
+        } catch { /* ignore malformed package.json */ }
+    }
+    return 'npm';
+}
+
+const pm = detectPkgManager();
+console.log(`Nuking node_modules and resetting package locks (package manager: ${pm})...`);
 rmSync('node_modules', { recursive: true, force: true });
-rmSync('package-lock.json', { force: true });
-rmSync('yarn.lock', { force: true });
-execSync('npm install', { stdio: 'inherit' });
+
+const lockfiles = { npm: ['package-lock.json'], yarn: ['yarn.lock'], pnpm: ['pnpm-lock.yaml'], bun: ['bun.lockb', 'bun.lock'] };
+for (const f of lockfiles[pm]) rmSync(f, { force: true });
+
+const installCmd = { npm: 'npm install', yarn: 'yarn', pnpm: 'pnpm install', bun: 'bun install' };
+execSync(installCmd[pm], { stdio: 'inherit' });

package/templates-win/node/lint.mjs.tmpl

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+
+let cmd = 'npm run lint';
+if (existsSync('pnpm-lock.yaml')) cmd = 'pnpm run lint';
+else if (existsSync('yarn.lock')) cmd = 'yarn lint';
+else if (existsSync('bun.lockb') || existsSync('bun.lock')) cmd = 'bun run lint';
+
+execSync(cmd, { stdio: 'inherit' });

package/templates-win/node/start.mjs.tmpl

@@ -1,3 +1,10 @@
 #!/usr/bin/env node
 import { execSync } from 'node:child_process';
-execSync('npm run start', { stdio: 'inherit' });
+import { existsSync } from 'node:fs';
+
+let cmd = 'npm run start';
+if (existsSync('pnpm-lock.yaml')) cmd = 'pnpm run start';
+else if (existsSync('yarn.lock')) cmd = 'yarn start';
+else if (existsSync('bun.lockb') || existsSync('bun.lock')) cmd = 'bun run start';
+
+execSync(cmd, { stdio: 'inherit' });

package/templates-win/node/test.mjs.tmpl

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+
+let cmd = 'npm run test';
+if (existsSync('pnpm-lock.yaml')) cmd = 'pnpm run test';
+else if (existsSync('yarn.lock')) cmd = 'yarn test';
+else if (existsSync('bun.lockb') || existsSync('bun.lock')) cmd = 'bun run test';
+
+execSync(cmd, { stdio: 'inherit' });

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

@@ -1,3 +1,10 @@
 #!/usr/bin/env node
 import { execSync } from 'node:child_process';
-execSync('npm run build', { stdio: 'inherit' });
+import { existsSync } from 'node:fs';
+
+let cmd = 'npm run build';
+if (existsSync('pnpm-lock.yaml')) cmd = 'pnpm run build';
+else if (existsSync('yarn.lock')) cmd = 'yarn build';
+else if (existsSync('bun.lockb') || existsSync('bun.lock')) cmd = 'bun run build';
+
+execSync(cmd, { stdio: 'inherit' });

package/templates-win/webframework/dev.mjs.tmpl

@@ -1,3 +1,10 @@
 #!/usr/bin/env node
 import { execSync } from 'node:child_process';
-execSync('npm run dev', { stdio: 'inherit' });
+import { existsSync } from 'node:fs';
+
+let cmd = 'npm run dev';
+if (existsSync('pnpm-lock.yaml')) cmd = 'pnpm run dev';
+else if (existsSync('yarn.lock')) cmd = 'yarn dev';
+else if (existsSync('bun.lockb') || existsSync('bun.lock')) cmd = 'bun run dev';
+
+execSync(cmd, { stdio: 'inherit' });

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

@@ -1,9 +1,32 @@
 #!/usr/bin/env node
 import { execSync } from 'node:child_process';
-import { rmSync } from 'node:fs';
+import { existsSync, rmSync, readFileSync } from 'node:fs';
 
-console.log('Resetting __FRAMEWORK__ dependencies...');
+// 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.
+function detectPkgManager() {
+    if (existsSync('pnpm-lock.yaml')) return 'pnpm';
+    if (existsSync('yarn.lock')) return 'yarn';
+    if (existsSync('bun.lockb') || existsSync('bun.lock')) return 'bun';
+    if (existsSync('package.json')) {
+        try {
+            const pkg = JSON.parse(readFileSync('package.json', 'utf8'));
+            if (['npm', 'yarn', 'pnpm', 'bun'].includes(pkg.packageManager?.split('@')[0])) {
+                return pkg.packageManager.split('@')[0];
+            }
+        } catch { /* ignore malformed package.json */ }
+    }
+    return 'npm';
+}
+
+const pm = detectPkgManager();
+console.log(`Resetting __FRAMEWORK__ dependencies (package manager: ${pm})...`);
 rmSync('node_modules', { recursive: true, force: true });
-rmSync('package-lock.json', { force: true });
-rmSync('yarn.lock', { force: true });
-execSync('npm install', { stdio: 'inherit' });
+
+const lockfiles = { npm: ['package-lock.json'], yarn: ['yarn.lock'], pnpm: ['pnpm-lock.yaml'], bun: ['bun.lockb', 'bun.lock'] };
+for (const f of lockfiles[pm]) rmSync(f, { force: true });
+
+const installCmd = { npm: 'npm install', yarn: 'yarn', pnpm: 'pnpm install', bun: 'bun install' };
+execSync(installCmd[pm], { stdio: 'inherit' });

package/templates-win/webframework/lint.mjs.tmpl

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+
+let cmd = 'npm run lint';
+if (existsSync('pnpm-lock.yaml')) cmd = 'pnpm run lint';
+else if (existsSync('yarn.lock')) cmd = 'yarn lint';
+else if (existsSync('bun.lockb') || existsSync('bun.lock')) cmd = 'bun run lint';
+
+execSync(cmd, { stdio: 'inherit' });