gsd-pi 2.37.1 → 2.38.0-dev.29edcdc

package/src/resources/extensions/gsd/doctor-checks.ts

@@ -657,6 +657,81 @@ export async function checkRuntimeHealth(
   } catch {
     // Non-fatal — external state check failed
   }
+
+  // ── Metrics ledger integrity ───────────────────────────────────────────
+  try {
+    const metricsPath = join(root, "metrics.json");
+    if (existsSync(metricsPath)) {
+      try {
+        const raw = readFileSync(metricsPath, "utf-8");
+        const ledger = JSON.parse(raw);
+        if (ledger.version !== 1 || !Array.isArray(ledger.units)) {
+          issues.push({
+            severity: "warning",
+            code: "metrics_ledger_corrupt",
+            scope: "project",
+            unitId: "project",
+            message: "metrics.json has an unexpected structure (version !== 1 or units is not an array) — metrics data may be unreliable",
+            file: ".gsd/metrics.json",
+            fixable: false,
+          });
+        }
+      } catch {
+        issues.push({
+          severity: "warning",
+          code: "metrics_ledger_corrupt",
+          scope: "project",
+          unitId: "project",
+          message: "metrics.json is not valid JSON — metrics data may be corrupt",
+          file: ".gsd/metrics.json",
+          fixable: false,
+        });
+      }
+    }
+  } catch {
+    // Non-fatal — metrics check failed
+  }
+
+  // ── Large planning file detection ──────────────────────────────────────
+  // Files over 100KB can cause LLM context pressure. Report the worst offenders.
+  try {
+    const MAX_FILE_BYTES = 100 * 1024; // 100KB
+    const milestonesPath = milestonesDir(basePath);
+    if (existsSync(milestonesPath)) {
+      const largeFiles: Array<{ path: string; sizeKB: number }> = [];
+      function scanForLargeFiles(dir: string, depth = 0): void {
+        if (depth > 6) return;
+        try {
+          for (const entry of readdirSync(dir)) {
+            const full = join(dir, entry);
+            try {
+              const s = statSync(full);
+              if (s.isDirectory()) { scanForLargeFiles(full, depth + 1); continue; }
+              if (entry.endsWith(".md") && s.size > MAX_FILE_BYTES) {
+                largeFiles.push({ path: full.replace(basePath + "/", ""), sizeKB: Math.round(s.size / 1024) });
+              }
+            } catch { /* skip entry */ }
+          }
+        } catch { /* skip dir */ }
+      }
+      scanForLargeFiles(milestonesPath);
+      if (largeFiles.length > 0) {
+        largeFiles.sort((a, b) => b.sizeKB - a.sizeKB);
+        const worst = largeFiles[0]!;
+        issues.push({
+          severity: "warning",
+          code: "large_planning_file",
+          scope: "project",
+          unitId: "project",
+          message: `${largeFiles.length} planning file(s) exceed 100KB — largest: ${worst.path} (${worst.sizeKB}KB). Large files cause LLM context pressure.`,
+          file: worst.path,
+          fixable: false,
+        });
+      }
+    }
+  } catch {
+    // Non-fatal — large file scan failed
+  }
 }
 
 /**

package/src/resources/extensions/gsd/doctor-environment.ts

@@ -407,6 +407,63 @@ function checkGitRemote(basePath: string): EnvironmentCheckResult | null {
   return { name: "git_remote", status: "ok", message: "Git remote reachable" };
 }
 
+/**
+ * Check if the project build passes (opt-in slow check, use --build flag).
+ * Runs npm run build and reports failure as env_build.
+ */
+function checkBuildHealth(basePath: string): EnvironmentCheckResult | null {
+  const pkgPath = join(basePath, "package.json");
+  if (!existsSync(pkgPath)) return null;
+
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const buildScript = pkg.scripts?.build;
+    if (!buildScript) return null;
+
+    const result = tryExec("npm run build 2>&1", basePath);
+    if (result === null) {
+      return {
+        name: "build",
+        status: "error",
+        message: "Build failed — npm run build exited non-zero",
+        detail: "Fix build errors before dispatching work",
+      };
+    }
+    return { name: "build", status: "ok", message: "Build passes" };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if tests pass (opt-in slow check, use --test flag).
+ * Runs npm test and reports failures as env_test.
+ */
+function checkTestHealth(basePath: string): EnvironmentCheckResult | null {
+  const pkgPath = join(basePath, "package.json");
+  if (!existsSync(pkgPath)) return null;
+
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const testScript = pkg.scripts?.test;
+    // Skip if no test script or the default placeholder
+    if (!testScript || testScript.includes("no test specified")) return null;
+
+    const result = tryExec("npm test 2>&1", basePath);
+    if (result === null) {
+      return {
+        name: "test",
+        status: "warning",
+        message: "Tests failing — npm test exited non-zero",
+        detail: "Fix failing tests before shipping",
+      };
+    }
+    return { name: "test", status: "ok", message: "Tests pass" };
+  } catch {
+    return null;
+  }
+}
+
 // ── Public API ─────────────────────────────────────────────────────────────
 
 /**
@@ -454,6 +511,26 @@ export function runFullEnvironmentChecks(basePath: string): EnvironmentCheckResu
   return results;
 }
 
+/**
+ * Run slow opt-in checks (build and/or test).
+ * These are never run on the pre-dispatch gate — only on explicit /gsd doctor --build/--test.
+ */
+export function runSlowEnvironmentChecks(
+  basePath: string,
+  options?: { includeBuild?: boolean; includeTests?: boolean },
+): EnvironmentCheckResult[] {
+  const results: EnvironmentCheckResult[] = [];
+  if (options?.includeBuild) {
+    const buildCheck = checkBuildHealth(basePath);
+    if (buildCheck) results.push(buildCheck);
+  }
+  if (options?.includeTests) {
+    const testCheck = checkTestHealth(basePath);
+    if (testCheck) results.push(testCheck);
+  }
+  return results;
+}
+
 /**
  * Convert environment check results to DoctorIssue format for the doctor pipeline.
  */
@@ -477,12 +554,16 @@ export function environmentResultsToDoctorIssues(results: EnvironmentCheckResult
 export async function checkEnvironmentHealth(
   basePath: string,
   issues: DoctorIssue[],
-  options?: { includeRemote?: boolean },
+  options?: { includeRemote?: boolean; includeBuild?: boolean; includeTests?: boolean },
 ): Promise<void> {
   const results = options?.includeRemote
     ? runFullEnvironmentChecks(basePath)
     : runEnvironmentChecks(basePath);
 
+  if (options?.includeBuild || options?.includeTests) {
+    results.push(...runSlowEnvironmentChecks(basePath, options));
+  }
+
   issues.push(...environmentResultsToDoctorIssues(results));
 }
 

package/src/resources/extensions/gsd/doctor-format.ts

@@ -76,3 +76,23 @@ export function formatDoctorIssuesForPrompt(issues: DoctorIssue[]): string {
     return `- [${prefix}] ${issue.unitId} | ${issue.code} | ${issue.message}${issue.file ? ` | file: ${issue.file}` : ""} | fixable: ${issue.fixable ? "yes" : "no"}`;
   }).join("\n");
 }
+
+/**
+ * Serialize a doctor report to JSON — suitable for CI/tooling integration.
+ * Usage: /gsd doctor --json
+ */
+export function formatDoctorReportJson(report: DoctorReport): string {
+  return JSON.stringify(
+    {
+      ok: report.ok,
+      basePath: report.basePath,
+      generatedAt: new Date().toISOString(),
+      summary: summarizeDoctorIssues(report.issues),
+      issues: report.issues,
+      fixesApplied: report.fixesApplied,
+      ...(report.timing ? { timing: report.timing } : {}),
+    },
+    null,
+    2,
+  );
+}

package/src/resources/extensions/gsd/doctor-providers.ts

@@ -14,6 +14,7 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { AuthStorage } from "@gsd/pi-coding-agent";
+import { getEnvApiKey } from "@gsd/pi-ai";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { getAuthPath, PROVIDER_REGISTRY, type ProviderCategory } from "./key-manager.js";
 
@@ -50,12 +51,15 @@ function modelToProviderId(model: string): string | null {
     const prefix = model.split("/")[0].toLowerCase();
     // Map known prefixes to registry IDs
     const prefixMap: Record<string, string> = {
+      "anthropic-vertex": "anthropic-vertex",
       openrouter: "openrouter",
       groq: "groq",
       mistral: "mistral",
       google: "google",
+      "google-vertex": "google-vertex",
       anthropic: "anthropic",
       openai: "openai",
+      "github-copilot": "github-copilot",
     };
     if (prefixMap[prefix]) return prefixMap[prefix];
   }
@@ -86,11 +90,20 @@ function collectConfiguredModelProviders(): Set<string> {
 
     const modelEntries = typeof models === "object" ? Object.values(models) : [];
     for (const entry of modelEntries) {
-      const modelId = typeof entry === "string" ? entry
-        : typeof entry === "object" && entry !== null && "model" in entry
-          ? String((entry as { model: unknown }).model)
-          : null;
-      if (modelId) {
+      if (typeof entry === "string") {
+        const pid = modelToProviderId(entry);
+        if (pid) providers.add(pid);
+        continue;
+      }
+
+      if (typeof entry === "object" && entry !== null && "model" in entry) {
+        const configuredProvider = "provider" in entry ? (entry as { provider?: unknown }).provider : undefined;
+        if (typeof configuredProvider === "string" && configuredProvider.trim().length > 0) {
+          providers.add(configuredProvider);
+          continue;
+        }
+
+        const modelId = String((entry as { model: unknown }).model);
         const pid = modelToProviderId(modelId);
         if (pid) providers.add(pid);
       }
@@ -139,7 +152,15 @@ function resolveKey(providerId: string): KeyLookup {
     }
   }
 
-  // Check environment variable
+  // Check environment variable using the authoritative env var resolution
+  // (handles multi-var lookups like ANTHROPIC_OAUTH_TOKEN || ANTHROPIC_API_KEY,
+  //  COPILOT_GITHUB_TOKEN || GH_TOKEN || GITHUB_TOKEN, Vertex ADC, Bedrock, etc.)
+  if (getEnvApiKey(providerId)) {
+    return { found: true, source: "env", backedOff: false };
+  }
+
+  // Fall back to PROVIDER_REGISTRY env var for providers not covered by getEnvApiKey
+  // (e.g., search providers like Brave, Tavily; tool providers like Jina, Context7)
   if (info?.envVar && process.env[info.envVar]) {
     return { found: true, source: "env", backedOff: false };
   }
@@ -149,24 +170,57 @@ function resolveKey(providerId: string): KeyLookup {
 
 // ── Individual check groups ────────────────────────────────────────────────────
 
+/**
+ * Providers that can serve models normally associated with another provider.
+ * Key = the provider whose models can be served, Value = alternative providers to check.
+ * e.g. GitHub Copilot subscriptions can access Claude and GPT models.
+ */
+const PROVIDER_ROUTES: Record<string, string[]> = {
+  anthropic: ["github-copilot"],
+  openai: ["github-copilot"],
+};
+
 function checkLlmProviders(): ProviderCheckResult[] {
   const required = collectConfiguredModelProviders();
   const results: ProviderCheckResult[] = [];
 
   for (const providerId of required) {
     const info = PROVIDER_REGISTRY.find(p => p.id === providerId);
-    const label = info?.label ?? providerId;
+    const label = providerId === "anthropic-vertex"
+      ? "Anthropic Vertex"
+      : info?.label ?? providerId;
     const lookup = resolveKey(providerId);
 
     if (!lookup.found) {
-      const envVar = info?.envVar ?? `${providerId.toUpperCase()}_API_KEY`;
+      // Check if a cross-provider can serve this provider's models
+      const routes = PROVIDER_ROUTES[providerId];
+      const routeProvider = routes?.find(routeId => resolveKey(routeId).found);
+      if (routeProvider) {
+        const routeInfo = PROVIDER_REGISTRY.find(p => p.id === routeProvider);
+        const routeLabel = routeInfo?.label ?? routeProvider;
+        results.push({
+          name: providerId,
+          label,
+          category: "llm",
+          status: "ok",
+          message: `${label} — available via ${routeLabel}`,
+          required: true,
+        });
+        continue;
+      }
+
+      const envVar = providerId === "anthropic-vertex"
+        ? "ANTHROPIC_VERTEX_PROJECT_ID"
+        : info?.envVar ?? `${providerId.toUpperCase()}_API_KEY`;
       results.push({
         name: providerId,
         label,
         category: "llm",
         status: "error",
-        message: `${label} — no API key found`,
-        detail: info?.hasOAuth
+        message: `${label} — not configured`,
+        detail: providerId === "anthropic-vertex"
+          ? "Set ANTHROPIC_VERTEX_PROJECT_ID and authenticate with Google ADC"
+          : info?.hasOAuth
           ? `Run /gsd keys to authenticate`
           : `Set ${envVar} or run /gsd keys`,
         required: true,

package/src/resources/extensions/gsd/doctor-types.ts

@@ -53,7 +53,20 @@ export type DoctorIssueCode =
   | "stranded_lock_directory"
   // Git / worktree integrity checks
   | "integration_branch_missing"
-  | "worktree_directory_orphaned";
+  | "worktree_directory_orphaned"
+  // GSD state structural checks
+  | "circular_slice_dependency"
+  | "orphaned_slice_directory"
+  | "duplicate_task_id"
+  | "task_file_not_in_plan"
+  | "stale_replan_file"
+  | "future_timestamp"
+  // Runtime data integrity
+  | "metrics_ledger_corrupt"
+  | "large_planning_file"
+  // Slow environment checks (opt-in via --build / --test flags)
+  | "env_build"
+  | "env_test";
 
 /**
  * Issue codes that represent expected completion-transition states.
@@ -83,6 +96,8 @@ export interface DoctorReport {
   basePath: string;
   issues: DoctorIssue[];
   fixesApplied: string[];
+  /** Per-domain check durations in milliseconds. Present on explicit /gsd doctor runs. */
+  timing?: { git: number; runtime: number; environment: number; gsdState: number };
 }
 
 export interface DoctorSummary {