@mmerterden/dev-toolkit-mcp 2.24.1

package/tools/design-check/mock-detect.js

@@ -0,0 +1,213 @@
+/**
+ * design_mock_detect - decide whether a mobile project can be launched in a
+ * mock/stub mode so its screens can be captured deterministically.
+ *
+ * Fully generic: no project, owner, or repo name is hardcoded. Detection is
+ * signal-based (naming conventions + DI patterns + well-known switch NAMES),
+ * and the caller may inject project-specific switch keys via opts.extraKeys.
+ * Scanning uses ripgrep when available (fast, .gitignore-aware) and falls back
+ * to a bounded node walk otherwise.
+ *
+ * returns:
+ *   {
+ *     supported: true | false | "debug-only",
+ *     platform:  "ios" | "android" | "unknown",
+ *     mechanism: "userdefaults-launcharg" | "interceptor" | "debug-di" | null,
+ *     activation: { kind, key?, value?, launchArg?/intentExtra?, buildConfig },
+ *     variantsHint: [ ... ],
+ *     evidence: [ { signal, file, line, snippet } ],
+ *     reason: <human string when unsupported>
+ *   }
+ */
+
+import { readFileSync, existsSync } from "fs";
+import { basename } from "path";
+
+import { hasRg, rg, walk, rel, detectPlatform, SRC_EXT } from "./scan.js";
+
+const KNOWN_MOCK_KEYS = [
+  "debugMockMode", "mockServiceIsActive", "mock-service-is-active",
+  "traceweave.mock.enabled", "isMockEnabled", "isMockMode", "useMockData",
+  "useMockServices", "MOCK_MODE", "UITEST_MOCK", "mockEnabled",
+];
+
+function hasLaunchableAndroidApp(repoPath) {
+  if (hasRg()) {
+    try {
+      const app = rg("com\\.android\\.application|applicationId\\s+[\"']", repoPath,
+        { globs: ["-g", "*.gradle", "-g", "*.gradle.kts"] });
+      if (app.length) return true;
+      const launcher = rg("android\\.intent\\.category\\.LAUNCHER", repoPath, { globs: ["-g", "AndroidManifest.xml"] });
+      return launcher.length > 0;
+    } catch { /* fall through */ }
+  }
+  let launchable = false;
+  walk(repoPath, (f) => {
+    const b = basename(f);
+    if (b === "build.gradle" || b === "build.gradle.kts" || b === "AndroidManifest.xml") {
+      let t = ""; try { t = readFileSync(f, "utf-8"); } catch { return; }
+      if (/com\.android\.application|applicationId\s+["']|android\.intent\.category\.LAUNCHER/.test(t)) launchable = true;
+    }
+  });
+  return launchable;
+}
+
+// Core signal scan. Populates `state` with runtimeKey/interceptor/debugDI/etc.
+function scanWithRg(repoPath, keys, state) {
+  const keyAlt = keys.map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  // 1. known/injected runtime switch keys
+  for (const hit of rg(`["'](?:${keyAlt})["']`, repoPath)) {
+    const km = /["']([^"']+)["']/.exec(hit.text);
+    const k = km ? km[1] : "?";
+    if (/traceweave\.mock|URLProtocol|interceptor/i.test(hit.text) || k.includes("traceweave")) state.interceptor = true;
+    state.runtimeKey = state.runtimeKey || k;
+    state.push(`runtime-switch:${k}`, hit, repoPath);
+  }
+  // 2. generic AppStorage/UserDefaults "mock" bool key
+  if (!state.runtimeKey) {
+    for (const hit of rg(`(?:@AppStorage|forKey|defaults\\.\\w+)\\s*\\(?\\s*["'][A-Za-z0-9_.\\-]*[Mm]ock[A-Za-z0-9_.\\-]*["']`, repoPath)) {
+      const km = /["']([A-Za-z0-9_.\-]*[Mm]ock[A-Za-z0-9_.\-]*)["']/.exec(hit.text);
+      if (km) { state.runtimeKey = km[1]; state.push(`runtime-switch:${km[1]}`, hit, repoPath); break; }
+    }
+  }
+  // 2b. launch-argument mock (ProcessInfo.processInfo.arguments.contains) + arg constants
+  if (!state.runtimeKey) {
+    const la = rg("ProcessInfo\\.processInfo\\.arguments\\.contains", repoPath);
+    if (la.length) {
+      const argHits = rg("static let \\w+\\s*=\\s*\"(-[A-Za-z]*[Mm]ock[A-Za-z0-9]*)\"", repoPath);
+      const am = argHits.length ? /"(-[A-Za-z0-9]+)"/.exec(argHits[0].text) : null;
+      state.runtimeKey = am ? am[1] : "-Mock";
+      state.launchArg = true;
+      state.push("runtime-launcharg", la[0], repoPath);
+    }
+  }
+  // 2c. constant-defined UserDefaults mock key (string literal with 'mock', not inline @AppStorage)
+  if (!state.runtimeKey) {
+    const ck = rg("static let \\w+\\s*=\\s*\"[A-Za-z0-9_.\\-]*[Mm]ock[A-Za-z0-9_.\\-]*\"", repoPath);
+    if (ck.length) {
+      const cm = /"([A-Za-z0-9_.\-]*[Mm]ock[A-Za-z0-9_.\-]*)"/.exec(ck[0].text);
+      if (cm) { state.runtimeKey = cm[1]; state.push(`runtime-switch:${cm[1]}`, ck[0], repoPath); }
+    }
+  }
+  // 3. mock type declarations
+  const typeHits = rg(`\\b(?:class|struct|final class|object|enum)\\s+(?:Mock[A-Za-z0-9]+|[A-Za-z0-9]+Mock(?:Service|NetworkService|Repository|Provider|DataSource))\\b`, repoPath);
+  state.mockTypeCount = typeHits.length;
+  typeHits.slice(0, 8).forEach((h) => {
+    const tm = /\s(Mock[A-Za-z0-9]+|[A-Za-z0-9]+Mock(?:Service|NetworkService|Repository|Provider|DataSource))\b/.exec(h.text);
+    state.push(`mock-type:${tm ? tm[1] : "Mock"}`, h, repoPath);
+  });
+  // 4. #if DEBUG return Mock (compile-time DI)
+  const diHits = rg(`#if\\s+DEBUG.{0,400}?return\\s+Mock[A-Za-z0-9]+`, repoPath, { multiline: true });
+  if (diHits.length) { state.debugDI = true; state.push("debug-di", diHits[0], repoPath); }
+  // 5. MockData fixtures → variant hints
+  for (const f of rg("**/MockData/**/*.json", repoPath, { files: true, globs: [] })) {
+    const b = basename(f.file);
+    const vm = /([A-Za-z0-9]+)_mock\.json$|mock_([A-Za-z0-9]+)\.json$/i.exec(b);
+    state.variants.add((vm ? (vm[1] || vm[2]) : b.replace(/\.json$/i, "")).toLowerCase());
+  }
+}
+
+function scanWithWalk(repoPath, keys, state) {
+  const keyRegexes = keys.map((k) => ({ k, re: new RegExp(`["']${k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']`) }));
+  const genericRe = /(?:@AppStorage|forKey|defaults\.\w+)\s*\(?\s*["']([A-Za-z0-9_.\-]*[Mm]ock[A-Za-z0-9_.\-]*)["']/;
+  const typeRe = /\b(?:class|struct|final class|object|enum)\s+(Mock[A-Za-z0-9]+|[A-Za-z0-9]+Mock(?:Service|NetworkService|Repository|Provider|DataSource))\b/;
+  const diRe = /#if\s+DEBUG[\s\S]{0,400}?\breturn\s+Mock[A-Za-z0-9]+/;
+  const varRe = /([A-Za-z0-9]+)_mock\.json$|mock_([A-Za-z0-9]+)\.json$/i;
+  const laUseRe = /ProcessInfo\.processInfo\.arguments\.contains/;
+  const laConstRe = /static let \w+\s*=\s*"(-[A-Za-z]*[Mm]ock[A-Za-z0-9]*)"/;
+  const constKeyRe = /static let \w+\s*=\s*"([A-Za-z0-9_.\-]*[Mm]ock[A-Za-z0-9_.\-]*)"/;
+  walk(repoPath, (file) => {
+    const b = basename(file);
+    const ext = "." + (b.split(".").pop() || "");
+    if (ext === ".json" && /\/MockData\//.test(file)) {
+      const m = varRe.exec(b);
+      state.variants.add((m ? (m[1] || m[2]) : b.replace(/\.json$/i, "")).toLowerCase());
+      return;
+    }
+    if (!SRC_EXT.has(ext)) return;
+    let txt = ""; try { txt = readFileSync(file, "utf-8"); } catch { return; }
+    if (!/[Mm]ock/.test(txt)) return;
+    const mkHit = (idx) => { const line = txt.slice(0, idx).split("\n").length; return { file, line, text: (txt.split("\n")[line - 1] || "").trim() }; };
+    for (const { k, re } of keyRegexes) {
+      const m = re.exec(txt);
+      if (m) { if (/traceweave\.mock|URLProtocol|interceptor/i.test(txt) || k.includes("traceweave")) state.interceptor = true; state.runtimeKey = state.runtimeKey || k; state.push(`runtime-switch:${k}`, mkHit(m.index), repoPath); }
+    }
+    if (!state.runtimeKey) { const gm = genericRe.exec(txt); if (gm) { state.runtimeKey = gm[1]; state.push(`runtime-switch:${gm[1]}`, mkHit(gm.index), repoPath); } }
+    // launch-argument mock (ProcessInfo.arguments.contains) + arg constant (may be in different files)
+    if (laUseRe.test(txt)) state.launchArgUsed = true;
+    if (!state.launchArgConst) { const lm = laConstRe.exec(txt); if (lm) { state.launchArgConst = lm[1]; state.launchArgHit = mkHit(lm.index); } }
+    if (!state.constKeyCand) { const cm = constKeyRe.exec(txt); if (cm && !cm[1].startsWith("-")) { state.constKeyCand = cm[1]; state.constKeyHit = mkHit(cm.index); } }
+    const dm = diRe.exec(txt); if (dm) { state.debugDI = true; state.push("debug-di", mkHit(dm.index), repoPath); }
+    const tm = typeRe.exec(txt); if (tm) { state.mockTypeCount++; if (state.mockTypeCount <= 8) state.push(`mock-type:${tm[1]}`, mkHit(tm.index), repoPath); }
+  });
+}
+
+export function detectMock({ repoPath, platform, extraKeys = [] } = {}) {
+  if (!repoPath || !existsSync(repoPath)) {
+    return { supported: false, platform: "unknown", mechanism: null, reason: `repoPath not found: ${repoPath}`, evidence: [] };
+  }
+  const plat = platform || detectPlatform(repoPath);
+  const keys = [...new Set([...KNOWN_MOCK_KEYS, ...extraKeys])];
+
+  const evidence = [];
+  const state = {
+    runtimeKey: null, launchArg: false, interceptor: false, debugDI: false, mockTypeCount: 0,
+    variants: new Set(),
+    push(signal, hit, rp) { evidence.push({ signal, file: rel(rp, hit.file), line: hit.line, snippet: (hit.text || "").slice(0, 160) }); },
+  };
+
+  let scanned = false;
+  if (hasRg()) { try { scanWithRg(repoPath, keys, state); scanned = true; } catch { /* fall back */ } }
+  if (!scanned) scanWithWalk(repoPath, keys, state);
+
+  // Resolve launch-argument / constant-defined mock switches (either scan sets the flags).
+  if (!state.runtimeKey) {
+    if (state.launchArgUsed && state.launchArgConst) {
+      state.runtimeKey = state.launchArgConst; state.launchArg = true;
+      if (state.launchArgHit) state.push(`runtime-launcharg:${state.launchArgConst}`, state.launchArgHit, repoPath);
+    } else if (state.constKeyCand) {
+      state.runtimeKey = state.constKeyCand;
+      if (state.constKeyHit) state.push(`runtime-switch:${state.constKeyCand}`, state.constKeyHit, repoPath);
+    }
+  }
+
+  const variantsHint = [...state.variants].slice(0, 40);
+
+  // If platform is still unknown, infer it from the evidence file extensions so
+  // the activation (iOS launch arg vs Android intent extra) is never mis-picked.
+  let effPlat = plat;
+  if (effPlat === "unknown") {
+    const exts = evidence.map((e) => (e.file || "").split(".").pop());
+    if (exts.includes("swift")) effPlat = "ios";
+    else if (exts.includes("kt") || exts.includes("kts")) effPlat = "android";
+  }
+
+  if (effPlat === "android" && !hasLaunchableAndroidApp(repoPath)) {
+    return { supported: false, platform: effPlat, mechanism: null,
+      reason: "No launchable Android application module found (library set only) - nothing to run in mock mode.",
+      variantsHint, evidence };
+  }
+
+  if (state.runtimeKey) {
+    const isFlag = state.launchArg || state.runtimeKey.startsWith("-");
+    const kind = state.interceptor ? "interceptor" : (isFlag ? "launch-argument" : "userdefaults-launcharg");
+    return {
+      supported: true, platform: effPlat, mechanism: kind,
+      activation: effPlat === "android"
+        ? { kind, key: state.runtimeKey, value: "true", intentExtra: `--ez ${state.runtimeKey.replace(/^-/, "")} true`, buildConfig: "debug" }
+        : { kind, key: state.runtimeKey, value: isFlag ? "(flag)" : "YES", launchArg: isFlag ? state.runtimeKey : `-${state.runtimeKey} YES`, buildConfig: "Debug" },
+      variantsHint, evidence,
+    };
+  }
+  if (state.debugDI || state.mockTypeCount > 0) {
+    return {
+      supported: "debug-only", platform: effPlat, mechanism: "debug-di",
+      activation: { kind: "build-config", buildConfig: effPlat === "android" ? "debug" : "Debug" },
+      note: "Mocks are compiled into the Debug build via #if DEBUG DI. No runtime switch → variants cannot be toggled at launch; only the default Debug state is comparable.",
+      variantsHint, evidence,
+    };
+  }
+  return { supported: false, platform: effPlat, mechanism: null,
+    reason: "No mock switch, mock service naming, or MockData fixtures detected - project has no mock support this tool can drive.",
+    variantsHint, evidence };
+}