# Install repomix globally
npm install -g repomix

# Verify installation
repomix --version

{
  "output": {
    "style": "xml",
    "filePath": "codex-architecture-sync.xml",
    "headerText": "_codex_ Repository Consolidation for AI Analysis",
    "instructionFilePath": "repomix-instruction.md",
    "removeComments": false,
    "removeEmptyLines": false,
    "topFilesLength": 20,
    "showLineNumbers": true,
    "compress": true
  },
  "include": [
    "src/**",
    "tests/**",
    ".github/**",
    "tools/**",
    "monitoring/**",
    "services/**",
    "docs/**",
    "*.md",
    "*.py",
    "*.yml",
    "*.yaml",
    "*.toml",
    "*.json"
  ],
  "ignore": {
    "useGitignore": true,
    "useDefaultPatterns": true,
    "customPatterns": [
      ".env*",
      "*.env",
      ".config.local",
      "config.local.json",
      "secrets.yml",
      "secrets.yaml",
      "node_modules/**",
      ".git/**",
      "*.pyc",
      "__pycache__/**",
      "*.so",
      "*.dylib",
      "*.dll",
      "*.bin",
      "*.exe",
      "target/**",
      "dist/**",
      "build/**",
      ".pytest_cache/**",
      ".mypy_cache/**",
      ".hypothesis/**",
      "*.log",
      "*.sqlite",
      "*.db",
      "*.sql",
      ".vscode/**",
      ".idea/**",
      "*.key",
      "*.pem",
      "*.crt",
      "*.p12",
      "*.pfx",
      "*.jks",
      "*.keystore",
      "*.swp",
      "*.swo",
      "*~",
      ".DS_Store",
      "Thumbs.db",
      "coverage/**",
      "htmlcov/**",
      ".coverage",
      "*.whl",
      "*.egg-info/**"
    ]
  },
  "security": {
    "enableSecretDetection": true
  },
  "compress": {
    "enabled": true,
    "targetTokenCount": 500000
  }
}

# _codex_ Repository Architecture & Guidelines

## Project Overview

_codex_ is an advanced AI-powered development automation platform featuring:
- Autonomous code remediation
- Real-time CI/CD monitoring
- ML-based threat detection
- Self-healing workflows
- Cognitive decision-making engine

## Architecture Principles

### 1. Modular Design
- Each module is self-contained with clear boundaries
- Inter-module communication via well-defined interfaces
- Dependency injection for testability

### 2. Security First
- No credentials in code (use environment variables)
- All inputs validated before processing
- Secrets detected and blocked pre-commit
- Multi-layer defense in depth

### 3. Test-Driven Development
- Minimum 85% code coverage
- Unit tests for all business logic
- Integration tests for critical paths
- Deterministic test execution

### 4. Documentation Standards
- Docstrings for all public APIs
- Type hints for all function signatures
- README files in each major directory
- Architecture diagrams in Mermaid format

## Key Modules

### Auto-Remediation (`tools/auto_remediation/`)
- Intelligent fix generation for security vulnerabilities
- AST-based code analysis and transformation
- PR generation with testing and verification

### CI Diagnostic (`/github/agents/ci-diagnostic-agent/`)
- Automated CI failure analysis
- Root cause determination with confidence scoring
- Auto-fix suggestions for common patterns

### Monitoring (`monitoring/`)
- Real-time metrics collection from GitHub APIs
- Dashboard for CI/CD and security visualization
- Alert generation for critical issues

### Security Scanning (`semgrep_rules/`, `.github/workflows/security-*.yml`)
- Custom Semgrep rules for _codex_-specific patterns
- CodeQL analysis for vulnerability detection
- Pre-commit hooks for prevention

## Coding Conventions

### Python
- Black formatter (line length: 100)
- Ruff linter with strict settings
- Type hints required for public APIs
- Docstrings in Google style

### Rust
- cargo fmt for formatting
- cargo clippy with deny warnings
- Explicit error handling (no unwrap in production)
- Documentation comments for public items

### YAML (Workflows)
- 2-space indentation
- Descriptive job and step names
- Comments for complex logic
- Secrets via GitHub Secrets only

## Critical Paths to Analyze

1. **Auto-Remediation Pipeline**
   - `tools/auto_remediation/fix_generator.py` → generates fixes
   - `tools/auto_remediation/verifier.py` → validates fixes
   - `tools/auto_remediation/pr_generator.py` → creates PRs

2. **CI Health Monitoring**
   - `monitoring/metrics_collector.py` → collects metrics
   - `monitoring/dashboard_api.py` → serves dashboard
   - `.github/workflows/ci-diagnostic-automation.yml` → diagnostic workflow

3. **Security Enforcement**
   - `.pre-commit-config.yaml` → pre-commit hooks
   - `semgrep_rules/` → custom security rules
   - `.github/workflows/security-suite.yml` → security scanning

## AI Architect Focus Areas

When analyzing this codebase:

1. **Validate Modular Boundaries**
   - Check for circular dependencies
   - Identify God classes (>500 LOC)
   - Verify dependency injection usage

2. **Security Audit**
   - Scan for unvalidated inputs
   - Check SQL/command injection risks
   - Validate authentication patterns

3. **Performance Analysis**
   - Identify N+1 query patterns
   - Check for inefficient algorithms
   - Validate caching strategies

4. **Code Quality**
   - Calculate cyclomatic complexity
   - Detect code duplication
   - Verify error handling completeness

5. **Test Coverage**
   - Identify untested code paths
   - Validate test determinism
   - Check for flaky tests

# Security Sensitive Files
.env
.env.*
*.env
.config.local
config.local.json
secrets.yml
secrets.yaml
*.key
*.pem
*.crt
*.p12
*.pfx
*.jks
*.keystore

# Build Artifacts
node_modules/
dist/
build/
target/
*.pyc
__pycache__/
*.so
*.dylib
*.dll
*.bin
*.exe

# Test Artifacts
.pytest_cache/
.mypy_cache/
.hypothesis/
.coverage
coverage/
htmlcov/
*.whl
*.egg-info/

# Logs & Databases
*.log
*.sqlite
*.db
*.sql

# IDE & OS
.vscode/
.idea/
.DS_Store
Thumbs.db
*.swp
*.swo
*~

# Git
.git/
.github/secrets/

# Large Binary Files
*.png
*.jpg
*.jpeg
*.gif
*.pdf
*.zip
*.tar.gz
*.mp4
*.mov

# Run repomix with configuration
repomix --config repomix.config.json

# Check output size
ls -lh codex-architecture-sync.xml

# Validate XML structure
xmllint --noout codex-architecture-sync.xml

# Check for secrets (should be none)
grep -i "api.key\|password\|secret" codex-architecture-sync.xml

{
  "compress": {
    "enabled": true,
    "targetTokenCount": 300000,
    "preserveStructure": true,
    "keepComments": false
  }
}

# Install gcloud CLI if not present
curl https://sdk.cloud.google.com | bash
exec -l $SHELL
gcloud init

# Create project
gcloud projects create codex-notebooklm-sync \
  --name="Codex NotebookLM Sync" \
  --set-as-default

# Enable Drive API
gcloud services enable drive.googleapis.com

# Create service account
gcloud iam service-accounts create notebooklm-sync \
  --display-name="NotebookLM Sync Service Account" \
  --description="Automated sync for _codex_ repository"

# Get service account email
SA_EMAIL=$(gcloud iam service-accounts list \
  --filter="displayName:NotebookLM Sync Service Account" \
  --format="value(email)")

echo "Service Account: $SA_EMAIL"

# Create and download key
gcloud iam service-accounts keys create ~/notebooklm-sync-key.json \
  --iam-account=$SA_EMAIL

# Display key (for GitHub Secrets)
cat ~/notebooklm-sync-key.json

# Create dedicated folder in Drive (manual step via web UI)
# Note the Folder ID from URL: https://drive.google.com/drive/folders/[FOLDER_ID]

# Share folder with service account (manual step via web UI)
# Share with: [SA_EMAIL] with Editor permissions

name: NotebookLM Live Sync

on:
  push:
    branches:
      - main
      - develop
    paths:
      - 'src/**'
      - 'tools/**'
      - 'monitoring/**'
      - 'services/**'
      - '.github/**'
      - 'tests/**'
      - '**.md'
      - '**.py'
  workflow_dispatch:
    inputs:
      force_sync:
        description: 'Force full synchronization'
        required: false
        default: 'false'
  schedule:
    # Daily backup sync at 00:00 UTC
    - cron: '0 0 * * *'

permissions:
  contents: read
  id-token: write

env:
  OUTPUT_FILE: codex-architecture-sync.xml

jobs:
  consolidate-and-sync:
    name: Repository Consolidation & Drive Sync
    runs-on: ubuntu-latest
    timeout-minutes: 15

    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 1  # Shallow clone for speed

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'
          cache: 'npm'

      - name: Install Repomix
        run: |
          npm install -g repomix
          repomix --version

      - name: Generate Repository Consolidation
        id: consolidate
        run: |
          echo "::group::Running Repomix"
          repomix --config repomix.config.json
          echo "::endgroup::"

          # Validate output
          if [ ! -f "$OUTPUT_FILE" ]; then
            echo "❌ Consolidation failed: Output file not created"
            exit 1
          fi

          FILE_SIZE=$(stat -f%z "$OUTPUT_FILE" 2>/dev/null || stat -c%s "$OUTPUT_FILE")
          FILE_SIZE_MB=$(echo "scale=2; $FILE_SIZE / 1048576" | bc)

          echo "✅ Consolidation complete"
          echo "📦 File size: ${FILE_SIZE_MB}MB"
          echo "file_size_mb=${FILE_SIZE_MB}" >> $GITHUB_OUTPUT

          # Validate XML structure
          if command -v xmllint &> /dev/null; then
            xmllint --noout "$OUTPUT_FILE" && echo "✅ XML is well-formed"
          fi

      - name: Security Scan - Secretlint
        id: secretlint
        continue-on-error: true
        run: |
          echo "::group::Installing Secretlint"
          npm install -g @secretlint/secretlint @secretlint/secretlint-rule-preset-recommend
          echo "::endgroup::"

          echo "::group::Scanning for Secrets"
          if secretlint "$OUTPUT_FILE"; then
            echo "✅ No secrets detected by Secretlint"
            echo "secrets_found=false" >> $GITHUB_OUTPUT
          else
            echo "⚠️ Secretlint found potential secrets"
            echo "secrets_found=true" >> $GITHUB_OUTPUT
          fi
          echo "::endgroup::"

      - name: Security Scan - detect-secrets
        id: detect_secrets
        run: |
          echo "::group::Installing detect-secrets"
          pip install detect-secrets
          echo "::endgroup::"

          echo "::group::Scanning for Secrets"
          if detect-secrets scan "$OUTPUT_FILE" --baseline .secrets.baseline; then
            echo "✅ No secrets detected by detect-secrets"
            echo "secrets_found=false" >> $GITHUB_OUTPUT
          else
            echo "❌ detect-secrets found secrets!"
            echo "secrets_found=true" >> $GITHUB_OUTPUT
            exit 1
          fi
          echo "::endgroup::"

      - name: Fail if Secrets Detected
        if: steps.secretlint.outputs.secrets_found == 'true' || steps.detect_secrets.outputs.secrets_found == 'true'
        run: |
          echo "❌ SECURITY ALERT: Secrets detected in consolidation output!"
          echo "Workflow terminated to prevent credential exposure."
          exit 1

      - name: Upload to Google Drive
        id: drive_upload
        uses: satackey/action-google-drive@v1
        with:
          skicka-tokencache-json: ${{ secrets.GDRIVE_SERVICE_ACCOUNT_JSON }}
          upload-from: ${{ env.OUTPUT_FILE }}
          upload-to: /codex-sync/${{ env.OUTPUT_FILE }}
          google-client-id: ${{ secrets.GOOGLE_CLIENT_ID }}
          google-client-secret: ${{ secrets.GOOGLE_CLIENT_SECRET }}
          remove-outdated: true

      - name: Notify Sync Complete
        if: success()
        env:
          WEBHOOK_URL: ${{ secrets.NOTEBOOKLM_WEBHOOK_URL }}
        run: |
          if [ -n "$WEBHOOK_URL" ]; then
            curl -X POST "$WEBHOOK_URL" \
              -H "Content-Type: application/json" \
              -d "{
                \"status\": \"success\",
                \"timestamp\": \"$(date -Iseconds)\",
                \"file_size_mb\": \"${{ steps.consolidate.outputs.file_size_mb }}\",
                \"commit_sha\": \"${{ github.sha }}\",
                \"commit_message\": \"$(git log -1 --pretty=%B | head -1)\"
              }"
            echo "✅ Notification sent"
          else
            echo "ℹ️ Webhook URL not configured, skipping notification"
          fi

      - name: Upload Artifact (Backup)
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: codex-sync-${{ github.sha }}
          path: ${{ env.OUTPUT_FILE }}
          retention-days: 7

      - name: Summary
        if: always()
        run: |
          echo "## 📊 Sync Summary" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "- **File Size**: ${{ steps.consolidate.outputs.file_size_mb }}MB" >> $GITHUB_STEP_SUMMARY
          echo "- **Secrets Detected**: ${{ steps.detect_secrets.outputs.secrets_found }}" >> $GITHUB_STEP_SUMMARY
          echo "- **Drive Upload**: ${{ steps.drive_upload.outcome }}" >> $GITHUB_STEP_SUMMARY
          echo "- **Commit**: ${{ github.sha }}" >> $GITHUB_STEP_SUMMARY
          echo "- **Timestamp**: $(date -Iseconds)" >> $GITHUB_STEP_SUMMARY

# Trigger workflow manually
gh workflow run notebooklm-sync.yml

# Watch workflow execution
gh run watch

# Check output
gh run view --log

- name: Cache Repomix
  uses: actions/cache@v4
  with:
    path: ~/.npm
    key: ${{ runner.os }}-repomix-${{ hashFiles('repomix.config.json') }}
    restore-keys: |
      ${{ runner.os }}-repomix-

- name: Cache Python Dependencies
  uses: actions/cache@v4
  with:
    path: ~/.cache/pip
    key: ${{ runner.os }}-pip-detect-secrets
    restore-keys: |
      ${{ runner.os }}-pip-

# Create skills directory if not exists
mkdir -p ~/.claude/skills

# Clone the skill repository
git clone https://github.com/PleasePrompto/notebooklm-skill ~/.claude/skills/notebooklm

# Navigate to skill directory
cd ~/.claude/skills/notebooklm

# Install dependencies
pip install -r requirements.txt

# Verify installation
python scripts/run.py --version

# Run authentication setup
python scripts/run.py auth_manager.py setup

# Follow interactive prompts:
# 1. Opens browser for Google OAuth
# 2. Select Google account
# 3. Grant permissions to access Drive
# 4. Returns to terminal with success message

# Verify authentication
python scripts/run.py auth_manager.py verify

# Add notebook using URL
python scripts/run.py notebook_manager.py add \
  --url "https://notebooklm.google.com/notebook/[NOTEBOOK_ID]" \
  --name "codex_architecture" \
  --description "_codex_ repository comprehensive analysis"

# Verify notebook added
python scripts/run.py notebook_manager.py list

# Test query
python scripts/run.py notebook_manager.py query \
  --notebook "codex_architecture" \
  --question "What is the architecture of the auto-remediation system?"

# Enable automatic context loading
python scripts/run.py config.py set --auto-context true

# Set context window size
python scripts/run.py config.py set --context-window 128000

# Configure caching
python scripts/run.py config.py set --enable-cache true
python scripts/run.py config.py set --cache-ttl 3600

# View all configuration
python scripts/run.py config.py show

@architect Query the _codex_ architecture

Test queries:
1. What are the main modules in _codex_?
2. Explain the auto-remediation pipeline
3. How does the CI diagnostic agent work?
4. What security measures are implemented?
5. Show me the dependency structure of monitoring module

{
  "commands": [
    {
      "name": "health_check",
      "trigger": "@architect health check",
      "prompt": "Perform a comprehensive health check of the _codex_ repository architecture. Analyze: 1) Module dependencies, 2) Security posture, 3) Code quality metrics, 4) Test coverage, 5) Technical debt. Provide a structured report with scores (0-100) for each category.",
      "notebook": "codex_architecture"
    },
    {
      "name": "dependency_analysis",
      "trigger": "@architect analyze dependencies",
      "prompt": "Generate a dependency graph for the _codex_ repository. Identify: 1) Circular dependencies, 2) Tightly coupled modules, 3) God classes, 4) Unused dependencies. Output as Mermaid diagram.",
      "notebook": "codex_architecture"
    },
    {
      "name": "security_audit",
      "trigger": "@architect security audit",
      "prompt": "Conduct a security audit of _codex_. Check for: 1) Unvalidated inputs, 2) Injection vulnerabilities, 3) Weak crypto, 4) Authentication issues, 5) Secrets in code. Prioritize findings by severity.",
      "notebook": "codex_architecture"
    },
    {
      "name": "refactoring_suggestions",
      "trigger": "@architect suggest refactoring for {module}",
      "prompt": "Analyze the {module} module in _codex_ and suggest refactoring improvements. Consider: 1) Code complexity, 2) Duplication, 3) Performance, 4) Maintainability. Provide specific code examples.",
      "notebook": "codex_architecture"
    },
    {
      "name": "test_coverage",
      "trigger": "@architect check test coverage",
      "prompt": "Analyze test coverage for _codex_. Identify: 1) Untested code paths, 2) Missing edge cases, 3) Flaky tests, 4) Test duplication. Suggest new test cases for critical paths.",
      "notebook": "codex_architecture"
    }
  ]
}

name: AI Architect Health Check

on:
  schedule:
    # Weekly health check every Monday at 09:00 UTC
    - cron: '0 9 * * 1'
  workflow_dispatch:
    inputs:
      focus_area:
        description: 'Specific area to analyze'
        required: false
        type: choice
        options:
          - 'all'
          - 'architecture'
          - 'security'
          - 'performance'
          - 'code_quality'
          - 'dependencies'
        default: 'all'

permissions:
  contents: write
  issues: write
  pull-requests: write

jobs:
  health-check:
    name: Run AI Architect Analysis
    runs-on: ubuntu-latest
    timeout-minutes: 30

    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install Dependencies
        run: |
          pip install openai anthropic python-dotenv

      - name: Run Health Check via Claude API
        id: health_check
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          FOCUS_AREA: ${{ github.event.inputs.focus_area || 'all' }}
        run: |
          python scripts/ai_architect_check.py \
            --focus "$FOCUS_AREA" \
            --output health_report.json \
            --format json

      - name: Generate Markdown Report
        run: |
          python scripts/generate_health_report.py \
            --input health_report.json \
            --output HEALTH_REPORT.md

      - name: Create Issue for Critical Findings
        if: steps.health_check.outputs.critical_count > 0
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const report = fs.readFileSync('HEALTH_REPORT.md', 'utf8');

            github.rest.issues.create({
              owner: context.repo.owner,
              repo: context.repo.repo,
              title: `🚨 AI Architect: Critical Issues Detected`,
              body: report,
              labels: ['ai-architect', 'critical', 'technical-debt']
            });

      - name: Commit Health Report
        run: |
          git config user.name "AI Architect Bot"
          git config user.email "ai-architect@codex.bot"
          git add HEALTH_REPORT.md
          git commit -m "chore: update AI architect health report [skip ci]" || echo "No changes"
          git push

      - name: Upload Artifacts
        uses: actions/upload-artifact@v4
        with:
          name: health-check-report-${{ github.run_number }}
          path: |
            health_report.json
            HEALTH_REPORT.md
          retention-days: 90

#!/usr/bin/env python3
"""AI Architect Health Check Script"""

import argparse
import json
import os
import sys
from anthropic import Anthropic

def load_architect_prompt():
    """Load architect system prompt."""
    with open('docs/ai-architect-prompt.md', 'r') as f:
        return f.read()

def perform_health_check(focus_area='all'):
    """Execute health check via Claude API."""
    client = Anthropic(api_key=os.environ['ANTHROPIC_API_KEY'])

    system_prompt = load_architect_prompt()

    user_prompt = f"""
    Perform a comprehensive health check of the _codex_ repository.
    Focus area: {focus_area}

    Analyze the complete codebase structure and provide:
    1. Overall health score (0-100)
    2. Category-specific scores
    3. List of critical issues
    4. Actionable recommendations
    5. Dependency graph (if applicable)

    Output format: Structured JSON matching the health report schema.
    """

    message = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=16000,
        system=system_prompt,
        messages=[
            {"role": "user", "content": user_prompt}
        ]
    )

    return message.content[0].text

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--focus', default='all')
    parser.add_argument('--output', required=True)
    parser.add_argument('--format', default='json')
    args = parser.parse_args()

    result = perform_health_check(args.focus)

    with open(args.output, 'w') as f:
        f.write(result)

    # Parse for critical issues
    try:
        data = json.loads(result)
        critical_count = len([i for i in data.get('critical_issues', []) if i.get('severity') == 'critical'])
        print(f"::set-output name=critical_count::{critical_count}")
    except:
        print("::set-output name=critical_count::0")

if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""Generate Markdown health report from JSON."""

import argparse
import json
from datetime import datetime

TEMPLATE = """# AI Architect Health Report

**Generated**: {timestamp}  
**Overall Health**: {overall_health}/100 {status_emoji}

## Summary

{summary}

## Category Scores

| Category | Score | Status | Issues |
|----------|-------|--------|--------|
{category_table}

## Critical Issues

{critical_issues}

## Recommendations

{recommendations}

## Dependency Analysis

{dependency_graph}

---

*Generated by AI Architect Bot - Powered by Cognitive Brain*
"""

def generate_report(data):
    """Generate markdown report."""
    timestamp = datetime.now().isoformat()
    overall_health = data['overall_health']

    # Determine status emoji
    if overall_health >= 95:
        status_emoji = "✅"
    elif overall_health >= 85:
        status_emoji = "🟢"
    elif overall_health >= 70:
        status_emoji = "🟡"
    else:
        status_emoji = "🔴"

    # Build category table
    category_rows = []
    for cat, info in data['categories'].items():
        score = info['score']
        issue_count = len(info['issues'])
        status = "✅" if score >= 90 else "⚠️" if score >= 70 else "❌"
        category_rows.append(f"| {cat.title()} | {score}/100 | {status} | {issue_count} |")

    # Format critical issues
    critical_items = []
    for issue in data.get('critical_issues', []):
        critical_items.append(f"### {issue['title']}\n\n{issue['description']}\n\n**Impact**: {issue['impact']}\n")

    # Format recommendations
    rec_items = []
    for i, rec in enumerate(data.get('recommendations', []), 1):
        rec_items.append(f"{i}. **{rec['title']}** - {rec['description']}")

    return TEMPLATE.format(
        timestamp=timestamp,
        overall_health=overall_health,
        status_emoji=status_emoji,
        summary=data.get('summary', 'No summary provided'),
        category_table='\n'.join(category_rows),
        critical_issues='\n\n'.join(critical_items) or 'No critical issues found ✅',
        recommendations='\n'.join(rec_items) or 'No recommendations at this time ✅',
        dependency_graph=f"```mermaid\n{data.get('dependency_graph', 'graph TB')}\n```"
    )

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--input', required=True)
    parser.add_argument('--output', required=True)
    args = parser.parse_args()

    with open(args.input, 'r') as f:
        data = json.load(f)

    report = generate_report(data)

    with open(args.output, 'w') as f:
        f.write(report)

if __name__ == '__main__':
    main()

# Run health check locally
ANTHROPIC_API_KEY=sk-... python scripts/ai_architect_check.py \
  --focus all \
  --output health_report.json

# Generate report
python scripts/generate_health_report.py \
  --input health_report.json \
  --output HEALTH_REPORT.md

# View report
cat HEALTH_REPORT.md