refactor: update constants and improve score calculation logic with proxy fetch

aidenybai · aidenybai · commit 051a02cf3581 · 2026-02-19T04:41:26.000-08:00
diff --git a/packages/react-doctor/src/constants.ts b/packages/react-doctor/src/constants.ts
@@ -26,7 +26,7 @@ export const SHARE_BASE_URL = "https://www.react.doctor/share";
 
 export const OPEN_BASE_URL = "https://www.react.doctor/open";
 
-export const INSTALL_SKILL_URL = "https://www.react.doctor/install-skill";
+export const FETCH_TIMEOUT_MS = 10_000;
 
 export const GIT_LS_FILES_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
 
diff --git a/packages/react-doctor/src/utils/calculate-score.ts b/packages/react-doctor/src/utils/calculate-score.ts
@@ -6,6 +6,7 @@ import {
   SCORE_OK_THRESHOLD,
 } from "../constants.js";
 import type { Diagnostic, EstimatedScoreResult, ScoreResult } from "../types.js";
+import { proxyFetch } from "./proxy-fetch.js";
 
 const ERROR_RULE_PENALTY = 1.5;
 const WARNING_RULE_PENALTY = 0.75;
@@ -66,7 +67,7 @@ const estimateScoreLocally = (diagnostics: Diagnostic[]): EstimatedScoreResult =
 
 export const calculateScore = async (diagnostics: Diagnostic[]): Promise<ScoreResult | null> => {
   try {
-    const response = await fetch(SCORE_API_URL, {
+    const response = await proxyFetch(SCORE_API_URL, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ diagnostics }),
@@ -84,7 +85,7 @@ export const fetchEstimatedScore = async (
   diagnostics: Diagnostic[],
 ): Promise<EstimatedScoreResult | null> => {
   try {
-    const response = await fetch(ESTIMATE_SCORE_API_URL, {
+    const response = await proxyFetch(ESTIMATE_SCORE_API_URL, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ diagnostics }),
diff --git a/packages/react-doctor/src/utils/proxy-fetch.ts b/packages/react-doctor/src/utils/proxy-fetch.ts
@@ -0,0 +1,60 @@
+import { execSync } from "node:child_process";
+import { FETCH_TIMEOUT_MS } from "../constants.js";
+
+const readNpmConfigValue = (key: string): string | undefined => {
+  try {
+    const value = execSync(`npm config get ${key}`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"],
+    }).trim();
+    if (value && value !== "null" && value !== "undefined") return value;
+  } catch {}
+  return undefined;
+};
+
+const resolveProxyUrl = (): string | undefined =>
+  process.env.HTTPS_PROXY ??
+  process.env.https_proxy ??
+  process.env.HTTP_PROXY ??
+  process.env.http_proxy ??
+  readNpmConfigValue("https-proxy") ??
+  readNpmConfigValue("proxy");
+
+let isProxyUrlResolved = false;
+let resolvedProxyUrl: string | undefined;
+
+const getProxyUrl = (): string | undefined => {
+  if (isProxyUrlResolved) return resolvedProxyUrl;
+  isProxyUrlResolved = true;
+  resolvedProxyUrl = resolveProxyUrl();
+  return resolvedProxyUrl;
+};
+
+const createProxyDispatcher = async (proxyUrl: string): Promise<object | null> => {
+  try {
+    // @ts-expect-error undici is bundled with Node.js 18+ but lacks standalone type declarations
+    const { ProxyAgent } = await import("undici");
+    return new ProxyAgent(proxyUrl);
+  } catch {
+    return null;
+  }
+};
+
+// HACK: Node.js's global fetch (undici) accepts `dispatcher` for proxy routing,
+// which isn't part of the standard RequestInit type.
+export const proxyFetch = async (url: string | URL, init?: RequestInit): Promise<Response> => {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+
+  try {
+    const proxyUrl = getProxyUrl();
+    const dispatcher = proxyUrl ? await createProxyDispatcher(proxyUrl) : null;
+
+    return await fetch(
+      url,
+      { ...init, signal: controller.signal, ...(dispatcher ? { dispatcher } : {}) } as RequestInit,
+    );
+  } finally {
+    clearTimeout(timeoutId);
+  }
+};
diff --git a/packages/react-doctor/src/utils/skill-prompt.ts b/packages/react-doctor/src/utils/skill-prompt.ts
@@ -1,19 +1,66 @@
 import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { INSTALL_SKILL_URL } from "../constants.js";
 import { highlighter } from "./highlighter.js";
 import { logger } from "./logger.js";
 import { prompts } from "./prompts.js";
 
-const CONFIG_DIRECTORY = join(homedir(), ".react-doctor");
+const HOME_DIRECTORY = homedir();
+const CONFIG_DIRECTORY = join(HOME_DIRECTORY, ".react-doctor");
 const CONFIG_FILE = join(CONFIG_DIRECTORY, "config.json");
 
+const SKILL_NAME = "react-doctor";
+const WINDSURF_MARKER = "# React Doctor";
+
+const SKILL_DESCRIPTION =
+  "Run after making React changes to catch issues early. Use when reviewing code, finishing a feature, or fixing bugs in a React project.";
+
+const SKILL_BODY = `Scans your React codebase for security, performance, correctness, and architecture issues. Outputs a 0-100 score with actionable diagnostics.
+
+## Usage
+
+\`\`\`bash
+npx -y react-doctor@latest . --verbose --diff
+\`\`\`
+
+## Workflow
+
+Run after making changes to catch issues early. Fix errors first, then re-run to verify the score improved.`;
+
+const SKILL_CONTENT = `---
+name: ${SKILL_NAME}
+description: ${SKILL_DESCRIPTION}
+version: 1.0.0
+---
+
+# React Doctor
+
+${SKILL_BODY}
+`;
+
+const AGENTS_CONTENT = `# React Doctor
+
+${SKILL_DESCRIPTION}
+
+${SKILL_BODY}
+`;
+
+const CODEX_AGENT_CONFIG = `interface:
+  display_name: "${SKILL_NAME}"
+  short_description: "Diagnose and fix React codebase health issues"
+`;
+
 interface SkillPromptConfig {
   skillPromptDismissed?: boolean;
 }
 
+interface SkillTarget {
+  name: string;
+  detect: () => boolean;
+  install: () => void;
+}
+
 const readSkillPromptConfig = (): SkillPromptConfig => {
   try {
     if (!existsSync(CONFIG_FILE)) return {};
@@ -25,20 +72,127 @@ const readSkillPromptConfig = (): SkillPromptConfig => {
 
 const writeSkillPromptConfig = (config: SkillPromptConfig): void => {
   try {
-    if (!existsSync(CONFIG_DIRECTORY)) {
-      mkdirSync(CONFIG_DIRECTORY, { recursive: true });
-    }
+    mkdirSync(CONFIG_DIRECTORY, { recursive: true });
     writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
   } catch {}
 };
 
+const writeSkillFiles = (directory: string): void => {
+  mkdirSync(directory, { recursive: true });
+  writeFileSync(join(directory, "SKILL.md"), SKILL_CONTENT);
+  writeFileSync(join(directory, "AGENTS.md"), AGENTS_CONTENT);
+};
+
+const isCommandAvailable = (command: string): boolean => {
+  try {
+    const whichCommand = process.platform === "win32" ? "where" : "which";
+    execSync(`${whichCommand} ${command}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const SKILL_TARGETS: SkillTarget[] = [
+  {
+    name: "Claude Code",
+    detect: () => existsSync(join(HOME_DIRECTORY, ".claude")),
+    install: () => writeSkillFiles(join(HOME_DIRECTORY, ".claude", "skills", SKILL_NAME)),
+  },
+  {
+    name: "Amp Code",
+    detect: () => existsSync(join(HOME_DIRECTORY, ".amp")),
+    install: () =>
+      writeSkillFiles(join(HOME_DIRECTORY, ".config", "amp", "skills", SKILL_NAME)),
+  },
+  {
+    name: "Cursor",
+    detect: () => existsSync(join(HOME_DIRECTORY, ".cursor")),
+    install: () => writeSkillFiles(join(HOME_DIRECTORY, ".cursor", "skills", SKILL_NAME)),
+  },
+  {
+    name: "OpenCode",
+    detect: () =>
+      isCommandAvailable("opencode") ||
+      existsSync(join(HOME_DIRECTORY, ".config", "opencode")),
+    install: () =>
+      writeSkillFiles(join(HOME_DIRECTORY, ".config", "opencode", "skills", SKILL_NAME)),
+  },
+  {
+    name: "Windsurf",
+    detect: () =>
+      existsSync(join(HOME_DIRECTORY, ".codeium")) ||
+      existsSync(join(HOME_DIRECTORY, "Library", "Application Support", "Windsurf")),
+    install: () => {
+      const memoriesDirectory = join(HOME_DIRECTORY, ".codeium", "windsurf", "memories");
+      mkdirSync(memoriesDirectory, { recursive: true });
+      const rulesFile = join(memoriesDirectory, "global_rules.md");
+
+      if (existsSync(rulesFile)) {
+        const existingContent = readFileSync(rulesFile, "utf-8");
+        if (existingContent.includes(WINDSURF_MARKER)) return;
+        appendFileSync(rulesFile, `\n${WINDSURF_MARKER}\n\n${SKILL_CONTENT}`);
+      } else {
+        writeFileSync(rulesFile, `${WINDSURF_MARKER}\n\n${SKILL_CONTENT}`);
+      }
+    },
+  },
+  {
+    name: "Antigravity",
+    detect: () =>
+      isCommandAvailable("agy") ||
+      existsSync(join(HOME_DIRECTORY, ".gemini", "antigravity")),
+    install: () =>
+      writeSkillFiles(join(HOME_DIRECTORY, ".gemini", "antigravity", "skills", SKILL_NAME)),
+  },
+  {
+    name: "Gemini CLI",
+    detect: () =>
+      isCommandAvailable("gemini") || existsSync(join(HOME_DIRECTORY, ".gemini")),
+    install: () => writeSkillFiles(join(HOME_DIRECTORY, ".gemini", "skills", SKILL_NAME)),
+  },
+  {
+    name: "Codex",
+    detect: () =>
+      isCommandAvailable("codex") || existsSync(join(HOME_DIRECTORY, ".codex")),
+    install: () => {
+      const skillDirectory = join(HOME_DIRECTORY, ".codex", "skills", SKILL_NAME);
+      writeSkillFiles(skillDirectory);
+      const agentsDirectory = join(skillDirectory, "agents");
+      mkdirSync(agentsDirectory, { recursive: true });
+      writeFileSync(join(agentsDirectory, "openai.yaml"), CODEX_AGENT_CONFIG);
+    },
+  },
+];
+
 const installSkill = (): void => {
+  let installedCount = 0;
+
+  for (const target of SKILL_TARGETS) {
+    if (!target.detect()) continue;
+    try {
+      target.install();
+      logger.log(`  ${highlighter.success("✔")} ${target.name}`);
+      installedCount++;
+    } catch {
+      logger.dim(`  ✗ ${target.name} (failed)`);
+    }
+  }
+
   try {
-    execSync(`curl -fsSL ${INSTALL_SKILL_URL} | bash`, { stdio: "inherit" });
+    const projectSkillDirectory = join(".agents", SKILL_NAME);
+    writeSkillFiles(projectSkillDirectory);
+    logger.log(`  ${highlighter.success("✔")} .agents/`);
+    installedCount++;
   } catch {
-    logger.break();
-    logger.dim("Skill install failed. You can install manually:");
-    logger.dim(`  curl -fsSL ${INSTALL_SKILL_URL} | bash`);
+    logger.dim("  ✗ .agents/ (failed)");
+  }
+
+  logger.break();
+  if (installedCount === 0) {
+    logger.dim("No supported tools detected.");
+  } else {
+    logger.success("Done! The skill will activate when working on React projects.");
   }
 };
 
@@ -48,9 +202,7 @@ export const maybePromptSkillInstall = async (shouldSkipPrompts: boolean): Promi
   if (shouldSkipPrompts) return;
 
   logger.break();
-  logger.log(
-    `${highlighter.info("💡")} Have your coding agent fix these issues automatically?`,
-  );
+  logger.log(`${highlighter.info("💡")} Have your coding agent fix these issues automatically?`);
   logger.dim(
     `   Install the ${highlighter.info("react-doctor")} skill to teach Cursor, Claude Code,`,
   );
