chore: resolve merge conflicts and update @openai/agents peer dependencies

Author: jmbish04

.github/scripts/hygeine/audit_drizzle_schema.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+import os
+import re
+import sys
+import argparse
+from collections import defaultdict
+from datetime import datetime
+
+def get_ts_files(root_dir):
+    """Recursively find all TypeScript files, ignoring build/module directories."""
+    ignore_dirs = {'node_modules', 'dist', '.git', '.wrangler', '.vscode', 'drizzle', '.github'}
+    ts_files = []
+    
+    for dirpath, dirnames, filenames in os.walk(root_dir):
+        # Modify dirnames in-place to skip ignored directories
+        dirnames[:] = [d for d in dirnames if d not in ignore_dirs]
+        for filename in filenames:
+            if filename.endswith('.ts') or filename.endswith('.tsx'):
+                ts_files.append(os.path.join(dirpath, filename))
+                
+    return ts_files
+
+def main():
+    # Generate timestamp in yyyy-mm-dd 12h time format (e.g., 2026-03-13-06-44pm)
+    now_str = datetime.now().strftime("%Y-%m-%d-%I-%M%p").lower()
+    filename = f"drizzle-schema-report-{now_str}.md"
+    
+    # User's custom report location (preserving original spelling of 'hygeine')
+    default_report_path = os.path.join(os.getcwd(), "scripts", "reports", "hygeine", filename)
+    
+    parser = argparse.ArgumentParser(description="Analyze Drizzle ORM schema and D1 usage.")
+    parser.add_argument("--output", default=default_report_path, help="Output Markdown file path")
+    args = parser.parse_args()
+
+    # Ensure the target directory exists before executing the file scan
+    os.makedirs(os.path.dirname(args.output), exist_ok=True)
+
+    root_dir = os.getcwd()
+    files = get_ts_files(root_dir)
+    
+    tables = []
+    
+    # 1. Extract all Drizzle Table definitions
+    # Matches: export const varName = sqliteTable('tableName', ...)
+    table_regex = re.compile(r"export\s+const\s+([a-zA-Z0-9_]+)\s*=\s*(?:sqliteTable|pgTable|mysqlTable)\(\s*['\"]([^'\"]+)['\"]")
+    
+    for file_path in files:
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                matches = table_regex.findall(content)
+                for var_name, table_name in matches:
+                    rel_path = os.path.relpath(file_path, root_dir)
+                    tables.append({
+                        "var_name": var_name,
+                        "table_name": table_name,
+                        "file": rel_path
+                    })
+        except Exception as e:
+            print(f"Warning: Could not read {file_path}: {e}")
+
+    file_interactions = defaultdict(set)
+    db1_map = defaultdict(set) # For env.DB
+    db2_map = defaultdict(set) # For env.DB_WEBHOOKS
+    
+    # 2. Scan files for table imports and D1 database interactions
+    for file_path in files:
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                
+            rel_path = os.path.relpath(file_path, root_dir)
+            
+            # Look for standard Cloudflare Worker / Hono context bindings
+            uses_db1 = 'env.DB' in content or 'c.env.DB' in content
+            uses_db2 = 'env.DB_WEBHOOKS' in content or 'c.env.DB_WEBHOOKS' in content
+            
+            imported_tables = set()
+            
+            for t in tables:
+                # Regex boundary check for the specific Drizzle table variable
+                var_regex = re.compile(r"\b" + re.escape(t['var_name']) + r"\b")
+                
+                if var_regex.search(content):
+                    imported_tables.add(t['table_name'])
+                    
+                    if uses_db1:
+                        db1_map[t['table_name']].add(rel_path)
+                    if uses_db2:
+                        db2_map[t['table_name']].add(rel_path)
+                        
+            if imported_tables:
+                file_interactions[rel_path] = imported_tables
+                
+        except Exception as e:
+            print(f"Warning: Could not read {file_path}: {e}")
+
+    # 3. Generate the Markdown Report
+    md = ["# Drizzle ORM Schema & D1 Analysis Report\n"]
+    md.append("## Table Names by Database\n")
+    
+    md.append("### env.DB")
+    db1_sorted = sorted(db1_map.keys())
+    if db1_sorted:
+        for t in db1_sorted:
+            md.append(f"- {t}")
+    else:
+        md.append("- *No tables definitively mapped to env.DB yet*")
+        
+    md.append("\n### env.DB_WEBHOOKS")
+    db2_sorted = sorted(db2_map.keys())
+    if db2_sorted:
+        for t in db2_sorted:
+            md.append(f"- {t}")
+    else:
+        md.append("- *No tables definitively mapped to env.DB_WEBHOOKS yet*")
+
+    # Catch AI Slop (Orphaned Tables)
+    all_discovered = sorted(list(set(t['table_name'] for t in tables)))
+    mapped_tables = set(db1_sorted + db2_sorted)
+    unmapped = [t for t in all_discovered if t not in mapped_tables]
+    
+    if unmapped:
+        md.append("\n### Unmapped / Orphaned Schema Tables")
+        md.append("*(Suspicious AI Slop: Defined in code but no CRUD operations with a known D1 env var detected)*")
+        for t in unmapped:
+            md.append(f"- {t}")
+
+    md.append("\n---\n\n## Code Files Interacting with D1 Tables\n")
+    for file_path in sorted(file_interactions.keys()):
+        tables_used = ", ".join(sorted(file_interactions[file_path]))
+        md.append(f"### `{file_path}`")
+        md.append(f"- **Tables Imported:** {tables_used}\n")
+
+    md.append("---\n\n## env.DB d1 db")
+    md.append("| Table Name | Short File Paths |")
+    md.append("|---|---|")
+    if db1_sorted:
+        for t in db1_sorted:
+            paths = ", ".join([f"`{p}`" for p in sorted(db1_map[t])])
+            md.append(f"| **{t}** | {paths} |")
+    else:
+        md.append("| *None Detected* | *N/A* |")
+
+    md.append("\n## env.DB_WEBHOOKS d1 db")
+    md.append("| Table Name | Short File Paths |")
+    md.append("|---|---|")
+    if db2_sorted:
+        for t in db2_sorted:
+            paths = ", ".join([f"`{p}`" for p in sorted(db2_map[t])])
+            md.append(f"| **{t}** | {paths} |")
+    else:
+        md.append("| *None Detected* | *N/A* |")
+
+    # 4. Write to disk
+    try:
+        with open(args.output, 'w', encoding='utf-8') as f:
+            f.write("\n".join(md) + "\n")
+        print(f"✅ Schema analysis complete! Report generated at: {args.output}")
+    except Exception as e:
+        print(f"❌ Failed to write report: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

.github/workflows/drizzle-schema-report.yml

@@ -0,0 +1,44 @@
+name: Drizzle Schema Analysis Report
+
+on:
+  pull_request:
+    paths:
+      - '**/*.ts'
+      - '**/*.tsx'
+  workflow_dispatch: # Allows manual triggering from the Actions tab
+
+jobs:
+  analyze-schema:
+    runs-on: ubuntu-latest
+    name: Generate Schema Report
+    
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+          
+      - name: Ensure Script is Executable
+        run: chmod +x scripts/analyze_drizzle_schema.py
+          
+      - name: Run Schema Analysis
+        run: python scripts/analyze_drizzle_schema.py --output drizzle-schema-report.md
+        
+      - name: Upload Report Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: drizzle-schema-report
+          path: drizzle-schema-report.md
+          retention-days: 14
+
+      # Optional: Fail the PR if unmapped/orphaned tables (AI slop) are detected. 
+      # Remove or comment out if you just want the report without blocking the PR.
+      - name: Check for AI Slop
+        run: |
+          if grep -q "### Unmapped / Orphaned Schema Tables" drizzle-schema-report.md; then
+            echo "::error::Orphaned Drizzle tables detected! Please review the schema for AI slop."
+            exit 1
+          fi

.github/workflows/jules-merge-conflicts.yml

@@ -0,0 +1,86 @@
+name: PR Code Block Merger
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  workflow_dispatch: # Allow manual triggers
+
+jobs:
+  merge-code-blocks:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 30
+
+      - name: Create initial prompt
+        env:
+          USER_PROMPT: |
+            Please analyze the code changes in this Pull Request and merge duplicate or adjacent code blocks where appropriate:
+
+            ## Focus Areas
+
+            1. **Code Duplication & Merging**
+               - Identify duplicated code blocks introduced or existing in the modified files.
+               - Consolidate redundant logic into reusable functions or shared blocks.
+               - Merge adjacent or consecutive blocks that perform similar operations.
+               - Apply DRY principles strictly across the current PR scope.
+
+            2. **Complexity Reduction**
+               - Simplify overly complex functions resulting from merged blocks.
+               - Combine conditionals and reduce nesting where logic overlaps.
+
+            3. **Formatting & Cleanup**
+               - Ensure the newly merged code blocks maintain consistent indentation.
+               - Clean up any orphaned variables or dead code left behind after the merge.
+               - Organize imports if the merged blocks change dependencies.
+
+            Guidelines:
+            - Make incremental, safe refactorings targeted at the PR diff.
+            - Strictly preserve existing functionality and operational behavior.
+            - Group related changes logically and format them cleanly.
+            - Push the refactored, merged code blocks directly to this PR branch.
+
+            Do not make changes if the code blocks cannot be safely merged without altering intended behavior.
+        shell: bash
+        run: |
+          echo "$USER_PROMPT" > prompt.txt
+
+      - name: Save git log
+        shell: bash
+        run: |
+          echo -e '\n\nLog of the last 20 commits (in the format of `git log --stat`):' >> prompt.txt
+          echo '```'         >> prompt.txt
+          git log -20 --stat >> prompt.txt
+          echo '```'         >> prompt.txt
+
+      - name: Assemble Jules payload
+        shell: bash
+        env:
+          STARTING_BRANCH: ${{ github.head_ref || github.ref_name }}
+        run: |
+          jq -n --arg jules_prompt "$(cat prompt.txt)" --arg starting_branch "$STARTING_BRANCH" --arg repo_full_name "${{ github.repository }}" '{
+              "prompt": $jules_prompt,
+              "sourceContext": {
+                "source": "sources/github/\($repo_full_name)",
+                "githubRepoContext": {
+                  "startingBranch": $starting_branch
+                }
+              },
+              "requirePlanApproval": false,
+              "automationMode": "AUTO_CREATE_PR"
+            }' > jules_payload.json
+
+      - name: Invoke Jules API
+        shell: bash
+        run: |
+          curl 'https://jules.googleapis.com/v1alpha/sessions' \
+            -X POST \
+            -H "Content-Type: application/json" \
+            -H "X-Goog-Api-Key: ${{ secrets.JULES_API_KEY }}" \
+            -d @jules_payload.json