crca 1.4.0__py3-none-any.whl

tools/bolt.diy/test-workflows.sh

@@ -0,0 +1,240 @@
+#!/bin/bash
+
+# GitHub Workflow Testing Script
+# This script helps you test the new workflows safely
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Function to print colored output
+print_status() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Check if GitHub CLI is installed
+check_gh_cli() {
+    if ! command -v gh &> /dev/null; then
+        print_error "GitHub CLI (gh) is not installed. Please install it first."
+        echo "Visit: https://cli.github.com/"
+        exit 1
+    fi
+    print_success "GitHub CLI is installed"
+}
+
+# Check if user is authenticated
+check_auth() {
+    if ! gh auth status &> /dev/null; then
+        print_error "Not authenticated with GitHub. Please run: gh auth login"
+        exit 1
+    fi
+    print_success "Authenticated with GitHub"
+}
+
+# Create test branch
+create_test_branch() {
+    print_status "Creating test branch 'workflow-testing'..."
+    
+    if git show-branch workflow-testing &> /dev/null; then
+        print_warning "Branch 'workflow-testing' already exists. Switching to it..."
+        git checkout workflow-testing
+    else
+        git checkout -b workflow-testing
+        git push -u origin workflow-testing
+        print_success "Created and pushed test branch"
+    fi
+}
+
+# Run specific test type
+run_test() {
+    local test_type=$1
+    print_status "Running workflow test: $test_type"
+    
+    gh workflow run "Test Workflows" \
+        --ref workflow-testing \
+        -f test_type="$test_type"
+    
+    print_success "Triggered workflow test: $test_type"
+    print_status "Monitor progress at: https://github.com/$(gh repo view --json owner,name -q '.owner.login + "/" + .name')/actions"
+}
+
+# Monitor latest workflow run
+monitor_run() {
+    print_status "Finding latest workflow run..."
+    
+    local run_id=$(gh run list --workflow="Test Workflows" --limit=1 --json databaseId -q '.[0].databaseId')
+    
+    if [ -n "$run_id" ]; then
+        print_status "Monitoring run ID: $run_id"
+        gh run watch "$run_id"
+    else
+        print_warning "No workflow runs found. Did you trigger a test?"
+    fi
+}
+
+# Create test PR
+create_test_pr() {
+    print_status "Creating test PR..."
+    
+    # Make a small change to trigger workflows
+    echo "# Workflow Testing - $(date)" >> WORKFLOW_TESTING.md
+    git add WORKFLOW_TESTING.md
+    git commit -m "test: trigger workflow validation"
+    git push origin workflow-testing
+    
+    # Create PR
+    gh pr create \
+        --title "Test: Workflow Validation - $(date +%Y-%m-%d)" \
+        --body "🧪 **This is a test PR for workflow validation - DO NOT MERGE**
+
+This PR tests:
+- [x] PR validation workflows
+- [x] Quality gates 
+- [x] Security scanning
+- [x] Preview deployment
+- [x] Semantic PR validation
+
+**Testing checklist:**
+- [ ] All workflows complete successfully
+- [ ] Quality gates pass
+- [ ] Security scans complete
+- [ ] Preview deployment works
+- [ ] No errors in workflow logs
+
+**Next steps:**
+1. Monitor workflow execution
+2. Verify all checks pass
+3. Test any failing workflows
+4. Close this PR when testing is complete" \
+        --draft
+    
+    print_success "Created test PR (draft)"
+}
+
+# Clean up test resources
+cleanup() {
+    print_status "Cleaning up test resources..."
+    
+    # Close any open test PRs
+    local test_prs=$(gh pr list --state=open --search="Test: Workflow Validation" --json number -q '.[].number')
+    
+    for pr in $test_prs; do
+        print_status "Closing test PR #$pr"
+        gh pr close "$pr" --comment "Workflow testing completed - closing test PR"
+    done
+    
+    # Switch back to main branch
+    git checkout main
+    
+    print_warning "Test branch 'workflow-testing' preserved for future testing"
+    print_success "Cleanup completed"
+}
+
+# Main menu
+show_menu() {
+    echo
+    echo "🧪 GitHub Workflow Testing Script"
+    echo "=================================="
+    echo
+    echo "Select an option:"
+    echo "1) Test all workflows"
+    echo "2) Test CI/CD only"
+    echo "3) Test security scanning only"
+    echo "4) Test quality checks only"
+    echo "5) Create test PR"
+    echo "6) Monitor latest workflow run"
+    echo "7) Cleanup test resources"
+    echo "8) View workflow testing guide"
+    echo "9) Exit"
+    echo
+}
+
+# View testing guide
+view_guide() {
+    if [ -f "WORKFLOW_TESTING.md" ]; then
+        print_status "Opening workflow testing guide..."
+        if command -v bat &> /dev/null; then
+            bat WORKFLOW_TESTING.md
+        elif command -v less &> /dev/null; then
+            less WORKFLOW_TESTING.md
+        else
+            cat WORKFLOW_TESTING.md
+        fi
+    else
+        print_error "WORKFLOW_TESTING.md not found in current directory"
+    fi
+}
+
+# Main script
+main() {
+    print_status "Starting GitHub Workflow Testing Script"
+    
+    # Check prerequisites
+    check_gh_cli
+    check_auth
+    
+    # Create test branch if it doesn't exist
+    create_test_branch
+    
+    while true; do
+        show_menu
+        read -p "Enter your choice (1-9): " choice
+        
+        case $choice in
+            1)
+                run_test "all"
+                ;;
+            2)
+                run_test "ci-only"
+                ;;
+            3)
+                run_test "security-only"
+                ;;
+            4)
+                run_test "quality-only"
+                ;;
+            5)
+                create_test_pr
+                ;;
+            6)
+                monitor_run
+                ;;
+            7)
+                cleanup
+                ;;
+            8)
+                view_guide
+                ;;
+            9)
+                print_success "Exiting workflow testing script"
+                exit 0
+                ;;
+            *)
+                print_error "Invalid option. Please choose 1-9."
+                ;;
+        esac
+        
+        echo
+        read -p "Press Enter to continue..."
+    done
+}
+
+# Run main function
+main "$@"

tools/bolt.diy/tests/integration/corporate-swarm.test.ts

@@ -0,0 +1,208 @@
+/**
+ * Integration tests for CorporateSwarm → bolt.diy flow.
+ * 
+ * These tests validate the complete integration between CorporateSwarm
+ * governance system and bolt.diy execution engine.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import type { Mandate } from '~/types/mandate';
+
+describe('CorporateSwarm → bolt.diy Integration', () => {
+  const baseUrl = process.env.BOLT_DIY_API_URL || 'http://localhost:5173';
+
+  describe('Mandate Submission', () => {
+    it('should accept a valid mandate from CorporateSwarm', async () => {
+      const mandate: Mandate = {
+        mandate_id: 'test-integration-001',
+        objectives: ['Test objective'],
+        constraints: {
+          language: 'ts',
+          maxDependencies: 10,
+          noNetwork: false,
+          allowedPackages: [],
+          maxFileSize: 10000,
+          maxFiles: 10,
+        },
+        budget: {
+          token: 10000,
+          time: 60,
+          cost: 1.0,
+        },
+        deliverables: ['src/index.ts'],
+        governance: {
+          proposal_id: 'test-proposal-001',
+        },
+        iteration_config: {
+          max_iterations: 1,
+          test_required: false,
+          quality_threshold: 0.7,
+        },
+      };
+
+      const response = await fetch(`${baseUrl}/api/mandate`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(mandate),
+      });
+
+      expect(response.status).toBe(202);
+      const result = await response.json() as { success: boolean; mandate_id: string; event_stream_url?: string };
+      expect(result.success).toBe(true);
+      expect(result.mandate_id).toBe(mandate.mandate_id);
+      expect(result.event_stream_url).toBeDefined();
+    });
+
+    it('should reject an invalid mandate', async () => {
+      const invalidMandate = {
+        mandate_id: 'test-invalid',
+        // Missing required fields
+      };
+
+      const response = await fetch(`${baseUrl}/api/mandate`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(invalidMandate),
+      });
+
+      expect(response.status).toBe(400);
+      const result = await response.json() as { success: boolean; errors?: any };
+      expect(result.success).toBe(false);
+      expect(result.errors).toBeDefined();
+    });
+  });
+
+  describe('Execution Event Streaming', () => {
+    it('should stream execution events for a mandate', async () => {
+      const mandateId = 'test-stream-001';
+      
+      // First submit a mandate
+      const mandate: Mandate = {
+        mandate_id: mandateId,
+        objectives: ['Test streaming'],
+        constraints: {
+          language: 'ts',
+          maxDependencies: 5,
+          noNetwork: false,
+          allowedPackages: [],
+          maxFileSize: 10000,
+          maxFiles: 5,
+        },
+        budget: {
+          token: 5000,
+          time: 30,
+          cost: 0.5,
+        },
+        deliverables: ['src/test.ts'],
+        governance: {},
+        iteration_config: {
+          max_iterations: 1,
+          test_required: false,
+          quality_threshold: 0.7,
+        },
+      };
+
+      const submitResponse = await fetch(`${baseUrl}/api/mandate`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(mandate),
+      });
+
+      expect(submitResponse.status).toBe(202);
+      const submitResult = await submitResponse.json() as { event_stream_url?: string };
+      const eventStreamUrl = submitResult.event_stream_url;
+      
+      if (!eventStreamUrl) {
+        throw new Error('Event stream URL not provided');
+      }
+
+      // Connect to event stream
+      const eventSource = new EventSource(eventStreamUrl);
+      const events: any[] = [];
+
+      return new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          eventSource.close();
+          reject(new Error('Event stream timeout'));
+        }, 10000);
+
+        eventSource.onmessage = (event) => {
+          try {
+            const data = JSON.parse(event.data);
+            events.push(data);
+
+            // Check for connection confirmation
+            if (data.type === 'connected') {
+              expect(data.mandate_id).toBe(mandateId);
+            }
+
+            // If we receive an iteration_start event, we're good
+            if (data.type === 'iteration_start') {
+              clearTimeout(timeout);
+              eventSource.close();
+              expect(events.length).toBeGreaterThan(0);
+              resolve();
+            }
+          } catch (error) {
+            clearTimeout(timeout);
+            eventSource.close();
+            reject(error);
+          }
+        };
+
+        eventSource.onerror = (error) => {
+          clearTimeout(timeout);
+          eventSource.close();
+          reject(error);
+        };
+      });
+    });
+  });
+
+  describe('Governance Reporting', () => {
+    it('should report execution status to CorporateSwarm', async () => {
+      // This test would require a mock CorporateSwarm API endpoint
+      // For now, we'll test that the CorporateSwarmClient can be instantiated
+      const { CorporateSwarmClient } = await import('~/lib/governance/corporate-swarm-client');
+      const client = new CorporateSwarmClient({ baseUrl: 'http://localhost:8000' });
+
+      // Test that client methods exist
+      expect(client.submitExecutionReport).toBeDefined();
+      expect(client.requestApproval).toBeDefined();
+      expect(client.updateProposalStatus).toBeDefined();
+    });
+  });
+
+  describe('Deployment Integration', () => {
+    it('should deploy project when deployment is enabled in mandate', async () => {
+      // This test would require actual deployment credentials
+      // For now, we'll test that deployment APIs accept mandate_id
+      const deployRequest = {
+        files: {
+          'index.html': '<html><body>Test</body></html>',
+        },
+        mandate_id: 'test-deploy-001',
+        proposal_id: 'test-proposal-deploy-001',
+      };
+
+      // Note: This will fail without actual Netlify token, but we can test the API structure
+      const response = await fetch(`${baseUrl}/api/netlify-deploy`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(deployRequest),
+      });
+
+      // Should either succeed (if token provided) or fail with 401 (if no token)
+      expect([200, 201, 401]).toContain(response.status);
+    });
+  });
+});
+

tools/bolt.diy/tests/mandates/budget-limited.json

@@ -0,0 +1,34 @@
+{
+  "mandate_id": "test-budget-limited-001",
+  "objectives": [
+    "Create a simple calculator application",
+    "Implement basic arithmetic operations"
+  ],
+  "constraints": {
+    "language": "js",
+    "maxDependencies": 3,
+    "noNetwork": true,
+    "allowedPackages": [],
+    "maxFileSize": 5000,
+    "maxFiles": 2
+  },
+  "budget": {
+    "token": 1000,
+    "time": 10,
+    "cost": 0.1
+  },
+  "deliverables": [
+    "index.html",
+    "calculator.js"
+  ],
+  "governance": {
+    "proposal_id": "test-proposal-budget-001",
+    "risk_threshold": 30.0
+  },
+  "iteration_config": {
+    "max_iterations": 1,
+    "test_required": false,
+    "quality_threshold": 0.5
+  }
+}
+

tools/bolt.diy/tests/mandates/complex.json

@@ -0,0 +1,53 @@
+{
+  "mandate_id": "test-complex-001",
+  "objectives": [
+    "Create a full-stack web application with React frontend",
+    "Implement user authentication",
+    "Add database integration",
+    "Create REST API endpoints",
+    "Deploy to production"
+  ],
+  "constraints": {
+    "language": "ts",
+    "maxDependencies": 50,
+    "noNetwork": false,
+    "allowedPackages": ["react", "react-dom", "express", "typescript", "node"],
+    "maxFileSize": 100000,
+    "maxFiles": 50
+  },
+  "budget": {
+    "token": 100000,
+    "time": 600,
+    "cost": 10.0
+  },
+  "deliverables": [
+    "src/App.tsx",
+    "src/components/Login.tsx",
+    "src/api/auth.ts",
+    "server/index.ts",
+    "package.json",
+    "README.md"
+  ],
+  "governance": {
+    "proposal_id": "test-proposal-complex-001",
+    "esg_requirements": {
+      "environmental_score": 75.0,
+      "social_score": 80.0,
+      "governance_score": 85.0,
+      "overall_score": 80.0
+    },
+    "risk_threshold": 60.0,
+    "causal_analysis_required": true
+  },
+  "iteration_config": {
+    "max_iterations": 5,
+    "test_required": true,
+    "quality_threshold": 0.85
+  },
+  "deployment": {
+    "enabled": true,
+    "provider": "netlify",
+    "auto_deploy": true
+  }
+}
+

tools/bolt.diy/tests/mandates/constraint-enforced.json

@@ -0,0 +1,36 @@
+{
+  "mandate_id": "test-constraint-enforced-001",
+  "objectives": [
+    "Create a secure password generator",
+    "Ensure no external dependencies",
+    "Follow strict security guidelines"
+  ],
+  "constraints": {
+    "language": "ts",
+    "maxDependencies": 0,
+    "noNetwork": true,
+    "allowedPackages": [],
+    "maxFileSize": 5000,
+    "maxFiles": 2
+  },
+  "budget": {
+    "token": 5000,
+    "time": 30,
+    "cost": 0.5
+  },
+  "deliverables": [
+    "src/password-generator.ts",
+    "index.html"
+  ],
+  "governance": {
+    "proposal_id": "test-proposal-constraint-001",
+    "risk_threshold": 20.0,
+    "approval_chain": ["security-team", "compliance-officer"]
+  },
+  "iteration_config": {
+    "max_iterations": 2,
+    "test_required": true,
+    "quality_threshold": 0.9
+  }
+}
+

tools/bolt.diy/tests/mandates/simple.json

@@ -0,0 +1,35 @@
+{
+  "mandate_id": "test-simple-001",
+  "objectives": [
+    "Create a hello world React component",
+    "Display the component in a simple HTML page"
+  ],
+  "constraints": {
+    "language": "ts",
+    "maxDependencies": 5,
+    "noNetwork": false,
+    "allowedPackages": ["react", "react-dom"],
+    "maxFileSize": 10000,
+    "maxFiles": 3
+  },
+  "budget": {
+    "token": 10000,
+    "time": 60,
+    "cost": 1.0
+  },
+  "deliverables": [
+    "src/App.tsx",
+    "index.html",
+    "package.json"
+  ],
+  "governance": {
+    "proposal_id": "test-proposal-001",
+    "risk_threshold": 50.0
+  },
+  "iteration_config": {
+    "max_iterations": 1,
+    "test_required": false,
+    "quality_threshold": 0.7
+  }
+}
+

tools/bolt.diy/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "lib": ["DOM", "DOM.Iterable", "ESNext"],
+    "types": [
+      "@remix-run/cloudflare",
+      "vite/client",
+      "@cloudflare/workers-types/2023-07-01",
+      "@types/dom-speech-recognition"
+    ],
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "jsx": "react-jsx",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "target": "ESNext",
+    "strict": true,
+    "allowJs": true,
+    "skipLibCheck": true,
+    "verbatimModuleSyntax": true,
+    "forceConsistentCasingInFileNames": true,
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["./app/*", "./*"]
+    },
+    // vite takes care of building everything, not tsc
+    "noEmit": true
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx",
+    "**/.server/**/*.ts",
+    "**/.server/**/*.tsx",
+    "**/.client/**/*.ts",
+    "**/.client/**/*.tsx"
+  ]
+}

tools/bolt.diy/types/istextorbinary.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @note For some reason the types aren't picked up from node_modules so I declared the module here
+ * with only the function that we use.
+ */
+declare module 'istextorbinary' {
+  export interface EncodingOpts {
+    /** Defaults to 24 */
+    chunkLength?: number;
+
+    /** If not provided, will check the start, beginning, and end */
+    chunkBegin?: number;
+  }
+
+  export function getEncoding(buffer: Buffer | null, opts?: EncodingOpts): 'utf8' | 'binary' | null;
+}