xtrm-cli 2.1.4

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, ~/.gemini, ~/.qwen)\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/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,143 @@
+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 },
+    };
+
+    // ~/.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);
+        }
+        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
+            );
+        }
+    }
+
+    // 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);
+        }
+    }
+
+    return changeSet;
+}
+
+async function compareItem(
+    category: keyof ChangeSet,
+    item: string,
+    repoPath: string,
+    systemPath: string,
+    changeSet: ChangeSet,
+    pruneMode: boolean = false
+): 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 repoMtime = await getNewestMtime(repoPath);
+        const systemMtime = await getNewestMtime(systemPath);
+
+        if (systemMtime > repoMtime + 2000) {
+            cat.drifted.push(item);
+        } else {
+            cat.outdated.push(item);
+        }
+    }
+}

package/src/core/interactive-plan.ts

@@ -0,0 +1,165 @@
+// @ts-ignore
+import prompts from 'prompts';
+import kleur from 'kleur';
+import type { PreflightPlan, TargetPlan, OptionalServerItem } from './preflight.js';
+
+// ── Types ──────────────────────────────────────────────────────────────────
+
+export interface SelectedFileItem {
+    target: string;
+    name: string;
+    status: 'missing' | 'outdated' | 'drifted';
+    category: string;
+}
+
+export interface SelectedMcpItem {
+    target: string;
+    agent: string;
+    name: string;
+}
+
+export interface SelectedPlan {
+    files: SelectedFileItem[];
+    mcpCore: SelectedMcpItem[];
+    optionalServers: OptionalServerItem[];
+    repoRoot: string;
+    syncMode: 'copy' | 'symlink';
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+const STATUS_LABEL: Record<string, string> = {
+    missing:  kleur.green('[+]'),
+    outdated: kleur.yellow('[↑]'),    // yellow = actionable warning, not blue
+    drifted:  kleur.magenta('[≠]'),   // magenta = conflict/divergence
+};
+
+function fileChoices(target: TargetPlan): any[] {
+    if (target.files.length === 0) return [];
+    const choices: any[] = [
+        { title: kleur.bold().dim(`  ── ${target.label} files ──`), disabled: true, value: null },
+    ];
+    for (const f of target.files) {
+        const label = STATUS_LABEL[f.status] ?? '[?]';
+        const hint = f.status === 'drifted' ? kleur.dim('  local edits — skip recommended') : '';
+        choices.push({
+            title: `  ${label} ${f.category}/${f.name}${hint}`,
+            value: { type: 'file', target: target.target, name: f.name, status: f.status, category: f.category },
+            selected: f.status !== 'drifted',
+        });
+    }
+    return choices;
+}
+
+function mcpCoreChoices(target: TargetPlan): any[] {
+    const uninstalled = target.mcpCore.filter(m => !m.installed);
+    const installed   = target.mcpCore.filter(m => m.installed);
+    if (target.mcpCore.length === 0) return [];
+
+    const choices: any[] = [
+        { title: kleur.bold().dim(`  ── ${target.label} MCP servers ──`), disabled: true, value: null },
+    ];
+    for (const m of uninstalled) {
+        choices.push({
+            title: `  ${kleur.green('[+]')} ${m.name}`,
+            value: { type: 'mcp-core', target: target.target, agent: target.agent, name: m.name },
+            selected: true,
+        });
+    }
+    for (const m of installed) {
+        choices.push({
+            title: kleur.dim(`  [=] ${m.name}  (already installed)`),
+            disabled: true,
+            value: null,
+        });
+    }
+    return choices;
+}
+
+function optionalChoices(optionalServers: OptionalServerItem[]): any[] {
+    if (optionalServers.length === 0) return [];
+    const choices: any[] = [
+        { title: kleur.bold().dim('  ── optional servers ──'), disabled: true, value: null },
+    ];
+    for (const s of optionalServers) {
+        const prereq = s.prerequisite ? kleur.yellow(` ⚠ ${s.prerequisite}`) : '';
+        choices.push({
+            title: `  ${kleur.yellow('[?]')} ${s.name}${prereq}`,
+            value: { type: 'mcp-optional', server: s },
+            selected: false,
+        });
+    }
+    return choices;
+}
+
+// ── Main export ────────────────────────────────────────────────────────────
+
+export async function interactivePlan(
+    plan: PreflightPlan,
+    opts: { dryRun?: boolean; yes?: boolean } = {}
+): Promise<SelectedPlan | null> {
+    const allChoices = [
+        ...plan.targets.flatMap(t => [...fileChoices(t), ...mcpCoreChoices(t)]),
+        ...optionalChoices(plan.optionalServers),
+    ].filter(c => c.title); // remove any undefined entries
+
+    const totalSelectable = allChoices.filter(c => !c.disabled && c.value !== null).length;
+
+    if (totalSelectable === 0) {
+        console.log(kleur.green('\n✓ Everything is up-to-date\n'));
+        return { files: [], mcpCore: [], optionalServers: [], repoRoot: plan.repoRoot, syncMode: plan.syncMode };
+    }
+
+    console.log(kleur.bold('\n📋 Sync Plan') + kleur.dim('  (space to toggle, a = all, enter to confirm)\n'));
+
+    if (opts.dryRun) {
+        // Just display, don't prompt
+        for (const c of allChoices) {
+            if (c.disabled) { console.log(kleur.dim(c.title)); continue; }
+            const bullet = c.selected ? '◉' : '◯';
+            console.log(`  ${bullet} ${c.title?.trim()}`);
+        }
+        console.log(kleur.cyan('\n💡 Dry run — no changes written\n'));
+        return null;
+    }
+
+    if (opts.yes) {
+        // Select all pre-selected defaults, skip prompt
+        const selected = allChoices.filter(c => !c.disabled && c.selected && c.value).map(c => c.value);
+        return buildSelectedPlan(selected, plan);
+    }
+
+    const response = await prompts({
+        type: 'multiselect',
+        name: 'selected',
+        message: 'Select items to sync:',
+        choices: allChoices,
+        hint: 'space to toggle · a = all · enter to confirm',
+        instructions: false,
+        min: 0,
+    });
+
+    // ctrl+c returns undefined
+    if (!response || response.selected === undefined) {
+        console.log(kleur.gray('\n  Cancelled.\n'));
+        return null;
+    }
+
+    return buildSelectedPlan(response.selected, plan);
+}
+
+function buildSelectedPlan(selected: any[], plan: PreflightPlan): SelectedPlan {
+    const files: SelectedFileItem[] = selected
+        .filter(v => v?.type === 'file')
+        .map(v => ({ target: v.target, name: v.name, status: v.status, category: v.category }));
+
+    const mcpCore: SelectedMcpItem[] = selected
+        .filter(v => v?.type === 'mcp-core')
+        .map(v => ({ target: v.target, agent: v.agent, name: v.name }));
+
+    const optionalServers: OptionalServerItem[] = selected
+        .filter(v => v?.type === 'mcp-optional')
+        .map(v => v.server);
+
+    return { files, mcpCore, optionalServers, repoRoot: plan.repoRoot, syncMode: plan.syncMode };
+}

package/src/core/manifest.ts

@@ -0,0 +1,26 @@
+import fs from 'fs-extra';
+import { join } from 'path';
+import { Manifest, ManifestSchema } from '../types/config.js';
+
+const MANIFEST_FILE = '.jaggers-sync-manifest.json';
+
+export function getManifestPath(projectDir: string): string {
+    return join(projectDir, MANIFEST_FILE);
+}
+
+export async function loadManifest(projectDir: string): Promise<Manifest | null> {
+    const manifestPath = join(projectDir, MANIFEST_FILE);
+
+    try {
+        const content = await fs.readJson(manifestPath);
+        // Let schema validation gracefully fail or handle legacy
+        return ManifestSchema.parse(content) as Manifest;
+    } catch {
+        return null;
+    }
+}
+
+export async function saveManifest(projectDir: string, manifest: any): Promise<void> {
+    const manifestPath = join(projectDir, MANIFEST_FILE);
+    await fs.writeJson(manifestPath, manifest, { spaces: 2 });
+}