vibeman 0.0.0 → 0.0.1

package/dist/runtime/api/tasks/file-watcher.js

@@ -0,0 +1,88 @@
+import path from 'path';
+import fs from 'fs';
+import { EventEmitter } from 'events';
+import { log } from '../lib/logger.js';
+export class FileWatcher extends EventEmitter {
+    constructor(watchDir, options = {}) {
+        super();
+        this.watcher = null;
+        this.pendingChanges = new Map();
+        this.watchDir = path.resolve(watchDir);
+        this.options = {
+            recursive: false,
+            debounceMs: 100,
+            fileFilter: () => true,
+            ...options,
+        };
+    }
+    start() {
+        if (this.watcher) {
+            return;
+        }
+        // Check if directory exists
+        if (!fs.existsSync(this.watchDir)) {
+            const error = new Error(`Watch directory does not exist: ${this.watchDir}`);
+            log.error('FileWatcher start failed', error, 'file-watcher');
+            this.emit('error', error);
+            return;
+        }
+        this.watcher = fs.watch(this.watchDir, { recursive: this.options.recursive }, (eventType, filename) => {
+            if (filename && this.options.fileFilter(filename)) {
+                this.debounceFileChange(filename);
+            }
+        });
+        log.debug('FileWatcher started', { watchDir: this.watchDir }, 'file-watcher');
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+            // Clear all pending timeouts
+            for (const timeout of this.pendingChanges.values()) {
+                clearTimeout(timeout);
+            }
+            this.pendingChanges.clear();
+            log.info('FileWatcher stopped', { watchDir: this.watchDir }, 'file-watcher');
+        }
+    }
+    debounceFileChange(filename) {
+        // Clear any existing timeout for this file
+        const existingTimeout = this.pendingChanges.get(filename);
+        if (existingTimeout) {
+            clearTimeout(existingTimeout);
+        }
+        // Set a new timeout to handle the change after a short delay
+        const timeout = setTimeout(() => {
+            this.handleFileChange(filename);
+            this.pendingChanges.delete(filename);
+        }, this.options.debounceMs);
+        this.pendingChanges.set(filename, timeout);
+    }
+    async handleFileChange(filename) {
+        const fullPath = path.join(this.watchDir, filename);
+        try {
+            const fileExists = await this.fileExists(fullPath);
+            const changeType = fileExists ? 'updated' : 'deleted';
+            const event = {
+                type: changeType,
+                filename,
+                fullPath,
+            };
+            this.emit('fileChanged', event);
+            log.debug(`File ${changeType}: ${filename}`, { filename, fullPath, type: changeType }, 'file-watcher');
+        }
+        catch (error) {
+            log.error(`Error processing file change for ${filename}`, error, 'file-watcher');
+            this.emit('error', error);
+        }
+    }
+    async fileExists(filePath) {
+        try {
+            await fs.promises.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/runtime/api/tasks/task-file-parser.d.ts

@@ -0,0 +1,13 @@
+import { Task } from '../types/index.js';
+export declare class TaskFileParser {
+    private baseDir;
+    constructor(baseDir: string);
+    parseFile(filePath: string): Promise<Task | null>;
+    parseDirectory(dirPath?: string): Promise<Task[]>;
+    parseContent(content: string, filePath?: string): Promise<Task | null>;
+    private getFileStats;
+    writeTask(task: Task): Promise<void>;
+    deleteTask(taskId: string): Promise<void>;
+    generateFilePath(task: Task): string;
+    generateFilePathFromId(taskId: string): string;
+}

package/dist/runtime/api/tasks/task-file-parser.js

@@ -0,0 +1,161 @@
+import fs from 'fs/promises';
+import path from 'path';
+import matter from 'gray-matter';
+import { log } from '../lib/logger.js';
+export class TaskFileParser {
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    async parseFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            return await this.parseContent(content, filePath);
+        }
+        catch (error) {
+            log.error(`Error reading file ${filePath}`, error, 'task-file-parser:parseFile');
+            return null;
+        }
+    }
+    async parseDirectory(dirPath) {
+        const targetDir = dirPath || this.baseDir;
+        try {
+            const files = await fs.readdir(targetDir);
+            const markdownFiles = files.filter((file) => file.endsWith('.md'));
+            const tasks = [];
+            for (const file of markdownFiles) {
+                const filePath = path.join(targetDir, file);
+                const task = await this.parseFile(filePath);
+                if (task) {
+                    tasks.push(task);
+                }
+            }
+            // Sort by ID for consistent ordering
+            return tasks.sort((a, b) => a.id.localeCompare(b.id));
+        }
+        catch (error) {
+            log.error(`Error reading directory ${targetDir}`, error, 'task-file-parser:parseDirectory');
+            return [];
+        }
+    }
+    async parseContent(content, filePath) {
+        try {
+            const parsed = matter(content);
+            const metadata = parsed.data;
+            // Validate required fields
+            if (!metadata.id || !metadata.title || !metadata.type || !metadata.status) {
+                log.error(`Invalid task metadata in ${filePath}`, { metadata, filePath }, 'task-file-parser:parseContent');
+                return null;
+            }
+            // Validate enum values
+            const validTypes = ['feature', 'bug', 'chore', 'refactor', 'test', 'doc'];
+            const validStatuses = ['backlog', 'in-progress', 'review', 'done'];
+            const validPriorities = ['low', 'medium', 'high'];
+            if (!validTypes.includes(metadata.type)) {
+                log.error(`Invalid task type '${metadata.type}' in ${filePath}`, { type: metadata.type, filePath, validTypes }, 'task-file-parser:parseContent');
+                return null;
+            }
+            if (!validStatuses.includes(metadata.status)) {
+                log.error(`Invalid task status '${metadata.status}' in ${filePath}`, { status: metadata.status, filePath, validStatuses }, 'task-file-parser:parseContent');
+                return null;
+            }
+            if (metadata.priority && !validPriorities.includes(metadata.priority)) {
+                log.error(`Invalid task priority '${metadata.priority}' in ${filePath}`, { priority: metadata.priority, filePath, validPriorities }, 'task-file-parser:parseContent');
+                return null;
+            }
+            const now = new Date().toISOString();
+            const stats = filePath ? await this.getFileStats(filePath) : null;
+            const task = {
+                id: metadata.id,
+                title: metadata.title,
+                type: metadata.type,
+                status: metadata.status,
+                tags: Array.isArray(metadata.tags) ? metadata.tags : [],
+                due_date: metadata.due_date
+                    ? metadata.due_date instanceof Date
+                        ? metadata.due_date.toISOString().split('T')[0]
+                        : String(metadata.due_date)
+                    : undefined,
+                assignee: Array.isArray(metadata.assignee)
+                    ? metadata.assignee
+                    : metadata.assignee
+                        ? [metadata.assignee]
+                        : [],
+                priority: metadata.priority || 'medium',
+                comments: Array.isArray(metadata.comments)
+                    ? metadata.comments
+                    : metadata.comments
+                        ? [metadata.comments]
+                        : [],
+                deleted_at: metadata.deleted_at ? String(metadata.deleted_at) : undefined,
+                content: parsed.content.trim(),
+                created_at: stats?.birthtime && !isNaN(stats.birthtime.getTime())
+                    ? stats.birthtime.toISOString()
+                    : now,
+                updated_at: stats?.mtime && !isNaN(stats.mtime.getTime()) ? stats.mtime.toISOString() : now,
+            };
+            return task;
+        }
+        catch (error) {
+            log.error(`Error parsing task content from ${filePath}`, error, 'task-file-parser:parseContent');
+            return null;
+        }
+    }
+    async getFileStats(filePath) {
+        try {
+            return await fs.stat(filePath);
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeTask(task) {
+        const filePath = this.generateFilePath(task);
+        const frontMatter = {
+            id: task.id,
+            title: task.title,
+            type: task.type,
+            status: task.status,
+            tags: task.tags.join(', ') || '',
+            due_date: task.due_date || '',
+            assignee: task.assignee?.join(', ') || '',
+            priority: task.priority,
+            comments: task.comments?.join(', ') || '',
+            deleted_at: task.deleted_at || '',
+        };
+        // Compose the file so there is always exactly one blank line
+        // between the front matter and the content body.
+        // 1) Build only front matter
+        let fmOnly = matter.stringify('', frontMatter);
+        // 2) Normalize trailing newlines on FM to exactly one
+        fmOnly = fmOnly.replace(/\n*$/, '\n');
+        // 3) Normalize leading newlines on body
+        const body = (task.content || '').replace(/^[\r\n]+/, '');
+        // 4) Join with exactly one extra newline to create a single blank line
+        const fileContent = body ? fmOnly + '\n' + body : fmOnly;
+        try {
+            await fs.writeFile(filePath, fileContent, 'utf-8');
+        }
+        catch (error) {
+            log.error(`Error writing task file ${filePath}`, error, 'task-file-parser:writeTask');
+            throw error;
+        }
+    }
+    async deleteTask(taskId) {
+        const filePath = this.generateFilePathFromId(taskId);
+        try {
+            await fs.unlink(filePath);
+        }
+        catch (error) {
+            log.error(`Error deleting task file ${filePath}`, error, 'task-file-parser:deleteTask');
+            throw error;
+        }
+    }
+    generateFilePath(task) {
+        const fileName = `${task.id}.md`;
+        return path.join(this.baseDir, fileName);
+    }
+    generateFilePathFromId(taskId) {
+        const fileName = `${taskId}.md`;
+        return path.join(this.baseDir, fileName);
+    }
+}

package/dist/runtime/api/tasks/task-service.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter } from 'events';
+import { Task } from '../types/index.js';
+export declare class TaskService extends EventEmitter {
+    private tasks;
+    private fileWatcher;
+    private taskParser;
+    private tasksDir;
+    private initialized;
+    constructor(vibeDir: string);
+    private handleFileChange;
+    private extractTaskIdFromFilename;
+    initialize(): Promise<void>;
+    ensureInitialized(): Promise<void>;
+    stop(): void;
+    getAllTasks(): Task[];
+    getActiveTasks(): Task[];
+    getTask(id: string): Task | undefined;
+    getTasksByStatus(status: Task['status']): Task[];
+    getTasksByType(type: Task['type']): Task[];
+    searchTasks(query: string): Task[];
+    createTask(taskData: Omit<Task, 'id' | 'created_at' | 'updated_at'> & {
+        id?: string;
+    }): Promise<Task>;
+    updateTask(id: string, updates: Partial<Task>): Promise<Task>;
+    deleteTask(id: string): Promise<void>;
+    moveTask(id: string, newStatus: Task['status']): Promise<Task>;
+    getTaskStats(): {
+        total: number;
+        backlog: number;
+        'in-progress': number;
+        review: number;
+        done: number;
+        byType: Record<Task["type"], number>;
+        byPriority: Record<Task["priority"], number>;
+    };
+}

package/dist/runtime/api/tasks/task-service.js

@@ -0,0 +1,173 @@
+import { EventEmitter } from 'events';
+import { FileWatcher } from './file-watcher.js';
+import { TaskFileParser } from './task-file-parser.js';
+import { generateHumanTaskId } from '../utils/title-slug.js';
+import { log } from '../lib/logger.js';
+import fs from 'fs/promises';
+export class TaskService extends EventEmitter {
+    constructor(vibeDir) {
+        super();
+        this.tasks = new Map();
+        this.initialized = false;
+        this.tasksDir = `${vibeDir}/tasks`;
+        this.fileWatcher = new FileWatcher(this.tasksDir, {
+            fileFilter: (filename) => filename.endsWith('.md'),
+        });
+        this.taskParser = new TaskFileParser(this.tasksDir);
+        this.fileWatcher.on('fileChanged', async (event) => {
+            try {
+                await this.handleFileChange(event);
+            }
+            catch (error) {
+                log.error('Error handling file change', error, 'task-service');
+                this.emit('error', error);
+            }
+        });
+        this.fileWatcher.on('error', (error) => {
+            log.error('FileWatcher error', error, 'task-service');
+            this.emit('error', error);
+        });
+    }
+    async handleFileChange(event) {
+        const { type, filename, fullPath } = event;
+        if (type === 'deleted') {
+            const taskId = this.extractTaskIdFromFilename(filename);
+            if (taskId && this.tasks.has(taskId)) {
+                this.tasks.delete(taskId);
+                this.emit('taskDeleted', taskId);
+                log.info('Task deleted', { taskId }, 'task-service');
+            }
+        }
+        else {
+            // File exists, parse and update
+            const task = await this.taskParser.parseFile(fullPath);
+            if (task) {
+                this.tasks.set(task.id, task);
+                this.emit('taskUpdated', task);
+                log.info(`Task updated from file change: ${task.id}`, { taskId: task.id, filename }, 'task-service');
+            }
+            else {
+                log.warn(`Failed to parse task from ${filename}`, { filename }, 'task-service');
+            }
+        }
+    }
+    extractTaskIdFromFilename(filename) {
+        // Use the basename (without extension) as ID, supports multi-hyphen IDs
+        return filename.endsWith('.md') ? filename.slice(0, -3) : null;
+    }
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        // Ensure directories exist
+        await fs.mkdir(this.tasksDir, { recursive: true });
+        // Load existing tasks
+        const tasks = await this.taskParser.parseDirectory();
+        for (const task of tasks) {
+            this.tasks.set(task.id, task);
+        }
+        // Start file watcher
+        this.fileWatcher.start();
+        this.initialized = true;
+    }
+    async ensureInitialized() {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+    }
+    stop() {
+        this.fileWatcher.stop();
+        this.tasks.clear();
+        this.initialized = false;
+        log.info('Task Service stopped', undefined, 'task-service');
+    }
+    // Task CRUD operations
+    getAllTasks() {
+        return Array.from(this.tasks.values());
+    }
+    // Get all non-deleted tasks (excludes soft-deleted tasks)
+    getActiveTasks() {
+        return Array.from(this.tasks.values()).filter((task) => !task.deleted_at);
+    }
+    getTask(id) {
+        return this.tasks.get(id);
+    }
+    getTasksByStatus(status) {
+        return this.getAllTasks().filter((task) => task.status === status);
+    }
+    getTasksByType(type) {
+        return this.getAllTasks().filter((task) => task.type === type);
+    }
+    searchTasks(query) {
+        const searchTerm = query.toLowerCase();
+        return this.getAllTasks().filter((task) => task.title.toLowerCase().includes(searchTerm) ||
+            task.content.toLowerCase().includes(searchTerm) ||
+            task.tags.some((tag) => tag.toLowerCase().includes(searchTerm)));
+    }
+    async createTask(taskData) {
+        const now = new Date().toISOString();
+        // Generate human-readable ID if not provided
+        const id = taskData.id ||
+            generateHumanTaskId(taskData.type, taskData.title, Array.from(this.tasks.keys()));
+        const task = {
+            ...taskData,
+            id,
+            created_at: now,
+            updated_at: now,
+        };
+        // Write to file system (watcher will update memory)
+        await this.taskParser.writeTask(task);
+        return task;
+    }
+    async updateTask(id, updates) {
+        const existingTask = this.tasks.get(id);
+        if (!existingTask) {
+            throw new Error(`Task ${id} not found`);
+        }
+        const updatedTask = {
+            ...existingTask,
+            ...updates,
+            id, // Ensure ID cannot be changed
+            updated_at: new Date().toISOString(),
+        };
+        // Write to file system (watcher will update memory)
+        await this.taskParser.writeTask(updatedTask);
+        return updatedTask;
+    }
+    async deleteTask(id) {
+        const existingTask = this.tasks.get(id);
+        if (!existingTask) {
+            throw new Error(`Task ${id} not found`);
+        }
+        // Soft delete: mark deleted_at and write file
+        const softDeleted = {
+            ...existingTask,
+            deleted_at: new Date().toISOString(),
+        };
+        await this.taskParser.writeTask(softDeleted);
+        // Update in-memory map and emit update event for subscribers
+        this.tasks.set(id, softDeleted);
+        this.emit('taskUpdated', softDeleted);
+    }
+    async moveTask(id, newStatus) {
+        return this.updateTask(id, { status: newStatus });
+    }
+    getTaskStats() {
+        const tasks = this.getAllTasks();
+        const stats = {
+            total: tasks.length,
+            backlog: 0,
+            'in-progress': 0,
+            review: 0,
+            done: 0,
+            byType: {},
+            byPriority: {},
+        };
+        for (const task of tasks) {
+            stats[task.status]++;
+            stats.byType[task.type] = (stats.byType[task.type] || 0) + 1;
+            stats.byPriority[task.priority] = (stats.byPriority[task.priority] || 0) + 1;
+        }
+        return stats;
+    }
+}

package/dist/runtime/api/types/index.d.ts

@@ -0,0 +1,179 @@
+import type { VibingStatus, VibingStage } from '@vibeman/types';
+export interface Task {
+    id: string;
+    title: string;
+    type: 'feature' | 'bug' | 'chore' | 'refactor' | 'test' | 'doc';
+    status: 'backlog' | 'in-progress' | 'review' | 'done';
+    tags: string[];
+    due_date?: string;
+    assignee?: string[];
+    priority: 'low' | 'medium' | 'high';
+    comments?: string[];
+    content: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+}
+export interface TaskMetadata {
+    id: string;
+    title: string;
+    type: Task['type'];
+    status: Task['status'];
+    tags: string[];
+    due_date?: string | Date;
+    assignee?: string[];
+    priority: Task['priority'];
+    comments?: string[];
+    deleted_at?: string;
+}
+export interface ServerConfig {
+    port: number;
+    host: string;
+    vibeDir: string;
+    tasksDir: string;
+}
+export interface ExecutionLog {
+    id: string;
+    taskId: string;
+    timestamp: string;
+    level: 'info' | 'warn' | 'error';
+    message: string;
+    data?: Record<string, unknown>;
+}
+export interface AgentExecution {
+    id: string;
+    taskId: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    startTime: string;
+    endTime?: string;
+    logs: string[];
+    error?: string;
+    provider?: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        cost?: number;
+    };
+    worktree?: WorktreeInfo;
+    workingDirectory: string;
+}
+export interface WorktreeInfo {
+    taskId: string;
+    path: string;
+    branchName: string;
+}
+export interface WorktreeConfig {
+    worktreePath: string;
+}
+export interface TaskImprovementRequest {
+    taskId: string;
+    title: string;
+    type: Task['type'];
+    priority: Task['priority'];
+    content: string;
+}
+export interface TaskImprovementResponse {
+    type: Task['type'];
+    priority: Task['priority'];
+    content: string;
+    executionId: string;
+}
+export type VibingPhase = VibingStatus | VibingStage;
+export interface VibingExecution {
+    id: string;
+    taskId: string;
+    phase: VibingPhase;
+    startTime: string;
+    endTime?: string;
+    status?: VibingStatus;
+    lastPhase?: VibingPhase;
+    phaseHistory?: Array<{
+        from: VibingPhase;
+        to: VibingPhase;
+        at: string;
+        reason?: string;
+    }>;
+    failureContext?: {
+        atPhase: VibingPhase;
+        error?: string;
+        timestamp: string;
+    };
+    executionIds?: Partial<Record<VibingPhase, string[]>>;
+    attempts?: Partial<Record<VibingPhase, number>>;
+    rerunContextHistory?: Array<{
+        at: string;
+        phase: VibingPhase;
+        reason: string;
+        attempt: number;
+        previousExecutionId?: string;
+    }>;
+    qualityResults?: QualityResults;
+    links?: {
+        prUrl?: string;
+        prNumber?: number;
+        branchName?: string;
+        baseBranch?: string;
+    };
+    error?: string;
+    metrics?: {
+        durationsMs: Partial<Record<VibingPhase, number>>;
+        totalDurationMs?: number;
+        lastPhaseStartedAt?: string;
+    };
+    lastUpdatedAt?: string;
+    metadata: VibingConfig;
+    timeline?: Array<{
+        id: string;
+        label: string;
+        phase: VibingPhase;
+        attempt?: number;
+        executionId?: string;
+        startTime: string;
+        endTime?: string;
+        reason?: string;
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+            cost?: number;
+        };
+    }>;
+}
+export interface QualityResults {
+    overall: boolean;
+    timestamp: string;
+    details: Record<string, boolean>;
+    outputs: Record<string, string>;
+}
+export interface VibingConfig {
+    autoQualityChecks: boolean;
+    requireHumanApproval: boolean;
+    stepByStepMode?: boolean;
+    retryPolicy?: {
+        maxImplementationAttempts: number;
+    };
+    autoCommit?: boolean;
+    createPR?: boolean;
+    autoMerge?: boolean;
+    aiCodeReview?: boolean;
+    qualityChecks?: Array<{
+        name: string;
+        command: string;
+        args?: string[];
+        timeout?: number;
+        enabled?: boolean;
+    }>;
+    aiRoutingOverrides?: Partial<Record<'execute_task' | 'improve_task' | 'ai_codereview' | 'ai_merge', {
+        provider?: string;
+        model?: string;
+    }>>;
+    aiReviewResult?: {
+        executionId: string;
+        reviewSummary: string;
+        recommendations: string[];
+        qualityScore: number;
+        timestamp?: string;
+    };
+}
+export type { VibingStage, VibingStatus, LegacyVibingPhase, VibingWorkflowV2, StageToStatusMapping, } from '@vibeman/types';

package/dist/runtime/api/types/index.js

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