vibeman 0.0.3 → 0.0.6

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

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

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

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

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

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

@@ -1,186 +0,0 @@
-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;
-    aiReviewResult?: {
-        executionId: string;
-        reviewSummary: string;
-        recommendations: string[];
-        qualityScore: number;
-        timestamp?: string;
-    };
-    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' | 'quality_checks' | 'ai_codereview' | 'ai_merge' | 'improve_task', {
-        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

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