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

package/lib/version.sh

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

package/lib-win/bootstrap.js

@@ -0,0 +1,189 @@
+// xgem Windows engine bootstrap — port of lib/bootstrap.sh. `swift` is
+// omitted from detection, matching lib-win/scaffold.js's decision that
+// 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, logDebug, die } = require('./logger');
+const { hasCmd, confirm, prompt } = require('./utils');
+const scaffold = require('./scaffold');
+
+function run(cmd, args, opts = {}) {
+    return spawnSync(cmd, args, { stdio: 'inherit', shell: process.platform === 'win32', ...opts });
+}
+
+function detectFramework() {
+    if (fs.existsSync('pubspec.yaml')) return 'flutter';
+    if (fs.existsSync('go.mod')) return 'go';
+    if (fs.existsSync('Cargo.toml')) return 'rust';
+    if (fs.existsSync('pyproject.toml') || fs.existsSync('requirements.txt') || fs.existsSync('setup.py')) return 'python';
+    if (fs.existsSync('package.json')) {
+        const content = fs.readFileSync('package.json', 'utf8');
+        if (content.includes('"next"')) return 'next';
+        if (content.includes('"@angular/core"')) return 'angular';
+        if (content.includes('"vue"')) return 'vue';
+        if (content.includes('"react"')) return 'react';
+        return 'node';
+    }
+    if (fs.existsSync('Dockerfile')) return 'docker';
+    return '';
+}
+
+async function selectFrameworkManually() {
+    scaffold.ALL_FRAMEWORKS.forEach((fw, i) => console.log(`${i + 1}) ${fw}`));
+    const choice = await prompt('Enter target selection number');
+    const idx = parseInt(choice, 10) - 1;
+    if (Number.isNaN(idx) || idx < 0 || idx >= scaffold.ALL_FRAMEWORKS.length) die('Invalid selection.');
+    return scaffold.ALL_FRAMEWORKS[idx];
+}
+
+async function bootstrapEnvFile() {
+    if (fs.existsSync('.env')) { logDebug('.env already exists, leaving it as-is.'); return; }
+    for (const example of ['.env.example', '.env.sample']) {
+        if (!fs.existsSync(example)) continue;
+        fs.copyFileSync(example, '.env');
+        logSuccess(`Created .env from ${example}.`);
+        const missing = fs.readFileSync('.env', 'utf8')
+            .split(/\r?\n/)
+            .filter((line) => /^[A-Za-z_][A-Za-z0-9_]*=\s*$/.test(line))
+            .map((line) => line.split('=')[0]);
+        if (missing.length) {
+            logWarn('These .env keys are empty — fill them in:');
+            missing.forEach((k) => console.log(`  - ${k}`));
+        }
+        return;
+    }
+}
+
+function nodePm() {
+    if (fs.existsSync('pnpm-lock.yaml')) return 'pnpm';
+    if (fs.existsSync('yarn.lock')) return 'yarn';
+    if (fs.existsSync('bun.lockb') || fs.existsSync('bun.lock')) return 'bun';
+    return 'npm';
+}
+
+function installWith(pm, extraArgs = []) {
+    switch (pm) {
+        case 'yarn': return run('yarn', extraArgs);
+        case 'pnpm': return run('pnpm', ['install', ...extraArgs]);
+        case 'bun': return run('bun', ['install', ...extraArgs]);
+        default: return run('npm', ['install', ...extraArgs]);
+    }
+}
+
+async function bootstrapInstall(fw) {
+    switch (fw) {
+        case 'node':
+        case 'react':
+        case 'vue':
+        case 'angular':
+        case 'next': {
+            const pm = nodePm();
+            logInfo(`Installing dependencies with ${pm}...`);
+            installWith(pm);
+            break;
+        }
+        case 'flutter':
+            if (!hasCmd('flutter')) { logWarn("flutter not found — skipping 'flutter pub get'."); break; }
+            logInfo('Running flutter pub get...');
+            run('flutter', ['pub', 'get']);
+            break;
+        case 'python':
+            if (fs.existsSync('pyproject.toml') && hasCmd('poetry')) {
+                logInfo('Installing dependencies with poetry...');
+                run('poetry', ['install']);
+            } else if (fs.existsSync('requirements.txt')) {
+                if (!hasCmd('python') && !hasCmd('python3')) { logWarn('python not found — skipping install.'); break; }
+                const py = hasCmd('python') ? 'python' : 'python3';
+                if (!fs.existsSync('.venv')) run(py, ['-m', 'venv', '.venv']);
+                const pipPath = process.platform === 'win32' ? path.join('.venv', 'Scripts', 'pip.exe') : path.join('.venv', 'bin', 'pip');
+                logInfo('Installing dependencies into .venv...');
+                run(pipPath, ['install', '-r', 'requirements.txt']);
+            }
+            break;
+        case 'go':
+            if (!hasCmd('go')) { logWarn("go not found — skipping 'go mod download'."); break; }
+            logInfo('Running go mod download...');
+            run('go', ['mod', 'download']);
+            break;
+        case 'rust':
+            if (!hasCmd('cargo')) { logWarn("cargo not found — skipping 'cargo fetch'."); break; }
+            logInfo('Running cargo fetch...');
+            run('cargo', ['fetch']);
+            break;
+        case 'docker':
+            logDebug('Docker project — nothing to install locally.');
+            break;
+        default:
+            break;
+    }
+}
+
+function packageJsonHasScript(name) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+        return Boolean(pkg.scripts && pkg.scripts[name]);
+    } catch {
+        return false;
+    }
+}
+
+async function bootstrapMigrations(fw) {
+    if (['node', 'react', 'vue', 'angular', 'next'].includes(fw) && packageJsonHasScript('migrate')) {
+        const pm = nodePm();
+        if (await confirm(`Run the project's 'migrate' script (via ${pm})?`)) {
+            if (pm === 'yarn') run('yarn', ['migrate']);
+            else if (pm === 'pnpm') run('pnpm', ['run', 'migrate']);
+            else if (pm === 'bun') run('bun', ['run', 'migrate']);
+            else run('npm', ['run', 'migrate']);
+        }
+        return;
+    }
+    if (fs.existsSync(path.join('prisma', 'schema.prisma'))) {
+        if (await confirm("Run 'npx prisma migrate dev'?")) run('npx', ['prisma', 'migrate', 'dev']);
+    } else if (fs.existsSync('manage.py')) {
+        const py = hasCmd('python') ? 'python' : (hasCmd('python3') ? 'python3' : '');
+        if (py && (await confirm(`Run '${py} manage.py migrate'?`))) run(py, ['manage.py', 'migrate']);
+    }
+}
+
+async function offerDevServer(fw, configDir) {
+    let script = '';
+    if (fw === 'node') script = 'start';
+    else if (['react', 'vue', 'angular', 'next'].includes(fw)) script = 'dev';
+    else return;
+
+    const target = path.join(configDir, fw, `${script}.mjs`);
+    if (!fs.existsSync(target)) return;
+    if (await confirm(`Launch the dev server now ('xgem run ${fw} ${script}')?`)) {
+        scaffold.runScript(fw, script, configDir);
+    }
+}
+
+async function cmdBootstrap(configDir) {
+    logInfo('Detecting project framework...');
+    let fw = detectFramework();
+    if (!fw) {
+        logWarn('Could not auto-detect the framework from any known marker file.');
+        console.log('Pick one:');
+        fw = await selectFrameworkManually();
+    } else {
+        logSuccess(`Detected: ${fw}`);
+    }
+
+    await bootstrapEnvFile();
+    await bootstrapInstall(fw);
+    await bootstrapMigrations(fw);
+
+    if (!fs.existsSync(configDir)) {
+        if (await confirm(`Scaffold xgem automation scripts (${configDir}) for ${fw} too?`)) {
+            await scaffold.bookkeeping(fw, configDir);
+        }
+    }
+
+    await offerDevServer(fw, configDir);
+    logSuccess('Bootstrap complete.');
+}
+
+module.exports = { cmdBootstrap };

package/lib-win/ci.js

@@ -0,0 +1,43 @@
+// xgem Windows engine ci — port of lib/ci.sh: run lint -> test -> build for
+// every configured framework before you push.
+
+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 STEPS = ['lint', 'test', 'build'];
+
+async function cmdCi(configDir) {
+    if (!fs.existsSync(configDir)) die(`No ${configDir} found — run 'xgem init' or 'xgem add' first.`);
+
+    const results = [];
+    let overallOk = true;
+
+    for (const fw of fs.readdirSync(configDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name)) {
+        for (const step of STEPS) {
+            const target = path.join(configDir, fw, `${step}.mjs`);
+            if (!fs.existsSync(target)) continue;
+            logInfo(`Running ${fw} ${step}...`);
+            const result = spawnSync(process.execPath, [target], { stdio: 'inherit' });
+            const ok = (result.status ?? 1) === 0;
+            results.push(`${ok ? 'PASS ' : 'FAIL '} ${fw} ${step}`);
+            if (!ok) overallOk = false;
+        }
+    }
+
+    if (results.length === 0) {
+        logWarn(`No lint/test/build scripts found under ${configDir} to run.`);
+        return;
+    }
+
+    console.log('');
+    console.log('=== xgem ci summary ===');
+    results.forEach((r) => console.log(r));
+
+    if (overallOk) logSuccess('All checks passed.');
+    else logError('Some checks failed.');
+    process.exitCode = overallOk ? 0 : 1;
+}
+
+module.exports = { cmdCi };

package/lib-win/git.js

@@ -3,23 +3,60 @@
 // commit-exit-code check and origin-preference fix already in lib/git.sh
 // carry over here too.
 
+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 { prompt, confirm, hasCmd, openUrl } = 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 ghCapture(args) {
+    const result = spawnSync('gh', args, { encoding: 'utf8' });
+    return result.status === 0 ? (result.stdout || '').trim() : '';
+}
+
 function remoteExists(name) {
     return gitCapture(['remote']).split(/\r?\n/).includes(name);
 }
 
+// defaultRemote() -> "origin" if configured, else the first remote, else ''.
+function defaultRemote() {
+    if (remoteExists('origin')) return 'origin';
+    return gitCapture(['remote']).split(/\r?\n/)[0] || '';
+}
+
+// baseBranch(remote) -> the repo's default branch, via gh's own knowledge
+// where possible, else probing common names against the remote's
+// tracking refs.
+function baseBranch(remote) {
+    if (hasCmd('gh')) {
+        const base = ghCapture(['repo', 'view', '--json', 'defaultBranchRef', '--jq', '.defaultBranchRef.name']);
+        if (base) return base;
+    }
+    for (const candidate of ['main', 'master', 'develop', 'dev']) {
+        if (git(['show-ref', '--verify', '--quiet', `refs/remotes/${remote}/${candidate}`], { stdio: 'ignore' }).status === 0) {
+            return candidate;
+        }
+    }
+    return '';
+}
+
 async function cmdCmt(commitMsg) {
     if (!commitMsg) die('Missing commit message!');
 
@@ -53,7 +90,7 @@ async function cmdCmt(commitMsg) {
     }
 
     const currentBranch = gitCapture(['branch', '--show-current']);
-    const remoteName = remoteExists('origin') ? 'origin' : gitCapture(['remote']).split(/\r?\n/)[0];
+    const remoteName = defaultRemote();
 
     if (!remoteName) {
         logWarn('No remote configured — sync was skipped.');
@@ -90,7 +127,6 @@ async function cmdCmt(commitMsg) {
     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) {
@@ -112,30 +148,60 @@ async function cmdCmt(commitMsg) {
     }
 }
 
-async function cmdInit() {
-    logInfo('Initializing local Git repository...');
-    git(['init']);
+async function manualRemoteSetup(defaultRemoteName) {
+    let remoteName = defaultRemoteName;
+    const remoteUrl = await prompt('Enter remote repository URL (or leave blank to skip)');
+    if (!remoteUrl) return;
 
-    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;
+    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.`);
-        }
+    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.');
 }
 
@@ -227,15 +293,203 @@ async function cmdBranch() {
     logSuccess(`Switched to '${selected}' and set as default for this repo.`);
 }
 
-async function cmdGit(sub, arg) {
+async function cmdPr(configDir) {
+    const currentBranch = gitCapture(['branch', '--show-current']);
+    if (!currentBranch) die('Not on a branch (detached HEAD?) — nothing to open a PR from.');
+    const remote = defaultRemote();
+    if (!remote) die('No remote configured.');
+
+    if (!hasCmd('gh') || !ghAuthenticated()) {
+        if (hasCmd('gh')) logWarn("GitHub CLI (gh) is installed but not authenticated — run 'gh auth login' to enable 'xgem git pr'.");
+        else logWarn('GitHub CLI (gh) is not installed — install it for \'xgem git pr\' to open PRs directly: https://cli.github.com');
+        const remoteUrl = gitCapture(['remote', 'get-url', remote]);
+        const ownerRepo = remoteUrl.replace(/^git@[^:]+:/, '').replace(/^https?:\/\/[^/]+\//, '').replace(/\.git$/, '');
+        if (!ownerRepo) die(`Could not determine owner/repo from remote '${remote}' (${remoteUrl}).`);
+        const base = baseBranch(remote) || 'main';
+        const url = `https://github.com/${ownerRepo}/compare/${base}...${currentBranch}?expand=1`;
+        logInfo(`Open this URL to create the PR manually: ${url}`);
+        if (await confirm('Open it in your browser now?')) openUrl(url);
+        return;
+    }
+
+    const base = baseBranch(remote);
+    if (!base) die("Could not determine the repo's base branch.");
+    if (currentBranch === base) die(`You're on '${base}' — switch to a feature branch first.`);
+
+    logInfo(`Pushing '${currentBranch}' to '${remote}'...`);
+    if (git(['push', '-u', remote, currentBranch]).status !== 0) die('Push failed.');
+
+    if (spawnSync('gh', ['pr', 'view', '--json', 'number'], { stdio: 'ignore' }).status === 0) {
+        logSuccess(`A PR for '${currentBranch}' already exists.`);
+        if (await confirm('Open it in your browser?')) gh(['pr', 'view', '--web']);
+        return;
+    }
+
+    const commits = gitCapture(['log', '--format=%s', `${remote}/${base}..HEAD`]).split(/\r?\n/).filter(Boolean);
+    let title;
+    let body;
+    if (commits.length <= 1) {
+        title = commits[0] || '';
+        body = '';
+    } else {
+        const spaced = currentBranch.replace(/[-_]/g, ' ');
+        title = spaced.charAt(0).toUpperCase() + spaced.slice(1);
+        body = commits.map((c) => `- ${c}`).join('\n');
+    }
+
+    const titleOverride = await prompt(`PR title [${title}]`);
+    if (titleOverride) title = titleOverride;
+    if (!title) die('A PR title is required.');
+
+    if (gh(['pr', 'create', '--title', title, '--body', body, '--base', base]).status === 0) {
+        logSuccess('PR created.');
+        if (await confirm('Open it in your browser?')) gh(['pr', 'view', '--web']);
+    } else {
+        die('gh pr create failed.');
+    }
+}
+
+async function cmdSync() {
+    const remote = defaultRemote();
+    if (!remote) die('No remote configured.');
+    const base = baseBranch(remote);
+    if (!base) die("Could not determine the repo's base branch.");
+    const currentBranch = gitCapture(['branch', '--show-current']);
+
+    logInfo(`Fetching '${base}' from '${remote}'...`);
+    if (git(['fetch', remote, base]).status !== 0) die('Fetch failed.');
+
+    logInfo(`Rebasing '${currentBranch}' onto '${remote}/${base}'...`);
+    if (git(['rebase', `${remote}/${base}`]).status === 0) {
+        logSuccess(`'${currentBranch}' is now up to date with '${remote}/${base}'.`);
+        return;
+    }
+
+    const gitDir = gitCapture(['rev-parse', '--git-dir']);
+    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, then 'git rebase --continue'.");
+        const openEditor = (await prompt('Do you want to open VS Code to resolve this now? (y/n)')).toLowerCase();
+        if (openEditor === 'y') spawnSync('code', ['.'], { stdio: 'inherit' });
+    } else {
+        logError('Rebase failed — this looks like a connection problem, not a merge conflict (see the git error above).');
+    }
+    process.exit(1);
+}
+
+async function cmdCleanBranches() {
+    const remote = defaultRemote();
+    if (!remote) die('No remote configured.');
+
+    logInfo(`Pruning stale remote-tracking refs on '${remote}'...`);
+    if (git(['fetch', remote, '--prune']).status !== 0) die('Fetch failed.');
+
+    const base = baseBranch(remote);
+    if (!base) die("Could not determine the repo's base branch.");
+    const currentBranch = gitCapture(['branch', '--show-current']);
+    const protectedNames = new Set([currentBranch, 'main', 'master', 'develop', 'dev']);
+
+    const candidates = gitCapture(['branch', '--format=%(refname:short)', '--merged', `${remote}/${base}`])
+        .split(/\r?\n/)
+        .filter((b) => b && !protectedNames.has(b));
+
+    if (candidates.length === 0) {
+        logSuccess('No merged local branches to clean up.');
+        return;
+    }
+
+    logInfo(`Local branches already merged into '${base}':`);
+    candidates.forEach((b) => console.log(`  - ${b}`));
+
+    if (!(await confirm(`Delete all ${candidates.length} of these local branches?`))) {
+        logInfo('Cancelled.');
+        return;
+    }
+
+    for (const b of candidates) {
+        if (git(['branch', '-d', b]).status === 0) {
+            logSuccess(`Deleted '${b}'.`);
+        } else {
+            logWarn(`Could not delete '${b}' (not fully merged?) — left as-is.`);
+        }
+    }
+}
+
+const HOOK_MARKER = '# xgem-managed-hook';
+
+async function cmdHooksInstall(configDir) {
+    const gitDir = gitCapture(['rev-parse', '--git-dir']);
+    if (!gitDir) die('Not a git repository.');
+    const hooksDir = path.join(gitDir, 'hooks');
+    const hookPath = path.join(hooksDir, 'pre-commit');
+
+    if (fs.existsSync(hookPath) && !fs.readFileSync(hookPath, 'utf8').includes(HOOK_MARKER)) {
+        logWarn("An existing pre-commit hook was found that xgem didn't create.");
+        if (!(await confirm('Overwrite it?'))) { logInfo('Cancelled.'); return; }
+    }
+
+    const runTests = (await prompt('Also run tests before commit (slower)? (y/N)')).toLowerCase() === 'y';
+    const xgemPath = process.argv[1];
+
+    const lines = ['#!/bin/sh', HOOK_MARKER];
+    let checksAdded = 0;
+    if (fs.existsSync(configDir)) {
+        for (const fw of fs.readdirSync(configDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name)) {
+            if (fs.existsSync(path.join(configDir, fw, 'lint.mjs'))) {
+                lines.push(`node "${xgemPath}" run ${fw} lint || exit 1`);
+                checksAdded += 1;
+            }
+            if (runTests && fs.existsSync(path.join(configDir, fw, 'test.mjs'))) {
+                lines.push(`node "${xgemPath}" run ${fw} test || exit 1`);
+                checksAdded += 1;
+            }
+        }
+    }
+
+    fs.mkdirSync(hooksDir, { recursive: true });
+    fs.writeFileSync(hookPath, lines.join('\n') + '\n', { mode: 0o755 });
+
+    if (checksAdded === 0) {
+        logWarn(`No lint/test scripts found under ${configDir} — installed a hook that doesn't check anything yet.`);
+    }
+    logSuccess(`Installed pre-commit hook at ${hookPath}.`);
+}
+
+async function cmdHooksUninstall() {
+    const gitDir = gitCapture(['rev-parse', '--git-dir']);
+    if (!gitDir) die('Not a git repository.');
+    const hookPath = path.join(gitDir, 'hooks', 'pre-commit');
+
+    if (!fs.existsSync(hookPath)) { logInfo('No pre-commit hook installed.'); return; }
+    if (!fs.readFileSync(hookPath, 'utf8').includes(HOOK_MARKER)) {
+        die(`${hookPath} wasn't created by xgem — not removing it.`);
+    }
+    fs.rmSync(hookPath);
+    logSuccess('Removed pre-commit hook.');
+}
+
+async function cmdHooks(sub, configDir) {
+    switch (sub) {
+        case 'install': return cmdHooksInstall(configDir);
+        case 'uninstall': return cmdHooksUninstall();
+        default: die('Usage: xgem git hooks <install|uninstall>');
+    }
+}
+
+async function cmdGit(sub, arg, configDir) {
     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>`);
+        case 'pr': return cmdPr(configDir);
+        case 'sync': return cmdSync();
+        case 'clean-branches': return cmdCleanBranches();
+        case 'hooks': return cmdHooks(arg, configDir);
+        default: die(`Unknown git subcommand '${sub}'. Usage: xgem git <cmt|init|branch|rm-remote|rm-branch|pr|sync|clean-branches|hooks>`);
     }
 }
 
-module.exports = { cmdGit };
+module.exports = { cmdGit, defaultRemote };

package/lib-win/registry.js

@@ -0,0 +1,43 @@
+// xgem's global (cross-project) registry — port of lib/registry.sh. Same
+// plain newline-delimited path file, so a dual-boot user's registry is
+// readable from either platform.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const REGISTRY_FILE = process.env.XGEM_REGISTRY_FILE || path.join(os.homedir(), '.xgem', 'projects');
+
+function readLines() {
+    if (!fs.existsSync(REGISTRY_FILE)) return [];
+    return fs.readFileSync(REGISTRY_FILE, 'utf8').split(/\r?\n/).filter(Boolean);
+}
+
+function writeLines(lines) {
+    fs.mkdirSync(path.dirname(REGISTRY_FILE), { recursive: true });
+    fs.writeFileSync(REGISTRY_FILE, lines.length ? lines.join('\n') + '\n' : '');
+}
+
+function registryAdd(projectPath) {
+    const lines = readLines();
+    if (!lines.includes(projectPath)) {
+        lines.push(projectPath);
+        writeLines(lines);
+    }
+}
+
+function registryRemove(projectPath) {
+    writeLines(readLines().filter((l) => l !== projectPath));
+}
+
+// registryList(configDir) — returns live project paths, pruning (and
+// rewriting the registry for) any entry that no longer exists or is no
+// longer xgem-tracked.
+function registryList(configDir) {
+    const lines = readLines();
+    const live = lines.filter((p) => fs.existsSync(path.join(p, configDir)));
+    if (live.length !== lines.length) writeLines(live);
+    return live;
+}
+
+module.exports = { registryAdd, registryRemove, registryList };