xtrm-cli 0.5.0

package/src/commands/install-pi.ts

@@ -0,0 +1,276 @@
+import { Command } from 'commander';
+import kleur from 'kleur';
+import prompts from 'prompts';
+import fs from 'fs-extra';
+import path from 'path';
+import { spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { findRepoRoot } from '../utils/repo-root.js';
+import { t, sym } from '../utils/theme.js';
+
+const PI_AGENT_DIR = process.env.PI_AGENT_DIR || path.join(homedir(), '.pi', 'agent');
+
+export interface PiExtensionDiff {
+    missing: string[];
+    stale: string[];
+    upToDate: string[];
+}
+
+interface SchemaField { key: string; label: string; hint: string; secret: boolean; required: boolean; }
+interface OAuthProvider { key: string; instruction: string; }
+interface InstallSchema { fields: SchemaField[]; oauth_providers: OAuthProvider[]; packages: string[]; }
+
+export const EXTRA_PI_CONFIGS = ['pi-worktrees-settings.json'];
+
+export async function copyExtraConfigs(srcDir: string, destDir: string): Promise<void> {
+    for (const name of EXTRA_PI_CONFIGS) {
+        const src = path.join(srcDir, name);
+        const dest = path.join(destDir, name);
+        if (await fs.pathExists(src) && !await fs.pathExists(dest)) {
+            await fs.copy(src, dest);
+        }
+    }
+}
+
+export function fillTemplate(template: string, values: Record<string, string>): string {
+    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => values[key] ?? '');
+}
+
+
+export function readExistingPiValues(piAgentDir: string): Record<string, string> {
+    const values: Record<string, string> = {};
+    try {
+        const auth = JSON.parse(require('fs').readFileSync(path.join(piAgentDir, 'auth.json'), 'utf8'));
+        if (auth?.dashscope?.key) values['DASHSCOPE_API_KEY'] = auth.dashscope.key;
+        if (auth?.zai?.key) values['ZAI_API_KEY'] = auth.zai.key;
+    } catch { /* file doesn't exist or invalid */ }
+    try {
+        const models = JSON.parse(require('fs').readFileSync(path.join(piAgentDir, 'models.json'), 'utf8'));
+        if (!values['DASHSCOPE_API_KEY'] && models?.providers?.dashscope?.apiKey) {
+            values['DASHSCOPE_API_KEY'] = models.providers.dashscope.apiKey;
+        }
+    } catch { /* file doesn't exist or invalid */ }
+    return values;
+}
+
+function isPiInstalled(): boolean {
+    return spawnSync('pi', ['--version'], { encoding: 'utf8' }).status === 0;
+}
+
+/**
+ * List extension directories (contain package.json) in a base directory.
+ */
+async function listExtensionDirs(baseDir: string): Promise<string[]> {
+    if (!await fs.pathExists(baseDir)) return [];
+    const entries = await fs.readdir(baseDir, { withFileTypes: true });
+    const extDirs: string[] = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const extPath = path.join(baseDir, entry.name);
+        const pkgPath = path.join(extPath, 'package.json');
+        if (await fs.pathExists(pkgPath)) {
+            extDirs.push(entry.name);
+        }
+    }
+    return extDirs.sort();
+}
+
+async function fileSha256(filePath: string): Promise<string> {
+    const crypto = await import('node:crypto');
+    const content = await fs.readFile(filePath);
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+/**
+ * Compute a hash for an extension package based on package.json + index.ts.
+ */
+async function extensionHash(extDir: string): Promise<string> {
+    const pkgPath = path.join(extDir, 'package.json');
+    const indexPath = path.join(extDir, 'index.ts');
+    
+    const hashes: string[] = [];
+    
+    if (await fs.pathExists(pkgPath)) {
+        hashes.push(await fileSha256(pkgPath));
+    }
+    if (await fs.pathExists(indexPath)) {
+        hashes.push(await fileSha256(indexPath));
+    }
+    
+    return hashes.join(':');
+}
+
+/**
+ * Compare extension packages between source and target directories.
+ * Returns missing, stale, and up-to-date extension names.
+ */
+export async function diffPiExtensions(sourceDir: string, targetDir: string): Promise<PiExtensionDiff> {
+    const sourceAbs = path.resolve(sourceDir);
+    const targetAbs = path.resolve(targetDir);
+
+    const sourceExts = await listExtensionDirs(sourceAbs);
+    const missing: string[] = [];
+    const stale: string[] = [];
+    const upToDate: string[] = [];
+
+    for (const extName of sourceExts) {
+        const srcExtPath = path.join(sourceAbs, extName);
+        const dstExtPath = path.join(targetAbs, extName);
+        
+        // Check if extension exists in target
+        if (!await fs.pathExists(dstExtPath)) {
+            missing.push(extName);
+            continue;
+        }
+        
+        // Check if package.json exists in target
+        const dstPkgPath = path.join(dstExtPath, 'package.json');
+        if (!await fs.pathExists(dstPkgPath)) {
+            missing.push(extName);
+            continue;
+        }
+
+        // Compare hashes
+        const [srcHash, dstHash] = await Promise.all([
+            extensionHash(srcExtPath),
+            extensionHash(dstExtPath)
+        ]);
+        
+        if (srcHash !== dstHash) {
+            stale.push(extName);
+        } else {
+            upToDate.push(extName);
+        }
+    }
+
+    return { missing, stale, upToDate };
+}
+
+function printPiCheckSummary(diff: PiExtensionDiff): void {
+    const totalDiff = diff.missing.length + diff.stale.length;
+
+    console.log(t.bold('\n  Pi extension drift check\n'));
+    console.log(t.muted(`  Up-to-date: ${diff.upToDate.length}`));
+    console.log(kleur.yellow(`  Missing:    ${diff.missing.length}`));
+    console.log(kleur.yellow(`  Stale:      ${diff.stale.length}`));
+
+    if (diff.missing.length > 0) {
+        console.log(kleur.yellow('\n  Missing extensions:'));
+        diff.missing.forEach((f) => console.log(kleur.yellow(`    - ${f}`)));
+    }
+
+    if (diff.stale.length > 0) {
+        console.log(kleur.yellow('\n  Stale extensions:'));
+        diff.stale.forEach((f) => console.log(kleur.yellow(`    - ${f}`)));
+    }
+
+    if (totalDiff === 0) {
+        console.log(t.success('\n  ✓ Pi extensions are in sync\n'));
+    }
+}
+
+export function createInstallPiCommand(): Command {
+    const cmd = new Command('pi');
+    cmd
+        .description('Install Pi coding agent with providers, extensions, and npm packages')
+        .option('-y, --yes', 'Skip confirmation prompts', false)
+        .option('--check', 'Check Pi extension deployment drift without writing changes', false)
+        .action(async (opts) => {
+            const { yes, check } = opts;
+            const repoRoot = await findRepoRoot();
+            const piConfigDir = path.join(repoRoot, 'config', 'pi');
+
+            if (check) {
+                const sourceDir = path.join(piConfigDir, 'extensions');
+                const targetDir = path.join(PI_AGENT_DIR, 'extensions');
+                const diff = await diffPiExtensions(sourceDir, targetDir);
+                printPiCheckSummary(diff);
+
+                if (diff.missing.length > 0 || diff.stale.length > 0) {
+                    console.error(kleur.red('  ✗ Pi extension drift detected. Run `xtrm install pi` to sync.\n'));
+                    process.exit(1);
+                }
+                return;
+            }
+
+            console.log(t.bold('\n  Pi Coding Agent Setup\n'));
+
+            if (!isPiInstalled()) {
+                console.log(kleur.yellow('  pi not found — installing oh-pi globally...\n'));
+                const r = spawnSync('npm', ['install', '-g', 'oh-pi'], { stdio: 'inherit' });
+                if (r.status !== 0) {
+                    console.error(kleur.red('\n  Failed to install oh-pi. Run: npm install -g oh-pi\n'));
+                    process.exit(1);
+                }
+                console.log(t.success('  pi installed\n'));
+            } else {
+                const v = spawnSync('pi', ['--version'], { encoding: 'utf8' });
+                console.log(t.success(`  pi ${v.stdout.trim()} already installed\n`));
+            }
+
+            const schema: InstallSchema = await fs.readJson(path.join(piConfigDir, 'install-schema.json'));
+            const existing = readExistingPiValues(PI_AGENT_DIR);
+            const values: Record<string, string> = { ...existing };
+
+            console.log(t.bold('  API Keys\n'));
+            for (const field of schema.fields) {
+                if (existing[field.key]) {
+                    console.log(t.success(`    ${sym.ok} ${field.label} [already set]`));
+                    continue;
+                }
+                if (!field.required && !yes) {
+                    const { include } = await prompts({ type: 'confirm', name: 'include', message: `  Configure ${field.label}? (optional)`, initial: false });
+                    if (!include) continue;
+                }
+                const { value } = await prompts({ type: field.secret ? 'password' : 'text', name: 'value', message: `  ${field.label}`, hint: field.hint, validate: (v) => (field.required && !v) ? 'Required' : true });
+                if (value) values[field.key] = value;
+            }
+
+            await fs.ensureDir(PI_AGENT_DIR);
+            console.log(t.muted(`\n  Writing config to ${PI_AGENT_DIR}`));
+
+            for (const name of ['models.json', 'auth.json', 'settings.json']) {
+                const destPath = path.join(PI_AGENT_DIR, name);
+                if (name === 'auth.json' && await fs.pathExists(destPath) && !yes) {
+                    const { overwrite } = await prompts({ type: 'confirm', name: 'overwrite', message: `  ${name} already exists — overwrite? (OAuth tokens will be lost)`, initial: false });
+                    if (!overwrite) { console.log(t.muted(`    skipped ${name}`)); continue; }
+                }
+                const raw = await fs.readFile(path.join(piConfigDir, `${name}.template`), 'utf8');
+                await fs.writeFile(destPath, fillTemplate(raw, values), 'utf8');
+                console.log(t.success(`    ${sym.ok} ${name}`));
+            }
+
+            await fs.copy(path.join(piConfigDir, 'extensions'), path.join(PI_AGENT_DIR, 'extensions'), { overwrite: true });
+            console.log(t.success(`    ${sym.ok} extensions/`));
+
+            // Register each extension with pi install -l
+            const extDirs = await listExtensionDirs(path.join(PI_AGENT_DIR, 'extensions'));
+            if (extDirs.length > 0) {
+                console.log(kleur.dim(`\n  Registering ${extDirs.length} extensions...`));
+                for (const extName of extDirs) {
+                    const extPath = path.join(PI_AGENT_DIR, 'extensions', extName);
+                    const r = spawnSync('pi', ['install', '-l', extPath], { stdio: 'pipe', encoding: 'utf8' });
+                    if (r.status === 0) {
+                        console.log(t.success(`    ${sym.ok} ${extName} registered`));
+                    } else {
+                        console.log(kleur.yellow(`    ⚠ ${extName} — registration failed`));
+                    }
+                }
+            }
+
+            console.log(t.bold('\n  npm Packages\n'));
+            for (const pkg of schema.packages) {
+                const r = spawnSync('pi', ['install', pkg], { stdio: 'inherit' });
+                if (r.status === 0) console.log(t.success(`    ${sym.ok} ${pkg}`));
+                else console.log(kleur.yellow(`    ${pkg} — failed, run manually: pi install ${pkg}`));
+            }
+
+            console.log(t.bold('\n  OAuth (manual steps)\n'));
+            for (const provider of schema.oauth_providers) {
+                console.log(t.muted(`    ${provider.key}: ${provider.instruction}`));
+            }
+
+            console.log(t.boldGreen('\n  Pi setup complete\n'));
+        });
+    return cmd;
+}

package/src/commands/install-service-skills.ts

@@ -0,0 +1,281 @@
+import { Command } from 'commander';
+import kleur from 'kleur';
+import path from 'path';
+import fs from 'fs-extra';
+import { spawnSync } from 'child_process';
+
+declare const __dirname: string;
+function resolvePkgRoot(): string {
+    const candidates = [
+        path.resolve(__dirname, '../..'),
+        path.resolve(__dirname, '../../..'),
+    ];
+
+    const match = candidates.find(candidate => fs.existsSync(path.join(candidate, 'project-skills')));
+    if (!match) {
+        throw new Error('Unable to locate project-skills directory from CLI runtime.');
+    }
+    return match;
+}
+
+const PKG_ROOT = resolvePkgRoot();
+const SKILLS_SRC = path.join(PKG_ROOT, 'project-skills', 'service-skills-set', '.claude');
+
+const TRINITY = [
+    'creating-service-skills',
+    'using-service-skills',
+    'updating-service-skills',
+    'scoping-service-skills',
+];
+
+const SETTINGS_HOOKS: Record<string, unknown[]> = {
+    SessionStart: [
+        {
+            hooks: [{
+                type: 'command',
+                command: 'python3 "$CLAUDE_PROJECT_DIR/.claude/skills/using-service-skills/scripts/cataloger.py"',
+            }],
+        },
+    ],
+    PreToolUse: [
+        {
+            matcher: 'Read|Write|Edit|Glob|Grep|Bash|mcp__serena__rename_symbol|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol',
+            hooks: [{
+                type: 'command',
+                command: 'python3 "$CLAUDE_PROJECT_DIR/.claude/skills/using-service-skills/scripts/skill_activator.py"',
+            }],
+        },
+    ],
+    PostToolUse: [
+        {
+            matcher: 'Write|Edit|mcp__serena__rename_symbol|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol',
+            hooks: [{
+                type: 'command',
+                command: 'python3 "$CLAUDE_PROJECT_DIR/.claude/skills/updating-service-skills/scripts/drift_detector.py" check-hook',
+                timeout: 10,
+            }],
+        },
+    ],
+};
+
+const MARKER_DOC = '# [jaggers] doc-reminder';
+const MARKER_STALENESS = '# [jaggers] skill-staleness';
+const MARKER_CHAIN = '# [jaggers] chain-githooks';
+
+// ─── Pure functions (exported for testing) ───────────────────────────────────
+
+export function mergeSettingsHooks(existing: Record<string, unknown>): {
+    result: Record<string, unknown>;
+    added: string[];
+    skipped: string[];
+} {
+    const result = { ...existing };
+    const hooks = (result.hooks ?? {}) as Record<string, unknown>;
+    result.hooks = hooks;
+
+    const added: string[] = [];
+    const skipped: string[] = [];
+
+    for (const [event, config] of Object.entries(SETTINGS_HOOKS)) {
+        if (event in hooks) {
+            skipped.push(event);
+        } else {
+            hooks[event] = config;
+            added.push(event);
+        }
+    }
+
+    return { result, added, skipped };
+}
+
+export async function installSkills(projectRoot: string, skillsSrc: string = SKILLS_SRC): Promise<{ skill: string; status: 'installed' | 'updated' }[]> {
+    const results: { skill: string; status: 'installed' | 'updated' }[] = [];
+    for (const skill of TRINITY) {
+        const src = path.join(skillsSrc, skill);
+        const dest = path.join(projectRoot, '.claude', 'skills', skill);
+        const existed = await fs.pathExists(dest);
+        if (existed) {
+            await fs.remove(dest);
+        }
+        await fs.copy(src, dest, {
+            filter: (src: string) => !src.includes('.Zone.Identifier')
+                && !src.includes('__pycache__')
+                && !src.includes('.pytest_cache')
+                && !src.endsWith('.pyc'),
+        });
+        results.push({ skill, status: existed ? 'updated' : 'installed' });
+    }
+    return results;
+}
+
+export async function installGitHooks(projectRoot: string, skillsSrc: string = SKILLS_SRC): Promise<{
+    hookFiles: { name: string; status: 'added' | 'already-present' }[];
+}> {
+    // Copy git-hook scripts into target project (no back-reference to jaggers package path)
+    const gitHooksSrc = path.join(skillsSrc, 'git-hooks');
+    const gitHooksDest = path.join(projectRoot, '.claude', 'git-hooks');
+    await fs.copy(gitHooksSrc, gitHooksDest, { overwrite: true });
+
+    const docScript = path.join(projectRoot, '.claude', 'git-hooks', 'doc_reminder.py');
+    const stalenessScript = path.join(projectRoot, '.claude', 'git-hooks', 'skill_staleness.py');
+
+    const preCommit = path.join(projectRoot, '.githooks', 'pre-commit');
+    const prePush = path.join(projectRoot, '.githooks', 'pre-push');
+
+    for (const hookPath of [preCommit, prePush]) {
+        if (!await fs.pathExists(hookPath)) {
+            await fs.mkdirp(path.dirname(hookPath));
+            await fs.writeFile(hookPath, '#!/usr/bin/env bash\n', { mode: 0o755 });
+        }
+    }
+
+    const snippets: [string, string, string][] = [
+        [
+            preCommit,
+            MARKER_DOC,
+            `\n${MARKER_DOC}\nif command -v python3 &>/dev/null && [ -f "${docScript}" ]; then\n    python3 "${docScript}" || true\nfi\n`,
+        ],
+        [
+            prePush,
+            MARKER_STALENESS,
+            `\n${MARKER_STALENESS}\nif command -v python3 &>/dev/null && [ -f "${stalenessScript}" ]; then\n    python3 "${stalenessScript}" || true\nfi\n`,
+        ],
+    ];
+
+    const hookFiles: { name: string; status: 'added' | 'already-present' }[] = [];
+
+    for (const [hookPath, marker, snippet] of snippets) {
+        const content = await fs.readFile(hookPath, 'utf8');
+        const name = path.basename(hookPath);
+        if (!content.includes(marker)) {
+            await fs.writeFile(hookPath, content + snippet);
+            hookFiles.push({ name, status: 'added' });
+        } else {
+            hookFiles.push({ name, status: 'already-present' });
+        }
+    }
+
+    const hooksPathResult = spawnSync('git', ['config', '--get', 'core.hooksPath'], {
+        cwd: projectRoot,
+        encoding: 'utf8',
+        timeout: 5000,
+    });
+    const configuredHooksPath = hooksPathResult.status === 0 ? hooksPathResult.stdout.trim() : '';
+    const activeHooksDir = configuredHooksPath
+        ? (path.isAbsolute(configuredHooksPath)
+            ? configuredHooksPath
+            : path.join(projectRoot, configuredHooksPath))
+        : path.join(projectRoot, '.git', 'hooks');
+
+    const activationTargets = new Set([path.join(projectRoot, '.git', 'hooks'), activeHooksDir]);
+    for (const hooksDir of activationTargets) {
+        await fs.mkdirp(hooksDir);
+
+        for (const [name, sourceHook] of [['pre-commit', preCommit], ['pre-push', prePush]] as const) {
+            const targetHook = path.join(hooksDir, name);
+            if (!await fs.pathExists(targetHook)) {
+                await fs.writeFile(targetHook, '#!/usr/bin/env bash\n', { mode: 0o755 });
+            } else {
+                await fs.chmod(targetHook, 0o755);
+            }
+
+            if (path.resolve(targetHook) === path.resolve(sourceHook)) {
+                continue;
+            }
+
+            const chainSnippet =
+                `\n${MARKER_CHAIN}\n` +
+                `if [ -x "${sourceHook}" ]; then\n` +
+                `    "${sourceHook}" "$@"\n` +
+                'fi\n';
+            const targetContent = await fs.readFile(targetHook, 'utf8');
+            if (!targetContent.includes(MARKER_CHAIN)) {
+                await fs.writeFile(targetHook, targetContent + chainSnippet);
+            }
+        }
+    }
+
+    return { hookFiles };
+}
+
+export async function installSettings(projectRoot: string): Promise<{ added: string[]; skipped: string[] }> {
+    const settingsPath = path.join(projectRoot, '.claude', 'settings.json');
+    await fs.mkdirp(path.dirname(settingsPath));
+
+    let existing: Record<string, unknown> = {};
+    if (await fs.pathExists(settingsPath)) {
+        try {
+            existing = JSON.parse(await fs.readFile(settingsPath, 'utf8'));
+        } catch {
+            // malformed JSON — start fresh
+        }
+    }
+
+    const { result, added, skipped } = mergeSettingsHooks(existing);
+    await fs.writeFile(settingsPath, JSON.stringify(result, null, 2) + '\n');
+    return { added, skipped };
+}
+
+export function getProjectRoot(pkgRoot: string): string {
+    const result = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+        encoding: 'utf8',
+        timeout: 5000,
+    });
+    if (result.status !== 0) {
+        throw new Error('Not inside a git repository. Run this command from your target project directory.');
+    }
+    const root = path.resolve(result.stdout.trim());
+    if (root === path.resolve(pkgRoot)) {
+        throw new Error('Run this from inside your TARGET project, not the jaggers-agent-tools repo itself.');
+    }
+    return root;
+}
+
+export function createInstallServiceSkillsCommand(): Command {
+    return new Command('install-project-skill')
+        .description('Install the Service Skill Trinity into the current project')
+        .action(async () => {
+            let projectRoot: string;
+            try {
+                projectRoot = getProjectRoot(PKG_ROOT);
+            } catch (err) {
+                console.error(kleur.red(`\n✗ ${(err as Error).message}\n`));
+                process.exit(1);
+            }
+
+            console.log(kleur.dim(`\n  Installing into: ${projectRoot}\n`));
+
+            console.log(kleur.bold('── Skills ──────────────────────────────'));
+            const skillResults = await installSkills(projectRoot);
+            for (const { skill, status } of skillResults) {
+                const icon = status === 'installed' ? kleur.green('  ✓') : kleur.yellow('  ↺');
+                console.log(`${icon} .claude/skills/${skill}/`);
+            }
+
+            console.log(kleur.bold('\n── settings.json ───────────────────────'));
+            const { added, skipped } = await installSettings(projectRoot);
+            for (const event of added) {
+                console.log(`${kleur.green('  ✓')} added hook: ${event}`);
+            }
+            for (const event of skipped) {
+                console.log(`${kleur.yellow('  ○')} already present: ${event} (not overwritten)`);
+            }
+
+            console.log(kleur.bold('\n── Git hooks ───────────────────────────'));
+            const { hookFiles } = await installGitHooks(projectRoot);
+            for (const { name, status } of hookFiles) {
+                if (status === 'added') {
+                    console.log(`${kleur.green('  ✓')} .githooks/${name}`);
+                } else {
+                    console.log(`${kleur.yellow('  ○')} already installed: ${name}`);
+                }
+            }
+            if (hookFiles.some(h => h.status === 'added')) {
+                console.log(`${kleur.green('  ✓')} activated in .git/hooks/`);
+            }
+            console.log(`${kleur.green('  ✓')} scripts → .claude/git-hooks/`);
+
+            console.log(kleur.green('\n  Done.'));
+            console.log(kleur.dim('  Hooks active: SessionStart · PreToolUse · PostToolUse · pre-commit · pre-push\n'));
+        });
+}