/context-load-fresh-connect-stack

allowed-tools: Read, Write, Bash(fd:*), Bash(rg:*), Bash(jq:*), Bash(gdate:*), WebFetch, Task
name: "Context Load Fresh Connect Stack"
description: "Load comprehensive context about Fresh + ConnectRPC full-stack architecture with project-specific analysis"
author: "wcygan"
tags: ["context","web"]
version: "1.0.0"
created_at: "2025-07-14T00:00:00Z"
updated_at: "2025-07-14T00:00:00Z"

Context

• Session ID: !`gdate +%s%N`
• Current directory: !`pwd`
• Project structure: !`fd . -t d -d 3 | head -10 || echo "No directories found"`
• Fresh indicators: !`fd "deno.json" . -d 2 -x jq -r '.imports | keys[]? // empty' {} 2>/dev/null | rg "@fresh" || echo "No Fresh imports found"`
• Go backend indicators: !`fd "go.mod" . -d 3 | head -3 || echo "No Go modules found"`
• ConnectRPC patterns: !`rg "connectrpc|connect-go|@connectrpc" . --type typescript --type go | head -5 || echo "No ConnectRPC patterns found"`
• Buf.build packages: !`rg "@buf/.*\.bufbuild" . --type json --type typescript | head -3 || echo "No buf.build packages found"`
• Docker setup: !`fd "docker-compose.yml|Dockerfile" . -d 2 || echo "No Docker configuration found"`
• Technology stack summary: !`echo "Frontend: $(fd "deno.json" . -d 2 | wc -l | tr -d ' ') | Backend: $(fd "go.mod" . -d 3 | wc -l | tr -d ' ') | Docker: $(fd "docker-compose.yml" . -d 2 | wc -l | tr -d ' ')"`

Your Task

STEP 1: Initialize comprehensive Fresh + ConnectRPC context loading session

• CREATE session state file: `/tmp/fresh-connect-context-$SESSION_ID.json`
• SET initial state:

  {
    "sessionId": "$SESSION_ID",
    "timestamp": "$(date -Iseconds)",
    "phase": "initialization",
    "architecture_type": "auto-detect",
    "frontend_detected": false,
    "backend_detected": false,
    "integration_patterns": [],
    "documentation_loaded": {},
    "project_analysis": {},
    "context_areas": [
      "architecture_overview",
      "project_structure",
      "development_workflow",
      "integration_patterns",
      "production_features"
    ],
    "checkpoints": []
  }

• CREATE context workspace: `/tmp/fresh-connect-context-$SESSION_ID/`

STEP 2: Project architecture detection and analysis

TRY:

• Think deeply about the optimal Fresh + ConnectRPC architecture patterns based on the detected project structure

• ANALYZE project structure from Context section
• DETERMINE Fresh + ConnectRPC architecture type:

IF Fresh indicators found AND Go backend indicators found:

• SET architecture_type = "full_stack_fresh_connect"
• ENABLE comprehensive full-stack context loading
• PRIORITIZE: Integration patterns, API proxy setup, type safety

ELSE IF Fresh indicators found AND NOT Go backend:

• SET architecture_type = "fresh_frontend_only"
• FOCUS on Fresh-specific patterns and potential ConnectRPC integration
• PRIORITIZE: Frontend architecture, potential backend integration

ELSE IF Go backend indicators found AND NOT Fresh:

• SET architecture_type = "connectrpc_backend_only"
• FOCUS on ConnectRPC service patterns and frontend integration readiness
• PRIORITIZE: Backend architecture, API design, frontend integration prep

ELSE:

• SET architecture_type = "greenfield_setup"
• PROVIDE comprehensive setup guidance for new Fresh + ConnectRPC project
• PRIORITIZE: Project initialization, architecture decisions, tooling setup

CATCH (project_analysis_failed):

• LOG analysis issues to session state
• CONTINUE with generic Fresh + ConnectRPC guidance
• PROVIDE manual project setup instructions

STEP 3: Adaptive documentation loading based on detected architecture

CASE architecture_type: WHEN "full_stack_fresh_connect":

• Think harder about full-stack integration patterns and potential architectural challenges
• USE Task tool for parallel documentation loading with 5 specialized agents:

1. **Fresh Architecture Agent**: Load Fresh 2.0 Islands, SSR, routing patterns

• SAVE findings to: `/tmp/fresh-connect-context-$SESSION_ID/fresh-architecture.json`

2. **ConnectRPC Integration Agent**: Load Go ConnectRPC, buf.build, protobuf patterns

• SAVE findings to: `/tmp/fresh-connect-context-$SESSION_ID/connectrpc-integration.json`

3. **API Proxy Patterns Agent**: Load proxy configuration, CORS, type safety

• SAVE findings to: `/tmp/fresh-connect-context-$SESSION_ID/api-proxy-patterns.json`

4. **Development Workflow Agent**: Load Deno tasks, hot reload, Docker setup

• SAVE findings to: `/tmp/fresh-connect-context-$SESSION_ID/dev-workflow.json`

5. **Production Deployment Agent**: Load deployment, monitoring, security patterns

• SAVE findings to: `/tmp/fresh-connect-context-$SESSION_ID/production-patterns.json`

WHEN "fresh_frontend_only":

• EXECUTE focused Fresh documentation loading:
• Think deeply about Fresh 2.0 architecture and integration capabilities
• LOAD: Fresh Islands, routing, Preact signals, API integration patterns
• FOCUS: Preparing for potential ConnectRPC backend integration
• PROVIDE: Backend integration readiness assessment

WHEN "connectrpc_backend_only":

• EXECUTE focused ConnectRPC documentation loading:
• Think harder about ConnectRPC service design and frontend integration
• LOAD: Go ConnectRPC, protobuf schemas, CORS handling, API design
• FOCUS: Frontend-ready API design and integration patterns
• PROVIDE: Fresh frontend integration guidance

WHEN "greenfield_setup":

• EXECUTE comprehensive setup documentation loading:
• LOAD: Project initialization, architecture decisions, tooling setup
• FOCUS: Best practices for Fresh + ConnectRPC project creation
• PROVIDE: Step-by-step project setup guidance

STEP 4: Comprehensive documentation fetching and context synthesis

TRY:

**Core Framework Documentation:**

1. **Fresh Framework Context**

• TRY WebFetch: `https://fresh.deno.dev/docs/introduction`
• FOCUS: Islands architecture, SSR, routing, deployment
• EXTRACT: Key concepts, integration patterns, best practices
• FALLBACK: Use embedd