ui-read

Signed-off-by: Arya Pratap Singh <notaryasingh@gmail.com>

Author: ARYPROGRAMMER

backend-services/dsa_agent/__init__.py

@@ -0,0 +1,5 @@
+from .complexity_analyzer import analyze_complexity
+from .visualizer import generate_visualization
+from .test_generator import generate_test_cases
+
+__all__ = ['analyze_complexity', 'generate_visualization', 'generate_test_cases']

backend-services/dsa_agent/agent.py

@@ -0,0 +1,136 @@
+# langgraph_agent.py
+from typing import Dict, List, Tuple, Any
+from langchain_core.messages import HumanMessage, SystemMessage
+from langgraph.prebuilt import ToolExecutor
+from langgraph.graph import Graph, END
+from langchain_groq import ChatGroq
+from langchain_core.tools import Tool
+import operator
+from typing import TypedDict, Annotated, Sequence
+import json
+
+# Define types for our graph
+class AgentState(TypedDict):
+    messages: Annotated[Sequence[Dict], operator.add]
+    next: str
+
+# Initialize Groq LLM
+llm = ChatGroq(
+    api_key="your-groq-api-key",
+    model_name="mixtral-8x7b-32768"
+)
+
+# Define our tools
+def analyze_complexity(code: str) -> Dict[str, str]:
+    """Analyzes time and space complexity of given code"""
+    prompt = f"Analyze the following code and provide its time and space complexity:\n{code}"
+    response = llm.invoke(prompt)
+    return {
+        "timeComplexity": response.content.split("Time Complexity:")[1].split("Space Complexity:")[0].strip(),
+        "spaceComplexity": response.content.split("Space Complexity:")[1].strip()
+    }
+
+def generate_visualization(problem: str) -> str:
+    """Generates a Mermaid diagram for the problem"""
+    prompt = f"Create a Mermaid diagram to visualize the solution approach for this problem:\n{problem}"
+    response = llm.invoke(prompt)
+    return response.content
+
+def generate_test_cases(problem: str) -> List[Dict[str, str]]:
+    """Generates test cases for the problem"""
+    prompt = f"Generate 3 diverse test cases for this problem:\n{problem}"
+    response = llm.invoke(prompt)
+    return json.loads(response.content)
+
+tools = [
+    Tool(
+        name="complexity_analyzer",
+        description="Analyzes time and space complexity of code",
+        func=analyze_complexity
+    ),
+    Tool(
+        name="visualizer",
+        description="Generates Mermaid diagram for visualization",
+        func=generate_visualization
+    ),
+    Tool(
+        name="test_generator",
+        description="Generates test cases",
+        func=generate_test_cases
+    )
+]
+
+# Create tool executor
+tool_executor = ToolExecutor(tools)
+
+# Define agent functions
+def should_use_tool(state: AgentState) -> Tuple[str, str]:
+    """Decide if and which tool to use"""
+    messages = state["messages"]
+    response = llm.invoke(
+        messages + [SystemMessage(content="What tool should be used next? Reply with 'END' if no tool is needed.")]
+    )
+    tool_name = response.content
+    return "tool" if tool_name != "END" else "end", tool_name
+
+def call_tool(state: AgentState, tool_name: str) -> AgentState:
+    """Call the specified tool"""
+    messages = state["messages"]
+    # Extract relevant info from messages and call tool
+    result = tool_executor.execute(tool_name, messages[-1].content)
+    return {
+        "messages": messages + [HumanMessage(content=str(result))],
+        "next": "agent"
+    }
+
+def process_response(state: AgentState) -> AgentState:
+    """Process the final response"""
+    messages = state["messages"]
+    final_response = llm.invoke(messages + [SystemMessage(content="Provide final solution summary")])
+    return {
+        "messages": messages + [final_response],
+        "next": "end"
+    }
+
+# Create the graph
+workflow = Graph()
+
+# Add nodes
+workflow.add_node("agent", should_use_tool)
+workflow.add_node("tool", call_tool)
+workflow.add_node("process", process_response)
+
+# Add edges
+workflow.add_edge("agent", "tool")
+workflow.add_edge("tool", "agent")
+workflow.add_edge("agent", "process")
+workflow.add_edge("process", END)
+
+# Compile the graph
+app = workflow.compile()
+
+def solve_dsa_problem(problem: str, test_cases: List[Dict[str, str]] = None) -> Dict:
+    """Main function to solve DSA problems"""
+    initial_state = {
+        "messages": [HumanMessage(content=problem)],
+        "next": "agent"
+    }
+    result = app.invoke(initial_state)
+    
+    # Process result into structured format
+    final_message = result["messages"][-1].content
+    # Parse the response into required format
+    try:
+        response_dict = json.loads(final_message)
+    except:
+        # Fallback structure if parsing fails
+        response_dict = {
+            "explanation": final_message,
+            "code": "",
+            "timeComplexity": "",
+            "spaceComplexity": "",
+            "visualization": "",
+            "testCases": test_cases or []
+        }
+    
+    return response_dict

backend-services/dsa_agent/complexity-analyser.py

@@ -0,0 +1,21 @@
+from typing import Dict
+from langchain_groq import ChatGroq
+
+def analyze_complexity(code: str, llm: ChatGroq) -> Dict[str, str]:
+    """Analyzes time and space complexity of given code"""
+    prompt = f"""Analyze the following code and provide its time and space complexity.
+    Format the response as JSON with keys 'timeComplexity' and 'spaceComplexity'.
+    
+    Code:
+    {code}
+    """
+    
+    response = llm.invoke(prompt)
+    
+    try:
+        return eval(response.content)
+    except:
+        return {
+            "timeComplexity": "Unknown",
+            "spaceComplexity": "Unknown"
+        }

backend-services/dsa_agent/test_generator.py

@@ -0,0 +1,20 @@
+from typing import List, Dict
+from langchain_groq import ChatGroq
+import json
+
+def generate_test_cases(problem: str, llm: ChatGroq) -> List[Dict[str, str]]:
+    """Generates test cases for the problem"""
+    prompt = f"""Generate 3 diverse test cases for this problem.
+    Include edge cases and normal cases.
+    Format as JSON array with 'input' and 'output' keys.
+    
+    Problem:
+    {problem}
+    """
+    
+    response = llm.invoke(prompt)
+    
+    try:
+        return json.loads(response.content)
+    except:
+        return [{"input": "", "output": ""}]

backend-services/dsa_agent/visualiser.py

@@ -0,0 +1,13 @@
+from langchain_groq import ChatGroq
+
+def generate_visualization(problem: str, llm: ChatGroq) -> str:
+    """Generates a Mermaid diagram for the problem"""
+    prompt = f"""Create a Mermaid diagram to visualize the solution approach for this problem.
+    Use proper Mermaid syntax and focus on the algorithm's flow.
+    
+    Problem:
+    {problem}
+    """
+    
+    response = llm.invoke(prompt)
+    return response.content.strip()

frontend-interface/app/api/copilot/route.ts

@@ -0,0 +1,73 @@
+// import { NextRequest } from "next/server";
+// import {
+//   CopilotRuntime,
+//   GroqAdapter,
+//   copilotRuntimeNextJSAppRouterEndpoint,
+// } from "@copilotkit/runtime";
+
+// const serviceAdapter = new GroqAdapter({ model: "llama-3.3-70b-versatile" });
+
+// const runtime = new CopilotRuntime({
+//   remoteEndpoints: [
+//     {
+//       url: process.env.REMOTE_ACTION_URL || "http://localhost:8000/copilotkit",
+//     },
+//   ],
+// });
+
+// export const POST = async (req: NextRequest) => {
+//   const { handleRequest } = copilotRuntimeNextJSAppRouterEndpoint({
+//     runtime,
+//     serviceAdapter,
+//     endpoint: "/api/copilotkit",
+//   });
+
+//   return handleRequest(req);
+// };
+
+import { NextResponse } from 'next/server';
+
+import { analyzeDSAProblem } from '@/lib/python-bridge';
+import { createGroqClient } from '@/lib/groq';
+
+const groq = createGroqClient();
+
+export async function POST(req: Request) {
+  try {
+    const { question, testCases } = await req.json();
+    
+    interface DSASolution {
+      explanation: string;
+      [key: string]: any;
+    }
+
+    // Call Python agent through API
+    const solution = await analyzeDSAProblem(question, testCases) as DSASolution;
+    
+    // Get additional insights from Groq
+    const additionalInsights = await groq.chat.completions.create({
+      messages: [
+        {
+          role: "system",
+          content: "You are a DSA expert. Provide additional insights for the solution."
+        },
+        {
+          role: "user",
+          content: `Problem: ${question}\nSolution: ${solution.explanation}`
+        }
+      ],
+      model: "mixtral-8x7b-32768",
+    });
+
+    return NextResponse.json({
+      ...solution,
+      additionalInsights: additionalInsights.choices[0].message.content
+    });
+  } catch (error) {
+    console.error('Error:', error);
+    return NextResponse.json(
+      { error: 'Failed to process request' },
+      { status: 500 }
+    );
+  }
+}

frontend-interface/app/globals.css

@@ -3,19 +3,84 @@
 @tailwind utilities;
 
 :root {
-  --background: #ffffff;
-  --foreground: #171717;
+  --foreground-rgb: 0, 0, 0;
+  --background-start-rgb: 214, 219, 220;
+  --background-end-rgb: 255, 255, 255;
 }
 
 @media (prefers-color-scheme: dark) {
   :root {
-    --background: #0a0a0a;
-    --foreground: #ededed;
+    --foreground-rgb: 255, 255, 255;
+    --background-start-rgb: 0, 0, 0;
+    --background-end-rgb: 0, 0, 0;
   }
 }
 
-body {
-  color: var(--foreground);
-  background: var(--background);
-  font-family: Arial, Helvetica, sans-serif;
+/* Ensure Comfortaa is used for all text */
+body, input, textarea, button {
+  font-family: 'Comfortaa', sans-serif;
 }
+@layer base {
+  :root {
+    --background: 0 0% 100%;
+    --foreground: 0 0% 3.9%;
+    --card: 0 0% 100%;
+    --card-foreground: 0 0% 3.9%;
+    --popover: 0 0% 100%;
+    --popover-foreground: 0 0% 3.9%;
+    --primary: 0 0% 9%;
+    --primary-foreground: 0 0% 98%;
+    --secondary: 0 0% 96.1%;
+    --secondary-foreground: 0 0% 9%;
+    --muted: 0 0% 96.1%;
+    --muted-foreground: 0 0% 45.1%;
+    --accent: 0 0% 96.1%;
+    --accent-foreground: 0 0% 9%;
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 0 0% 98%;
+    --border: 0 0% 89.8%;
+    --input: 0 0% 89.8%;
+    --ring: 0 0% 3.9%;
+    --chart-1: 12 76% 61%;
+    --chart-2: 173 58% 39%;
+    --chart-3: 197 37% 24%;
+    --chart-4: 43 74% 66%;
+    --chart-5: 27 87% 67%;
+    --radius: 0.5rem;
+  }
+  .dark {
+    --background: 0 0% 3.9%;
+    --foreground: 0 0% 98%;
+    --card: 0 0% 3.9%;
+    --card-foreground: 0 0% 98%;
+    --popover: 0 0% 3.9%;
+    --popover-foreground: 0 0% 98%;
+    --primary: 0 0% 98%;
+    --primary-foreground: 0 0% 9%;
+    --secondary: 0 0% 14.9%;
+    --secondary-foreground: 0 0% 98%;
+    --muted: 0 0% 14.9%;
+    --muted-foreground: 0 0% 63.9%;
+    --accent: 0 0% 14.9%;
+    --accent-foreground: 0 0% 98%;
+    --destructive: 0 62.8% 30.6%;
+    --destructive-foreground: 0 0% 98%;
+    --border: 0 0% 14.9%;
+    --input: 0 0% 14.9%;
+    --ring: 0 0% 83.1%;
+    --chart-1: 220 70% 50%;
+    --chart-2: 160 60% 45%;
+    --chart-3: 30 80% 55%;
+    --chart-4: 280 65% 60%;
+    --chart-5: 340 75% 55%;
+  }
+}
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}
+