@shepai/cli 1.39.0 → 1.40.0

package/dist/packages/core/src/infrastructure/services/agents/common/agent-executor-factory.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-executor-factory.service.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/common/agent-executor-factory.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AACrF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yEAAyE,CAAC;AAC9G,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iFAAiF,CAAC;AAG7H,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;GAKG;AACH,qBAAa,oBAAqB,YAAW,qBAAqB;IAMpD,OAAO,CAAC,QAAQ,CAAC,KAAK;IALlC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAE3D;;OAEG;gBAC0B,KAAK,EAAE,aAAa;IAEjD;;;;;;;OAOG;IACH,cAAc,CAAC,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,GAAG,cAAc;IAuB9E;;;;OAIG;IACH,kBAAkB,IAAI,SAAS,EAAE;CAGlC"}
+{"version":3,"file":"agent-executor-factory.service.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/common/agent-executor-factory.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AACrF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yEAAyE,CAAC;AAC9G,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iFAAiF,CAAC;AAI7H,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;GAKG;AACH,qBAAa,oBAAqB,YAAW,qBAAqB;IAMpD,OAAO,CAAC,QAAQ,CAAC,KAAK;IALlC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAE3D;;OAEG;gBAC0B,KAAK,EAAE,aAAa;IAEjD;;;;;;;OAOG;IACH,cAAc,CAAC,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,GAAG,cAAc;IA0B9E;;;;OAIG;IACH,kBAAkB,IAAI,SAAS,EAAE;CAGlC"}

package/dist/packages/core/src/infrastructure/services/agents/common/agent-executor-factory.service.js

@@ -9,6 +9,7 @@
  */
 import { ClaudeCodeExecutorService } from './executors/claude-code-executor.service.js';
 import { CursorExecutorService } from './executors/cursor-executor.service.js';
+import { GeminiCliExecutorService } from './executors/gemini-cli-executor.service.js';
 /**
  * Factory that creates and caches agent executor instances.
  *
@@ -45,6 +46,9 @@ export class AgentExecutorFactory {
             case 'cursor':
                 executor = new CursorExecutorService(this.spawn);
                 break;
+            case 'gemini-cli':
+                executor = new GeminiCliExecutorService(this.spawn, _authConfig);
+                break;
             default:
                 throw new Error(`Unsupported agent type: ${agentType}. Supported: ${this.getSupportedAgents().join(', ')}`);
         }
@@ -57,6 +61,6 @@ export class AgentExecutorFactory {
      * @returns Array of supported agent types
      */
     getSupportedAgents() {
-        return ['claude-code', 'cursor'];
+        return ['claude-code', 'cursor', 'gemini-cli'];
     }
 }

package/dist/packages/core/src/infrastructure/services/agents/common/agent-validator.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-validator.service.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/common/agent-validator.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAC;AACxE,OAAO,KAAK,EACV,eAAe,EACf,qBAAqB,EACtB,MAAM,0EAA0E,CAAC;AAElF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAU/C;;;;;GAKG;AACH,qBACa,qBAAsB,YAAW,eAAe;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IAEtC;;;OAGG;gBACiC,MAAM,EAAE,YAAY;IAIxD;;;;;OAKG;IACG,WAAW,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,qBAAqB,CAAC;CA2BxE"}
+{"version":3,"file":"agent-validator.service.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/common/agent-validator.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAC;AACxE,OAAO,KAAK,EACV,eAAe,EACf,qBAAqB,EACtB,MAAM,0EAA0E,CAAC;AAElF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAW/C;;;;;GAKG;AACH,qBACa,qBAAsB,YAAW,eAAe;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IAEtC;;;OAGG;gBACiC,MAAM,EAAE,YAAY;IAIxD;;;;;OAKG;IACG,WAAW,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,qBAAqB,CAAC;CA2BxE"}

package/dist/packages/core/src/infrastructure/services/agents/common/agent-validator.service.js

@@ -27,6 +27,7 @@ import { injectable, inject } from 'tsyringe';
 const AGENT_BINARY_MAP = {
     'claude-code': 'claude',
     cursor: 'agent',
+    'gemini-cli': 'gemini',
 };
 /**
  * Service that validates agent tool availability on the system.

package/dist/packages/core/src/infrastructure/services/agents/common/executors/gemini-cli-executor.service.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Gemini CLI Executor Service
+ *
+ * Infrastructure implementation of IAgentExecutor for the Gemini CLI agent.
+ * Executes prompts via the `gemini` CLI subprocess with JSON output format.
+ *
+ * Uses constructor dependency injection for the spawn function
+ * to enable testability without mocking node:child_process directly.
+ */
+import type { AgentType, AgentFeature, AgentConfig } from '../../../../../domain/generated/output.js';
+import type { IAgentExecutor, AgentExecutionOptions, AgentExecutionResult, AgentExecutionStreamEvent } from '../../../../../application/ports/output/agents/agent-executor.interface.js';
+import type { SpawnFunction } from '../types.js';
+/**
+ * Executor service for Gemini CLI agent.
+ * Uses subprocess spawning to interact with the `gemini` CLI.
+ */
+export declare class GeminiCliExecutorService implements IAgentExecutor {
+    private readonly spawn;
+    private readonly authConfig?;
+    readonly agentType: AgentType;
+    /** When true, suppresses debug logging (set per-call via options.silent) */
+    private silent;
+    constructor(spawn: SpawnFunction, authConfig?: AgentConfig | undefined);
+    /** Debug logging — writes to stdout so it appears in the worker log file */
+    private log;
+    supportsFeature(feature: AgentFeature): boolean;
+    execute(prompt: string, options?: AgentExecutionOptions): Promise<AgentExecutionResult>;
+    executeStream(prompt: string, options?: AgentExecutionOptions): AsyncIterable<AgentExecutionStreamEvent>;
+    /**
+     * Parse a single stream-JSON line into an AgentExecutionStreamEvent.
+     * Returns null for events that should be skipped (init, user messages, unknown types).
+     */
+    private parseStreamEvent;
+    /**
+     * Patterns in stderr that indicate a fatal API error even when exit code is 0.
+     * Gemini CLI sometimes exits 0 after exhausting retries on 429/5xx errors.
+     */
+    private static readonly FATAL_STDERR_PATTERNS;
+    /**
+     * Check stderr for patterns indicating fatal API errors.
+     * Returns an error message if fatal patterns are found, null otherwise.
+     */
+    private detectFatalStderrError;
+    /**
+     * Extract token usage from Gemini stats structure.
+     * Returns undefined if stats are missing (does not throw).
+     */
+    private extractUsage;
+    private buildArgs;
+    private buildSpawnOptions;
+}
+//# sourceMappingURL=gemini-cli-executor.service.d.ts.map

package/dist/packages/core/src/infrastructure/services/agents/common/executors/gemini-cli-executor.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemini-cli-executor.service.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/common/executors/gemini-cli-executor.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EACZ,WAAW,EACZ,MAAM,2CAA2C,CAAC;AACnD,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EAC1B,MAAM,4EAA4E,CAAC;AACpF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD;;;GAGG;AACH,qBAAa,wBAAyB,YAAW,cAAc;IAO3D,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC;IAP9B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAA6B;IAE1D,4EAA4E;IAC5E,OAAO,CAAC,MAAM,CAAS;gBAGJ,KAAK,EAAE,aAAa,EACpB,UAAU,CAAC,EAAE,WAAW,YAAA;IAG3C,4EAA4E;IAC5E,OAAO,CAAC,GAAG;IAMX,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO;IAIzC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAsFtF,aAAa,CAClB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,qBAAqB,GAC9B,aAAa,CAAC,yBAAyB,CAAC;IAsG3C;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAmDxB;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAI3C;IAEF;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;;OAGG;IACH,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,SAAS;IAsBjB,OAAO,CAAC,iBAAiB;CAiB1B"}

package/dist/packages/core/src/infrastructure/services/agents/common/executors/gemini-cli-executor.service.js

@@ -0,0 +1,337 @@
+/**
+ * Gemini CLI Executor Service
+ *
+ * Infrastructure implementation of IAgentExecutor for the Gemini CLI agent.
+ * Executes prompts via the `gemini` CLI subprocess with JSON output format.
+ *
+ * Uses constructor dependency injection for the spawn function
+ * to enable testability without mocking node:child_process directly.
+ */
+/** Features supported by Gemini CLI */
+const SUPPORTED_FEATURES = new Set(['session-resume', 'streaming', 'tool-scoping']);
+/**
+ * Executor service for Gemini CLI agent.
+ * Uses subprocess spawning to interact with the `gemini` CLI.
+ */
+export class GeminiCliExecutorService {
+    spawn;
+    authConfig;
+    agentType = 'gemini-cli';
+    /** When true, suppresses debug logging (set per-call via options.silent) */
+    silent = false;
+    constructor(spawn, authConfig) {
+        this.spawn = spawn;
+        this.authConfig = authConfig;
+    }
+    /** Debug logging — writes to stdout so it appears in the worker log file */
+    log(message) {
+        if (this.silent)
+            return;
+        const ts = new Date().toISOString();
+        process.stdout.write(`[${ts}] [gemini-cli-executor] ${message}\n`);
+    }
+    supportsFeature(feature) {
+        return SUPPORTED_FEATURES.has(feature);
+    }
+    async execute(prompt, options) {
+        this.silent = options?.silent ?? false;
+        const args = this.buildArgs(prompt, options, 'json');
+        const spawnOpts = this.buildSpawnOptions(options);
+        this.log(`Spawning: gemini ${args.map((a) => (a.length > 80 ? `${a.slice(0, 77)}...` : a)).join(' ')}`);
+        this.log(`Spawn options: ${JSON.stringify(spawnOpts)}`);
+        const proc = this.spawn('gemini', args, spawnOpts);
+        this.log(`Subprocess PID: ${proc.pid ?? 'undefined (spawn may have failed)'}`);
+        if (proc.stdin)
+            proc.stdin.end();
+        return new Promise((resolve, reject) => {
+            let stdout = '';
+            let stderr = '';
+            let timedOut = false;
+            let timeoutId;
+            if (options?.timeout) {
+                timeoutId = setTimeout(() => {
+                    timedOut = true;
+                    proc.kill();
+                }, options.timeout);
+            }
+            proc.stdout?.on('data', (chunk) => {
+                stdout += chunk.toString();
+            });
+            proc.stderr?.on('data', (chunk) => {
+                const data = chunk.toString();
+                stderr += data;
+                this.log(`stderr: ${data.trimEnd()}`);
+            });
+            proc.on('error', (error) => {
+                this.log(`Process error event: ${error.message}`);
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                reject(error);
+            });
+            proc.on('close', (code) => {
+                this.log(`Process closed with code ${code}, stdout=${stdout.length} chars`);
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (timedOut) {
+                    reject(new Error('Agent execution timed out'));
+                    return;
+                }
+                if (code !== 0 && code !== null) {
+                    const message = stderr.trim()
+                        ? `Process exited with code ${code}: ${stderr.trim()}`
+                        : `Process exited with code ${code}`;
+                    reject(new Error(message));
+                    return;
+                }
+                // Gemini CLI may exit 0 despite fatal API errors (e.g. 429 rate limits).
+                // Check stderr for known fatal patterns before trusting the output.
+                const fatalError = this.detectFatalStderrError(stderr);
+                if (fatalError) {
+                    reject(new Error(fatalError));
+                    return;
+                }
+                try {
+                    const parsed = JSON.parse(stdout);
+                    const result = { result: parsed.response ?? '' };
+                    if (parsed.session_id)
+                        result.sessionId = parsed.session_id;
+                    const usage = this.extractUsage(parsed);
+                    if (usage)
+                        result.usage = usage;
+                    resolve(result);
+                }
+                catch {
+                    reject(new Error(`Failed to parse Gemini JSON output: ${stdout.slice(0, 200)}`));
+                }
+            });
+        });
+    }
+    async *executeStream(prompt, options) {
+        this.silent = options?.silent ?? false;
+        const args = this.buildArgs(prompt, options, 'stream-json');
+        const spawnOpts = this.buildSpawnOptions(options);
+        const proc = this.spawn('gemini', args, spawnOpts);
+        if (proc.stdin)
+            proc.stdin.end();
+        let lineBuffer = '';
+        let stderr = '';
+        let timedOut = false;
+        let timeoutId;
+        const queue = [];
+        let resolve = null;
+        let error = null;
+        function enqueue(event) {
+            queue.push(event);
+            if (resolve) {
+                resolve();
+                resolve = null;
+            }
+        }
+        function waitForItem() {
+            if (queue.length > 0)
+                return Promise.resolve();
+            return new Promise((r) => {
+                resolve = r;
+            });
+        }
+        if (options?.timeout) {
+            timeoutId = setTimeout(() => {
+                timedOut = true;
+                proc.kill();
+                enqueue({ type: 'error', content: 'Agent execution timed out', timestamp: new Date() });
+                enqueue(null);
+            }, options.timeout);
+        }
+        proc.stdout?.on('data', (chunk) => {
+            lineBuffer += chunk.toString();
+            const lines = lineBuffer.split('\n');
+            lineBuffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                const event = this.parseStreamEvent(trimmed);
+                if (event)
+                    enqueue(event);
+            }
+        });
+        proc.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        proc.on('error', (err) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            error = err;
+            enqueue(null);
+        });
+        proc.on('close', (code) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (timedOut)
+                return; // already handled by timeout callback
+            if (lineBuffer.trim()) {
+                const event = this.parseStreamEvent(lineBuffer.trim());
+                if (event)
+                    enqueue(event);
+            }
+            if (code !== 0 && code !== null) {
+                const msg = stderr.trim()
+                    ? `Process exited with code ${code}: ${stderr.trim()}`
+                    : `Process exited with code ${code}`;
+                enqueue({ type: 'error', content: msg, timestamp: new Date() });
+            }
+            else {
+                // Gemini CLI may exit 0 despite fatal API errors (e.g. 429 rate limits)
+                const fatalError = this.detectFatalStderrError(stderr);
+                if (fatalError) {
+                    enqueue({ type: 'error', content: fatalError, timestamp: new Date() });
+                }
+            }
+            enqueue(null);
+        });
+        while (true) {
+            await waitForItem();
+            const item = queue.shift();
+            if (item === null || item === undefined) {
+                if (error !== null) {
+                    yield {
+                        type: 'error',
+                        content: error.message,
+                        timestamp: new Date(),
+                    };
+                }
+                return;
+            }
+            yield item;
+        }
+    }
+    /**
+     * Parse a single stream-JSON line into an AgentExecutionStreamEvent.
+     * Returns null for events that should be skipped (init, user messages, unknown types).
+     */
+    parseStreamEvent(line) {
+        try {
+            const parsed = JSON.parse(line);
+            const type = parsed.type;
+            switch (type) {
+                case 'init':
+                    return null;
+                case 'message':
+                    if (parsed.role === 'user')
+                        return null;
+                    if (parsed.role === 'assistant' && parsed.delta) {
+                        return {
+                            type: 'progress',
+                            content: parsed.content ?? '',
+                            timestamp: new Date(),
+                        };
+                    }
+                    return null;
+                case 'tool_use':
+                    return {
+                        type: 'progress',
+                        content: `[tool_use: ${parsed.tool_name}]`,
+                        timestamp: new Date(),
+                    };
+                case 'tool_result':
+                    return {
+                        type: 'progress',
+                        content: `[tool_result: ${parsed.status}]`,
+                        timestamp: new Date(),
+                    };
+                case 'result':
+                    return {
+                        type: 'result',
+                        content: parsed.response ?? '',
+                        timestamp: new Date(),
+                    };
+                case 'error':
+                    return {
+                        type: 'error',
+                        content: parsed.message ?? '',
+                        timestamp: new Date(),
+                    };
+                default:
+                    return null;
+            }
+        }
+        catch {
+            // Non-JSON line — emit as raw progress
+            return { type: 'progress', content: line, timestamp: new Date() };
+        }
+    }
+    /**
+     * Patterns in stderr that indicate a fatal API error even when exit code is 0.
+     * Gemini CLI sometimes exits 0 after exhausting retries on 429/5xx errors.
+     */
+    static FATAL_STDERR_PATTERNS = [
+        /RESOURCE_EXHAUSTED/i,
+        /failed with status 4\d{2}\. Retrying/i,
+        /failed with status 5\d{2}\. Retrying/i,
+    ];
+    /**
+     * Check stderr for patterns indicating fatal API errors.
+     * Returns an error message if fatal patterns are found, null otherwise.
+     */
+    detectFatalStderrError(stderr) {
+        for (const pattern of GeminiCliExecutorService.FATAL_STDERR_PATTERNS) {
+            if (pattern.test(stderr)) {
+                // Extract a concise summary from the noisy stderr
+                const lines = stderr.split('\n').filter((l) => l.trim());
+                const summary = lines.slice(0, 3).join(' | ').slice(0, 300);
+                return `Gemini CLI exited 0 but fatal error detected in stderr: ${summary}`;
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract token usage from Gemini stats structure.
+     * Returns undefined if stats are missing (does not throw).
+     */
+    extractUsage(parsed) {
+        const stats = parsed.stats;
+        if (!stats?.models)
+            return undefined;
+        const models = stats.models;
+        const firstModel = Object.values(models)[0];
+        if (!firstModel?.tokens)
+            return undefined;
+        const tokens = firstModel.tokens;
+        if (tokens.prompt === undefined || tokens.candidates === undefined)
+            return undefined;
+        return { inputTokens: tokens.prompt, outputTokens: tokens.candidates };
+    }
+    buildArgs(prompt, options, outputFormat = 'json') {
+        const args = ['-p', prompt, '--output-format', outputFormat, '-y'];
+        if (options?.resumeSession)
+            args.push('--resume', options.resumeSession);
+        if (options?.model)
+            args.push('-m', options.model);
+        if (options?.allowedTools?.length)
+            args.push('--allowed-tools', options.allowedTools.join(','));
+        // Unsupported options silently omitted: maxTurns, disableMcp
+        if (options?.systemPrompt) {
+            this.log('systemPrompt option is not supported by Gemini CLI — ignoring');
+        }
+        if (options?.outputSchema) {
+            this.log('outputSchema option is not supported by Gemini CLI — ignoring');
+        }
+        return args;
+    }
+    buildSpawnOptions(options) {
+        const spawnOpts = {};
+        if (options?.cwd)
+            spawnOpts.cwd = options.cwd;
+        // Strip CLAUDECODE env var to prevent "nested session" error when shep
+        // is invoked from within a Claude Code session.
+        const { CLAUDECODE: _, ...cleanEnv } = process.env;
+        // Inject GEMINI_API_KEY when using token auth
+        if (this.authConfig?.authMethod === 'token' && this.authConfig.token) {
+            spawnOpts.env = { ...cleanEnv, GEMINI_API_KEY: this.authConfig.token };
+        }
+        else {
+            spawnOpts.env = cleanEnv;
+        }
+        return spawnOpts;
+    }
+}

package/dist/src/presentation/tui/prompts/agent-select.prompt.d.ts

@@ -20,7 +20,7 @@ export declare function createAgentSelectConfig(): {
     }, {
         readonly name: "Gemini CLI";
         readonly value: AgentType.GeminiCli;
-        readonly disabled: "(Coming Soon)";
+        readonly description: "Google Gemini CLI";
     }, {
         readonly name: "Aider";
         readonly value: AgentType.Aider;

package/dist/src/presentation/tui/prompts/agent-select.prompt.js

@@ -24,7 +24,7 @@ export function createAgentSelectConfig() {
             {
                 name: 'Gemini CLI',
                 value: AgentType.GeminiCli,
-                disabled: '(Coming Soon)',
+                description: 'Google Gemini CLI',
             },
             {
                 name: 'Aider',