vibeman 0.0.3 → 0.0.6

package/dist/runtime/api/lib/logger.js

@@ -1,188 +0,0 @@
-import pino from 'pino';
-// Check if we're running in browser context
-const isBrowser = typeof globalThis !== 'undefined' && 'window' in globalThis;
-// Simple environment detection to avoid import issues
-function isDevelopment() {
-    return process.env.NODE_ENV === 'development';
-}
-// Environment detection - check both environment variable and process args for verbose mode
-const isVerbose = process.env.VERBOSE === 'true' ||
-    (typeof process !== 'undefined' &&
-        process.argv &&
-        (process.argv.includes('--verbose') || process.argv.includes('-v')));
-// Optional explicit log level/format override
-const envLogLevel = (process.env.VIBEMAN_LOG_LEVEL || process.env.LOG_LEVEL || '').toLowerCase();
-const envLogStyle = (process.env.VIBEMAN_LOG_STYLE || process.env.LOG_STYLE || '').toLowerCase();
-const paramSplitter = process.env.VIBEMAN_LOG_SPLIT || process.env.LOG_SPLIT || ' | ';
-// Determine log level based on environment and verbose flag
-function getLogLevel() {
-    if (envLogLevel &&
-        ['silent', 'fatal', 'error', 'warn', 'info', 'debug', 'trace'].includes(envLogLevel)) {
-        return envLogLevel;
-    }
-    if (isVerbose)
-        return 'debug';
-    if (isDevelopment())
-        return 'info';
-    return 'error';
-}
-// Create logger configuration
-const loggerConfig = {
-    level: getLogLevel(),
-    ...(isBrowser
-        ? {
-            // Browser configuration - use simple console
-            browser: { asObject: false },
-        }
-        : {
-            // Node.js configuration
-            formatters: {
-                level: (label) => ({ level: label }),
-                log: (object) => object,
-            },
-            transport: {
-                target: 'pino-pretty',
-                options: (() => {
-                    const base = {
-                        colorize: true,
-                        translateTime: 'HH:MM:ss',
-                        ignore: 'pid,hostname',
-                    };
-                    if (envLogStyle !== 'pretty') {
-                        base.singleLine = false;
-                        base.hideObject = false; // allow error objects to render stacks
-                        return base;
-                    }
-                    // Pretty (multi-line) with inline context, print objects nicely
-                    base.levelFirst = true;
-                    base.messageFormat = (log, messageKey) => log?.context ? `[${log.context}] ${log[messageKey]}` : log[messageKey];
-                    return base;
-                })(),
-            },
-        }),
-};
-// Create the logger instance
-export const logger = pino(loggerConfig);
-// Context-aware logger factory
-export function createContextLogger(context) {
-    return logger.child({ context });
-}
-// Convenience methods for common logging patterns
-export const log = {
-    error: (message, error, context) => {
-        const contextLogger = context ? createContextLogger(context) : logger;
-        const msg = context ? `[${context}] ${message}` : message;
-        if (error instanceof Error) {
-            // Keep error object so stack renders, even in compact
-            contextLogger.error({ err: error }, msg);
-        }
-        else if (error) {
-            contextLogger.error({ err: error }, msg);
-        }
-        else {
-            contextLogger.error(msg);
-        }
-    },
-    warn: (message, data, context) => {
-        const contextLogger = context ? createContextLogger(context) : logger;
-        const msg = context ? `[${context}] ${message}` : message;
-        if (data && envLogStyle !== 'pretty') {
-            const entries = Object.entries(data);
-            const messageEntry = entries.find(([k]) => k === 'message');
-            const other = entries.filter(([k]) => k !== 'message');
-            const pairs = other.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(paramSplitter);
-            const body = (() => {
-                if (!messageEntry)
-                    return '';
-                const val = messageEntry[1];
-                if (typeof val === 'string')
-                    return `\n${val}`; // print as-is (newlines preserved)
-                return `\n${JSON.stringify(val, null, 2)}`;
-            })();
-            contextLogger.warn(pairs ? `${msg} ${pairs}${body}` : `${msg}${body}`);
-        }
-        else if (data) {
-            contextLogger.warn(data, msg);
-        }
-        else {
-            contextLogger.warn(msg);
-        }
-    },
-    info: (message, data, context) => {
-        const contextLogger = context ? createContextLogger(context) : logger;
-        const msg = context ? `[${context}] ${message}` : message;
-        if (data && envLogStyle !== 'pretty') {
-            const entries = Object.entries(data);
-            const messageEntry = entries.find(([k]) => k === 'message');
-            const other = entries.filter(([k]) => k !== 'message');
-            const pairs = other.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(paramSplitter);
-            const body = (() => {
-                if (!messageEntry)
-                    return '';
-                const val = messageEntry[1];
-                if (typeof val === 'string')
-                    return `\n${val}`;
-                return `\n${JSON.stringify(val, null, 2)}`;
-            })();
-            contextLogger.info(pairs ? `${msg} ${pairs}${body}` : `${msg}${body}`);
-        }
-        else if (data) {
-            contextLogger.info(data, msg);
-        }
-        else {
-            contextLogger.info(msg);
-        }
-    },
-    debug: (message, data, context) => {
-        const contextLogger = context ? createContextLogger(context) : logger;
-        const msg = context ? `[${context}] ${message}` : message;
-        if (data && envLogStyle !== 'pretty') {
-            const entries = Object.entries(data);
-            const messageEntry = entries.find(([k]) => k === 'message');
-            const other = entries.filter(([k]) => k !== 'message');
-            const pairs = other.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(paramSplitter);
-            const body = (() => {
-                if (!messageEntry)
-                    return '';
-                const val = messageEntry[1];
-                if (typeof val === 'string')
-                    return `\n${val}`;
-                return `\n${JSON.stringify(val, null, 2)}`;
-            })();
-            contextLogger.debug(pairs ? `${msg} ${pairs}${body}` : `${msg}${body}`);
-        }
-        else if (data) {
-            contextLogger.debug(data, msg);
-        }
-        else {
-            contextLogger.debug(msg);
-        }
-    },
-    trace: (message, data, context) => {
-        const contextLogger = context ? createContextLogger(context) : logger;
-        const msg = context ? `[${context}] ${message}` : message;
-        if (data && envLogStyle !== 'pretty') {
-            const entries = Object.entries(data);
-            const messageEntry = entries.find(([k]) => k === 'message');
-            const other = entries.filter(([k]) => k !== 'message');
-            const pairs = other.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(paramSplitter);
-            const body = (() => {
-                if (!messageEntry)
-                    return '';
-                const val = messageEntry[1];
-                if (typeof val === 'string')
-                    return `\n${val}`;
-                return `\n${JSON.stringify(val, null, 2)}`;
-            })();
-            contextLogger.trace(pairs ? `${msg} ${pairs}${body}` : `${msg}${body}`);
-        }
-        else if (data) {
-            contextLogger.trace(data, msg);
-        }
-        else {
-            contextLogger.trace(msg);
-        }
-    },
-};
-// Export default logger for direct use
-export default logger;

package/dist/runtime/api/lib/provider-detection.d.ts

@@ -1,59 +0,0 @@
-/**
- * Enhanced Provider Detection Service
- * Robust detection logic for AI provider CLI tools with multiple fallback strategies
- */
-export interface DetectionResult {
-    found: boolean;
-    path?: string;
-    version?: string;
-    method?: 'explicit' | 'PATH' | 'common-location';
-    error?: string;
-}
-export interface ProviderInfo {
-    name: string;
-    command: string;
-    versionArgsList?: string[][];
-    versionRegex: RegExp;
-}
-/**
- * Provider definitions for detection
- */
-export declare const PROVIDER_DEFINITIONS: Record<string, ProviderInfo>;
-/**
- * Enhanced Provider Detection Service
- */
-export declare class ProviderDetectionService {
-    private localConfig;
-    constructor();
-    /**
-     * Detect a specific provider with all fallback strategies
-     */
-    detectProvider(providerId: string): Promise<DetectionResult>;
-    /**
-     * Detect all configured providers
-     */
-    detectAllProviders(): Promise<Record<string, DetectionResult>>;
-    /**
-     * Validate a specific binary path
-     */
-    validateBinaryPath(binPath: string, provider: ProviderInfo, method?: DetectionResult['method']): Promise<DetectionResult>;
-    /**
-     * Set explicit provider path and cache it
-     */
-    setProviderPath(providerId: string, binPath: string): Promise<DetectionResult>;
-    /**
-     * Clear cached provider configuration
-     */
-    clearProviderPath(providerId: string): Promise<void>;
-    /**
-     * Get cached detection results if still fresh
-     */
-    getCachedResult(providerId: string): Promise<DetectionResult | null>;
-    private checkExplicitConfig;
-    private checkSystemCommand;
-    private getVersion;
-    private resolveCommand;
-    private toLocalConfigKey;
-    private cacheDetectionResult;
-}
-export declare function getProviderDetectionService(): ProviderDetectionService;

package/dist/runtime/api/lib/provider-detection.js

@@ -1,244 +0,0 @@
-/**
- * Enhanced Provider Detection Service
- * Robust detection logic for AI provider CLI tools with multiple fallback strategies
- */
-import { exec, execFile } from 'child_process';
-import { promisify } from 'util';
-import fs from 'fs/promises';
-import which from 'which';
-import { log } from './logger.js';
-import { getLocalConfigService } from './local-config.js';
-const execAsync = promisify(exec);
-const execFileAsync = promisify(execFile);
-/**
- * Provider definitions for detection
- */
-export const PROVIDER_DEFINITIONS = {
-    'claude-code': {
-        name: 'Claude Code',
-        command: 'claude',
-        versionArgsList: [['--version'], ['-v']],
-        versionRegex: /(\d+\.\d+\.\d+)/,
-    },
-    codex: {
-        name: 'Codex CLI',
-        command: 'codex',
-        versionArgsList: [['--version'], ['-v']],
-        versionRegex: /(\d+\.\d+\.\d+)/,
-    },
-};
-/**
- * Enhanced Provider Detection Service
- */
-export class ProviderDetectionService {
-    constructor() {
-        this.localConfig = getLocalConfigService();
-        // Ensure local config is initialized
-        this.localConfig.initialize().catch((error) => {
-            log.error('Failed to initialize local config for provider detection', error, 'provider-detection');
-        });
-    }
-    /**
-     * Detect a specific provider with all fallback strategies
-     */
-    async detectProvider(providerId) {
-        const provider = PROVIDER_DEFINITIONS[providerId];
-        if (!provider) {
-            return {
-                found: false,
-                error: `Unknown provider: ${providerId}`,
-            };
-        }
-        log.debug(`Detecting provider: ${provider.name}`, { providerId }, 'provider-detection');
-        // Strategy 1: Check explicit configuration from local config
-        const explicitResult = await this.checkExplicitConfig(providerId, provider);
-        if (explicitResult.found) {
-            log.info(`Provider found via explicit config: ${provider.name}`, explicitResult, 'provider-detection');
-            return explicitResult;
-        }
-        // Strategy 2: Resolve via system command lookup
-        const systemResult = await this.checkSystemCommand(provider);
-        if (systemResult.found) {
-            log.info(`Provider found on system PATH: ${provider.name}`, systemResult, 'provider-detection');
-            await this.cacheDetectionResult(providerId, systemResult);
-            return systemResult;
-        }
-        // All strategies failed
-        const result = {
-            found: false,
-            error: `${provider.name} not found via explicit config or system PATH`,
-        };
-        log.warn(`Provider not found: ${provider.name}`, result, 'provider-detection');
-        return result;
-    }
-    /**
-     * Detect all configured providers
-     */
-    async detectAllProviders() {
-        const results = {};
-        for (const providerId of Object.keys(PROVIDER_DEFINITIONS)) {
-            try {
-                results[providerId] = await this.detectProvider(providerId);
-            }
-            catch (error) {
-                results[providerId] = {
-                    found: false,
-                    error: `Detection failed: ${error instanceof Error ? error.message : String(error)}`,
-                };
-            }
-        }
-        return results;
-    }
-    /**
-     * Validate a specific binary path
-     */
-    async validateBinaryPath(binPath, provider, method = 'explicit') {
-        try {
-            // Check if file exists and is executable
-            const stats = await fs.stat(binPath);
-            if (!stats.isFile()) {
-                return {
-                    found: false,
-                    error: `Path is not a file: ${binPath}`,
-                };
-            }
-            // Try to execute version command
-            const version = await this.getVersion(binPath, provider);
-            return {
-                found: true,
-                path: binPath,
-                version,
-                method,
-            };
-        }
-        catch (error) {
-            return {
-                found: false,
-                path: binPath,
-                error: `Validation failed: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
-    /**
-     * Set explicit provider path and cache it
-     */
-    async setProviderPath(providerId, binPath) {
-        const provider = PROVIDER_DEFINITIONS[providerId];
-        if (!provider) {
-            return {
-                found: false,
-                error: `Unknown provider: ${providerId}`,
-            };
-        }
-        const result = await this.validateBinaryPath(binPath, provider);
-        if (result.found) {
-            const localId = this.toLocalConfigKey(providerId);
-            await this.localConfig.setProviderPath(localId, binPath, 'explicit');
-        }
-        return result;
-    }
-    /**
-     * Clear cached provider configuration
-     */
-    async clearProviderPath(providerId) {
-        const localId = this.toLocalConfigKey(providerId);
-        await this.localConfig.clearProviderPath(localId);
-    }
-    /**
-     * Get cached detection results if still fresh
-     */
-    async getCachedResult(providerId) {
-        if (this.localConfig.isCachedValidationFresh(providerId)) {
-            const cached = this.localConfig.getCachedValidationResult(providerId);
-            if (cached) {
-                const localId = this.toLocalConfigKey(providerId);
-                return {
-                    found: cached.available,
-                    path: cached.available
-                        ? this.localConfig.getProviderConfig(localId)?.detectedPath
-                        : undefined,
-                    version: cached.version,
-                    error: cached.error,
-                };
-            }
-        }
-        return null;
-    }
-    // Private detection strategies
-    async checkExplicitConfig(providerId, provider) {
-        const localId = this.toLocalConfigKey(providerId);
-        const config = this.localConfig.getProviderConfig(localId);
-        if (!config?.binPath) {
-            return { found: false };
-        }
-        return this.validateBinaryPath(config.binPath, provider, 'explicit');
-    }
-    async checkSystemCommand(provider) {
-        const resolvedPath = await this.resolveCommand(provider.command);
-        if (!resolvedPath) {
-            return { found: false };
-        }
-        return this.validateBinaryPath(resolvedPath, provider, 'PATH');
-    }
-    async getVersion(binPath, provider) {
-        const argSets = provider.versionArgsList ?? [['--version']];
-        for (const args of argSets) {
-            try {
-                const { stdout, stderr } = await execFileAsync(binPath, args, { timeout: 10000 });
-                const output = (stdout + stderr).trim();
-                const match = output.match(provider.versionRegex);
-                if (match?.[1]) {
-                    return match[1];
-                }
-            }
-            catch (error) {
-                log.debug(`Version command failed for ${binPath}`, { args, error }, 'provider-detection');
-            }
-        }
-        return undefined;
-    }
-    async resolveCommand(command) {
-        try {
-            return await which(command);
-        }
-        catch (error) {
-            log.debug(`which lookup failed for ${command}`, error, 'provider-detection');
-        }
-        if (process.platform !== 'win32') {
-            try {
-                const { stdout } = await execAsync(`command -v ${command}`, { timeout: 5000 });
-                const resolved = stdout.trim().split('\n')[0];
-                return resolved ? resolved : null;
-            }
-            catch (error) {
-                log.debug(`command -v lookup failed for ${command}`, error, 'provider-detection');
-            }
-        }
-        return null;
-    }
-    toLocalConfigKey(providerId) {
-        return providerId === 'claude-code' ? 'claude-code' : 'codex';
-    }
-    async cacheDetectionResult(providerId, result) {
-        if (result.found && result.path) {
-            const localId = this.toLocalConfigKey(providerId);
-            if (result.method === 'explicit') {
-                await this.localConfig.setProviderPath(localId, result.path, 'explicit');
-            }
-            else {
-                await this.localConfig.updateDetectedProvider(localId, result.path, result.method || 'PATH');
-            }
-        }
-        await this.localConfig.cacheValidationResult(providerId, {
-            available: result.found,
-            error: result.error,
-            version: result.version,
-        });
-    }
-}
-// Singleton instance
-let providerDetectionService = null;
-export function getProviderDetectionService() {
-    providerDetectionService ?? (providerDetectionService = new ProviderDetectionService());
-    return providerDetectionService;
-}

package/dist/runtime/api/lib/server/agent-service-singleton.d.ts

@@ -1,6 +0,0 @@
-import { AgentService } from '../../agent/agent-service.js';
-declare global {
-    var __vibeman_agent_service__: unknown;
-}
-export declare function getAgentService(): AgentService;
-export declare function resetAgentService(): void;

package/dist/runtime/api/lib/server/agent-service-singleton.js

@@ -1,27 +0,0 @@
-import { AgentService } from '../../agent/agent-service.js';
-import { getTaskService } from './task-service-singleton.js';
-import { getSettingsService } from '../../settings-service.js';
-import { getProjectRoot, getVibeDir } from './project-root.js';
-export function getAgentService() {
-    if (!globalThis.__vibeman_agent_service__) {
-        const taskService = getTaskService();
-        const settingsVibeDir = (() => {
-            try {
-                const svc = getSettingsService();
-                const s = svc.getSettings();
-                return s?.development?.vibeDir;
-            }
-            catch {
-                return undefined;
-            }
-        })();
-        const projectRoot = getProjectRoot();
-        const vibeDir = settingsVibeDir || getVibeDir();
-        globalThis.__vibeman_agent_service__ = new AgentService(taskService, projectRoot);
-        console.log(`🤖 Agent Service initialized (projectRoot=${projectRoot}, vibeDir=${vibeDir})`);
-    }
-    return globalThis.__vibeman_agent_service__;
-}
-export function resetAgentService() {
-    globalThis.__vibeman_agent_service__ = undefined;
-}

package/dist/runtime/api/lib/server/bootstrap.d.ts

@@ -1,38 +0,0 @@
-/**
- * Server Bootstrap - Async-first service initialization
- *
- * Provides ordered initialization of core services before router creation,
- * ensuring all dependencies are ready for synchronous access during runtime.
- */
-import { getSettingsService } from '../../settings-service.js';
-import { TaskService } from '../../tasks/task-service.js';
-import { AgentService } from '../../agent/agent-service.js';
-import { GitService } from '../../vcs/git-service.js';
-import { WorktreeService } from '../../vcs/worktree-service.js';
-import { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
-/**
- * Initialize core services in proper dependency order.
- * Must be called before any service getters or router creation.
- */
-export declare function bootstrap(): Promise<void>;
-/**
- * Ready-only sync getters - throw if called before bootstrap
- */
-export declare function getBootstrappedSettingsService(): ReturnType<typeof getSettingsService>;
-export declare function getBootstrappedTaskService(): TaskService;
-export declare function getBootstrappedAgentService(): AgentService;
-export declare function getBootstrappedGitService(): GitService;
-export declare function getBootstrappedWorktreeService(): WorktreeService;
-export declare function getBootstrappedVibingOrchestrator(): VibingOrchestrator;
-/**
- * Get bootstrap completion promise for diagnostics/tests
- */
-export declare function getBootstrapReady(): Promise<void> | null;
-/**
- * Check if bootstrap has completed
- */
-export declare function isBootstrapComplete(): boolean;
-/**
- * Test bootstrap function that initializes against a temp workspace
- */
-export declare function testBootstrap(tempWorkspace?: string): Promise<void>;