update with removing a

backend/package.json

@@ -25,4 +25,4 @@
     "ts-node-dev": "^2.0.0",
     "typescript": "^5.3.0"
   }
-}
+}

backend/src/index.ts

@@ -24,4 +24,4 @@ app.use('/api/generate', generateRouter);
 
 app.listen(PORT, () => {
   console.log(`Backend running on port ${PORT}`);
-});
+});

backend/src/services/archestra.ts

@@ -3,66 +3,78 @@ import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import EventSource from "eventsource";
 
 export class ArchestraService {
-  private client: Client;
-  private transport: SSEClientTransport;
+  private client: Client | null = null;
+  private transport: SSEClientTransport | null = null;
   private isConnected: boolean = false;
+  private useLocalFallback: boolean = false;
 
   constructor() {
-    const baseUrl = process.env.ARCHESTRA_URL || "http://localhost:9000";
     const profileId = process.env.ARCHESTRA_PROFILE_ID;
-    const token = process.env.ARCHESTRA_TOKEN;
+    const baseUrl = process.env.ARCHESTRA_URL;
 
-    if (!profileId) throw new Error("ARCHESTRA_PROFILE_ID is required");
-    
     // Polyfill EventSource for Node.js
     // @ts-ignore
     global.EventSource = EventSource;
 
-    this.transport = new SSEClientTransport(
-      new URL(`${baseUrl}/v1/mcp/${profileId}`),
-      {
-        eventSourceInit: {
+    if (profileId && baseUrl) {
+      console.log("Configuring Archestra Platform connection...");
+      this.transport = new SSEClientTransport(
+        new URL(`${baseUrl}/v1/mcp/${profileId}`),
+        {
+          eventSourceInit: {
             headers: {
-                Authorization: `Bearer ${token}`
+              Authorization: `Bearer ${process.env.ARCHESTRA_TOKEN}`
             }
-        }
-      } as any
-    );
+          }
+        } as any
+      );
 
-    this.client = new Client(
-      {
-        name: "readmere-backend",
-        version: "1.0.0",
-      },
-      {
-        capabilities: {},
-      }
-    );
+      this.client = new Client(
+        { name: "readmere-backend", version: "1.0.0" },
+        { capabilities: {} }
+      );
+    } else {
+      console.warn("ARCHESTRA_PROFILE_ID or URL not found. Using direct local agent connection.");
+      this.useLocalFallback = true;
+    }
   }
 
   async connect() {
-    if (this.isConnected) return;
-    await this.client.connect(this.transport);
-    this.isConnected = true;
-    console.log("Connected to Archestra MCP Gateway");
+    if (this.useLocalFallback || this.isConnected) return;
+    if (!this.client || !this.transport) return;
+
+    try {
+      await this.client.connect(this.transport);
+      this.isConnected = true;
+      console.log("Connected to Archestra MCP Gateway");
+    } catch (e) {
+      console.error("Failed to connect to Archestra, falling back to local agents.");
+      this.useLocalFallback = true;
+    }
   }
 
-  async listTools() {
-    await this.connect();
-    return await this.client.listTools();
+  private async callLocalAgent(port: number, toolName: string, args: any) {
+    const localTransport = new SSEClientTransport(new URL(`http://localhost:${port}/sse`));
+    const localClient = new Client(
+      { name: "local-dispatcher", version: "1.0.0" },
+      { capabilities: {} }
+    );
+
+    await localClient.connect(localTransport);
+    const result = await localClient.callTool({
+      name: toolName,
+      arguments: args,
+    });
+    
+    // Cleanup connection
+    await localClient.close();
+    return result;
   }
 
   async callTool(name: string, args: any) {
-    try {
-      await this.connect();
-      return await this.client.callTool({
-        name,
-        arguments: args,
-      });
-    } catch (error) {
-      console.warn(`Archestra Gateway unreachable, attempting direct call for tool: ${name}`);
-      
-      // Fallback: Map tool names to local agent ports
+    await this.connect();
+
+    if (this.useLocalFallback) {
       const portMap: Record<string, number> = {
         'analyze_repository': 3002,
         'get_repo_metadata': 3002,
@@ -76,13 +88,15 @@ export class ArchestraService {
       };
 
       const port = portMap[name];
-      if (!port) throw error;
-
-      // Direct MCP-over-HTTP call to the local agent
-      const response = await fetch(`http://localhost:${port}/sse`); // This is simplified for the example
-      // In a real hackathon fallback, you'd use a direct fetch to the tool logic or a mock
-      // For now, we will throw a clearer error so the user knows to fix the platform
-      throw new Error("Archestra Platform is required for this orchestration. Please ensure yadnyeshkolte-archestra-platform is running.");
+      if (!port) throw new Error(`Tool ${name} not supported in local mode`);
+      
+      console.log(`Direct Call: ${name} on port ${port}`);
+      return await this.callLocalAgent(port, name, args);
     }
+
+    return await this.client!.callTool({
+      name,
+      arguments: args,
+    });
   }
-}
+}