Chain Workspace Development Agent

An expert development agent for the Chain Workspace application - a lightweight, modular workspace platform for creating and managing document processing chains with AI agents.

What This Agent Does

This agent specializes in developing the Chain Workspace application using:

Architecture Principles

The agent follows these core patterns:

1. **Event-Sourced State**: Immutable event log with undo/redo capabilities

2. **Schema-Driven Development**: Zod schemas as single source of truth for data contracts

3. **Test-Driven Development (TDD)**: Write failing tests first, then implement

4. **Memory Bank**: Maintains long-term knowledge base in `.memri/` directory

5. **Sub-Agent Workflow**: Specialized agents for different development phases

6. **Task-Based Commits**: Every step committed with task references

Development Workflow Instructions

1. Environment Setup

Start by ensuring the development environment is ready:

```bash

Start database and services

docker-compose -f docker-compose.dev.yml up -d

Install dependencies

npm install

Run database migrations

npm run db:migrate

Seed development data

npm run db:seed

```

**Verify**: Check that PostgreSQL is running on port 5432 and Adminer is accessible at http://localhost:8080

2. Sub-Agent Workflow

Follow this sequence for feature development:

**Phase 1: test-runner**

**Phase 2: schema-keeper**

**Phase 3: ui-developer**

**Phase 4: backend-developer**

**Phase 5: commit-bot**

3. Testing Strategy

**Always run tests before committing:**

```bash

Unit tests (fast feedback)

npm run test:unit

Integration tests (requires database)

npm run test:integration

E2E tests (full user flows)

npm run test:e2e

All tests with coverage

npm run test:coverage

```

**Test file patterns:**

4. Database Operations

**Creating migrations:**

```bash

Create new migration file

npm run db:migrate:create

Deploy migrations to database

npm run db:migrate:deploy

Reset database (development only)

npm run db:reset

```

**Prisma workflow:**

1. Edit schema in `prisma/schema.prisma`

2. Generate migration: `npm run db:migrate:create`

3. Apply migration: `npm run db:migrate:deploy`

4. Regenerate Prisma client: `npx prisma generate`

5. Commit Workflow (CRITICAL)

**Every completed step MUST be committed immediately with proper task references.**

**Commit message format:**

```bash

Feature commits

git commit -m "feat(task-X): implement [description]"

Bug fixes

git commit -m "fix(task-X): resolve [description]"

Tests

git commit -m "test(task-X): add [test type] for [feature]"

Refactoring

git commit -m "refactor(task-X): optimize [description]"

```

**Task completion commit (via commit-bot):**

```bash

feat(task-X): complete [task title]

Closes task-X

```

**When to commit:**

6. Memory Bank Maintenance

**Update these files in `.memri/` directory:**

**When to update:**

7. Project Structure Navigation

**Key directories:**

```

COD_V01/

├── .claude/agents/ # Sub-agent definitions

├── .memri/ # Memory Bank knowledge files

├── src/ # React frontend

│ ├── components/ # Reusable UI components

│ ├── pages/ # Route components

│ └── lib/ # Utilities and hooks

├── api/ # Node.js backend

│ ├── routes/ # Fastify route handlers

│ ├── services/ # Business logic

│ └── db/ # Database utilities

├── schemas/ # Shared Zod schemas

├── tests/ # Test suites

├── migrations/ # Database migrations

└── docker/ # Container configurations

```

Important Constraints

1. **Always write tests first** (TDD methodology)

2. **Never skip commits** - commit after every completed step

3. **Use Zod schemas** for all data validation (frontend and backend)

4. **Follow event-sourcing patterns** for state management

5. **Update Memory Bank** when making significant changes

6. **Run full test suite** before pushing to repository

7. **Use Docker Compose** for local development (no direct PostgreSQL installations)

8. **Reference task numbers** in all commits for traceability

Environment Configuration

**Required environment variables:**

```bash

DATABASE_URL=postgresql://user:password@localhost:5432/chainworkspace

OPENAI_API_KEY=your_openai_key_here

JWT_SECRET=your_jwt_secret_here

NODE_ENV=development

```

**Service ports:**

Code Quality Commands

```bash

Linting

npm run lint

npm run lint:fix

Type checking

npm run typecheck

Code formatting

npm run format

```

Quick Start for New Features

1. **Read Task Master instructions** (if available in `.taskmaster/CLAUDE.md`)

2. **Start development environment**: `docker-compose -f docker-compose.dev.yml up -d`

3. **Install dependencies**: `npm install`

4. **Run migrations**: `npm run db:migrate`

5. **Start servers**: `npm run dev` (runs both frontend and backend)

6. **Follow sub-agent workflow**: test-runner → schema-keeper → ui-developer → backend-developer → commit-bot

7. **Commit every step**: Use task-based commit format

8. **Update Memory Bank**: Maintain project knowledge in `.memri/`

Example Development Session

```bash

1. Start environment

docker-compose -f docker-compose.dev.yml up -d

2. Create feature branch

git checkout -b feat/task-42-user-authentication

3. Write failing tests

npm run test:unit -- --watch

Create tests in tests/unit/auth.test.ts

4. Define schemas

Edit schemas/auth.ts with Zod schemas

5. Implement frontend

npm run dev:ui

Create components in src/components/Auth/

6. Implement backend

npm run dev:api

Create routes in api/routes/auth.ts

7. Run all tests

npm test

8. Commit with task reference

git add .

git commit -m "feat(task-42): implement user authentication

Closes task-42"

9. Push to repository

git push origin feat/task-42-user-authentication

```

This agent ensures consistent, test-driven development following the Chain Workspace project's architectural patterns and Memory Bank methodology.