feat: Migrate Devlog from Go to Rust

- Changed the implementation language from Go to Rust, updating the README to reflect this change.
- Updated dependencies in Cargo.toml files for various modules.
- Implemented the Cursor adapter for log parsing and added tests for it.
- Enhanced the BackfillManager to support directory scanning and batch processing of log files.
- Added integration tests for the CLI server to ensure health checks and event ingestion work correctly.
- Updated configuration structures to include backfill settings.
- Completed migration tasks and updated project status in documentation.

Author: Marvin Zhang

CONTRIBUTING.md

@@ -1,25 +1,21 @@
 # Contributing to Devlog
 
-A Go-based AI agent event collector. This document explains the project structure and development workflow.
+A Rust-based AI agent event collector. This document explains the project structure and development workflow.
 
 ## Project Structure
 
 ```
 devlog/
-├── cmd/
-│   └── devlog/           # CLI entry point (Cobra)
-├── internal/
-│   ├── adapters/         # Agent-specific log parsers
-│   ├── backfill/         # Historical log processing
-│   ├── buffer/           # SQLite offline event buffer
-│   ├── client/           # HTTP client for remote endpoints
-│   ├── config/           # Configuration management
-│   ├── hierarchy/        # Workspace/project resolution
-│   ├── integration/      # Integration tests
-│   └── watcher/          # File system watching
-├── pkg/
-│   ├── models/           # Data models
-│   └── types/            # Event types and constants
+├── rust/
+│   ├── devlog-cli/       # CLI entry point (clap)
+│   ├── devlog-adapters/  # Agent-specific log parsers
+│   ├── devlog-backfill/  # Historical log processing
+│   ├── devlog-buffer/    # SQLite offline event buffer
+│   ├── devlog-core/      # Shared types and config
+│   ├── devlog-hierarchy/ # Workspace/project resolution
+│   └── devlog-watcher/   # File system watching with notify
+├── cmd/                  # Legacy Go CLI (deprecated)
+├── internal/             # Legacy Go internal packages (deprecated)
 ├── configs/              # Default configuration files
 ├── docs/                 # Documentation
 └── specs/                # Feature specifications
@@ -29,7 +25,7 @@ devlog/
 
 ### Prerequisites
 
-- Go 1.24+
+- Rust 1.75+
 - Make
 
 ### Initial Setup
@@ -39,9 +35,6 @@ devlog/
 git clone https://github.com/codervisor/devlog.git
 cd devlog
 
-# Download dependencies
-make deps
-
 # Build the binary
 make build
 ```
@@ -50,63 +43,60 @@ make build
 
 ```bash
 make build         # Build for current platform
-make build-all     # Build for macOS, Linux, Windows (all architectures)
 make clean         # Remove build artifacts
 make install       # Install to /usr/local/bin
 ```
 
 ### Development
 
 ```bash
-make dev           # Run with live reload (requires air)
 make run           # Build and run
 make fmt           # Format code
-make lint          # Run golangci-lint
+make lint          # Run clippy
 ```
 
 ### Testing
 
 ```bash
-make test          # Run all tests with race detection
-make test-coverage # Generate HTML coverage report
+make test          # Run all tests
 ```
 
 ## Adding a New Agent Adapter
 
 To add support for a new AI coding agent:
 
-1. Create a new file in `internal/adapters/` (e.g., `myagent_adapter.go`)
-2. Implement the `AgentAdapter` interface:
+1. Create a new file in `rust/devlog-adapters/src/` (e.g., `myagent.rs`)
+2. Implement the `AgentAdapter` trait:
 
-```go
-type AgentAdapter interface {
-    Name() string
-    ParseLogLine(line string) (*types.AgentEvent, error)
-    ParseLogFile(filePath string) ([]*types.AgentEvent, error)
-    SupportsFormat(sample string) bool
+```rust
+#[async_trait]
+pub trait AgentAdapter: Send + Sync {
+    fn name(&self) -> &str;
+    fn parse_log_line(&self, line: &str) -> Result<Option<AgentEvent>>;
+    async fn parse_log_file(&self, file_path: &Path) -> Result<Vec<AgentEvent>>;
+    fn supports_format(&self, sample: &str) -> bool;
 }
 ```
 
-3. Register in `internal/adapters/registry.go`
-4. Add log discovery paths in `internal/watcher/discovery.go`
-5. Add tests in `internal/adapters/myagent_adapter_test.go`
+3. Register in `rust/devlog-adapters/src/lib.rs` and `rust/devlog-cli/src/main.rs`
+4. Add tests in `rust/devlog-adapters/src/myagent.rs`
 
 ## Code Style
 
-- Follow standard Go conventions
+- Follow standard Rust conventions
 - Use `make fmt` before committing
 - Use `make lint` to check for issues
 - Add tests for new functionality
-- Keep functions focused and well-documented
 
 ## Architecture Decisions
 
-### Why Go?
+### Why Rust?
 
-- Single static binary - no runtime dependencies
-- Low memory footprint for always-on daemon
-- Excellent file watching and concurrent I/O
-- Cross-platform support (macOS, Linux, Windows)
+- Memory safety without garbage collection
+- Zero-cost abstractions
+- Excellent performance for parsing and I/O
+- Strong type system with Result/Option
+- Single static binary
 
 ### Design Principles
 
@@ -118,7 +108,7 @@ type AgentAdapter interface {
 ## Pull Request Guidelines
 
 1. Fork the repository
-2. Create a feature branch from `develop`
+2. Create a feature branch
 3. Make your changes with tests
 4. Run `make test` and `make lint`
 5. Submit a PR with a clear description

Makefile

@@ -2,19 +2,9 @@
 
 # Binary name
 BINARY_NAME=devlog
-VERSION?=1.0.0
+VERSION?=0.1.0
 BUILD_DIR=bin
-
-# Go parameters
-GOCMD=go
-GOBUILD=$(GOCMD) build
-GOCLEAN=$(GOCMD) clean
-GOTEST=$(GOCMD) test
-GOGET=$(GOCMD) get
-GOMOD=$(GOCMD) mod
-
-# Build flags
-LDFLAGS=-ldflags "-X main.version=$(VERSION) -s -w"
+RUST_DIR=rust
 
 # Default target
 all: clean build
@@ -23,53 +13,31 @@ all: clean build
 build:
 	@echo "Building $(BINARY_NAME) for current platform..."
 	@mkdir -p $(BUILD_DIR)
-	$(GOBUILD) $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME) ./cmd/devlog
+	cd $(RUST_DIR) && cargo build --release
+	cp $(RUST_DIR)/target/release/devlog-cli $(BUILD_DIR)/$(BINARY_NAME)
 
-# Build for all platforms
+# Build for all platforms (requires cross-compilation setup)
 build-all: clean
 	@echo "Building for all platforms..."
 	@mkdir -p $(BUILD_DIR)
 
-	@echo "Building for macOS (Intel)..."
-	GOOS=darwin GOARCH=amd64 $(GOBUILD) $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-darwin-amd64 ./cmd/devlog
-	
-	@echo "Building for macOS (Apple Silicon)..."
-	GOOS=darwin GOARCH=arm64 $(GOBUILD) $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-darwin-arm64 ./cmd/devlog
-	
-	@echo "Building for Linux (amd64)..."
-	GOOS=linux GOARCH=amd64 $(GOBUILD) $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-amd64 ./cmd/devlog
-	
-	@echo "Building for Linux (arm64)..."
-	GOOS=linux GOARCH=arm64 $(GOBUILD) $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm64 ./cmd/devlog
+	@echo "Building for current platform..."
+	cd $(RUST_DIR) && cargo build --release
+	cp $(RUST_DIR)/target/release/devlog-cli $(BUILD_DIR)/$(BINARY_NAME)
 
-	@echo "Building for Windows (amd64)..."
-	GOOS=windows GOARCH=amd64 $(GOBUILD) $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-windows-amd64.exe ./cmd/devlog
-	
-	@echo "Build complete! Binaries in $(BUILD_DIR)/"
+	@echo "Build complete! Binary in $(BUILD_DIR)/"
 	@ls -lh $(BUILD_DIR)/
 
 # Clean build artifacts
 clean:
 	@echo "Cleaning..."
-	@$(GOCLEAN)
+	cd $(RUST_DIR) && cargo clean
 	@rm -rf $(BUILD_DIR)
 
 # Run tests
 test:
 	@echo "Running tests..."
-	$(GOTEST) -v -race -coverprofile=coverage.txt -covermode=atomic ./...
-
-# Run tests with coverage report
-test-coverage: test
-	@echo "Generating coverage report..."
-	@go tool cover -html=coverage.txt -o coverage.html
-	@echo "Coverage report: coverage.html"
-
-# Download dependencies
-deps:
-	@echo "Downloading dependencies..."
-	$(GOMOD) download
-	$(GOMOD) tidy
+	cd $(RUST_DIR) && cargo test
 
 # Install binary to system
 install: build
@@ -78,31 +46,19 @@ install: build
 	@echo "Installed to /usr/local/bin/$(BINARY_NAME)"
 
 # Run the collector (development)
-run: build
+run:
 	@echo "Running $(BINARY_NAME)..."
-	@$(BUILD_DIR)/$(BINARY_NAME) start
-
-# Run with live reload (requires air: go install github.com/cosmtrek/air@latest)
-dev:
-	@if command -v air > /dev/null; then \
-		air; \
-	else \
-		echo "Error: 'air' not found. Install with: go install github.com/cosmtrek/air@latest"; \
-		exit 1; \
-	fi
+	cd $(RUST_DIR) && cargo run -- start
 
 # Format code
 fmt:
 	@echo "Formatting code..."
-	@go fmt ./...
+	cd $(RUST_DIR) && cargo fmt
 
-# Lint code (requires golangci-lint)
+# Lint code
 lint:
-	@if command -v golangci-lint > /dev/null; then \
-		golangci-lint run; \
-	else \
-		echo "Warning: golangci-lint not found. Install from https://golangci-lint.run/"; \
-	fi
+	@echo "Linting code..."
+	cd $(RUST_DIR) && cargo clippy -- -D warnings
 
 # Show help
 help:
@@ -112,11 +68,8 @@ help:
 	@echo "  make build-all     - Build for all platforms"
 	@echo "  make clean         - Remove build artifacts"
 	@echo "  make test          - Run tests"
-	@echo "  make test-coverage - Run tests with coverage report"
-	@echo "  make deps          - Download dependencies"
 	@echo "  make install       - Install to /usr/local/bin"
 	@echo "  make run           - Build and run"
-	@echo "  make dev           - Run with live reload (requires air)"
 	@echo "  make fmt           - Format code"
-	@echo "  make lint          - Lint code (requires golangci-lint)"
+	@echo "  make lint          - Lint code"
 	@echo "  make help          - Show this help"