rebar-mcp 2.0.0

package/src/constants.ts

@@ -0,0 +1,131 @@
+/**
+ * Constants and default values for rebar-mcp
+ */
+
+export const TOOL_PREFIX = "rebar_";
+
+export const SKILL_NAME_MAX_LENGTH = 64;
+export const SKILL_DESCRIPTION_MAX_LENGTH = 200;
+export const CLAUDEMD_MAX_LINES = 500;
+export const SKILL_BUDGET_PERCENT = 2;
+
+/** Approximate tokens per character for budget estimation */
+export const TOKENS_PER_CHAR = 0.25;
+
+/** Claude Code context window size for budget calculations */
+export const CONTEXT_WINDOW_TOKENS = 200_000;
+
+export const HOOK_EVENTS = [
+  "PreToolCall",
+  "PostToolCall",
+  "Notification",
+  "Stop",
+  "SubagentStop",
+  "PreCompact",
+  "PostCompact",
+  "SessionStart",
+] as const;
+
+export const TECH_STACKS = [
+  "nextjs",
+  "react",
+  "vue",
+  "angular",
+  "svelte",
+  "express",
+  "fastapi",
+  "django",
+  "flask",
+  "springboot",
+  "rails",
+  "laravel",
+  "go",
+  "rust",
+  "dotnet",
+] as const;
+
+export const COMPLIANCE_STANDARDS = ["hipaa", "sox", "pci-dss", "soc2"] as const;
+
+export const ARTIFACT_TYPES = [
+  "skill",
+  "agent",
+  "hook",
+  "command",
+  "knowledge",
+  "claudemd",
+  "mcp-config",
+  "settings",
+] as const;
+
+export const MCP_SERVICES = [
+  "github",
+  "sentry",
+  "postgres",
+  "slack",
+  "linear",
+  "jira",
+  "datadog",
+  "pagerduty",
+  "vercel",
+  "supabase",
+] as const;
+
+/** Dangerous commands blocked by security hooks */
+export const DANGEROUS_COMMANDS_STANDARD = [
+  "rm -rf /",
+  "rm -rf ~",
+  "rm -rf .",
+  "git push --force",
+  "git push -f",
+  "DROP TABLE",
+  "DROP DATABASE",
+  "TRUNCATE",
+];
+
+export const DANGEROUS_COMMANDS_STRICT = [
+  ...DANGEROUS_COMMANDS_STANDARD,
+  "git reset --hard",
+  "git checkout -- .",
+  "chmod 777",
+  "curl | sh",
+  "wget | sh",
+];
+
+export const DANGEROUS_COMMANDS_PARANOID = [
+  ...DANGEROUS_COMMANDS_STRICT,
+  "eval(",
+  "exec(",
+  "sudo ",
+  "su -",
+  "pkill",
+  "killall",
+];
+
+export const SECRET_PATTERNS = [
+  "AKIA[0-9A-Z]{16}", // AWS Access Key
+  "sk-[a-zA-Z0-9]{48}", // OpenAI API Key
+  "sk-ant-[a-zA-Z0-9-]{90,}", // Anthropic API Key
+  "ghp_[a-zA-Z0-9]{36}", // GitHub PAT
+  "glpat-[a-zA-Z0-9-]{20}", // GitLab PAT
+  "xoxb-[0-9]{10,}", // Slack Bot Token
+  "-----BEGIN (RSA |EC )?PRIVATE KEY-----", // Private keys
+];
+
+/** Default file patterns for tech stack detection */
+export const STACK_DETECTION_FILES: Record<string, string[]> = {
+  nextjs: ["next.config.js", "next.config.ts", "next.config.mjs"],
+  react: ["src/App.tsx", "src/App.jsx"],
+  vue: ["vue.config.js", "nuxt.config.ts"],
+  angular: ["angular.json"],
+  svelte: ["svelte.config.js"],
+  express: ["app.js", "server.js"],
+  fastapi: ["main.py", "app/main.py"],
+  django: ["manage.py", "settings.py"],
+  flask: ["app.py", "wsgi.py"],
+  springboot: ["pom.xml", "build.gradle"],
+  rails: ["Gemfile", "config/routes.rb"],
+  laravel: ["artisan", "composer.json"],
+  go: ["go.mod"],
+  rust: ["Cargo.toml"],
+  dotnet: ["*.csproj", "*.sln"],
+};

package/src/index.ts

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+/**
+ * rebar-mcp
+ *
+ * Reinforcement for AI-generated code. Enforcement hooks, quality audits,
+ * and opinionated templates that prevent AI coding tools from shipping broken code.
+ *
+ * Transport: stdio (primary), streamable HTTP (secondary)
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerScaffoldingTools } from "./tools/scaffolding.js";
+import { registerKnowledgeTools } from "./tools/knowledge.js";
+import { registerManagementTools } from "./tools/management.js";
+import { registerEnterpriseTools } from "./tools/enterprise.js";
+import { runCLI } from "./cli.js";
+
+async function runMCPServer(): Promise<void> {
+  const server = new McpServer({
+    name: "rebar-mcp",
+    version: "2.0.0",
+  });
+
+  // Register all tool modules
+  registerScaffoldingTools(server);   // Tier 1: init, claudemd, skill, agent, hook, command
+  registerKnowledgeTools(server);     // Tier 2: knowledge, adr
+  registerManagementTools(server);    // Tier 2: list, validate, audit, doctor
+  registerEnterpriseTools(server);    // Tier 3: compliance, ci, security, mcp-config
+
+  // Connect via stdio transport
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  // Log to stderr (stdout is reserved for MCP protocol)
+  console.error("rebar-mcp v2.0.0 started on stdio transport");
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  // CLI mode: any command without --mcp flag
+  if (args.length > 0 && !args.includes("--mcp")) {
+    const exitCode = await runCLI(args);
+    process.exit(exitCode);
+  }
+
+  // MCP server mode (default when no args, or with --mcp flag)
+  await runMCPServer();
+}
+
+main().catch((err: unknown) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/src/schemas/common.ts

@@ -0,0 +1,22 @@
+/**
+ * Common Zod schemas shared across tools
+ */
+import { z } from "zod";
+import {
+  TECH_STACKS,
+  COMPLIANCE_STANDARDS,
+  HOOK_EVENTS,
+  ARTIFACT_TYPES,
+  MCP_SERVICES,
+} from "../constants.js";
+
+export const TechStackSchema = z.enum(TECH_STACKS);
+export const ComplianceStandardSchema = z.enum(COMPLIANCE_STANDARDS);
+export const HookEventSchema = z.enum(HOOK_EVENTS);
+export const ArtifactTypeFilterSchema = z.enum([...ARTIFACT_TYPES, "all"] as const);
+export const MCPServiceSchema = z.enum(MCP_SERVICES);
+
+export const ProjectPathSchema = z
+  .string()
+  .min(1)
+  .describe("Absolute or relative path to the project root directory");

package/src/schemas/scaffolding.ts

@@ -0,0 +1,161 @@
+/**
+ * Zod schemas for scaffolding tool inputs
+ */
+import { z } from "zod";
+import {
+  TechStackSchema,
+  ComplianceStandardSchema,
+  HookEventSchema,
+  ProjectPathSchema,
+  ArtifactTypeFilterSchema,
+  MCPServiceSchema,
+} from "./common.js";
+
+export const InitProjectInputSchema = z.object({
+  project_path: ProjectPathSchema,
+  tech_stack: z.array(TechStackSchema).min(1).describe("Technology stacks used in the project"),
+  team_size: z.number().int().min(1).max(1000).describe("Number of developers on the team"),
+  compliance: z
+    .array(ComplianceStandardSchema)
+    .optional()
+    .default([])
+    .describe("Compliance standards to apply"),
+  strictness: z
+    .enum(["standard", "strict", "paranoid"])
+    .default("standard")
+    .describe("Enforcement strictness level. 'standard' notifies on issues, 'strict' blocks on test/lint failures, 'paranoid' adds file size limits, any-type blocking, and commit completeness checks."),
+  platforms: z
+    .array(z.enum(["claude-code", "cursor", "windsurf", "codex", "all"]))
+    .default(["all"])
+    .describe("Which AI coding platforms to generate configuration for. 'all' generates for all supported platforms."),
+}).strict();
+
+export const GenerateClaudeMDInputSchema = z.object({
+  project_path: ProjectPathSchema,
+  scope: z.enum(["root", "subdir"]).default("root").describe("Whether this is the root or subdirectory CLAUDE.md"),
+  tech_stack: z.array(TechStackSchema).optional().describe("Tech stack override; auto-detected if omitted"),
+  merge_existing: z.boolean().default(false).describe("Whether to merge with an existing CLAUDE.md"),
+}).strict();
+
+export const CreateSkillInputSchema = z.object({
+  name: z.string().min(1).max(64).describe("Skill name (max 64 chars, lowercase with hyphens)"),
+  description: z.string().min(1).max(200).describe("Skill description (max 200 chars)"),
+  invocation: z.enum(["user", "auto", "both"]).default("user").describe("How the skill is triggered"),
+  context: z.enum(["inline", "fork"]).default("inline").describe("Whether skill runs inline or in forked context"),
+  agent_type: z.string().optional().describe("Agent type hint for forked skills"),
+  allowed_tools: z.array(z.string()).optional().default([]).describe("List of tools the skill can use"),
+}).strict();
+
+export const CreateAgentInputSchema = z.object({
+  name: z.string().min(1).max(64).describe("Agent name (lowercase with hyphens)"),
+  description: z.string().min(1).max(200).describe("Agent description"),
+  role: z.enum(["explore", "plan", "general", "custom"]).default("general").describe("Agent role type"),
+  allowed_tools: z.array(z.string()).optional().default([]).describe("Tools the agent can access"),
+  model_hint: z.string().optional().describe("Preferred model hint"),
+}).strict();
+
+export const CreateHookInputSchema = z.object({
+  event: HookEventSchema.describe("Claude Code lifecycle event to hook into"),
+  matcher: z.string().optional().describe("Regex pattern to match (e.g., tool name for PreToolCall)"),
+  command: z.string().min(1).describe("Shell command to execute"),
+  exit_behavior: z.enum(["block", "notify"]).default("block").describe("What to do on non-zero exit"),
+  description: z.string().min(1).describe("Human-readable description of the hook"),
+}).strict();
+
+export const CreateCommandInputSchema = z.object({
+  name: z.string().min(1).max(64).describe("Command name (used as /command-name)"),
+  description: z.string().min(1).max(200).describe("Command description"),
+  prompt_body: z.string().min(1).describe("The prompt template body for the command"),
+  arguments: z
+    .array(
+      z.object({
+        name: z.string(),
+        description: z.string(),
+        required: z.boolean().default(true),
+      }).strict()
+    )
+    .optional()
+    .default([])
+    .describe("Arguments the command accepts"),
+}).strict();
+
+export const CreateKnowledgeInputSchema = z.object({
+  title: z.string().min(1).describe("Document title"),
+  category: z.enum(["adr", "runbook", "api", "schema", "style"]).describe("Document category"),
+  content: z.string().min(1).describe("Document content in markdown"),
+  tags: z.array(z.string()).optional().default([]).describe("Tags for categorization"),
+}).strict();
+
+export const CreateADRInputSchema = z.object({
+  title: z.string().min(1).describe("ADR title"),
+  status: z.enum(["proposed", "accepted", "deprecated"]).default("proposed").describe("Decision status"),
+  context: z.string().min(1).describe("Context and problem statement"),
+  decision: z.string().min(1).describe("The decision made"),
+  consequences: z.string().min(1).describe("Consequences of the decision"),
+}).strict();
+
+export const ListArtifactsInputSchema = z.object({
+  project_path: ProjectPathSchema,
+  type_filter: ArtifactTypeFilterSchema.optional().default("all").describe("Filter by artifact type"),
+}).strict();
+
+export const ValidateConfigInputSchema = z.object({
+  project_path: ProjectPathSchema,
+  fix_mode: z.enum(["report", "auto_fix"]).default("report").describe("Whether to report issues or auto-fix them"),
+}).strict();
+
+export const AuditContextInputSchema = z.object({
+  project_path: ProjectPathSchema,
+}).strict();
+
+export const ApplyComplianceInputSchema = z.object({
+  project_path: ProjectPathSchema,
+  standard: ComplianceStandardSchema.describe("Compliance standard to apply"),
+  scope: z.enum(["full", "hooks_only", "skills_only"]).default("full").describe("Scope of compliance artifacts"),
+}).strict();
+
+export const CreateCIWorkflowInputSchema = z.object({
+  repo_path: ProjectPathSchema.describe("Path to the git repository"),
+  review_focus: z.enum(["security", "performance", "style", "all"]).default("all").describe("Focus area for reviews"),
+  branch_pattern: z.string().default("main").describe("Branch pattern to trigger on"),
+}).strict();
+
+export const CreateSecurityHookInputSchema = z.object({
+  project_path: ProjectPathSchema,
+  strictness: z.enum(["standard", "strict", "paranoid"]).default("standard").describe("Security strictness level"),
+}).strict();
+
+export const GenerateMCPConfigInputSchema = z.object({
+  project_path: ProjectPathSchema,
+  services: z.array(MCPServiceSchema).min(1).describe("MCP services to configure"),
+  scope: z.enum(["project", "user"]).default("project").describe("Configuration scope"),
+}).strict();
+
+export const SetStrictnessInputSchema = z.object({
+  project_path: ProjectPathSchema,
+  strictness: z.enum(["standard", "strict", "paranoid"]).describe("Desired strictness level"),
+  output_format: z.enum(["markdown", "json"]).default("markdown").describe("Output format"),
+}).strict();
+
+export const DoctorInputSchema = z.object({
+  project_path: ProjectPathSchema,
+  output_format: z.enum(["markdown", "json"]).default("markdown").describe("Output format"),
+}).strict();
+
+export const MetricsInputSchema = z.object({
+  project_path: ProjectPathSchema,
+  action: z.enum(["view", "record"]).default("view").describe("View history or record new score"),
+  output_format: z.enum(["markdown", "json"]).default("markdown").describe("Output format"),
+}).strict();
+
+export const BadgeInputSchema = z.object({
+  project_path: ProjectPathSchema,
+  style: z.enum(["flat", "flat-square", "plastic"]).default("flat").describe("Badge style"),
+  output_format: z.enum(["svg", "json"]).default("svg").describe("Output format"),
+}).strict();
+
+export const CustomRulesInputSchema = z.object({
+  project_path: ProjectPathSchema,
+  action: z.enum(["list", "init", "evaluate"]).default("list").describe("Action to perform"),
+  output_format: z.enum(["markdown", "json"]).default("markdown").describe("Output format"),
+}).strict();