vibeman 0.0.5 → 0.0.6

package/dist/runtime/api/agent/ai-providers/amp-cli-provider.d.ts

@@ -1,38 +0,0 @@
-/**
- * Amp CLI Provider
- * Headless wrapper around the Amp CLI `amp -x` command.
- */
-import { AIProvider, ExecutionMessage, ExecutionOptions, ModelInfo, ProviderCapabilities, ProviderStatus } from './types.js';
-export interface AmpCliConfig {
-    ampBinPath?: string;
-    defaultWorkingDirectory?: string;
-    /**
-     * Amp CLI does not support explicit model selection in this integration.
-     * Kept for backwards compatibility but ignored.
-     */
-    defaultModel?: string;
-    defaultTimeoutMs?: number;
-}
-export declare class AmpCliProvider implements AIProvider {
-    private config;
-    readonly name = "amp";
-    readonly displayName = "Amp CLI";
-    constructor(config?: AmpCliConfig);
-    private resolveExecutable;
-    execute(prompt: string, options?: ExecutionOptions): AsyncIterableIterator<ExecutionMessage>;
-    executeSync(prompt: string, options?: ExecutionOptions): Promise<{
-        id: string;
-        provider: string;
-        model: string;
-        content: string;
-        usage: {
-            promptTokens: number;
-            completionTokens: number;
-            totalTokens: number;
-        };
-        duration: number;
-    }>;
-    detectAvailableModels(): Promise<ModelInfo[]>;
-    validateSetup(): Promise<ProviderStatus>;
-    getCapabilities(): ProviderCapabilities;
-}

package/dist/runtime/api/agent/ai-providers/amp-cli-provider.js

@@ -1,268 +0,0 @@
-/**
- * Amp CLI Provider
- * Headless wrapper around the Amp CLI `amp -x` command.
- */
-import { spawn } from 'child_process';
-import { getSettingsService } from '../../settings-service.js';
-import { getProviderDetectionService } from '../../lib/provider-detection.js';
-import { logger } from '../../lib/logger.js';
-export class AmpCliProvider {
-    constructor(config = {}) {
-        this.config = config;
-        this.name = 'amp';
-        this.displayName = 'Amp CLI';
-    }
-    async resolveExecutable() {
-        if (this.config.ampBinPath)
-            return this.config.ampBinPath;
-        // Use enhanced detection service
-        const detectionService = getProviderDetectionService();
-        const result = await detectionService.detectProvider('amp');
-        if (result.found && result.path) {
-            return result.path;
-        }
-        // Fallback: try old settings-based approach (though new for Amp, following pattern)
-        const settingsBinPath = (() => {
-            try {
-                const svc = getSettingsService();
-                const s = svc.getSettings();
-                return s?.agents?.providers?.amp?.binPath;
-            }
-            catch {
-                return undefined;
-            }
-        })();
-        if (settingsBinPath?.trim())
-            return settingsBinPath.trim();
-        // Default to binary name (resolve via PATH)
-        return 'amp';
-    }
-    async *execute(prompt, options) {
-        // Effective options
-        const cwd = options?.workingDirectory || this.config.defaultWorkingDirectory || process.cwd();
-        // Amp CLI runs in an automatic mode for model/tool selection in this integration.
-        // We intentionally ignore any requested model.
-        const requestedModel = options?.model || this.config.defaultModel;
-        const model = 'auto';
-        const timeoutMs = options?.timeout ?? this.config.defaultTimeoutMs ?? 10 * 60 * 1000; // 10m
-        const systemPrompt = options?.systemPrompt?.trim();
-        const appendSystemPrompt = options?.appendSystemPrompt?.trim();
-        // Construct effective prompt
-        const promptSegments = [];
-        if (systemPrompt) {
-            promptSegments.push(systemPrompt);
-        }
-        if (appendSystemPrompt) {
-            promptSegments.push(appendSystemPrompt);
-        }
-        promptSegments.push(prompt);
-        const effectivePrompt = promptSegments.join('\n\n');
-        // Build argv for `amp -x`
-        const argv = ['-x', effectivePrompt];
-        if (options?.dangerouslyBypassApprovalsAndSandbox) {
-            argv.push('--dangerously-allow-all');
-        }
-        const cmd = await this.resolveExecutable();
-        const child = spawn(cmd, argv, {
-            cwd,
-            env: { ...process.env },
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        // Emit an init/system message with effective command
-        const init = {
-            type: 'init',
-            timestamp: new Date().toISOString(),
-            sessionId: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-            model,
-            provider: this.name,
-        };
-        yield init;
-        yield {
-            type: 'system',
-            timestamp: new Date().toISOString(),
-            content: `Running: ${cmd} ${argv
-                .map((a) => (a.includes(' ') ? '"' + a + '"' : a))
-                .join(' ')} (cwd=${cwd})`,
-            metadata: {
-                provider: this.name,
-                requestedModel,
-                systemPrompt,
-                appendSystemPrompt,
-                dangerouslyBypassApprovalsAndSandbox: !!options?.dangerouslyBypassApprovalsAndSandbox,
-            },
-        };
-        let stdoutBuf = '';
-        let finished = false;
-        let lastFlushedIndex = 0;
-        let lineCarry = '';
-        // Helper to push incremental stdout as assistant log lines
-        const flushNewOutput = () => {
-            const newChunk = stdoutBuf.slice(lastFlushedIndex);
-            if (!newChunk)
-                return;
-            lastFlushedIndex = stdoutBuf.length;
-            // Accumulate and split by line breaks, keep trailing partial
-            lineCarry += newChunk;
-            const parts = lineCarry.split(/\r?\n/);
-            lineCarry = parts.pop() || '';
-            return parts.map((l) => l.trimEnd()).filter(Boolean);
-        };
-        const onAbort = () => {
-            try {
-                child.kill('SIGTERM');
-            }
-            catch {
-                /* ignore */
-            }
-            setTimeout(() => {
-                if (!finished) {
-                    try {
-                        child.kill('SIGKILL');
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                }
-            }, 3000);
-        };
-        if (options?.abortSignal) {
-            if (options.abortSignal.aborted)
-                onAbort();
-            else
-                options.abortSignal.addEventListener('abort', onAbort, { once: true });
-        }
-        const guard = setTimeout(() => {
-            onAbort();
-        }, timeoutMs);
-        child.stdout?.on('data', (data) => {
-            stdoutBuf += data.toString('utf8');
-        });
-        const exitPromise = new Promise((resolve) => {
-            child.on('exit', (code, signal) => resolve({ code, signal }));
-        });
-        // Poll for output until the process exits
-        let exitStatus;
-        while (!finished) {
-            const tick = new Promise((r) => setTimeout(r, 150));
-            const exit = await Promise.race([exitPromise, tick]);
-            if (exit && typeof exit.code !== 'undefined') {
-                const lines = flushNewOutput();
-                if (lines && lines.length) {
-                    for (const text of lines) {
-                        yield {
-                            type: 'assistant',
-                            timestamp: new Date().toISOString(),
-                            content: text,
-                        };
-                    }
-                }
-                finished = true;
-                exitStatus = exit;
-                break;
-            }
-            const lines = flushNewOutput();
-            if (lines && lines.length) {
-                for (const text of lines) {
-                    yield {
-                        type: 'assistant',
-                        timestamp: new Date().toISOString(),
-                        content: text,
-                    };
-                }
-            }
-        }
-        const exit = exitStatus ?? (await exitPromise);
-        finished = true;
-        clearTimeout(guard);
-        if (lineCarry.trim()) {
-            yield {
-                type: 'assistant',
-                timestamp: new Date().toISOString(),
-                content: lineCarry.trimEnd(),
-            };
-            lineCarry = '';
-        }
-        const success = (exit.code ?? 1) === 0 && !exit.signal;
-        const remainingStdout = stdoutBuf.trim();
-        const resultMsg = {
-            type: 'result',
-            timestamp: new Date().toISOString(),
-            success,
-            result: success ? (remainingStdout || '').toString() : undefined,
-            error: success
-                ? undefined
-                : `amp exited ${exit.signal ? 'by ' + exit.signal : 'with code ' + exit.code}`,
-            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-        };
-        yield resultMsg;
-    }
-    async executeSync(prompt, options) {
-        let content = '';
-        const start = Date.now();
-        for await (const msg of this.execute(prompt, options)) {
-            if (msg.type === 'assistant' && typeof msg.content === 'string') {
-                content += (content ? '\n' : '') + msg.content;
-            }
-        }
-        return {
-            id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-            provider: this.name,
-            model: 'auto',
-            content,
-            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-            duration: Date.now() - start,
-        };
-    }
-    async detectAvailableModels() {
-        const capabilities = ['code', 'analysis', 'tools', 'vision', 'reasoning'];
-        const makeModel = (id, displayName) => ({
-            id,
-            name: id,
-            displayName,
-            provider: this.name,
-            contextWindow: 128000,
-            maxOutputTokens: 16384,
-            capabilities,
-        });
-        return [makeModel('auto', 'Auto (recommended)')];
-    }
-    async validateSetup() {
-        try {
-            const detectionService = getProviderDetectionService();
-            const result = await detectionService.detectProvider('amp');
-            if (!result.found) {
-                return {
-                    available: false,
-                    error: result.error || 'Amp CLI not found. Install Amp and ensure it is in your PATH.',
-                    models: [],
-                    capabilities: this.getCapabilities(),
-                };
-            }
-            return {
-                available: true,
-                models: await this.detectAvailableModels(),
-                capabilities: this.getCapabilities(),
-            };
-        }
-        catch (error) {
-            logger.error(error);
-            return {
-                available: false,
-                error: error instanceof Error ? error.message : String(error),
-                models: [],
-                capabilities: this.getCapabilities(),
-            };
-        }
-    }
-    getCapabilities() {
-        return {
-            streaming: true,
-            tools: true,
-            functionCalling: false,
-            vision: true,
-            codeExecution: true,
-            maxContextWindow: 128000,
-            maxOutputTokens: 8192,
-        };
-    }
-}

package/dist/runtime/api/agent/ai-providers/claude-code-adapter.d.ts

@@ -1,61 +0,0 @@
-/**
- * Claude Code Adapter
- * Implements AIProvider interface for Claude Code SDK
- */
-import { AIProvider, ExecutionOptions, ExecutionMessage, ExecutionResult, ModelInfo, ProviderStatus, ProviderCapabilities } from './types.js';
-/**
- * Configuration for Claude Code Adapter
- */
-export interface ClaudeCodeConfig {
-    /**
-     * Path to Claude CLI executable
-     * If not provided, will use default resolution
-     */
-    claudeBinPath?: string;
-    /**
-     * Default working directory
-     */
-    defaultWorkingDirectory?: string;
-    /**
-     * Default model to use
-     */
-    defaultModel?: string;
-}
-/**
- * Claude Code Adapter
- * Wraps the Claude Code SDK to implement the AIProvider interface
- */
-export declare class ClaudeCodeAdapter implements AIProvider {
-    readonly name = "claude-code";
-    readonly displayName = "Claude Code";
-    private config;
-    constructor(config?: ClaudeCodeConfig);
-    /**
-     * Execute a prompt using Claude Code SDK
-     */
-    execute(prompt: string, options?: ExecutionOptions): AsyncIterableIterator<ExecutionMessage>;
-    /**
-     * Execute synchronously and return the final result
-     */
-    executeSync(prompt: string, options?: ExecutionOptions): Promise<ExecutionResult>;
-    /**
-     * Detect available Claude models
-     */
-    detectAvailableModels(): Promise<ModelInfo[]>;
-    /**
-     * Validate Claude Code setup using enhanced detection
-     */
-    validateSetup(): Promise<ProviderStatus>;
-    /**
-     * Get provider capabilities
-     */
-    getCapabilities(): ProviderCapabilities;
-    /**
-     * Map ExecutionOptions to Claude Code Options
-     */
-    private mapToClaudeOptions;
-    /**
-     * Resolve Claude CLI executable path using enhanced detection
-     */
-    private getClaudeExecutablePath;
-}