rebar-mcp 2.0.0

package/src/services/file-ops.ts

@@ -0,0 +1,172 @@
+/**
+ * File operations service with atomic writes and safety checks
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as crypto from "node:crypto";
+
+/**
+ * Ensures a directory exists, creating it recursively if needed.
+ */
+export async function ensureDir(dirPath: string): Promise<void> {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+/**
+ * Writes a file atomically: writes to a temp file first, then renames.
+ * This prevents partial writes from corrupting existing files.
+ */
+export async function atomicWrite(filePath: string, content: string): Promise<void> {
+  const dir = path.dirname(filePath);
+  await ensureDir(dir);
+
+  const tmpName = `.tmp-${crypto.randomBytes(8).toString("hex")}`;
+  const tmpPath = path.join(dir, tmpName);
+
+  try {
+    await fs.writeFile(tmpPath, content, "utf-8");
+    await fs.rename(tmpPath, filePath);
+  } catch (err: unknown) {
+    // Clean up temp file on failure
+    try {
+      await fs.unlink(tmpPath);
+    } catch {
+      // Ignore cleanup errors
+    }
+    throw err;
+  }
+}
+
+/**
+ * Checks if a file exists.
+ */
+export async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Reads a file and returns its content, or null if it doesn't exist.
+ */
+export async function readFileSafe(filePath: string): Promise<string | null> {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Lists files in a directory matching an optional extension filter.
+ */
+export async function listFiles(
+  dirPath: string,
+  extension?: string
+): Promise<string[]> {
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    return entries
+      .filter((e) => e.isFile() && (!extension || e.name.endsWith(extension)))
+      .map((e) => path.join(dirPath, e.name));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Recursively lists all files under a directory.
+ */
+export async function listFilesRecursive(
+  dirPath: string,
+  extension?: string
+): Promise<string[]> {
+  const results: string[] = [];
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        const sub = await listFilesRecursive(fullPath, extension);
+        results.push(...sub);
+      } else if (!extension || entry.name.endsWith(extension)) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+    // Directory doesn't exist or not readable
+  }
+  return results;
+}
+
+/**
+ * Resolves a project path to an absolute path.
+ */
+export function resolveProjectPath(projectPath: string): string {
+  if (path.isAbsolute(projectPath)) {
+    return path.normalize(projectPath);
+  }
+  return path.resolve(process.cwd(), projectPath);
+}
+
+/**
+ * Sanitizes a file path to prevent directory traversal attacks.
+ * Ensures the resolved path is within the project root.
+ */
+export function sanitizePath(basePath: string, relativePath: string): string {
+  const resolved = path.resolve(basePath, relativePath);
+  const normalizedBase = path.normalize(basePath);
+  if (!resolved.startsWith(normalizedBase)) {
+    throw new Error(
+      `Path traversal detected: "${relativePath}" resolves outside project root`
+    );
+  }
+  return resolved;
+}
+
+/**
+ * Writes a file only if it doesn't exist or mergeExisting is true.
+ * Returns info about what was done.
+ */
+export async function safeWriteFile(
+  filePath: string,
+  content: string,
+  mergeExisting: boolean
+): Promise<{ written: boolean; merged: boolean; message: string }> {
+  const exists = await fileExists(filePath);
+
+  if (exists && !mergeExisting) {
+    return {
+      written: false,
+      merged: false,
+      message: `File already exists: ${filePath}. Set merge_existing=true to overwrite.`,
+    };
+  }
+
+  if (exists && mergeExisting) {
+    await atomicWrite(filePath, content);
+    return {
+      written: true,
+      merged: true,
+      message: `Merged/updated: ${filePath}`,
+    };
+  }
+
+  await atomicWrite(filePath, content);
+  return {
+    written: true,
+    merged: false,
+    message: `Created: ${filePath}`,
+  };
+}
+
+/**
+ * Creates a temp directory for intermediate operations.
+ */
+export async function createTempDir(): Promise<string> {
+  return await fs.mkdtemp(path.join(os.tmpdir(), "rebar-"));
+}

package/src/services/platform-detect.ts

@@ -0,0 +1,80 @@
+/**
+ * Platform detection for multi-AI-tool support.
+ *
+ * Detects which AI coding platforms are configured in a project:
+ * - Claude Code: .claude/ directory or CLAUDE.md
+ * - Cursor: .cursor/ directory or .cursorrules
+ * - Windsurf: .windsurf/ directory
+ * - Codex CLI: AGENTS.md
+ */
+import * as path from "node:path";
+import { fileExists } from "./file-ops.js";
+
+export type AIPlatform = "claude-code" | "cursor" | "windsurf" | "codex";
+
+export interface DetectedPlatforms {
+  platforms: AIPlatform[];
+  evidence: Record<AIPlatform, string>;
+}
+
+/**
+ * Detects which AI coding platforms are configured in a project.
+ */
+export async function detectPlatforms(projectPath: string): Promise<DetectedPlatforms> {
+  const platforms: AIPlatform[] = [];
+  const evidence: Partial<Record<AIPlatform, string>> = {};
+
+  // Claude Code: .claude/ directory or CLAUDE.md exists
+  if (await fileExists(path.join(projectPath, ".claude")) || await fileExists(path.join(projectPath, "CLAUDE.md"))) {
+    platforms.push("claude-code");
+    evidence["claude-code"] = "Found .claude/ directory or CLAUDE.md";
+  }
+
+  // Cursor: .cursor/ directory or .cursorrules exists
+  if (await fileExists(path.join(projectPath, ".cursor")) || await fileExists(path.join(projectPath, ".cursorrules"))) {
+    platforms.push("cursor");
+    evidence["cursor"] = "Found .cursor/ directory or .cursorrules";
+  }
+
+  // Windsurf: .windsurf/ directory exists
+  if (await fileExists(path.join(projectPath, ".windsurf"))) {
+    platforms.push("windsurf");
+    evidence["windsurf"] = "Found .windsurf/ directory";
+  }
+
+  // Codex: AGENTS.md exists
+  if (await fileExists(path.join(projectPath, "AGENTS.md"))) {
+    platforms.push("codex");
+    evidence["codex"] = "Found AGENTS.md";
+  }
+
+  // If nothing detected, default to Claude Code (since we're an MCP server running in it)
+  if (platforms.length === 0) {
+    platforms.push("claude-code");
+    evidence["claude-code"] = "Default (no platform detected)";
+  }
+
+  return {
+    platforms,
+    evidence: evidence as Record<AIPlatform, string>,
+  };
+}
+
+/**
+ * Resolves "all" platform specifier to actual platforms.
+ */
+export async function resolvePlatforms(
+  projectPath: string,
+  specified: string[]
+): Promise<AIPlatform[]> {
+  if (specified.includes("all")) {
+    // Detect existing platforms, or generate for all if none found
+    const detected = await detectPlatforms(projectPath);
+    if (detected.platforms.length <= 1 && detected.evidence["claude-code"]?.includes("Default")) {
+      // Nothing detected, generate for all platforms
+      return ["claude-code", "cursor", "windsurf", "codex"];
+    }
+    return detected.platforms;
+  }
+  return specified.filter((p) => p !== "all") as AIPlatform[];
+}