@lovelybunch/api 1.0.76-alpha.7 → 1.0.76-alpha.8

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

@@ -0,0 +1,315 @@
+import { Context } from 'hono';
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        id: 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;
+        }[];
+        evidence: {
+            type: "test" | "benchmark" | "screenshot" | "log" | "other";
+            description: string;
+            data: any;
+            timestamp: string;
+        }[];
+        policies: {
+            id: string;
+            name: string;
+            description: string;
+            status: "pending" | "passed" | "failed" | "skipped";
+            message?: string;
+            checkedAt?: string;
+        }[];
+        featureFlags: {
+            id: string;
+            version: string;
+            name: string;
+            description: string;
+            type: import("@lovelybunch/types").FeatureFlagType;
+            defaultValue: any;
+            scopes: string[];
+            targets: {
+                audience: string;
+                value: any;
+                percentage?: number;
+            }[];
+            killSwitch: boolean;
+            dependencies: string[];
+            createdAt: string;
+            updatedAt: string;
+        }[];
+        experiments: {
+            id: string;
+            name: string;
+            hypothesis: string;
+            variants: {
+                id: string;
+                name: string;
+                description: string;
+                allocation: number;
+                config: {
+                    [x: string]: any;
+                };
+            }[];
+            allocation: {
+                method: "random" | "deterministic" | "weighted";
+                seed?: string;
+                totalAllocation: number;
+            };
+            successMetrics: string[];
+            guardrailMetrics: {
+                name: string;
+                threshold: number;
+                comparison: "greater" | "less" | "equal";
+                action: "alert" | "pause" | "stop";
+            }[];
+            stopRules: {
+                metric: string;
+                condition: string;
+                action: "stop" | "pause";
+            }[];
+            analysisConfig: {
+                confidenceLevel: number;
+                minimumSampleSize: number;
+                testType: "two-tailed" | "one-tailed";
+            };
+            status: import("@lovelybunch/types").ExperimentStatus;
+            startedAt?: string;
+            endedAt?: string;
+        }[];
+        telemetryContracts: {
+            eventName: string;
+            version: string;
+            schema: {
+                [x: string]: any;
+            };
+            piiFields: {
+                field: string;
+                classification: "none" | "quasi" | "sensitive" | "highly-sensitive";
+                handling: "clear" | "hash" | "encrypt" | "remove";
+            }[];
+            samplingRate: number;
+            retentionPolicy: {
+                duration: number;
+                archiveAfter?: number;
+                deleteAfter: number;
+            };
+            approvals: {
+                approver: string;
+                approvedAt: string;
+                comment?: string;
+            }[];
+        }[];
+        releasePlan: {
+            strategy: "immediate" | "gradual" | "scheduled" | "gated";
+            stages?: {
+                name: string;
+                percentage: number;
+                duration?: number;
+                criteria?: string[];
+            }[];
+            schedule?: string;
+            rollbackPlan?: string;
+        };
+        status: import("@lovelybunch/types").CPStatus;
+        metadata: {
+            createdAt: string;
+            updatedAt: string;
+            reviewers: string[];
+            aiInteractions: {
+                id: string;
+                timestamp: string;
+                model: string;
+                prompt: string;
+                response: string;
+                tokens: {
+                    prompt: number;
+                    completion: number;
+                    total: number;
+                };
+                cost?: number;
+            }[];
+            tags?: string[];
+            priority?: "low" | "medium" | "high" | "critical";
+        };
+    }[];
+}, 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;
+        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;
+        }[];
+        evidence: {
+            type: "test" | "benchmark" | "screenshot" | "log" | "other";
+            description: string;
+            data: any;
+            timestamp: string;
+        }[];
+        policies: {
+            id: string;
+            name: string;
+            description: string;
+            status: "pending" | "passed" | "failed" | "skipped";
+            message?: string;
+            checkedAt?: string;
+        }[];
+        featureFlags: {
+            id: string;
+            version: string;
+            name: string;
+            description: string;
+            type: import("@lovelybunch/types").FeatureFlagType;
+            defaultValue: any;
+            scopes: string[];
+            targets: {
+                audience: string;
+                value: any;
+                percentage?: number;
+            }[];
+            killSwitch: boolean;
+            dependencies: string[];
+            createdAt: string;
+            updatedAt: string;
+        }[];
+        experiments: {
+            id: string;
+            name: string;
+            hypothesis: string;
+            variants: {
+                id: string;
+                name: string;
+                description: string;
+                allocation: number;
+                config: {
+                    [x: string]: any;
+                };
+            }[];
+            allocation: {
+                method: "random" | "deterministic" | "weighted";
+                seed?: string;
+                totalAllocation: number;
+            };
+            successMetrics: string[];
+            guardrailMetrics: {
+                name: string;
+                threshold: number;
+                comparison: "greater" | "less" | "equal";
+                action: "alert" | "pause" | "stop";
+            }[];
+            stopRules: {
+                metric: string;
+                condition: string;
+                action: "stop" | "pause";
+            }[];
+            analysisConfig: {
+                confidenceLevel: number;
+                minimumSampleSize: number;
+                testType: "two-tailed" | "one-tailed";
+            };
+            status: import("@lovelybunch/types").ExperimentStatus;
+            startedAt?: string;
+            endedAt?: string;
+        }[];
+        telemetryContracts: {
+            eventName: string;
+            version: string;
+            schema: {
+                [x: string]: any;
+            };
+            piiFields: {
+                field: string;
+                classification: "none" | "quasi" | "sensitive" | "highly-sensitive";
+                handling: "clear" | "hash" | "encrypt" | "remove";
+            }[];
+            samplingRate: number;
+            retentionPolicy: {
+                duration: number;
+                archiveAfter?: number;
+                deleteAfter: number;
+            };
+            approvals: {
+                approver: string;
+                approvedAt: string;
+                comment?: string;
+            }[];
+        }[];
+        releasePlan: {
+            strategy: "immediate" | "gradual" | "scheduled" | "gated";
+            stages?: {
+                name: string;
+                percentage: number;
+                duration?: number;
+                criteria?: string[];
+            }[];
+            schedule?: string;
+            rollbackPlan?: string;
+        };
+        status: import("@lovelybunch/types").CPStatus;
+        metadata: {
+            createdAt: string;
+            updatedAt: string;
+            reviewers: string[];
+            aiInteractions: {
+                id: string;
+                timestamp: string;
+                model: string;
+                prompt: string;
+                response: string;
+                tokens: {
+                    prompt: number;
+                    completion: number;
+                    total: number;
+                };
+                cost?: number;
+            }[];
+            tags?: string[];
+            priority?: "low" | "medium" | "high" | "critical";
+        };
+    };
+}, 201, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;

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

@@ -0,0 +1,129 @@
+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';
+import { getSlackService } from '../../../../lib/slack/slack-service.js';
+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'); // Add search query parameter
+        let proposals = await storage.listCPs({
+            status,
+            author: author || undefined,
+            priority: priority || undefined,
+            tags
+        });
+        // Apply search filter if provided
+        if (searchQuery?.trim()) {
+            const fuse = new Fuse(proposals, {
+                keys: [
+                    { name: 'intent', weight: 0.4 },
+                    { 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);
+            proposals = searchResults.map(result => result.item);
+        }
+        return c.json({
+            success: true,
+            data: proposals
+        });
+    }
+    catch (error) {
+        console.error('Error listing proposals:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'LIST_PROPOSALS_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 proposal with required fields
+        const now = new Date();
+        const proposal = {
+            id: body.id || `cp-${Date.now()}`,
+            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 || [],
+            evidence: body.evidence || [],
+            policies: body.policies || [],
+            featureFlags: body.featureFlags || [],
+            experiments: body.experiments || [],
+            telemetryContracts: body.telemetryContracts || [],
+            releasePlan: body.releasePlan || { strategy: 'immediate' },
+            status: body.status || 'draft',
+            metadata: {
+                createdAt: now,
+                updatedAt: now,
+                reviewers: body.metadata?.reviewers || [],
+                aiInteractions: body.metadata?.aiInteractions || [],
+                tags: body.metadata?.tags || [],
+                priority: body.metadata?.priority || 'medium'
+            },
+            productSpecRef: body.productSpecRef
+        };
+        await storage.createCP(proposal);
+        // Log the proposal creation event
+        const logger = getLogger();
+        logger.log({
+            kind: 'proposal.create',
+            actor: proposal.author.type === 'agent'
+                ? `agent:${proposal.author.name}`
+                : `human:${proposal.author.email}`,
+            subject: `proposal:${proposal.id}`,
+            tags: ['proposal'],
+            payload: {
+                id: proposal.id,
+                intent: proposal.intent,
+                priority: proposal.metadata.priority,
+                author: proposal.author
+            }
+        });
+        // Send Slack notification (non-blocking)
+        getSlackService().sendNotification({
+            type: 'proposal.created',
+            proposalId: proposal.id,
+            intent: proposal.intent,
+            author: proposal.author.name,
+        }).catch(err => console.warn('[proposals] Slack notification failed:', err));
+        return c.json({
+            success: true,
+            data: proposal
+        }, 201);
+    }
+    catch (error) {
+        console.error('Error creating proposal:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'CREATE_PROPOSAL_ERROR',
+                message: error.message
+            }
+        }, 500);
+    }
+}

package/dist/routes/api/v1/terminal/[proposalId]/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/[proposalId]/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/[proposalId]/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;
+    proposalId: string;
+    createdAt: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;

package/dist/routes/api/v1/terminal/[proposalId]/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 proposalId = c.req.param('proposalId');
+        const body = await c.req.json().catch(() => ({}));
+        const { enableLogging = false, startupCommand } = body;
+        if (!proposalId) {
+            return c.json({ error: 'Proposal 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 proposal
+        const terminalManager = getGlobalTerminalManager();
+        const session = await terminalManager.createSession(proposalId, enableLogging, shellPreference, startupCommand);
+        return c.json({
+            sessionId: session.id,
+            proposalId: session.proposalId,
+            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/[proposalId]/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/[proposalId]/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/[proposalId]/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/[proposalId]/destroy/route.js

@@ -0,0 +1,21 @@
+import { getGlobalTerminalManager } from '../../../../../../lib/terminal/global-manager.js';
+export async function POST(c) {
+    try {
+        const proposalId = c.req.param('proposalId');
+        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/[proposalId]/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/[proposalId]/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/[proposalId]/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">)>;

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

@@ -0,0 +1,21 @@
+import { getGlobalTerminalManager } from '../../../../../../lib/terminal/global-manager.js';
+export async function POST(c) {
+    try {
+        const proposalId = c.req.param('proposalId');
+        const body = await c.req.json();
+        const { sessionId, cols, rows } = body;
+        if (!sessionId || !cols || !rows) {
+            return c.json({ error: 'Session ID, cols, and rows are required' }, 400);
+        }
+        const terminalManager = getGlobalTerminalManager();
+        const success = terminalManager.resizeSession(sessionId, cols, rows);
+        if (!success) {
+            return c.json({ error: 'Session not found or resize failed' }, 404);
+        }
+        return c.json({ success: true });
+    }
+    catch (error) {
+        console.error('Error resizing terminal session:', error);
+        return c.json({ error: 'Failed to resize terminal session' }, 500);
+    }
+}

package/dist/routes/api/v1/terminal/code/route.js

@@ -111,14 +111,6 @@ export async function POST(c) {
                 // Continue without worktree
             }
         }
-        // Create terminal session
-        const userSettings = await loadUserSettings();
-        const shellPreference = (userSettings.preferences.terminalShell || 'bash');
-        const startupCommand = worktreePath
-            ? `cd '${worktreePath.replace(/'/g, "'\\''")}'`
-            : undefined;
-        const terminalManager = getGlobalTerminalManager();
-        const session = await terminalManager.createSession(taskId, shellPreference, startupCommand);
         // Load MCP servers and skills
         const { servers: selectedMcpServers, mcpServersMap } = await loadMcpServers();
         const { skills, ids: selectedSkillIds } = await loadSkills();
@@ -143,14 +135,15 @@ export async function POST(c) {
         const banner = buildPipelineBanner({ taskId, cliAgent: agent, contextType, interactive });
         const exitSuffix = interactive ? '' : '; exit';
         const command = `printf '${banner}' && node ${scriptPath}${exitSuffix}`;
-        // Send the command to the terminal session after a brief delay for shell init
-        setTimeout(() => {
-            const s = terminalManager.getSession(session.id);
-            if (s?.pty) {
-                s.pty.write(command + '\r');
-                s.lastActivity = new Date();
-            }
-        }, 1500);
+        // Create terminal session with the pipeline command as a startup command
+        // so it runs via GAIT_STARTUP_CMD during shell init (same as the web UI path).
+        const userSettings = await loadUserSettings();
+        const shellPreference = (userSettings.preferences.terminalShell || 'bash');
+        const startupCommand = worktreePath
+            ? `cd '${worktreePath.replace(/'/g, "'\\''")}' && ${command}`
+            : command;
+        const terminalManager = getGlobalTerminalManager();
+        const session = await terminalManager.createSession(taskId, shellPreference, startupCommand);
         return c.json({
             sessionId: session.id,
             taskId: session.taskId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovelybunch/api",
-  "version": "1.0.76-alpha.7",
+  "version": "1.0.76-alpha.8",
   "type": "module",
   "main": "dist/server-with-static.js",
   "exports": {
@@ -37,9 +37,9 @@
     "@ai-sdk/anthropic": "^3.0.41",
     "@hono/node-server": "^1.13.7",
     "@hono/node-ws": "^1.0.6",
-    "@lovelybunch/core": "^1.0.76-alpha.7",
-    "@lovelybunch/mcp": "^1.0.76-alpha.7",
-    "@lovelybunch/types": "^1.0.76-alpha.7",
+    "@lovelybunch/core": "^1.0.76-alpha.8",
+    "@lovelybunch/mcp": "^1.0.76-alpha.8",
+    "@lovelybunch/types": "^1.0.76-alpha.8",
     "adm-zip": "^0.5.16",
     "ai": "^6.0.79",
     "bcryptjs": "^2.4.3",