sea-dev 1.0.0

package/.claude/tasks/README.md

@@ -0,0 +1,89 @@
+# Claude Code Active Tasks
+
+This directory tracks tasks being worked on by Claude Code sessions.
+
+## Purpose
+
+- **Persistent progress tracking** across Claude sessions
+- **Avoid conflicts** between concurrent sessions working on different tasks
+- **Team visibility** into active AI-assisted work
+- **Continuity** when switching sessions or machines
+
+## In Progress
+
+- [pipeline-ui-completeness.md](pipeline-ui-completeness.md) - Complete pipeline UI functionality
+  - **Started**: 2026-04-01
+  - **Priority**: High - Blocking core user functionality
+  - **Phases**:
+    1. Submission data loading (show actual input/output data)
+    2. Blocker resolution UI (upload docs, select submissions)
+    3. Document extraction implementation (discussion needed)
+
+## Queued
+
+_(No queued tasks)_
+
+## Recently Completed
+
+- [pipeline-data-model-fixes.md](../tasks-archive/pipeline-data-model-fixes.md) - Pipeline data model refactor
+  - **Completed**: 2026-04-01
+  - **Summary**: Fixed all deprecated field references, implemented formIdMapping filtering, added status constants, removed type casts
+  - **Result**: All type checks passing (db, dal, core, workers)
+
+---
+
+## Guidelines for Claude Code Sessions
+
+### Starting a New Task
+
+1. **Create a task file**: `.claude/tasks/{feature-area}-{brief-description}.md`
+   - Examples: `auth-sso-integration.md`, `ui-mobile-responsive.md`
+2. **Add to this README** under "In Progress"
+3. **Use the template** from `dag-pipeline-implementation.md` as reference
+4. **Update regularly** as you make progress
+
+### Continuing an Existing Task
+
+1. **Read the task file first** to understand what's been done
+2. **Check the todo list** for next steps
+3. **Update progress** as you complete items
+4. **Document decisions** and architectural choices
+
+### Completing a Task
+
+1. **Mark all todos complete** in the task file
+2. **Move file** to `../tasks-archive/`
+3. **Update this README** to move task from "In Progress" to "Recently Completed"
+4. **Create a summary** of what was accomplished
+
+### Naming Convention
+
+`{feature-area}-{brief-description}.md`
+
+- `feature-area`: dal, core, ui, api, db, worker, etc.
+- `brief-description`: 2-4 words describing the task
+- Use kebab-case (lowercase with hyphens)
+
+**Examples**:
+- `dag-pipeline-implementation.md`
+- `auth-sso-integration.md`
+- `ui-table-virtualization.md`
+- `api-rate-limiting.md`
+
+---
+
+## Tips for Success
+
+- **Link to files and line numbers**: Use relative paths like `[file.ts:123](../../libs/dal/src/file.ts#L123)` for easy navigation
+- **Track decisions**: Document why you made architectural choices
+- **List completed work**: With file references so others can verify
+- **Keep todos granular**: Break large tasks into smaller checkboxes
+- **Update frequently**: After completing each subtask, not just at the end
+
+---
+
+## Related
+
+- Project docs: [`../../docs/`](../../docs/)
+- Database migrations: [`../../apps/main/drizzle/`](../../apps/main/drizzle/)
+- Claude Code settings: [`../settings.local.json`](../settings.local.json)

package/.cursor/rules/commits.mdc

@@ -0,0 +1,31 @@
+---
+description: Make sure to do this before committing
+globs: ["**/*"]
+alwaysApply: true
+---
+<!-- The remainder of the file is unchanged -->
+
+## Testing 
+
+Always run these commands to verify code quality:
+
+```bash
+npm run lint      # Run ESLint
+npm run check     # TypeScript type checking
+npm run test      # Run tests
+npm run fmt       # Format code with Prettier
+```
+
+
+### Code Review Checklist
+
+Before requesting review or committing:
+1. ✓ Searched for existing patterns
+2. ✓ Removed all unused code
+3. ✓ Ran `npm run fmt`
+4. ✓ Ran `npm run lint` 
+5. ✓ Ran `npm run check`
+5. ✓ Ran `npm run test`
+6. ✓ Verified DB access controls
+7. ✓ Used existing components where possible
+8. ✓ Minimized client state

package/.cursor/rules/general.mdc

@@ -0,0 +1,84 @@
+---
+description: General development patterns and best practices
+globs: ["**/*"]
+alwaysApply: true
+---
+<!-- The remainder of the file is unchanged -->
+
+## Important Notes
+
+- This is a private repository
+- Uses ES modules (`"type": "module"` in package.json)
+- Strict TypeScript configuration
+- Production deployments use `dotenvx run` for secure env vars
+
+## Developer Guidelines
+
+### General Principles
+
+- **Always find existing patterns**: Use extra time to search for relevant code patterns before implementing something new
+- **Clean code**: Don't leave unused code or files in the project
+- **Research first**: Look extensively for existing implementations before creating new ones
+
+### Development Workflow
+
+- **Pre-commit checks**: Always run `npm run fmt`, `npm run lint`, and `npm run check` before committing
+- **Commit frequently**: Make small, focused commits with descriptive messages
+- **Branch management**: Consider working on a separate branch if scope creeps significantly
+
+### UI Development
+
+- **Component reuse**: Always check for existing components before creating new ones
+- **Prefer components over custom Tailwind**: Use existing UI components rather than creating custom Tailwind implementations
+- **Use defined colors**: Use colors from `app.css` instead of creating custom color values
+- **Minimize client state**: 
+  - Prefer cache invalidation over client-side state management
+  - Store state in URL search params when appropriate
+  - Keep client-side state to an absolute minimum
+
+### Database Best Practices
+
+- **Access control**: Always ensure proper access to DB resources before any read/write operations
+  - Usually done via `organizationId` field on objects or their parents
+- **Use DAL pattern**: 
+  - Use existing data access code from `dal/*.ts` files
+  - Move reusable database code into DAL files when appropriate
+  - Don't write direct database queries outside of DAL layer
+
+
+## Code Style Guidelines
+
+1. **Components**: Use functional components with TypeScript
+2. **State Management**: Prefer React hooks and context
+3. **Styling**: Use Tailwind CSS utility classes
+4. **File Naming**: Use kebab-case for files, PascalCase for components
+5. **Imports**: Let Prettier organize imports automatically
+
+## Testing Guidelines
+
+- Tests use Vitest
+- Test files should be colocated with source files as `*.test.ts` or `*.test.tsx`
+- Run tests with `npm test` or `npm run ci:test` for CI
+
+## Common Patterns
+
+### API Routes
+Located in `src/server/` using TanStack Start server functions.
+
+### Database Queries
+Use Drizzle ORM with typed schemas from `drizzle/schema.ts`.
+
+### Authentication
+Using Better Auth library configured in the project.
+
+## Troubleshooting
+
+1. **TypeScript errors**: Run `npm run check` to see all type errors
+2. **Lint errors**: Run `npm run lint` to identify and fix linting issues
+3. **Database issues**: Ensure Docker is running and use `npm run db:dev`
+
+
+
+## Linear Integration
+
+The project includes Linear SDK integration for issue tracking and project management.

package/.github/workflows/ci-cd.yml

@@ -0,0 +1,141 @@
+name: CI/CD
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    types: [opened, reopened, synchronize]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: "pnpm"
+
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm run --filter "{apps/**}^..." build
+
+      - name: Cache build outputs
+        uses: actions/cache/save@v4
+        with:
+          path: |
+            apps/*/dist
+            libs/*/dist
+            packages/*/dist
+          key: build-${{ github.sha }}
+
+  migrations:
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: "pnpm"
+
+      - run: pnpm install --frozen-lockfile
+
+      - name: Restore build cache
+        uses: actions/cache/restore@v4
+        with:
+          path: |
+            apps/*/dist
+            libs/*/dist
+            packages/*/dist
+          key: build-${{ github.sha }}
+
+      - name: Check migrations
+        run: |
+          cd apps/main
+          pnpm run db:generate
+          if git diff --exit-code drizzle/; then
+            echo "✅ Migrations are up to date"
+          else
+            echo "❌ Schema changes detected but migrations not generated"
+            echo "Run: cd apps/main && pnpm run db:generate"
+            exit 1
+          fi
+
+  lint:
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: "pnpm"
+
+      - run: pnpm install --frozen-lockfile
+
+      - name: Restore build cache
+        uses: actions/cache/restore@v4
+        with:
+          path: |
+            apps/*/dist
+            libs/*/dist
+            packages/*/dist
+          key: build-${{ github.sha }}
+
+      - run: pnpm run -r ci:fmt
+      - run: pnpm run -r ci:lint
+
+  typecheck:
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: "pnpm"
+
+      - run: pnpm install --frozen-lockfile
+
+      - name: Restore build cache
+        uses: actions/cache/restore@v4
+        with:
+          path: |
+            apps/*/dist
+            libs/*/dist
+            packages/*/dist
+          key: build-${{ github.sha }}
+
+      - run: pnpm run -r ci:check
+
+  test:
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: "pnpm"
+
+      - run: pnpm install --frozen-lockfile
+
+      - name: Restore build cache
+        uses: actions/cache/restore@v4
+        with:
+          path: |
+            apps/*/dist
+            libs/*/dist
+            packages/*/dist
+          key: build-${{ github.sha }}
+
+      - run: pnpm run -r ci:test

package/CLAUDE.md

@@ -0,0 +1,337 @@
+# Claude Development Guidelines
+
+This document contains critical guidelines for AI assistants (Claude) working on this codebase.
+
+## Core Principles
+
+### 1. Understand the Monorepo Structure First
+
+**Before planning any task, check the monorepo structure to understand which package is responsible for what.**
+
+This is a pnpm workspace monorepo with the following structure:
+
+```
+sea/
+├── apps/                          # Application packages
+│   ├── api/                       # REST API service (Fastify)
+│   ├── conversion-worker/         # Document conversion worker
+│   ├── main/                      # Main React web application (TanStack Start)
+│   ├── posthog-proxy/            # PostHog analytics proxy
+│   └── workers/                   # Hatchet async workers
+│
+├── libs/                          # Shared library packages
+│   ├── ai/                        # AI/LLM integration (agents, tools, prompts)
+│   ├── cache/                     # Caching utilities (Upstash Redis)
+│   ├── clients/                   # External service clients (Azure, GCP, Hatchet)
+│   ├── config/                    # Shared configuration
+│   ├── core/                      # Core business logic (data extraction, chat)
+│   ├── dal/                       # Data Access Layer (database queries)
+│   ├── db/                        # Database schema & migrations (Drizzle ORM)
+│   ├── lint/                      # Shared ESLint/Prettier config
+│   ├── schemas/                   # Zod schemas & TypeScript types
+│   │   ├── core/                  # Core API schemas (agent-runtime, submission, etc.)
+│   │   └── db/                    # Database schema validators
+│   ├── ui/                        # React UI components (shadcn/ui)
+│   ├── util/                      # Utility functions
+│   ├── validators/                # Validation logic (chart configs, etc.)
+│   ├── widget/                    # Embeddable widget (React)
+│   └── widget-ng/                 # Angular widget (separate codebase)
+│
+├── scripts/                       # Deployment & maintenance scripts
+└── tests/                         # Test applications
+```
+
+### 2. Never Duplicate - Always Reuse
+
+**Never create a function, type, or component for something that already exists.**
+
+Before implementing anything:
+1. Search for existing implementations using Grep/Glob
+2. Check the appropriate package (see package responsibilities below)
+3. Reuse and extend rather than duplicate
+
+### 3. Package Placement - Put Things in the Right Place
+
+**Always put things in the right package to enable sharing across the monorepo.**
+
+#### Package Responsibilities
+
+| Package | Purpose | What Goes Here |
+|---------|---------|----------------|
+| `@sea/schemas` | Type definitions & validation | - Zod schemas<br>- TypeScript types exported from schemas<br>- API request/response types<br>- Database schema validators |
+| `@sea/db` | Database layer | - Drizzle table definitions<br>- Database relations<br>- Schema types (`$inferSelect`)<br>- Migrations |
+| `@sea/dal` | Data access | - Database query functions<br>- CRUD operations<br>- Business logic queries<br>- Result types (`DalResult`) |
+| `@sea/core` | Business logic | - Data extraction logic<br>- Chat/conversation logic<br>- Agent execution<br>- Core workflows |
+| `@sea/ai` | AI/LLM features | - Agent definitions<br>- Tool definitions<br>- Prompts<br>- LLM integrations |
+| `@sea/ui` | UI components | - Reusable React components<br>- shadcn/ui wrappers<br>- Design system tokens |
+| `@sea/util` | Utilities | - Pure utility functions<br>- Helpers<br>- Common algorithms |
+| `@sea/clients` | External services | - API clients (Azure, GCP)<br>- Service integrations<br>- Client configurations |
+| `@sea/config` | Configuration | - Environment config<br>- Shared constants<br>- Feature flags |
+| `@sea/validators` | Validation logic | - Complex validators<br>- Business rule validators<br>- Format validators |
+
+#### Type & Schema Flow
+
+```
+1. Define schema in @sea/schemas
+   ├── Create Zod schema
+   └── Export inferred TypeScript type
+
+2. Use schema in @sea/dal
+   ├── Import schema for validation
+   └── Use DB types from @sea/db
+
+3. Use in business logic
+   ├── Import types from @sea/schemas
+   └── Import functions from @sea/dal
+```
+
+**If unclear about placement, always verify first before making assumptions.**
+
+### 4. Strict Typing - Never Use `any`
+
+**There is literally never a good reason to use the `any` type.**
+
+#### Rules
+- ✅ Use `unknown` for truly unknown data that will be validated
+- ✅ Use proper type inference from Zod schemas
+- ✅ Use generic types with constraints
+- ✅ Use database types from `@sea/db/types` - NEVER use `$inferSelect` outside of `@sea/db`
+- ❌ NEVER use `any` - this rule has no exceptions
+
+#### Examples
+
+**Bad:**
+```typescript
+// ❌ Don't use any
+function process(data: any) {
+  return data.foo;
+}
+
+// ❌ Don't use $inferSelect outside @sea/db
+import { schema } from '@sea/db';
+type User = typeof schema.user.$inferSelect;
+```
+
+**Good:**
+```typescript
+// ✅ For unknown data that will be validated
+function process(data: unknown) {
+  const validated = mySchema.parse(data);
+  return validated.foo;
+}
+
+// ✅ For generic types
+function process<T extends { foo: string }>(data: T) {
+  return data.foo;
+}
+
+// ✅ For database types - import from @sea/db/types
+import type { User } from '@sea/db/types';
+function process(user: User) {
+  return user.email;
+}
+```
+
+#### Database Types Rule
+
+**CRITICAL:** `$inferSelect` and `$inferInsert` should ONLY be used in `@sea/db` package to define types.
+
+All database types must be:
+1. Inferred in `@sea/db/src/types.ts` using `$inferSelect`
+2. Exported from `@sea/db/types`
+3. Imported and used everywhere else
+
+```typescript
+// ❌ WRONG - Don't do this outside @sea/db
+import { schema } from '@sea/db';
+type Submission = typeof schema.submission.$inferSelect;
+
+// ✅ CORRECT - Import the type from @sea/db/types
+import type { Submission } from '@sea/db/types';
+```
+
+## Development Workflow
+
+### ⚠️ CRITICAL: Always Run Type Check
+
+**BEFORE marking any phase or task as complete, ALWAYS run type checking:**
+
+```bash
+# Check the packages you modified
+pnpm --filter @sea/main exec tsc --noEmit
+pnpm --filter @sea/workers exec tsc --noEmit
+pnpm --filter @sea/core exec tsc --noEmit
+pnpm --filter @sea/dal exec tsc --noEmit
+pnpm --filter @sea/db build  # db needs build, not just typecheck
+```
+
+**Fix ALL TypeScript errors before proceeding.** No exceptions.
+
+### Progress Tracking for Multi-Session Work
+
+**IMPORTANT:** For tasks that span multiple Claude Code sessions, use the progress tracking system in `.claude/tasks/`.
+
+#### Continuing an Existing Task
+
+**Before starting work**, check if there's already a task in progress:
+
+```bash
+# List active tasks
+ls .claude/tasks/
+
+# Read the task file
+cat .claude/tasks/dag-pipeline-implementation.md
+```
+
+**Key steps:**
+1. **Read the task file completely** - Understand what's been completed
+2. **Check the todo list** - Find the next item to work on
+3. **Update as you go** - Check off completed items, add notes
+4. **⚠️ Run type check** after making changes (see commands above)
+5. **Commit progress** - Update the task file regularly
+
+#### Starting a New Task
+
+If starting a new multi-session task:
+
+1. **Create a task file**: `.claude/tasks/{feature-area}-{brief-description}.md`
+   - Use the template from existing tasks
+   - Include: overview, progress tracker, todos, decisions, next session instructions
+
+2. **Update the index**: Add your task to `.claude/tasks/README.md`
+
+3. **Update regularly** as you complete work
+
+See [.claude/tasks/README.md](.claude/tasks/README.md) for detailed guidelines.
+
+### Before Starting Any Task
+
+1. **Check for existing progress tracking**
+   - Look in `.claude/tasks/` for related work
+   - Read any existing task files to avoid duplication
+
+2. **Understand the scope**
+   - What packages are involved?
+   - Does similar functionality exist?
+   - Which package should own the new code?
+
+3. **Search for existing code**
+   ```bash
+   # Search for similar functions
+   grep -r "functionName" libs/
+
+   # Find type definitions
+   grep -r "type TypeName" libs/schemas/
+   ```
+
+4. **Check package dependencies**
+   - Ensure you're not creating circular dependencies
+   - Verify the package has access to dependencies it needs
+
+### When Adding New Functionality
+
+1. **Types/Schemas** → Start in `@sea/schemas`
+2. **Database Tables** → Define in `@sea/db`
+3. **Database Queries** → Implement in `@sea/dal`
+4. **Business Logic** → Implement in `@sea/core` or `@sea/ai`
+5. **UI Components** → Add to `@sea/ui` (if reusable) or app (if specific)
+6. **⚠️ RUN TYPE CHECK** → Verify no errors (see type check section above)
+
+### Common Patterns
+
+#### Database Query Pattern
+```typescript
+// 1. Define schema in @sea/schemas/core/
+export const myDataSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+});
+export type MyData = z.infer<typeof myDataSchema>;
+
+// 2. Define table in @sea/db
+export const myTable = pgTable('my_table', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+});
+
+// 3. Create DAL function in @sea/dal
+export async function getMyData(id: string): Promise<DalResult<MyData>> {
+  const result = await db.query.myTable.findFirst({
+    where: eq(schema.myTable.id, id),
+  });
+  if (!result) return { ok: false, error: 'not-found' };
+  return { ok: true, data: result };
+}
+```
+
+#### Type Import Pattern
+```typescript
+// Always import types from their source package
+import type { MyData } from '@sea/schemas/core/my-data';
+import type { Member } from '@sea/db/types';
+import { getMyData } from '@sea/dal/my-data';
+```
+
+## Anti-Patterns to Avoid
+
+❌ Defining types inline in DAL/Core when they should be in schemas
+❌ Using dynamic inline imports with const x = await import("y") - all imports should be at the top of file and static
+❌ Duplicating database queries across files
+❌ Using `any` type anywhere
+❌ Using `$inferSelect` or `$inferInsert` outside of `@sea/db`
+❌ Creating new packages without discussion
+❌ Putting business logic in UI components
+❌ Hardcoding values that should be in config
+❌ Bypassing the DAL to query the database directly
+
+## Quick Reference
+
+### Finding Things
+
+```bash
+# Find type definitions
+grep -r "export type TypeName" libs/schemas/
+
+# Find database queries
+grep -r "export async function" libs/dal/
+
+# Find React components
+find libs/ui -name "*.tsx"
+
+# Find agent/tool definitions
+find libs/ai -name "*.ts"
+```
+
+### Adding Dependencies
+
+```bash
+# Add to a specific package
+pnpm --filter @sea/package-name add dependency-name
+
+# Add workspace dependency
+# Edit package.json and add:
+# "@sea/other-package": "workspace:*"
+```
+
+### Building & Testing
+
+```bash
+# Build a package and its dependencies
+pnpm --filter @sea/package-name build
+
+# Run type checking
+pnpm --filter @sea/package-name exec tsc --noEmit
+
+# Format and lint
+pnpm --filter @sea/package-name fmt
+pnpm --filter @sea/package-name lint
+```
+
+## Summary
+
+1. ✅ **Understand the monorepo structure** before starting
+2. ✅ **Reuse existing code** - search before creating
+3. ✅ **Put code in the right package** - schemas, db, dal, core, ai, ui
+4. ✅ **Never use `any`** - use proper TypeScript types
+
+When in doubt, ask or verify rather than assume!