@aiready/mcp-server 0.6.1 → 0.6.2

package/dist/index.js

@@ -5,24 +5,213 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
   CallToolRequestSchema,
-  ListToolsRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema
+  ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/index.ts
+import { z as z3 } from "zod";
 import { ToolRegistry, ToolName } from "@aiready/core";
+
+// src/tools/best-practices.ts
 import { z } from "zod";
-var AnalysisArgsSchema = z.object({
-  path: z.string().describe("Path to the directory to analyze"),
-  summary_only: z.boolean().optional().describe(
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var SKILLS_AGENTS_MD_PATH = path.resolve(
+  __dirname,
+  "../../skills/aiready-best-practices/AGENTS.md"
+);
+var BestPracticesArgsSchema = z.object({
+  category: z.string().describe(
+    "Category of best practices (e.g., patterns, context, consistency, signal, grounding)"
+  )
+});
+var ComplianceArgsSchema = z.object({
+  file_path: z.string().describe("Absolute path to the file to check")
+});
+async function handleGetBestPractices(args) {
+  const { category } = args;
+  try {
+    const content = await fs.promises.readFile(SKILLS_AGENTS_MD_PATH, "utf-8");
+    const lines = content.split("\n");
+    let inSection = false;
+    const sectionContent = [];
+    for (const line of lines) {
+      if (line.startsWith("## ") && line.toLowerCase().includes(`(${category.toLowerCase()})`)) {
+        inSection = true;
+        sectionContent.push(line);
+        continue;
+      }
+      if (inSection && line.startsWith("## ") && !line.toLowerCase().includes(`(${category.toLowerCase()})`)) {
+        break;
+      }
+      if (inSection) {
+        sectionContent.push(line);
+      }
+    }
+    if (sectionContent.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Category "${category}" not found in AIReady Best Practices.`
+          }
+        ],
+        isError: true
+      };
+    }
+    return {
+      content: [{ type: "text", text: sectionContent.join("\n") }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error reading best practices: ${error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function handleCheckCompliance(args) {
+  const { file_path } = args;
+  try {
+    const content = await fs.promises.readFile(file_path, "utf-8");
+    const issues = [];
+    const lineCount = content.split("\n").length;
+    if (lineCount > 500) {
+      issues.push(
+        `\u26A0\uFE0F **Context Optimization (2.3)**: File has ${lineCount} lines. Large files waste context. Consider splitting into smaller modules.`
+      );
+    }
+    if (content.includes("true, false") || content.includes("false, true") || content.includes("true, true")) {
+      issues.push(
+        `\u{1F6A9} **AI Signal Clarity (4.1)**: Detected potential positional boolean traps. Prefer named options objects for clarity.`
+      );
+    }
+    const magicNumberRegex = /[^A-Z_a-z][0-9]{2,}[^A-Z_a-z0-9]/g;
+    if (magicNumberRegex.test(content)) {
+      issues.push(
+        `\u{1F6A9} **AI Signal Clarity (4.3)**: Detected potential magic literals (raw numbers). Use named constants/enums for business rules.`
+      );
+    }
+    const entropyRegex = /\b(data|info|handle|obj|item)\b/gi;
+    const matches = content.match(entropyRegex);
+    if (matches && matches.length > 5) {
+      issues.push(
+        `\u{1F6A9} **AI Signal Clarity (4.2)**: High-entropy names detected (${[...new Set(matches.map((m) => m.toLowerCase()))].join(", ")}). Use specific domain names instead.`
+      );
+    }
+    if (issues.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u2705 File "${path.basename(file_path)}" is compliant with lightweight AIReady Best Practices.`
+          }
+        ]
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `AIReady Compliance Report for "${path.basename(file_path)}":
+
+${issues.join("\n")}`
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        { type: "text", text: `Error checking compliance: ${error.message}` }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/context-budget.ts
+import { z as z2 } from "zod";
+import fs2 from "fs";
+import path2 from "path";
+var ContextBudgetArgsSchema = z2.object({
+  file_path: z2.string().describe("Absolute path to the file to analyze")
+});
+async function handleAnalyzeContextBudget(args) {
+  const { file_path } = args;
+  try {
+    const content = await fs2.promises.readFile(file_path, "utf-8");
+    const charCount = content.length;
+    const tokens = Math.ceil(charCount / 4);
+    const tiers = [
+      { name: "8k (GPT-4/Turbo)", threshold: 8e3 },
+      { name: "32k (GPT-4o/Mini)", threshold: 32e3 },
+      { name: "128k (GPT-4o/Claude 3)", threshold: 128e3 },
+      { name: "200k (Claude 3.5 Sonnet)", threshold: 2e5 },
+      { name: "1M (Gemini 1.5 Pro)", threshold: 1e6 }
+    ];
+    let result = `# Context Budget for "${path2.basename(file_path)}"
+
+`;
+    result += `**Estimated Tokens:** ${tokens.toLocaleString()}
+
+`;
+    result += `### Context Usage By Tier
+`;
+    tiers.forEach((tier) => {
+      const percentage = tokens / tier.threshold * 100;
+      const barLength = Math.min(Math.ceil(percentage / 5), 20);
+      const bar = "\u2588".repeat(barLength) + "\u2591".repeat(Math.max(0, 20 - barLength));
+      result += ` - **${tier.name}:** ${bar} ${percentage.toFixed(1)}%
+`;
+    });
+    result += `
+### Recommendations
+`;
+    if (tokens > 5e3) {
+      result += `\u26A0\uFE0F **High Context Usage:** This file alone takes up a significant chunk of smaller context windows. Consider refactoring to extract logical sub-modules.
+`;
+    } else {
+      result += `\u2705 **Optimal Size:** This file is well-sized for AI context windows.
+`;
+    }
+    const importCount = (content.match(/^import /gm) || []).length;
+    if (importCount > 20) {
+      result += `\u26A0\uFE0F **High Dependency Load:** ${importCount} imports found. AI will need to load many dependent files, multiplying the context budget needed. Use barrel exports (index.ts) to flatten the dependency tree.
+`;
+    }
+    return {
+      content: [{ type: "text", text: result }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error analyzing context budget: ${error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/index.ts
+var AnalysisArgsSchema = z3.object({
+  path: z3.string().describe("Path to the directory to analyze"),
+  summary_only: z3.boolean().optional().describe(
     "If true, returns only the summary and skips the detailed issue list. Best for large projects to save context."
   )
 });
-var RemediationArgsSchema = z.object({
-  issue_id: z.string().describe("The unique ID of the issue to fix"),
-  file_path: z.string().describe("The path to the file containing the issue"),
-  context: z.string().describe("The content of the file or surrounding code")
+var RemediationArgsSchema = z3.object({
+  issue_id: z3.string().describe("The unique ID of the issue to fix"),
+  file_path: z3.string().describe("The path to the file containing the issue"),
+  context: z3.string().describe("The content of the file or surrounding code")
 });
 var TOOL_PACKAGE_MAP = {
   [ToolName.PatternDetect]: "@aiready/pattern-detect",
@@ -35,6 +224,11 @@ var TOOL_PACKAGE_MAP = {
   [ToolName.DependencyHealth]: "@aiready/deps",
   [ToolName.ChangeAmplification]: "@aiready/change-amplification",
   [ToolName.ContractEnforcement]: "@aiready/contract-enforcement",
+  // New tools from core
+  [ToolName.CognitiveLoad]: "@aiready/cognitive-load",
+  [ToolName.PatternEntropy]: "@aiready/pattern-entropy",
+  [ToolName.ConceptCohesion]: "@aiready/concept-cohesion",
+  [ToolName.SemanticDistance]: "@aiready/semantic-distance",
   // Aliases
   patterns: "@aiready/pattern-detect",
   duplicates: "@aiready/pattern-detect",
@@ -48,216 +242,423 @@ var TOOL_PACKAGE_MAP = {
   "change-amp": "@aiready/change-amplification",
   "contract-enforce": "@aiready/contract-enforcement"
 };
-var AIReadyMcpServer = class {
-  constructor() {
-    this.version = "0.2.10";
-    this.server = new Server(
-      {
-        name: "aiready-server",
-        version: this.version
-      },
-      {
-        capabilities: {
-          tools: {},
-          resources: {},
-          prompts: {}
-        }
-      }
+var ADVERTISED_TOOLS = [
+  ToolName.PatternDetect,
+  ToolName.ContextAnalyzer,
+  ToolName.NamingConsistency,
+  ToolName.AiSignalClarity,
+  ToolName.AgentGrounding,
+  ToolName.TestabilityIndex,
+  ToolName.DocDrift,
+  ToolName.DependencyHealth,
+  ToolName.ChangeAmplification,
+  ToolName.ContractEnforcement,
+  ToolName.CognitiveLoad,
+  ToolName.PatternEntropy,
+  ToolName.ConceptCohesion,
+  ToolName.SemanticDistance,
+  "get_best_practices",
+  "check_best_practice_compliance",
+  "analyze_context_budget"
+];
+async function handleAnalysis(name, args, stateStore2) {
+  const parsedArgs = AnalysisArgsSchema.safeParse(args);
+  if (!parsedArgs.success) {
+    throw new Error(
+      `Invalid arguments for ${name}: ${parsedArgs.error.message}`
     );
-    this.setupHandlers();
-    this.server.onerror = (error) => {
-      console.error("[MCP Error]", error);
+  }
+  const { path: rootDir, summary_only } = parsedArgs.data;
+  let provider = ToolRegistry.find(name);
+  if (!provider) {
+    const packageName = TOOL_PACKAGE_MAP[name] ?? (name.startsWith("@aiready/") ? name : `@aiready/${name}`);
+    try {
+      console.error(
+        `[MCP] Dynamically loading ${packageName} for tool ${name}`
+      );
+      await import(packageName);
+      provider = ToolRegistry.find(name);
+    } catch (importError) {
+      const importErrorMessage = importError instanceof Error ? importError.message : String(importError);
+      const error = new Error(
+        `Tool ${name} not found and failed to load package ${packageName}: ${importErrorMessage}`
+      );
+      error.cause = importError;
+      throw error;
+    }
+  }
+  if (!provider) {
+    throw new Error(`Tool ${name} not found after attempting to load`);
+  }
+  console.error(
+    `[MCP] Executing ${name} on ${rootDir}${summary_only ? " (summary only)" : ""}`
+  );
+  const results = await provider.analyze({
+    rootDir
+  });
+  if (stateStore2) {
+    stateStore2.updateLastResults(results);
+  }
+  if (summary_only) {
+    const summary = results.summary;
+    return {
+      summary: `## Issue Breakdown
+- Critical: ${summary.criticalIssues}
+- Major: ${summary.majorIssues}
+- Total Issues: ${summary.totalIssues}
+- Files Analyzed: ${summary.totalFiles}`,
+      metadata: results.metadata,
+      notice: "Detailed issues were omitted (summary_only: true). Run without summary_only for full details."
     };
   }
-  async handleRemediation(args) {
-    const apiKey = process.env.AIREADY_API_KEY;
-    const serverUrl = process.env.AIREADY_PLATFORM_URL || "https://platform.getaiready.dev";
-    if (!apiKey) {
+  return results;
+}
+async function handleRemediation(args) {
+  const apiKey = process.env.AIREADY_API_KEY;
+  const serverUrl = process.env.AIREADY_PLATFORM_URL || "https://platform.getaiready.dev";
+  if (!apiKey) {
+    throw new Error(
+      "AIREADY_API_KEY is not set. Remediation requires an active subscription."
+    );
+  }
+  console.error(`[MCP] Requesting remediation for ${args.issue_id}...`);
+  try {
+    const response = await fetch(`${serverUrl}/api/v1/remediate`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-KEY": apiKey
+      },
+      body: JSON.stringify({
+        issueId: args.issue_id,
+        filePath: args.file_path,
+        context: args.context,
+        agent: "mcp-server"
+      })
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
       throw new Error(
-        "AIREADY_API_KEY is not set. Remediation requires an active subscription."
+        `Platform Error: ${errorData.message || response.statusText}`
       );
     }
-    console.error(`[MCP] Requesting remediation for ${args.issue_id}...`);
-    try {
-      const response = await fetch(`${serverUrl}/api/v1/remediate`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-API-KEY": apiKey
-        },
-        body: JSON.stringify({
-          issueId: args.issue_id,
-          filePath: args.file_path,
-          context: args.context,
-          agent: "mcp-server"
-        })
-      });
-      if (!response.ok) {
-        const errorData = await response.json().catch(() => ({}));
-        throw new Error(
-          `Platform Error: ${errorData.message || response.statusText}`
-        );
-      }
-      const data = await response.json();
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Recommended Fix (Diff):
+    const data = await response.json();
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Recommended Fix (Diff):
 
 ${data.diff}
 
 Rationale:
 ${data.rationale}`
+        }
+      ]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Failed to get remediation: ${errorMessage}. Please visit the dashboard to fix manually.`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/resources/index.ts
+import {
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+function registerResourceHandlers(server, stateStore2) {
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return {
+      resources: [
+        {
+          uri: "aiready://project/summary",
+          name: "AIReady Project Summary",
+          description: "Quick top-level AI-readiness summary.",
+          mimeType: "text/markdown"
+        },
+        {
+          uri: "aiready://project/issues",
+          name: "AIReady Critical Issues",
+          description: "List of top 10 critical readiness issues.",
+          mimeType: "application/json"
+        },
+        {
+          uri: "aiready://project/graph",
+          name: "AIReady Codebase Graph",
+          description: "Force-directed graph data for visualization.",
+          mimeType: "application/json"
+        },
+        {
+          uri: "aiready://project/roadmap",
+          name: "AIReady Readiness Roadmap",
+          description: "A prioritized plan to reach elite readiness.",
+          mimeType: "text/markdown"
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    if (uri === "aiready://project/summary") {
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "text/markdown",
+            text: stateStore2.getSummaryMarkdown()
           }
         ]
       };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
+    }
+    if (uri === "aiready://project/issues") {
       return {
-        content: [
+        contents: [
           {
-            type: "text",
-            text: `Failed to get remediation: ${errorMessage}. Please visit the dashboard to fix manually.`
+            uri,
+            mimeType: "application/json",
+            text: stateStore2.getIssuesJson()
           }
-        ],
-        isError: true
+        ]
       };
     }
-  }
-  setupHandlers() {
-    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    if (uri === "aiready://project/graph") {
       return {
-        resources: [
+        contents: [
           {
-            uri: "aiready://project/summary",
-            name: "AIReady Project Summary",
-            description: "Quick top-level AI-readiness summary.",
-            mimeType: "text/markdown"
-          },
-          {
-            uri: "aiready://project/issues",
-            name: "AIReady Critical Issues",
-            description: "List of top 10 critical readiness issues.",
-            mimeType: "application/json"
-          },
-          {
-            uri: "aiready://project/graph",
-            name: "AIReady Codebase Graph",
-            description: "Force-directed graph data for visualization.",
-            mimeType: "application/json"
+            uri,
+            mimeType: "application/json",
+            text: stateStore2.getGraphJson()
           }
         ]
       };
-    });
-    this.server.setRequestHandler(
-      ReadResourceRequestSchema,
-      async (request) => {
-        const { uri } = request.params;
-        if (uri === "aiready://project/summary") {
-          return {
-            contents: [
-              {
-                uri,
-                mimeType: "text/markdown",
-                text: "# AIReady Summary\n\nProject: Current Directory\nScore: 84/100 (B)\n\nCritical Issues: 2\nMajor Issues: 14\n\nRun the `aiready-mcp` tool for full analysis."
-              }
-            ]
-          };
-        }
-        if (uri === "aiready://project/issues" || uri === "aiready://project/graph") {
-          return {
-            contents: [
-              {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify({
-                  message: "Resource content coming from latest scan..."
-                })
-              }
-            ]
-          };
-        }
-        throw new Error(`Resource not found: ${uri}`);
-      }
-    );
-    this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    }
+    if (uri === "aiready://project/roadmap") {
       return {
-        prompts: [
-          {
-            name: "analyze-project",
-            description: "Audit the project for AI-readiness and suggest improvements.",
-            arguments: [
-              {
-                name: "path",
-                description: "Path/directory to analyze",
-                required: true
-              }
-            ]
-          },
+        contents: [
           {
-            name: "remediate-issue",
-            description: "Help the user fix a specific AIReady issue.",
-            arguments: [
-              {
-                name: "issueId",
-                description: "The unique ID of the issue to fix",
-                required: true
-              }
-            ]
+            uri,
+            mimeType: "text/markdown",
+            text: stateStore2.getRoadmapMarkdown()
           }
         ]
       };
-    });
-    this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-      if (name === "analyze-project") {
-        const path = args?.path || ".";
-        return {
-          description: "Project audit instructions",
-          messages: [
+    }
+    throw new Error(`Resource not found: ${uri}`);
+  });
+}
+
+// src/prompts/index.ts
+import {
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+function registerPromptHandlers(server) {
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return {
+      prompts: [
+        {
+          name: "analyze-project",
+          description: "Audit the project for AI-readiness and suggest improvements.",
+          arguments: [
             {
-              role: "user",
-              content: {
-                type: "text",
-                text: `I want to audit the project at "${path}" for AI-readiness. Please use the AIReady tools to identify duplication patterns, context fragmentation, and naming inconsistencies. Then, provide a prioritized list of improvements to help me leverage AI agents more effectively.`
-              }
+              name: "path",
+              description: "Path/directory to analyze",
+              required: true
             }
           ]
-        };
-      }
-      if (name === "remediate-issue") {
-        const issueId = args?.issueId;
-        return {
-          description: "Issue remediation instructions",
-          messages: [
+        },
+        {
+          name: "remediate-issue",
+          description: "Help the user fix a specific AIReady issue.",
+          arguments: [
             {
-              role: "user",
-              content: {
-                type: "text",
-                text: `I've identified an AIReady issue with ID: ${issueId}. Please use the \`get_remediation_diff\` tool to find a fix, explain the rationale behind the recommended change, and then help me apply it to the codebase.`
-              }
+              name: "issueId",
+              description: "The unique ID of the issue to fix",
+              required: true
             }
           ]
-        };
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    if (name === "analyze-project") {
+      const path3 = args?.path || ".";
+      return {
+        description: "Project audit instructions",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `I want to audit the project at "${path3}" for AI-readiness. Please use the AIReady tools to identify duplication patterns, context fragmentation, and naming inconsistencies. Then, provide a prioritized list of improvements to help me leverage AI agents more effectively.`
+            }
+          }
+        ]
+      };
+    }
+    if (name === "remediate-issue") {
+      const issueId = args?.issueId;
+      return {
+        description: "Issue remediation instructions",
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `I've identified an AIReady issue with ID: ${issueId}. Please use the \`get_remediation_diff\` tool to find a fix, explain the rationale behind the recommended change, and then help me apply it to the codebase.`
+            }
+          }
+        ]
+      };
+    }
+    throw new Error(`Prompt not found: ${name}`);
+  });
+}
+
+// src/state-store.ts
+var StateStore = class {
+  constructor() {
+    this.lastResults = null;
+    this.lastScanTimestamp = null;
+  }
+  updateLastResults(results) {
+    this.lastResults = results;
+    this.lastScanTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  getLastResults() {
+    return this.lastResults;
+  }
+  getSummaryMarkdown() {
+    if (!this.lastResults) {
+      return "# AIReady Summary\n\nNo scan has been run yet. Run an AIReady scan tool to see results here.";
+    }
+    const { score, summary } = this.lastResults;
+    const grade = this.calculateGrade(score);
+    return `# AIReady Summary
+    
+Project Score: **${score}/100 (${grade})**
+Last Scan: ${this.lastScanTimestamp}
+
+## Issue Breakdown
+- Critical: ${summary.criticalIssues}
+- Major: ${summary.majorIssues}
+- Total Issues: ${summary.totalIssues}
+- Files Analyzed: ${summary.totalFiles}
+
+Run the \`aiready-mcp\` tool for a detailed analysis.`;
+  }
+  getIssuesJson() {
+    if (!this.lastResults) {
+      return JSON.stringify({
+        message: "No issues found. Please run a scan first."
+      });
+    }
+    const topIssues = this.lastResults.issues.slice(0, 10);
+    return JSON.stringify(topIssues, null, 2);
+  }
+  getGraphJson() {
+    if (!this.lastResults || !this.lastResults.metadata.graph) {
+      return JSON.stringify({
+        message: "Graph data not available. Run a scan with graph analysis enabled."
+      });
+    }
+    return JSON.stringify(this.lastResults.metadata.graph, null, 2);
+  }
+  getRoadmapMarkdown() {
+    if (!this.lastResults) {
+      return "# AIReady Roadmap\n\nNo scan has been run yet. Run an AIReady scan to generate a prioritized roadmap.";
+    }
+    const { score, issues } = this.lastResults;
+    const grade = this.calculateGrade(score);
+    let roadmap = `# AIReady Roadmap
+
+`;
+    roadmap += `Current Score: **${score}/100 (${grade})**
+
+`;
+    roadmap += `## Phase 1: High-Impact Fixes (Readiness Score 90+)
+`;
+    const criticalIssues = issues.filter((i) => i.severity === "critical").slice(0, 3);
+    if (criticalIssues.length > 0) {
+      criticalIssues.forEach((i) => {
+        roadmap += ` - [ ] **Fix ${i.type}** in \`${i.location.file}:L${i.location.line}\`: ${i.message}
+`;
+      });
+    } else {
+      roadmap += ` - \u2705 All critical issues resolved!
+`;
+    }
+    roadmap += `
+## Phase 2: Structural Optimization (Efficiency)
+`;
+    const majorIssues = issues.filter((i) => i.severity === "major").slice(0, 3);
+    if (majorIssues.length > 0) {
+      majorIssues.forEach((i) => {
+        roadmap += ` - [ ] **Address ${i.type}**: ${i.message} (\`${i.location.file}\`)
+`;
+      });
+    } else {
+      roadmap += ` - \u2705 All major structural issues resolved!
+`;
+    }
+    roadmap += `
+## Phase 3: Continuous AI Excellence
+`;
+    roadmap += ` - [ ] Implement \`mcp-server\` in CI/CD pipeline.
+`;
+    roadmap += ` - [ ] Achieve consistency score > 95 across all naming patterns.
+`;
+    return roadmap;
+  }
+  calculateGrade(score) {
+    if (score >= 90) return "A";
+    if (score >= 80) return "B";
+    if (score >= 70) return "C";
+    if (score >= 60) return "D";
+    return "F";
+  }
+};
+var stateStore = new StateStore();
+
+// src/index.ts
+var AIReadyMcpServer = class {
+  constructor() {
+    this.version = "0.3.0";
+    this.server = new Server(
+      {
+        name: "aiready-server",
+        version: this.version
+      },
+      {
+        capabilities: {
+          tools: {},
+          resources: {},
+          prompts: {}
+        }
       }
-      throw new Error(`Prompt not found: ${name}`);
-    });
+    );
+    this.setupHandlers();
+    this.server.onerror = (error) => {
+      console.error("[MCP Error]", error);
+    };
+  }
+  setupHandlers() {
+    registerResourceHandlers(this.server, stateStore);
+    registerPromptHandlers(this.server);
     this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      const toolsToAdvertise = [
-        ToolName.PatternDetect,
-        ToolName.ContextAnalyzer,
-        ToolName.NamingConsistency,
-        ToolName.AiSignalClarity,
-        ToolName.AgentGrounding,
-        ToolName.TestabilityIndex,
-        ToolName.DocDrift,
-        ToolName.DependencyHealth,
-        ToolName.ChangeAmplification,
-        ToolName.ContractEnforcement
-      ];
       const tools = [
-        ...toolsToAdvertise.map((id) => ({
+        ...ADVERTISED_TOOLS.map((id) => ({
           name: id,
           description: `Scan the directory for ${id} issues to improve AI-readiness.`,
           inputSchema: {
@@ -304,61 +705,27 @@ ${data.rationale}`
       const { name, arguments: args } = request.params;
       try {
         if (name === "get_remediation_diff") {
-          const parsedArgs2 = RemediationArgsSchema.safeParse(args);
-          if (!parsedArgs2.success) {
-            throw new Error(
-              `Invalid arguments for ${name}: ${parsedArgs2.error.message}`
-            );
-          }
-          return await this.handleRemediation(parsedArgs2.data);
+          const parsedArgs = RemediationArgsSchema.parse(args);
+          return await handleRemediation(parsedArgs);
         }
-        const parsedArgs = AnalysisArgsSchema.safeParse(args);
-        if (!parsedArgs.success) {
-          throw new Error(
-            `Invalid arguments for ${name}: ${parsedArgs.error.message}`
-          );
+        if (name === "get_best_practices") {
+          const parsedArgs = BestPracticesArgsSchema.parse(args);
+          return await handleGetBestPractices(parsedArgs);
         }
-        const { path: rootDir, summary_only } = parsedArgs.data;
-        let provider = ToolRegistry.find(name);
-        if (!provider) {
-          const packageName = TOOL_PACKAGE_MAP[name] ?? (name.startsWith("@aiready/") ? name : `@aiready/${name}`);
-          try {
-            console.error(
-              `[MCP] Dynamically loading ${packageName} for tool ${name}`
-            );
-            await import(packageName);
-            provider = ToolRegistry.find(name);
-          } catch (importError) {
-            const importErrorMessage = importError instanceof Error ? importError.message : String(importError);
-            console.error(
-              `[MCP] Failed to load tool package ${packageName}: ${importErrorMessage}`
-            );
-            const error = new Error(
-              `Tool ${name} not found and failed to load package ${packageName}: ${importErrorMessage}`
-            );
-            error.cause = importError;
-            throw error;
-          }
+        if (name === "check_best_practice_compliance") {
+          const parsedArgs = ComplianceArgsSchema.parse(args);
+          return await handleCheckCompliance(parsedArgs);
         }
-        if (!provider) {
-          throw new Error(`Tool ${name} not found after attempting to load`);
+        if (name === "analyze_context_budget") {
+          const parsedArgs = ContextBudgetArgsSchema.parse(args);
+          return await handleAnalyzeContextBudget(parsedArgs);
         }
-        console.error(
-          `[MCP] Executing ${name} on ${rootDir}${summary_only ? " (summary only)" : ""}`
-        );
-        const results = await provider.analyze({
-          rootDir
-        });
-        const responseData = summary_only ? {
-          summary: results.summary,
-          metadata: results.metadata,
-          notice: "Detailed issues were omitted (summary_only: true). Run without summary_only for full details."
-        } : results;
+        const results = await handleAnalysis(name, args, stateStore);
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify(responseData, null, 2)
+              text: JSON.stringify(results, null, 2)
             }
           ]
         };