Implementation Roadmap

Phase Overview

gantt
    title Kairos Implementation Phases
    dateFormat YYYY-MM-DD
    axisFormat %b %d

    section Phase 1 Skeleton + API
    Workspace + Entities + Traits       :p1a, 2026-03-27, 2d
    Config + SQLite + Migrations        :p1b, after p1a, 1d
    axum Server + Core Routes           :p1c, after p1a, 2d
    kairos-client Library               :p1d, after p1c, 1d

    section Phase 2 Seek Search
    SeekClient + Parser                 :p2a, after p1d, 3d
    SQLite Job Repository               :p2b, after p1b, 1d
    Job Search + List API Endpoints     :p2c, after p2a, 1d

    section Phase 3 LLM Analysis
    rig-core Claude Client              :p3a, after p2c, 2d
    JD Analysis + Match Scoring         :p3b, after p3a, 2d
    Analysis API Endpoints              :p3c, after p3b, 1d

    section Phase 4 Resume Tailoring
    LaTeX Parser                        :p4a, after p3c, 2d
    Tailoring Prompts + Validation      :p4b, after p4a, 3d
    Resume API Endpoints + WebSocket    :p4c, after p4b, 1d

    section Phase 5 CLI
    clap Commands + kairos-client       :p5a, after p1d, 3d
    Output Formatting (table/JSON)      :p5b, after p5a, 1d

    section Phase 6 Apply + Track
    Apply Workflow + Browser Open       :p6a, after p4c, 1d
    Application Tracking                :p6b, after p6a, 2d
    Indeed + LinkedIn Adapters          :p6c, after p6a, 3d

    section Phase 7 Polish
    Error Handling + Edge Cases         :p7a, after p6c, 2d
    CLI UX Polish                       :p7b, after p7a, 2d

    section Phase 8 Web Frontend
    React Project Setup                 :p8a, after p7b, 2d
    Core Views (Search + Jobs + Resume) :p8b, after p8a, 5d
    Dashboard + Application Tracking    :p8c, after p8b, 3d

Phase Details

Phase 1: Skeleton + API

Goal: Compilable workspace with a running API server and shared client library.

Init cargo workspace with all crates
Define all entities in kairos-core
Define all traits (Repository + Service)
Define error types per crate
Config loading (TOML + XDG paths)
SQLite setup + migration V1
axum server with health check, response envelope, middleware stack
kairos-client library with typed API methods

Verify: cargo build succeeds. curl localhost:3001/api/health returns 200.

Phase 2: Seek Search

Goal: Search Seek.com.au via API.

SeekClient with HTTP + HTML parsing
Rate limiter with randomized delays
SqliteJobRepository
API endpoints: POST /api/jobs/search, GET /api/jobs, GET /api/jobs/:id
kairos-client: client.jobs().search(), client.jobs().list()

Verify: curl -X POST localhost:3001/api/jobs/search -d '{"keywords":"rust","location":"perth"}' returns Seek results.

Phase 3: LLM Analysis

Goal: Analyze JDs with Claude via API.

rig-core client setup
JD analysis prompt templates
Analyzer implementation
API endpoints: POST /api/jobs/:id/analyze, GET /api/jobs/:id/analysis
Match score computation

Verify: POST /api/jobs/:id/analyze returns analysis with match score.

Phase 4: Resume Tailoring

Goal: Import resume, tailor per JD via API, with WebSocket streaming.

LaTeX section parser
Resume import flow
SqliteResumeRepository
Tailoring prompts with anti-hallucination
Validation step
API endpoints: resume CRUD, POST /api/resumes/:id/tailor
WebSocket streaming for tailoring progress

Verify: Full resume flow works via API: import → tailor → approve.

Phase 5: CLI

Goal: Lightweight command-line client for scripting and daily use.

clap derive-based command parsing
Uses kairos-client for all API calls
Commands: jobs search, jobs list, resume import, resume tailor, applications list
Output formatting: table (default) and JSON (--json flag)
Auto-spawn local server if not running
Interactive approve/reject flow for resume tailoring

Verify: kairos jobs search "rust" --location perth returns results.

Phase 6: Apply + Track

Goal: Complete semi-automatic workflow.

Apply action (open browser with application URL)
Application tracking API endpoints
Indeed adapter (chromiumoxide)
LinkedIn adapter

Verify: Full flow: search → analyze → tailor → apply → track.

Phase 7: Polish

Goal: Production-quality UX.

Graceful error handling across API and CLI
CLI: colorized output, progress spinners, help text
Resume export (PDF/LaTeX)
API rate limits, retries, and edge case handling

Phase 8: Web Frontend (React)

Goal: Browser-based access to all Kairos features.

React project setup with TypeScript
Core views: search, job list, job detail, resume management
LLM streaming via WebSocket (real-time analysis/tailoring progress)
Dashboard with application pipeline and statistics
Responsive design for mobile access

Verify: Open browser → search → analyze → tailor → track — full workflow.

Definition of Done

All crates build with cargo build
cargo clippy passes with no warnings
Core workflow works end-to-end (search → analyze → tailor → apply → track)
At least Seek adapter is fully functional
Resume tailoring produces valid LaTeX output
API server handles all core operations via REST + WebSocket
CLI can perform the full workflow via API
All frontends produce consistent behavior through the unified API
API keys and JWT secrets handled securely (env var or config, never logged)

Keyboard shortcuts

Kairos