@lovelybunch/api 1.0.75-alpha.9 → 1.0.75

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

@@ -49,44 +49,45 @@ 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',
+            ...(task.metadata.readiness != null && { readiness: task.metadata.readiness }),
             // 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
+                type: task.author.type
             },
             // Steps (top-level for consistency with CLI storage format)
-            steps: cp.planSteps.map(step => ({
+            steps: task.planSteps.map(step => ({
                 id: step.id,
                 description: step.description,
                 status: step.status,
@@ -96,10 +97,10 @@ export class FileStorageAdapter {
                 ...(step.executedAt && { executedAt: step.executedAt instanceof Date ? step.executedAt.toISOString() : step.executedAt }),
             })),
             // Metadata
-            tags: cp.metadata.tags || [],
+            tags: task.metadata.tags || [],
             labels: [],
             // Comments use consistent field names: id, author, content, createdAt
-            comments: (cp.comments || [])
+            comments: (task.comments || [])
                 .filter((c) => c !== undefined)
                 .map((c) => ({
                 id: c.id,
@@ -108,17 +109,17 @@ export class FileStorageAdapter {
                 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')
@@ -126,13 +127,13 @@ 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;
-        // Comments live at root level on ChangeProposal (not in metadata).
+        // 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) {
@@ -151,36 +152,36 @@ export class FileStorageAdapter {
             },
             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;
@@ -208,9 +209,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
@@ -223,7 +224,7 @@ export class FileStorageAdapter {
         });
         return fuse.search(query).map(result => result.item);
     }
-    frontmatterToCP(data, content) {
+    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).
@@ -258,30 +259,24 @@ export class FileStorageAdapter {
                 error: step.error,
                 executedAt: step.executedAt ? new Date(step.executedAt) : undefined
             })),
-            evidence: data.evidence || [],
-            policies: data.policies || [],
-            featureFlags: data.featureFlags || [],
-            experiments: data.experiments || [],
-            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()),
                 reviewers: data.reviewers || [],
-                aiInteractions: data.aiInteractions || [],
                 tags: data.tags || [],
                 priority: data.priority || 'medium',
+                ...(data.readiness != null && { readiness: data.readiness }),
             },
             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,7 +2,7 @@ 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;
@@ -19,9 +19,9 @@ export declare class TerminalManager {
     private cleanupInterval;
     private static readonly MAX_BACKLOG_BYTES;
     constructor();
-    createSession(proposalId: string, 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;

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

@@ -16,8 +16,8 @@ export class TerminalManager {
             this.cleanupInactiveSessions();
         }, 5 * 60 * 1000);
     }
-    async createSession(proposalId, shellPreference = 'bash', startupCommand) {
-        const sessionId = `${proposalId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    async createSession(taskId, shellPreference = 'bash', startupCommand) {
+        const sessionId = `${taskId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
         // Get the project root directory
         let projectRoot;
         if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
@@ -32,8 +32,8 @@ export class TerminalManager {
         }
         // Prepare context information
         const contextInfo = {
-            proposalId,
-            proposalPath: path.join(projectRoot, '.nut', 'proposals', `${proposalId}.md`),
+            proposalId: taskId,
+            proposalPath: path.join(projectRoot, '.nut', 'tasks', `${taskId}.md`),
             contextPath: path.join(projectRoot, '.nut', 'context'),
             projectRoot,
         };
@@ -76,9 +76,9 @@ export class TerminalManager {
         delete injected.NODE_ENV;
         const env = {
             ...injected,
-            COCONUT_PROPOSAL_ID: proposalId,
+            COCONUT_TASK_ID: taskId,
             COCONUT_CONTEXT_PATH: path.join(projectRoot, '.nut', 'context'),
-            COCONUT_PROPOSAL_PATH: path.join(projectRoot, '.nut', 'proposals', `${proposalId}.md`),
+            COCONUT_TASK_PATH: path.join(projectRoot, '.nut', 'tasks', `${taskId}.md`),
             GAIT_DATA_PATH: projectRoot,
             TERM: 'xterm-256color',
             COLORTERM: 'truecolor',
@@ -100,7 +100,7 @@ export class TerminalManager {
         });
         const session = {
             id: sessionId,
-            proposalId,
+            taskId,
             pty: ptyProcess,
             createdAt: new Date(),
             lastActivity: new Date(),
@@ -122,7 +122,7 @@ export class TerminalManager {
                 tags: ["agent", "terminal", "session"],
                 payload: {
                     sessionId,
-                    proposalId,
+                    taskId,
                     cwd: projectRoot,
                     shell: shellPath,
                 }
@@ -209,8 +209,8 @@ export class TerminalManager {
     getSession(sessionId) {
         return this.sessions.get(sessionId);
     }
-    getSessionsByProposal(proposalId) {
-        return Array.from(this.sessions.values()).filter(session => session.proposalId === proposalId);
+    getSessionsByTask(taskId) {
+        return Array.from(this.sessions.values()).filter(session => session.taskId === taskId);
     }
     attachWebSocket(sessionId, ws) {
         const session = this.sessions.get(sessionId);

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

@@ -6,8 +6,8 @@ import readline from 'readline';
 import { ZodError } from 'zod';
 import { streamText, tool, jsonSchema, stepCountIs } from 'ai';
 import { createAnthropic } from '@ai-sdk/anthropic';
-import { getLogsDir, listProposals, getProposal, createProposal, updateProposal, deleteProposal, } from '@lovelybunch/core';
-import { proposalsFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool, resourcesTool } from '@lovelybunch/mcp';
+import { getLogsDir, listTasks, getTask, createTask, updateTask, deleteTask, } from '@lovelybunch/core';
+import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool, resourcesTool } from '@lovelybunch/mcp';
 import matter from 'gray-matter';
 import Fuse from 'fuse.js';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
@@ -96,11 +96,11 @@ export async function POST(c) {
         // Using tool<any, string>() to properly type jsonSchema-based tools
         const storage = new FileStorageAdapter();
         const aiTools = {
-            change_proposals: tool({
-                description: proposalsFullTool.description,
-                inputSchema: jsonSchema(proposalsFullTool.parameters),
+            tasks: tool({
+                description: tasksFullTool.description,
+                inputSchema: jsonSchema(tasksFullTool.parameters),
                 execute: async (args) => {
-                    const result = await executeProposalsToolDirect(args, storage);
+                    const result = await executeTasksToolDirect(args, storage);
                     return JSON.stringify(result);
                 },
             }),
@@ -183,24 +183,44 @@ export async function POST(c) {
 // These are unchanged from the previous implementation. They handle the actual
 // business logic for each tool, called automatically by the AI SDK when the
 // LLM makes tool calls.
-async function executeProposalsToolDirect(args, _storage) {
-    const { operation, id, filters, proposal, updates } = args;
+async function executeTasksToolDirect(args, _storage) {
+    const { operation, id, filters, task, updates } = args;
     try {
         switch (operation) {
             case 'list': {
-                const proposals = await listProposals(filters || {});
+                const DEFAULT_LIST_LIMIT = 20;
+                const requestedLimit = filters?.limit;
+                const effectiveLimit = requestedLimit ?? DEFAULT_LIST_LIMIT;
+                const tasks = await listTasks(filters || {});
+                const totalCount = tasks.length;
+                const limited = tasks.slice(0, effectiveLimit);
+                // Return lightweight summaries to keep token usage manageable.
+                // The AI can use "get" with a specific task ID to retrieve full details.
+                const summaries = limited.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    status: t.status,
+                    priority: t.metadata?.priority,
+                    tags: t.metadata?.tags,
+                    author: t.author ? { name: t.author.name, type: t.author.type } : undefined,
+                    createdAt: t.metadata?.createdAt,
+                    updatedAt: t.metadata?.updatedAt,
+                }));
                 return {
                     success: true,
-                    data: proposals,
-                    count: proposals.length,
-                    message: `Found ${proposals.length} tasks`
+                    data: summaries,
+                    count: summaries.length,
+                    totalCount,
+                    message: totalCount > effectiveLimit
+                        ? `Showing ${summaries.length} of ${totalCount} tasks (limit: ${effectiveLimit}). Use filters or increase limit to see more. Use "get" with a task ID for full details.`
+                        : `Found ${totalCount} tasks. Use "get" with a task ID for full details.`
                 };
             }
             case 'get': {
                 if (!id) {
                     return { success: false, error: 'Task ID is required for get operation' };
                 }
-                const result = await getProposal(id);
+                const result = await getTask(id);
                 if (!result) {
                     return { success: false, error: 'Task not found' };
                 }
@@ -211,10 +231,10 @@ async function executeProposalsToolDirect(args, _storage) {
                 };
             }
             case 'create': {
-                if (!proposal) {
+                if (!task) {
                     return { success: false, error: 'Task data is required for create operation' };
                 }
-                const created = await createProposal(proposal);
+                const created = await createTask(task);
                 return {
                     success: true,
                     data: created,
@@ -225,11 +245,11 @@ async function executeProposalsToolDirect(args, _storage) {
                 if (!id) {
                     return { success: false, error: 'Task ID is required for update operation' };
                 }
-                const updateData = updates || proposal;
+                const updateData = updates || task;
                 if (!updateData) {
                     return { success: false, error: 'Update data is required for update operation' };
                 }
-                const updated = await updateProposal(id, updateData);
+                const updated = await updateTask(id, updateData);
                 return {
                     success: true,
                     data: updated,
@@ -240,7 +260,7 @@ async function executeProposalsToolDirect(args, _storage) {
                 if (!id) {
                     return { success: false, error: 'Task ID is required for delete operation' };
                 }
-                const deleted = await deleteProposal(id);
+                const deleted = await deleteTask(id);
                 if (!deleted) {
                     return { success: false, error: 'Task not found' };
                 }
@@ -264,7 +284,7 @@ async function executeProposalsToolDirect(args, _storage) {
                 }))
             };
         }
-        console.error('Error executing proposals tool:', error);
+        console.error('Error executing tasks tool:', error);
         return { success: false, error: error.message || 'Tool execution failed' };
     }
 }

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

@@ -331,6 +331,22 @@ app.post('/branches/:branch/merge', async (c) => {
         catch { }
         const mergeStrategy = strategy?.strategy === 'squash' || strategy?.strategy === 'rebase' ? strategy.strategy : 'merge';
         const result = await mergeBranch(name, mergeStrategy);
+        // Determine target branch for notification
+        try {
+            const { runGit } = await import('../../../../lib/git.js');
+            const { stdout: branchOutput } = await runGit(['branch', '--show-current']);
+            const targetBranch = branchOutput.trim();
+            // Send Slack notification (non-blocking)
+            import('../../../../lib/slack/slack-service.js').then(({ getSlackService }) => {
+                getSlackService().sendNotification({
+                    type: 'git.merge',
+                    branch: name,
+                    targetBranch,
+                    message: `Merged ${name} into ${targetBranch} using ${mergeStrategy}`,
+                }).catch(err => console.warn('[git] Slack notification failed:', err));
+            }).catch(() => { });
+        }
+        catch { }
         return c.json({ success: true, data: { branch: name, strategy: mergeStrategy, result } });
     }
     catch (e) {
@@ -466,6 +482,13 @@ app.post('/push', async (c) => {
                     remote: remoteName,
                 }
             });
+            // Send Slack notification (non-blocking)
+            import('../../../../lib/slack/slack-service.js').then(({ getSlackService }) => {
+                getSlackService().sendNotification({
+                    type: 'git.push',
+                    branch: currentBranch,
+                }).catch(err => console.warn('[git] Slack notification failed:', err));
+            }).catch(() => { });
         }
         catch (logError) {
             console.error('Error logging push:', logError);

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

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

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

@@ -0,0 +1,23 @@
+import { Hono } from 'hono';
+import { listMailHandler, getMailHandler, setMailStatusHandler, setMailActionHandler, replyMailHandler, sendMailHandler, deleteMailHandler, inboundWebhookHandler, getMailProcessingHandler, stopMailProcessingHandler, } from './route.js';
+const mailRoutes = new Hono();
+// Resend inbound webhook
+mailRoutes.post('/inbound', inboundWebhookHandler);
+// Send email (coming soon)
+mailRoutes.post('/send', sendMailHandler);
+// Processing status and control
+mailRoutes.get('/:id/processing', getMailProcessingHandler);
+mailRoutes.post('/:id/processing/stop', stopMailProcessingHandler);
+// Set email status (read/unread)
+mailRoutes.put('/:id/status', setMailStatusHandler);
+// Set agent action summary
+mailRoutes.put('/:id/action', setMailActionHandler);
+// Reply to email
+mailRoutes.post('/:id/reply', replyMailHandler);
+// List emails in folder
+mailRoutes.get('/:folder', listMailHandler);
+// Get specific email in folder
+mailRoutes.get('/:folder/:id', getMailHandler);
+// Delete email from folder
+mailRoutes.delete('/:folder/:id', deleteMailHandler);
+export { mailRoutes };