vibeman 0.0.0 → 0.0.1

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

@@ -0,0 +1,11 @@
+import { createRouter } from '../../router.js';
+import { getTaskService } from '../server/task-service-singleton.js';
+import { getGitService } from '../server/git-service-singleton.js';
+import { getVibingOrchestrator, getVibingOrchestratorAsync, } from '../server/vibing-orchestrator-singleton.js';
+// Build the application router for use by the standalone API server.
+// Note: This module no longer starts any WebSocket servers automatically.
+// Runtime bootstrapping happens in the API server entrypoint.
+const taskService = getTaskService();
+const gitService = getGitService();
+const workflowOrchestrator = getVibingOrchestrator();
+export const appRouter = createRouter(taskService, gitService, workflowOrchestrator, getVibingOrchestratorAsync);

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,33 @@
+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: prefer explicit env; else (+1) from HTTP port
+    const httpPort = Number(process.env.PORT || 3000);
+    const wsPort = Number(process.env.NEXT_PUBLIC_VIBEMAN_WS_PORT || process.env.VIBEMAN_WS_PORT || 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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,410 @@
+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

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