vigthoria-cli 1.9.9 → 1.9.19

package/dist/commands/device.d.ts

@@ -0,0 +1,35 @@
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+type DeviceOptions = {
+    device?: string;
+    json?: boolean;
+    output?: string;
+    lines?: string;
+    follow?: boolean;
+    port?: string;
+};
+export declare class DeviceCommand {
+    private logger;
+    constructor(_config: Config, logger: Logger);
+    status(options?: DeviceOptions): Promise<void>;
+    list(options?: DeviceOptions): Promise<void>;
+    screenshot(options?: DeviceOptions): Promise<void>;
+    install(apkPath: string, options?: DeviceOptions): Promise<void>;
+    launch(packageName: string, options?: DeviceOptions & {
+        activity?: string;
+    }): Promise<void>;
+    logs(options?: DeviceOptions): Promise<void>;
+    tcpip(options?: DeviceOptions): Promise<void>;
+    connect(address: string, options?: DeviceOptions): Promise<void>;
+    disconnect(address?: string, options?: DeviceOptions): Promise<void>;
+    private getDevices;
+    private parseDeviceLine;
+    private resolveDeviceId;
+    private withDevice;
+    private runAdb;
+    private printResult;
+    private requireAdbPath;
+    private findAdbPath;
+    private timestamp;
+}
+export {};

package/dist/commands/device.js

@@ -0,0 +1,239 @@
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { execFile, spawn } from 'child_process';
+import { promisify } from 'util';
+import { CH } from '../utils/logger.js';
+const execFileAsync = promisify(execFile);
+export class DeviceCommand {
+    logger;
+    constructor(_config, logger) {
+        this.logger = logger;
+    }
+    async status(options = {}) {
+        const adbPath = this.findAdbPath();
+        const devices = adbPath ? await this.getDevices(adbPath) : [];
+        const payload = {
+            adbAvailable: Boolean(adbPath),
+            adbPath,
+            deviceCount: devices.filter((device) => device.state === 'device').length,
+            devices,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(payload, null, 2));
+            return;
+        }
+        console.log();
+        console.log(chalk.bold.white(`  ${CH.hLine.repeat(3)} Vigthoria Android Developer Bridge ${CH.hLine.repeat(20)}`));
+        console.log(chalk.gray('  ADB: ') + (adbPath ? chalk.green(adbPath) : chalk.yellow('not found')));
+        if (!adbPath) {
+            console.log(chalk.gray('  Install Android SDK Platform Tools, then make adb available on PATH.'));
+            console.log();
+            return;
+        }
+        if (devices.length === 0) {
+            console.log(chalk.yellow('  No Android devices visible.'));
+            console.log(chalk.gray('  Enable Developer Options + USB debugging, then run `vigthoria device list`.'));
+            console.log();
+            return;
+        }
+        for (const device of devices) {
+            const label = device.model || device.product || 'Android device';
+            const state = device.state === 'device' ? chalk.green(device.state) : chalk.yellow(device.state);
+            console.log(`  ${chalk.white(device.id)}  ${state}  ${chalk.gray(label)}`);
+        }
+        console.log();
+    }
+    async list(options = {}) {
+        const adbPath = this.requireAdbPath();
+        const devices = await this.getDevices(adbPath);
+        if (options.json) {
+            console.log(JSON.stringify({ devices }, null, 2));
+            return;
+        }
+        if (devices.length === 0) {
+            console.log(chalk.yellow('No Android devices found.'));
+            return;
+        }
+        for (const device of devices) {
+            console.log(`${chalk.white(device.id)}\t${device.state}\t${device.model || device.product || ''}`.trim());
+        }
+    }
+    async screenshot(options = {}) {
+        const adbPath = this.requireAdbPath();
+        const deviceId = await this.resolveDeviceId(adbPath, options.device);
+        const output = path.resolve(options.output || `vigthoria-android-screenshot-${this.timestamp()}.png`);
+        const args = this.withDevice(deviceId, ['exec-out', 'screencap', '-p']);
+        const result = await execFileAsync(adbPath, args, { encoding: 'buffer', maxBuffer: 20 * 1024 * 1024 });
+        fs.writeFileSync(output, result.stdout);
+        console.log(chalk.green(`Saved screenshot: ${output}`));
+    }
+    async install(apkPath, options = {}) {
+        if (!apkPath)
+            throw new Error('APK path is required.');
+        const resolvedApk = path.resolve(apkPath);
+        if (!fs.existsSync(resolvedApk))
+            throw new Error(`APK not found: ${resolvedApk}`);
+        const adbPath = this.requireAdbPath();
+        const deviceId = await this.resolveDeviceId(adbPath, options.device);
+        const result = await this.runAdb(adbPath, this.withDevice(deviceId, ['install', '-r', resolvedApk]), 120000);
+        this.printResult(result, options.json);
+    }
+    async launch(packageName, options = {}) {
+        if (!packageName)
+            throw new Error('Android package name is required.');
+        const adbPath = this.requireAdbPath();
+        const deviceId = await this.resolveDeviceId(adbPath, options.device);
+        const args = options.activity
+            ? ['shell', 'am', 'start', '-n', `${packageName}/${options.activity}`]
+            : ['shell', 'monkey', '-p', packageName, '-c', 'android.intent.category.LAUNCHER', '1'];
+        const result = await this.runAdb(adbPath, this.withDevice(deviceId, args));
+        this.printResult(result, options.json);
+    }
+    async logs(options = {}) {
+        const adbPath = this.requireAdbPath();
+        const deviceId = await this.resolveDeviceId(adbPath, options.device);
+        const lines = String(options.lines || '250');
+        const args = this.withDevice(deviceId, options.follow ? ['logcat'] : ['logcat', '-d', '-t', lines]);
+        if (options.follow) {
+            await new Promise((resolve, reject) => {
+                const child = spawn(adbPath, args, { stdio: 'inherit' });
+                child.on('error', reject);
+                child.on('exit', (code) => {
+                    if (code && code !== 0)
+                        reject(new Error(`adb logcat exited with code ${code}`));
+                    else
+                        resolve();
+                });
+            });
+            return;
+        }
+        const result = await this.runAdb(adbPath, args, 30000, 8 * 1024 * 1024);
+        this.printResult(result, options.json);
+    }
+    async tcpip(options = {}) {
+        const adbPath = this.requireAdbPath();
+        const deviceId = await this.resolveDeviceId(adbPath, options.device);
+        const port = String(options.port || '5555');
+        const result = await this.runAdb(adbPath, this.withDevice(deviceId, ['tcpip', port]));
+        this.printResult(result, options.json);
+    }
+    async connect(address, options = {}) {
+        if (!address)
+            throw new Error('Device address is required, for example 192.168.1.30:5555.');
+        const adbPath = this.requireAdbPath();
+        const result = await this.runAdb(adbPath, ['connect', address]);
+        this.printResult(result, options.json);
+    }
+    async disconnect(address, options = {}) {
+        const adbPath = this.requireAdbPath();
+        const result = await this.runAdb(adbPath, address ? ['disconnect', address] : ['disconnect']);
+        this.printResult(result, options.json);
+    }
+    async getDevices(adbPath) {
+        const result = await this.runAdb(adbPath, ['devices', '-l']);
+        if (!result.success)
+            return [];
+        return result.stdout
+            .split(/\r?\n/)
+            .slice(1)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => this.parseDeviceLine(line));
+    }
+    parseDeviceLine(line) {
+        const parts = line.split(/\s+/);
+        const id = parts[0] || '';
+        const state = parts[1] || 'unknown';
+        const metadata = new Map();
+        for (const token of parts.slice(2)) {
+            const separator = token.indexOf(':');
+            if (separator > 0)
+                metadata.set(token.slice(0, separator), token.slice(separator + 1));
+        }
+        return {
+            id,
+            state,
+            model: metadata.get('model'),
+            product: metadata.get('product'),
+            transport: metadata.get('transport_id'),
+            raw: line,
+        };
+    }
+    async resolveDeviceId(adbPath, requested) {
+        if (requested && requested.trim())
+            return requested.trim();
+        const devices = (await this.getDevices(adbPath)).filter((device) => device.state === 'device');
+        if (devices.length === 0)
+            throw new Error('No authorized Android device found. Run `vigthoria device status`.');
+        if (devices.length > 1)
+            throw new Error('Multiple Android devices found. Pass --device <id>.');
+        return devices[0].id;
+    }
+    withDevice(deviceId, args) {
+        return deviceId ? ['-s', deviceId, ...args] : args;
+    }
+    async runAdb(adbPath, args, timeout = 30000, maxBuffer = 1024 * 1024) {
+        try {
+            const result = await execFileAsync(adbPath, args, { timeout, maxBuffer });
+            return { success: true, stdout: String(result.stdout || '').trim(), stderr: String(result.stderr || '').trim() };
+        }
+        catch (error) {
+            const failure = error;
+            return {
+                success: false,
+                stdout: String(failure.stdout || '').trim(),
+                stderr: String(failure.stderr || failure.message || '').trim(),
+            };
+        }
+    }
+    printResult(result, json = false) {
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        if (result.stdout)
+            console.log(result.stdout);
+        if (result.stderr)
+            console.error(result.success ? chalk.gray(result.stderr) : chalk.red(result.stderr));
+        if (!result.success)
+            process.exitCode = 1;
+    }
+    requireAdbPath() {
+        const adbPath = this.findAdbPath();
+        if (!adbPath) {
+            throw new Error('ADB not found. Install Android SDK Platform Tools and make adb available on PATH.');
+        }
+        return adbPath;
+    }
+    findAdbPath() {
+        const executable = process.platform === 'win32' ? 'adb.exe' : 'adb';
+        const candidates = [
+            process.env.VIGTHORIA_ADB_PATH,
+            process.env.ADB_PATH,
+            process.env.ANDROID_HOME ? path.join(process.env.ANDROID_HOME, 'platform-tools', executable) : undefined,
+            process.env.ANDROID_SDK_ROOT ? path.join(process.env.ANDROID_SDK_ROOT, 'platform-tools', executable) : undefined,
+            path.join(os.homedir(), 'Android', 'Sdk', 'platform-tools', executable),
+            process.platform === 'win32' ? path.join(process.env.LOCALAPPDATA || '', 'Android', 'Sdk', 'platform-tools', executable) : undefined,
+            process.platform === 'darwin' ? path.join(os.homedir(), 'Library', 'Android', 'sdk', 'platform-tools', executable) : undefined,
+            '/usr/bin/adb',
+            '/usr/local/bin/adb',
+            '/opt/android-sdk/platform-tools/adb',
+        ].filter((candidate) => Boolean(candidate));
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+        const pathDirs = String(process.env.PATH || '').split(path.delimiter).filter(Boolean);
+        for (const pathDir of pathDirs) {
+            const candidate = path.join(pathDir, executable);
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+        return null;
+    }
+    timestamp() {
+        return new Date().toISOString().replace(/[:.]/g, '-');
+    }
+}

package/dist/commands/edit.js

@@ -1,18 +1,12 @@
-"use strict";
 /**
  * Edit Command - File editing with AI assistance
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EditCommand = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const inquirer_1 = __importDefault(require("inquirer"));
-const logger_js_1 = require("../utils/logger.js");
-const api_js_1 = require("../utils/api.js");
-const files_js_1 = require("../utils/files.js");
-class EditCommand {
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { createSpinner } from '../utils/logger.js';
+import { APIClient, CLIError, classifyError, formatCLIError } from '../utils/api.js';
+import { FileUtils } from '../utils/files.js';
+export class EditCommand {
     config;
     logger;
     api;
@@ -20,8 +14,8 @@ class EditCommand {
     constructor(config, logger) {
         this.config = config;
         this.logger = logger;
-        this.api = new api_js_1.APIClient(config, logger);
-        this.fileUtils = new files_js_1.FileUtils(process.cwd(), config.get('project').ignorePatterns);
+        this.api = new APIClient(config, logger);
+        this.fileUtils = new FileUtils(process.cwd(), config.get('project').ignorePatterns);
     }
     async run(filePath, options) {
         // Check auth
@@ -42,7 +36,7 @@ class EditCommand {
             return;
         }
         this.logger.section(`Editing: ${file.relativePath}`);
-        console.log(chalk_1.default.gray(`Language: ${file.language} | Lines: ${file.lines}`));
+        console.log(chalk.gray(`Language: ${file.language} | Lines: ${file.lines}`));
         console.log();
         // Get instruction
         let instruction = options.instruction;
@@ -57,7 +51,7 @@ class EditCommand {
                 this.logger.error('No --instruction provided and stdin is not interactive. Use: vigthoria edit file.ts --instruction "..."');
                 return;
             }
-            const answer = await inquirer_1.default.prompt([
+            const answer = await inquirer.prompt([
                 {
                     type: 'input',
                     name: 'instruction',
@@ -68,7 +62,7 @@ class EditCommand {
             instruction = answer.instruction;
         }
         // Generate edit
-        const spinner = (0, logger_js_1.createSpinner)({
+        const spinner = createSpinner({
             text: 'Generating changes...',
             spinner: 'dots',
         }).start();
@@ -122,8 +116,8 @@ Return the complete modified file content:`,
         }
         catch (error) {
             spinner.stop();
-            const cliErr = error instanceof api_js_1.CLIError ? error : (0, api_js_1.classifyError)(error);
-            this.logger.error((0, api_js_1.formatCLIError)(cliErr));
+            const cliErr = error instanceof CLIError ? error : classifyError(error);
+            this.logger.error(formatCLIError(cliErr));
         }
     }
     async fix(filePath, options) {
@@ -145,9 +139,9 @@ Return the complete modified file content:`,
             return;
         }
         this.logger.section(`Fixing: ${file.relativePath}`);
-        console.log(chalk_1.default.gray(`Fix type: ${options.type} | Language: ${file.language}`));
+        console.log(chalk.gray(`Fix type: ${options.type} | Language: ${file.language}`));
         console.log();
-        const spinner = (0, logger_js_1.createSpinner)({
+        const spinner = createSpinner({
             text: `Analyzing for ${options.type} issues...`,
             spinner: 'dots',
         }).start();
@@ -162,7 +156,7 @@ Return the complete modified file content:`,
                 // diff and let the user decide instead of silently discarding.
                 if (result.fixed && result.fixed !== file.content) {
                     this.logger.section('Found 1 issue(s)');
-                    console.log(chalk_1.default.yellow('1. Operator/character-level fix detected'));
+                    console.log(chalk.yellow('1. Operator/character-level fix detected'));
                     console.log();
                     if (options.apply) {
                         await this.applyFix(file.path, file.content, result.fixed);
@@ -178,10 +172,10 @@ Return the complete modified file content:`,
             // Show fixes
             this.logger.section(`Found ${result.changes.length} issue(s)`);
             result.changes.forEach((change, i) => {
-                console.log(chalk_1.default.yellow(`${i + 1}. Line ${change.line}:`));
-                console.log(chalk_1.default.red(`   - ${change.before}`));
-                console.log(chalk_1.default.green(`   + ${change.after}`));
-                console.log(chalk_1.default.gray(`   Reason: ${change.reason}`));
+                console.log(chalk.yellow(`${i + 1}. Line ${change.line}:`));
+                console.log(chalk.red(`   - ${change.before}`));
+                console.log(chalk.green(`   + ${change.after}`));
+                console.log(chalk.gray(`   Reason: ${change.reason}`));
                 console.log();
             });
             // Apply or confirm
@@ -194,8 +188,8 @@ Return the complete modified file content:`,
         }
         catch (error) {
             spinner.stop();
-            const cliErr = error instanceof api_js_1.CLIError ? error : (0, api_js_1.classifyError)(error);
-            this.logger.error((0, api_js_1.formatCLIError)(cliErr));
+            const cliErr = error instanceof CLIError ? error : classifyError(error);
+            this.logger.error(formatCLIError(cliErr));
         }
     }
     extractCode(response, language) {
@@ -358,10 +352,10 @@ Return the complete modified file content:`,
         // Show diff
         this.logger.section('Changes');
         diff.removed.forEach(line => {
-            console.log(chalk_1.default.red(line));
+            console.log(chalk.red(line));
         });
         diff.added.forEach(line => {
-            console.log(chalk_1.default.green(line));
+            console.log(chalk.green(line));
         });
         console.log();
         // Confirm
@@ -376,7 +370,7 @@ Return the complete modified file content:`,
             this.logger.info('Non-interactive mode. Re-run with --apply to apply changes.');
             return;
         }
-        const { action } = await inquirer_1.default.prompt([
+        const { action } = await inquirer.prompt([
             {
                 type: 'list',
                 name: 'action',
@@ -394,7 +388,7 @@ Return the complete modified file content:`,
                 break;
             case 'view':
                 this.showFullDiff(original, modified);
-                const { confirm } = await inquirer_1.default.prompt([
+                const { confirm } = await inquirer.prompt([
                     {
                         type: 'confirm',
                         name: 'confirm',
@@ -415,7 +409,7 @@ Return the complete modified file content:`,
         const originalLines = original.split('\n');
         const modifiedLines = modified.split('\n');
         console.log();
-        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk.gray('─'.repeat(60)));
         // Use LCS-based diff to avoid line-shift inflation
         const m = originalLines.length;
         const n = modifiedLines.length;
@@ -454,26 +448,26 @@ Return the complete modified file content:`,
             if (op.type === 'keep') {
                 displayLine++;
                 const lineNum = String(displayLine).padStart(4, ' ');
-                console.log(chalk_1.default.gray(`${lineNum} │ ${op.text || ''}`));
+                console.log(chalk.gray(`${lineNum} │ ${op.text || ''}`));
             }
             else if (op.type === 'remove') {
                 displayLine++;
                 const lineNum = String(displayLine).padStart(4, ' ');
-                console.log(chalk_1.default.red(`${lineNum} - ${op.text}`));
+                console.log(chalk.red(`${lineNum} - ${op.text}`));
             }
             else {
                 const lineNum = '   +';
-                console.log(chalk_1.default.green(`${lineNum} + ${op.text}`));
+                console.log(chalk.green(`${lineNum} + ${op.text}`));
             }
         }
-        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk.gray('─'.repeat(60)));
         console.log();
     }
     async applyFix(filePath, original, modified) {
         // Create backup
         const backup = this.fileUtils.backupFile(filePath);
         if (backup) {
-            this.logger.info(`Backup: ${chalk_1.default.gray(backup)}`);
+            this.logger.info(`Backup: ${chalk.gray(backup)}`);
         }
         // Apply changes
         if (this.fileUtils.writeFile(filePath, modified)) {
@@ -484,4 +478,3 @@ Return the complete modified file content:`,
         }
     }
 }
-exports.EditCommand = EditCommand;

package/dist/commands/explain.js

@@ -1,19 +1,13 @@
-"use strict";
 /**
  * Explain Command - Explain code in files
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExplainCommand = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const marked_1 = require("marked");
-const marked_terminal_1 = require("marked-terminal");
-const logger_js_1 = require("../utils/logger.js");
-const api_js_1 = require("../utils/api.js");
-const files_js_1 = require("../utils/files.js");
-class ExplainCommand {
+import chalk from 'chalk';
+import { Marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import { createSpinner } from '../utils/logger.js';
+import { APIClient, CLIError, classifyError, formatCLIError } from '../utils/api.js';
+import { FileUtils } from '../utils/files.js';
+export class ExplainCommand {
     config;
     logger;
     api;
@@ -22,10 +16,10 @@ class ExplainCommand {
     constructor(config, logger) {
         this.config = config;
         this.logger = logger;
-        this.api = new api_js_1.APIClient(config, logger);
-        this.fileUtils = new files_js_1.FileUtils(process.cwd(), config.get('project').ignorePatterns);
-        this.marked = new marked_1.Marked();
-        this.marked.use((0, marked_terminal_1.markedTerminal)({
+        this.api = new APIClient(config, logger);
+        this.fileUtils = new FileUtils(process.cwd(), config.get('project').ignorePatterns);
+        this.marked = new Marked();
+        this.marked.use(markedTerminal({
             showSectionPrefix: false,
             tab: 2,
             width: 80,
@@ -62,17 +56,17 @@ class ExplainCommand {
             }
         }
         this.logger.section(`Explaining: ${file.relativePath}${lineInfo}`);
-        console.log(chalk_1.default.gray(`Language: ${file.language} | Detail: ${options.detail}`));
+        console.log(chalk.gray(`Language: ${file.language} | Detail: ${options.detail}`));
         console.log();
         // Show the code being explained
-        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk.gray('─'.repeat(60)));
         codeToExplain.split('\n').forEach((line, i) => {
-            const lineNum = chalk_1.default.gray(String(i + 1).padStart(4, ' ') + ' │ ');
+            const lineNum = chalk.gray(String(i + 1).padStart(4, ' ') + ' │ ');
             console.log(lineNum + line);
         });
-        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk.gray('─'.repeat(60)));
         console.log();
-        const spinner = (0, logger_js_1.createSpinner)({
+        const spinner = createSpinner({
             text: 'Analyzing code...',
             spinner: 'dots',
         }).start();
@@ -86,8 +80,8 @@ class ExplainCommand {
         }
         catch (error) {
             spinner.stop();
-            const cliErr = error instanceof api_js_1.CLIError ? error : (0, api_js_1.classifyError)(error);
-            this.logger.error((0, api_js_1.formatCLIError)(cliErr));
+            const cliErr = error instanceof CLIError ? error : classifyError(error);
+            this.logger.error(formatCLIError(cliErr));
         }
     }
     /**
@@ -132,4 +126,3 @@ class ExplainCommand {
         }
     }
 }
-exports.ExplainCommand = ExplainCommand;

package/dist/commands/fork.js

@@ -1,16 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ForkCommand = void 0;
-const api_js_1 = require("../utils/api.js");
+import { isServerRuntime } from '../utils/api.js';
 /**
  * fork.ts — Fork from an existing V3 agent run and stream the result.
  */
-const chalk_1 = __importDefault(require("chalk"));
-const logger_js_1 = require("../utils/logger.js");
-class ForkCommand {
+import chalk from 'chalk';
+import { createRequire } from 'node:module';
+import { createSpinner, CH } from '../utils/logger.js';
+const require = createRequire(import.meta.url);
+export class ForkCommand {
     config;
     logger;
     constructor(config, logger) {
@@ -33,7 +29,7 @@ class ForkCommand {
     }
     getBaseUrl() {
         const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
-        const allowLocal = (0, api_js_1.isServerRuntime)() && process.env.VIGTHORIA_ALLOW_LOCAL_V3_AGENT === '1';
+        const allowLocal = isServerRuntime() && process.env.VIGTHORIA_ALLOW_LOCAL_V3_AGENT === '1';
         return (process.env.VIGTHORIA_V3_AGENT_URL ||
             process.env.V3_AGENT_URL ||
             (allowLocal ? 'http://127.0.0.1:8030' : null) ||
@@ -56,7 +52,7 @@ class ForkCommand {
         const project = options.project || process.cwd();
         const workspace = this.resolveWorkspaceRoot(project);
         const eventIndex = options.eventIndex || 0;
-        const spinner = (0, logger_js_1.createSpinner)(`Forking run ${runId}...`).start();
+        const spinner = createSpinner(`Forking run ${runId}...`).start();
         try {
             const baseUrl = this.getBaseUrl();
             const body = {
@@ -85,7 +81,7 @@ class ForkCommand {
                 return;
             }
             spinner.stop();
-            console.log(chalk_1.default.bold(`\n${logger_js_1.CH.success} Forked from ${chalk_1.default.cyan(runId)} at event ${eventIndex}\n`));
+            console.log(chalk.bold(`\n${CH.success} Forked from ${chalk.cyan(runId)} at event ${eventIndex}\n`));
             if (!resp.body) {
                 this.logger.error('No response body');
                 return;
@@ -107,7 +103,7 @@ class ForkCommand {
                         continue;
                     const payload = line.slice(6).trim();
                     if (payload === '[DONE]') {
-                        console.log(chalk_1.default.bold(`\n${logger_js_1.CH.success} Fork run complete\n`));
+                        console.log(chalk.bold(`\n${CH.success} Fork run complete\n`));
                         return;
                     }
                     try {
@@ -119,39 +115,39 @@ class ForkCommand {
                         }
                         switch (type) {
                             case 'context':
-                                console.log(chalk_1.default.blue(`  context: ${evt.context_id || '?'}`) +
-                                    (evt.forked_from ? chalk_1.default.dim(` (forked from ${evt.forked_from})`) : ''));
+                                console.log(chalk.blue(`  context: ${evt.context_id || '?'}`) +
+                                    (evt.forked_from ? chalk.dim(` (forked from ${evt.forked_from})`) : ''));
                                 break;
                             case 'start':
-                                console.log(chalk_1.default.green(`  ▶ START`) + ` task=${evt.task_id || '?'}` +
-                                    (evt.forked_from ? chalk_1.default.dim(` forked_from=${evt.forked_from}`) : ''));
+                                console.log(chalk.green(`  ▶ START`) + ` task=${evt.task_id || '?'}` +
+                                    (evt.forked_from ? chalk.dim(` forked_from=${evt.forked_from}`) : ''));
                                 break;
                             case 'plan':
-                                console.log(chalk_1.default.magenta(`  📋 PLAN`) + ` ${evt.tasks?.length || 0} tasks`);
+                                console.log(chalk.magenta(`  📋 PLAN`) + ` ${evt.tasks?.length || 0} tasks`);
                                 break;
                             case 'tool_call':
                                 toolCallNum++;
-                                console.log(chalk_1.default.yellow(`  🔧 #${toolCallNum}`) + ` ${evt.name || '?'}(${JSON.stringify(evt.arguments || {}).substring(0, 60)})`);
+                                console.log(chalk.yellow(`  🔧 #${toolCallNum}`) + ` ${evt.name || '?'}(${JSON.stringify(evt.arguments || {}).substring(0, 60)})`);
                                 break;
                             case 'tool_result': {
-                                const icon = evt.success !== false ? chalk_1.default.green('✓') : chalk_1.default.red('✗');
-                                console.log(`    ${icon} ${evt.name || '?'}: ${chalk_1.default.dim((evt.output || '').substring(0, 100))}`);
+                                const icon = evt.success !== false ? chalk.green('✓') : chalk.red('✗');
+                                console.log(`    ${icon} ${evt.name || '?'}: ${chalk.dim((evt.output || '').substring(0, 100))}`);
                                 break;
                             }
                             case 'message':
-                                console.log(chalk_1.default.cyan(`  💬 `) + (evt.content || '').substring(0, 150));
+                                console.log(chalk.cyan(`  💬 `) + (evt.content || '').substring(0, 150));
                                 break;
                             case 'complete': {
                                 const seal = evt.seal_score ? `[${evt.seal_score.tier} ${evt.seal_score.overall}]` : '';
-                                console.log(chalk_1.default.green(`  ✅ COMPLETE `) + chalk_1.default.yellow(seal) +
+                                console.log(chalk.green(`  ✅ COMPLETE `) + chalk.yellow(seal) +
                                     ` ${evt.iterations || '?'} iterations, ${evt.tool_calls || '?'} tool calls`);
                                 break;
                             }
                             case 'error':
-                                console.log(chalk_1.default.red(`  ❌ ERROR: `) + (evt.message || '').substring(0, 200));
+                                console.log(chalk.red(`  ❌ ERROR: `) + (evt.message || '').substring(0, 200));
                                 break;
                             default:
-                                console.log(chalk_1.default.dim(`  ${type}: ${JSON.stringify(evt).substring(0, 80)}`));
+                                console.log(chalk.dim(`  ${type}: ${JSON.stringify(evt).substring(0, 80)}`));
                         }
                     }
                     catch {
@@ -166,4 +162,3 @@ class ForkCommand {
         }
     }
 }
-exports.ForkCommand = ForkCommand;