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

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

@@ -0,0 +1,337 @@
+import { Context } from 'hono';
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        id: string;
+        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 PATCH(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;
+    };
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;
+export declare function DELETE(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;

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

@@ -0,0 +1,165 @@
+import { FileStorageAdapter } from '../../../../../lib/storage/file-storage.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 id = c.req.param('id');
+        const proposal = await storage.getCP(id);
+        if (!proposal) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'PROPOSAL_NOT_FOUND',
+                    message: `Proposal with id ${id} not found`
+                }
+            }, 404);
+        }
+        return c.json({
+            success: true,
+            data: proposal
+        });
+    }
+    catch (error) {
+        console.error('Error getting proposal:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'GET_PROPOSAL_ERROR',
+                message: error.message
+            }
+        }, 500);
+    }
+}
+export async function PATCH(c) {
+    try {
+        const id = c.req.param('id');
+        const updates = await c.req.json();
+        // Get existing proposal to merge updates properly
+        const existing = await storage.getCP(id);
+        if (!existing) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'PROPOSAL_NOT_FOUND',
+                    message: `Proposal with id ${id} not found`
+                }
+            }, 404);
+        }
+        // Handle special fields like comments
+        let finalUpdates = { ...updates };
+        if (updates.comments) {
+            finalUpdates = { ...finalUpdates, comments: updates.comments };
+        }
+        await storage.updateCP(id, finalUpdates);
+        // Fetch the updated proposal
+        const updatedProposal = await storage.getCP(id);
+        // Determine what changed
+        const changedFields = Object.keys(updates);
+        const oldStatus = existing.status;
+        const newStatus = updatedProposal?.status || existing.status;
+        // Log proposal.update event
+        const logger = getLogger();
+        logger.log({
+            kind: 'proposal.update',
+            actor: updatedProposal?.author.type === 'agent'
+                ? `agent:${updatedProposal.author.name}`
+                : `human:${updatedProposal?.author.email || 'unknown'}`,
+            subject: `proposal:${id}`,
+            tags: ['proposal'],
+            payload: {
+                id,
+                changes: changedFields,
+                oldStatus,
+                newStatus
+            }
+        });
+        // If status changed, also log a status.change event
+        if (oldStatus !== newStatus) {
+            logger.log({
+                kind: 'proposal.status.change',
+                actor: updatedProposal?.author.type === 'agent'
+                    ? `agent:${updatedProposal.author.name}`
+                    : `human:${updatedProposal?.author.email || 'unknown'}`,
+                subject: `proposal:${id}`,
+                tags: ['proposal', 'status'],
+                payload: {
+                    id,
+                    from: oldStatus,
+                    to: newStatus,
+                    reason: null
+                }
+            });
+            // Send Slack notification for status change (non-blocking)
+            getSlackService().sendNotification({
+                type: 'proposal.statusChange',
+                proposalId: id,
+                intent: updatedProposal?.intent || existing.intent,
+                status: newStatus,
+                previousStatus: oldStatus,
+            }).catch(err => console.warn('[proposals] Slack notification failed:', err));
+        }
+        return c.json({
+            success: true,
+            data: updatedProposal
+        });
+    }
+    catch (error) {
+        console.error('Error updating proposal:', error);
+        if (error.message.includes('not found')) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'PROPOSAL_NOT_FOUND',
+                    message: error.message
+                }
+            }, 404);
+        }
+        return c.json({
+            success: false,
+            error: {
+                code: 'UPDATE_PROPOSAL_ERROR',
+                message: error.message
+            }
+        }, 500);
+    }
+}
+export async function DELETE(c) {
+    try {
+        const id = c.req.param('id');
+        // Get proposal info before deleting
+        const proposal = await storage.getCP(id);
+        await storage.deleteCP(id);
+        // Log the deletion event
+        if (proposal) {
+            const logger = getLogger();
+            logger.log({
+                kind: 'proposal.delete',
+                actor: proposal.author.type === 'agent'
+                    ? `agent:${proposal.author.name}`
+                    : `human:${proposal.author.email || 'unknown'}`,
+                subject: `proposal:${id}`,
+                tags: ['proposal'],
+                payload: {
+                    id,
+                    intent: proposal.intent
+                }
+            });
+        }
+        return c.json({
+            success: true,
+            message: `Proposal ${id} deleted successfully`
+        });
+    }
+    catch (error) {
+        console.error('Error deleting proposal:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'DELETE_PROPOSAL_ERROR',
+                message: error.message
+            }
+        }, 500);
+    }
+}

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

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

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

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