rvue-mcp 0.1.0

package/dist/bin/rvue-mcp.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/rvue-mcp.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import {
+  startServer
+} from "../chunk-TNWUYJWK.js";
+
+// bin/rvue-mcp.ts
+startServer().catch((error) => {
+  console.error("Failed to start rvue MCP server:", error);
+  process.exit(1);
+});

package/dist/chunk-TNWUYJWK.js

@@ -0,0 +1,752 @@
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z3 } from "zod";
+
+// src/intelligence/reader.ts
+import { readFileSync, existsSync, watchFile, unwatchFile } from "fs";
+import { join } from "path";
+
+// ../shared/src/schemas/intelligence.ts
+import { z } from "zod";
+var intelligenceSourceSchema = z.enum([
+  "code_analysis",
+  "config_import",
+  "stack_baseline",
+  "git_history",
+  "pr_analysis",
+  "rejection_analysis",
+  "comment_analysis"
+]);
+var maturityLevelSchema = z.union([
+  z.literal(1),
+  z.literal(2),
+  z.literal(3),
+  z.literal(4)
+]);
+var maturityLabelSchema = z.enum([
+  "baseline",
+  "growing",
+  "established",
+  "mature"
+]);
+var conventionCategorySchema = z.enum([
+  "imports",
+  "testing",
+  "naming",
+  "async",
+  "structure",
+  "error-handling",
+  "api",
+  "documentation",
+  "security",
+  "performance",
+  "type-safety",
+  "other"
+]);
+var antiPatternSeveritySchema = z.enum([
+  "critical",
+  "high",
+  "medium",
+  "low"
+]);
+var techStackSchema = z.object({
+  language: z.string(),
+  languages: z.array(z.string()).optional(),
+  framework: z.string().optional(),
+  framework_version: z.string().optional(),
+  test_framework: z.string().optional(),
+  linter: z.string().optional(),
+  formatter: z.string().optional(),
+  build_tool: z.string().optional(),
+  package_manager: z.string().optional()
+});
+var conventionExampleSchema = z.object({
+  pr_number: z.number().optional(),
+  file_path: z.string(),
+  snippet: z.string().optional()
+});
+var conventionSchema = z.object({
+  id: z.string(),
+  category: conventionCategorySchema,
+  rule: z.string(),
+  confidence: z.number().min(0).max(1),
+  source: intelligenceSourceSchema,
+  evidence_count: z.number(),
+  first_seen: z.string(),
+  examples: z.array(conventionExampleSchema),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var antiPatternEvidenceSchema = z.object({
+  pr_number: z.number(),
+  type: z.enum(["rejected_pr", "review_comment", "bug_fix"]),
+  excerpt: z.string().optional()
+});
+var antiPatternSchema = z.object({
+  id: z.string(),
+  pattern: z.string(),
+  severity: antiPatternSeveritySchema,
+  reason: z.string(),
+  correct_approach: z.string(),
+  evidence: z.array(antiPatternEvidenceSchema)
+});
+var knowledgeEntrySchema = z.object({
+  value: z.string(),
+  confidence: z.number().min(0).max(1),
+  source_prs: z.array(z.number())
+});
+var knowledgeGraphSchema = z.record(
+  z.string(),
+  z.record(z.string(), knowledgeEntrySchema)
+);
+var reviewerExpertiseSchema = z.object({
+  area: z.string(),
+  confidence: z.number().min(0).max(1),
+  review_count: z.number()
+});
+var reviewerStatsSchema = z.object({
+  total_reviews: z.number(),
+  avg_review_time_hours: z.number(),
+  approval_rate: z.number().min(0).max(1)
+});
+var reviewerProfileSchema = z.object({
+  github_login: z.string(),
+  expertise: z.array(reviewerExpertiseSchema),
+  stats: reviewerStatsSchema
+});
+var riskFactorSchema = z.object({
+  type: z.enum(["file", "size", "timing", "complexity"]),
+  description: z.string(),
+  value: z.string(),
+  risk_multiplier: z.number(),
+  evidence: z.object({
+    total_prs: z.number(),
+    incidents: z.number()
+  })
+});
+var maturitySchema = z.object({
+  level: maturityLevelSchema,
+  label: maturityLabelSchema,
+  prs_analyzed: z.number(),
+  next_level_at: z.number(),
+  sources: z.array(intelligenceSourceSchema)
+});
+var repositoryInfoSchema = z.object({
+  owner: z.string(),
+  name: z.string(),
+  full_name: z.string(),
+  analyzed_prs: z.number(),
+  analyzed_period: z.object({
+    from: z.string(),
+    to: z.string()
+  }),
+  tech_stack: techStackSchema,
+  rvue_version: z.string()
+});
+var intelligenceFileSchema = z.object({
+  version: z.string(),
+  generated_at: z.string(),
+  last_synced_at: z.string(),
+  maturity: maturitySchema,
+  repository: repositoryInfoSchema,
+  conventions: z.array(conventionSchema),
+  anti_patterns: z.array(antiPatternSchema),
+  knowledge_graph: knowledgeGraphSchema,
+  reviewers: z.array(reviewerProfileSchema),
+  risk_factors: z.array(riskFactorSchema)
+});
+var conventionsFileSchema = z.array(conventionSchema);
+var antiPatternsFileSchema = z.array(antiPatternSchema);
+var knowledgeFileSchema = knowledgeGraphSchema;
+var reviewersFileSchema = z.array(reviewerProfileSchema);
+var intelligenceMetaSchema = z.object({
+  version: z.string(),
+  generated_at: z.string(),
+  last_synced_at: z.string(),
+  maturity: maturitySchema,
+  repository: repositoryInfoSchema,
+  risk_factors: z.array(riskFactorSchema),
+  counts: z.object({
+    conventions: z.number(),
+    anti_patterns: z.number(),
+    reviewers: z.number(),
+    knowledge_topics: z.number()
+  })
+});
+var proposalSchema = z.object({
+  id: z.string(),
+  type: z.enum(["new_convention", "update_convention", "new_exception", "deprecate"]),
+  targetId: z.string().optional(),
+  data: conventionSchema.partial(),
+  reason: z.string(),
+  filePath: z.string().optional(),
+  createdAt: z.string(),
+  status: z.enum(["pending", "approved", "rejected"]),
+  approvedBy: z.string().optional()
+});
+var proposalsFileSchema = z.array(proposalSchema);
+
+// ../shared/src/schemas/config.ts
+import { z as z2 } from "zod";
+var customRuleSchema = z2.object({
+  name: z2.string(),
+  severity: z2.enum(["error", "warning", "info"]),
+  description: z2.string()
+});
+var RvueConfigSchema = z2.object({
+  version: z2.string(),
+  analysis: z2.object({
+    lookback_months: z2.number().default(12),
+    min_prs_for_pattern: z2.number().default(10),
+    min_confidence: z2.number().min(0).max(1).default(0.7),
+    include_closed_prs: z2.boolean().default(true)
+  }),
+  ignore: z2.object({
+    files: z2.array(z2.string()).default([]),
+    authors: z2.array(z2.string()).default(["dependabot", "renovate"]),
+    labels: z2.array(z2.string()).default(["wip", "draft"])
+  }),
+  sync: z2.object({
+    auto_commit: z2.boolean().default(false)
+  }),
+  custom_rules: z2.array(customRuleSchema).default([])
+});
+var userConfigSchema = z2.object({
+  auth: z2.object({
+    token: z2.string(),
+    github_token: z2.string(),
+    user: z2.object({
+      id: z2.string(),
+      login: z2.string(),
+      email: z2.string()
+    })
+  }).optional(),
+  defaults: z2.object({
+    ai_model: z2.string().default("deepseek")
+  }).optional()
+});
+
+// ../shared/src/constants.ts
+var PATHS = {
+  /** @deprecated Use individual file paths instead */
+  INTELLIGENCE_FILE: ".rvue/intelligence.json",
+  CONVENTIONS_FILE: ".rvue/conventions.json",
+  ANTI_PATTERNS_FILE: ".rvue/anti-patterns.json",
+  KNOWLEDGE_FILE: ".rvue/knowledge.json",
+  REVIEWERS_FILE: ".rvue/reviewers.json",
+  META_FILE: ".rvue/meta.json",
+  PROPOSALS_FILE: ".rvue/proposals.json",
+  README_FILE: ".rvue/README.md",
+  RVUE_GITIGNORE: ".rvue/.gitignore",
+  CONFIG_FILE: ".rvue/config.json",
+  SKILL_DIR: ".cursor/skills/rvue-team-intel",
+  SKILL_FILE: ".cursor/skills/rvue-team-intel/SKILL.md",
+  SKILL_REFERENCES: ".cursor/skills/rvue-team-intel/references",
+  SKILL_SCRIPTS: ".cursor/skills/rvue-team-intel/scripts",
+  USER_CONFIG: ".rvue/config.json"
+};
+var AI_MODELS = {
+  FREE: "deepseek/deepseek-v3.2",
+  PAID: "anthropic/claude-sonnet-4-20250514"
+};
+var PLAN_LIMITS = {
+  free: {
+    private_repos: 1,
+    pr_lookback: 100,
+    ai_model: AI_MODELS.FREE
+  },
+  team: {
+    private_repos: Infinity,
+    pr_lookback: Infinity,
+    ai_model: AI_MODELS.PAID
+  },
+  enterprise: {
+    private_repos: Infinity,
+    pr_lookback: Infinity,
+    ai_model: AI_MODELS.PAID
+  }
+};
+
+// src/intelligence/reader.ts
+var SPLIT_FILES = [
+  PATHS.META_FILE,
+  PATHS.CONVENTIONS_FILE,
+  PATHS.ANTI_PATTERNS_FILE,
+  PATHS.KNOWLEDGE_FILE,
+  PATHS.REVIEWERS_FILE
+];
+function readIntelligenceFile(cwd) {
+  const metaPath = join(cwd, PATHS.META_FILE);
+  if (existsSync(metaPath)) {
+    return readSplitFiles(cwd);
+  }
+  return readLegacyFile(cwd);
+}
+function watchIntelligenceFile(cwd, onChange) {
+  const reload = () => {
+    onChange(readIntelligenceFile(cwd));
+  };
+  const allPaths = [
+    join(cwd, PATHS.INTELLIGENCE_FILE),
+    ...SPLIT_FILES.map((rel) => join(cwd, rel))
+  ];
+  for (const abs of allPaths) {
+    watchFile(abs, { interval: 2e3 }, reload);
+  }
+  return () => {
+    for (const abs of allPaths) {
+      unwatchFile(abs, reload);
+    }
+  };
+}
+function readSplitFiles(cwd) {
+  try {
+    const meta = readJson(join(cwd, PATHS.META_FILE), intelligenceMetaSchema);
+    if (!meta) return null;
+    const conventions = readJson(join(cwd, PATHS.CONVENTIONS_FILE), conventionsFileSchema) ?? [];
+    const antiPatterns = readJson(join(cwd, PATHS.ANTI_PATTERNS_FILE), antiPatternsFileSchema) ?? [];
+    const knowledgeGraph = readJson(join(cwd, PATHS.KNOWLEDGE_FILE), knowledgeFileSchema) ?? {};
+    const reviewers = readJson(join(cwd, PATHS.REVIEWERS_FILE), reviewersFileSchema) ?? [];
+    return {
+      version: meta.version,
+      generated_at: meta.generated_at,
+      last_synced_at: meta.last_synced_at,
+      maturity: meta.maturity,
+      repository: meta.repository,
+      conventions,
+      anti_patterns: antiPatterns,
+      knowledge_graph: knowledgeGraph,
+      reviewers,
+      risk_factors: meta.risk_factors
+    };
+  } catch (error) {
+    console.error("Failed to read split intelligence files:", error);
+    return null;
+  }
+}
+function readLegacyFile(cwd) {
+  return readJson(
+    join(cwd, PATHS.INTELLIGENCE_FILE),
+    intelligenceFileSchema
+  );
+}
+function readJson(filePath, schema) {
+  if (!existsSync(filePath)) return null;
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return schema.parse(parsed);
+  } catch (error) {
+    console.error(`Failed to read ${filePath}:`, error);
+    return null;
+  }
+}
+
+// src/tools/get-team-context.ts
+function handleGetTeamContext(intelligence2, input) {
+  const scope = input.scope || "all";
+  const sections = [];
+  sections.push(`# Team Intelligence: ${intelligence2.repository.full_name}`);
+  sections.push(
+    `Maturity: ${intelligence2.maturity.label} | PRs analyzed: ${intelligence2.maturity.prs_analyzed}`
+  );
+  sections.push(
+    `Tech stack: ${intelligence2.repository.tech_stack.language}${intelligence2.repository.tech_stack.framework ? ` / ${intelligence2.repository.tech_stack.framework}` : ""}`
+  );
+  sections.push("");
+  let conventions;
+  if (scope === "all") {
+    conventions = intelligence2.conventions.slice(0, 20);
+  } else {
+    conventions = intelligence2.conventions.filter((c) => {
+      if (c.category === scope) return true;
+      if (input.file_path) {
+        return isConventionRelevantToFile(c, input.file_path);
+      }
+      return false;
+    });
+    if (conventions.length < 3) {
+      conventions = [
+        ...conventions,
+        ...intelligence2.conventions.filter((c) => c.category === scope).slice(0, 5)
+      ];
+    }
+  }
+  if (conventions.length > 0) {
+    sections.push("## Conventions");
+    sections.push("");
+    for (const conv of conventions) {
+      sections.push(
+        `- **${conv.rule}** (${conv.category}, ${Math.round(conv.confidence * 100)}% confidence)`
+      );
+    }
+    sections.push("");
+  }
+  let antiPatterns;
+  if (scope === "all") {
+    antiPatterns = intelligence2.anti_patterns.slice(0, 10);
+  } else {
+    antiPatterns = intelligence2.anti_patterns.filter((ap) => {
+      const patternLower = ap.pattern.toLowerCase();
+      const scopeLower = scope.toLowerCase();
+      return patternLower.includes(scopeLower);
+    });
+    if (antiPatterns.length === 0) {
+      antiPatterns = intelligence2.anti_patterns.slice(0, 5);
+    }
+  }
+  if (antiPatterns.length > 0) {
+    sections.push("## Anti-Patterns (Avoid These)");
+    sections.push("");
+    for (const ap of antiPatterns) {
+      sections.push(
+        `- **${ap.pattern}** [${ap.severity}] - ${ap.correct_approach}`
+      );
+    }
+    sections.push("");
+  }
+  if (scope !== "all") {
+    const relevantTopics = Object.entries(intelligence2.knowledge_graph).filter(
+      ([topic]) => topic.toLowerCase().includes(scope.toLowerCase())
+    );
+    if (relevantTopics.length > 0) {
+      sections.push("## Domain Knowledge");
+      sections.push("");
+      for (const [topic, entries] of relevantTopics) {
+        sections.push(`### ${topic}`);
+        for (const [key, entry] of Object.entries(entries)) {
+          sections.push(`- ${key}: ${entry.value}`);
+        }
+      }
+      sections.push("");
+    }
+  }
+  if (input.file_path) {
+    const fileReviewers = intelligence2.reviewers.filter(
+      (r) => r.expertise.some(
+        (e) => e.area.split("/").some((part) => input.file_path.includes(part))
+      )
+    ).slice(0, 3);
+    if (fileReviewers.length > 0) {
+      sections.push("## Suggested Reviewers for This File");
+      sections.push("");
+      for (const r of fileReviewers) {
+        sections.push(
+          `- @${r.github_login} (${r.stats.total_reviews} reviews)`
+        );
+      }
+    }
+  }
+  return sections.join("\n");
+}
+function isConventionRelevantToFile(conv, filePath) {
+  const fp = filePath.toLowerCase();
+  if (fp.includes(".test.") || fp.includes(".spec.") || fp.includes("__tests__")) {
+    return conv.category === "testing";
+  }
+  if (fp.includes("/api/") || fp.includes("route.ts") || fp.includes("handler")) {
+    return conv.category === "api" || conv.category === "error-handling";
+  }
+  if (fp.includes("component") || fp.endsWith(".tsx")) {
+    return conv.category === "naming" || conv.category === "structure";
+  }
+  return false;
+}
+
+// src/tools/check-code.ts
+function handleCheckCode(intelligence2, input) {
+  const violations = [];
+  const code = input.code;
+  const filePath = input.file_path || "";
+  for (const conv of intelligence2.conventions) {
+    if (conv.confidence < 0.7) continue;
+    const violation = checkConventionViolation(code, filePath, conv);
+    if (violation) {
+      violations.push({
+        convention_id: conv.id,
+        rule: conv.rule,
+        severity: violation.severity,
+        suggestion: violation.suggestion
+      });
+    }
+  }
+  for (const ap of intelligence2.anti_patterns) {
+    const violation = checkAntiPatternViolation(code, filePath, ap);
+    if (violation) {
+      violations.push({
+        convention_id: ap.id,
+        rule: ap.pattern,
+        severity: violation.severity,
+        suggestion: violation.suggestion
+      });
+    }
+  }
+  return {
+    violations,
+    passed: violations.filter((v) => v.severity === "error").length === 0
+  };
+}
+function checkConventionViolation(code, filePath, conv) {
+  const rule = conv.rule.toLowerCase();
+  if (rule.includes("named export") && conv.category === "imports") {
+    if (code.includes("export default ") && !filePath.includes("page.") && !filePath.includes("layout.")) {
+      return {
+        severity: "warning",
+        suggestion: "Use named exports. Replace `export default X` with `export { X }` or `export const/function X`."
+      };
+    }
+  }
+  if (rule.includes("path alias") && conv.category === "imports") {
+    if (code.match(/from\s+['"]\.\.\/\.\.\/\.\.\//)) {
+      return {
+        severity: "info",
+        suggestion: "Use path aliases (e.g., @/) instead of deep relative imports."
+      };
+    }
+  }
+  if (rule.includes("async/await") || rule.includes("async_await")) {
+    const thenCount = (code.match(/\.then\s*\(/g) || []).length;
+    if (thenCount > 0) {
+      return {
+        severity: "info",
+        suggestion: "Use async/await instead of .then() chains."
+      };
+    }
+  }
+  if (rule.includes("explicit return type") || rule.includes("return types")) {
+    const functionsWithoutReturnType = code.match(/(?:export\s+)?(?:async\s+)?function\s+\w+\s*\([^)]*\)\s*\{/g) || [];
+    if (functionsWithoutReturnType.length > 0) {
+      return {
+        severity: "info",
+        suggestion: "Add explicit return type annotations to functions."
+      };
+    }
+  }
+  return null;
+}
+function checkAntiPatternViolation(code, filePath, ap) {
+  const pattern = ap.pattern.toLowerCase();
+  if (pattern.includes("console.log") || pattern.includes("console statement")) {
+    const matches = code.match(/console\.(log|debug|info)\s*\(/g) || [];
+    if (matches.length > 0 && !filePath.includes(".test.") && !filePath.includes(".spec.")) {
+      return {
+        severity: ap.severity === "critical" ? "error" : "warning",
+        suggestion: ap.correct_approach || "Remove console statements or use a proper logger."
+      };
+    }
+  }
+  if (pattern.includes("any type") || pattern.includes("typescript any")) {
+    if (code.match(/:\s*any\b/) && !code.includes("eslint-disable")) {
+      return {
+        severity: "warning",
+        suggestion: ap.correct_approach || "Use specific types instead of `any`."
+      };
+    }
+  }
+  if (pattern.includes("todo") && pattern.includes("comment")) {
+    if (code.match(/\/\/\s*TODO/i)) {
+      return {
+        severity: "info",
+        suggestion: ap.correct_approach || "Resolve TODO comments before submitting."
+      };
+    }
+  }
+  return null;
+}
+
+// src/tools/get-knowledge.ts
+function handleGetKnowledge(intelligence2, input) {
+  const topic = input.topic.toLowerCase();
+  const exactMatch = Object.entries(intelligence2.knowledge_graph).find(([key]) => key.toLowerCase() === topic);
+  if (exactMatch) {
+    return formatKnowledge(exactMatch[0], exactMatch[1]);
+  }
+  const fuzzyMatches = Object.entries(intelligence2.knowledge_graph).filter(
+    ([key]) => key.toLowerCase().includes(topic) || topic.includes(key.toLowerCase())
+  );
+  if (fuzzyMatches.length > 0) {
+    const sections = fuzzyMatches.map(([key, entries]) => formatKnowledge(key, entries));
+    return sections.join("\n\n");
+  }
+  const availableTopics = Object.keys(intelligence2.knowledge_graph);
+  if (availableTopics.length === 0) {
+    return "No domain knowledge available yet. Run `rvue sync` to analyze PRs and extract knowledge.";
+  }
+  return `No knowledge found for topic: "${input.topic}"
+
+Available topics: ${availableTopics.join(", ")}`;
+}
+function formatKnowledge(topic, entries) {
+  const lines = [`## ${topic}`, ""];
+  for (const [key, entry] of Object.entries(entries)) {
+    lines.push(`### ${key}`);
+    lines.push(entry.value);
+    lines.push(`(confidence: ${Math.round(entry.confidence * 100)}%, sources: ${entry.source_prs.length} PRs)`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/suggest-reviewers.ts
+function handleSuggestReviewers(intelligence2, input) {
+  if (intelligence2.reviewers.length === 0) {
+    return [];
+  }
+  const changedDirs = /* @__PURE__ */ new Set();
+  for (const file of input.files) {
+    const parts = file.split("/");
+    if (parts.length > 1) {
+      changedDirs.add(parts.slice(0, 2).join("/"));
+      changedDirs.add(parts[0]);
+    } else {
+      changedDirs.add(parts[0]);
+    }
+  }
+  const scored = [];
+  for (const reviewer of intelligence2.reviewers) {
+    let relevance = 0;
+    const matchedAreas = [];
+    for (const expertise of reviewer.expertise) {
+      const area = expertise.area.toLowerCase();
+      for (const dir of changedDirs) {
+        const dirLower = dir.toLowerCase();
+        if (area.includes(dirLower) || dirLower.includes(area)) {
+          relevance += expertise.confidence * expertise.review_count;
+          matchedAreas.push(expertise.area);
+        }
+      }
+      for (const file of input.files) {
+        const ext = file.split(".").pop()?.toLowerCase() || "";
+        if (area.includes(ext) || area.includes(file.split("/").pop() || "")) {
+          relevance += expertise.confidence * 0.5;
+          if (!matchedAreas.includes(expertise.area)) {
+            matchedAreas.push(expertise.area);
+          }
+        }
+      }
+    }
+    if (relevance > 0) {
+      scored.push({
+        login: reviewer.github_login,
+        relevance: Math.round(relevance * 100) / 100,
+        areas: [...new Set(matchedAreas)]
+      });
+    }
+  }
+  return scored.sort((a, b) => b.relevance - a.relevance).slice(0, 5);
+}
+
+// src/server.ts
+var intelligence = null;
+async function startServer() {
+  const cwd = process.cwd();
+  intelligence = readIntelligenceFile(cwd);
+  if (!intelligence) {
+    console.error("Warning: No .rvue/ intelligence files found in current directory.");
+    console.error("Run `rvue enable` to generate intelligence first.");
+  }
+  const unwatch = watchIntelligenceFile(cwd, (updated) => {
+    intelligence = updated;
+    if (updated) {
+      console.error("Intelligence file updated, reloaded.");
+    }
+  });
+  const server = new McpServer({
+    name: "rvue",
+    version: "0.1.0"
+  });
+  server.tool(
+    "get_team_context",
+    "Get team coding conventions, anti-patterns, and domain knowledge. Use this before writing or reviewing code to understand how the team works.",
+    {
+      scope: z3.enum(["all", "imports", "testing", "naming", "async", "api", "auth", "database", "structure", "error-handling", "documentation", "security", "performance", "type-safety"]).optional().describe("Filter context to a specific area"),
+      file_path: z3.string().optional().describe("File path to get context specific to that file type")
+    },
+    async (params) => {
+      if (!intelligence) {
+        return {
+          content: [{ type: "text", text: "No intelligence data available. Run `rvue enable` first." }]
+        };
+      }
+      const result = handleGetTeamContext(intelligence, {
+        scope: params.scope,
+        file_path: params.file_path
+      });
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "check_code",
+    "Validate a code snippet against team conventions and anti-patterns. Returns violations with suggestions.",
+    {
+      code: z3.string().describe("The code snippet to check"),
+      file_path: z3.string().optional().describe("File path for context-aware checking")
+    },
+    async (params) => {
+      if (!intelligence) {
+        return {
+          content: [{ type: "text", text: "No intelligence data available. Run `rvue enable` first." }]
+        };
+      }
+      const result = handleCheckCode(intelligence, {
+        code: params.code,
+        file_path: params.file_path
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_knowledge",
+    "Get domain-specific knowledge about a topic (e.g., authentication, database, deployment)",
+    {
+      topic: z3.string().describe('The topic to look up (e.g., "authentication", "database", "api")')
+    },
+    async (params) => {
+      if (!intelligence) {
+        return {
+          content: [{ type: "text", text: "No intelligence data available. Run `rvue enable` first." }]
+        };
+      }
+      const result = handleGetKnowledge(intelligence, { topic: params.topic });
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "suggest_reviewers",
+    "Suggest the best reviewers for a set of changed files based on team expertise",
+    {
+      files: z3.array(z3.string()).describe("List of file paths that were changed")
+    },
+    async (params) => {
+      if (!intelligence) {
+        return {
+          content: [{ type: "text", text: "No intelligence data available. Run `rvue enable` first." }]
+        };
+      }
+      const result = handleSuggestReviewers(intelligence, { files: params.files });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.on("SIGINT", () => {
+    unwatch();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    unwatch();
+    process.exit(0);
+  });
+}
+
+export {
+  startServer
+};

package/dist/src/server.d.ts

@@ -0,0 +1,3 @@
+declare function startServer(): Promise<void>;
+
+export { startServer };

package/dist/src/server.js

@@ -0,0 +1,6 @@
+import {
+  startServer
+} from "../chunk-TNWUYJWK.js";
+export {
+  startServer
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "rvue-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for rvue team intelligence. Serves team conventions, anti-patterns, and domain knowledge to AI coding agents via the Model Context Protocol.",
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://rvue.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sriramfullstack/rvue-web-app",
+    "directory": "packages/mcp-server"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "cursor",
+    "conventions",
+    "code-review",
+    "team-intelligence"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "rvue-mcp": "./dist/bin/rvue-mcp.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "latest",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@rvue/shared": "workspace:*",
+    "tsup": "latest",
+    "typescript": "^5",
+    "@types/node": "^22"
+  }
+}