[memory-bank] Tell cline how to build components

Tool: gitpod/catfood.gitpod.cloud

Author: geropl

memory-bank/.clinerules

@@ -26,19 +26,35 @@ This file captures important patterns, preferences, and project intelligence tha
 
 ## Development Workflow
 
-- **Build System**: Use Leeway for building components
-  - `leeway build` to build specific components
-  - `leeway exec` to run commands across components
+- **Build Approaches**:
+  - **In-tree builds** (primary for local development):
+    - TypeScript components: Use `yarn` commands defined in package.json
+      - `yarn build`: Compile the component
+      - `yarn test`: Run tests
+      - `yarn lint`: Check code style
+      - `yarn watch`: Watch for changes and rebuild
+    - Go components: Use standard Go tools
+      - `go build ./...`: Build all packages
+      - `go test ./...`: Test all packages
+      - `go run main.go`: Build and run
+
+  - **Out-of-tree builds** (Leeway, primary for CI):
+    - `leeway build components/component-name:app`: Build a specific component
+    - `leeway build -D components/component-name:app`: Build with dependencies
+    - `leeway exec --package components/component-name:app -- command`: Run a command for a package
 
 - **Testing**:
   - Unit tests alongside code
   - Integration tests in separate directories
   - End-to-end tests in the `test/` directory
+  - Component-specific test commands in package.json (for TypeScript)
+  - Go tests use standard `go test` command
 
 - **Local Development**:
   - Use Gitpod workspaces for development (dogfooding)
   - Components can be run individually for testing
   - Preview environments for testing changes
+  - Use in-tree builds for rapid iteration during development
 
 ## Critical Implementation Paths
 
@@ -102,6 +118,23 @@ This section will be updated as I learn about how and why certain architectural
 
 This section will be updated as I learn about specific user preferences for working with the codebase.
 
+## Build and Test Information
+
+When working with components, I should always document:
+
+- **Build Commands**: Document any new or component-specific build commands I encounter
+- **Test Commands**: Document how to run tests for each component
+- **Dependencies**: Note any special dependencies required for building or testing
+- **Common Issues**: Document common build or test issues and their solutions
+- **Performance Considerations**: Note any performance considerations for builds
+
+Whenever I encounter new build patterns or commands, I should update:
+1. The relevant component documentation in `memory-bank/components/`
+2. The `.clinerules` file with general patterns
+3. The `techContext.md` file if it represents a significant pattern
+
+This information is critical for effective development work, as being able to build and test components is fundamental to making changes and verifying their correctness.
+
 ---
 
 Note: This file will be continuously updated as I work with the Gitpod codebase and discover new patterns, preferences, and insights.

memory-bank/activeContext.md

@@ -63,9 +63,11 @@ The immediate next steps are:
 
 1. **Explore Component Interactions**: Understand how components interact with each other
 2. **Set Up Development Environment**: Configure a local development environment for effective testing
-3. **Identify Initial Tasks**: Determine specific tasks or improvements to focus on
-4. **Establish Testing Approach**: Define how changes will be tested and validated
-5. **Update Memory Bank**: Continue to refine and expand the memory bank as new information is discovered
+3. **Explore Build System**: Gain hands-on experience with both in-tree and Leeway builds
+4. **Test Component Builds**: Practice building and testing different component types
+5. **Identify Initial Tasks**: Determine specific tasks or improvements to focus on
+6. **Establish Testing Approach**: Define how changes will be tested and validated
+7. **Update Memory Bank**: Continue to refine and expand the memory bank as new information is discovered
 
 ## Active Decisions and Considerations
 
@@ -115,5 +117,15 @@ Initial exploration of the Gitpod codebase has revealed:
   - Go services typically have a cmd/ directory with command implementations
   - TypeScript services use React and modern frontend practices
   - Most components have a clear separation between API definitions and implementations
+- **Build System Approaches**: Gitpod uses two primary approaches for building components:
+  - **In-tree builds**: Using language-specific tools (yarn, go) directly in the workspace
+    - Primary method for local development
+    - TypeScript components use commands defined in package.json (yarn build, yarn test, etc.)
+    - Go components use standard Go tools (go build, go test, etc.)
+  - **Out-of-tree builds**: Using Leeway, a custom build tool
+    - Primary method for CI to generate build artifacts
+    - Works by copying relevant sources into a separate file tree
+    - Can also be run from inside the workspace
+    - Manages complex dependencies between components
 
 This section will be continuously updated as new insights are gained through working with the system.

memory-bank/progress.md

@@ -68,8 +68,10 @@ The existing functionality of the Gitpod platform:
 ## What's Left to Build
 
 ### Immediate Tasks
-- Explore component interactios
+- Explore component interactions
 - Set up local development environment
+- Explore build system approaches (in-tree and Leeway)
+- Test component builds for different component types
 - Identify specific components for deeper exploration
 - Establish testing methodology
 - Create initial contribution plan
@@ -166,6 +168,14 @@ No specific blockers or dependencies have been identified yet. This section will
   - Documented scheduler-extender component
   - Documented ipfs component
 
+- **2/27/2025**:
+  - Documented build system approaches:
+    - In-tree builds using language-specific tools (yarn, go)
+    - Out-of-tree builds using Leeway
+  - Updated techContext.md with detailed build process information
+  - Updated .clinerules with build patterns and commands
+  - Added build information tracking to memory bank maintenance procedures
+
 ## Next Evaluation Point
 
 The next evaluation of progress will occur after:

memory-bank/techContext.md

@@ -42,13 +42,57 @@ The project uses a Gitpod-based development workflow (dogfooding), with the foll
 4. **Dev Containers**: Development occurs in containers that mirror production
 
 ### Build Process
-1. **Leeway**: Custom build system that manages the complex dependencies between components
-2. **Component Compilation**: Each component is compiled independently
-   - TypeScript components use `yarn build`
-   - Go components use `go build`
-   - Java components use Gradle
-3. **Docker Images**: Components are packaged as Docker images
-4. **Helm Charts**: Deployment configurations are managed as Helm charts
+
+Gitpod uses two primary approaches for building components:
+
+#### 1. In-tree Builds (Primary for Local Development)
+Components are built directly in the workspace using language-specific tools:
+
+- **TypeScript/JavaScript Components**:
+  - Commands are defined in each component's `package.json`
+  - Common commands:
+    - `yarn build`: Compiles the component
+    - `yarn test`: Runs unit tests
+    - `yarn lint`: Checks code style
+    - `yarn watch`: Watches for changes and rebuilds automatically
+  - Example (from server component):
+    ```bash
+    cd components/server
+    yarn build        # Build the component
+    yarn test:unit    # Run unit tests
+    yarn test:db      # Run database tests
+    ```
+
+- **Go Components**:
+  - Use standard Go tools
+  - Common commands:
+    - `go build`: Compiles the component
+    - `go test`: Runs tests
+    - `go run`: Builds and runs the component
+  - Example:
+    ```bash
+    cd components/ws-daemon
+    go build ./...    # Build all packages
+    go test ./...     # Test all packages
+    ```
+
+#### 2. Leeway Builds (Out-of-tree, Primary for CI)
+Leeway is a custom build tool that:
+- Copies relevant sources into a separate file tree
+- Manages complex dependencies between components
+- Generates build artifacts for CI/CD pipelines
+- Can also be run from inside the workspace
+
+Common Leeway commands:
+```bash
+leeway build components/server:app    # Build a specific component
+leeway build -D components/server:app # Build with dependencies
+leeway exec --package components/server:app -- yarn test  # Run a command for a package
+```
+
+#### 3. Component Packaging
+- **Docker Images**: Components are packaged as Docker images using `leeway.Dockerfile` files
+- **Helm Charts**: Deployment configurations are managed as Helm charts for Kubernetes deployment
 
 ### Testing Strategy
 1. **Unit Tests**: Component-level tests for individual functions and classes