profclaw 0.0.1-beta.1

package/dist/queue/memory-queue.js

@@ -0,0 +1,429 @@
+/**
+ * In-Memory Task Queue
+ *
+ * Drop-in replacement for BullMQ task queue in pico/mini modes.
+ * Uses a Map-based FIFO with priority ordering. No Redis required.
+ * Persists tasks to the same SQLite storage as the BullMQ queue.
+ */
+import { randomUUID } from 'crypto';
+import { logger } from '../utils/logger.js';
+import { getStorage, initStorage } from '../storage/index.js';
+import { getConcurrency } from '../core/deployment.js';
+// Lazy-loaded heavy modules (deferred to first task execution for lower cold-start footprint)
+async function lazyGetAgentRegistry() {
+    const { getAgentRegistry } = await import('../adapters/registry.js');
+    return getAgentRegistry();
+}
+async function lazyPostResultToSource(task, result) {
+    const { postResultToSource } = await import('./notifications.js');
+    return postResultToSource(task, result);
+}
+async function lazyCreateTaskNotification(event) {
+    const { createTaskNotification } = await import('../notifications/in-app.js');
+    return createTaskNotification(event);
+}
+async function lazyExtractAndSummarize(result, meta) {
+    const { extractFromTaskResult, createSummary } = await import('../summaries/index.js');
+    const summaryInput = await extractFromTaskResult(result, meta);
+    await createSummary(summaryInput);
+}
+import { handleTaskFailure, initDeadLetterQueue, } from './failure-handler.js';
+// Task store (cache, synced with DB)
+const taskStore = new Map();
+const eventCallbacks = new Map();
+// Processing state
+let processing = false;
+let activeCount = 0;
+let maxConcurrency = 1;
+let pollInterval = null;
+let evictionInterval = null;
+// Task eviction settings (prevent unbounded memory growth)
+const TASK_EVICTION_TTL_MS = parseInt(process.env['TASK_EVICTION_TTL_MS'] ?? '3600000', 10); // 1 hour
+const TASK_EVICTION_INTERVAL_MS = 300000; // 5 minutes
+const TASK_LOAD_MAX_AGE_MS = 86400000; // 24 hours - only load recent tasks from DB
+function ensureDate(value) {
+    if (!value)
+        return undefined;
+    if (value instanceof Date)
+        return value;
+    return new Date(value);
+}
+async function persistTask(task) {
+    try {
+        const storage = getStorage();
+        const taskWithDates = {
+            ...task,
+            createdAt: ensureDate(task.createdAt) || new Date(),
+            updatedAt: ensureDate(task.updatedAt) || new Date(),
+            startedAt: ensureDate(task.startedAt),
+            completedAt: ensureDate(task.completedAt),
+        };
+        const existing = await storage.getTask(task.id);
+        if (existing) {
+            await storage.updateTask(task.id, taskWithDates);
+        }
+        else {
+            await storage.createTask(taskWithDates);
+        }
+    }
+    catch (error) {
+        logger.error('[MemQueue] Failed to persist task to DB:', {
+            taskId: task.id,
+            error,
+        });
+    }
+}
+async function loadTasksFromDB() {
+    try {
+        const storage = getStorage();
+        const { tasks } = await storage.getTasks({ limit: 10000 });
+        const loadCutoff = Date.now() - TASK_LOAD_MAX_AGE_MS;
+        let loaded = 0;
+        for (const task of tasks) {
+            // Only load active tasks or recently updated tasks to bound startup memory
+            const isActive = task.status === 'pending' || task.status === 'queued' ||
+                task.status === 'in_progress' || task.status === 'assigned';
+            const updatedAt = task.updatedAt instanceof Date
+                ? task.updatedAt.getTime()
+                : new Date(task.updatedAt).getTime();
+            if (isActive || updatedAt > loadCutoff) {
+                taskStore.set(task.id, task);
+                loaded++;
+            }
+        }
+        logger.info(`[MemQueue] Loaded ${loaded} tasks from database (${tasks.length - loaded} older tasks skipped)`);
+    }
+    catch (error) {
+        logger.warn('[MemQueue] Failed to load tasks from DB, starting fresh:', {
+            error,
+        });
+    }
+}
+// SSE broadcast callback
+let sseBroadcaster = null;
+function emitEvent(event) {
+    for (const callback of eventCallbacks.values()) {
+        try {
+            callback(event);
+        }
+        catch (error) {
+            console.error('[MemQueue] Error in event callback:', error);
+        }
+    }
+    if (sseBroadcaster) {
+        try {
+            sseBroadcaster(`task:${event.type}`, {
+                taskId: event.taskId,
+                task: {
+                    id: event.task.id,
+                    title: event.task.title,
+                    status: event.task.status,
+                    priority: event.task.priority,
+                    source: event.task.source,
+                    assignedAgent: event.task.assignedAgent,
+                    createdAt: event.task.createdAt,
+                    startedAt: event.task.startedAt,
+                    completedAt: event.task.completedAt,
+                },
+                result: event.result
+                    ? {
+                        success: event.result.success,
+                        error: event.result.error?.message,
+                    }
+                    : undefined,
+                progress: event.progress,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            console.error('[MemQueue] Error broadcasting SSE event:', error);
+        }
+    }
+    if (event.type === 'completed' || event.type === 'failed') {
+        lazyCreateTaskNotification(event).then((id) => {
+            if (id && sseBroadcaster)
+                sseBroadcaster('notification:new', { id });
+        }).catch(console.error);
+    }
+}
+/**
+ * Process a single task (same logic as BullMQ worker).
+ */
+async function processTask(task) {
+    console.log(`[MemQueue] Processing task ${task.id}: ${task.title}`);
+    task.status = 'in_progress';
+    task.startedAt = new Date();
+    task.attempts += 1;
+    taskStore.set(task.id, task);
+    persistTask(task);
+    emitEvent({ type: 'started', taskId: task.id, task });
+    const registry = await lazyGetAgentRegistry();
+    const adapter = registry.findAdapterForTask(task);
+    if (!adapter) {
+        const result = {
+            success: false,
+            output: 'No suitable agent adapter found for task',
+            error: { code: 'NO_ADAPTER', message: 'No suitable agent adapter found for task' },
+        };
+        task.status = 'failed';
+        task.completedAt = new Date();
+        task.result = result;
+        taskStore.set(task.id, task);
+        await persistTask(task);
+        emitEvent({ type: 'failed', taskId: task.id, task, result });
+        return result;
+    }
+    console.log(`[MemQueue] Using adapter: ${adapter.name}`);
+    try {
+        const result = await adapter.executeTask(task);
+        task.result = result;
+        if (result.success) {
+            task.status = 'completed';
+            task.completedAt = new Date();
+            taskStore.set(task.id, task);
+            await persistTask(task);
+            // Create summary
+            try {
+                await lazyExtractAndSummarize(result, {
+                    taskId: task.id,
+                    agent: adapter.type,
+                    model: result.metadata?.model,
+                    startedAt: task.startedAt,
+                });
+            }
+            catch (error) {
+                logger.error(`[MemQueue] Failed to create summary for task ${task.id}:`, error);
+            }
+            // Post results back to source
+            try {
+                await lazyPostResultToSource(task, result);
+            }
+            catch (error) {
+                logger.error(`[MemQueue] Failed to post result to source for task ${task.id}:`, error);
+            }
+            emitEvent({ type: 'completed', taskId: task.id, task, result });
+        }
+        else {
+            // Handle failure with retry logic
+            if (task.attempts < task.maxAttempts) {
+                task.status = 'queued';
+                taskStore.set(task.id, task);
+                await persistTask(task);
+                console.log(`[MemQueue] Task ${task.id} failed, retrying (${task.attempts}/${task.maxAttempts})`);
+            }
+            else {
+                task.status = 'failed';
+                task.completedAt = new Date();
+                taskStore.set(task.id, task);
+                await persistTask(task);
+                emitEvent({ type: 'failed', taskId: task.id, task, result });
+                // Send to DLQ
+                try {
+                    await handleTaskFailure(task, new Error(result.error?.message || 'Task failed'));
+                }
+                catch (dlqError) {
+                    logger.error(`[MemQueue] DLQ error for task ${task.id}:`, dlqError);
+                }
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        const result = {
+            success: false,
+            output: `Task execution failed: ${errorMessage}`,
+            error: { code: 'EXECUTION_ERROR', message: errorMessage },
+        };
+        if (task.attempts < task.maxAttempts) {
+            task.status = 'queued';
+            taskStore.set(task.id, task);
+            await persistTask(task);
+            console.log(`[MemQueue] Task ${task.id} errored, retrying (${task.attempts}/${task.maxAttempts})`);
+        }
+        else {
+            task.status = 'failed';
+            task.completedAt = new Date();
+            task.result = result;
+            taskStore.set(task.id, task);
+            await persistTask(task);
+            emitEvent({ type: 'failed', taskId: task.id, task, result });
+            try {
+                await handleTaskFailure(task, new Error(errorMessage));
+            }
+            catch (dlqError) {
+                logger.error(`[MemQueue] DLQ error for task ${task.id}:`, dlqError);
+            }
+        }
+        return result;
+    }
+}
+/**
+ * Process the next queued task if capacity allows.
+ */
+async function processNext() {
+    if (activeCount >= maxConcurrency)
+        return;
+    // Find next queued task by priority (lower number = higher priority)
+    const queued = Array.from(taskStore.values())
+        .filter(t => t.status === 'queued')
+        .sort((a, b) => a.priority - b.priority);
+    if (queued.length === 0)
+        return;
+    const task = queued[0];
+    activeCount++;
+    try {
+        await processTask(task);
+    }
+    finally {
+        activeCount--;
+        // Check for more work
+        processNext().catch(console.error);
+    }
+}
+/**
+ * Evict completed/failed/cancelled tasks older than the configured TTL
+ * to prevent unbounded memory growth in long-running instances.
+ */
+function evictStaleTasks() {
+    const cutoff = Date.now() - TASK_EVICTION_TTL_MS;
+    let evicted = 0;
+    for (const [id, task] of taskStore) {
+        if (task.status === 'completed' || task.status === 'failed' || task.status === 'cancelled') {
+            const updatedAt = task.updatedAt instanceof Date
+                ? task.updatedAt.getTime()
+                : new Date(task.updatedAt).getTime();
+            if (updatedAt < cutoff) {
+                taskStore.delete(id);
+                evicted++;
+            }
+        }
+    }
+    if (evicted > 0) {
+        logger.info(`[MemQueue] Evicted ${evicted} stale tasks (store size: ${taskStore.size})`);
+    }
+}
+// -- Exported interface (matches task-queue.ts) --
+export async function initTaskQueue() {
+    await initStorage();
+    await loadTasksFromDB();
+    await initDeadLetterQueue();
+    maxConcurrency = getConcurrency();
+    processing = true;
+    // Poll for queued tasks every 500ms
+    pollInterval = setInterval(() => {
+        if (processing) {
+            processNext().catch(console.error);
+        }
+    }, 500);
+    // Periodic eviction of completed/failed tasks to bound memory
+    evictionInterval = setInterval(evictStaleTasks, TASK_EVICTION_INTERVAL_MS);
+    console.log(`[MemQueue] In-memory queue initialized (concurrency: ${maxConcurrency})`);
+}
+export async function addTask(input) {
+    const task = {
+        ...input,
+        labels: input.labels ?? [],
+        metadata: input.metadata ?? {},
+        id: randomUUID(),
+        status: 'pending',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        attempts: 0,
+        maxAttempts: 3,
+    };
+    taskStore.set(task.id, task);
+    await persistTask(task);
+    emitEvent({ type: 'created', taskId: task.id, task });
+    // Queue immediately
+    task.status = 'queued';
+    taskStore.set(task.id, task);
+    await persistTask(task);
+    emitEvent({ type: 'queued', taskId: task.id, task });
+    console.log(`[MemQueue] Task ${task.id} added to queue`);
+    // Trigger processing
+    processNext().catch(console.error);
+    return task;
+}
+export function getTask(id) {
+    return taskStore.get(id);
+}
+export function getTasks(options) {
+    let tasks = Array.from(taskStore.values());
+    if (options?.status) {
+        tasks = tasks.filter(t => t.status === options.status);
+    }
+    tasks.sort((a, b) => {
+        const dateA = a.createdAt instanceof Date ? a.createdAt.getTime() : new Date(a.createdAt).getTime();
+        const dateB = b.createdAt instanceof Date ? b.createdAt.getTime() : new Date(b.createdAt).getTime();
+        return dateB - dateA;
+    });
+    const offset = options?.offset || 0;
+    const limit = options?.limit || 50;
+    return tasks.slice(offset, offset + limit);
+}
+export function onTaskEvent(callback) {
+    const id = randomUUID();
+    eventCallbacks.set(id, callback);
+    return () => eventCallbacks.delete(id);
+}
+export function registerSSEBroadcaster(broadcaster) {
+    sseBroadcaster = broadcaster;
+}
+export async function cancelTask(id) {
+    const task = taskStore.get(id);
+    if (!task)
+        return false;
+    const cancellableStatuses = ['pending', 'queued', 'assigned', 'in_progress'];
+    if (!cancellableStatuses.includes(task.status))
+        return false;
+    task.status = 'cancelled';
+    task.completedAt = new Date();
+    task.result = {
+        success: false,
+        output: 'Task was cancelled by user',
+        error: { code: 'CANCELLED', message: 'Task cancelled by user' },
+    };
+    taskStore.set(id, task);
+    await persistTask(task);
+    emitEvent({ type: 'failed', taskId: id, task });
+    return true;
+}
+export async function retryTask(id) {
+    const task = taskStore.get(id);
+    if (!task)
+        return null;
+    const retryableStatuses = ['failed', 'cancelled', 'completed'];
+    if (!retryableStatuses.includes(task.status))
+        return null;
+    const newTask = await addTask({
+        title: task.title,
+        description: task.description,
+        prompt: task.prompt,
+        priority: task.priority,
+        source: task.source,
+        sourceId: task.sourceId,
+        sourceUrl: task.sourceUrl,
+        repository: task.repository,
+        branch: task.branch,
+        labels: task.labels,
+        metadata: {
+            ...task.metadata,
+            retriedFrom: id,
+        },
+    });
+    return newTask;
+}
+export async function closeTaskQueue() {
+    processing = false;
+    if (pollInterval) {
+        clearInterval(pollInterval);
+        pollInterval = null;
+    }
+    if (evictionInterval) {
+        clearInterval(evictionInterval);
+        evictionInterval = null;
+    }
+    console.log('[MemQueue] In-memory queue closed');
+}
+//# sourceMappingURL=memory-queue.js.map

package/dist/queue/notifications.d.ts

@@ -0,0 +1,6 @@
+import type { Task, TaskResult } from '../types/task.js';
+/**
+ * Post task result back to the source
+ */
+export declare function postResultToSource(task: Task, result: TaskResult): Promise<void>;
+//# sourceMappingURL=notifications.d.ts.map

package/dist/queue/notifications.js

@@ -0,0 +1,128 @@
+import { GitHubClient } from '../integrations/github-client.js';
+import { JiraClient } from '../integrations/jira-client.js';
+import { LinearClient } from '../integrations/linear-client.js';
+import { getTaskSummaries } from '../summaries/storage.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Post task result back to the source
+ */
+export async function postResultToSource(task, result) {
+    const summaries = await getTaskSummaries(task.id);
+    const summary = summaries[0] || null;
+    const body = buildNotificationBody(summary, result);
+    if (task.source === 'github_issue' || task.source === 'github_pr') {
+        await postGitHubComment(task, body);
+    }
+    else if (task.source === 'jira') {
+        await postJiraComment(task, body);
+    }
+    else if (task.source === 'linear_issue' || task.source === 'linear_comment') {
+        await postLinearComment(task, body);
+    }
+}
+/**
+ * Build a structured notification body from a summary or raw result
+ */
+function buildNotificationBody(summary, result) {
+    let body = '';
+    if (summary) {
+        // Build a rich comment from the structured summary
+        body = `## 🤖 AI Transformation Complete: ${summary.title}\n\n`;
+        body += `**Status:** ${result.success ? '✅ Success' : '❌ Failed'}\n\n`;
+        body += `### 📝 What Changed\n${summary.whatChanged}\n\n`;
+        if (summary.whyChanged) {
+            body += `### 🎯 Rationale\n${summary.whyChanged}\n\n`;
+        }
+        if (summary.filesChanged && summary.filesChanged.length > 0) {
+            body += `### 📂 Files Modified\n`;
+            summary.filesChanged.forEach(f => {
+                const icon = f.action === 'created' ? '🆕' : f.action === 'deleted' ? '🗑️' : '📝';
+                body += `- ${icon} \`${f.path}\`\n`;
+            });
+            body += '\n';
+        }
+        if (summary.decisions && summary.decisions.length > 0) {
+            body += `### 💡 Key Decisions\n`;
+            summary.decisions.forEach(d => body += `- ${d.description}${d.reason ? ` (${d.reason})` : ''}\n`);
+            body += '\n';
+        }
+        if (summary.artifacts && summary.artifacts.length > 0) {
+            body += `### 📦 Artifacts\n`;
+            summary.artifacts.forEach(a => {
+                const link = a.url ? `([link](${a.url}))` : '';
+                const label = a.title || a.identifier || a.type;
+                body += `- **${a.type}**: ${label} ${link}\n`;
+            });
+            body += '\n';
+        }
+    }
+    else {
+        // Fallback to raw output if no summary exists
+        body = `## 🤖 AI Task Result\n\n`;
+        body += `**Status:** ${result.success ? '✅ Completed' : '❌ Failed'}\n\n`;
+        if (result.output) {
+            body += `### Summary\n\n${result.output}\n\n`;
+        }
+    }
+    if (result.error) {
+        body += `### ⚠️ Error\n\`\`\`\n${result.error.message}\n\`\`\`\n\n`;
+    }
+    body += `---\n*Generated by [profClaw](https://github.com/profclaw/profclaw) • ${result.duration ? `Duration: ${(result.duration / 1000).toFixed(1)}s` : ''}*`;
+    return body;
+}
+/**
+ * Post a comment on GitHub
+ */
+async function postGitHubComment(task, body) {
+    const token = process.env.GITHUB_TOKEN;
+    if (!token || !task.repository || !task.sourceId)
+        return;
+    try {
+        const client = new GitHubClient(token);
+        const issueNumber = parseInt(task.sourceId);
+        await client.addComment(task.repository, issueNumber, body);
+        logger.info(`[GitHub] Posted result to #${issueNumber} in ${task.repository}`);
+    }
+    catch (error) {
+        logger.error('[GitHub] Error posting comment:', error);
+    }
+}
+/**
+ * Post a comment on Jira
+ */
+async function postJiraComment(task, body) {
+    const baseUrl = process.env.JIRA_BASE_URL;
+    const email = process.env.JIRA_EMAIL;
+    const apiToken = process.env.JIRA_API_TOKEN;
+    if (!baseUrl || !email || !apiToken || !task.sourceId)
+        return;
+    try {
+        const client = new JiraClient({ baseUrl, email, apiToken });
+        await client.addComment(task.sourceId, body);
+        logger.info(`[Jira] Posted result to ${task.sourceId}`);
+    }
+    catch (error) {
+        logger.error('[Jira] Error posting comment:', error);
+    }
+}
+/**
+ * Post a comment on Linear
+ */
+async function postLinearComment(task, body) {
+    const apiKey = process.env.LINEAR_API_KEY;
+    if (!apiKey || !task.sourceId)
+        return;
+    try {
+        const client = new LinearClient({ apiKey });
+        // Note: for linear_comment tasks, the sourceId might be the comment ID.
+        // We ideally need the issue ID here. 
+        // If task.metadata.issueId exists, use that.
+        const issueId = task.metadata?.issueId || task.sourceId;
+        await client.addComment(issueId, body);
+        logger.info(`[Linear] Posted result to issue ${issueId}`);
+    }
+    catch (error) {
+        logger.error('[Linear] Error posting comment:', error);
+    }
+}
+//# sourceMappingURL=notifications.js.map

package/dist/queue/task-queue.d.ts

@@ -0,0 +1,55 @@
+import { Job } from "bullmq";
+import type { Task, TaskResult, CreateTaskInput, TaskStatusType } from "../types/task.js";
+interface TaskEvent {
+    type: "created" | "queued" | "started" | "progress" | "completed" | "failed";
+    taskId: string;
+    task: Task;
+    result?: TaskResult;
+    progress?: number;
+}
+/**
+ * Initialize the task queue
+ */
+export declare function initTaskQueue(): Promise<void>;
+/**
+ * Process a task
+ */
+export declare function processTask(job: Job<Task>): Promise<TaskResult>;
+/**
+ * Add a new task to the queue
+ */
+export declare function addTask(input: CreateTaskInput): Promise<Task>;
+/**
+ * Get task by ID
+ */
+export declare function getTask(id: string): Task | undefined;
+/**
+ * Get all tasks (paginated)
+ */
+export declare function getTasks(options?: {
+    status?: TaskStatusType;
+    limit?: number;
+    offset?: number;
+}): Task[];
+/**
+ * Subscribe to task events
+ */
+export declare function onTaskEvent(callback: (event: TaskEvent) => void): () => void;
+/**
+ * Register SSE broadcaster for real-time updates
+ */
+export declare function registerSSEBroadcaster(broadcaster: (eventType: string, data: Record<string, unknown>) => void): void;
+/**
+ * Cancel a running task
+ */
+export declare function cancelTask(id: string): Promise<boolean>;
+/**
+ * Retry a failed task
+ */
+export declare function retryTask(id: string): Promise<Task | null>;
+/**
+ * Close the queue (for graceful shutdown)
+ */
+export declare function closeTaskQueue(): Promise<void>;
+export {};
+//# sourceMappingURL=task-queue.d.ts.map