gsd-pi 2.31.2-dev.c8d7e03 → 2.32.0-dev.1e39869

package/dist/resources/extensions/gsd/tests/doctor-providers.test.ts

@@ -0,0 +1,298 @@
+/**
+ * doctor-providers.test.ts — Tests for provider & integration health checks.
+ *
+ * Tests:
+ *   - LLM provider key detection from env vars
+ *   - LLM provider key detection from auth.json
+ *   - Missing required provider → error status
+ *   - Backed-off credentials → warning status
+ *   - Remote questions channel check (configured vs missing token)
+ *   - Optional provider unconfigured status
+ *   - formatProviderReport output
+ *   - summariseProviderIssues compaction
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  runProviderChecks,
+  formatProviderReport,
+  summariseProviderIssues,
+  type ProviderCheckResult,
+} from "../doctor-providers.ts";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function withEnv(vars: Record<string, string | undefined>, fn: () => void): void {
+  const saved: Record<string, string | undefined> = {};
+  for (const [k, v] of Object.entries(vars)) {
+    saved[k] = process.env[k];
+    if (v === undefined) {
+      delete process.env[k];
+    } else {
+      process.env[k] = v;
+    }
+  }
+  try {
+    fn();
+  } finally {
+    for (const [k, v] of Object.entries(saved)) {
+      if (v === undefined) delete process.env[k];
+      else process.env[k] = v;
+    }
+  }
+}
+
+// ─── formatProviderReport ─────────────────────────────────────────────────────
+
+test("formatProviderReport returns fallback for empty results", () => {
+  const out = formatProviderReport([]);
+  assert.equal(out, "No provider checks run.");
+});
+
+test("formatProviderReport shows ok icon for ok status", () => {
+  const results: ProviderCheckResult[] = [{
+    name: "anthropic",
+    label: "Anthropic (Claude)",
+    category: "llm",
+    status: "ok",
+    message: "Anthropic (Claude) — key present (env)",
+    required: true,
+  }];
+  const out = formatProviderReport(results);
+  assert.ok(out.includes("✓"), "should include checkmark for ok");
+  assert.ok(out.includes("Anthropic"), "should include provider name");
+});
+
+test("formatProviderReport shows error icon and detail for error status", () => {
+  const results: ProviderCheckResult[] = [{
+    name: "anthropic",
+    label: "Anthropic (Claude)",
+    category: "llm",
+    status: "error",
+    message: "Anthropic (Claude) — no API key found",
+    detail: "Set ANTHROPIC_API_KEY or run /gsd keys",
+    required: true,
+  }];
+  const out = formatProviderReport(results);
+  assert.ok(out.includes("✗"), "should include cross for error");
+  assert.ok(out.includes("ANTHROPIC_API_KEY"), "should include detail");
+});
+
+test("formatProviderReport shows warning icon for warning status", () => {
+  const results: ProviderCheckResult[] = [{
+    name: "slack_bot",
+    label: "Slack Bot",
+    category: "remote",
+    status: "warning",
+    message: "Slack Bot — channel configured but token not found",
+    required: true,
+  }];
+  const out = formatProviderReport(results);
+  assert.ok(out.includes("⚠"), "should include warning icon");
+});
+
+test("formatProviderReport groups by category", () => {
+  const results: ProviderCheckResult[] = [
+    { name: "anthropic", label: "Anthropic", category: "llm", status: "ok", message: "ok", required: true },
+    { name: "brave", label: "Brave Search", category: "search", status: "unconfigured", message: "not configured", required: false },
+  ];
+  const out = formatProviderReport(results);
+  assert.ok(out.includes("LLM Providers"), "should have LLM section");
+  assert.ok(out.includes("Search"), "should have Search section");
+});
+
+test("formatProviderReport omits detail for ok status", () => {
+  const results: ProviderCheckResult[] = [{
+    name: "openai",
+    label: "OpenAI",
+    category: "llm",
+    status: "ok",
+    message: "OpenAI — key present (env)",
+    detail: "should not appear",
+    required: true,
+  }];
+  const out = formatProviderReport(results);
+  assert.ok(!out.includes("should not appear"), "detail should not show for ok");
+});
+
+// ─── summariseProviderIssues ──────────────────────────────────────────────────
+
+test("summariseProviderIssues returns null when no required issues", () => {
+  const results: ProviderCheckResult[] = [
+    { name: "anthropic", label: "Anthropic", category: "llm", status: "ok", message: "ok", required: true },
+    { name: "brave", label: "Brave", category: "search", status: "unconfigured", message: "not configured", required: false },
+  ];
+  assert.equal(summariseProviderIssues(results), null);
+});
+
+test("summariseProviderIssues returns error summary for missing required key", () => {
+  const results: ProviderCheckResult[] = [{
+    name: "anthropic",
+    label: "Anthropic (Claude)",
+    category: "llm",
+    status: "error",
+    message: "no key",
+    required: true,
+  }];
+  const summary = summariseProviderIssues(results);
+  assert.ok(summary !== null, "should return a summary");
+  assert.ok(summary!.includes("Anthropic"), "should name the provider");
+  assert.ok(summary!.includes("✗"), "should use error icon");
+});
+
+test("summariseProviderIssues returns warning for backed-off required provider", () => {
+  const results: ProviderCheckResult[] = [{
+    name: "anthropic",
+    label: "Anthropic (Claude)",
+    category: "llm",
+    status: "warning",
+    message: "backed off",
+    required: true,
+  }];
+  const summary = summariseProviderIssues(results);
+  assert.ok(summary !== null, "should return summary");
+  assert.ok(summary!.includes("⚠"), "should use warning icon");
+});
+
+test("summariseProviderIssues appends count when multiple issues", () => {
+  const results: ProviderCheckResult[] = [
+    { name: "anthropic", label: "Anthropic", category: "llm", status: "error", message: "err", required: true },
+    { name: "openai",    label: "OpenAI",    category: "llm", status: "error", message: "err", required: true },
+    { name: "google",    label: "Google",    category: "llm", status: "error", message: "err", required: true },
+  ];
+  const summary = summariseProviderIssues(results);
+  assert.ok(summary!.includes("+2 more"), "should show overflow count");
+});
+
+test("summariseProviderIssues ignores unconfigured optional providers", () => {
+  const results: ProviderCheckResult[] = [
+    { name: "anthropic", label: "Anthropic", category: "llm",    status: "ok",           message: "ok", required: true },
+    { name: "brave",     label: "Brave",     category: "search", status: "unconfigured", message: "nc", required: false },
+    { name: "tavily",    label: "Tavily",    category: "search", status: "unconfigured", message: "nc", required: false },
+  ];
+  assert.equal(summariseProviderIssues(results), null, "optional missing providers should not raise issue");
+});
+
+// ─── runProviderChecks — env var detection ────────────────────────────────────
+
+test("runProviderChecks detects Anthropic key from ANTHROPIC_API_KEY env var", () => {
+  // Isolate from real HOME so loadEffectiveGSDPreferences returns null (default → anthropic)
+  // and auth.json lookups hit an empty directory.
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-env-test-")));
+  withEnv({ ANTHROPIC_API_KEY: "sk-ant-test-key", HOME: tmpHome }, () => {
+    try {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic result should exist");
+      assert.equal(anthropic!.status, "ok", "should be ok when env var set");
+      assert.ok(anthropic!.message.includes("env"), "should report env source");
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
+test("runProviderChecks returns error for Anthropic when no key present", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-test-")));
+  withEnv({ ANTHROPIC_API_KEY: undefined, HOME: tmpHome }, () => {
+    try {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic should be present (default required)");
+      assert.equal(anthropic!.status, "error", "should be error when no key");
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});
+
+test("runProviderChecks optional providers have required=false", () => {
+  const results = runProviderChecks();
+  const optional = results.filter(r => ["brave", "tavily", "jina", "context7"].includes(r.name));
+  for (const r of optional) {
+    assert.equal(r.required, false, `${r.name} should not be required`);
+  }
+});
+
+test("runProviderChecks optional providers show unconfigured when no key", () => {
+  withEnv(
+    { BRAVE_API_KEY: undefined, TAVILY_API_KEY: undefined, JINA_API_KEY: undefined, CONTEXT7_API_KEY: undefined },
+    () => {
+      const origHome = process.env.HOME;
+      process.env.HOME = mkdtempSync(join(tmpdir(), "gsd-providers-test-"));
+      try {
+        const results = runProviderChecks();
+        const brave = results.find(r => r.name === "brave");
+        assert.ok(brave, "brave should be present");
+        assert.equal(brave!.status, "unconfigured", "should be unconfigured");
+      } finally {
+        rmSync(process.env.HOME!, { recursive: true, force: true });
+        process.env.HOME = origHome;
+      }
+    }
+  );
+});
+
+test("runProviderChecks optional providers show ok when key set", () => {
+  withEnv({ BRAVE_API_KEY: "test-brave-key" }, () => {
+    const results = runProviderChecks();
+    const brave = results.find(r => r.name === "brave");
+    assert.ok(brave, "brave should be present");
+    assert.equal(brave!.status, "ok", "should be ok when env var set");
+  });
+});
+
+// ─── runProviderChecks — auth.json detection ─────────────────────────────────
+
+test("runProviderChecks detects key from auth.json", () => {
+  withEnv({ ANTHROPIC_API_KEY: undefined }, () => {
+    const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-test-")));
+    const agentDir = join(tmpHome, ".gsd", "agent");
+    mkdirSync(agentDir, { recursive: true });
+
+    // AuthStorage persists credentials with provider ID as the top-level key:
+    // { "anthropic": { "type": "api_key", "key": "..." } }
+    const authData = {
+      anthropic: { type: "api_key", key: "sk-ant-from-auth-json" },
+    };
+    writeFileSync(join(agentDir, "auth.json"), JSON.stringify(authData));
+
+    withEnv({ HOME: tmpHome }, () => {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic should be present");
+      assert.equal(anthropic!.status, "ok", "should be ok with auth.json key");
+      assert.ok(anthropic!.message.includes("auth.json"), "should report auth.json source");
+    });
+
+    rmSync(tmpHome, { recursive: true, force: true });
+  });
+});
+
+test("runProviderChecks ignores empty placeholder keys in auth.json", () => {
+  withEnv({ ANTHROPIC_API_KEY: undefined }, () => {
+    const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-test-")));
+    const agentDir = join(tmpHome, ".gsd", "agent");
+    mkdirSync(agentDir, { recursive: true });
+
+    // Empty key — what onboarding writes when user skips
+    const authData = {
+      anthropic: { type: "api_key", key: "" },
+    };
+    writeFileSync(join(agentDir, "auth.json"), JSON.stringify(authData));
+
+    withEnv({ HOME: tmpHome }, () => {
+      const results = runProviderChecks();
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(anthropic, "anthropic should be present");
+      assert.equal(anthropic!.status, "error", "empty placeholder key should count as not configured");
+    });
+
+    rmSync(tmpHome, { recursive: true, force: true });
+  });
+});

package/dist/resources/extensions/gsd/tests/export-html-enhancements.test.ts

@@ -119,6 +119,9 @@ function mockData(overrides: Partial<VisualizerData> = {}): VisualizerData {
       toolCalls: 40,
       assistantMessages: 20,
       userMessages: 12,
+      providers: [],
+      skillSummary: { total: 0, warningCount: 0, criticalCount: 0, topIssue: null },
+      environmentIssues: [],
     },
     discussion: [],
     stats: { missingCount: 0, missingSlices: [], updatedCount: 0, updatedSlices: [], recentEntries: [] },

package/dist/resources/extensions/gsd/tests/memory-leak-guards.test.ts

@@ -7,7 +7,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, existsSync, readdirSync, readFileSync } from "node:fs";
+import { mkdtempSync, rmSync, existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -23,7 +23,11 @@ function createCtx(entries: unknown[]) {
 
 test("clearActivityLogState resets dedup state so identical saves write again", () => {
   clearActivityLogState();
-  const baseDir = mkdtempSync(join(tmpdir(), "gsd-memleak-test-"));
+  // Pre-resolve baseDir so gsdRoot() returns a stable key across calls.
+  // On macOS, /tmp is a symlink to /private/tmp — without realpathSync, the
+  // key changes between the first save (dir doesn't exist, realpathSync throws)
+  // and subsequent saves (dir exists, realpathSync resolves to /private/tmp/...).
+  const baseDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-memleak-test-")));
   try {
     const entries = [{ role: "assistant", content: "test entry" }];
     const ctx = createCtx(entries);
@@ -53,7 +57,7 @@ test("clearActivityLogState resets dedup state so identical saves write again",
 
 test("saveActivityLog writes valid JSONL via streaming", () => {
   clearActivityLogState();
-  const baseDir = mkdtempSync(join(tmpdir(), "gsd-memleak-jsonl-"));
+  const baseDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-memleak-jsonl-")));
   try {
     const entries = [
       { type: "message", message: { role: "user", content: "hello" } },

package/dist/resources/extensions/gsd/tests/progress-score.test.ts

@@ -0,0 +1,206 @@
+/**
+ * progress-score.test.ts — Tests for progress score / traffic light (#1221).
+ *
+ * Tests:
+ *   - Score computation from health signals
+ *   - Signal evaluation (trend, error streak, recent errors)
+ *   - Context-aware scoring (retry counts, unit progress)
+ *   - Formatting (single-line, detailed report)
+ */
+
+import {
+  recordHealthSnapshot,
+  resetProactiveHealing,
+} from "../doctor-proactive.ts";
+
+import {
+  computeProgressScore,
+  computeProgressScoreWithContext,
+  formatProgressLine,
+  formatProgressReport,
+} from "../progress-score.ts";
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+async function main(): Promise<void> {
+  try {
+    // ── Base Score: No Data ─────────────────────────────────────────────
+    console.log("\n=== progress: green with no data ===");
+    {
+      resetProactiveHealing();
+      const score = computeProgressScore();
+      assertEq(score.level, "green", "green when no data available");
+      assertTrue(score.summary.includes("Progressing well"), "summary says progressing");
+      assertTrue(score.signals.length > 0, "has signals");
+    }
+
+    // ── Green: Clean Health Data ────────────────────────────────────────
+    console.log("\n=== progress: green with clean health ===");
+    {
+      resetProactiveHealing();
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(0, 0, 0);
+      }
+      const score = computeProgressScore();
+      assertEq(score.level, "green", "green with all clean snapshots");
+    }
+
+    // ── Yellow: Some Warnings ──────────────────────────────────────────
+    console.log("\n=== progress: yellow with error streak ===");
+    {
+      resetProactiveHealing();
+      recordHealthSnapshot(1, 2, 0);
+      recordHealthSnapshot(1, 1, 0);
+      const score = computeProgressScore();
+      assertEq(score.level, "yellow", "yellow with consecutive errors");
+      assertTrue(score.summary.includes("Struggling"), "summary says struggling");
+    }
+
+    // ── Red: Degrading Health ──────────────────────────────────────────
+    console.log("\n=== progress: red with degrading trend ===");
+    {
+      resetProactiveHealing();
+      // 5 older clean snapshots
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(0, 0, 0);
+      }
+      // 5 recent error snapshots — triggers degrading trend
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(3, 5, 0);
+      }
+      const score = computeProgressScore();
+      assertEq(score.level, "red", "red with degrading trend and persistent errors");
+      assertTrue(score.summary.includes("Stuck"), "summary says stuck");
+    }
+
+    // ── Red: High Error Streak ─────────────────────────────────────────
+    console.log("\n=== progress: red with high error streak ===");
+    {
+      resetProactiveHealing();
+      for (let i = 0; i < 4; i++) {
+        recordHealthSnapshot(2, 0, 0);
+      }
+      const score = computeProgressScore();
+      assertEq(score.level, "red", "red with 4 consecutive error units");
+    }
+
+    // ── Context-Aware Scoring ──────────────────────────────────────────
+    console.log("\n=== progress: context with retries ===");
+    {
+      resetProactiveHealing();
+      for (let i = 0; i < 3; i++) {
+        recordHealthSnapshot(0, 0, 0);
+      }
+      const score = computeProgressScoreWithContext({
+        currentUnitId: "M001/S01/T03",
+        completedUnits: 2,
+        totalUnits: 5,
+        retryCount: 0,
+        maxRetries: 5,
+      });
+      assertEq(score.level, "green", "green with no retries");
+      assertTrue(score.summary.includes("M001/S01/T03"), "summary includes unit ID");
+      assertTrue(score.summary.includes("2 of 5"), "summary includes progress");
+    }
+
+    console.log("\n=== progress: context with high retry count ===");
+    {
+      resetProactiveHealing();
+      for (let i = 0; i < 3; i++) {
+        recordHealthSnapshot(0, 0, 0);
+      }
+      const score = computeProgressScoreWithContext({
+        currentUnitId: "M001/S01/T03",
+        retryCount: 4,
+        maxRetries: 5,
+      });
+      assertEq(score.level, "red", "red with high retry count");
+      assertTrue(score.summary.includes("looping"), "summary mentions looping");
+    }
+
+    console.log("\n=== progress: context with moderate retries ===");
+    {
+      resetProactiveHealing();
+      for (let i = 0; i < 3; i++) {
+        recordHealthSnapshot(0, 0, 0);
+      }
+      const score = computeProgressScoreWithContext({
+        currentUnitId: "M001/S01/T03",
+        retryCount: 1,
+        maxRetries: 5,
+      });
+      assertEq(score.level, "yellow", "yellow with 1 retry");
+    }
+
+    // ── Formatting ─────────────────────────────────────────────────────
+    console.log("\n=== progress: formatProgressLine ===");
+    {
+      resetProactiveHealing();
+      const score = computeProgressScore();
+      const line = formatProgressLine(score);
+      assertTrue(line.includes("Progressing well"), "line includes summary");
+      // Should start with green circle emoji
+      assertTrue(line.startsWith("\uD83D\uDFE2"), "starts with green circle");
+    }
+
+    console.log("\n=== progress: formatProgressLine yellow ===");
+    {
+      resetProactiveHealing();
+      recordHealthSnapshot(1, 0, 0);
+      recordHealthSnapshot(1, 0, 0);
+      const score = computeProgressScore();
+      const line = formatProgressLine(score);
+      assertTrue(line.startsWith("\uD83D\uDFE1"), "starts with yellow circle");
+    }
+
+    console.log("\n=== progress: formatProgressReport ===");
+    {
+      resetProactiveHealing();
+      recordHealthSnapshot(0, 1, 0);
+      const score = computeProgressScore();
+      const detailed = formatProgressReport(score);
+      assertTrue(detailed.includes("Signals:"), "report has signals section");
+      assertTrue(detailed.includes("health_trend"), "report includes trend signal");
+      assertTrue(detailed.includes("error_streak"), "report includes streak signal");
+    }
+
+    // ── Signal Details ─────────────────────────────────────────────────
+    console.log("\n=== progress: signal names are consistent ===");
+    {
+      resetProactiveHealing();
+      recordHealthSnapshot(0, 0, 0);
+      const score = computeProgressScore();
+      const names = score.signals.map(s => s.name);
+      assertTrue(names.includes("health_trend"), "has health_trend signal");
+      assertTrue(names.includes("error_streak"), "has error_streak signal");
+      assertTrue(names.includes("recent_errors"), "has recent_errors signal");
+      assertTrue(names.includes("artifact_production"), "has artifact_production signal");
+      assertTrue(names.includes("dispatch_velocity"), "has dispatch_velocity signal");
+    }
+
+    console.log("\n=== progress: all signals have valid levels ===");
+    {
+      resetProactiveHealing();
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(1, 1, 1);
+      }
+      const score = computeProgressScore();
+      for (const signal of score.signals) {
+        assertTrue(
+          signal.level === "green" || signal.level === "yellow" || signal.level === "red",
+          `signal ${signal.name} has valid level: ${signal.level}`,
+        );
+        assertTrue(signal.detail.length > 0, `signal ${signal.name} has non-empty detail`);
+      }
+    }
+
+  } finally {
+    resetProactiveHealing();
+  }
+
+  report();
+}
+
+main();

package/dist/resources/extensions/gsd/tests/visualizer-views.test.ts

@@ -60,6 +60,9 @@ function makeVisualizerData(overrides: Partial<VisualizerData> = {}): Visualizer
       toolCalls: 0,
       assistantMessages: 0,
       userMessages: 0,
+      providers: [],
+      skillSummary: { total: 0, warningCount: 0, criticalCount: 0, topIssue: null },
+      environmentIssues: [],
     },
     discussion: [],
     stats: {
@@ -503,6 +506,9 @@ console.log("\n=== renderAgentView ===");
       truncationRate: 15.5, continueHereRate: 5.0,
       tierBreakdown: [], tierSavingsLine: "",
       toolCalls: 20, assistantMessages: 15, userMessages: 8,
+      providers: [],
+      skillSummary: { total: 0, warningCount: 0, criticalCount: 0, topIssue: null },
+      environmentIssues: [],
     },
     captures: { entries: [], pendingCount: 3, totalCount: 5 },
   });
@@ -669,6 +675,9 @@ console.log("\n=== renderHealthView ===");
       toolCalls: 50,
       assistantMessages: 30,
       userMessages: 15,
+      providers: [],
+      skillSummary: { total: 0, warningCount: 0, criticalCount: 0, topIssue: null },
+      environmentIssues: [],
     },
   });
 
@@ -693,6 +702,9 @@ console.log("\n=== renderHealthView ===");
       truncationRate: 0, continueHereRate: 0,
       tierBreakdown: [], tierSavingsLine: "",
       toolCalls: 0, assistantMessages: 0, userMessages: 0,
+      providers: [],
+      skillSummary: { total: 0, warningCount: 0, criticalCount: 0, topIssue: null },
+      environmentIssues: [],
     },
   });