crosspad-mcp-server 4.0.0

package/src/tools/architecture.ts

@@ -0,0 +1,260 @@
+import fs from "fs";
+import path from "path";
+import { REPOS } from "../config.js";
+import { runCommand } from "../utils/exec.js";
+
+// --- crosspad_interfaces ---
+
+export interface InterfaceInfo {
+  name: string;
+  file: string;
+}
+
+export interface ImplementationInfo {
+  className: string;
+  file: string;
+  platform: string;
+}
+
+function findInterfaces(): InterfaceInfo[] {
+  const coreInclude = path.join(REPOS["crosspad-core"], "include", "crosspad");
+  const results: InterfaceInfo[] = [];
+
+  function scan(dir: string) {
+    if (!fs.existsSync(dir)) return;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scan(fullPath);
+      } else if (entry.name.startsWith("I") && entry.name.endsWith(".hpp")) {
+        // Extract class name from file
+        const content = fs.readFileSync(fullPath, "utf-8");
+        const match = content.match(/class\s+(I[A-Z]\w+)\b/);
+        if (match) {
+          results.push({
+            name: match[1],
+            file: fullPath.replace(/\\/g, "/"),
+          });
+        }
+      }
+    }
+  }
+
+  scan(coreInclude);
+  return results;
+}
+
+function findImplementations(interfaceName: string): ImplementationInfo[] {
+  const results: ImplementationInfo[] = [];
+  const pattern = `class\\s+\\w+.*:\\s*(public\\s+)?.*${interfaceName}`;
+
+  const platformMap: Record<string, string> = {
+    "crosspad-core": "shared",
+    "crosspad-gui": "gui",
+    "crosspad-pc": "PC",
+    "ESP32-S3": "ESP32-S3",
+    "2playerCrosspad": "2player",
+  };
+
+  for (const [name, repoPath] of Object.entries(REPOS)) {
+    if (!fs.existsSync(repoPath)) continue;
+
+    const result = runCommand(
+      `git grep -n -E "${pattern}" -- "*.hpp" "*.cpp" "*.h"`,
+      repoPath
+    );
+
+    if (!result.success && result.stdout.length === 0) continue;
+
+    for (const line of result.stdout.split("\n")) {
+      if (!line.trim()) continue;
+      const colonIdx = line.indexOf(":");
+      if (colonIdx < 0) continue;
+
+      const filePart = line.slice(0, colonIdx);
+      const codePart = line.slice(colonIdx + 1);
+
+      // Extract the line number and code
+      const lineNumMatch = codePart.match(/^(\d+):(.*)/);
+      const code = lineNumMatch ? lineNumMatch[2] : codePart;
+
+      const classMatch = code.match(/class\s+(\w+)/);
+      if (classMatch) {
+        results.push({
+          className: classMatch[1],
+          file: path.join(repoPath, filePart).replace(/\\/g, "/"),
+          platform: platformMap[name] ?? name,
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
+interface CapabilityInfo {
+  flags: string[];
+  platforms: Record<string, string[]>;
+}
+
+function queryCapabilities(): CapabilityInfo {
+  const capsFile = path.join(
+    REPOS["crosspad-core"],
+    "include",
+    "crosspad",
+    "platform",
+    "PlatformCapabilities.hpp"
+  );
+
+  // Parse enum flags
+  const flags: string[] = [];
+  if (fs.existsSync(capsFile)) {
+    const content = fs.readFileSync(capsFile, "utf-8");
+    const enumMatch = content.match(/enum\s+class\s+Capability[^{]*\{([^}]+)\}/s);
+    if (enumMatch) {
+      for (const line of enumMatch[1].split("\n")) {
+        const flagMatch = line.match(/\b(\w+)\s*=/);
+        if (flagMatch && flagMatch[1] !== "None" && flagMatch[1] !== "All") {
+          flags.push(flagMatch[1]);
+        }
+      }
+    }
+  }
+
+  // Find which platforms set which caps
+  const platforms: Record<string, string[]> = {};
+  const platformMap: Record<string, string> = {
+    "crosspad-pc": "PC",
+    "ESP32-S3": "ESP32-S3",
+    "2playerCrosspad": "2player",
+  };
+
+  for (const [name, repoPath] of Object.entries(REPOS)) {
+    if (!platformMap[name]) continue;
+    if (!fs.existsSync(repoPath)) continue;
+
+    const result = runCommand(
+      `git grep -h "addPlatformCapability\\|setPlatformCapabilities" -- "*.cpp" "*.hpp" "*.h"`,
+      repoPath
+    );
+
+    if (!result.success && result.stdout.length === 0) continue;
+
+    const caps: string[] = [];
+    for (const line of result.stdout.split("\n")) {
+      const matches = line.match(/Capability::(\w+)/g);
+      if (matches) {
+        for (const m of matches) {
+          const cap = m.replace("Capability::", "");
+          if (!caps.includes(cap)) caps.push(cap);
+        }
+      }
+    }
+    if (caps.length > 0) {
+      platforms[platformMap[name]] = caps;
+    }
+  }
+
+  return { flags, platforms };
+}
+
+export function crosspadInterfaces(
+  query: string
+): Record<string, unknown> {
+  const parts = query.trim().split(/\s+/);
+  const command = parts[0]?.toLowerCase();
+
+  if (command === "list") {
+    return { interfaces: findInterfaces() };
+  }
+
+  if (command === "implementations" && parts[1]) {
+    const interfaceName = parts[1];
+    const interfaces = findInterfaces();
+    const defined = interfaces.find((i) => i.name === interfaceName);
+    return {
+      interface: interfaceName,
+      defined_in: defined?.file ?? "not found",
+      implementations: findImplementations(interfaceName),
+    };
+  }
+
+  if (command === "capabilities") {
+    const caps = queryCapabilities();
+    return { flags: caps.flags, platforms: caps.platforms };
+  }
+
+  return {
+    error: `Unknown query: "${query}". Use "list", "implementations <InterfaceName>", or "capabilities".`,
+  };
+}
+
+// --- crosspad_apps ---
+
+export interface AppInfo {
+  name: string;
+  registration_file: string;
+  platform: string;
+}
+
+export function crosspadApps(
+  platform: "pc" | "esp32" | "2player" | "all"
+): AppInfo[] {
+  const results: AppInfo[] = [];
+
+  const targets: [string, string][] = [];
+  if (platform === "pc" || platform === "all") targets.push(["PC", REPOS["crosspad-pc"]]);
+  if (platform === "esp32" || platform === "all") targets.push(["ESP32-S3", REPOS["ESP32-S3"]]);
+  if (platform === "2player" || platform === "all") targets.push(["2player", REPOS["2playerCrosspad"]]);
+
+  for (const [platName, repoPath] of targets) {
+    if (!fs.existsSync(repoPath)) continue;
+
+    // Search for REGISTER_APP and _register_*_app patterns
+    const result = runCommand(
+      `git grep -n -E "REGISTER_APP\\(|void _register_\\w+_app\\(\\)" -- "*.cpp"`,
+      repoPath
+    );
+
+    if (!result.success && result.stdout.length === 0) continue;
+
+    for (const line of result.stdout.split("\n")) {
+      if (!line.trim()) continue;
+
+      const colonIdx = line.indexOf(":");
+      if (colonIdx < 0) continue;
+      const filePart = line.slice(0, colonIdx);
+      const rest = line.slice(colonIdx + 1);
+
+      // REGISTER_APP(Name, ...)
+      let match = rest.match(/REGISTER_APP\((\w+)/);
+      if (match) {
+        results.push({
+          name: match[1],
+          registration_file: filePart,
+          platform: platName,
+        });
+        continue;
+      }
+
+      // void _register_Name_app()
+      match = rest.match(/_register_(\w+)_app\(/);
+      if (match) {
+        results.push({
+          name: match[1],
+          registration_file: filePart,
+          platform: platName,
+        });
+      }
+    }
+  }
+
+  // Deduplicate by name+platform
+  const seen = new Set<string>();
+  return results.filter((app) => {
+    const key = `${app.platform}:${app.name}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}

package/src/tools/build-check.ts

@@ -0,0 +1,178 @@
+import fs from "fs";
+import path from "path";
+import { CROSSPAD_PC_ROOT, BUILD_DIR, BIN_EXE, REPOS } from "../config.js";
+import { runCommand } from "../utils/exec.js";
+import { getHead, getSubmodulePin } from "../utils/git.js";
+
+export interface BuildCheckResult {
+  needs_reconfigure: boolean;
+  needs_rebuild: boolean;
+  exe_exists: boolean;
+  exe_age_seconds: number | null;
+  reasons: string[];
+  submodule_changes: Record<string, { pinned: string | null; current: string | null; changed: boolean }>;
+  new_source_files: string[];
+}
+
+/**
+ * Detect whether cmake reconfigure or rebuild is needed.
+ * Checks:
+ * - Does build/ dir exist?
+ * - Does bin/main.exe exist?
+ * - Are there new .cpp/.hpp files not in CMakeCache?
+ * - Did crosspad-core or crosspad-gui HEAD change vs pinned?
+ * - Are there uncommitted changes in source?
+ */
+export function crosspadBuildCheck(): BuildCheckResult {
+  const reasons: string[] = [];
+  let needsReconfigure = false;
+  let needsRebuild = false;
+
+  // Check build dir
+  const buildExists = fs.existsSync(BUILD_DIR);
+  if (!buildExists) {
+    needsReconfigure = true;
+    reasons.push("build/ directory does not exist — need full configure");
+  }
+
+  // Check exe
+  const exeExists = fs.existsSync(BIN_EXE);
+  let exeAgeSeconds: number | null = null;
+  if (exeExists) {
+    const stat = fs.statSync(BIN_EXE);
+    exeAgeSeconds = (Date.now() - stat.mtimeMs) / 1000;
+  } else {
+    needsRebuild = true;
+    reasons.push(`${path.relative(CROSSPAD_PC_ROOT, BIN_EXE)} not found — need build`);
+  }
+
+  // Check for source files newer than exe
+  if (exeExists) {
+    const exeMtime = fs.statSync(BIN_EXE).mtimeMs;
+    const srcDirs = [
+      path.join(CROSSPAD_PC_ROOT, "src"),
+      path.join(CROSSPAD_PC_ROOT, "crosspad-core", "src"),
+      path.join(CROSSPAD_PC_ROOT, "crosspad-core", "include"),
+      path.join(CROSSPAD_PC_ROOT, "crosspad-gui", "src"),
+      path.join(CROSSPAD_PC_ROOT, "crosspad-gui", "include"),
+    ];
+
+    let newerCount = 0;
+    for (const dir of srcDirs) {
+      if (!fs.existsSync(dir)) continue;
+      newerCount += countFilesNewerThan(dir, exeMtime, [".cpp", ".hpp", ".h", ".c"]);
+      if (newerCount > 0) break; // One is enough
+    }
+    if (newerCount > 0) {
+      needsRebuild = true;
+      reasons.push("Source files are newer than executable");
+    }
+  }
+
+  // Check for new source files not tracked by CMake (GLOB_RECURSE freshness)
+  const newSourceFiles: string[] = [];
+  if (buildExists) {
+    const cacheFile = path.join(BUILD_DIR, "build.ninja");
+    if (fs.existsSync(cacheFile)) {
+      const ninjaContent = fs.readFileSync(cacheFile, "utf-8");
+      // Find .cpp files in src/apps that aren't in build.ninja
+      const appsDir = path.join(CROSSPAD_PC_ROOT, "src", "apps");
+      if (fs.existsSync(appsDir)) {
+        const cppFiles = findFiles(appsDir, [".cpp"]);
+        for (const f of cppFiles) {
+          const relative = path.relative(CROSSPAD_PC_ROOT, f).replace(/\\/g, "/");
+          if (!ninjaContent.includes(relative) && !ninjaContent.includes(path.basename(f))) {
+            newSourceFiles.push(relative);
+          }
+        }
+      }
+    }
+  }
+
+  if (newSourceFiles.length > 0) {
+    needsReconfigure = true;
+    reasons.push(`${newSourceFiles.length} source file(s) not in build system — need reconfigure`);
+  }
+
+  // Submodule changes (dev-mode aware)
+  const submoduleChanges: Record<string, { pinned: string | null; current: string | null; changed: boolean }> = {};
+  for (const sub of ["crosspad-core", "crosspad-gui"]) {
+    const pinned = getSubmodulePin(CROSSPAD_PC_ROOT, sub);
+    const subPath = path.join(CROSSPAD_PC_ROOT, sub);
+    let current: string | null = null;
+
+    if (fs.existsSync(subPath)) {
+      // In dev-mode (junction), get HEAD of the junction target
+      const result = runCommand("git rev-parse HEAD", subPath);
+      current = result.success ? result.stdout.trim() : null;
+    }
+
+    const changed = pinned !== null && current !== null && !current.startsWith(pinned.slice(0, 7));
+    submoduleChanges[sub] = { pinned, current, changed };
+
+    if (changed) {
+      needsRebuild = true;
+      reasons.push(`${sub} HEAD differs from pinned commit`);
+    }
+
+    // Check for dirty files in submodule
+    if (fs.existsSync(subPath)) {
+      const dirty = runCommand("git status --porcelain", subPath);
+      if (dirty.success && dirty.stdout.trim().length > 0) {
+        const dirtyCount = dirty.stdout.trim().split("\n").length;
+        needsRebuild = true;
+        reasons.push(`${sub} has ${dirtyCount} dirty file(s)`);
+      }
+    }
+  }
+
+  if (reasons.length === 0) {
+    reasons.push("Build appears up to date");
+  }
+
+  return {
+    needs_reconfigure: needsReconfigure,
+    needs_rebuild: needsRebuild || needsReconfigure,
+    exe_exists: exeExists,
+    exe_age_seconds: exeAgeSeconds !== null ? Math.round(exeAgeSeconds) : null,
+    reasons,
+    submodule_changes: submoduleChanges,
+    new_source_files: newSourceFiles,
+  };
+}
+
+function countFilesNewerThan(dir: string, thresholdMs: number, extensions: string[]): number {
+  let count = 0;
+  try {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        count += countFilesNewerThan(fullPath, thresholdMs, extensions);
+      } else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+        const stat = fs.statSync(fullPath);
+        if (stat.mtimeMs > thresholdMs) count++;
+      }
+      if (count > 0) return count; // Early exit
+    }
+  } catch {
+    // Ignore permission errors etc.
+  }
+  return count;
+}
+
+function findFiles(dir: string, extensions: string[]): string[] {
+  const results: string[] = [];
+  try {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findFiles(fullPath, extensions));
+      } else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+    // Ignore
+  }
+  return results;
+}

package/src/tools/build.ts

@@ -0,0 +1,130 @@
+import fs from "fs";
+import path from "path";
+import { CROSSPAD_PC_ROOT, BUILD_DIR, BIN_EXE, VCPKG_TOOLCHAIN, IS_WINDOWS } from "../config.js";
+import { runBuild, runBuildStream, spawnDetached, OnLine } from "../utils/exec.js";
+
+export interface BuildResult {
+  success: boolean;
+  duration_seconds: number;
+  errors: string[];
+  warnings_count: number;
+  output_path: string;
+}
+
+function parseErrors(output: string): string[] {
+  const errors: string[] = [];
+  for (const line of output.split("\n")) {
+    if (/\berror\b/i.test(line) && !line.includes("error(s)")) {
+      errors.push(line.trim());
+    }
+  }
+  return errors.slice(0, 20); // Cap at 20 errors
+}
+
+function countWarnings(output: string): number {
+  let count = 0;
+  for (const line of output.split("\n")) {
+    if (/\bwarning\b/i.test(line) && !line.includes("warning(s)")) {
+      count++;
+    }
+  }
+  return count;
+}
+
+export async function crosspadBuild(
+  mode: "incremental" | "clean" | "reconfigure",
+  onLine?: OnLine
+): Promise<BuildResult> {
+  const startTime = Date.now();
+
+  // Clean: remove build dir
+  if (mode === "clean" && fs.existsSync(BUILD_DIR)) {
+    onLine?.("stdout", "[crosspad] Cleaning build directory...");
+    fs.rmSync(BUILD_DIR, { recursive: true, force: true });
+  }
+
+  // Configure if clean or reconfigure
+  if (mode === "clean" || mode === "reconfigure") {
+    const generator = process.env.CMAKE_GENERATOR || (IS_WINDOWS ? "Ninja" : "");
+    const genFlag = generator ? ` -G ${generator}` : "";
+    const configCmd = [
+      `cmake -B build${genFlag}`,
+      `-DCMAKE_TOOLCHAIN_FILE=${VCPKG_TOOLCHAIN}`,
+      "-DCMAKE_BUILD_TYPE=Debug",
+    ].join(" ");
+
+    onLine?.("stdout", `[crosspad] Configuring: ${mode}...`);
+
+    if (onLine) {
+      const configResult = await runBuildStream(configCmd, CROSSPAD_PC_ROOT, onLine, 600_000);
+      if (!configResult.success) {
+        const combined = configResult.stdout + "\n" + configResult.stderr;
+        return {
+          success: false,
+          duration_seconds: (Date.now() - startTime) / 1000,
+          errors: parseErrors(combined),
+          warnings_count: countWarnings(combined),
+          output_path: BIN_EXE,
+        };
+      }
+    } else {
+      const configResult = runBuild(configCmd, CROSSPAD_PC_ROOT, 600_000);
+      if (!configResult.success) {
+        const combined = configResult.stdout + "\n" + configResult.stderr;
+        return {
+          success: false,
+          duration_seconds: (Date.now() - startTime) / 1000,
+          errors: parseErrors(combined),
+          warnings_count: countWarnings(combined),
+          output_path: BIN_EXE,
+        };
+      }
+    }
+  }
+
+  // Build
+  onLine?.("stdout", "[crosspad] Building...");
+
+  let buildStdout: string;
+  let buildStderr: string;
+  let buildSuccess: boolean;
+
+  if (onLine) {
+    const buildResult = await runBuildStream("cmake --build build", CROSSPAD_PC_ROOT, onLine, 600_000);
+    buildStdout = buildResult.stdout;
+    buildStderr = buildResult.stderr;
+    buildSuccess = buildResult.success;
+  } else {
+    const buildResult = runBuild("cmake --build build", CROSSPAD_PC_ROOT, 600_000);
+    buildStdout = buildResult.stdout;
+    buildStderr = buildResult.stderr;
+    buildSuccess = buildResult.success;
+  }
+
+  const combined = buildStdout + "\n" + buildStderr;
+  const result: BuildResult = {
+    success: buildSuccess,
+    duration_seconds: (Date.now() - startTime) / 1000,
+    errors: parseErrors(combined),
+    warnings_count: countWarnings(combined),
+    output_path: BIN_EXE,
+  };
+
+  onLine?.("stdout", `[crosspad] Build ${result.success ? "succeeded" : "FAILED"} in ${result.duration_seconds.toFixed(1)}s`);
+
+  return result;
+}
+
+export interface RunResult {
+  pid: number | null;
+  exe_path: string;
+}
+
+export function crosspadRun(): RunResult {
+  if (!fs.existsSync(BIN_EXE)) {
+    return { pid: null, exe_path: BIN_EXE };
+  }
+
+  const pid = spawnDetached(BIN_EXE, [], CROSSPAD_PC_ROOT);
+  return { pid, exe_path: BIN_EXE };
+}

package/src/tools/diff-core.ts

@@ -0,0 +1,130 @@
+import fs from "fs";
+import path from "path";
+import { CROSSPAD_PC_ROOT, REPOS } from "../config.js";
+import { runCommand } from "../utils/exec.js";
+import { getSubmodulePin } from "../utils/git.js";
+
+export interface DiffEntry {
+  status: string; // A, M, D, R
+  file: string;
+}
+
+export interface SubmoduleDiff {
+  name: string;
+  pinned_commit: string | null;
+  current_commit: string | null;
+  is_dev_mode: boolean;
+  ahead_count: number;
+  behind_count: number;
+  changed_files: DiffEntry[];
+  uncommitted_changes: string[];
+  commit_log: string[];
+}
+
+export interface DiffCoreResult {
+  submodules: SubmoduleDiff[];
+}
+
+/**
+ * Show what changed in crosspad-core and/or crosspad-gui relative to the
+ * pinned submodule commit. Essential for dev-mode workflows where you're
+ * editing shared repos but haven't committed/pinned yet.
+ */
+export function crosspadDiffCore(
+  submodule: "crosspad-core" | "crosspad-gui" | "both" = "both"
+): DiffCoreResult {
+  const targets = submodule === "both"
+    ? ["crosspad-core", "crosspad-gui"]
+    : [submodule];
+
+  const submodules: SubmoduleDiff[] = [];
+
+  for (const sub of targets) {
+    const subPath = path.join(CROSSPAD_PC_ROOT, sub);
+    const isDevMode = isJunction(subPath);
+    const pinnedCommit = getSubmodulePin(CROSSPAD_PC_ROOT, sub);
+
+    // Get current HEAD
+    const headResult = runCommand("git rev-parse HEAD", subPath);
+    const currentCommit = headResult.success ? headResult.stdout.trim() : null;
+
+    let aheadCount = 0;
+    let behindCount = 0;
+    let changedFiles: DiffEntry[] = [];
+    let commitLog: string[] = [];
+
+    if (pinnedCommit && currentCommit && pinnedCommit !== currentCommit) {
+      // Count commits ahead/behind
+      const countResult = runCommand(
+        `git rev-list --count --left-right ${pinnedCommit}...HEAD`,
+        subPath
+      );
+      if (countResult.success) {
+        const parts = countResult.stdout.trim().split(/\s+/);
+        behindCount = parseInt(parts[0] || "0", 10);
+        aheadCount = parseInt(parts[1] || "0", 10);
+      }
+
+      // Get diff stat (files changed between pinned and HEAD)
+      const diffResult = runCommand(
+        `git diff --name-status ${pinnedCommit}...HEAD`,
+        subPath
+      );
+      if (diffResult.success) {
+        changedFiles = diffResult.stdout
+          .trim()
+          .split("\n")
+          .filter((l) => l.length > 0)
+          .map((line) => {
+            const parts = line.split("\t");
+            return { status: parts[0], file: parts.slice(1).join("\t") };
+          });
+      }
+
+      // Get commit log between pinned and HEAD
+      const logResult = runCommand(
+        `git log --oneline ${pinnedCommit}..HEAD`,
+        subPath
+      );
+      if (logResult.success) {
+        commitLog = logResult.stdout
+          .trim()
+          .split("\n")
+          .filter((l) => l.length > 0)
+          .slice(0, 20); // Cap at 20
+      }
+    }
+
+    // Uncommitted changes (working tree)
+    const statusResult = runCommand("git status --porcelain", subPath);
+    const uncommittedChanges = statusResult.success
+      ? statusResult.stdout
+          .trim()
+          .split("\n")
+          .filter((l) => l.length > 0)
+      : [];
+
+    submodules.push({
+      name: sub,
+      pinned_commit: pinnedCommit,
+      current_commit: currentCommit,
+      is_dev_mode: isDevMode,
+      ahead_count: aheadCount,
+      behind_count: behindCount,
+      changed_files: changedFiles,
+      uncommitted_changes: uncommittedChanges,
+      commit_log: commitLog,
+    });
+  }
+
+  return { submodules };
+}
+
+function isJunction(p: string): boolean {
+  try {
+    const stat = fs.lstatSync(p);
+    return stat.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}