merging

Author: williams21v

README.md

@@ -45,6 +45,7 @@ AutoDeploy/
 │       └── github-oauth.js      # helper functions for GitHub API
     ├── routes/
 │   │   └── auth.github.js       # all GitHub OAuth + /me routes
+		└── usersRoutes
 │   ├── server.js                # Express bootstrap & route mounting
 │   ├── db.js                    # pg Pool + query() + healthCheck()
 │

server/agent/wizardAgent.js

@@ -0,0 +1,64 @@
+
+
+import OpenAI from "openai";
+import dotenv from "dotenv";
+import fetch from "node-fetch";
+
+dotenv.config();
+const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+// Helper: call MCP routes dynamically
+async function callMCPTool(tool, input) {
+  const response = await fetch(`http://localhost:4000/mcp/v1/${tool}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(input),
+  });
+  return await response.json();
+}
+
+// Wizard Agent Core
+export async function runWizardAgent(userPrompt) {
+  const systemPrompt = `
+  You are the MCP Wizard Agent. 
+  You have access to these tools:
+  - repo_reader: lists repos and branches
+  - pipeline_generator: builds a CI/CD pipeline YAML
+  - oidc_adapter: lists AWS roles or Jenkins jobs
+  Decide which tool to call based on user intent and return results in plain text.
+  `;
+
+  const completion = await client.chat.completions.create({
+    model: "gpt-4o-mini",
+    messages: [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt },
+    ],
+  });
+
+  const decision = completion.choices[0].message.content;
+  console.log("\n🤖 Agent decided:", decision);
+
+  // Basic keyword trigger (mock reasoning)
+  if (decision.toLowerCase().includes("repo")) return await callMCPTool("repo_reader", {});
+  if (decision.toLowerCase().includes("pipeline"))
+    return await callMCPTool("pipeline_generator", {
+      repo: "askmyrepo",
+      provider: "aws",
+      template: "node_app",
+    });
+  if (decision.toLowerCase().includes("role") || decision.toLowerCase().includes("jenkins"))
+    return await callMCPTool("oidc_adapter", { provider: "aws" });
+
+  return { message: "No matching tool found." };
+}
+
+// Example local test (can comment out for production)
+if (process.argv[2]) {
+  const input = process.argv.slice(2).join(" ");
+  runWizardAgent(input)
+    .then((res) => {
+      console.log("\n📦 Tool Output:\n", res);
+    })
+    .catch(console.error);
+}

server/routes/mcp.js

@@ -0,0 +1,45 @@
+import express from "express";
+import { MCP_TOOLS } from "../tools/index.js";
+
+const router = express.Router();
+
+// Utility logger
+const logRequest = (req, route) => {
+  console.log(`[MCP] ${new Date().toISOString()} | user=${req.headers["x-user-id"] || "anonymous"} | route=${route}`);
+};
+
+// --- MCP Status Route ---
+router.get("/status", (req, res) => {
+  logRequest(req, "/mcp/v1/status");
+
+  res.json({
+    status: "ok",
+    version: "v1.0.0",
+    tools_registered: Object.keys(MCP_TOOLS),
+    timestamp: new Date().toISOString(),
+  });
+});
+
+// Dynamic route: handles any tool in registry
+router.all("/:tool_name", async (req, res) => {
+  const { tool_name } = req.params;
+  const tool = MCP_TOOLS[tool_name];
+  logRequest(req, `/mcp/v1/${tool_name}`);
+
+  if (!tool) {
+    return res.status(404).json({ success: false, error: `Tool '${tool_name}' not found.` });
+  }
+
+  try {
+    // Merge query + body to handle GET or POST
+    const input = { ...req.query, ...req.body };
+    const validatedInput = tool.input_schema.parse(input);
+    const data = await tool.handler(validatedInput);
+    res.json({ success: true, data });
+  } catch (error) {
+    console.error(`Error in ${tool_name}:`, error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+export default router;

server/routes/usersRoutes.js

@@ -0,0 +1,48 @@
+import { Router } from 'express';
+import { z } from 'zod';
+import { query } from '../db.js';
+
+const router = Router();
+
+/** Users */
+const UserBody = z.object({
+  email: z.string().email(),
+  github_username: z.string().min(1).optional(),
+});
+
+// Create or upsert user by email
+router.post('/users', async (req, res) => {
+  const parse = UserBody.safeParse(req.body);
+  if (!parse.success)
+    return res.status(400).json({ error: parse.error.message });
+  const { email, github_username } = parse.data;
+
+  // upsert on email; requires a unique index on users.email
+  try {
+    const rows = await query(
+      `
+      insert into users (email, github_username)
+      values ($1, $2)
+      on conflict (email) do update set github_username = excluded.github_username
+      returning *;
+      `,
+      [email, github_username ?? null]
+    );
+    res.status(201).json({ user: rows[0] });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+router.get('/users', async (_req, res) => {
+  try {
+    const rows = await query(
+      `select * from users order by created_at desc limit 100;`
+    );
+    res.json({ users: rows });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+export default router;

server/server.js

@@ -3,9 +3,10 @@ import express from 'express';
 import cors from 'cors';
 import helmet from 'helmet';
 import morgan from 'morgan';
-import { healthCheck, query } from './db.js';
+import { healthCheck } from './db.js';
 import githubAuthRouter from './routes/auth.github.js';
-import { z } from 'zod';
+import userRouter from './routes/usersRoutes.js';
+import mcpRoutes from './routes/mcp.js';
 
 const app = express();
 app.use(express.json());
@@ -26,45 +27,31 @@ app.get('/db/ping', async (_req, res) => {
   }
 });
 
-/** Users */
-const UserBody = z.object({
-  email: z.string().email(),
-  github_username: z.string().min(1).optional(),
+// Mount users route at /users
+app.use('/', userRouter);
+
+// --- Request Logging Middleware ---
+app.use((req, res, next) => {
+  const user = req.headers['x-user-id'] || 'anonymous';
+  console.log(
+    `[${new Date().toISOString()}] ${req.method} ${
+      req.originalUrl
+    } | user=${user}`
+  );
+  next();
 });
 
-// Create or upsert user by email
-app.post('/users', async (req, res) => {
-  const parse = UserBody.safeParse(req.body);
-  if (!parse.success)
-    return res.status(400).json({ error: parse.error.message });
-  const { email, github_username } = parse.data;
-
-  // upsert on email; requires a unique index on users.email
-  try {
-    const rows = await query(
-      `
-      insert into users (email, github_username)
-      values ($1, $2)
-      on conflict (email) do update set github_username = excluded.github_username
-      returning *;
-      `,
-      [email, github_username ?? null]
-    );
-    res.status(201).json({ user: rows[0] });
-  } catch (e) {
-    res.status(500).json({ error: e.message });
-  }
-});
-
-app.get('/users', async (_req, res) => {
-  try {
-    const rows = await query(
-      `select * from users order by created_at desc limit 100;`
-    );
-    res.json({ users: rows });
-  } catch (e) {
-    res.status(500).json({ error: e.message });
-  }
+// -- Agent entry point
+app.use('/mcp/v1', mcpRoutes);
+
+// --- Global Error Handler ---
+app.use((err, req, res, next) => {
+  console.error('Global Error:', err);
+  res.status(500).json({
+    success: false,
+    error: 'Internal Server Error',
+    message: err.message,
+  });
 });
 
 // Mount GitHub OAuth routes at /auth/github

server/src/MCP_Hybrid_AI_Wizard_Flow.md

@@ -0,0 +1,126 @@
+# 🧭 MCP Hybrid AI Wizard – Flow & Module Architecture
+
+This document shows how user-driven input and AI-driven automation combine within the MCP system.  
+The goal: users still interact with forms, while the AI Wizard orchestrates MCP tools to build pipelines and deploy them automatically.
+
+---
+
+## 🧩 High-Level Flow
+
+```mermaid
+flowchart TD
+
+A[User UI / Wizard Form] -->|Form Data| B[AI Wizard Agent]
+B -->|Decides Which Tool(s) to Use| C[MCP API Layer]
+C -->|REST Call| D[Tool Endpoint]
+D -->|Calls Integration Stub| E[Integration Layer]
+E -->|Returns Mock/Real Data| C
+C -->|Response| B
+B -->|Summarized Result / Next Step| A
+```
+
+---
+
+## ⚙️ Module Breakdown
+
+### 1️⃣ Frontend (Wizard UI)
+- Presents form fields (repo, branch, provider, template).
+- Sends collected inputs to the **AI Wizard Agent**.
+- Renders conversation steps or results returned by the agent.
+
+**Tech stack:** React + Zustand + shadcn/ui  
+**Responsibility:** UX and data capture.
+
+---
+
+### 2️⃣ AI Wizard Agent
+- Acts as the **intelligent middle layer** between the user and the MCP tools.
+- Determines which tool(s) to invoke based on the user’s form data and conversation context.
+- Parses MCP responses, summarizes, and sends human-readable updates back to UI.
+
+**Example logic:**
+```js
+if (user.provider === "aws") useTool("oidc_adapter");
+useTool("pipeline_generator", user);
+```
+
+**Responsibility:** Reasoning, orchestration, and dynamic flow.
+
+---
+
+### 3️⃣ MCP API Layer
+- Express server exposing endpoints under `/mcp/v1`.
+- Validates input with Zod.
+- Routes requests to internal tool modules (repo_reader, pipeline_generator, oidc_adapter).
+
+**Responsibility:** Standardize all backend access through predictable JSON schemas.
+
+---
+
+### 4️⃣ MCP Tools (under `/server/tools/`)
+Each tool = single responsibility function with metadata and schema.
+
+Example structure:
+```js
+export const pipeline_generator = {
+  name: "pipeline_generator",
+  description: "Generate CI/CD YAML for a given repo and provider",
+  input_schema: z.object({
+    repo: z.string(),
+    provider: z.enum(["aws", "jenkins"]),
+    template: z.string()
+  }),
+  handler: async (params) => { ... }
+}
+```
+
+**Responsibility:** Encapsulate logic for each automation unit.
+
+---
+
+### 5️⃣ Integrations Layer
+- Mock or real API wrappers for external systems.
+- Organized by provider type.
+
+Structure:
+```
+server/integrations/
+├── github/
+│   └── index.js
+├── aws/
+│   └── index.js
+└── jenkins/
+    └── index.js
+```
+
+**Responsibility:** Handle API auth, SDK calls, and return normalized data.
+
+---
+
+### 6️⃣ Database (Supabase / Postgres)
+- Stores users, connections, and tokens (encrypted).
+- Provides audit logs of which tools ran under which user.
+
+**Responsibility:** Persistence and security layer.
+
+---
+
+## ✅ Summary
+
+| Layer | Role | Example Interaction |
+|-------|------|----------------------|
+| Frontend | Collects user input | Form submits data |
+| AI Wizard | Decides which MCP tool to use | “I’ll generate your AWS pipeline.” |
+| MCP Server | Hosts tools and APIs | `/mcp/v1/pipeline_generator` |
+| Tools | Do one job well | Return YAML or list of roles |
+| Integrations | Communicate externally | AWS IAM, GitHub, Jenkins |
+| Database | Persist context | Users, connections, logs |
+
+---
+
+## 🧠 Next Steps for Implementation
+1. Create `/server/routes/mcp.js` to modularize endpoints.  
+2. Move endpoint logic into `/server/tools/`.  
+3. Register each tool in an MCP registry.  
+4. Integrate the AI Wizard (OpenAI, LangChain, or custom agent).  
+5. Have the agent call MCP tools dynamically based on user input.