@lovelybunch/api 1.0.75-alpha.8 → 1.0.75

package/dist/routes/api/v1/tasks/[id]/route.d.ts

@@ -0,0 +1,117 @@
+import { Context } from 'hono';
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        id: string;
+        title: string;
+        intent?: string;
+        content?: string;
+        author: {
+            type: import("@lovelybunch/core").AuthorType;
+            id: string;
+            name: string;
+            email?: string;
+        };
+        productSpecRef?: string;
+        planSteps: {
+            id: string;
+            description: string;
+            command?: string;
+            expectedOutcome?: string;
+            status: "pending" | "in-progress" | "completed" | "failed";
+            output?: string;
+            error?: string;
+            executedAt?: string;
+        }[];
+        status: import("@lovelybunch/core").TaskStatus;
+        comments?: {
+            id: string;
+            author: string;
+            content: string;
+            createdAt: string;
+        }[];
+        metadata: {
+            createdAt: string;
+            updatedAt: string;
+            reviewers: string[];
+            tags?: string[];
+            priority?: "low" | "medium" | "high" | "critical";
+            readiness?: number;
+        };
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;
+export declare function PATCH(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        id: string;
+        title: string;
+        intent?: string;
+        content?: string;
+        author: {
+            type: import("@lovelybunch/core").AuthorType;
+            id: string;
+            name: string;
+            email?: string;
+        };
+        productSpecRef?: string;
+        planSteps: {
+            id: string;
+            description: string;
+            command?: string;
+            expectedOutcome?: string;
+            status: "pending" | "in-progress" | "completed" | "failed";
+            output?: string;
+            error?: string;
+            executedAt?: string;
+        }[];
+        status: import("@lovelybunch/core").TaskStatus;
+        comments?: {
+            id: string;
+            author: string;
+            content: string;
+            createdAt: string;
+        }[];
+        metadata: {
+            createdAt: string;
+            updatedAt: string;
+            reviewers: string[];
+            tags?: string[];
+            priority?: "low" | "medium" | "high" | "critical";
+            readiness?: number;
+        };
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;
+export declare function DELETE(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;

package/dist/routes/api/v1/tasks/[id]/route.js

@@ -0,0 +1,166 @@
+import { FileStorageAdapter } from '../../../../../lib/storage/file-storage.js';
+import { getLogger } from '@lovelybunch/core/logging';
+const storage = new FileStorageAdapter();
+// Logger is lazily initialized inside handlers to use server config
+export async function GET(c) {
+    try {
+        const id = c.req.param('id');
+        const task = await storage.getTask(id);
+        if (!task) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'TASK_NOT_FOUND',
+                    message: `Task with id ${id} not found`
+                }
+            }, 404);
+        }
+        return c.json({
+            success: true,
+            data: task
+        });
+    }
+    catch (error) {
+        console.error('Error getting task:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'GET_TASK_ERROR',
+                message: error.message
+            }
+        }, 500);
+    }
+}
+export async function PATCH(c) {
+    try {
+        const id = c.req.param('id');
+        const updates = await c.req.json();
+        // Get existing task to merge updates properly
+        const existing = await storage.getTask(id);
+        if (!existing) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'TASK_NOT_FOUND',
+                    message: `Task with id ${id} not found`
+                }
+            }, 404);
+        }
+        // Handle special fields like comments
+        let finalUpdates = { ...updates };
+        if (updates.comments) {
+            finalUpdates = { ...finalUpdates, comments: updates.comments };
+        }
+        await storage.updateTask(id, finalUpdates);
+        // Fetch the updated task
+        const updatedTask = await storage.getTask(id);
+        // Determine what changed
+        const changedFields = Object.keys(updates);
+        const oldStatus = existing.status;
+        const newStatus = updatedTask?.status || existing.status;
+        // Log task.update event
+        const logger = getLogger();
+        logger.log({
+            kind: 'task.update',
+            actor: updatedTask?.author.type === 'agent'
+                ? `agent:${updatedTask.author.name}`
+                : `human:${updatedTask?.author.email || 'unknown'}`,
+            subject: `task:${id}`,
+            tags: ['task'],
+            payload: {
+                id,
+                changes: changedFields,
+                oldStatus,
+                newStatus
+            }
+        });
+        // If status changed, also log a status.change event
+        if (oldStatus !== newStatus) {
+            logger.log({
+                kind: 'task.status.change',
+                actor: updatedTask?.author.type === 'agent'
+                    ? `agent:${updatedTask.author.name}`
+                    : `human:${updatedTask?.author.email || 'unknown'}`,
+                subject: `task:${id}`,
+                tags: ['task', 'status'],
+                payload: {
+                    id,
+                    from: oldStatus,
+                    to: newStatus,
+                    reason: null
+                }
+            });
+            // Send Slack notification for status change (non-blocking)
+            import('../../../../../lib/slack/slack-service.js').then(({ getSlackService }) => {
+                getSlackService().sendNotification({
+                    type: 'proposal.statusChange',
+                    proposalId: id,
+                    intent: updatedTask?.title || existing.title || '',
+                    status: newStatus,
+                    previousStatus: oldStatus,
+                }).catch(err => console.warn('[tasks] Slack notification failed:', err));
+            }).catch(() => { });
+        }
+        return c.json({
+            success: true,
+            data: updatedTask
+        });
+    }
+    catch (error) {
+        console.error('Error updating task:', error);
+        if (error.message.includes('not found')) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'TASK_NOT_FOUND',
+                    message: error.message
+                }
+            }, 404);
+        }
+        return c.json({
+            success: false,
+            error: {
+                code: 'UPDATE_TASK_ERROR',
+                message: error.message
+            }
+        }, 500);
+    }
+}
+export async function DELETE(c) {
+    try {
+        const id = c.req.param('id');
+        // Get task info before deleting
+        const task = await storage.getTask(id);
+        await storage.deleteTask(id);
+        // Log the deletion event
+        if (task) {
+            const logger = getLogger();
+            logger.log({
+                kind: 'task.delete',
+                actor: task.author.type === 'agent'
+                    ? `agent:${task.author.name}`
+                    : `human:${task.author.email || 'unknown'}`,
+                subject: `task:${id}`,
+                tags: ['task'],
+                payload: {
+                    id,
+                    title: task.title
+                }
+            });
+        }
+        return c.json({
+            success: true,
+            message: `Task ${id} deleted successfully`
+        });
+    }
+    catch (error) {
+        console.error('Error deleting task:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'DELETE_TASK_ERROR',
+                message: error.message
+            }
+        }, 500);
+    }
+}

package/dist/routes/api/v1/tasks/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const tasks: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default tasks;

package/dist/routes/api/v1/tasks/index.js

@@ -0,0 +1,10 @@
+import { Hono } from 'hono';
+import { GET, POST } from './route.js';
+import { GET as getTask, PATCH as patchTask, DELETE as deleteTask } from './[id]/route.js';
+const tasks = new Hono();
+tasks.get('/', GET);
+tasks.post('/', POST);
+tasks.get('/:id', getTask);
+tasks.patch('/:id', patchTask);
+tasks.delete('/:id', deleteTask);
+export default tasks;

package/dist/routes/api/v1/tasks/route.d.ts

@@ -0,0 +1,96 @@
+import { Context } from 'hono';
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    totalCount: number;
+    success: true;
+    data: {
+        id: string;
+        title: string;
+        intent?: string;
+        content?: string;
+        author: {
+            type: import("@lovelybunch/types").AuthorType;
+            id: string;
+            name: string;
+            email?: string;
+        };
+        productSpecRef?: string;
+        planSteps: {
+            id: string;
+            description: string;
+            command?: string;
+            expectedOutcome?: string;
+            status: "pending" | "in-progress" | "completed" | "failed";
+            output?: string;
+            error?: string;
+            executedAt?: string;
+        }[];
+        status: import("@lovelybunch/types").TaskStatus;
+        comments?: {
+            id: string;
+            author: string;
+            content: string;
+            createdAt: string;
+        }[];
+        metadata: {
+            createdAt: string;
+            updatedAt: string;
+            reviewers: string[];
+            tags?: string[];
+            priority?: "low" | "medium" | "high" | "critical";
+            readiness?: number;
+        };
+    }[];
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        id: string;
+        title: string;
+        intent?: string;
+        content?: string;
+        author: {
+            type: import("@lovelybunch/types").AuthorType;
+            id: string;
+            name: string;
+            email?: string;
+        };
+        productSpecRef?: string;
+        planSteps: {
+            id: string;
+            description: string;
+            command?: string;
+            expectedOutcome?: string;
+            status: "pending" | "in-progress" | "completed" | "failed";
+            output?: string;
+            error?: string;
+            executedAt?: string;
+        }[];
+        status: import("@lovelybunch/types").TaskStatus;
+        comments?: {
+            id: string;
+            author: string;
+            content: string;
+            createdAt: string;
+        }[];
+        metadata: {
+            createdAt: string;
+            updatedAt: string;
+            reviewers: string[];
+            tags?: string[];
+            priority?: "low" | "medium" | "high" | "critical";
+            readiness?: number;
+        };
+    };
+}, 201, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;

package/dist/routes/api/v1/tasks/route.js

@@ -0,0 +1,136 @@
+import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
+import { getAuthorInfo } from '../../../../lib/user-preferences.js';
+import Fuse from 'fuse.js';
+import { getLogger } from '@lovelybunch/core/logging';
+const storage = new FileStorageAdapter();
+// Logger is lazily initialized inside handlers to use server config
+export async function GET(c) {
+    try {
+        const url = new URL(c.req.url);
+        const searchParams = url.searchParams;
+        const status = searchParams.get('status');
+        const author = searchParams.get('author');
+        const priority = searchParams.get('priority');
+        const tags = searchParams.get('tags')?.split(',');
+        const searchQuery = searchParams.get('q');
+        const limitParam = searchParams.get('limit');
+        const limit = limitParam ? Math.min(Math.max(1, parseInt(limitParam, 10) || 20), 100) : undefined;
+        let tasks = await storage.listTasks({
+            status,
+            author: author || undefined,
+            priority: priority || undefined,
+            tags
+        });
+        // Apply search filter if provided
+        if (searchQuery?.trim()) {
+            const fuse = new Fuse(tasks, {
+                keys: [
+                    { name: 'title', weight: 0.4 },
+                    { name: 'intent', weight: 0.4 }, // Deprecated fallback
+                    { name: 'id', weight: 0.3 },
+                    { name: 'author.name', weight: 0.2 },
+                    { name: 'metadata.tags', weight: 0.1 }
+                ],
+                threshold: 0.3,
+                includeScore: true
+            });
+            const searchResults = fuse.search(searchQuery);
+            tasks = searchResults.map(result => result.item);
+        }
+        const totalCount = tasks.length;
+        if (limit !== undefined) {
+            tasks = tasks.slice(0, limit);
+        }
+        return c.json({
+            success: true,
+            data: tasks,
+            ...(limit !== undefined && { totalCount })
+        });
+    }
+    catch (error) {
+        console.error('Error listing tasks:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'LIST_TASKS_ERROR',
+                message: error.message
+            }
+        }, 500);
+    }
+}
+export async function POST(c) {
+    try {
+        const body = await c.req.json();
+        // Get author info from saved preferences if not provided
+        const authorInfo = await getAuthorInfo();
+        // Create a new task with required fields
+        const now = new Date();
+        // Use title as primary, fall back to deprecated intent for backward compatibility
+        const titleValue = body.title || body.intent || '';
+        const task = {
+            id: body.id || `cp-${Date.now()}`,
+            title: titleValue,
+            // Keep intent for backward compatibility (deprecated)
+            ...(body.intent && { intent: body.intent }),
+            content: body.content,
+            author: body.author || {
+                id: 'current-user',
+                name: authorInfo.name,
+                email: authorInfo.email,
+                role: 'engineer',
+                type: 'human'
+            },
+            planSteps: body.planSteps || [],
+            status: body.status || 'draft',
+            metadata: {
+                createdAt: now,
+                updatedAt: now,
+                reviewers: body.metadata?.reviewers || [],
+                tags: body.metadata?.tags || [],
+                priority: body.metadata?.priority || 'medium',
+                ...(body.metadata?.readiness != null && { readiness: body.metadata.readiness }),
+            },
+            productSpecRef: body.productSpecRef
+        };
+        await storage.createTask(task);
+        // Log the task creation event
+        const logger = getLogger();
+        logger.log({
+            kind: 'task.create',
+            actor: task.author.type === 'agent'
+                ? `agent:${task.author.name}`
+                : `human:${task.author.email}`,
+            subject: `task:${task.id}`,
+            tags: ['task'],
+            payload: {
+                id: task.id,
+                title: task.title,
+                priority: task.metadata.priority,
+                author: task.author
+            }
+        });
+        // Send Slack notification (non-blocking)
+        import('../../../../lib/slack/slack-service.js').then(({ getSlackService }) => {
+            getSlackService().sendNotification({
+                type: 'proposal.created',
+                proposalId: task.id,
+                intent: task.title,
+                author: task.author.name,
+            }).catch(err => console.warn('[tasks] Slack notification failed:', err));
+        }).catch(() => { });
+        return c.json({
+            success: true,
+            data: task
+        }, 201);
+    }
+    catch (error) {
+        console.error('Error creating task:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'CREATE_TASK_ERROR',
+                message: error.message
+            }
+        }, 500);
+    }
+}

package/dist/routes/api/v1/terminal/[proposalId]/create/route.js

@@ -4,7 +4,7 @@ export async function POST(c) {
     try {
         const proposalId = c.req.param('proposalId');
         const body = await c.req.json().catch(() => ({}));
-        const { enableLogging = false, startupCommand } = body;
+        const { startupCommand } = body;
         if (!proposalId) {
             return c.json({ error: 'Proposal ID is required' }, 400);
         }
@@ -13,7 +13,7 @@ export async function POST(c) {
         const shellPreference = (userSettings.preferences.terminalShell || 'bash');
         // Create a new terminal session for this proposal
         const terminalManager = getGlobalTerminalManager();
-        const session = await terminalManager.createSession(proposalId, enableLogging, shellPreference, startupCommand);
+        const session = await terminalManager.createSession(proposalId, shellPreference, startupCommand);
         return c.json({
             sessionId: session.id,
             proposalId: session.proposalId,

package/dist/routes/api/v1/terminal/[taskId]/create/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const create: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default create;

package/dist/routes/api/v1/terminal/[taskId]/create/index.js

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { POST } from './route.js';
+const create = new Hono();
+create.post('/', POST);
+export default create;

package/dist/routes/api/v1/terminal/[taskId]/create/route.d.ts

@@ -0,0 +1,10 @@
+import { Context } from 'hono';
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    sessionId: string;
+    taskId: string;
+    createdAt: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;

package/dist/routes/api/v1/terminal/[taskId]/create/route.js

@@ -0,0 +1,27 @@
+import { getGlobalTerminalManager } from '../../../../../../lib/terminal/global-manager.js';
+import { loadUserSettings } from '../../../../../../lib/user-preferences.js';
+export async function POST(c) {
+    try {
+        const taskId = c.req.param('taskId');
+        const body = await c.req.json().catch(() => ({}));
+        const { startupCommand } = body;
+        if (!taskId) {
+            return c.json({ error: 'Task ID is required' }, 400);
+        }
+        // Load user settings to get shell preference
+        const userSettings = await loadUserSettings();
+        const shellPreference = (userSettings.preferences.terminalShell || 'bash');
+        // Create a new terminal session for this task
+        const terminalManager = getGlobalTerminalManager();
+        const session = await terminalManager.createSession(taskId, shellPreference, startupCommand);
+        return c.json({
+            sessionId: session.id,
+            taskId: session.taskId,
+            createdAt: session.createdAt,
+        });
+    }
+    catch (error) {
+        console.error('Error creating terminal session:', error);
+        return c.json({ error: 'Failed to create terminal session' }, 500);
+    }
+}

package/dist/routes/api/v1/terminal/[taskId]/destroy/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/routes/api/v1/terminal/[taskId]/destroy/index.js

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { POST } from './route.js';
+const app = new Hono();
+app.post('/', POST);
+export default app;

package/dist/routes/api/v1/terminal/[taskId]/destroy/route.d.ts

@@ -0,0 +1,10 @@
+import { Context } from 'hono';
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;

package/dist/routes/api/v1/terminal/[taskId]/destroy/route.js

@@ -0,0 +1,21 @@
+import { getGlobalTerminalManager } from '../../../../../../lib/terminal/global-manager.js';
+export async function POST(c) {
+    try {
+        const taskId = c.req.param('taskId');
+        const body = await c.req.json();
+        const { sessionId } = body;
+        if (!sessionId) {
+            return c.json({ error: 'Session ID is required' }, 400);
+        }
+        const terminalManager = getGlobalTerminalManager();
+        const success = terminalManager.destroySession(sessionId);
+        if (!success) {
+            return c.json({ error: 'Session not found' }, 404);
+        }
+        return c.json({ success: true });
+    }
+    catch (error) {
+        console.error('Error destroying terminal session:', error);
+        return c.json({ error: 'Failed to destroy terminal session' }, 500);
+    }
+}

package/dist/routes/api/v1/terminal/[taskId]/resize/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/routes/api/v1/terminal/[taskId]/resize/index.js

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { POST } from './route.js';
+const app = new Hono();
+app.post('/', POST);
+export default app;

package/dist/routes/api/v1/terminal/[taskId]/resize/route.d.ts

@@ -0,0 +1,10 @@
+import { Context } from 'hono';
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;