gemkit-cli 0.2.2 → 0.3.0

package/dist/services/aipty.d.ts

@@ -0,0 +1,76 @@
+/**
+ * AIPTY - Cross-platform PTY wrapper for Claude Code and Gemini CLI
+ * Ported from claude-pty-wrapper/index.js
+ */
+import { EventEmitter } from 'events';
+import type { CliProvider } from '../domains/agent/types.js';
+export interface AIPTYOptions {
+    provider: CliProvider;
+    model?: string;
+    tools?: string[];
+    cwd?: string;
+    debug?: boolean;
+}
+export declare class AIPTY extends EventEmitter {
+    private process;
+    private output;
+    private outputBuffer;
+    private isReady;
+    private provider;
+    private config;
+    private model;
+    private tools;
+    private cwd;
+    private debug;
+    constructor(options: AIPTYOptions);
+    /**
+     * Start AI CLI session
+     */
+    start(): Promise<void>;
+    /**
+     * Send text (raw write)
+     */
+    write(text: string): void;
+    /**
+     * Send a prompt and wait for response
+     */
+    send(prompt: string, options?: {
+        timeout?: number;
+    }): Promise<string>;
+    /**
+     * Extract the last answer from output
+     */
+    extractLastAnswer(): string;
+    /**
+     * Extract answer from Claude output
+     */
+    private extractAnswerClaude;
+    /**
+     * Extract answer from Gemini output
+     */
+    private extractAnswerGemini;
+    /**
+     * Get raw output
+     */
+    getOutput(lines?: number): string;
+    /**
+     * Get full output
+     */
+    getFullOutput(): string;
+    /**
+     * Check if session is running
+     */
+    isRunning(): boolean;
+    /**
+     * Check if session is ready
+     */
+    getIsReady(): boolean;
+    /**
+     * Get provider
+     */
+    getProvider(): CliProvider;
+    /**
+     * Stop the session
+     */
+    stop(): Promise<void>;
+}

package/dist/services/aipty.js

@@ -0,0 +1,276 @@
+/**
+ * AIPTY - Cross-platform PTY wrapper for Claude Code and Gemini CLI
+ * Ported from claude-pty-wrapper/index.js
+ */
+import * as pty from 'node-pty';
+import { EventEmitter } from 'events';
+import { PTY_PROVIDERS, buildPtyArgs } from '../domains/agent/pty-providers.js';
+export class AIPTY extends EventEmitter {
+    process = null;
+    output = '';
+    outputBuffer = [];
+    isReady = false;
+    provider;
+    config;
+    model;
+    tools;
+    cwd;
+    debug;
+    constructor(options) {
+        super();
+        this.provider = options.provider;
+        this.config = PTY_PROVIDERS[options.provider];
+        if (!this.config) {
+            throw new Error(`Unknown provider: ${options.provider}. Use 'claude' or 'gemini'`);
+        }
+        this.model = options.model || '';
+        this.tools = options.tools || [];
+        this.cwd = options.cwd || process.cwd();
+        this.debug = options.debug || false;
+    }
+    /**
+     * Start AI CLI session
+     */
+    start() {
+        return new Promise((resolve, reject) => {
+            if (this.process) {
+                reject(new Error('Session already running'));
+                return;
+            }
+            const command = this.config.command;
+            const args = buildPtyArgs(this.provider, this.model, this.tools);
+            if (this.debug) {
+                console.log(`[DEBUG] Spawning: ${command} ${args.join(' ')}`);
+            }
+            try {
+                this.process = pty.spawn(command, args, {
+                    name: 'xterm-256color',
+                    cols: 120,
+                    rows: 40,
+                    cwd: this.cwd,
+                    env: { ...process.env, TERM: 'xterm-256color' }
+                });
+            }
+            catch (err) {
+                reject(new Error(`Failed to spawn ${command}: ${err.message}`));
+                return;
+            }
+            this.output = '';
+            this.outputBuffer = [];
+            this.process.onData((data) => {
+                this.output += data;
+                this.outputBuffer.push({ time: Date.now(), data });
+                if (this.debug) {
+                    process.stdout.write(data);
+                }
+                this.emit('data', data);
+                // Check if ready (prompt appeared)
+                if (!this.isReady && this.output.includes(this.config.readyIndicator)) {
+                    this.isReady = true;
+                    this.emit('ready');
+                }
+            });
+            this.process.onExit(({ exitCode }) => {
+                this.isReady = false;
+                this.process = null;
+                this.emit('exit', exitCode);
+            });
+            // Wait for ready or timeout
+            const timeout = setTimeout(() => {
+                if (!this.isReady) {
+                    // Check if trust prompt appeared (Claude specific)
+                    if (this.output.includes('Yes, I trust')) {
+                        this.write('1'); // Auto-trust
+                        setTimeout(() => {
+                            if (this.isReady)
+                                resolve();
+                            else
+                                reject(new Error(`Timeout waiting for ${this.config.name} to be ready`));
+                        }, 5000);
+                    }
+                    else {
+                        reject(new Error(`Timeout waiting for ${this.config.name} to start`));
+                    }
+                }
+            }, 60000); // 60s timeout for npx downloads
+            this.once('ready', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Send text (raw write)
+     */
+    write(text) {
+        if (!this.process) {
+            throw new Error('No active session');
+        }
+        this.process.write(text);
+    }
+    /**
+     * Send a prompt and wait for response
+     */
+    send(prompt, options = {}) {
+        return new Promise((resolve, reject) => {
+            if (!this.process || !this.isReady) {
+                reject(new Error('No active session or not ready'));
+                return;
+            }
+            const timeout = options.timeout || 120000;
+            const responseStart = this.output.length;
+            this.write(prompt);
+            setTimeout(() => {
+                this.write('\r');
+                if (this.debug) {
+                    console.log('\n[DEBUG] Prompt sent, waiting for response...');
+                }
+            }, 500);
+            const checkInterval = setInterval(() => {
+                const newOutput = this.output.slice(responseStart);
+                // Check completion based on provider
+                let isComplete = false;
+                if (this.provider === 'claude') {
+                    const hasResponse = newOutput.includes('●');
+                    const promptAfterResponse = newOutput.lastIndexOf('❯') > newOutput.lastIndexOf('●');
+                    isComplete = hasResponse && promptAfterResponse;
+                }
+                else if (this.provider === 'gemini') {
+                    // Gemini: look for response block then new prompt
+                    const hasResponse = newOutput.includes('✦') && newOutput.length > 100;
+                    isComplete = hasResponse;
+                }
+                if (isComplete) {
+                    clearInterval(checkInterval);
+                    clearTimeout(timeoutId);
+                    const answer = this.extractLastAnswer();
+                    resolve(answer);
+                }
+            }, 500);
+            const timeoutId = setTimeout(() => {
+                clearInterval(checkInterval);
+                reject(new Error('Timeout waiting for response'));
+            }, timeout);
+        });
+    }
+    /**
+     * Extract the last answer from output
+     */
+    extractLastAnswer() {
+        const cleanOutput = this.output
+            .replace(/\x1b\[1C/g, ' ')
+            .replace(/\x1b\[[0-9;]*[A-Za-z]/g, '')
+            .replace(/\x1b\][^\x07]*\x07/g, '')
+            .replace(/\r/g, '');
+        if (this.provider === 'claude') {
+            return this.extractAnswerClaude(cleanOutput);
+        }
+        else if (this.provider === 'gemini') {
+            return this.extractAnswerGemini(cleanOutput);
+        }
+        return '';
+    }
+    /**
+     * Extract answer from Claude output
+     */
+    extractAnswerClaude(cleanOutput) {
+        const matches = cleanOutput.match(/●\s*([\s\S]*?)(?=❯|$)/g);
+        if (matches && matches.length > 0) {
+            let lastMatch = matches[matches.length - 1];
+            lastMatch = lastMatch
+                .replace(/^●\s*/, '')
+                .replace(/[─╭╰│┌┐└┘├┤┬┴┼]+/g, '')
+                .replace(/\? for shortcuts/g, '')
+                .replace(/esc to interrupt/g, '')
+                .replace(/Churning…/g, '')
+                .replace(/\(thinking\)/g, '')
+                .trim();
+            const lines = lastMatch.split('\n')
+                .map(l => l.trim())
+                .filter(l => {
+                if (l.length === 0)
+                    return false;
+                if (l.match(/^[\s─╭╰│┌┐└┘├┤┬┴┼✢✶✻✽·*]+$/))
+                    return false;
+                if (l.match(/Cascading|Churning|thinking|thought for/i))
+                    return false;
+                if (l.match(/^\d+s\)$/))
+                    return false;
+                return true;
+            });
+            return lines.join('\n').trim();
+        }
+        return '';
+    }
+    /**
+     * Extract answer from Gemini output
+     */
+    extractAnswerGemini(cleanOutput) {
+        const lines = cleanOutput.split('\n');
+        let inResponse = false;
+        const response = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Skip UI elements
+            if (trimmed.match(/^[┃┏┓┗┛━─╭╮╯╰│]+$/) ||
+                trimmed.match(/^Gemini/i) ||
+                trimmed.match(/^Type .* to/i)) {
+                continue;
+            }
+            if (trimmed.length > 0 && !trimmed.match(/^>/)) {
+                response.push(trimmed);
+            }
+        }
+        return response.join('\n').trim();
+    }
+    /**
+     * Get raw output
+     */
+    getOutput(lines = 100) {
+        const allLines = this.output.split('\n');
+        return allLines.slice(-lines).join('\n');
+    }
+    /**
+     * Get full output
+     */
+    getFullOutput() {
+        return this.output;
+    }
+    /**
+     * Check if session is running
+     */
+    isRunning() {
+        return this.process !== null && this.isReady;
+    }
+    /**
+     * Check if session is ready
+     */
+    getIsReady() {
+        return this.isReady;
+    }
+    /**
+     * Get provider
+     */
+    getProvider() {
+        return this.provider;
+    }
+    /**
+     * Stop the session
+     */
+    stop() {
+        return new Promise((resolve) => {
+            if (!this.process) {
+                resolve();
+                return;
+            }
+            this.once('exit', () => resolve());
+            this.write(this.config.exitCommand);
+            setTimeout(() => {
+                if (this.process) {
+                    this.process.kill();
+                }
+                resolve();
+            }, 3000);
+        });
+    }
+}

package/dist/services/archive.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Archive extraction service for .tar.gz files
+ */
+export interface ExtractOptions {
+    source: string;
+    destination: string;
+    strip?: number;
+    filter?: (path: string) => boolean;
+}
+export interface ExtractResult {
+    success: boolean;
+    extractedFiles: string[];
+    error?: string;
+}
+/**
+ * Extract a .tar.gz archive
+ */
+export declare function extractTarGz(options: ExtractOptions): Promise<ExtractResult>;
+/**
+ * Simple file copy for non-archive files
+ */
+export declare function copyFile(source: string, destination: string): Promise<void>;

package/dist/services/archive.js

@@ -0,0 +1,53 @@
+/**
+ * Archive extraction service for .tar.gz files
+ */
+import { createReadStream, createWriteStream, existsSync, mkdirSync } from 'fs';
+import { pipeline } from 'stream/promises';
+import { createGunzip } from 'zlib';
+import { dirname } from 'path';
+import * as tar from 'tar';
+/**
+ * Extract a .tar.gz archive
+ */
+export async function extractTarGz(options) {
+    const { source, destination, strip = 1, filter } = options;
+    const extractedFiles = [];
+    if (!existsSync(source)) {
+        return { success: false, extractedFiles: [], error: `Source file not found: ${source}` };
+    }
+    // Ensure destination exists
+    if (!existsSync(destination)) {
+        mkdirSync(destination, { recursive: true });
+    }
+    try {
+        await pipeline(createReadStream(source), createGunzip(), tar.x({
+            cwd: destination,
+            strip,
+            filter: (path) => {
+                if (filter && !filter(path)) {
+                    return false;
+                }
+                extractedFiles.push(path);
+                return true;
+            },
+        }));
+        return { success: true, extractedFiles };
+    }
+    catch (error) {
+        return {
+            success: false,
+            extractedFiles,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Simple file copy for non-archive files
+ */
+export async function copyFile(source, destination) {
+    const destDir = dirname(destination);
+    if (!existsSync(destDir)) {
+        mkdirSync(destDir, { recursive: true });
+    }
+    await pipeline(createReadStream(source), createWriteStream(destination));
+}

package/dist/services/auto-update.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Auto-update checker service
+ *
+ * Checks for updates on CLI startup based on config settings.
+ * Uses a timestamp file to track last check time.
+ */
+/**
+ * Run auto-update check on startup
+ * This runs in the background and only shows notifications
+ */
+export declare function runAutoUpdateCheck(): Promise<void>;
+/**
+ * Force check for updates (ignores interval)
+ */
+export declare function forceUpdateCheck(): Promise<{
+    cli: {
+        current: string;
+        latest: string;
+        available: boolean;
+    } | null;
+    kits: {
+        current: string;
+        latest: string;
+        available: boolean;
+    } | null;
+}>;

package/dist/services/auto-update.js

@@ -0,0 +1,117 @@
+/**
+ * Auto-update checker service
+ *
+ * Checks for updates on CLI startup based on config settings.
+ * Uses a timestamp file to track last check time.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { loadConfig } from '../domains/config/manager.js';
+import { checkForUpdates } from '../commands/update/index.js';
+import { brand } from '../utils/colors.js';
+// File to track last update check
+const UPDATE_CHECK_FILE = join(homedir(), '.gemkit', 'last-update-check.json');
+/**
+ * Get last update check state
+ */
+function getLastCheckState() {
+    try {
+        if (!existsSync(UPDATE_CHECK_FILE)) {
+            return null;
+        }
+        return JSON.parse(readFileSync(UPDATE_CHECK_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save update check state
+ */
+function saveCheckState(state) {
+    try {
+        const dir = dirname(UPDATE_CHECK_FILE);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(UPDATE_CHECK_FILE, JSON.stringify(state, null, 2));
+    }
+    catch {
+        // Ignore errors
+    }
+}
+/**
+ * Check if enough time has passed since last check
+ */
+function shouldCheck(intervalHours) {
+    const state = getLastCheckState();
+    if (!state) {
+        return true;
+    }
+    const lastCheck = new Date(state.lastCheck);
+    const now = new Date();
+    const hoursSinceCheck = (now.getTime() - lastCheck.getTime()) / (1000 * 60 * 60);
+    return hoursSinceCheck >= intervalHours;
+}
+/**
+ * Run auto-update check on startup
+ * This runs in the background and only shows notifications
+ */
+export async function runAutoUpdateCheck() {
+    const config = loadConfig();
+    const updateConfig = config.update;
+    // Skip if auto-check is disabled
+    if (!updateConfig?.autoCheck) {
+        return;
+    }
+    // Skip if not enough time has passed
+    if (!shouldCheck(updateConfig.checkInterval)) {
+        return;
+    }
+    try {
+        const updates = await checkForUpdates();
+        const state = getLastCheckState() || { lastCheck: '' };
+        const notifications = [];
+        // Check CLI updates
+        if (updates.cli?.available && state.notifiedCli !== updates.cli.latest) {
+            notifications.push(`${brand.primary('CLI')} update available: v${updates.cli.current} → v${updates.cli.latest}`);
+            state.notifiedCli = updates.cli.latest;
+        }
+        // Check Kits updates
+        if (updates.kits?.available && state.notifiedKits !== updates.kits.latest) {
+            notifications.push(`${brand.primary('Kits')} update available: v${updates.kits.current} → v${updates.kits.latest}`);
+            state.notifiedKits = updates.kits.latest;
+        }
+        // Show notifications
+        if (notifications.length > 0) {
+            console.log();
+            console.log(brand.dim('─'.repeat(50)));
+            console.log(`${brand.warn('⬆')} Updates available:`);
+            notifications.forEach((n) => console.log(`  ${n}`));
+            console.log(`  Run ${brand.primary('gk update')} to update.`);
+            console.log(brand.dim('─'.repeat(50)));
+            console.log();
+        }
+        // Save state
+        state.lastCheck = new Date().toISOString();
+        saveCheckState(state);
+    }
+    catch {
+        // Silently fail - don't interrupt user workflow
+    }
+}
+/**
+ * Force check for updates (ignores interval)
+ */
+export async function forceUpdateCheck() {
+    const updates = await checkForUpdates();
+    // Update state
+    const state = {
+        lastCheck: new Date().toISOString(),
+        notifiedCli: updates.cli?.latest,
+        notifiedKits: updates.kits?.latest,
+    };
+    saveCheckState(state);
+    return updates;
+}

package/dist/services/hash.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Hashing utilities for project identification
+ */
+/**
+ * Generate SHA256 hash of a string
+ */
+export declare function sha256(input: string): string;
+/**
+ * Generate short hash (first 8 characters)
+ */
+export declare function shortHash(input: string): string;
+/**
+ * Generate project hash from directory path
+ */
+export declare function generateProjectHash(projectDir: string): string;
+/**
+ * Generate file hash for change detection
+ */
+export declare function hashFile(filePath: string): string | null;
+/**
+ * Generate hash from multiple inputs
+ */
+export declare function combineHash(...inputs: string[]): string;
+/**
+ * Generate unique ID with timestamp
+ */
+export declare function generateUniqueId(prefix?: string): string;
+/**
+ * Generate gkSessionId - consistent format for ALL clients
+ * Matches gk-session-manager.cjs generateGkSessionId()
+ *
+ * @param appName - Application identifier (e.g., 'gemini-main', 'vscode')
+ * @param pid - Process ID to embed in the session ID
+ * @returns Format: "{appName}-{PID}-{timestamp36}-{random4}"
+ */
+export declare function generateGkSessionId(appName: string, pid: number): string;

package/dist/services/hash.js

@@ -0,0 +1,63 @@
+/**
+ * Hashing utilities for project identification
+ */
+import { createHash } from 'crypto';
+import { existsSync, readFileSync } from 'fs';
+/**
+ * Generate SHA256 hash of a string
+ */
+export function sha256(input) {
+    return createHash('sha256').update(input).digest('hex');
+}
+/**
+ * Generate short hash (first 8 characters)
+ */
+export function shortHash(input) {
+    return sha256(input).substring(0, 8);
+}
+/**
+ * Generate project hash from directory path
+ */
+export function generateProjectHash(projectDir) {
+    // Normalize path for consistent hashing
+    const normalized = projectDir.replace(/\\/g, '/').toLowerCase();
+    return shortHash(normalized);
+}
+/**
+ * Generate file hash for change detection
+ */
+export function hashFile(filePath) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    const content = readFileSync(filePath);
+    return createHash('sha256').update(content).digest('hex');
+}
+/**
+ * Generate hash from multiple inputs
+ */
+export function combineHash(...inputs) {
+    const combined = inputs.join(':');
+    return sha256(combined);
+}
+/**
+ * Generate unique ID with timestamp
+ */
+export function generateUniqueId(prefix = '') {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return prefix ? `${prefix}-${timestamp}-${random}` : `${timestamp}-${random}`;
+}
+/**
+ * Generate gkSessionId - consistent format for ALL clients
+ * Matches gk-session-manager.cjs generateGkSessionId()
+ *
+ * @param appName - Application identifier (e.g., 'gemini-main', 'vscode')
+ * @param pid - Process ID to embed in the session ID
+ * @returns Format: "{appName}-{PID}-{timestamp36}-{random4}"
+ */
+export function generateGkSessionId(appName, pid) {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 6);
+    return `${appName}-${pid}-${timestamp}-${random}`;
+}

package/dist/services/logger.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Logging service for GemKit CLI
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+interface LoggerConfig {
+    level: LogLevel;
+    verbose: boolean;
+    json: boolean;
+}
+export declare function configureLogger(options: Partial<LoggerConfig>): void;
+export declare function debug(message: string, data?: unknown): void;
+export declare function info(message: string, data?: unknown): void;
+export declare function success(message: string, data?: unknown): void;
+export declare function warn(message: string, data?: unknown): void;
+export declare function error(message: string, data?: unknown): void;
+export declare function table(data: Record<string, unknown>[]): void;
+export declare function json(data: unknown): void;
+export declare const logger: {
+    debug: typeof debug;
+    info: typeof info;
+    success: typeof success;
+    warn: typeof warn;
+    error: typeof error;
+    table: typeof table;
+    json: typeof json;
+    configure: typeof configureLogger;
+};
+export {};