Pathwise

A modern job application tracking system with both web interface and programmatic access. Built with Go, templ, HTMX, and SQLite, Pathwise helps you organize and track your job search with features like status updates, notes, salary tracking, timeline views, and export capabilities.

Components

• Web Application: Interactive web interface for managing job applications
• MCP Server: Model Context Protocol server providing programmatic access to your job data
• Jobs Processor: Background service that scrapes job postings from Hacker News and processes them with AI/LLM integration

Note: This follows standard Go project layout with applications in cmd/ and private code in internal/. Commands should be run from the project root unless otherwise specified.

Features

• Application Tracking: Track where you've applied, position details, application dates, and current status
• Status Management: Monitor applications through stages (applied, interviewing, offered, rejected, etc.)
• Notes & Timeline: Add notes and view a complete timeline of your application history
• Salary Tracking: Record salary ranges and currency for each position
• Archive System: Archive old applications to keep your active list focused
• Export Functionality: Export your data in various formats
• Responsive Design: Works seamlessly on desktop and mobile devices
• User Authentication: Secure login system with session management
• HN Job Scraping: Automated scraping of job postings from Hacker News with AI-powered processing
• MCP Integration: Programmatic access via Model Context Protocol for AI assistants and automation

MCP Server

The MCP (Model Context Protocol) server provides programmatic access to your job application data for AI assistants and automation tools.

Authentication

Generate an API key through the web application settings, then configure your MCP client with the key and server URL.

Tech Stack

• Backend: Go 1.25.0+ with standard library HTTP server
• Frontend: templ templates with HTMX for dynamic interactions
• Database: SQLite with sqlc for type-safe queries
• Styling: Tailwind CSS processed with go-tw
• Testing: Go testing with Playwright for E2E tests
• Development: Air for hot reloading

Prerequisites

• Go 1.25.0+ - Download Go
• Air (optional, for development) - go install github.com/air-verse/air@latest
• golangci-lint (optional, for linting) - Installation guide

Quick Start

1. Clone the repository

   git clone https://github.com/Piszmog/pathwise.git
   cd pathwise

2. Install dependencies

   go mod download

3. Generate code and build assets

   go tool templ generate -path ./internal/ui/components
   go tool go-tw -i ./internal/ui/styles/input.css -o ./internal/ui/dist/assets/css/[email protected]
   go tool sqlc generate

4. Run the application

   cd cmd/ui && air
   
   cd cmd/mcp && air
   
   export GEMINI_API_KEY=your_api_key_here
   cd cmd/jobs && air

5. Open your browser Navigate to http://localhost:8080

Environment Variables

Variable	Description	Default
PORT	Server port	8080
LOG_LEVEL	Logging level (debug, info, warn, error)	info
LOG_OUTPUT	Log output (stdout or file path)	stdout
DB_URL	Database URL	./db.sqlite3
DB_TOKEN	Database token (for remote databases)	-
DB_PRIMARY_URL	Primary database URL (used by jobs and mcp for write operations)	-
DB_TOKEN_READONLY	Read-only database token (used by mcp)	-
ENC_KEY	Encryption key for sensitive data	-
URL_SEARCH	Search service URL (used by ui)	-
GEMINI_API_KEY	Google Gemini API key (required for jobs processor)	-
VERSION	Application version (used by ui and mcp)	-

Development

Commands

# Development servers with hot reload
cd cmd/ui && air
cd cmd/mcp && air
cd cmd/jobs && air

# Build applications
go build -o ./tmp/main ./cmd/ui
go build -o ./tmp/mcp ./cmd/mcp
go build -o ./tmp/jobs ./cmd/jobs

# Run tests
go test ./...
go test -tags=e2e ./internal/ui/e2e/...
go test ./internal/mcp/tool/... -tags=integration

# Lint code
golangci-lint run

# Generate code (templates, CSS, SQL)
go tool templ generate -path ./internal/ui/components
go tool go-tw -i ./internal/ui/styles/input.css -o ./internal/ui/dist/assets/css/[email protected]
go tool sqlc generate

Code Generation

The project uses several code generation tools:

• templ: Compiles .templ files to Go code for type-safe HTML templates
• sqlc: Generates type-safe Go code from SQL queries
• go-tw: Processes Tailwind CSS for styling

Testing

go test ./...

go test -tags=e2e ./internal/ui/e2e/...

go test ./internal/mcp/tool/... -tags=integration

go test ./internal/ui/server/handler -run TestJobHandler

Deployment

Docker

# Build application images
docker build -f cmd/ui/Dockerfile -t pathwise-ui .
docker build -f cmd/mcp/Dockerfile -t pathwise-mcp .
docker build -f cmd/jobs/Dockerfile -t pathwise-jobs .

# Run containers
docker run -p 8080:8080 pathwise-ui
docker run -p 8081:8080 pathwise-mcp
docker run -e GEMINI_API_KEY=your_key pathwise-jobs

Manual Deployment

1. Build the applications:

   go build -o pathwise-ui ./cmd/ui
   go build -o pathwise-mcp ./cmd/mcp
   go build -o pathwise-jobs ./cmd/jobs

2. Set environment variables as needed
3. Run the binaries:

   ./pathwise-ui
   ./pathwise-mcp
   ./pathwise-jobs

Contributing

1. Fork the repository
2. Create a feature branch: git checkout -b feature-name
3. Make your changes and add tests
4. Run tests and linting: go test ./... && golangci-lint run
5. Commit your changes: git commit -am 'Add feature'
6. Push to the branch: git push origin feature-name
7. Submit a pull request

Related Projects

• Desktop version - A desktop application with similar functionality

License

See LICENSE for details.