vibeman 0.0.3 → 0.0.6

package/dist/runtime/api/lib/trpc/server.js

@@ -1,11 +0,0 @@
-import { createRouter } from '../../router.js';
-import { bootstrap, getBootstrappedTaskService, getBootstrappedGitService, getBootstrappedVibingOrchestrator, } from '../server/bootstrap.js';
-// Build the application router for use by the standalone API server.
-// Note: This module no longer starts any WebSocket servers automatically.
-// Services must be bootstrapped before calling this.
-// Ensure bootstrap is complete before creating router
-await bootstrap();
-const taskService = getBootstrappedTaskService();
-const gitService = getBootstrappedGitService();
-const workflowOrchestrator = getBootstrappedVibingOrchestrator();
-export const appRouter = createRouter(taskService, gitService, workflowOrchestrator);

package/dist/runtime/api/lib/trpc/ws-server.d.ts

@@ -1,8 +0,0 @@
-import type { AppRouter } from './server.js';
-declare global {
-    var __VIBEMAN_WSS__: {
-        started: boolean;
-    } | undefined;
-}
-export declare function startTRPCWebSocketServer(router: AppRouter): void;
-export {};

package/dist/runtime/api/lib/trpc/ws-server.js

@@ -1,33 +0,0 @@
-import { applyWSSHandler } from '@trpc/server/adapters/ws';
-import { WebSocketServer } from 'ws';
-import { getTaskService } from '../server/task-service-singleton.js';
-export function startTRPCWebSocketServer(router) {
-    if (typeof global.__VIBEMAN_WSS__ === 'object' && global.__VIBEMAN_WSS__?.started) {
-        return; // already started
-    }
-    // Decide WS port: (+1) from HTTP port
-    const httpPort = Number(process.env.PORT || 3000);
-    const wsPort = httpPort + 1;
-    try {
-        const wss = new WebSocketServer({ port: wsPort, path: '/api/trpc' });
-        // Handle binding errors gracefully (e.g., EADDRINUSE across HMR workers)
-        wss.on('error', (err) => {
-            const code = (err && err.code) || '';
-            if (code === 'EADDRINUSE') {
-                console.warn(`[vibeman] WS port ${wsPort} in use; skipping secondary start.`);
-            }
-            else {
-                console.warn('[vibeman] WS server error:', err);
-            }
-        });
-        wss.on('listening', () => {
-            const createContext = () => ({ taskService: getTaskService() });
-            applyWSSHandler({ wss, router, createContext });
-            console.log(`📡 tRPC WebSocket listening ws://localhost:${wsPort}/api/trpc`);
-            global.__VIBEMAN_WSS__ = { started: true };
-        });
-    }
-    catch (err) {
-        console.warn('[vibeman] WS server not started:', err instanceof Error ? err.message : err);
-    }
-}

package/dist/runtime/api/persistence/database-service.d.ts

@@ -1,14 +0,0 @@
-export declare class DatabaseService<T extends object> {
-    private filePath;
-    private dbPromise;
-    constructor(filePath: string);
-    private ensureDir;
-    private getDb;
-    getAll(): Promise<Record<string, T>>;
-    setAll(value: Record<string, T>): Promise<void>;
-    get(id: string): Promise<T | undefined>;
-    set(id: string, value: T): Promise<void>;
-    delete(id: string): Promise<void>;
-    clear(): Promise<void>;
-    getFilePath(): string;
-}

package/dist/runtime/api/persistence/database-service.js

@@ -1,74 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import { JSONFilePreset } from 'lowdb/node';
-// A tiny generic wrapper around lowdb that stores a single
-// object map `{ [id: string]: T }` in a JSON file.
-// No domain/business logic here — just generic CRUD helpers.
-export class DatabaseService {
-    constructor(filePath) {
-        this.dbPromise = null;
-        // If filePath is absolute, use it as-is; otherwise resolve relative to cwd
-        this.filePath = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
-    }
-    async ensureDir() {
-        const dir = path.dirname(this.filePath);
-        try {
-            await fs.access(dir);
-        }
-        catch {
-            await fs.mkdir(dir, { recursive: true });
-        }
-    }
-    async getDb() {
-        if (!this.dbPromise) {
-            await this.ensureDir();
-            this.dbPromise = (async () => {
-                const db = await JSONFilePreset(this.filePath, {});
-                // Lightweight migration: if file accidentally has array shape, convert to id map
-                const raw = db.data;
-                if (Array.isArray(raw)) {
-                    const migrated = {};
-                    for (const item of raw) {
-                        if (item && typeof item.id === 'string')
-                            migrated[item.id] = item;
-                    }
-                    db.data = migrated;
-                    await db.write();
-                }
-                return db;
-            })();
-        }
-        return this.dbPromise;
-    }
-    async getAll() {
-        const db = await this.getDb();
-        return { ...db.data };
-    }
-    async setAll(value) {
-        const db = await this.getDb();
-        db.data = { ...value };
-        await db.write();
-    }
-    async get(id) {
-        const db = await this.getDb();
-        return db.data[id];
-    }
-    async set(id, value) {
-        const db = await this.getDb();
-        db.data[id] = value;
-        await db.write();
-    }
-    async delete(id) {
-        const db = await this.getDb();
-        delete db.data[id];
-        await db.write();
-    }
-    async clear() {
-        const db = await this.getDb();
-        db.data = {};
-        await db.write();
-    }
-    getFilePath() {
-        return this.filePath;
-    }
-}

package/dist/runtime/api/persistence/execution-log-persistence.d.ts

@@ -1,90 +0,0 @@
-import type { AgentExecution } from '../types/index.js';
-export interface ExecutionLogEntry {
-    timestamp: string;
-    level: 'info' | 'warn' | 'error';
-    message: string;
-    data?: Record<string, unknown>;
-}
-export interface ExecutionMetadata {
-    executionId: string;
-    taskId: string;
-    workflowId?: string;
-    startTime: string;
-    endTime?: string;
-    status: AgentExecution['status'];
-    error?: string;
-    worktreePath?: string;
-}
-export interface ExecutionIndexEntry {
-    executionId: string;
-    taskId: string;
-    workflowId?: string;
-    status: AgentExecution['status'];
-    startTime: string;
-    endTime?: string;
-    dirPath: string;
-}
-export declare class ExecutionLogPersistence {
-    private dataDir;
-    private logsDir;
-    private indexDb;
-    constructor();
-    /**
-     * Ensure logs directory exists
-     */
-    private ensureLogsDir;
-    /**
-     * Get execution log directory path, grouped by task ID
-     * .vibeman/execution-logs/{taskId}/{executionId-YYYYMMDD_HHMMSS}/
-     */
-    private getExecutionDirFor;
-    /**
-     * Get existing execution directory (for reading)
-     */
-    private findExecutionDir;
-    /**
-     * Start logging for an execution
-     */
-    startExecution(execution: AgentExecution, workflowId?: string): Promise<void>;
-    /**
-     * Append a log entry
-     */
-    appendLog(executionId: string, entry: ExecutionLogEntry): Promise<void>;
-    /**
-     * Log a simple message
-     */
-    logMessage(executionId: string, message: string, level?: ExecutionLogEntry['level'], data?: Record<string, unknown>): Promise<void>;
-    /**
-     * Complete execution and update metadata
-     */
-    completeExecution(executionId: string, status: AgentExecution['status'], error?: string): Promise<void>;
-    /**
-     * Read execution logs
-     */
-    readExecutionLogs(executionId: string): Promise<{
-        metadata: ExecutionMetadata | null;
-        logs: ExecutionLogEntry[];
-    }>;
-    /**
-     * List all executions with metadata
-     */
-    listExecutions(): Promise<ExecutionMetadata[]>;
-    /**
-     * Clean up old execution logs
-     */
-    cleanupOldLogs(maxAgeDays?: number): Promise<number>;
-    /**
-     * Remove execution logs for a specific task
-     */
-    removeExecutionsByTask(taskId: string): Promise<number>;
-    /**
-     * Get execution log statistics
-     */
-    getStats(): Promise<{
-        total: number;
-        byStatus: Record<string, number>;
-        totalLogFiles: number;
-        oldestExecution?: string;
-        newestExecution?: string;
-    }>;
-}

package/dist/runtime/api/persistence/execution-log-persistence.js

@@ -1,410 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import { log } from '../lib/logger.js';
-import { DatabaseService } from './database-service.js';
-import { getVibeDir } from '../lib/server/project-root.js';
-export class ExecutionLogPersistence {
-    constructor() {
-        this.dataDir = getVibeDir();
-        this.logsDir = path.join(this.dataDir, 'execution-logs');
-        this.indexDb = new DatabaseService(path.join(this.logsDir, 'index.json'));
-    }
-    /**
-     * Ensure logs directory exists
-     */
-    async ensureLogsDir() {
-        try {
-            await fs.access(this.logsDir);
-        }
-        catch {
-            await fs.mkdir(this.logsDir, { recursive: true });
-        }
-    }
-    /**
-     * Get execution log directory path, grouped by task ID
-     * .vibeman/execution-logs/{taskId}/{executionId-YYYYMMDD_HHMMSS}/
-     */
-    getExecutionDirFor(execution) {
-        const timestamp = new Date()
-            .toISOString()
-            .replace(/[-:]/g, '')
-            .replace(/\..+/, '')
-            .replace('T', '_');
-        const safeTask = String(execution.taskId).replace(/[^\w.-]+/g, '_');
-        const name = `${execution.id}-${timestamp}`;
-        return path.join(this.logsDir, safeTask, name);
-    }
-    /**
-     * Get existing execution directory (for reading)
-     */
-    async findExecutionDir(executionId) {
-        try {
-            await this.ensureLogsDir();
-            // Prefer index lookup (non-throwing)
-            const idx = await this.indexDb.get(executionId).catch(() => undefined);
-            if (idx?.dirPath) {
-                return idx.dirPath;
-            }
-            // Walk task directories
-            const taskDirs = await fs.readdir(this.logsDir, { withFileTypes: true });
-            for (const taskEntry of taskDirs) {
-                if (!taskEntry.isDirectory())
-                    continue;
-                const taskPath = path.join(this.logsDir, taskEntry.name);
-                const execDirs = await fs.readdir(taskPath, { withFileTypes: true });
-                for (const ed of execDirs) {
-                    if (ed.isDirectory() && ed.name.includes(executionId)) {
-                        return path.join(taskPath, ed.name);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            log.error('Failed to find execution directory', error, 'execution-log-persistence:findExecutionDir');
-        }
-        return null;
-    }
-    /**
-     * Start logging for an execution
-     */
-    async startExecution(execution, workflowId) {
-        try {
-            await this.ensureLogsDir();
-            const executionDir = this.getExecutionDirFor(execution);
-            await fs.mkdir(executionDir, { recursive: true });
-            // Save metadata
-            const metadata = {
-                executionId: execution.id,
-                taskId: execution.taskId,
-                workflowId,
-                startTime: execution.startTime,
-                status: execution.status,
-                worktreePath: execution.worktree?.path,
-            };
-            await fs.writeFile(path.join(executionDir, 'metadata.json'), JSON.stringify(metadata, null, 2));
-            // Update index (best-effort)
-            try {
-                await this.indexDb.set(execution.id, {
-                    executionId: execution.id,
-                    taskId: execution.taskId,
-                    workflowId,
-                    status: execution.status,
-                    startTime: execution.startTime,
-                    dirPath: executionDir,
-                });
-            }
-            catch (error) {
-                log.error('Failed to update execution index on start', error, 'execution-log-persistence:startExecution');
-            }
-            // Update latest symlink per task (best-effort)
-            try {
-                const taskDir = path.dirname(executionDir);
-                const latestLink = path.join(taskDir, 'latest');
-                // Remove existing symlink if any (ignore if missing)
-                await fs.unlink(latestLink).catch(() => undefined);
-                await fs.symlink(executionDir, latestLink);
-            }
-            catch (error) {
-                log.warn('Failed to update latest symlink', error, 'execution-log-persistence:startExecution');
-            }
-            // Create initial log file
-            const initialLog = {
-                timestamp: new Date().toISOString(),
-                level: 'info',
-                message: `Execution started for task ${execution.taskId}`,
-                data: {
-                    executionId: execution.id,
-                    taskId: execution.taskId,
-                    workingDirectory: execution.workingDirectory,
-                },
-            };
-            await this.appendLog(execution.id, initialLog);
-        }
-        catch (error) {
-            log.error(`Failed to start execution logging for ${execution.id}`, error, 'execution-log-persistence:startExecution');
-        }
-    }
-    /**
-     * Append a log entry
-     */
-    async appendLog(executionId, entry) {
-        try {
-            const executionDir = await this.findExecutionDir(executionId);
-            if (!executionDir)
-                return;
-            const logLine = JSON.stringify(entry) + '\n';
-            await fs.appendFile(path.join(executionDir, 'execution.log'), logLine);
-        }
-        catch (error) {
-            log.error(`Failed to append log for ${executionId}`, error, 'execution-log-persistence:appendLog');
-        }
-    }
-    /**
-     * Log a simple message
-     */
-    async logMessage(executionId, message, level = 'info', data) {
-        const entry = {
-            timestamp: new Date().toISOString(),
-            level,
-            message,
-            data,
-        };
-        await this.appendLog(executionId, entry);
-    }
-    /**
-     * Complete execution and update metadata
-     */
-    async completeExecution(executionId, status, error) {
-        try {
-            const executionDir = await this.findExecutionDir(executionId);
-            if (!executionDir)
-                return;
-            // Update metadata
-            const metadataPath = path.join(executionDir, 'metadata.json');
-            try {
-                const existingMetadata = JSON.parse(await fs.readFile(metadataPath, 'utf-8'));
-                existingMetadata.endTime = new Date().toISOString();
-                existingMetadata.status = status;
-                if (error)
-                    existingMetadata.error = error;
-                await fs.writeFile(metadataPath, JSON.stringify(existingMetadata, null, 2));
-            }
-            catch (metaError) {
-                log.error('Failed to update execution metadata', metaError, 'execution-log-persistence:completeExecution');
-            }
-            // Final log entry
-            const finalLog = {
-                timestamp: new Date().toISOString(),
-                level: status === 'completed' ? 'info' : 'error',
-                message: `Execution ${status}${error ? `: ${error}` : ''}`,
-                data: { executionId, status, error },
-            };
-            await this.appendLog(executionId, finalLog);
-            // Update index with status/endTime (best-effort)
-            try {
-                const metaPath = path.join(executionDir, 'metadata.json');
-                const md = JSON.parse(await fs.readFile(metaPath, 'utf-8'));
-                await this.indexDb.set(executionId, {
-                    executionId,
-                    taskId: md.taskId,
-                    workflowId: md.workflowId,
-                    status: md.status,
-                    startTime: md.startTime,
-                    endTime: md.endTime,
-                    dirPath: executionDir,
-                });
-            }
-            catch (error) {
-                log.error('Failed to update execution index on complete', error, 'execution-log-persistence:completeExecution');
-            }
-        }
-        catch (error) {
-            log.error(`Failed to complete execution logging for ${executionId}`, error, 'execution-log-persistence:completeExecution');
-        }
-    }
-    /**
-     * Read execution logs
-     */
-    async readExecutionLogs(executionId) {
-        try {
-            const executionDir = await this.findExecutionDir(executionId);
-            if (!executionDir) {
-                return { metadata: null, logs: [] };
-            }
-            // Read metadata
-            let metadata = null;
-            try {
-                const metadataContent = await fs.readFile(path.join(executionDir, 'metadata.json'), 'utf-8');
-                metadata = JSON.parse(metadataContent);
-            }
-            catch (error) {
-                if (error && error.code === 'ENOENT') {
-                    // Expected when metadata was pruned or not yet written; return null without error noise
-                    log.debug('Execution metadata not found (ENOENT)', { executionId, executionDir }, 'execution-log-persistence:readExecutionLogs');
-                    metadata = null;
-                }
-                else {
-                    log.error('Failed to read execution metadata', error, 'execution-log-persistence:readExecutionLogs');
-                }
-            }
-            // Read logs
-            const logs = [];
-            try {
-                const logContent = await fs.readFile(path.join(executionDir, 'execution.log'), 'utf-8');
-                for (const line of logContent.trim().split('\n')) {
-                    if (line) {
-                        try {
-                            logs.push(JSON.parse(line));
-                        }
-                        catch {
-                            // Skip malformed log lines
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                if (error && error.code === 'ENOENT') {
-                    // No log file yet; treat as empty without logging error
-                    log.debug('Execution log file not found (ENOENT)', { executionId, executionDir }, 'execution-log-persistence:readExecutionLogs');
-                }
-                else {
-                    log.error('Failed to read execution logs', error, 'execution-log-persistence:readExecutionLogs');
-                }
-            }
-            return { metadata, logs };
-        }
-        catch (error) {
-            log.error(`Failed to read execution logs for ${executionId}`, error, 'execution-log-persistence:readExecutionLogs');
-            return { metadata: null, logs: [] };
-        }
-    }
-    /**
-     * List all executions with metadata
-     */
-    async listExecutions() {
-        try {
-            await this.ensureLogsDir();
-            const executions = [];
-            // Iterate task directories and collect metadata
-            const taskDirs = await fs.readdir(this.logsDir, { withFileTypes: true });
-            for (const taskEntry of taskDirs) {
-                if (!taskEntry.isDirectory())
-                    continue;
-                const taskPath = path.join(this.logsDir, taskEntry.name);
-                let execDirs = [];
-                try {
-                    execDirs = await fs.readdir(taskPath, { withFileTypes: true });
-                }
-                catch {
-                    execDirs = [];
-                }
-                for (const ed of execDirs) {
-                    if (!ed.isDirectory())
-                        continue;
-                    try {
-                        const metadataPath = path.join(taskPath, ed.name, 'metadata.json');
-                        const metadata = JSON.parse(await fs.readFile(metadataPath, 'utf-8'));
-                        executions.push(metadata);
-                    }
-                    catch {
-                        // skip invalid dirs
-                    }
-                }
-            }
-            // Sort by start time (most recent first)
-            return executions.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
-        }
-        catch (error) {
-            log.error('Failed to list executions', error, 'execution-log-persistence:listExecutions');
-            return [];
-        }
-    }
-    /**
-     * Clean up old execution logs
-     */
-    async cleanupOldLogs(maxAgeDays = 30) {
-        try {
-            const executions = await this.listExecutions();
-            const cutoffTime = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
-            let removedCount = 0;
-            for (const execution of executions) {
-                const executionTime = new Date(execution.endTime || execution.startTime).getTime();
-                if (executionTime < cutoffTime &&
-                    ['completed', 'failed', 'cancelled'].includes(execution.status)) {
-                    const executionDir = await this.findExecutionDir(execution.executionId);
-                    if (executionDir) {
-                        try {
-                            await fs.rm(executionDir, { recursive: true, force: true });
-                            removedCount++;
-                            // Remove from index (non-throwing)
-                            await this.indexDb.delete(execution.executionId).catch(() => undefined);
-                        }
-                        catch (error) {
-                            log.error(`Failed to remove execution log directory ${executionDir}`, error, 'execution-log-persistence:cleanupOldLogs');
-                        }
-                    }
-                }
-            }
-            if (removedCount > 0) {
-                log.warn(`Cleaned up ${removedCount} old execution logs`, { removedCount, maxAgeDays }, 'execution-log-persistence:cleanupOldLogs');
-            }
-            return removedCount;
-        }
-        catch (error) {
-            log.error('Failed to cleanup old logs', error, 'execution-log-persistence:cleanupOldLogs');
-            return 0;
-        }
-    }
-    /**
-     * Remove execution logs for a specific task
-     */
-    async removeExecutionsByTask(taskId) {
-        try {
-            const executions = await this.listExecutions();
-            let removedCount = 0;
-            for (const execution of executions) {
-                if (execution.taskId === taskId) {
-                    const executionDir = await this.findExecutionDir(execution.executionId);
-                    if (executionDir) {
-                        try {
-                            await fs.rm(executionDir, { recursive: true, force: true });
-                            removedCount++;
-                            await this.indexDb.delete(execution.executionId).catch(() => undefined);
-                        }
-                        catch (error) {
-                            log.error(`Failed to remove execution log directory ${executionDir}`, error, 'execution-log-persistence:cleanupOldLogs');
-                        }
-                    }
-                }
-            }
-            if (removedCount > 0) {
-                log.warn(`Removed ${removedCount} execution logs for task ${taskId}`, { removedCount, taskId }, 'execution-log-persistence:removeExecutionsByTask');
-            }
-            return removedCount;
-        }
-        catch (error) {
-            log.error(`Failed to remove executions for task ${taskId}`, error, 'execution-log-persistence:removeExecutionsByTask');
-            return 0;
-        }
-    }
-    /**
-     * Get execution log statistics
-     */
-    async getStats() {
-        try {
-            const executions = await this.listExecutions();
-            const stats = {
-                total: executions.length,
-                byStatus: {},
-                totalLogFiles: executions.length,
-                oldestExecution: undefined,
-                newestExecution: undefined,
-            };
-            let oldest = null;
-            let newest = null;
-            for (const execution of executions) {
-                // Count by status
-                stats.byStatus[execution.status] = (stats.byStatus[execution.status] || 0) + 1;
-                // Find oldest/newest
-                const startTime = new Date(execution.startTime);
-                if (!oldest || startTime < oldest) {
-                    oldest = startTime;
-                    stats.oldestExecution = execution.executionId;
-                }
-                if (!newest || startTime > newest) {
-                    newest = startTime;
-                    stats.newestExecution = execution.executionId;
-                }
-            }
-            return stats;
-        }
-        catch (error) {
-            log.error('Failed to get execution log stats', error, 'execution-log-persistence:getStats');
-            return {
-                total: 0,
-                byStatus: {},
-                totalLogFiles: 0,
-            };
-        }
-    }
-}

package/dist/runtime/api/persistence/execution-log-persistence.test.d.ts

@@ -1 +0,0 @@
-export {};