xtrm-cli 0.5.0

package/src/commands/status.ts

@@ -0,0 +1,170 @@
+import { Command } from 'commander';
+import kleur from 'kleur';
+// @ts-ignore
+import prompts from 'prompts';
+import { getCandidatePaths } from '../core/context.js';
+import { calculateDiff } from '../core/diff.js';
+import { executeSync } from '../core/sync-executor.js';
+import { findRepoRoot } from '../utils/repo-root.js';
+import { getManifestPath } from '../core/manifest.js';
+import fs from 'fs-extra';
+import path from 'path';
+// @ts-ignore
+import Conf from 'conf';
+
+function formatTargetLabel(target: string): string {
+    const normalized = target.replace(/\\/g, '/').toLowerCase();
+    if (normalized.endsWith('/.agents/skills') || normalized.includes('/.agents/skills/')) return '~/.agents/skills';
+    if (normalized.endsWith('/.claude') || normalized.includes('/.claude/')) return '~/.claude';
+    return path.basename(target);
+}
+
+function formatRelativeTime(timestamp: number): string {
+    const now = Date.now();
+    const diff = now - timestamp;
+
+    const minutes = Math.floor(diff / 60000);
+    const hours = Math.floor(diff / 3600000);
+    const days = Math.floor(diff / 86400000);
+
+    if (minutes < 1) return 'just now';
+    if (minutes < 60) return `${minutes} minute${minutes > 1 ? 's' : ''} ago`;
+    if (hours < 24) return `${hours} hour${hours > 1 ? 's' : ''} ago`;
+    return `${days} day${days > 1 ? 's' : ''} ago`;
+}
+
+export function createStatusCommand(): Command {
+    return new Command('status')
+        .description('Show status and optionally sync target environments')
+        .option('--json', 'Output machine-readable JSON', false)
+        .action(async (opts) => {
+            const { json } = opts;
+
+            const repoRoot = await findRepoRoot();
+
+            // Auto-detect all existing environments (no prompt needed for read-only view)
+            const candidates = getCandidatePaths();
+            const targets: string[] = [];
+            for (const c of candidates) {
+                if (await fs.pathExists(c.path)) targets.push(c.path);
+            }
+            if (targets.length === 0) {
+                console.log(kleur.yellow('\n  No agent environments found (~/.claude, ~/.agents/skills)\n'));
+                return;
+            }
+
+            interface TargetStatus {
+                path: string;
+                name: string;
+                lastSync: string | null;
+                changes: Record<string, { missing: string[]; outdated: string[]; drifted: string[] }>;
+                totalChanges: number;
+            }
+
+            const results: TargetStatus[] = [];
+
+            for (const target of targets) {
+                const manifestPath = getManifestPath(target);
+                let lastSync: string | null = null;
+                try {
+                    if (await fs.pathExists(manifestPath)) {
+                        const manifest = await fs.readJson(manifestPath);
+                        if (manifest.lastSync) lastSync = manifest.lastSync;
+                    }
+                } catch { /* ignore */ }
+
+                const changeSet = await calculateDiff(repoRoot, target);
+                const totalChanges = Object.values(changeSet).reduce(
+                    (sum: number, c: any) => sum + c.missing.length + c.outdated.length + c.drifted.length, 0,
+                ) as number;
+
+                results.push({ path: target, name: formatTargetLabel(target), lastSync, changes: changeSet as any, totalChanges });
+            }
+
+            // ── JSON output ──────────────────────────────────────────────────
+            if (json) {
+                console.log(JSON.stringify({ targets: results }, null, 2));
+                return;
+            }
+
+            // ── Table output ─────────────────────────────────────────────────
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const Table = require('cli-table3');
+
+            const table = new Table({
+                head: [
+                    kleur.bold('Target'),
+                    kleur.bold(kleur.green('+ New')),
+                    kleur.bold(kleur.yellow('↑ Update')),
+                    kleur.bold(kleur.red('! Drift')),
+                    kleur.bold('Last Sync'),
+                ],
+                style: { head: [], border: [] },
+            });
+
+            for (const r of results) {
+                const missing  = Object.values(r.changes).reduce((s: number, c: any) => s + c.missing.length,  0) as number;
+                const outdated = Object.values(r.changes).reduce((s: number, c: any) => s + c.outdated.length, 0) as number;
+                const drifted  = Object.values(r.changes).reduce((s: number, c: any) => s + c.drifted.length,  0) as number;
+
+                const lastSyncStr = r.lastSync
+                    ? kleur.gray(formatRelativeTime(new Date(r.lastSync).getTime()))
+                    : kleur.gray('never');
+
+                table.push([
+                    r.totalChanges > 0 ? kleur.bold(r.name) : r.name,
+                    missing  > 0 ? kleur.green(String(missing))  : kleur.gray('—'),
+                    outdated > 0 ? kleur.yellow(String(outdated)) : kleur.gray('—'),
+                    drifted  > 0 ? kleur.red(String(drifted))    : kleur.gray('—'),
+                    lastSyncStr,
+                ]);
+            }
+
+            console.log('\n' + table.toString());
+
+            const totalPending = results.reduce((s, r) => s + r.totalChanges, 0);
+
+            if (totalPending === 0) {
+                console.log(kleur.green('\n  ✓ All environments up-to-date\n'));
+                return;
+            }
+
+            const pending = results.filter(r => r.totalChanges > 0);
+            console.log(kleur.yellow(`\n  ⚠  ${totalPending} pending change${totalPending !== 1 ? 's' : ''} across ${pending.length} environment${pending.length !== 1 ? 's' : ''}\n`));
+
+            // ── Inline sync offer ────────────────────────────────────────────
+            const { selected } = await prompts({
+                type: 'multiselect',
+                name: 'selected',
+                message: 'Select environments to sync:',
+                choices: pending.map(r => ({
+                    title: `${r.name}  ${kleur.gray(`(${r.totalChanges} change${r.totalChanges !== 1 ? 's' : ''})`)}`,
+                    value: r.path,
+                    selected: true,
+                })),
+                hint: '- Space to toggle. Enter to confirm. Esc to skip.',
+                instructions: false,
+            });
+
+            if (!selected || selected.length === 0) {
+                console.log(kleur.gray('  Skipped. Run xtrm sync anytime to apply.\n'));
+                return;
+            }
+
+            const toSync = pending.filter(r => selected.includes(r.path));
+
+            // Reuse the already-computed changeSets — no second diff needed
+            const store = new Conf({ projectName: 'xtrm-manager' });
+            const syncMode = (store.get('syncMode') as string) || 'copy';
+
+            let totalSynced = 0;
+            for (const r of toSync) {
+                console.log(kleur.bold(`\n  → ${r.name}`));
+                const count = await executeSync(repoRoot, r.path, r.changes as any, syncMode as any, 'sync', false);
+                totalSynced += count;
+                console.log(kleur.green(`  ✓ ${count} item${count !== 1 ? 's' : ''} synced`));
+            }
+
+            console.log(kleur.bold().green(`\n✓ Done — ${totalSynced} item${totalSynced !== 1 ? 's' : ''} synced\n`));
+        });
+}

package/src/commands/worktree.ts

@@ -0,0 +1,193 @@
+import { Command } from 'commander';
+import kleur from 'kleur';
+import prompts from 'prompts';
+import { spawnSync } from 'node:child_process';
+import { t } from '../utils/theme.js';
+
+interface WorktreeInfo {
+    path: string;
+    branch: string;
+    head: string;
+    prunable: boolean;
+}
+
+/** Parse `git worktree list --porcelain` output into WorktreeInfo array */
+function listXtWorktrees(repoRoot: string): WorktreeInfo[] {
+    const r = spawnSync('git', ['worktree', 'list', '--porcelain'], {
+        cwd: repoRoot, encoding: 'utf8', stdio: 'pipe',
+    });
+    if (r.status !== 0) return [];
+
+    const worktrees: WorktreeInfo[] = [];
+    let current: Partial<WorktreeInfo> = {};
+
+    for (const line of (r.stdout ?? '').split('\n')) {
+        if (line.startsWith('worktree ')) {
+            if (current.path && current.branch?.startsWith('refs/heads/xt/')) {
+                worktrees.push(current as WorktreeInfo);
+            }
+            current = { path: line.slice('worktree '.length), prunable: false };
+        } else if (line.startsWith('HEAD ')) {
+            current.head = line.slice('HEAD '.length);
+        } else if (line.startsWith('branch ')) {
+            current.branch = line.slice('branch '.length);
+        } else if (line === 'prunable') {
+            current.prunable = true;
+        }
+    }
+    // Flush last entry
+    if (current.path && current.branch?.startsWith('refs/heads/xt/')) {
+        worktrees.push(current as WorktreeInfo);
+    }
+
+    return worktrees;
+}
+
+/** Check if a branch has been merged into main */
+function isMergedIntoMain(branch: string, repoRoot: string): boolean {
+    const branchShort = branch.replace('refs/heads/', '');
+    const r = spawnSync('git', ['branch', '--merged', 'origin/main', '--list', branchShort], {
+        cwd: repoRoot, encoding: 'utf8', stdio: 'pipe',
+    });
+    return (r.stdout ?? '').includes(branchShort);
+}
+
+/** Check if a branch has an open or merged PR */
+function getPrStatus(branch: string, repoRoot: string): string {
+    const branchShort = branch.replace('refs/heads/', '');
+    const r = spawnSync('gh', ['pr', 'list', '--head', branchShort, '--state', 'all', '--json', 'state,url', '--limit', '1'], {
+        cwd: repoRoot, encoding: 'utf8', stdio: 'pipe',
+    });
+    if (r.status !== 0) return 'unknown';
+    try {
+        const data = JSON.parse(r.stdout ?? '[]');
+        if (data.length === 0) return 'no PR';
+        return `${data[0].state.toLowerCase()} (${data[0].url})`;
+    } catch {
+        return 'unknown';
+    }
+}
+
+function getRepoRoot(cwd: string): string {
+    const r = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8', stdio: 'pipe' });
+    return r.ok ? r.stdout.trim() : cwd;
+}
+
+export function createWorktreeCommand(): Command {
+    const cmd = new Command('worktree')
+        .description('Manage xt session worktrees');
+
+    cmd.command('list')
+        .description('List all active xt/* worktrees with status')
+        .action(async () => {
+            const repoRoot = getRepoRoot(process.cwd());
+            const worktrees = listXtWorktrees(repoRoot);
+
+            if (worktrees.length === 0) {
+                console.log(kleur.dim('\n  No xt worktrees found\n'));
+                return;
+            }
+
+            console.log(t.bold(`\n  xt worktrees (${worktrees.length})\n`));
+            for (const wt of worktrees) {
+                const branch = wt.branch.replace('refs/heads/', '');
+                const merged = isMergedIntoMain(wt.branch, repoRoot);
+                const status = merged ? kleur.green('merged') : kleur.yellow('open');
+                const prunable = wt.prunable ? kleur.dim(' [prunable]') : '';
+                console.log(`  ${status} ${kleur.bold(branch)}${prunable}`);
+                console.log(kleur.dim(`         ${wt.path}`));
+            }
+            console.log('');
+        });
+
+    cmd.command('clean')
+        .description('Remove worktrees whose branch has been merged into main')
+        .option('-y, --yes', 'Skip confirmation prompt', false)
+        .action(async (opts) => {
+            const repoRoot = getRepoRoot(process.cwd());
+            const worktrees = listXtWorktrees(repoRoot);
+            const merged = worktrees.filter(wt => isMergedIntoMain(wt.branch, repoRoot));
+
+            if (merged.length === 0) {
+                console.log(kleur.dim('\n  No merged xt worktrees to clean\n'));
+                return;
+            }
+
+            console.log(t.bold(`\n  ${merged.length} merged worktree(s) to remove:\n`));
+            for (const wt of merged) {
+                console.log(kleur.dim(`  - ${wt.path} (${wt.branch.replace('refs/heads/', '')})`));
+            }
+
+            let doRemove = opts.yes;
+            if (!opts.yes) {
+                const { confirm } = await prompts({
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Remove ${merged.length} worktree(s)?`,
+                    initial: true,
+                });
+                doRemove = confirm;
+            }
+
+            if (!doRemove) {
+                console.log(kleur.dim('  Cancelled\n'));
+                return;
+            }
+
+            for (const wt of merged) {
+                const r = spawnSync('git', ['worktree', 'remove', wt.path, '--force'], {
+                    cwd: repoRoot, encoding: 'utf8', stdio: 'pipe',
+                });
+                if (r.status === 0) {
+                    console.log(t.success(`  ✓ Removed ${wt.path}`));
+                } else {
+                    console.log(kleur.yellow(`  ⚠ Could not remove ${wt.path}: ${(r.stderr ?? '').trim()}`));
+                }
+            }
+            console.log('');
+        });
+
+    cmd.command('remove <name>')
+        .description('Manually remove a specific xt worktree by branch name or path')
+        .option('-y, --yes', 'Skip confirmation', false)
+        .action(async (name: string, opts) => {
+            const repoRoot = getRepoRoot(process.cwd());
+            const worktrees = listXtWorktrees(repoRoot);
+            const target = worktrees.find(wt =>
+                wt.path === name ||
+                wt.branch === `refs/heads/${name}` ||
+                wt.branch === `refs/heads/xt/${name}`
+            );
+
+            if (!target) {
+                console.error(kleur.red(`\n  ✗ No xt worktree found matching "${name}"\n`));
+                console.log(kleur.dim('  Run: xt worktree list\n'));
+                process.exit(1);
+            }
+
+            let doRemove = opts.yes;
+            if (!opts.yes) {
+                const { confirm } = await prompts({
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Remove ${target.path}?`,
+                    initial: false,
+                });
+                doRemove = confirm;
+            }
+
+            if (!doRemove) { console.log(kleur.dim('  Cancelled\n')); return; }
+
+            const r = spawnSync('git', ['worktree', 'remove', target.path, '--force'], {
+                cwd: repoRoot, encoding: 'utf8', stdio: 'pipe',
+            });
+            if (r.status === 0) {
+                console.log(t.success(`\n  ✓ Removed ${target.path}\n`));
+            } else {
+                console.error(kleur.red(`\n  ✗ Failed: ${(r.stderr ?? '').trim()}\n`));
+                process.exit(1);
+            }
+        });
+
+    return cmd;
+}

package/src/core/context.ts

@@ -0,0 +1,141 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs-extra';
+// @ts-ignore
+import Conf from 'conf';
+// @ts-ignore
+import prompts from 'prompts';
+import kleur from 'kleur';
+import type { SyncMode } from '../types/config.js';
+
+
+export interface Context {
+    targets: string[];
+    syncMode: 'copy' | 'symlink' | 'prune';
+    config: any;
+}
+
+export interface GetContextOptions {
+    selector?: string;
+    createMissingDirs?: boolean;
+}
+
+let config: Conf | null = null;
+
+function getConfig(): Conf {
+    if (!config) {
+        config = new Conf({
+            projectName: 'xtrm-cli',
+            defaults: {
+                syncMode: 'copy',
+            },
+        });
+    }
+
+    return config;
+}
+
+export function getCandidatePaths(): Array<{ label: string; path: string }> {
+    const home = os.homedir();
+    const appData = process.env.APPDATA;
+    const isWindows = process.platform === 'win32';
+
+    const paths = [
+        { label: '~/.claude (hooks + skills)', path: path.join(home, '.claude') },
+        { label: '~/.agents/skills', path: path.join(home, '.agents', 'skills') },
+    ];
+
+    if (isWindows && appData) {
+        paths.push({ label: 'Claude (AppData)', path: path.join(appData, 'Claude') });
+    }
+
+    return paths;
+}
+
+export function resolveTargets(
+    selector: string | undefined,
+    candidates: Array<{ label: string; path: string }>,
+): string[] | null {
+    if (!selector) return null;
+
+    const normalized = selector.trim().toLowerCase();
+    if (normalized === '*' || normalized === 'all') {
+        return candidates.map(candidate => candidate.path);
+    }
+
+    throw new Error(`Unknown install target selector '${selector}'. Use '*' or 'all'.`);
+}
+
+export async function getContext(options: GetContextOptions = {}): Promise<Context> {
+    const { selector, createMissingDirs = true } = options;
+    const choices = [];
+    const candidates = getCandidatePaths();
+    const directTargets = resolveTargets(selector, candidates);
+
+    if (directTargets) {
+        const activeConfig = getConfig();
+        if (createMissingDirs) {
+            for (const target of directTargets) {
+                await fs.ensureDir(target);
+            }
+        }
+
+        return {
+            targets: directTargets,
+            syncMode: activeConfig.get('syncMode') as SyncMode,
+            config: activeConfig,
+        };
+    }
+
+    const activeConfig = getConfig();
+
+    for (const c of candidates) {
+        const exists = await fs.pathExists(c.path);
+        const icon = exists ? kleur.green('●') : kleur.gray('○');
+        const desc = exists ? 'Found' : 'Not found (will create)';
+
+        choices.push({
+            title: `${icon} ${c.label} (${c.path})`,
+            description: desc,
+            value: c.path,
+            selected: exists, // Pre-select existing environments
+        });
+    }
+
+    const response = await prompts({
+        type: 'multiselect',
+        name: 'targets',
+        message: 'Select target environment(s):',
+        choices: choices,
+        hint: '- Space to select. Return to submit',
+        instructions: false,
+    });
+
+    if (response.targets === undefined) {
+        console.log(kleur.gray('\nCancelled.'));
+        process.exit(130);
+    }
+    if (response.targets.length === 0) {
+        console.log(kleur.gray('No targets selected.'));
+        process.exit(0);
+    }
+
+    // Ensure directories exist for selected targets
+    if (createMissingDirs) {
+        for (const target of response.targets) {
+            await fs.ensureDir(target);
+        }
+    }
+
+    return {
+        targets: response.targets,
+        syncMode: activeConfig.get('syncMode') as SyncMode,
+        config: activeConfig,
+    };
+
+}
+
+export function resetContext(): void {
+    getConfig().clear();
+    console.log(kleur.yellow('Configuration cleared.'));
+}

package/src/core/diff.ts

@@ -0,0 +1,174 @@
+import { join, normalize } from 'path';
+import fs from 'fs-extra';
+import { hashDirectory, getNewestMtime } from '../utils/hash.js';
+import type { ChangeSet } from '../types/config.js';
+import { getAdapter } from '../adapters/registry.js';
+import { detectAdapter } from '../adapters/registry.js';
+
+// Items to ignore from diff scanning (similar to .gitignore)
+const IGNORED_ITEMS = new Set(['__pycache__', '.DS_Store', 'Thumbs.db', '.gitkeep', 'node_modules']);
+
+export class PruneModeReadError extends Error {
+    constructor(path: string) {
+        super(`Cannot read ${path} in prune mode — aborting to prevent accidental deletion`);
+        this.name = 'PruneModeReadError';
+    }
+}
+
+export async function calculateDiff(repoRoot: string, systemRoot: string, pruneMode: boolean = false): Promise<ChangeSet> {
+    const adapter = detectAdapter(systemRoot);
+    const isClaude = adapter?.toolName === 'claude-code';
+    const isQwen = adapter?.toolName === 'qwen';
+    const normalizedRoot = normalize(systemRoot).replace(/\\/g, '/');
+    const isAgentsSkills = normalizedRoot.includes('.agents/skills');
+
+    const changeSet: ChangeSet = {
+        skills: { missing: [], outdated: [], drifted: [], total: 0 },
+        hooks: { missing: [], outdated: [], drifted: [], total: 0 },
+        config: { missing: [], outdated: [], drifted: [], total: 0 },
+        commands: { missing: [], outdated: [], drifted: [], total: 0 },
+        'qwen-commands': { missing: [], outdated: [], drifted: [], total: 0 },
+        'antigravity-workflows': { missing: [], outdated: [], drifted: [], total: 0 },
+    };
+
+    // Load installed file hashes from manifest for precise drift classification
+    const manifestPath = join(systemRoot, '.jaggers-sync-manifest.json');
+    let installedHashes: Record<string, string> | null = null;
+    try {
+        if (await fs.pathExists(manifestPath)) {
+            const manifest = await fs.readJson(manifestPath);
+            if (manifest.fileHashes && typeof manifest.fileHashes === 'object') {
+                installedHashes = manifest.fileHashes;
+            }
+        }
+    } catch {
+        // Manifest unreadable — fall back to mtime heuristic
+    }
+
+    // ~/.agents/skills: skills-only, mapped directly (repoRoot/skills/* → systemRoot/*)
+    if (isAgentsSkills) {
+        const repoPath = join(repoRoot, 'skills');
+        if (!(await fs.pathExists(repoPath))) return changeSet;
+
+        const items = (await fs.readdir(repoPath)).filter(i => !IGNORED_ITEMS.has(i));
+        changeSet.skills.total = items.length;
+
+        for (const item of items) {
+            await compareItem('skills', item, join(repoPath, item), join(systemRoot, item), changeSet, pruneMode, installedHashes);
+        }
+        return changeSet;
+    }
+
+    // 1. Folders: Skills & Hooks & Commands
+    const folders = ['skills', 'hooks'];
+    if (isQwen) folders.push('qwen-commands');
+    else if (!isClaude) folders.push('commands');
+
+    for (const category of folders) {
+        let repoPath: string;
+        let systemPath: string;
+
+        if (category === 'qwen-commands') {
+            repoPath = join(repoRoot, '.qwen', 'commands');
+            systemPath = join(systemRoot, 'commands');
+        } else {
+            repoPath = join(repoRoot, category);
+            systemPath = join(systemRoot, category);
+        }
+
+        if (!(await fs.pathExists(repoPath))) continue;
+
+        const items = (await fs.readdir(repoPath)).filter(i => !IGNORED_ITEMS.has(i));
+        (changeSet[category as keyof ChangeSet] as any).total = items.length;
+
+        for (const item of items) {
+            await compareItem(
+                category as keyof ChangeSet,
+                item,
+                join(repoPath, item),
+                join(systemPath, item),
+                changeSet,
+                pruneMode,
+                installedHashes,
+            );
+        }
+    }
+
+    // 2. Config Files (Explicit Mapping)
+    const configMapping = {
+        'settings.json': { repo: 'config/settings.json', sys: 'settings.json' },
+    };
+
+    for (const [name, paths] of Object.entries(configMapping)) {
+        // settings.json is path-transformed on install for all agent environments,
+        // so the hash always differs — skip to prevent perpetual false "1 update"
+        if (name === 'settings.json' && adapter !== null) continue;
+
+        const itemRepoPath = join(repoRoot, paths.repo);
+        const itemSystemPath = join(systemRoot, paths.sys);
+
+        if (await fs.pathExists(itemRepoPath)) {
+            await compareItem('config', name, itemRepoPath, itemSystemPath, changeSet, false, installedHashes);
+        }
+    }
+
+    return changeSet;
+}
+
+async function compareItem(
+    category: keyof ChangeSet,
+    item: string,
+    repoPath: string,
+    systemPath: string,
+    changeSet: ChangeSet,
+    pruneMode: boolean = false,
+    installedHashes: Record<string, string> | null = null,
+): Promise<void> {
+    const cat = changeSet[category] as any;
+
+    if (!(await fs.pathExists(systemPath))) {
+        cat.missing.push(item);
+        return;
+    }
+
+    const repoHash = await hashDirectory(repoPath);
+
+    // Wrap system-side hash read in try/catch for prune mode safety
+    let systemHash: string;
+    try {
+        systemHash = await hashDirectory(systemPath);
+    } catch (error) {
+        if (pruneMode) {
+            throw new PruneModeReadError(systemPath);
+        }
+        // If not in prune mode, treat as missing
+        cat.missing.push(item);
+        return;
+    }
+
+    if (repoHash !== systemHash) {
+        const manifestKey = `${category}/${item}`;
+        const installedHash = installedHashes?.[manifestKey];
+
+        if (installedHash !== undefined) {
+            // Manifest-based classification: compare system against installed snapshot
+            if (systemHash !== installedHash) {
+                // System was modified after last install → drifted (local changes)
+                cat.drifted.push(item);
+            } else {
+                // System matches install snapshot but repo changed → outdated
+                cat.outdated.push(item);
+            }
+        } else {
+            // No manifest data: fall back to mtime heuristic
+            const repoMtime = await getNewestMtime(repoPath);
+            const systemMtime = await getNewestMtime(systemPath);
+
+            if (systemMtime > repoMtime + 2000) {
+                cat.drifted.push(item);
+            } else {
+                cat.outdated.push(item);
+            }
+        }
+    }
+}