chore: sync remaining workspace changes (refactors, deletions, and config)

Author: jmbish04

.agent/rules/HEALTH_GOVERNANCE.md

@@ -0,0 +1,32 @@
+# Health Check Governance
+
+## Rule: Every New Module Must Register a Health Check
+
+When adding a new domain module under `backend/src/`, you **MUST**:
+
+1. Create a `health.ts` file co-located with the module
+2. Export `checkHealth(env: Env): Promise<HealthStepResult>`
+3. Register the check in `backend/src/health/coordinator.ts` → `CODE_CHECKS` array
+4. Assign a `HealthCategory` from the union in `backend/src/health/types.ts`
+
+## Rule: Dynamic Tests via D1
+
+Runtime endpoint monitoring uses the `health_test_definitions` table. CRUD is available at:
+
+- `GET /api/health/tests` — list all
+- `POST /api/health/tests` — create (Zod-validated)
+- `DELETE /api/health/tests/:id` — remove
+
+## Rule: AI Remediation
+
+Failed health checks automatically receive AI-powered remediation hints via `analyzeFailure()`. These are stored in the `ai_suggestion` column of `health_results`.
+
+## Rule: Cron Schedule
+
+Health suite runs weekly via cron `0 3 * * 0` (Sundays 3AM UTC).  
+On-demand runs are available via `POST /api/health/run`.
+
+## Rule: Frontend Sync
+
+The frontend at `/health` **must** display all categories defined in `CATEGORY_META` in `Health.tsx`.
+When adding a new `HealthCategory` to `types.ts`, also add an entry to the frontend registry.

.agent/workflows/run-health-suite.md

@@ -0,0 +1,38 @@
+---
+description: Run the full health suite and review results
+---
+
+# Run Health Suite
+
+// turbo-all
+
+## Steps
+
+1. Trigger the health check via API:
+
+```bash
+curl -s -X POST https://core-github-api.126colby.workers.dev/api/health/run \
+  -H "Content-Type: application/json" \
+  -H "x-api-key: $API_KEY" | jq .
+```
+
+2. Check the latest results:
+
+```bash
+curl -s https://core-github-api.126colby.workers.dev/api/health/latest \
+  -H "x-api-key: $API_KEY" | jq '.results[] | {category, name, status, ai_suggestion}'
+```
+
+3. View run history:
+
+```bash
+curl -s "https://core-github-api.126colby.workers.dev/api/health/history?limit=5" \
+  -H "x-api-key: $API_KEY" | jq '.runs[] | {id: .run.id, status: .run.status, created: .run.created_at}'
+```
+
+4. List dynamic test definitions:
+
+```bash
+curl -s https://core-github-api.126colby.workers.dev/api/health/tests \
+  -H "x-api-key: $API_KEY" | jq .
+```

.github/workflows/daily-trends.yml

@@ -6,7 +6,7 @@ on:
 
 jobs:
   hunt:
-    name: Fetch Trends & Updates
+    name: Fetch Trends & Curate via AI
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -17,54 +17,58 @@ jobs:
           python-version: "3.11"
 
       - name: Install dependencies
-        run: pip install requests pygithub openai
+        run: pip install requests pygithub litellm pydantic
 
-      - name: Run Hunter Script
+      - name: Run Hunter & AI Curation Script
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }} # Optional: if you want AI summarization
-          WORKER_API_URL: "https://core-github-api.hacolby.workers.dev/upsert/daily-trends"
+          CF_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+          CF_GATEWAY_ID: ${{ secrets.CLOUDFLARE_GATEWAY_ID }}
+          CF_API_TOKEN: ${{ secrets.CLOUDFLARE_AI_GATEWAY_TOKEN }} 
+          WORKER_API_URL: ${{ secrets.WORKER_API_URL_BASE }}/upsert/daily-trends
           WORKER_API_KEY: ${{ secrets.WORKER_API_KEY }}
         run: |
-          cat <<EOF > hunter.py
+          cat << 'EOF' > hunter.py
           import os
           import requests
           import json
           from datetime import datetime, timedelta
           from github import Github
+          from pydantic import BaseModel
+          from litellm import completion
 
-          def main():
-              g = Github(os.environ["GITHUB_TOKEN"])
-              worker_url = os.environ["WORKER_API_URL"]
-              worker_secret = os.environ["WORKER_API_KEY"]
-              
-              # 1. Get User's Existing Stars (to avoid duplicates)
-              # We optimize by only fetching the IDs
+          # --- 1. Define the Structured Output Schema ---
+          class CuratedRepo(BaseModel):
+              name: str
+              url: str
+              category: str
+              why_its_interesting: str
+              innovation_score: int
+
+          class DailyReport(BaseModel):
+              trend_summary: str
+              top_picks: list[CuratedRepo]
+
+          def get_raw_trends(g):
+              # Get User's Existing Stars (to avoid duplicates)
+              # Note: PyGithub get_starred() can be slow if you have thousands of stars.
               me = g.get_user("${{ github.repository_owner }}")
               starred_ids = set()
               print("Fetching user stars...")
               for repo in me.get_starred():
                   starred_ids.add(repo.id)
 
-              # 2. Define Search Queries
               date_since = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d')
               queries = [
                   f"language:typescript created:>{date_since} sort:stars",
                   f"language:python created:>{date_since} sort:stars",
                   f"topic:google-apps-script created:>{date_since}",
                   f"topic:cloudflare-workers created:>{date_since}"
               ]
-
-              # 3. Define Watched Orgs for "New Releases"
-              watched_orgs = ["cloudflare", "openai", "google-gemini", "langchain-ai"]
               
-              results = {
-                  "date": datetime.now().isoformat(),
-                  "trending": [],
-                  "org_updates": []
-              }
+              watched_orgs = ["cloudflare", "openai", "google-gemini", "langchain-ai"]
+              raw_repos = []
 
-              # Execute Searches
               print("Scanning for trending repos...")
               for q in queries:
                   repos = g.search_repositories(query=q)
@@ -73,47 +77,83 @@ jobs:
                       if count >= 10: break # Top 10 per category
                       if repo.id in starred_ids: continue
                       
-                      results["trending"].append({
+                      raw_repos.append({
                           "name": repo.full_name,
-                          "description": repo.description,
-                          "stars": repo.stargazers_count,
+                          "description": repo.description or "No description",
                           "url": repo.html_url,
-                          "language": repo.language,
                           "category": q.split(" ")[0]
                       })
                       count += 1
 
-              # Execute Org Watch
               print("Scanning watched orgs...")
               for org_name in watched_orgs:
                   try:
                       org = g.get_organization(org_name)
-                      # check recent repos
                       for repo in org.get_repos(sort="created", direction="desc"):
                           if (datetime.now() - repo.created_at).days > 30: break
-                          results["org_updates"].append({
-                              "type": "new_repo",
-                              "org": org_name,
-                              "name": repo.name,
+                          raw_repos.append({
+                              "name": repo.full_name,
+                              "description": repo.description or "No description",
                               "url": repo.html_url,
-                              "description": repo.description
+                              "category": "org_watch"
                           })
                   except Exception as e:
                       print(f"Skipping {org_name}: {e}")
 
-              # 4. Post to Worker
-              print(f"Found {len(results['trending'])} trending and {len(results['org_updates'])} org updates.")
-              headers = {
-                  "Content-Type": "application/json",
-                  "X-API-Key": worker_secret,
-                  "User-Agent": "github-actions/hunter"
-              }
-              resp = requests.post(worker_url, json=results, headers=headers)
-              resp.raise_for_status()
-              print("Successfully uploaded to Worker.")
+              return raw_repos
+
+          def curate_with_ai(raw_repos):
+              print(f"Sending {len(raw_repos)} repos to Cloudflare AI Gateway for curation...")
+              
+              api_base = f"https://gateway.ai.cloudflare.com/v1/{os.environ['CF_ACCOUNT_ID']}/{os.environ['CF_GATEWAY_ID']}/workers-ai/v1"
+              
+              prompt = f"Review the following list of newly created repositories. Select the top 5 most innovative or interesting ones, and provide a brief summary of today's trends.\n\nData: {json.dumps(raw_repos)}"
+
+              response = completion(
+                  model="openai/@cf/openai/gpt-oss-120b",
+                  api_base=api_base,
+                  api_key=os.environ["CF_API_TOKEN"],
+                  messages=[
+                      {"role": "system", "content": "You are an expert developer curating daily tech trends. Return ONLY valid JSON matching the requested schema."},
+                      {"role": "user", "content": prompt}
+                  ],
+                  response_format=DailyReport,
+                  max_tokens=4096,
+                  extra_body={"reasoning": {"effort": "high"}}
+              )
+
+              return response.choices[0].message.content
+
+          def main():
+              g = Github(os.environ["GITHUB_TOKEN"])
+              
+              # 1. Fetch raw data from GitHub
+              raw_repos = get_raw_trends(g)
+              
+              # 2. Curate using Cloudflare Workers AI + LiteLLM
+              ai_curated_json_str = curate_with_ai(raw_repos)
+              
+              # 3. Post to Worker
+              worker_url = os.environ.get("WORKER_API_URL")
+              if worker_url:
+                  print("Posting curated trends to Worker API...")
+                  
+                  # Parse string to dict to ensure valid JSON payload
+                  payload = json.loads(ai_curated_json_str)
+                  payload["date"] = datetime.now().isoformat()
+                  
+                  headers = {
+                      "Content-Type": "application/json",
+                      "X-API-Key": os.environ["WORKER_API_KEY"],
+                      "User-Agent": "github-actions/hunter"
+                  }
+                  
+                  resp = requests.post(worker_url, json=payload, headers=headers)
+                  resp.raise_for_status()
+                  print("Successfully uploaded to Worker.")
 
           if __name__ == "__main__":
               main()
           EOF
 
-          python hunter.py
+          python hunter.py

.github/workflows/deep-research.yml

@@ -16,9 +16,15 @@ jobs:
       - name: Run Research Agent
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
           PAYLOAD: ${{ toJSON(github.event.client_payload) }}
+          
+          # GitHub & Worker Auth
+          CF_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+          CF_GATEWAY_ID: ${{ secrets.CLOUDFLARE_GATEWAY_ID }}
+          CF_API_TOKEN: ${{ secrets.CLOUDFLARE_AI_GATEWAY_TOKEN }}
+          WORKER_API_URL: ${{ secrets.WORKER_API_URL_BASE }}
           WORKER_API_KEY: ${{ secrets.WORKER_API_KEY }}
+
         run: |
           cat <<EOF > agent.py
           import os

.github/workflows/litellm-agent.yml

@@ -0,0 +1,109 @@
+name: LiteLLM Deep Research Agent
+on:
+  workflow_dispatch:
+    inputs:
+      query:
+        description: 'Research target (e.g., astro shadcn assistant-ui)'
+        required: true
+        default: 'astro shadcn assistant-ui'
+
+jobs:
+  research:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+          
+      - name: Install Dependencies
+        # Install LiteLLM and Pydantic for structured outputs
+        run: pip install litellm pydantic requests
+
+      - name: Run LiteLLM Gateway Agent
+        env:
+          # Add these to your GitHub Repo Secrets
+          CF_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+          CF_GATEWAY_ID: ${{ secrets.CLOUDFLARE_GATEWAY_ID }}
+          CF_API_TOKEN: ${{ secrets.CLOUDFLARE_AI_GATEWAY_TOKEN }}
+          WORKER_API_URL: ${{ secrets.WORKER_API_URL_BASE }}/upsert/daily-trends
+          WORKER_API_KEY: ${{ secrets.WORKER_API_KEY }}
+          QUERY: ${{ github.event.inputs.query }}
+        run: |
+          cat << 'EOF' > agent.py
+          import os
+          import json
+          import requests
+          from pydantic import BaseModel
+          from litellm import completion
+
+          # 1. Define your exact structured output using Pydantic
+          class RepoAnalysis(BaseModel):
+              is_relevant: bool
+              ai_features_found: list[str]
+              summary: str
+              confidence_score: float
+
+          def main():
+              account_id = os.environ["CF_ACCOUNT_ID"]
+              gateway_id = os.environ["CF_GATEWAY_ID"]
+              api_token = os.environ["CF_API_TOKEN"]
+              query = os.environ["QUERY"]
+
+              # 2. Format the Cloudflare AI Gateway URL
+              # Note: We use the /workers-ai/v1 endpoint to enable OpenAI compatibility
+              api_base = f"https://gateway.ai.cloudflare.com/v1/{account_id}/{gateway_id}/workers-ai/v1"
+
+              print(f"Executing Deep Research analysis for: {query}")
+
+              # 3. Call the model using LiteLLM
+              response = completion(
+                  # The 'openai/' prefix tells LiteLLM to treat this custom endpoint exactly like OpenAI
+                  model="openai/@cf/openai/gpt-oss-120b",
+                  api_base=api_base,
+                  api_key=api_token,
+                  messages=[
+                      {"role": "system", "content": "You are a code analyzer. Extract structured data from the provided repository description. You must strictly adhere to the requested JSON schema."},
+                      {"role": "user", "content": f"Analyze this repository based on the search query: '{query}'."}
+                  ],
+                  
+                  # 4. Enforce Structured Output
+                  # LiteLLM automatically converts this Pydantic class into JSON Schema for Cloudflare
+                  response_format=RepoAnalysis,
+                  
+                  # 5. Reasoning Tokens Configuration
+                  # Allocate 4096 tokens and force 'high' effort to simulate a "minimum" reasoning constraint
+                  max_tokens=4096,
+                  extra_body={
+                      "reasoning": {
+                          "effort": "high"
+                      }
+                  }
+              )
+
+              # 6. Extract and validate the response
+              # The model returns a stringified JSON object matching our Pydantic schema
+              raw_json_str = response.choices[0].message.content
+              print("\n--- AI Analysis Result ---")
+              print(raw_json_str)
+
+              # 7. Post the verified data in a batch to your Cloudflare Worker API
+              worker_url = os.environ.get("WORKER_API_URL")
+              if worker_url:
+                  print(f"Posting data to Worker API: {worker_url}...")
+                  # We parse it just to ensure it's valid JSON before sending
+                  payload = json.loads(raw_json_str) 
+                  
+                  requests.post(
+                      worker_url, 
+                      json={"query": query, "results": payload}, 
+                      headers={"X-API-Key": os.environ.get("WORKER_API_KEY", "")}
+                  )
+                  print("Data successfully synced to Worker.")
+
+          if __name__ == "__main__":
+              main()
+          EOF
+          
+          python agent.py