@aiready/agents 0.3.4 → 0.3.6

package/.turbo/turbo-test.log

@@ -1,16 +1,44 @@
 
 
-> @aiready/agents@0.3.3 test /Users/pengcao/projects/aiready/packages/agents
+> @aiready/agents@0.3.5 test /Users/pengcao/projects/aiready/packages/agents
 > vitest run
 
 [?25l
  RUN  v4.0.18 /Users/pengcao/projects/aiready/packages/agents
 
- ✓ src/__tests__/smoke.test.ts (1 test) 1ms
+ ✓ src/__tests__/smoke.test.ts (1 test) 3ms
+stdout | src/__tests__/remediation-swarm.test.ts > RemediationSwarm (MCP Powered) > should successfully connect to MCP, execute agent, and parse JSON response
+[RemediationSwarm] Connecting to MCP servers...
 
- Test Files  1 passed (1)
-      Tests  1 passed (1)
-   Start at  10:36:36
-   Duration  217ms (transform 23ms, setup 0ms, import 29ms, tests 1ms, environment 0ms)
+stdout | src/__tests__/remediation-swarm.test.ts > RemediationSwarm (MCP Powered) > should successfully connect to MCP, execute agent, and parse JSON response
+[RemediationSwarm] Executing agent logic...
+
+stdout | src/__tests__/remediation-swarm.test.ts > RemediationSwarm (MCP Powered) > should successfully connect to MCP, execute agent, and parse JSON response
+[RemediationSwarm] Cleaning up MCP connections...
+
+stdout | src/__tests__/remediation-swarm.test.ts > RemediationSwarm (MCP Powered) > should handle agent failures and return error status
+[RemediationSwarm] Connecting to MCP servers...
+
+stdout | src/__tests__/remediation-swarm.test.ts > RemediationSwarm (MCP Powered) > should handle agent failures and return error status
+[RemediationSwarm] Executing agent logic...
+
+stdout | src/__tests__/remediation-swarm.test.ts > RemediationSwarm (MCP Powered) > should handle agent failures and return error status
+[RemediationSwarm] Cleaning up MCP connections...
+
+stdout | src/__tests__/remediation-swarm.test.ts > RemediationSwarm (MCP Powered) > should fallback to raw text if agent fails to return valid JSON
+[RemediationSwarm] Connecting to MCP servers...
+
+stdout | src/__tests__/remediation-swarm.test.ts > RemediationSwarm (MCP Powered) > should fallback to raw text if agent fails to return valid JSON
+[RemediationSwarm] Executing agent logic...
+
+stdout | src/__tests__/remediation-swarm.test.ts > RemediationSwarm (MCP Powered) > should fallback to raw text if agent fails to return valid JSON
+[RemediationSwarm] Cleaning up MCP connections...
+
+ ✓ src/__tests__/remediation-swarm.test.ts (3 tests) 5ms
+
+ Test Files  2 passed (2)
+      Tests  4 passed (4)
+   Start at  10:12:50
+   Duration  308ms (transform 206ms, setup 0ms, import 251ms, tests 8ms, environment 0ms)
 
 [?25h

package/package.json

@@ -1,19 +1,22 @@
 {
   "name": "@aiready/agents",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Agentic remediation and analysis system for AIReady",
   "main": "index.js",
   "type": "module",
   "dependencies": {
     "@mastra/core": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@octokit/rest": "^21.0.0",
+    "isomorphic-git": "^1.25.0",
     "zod": "^4.0.0",
-    "@aiready/core": "0.23.4",
-    "@aiready/cli": "0.14.5"
+    "@aiready/core": "0.23.7",
+    "@aiready/cli": "0.14.9"
   },
   "devDependencies": {
+    "@types/node": "^24.0.0",
     "typescript": "^5.0.0",
-    "vitest": "^4.0.0",
-    "@types/node": "^24.0.0"
+    "vitest": "^4.0.0"
   },
   "scripts": {
     "test": "vitest run",

package/src/__tests__/remediation-swarm.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RemediationSwarm } from '../workflows/remediation-swarm';
+import { MCPAdapter } from '../tools/mcp-adapter';
+import { Agent } from '@mastra/core/agent';
+
+// Mock MCPAdapter
+vi.mock('../tools/mcp-adapter', () => {
+  const MockAdapter = vi.fn();
+  MockAdapter.prototype.connect = vi.fn().mockResolvedValue(undefined);
+  MockAdapter.prototype.disconnect = vi.fn().mockResolvedValue(undefined);
+  MockAdapter.prototype.getMastraTools = vi.fn().mockResolvedValue({
+    'list-files': { id: 'list-files', execute: vi.fn() },
+    'create-pr': { id: 'create-pr', execute: vi.fn() },
+  });
+  return { MCPAdapter: MockAdapter };
+});
+
+// Mock Mastra Agent
+vi.mock('@mastra/core/agent', () => {
+  const MockAgent = vi.fn();
+  MockAgent.prototype.generate = vi.fn().mockResolvedValue({
+    text: JSON.stringify({
+      status: 'success',
+      diff: 'test-diff',
+      prUrl: 'https://github.com/test/repo/pull/1',
+      prNumber: 1,
+      explanation: 'Fixed duplication in auth.ts',
+    }),
+  });
+  return { Agent: MockAgent };
+});
+
+describe('RemediationSwarm (MCP Powered)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should successfully connect to MCP, execute agent, and parse JSON response', async () => {
+    const input = {
+      remediation: { id: 'rem-1', type: 'consolidation' },
+      repo: { url: 'https://github.com/test/repo' },
+      rootDir: '/tmp/test-repo',
+      config: {
+        githubToken: 'gh-token-123',
+        openaiApiKey: 'oa-key-456',
+      },
+    };
+
+    const result = await RemediationSwarm.execute(input);
+
+    // Verify MCP Adapters were created and connected
+    expect(MCPAdapter).toHaveBeenCalledTimes(2);
+
+    const mockInstances = vi.mocked(MCPAdapter).mock.instances;
+    for (const instance of mockInstances) {
+      expect(instance.connect).toHaveBeenCalled();
+      expect(instance.getMastraTools).toHaveBeenCalled();
+      expect(instance.disconnect).toHaveBeenCalled();
+    }
+
+    // Verify result structure
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.status).toBe('success');
+      expect(result.value.prUrl).toBe('https://github.com/test/repo/pull/1');
+    }
+  });
+
+  it('should handle agent failures and return error status', async () => {
+    // Override mock for this specific test
+    const MockAgent = vi.mocked(Agent);
+    (MockAgent.prototype.generate as any).mockResolvedValueOnce({
+      text: JSON.stringify({
+        status: 'failure',
+        explanation: 'Could not find the duplicated files',
+      }),
+    });
+
+    const input = {
+      remediation: { id: 'rem-2' },
+      repo: { url: 'https://github.com/test/repo' },
+      rootDir: '/tmp/test',
+      config: { githubToken: 'token' },
+    };
+
+    const result = await RemediationSwarm.execute(input);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.status).toBe('failure');
+      expect(result.value.explanation).toBe(
+        'Could not find the duplicated files'
+      );
+    }
+  });
+
+  it('should fallback to raw text if agent fails to return valid JSON', async () => {
+    const MockAgent = vi.mocked(Agent);
+    (MockAgent.prototype.generate as any).mockResolvedValueOnce({
+      text: 'Applied fixes manually. PR created at https://github.com/test/repo/pull/99',
+    });
+
+    const input = {
+      remediation: { id: 'rem-3' },
+      repo: { url: 'https://github.com/test/repo' },
+      rootDir: '/tmp/test',
+      config: { githubToken: 'token' },
+    };
+
+    const result = await RemediationSwarm.execute(input);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.status).toBe('success');
+      expect(result.value.explanation).toContain('fallback to text response');
+    }
+  });
+});

package/src/refactor-agent.ts

@@ -1,32 +1,37 @@
 import { Agent } from '@mastra/core/agent';
 import { z } from 'zod';
+import { githubTools } from './tools/github';
+import { fsTools } from './tools/fs';
 
 export const RefactorAgent = new Agent({
   id: 'refactor-agent',
   name: 'Refactor Agent',
   instructions: `
     You are an expert full-stack engineer specialized in code consolidation and refactoring.
-    Your task is to take detected code duplicates or fragmentation issues and consolidate them into reusable components or utilities.
-
-    Follow these rules:
-    1. Preserve functionality: The behavior of the code must remain identical.
-    2. Follow patterns: Match the existing project's implementation patterns (e.g., React hooks, utility functions).
-    3. Type safety: Ensure all changes are correctly typed in TypeScript.
-    4. Minimal changes: Only modify what is necessary to resolve the duplication.
+    Your task is to take a detected code duplication or fragmentation issue and fix it.
 
     Workflow:
-    - Read the affected files.
-    - Extract the common logic into a new or existing shared location.
-    - Update the original call sites to use the consolidated logic.
-    - Verify with type checking if possible.
+    1. Research: Read the affected files using 'read-file'.
+    2. Branching: Create a new branch remotely using 'create-branch' AND locally using 'checkout-branch'.
+    3. Remediation: Consolidate the logic and write the changes using 'write-file'. 
+       Ensure type safety and preserve functionality.
+    4. Persist: Commit and push the changes using 'commit-and-push'.
+    5. Finalize: Create a Pull Request with a clear description using 'create-pr'.
+
+    Return a summary of your actions, including the PR URL and a unified diff of your changes.
   `,
   model: 'openai/gpt-4o',
+  tools: {
+    ...githubTools,
+    ...fsTools,
+  },
 });
 
 export const RefactorResultSchema = z.object({
   status: z.enum(['success', 'failure']),
   diff: z.string(),
-  filesModified: z.array(z.string()),
+  prUrl: z.string().optional(),
+  prNumber: z.number().optional(),
   explanation: z.string(),
 });
 

package/src/tools/fs.ts

@@ -0,0 +1,137 @@
+import { createTool } from '@mastra/core/tools';
+import { z } from 'zod';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as git from 'isomorphic-git';
+import http from 'isomorphic-git/http/node';
+
+export const fsTools = {
+  readFile: createTool({
+    id: 'read-file',
+    description: 'Read the contents of a file',
+    inputSchema: z.object({
+      rootDir: z.string(),
+      filePath: z.string(),
+    }),
+    outputSchema: z.object({
+      content: z.string().optional(),
+      error: z.string().optional(),
+    }),
+    execute: async ({ rootDir, filePath }) => {
+      try {
+        const fullPath = path.join(rootDir, filePath);
+        const content = fs.readFileSync(fullPath, 'utf-8');
+        return { content };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : 'Unknown error',
+        };
+      }
+    },
+  }),
+
+  writeFile: createTool({
+    id: 'write-file',
+    description: 'Write contents to a file',
+    inputSchema: z.object({
+      rootDir: z.string(),
+      filePath: z.string(),
+      content: z.string(),
+    }),
+    outputSchema: z.object({
+      success: z.boolean(),
+      error: z.string().optional(),
+    }),
+    execute: async ({ rootDir, filePath, content }) => {
+      try {
+        const fullPath = path.join(rootDir, filePath);
+        // Ensure directory exists
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, content, 'utf-8');
+        return { success: true };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : 'Unknown error',
+        };
+      }
+    },
+  }),
+
+  commitAndPush: createTool({
+    id: 'commit-and-push',
+    description: 'Commit all changes and push to a branch',
+    inputSchema: z.object({
+      rootDir: z.string(),
+      branchName: z.string(),
+      message: z.string(),
+      githubToken: z.string(),
+    }),
+    outputSchema: z.object({
+      success: z.boolean(),
+      error: z.string().optional(),
+    }),
+    execute: async ({ rootDir, branchName, message, githubToken }) => {
+      try {
+        // 1. Add all changed files
+        await git.add({ fs, dir: rootDir, filepath: '.' });
+
+        // 2. Commit
+        await git.commit({
+          fs,
+          dir: rootDir,
+          message,
+          author: {
+            name: 'AIReady Remediation Agent',
+            email: 'agents@getaiready.dev',
+          },
+        });
+
+        // 3. Push
+        await git.push({
+          fs,
+          http,
+          dir: rootDir,
+          ref: branchName,
+          onAuth: () => ({ username: githubToken, password: '' }),
+        });
+
+        return { success: true };
+      } catch (error) {
+        console.error('[FSTool] Error during commit/push:', error);
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : 'Unknown error',
+        };
+      }
+    },
+  }),
+
+  checkoutBranch: createTool({
+    id: 'checkout-branch',
+    description: 'Create and/or checkout a local branch',
+    inputSchema: z.object({
+      rootDir: z.string(),
+      branchName: z.string(),
+      create: z.boolean().default(true),
+    }),
+    outputSchema: z.object({
+      success: z.boolean(),
+      error: z.string().optional(),
+    }),
+    execute: async ({ rootDir, branchName, create }) => {
+      try {
+        if (create) {
+          await git.branch({ fs, dir: rootDir, ref: branchName });
+        }
+        await git.checkout({ fs, dir: rootDir, ref: branchName, force: true });
+        return { success: true };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : 'Unknown error',
+        };
+      }
+    },
+  }),
+};

package/src/tools/github.ts

@@ -1,29 +1,57 @@
 import { createTool } from '@mastra/core/tools';
 import { z } from 'zod';
+import { Octokit } from '@octokit/rest';
 
-// Note: In a real implementation, this would use Octokit with appropriate auth
 export const githubTools = {
   createBranch: createTool({
     id: 'create-branch',
     description: 'Create a new branch in the repository',
     inputSchema: z.object({
-      repoId: z.string(),
-      branchName: z.string(),
-      baseBranch: z.string().default('main'),
+      repoUrl: z.string().describe('The full URL of the repository'),
+      branchName: z.string().describe('The name of the new branch'),
+      baseBranch: z
+        .string()
+        .default('main')
+        .describe('The base branch to branch off from'),
+      githubToken: z.string().describe('GitHub Personal Access Token'),
     }),
     outputSchema: z.object({
       success: z.boolean(),
-      branchUrl: z.string().optional(),
+      branchName: z.string().optional(),
+      error: z.string().optional(),
     }),
-    execute: async (input) => {
-      console.log(
-        `[GitHubTool] Creating branch ${input.branchName} from ${input.baseBranch}`
-      );
-      // Mock implementation
-      return {
-        success: true,
-        branchUrl: `https://github.com/placeholder/${input.branchName}`,
-      };
+    execute: async ({ repoUrl, branchName, baseBranch, githubToken }) => {
+      try {
+        const octokit = new Octokit({ auth: githubToken });
+        const [owner, repo] = repoUrl
+          .replace('https://github.com/', '')
+          .replace('git@github.com:', '')
+          .replace('.git', '')
+          .split('/');
+
+        // 1. Get the SHA of the base branch
+        const { data: ref } = await octokit.git.getRef({
+          owner,
+          repo,
+          ref: `heads/${baseBranch}`,
+        });
+
+        // 2. Create the new branch
+        await octokit.git.createRef({
+          owner,
+          repo,
+          ref: `refs/heads/${branchName}`,
+          sha: ref.object.sha,
+        });
+
+        return { success: true, branchName };
+      } catch (error) {
+        console.error('[GitHubTool] Error creating branch:', error);
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : 'Unknown error',
+        };
+      }
     },
   }),
 
@@ -31,25 +59,49 @@ export const githubTools = {
     id: 'create-pr',
     description: 'Create a Pull Request for a branch',
     inputSchema: z.object({
-      repoId: z.string(),
-      title: z.string(),
-      body: z.string(),
-      head: z.string(),
-      base: z.string().default('main'),
+      repoUrl: z.string().describe('The full URL of the repository'),
+      title: z.string().describe('PR Title'),
+      body: z.string().describe('PR Description/Body'),
+      head: z.string().describe('The branch containing the changes'),
+      base: z.string().default('main').describe('The branch to merge into'),
+      githubToken: z.string().describe('GitHub Personal Access Token'),
     }),
     outputSchema: z.object({
       success: z.boolean(),
       prNumber: z.number().optional(),
       prUrl: z.string().optional(),
+      error: z.string().optional(),
     }),
-    execute: async (input) => {
-      console.log(`[GitHubTool] Creating PR: ${input.title}`);
-      // Mock implementation
-      return {
-        success: true,
-        prNumber: 123,
-        prUrl: 'https://github.com/placeholder/pull/123',
-      };
+    execute: async ({ repoUrl, title, body, head, base, githubToken }) => {
+      try {
+        const octokit = new Octokit({ auth: githubToken });
+        const [owner, repo] = repoUrl
+          .replace('https://github.com/', '')
+          .replace('git@github.com:', '')
+          .replace('.git', '')
+          .split('/');
+
+        const { data: pr } = await octokit.pulls.create({
+          owner,
+          repo,
+          title,
+          body,
+          head,
+          base: base || 'main',
+        });
+
+        return {
+          success: true,
+          prNumber: pr.number,
+          prUrl: pr.html_url,
+        };
+      } catch (error) {
+        console.error('[GitHubTool] Error creating PR:', error);
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : 'Unknown error',
+        };
+      }
     },
   }),
 };

package/src/tools/mcp-adapter.ts

@@ -0,0 +1,105 @@
+import { createTool } from '@mastra/core/tools';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+/**
+ * MCPAdapter allows connecting to external MCP servers and exposing their tools to Mastra agents.
+ */
+export class MCPAdapter {
+  private client: Client;
+  private transport: StdioClientTransport;
+
+  constructor(
+    command: string,
+    args: string[] = [],
+    env: Record<string, string> = {}
+  ) {
+    this.transport = new StdioClientTransport({
+      command,
+      args,
+      env: { ...process.env, ...env } as any,
+    });
+
+    this.client = new Client({ name: 'aiready-mcp-adapter', version: '1.0.0' });
+  }
+
+  async connect() {
+    await this.client.connect(this.transport);
+  }
+
+  async disconnect() {
+    await this.transport.close();
+  }
+
+  /**
+   * Discovers tools from the MCP server and wraps them as Mastra tools.
+   */
+  async getMastraTools(): Promise<Record<string, any>> {
+    const { tools } = await (this.client as any).request(
+      ListToolsRequestSchema,
+      {}
+    );
+    const mastraTools: Record<string, any> = {};
+
+    for (const tool of tools) {
+      mastraTools[tool.name] = createTool({
+        id: tool.name,
+        description: tool.description || `MCP Tool: ${tool.name}`,
+        inputSchema: this.mapJsonSchemaToZod(tool.inputSchema),
+        execute: async (args) => {
+          const result = await (this.client as any).request(
+            CallToolRequestSchema,
+            {
+              name: tool.name,
+              arguments: args,
+            }
+          );
+          return result;
+        },
+      });
+    }
+
+    return mastraTools;
+  }
+
+  /**
+   * Simple mapper from JSON Schema (MCP) to Zod (Mastra)
+   * Note: This is a basic implementation and might need enhancement for complex schemas.
+   */
+  private mapJsonSchemaToZod(schema: any): z.ZodObject<any> {
+    const shape: Record<string, z.ZodTypeAny> = {};
+
+    if (schema.type === 'object' && schema.properties) {
+      for (const [key, value] of Object.entries<any>(schema.properties)) {
+        let zodType: z.ZodTypeAny = z.any();
+
+        if (value.type === 'string') {
+          zodType = z.string();
+        } else if (value.type === 'number') {
+          zodType = z.number();
+        } else if (value.type === 'boolean') {
+          zodType = z.boolean();
+        } else if (value.type === 'array') {
+          zodType = z.array(z.any());
+        }
+
+        if (value.description) {
+          zodType = zodType.describe(value.description);
+        }
+
+        if (schema.required?.includes(key)) {
+          shape[key] = zodType;
+        } else {
+          shape[key] = zodType.optional();
+        }
+      }
+    }
+
+    return z.object(shape);
+  }
+}

package/src/workflows/remediation-swarm.ts

@@ -1,18 +1,128 @@
-import { Workflow } from '@mastra/core/workflows';
-import { z } from 'zod';
-import { PrioritizationAgent } from '../prioritization-agent';
-import { ImpactAgent } from '../impact-agent';
-import { RestructureAgent } from '../restructure-agent';
-import { RefactorAgent } from '../refactor-agent';
-import { ValidationAgent } from '../validation-agent';
-
-export const RemediationSwarm = new Workflow({
-  id: 'remediation-swarm',
-  inputSchema: z.any(),
-  outputSchema: z.any(),
-})
-  .then(PrioritizationAgent as any)
-  .then(ImpactAgent as any)
-  .then(RestructureAgent as any)
-  .then(RefactorAgent as any)
-  .then(ValidationAgent as any);
+import { Agent } from '@mastra/core/agent';
+import { MCPAdapter } from '../tools/mcp-adapter';
+
+// Standard MCP server commands (configured for a standard Node environment)
+// In a real SST/Lambda environment, these should be pre-installed or bundled.
+const GITHUB_MCP_COMMAND = 'npx';
+const GITHUB_MCP_ARGS = ['-y', '@modelcontextprotocol/server-github'];
+
+const FILESYSTEM_MCP_COMMAND = 'npx';
+const FILESYSTEM_MCP_ARGS = ['-y', '@modelcontextprotocol/server-filesystem'];
+
+export const RemediationSwarm = {
+  execute: async (input: any) => {
+    const { remediation, repo, rootDir, config } = input;
+
+    // 1. Setup MCP Adapters
+    const githubAdapter = new MCPAdapter(GITHUB_MCP_COMMAND, GITHUB_MCP_ARGS, {
+      GITHUB_PERSONAL_ACCESS_TOKEN: config.githubToken,
+    });
+
+    const fsAdapter = new MCPAdapter(FILESYSTEM_MCP_COMMAND, [
+      ...FILESYSTEM_MCP_ARGS,
+      rootDir,
+    ]);
+
+    try {
+      console.log('[RemediationSwarm] Connecting to MCP servers...');
+      await Promise.all([githubAdapter.connect(), fsAdapter.connect()]);
+
+      const githubTools = await githubAdapter.getMastraTools();
+      const fsTools = await fsAdapter.getMastraTools();
+
+      // 2. Create the Agent with MCP Tools
+      const agent = new Agent({
+        id: 'refactor-agent-mcp',
+        name: 'Refactor Agent (MCP Powered)',
+        instructions: `
+          You are an expert full-stack engineer specialized in code consolidation and refactoring.
+          Your task is to take a detected code duplication or fragmentation issue and fix it.
+
+          Context:
+          - Repository: ${repo.url}
+          - Local Path: ${rootDir} (You have full access via filesystem tools)
+
+          Available Toolsets:
+          - GitHub: Use for creating branches, commits, and pull requests.
+          - Filesystem: Use for reading and writing files in ${rootDir}.
+
+          Workflow:
+          1. Research: Read the affected files using filesystem tools.
+          2. Branching: Create a new branch remotely using GitHub tools AND locally using Git/Filesystem tools if available.
+          3. Remediation: Consolidate the logic and write the changes using filesystem tools.
+          4. Persist: Commit and push the changes using GitHub/Git tools.
+          5. Finalize: Create a Pull Request with a clear description using GitHub tools.
+
+          You MUST provide your final response as a VALID JSON object with this structure:
+          {
+            "status": "success" | "failure",
+            "diff": "unified diff string",
+            "prUrl": "URL of the created PR",
+            "prNumber": 123,
+            "explanation": "Brief explanation of changes"
+          }
+        `,
+        model: 'openai/gpt-4o',
+        tools: {
+          ...githubTools,
+          ...fsTools,
+        },
+      });
+
+      console.log('[RemediationSwarm] Executing agent logic...');
+
+      const prompt = `
+        Remediate this issue: ${JSON.stringify(remediation)}
+        The repository is cloned at: ${rootDir}
+      `;
+
+      const result = await agent.generate(prompt);
+
+      const text = result.text || '';
+      const jsonMatch = text.match(/\{[\s\S]*\}/);
+
+      if (jsonMatch) {
+        try {
+          const parsed = JSON.parse(jsonMatch[0]);
+          return {
+            ok: true,
+            value: parsed,
+          };
+        } catch (parseErr) {
+          console.error(
+            '[RemediationSwarm] JSON Parse Error:',
+            parseErr,
+            'Text:',
+            text
+          );
+        }
+      }
+
+      return {
+        ok: true,
+        value: {
+          status: 'success',
+          diff: text,
+          explanation:
+            'Applied refactoring successfully (fallback to text response)',
+        },
+      };
+    } catch (error) {
+      console.error('[RemediationSwarm] Execution error:', error);
+      return {
+        ok: false,
+        error:
+          error instanceof Error
+            ? error.message
+            : 'Unknown error during swarm execution',
+      };
+    } finally {
+      // 3. Cleanup MCP Connections
+      console.log('[RemediationSwarm] Cleaning up MCP connections...');
+      await Promise.allSettled([
+        githubAdapter.disconnect(),
+        fsAdapter.disconnect(),
+      ]);
+    }
+  },
+};