@lovelybunch/api 1.0.75-alpha.1 → 1.0.75-alpha.11

package/dist/lib/auth/auth-manager.d.ts

@@ -128,3 +128,8 @@ export declare class AuthManager {
  * @param configPath - Optional custom path to auth.json. If not provided, uses OS app data directory.
  */
 export declare function getAuthManager(configPath?: string): AuthManager;
+/**
+ * Reset the singleton AuthManager (for testing isolation).
+ * Only effective when NODE_ENV is 'test'.
+ */
+export declare function resetAuthManagerForTesting(): void;

package/dist/lib/auth/auth-manager.js

@@ -420,3 +420,12 @@ export function getAuthManager(configPath) {
     }
     return authManagerInstance;
 }
+/**
+ * Reset the singleton AuthManager (for testing isolation).
+ * Only effective when NODE_ENV is 'test'.
+ */
+export function resetAuthManagerForTesting() {
+    if (process.env.NODE_ENV === 'test') {
+        authManagerInstance = null;
+    }
+}

package/dist/lib/jobs/job-scheduler.js

@@ -195,6 +195,18 @@ export class JobScheduler {
             catch (logError) {
                 console.error('Error logging job run end:', logError);
             }
+            // Send Slack notification for job completion (non-blocking)
+            const notificationType = result.status === 'succeeded' ? 'job.completed' : 'job.failed';
+            import('../slack/slack-service.js').then(({ getSlackService }) => {
+                const duration = runRecord.finishedAt.getTime() - start.getTime();
+                getSlackService().sendNotification({
+                    type: notificationType,
+                    jobId: job.id,
+                    jobName: job.name || job.id,
+                    duration,
+                    error: result.error,
+                }).catch(err => console.warn('[jobs] Slack notification failed:', err));
+            }).catch(() => { });
         }
         catch (error) {
             runRecord.status = 'failed';
@@ -223,6 +235,15 @@ export class JobScheduler {
             catch (logError) {
                 console.error('Error logging job run error:', logError);
             }
+            // Send Slack notification for job failure (non-blocking)
+            import('../slack/slack-service.js').then(({ getSlackService }) => {
+                getSlackService().sendNotification({
+                    type: 'job.failed',
+                    jobId: job.id,
+                    jobName: job.name || job.id,
+                    error: error?.message || 'Unknown error',
+                }).catch(err => console.warn('[jobs] Slack notification failed:', err));
+            }).catch(() => { });
         }
         try {
             await this.store.saveJob(job);

package/dist/lib/mcp-client.d.ts

@@ -0,0 +1,39 @@
+/**
+ * MCP Client helper for connecting to HTTP/SSE MCP servers
+ * Provides tool discovery and execution proxying
+ */
+export interface McpServerConfig {
+    name?: string;
+    type?: 'http' | 'sse' | 'stdio';
+    url?: string;
+    enabled?: boolean;
+    env?: Record<string, string>;
+}
+export interface DiscoveredTool {
+    name: string;
+    description?: string;
+    inputSchema?: object;
+    serverName: string;
+    serverUrl: string;
+}
+export interface ToolCallResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+    isError?: boolean;
+    structuredContent?: unknown;
+}
+/**
+ * Connect to an HTTP/SSE MCP server and discover its available tools
+ */
+export declare function discoverToolsFromServer(serverName: string, config: McpServerConfig): Promise<DiscoveredTool[]>;
+/**
+ * Execute a tool on an HTTP/SSE MCP server
+ */
+export declare function executeToolOnServer(serverName: string, config: McpServerConfig, toolName: string, args: Record<string, unknown>): Promise<ToolCallResult>;
+/**
+ * Close all cached client connections (for cleanup)
+ */
+export declare function closeAllConnections(): void;

package/dist/lib/mcp-client.js

@@ -0,0 +1,131 @@
+/**
+ * MCP Client helper for connecting to HTTP/SSE MCP servers
+ * Provides tool discovery and execution proxying
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+// Cache for active client connections
+const clientCache = new Map();
+// Clean up stale connections after 5 minutes
+const CONNECTION_TTL_MS = 5 * 60 * 1000;
+/**
+ * Get or create a client connection to an MCP server
+ */
+async function getOrCreateClient(serverName, config) {
+    const cacheKey = `${serverName}:${config.url}`;
+    const cached = clientCache.get(cacheKey);
+    if (cached) {
+        cached.lastUsed = Date.now();
+        return cached.client;
+    }
+    const client = new Client({
+        name: 'coconut-api',
+        version: '1.0.0'
+    });
+    const url = new URL(config.url);
+    // Try StreamableHTTP first (newer), fall back to SSE (legacy)
+    let transport;
+    if (config.type === 'sse') {
+        // Explicitly SSE
+        transport = new SSEClientTransport(url);
+    }
+    else {
+        // Default to StreamableHTTP for 'http' type or unspecified
+        transport = new StreamableHTTPClientTransport(url);
+    }
+    await client.connect(transport);
+    clientCache.set(cacheKey, { client, lastUsed: Date.now() });
+    // Schedule cleanup
+    scheduleCleanup();
+    return client;
+}
+let cleanupScheduled = false;
+function scheduleCleanup() {
+    if (cleanupScheduled)
+        return;
+    cleanupScheduled = true;
+    setTimeout(() => {
+        cleanupScheduled = false;
+        const now = Date.now();
+        for (const [key, entry] of clientCache.entries()) {
+            if (now - entry.lastUsed > CONNECTION_TTL_MS) {
+                try {
+                    entry.client.close();
+                }
+                catch (e) {
+                    // Ignore close errors
+                }
+                clientCache.delete(key);
+            }
+        }
+        // Reschedule if there are still cached connections
+        if (clientCache.size > 0) {
+            scheduleCleanup();
+        }
+    }, CONNECTION_TTL_MS);
+}
+/**
+ * Connect to an HTTP/SSE MCP server and discover its available tools
+ */
+export async function discoverToolsFromServer(serverName, config) {
+    if (!config.url) {
+        throw new Error(`Server ${serverName} has no URL configured`);
+    }
+    if (config.enabled === false) {
+        return [];
+    }
+    try {
+        const client = await getOrCreateClient(serverName, config);
+        const toolsResult = await client.listTools();
+        return toolsResult.tools.map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            serverName,
+            serverUrl: config.url
+        }));
+    }
+    catch (error) {
+        console.error(`Failed to discover tools from ${serverName}:`, error);
+        throw error;
+    }
+}
+/**
+ * Execute a tool on an HTTP/SSE MCP server
+ */
+export async function executeToolOnServer(serverName, config, toolName, args) {
+    if (!config.url) {
+        throw new Error(`Server ${serverName} has no URL configured`);
+    }
+    try {
+        const client = await getOrCreateClient(serverName, config);
+        const result = await client.callTool({
+            name: toolName,
+            arguments: args
+        });
+        return {
+            content: result.content,
+            isError: result.isError,
+            structuredContent: result.structuredContent
+        };
+    }
+    catch (error) {
+        console.error(`Failed to execute tool ${toolName} on ${serverName}:`, error);
+        throw error;
+    }
+}
+/**
+ * Close all cached client connections (for cleanup)
+ */
+export function closeAllConnections() {
+    for (const [key, entry] of clientCache.entries()) {
+        try {
+            entry.client.close();
+        }
+        catch (e) {
+            // Ignore close errors
+        }
+        clientCache.delete(key);
+    }
+}

package/dist/lib/slack/slack-service.d.ts

@@ -0,0 +1,2 @@
+export { SlackService, getSlackService, DEFAULT_SLACK_CONFIG, } from '@lovelybunch/core';
+export type { SlackConfig, SlackNotificationSettings, SlackChannel, ProposalNotificationPayload, JobNotificationPayload, GitNotificationPayload, NotificationPayload, NotificationType, FreeformMessageOptions, } from '@lovelybunch/core';

package/dist/lib/slack/slack-service.js

@@ -0,0 +1,3 @@
+// Re-export from @lovelybunch/core for backward compatibility
+// All Slack logic now lives in packages/core/src/slack.ts
+export { SlackService, getSlackService, DEFAULT_SLACK_CONFIG, } from '@lovelybunch/core';

package/dist/lib/storage/file-storage.d.ts

@@ -1,30 +1,30 @@
-import { ChangeProposal, CPStatus } from '@lovelybunch/types';
-export interface CPFilter {
-    status?: CPStatus;
+import { Task, TaskStatus } from '@lovelybunch/types';
+export interface TaskFilter {
+    status?: TaskStatus;
     author?: string;
     priority?: string;
     tags?: string[];
     search?: string;
 }
 export interface StorageAdapter {
-    createCP(cp: ChangeProposal): Promise<void>;
-    getCP(id: string): Promise<ChangeProposal | null>;
-    updateCP(id: string, cp: Partial<ChangeProposal>): Promise<void>;
-    deleteCP(id: string): Promise<void>;
-    listCPs(filter?: CPFilter): Promise<ChangeProposal[]>;
-    searchCPs(query: string): Promise<ChangeProposal[]>;
+    createTask(task: Task): Promise<void>;
+    getTask(id: string): Promise<Task | null>;
+    updateTask(id: string, task: Partial<Task>): Promise<void>;
+    deleteTask(id: string): Promise<void>;
+    listTasks(filter?: TaskFilter): Promise<Task[]>;
+    searchTasks(query: string): Promise<Task[]>;
 }
 export declare class FileStorageAdapter implements StorageAdapter {
     private basePath;
     private sanitizeForYAML;
     constructor(basePath?: string);
     ensureDirectories(): Promise<void>;
-    createCP(cp: ChangeProposal): Promise<void>;
-    getCP(id: string): Promise<ChangeProposal | null>;
-    updateCP(id: string, updates: Partial<ChangeProposal>): Promise<void>;
-    deleteCP(id: string): Promise<void>;
-    listCPs(filter?: CPFilter): Promise<ChangeProposal[]>;
-    searchCPs(query: string): Promise<ChangeProposal[]>;
-    private frontmatterToCP;
+    createTask(task: Task): Promise<void>;
+    getTask(id: string): Promise<Task | null>;
+    updateTask(id: string, updates: Partial<Task>): Promise<void>;
+    deleteTask(id: string): Promise<void>;
+    listTasks(filter?: TaskFilter): Promise<Task[]>;
+    searchTasks(query: string): Promise<Task[]>;
+    private frontmatterToTask;
     private getDefaultContent;
 }

package/dist/lib/storage/file-storage.js

@@ -49,68 +49,76 @@ export class FileStorageAdapter {
         }
     }
     async ensureDirectories() {
-        const dirs = ['proposals', 'specs', 'flags', 'experiments', 'templates', 'jobs'];
+        const dirs = ['tasks', 'specs', 'flags', 'experiments', 'templates', 'jobs'];
         for (const dir of dirs) {
             await fs.mkdir(path.join(this.basePath, dir), { recursive: true });
         }
     }
-    async createCP(cp) {
+    async createTask(task) {
         await this.ensureDirectories();
-        // Extract content from the proposal if it exists
-        const { content, ...frontmatter } = cp;
+        // Extract content from the task if it exists
+        const { content, ...frontmatter } = task;
         // Normalize date fields to Date instances in case callers provide ISO strings
-        const createdAt = cp.metadata.createdAt instanceof Date
-            ? cp.metadata.createdAt
-            : new Date(cp.metadata.createdAt);
-        const updatedAt = cp.metadata.updatedAt instanceof Date
-            ? cp.metadata.updatedAt
-            : new Date(cp.metadata.updatedAt);
-        // Convert the proposal to markdown with YAML frontmatter
+        const createdAt = task.metadata.createdAt instanceof Date
+            ? task.metadata.createdAt
+            : new Date(task.metadata.createdAt);
+        const updatedAt = task.metadata.updatedAt instanceof Date
+            ? task.metadata.updatedAt
+            : new Date(task.metadata.updatedAt);
+        // Convert the task to markdown with YAML frontmatter
         const frontmatterData = this.sanitizeForYAML({
             // Required fields
-            id: cp.id,
-            title: cp.title,
+            id: task.id,
+            title: task.title,
             // Deprecated: intent is kept for backward compatibility during migration
             // TODO: Remove intent field in future version
-            ...(cp.intent && { intent: cp.intent }),
+            ...(task.intent && { intent: task.intent }),
             createdAt: createdAt.toISOString(),
             updatedAt: updatedAt.toISOString(),
-            status: cp.status,
-            priority: cp.metadata.priority || 'medium',
+            status: task.status,
+            priority: task.metadata.priority || 'medium',
             // Author information
             author: {
-                id: cp.author.id,
-                name: cp.author.name,
-                email: cp.author.email || '',
+                id: task.author.id,
+                name: task.author.name,
+                email: task.author.email || '',
                 role: 'engineer', // Default role
-                type: cp.author.type
-            },
-            // Plan
-            plan: {
-                estimatedDuration: 'TBD',
-                dependencies: [],
-                steps: cp.planSteps.map(step => ({
-                    id: step.id,
-                    description: step.description,
-                    status: step.status
-                }))
+                type: task.author.type
             },
+            // Steps (top-level for consistency with CLI storage format)
+            steps: task.planSteps.map(step => ({
+                id: step.id,
+                description: step.description,
+                status: step.status,
+                ...(step.command && { command: step.command }),
+                ...(step.expectedOutcome && { expectedOutcome: step.expectedOutcome }),
+                ...(step.output && { output: step.output }),
+                ...(step.executedAt && { executedAt: step.executedAt instanceof Date ? step.executedAt.toISOString() : step.executedAt }),
+            })),
             // Metadata
-            tags: cp.metadata.tags || [],
+            tags: task.metadata.tags || [],
             labels: [],
-            comments: (cp.comments || []).filter((c) => c !== undefined)
+            // Comments use consistent field names: id, author, content, createdAt
+            comments: (task.comments || [])
+                .filter((c) => c !== undefined)
+                .map((c) => ({
+                id: c.id,
+                author: typeof c.author === 'string' ? c.author : c.author?.name || 'Unknown',
+                content: c.content || c.text || '',
+                createdAt: c.createdAt || c.timestamp || new Date().toISOString(),
+            }))
         });
-        const markdown = matter.stringify(content || this.getDefaultContent(cp), frontmatterData);
-        const filePath = path.join(this.basePath, 'proposals', `${cp.id}.md`);
+        const markdown = matter.stringify(content || this.getDefaultContent(task), frontmatterData);
+        const filePath = path.join(this.basePath, 'tasks', `${task.id}.md`);
         await fs.writeFile(filePath, markdown, 'utf-8');
     }
-    async getCP(id) {
+    async getTask(id) {
         try {
-            const filePath = path.join(this.basePath, 'proposals', `${id}.md`);
+            const filePath = path.join(this.basePath, 'tasks', `${id}.md`);
             const fileContent = await fs.readFile(filePath, 'utf-8');
             const { data, content } = matter(fileContent);
-            // Convert the frontmatter back to a ChangeProposal
-            return this.frontmatterToCP(data, content);
+            // Convert the frontmatter back to a Task
+            return this.frontmatterToTask(data, content);
         }
         catch (error) {
             if (error.code === 'ENOENT')
@@ -118,21 +126,19 @@ export class FileStorageAdapter {
             throw error;
         }
     }
-    async updateCP(id, updates) {
-        const existing = await this.getCP(id);
+    async updateTask(id, updates) {
+        const existing = await this.getTask(id);
         if (!existing)
-            throw new Error(`CP ${id} not found`);
-        // Never allow id to be updated to prevent overwriting other proposals
+            throw new Error(`Task ${id} not found`);
+        // Never allow id to be updated to prevent overwriting other tasks
         const { id: _, ...safeUpdates } = updates;
-        // Handle comments separately as they're stored at root level in file format
-        // Comments can come from either root level or metadata.comments
-        let commentsToStore = existing.metadata.comments || [];
+        // Comments live at root level on Task (not in metadata).
+        // Accept comments from root level or metadata.comments for backward compat.
+        let commentsToStore = existing.comments || [];
         if (safeUpdates.comments) {
-            // If comments are provided at root level, use them
             commentsToStore = safeUpdates.comments;
         }
         else if (safeUpdates.metadata?.comments) {
-            // If comments are provided in metadata, use them
             commentsToStore = safeUpdates.metadata.comments;
         }
         const updated = {
@@ -142,41 +148,39 @@ export class FileStorageAdapter {
                 ...existing.metadata,
                 ...safeUpdates.metadata,
                 updatedAt: new Date(),
-                comments: commentsToStore
             },
-            // Store comments at the root level for the file format
             comments: commentsToStore
         };
-        await this.createCP(updated);
+        await this.createTask(updated);
     }
-    async deleteCP(id) {
-        const filePath = path.join(this.basePath, 'proposals', `${id}.md`);
+    async deleteTask(id) {
+        const filePath = path.join(this.basePath, 'tasks', `${id}.md`);
         await fs.unlink(filePath);
     }
-    async listCPs(filter) {
-        const proposalsDir = path.join(this.basePath, 'proposals');
+    async listTasks(filter) {
+        const tasksDir = path.join(this.basePath, 'tasks');
         try {
-            const files = await fs.readdir(proposalsDir);
-            const proposals = await Promise.all(files
+            const files = await fs.readdir(tasksDir);
+            const tasks = await Promise.all(files
                 .filter(f => f.endsWith('.md'))
                 .map(async (file) => {
-                const content = await fs.readFile(path.join(proposalsDir, file), 'utf-8');
+                const content = await fs.readFile(path.join(tasksDir, file), 'utf-8');
                 const { data, content: body } = matter(content);
-                return this.frontmatterToCP(data, body);
+                return this.frontmatterToTask(data, body);
             }));
             // Apply filters
-            let filtered = proposals.filter(cp => {
-                if (!cp)
+            let filtered = tasks.filter(task => {
+                if (!task)
                     return false;
-                if (filter?.status && cp.status !== filter.status)
+                if (filter?.status && task.status !== filter.status)
                     return false;
-                if (filter?.author && cp.author.id !== filter.author)
+                if (filter?.author && task.author.id !== filter.author)
                     return false;
-                if (filter?.priority && cp.metadata.priority !== filter.priority)
+                if (filter?.priority && task.metadata.priority !== filter.priority)
                     return false;
                 if (filter?.tags && filter.tags.length > 0) {
-                    const cpTags = cp.metadata.tags || [];
-                    if (!filter.tags.some(tag => cpTags.includes(tag)))
+                    const taskTags = task.metadata.tags || [];
+                    if (!filter.tags.some(tag => taskTags.includes(tag)))
                         return false;
                 }
                 return true;
@@ -204,9 +208,9 @@ export class FileStorageAdapter {
             throw error;
         }
     }
-    async searchCPs(query) {
-        const allCPs = await this.listCPs();
-        const fuse = new Fuse(allCPs, {
+    async searchTasks(query) {
+        const allTasks = await this.listTasks();
+        const fuse = new Fuse(allTasks, {
             keys: [
                 { name: 'title', weight: 2 },
                 { name: 'intent', weight: 2 }, // Deprecated fallback
@@ -219,15 +223,16 @@ export class FileStorageAdapter {
         });
         return fuse.search(query).map(result => result.item);
     }
-    frontmatterToCP(data, content) {
-        // Handle both old and new format files
-        const steps = data.plan?.steps || data.steps || [];
-        // Transform comments to match expected format
-        const transformedComments = (data.comments || []).map((comment) => ({
+    frontmatterToTask(data, content) {
+        // Handle both old format (plan.steps) and new format (top-level steps)
+        const steps = data.steps || data.plan?.steps || [];
+        // Normalize comments using consistent field names (content/createdAt).
+        // Also handle legacy format (text/timestamp) for backward compatibility.
+        const normalizedComments = (data.comments || []).map((comment) => ({
             id: comment.id,
-            text: comment.content || comment.text || '', // Handle both content and text fields
             author: typeof comment.author === 'string' ? comment.author : comment.author?.name || 'Unknown',
-            timestamp: comment.createdAt || comment.timestamp || new Date().toISOString()
+            content: comment.content || comment.text || '',
+            createdAt: comment.createdAt || comment.timestamp || new Date().toISOString(),
         }));
         // Use title as primary, fall back to deprecated intent for backward compatibility
         const titleValue = data.title || data.intent || '';
@@ -260,6 +265,7 @@ export class FileStorageAdapter {
             telemetryContracts: data.telemetryContracts || [],
             releasePlan: data.releasePlan || { strategy: 'immediate' },
             status: data.status || 'draft',
+            comments: normalizedComments,
             metadata: {
                 createdAt: new Date(data.createdAt || Date.now()),
                 updatedAt: new Date(data.updatedAt || Date.now()),
@@ -267,16 +273,15 @@ export class FileStorageAdapter {
                 aiInteractions: data.aiInteractions || [],
                 tags: data.tags || [],
                 priority: data.priority || 'medium',
-                comments: transformedComments
             },
             content // Store the markdown content
         };
     }
-    getDefaultContent(cp) {
-        return `# ${cp.title}
+    getDefaultContent(task) {
+        return `# ${task.title}
 
 ## Problem Statement
-Describe the problem this change proposal addresses.
+Describe the problem this task addresses.
 
 ## Proposed Solution
 Describe the solution you're proposing.

package/dist/lib/terminal/terminal-manager.d.ts

@@ -2,13 +2,11 @@ import { WebSocket } from 'ws';
 import { ShellType } from './shell-utils.js';
 export interface TerminalSession {
     id: string;
-    proposalId: string;
+    taskId: string;
     pty: any;
     websocket?: WebSocket;
     createdAt: Date;
     lastActivity: Date;
-    enableLogging?: boolean;
-    logFilePath?: string;
     backlog: string;
     previewSockets?: Set<WebSocket>;
     previewBuffer?: string;
@@ -21,9 +19,9 @@ export declare class TerminalManager {
     private cleanupInterval;
     private static readonly MAX_BACKLOG_BYTES;
     constructor();
-    createSession(proposalId: string, enableLogging?: boolean, shellPreference?: ShellType, startupCommand?: string): Promise<TerminalSession>;
+    createSession(taskId: string, shellPreference?: ShellType, startupCommand?: string): Promise<TerminalSession>;
     getSession(sessionId: string): TerminalSession | undefined;
-    getSessionsByProposal(proposalId: string): TerminalSession[];
+    getSessionsByTask(taskId: string): TerminalSession[];
     attachWebSocket(sessionId: string, ws: WebSocket): boolean;
     destroySession(sessionId: string): boolean;
     resizeSession(sessionId: string, cols: number, rows: number): boolean;