rebar-mcp 2.0.0

package/src/services/validation.ts

@@ -0,0 +1,138 @@
+/**
+ * Validation service for Claude Code configuration artifacts
+ */
+import { SKILL_NAME_MAX_LENGTH, SKILL_DESCRIPTION_MAX_LENGTH, CLAUDEMD_MAX_LINES } from "../constants.js";
+
+/**
+ * Extracts YAML frontmatter from a markdown file content.
+ * Returns the parsed key-value pairs or null if no frontmatter.
+ */
+export function extractFrontmatter(
+  content: string
+): Record<string, string> | null {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return null;
+
+  const frontmatter: Record<string, string> = {};
+  const lines = match[1].split("\n");
+
+  for (const line of lines) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx > 0) {
+      const key = line.substring(0, colonIdx).trim();
+      const value = line.substring(colonIdx + 1).trim();
+      frontmatter[key] = value;
+    }
+  }
+
+  return frontmatter;
+}
+
+/**
+ * Validates YAML frontmatter for a skill file.
+ */
+export function validateSkillFrontmatter(
+  content: string
+): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+  const fm = extractFrontmatter(content);
+
+  if (!fm) {
+    errors.push("Missing YAML frontmatter (must start with --- and end with ---)");
+    return { valid: false, errors };
+  }
+
+  if (!fm.name) {
+    errors.push("Missing required 'name' field in frontmatter");
+  } else if (fm.name.length > SKILL_NAME_MAX_LENGTH) {
+    errors.push(
+      `Skill name exceeds ${SKILL_NAME_MAX_LENGTH} chars: "${fm.name}" (${fm.name.length} chars)`
+    );
+  }
+
+  if (!fm.description) {
+    errors.push("Missing required 'description' field in frontmatter");
+  } else if (fm.description.length > SKILL_DESCRIPTION_MAX_LENGTH) {
+    errors.push(
+      `Skill description exceeds ${SKILL_DESCRIPTION_MAX_LENGTH} chars (${fm.description.length} chars)`
+    );
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Validates JSON content.
+ */
+export function validateJSON(
+  content: string,
+  label: string
+): { valid: boolean; errors: string[]; parsed: unknown } {
+  try {
+    const parsed: unknown = JSON.parse(content);
+    return { valid: true, errors: [], parsed };
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      valid: false,
+      errors: [`Invalid JSON in ${label}: ${message}`],
+      parsed: null,
+    };
+  }
+}
+
+/**
+ * Validates a CLAUDE.md file.
+ */
+export function validateClaudeMD(
+  content: string,
+  filePath: string
+): { valid: boolean; errors: string[]; warnings: string[] } {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  const lines = content.split("\n");
+
+  if (lines.length > CLAUDEMD_MAX_LINES) {
+    warnings.push(
+      `${filePath}: CLAUDE.md has ${lines.length} lines (recommended max: ${CLAUDEMD_MAX_LINES})`
+    );
+  }
+
+  if (!content.startsWith("#")) {
+    warnings.push(`${filePath}: CLAUDE.md should start with a heading`);
+  }
+
+  if (content.length === 0) {
+    errors.push(`${filePath}: CLAUDE.md is empty`);
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+/**
+ * Validates hook configuration object.
+ */
+export function validateHookConfig(
+  hook: Record<string, unknown>
+): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  if (!hook.command || typeof hook.command !== "string") {
+    errors.push("Hook missing required 'command' field (string)");
+  }
+
+  if (hook.event && typeof hook.event !== "string") {
+    errors.push("Hook 'event' must be a string");
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Estimates token count for a string.
+ * Uses a rough approximation of ~4 chars per token.
+ */
+export function estimateTokens(content: string): number {
+  return Math.ceil(content.length / 4);
+}

package/src/services/windsurf-generator.ts

@@ -0,0 +1,145 @@
+/**
+ * Windsurf configuration generator.
+ *
+ * Windsurf uses .windsurf/rules/*.md files similar to Cursor,
+ * but with a simpler frontmatter format using 'trigger: always'.
+ */
+import * as path from "node:path";
+import { ensureDir, atomicWrite } from "./file-ops.js";
+import type { GeneratedFile } from "../types.js";
+
+export interface WindsurfRuleTemplate {
+  name: string;
+  description: string;
+  content: string;
+}
+
+/**
+ * Converts CLAUDE.md content to Windsurf project-rules.md format.
+ */
+function convertToProjectRules(claudeMdContent: string): string {
+  const frontmatter = `---
+trigger: always
+---
+
+> Note: Windsurf does not support enforcement hooks. The guardrails below rely on
+> you following these rules. For automated enforcement, use Rebar with Claude Code
+> or run \`npx rebar-mcp audit\` in your CI pipeline.
+
+`;
+  return frontmatter + claudeMdContent;
+}
+
+/**
+ * Converts a rule template to Windsurf rule format.
+ */
+function convertToWindsurfRule(rule: WindsurfRuleTemplate): string {
+  const frontmatter = `---
+trigger: manual
+---
+
+`;
+  return frontmatter + rule.content;
+}
+
+/**
+ * Generates Windsurf configuration files from CLAUDE.md and skills.
+ */
+export async function generateWindsurfConfig(
+  projectPath: string,
+  claudeMdContent: string,
+  rules: WindsurfRuleTemplate[]
+): Promise<GeneratedFile[]> {
+  const files: GeneratedFile[] = [];
+  const rulesDir = path.join(projectPath, ".windsurf", "rules");
+
+  await ensureDir(rulesDir);
+
+  // Generate project-rules.md from CLAUDE.md
+  const projectRulesContent = convertToProjectRules(claudeMdContent);
+  const projectRulesPath = path.join(rulesDir, "project-rules.md");
+  await atomicWrite(projectRulesPath, projectRulesContent);
+  files.push({
+    path: ".windsurf/rules/project-rules.md",
+    content: projectRulesContent,
+    description: "Main project rules (from CLAUDE.md)",
+  });
+
+  // Convert rules
+  for (const rule of rules) {
+    const ruleContent = convertToWindsurfRule(rule);
+    const rulePath = path.join(rulesDir, `${rule.name}.md`);
+    await atomicWrite(rulePath, ruleContent);
+    files.push({
+      path: `.windsurf/rules/${rule.name}.md`,
+      content: ruleContent,
+      description: `${rule.name} rule`,
+    });
+  }
+
+  return files;
+}
+
+/**
+ * Default rules for Windsurf.
+ */
+export function getDefaultWindsurfRules(): WindsurfRuleTemplate[] {
+  return [
+    {
+      name: "code-review",
+      description: "Code review guidelines",
+      content: `# Code Review
+
+When reviewing code changes:
+
+1. **Security First**: Check for injection vulnerabilities, auth issues, data exposure
+2. **Error Handling**: Ensure errors are properly caught and handled
+3. **Type Safety**: Verify types are correct and 'any' is avoided
+4. **Performance**: Watch for N+1 queries, memory leaks, unnecessary re-renders
+5. **Tests**: Ensure tests exist and pass for changed code
+`,
+    },
+    {
+      name: "test-writer",
+      description: "Test writing guidelines",
+      content: `# Test Writing
+
+When writing tests:
+
+1. Test behavior, not implementation
+2. Use descriptive test names
+3. Follow the Arrange-Act-Assert pattern
+4. Mock external dependencies
+5. Aim for edge cases, not just happy paths
+`,
+    },
+    {
+      name: "security-scan",
+      description: "Security scanning guidelines",
+      content: `# Security Scan
+
+Check for:
+
+1. Hardcoded secrets (API keys, passwords)
+2. SQL injection vulnerabilities
+3. XSS in rendered HTML
+4. Insecure direct object references
+5. Missing authentication/authorization
+`,
+    },
+    {
+      name: "documentation",
+      description: "Documentation guidelines",
+      content: `# Documentation
+
+When documenting:
+
+1. Document the WHY, not the WHAT
+2. Keep documentation close to code
+3. Update docs when changing code
+4. Use examples liberally
+5. Document public APIs thoroughly
+`,
+    },
+  ];
+}