@tenantegroup/ai-rules-mcp 1.0.0

package/src/index.js

@@ -0,0 +1,757 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const RULES_DIR = path.join(__dirname, "..", "rules");
+
+// Tool Input Schemas using Zod
+const GetRelevantRulesSchema = z.object({
+  task_description: z.string().describe("Description of what you're trying to accomplish"),
+  file_types: z.array(z.string()).optional().describe("File types involved (e.g., ['cs', 'dart', 'vue', 'ts'])"),
+  keywords: z.array(z.string()).optional().describe("Keywords related to the task (e.g., ['mvvm', 'riverpod', 'drizzle', 'workflows'])"),
+  include_all: z.boolean().default(false).describe("Include all rules (use sparingly, high token cost)"),
+});
+
+const GetRuleByNameSchema = z.object({
+  rule_name: z.string().describe("Rule path or name (e.g., 'flutter/riverpod' or 'cloudflare/workflows')"),
+});
+
+const SearchRuleContentSchema = z.object({
+  query: z.string().describe("The search term or phrase to find within rule contents"),
+  case_sensitive: z.boolean().default(false).describe("Whether the search should be case-sensitive"),
+});
+
+const InstallRulesSchema = z.object({
+  target_dir: z.string().describe("The absolute path to the project root where rules should be installed"),
+  stack: z.enum(["cloudflare", "nuxt", "flutter", "dotnet"]).optional().describe("Optional stack selector. If omitted, target directory is auto-detected."),
+});
+
+function toInputSchema(zodSchema) {
+  const schema = z.toJSONSchema(zodSchema);
+  delete schema.$schema;
+  if (!schema.type) schema.type = "object";
+  return schema;
+}
+
+const RULE_METADATA = {
+  // Cloudflare Backend Rules
+  "cloudflare/edge-parity.md": {
+    stack: "cloudflare",
+    keywords: ["cloudflare", "worker", "edge", "wrangler", "miniflare", "runtime", "fetch", "env"],
+    categories: ["backend", "runtime"],
+  },
+  "cloudflare/database-orm.md": {
+    stack: "cloudflare",
+    keywords: ["drizzle", "orm", "d1", "database", "sqlite", "query", "schema", "migration"],
+    categories: ["backend", "database"],
+  },
+  "cloudflare/seeding.md": {
+    stack: "cloudflare",
+    keywords: ["seed", "seeding", "test data", "fixtures"],
+    categories: ["backend", "database"],
+  },
+  "cloudflare/kv-usage.md": {
+    stack: "cloudflare",
+    keywords: ["kv", "cache", "key-value", "namespaces"],
+    categories: ["backend", "storage"],
+  },
+  "cloudflare/workflows.md": {
+    stack: "cloudflare",
+    keywords: ["workflow", "workflows", "saga", "compensation", "durable", "step"],
+    categories: ["backend", "orchestration"],
+  },
+  "cloudflare/realtime-background.md": {
+    stack: "cloudflare",
+    keywords: ["durable object", "do", "queue", "queues", "background", "realtime"],
+    categories: ["backend", "concurrency"],
+  },
+  "cloudflare/security.md": {
+    stack: "cloudflare",
+    keywords: ["security", "auth", "validation", "headers", "cors", "leak"],
+    categories: ["backend", "security"],
+  },
+  "cloudflare/performance.md": {
+    stack: "cloudflare",
+    keywords: ["performance", "speed", "latency", "cache-control", "stream", "optimize"],
+    categories: ["backend", "performance"],
+  },
+  "cloudflare/logging-observability.md": {
+    stack: "cloudflare",
+    keywords: ["logging", "log", "correlation", "observability", "sentry", "axiom"],
+    categories: ["backend", "logging"],
+  },
+  "cloudflare/cicd-deployment.md": {
+    stack: "cloudflare",
+    keywords: ["cicd", "github actions", "deploy", "deployment", "wrangler deploy"],
+    categories: ["backend", "deployment"],
+  },
+  "cloudflare/api-services.md": {
+    stack: "cloudflare",
+    keywords: ["api", "nitro", "service", "route", "handler", "endpoint"],
+    categories: ["backend", "api"],
+  },
+
+  // Nuxt Frontend Rules
+  "nuxt/core-directives.md": {
+    stack: "nuxt",
+    keywords: ["nuxt", "vue", "core", "directive", "rules"],
+    categories: ["frontend", "core"],
+    always: true,
+  },
+  "nuxt/architecture-principles.md": {
+    stack: "nuxt",
+    keywords: ["architecture", "nuxt", "structure", "vue", "pattern"],
+    categories: ["frontend", "architecture"],
+  },
+  "nuxt/project-structure.md": {
+    stack: "nuxt",
+    keywords: ["structure", "directory", "layout", "pages", "components", "server"],
+    categories: ["frontend", "structure"],
+  },
+  "nuxt/configuration.md": {
+    stack: "nuxt",
+    keywords: ["configuration", "nuxt.config", "wrangler.toml", "settings"],
+    categories: ["frontend", "config"],
+  },
+  "nuxt/authentication.md": {
+    stack: "nuxt",
+    keywords: ["auth", "login", "session", "jwt", "cookie", "oauth"],
+    categories: ["frontend", "security"],
+  },
+  "nuxt/testing.md": {
+    stack: "nuxt",
+    keywords: ["testing", "vitest", "unit test", "mock", "e2e"],
+    categories: ["frontend", "testing"],
+  },
+  "nuxt/project-initialization.md": {
+    stack: "nuxt",
+    keywords: ["init", "scaffold", "new project", "checklist"],
+    categories: ["frontend", "setup"],
+  },
+  "nuxt/code-quality.md": {
+    stack: "nuxt",
+    keywords: ["typescript", "eslint", "quality", "vue", "composition api"],
+    categories: ["frontend", "quality"],
+  },
+
+  // Flutter Client Rules
+  "flutter/architecture.md": {
+    stack: "flutter",
+    keywords: ["architecture", "layer", "domain", "data", "presentation", "result", "apperror"],
+    categories: ["flutter", "architecture"],
+    always: true,
+  },
+  "flutter/project-structure.md": {
+    stack: "flutter",
+    keywords: ["structure", "directory", "pubspec", "flutter", "layout"],
+    categories: ["flutter", "structure"],
+  },
+  "flutter/riverpod.md": {
+    stack: "flutter",
+    keywords: ["riverpod", "provider", "notifier", "asyncvalue", "state", "keepalive"],
+    categories: ["flutter", "state-management"],
+  },
+  "flutter/navigation.md": {
+    stack: "flutter",
+    keywords: ["navigation", "gorouter", "route", "shellroute", "guard"],
+    categories: ["flutter", "navigation"],
+  },
+  "flutter/api.md": {
+    stack: "flutter",
+    keywords: ["api", "retrofit", "dio", "http", "client", "interceptor"],
+    categories: ["flutter", "api"],
+  },
+  "flutter/database.md": {
+    stack: "flutter",
+    keywords: ["database", "drift", "sqlite", "dao", "table", "migration"],
+    categories: ["flutter", "database"],
+  },
+  "flutter/auth.md": {
+    stack: "flutter",
+    keywords: ["auth", "token", "secure storage", "login", "refresh"],
+    categories: ["flutter", "security"],
+  },
+  "flutter/offline-sync.md": {
+    stack: "flutter",
+    keywords: ["offline", "sync", "connectivity", "conflict", "background"],
+    categories: ["flutter", "sync"],
+  },
+  "flutter/logging.md": {
+    stack: "flutter",
+    keywords: ["logging", "logger", "applogger", "print"],
+    categories: ["flutter", "logging"],
+  },
+  "flutter/testing.md": {
+    stack: "flutter",
+    keywords: ["testing", "test", "mocktail", "providercontainer", "unit"],
+    categories: ["flutter", "testing"],
+  },
+  "flutter/configuration.md": {
+    stack: "flutter",
+    keywords: ["configuration", "config", "dart-define", "env"],
+    categories: ["flutter", "config"],
+  },
+  "flutter/platform.md": {
+    stack: "flutter",
+    keywords: ["platform", "ios", "android", "macos", "windows", "target", "build"],
+    categories: ["flutter", "platform"],
+  },
+
+  // dotNET Client Rules
+  "dotnet/architecture.md": {
+    stack: "dotnet",
+    keywords: ["architecture", "maui", "mvvm", "di", "dependency injection", "services"],
+    categories: ["dotnet", "architecture"],
+    always: true,
+  },
+  "dotnet/project-structure.md": {
+    stack: "dotnet",
+    keywords: ["structure", "directory", "layout", "csproj", "sln"],
+    categories: ["dotnet", "structure"],
+  },
+  "dotnet/maui.md": {
+    stack: "dotnet",
+    keywords: ["maui", "xaml", "shell", "navigation", "ui", "binding"],
+    categories: ["dotnet", "maui"],
+  },
+  "dotnet/mvvm.md": {
+    stack: "dotnet",
+    keywords: ["mvvm", "viewmodel", "observableproperty", "relaycommand", "communitytoolkit"],
+    categories: ["dotnet", "mvvm"],
+  },
+  "dotnet/sqlite.md": {
+    stack: "dotnet",
+    keywords: ["sqlite", "sqlite-net", "database", "repository", "migration"],
+    categories: ["dotnet", "database"],
+  },
+  "dotnet/api.md": {
+    stack: "dotnet",
+    keywords: ["api", "refit", "http", "dto", "retry"],
+    categories: ["dotnet", "api"],
+  },
+  "dotnet/logging.md": {
+    stack: "dotnet",
+    keywords: ["logging", "serilog", "diagnostics", "error"],
+    categories: ["dotnet", "logging"],
+  },
+  "dotnet/cli.md": {
+    stack: "dotnet",
+    keywords: ["cli", "spectre", "command", "console"],
+    categories: ["dotnet", "cli"],
+  },
+  "dotnet/configuration.md": {
+    stack: "dotnet",
+    keywords: ["configuration", "secrets", "securestorage", "appsettings"],
+    categories: ["dotnet", "config"],
+  },
+  "dotnet/packaging.md": {
+    stack: "dotnet",
+    keywords: ["packaging", "release", "msix", "winget", "brew"],
+    categories: ["dotnet", "packaging"],
+  },
+  "dotnet/testing.md": {
+    stack: "dotnet",
+    keywords: ["testing", "test", "mock", "unit", "xunit"],
+    categories: ["dotnet", "testing"],
+  }
+};
+
+class AIRulesServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: "@tenantegroup/ai-rules-mcp",
+        version: "1.0.0",
+      },
+      {
+        capabilities: {
+          resources: {},
+          tools: {},
+        },
+      }
+    );
+
+    this.setupHandlers();
+    this.setupErrorHandling();
+  }
+
+  setupErrorHandling() {
+    this.server.onerror = (error) => {
+      console.error("[MCP Error]", error);
+    };
+
+    process.on("SIGINT", async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  setupHandlers() {
+    // Resources - lists all available rules
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      const resources = [];
+      for (const [filename, metadata] of Object.entries(RULE_METADATA)) {
+        resources.push({
+          uri: `rule:///${filename}`,
+          name: filename.replace(".md", "").replace(/^\d+-/, "").replace(/-/g, " "),
+          description: `Stack: ${metadata.stack} | Categories: ${metadata.categories.join(", ")}`,
+          mimeType: "text/markdown",
+        });
+      }
+      return { resources };
+    });
+
+    // Read Resource
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const uri = request.params.uri;
+      const filename = uri.replace("rule:///", "");
+      const filePath = path.join(RULES_DIR, filename);
+
+      if (!RULE_METADATA[filename]) {
+        throw new Error(`Rule not found in metadata registry: ${filename}`);
+      }
+
+      try {
+        const content = await fs.readFile(filePath, "utf-8");
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: "text/markdown",
+              text: content,
+            },
+          ],
+        };
+      } catch (err) {
+        throw new Error(`Failed to read rule file: ${filename} | ${err.message}`);
+      }
+    });
+
+    // List Tools
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            name: "get_relevant_rules",
+            description: "Get rules relevant to the current task. Dynamically detects technology stack and auto-filters unrelated rules to optimize token budget.",
+            inputSchema: toInputSchema(GetRelevantRulesSchema),
+          },
+          {
+            name: "get_rule_by_name",
+            description: "Get a specific rule file by stack-relative path (e.g. 'flutter/riverpod' or 'cloudflare/workflows').",
+            inputSchema: toInputSchema(GetRuleByNameSchema),
+          },
+          {
+            name: "search_rule_content",
+            description: "Search for specific terms or patterns across the actual content of all rule files.",
+            inputSchema: toInputSchema(SearchRuleContentSchema),
+          },
+          {
+            name: "list_all_rules",
+            description: "List all available rules grouped by stack.",
+            inputSchema: { type: "object", properties: {} },
+          },
+          {
+            name: "install_rules_to_project",
+            description: "Auto-detects the project stack and copies standard .ai rules and git commit validator hooks to a local project directory.",
+            inputSchema: toInputSchema(InstallRulesSchema),
+          },
+        ],
+      };
+    });
+
+    // Call Tool
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      try {
+        switch (name) {
+          case "get_relevant_rules": {
+            const parsed = GetRelevantRulesSchema.parse(args);
+            return await this.getRelevantRules(parsed);
+          }
+          case "get_rule_by_name": {
+            const parsed = GetRuleByNameSchema.parse(args);
+            return await this.getRuleByName(parsed);
+          }
+          case "search_rule_content": {
+            const parsed = SearchRuleContentSchema.parse(args || {});
+            return await this.searchRuleContent(parsed);
+          }
+          case "list_all_rules":
+            return await this.listAllRules();
+          case "install_rules_to_project": {
+            const parsed = InstallRulesSchema.parse(args);
+            return await this.installRulesToProject(parsed);
+          }
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        if (error instanceof z.ZodError) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Invalid input: ${error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ')}` }],
+          };
+        }
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+        };
+      }
+    });
+  }
+
+  async getRelevantRules(args) {
+    const { task_description = "", file_types = [], keywords = [], include_all = false } = args || {};
+
+    if (include_all) {
+      return await this.getAllRules();
+    }
+
+    const safeTaskDesc = (task_description || "").toLowerCase();
+    const safeFileTypes = (file_types || []).map(f => f.toLowerCase());
+    const safeKeywords = (keywords || []).map(k => k.toLowerCase());
+    const context = [safeTaskDesc, ...safeFileTypes, ...safeKeywords].join(" ");
+
+    // 1. Detect target stacks
+    const targetStacks = new Set();
+
+    // dotNET checks
+    if (safeFileTypes.some(ft => ["cs", "xaml"].includes(ft)) || 
+        /\b(maui|dotnet|c#|refit|wpf|spectre\.console|communitytoolkit|viewmodel)\b/i.test(context)) {
+      targetStacks.add("dotnet");
+    }
+
+    // Flutter checks
+    if (safeFileTypes.includes("dart") || 
+        /\b(flutter|dart|riverpod|gorouter|drift|retrofit\.dart|mocktail)\b/i.test(context)) {
+      targetStacks.add("flutter");
+    }
+
+    // Nuxt checks
+    if (safeFileTypes.some(ft => ["vue", "html"].includes(ft)) || 
+        /\b(nuxt|vue|pinia|vitest)\b/i.test(context)) {
+      targetStacks.add("nuxt");
+    }
+
+    // Cloudflare checks
+    if (/\b(cloudflare|worker|wrangler|miniflare|drizzle|d1|kv|r2|durable object|workflows|queue|saga)\b/i.test(context)) {
+      targetStacks.add("cloudflare");
+    }
+
+    // Special behavior: If Nuxt is selected, it's very common to use Cloudflare as backend too
+    if (targetStacks.has("nuxt") && !targetStacks.has("dotnet") && !targetStacks.has("flutter")) {
+      targetStacks.add("cloudflare");
+    }
+
+    // If nothing detected, search all rules (fallback)
+    const restrictToStacks = targetStacks.size > 0;
+
+    // 2. Score rules
+    const scoredRules = [];
+    for (const [filename, metadata] of Object.entries(RULE_METADATA)) {
+      // If we detected specific stacks, strictly exclude files from other stacks
+      if (restrictToStacks && !targetStacks.has(metadata.stack)) {
+        continue;
+      }
+
+      let score = 0;
+
+      // Rules with 'always: true' within target stacks are automatically selected
+      if (metadata.always) {
+        score += 1000;
+      }
+
+      // Keyword matches
+      for (const kw of metadata.keywords) {
+        if (context.includes(kw.toLowerCase())) {
+          score += 15;
+        }
+      }
+
+      // Category matches
+      for (const cat of metadata.categories) {
+        if (context.includes(cat.toLowerCase())) {
+          score += 5;
+        }
+      }
+
+      if (score > 0) {
+        scoredRules.push({ filename, score });
+      }
+    }
+
+    // Sort rules by score descending
+    scoredRules.sort((a, b) => b.score - a.score);
+
+    if (scoredRules.length === 0) {
+      return {
+        content: [{ type: "text", text: "No relevant rules found matching the description or stack context." }],
+      };
+    }
+
+    // Read files
+    const ruleContents = await Promise.all(
+      scoredRules.map(async (item) => {
+        const filePath = path.join(RULES_DIR, item.filename);
+        const content = await fs.readFile(filePath, "utf-8");
+        return `\n\n## Rule: ${item.filename}\n${content}`;
+      })
+    );
+
+    const summary = `Selected ${scoredRules.length} relevant rules (Filter Stacks: ${[...targetStacks].join(", ") || "All"}): ${scoredRules.map(r => r.filename).join(", ")}`;
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `${summary}\n\n---\n${ruleContents.join("\n")}`,
+        },
+      ],
+    };
+  }
+
+  async getRuleByName(args) {
+    const { rule_name } = args;
+    
+    // Support either 'flutter/riverpod' or 'riverpod'
+    let matchedFilename = null;
+    const lowerName = rule_name.toLowerCase().replace(".md", "");
+
+    if (RULE_METADATA[lowerName + ".md"]) {
+      matchedFilename = lowerName + ".md";
+    } else {
+      // Search registry keys
+      for (const key of Object.keys(RULE_METADATA)) {
+        if (key.toLowerCase().endsWith(`/${lowerName}.md`) || key.toLowerCase() === `${lowerName}.md`) {
+          matchedFilename = key;
+          break;
+        }
+      }
+    }
+
+    if (!matchedFilename) {
+      return {
+        content: [{ type: "text", text: `Rule not found in registry: "${rule_name}"` }],
+      };
+    }
+
+    try {
+      const filePath = path.join(RULES_DIR, matchedFilename);
+      const content = await fs.readFile(filePath, "utf-8");
+      return {
+        content: [{ type: "text", text: `## ${matchedFilename}\n\n${content}` }],
+      };
+    } catch (err) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: `Failed to read rule file: ${err.message}` }],
+      };
+    }
+  }
+
+  async searchRuleContent(args) {
+    const { query, case_sensitive } = args;
+    const regex = new RegExp(query, case_sensitive ? "g" : "gi");
+    const matches = [];
+
+    for (const filename of Object.keys(RULE_METADATA)) {
+      try {
+        const filePath = path.join(RULES_DIR, filename);
+        const content = await fs.readFile(filePath, "utf-8");
+        if (regex.test(content)) {
+          const lines = content.split("\n");
+          const previews = lines
+            .filter(l => {
+              regex.lastIndex = 0;
+              return regex.test(l);
+            })
+            .map(l => l.trim())
+            .slice(0, 2);
+
+          matches.push({ filename, preview: previews.join("\n") });
+        }
+      } catch (err) {
+        // ignore
+      }
+    }
+
+    if (matches.length === 0) {
+      return {
+        content: [{ type: "text", text: `No rules found containing term: "${query}"` }],
+      };
+    }
+
+    const output = matches
+      .map(m => `### ${m.filename}\n${m.preview}\n...`)
+      .join("\n\n");
+
+    return {
+      content: [{ type: "text", text: `Found "${query}" in ${matches.length} rule files:\n\n${output}` }],
+    };
+  }
+
+  async listAllRules() {
+    const grouped = {};
+    for (const [filename, metadata] of Object.entries(RULE_METADATA)) {
+      const stack = metadata.stack;
+      if (!grouped[stack]) grouped[stack] = [];
+      grouped[stack].push(filename.split("/")[1].replace(".md", ""));
+    }
+
+    let output = "# Available AI Rules\n\n";
+    for (const [stack, list] of Object.entries(grouped)) {
+      output += `### ${stack.toUpperCase()} STACK\n`;
+      output += list.map(item => `- ${item}`).join("\n") + "\n\n";
+    }
+
+    return {
+      content: [{ type: "text", text: output }],
+    };
+  }
+
+  async installRulesToProject(args) {
+    const { target_dir, stack } = args;
+    const targetRulesDir = path.join(target_dir, ".ai", "rules");
+    const targetScriptsDir = path.join(target_dir, ".ai", "scripts");
+    const targetHooksDir = path.join(target_dir, ".ai", "hooks");
+
+    let detectedStack = stack;
+    if (!detectedStack) {
+      detectedStack = await this.autoDetectStack(target_dir);
+    }
+
+    if (!detectedStack) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: "Could not auto-detect stack. Please specify 'stack' parameter explicitly (cloudflare, nuxt, flutter, dotnet)." }],
+      };
+    }
+
+    try {
+      // 1. Create target directories
+      await fs.mkdir(targetRulesDir, { recursive: true });
+      
+      // 2. Select rule files to copy
+      const ruleFilesToCopy = Object.keys(RULE_METADATA).filter(filename => {
+        const meta = RULE_METADATA[filename];
+        return meta.stack === detectedStack;
+      });
+
+      // 3. Copy files
+      for (const filename of ruleFilesToCopy) {
+        const srcPath = path.join(RULES_DIR, filename);
+        // Copy to flat folder in target project
+        const basename = filename.split("/")[1];
+        const destPath = path.join(targetRulesDir, basename);
+        await fs.copyFile(srcPath, destPath);
+      }
+
+      // 4. Scaffold stack-specific compilation and validation tooling if templates exist
+      const templatesDir = path.join(__dirname, "..", "templates", detectedStack);
+      let copiedScriptsCount = 0;
+      
+      try {
+        const stat = await fs.stat(templatesDir);
+        if (stat.isDirectory()) {
+          await fs.mkdir(targetScriptsDir, { recursive: true });
+          
+          // Copy scripts
+          const scriptFiles = await fs.readdir(templatesDir);
+          for (const sfile of scriptFiles) {
+            const srcPath = path.join(templatesDir, sfile);
+            const destPath = path.join(targetScriptsDir, sfile);
+            const scriptStat = await fs.stat(srcPath);
+
+            if (scriptStat.isFile()) {
+              await fs.copyFile(srcPath, destPath);
+              copiedScriptsCount++;
+            } else if (sfile === "hooks") {
+              // Copy hook sub-directory
+              await fs.mkdir(targetHooksDir, { recursive: true });
+              const hookFiles = await fs.readdir(srcPath);
+              for (const hfile of hookFiles) {
+                await fs.copyFile(path.join(srcPath, hfile), path.join(targetHooksDir, hfile));
+              }
+            }
+          }
+        }
+      } catch (err) {
+        // No templates for this stack, ignore script copying
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Successfully scaffolded project in ${target_dir}!\n` + 
+                  `- Detected Stack: ${detectedStack}\n` + 
+                  `- Copied ${ruleFilesToCopy.length} rule files to .ai/rules/\n` +
+                  (copiedScriptsCount > 0 ? `- Scaffolded validation scripts to .ai/scripts/ and git hooks to .ai/hooks/\n` : "") +
+                  `\nNext steps:\n` + 
+                  (detectedStack === "nuxt" || detectedStack === "cloudflare" ? `1. Run 'node .ai/scripts/install-hooks.js' to activate git pre-commit checks.\n2. Run 'node .ai/scripts/compile-context.js' to initialize CLAUDE.md / GEMINI.md context.` : "1. Setup pre-commit linting in your IDE or git configuration.")
+          },
+        ],
+      };
+    } catch (err) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: `Error scaffolding rules: ${err.message}` }],
+      };
+    }
+  }
+
+  async autoDetectStack(targetDir) {
+    try {
+      const files = await fs.readdir(targetDir);
+      if (files.includes("pubspec.yaml")) return "flutter";
+      if (files.includes("package.json")) {
+        if (files.includes("nuxt.config.ts") || files.includes("nuxt.config.js")) {
+          return "nuxt";
+        }
+        return "cloudflare";
+      }
+      const hasDotnet = files.some(f => f.endsWith(".csproj") || f.endsWith(".sln"));
+      if (hasDotnet) return "dotnet";
+    } catch (e) {
+      // ignore
+    }
+    return null;
+  }
+
+  async getAllRules() {
+    const ruleContents = [];
+    for (const filename of Object.keys(RULE_METADATA)) {
+      const filePath = path.join(RULES_DIR, filename);
+      const content = await fs.readFile(filePath, "utf-8");
+      ruleContents.push(`\n\n## Rule: ${filename}\n${content}`);
+    }
+    return {
+      content: [{ type: "text", text: ruleContents.join("\n") }],
+    };
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error("Unified AI Rules MCP Server running on stdio");
+  }
+}
+
+const server = new AIRulesServer();
+server.run().catch(console.error);