workflows integrated

Author: Gerome-Elassaad

.gitignore

@@ -24,6 +24,8 @@ claude.md
 
 .env
 
+.mcp.json 
+
 # production
 /build
 

app/api/chat/route.ts

@@ -4,7 +4,8 @@ import { LLMModel, LLMModelConfig } from '@/lib/models'
 import { toPrompt } from '@/lib/prompt'
 import ratelimit from '@/lib/ratelimit'
 import { fragmentSchema as schema } from '@/lib/schema'
-import { Templates } from '@/lib/templates'
+import { TemplateId } from '@/lib/templates'
+import templates from '@/lib/templates'
 import { streamObject, LanguageModel, CoreMessage } from 'ai'
 
 export const maxDuration = 60
@@ -28,7 +29,7 @@ export async function POST(req: Request) {
     messages: CoreMessage[]
     userID: string | undefined
     teamID: string | undefined
-    template: Templates
+    template: TemplateId
     model: LLMModel
     config: LLMModelConfig
   } = await req.json()
@@ -61,7 +62,7 @@ export async function POST(req: Request) {
   const modelClient = getModelClient(model, config)
 
   try {
-    const systemPrompt = toPrompt(template);
+    const systemPrompt = toPrompt(templates);
 
     const stream = await streamObject({
       model: modelClient as LanguageModel,

app/api/debug/route.ts

@@ -0,0 +1,80 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { createServerClient } from '@/lib/supabase-server'
+import { errorAnalyzer } from '@/lib/debugging/error-analyzer'
+
+export const dynamic = 'force-dynamic'
+
+export async function POST(request: NextRequest) {
+  try {
+    const supabase = createServerClient()
+    const { data: { session } } = await supabase.auth.getSession()
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await request.json()
+    const { error, context, code } = body
+
+    if (!error) {
+      return NextResponse.json(
+        { error: 'Error message is required' },
+        { status: 400 }
+      )
+    }
+
+    // Analyze error in background
+    const errorContext = {
+      fragment: { code, template: 'code-interpreter-v1' },
+      template: 'code-interpreter-v1' as any,
+      executionResult: {} as any,
+      code,
+      ...(context || {})
+    }
+    const analysis = await errorAnalyzer.analyzeError(error, errorContext)
+
+    return NextResponse.json(analysis)
+  } catch (error) {
+    console.error('Error analyzing error:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}
+
+// GET /api/debug - Get debug session
+export async function GET(request: NextRequest) {
+  try {
+    const supabase = createServerClient()
+    const { data: { session } } = await supabase.auth.getSession()
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const searchParams = request.nextUrl.searchParams
+    const sessionId = searchParams.get('session_id')
+
+    if (sessionId) {
+      const debugSession = errorAnalyzer.getDebugSession(sessionId)
+      if (!debugSession) {
+        return NextResponse.json(
+          { error: 'Debug session not found' },
+          { status: 404 }
+        )
+      }
+      return NextResponse.json(debugSession)
+    }
+
+    // Return active debug sessions
+    const sessions = errorAnalyzer.getActiveSessions()
+    return NextResponse.json({ sessions })
+  } catch (error) {
+    console.error('Error fetching debug session:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}

app/api/deployments/[id]/rollback/route.ts

@@ -0,0 +1,37 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { createServerClient } from '@/lib/supabase-server'
+import { deploymentEngine } from '@/lib/deployment/deployment-engine'
+
+export const dynamic = 'force-dynamic'
+
+// POST /api/deployments/[id]/rollback - Rollback deployment
+export async function POST(
+  request: NextRequest,
+  { params }: { params: { id: string } }
+) {
+  try {
+    const supabase = createServerClient()
+    const { data: { session } } = await supabase.auth.getSession()
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const rolledBack = await deploymentEngine.rollbackDeployment(params.id)
+    
+    if (!rolledBack) {
+      return NextResponse.json(
+        { error: 'Deployment cannot be rolled back' },
+        { status: 400 }
+      )
+    }
+
+    return NextResponse.json({ success: true, message: 'Deployment rolled back' })
+  } catch (error) {
+    console.error('Error rolling back deployment:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}

app/api/deployments/[id]/route.ts

@@ -0,0 +1,69 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { createServerClient } from '@/lib/supabase-server'
+import { deploymentEngine } from '@/lib/deployment/deployment-engine'
+
+export const dynamic = 'force-dynamic'
+
+// GET /api/deployments/[id] - Get deployment status
+export async function GET(
+  request: NextRequest,
+  { params }: { params: { id: string } }
+) {
+  try {
+    const supabase = createServerClient()
+    const { data: { session } } = await supabase.auth.getSession()
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const status = deploymentEngine.getDeploymentStatus(params.id)
+    
+    if (!status) {
+      return NextResponse.json(
+        { error: 'Deployment not found' },
+        { status: 404 }
+      )
+    }
+
+    return NextResponse.json(status)
+  } catch (error) {
+    console.error('Error fetching deployment status:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}
+
+// DELETE /api/deployments/[id] - Cancel deployment
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: { id: string } }
+) {
+  try {
+    const supabase = createServerClient()
+    const { data: { session } } = await supabase.auth.getSession()
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const cancelled = await deploymentEngine.cancelDeployment(params.id)
+    
+    if (!cancelled) {
+      return NextResponse.json(
+        { error: 'Deployment cannot be cancelled' },
+        { status: 400 }
+      )
+    }
+
+    return NextResponse.json({ success: true, message: 'Deployment cancelled' })
+  } catch (error) {
+    console.error('Error cancelling deployment:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}

app/api/deployments/route.ts

@@ -0,0 +1,77 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { createServerClient } from '@/lib/supabase-server'
+import { deploymentEngine } from '@/lib/deployment/deployment-engine'
+import { FragmentSchema } from '@/lib/schema'
+
+export const dynamic = 'force-dynamic'
+
+// POST /api/deployments - Deploy fragment
+export async function POST(request: NextRequest) {
+  try {
+    const supabase = createServerClient()
+    const { data: { session } } = await supabase.auth.getSession()
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await request.json()
+    const { fragment, config } = body
+
+    if (!fragment || !config) {
+      return NextResponse.json(
+        { error: 'Fragment and config are required' },
+        { status: 400 }
+      )
+    }
+
+    // Validate fragment schema
+    const fragmentData = fragment as FragmentSchema
+    if (!fragmentData.template || !fragmentData.code) {
+      return NextResponse.json(
+        { error: 'Fragment must have template and code' },
+        { status: 400 }
+      )
+    }
+
+    // Start deployment in background
+    const deploymentResult = await deploymentEngine.deployFragment(fragmentData, config)
+
+    return NextResponse.json(deploymentResult)
+  } catch (error) {
+    console.error('Error deploying fragment:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}
+
+// GET /api/deployments - List deployments
+export async function GET(request: NextRequest) {
+  try {
+    const supabase = createServerClient()
+    const { data: { session } } = await supabase.auth.getSession()
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const searchParams = request.nextUrl.searchParams
+    const fragmentId = searchParams.get('fragment_id')
+
+    if (fragmentId) {
+      const history = deploymentEngine.getDeploymentHistory(fragmentId)
+      return NextResponse.json({ deployments: history })
+    }
+
+    // For now, return empty array since we don't have user-specific deployment tracking
+    return NextResponse.json({ deployments: [] })
+  } catch (error) {
+    console.error('Error listing deployments:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}