winter-super-cli 2026.5.32 → 2026.6.5

package/resources/local/ecc/scripts/gan-harness.sh

@@ -0,0 +1,299 @@
+#!/bin/bash
+# gan-harness.sh — GAN-Style Generator-Evaluator Harness Orchestrator
+#
+# Inspired by Anthropic's "Harness Design for Long-Running Application Development"
+# https://www.anthropic.com/engineering/harness-design-long-running-apps
+#
+# Usage:
+#   ./scripts/gan-harness.sh "Build a music streaming dashboard"
+#   GAN_MAX_ITERATIONS=10 GAN_PASS_THRESHOLD=8.0 ./scripts/gan-harness.sh "Build a Kanban board"
+#
+# Environment Variables:
+#   GAN_MAX_ITERATIONS  — Max generator-evaluator cycles (default: 15)
+#   GAN_PASS_THRESHOLD  — Weighted score to pass, 1-10 (default: 7.0)
+#   GAN_PLANNER_MODEL   — Model for planner (default: opus)
+#   GAN_GENERATOR_MODEL — Model for generator (default: opus)
+#   GAN_EVALUATOR_MODEL — Model for evaluator (default: opus)
+#   GAN_DEV_SERVER_PORT — Port for live app (default: 3000)
+#   GAN_DEV_SERVER_CMD  — Command to start dev server (default: "npm run dev")
+#   GAN_PROJECT_DIR     — Working directory (default: current dir)
+#   GAN_SKIP_PLANNER    — Set to "true" to skip planner phase
+#   GAN_EVAL_MODE       — playwright, screenshot, or code-only (default: playwright)
+
+set -euo pipefail
+
+# ─── Configuration ───────────────────────────────────────────────────────────
+
+BRIEF="${1:?Usage: ./scripts/gan-harness.sh \"description of what to build\"}"
+MAX_ITERATIONS="${GAN_MAX_ITERATIONS:-15}"
+PASS_THRESHOLD="${GAN_PASS_THRESHOLD:-7.0}"
+PLANNER_MODEL="${GAN_PLANNER_MODEL:-opus}"
+GENERATOR_MODEL="${GAN_GENERATOR_MODEL:-opus}"
+EVALUATOR_MODEL="${GAN_EVALUATOR_MODEL:-opus}"
+DEV_PORT="${GAN_DEV_SERVER_PORT:-3000}"
+DEV_CMD="${GAN_DEV_SERVER_CMD:-npm run dev}"
+PROJECT_DIR="${GAN_PROJECT_DIR:-.}"
+SKIP_PLANNER="${GAN_SKIP_PLANNER:-false}"
+EVAL_MODE="${GAN_EVAL_MODE:-playwright}"
+
+HARNESS_DIR="${PROJECT_DIR}/gan-harness"
+FEEDBACK_DIR="${HARNESS_DIR}/feedback"
+SCREENSHOTS_DIR="${HARNESS_DIR}/screenshots"
+START_TIME=$(date +%s)
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+PURPLE='\033[0;35m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+# ─── Helpers ─────────────────────────────────────────────────────────────────
+
+log()    { echo -e "${BLUE}[GAN-HARNESS]${NC} $*"; }
+ok()     { echo -e "${GREEN}[✓]${NC} $*"; }
+warn()   { echo -e "${YELLOW}[WARN]${NC} $*"; }
+fail()   { echo -e "${RED}[✗]${NC} $*"; }
+phase()  { echo -e "\n${PURPLE}═══════════════════════════════════════════════${NC}"; echo -e "${PURPLE}  $*${NC}"; echo -e "${PURPLE}═══════════════════════════════════════════════${NC}\n"; }
+
+extract_score() {
+  # Extract the TOTAL weighted score from a feedback file
+  local file="$1"
+  # Look for **TOTAL** or **X.X/10** pattern
+  grep -oP '(?<=\*\*TOTAL\*\*.*\*\*)[0-9]+\.[0-9]+' "$file" 2>/dev/null \
+    || grep -oP '(?<=TOTAL.*\|.*\| \*\*)[0-9]+\.[0-9]+' "$file" 2>/dev/null \
+    || grep -oP 'Verdict:.*([0-9]+\.[0-9]+)' "$file" 2>/dev/null | grep -oP '[0-9]+\.[0-9]+' \
+    || echo "0.0"
+}
+
+score_passes() {
+  local score="$1"
+  local threshold="$2"
+  awk -v s="$score" -v t="$threshold" 'BEGIN { exit !(s >= t) }'
+}
+
+elapsed() {
+  local now=$(date +%s)
+  local diff=$((now - START_TIME))
+  printf '%dh %dm %ds' $((diff/3600)) $((diff%3600/60)) $((diff%60))
+}
+
+# ─── Setup ───────────────────────────────────────────────────────────────────
+
+phase "GAN-STYLE HARNESS — Setup"
+
+log "Brief: ${CYAN}${BRIEF}${NC}"
+log "Max iterations: $MAX_ITERATIONS"
+log "Pass threshold: $PASS_THRESHOLD"
+log "Models: Planner=$PLANNER_MODEL, Generator=$GENERATOR_MODEL, Evaluator=$EVALUATOR_MODEL"
+log "Eval mode: $EVAL_MODE"
+log "Project dir: $PROJECT_DIR"
+
+mkdir -p "$FEEDBACK_DIR" "$SCREENSHOTS_DIR"
+
+# Initialize git if needed
+if [ ! -d "${PROJECT_DIR}/.git" ]; then
+  git -C "$PROJECT_DIR" init
+  ok "Initialized git repository"
+fi
+
+# Write config
+cat > "${HARNESS_DIR}/config.json" << EOF
+{
+  "brief": "$BRIEF",
+  "maxIterations": $MAX_ITERATIONS,
+  "passThreshold": $PASS_THRESHOLD,
+  "models": {
+    "planner": "$PLANNER_MODEL",
+    "generator": "$GENERATOR_MODEL",
+    "evaluator": "$EVALUATOR_MODEL"
+  },
+  "evalMode": "$EVAL_MODE",
+  "devServerPort": $DEV_PORT,
+  "startedAt": "$(date -Iseconds)"
+}
+EOF
+
+ok "Harness directory created: $HARNESS_DIR"
+
+# ─── Phase 1: Planning ──────────────────────────────────────────────────────
+
+if [ "$SKIP_PLANNER" = "true" ] && [ -f "${HARNESS_DIR}/spec.md" ]; then
+  phase "PHASE 1: Planning — SKIPPED (spec.md exists)"
+else
+  phase "PHASE 1: Planning"
+  log "Launching Planner agent (model: $PLANNER_MODEL)..."
+
+  claude -p --model "$PLANNER_MODEL" \
+    "You are the Planner in a GAN-style harness. Read the agent definition in agents/gan-planner.md for your full instructions.
+
+Your brief: \"$BRIEF\"
+
+Create two files:
+1. gan-harness/spec.md — Full product specification
+2. gan-harness/eval-rubric.md — Evaluation criteria for the Evaluator
+
+Be ambitious. Push for 12-16 features. Specify exact colors, fonts, and layouts. Don't be generic." \
+    2>&1 | tee "${HARNESS_DIR}/planner-output.log"
+
+  if [ -f "${HARNESS_DIR}/spec.md" ]; then
+    ok "Spec generated: $(wc -l < "${HARNESS_DIR}/spec.md") lines"
+  else
+    fail "Planner did not produce spec.md!"
+    exit 1
+  fi
+fi
+
+# ─── Phase 2: Generator-Evaluator Loop ──────────────────────────────────────
+
+phase "PHASE 2: Generator-Evaluator Loop"
+
+SCORES=()
+PREV_SCORE="0.0"
+PLATEAU_COUNT=0
+
+for (( i=1; i<=MAX_ITERATIONS; i++ )); do
+  echo ""
+  log "━━━ Iteration $i / $MAX_ITERATIONS ━━━"
+
+  # ── GENERATE ──
+  echo -e "${GREEN}>> GENERATOR (iteration $i)${NC}"
+
+  FEEDBACK_CONTEXT=""
+  if [ $i -gt 1 ] && [ -f "${FEEDBACK_DIR}/feedback-$(printf '%03d' $((i-1))).md" ]; then
+    FEEDBACK_CONTEXT="IMPORTANT: Read and address ALL issues in gan-harness/feedback/feedback-$(printf '%03d' $((i-1))).md before doing anything else."
+  fi
+
+  claude -p --model "$GENERATOR_MODEL" \
+    "You are the Generator in a GAN-style harness. Read agents/gan-generator.md for full instructions.
+
+Iteration: $i
+$FEEDBACK_CONTEXT
+
+Read gan-harness/spec.md for the product specification.
+Build/improve the application. Ensure the dev server runs on port $DEV_PORT.
+Commit your changes with message: 'iteration-$(printf '%03d' $i): [describe what you did]'
+Update gan-harness/generator-state.md." \
+    2>&1 | tee "${HARNESS_DIR}/generator-${i}.log"
+
+  ok "Generator completed iteration $i"
+
+  # ── EVALUATE ──
+  echo -e "${RED}>> EVALUATOR (iteration $i)${NC}"
+
+  claude -p --model "$EVALUATOR_MODEL" \
+    --allowedTools "Read,Write,Bash,Grep,Glob" \
+    "You are the Evaluator in a GAN-style harness. Read agents/gan-evaluator.md for full instructions.
+
+Iteration: $i
+Eval mode: $EVAL_MODE
+Dev server: http://localhost:$DEV_PORT
+
+1. Read gan-harness/eval-rubric.md for scoring criteria
+2. Read gan-harness/spec.md for feature requirements
+3. Read gan-harness/generator-state.md for what was built
+4. Test the live application (mode: $EVAL_MODE)
+5. Score against the rubric (1-10 per criterion)
+6. Write detailed feedback to gan-harness/feedback/feedback-$(printf '%03d' $i).md
+
+Be RUTHLESSLY strict. A 7 means genuinely good, not 'good for AI.'
+Include the weighted TOTAL score in the format: | **TOTAL** | | | **X.X** |" \
+    2>&1 | tee "${HARNESS_DIR}/evaluator-${i}.log"
+
+  FEEDBACK_FILE="${FEEDBACK_DIR}/feedback-$(printf '%03d' $i).md"
+
+  if [ -f "$FEEDBACK_FILE" ]; then
+    SCORE=$(extract_score "$FEEDBACK_FILE")
+    SCORES+=("$SCORE")
+    ok "Evaluator completed. Score: ${CYAN}${SCORE}${NC} / 10.0 (threshold: $PASS_THRESHOLD)"
+  else
+    warn "Evaluator did not produce feedback file. Assuming score 0.0"
+    SCORE="0.0"
+    SCORES+=("0.0")
+  fi
+
+  # ── CHECK PASS ──
+  if score_passes "$SCORE" "$PASS_THRESHOLD"; then
+    echo ""
+    ok "PASSED at iteration $i with score $SCORE (threshold: $PASS_THRESHOLD)"
+    break
+  fi
+
+  # ── CHECK PLATEAU ──
+  SCORE_DIFF=$(awk -v s="$SCORE" -v p="$PREV_SCORE" 'BEGIN { printf "%.1f", s - p }')
+  if [ $i -ge 3 ] && awk -v d="$SCORE_DIFF" 'BEGIN { exit !(d <= 0.2) }'; then
+    PLATEAU_COUNT=$((PLATEAU_COUNT + 1))
+  else
+    PLATEAU_COUNT=0
+  fi
+
+  if [ $PLATEAU_COUNT -ge 2 ]; then
+    warn "Score plateau detected (no improvement for 2 iterations). Stopping early."
+    break
+  fi
+
+  PREV_SCORE="$SCORE"
+done
+
+# ─── Phase 3: Summary ───────────────────────────────────────────────────────
+
+phase "PHASE 3: Build Report"
+
+FINAL_SCORE="${SCORES[-1]:-0.0}"
+NUM_ITERATIONS=${#SCORES[@]}
+ELAPSED=$(elapsed)
+
+# Build score progression table
+SCORE_TABLE="| Iter | Score |\n|------|-------|\n"
+for (( j=0; j<${#SCORES[@]}; j++ )); do
+  SCORE_TABLE+="| $((j+1)) | ${SCORES[$j]} |\n"
+done
+
+# Write report
+cat > "${HARNESS_DIR}/build-report.md" << EOF
+# GAN Harness Build Report
+
+**Brief:** $BRIEF
+**Result:** $(score_passes "$FINAL_SCORE" "$PASS_THRESHOLD" && echo "PASS" || echo "FAIL")
+**Iterations:** $NUM_ITERATIONS / $MAX_ITERATIONS
+**Final Score:** $FINAL_SCORE / 10.0 (threshold: $PASS_THRESHOLD)
+**Elapsed:** $ELAPSED
+
+## Score Progression
+
+$(echo -e "$SCORE_TABLE")
+
+## Configuration
+
+- Planner model: $PLANNER_MODEL
+- Generator model: $GENERATOR_MODEL
+- Evaluator model: $EVALUATOR_MODEL
+- Eval mode: $EVAL_MODE
+- Pass threshold: $PASS_THRESHOLD
+
+## Files
+
+- \`gan-harness/spec.md\` — Product specification
+- \`gan-harness/eval-rubric.md\` — Evaluation rubric
+- \`gan-harness/feedback/\` — All evaluation feedback ($NUM_ITERATIONS files)
+- \`gan-harness/generator-state.md\` — Final generator state
+- \`gan-harness/build-report.md\` — This report
+EOF
+
+ok "Report written to ${HARNESS_DIR}/build-report.md"
+
+echo ""
+log "━━━ Final Results ━━━"
+if score_passes "$FINAL_SCORE" "$PASS_THRESHOLD"; then
+  echo -e "${GREEN}  Result:     PASS${NC}"
+else
+  echo -e "${RED}  Result:     FAIL${NC}"
+fi
+echo -e "  Score:      ${CYAN}${FINAL_SCORE}${NC} / 10.0"
+echo -e "  Iterations: ${NUM_ITERATIONS} / ${MAX_ITERATIONS}"
+echo -e "  Elapsed:    ${ELAPSED}"
+echo ""
+
+log "Done! Review the build at http://localhost:$DEV_PORT"

package/resources/local/ecc/scripts/gemini-adapt-agents.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const TOOL_NAME_MAP = new Map([
+  ['Read', 'read_file'],
+  ['Write', 'write_file'],
+  ['Edit', 'replace'],
+  ['Bash', 'run_shell_command'],
+  ['Grep', 'grep_search'],
+  ['Glob', 'glob'],
+  ['WebSearch', 'google_web_search'],
+  ['WebFetch', 'web_fetch'],
+]);
+
+function usage() {
+  return [
+    'Adapt ECC agent frontmatter for Gemini CLI.',
+    '',
+    'Usage:',
+    '  node scripts/gemini-adapt-agents.js [agents-dir]',
+    '',
+    'Defaults to .gemini/agents under the current working directory.',
+    'Rewrites tools: to Gemini-compatible tool names and removes unsupported color: metadata.'
+  ].join('\n');
+}
+
+function parseArgs(argv) {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    return { help: true };
+  }
+
+  const positional = argv.filter(arg => !arg.startsWith('-'));
+  if (positional.length > 1) {
+    throw new Error('Expected at most one agents directory argument');
+  }
+
+  return {
+    help: false,
+    agentsDir: path.resolve(positional[0] || path.join(process.cwd(), '.gemini', 'agents')),
+  };
+}
+
+function ensureDirectory(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    throw new Error(`Agents directory not found: ${dirPath}`);
+  }
+
+  if (!fs.statSync(dirPath).isDirectory()) {
+    throw new Error(`Expected a directory: ${dirPath}`);
+  }
+}
+
+function stripQuotes(value) {
+  return value.trim().replace(/^['"]|['"]$/g, '');
+}
+
+function parseToolList(line) {
+  const match = line.match(/^(\s*tools\s*:\s*)\[(.*)\]\s*$/);
+  if (!match) {
+    return null;
+  }
+
+  const rawItems = match[2].trim();
+  if (!rawItems) {
+    return [];
+  }
+
+  return rawItems
+    .split(',')
+    .map(part => stripQuotes(part))
+    .filter(Boolean);
+}
+
+function adaptToolName(toolName) {
+  const mapped = TOOL_NAME_MAP.get(toolName);
+  if (mapped) {
+    return mapped;
+  }
+
+  if (toolName.startsWith('mcp__')) {
+    return toolName
+      .replace(/^mcp__/, 'mcp_')
+      .replace(/__/g, '_')
+      .replace(/[^A-Za-z0-9_]/g, '_')
+      .toLowerCase();
+  }
+
+  return toolName;
+}
+
+function formatToolLine(tools) {
+  return `tools: [${tools.map(tool => JSON.stringify(tool)).join(', ')}]`;
+}
+
+function adaptFrontmatter(text) {
+  const match = text.match(/^---\n([\s\S]*?)\n---(\n|$)/);
+  if (!match) {
+    return { text, changed: false };
+  }
+
+  let changed = false;
+  const updatedLines = [];
+
+  for (const line of match[1].split('\n')) {
+    if (/^\s*color\s*:/.test(line)) {
+      changed = true;
+      continue;
+    }
+
+    const tools = parseToolList(line);
+    if (tools) {
+      const adaptedTools = [];
+      const seen = new Set();
+
+      for (const tool of tools.map(adaptToolName)) {
+        if (seen.has(tool)) {
+          continue;
+        }
+        seen.add(tool);
+        adaptedTools.push(tool);
+      }
+
+      const updatedLine = formatToolLine(adaptedTools);
+      if (updatedLine !== line) {
+        changed = true;
+      }
+      updatedLines.push(updatedLine);
+      continue;
+    }
+
+    updatedLines.push(line);
+  }
+
+  if (!changed) {
+    return { text, changed: false };
+  }
+
+  return {
+    text: `---\n${updatedLines.join('\n')}\n---${match[2]}${text.slice(match[0].length)}`,
+    changed: true,
+  };
+}
+
+function adaptAgents(dirPath) {
+  ensureDirectory(dirPath);
+
+  let updated = 0;
+  let unchanged = 0;
+
+  for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith('.md')) {
+      continue;
+    }
+
+    const filePath = path.join(dirPath, entry.name);
+    const original = fs.readFileSync(filePath, 'utf8');
+    const adapted = adaptFrontmatter(original);
+
+    if (adapted.changed) {
+      fs.writeFileSync(filePath, adapted.text);
+      updated += 1;
+    } else {
+      unchanged += 1;
+    }
+  }
+
+  return { updated, unchanged };
+}
+
+function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    console.log(usage());
+    return;
+  }
+
+  const result = adaptAgents(options.agentsDir);
+  console.log(`Updated ${result.updated} agent file(s); ${result.unchanged} already compatible`);
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exit(1);
+}

package/resources/local/ecc/scripts/harness-adapter-compliance.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const {
+  ADAPTER_RECORDS,
+  renderMarkdownTable,
+  validateAdapterRecords,
+  validateDocumentation,
+} = require('./lib/harness-adapter-compliance');
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const parsed = {
+    check: false,
+    format: 'text',
+    help: false,
+    root: process.cwd(),
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--help' || arg === '-h') {
+      parsed.help = true;
+      continue;
+    }
+
+    if (arg === '--check') {
+      parsed.check = true;
+      continue;
+    }
+
+    if (arg === '--format') {
+      parsed.format = String(args[index + 1] || '').toLowerCase();
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--format=')) {
+      parsed.format = arg.slice('--format='.length).toLowerCase();
+      continue;
+    }
+
+    if (arg === '--root') {
+      parsed.root = path.resolve(args[index + 1] || process.cwd());
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--root=')) {
+      parsed.root = path.resolve(arg.slice('--root='.length));
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  if (!['text', 'json', 'markdown'].includes(parsed.format)) {
+    throw new Error(`Invalid format: ${parsed.format}. Use text, json, or markdown.`);
+  }
+
+  parsed.root = path.resolve(parsed.root);
+  return parsed;
+}
+
+function printHelp() {
+  console.log([
+    'Usage: node scripts/harness-adapter-compliance.js [options]',
+    '',
+    'Validate or render the ECC harness adapter compliance scorecard.',
+    '',
+    'Options:',
+    '  --check                 Fail if adapter records or docs are out of sync',
+    '  --format <text|json|markdown>',
+    '  --root <path>           Repository root, defaults to cwd',
+    '  -h, --help              Show this help',
+  ].join('\n'));
+}
+
+function buildPayload(root) {
+  const recordErrors = validateAdapterRecords();
+  const documentationErrors = validateDocumentation({ repoRoot: root });
+
+  return {
+    schema_version: 'ecc.harness-adapter-compliance.v1',
+    generated_from: 'scripts/lib/harness-adapter-compliance.js',
+    adapter_count: ADAPTER_RECORDS.length,
+    valid: recordErrors.length === 0 && documentationErrors.length === 0,
+    errors: [...recordErrors, ...documentationErrors],
+    adapters: ADAPTER_RECORDS,
+  };
+}
+
+function renderText(payload) {
+  const lines = [
+    `Harness Adapter Compliance: ${payload.valid ? 'PASS' : 'FAIL'}`,
+    `Adapters: ${payload.adapter_count}`,
+  ];
+
+  if (payload.errors.length > 0) {
+    lines.push('Errors:');
+    for (const error of payload.errors) {
+      lines.push(`- ${error}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function main() {
+  let parsed;
+
+  try {
+    parsed = parseArgs(process.argv);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+
+  if (parsed.help) {
+    printHelp();
+    return;
+  }
+
+  const payload = buildPayload(parsed.root);
+
+  if (parsed.format === 'json') {
+    console.log(JSON.stringify(payload, null, 2));
+  } else if (parsed.format === 'markdown') {
+    console.log(renderMarkdownTable());
+  } else {
+    console.log(renderText(payload));
+  }
+
+  if (parsed.check && !payload.valid) {
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  buildPayload,
+  parseArgs,
+};
+