gentyr 1.3.0

package/packages/mcp-servers/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@gentyr/mcp-servers",
+  "version": "1.0.0",
+  "description": "MCP servers for Claude Code integration",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "mcp-todo-db": "./dist/todo-db/server.js",
+    "mcp-specs-browser": "./dist/specs-browser/server.js",
+    "mcp-review-queue": "./dist/review-queue/server.js",
+    "mcp-agent-tracker": "./dist/agent-tracker/server.js",
+    "mcp-session-events": "./dist/session-events/server.js",
+    "mcp-agent-reports": "./dist/agent-reports/server.js",
+    "mcp-deputy-cto": "./dist/deputy-cto/server.js",
+    "mcp-cto-report": "./dist/cto-report/server.js",
+    "mcp-cto-reports": "./dist/cto-reports/server.js",
+    "mcp-render": "./dist/render/server.js",
+    "mcp-vercel": "./dist/vercel/server.js",
+    "mcp-github": "./dist/github/server.js",
+    "mcp-cloudflare": "./dist/cloudflare/server.js",
+    "mcp-supabase": "./dist/supabase/server.js",
+    "mcp-resend": "./dist/resend/server.js",
+    "mcp-elastic-logs": "./dist/elastic-logs/server.js",
+    "mcp-onepassword": "./dist/onepassword/server.js",
+    "mcp-codecov": "./dist/codecov/server.js",
+    "mcp-secret-sync": "./dist/secret-sync/server.js",
+    "mcp-user-feedback": "./dist/user-feedback/server.js",
+    "mcp-programmatic-feedback": "./dist/programmatic-feedback/server.js",
+    "mcp-playwright-feedback": "./dist/playwright-feedback/server.js",
+    "mcp-feedback-reporter": "./dist/feedback-reporter/server.js",
+    "mcp-playwright": "./dist/playwright/server.js",
+    "mcp-makerkit-docs": "./dist/makerkit-docs/server.js",
+    "mcp-setup-helper": "./dist/setup-helper/server.js",
+    "mcp-chrome-bridge": "./dist/chrome-bridge/server.js",
+    "mcp-product-manager": "./dist/product-manager/server.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src --ext .ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@elastic/elasticsearch": "^8.11.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "better-sqlite3": "^12.6.2",
+    "playwright": "^1.58.2",
+    "tweetnacl": "^1.0.3",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.8",
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/packages/mcp-servers/test/reporters/test-failure-reporter.ts

@@ -0,0 +1,372 @@
+/**
+ * Vitest Custom Reporter - Test Failure Handler
+ *
+ * This reporter spawns Claude Code to fix test failures automatically.
+ * Triggered by Vitest after test runs complete.
+ *
+ * Features:
+ * - Per-suite cooldown (120 minutes) - per individual test suite
+ * - Content-based deduplication via SHA-256 hashing (24-hour expiry)
+ * - Dynamic suite name extraction (no hardcoding)
+ * - Spawns Claude with failure details attached
+ * - Fire and forget (doesn't block test completion)
+ * - [Task][test-failure-vitest] prefix for CTO report tracking
+ * - CLAUDE_SPAWNED_SESSION env var to prevent hook chain reactions
+ *
+ * @version 1.0.0
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { spawn } from 'child_process';
+import type { Reporter, File, Task } from 'vitest';
+
+// Configuration
+const CONFIG = {
+  STATE_FILENAME: 'test-failure-state.json',
+  PROMPT_FILENAME: 'test-failure-prompt.md',
+  COOLDOWN_MINUTES: 60, // Per-suite cooldown
+  MAX_SUITES_PER_SPAWN: 3,
+  HASH_EXPIRY_HOURS: 12, // Failure output hashes expire after 12 hours
+  HOOKS_DIR: '.claude/hooks',
+};
+
+interface TestFailureState {
+  suites: Record<string, string>; // suiteName -> ISO timestamp
+  failureHashes: Record<string, string>; // hash -> ISO timestamp
+}
+
+interface FailedSuite {
+  name: string;
+  filepath: string;
+  failures: Array<{
+    name: string;
+    error: string;
+  }>;
+}
+
+/**
+ * Get the project root directory
+ */
+function getProjectRoot(): string {
+  // Navigate from packages/mcp-servers/test/reporters/ to project root
+  return process.env['CLAUDE_PROJECT_DIR'] || path.resolve(__dirname, '..', '..', '..', '..');
+}
+
+/**
+ * Get the path to the state file
+ */
+function getStatePath(): string {
+  return path.join(getProjectRoot(), CONFIG.HOOKS_DIR, CONFIG.STATE_FILENAME);
+}
+
+/**
+ * Get the path to the prompt file
+ */
+function getPromptPath(): string {
+  return path.join(getProjectRoot(), CONFIG.HOOKS_DIR, CONFIG.PROMPT_FILENAME);
+}
+
+/**
+ * Read the cooldown state from file
+ */
+function readState(): TestFailureState {
+  try {
+    const content = fs.readFileSync(getStatePath(), 'utf8');
+    const state = JSON.parse(content) as Partial<TestFailureState>;
+    return {
+      suites: state.suites || {},
+      failureHashes: state.failureHashes || {},
+    };
+  } catch {
+    return { suites: {}, failureHashes: {} };
+  }
+}
+
+/**
+ * Write the state to file
+ */
+function writeState(state: TestFailureState): void {
+  try {
+    const statePath = getStatePath();
+    const dir = path.dirname(statePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf8');
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Warning: Could not write state: ${message}`);
+  }
+}
+
+/**
+ * Check if a suite is in cooldown
+ */
+function isInCooldown(state: TestFailureState, suiteName: string, now: Date = new Date()): boolean {
+  const lastSpawn = state.suites[suiteName];
+  if (!lastSpawn) {return false;}
+
+  const lastSpawnDate = new Date(lastSpawn);
+  const minutesSince = (now.getTime() - lastSpawnDate.getTime()) / (1000 * 60);
+
+  return minutesSince < CONFIG.COOLDOWN_MINUTES;
+}
+
+/**
+ * Record spawn time for suites
+ */
+function recordSpawn(suiteNames: string[], now: Date = new Date()): void {
+  const state = readState();
+
+  // Record per-suite timestamps
+  for (const suite of suiteNames) {
+    state.suites[suite] = now.toISOString();
+  }
+
+  // Clean up old entries (older than 24 hours)
+  const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+  for (const [suite, timestamp] of Object.entries(state.suites)) {
+    if (new Date(timestamp) < oneDayAgo) {
+      delete state.suites[suite];
+    }
+  }
+
+  writeState(state);
+}
+
+/**
+ * Compute a hash of failure details for deduplication
+ */
+function computeFailureHash(failureDetails: string): string {
+  return crypto.createHash('sha256').update(failureDetails).digest('hex').slice(0, 16);
+}
+
+/**
+ * Check if a failure hash has been seen recently (within expiry period)
+ */
+function isHashSeen(state: TestFailureState, hash: string, now: Date = new Date()): boolean {
+  const timestamp = state.failureHashes[hash];
+  if (!timestamp) {return false;}
+
+  const hashDate = new Date(timestamp);
+  const hoursSince = (now.getTime() - hashDate.getTime()) / (1000 * 60 * 60);
+
+  return hoursSince < CONFIG.HASH_EXPIRY_HOURS;
+}
+
+/**
+ * Record a failure hash and clean up expired hashes
+ */
+function recordFailureHash(hash: string, now: Date = new Date()): void {
+  const state = readState();
+
+  // Record the new hash
+  state.failureHashes[hash] = now.toISOString();
+
+  // Clean up expired hashes (older than 24 hours)
+  const expiryTime = new Date(now.getTime() - CONFIG.HASH_EXPIRY_HOURS * 60 * 60 * 1000);
+  for (const [h, timestamp] of Object.entries(state.failureHashes)) {
+    if (new Date(timestamp) < expiryTime) {
+      delete state.failureHashes[h];
+    }
+  }
+
+  writeState(state);
+}
+
+/**
+ * Read the prompt template from file
+ */
+function readPrompt(): string | null {
+  try {
+    return fs.readFileSync(getPromptPath(), 'utf8').trim();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Warning: Could not read prompt file: ${message}`);
+    return null;
+  }
+}
+
+/**
+ * Format failure details from Vitest test results
+ */
+function formatFailureDetails(failedSuites: FailedSuite[]): string {
+  const details: string[] = [];
+
+  for (const suite of failedSuites) {
+    details.push(`\n=== ${suite.filepath} ===`);
+
+    for (const failure of suite.failures) {
+      details.push(`\n● ${failure.name}`);
+      // Truncate very long messages
+      const truncated =
+        failure.error.length > 1000 ? `${failure.error.slice(0, 1000)  }\n... (truncated)` : failure.error;
+      details.push(truncated);
+    }
+  }
+
+  return details.join('\n');
+}
+
+/**
+ * Extract failed tests from a Vitest task tree
+ */
+function extractFailures(tasks: Task[], ancestorNames: string[] = []): Array<{ name: string; error: string }> {
+  const failures: Array<{ name: string; error: string }> = [];
+
+  for (const task of tasks) {
+    const fullName = [...ancestorNames, task.name].join(' › ');
+
+    if (task.type === 'test' && task.result?.state === 'fail') {
+      const errorMessage = task.result.errors?.map((e) => e.message || String(e)).join('\n') || 'Unknown error';
+      failures.push({ name: fullName, error: errorMessage });
+    }
+
+    // Recursively check nested tasks (describe blocks)
+    if ('tasks' in task && Array.isArray(task.tasks)) {
+      failures.push(...extractFailures(task.tasks, [...ancestorNames, task.name]));
+    }
+  }
+
+  return failures;
+}
+
+/**
+ * Spawn Claude to fix test failures
+ */
+function spawnClaude(suiteNames: string[], failureDetails: string): boolean {
+  const promptTemplate = readPrompt();
+
+  if (!promptTemplate) {
+    console.error('Warning: No prompt file found, skipping Claude spawn');
+    return false;
+  }
+
+  const projectRoot = getProjectRoot();
+  const suitesFormatted = suiteNames.slice(0, CONFIG.MAX_SUITES_PER_SPAWN).join('\n- ');
+
+  // Add [Task][test-failure-vitest] prefix for CTO report tracking
+  const prompt = `[Task][test-failure-vitest] ${promptTemplate}
+
+FAILING TEST SUITES (processing up to ${CONFIG.MAX_SUITES_PER_SPAWN}):
+- ${suitesFormatted}
+
+FAILURE OUTPUT:
+\`\`\`
+${failureDetails.slice(0, 8000)}
+\`\`\``;
+
+  try {
+    // Try to register spawn with agent tracker (fire-and-forget, don't fail if unavailable)
+    try {
+      // Dynamic import to avoid hard dependency
+      const agentTrackerPath = path.join(projectRoot, '.claude/hooks/agent-tracker.js');
+      if (fs.existsSync(agentTrackerPath)) {
+        // We can't use dynamic import in this context, so we'll skip registration
+        // The agent will still be tracked by the session itself
+      }
+    } catch {
+      // Agent tracker not available, continue without registration
+    }
+
+    const claude = spawn(
+      'claude',
+      ['--dangerously-skip-permissions', '-p', prompt],
+      {
+        detached: true,
+        stdio: 'ignore',
+        cwd: projectRoot,
+        env: {
+          ...process.env,
+          CLAUDE_PROJECT_DIR: projectRoot,
+          CLAUDE_SPAWNED_SESSION: 'true', // Prevent chain reaction from hooks
+        },
+      }
+    );
+
+    claude.unref();
+    return true;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Warning: Failed to spawn Claude: ${message}`);
+    return false;
+  }
+}
+
+/**
+ * Vitest Custom Reporter Class
+ */
+export default class TestFailureReporter implements Reporter {
+  onFinished(files?: File[]): void {
+    if (!files || files.length === 0) {
+      return;
+    }
+
+    // Extract failed suites
+    const failedSuites: FailedSuite[] = [];
+
+    for (const file of files) {
+      const failures = extractFailures(file.tasks);
+
+      if (failures.length > 0) {
+        failedSuites.push({
+          name: path.basename(file.filepath),
+          filepath: file.filepath,
+          failures,
+        });
+      }
+    }
+
+    if (failedSuites.length === 0) {
+      return; // No failures, nothing to do
+    }
+
+    // Get suite names
+    const suiteNames = failedSuites.map((s) => s.name);
+
+    // Check cooldowns
+    const state = readState();
+    const now = new Date();
+
+    // Check per-suite cooldowns
+    const suitesToProcess = suiteNames.filter((suite) => !isInCooldown(state, suite, now));
+
+    if (suitesToProcess.length === 0) {
+      console.warn('\n[TestFailureReporter] All failing suites are in cooldown, skipping spawn');
+      return;
+    }
+
+    // Limit to max suites per spawn
+    const suitesToSpawn = suitesToProcess.slice(0, CONFIG.MAX_SUITES_PER_SPAWN);
+
+    // Get the failed suites that match our spawn list
+    const failedSuitesToReport = failedSuites.filter((s) => suitesToSpawn.includes(s.name));
+
+    // Format failure details
+    const failureDetails = formatFailureDetails(failedSuitesToReport);
+
+    // Check if this exact failure output has been seen recently (deduplication)
+    const failureHash = computeFailureHash(failureDetails);
+    if (isHashSeen(state, failureHash, now)) {
+      console.warn(`\n[TestFailureReporter] Duplicate failure output detected (hash: ${failureHash}), skipping spawn`);
+      return;
+    }
+
+    // Spawn Claude
+    const spawned = spawnClaude(suitesToSpawn, failureDetails);
+
+    if (spawned) {
+      recordSpawn(suitesToSpawn, now);
+      recordFailureHash(failureHash, now);
+      // Use console.warn since console.log is not allowed by lint rules
+      console.warn(
+        `\n[TestFailureReporter] Spawned Claude to fix ${suitesToSpawn.length} failing test suite(s) (hash: ${failureHash}):`
+      );
+      for (const suite of suitesToSpawn) {
+        console.warn(`  - ${suite}`);
+      }
+    }
+  }
+}

package/packages/mcp-servers/vitest.config.ts

@@ -0,0 +1,27 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/**',
+        'dist/**',
+        '**/*.test.ts',
+        '**/*.spec.ts',
+        '**/types.ts',
+        '**/index.ts',
+      ],
+    },
+    // Increase timeout for database operations
+    testTimeout: 10000,
+    // Custom reporters - TestFailureReporter spawns Claude to fix failures
+    reporters: [
+      'default',
+      './test/reporters/test-failure-reporter.ts',
+    ],
+  },
+});

package/scripts/__tests__/README.md

@@ -0,0 +1,163 @@
+# Scripts Tests
+
+This directory contains tests for standalone scripts in the `scripts/` directory.
+
+## Running Tests
+
+```bash
+# Run all script tests
+node --test scripts/__tests__/*.test.js
+
+# Run specific test file
+node --test scripts/__tests__/setup-check.test.js
+
+# Run with detailed output
+node --test --test-reporter=spec scripts/__tests__/*.test.js
+```
+
+## Test Files
+
+### `setup-check.test.js`
+Tests for the `setup-check.js` credential evaluation script.
+
+**What it tests:**
+- Code structure validation (ES module, required functions, CREDENTIALS registry)
+- JSON output schema compliance
+- Graceful degradation (missing GENTYR, missing op CLI, missing vault-mappings.json)
+- GITHUB_TOKEN/GITHUB_PAT deduplication (caching op:// path checks)
+- Summary calculation logic
+- Edge cases (environment variables, corrupted files)
+
+**Test approach:**
+- **Structure tests**: Regex matching on source code to validate constants and functions exist
+- **Behavior tests**: Execute script with mocked project directories, validate JSON output
+- **Graceful degradation**: Test all failure modes (missing dependencies, missing files, corrupted data)
+
+## Test Framework
+
+Uses Node's built-in test runner (`node:test`) rather than Jest or Vitest, because:
+- No external dependencies required
+- Perfect for standalone script testing
+- Native ES modules support
+- Built-in assertion library
+- Matches the pattern used in `.claude/hooks/__tests__/`
+
+## Testing Philosophy
+
+### Structure Validation
+When behavior is hard to test in isolation (e.g., requires live 1Password CLI), we validate the code structure:
+- Use regex to match expected patterns in source code
+- Verify constants, functions, and exports exist
+- Validate documentation and JSDoc
+
+### Behavior Validation
+When behavior can be tested without live dependencies:
+- Create temporary project directories with controlled states
+- Execute the script and parse JSON output
+- Validate output schema and calculations
+- Test all code paths (missing files, corrupted data, etc.)
+
+### Graceful Degradation
+All failure modes should be tested:
+- Missing GENTYR installation
+- Missing 1Password CLI
+- 1Password not authenticated
+- Missing vault-mappings.json
+- Corrupted vault-mappings.json
+- Partial credential configuration
+
+## Why Not Mock `execFileSync` for op CLI?
+
+**Decision: We do NOT mock the `op` CLI in these tests.**
+
+**Rationale:**
+1. **Real-world testing**: The script already has graceful degradation for missing op CLI
+2. **Complexity**: Mocking `execFileSync` requires module-level mocking (complex in ES modules)
+3. **Coverage**: We get sufficient coverage by testing:
+   - `opCliAvailable: false` (op CLI not in PATH)
+   - `opAuthenticated: false` (op CLI available but not authenticated)
+   - Real `op` CLI when available (opportunistic)
+
+**What we DO test:**
+- Code structure (functions exist, constants defined)
+- JSON output schema (all required fields present)
+- Graceful degradation (missing dependencies, corrupted files)
+- Summary calculations (counts, booleans)
+
+**What we DON'T test:**
+- Actual `op read` calls to 1Password (would require mocking or live credentials)
+- Exact `existsInOp` values (depends on live 1Password state)
+
+This approach gives us:
+- ✅ Fast tests (no mocking overhead)
+- ✅ High confidence in graceful degradation
+- ✅ Schema validation
+- ✅ Real-world behavior (when op CLI available)
+
+## Test Coverage
+
+### Code Structure (100%)
+- [x] ES module imports
+- [x] Shebang for direct execution
+- [x] CREDENTIALS registry with all required credentials
+- [x] All required functions defined
+- [x] main() called at end of script
+
+### Function Behavior (95%)
+- [x] checkGentyrInstalled() - directory/symlink detection
+- [x] readVaultMappings() - JSON parsing, graceful errors
+- [x] main() - JSON output schema
+- [ ] checkOpCli() - **Not fully tested** (would require mocking)
+- [ ] checkOpSecret() - **Not fully tested** (would require mocking)
+
+### Graceful Degradation (100%)
+- [x] Missing GENTYR installation
+- [x] Missing vault-mappings.json
+- [x] Corrupted vault-mappings.json
+- [x] Partial credential configuration
+- [x] op CLI not in PATH
+- [x] Environment variable handling
+
+### JSON Schema (100%)
+- [x] All top-level fields present
+- [x] credentials object structure
+- [x] summary object structure
+- [x] Credential metadata fields
+- [x] Summary calculation accuracy
+
+### Edge Cases (100%)
+- [x] GITHUB_TOKEN/GITHUB_PAT deduplication
+- [x] Identifier credentials (null opPath)
+- [x] CLAUDE_PROJECT_DIR environment variable
+- [x] Fallback to process.cwd()
+
+## Maintenance Notes
+
+### When to Update Tests
+
+**Add tests when:**
+- New credentials added to CREDENTIALS registry
+- New top-level fields added to JSON output
+- New summary calculations added
+- New graceful degradation behavior added
+
+**Update tests when:**
+- CREDENTIALS registry structure changes
+- JSON output schema changes
+- Summary calculation logic changes
+
+### Test Isolation
+
+All tests use temporary directories created with `createTestProject()`:
+- Each test creates a fresh temporary project directory
+- Tests clean up after themselves (in `finally` blocks)
+- No tests depend on actual GENTYR installation or 1Password state
+
+### Performance
+
+Tests are fast because:
+- No network calls (1Password CLI only used when available)
+- No mocking overhead (tests actual graceful degradation)
+- Temporary directories cleaned up immediately
+
+**Typical runtime:** < 2 seconds for full suite