@lovelybunch/api 1.0.75-alpha.8 → 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,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;

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

@@ -16,8 +16,8 @@ export class TerminalManager {
             this.cleanupInactiveSessions();
         }, 5 * 60 * 1000);
     }
-    async createSession(proposalId, enableLogging = false, 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,
         };
@@ -65,22 +65,6 @@ export class TerminalManager {
         catch (error) {
             console.error('Error creating init script:', error);
         }
-        // Set up logging if enabled
-        let logFilePath;
-        if (enableLogging) {
-            const sessionsDir = path.join(projectRoot, '.nut', 'sessions');
-            try {
-                fs.mkdirSync(sessionsDir, { recursive: true });
-                logFilePath = path.join(sessionsDir, `${sessionId}.log`);
-                // Create log file with session header
-                const logHeader = `# Terminal Session Log\n# Session ID: ${sessionId}\n# Proposal ID: ${proposalId}\n# Created: ${new Date().toISOString()}\n\n`;
-                fs.writeFileSync(logFilePath, logHeader);
-            }
-            catch (error) {
-                console.error('Error setting up session logging:', error);
-                logFilePath = undefined;
-            }
-        }
         // Get shell arguments
         const shellArgs = getShellArgs(shellPath, initScriptPath);
         // Prepare environment variables with API keys injected.
@@ -92,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',
@@ -116,12 +100,10 @@ export class TerminalManager {
         });
         const session = {
             id: sessionId,
-            proposalId,
+            taskId,
             pty: ptyProcess,
             createdAt: new Date(),
             lastActivity: new Date(),
-            enableLogging,
-            logFilePath,
             backlog: '',
             previewSockets: new Set(),
             previewBuffer: '',
@@ -140,7 +122,7 @@ export class TerminalManager {
                 tags: ["agent", "terminal", "session"],
                 payload: {
                     sessionId,
-                    proposalId,
+                    taskId,
                     cwd: projectRoot,
                     shell: shellPath,
                 }
@@ -153,17 +135,6 @@ export class TerminalManager {
         // Set up PTY event handlers
         ptyProcess.onData((data) => {
             session.lastActivity = new Date();
-            // Log data if logging is enabled
-            if (session.enableLogging && session.logFilePath) {
-                try {
-                    const timestamp = new Date().toISOString();
-                    const logEntry = `[${timestamp}] OUTPUT: ${data}`;
-                    fs.appendFileSync(session.logFilePath, logEntry);
-                }
-                catch (error) {
-                    console.error('Error writing to session log:', error);
-                }
-            }
             // Maintain in-memory backlog (trim to last MAX_BACKLOG_BYTES)
             try {
                 // Append and trim to max size
@@ -187,17 +158,6 @@ export class TerminalManager {
         ptyProcess.onExit((e) => {
             const endTime = new Date();
             const duration = endTime.getTime() - session.createdAt.getTime();
-            // Log session end if logging is enabled
-            if (session.enableLogging && session.logFilePath) {
-                try {
-                    const timestamp = endTime.toISOString();
-                    const logEntry = `\n[${timestamp}] SESSION ENDED: Exit code ${e.exitCode}\n`;
-                    fs.appendFileSync(session.logFilePath, logEntry);
-                }
-                catch (error) {
-                    console.error('Error writing session end to log:', error);
-                }
-            }
             // Log session end to activity log
             try {
                 const logger = getLogger();
@@ -249,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);
@@ -289,17 +249,6 @@ export class TerminalManager {
                 const data = JSON.parse(message.toString());
                 switch (data.type) {
                     case 'input':
-                        // Log input if logging is enabled
-                        if (session.enableLogging && session.logFilePath) {
-                            try {
-                                const timestamp = new Date().toISOString();
-                                const logEntry = `[${timestamp}] INPUT: ${data.data}`;
-                                fs.appendFileSync(session.logFilePath, logEntry);
-                            }
-                            catch (error) {
-                                console.error('Error writing input to session log:', error);
-                            }
-                        }
                         session.pty.write(data.data);
                         session.lastActivity = new Date();
                         break;