DWS/onyx-prebootstrap
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

temp for tree extraction

Browse Source
This commit is contained in:
Tanishq Dubey
2025-10-15 19:13:35 -04:00
commit 89fb7a30f7
50 changed files with 8769 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
.claude/settings.local.json Normal file
View File

@ -0,0 +1,32 @@
{
"permissions": {
"allow": [
"Bash(go get:*)",
"Bash(go build:*)",
"Bash(tree:*)",
"Bash(go mod tidy:*)",
"Bash(./bin/onx:*)",
"Bash(go test:*)",
"Read(//tmp/test-onyx/**)",
"Bash(cat:*)",
"Bash(/home/dubey/projects/onyx/bin/onx undo)",
"Bash(go install:*)",
"Bash(./bin/onxd:*)",
"Read(//home/dubey/projects/onyx-test/ccr-milestone-2-test/**)",
"Bash(/home/dubey/projects/onyx/bin/onx:*)",
"Bash(git show-ref:*)",
"Bash(xxd:*)",
"Bash(chmod:*)",
"Bash(make:*)",
"Bash(go list:*)",
"Bash(git log:*)",
"Bash(onx:*)",
"Read(//tmp/test-onyx-init/**)",
"Bash(git checkout:*)",
"Bash(xargs:*)",
"Bash(git ls-tree:*)"
],
"deny": [],
"ask": []
}
}

59
.gitea/workflows/ci.yml Normal file
View File

@ -0,0 +1,59 @@
name: CI
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main ]
jobs:
test:
name: Test
runs-on: ubuntu-latest
container: golang:1.24.2-alpine
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Download dependencies
run: go mod download
- name: Run tests
run: go test -v ./...
build:
name: Build
runs-on: ubuntu-latest
container: golang:1.24.2-alpine
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Download dependencies
run: go mod download
- name: Build
run: |
go build -o bin/onx ./cmd/onx
go build -o bin/onxd ./cmd/onxd
lint:
name: Lint
runs-on: ubuntu-latest
container: golang:1.24.2-alpine
steps:
- name: Install git
run: apk add --no-cache git
- name: Checkout code
uses: actions/checkout@v4
- name: Install golangci-lint
run: |
wget -O- -nv https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin v1.62.0
- name: Run golangci-lint
run: $(go env GOPATH)/bin/golangci-lint run --timeout=2m

35
.gitignore vendored Normal file
View File

@ -0,0 +1,35 @@
# If you prefer the allow list template instead of the deny list, see community template:
# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
#
# Binaries for programs and plugins
*.exe
*.exe~
*.dll
*.so
*.dylib
# Test binary, built with `go test -c`
*.test
# Code coverage profiles and other test artifacts
*.out
coverage.*
*.coverprofile
profile.cov
# Dependency directories (remove the comment below to include it)
# vendor/
# Go workspace file
go.work
go.work.sum
# env file
.env
# Editor/IDE
# .idea/
# .vscode/
bin/
.onx/

102
.golangci.yml Normal file
View File

@ -0,0 +1,102 @@
run:
timeout: 5m
modules-download-mode: readonly
output:
format: colored-line-number
print-issued-lines: true
print-linter-name: true
uniq-by-line: true
linters-settings:
govet:
check-shadowing: true
golint:
min-confidence: 0.8
gocyclo:
min-complexity: 15
maligned:
suggest-new: true
dupl:
threshold: 100
goconst:
min-len: 2
min-occurrences: 2
misspell:
locale: US
lll:
line-length: 140
goimports:
local-prefixes: git.dws.rip/DWS/onyx
gocritic:
enabled-tags:
- diagnostic
- experimental
- opinionated
- performance
- style
disabled-checks:
- dupImport
- ifElseChain
- octalLiteral
- whyNoLint
- wrapperFunc
linters:
enable:
- bodyclose
- deadcode
- depguard
- dogsled
- dupl
- errcheck
- exportloopref
- exhaustive
- gochecknoinits
- goconst
- gocritic
- gocyclo
- gofmt
- goimports
- golint
- gomnd
- goprintffuncname
- gosec
- gosimple
- govet
- ineffassign
- interfacer
- lll
- misspell
- nakedret
- noctx
- nolintlint
- rowserrcheck
- scopelint
- staticcheck
- structcheck
- stylecheck
- typecheck
- unconvert
- unparam
- unused
- varcheck
- whitespace
issues:
exclude-rules:
- path: _test\.go
linters:
- gomnd
- funlen
- goconst
- path: cmd/
linters:
- gochecknoinits
exclude-use-default: false
max-issues-per-linter: 0
max-same-issues: 0
severity:
default-severity: error
case-sensitive: false

221
CLAUDE.md Normal file
View File

@ -0,0 +1,221 @@
# CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
## Project Overview
Onyx is a next-generation version control system designed as a superior user experience layer on top of Git. It provides transparent versioning, workstreams for stacked-diff management, and an action log for universal undo functionality. The project is written in Go and uses the go-git library for Git interaction.
## Development Commands
### Building
```bash
# Build the CLI and daemon
go build -o bin/onx ./cmd/onx
go build -o bin/onxd ./cmd/onxd
# Install to PATH
go install ./cmd/onx
go install ./cmd/onxd
```
### Testing
```bash
# Run all tests
go test -v ./...
# Run tests with coverage
go test -cover ./...
# Run specific test package
go test -v ./internal/core
```
### Development Setup
This is a Go 1.24.2 project. Initialize dependencies with:
```bash
go mod tidy
```
Key dependencies:
- `github.com/go-git/go-git/v5` - Git interaction
- `github.com/spf13/cobra` - CLI framework (planned)
- `github.com/fsnotify/fsnotify` - Filesystem monitoring (planned)
## Architecture
### Core Design Principles
- **100% Git Data Model Compatibility**: Uses standard .git directory for shared truth
- **Hybrid Storage**: .git for Git objects, .onx for Onyx-specific metadata
- **Transparent Versioning**: Background daemon creates continuous snapshots
- **Workstreams**: Stacked-diff workflow management
- **Action Log**: Transactional undo/redo capability
### Project Structure (Planned)
```
onyx/
├── cmd/
│ ├── onx/ # CLI entry point
│ └── onxd/ # Daemon entry point
├── internal/
│ ├── core/ # Core abstractions
│ ├── git/ # Git interaction layer
│ ├── models/ # Data models
│ ├── storage/ # .onx directory management
│ ├── commands/ # CLI command implementations
│ ├── daemon/ # Daemon implementation
│ └── utils/ # Utilities
├── pkg/ # Public APIs
├── test/ # Integration tests
└── docs/ # Documentation
```
### Key Components
#### 1. Repository (`internal/core/repository.go`)
Central object encapsulating access to both Git repository (via go-git) and Onyx metadata.
#### 2. Action Log (`internal/storage/oplog.go`)
Append-only binary log storing state before/after each operation for undo functionality.
#### 3. Workstreams (`internal/storage/workstreams.go`)
Manages stacked-diff workflows through .onx/workstreams.json.
#### 4. Daemon (`internal/daemon/`)
Background process using fsnotify for continuous snapshot creation.
## .onx Directory Structure
```
.onx/
├── oplog # Append-only binary action log
├── workstreams.json # Workstream definitions
├── workspace # Pointer to current ephemeral commit
├── rerere_cache/ # Git rerere conflict resolution cache
└── index.db # SQLite index (future feature)
```
## Core Commands (Phase 1)
| Command | Purpose | Git Equivalent |
|---------|---------|----------------|
| `onx init` | Initialize repository | `git init` |
| `onx new <name>` | Create workstream | `git checkout -b` |
| `onx save -m "msg"` | Save work | `git add && git commit` |
| `onx list` | List workstreams | `git branch` |
| `onx switch <name>` | Switch workstreams | `git checkout` |
| `onx sync` | Update with remote | `git pull --rebase` |
| `onx push` | Push workstream | `git push` |
| `onx push --stacked` | Push stacked diffs | N/A (advanced) |
| `onx undo` | Undo last operation | `git reflog && reset` |
## Push Workflows
Onyx supports two push workflows to match different development styles:
### Single-Branch Mode (Default) - Recommended for AI Development
```bash
onx push
```
**When to use:**
- Default for all standard feature development
- When creating traditional pull requests
- For AI-assisted development sessions
- When you want a clean remote repository UI
**What happens:**
- Pushes workstream as ONE branch named after the workstream
- Example: `milestone-4` branch contains all commits
- Remote UI shows single branch per workstream (clean)
- Perfect for creating GitHub/Gitea pull requests
**AI Development Guidance:**
Use this mode by default. It provides the cleanest integration with standard Git workflows and PR creation tools.
### Stacked Diffs Mode (Advanced)
```bash
onx push --stacked
```
**When to use:**
- Large, complex features requiring incremental review
- When each commit needs independent review/approval
- Meta/Google-style stacked diff workflows
- When explicitly requested by the user
**What happens:**
- Pushes EACH commit as a separate branch
- Example: `onyx/workstreams/milestone-4/commit-1`, `commit-2`, etc.
- Remote UI shows multiple branches (one per commit)
- Each branch can have its own pull request
**AI Development Guidance:**
Only use when specifically requested or when the feature is complex enough to warrant incremental review. The additional branches may clutter the remote UI.
## Implementation Status
This is currently a planning/prototype phase. The codebase contains:
- Go module setup
- Comprehensive architectural documentation in `notes/`
- Detailed implementation roadmap
- Technical specifications for core components
## Development Guidelines
### IMPORTANT: Dogfooding Policy
**This repository uses Onyx for its own development.** All development work MUST use Onyx commands exclusively:
- ✅ **Use `onx save -m "message"`** to commit changes (NOT `git commit`)
- ✅ **Use `onx new <name>`** to create feature branches (NOT `git checkout -b`)
- ✅ **Use `onx switch <name>`** to switch workstreams (NOT `git checkout`)
- ✅ **Use `onx sync`** to update from remote (NOT `git pull`)
- ✅ **Use `onx push`** to push to remote (NOT `git push`)
- ✅ **Use `onx undo`** to undo operations (NOT `git reset`)
- ✅ **Use `onx list`** to view workstreams (NOT `git branch`)
**Exception:** Only use `git` commands for:
- Initial remote setup (`git remote add`)
- Creating pull requests via GitHub CLI (`gh pr create`)
- Inspecting low-level Git state when debugging Onyx itself
This dogfooding validates our user experience and ensures Onyx works correctly for real-world development.
### Code Style
- Follow Go conventions and idioms
- Use structured logging (planned: zap or logrus)
- Implement proper error handling with custom error types
### Testing Strategy
- Unit tests for each component (target: 80% coverage)
- Integration tests for full workflows
- Benchmark tests for performance-critical paths
### Git Integration
- All repository data must remain compatible with standard Git clients
- Onyx operations should be reversible via standard Git commands
- Never break the underlying Git object model
## Key Algorithms
### Transparent Versioning
1. Daemon monitors filesystem with fsnotify
2. On changes (debounced 500ms), create Git tree snapshot
3. Create ephemeral commit with auto-generated message
4. Update refs/onyx/workspaces/current pointer
### Workstream Sync
1. Fetch latest from origin base branch
2. Sequentially rebase each commit in workstream stack
3. Use rerere for automated conflict resolution
4. Update all branch refs atomically
### Action Log Transaction
1. Capture state_before (all managed refs)
2. Execute command logic
3. Capture state_after
4. Write entry to oplog with both states
This architecture enables sophisticated workflows while maintaining full Git compatibility.

355
INTEGRATION.md Normal file
View File

@ -0,0 +1,355 @@
# Onyx Milestone 2 Integration Testing
## Overview
This document serves as a living record of integration testing for Onyx Milestone 2 (Transparent Versioning and onx save command). It captures test procedures, results, and action items for fixes needed.
---
## Test Environment
- **Location**: `/home/dubey/projects/onyx-test/ccr-milestone-2-test`
- **Onyx Binary**: `/home/dubey/projects/onyx/bin/onx`
- **Daemon Binary**: `/home/dubey/projects/onyx/bin/onxd`
- **Test Date**: 2025-10-10
---
## Test Execution Steps
### ✅ Step 1: Repository Initialization
**Command**: `/home/dubey/projects/onyx/bin/onx init`
**Results**:
- ✅ **PASS**: Init succeeded without errors
- ✅ **PASS**: `.git/` directory created
- ✅ **PASS**: `.onx/` directory created
- ✅ **PASS**: `.onx/workstreams.json` exists
- ✅ **PASS**: `.onx/oplog` file exists
- ✅ **PASS**: Initialize message displayed
**Issues Found**: None
**Verification Commands**:
```bash
ls -la # Shows .git and .onx directories
cat .onx/workstreams.json # Shows: {"workstreams":[]}
stat .onx/oplog # Confirms file exists
```
---
### ✅ Step 2: Daemon Startup
**Command**: `onx daemon start`
**Results**:
- ✅ **PASS**: Daemon started without errors
- ✅ **PASS**: `onx daemon status` shows "Onyx daemon is running (PID: 369524)"
- ✅ **PASS**: `.onx/daemon.pid` file created with correct PID 369524
- ✅ **PASS**: Daemon process confirmed running in background
- ✅ **PASS**: No startup errors
**Verification Commands**:
```bash
onx daemon status # Shows daemon status
cat .onx/daemon.pid # Shows PID
ps aux | grep onxd # Shows running daemon process
```
---
### ✅ Step 3: Create Initial File
**Commands**:
```bash
echo 'print("hello world")' > main.py
```
**Results**:
- ✅ **PASS**: File creation succeeded
- ✅ **PASS**: File content correct: `print("hello world")`
- ✅ **PASS**: File exists in repository
**Verification**:
```bash
cat main.py # Shows content
ls -la # Confirms main.py exists
```
---
### ✅ Step 4: Automatic Snapshot Creation
**Action**: Wait 3 seconds for debouncing
**Results**:
- ✅ **PASS**: Daemon detected file change
- ✅ **PASS**: `.onx/workspace` file updated with timestamp
- ✅ **PASS**: Workspace ref `refs/onyx/workspaces/current` created
- ✅ **PASS**: Snapshot commit SHA: `620c8d55bc7bf749032b8ed0bc0e590aa09e34b3`
**Verification**:
```bash
cat .onx/workspace # Shows workspace state with commit SHA
git show-ref refs/onyx/workspaces/current # Shows reference exists
```
**Workspace State Content**:
```json
{
"current_commit_sha": "620c8d55bc7bf749032b8ed0bc0e590aa09e34b3",
"workstream_name": "main",
"last_snapshot": "2025-10-10T17:30:29.909137935-04:00",
"is_dirty": false,
"tree_hash": "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
}
```
---
### ✅ Step 5: Save Command Test (FIXED)
**Command**: `onx save -m "Add hello world program"`
**Initial Issue**: Workstreams.json structure mismatch
- **Fixed**: Changed `{"workstreams":[]}` to `{"workstreams":{}}` in repository.go:111
- **Note**: Requires manual workstream creation (onx new not yet implemented)
**Results (after fix)**:
- ✅ **PASS**: Save command succeeded
- ✅ **PASS**: Commit created: `e16343ad5a210d7b56092a3029cd22d9bb8b5ac0`
- ✅ **PASS**: Branch ref created: `refs/onyx/workstreams/feature-hello/commit-1`
- ✅ **PASS**: Workstreams.json updated with commit metadata
- ✅ **PASS**: Oplog entry created
---
### ✅ Step 6-8: File Modification, Snapshot, and Second Save
**Commands**:
```bash
echo 'print("goodbye")' >> main.py
sleep 3 # Wait for snapshot
onx save -m "Add goodbye message"
```
**Results**:
- ✅ **PASS**: File modification detected by daemon
- ✅ **PASS**: Second automatic snapshot created
- ✅ **PASS**: Second commit saved successfully
- ✅ **PASS**: Parent-child relationship established in commits
- ✅ **PASS**: Two commits now in workstream
- ✅ **PASS**: Both branch refs created (commit-1 and commit-2)
**Commits in Workstream**:
```json
"commits": [
{
"sha": "e16343ad5a210d7b56092a3029cd22d9bb8b5ac0",
"message": "Add hello world program",
"branch_ref": "refs/onyx/workstreams/feature-hello/commit-1"
},
{
"sha": "0397cd79213b9e5792b2cb335caf77f6182d5294",
"message": "Add goodbye message",
"parent_sha": "e16343ad5a210d7b56092a3029cd22d9bb8b5ac0",
"branch_ref": "refs/onyx/workstreams/feature-hello/commit-2"
}
]
```
---
### ⚠️ Step 9: Undo Command Test (PARTIAL)
**Command**: `onx undo`
**Results**:
- ❌ **FAIL**: Error: "cannot undo: last operation has no state_before"
- ⚠️ **ISSUE FOUND**: Transaction.Commit() only captures state_after, not state_before
**Root Cause**:
- The save command uses `Transaction.Commit()` which only logs state_after
- Undo requires state_before to know what to revert to
- See oplog entries: `"state_before":null`
**Impact**: Undo cannot revert save operations
---
### ✅ Step 10: Daemon Cleanup
**Command**: `onx daemon stop`
**Results**:
- ✅ **PASS**: Daemon stopped gracefully
- ✅ **PASS**: PID file removed
- ✅ **PASS**: Process terminated cleanly
- ✅ **PASS**: `onx daemon status` confirms not running
---
## Issues Discovered
### ✅ Issue #1: Workstreams.json Structure Mismatch [FIXED]
**Severity**: HIGH - Blocked save functionality
**Status**: ✅ RESOLVED
**Description**:
- The initialization in `internal/core/repository.go` created `workstreams.json` with array structure
- The `models.WorkstreamCollection` expects map structure for workstreams field
**Fix Applied**:
- File: `internal/core/repository.go:111`
- Changed: `{"workstreams":[]}` → `{"workstreams":{}}`
---
###✅ Issue #2: Save Transaction Missing state_before [FIXED]
**Severity**: HIGH - Blocked undo functionality
**Status**: ✅ RESOLVED
**Description**:
- The save command was creating oplog entries with `state_before: null`
- Transaction.Commit() method only captured state_after
- Undo command requires state_before to restore previous state
**Fix Applied**:
- Refactored save command to use `ExecuteWithTransaction()` wrapper
- This method automatically captures both state_before and state_after
- Removed manual transaction management from save command
**Code Changes**:
- File: `internal/commands/save.go`
- Changed from: `tx.Commit("save", message)`
- Changed to: `ExecuteWithTransaction(repo, "save", message, func() { executeSave(...) })`
- Simplified executeSave signature (removed tx parameter)
**Test Results**:
- ✅ Save operations now log complete state_before
- ✅ Undo command successfully restores Git refs
- ✅ Oplog entries contain reversible state information
---
## Action Items
### ✅ COMPLETED
- [x] **Fix workstreams.json initialization structure**
- **File**: `internal/core/repository.go:111`
- **Change**: `{"workstreams":[]}` → `{"workstreams":{}}`
- **Status**: FIXED and tested
- [x] **Fix save transaction to capture state_before**
- **File**: `internal/commands/save.go`
- **Solution**: Refactored to use `ExecuteWithTransaction()` wrapper
- **Status**: FIXED - Undo now works with save operations
### 🚨 HIGH PRIORITY
(None currently - all blocking issues resolved!)
### 🔍 MEDIUM PRIORITY (Future Investigation)
- [ ] **Enhance daemon logging**
- Add verbose logging mode for snapshot creation
- Log filesystem events being processed
- Useful for debugging and monitoring
- [ ] **Verify Git compatibility**
- Test standard git commands on Onyx-managed repositories
- Verify branch references are accessible via git CLI
- Ensure Git tools can read Onyx commits
- [ ] **Add integration tests**
- Automate the integration test workflow
- Test error cases and edge conditions
- Add CI/CD integration
---
## Test Status Summary
| Step | Status | Notes |
|------|---------|-------|
| 1. Repository Init | ✅ PASS | All artifacts created correctly |
| 2. Daemon Startup | ✅ PASS | PID management working correctly |
| 3. File Creation | ✅ PASS | Filesystem monitoring ready |
| 4. Auto Snapshot | ✅ PASS | Daemon creates snapshots as expected |
| 5. Save Command | ✅ PASS | Works after workstreams.json fix |
| 6. File Modification | ✅ PASS | Daemon detects changes correctly |
| 7. Second Snapshot | ✅ PASS | Multiple snapshots working |
| 8. Second Save | ✅ PASS | Commit chain works perfectly |
| 9. Undo Test | ✅ PASS | Successfully reverts save operations |
| 10. Daemon Cleanup | ✅ PASS | Daemon can be stopped cleanly |
**Overall Progress**: 10/10 steps completed successfully! 🎉
---
## Success Metrics
### ✅ Working Features:
- **Repository Initialization**: Creates correct directory structure
- **Daemon Management**: Start, stop, status all working perfectly
- **Automatic Snapshots**: Transparent versioning working as designed
- **Save Command**: Converts snapshots to permanent commits
- **Workstream Tracking**: Commits properly tracked with parent-child relationships
- **Branch References**: Git refs created correctly for all commits
- **Oplog**: All operations logged (though undo needs state_before fix)
### ⚠️ Future Enhancements:
- **Workstream Creation**: `onx new` command (planned for future milestone)
- **Error Messages**: Could be more helpful for new users
- **Workstreams.json Sync**: Consider syncing metadata files on undo
---
## Next Testing Steps
1. ✅ ~~Fix workstreams.json structure issue~~ **COMPLETED**
2. ✅ ~~Test save command~~ **COMPLETED**
3. ✅ ~~Test file modification workflow~~ **COMPLETED**
4. ✅ ~~Fix state_before capture for undo~~ **COMPLETED**
5. ✅ ~~Re-test complete workflow end-to-end~~ **COMPLETED**
**Milestone 2 Complete!** All core functionality working as designed.
---
## Testing Commands Reference
### Repository Commands
```bash
# Initialize
onx init
# Daemon Management
onx daemon start
onx daemon status
onx daemon stop
onx daemon --help
# Save Operations
onx save -m "message"
onx save --help
# Undo Operations
onx undo
onx undo --help
```
### Verification Commands
```bash
# Repository State
ls -la .onx/
cat .onx/workstreams.json
cat .onx/oplog
cat .onx/workspace
# Git State
git show-ref
git log --oneline
git status
# Daemon State
ps aux | grep onxd
cat .onx/daemon.pid
```
---
*This document will be updated as fixes are implemented and additional tests are completed.*

109
Makefile Normal file
View File

@ -0,0 +1,109 @@
# Makefile for Onyx
.PHONY: build test clean install lint security ci integration
# Default target
all: clean lint test build
build:
@echo "Building Onyx CLI and daemon..."
@mkdir -p bin
go build -ldflags="-s -w" -o bin/onx ./cmd/onx
go build -ldflags="-s -w" -o bin/onxd ./cmd/onxd
@echo "Build complete: bin/onx, bin/onxd"
test:
@echo "Running unit tests..."
go test -v -race -coverprofile=coverage.out ./...
@echo "Test coverage generated: coverage.out"
integration: build
@echo "Running integration tests..."
@mkdir -p test
@./test/integration_test.sh
coverage: test
@echo "Coverage report:"
go tool cover -html=coverage.out -o coverage.html
@echo "Coverage report generated: coverage.html"
lint:
@echo "Running linter..."
golangci-lint run
security:
@echo "Running security scan..."
@which gosec > /dev/null || (echo "Installing gosec..." && go install github.com/securecodewarrior/gosec/v2/cmd/gosec@latest)
gosec ./...
ci: lint security test build
@echo "CI pipeline completed successfully"
install:
go install ./cmd/onx
go install ./cmd/onxd
clean:
rm -rf bin/ coverage.out coverage.html
# Development targets
dev-setup:
@echo "Setting up development environment..."
go mod download
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
go install github.com/securecodewarrior/gosec/v2/cmd/gosec@latest
@echo "Development tools installed"
fmt:
@echo "Formatting code..."
go fmt ./...
goimports -w .
mod-tidy:
@echo "Tidying modules..."
go mod tidy
deps-update:
@echo "Updating dependencies..."
go get -u ./...
go mod tidy
# Cross-platform builds
build-all:
@echo "Building for all platforms..."
@mkdir -p bin
# Linux
GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o bin/onx-linux-amd64 ./cmd/onx
GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o bin/onxd-linux-amd64 ./cmd/onxd
GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -o bin/onx-linux-arm64 ./cmd/onx
GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -o bin/onxd-linux-arm64 ./cmd/onxd
# macOS
GOOS=darwin GOARCH=amd64 go build -ldflags="-s -w" -o bin/onx-darwin-amd64 ./cmd/onx
GOOS=darwin GOARCH=amd64 go build -ldflags="-s -w" -o bin/onxd-darwin-amd64 ./cmd/onxd
GOOS=darwin GOARCH=arm64 go build -ldflags="-s -w" -o bin/onx-darwin-arm64 ./cmd/onx
GOOS=darwin GOARCH=arm64 go build -ldflags="-s -w" -o bin/onxd-darwin-arm64 ./cmd/onxd
# Windows
GOOS=windows GOARCH=amd64 go build -ldflags="-s -w" -o bin/onx-windows-amd64.exe ./cmd/onx
GOOS=windows GOARCH=amd64 go build -ldflags="-s -w" -o bin/onxd-windows-amd64.exe ./cmd/onxd
@echo "Cross-platform builds completed"
help:
@echo "Available targets:"
@echo " all - Clean, lint, test, and build"
@echo " build - Build CLI and daemon for current platform"
@echo " build-all - Cross-platform builds"
@echo " test - Run unit tests with coverage"
@echo " integration - Run end-to-end integration tests"
@echo " coverage - Generate HTML coverage report"
@echo " lint - Run code linting"
@echo " security - Run security scanning"
@echo " ci - Run full CI pipeline"
@echo " install - Install to PATH"
@echo " clean - Clean build artifacts"
@echo " fmt - Format code"
@echo " mod-tidy - Tidy Go modules"
@echo " dev-setup - Install development tools"
@echo " help - Show this help message"

247
README.md Normal file
View File

@ -0,0 +1,247 @@
# Onyx
A next-generation version control system designed as a superior user experience layer on top of Git.
## Overview
Onyx provides transparent versioning, workstreams for stacked-diff management, and an action log for universal undo functionality. The project is written in Go and uses the go-git library for Git interaction.
## Features
- **100% Git Data Model Compatibility**: Uses standard .git directory for shared truth
- **Transparent Versioning**: Background daemon creates continuous snapshots
- **Workstreams**: Stacked-diff workflow management
- **Action Log**: Transactional undo/redo capability
- **Hybrid Storage**: .git for Git objects, .onx for Onyx-specific metadata
## Quick Start
### Prerequisites
- Go 1.24.2 or later
- Git 2.30.0 or later
### Installation
```bash
# Clone the repository
git clone https://git.dws.rip/DWS/onyx.git
cd onyx
# Install dependencies
go mod tidy
# Build the CLI and daemon
make build
# Install to PATH
make install
```
### Usage
```bash
# Initialize repository
onx init
# Create workstream
onx new feature-branch
# Save work
onx save -m "Add new feature"
# List workstreams
onx list
# Switch workstreams
onx switch main
# Sync with remote
onx sync
# Push workstream
onx push
# Undo last operation
onx undo
```
## Push Workflows: Single-Branch vs Stacked Diffs
Onyx supports two push workflows to match your team's needs:
### Single-Branch Mode (Default) - Recommended
**Perfect for:** Traditional teams, simple features, clean remote UI
```bash
onx new add-login --base main
onx save -m "Add login form"
onx save -m "Add validation"
onx save -m "Add tests"
# Push creates ONE branch with all commits
onx push
# Result on remote:
# - Branch: add-login (contains all 3 commits)
# - Clean UI, easy PR workflow
```
**What you get:**
- ✅ One clean branch per workstream
- ✅ Perfect for traditional PR workflows
- ✅ All commits preserved locally for undo
- ✅ Clean remote repository UI
### Stacked Diffs Mode - Advanced
**Perfect for:** Complex features, incremental review, Meta/Google-style workflows
```bash
onx new big-refactor --base main
onx save -m "Step 1: Database schema"
onx save -m "Step 2: API endpoints"
onx save -m "Step 3: Frontend UI"
# Push creates MULTIPLE branches (one per commit)
onx push --stacked
# Result on remote:
# - Branch: onyx/workstreams/big-refactor/commit-1
# - Branch: onyx/workstreams/big-refactor/commit-2
# - Branch: onyx/workstreams/big-refactor/commit-3
# - Each can have its own PR for focused review
```
**What you get:**
- ✅ One branch per commit for incremental review
- ✅ PRs can be merged independently
- ✅ Better for large, complex changes
- ⚠️ More branches in remote UI
### Choosing Your Workflow
| Criterion | Single-Branch (`onx push`) | Stacked Diffs (`onx push --stacked`) |
|-----------|---------------------------|-------------------------------------|
| **Team Style** | Traditional Git workflow | Meta/Google stacked review |
| **Feature Size** | Any size | Large, complex features |
| **Review Style** | One big PR | Multiple small PRs |
| **Remote UI** | Clean (1 branch) | More branches (N commits) |
| **PR Creation** | `gh pr create --head feature` | Multiple PRs, stacked dependencies |
**Recommendation:** Start with default `onx push` (single-branch). Use `--stacked` only when you need incremental review of complex changes.
## Development
### Building
```bash
# Build the CLI and daemon
go build -o bin/onx ./cmd/onx
go build -o bin/onxd ./cmd/onxd
# Install to PATH
go install ./cmd/onx
go install ./cmd/onxd
```
### Testing
```bash
# Run all tests
go test -v ./...
# Run tests with coverage
go test -cover ./...
# Run specific test package
go test -v ./internal/core
```
### Linting and Code Quality
The project uses several tools to maintain code quality:
```bash
# Run linter
golangci-lint run
# Run security scanner
gosec ./...
# Run tests with race detection
go test -race ./...
```
## CI/CD
This project uses Gitea Actions for continuous integration and deployment. The workflow includes:
### CI Pipeline
- **Test**: Runs unit tests with race detection and coverage reporting
- **Build**: Cross-compiles binaries for multiple platforms (Linux, Windows, macOS)
- **Security**: Runs security scans using Gosec
- **Lint**: Performs comprehensive code linting with golangci-lint
- **Release**: Creates releases and uploads artifacts for main branch builds
### Supported Platforms
- Linux (amd64, arm64)
- Windows (amd64)
- macOS (amd64, arm64)
### Workflow Triggers
- Push to `main` or `develop` branches
- Pull requests to `main` branch
## Architecture
### Project Structure
```
onyx/
├── cmd/
│ ├── onx/ # CLI entry point
│ └── onxd/ # Daemon entry point
├── internal/
│ ├── core/ # Core abstractions
│ ├── git/ # Git interaction layer
│ ├── models/ # Data models
│ ├── storage/ # .onx directory management
│ ├── commands/ # CLI command implementations
│ ├── daemon/ # Daemon implementation
│ └── utils/ # Utilities
├── pkg/ # Public APIs
├── test/ # Integration tests
└── docs/ # Documentation
```
### Core Components
- **Repository**: Central object encapsulating access to both Git repository and Onyx metadata
- **Action Log**: Append-only binary log storing state before/after each operation
- **Workstreams**: Manages stacked-diff workflows through .onx/workstreams.json
- **Daemon**: Background process for continuous snapshot creation
## Contributing
1. Fork the repository
2. Create a feature branch (`onx new feature-name`)
3. Make your changes
4. Run tests and linting (`make test lint`)
5. Commit your changes (`onx save -m "Add feature"`)
6. Push to your fork (`onx push`)
7. Create a pull request
## License
[License information to be added]
## Acknowledgments
- [go-git](https://github.com/go-git/go-git) - Git implementation in pure Go
- [cobra](https://github.com/spf13/cobra) - CLI framework
- [fsnotify](https://github.com/fsnotify/fsnotify) - Filesystem monitoring

40
cmd/onx/main.go Normal file
View File

@ -0,0 +1,40 @@
package main
import (
"fmt"
"os"
"git.dws.rip/DWS/onyx/internal/commands"
"github.com/spf13/cobra"
)
var version = "0.1.0"
func main() {
rootCmd := &cobra.Command{
Use: "onx",
Short: "Onyx - The iPhone of Version Control",
Long: `Onyx is a next-generation version control system that provides
a superior user experience layer on top of Git. It offers transparent
versioning, workstreams for stacked-diff management, and an action
log for universal undo functionality.`,
Version: version,
}
// Add commands
rootCmd.AddCommand(commands.NewInitCmd())
rootCmd.AddCommand(commands.NewUndoCmd())
rootCmd.AddCommand(commands.NewDaemonCmd())
rootCmd.AddCommand(commands.NewSaveCmd())
rootCmd.AddCommand(commands.NewNewCmd())
rootCmd.AddCommand(commands.NewListCmd())
rootCmd.AddCommand(commands.NewSwitchCmd())
rootCmd.AddCommand(commands.NewSyncCmd())
rootCmd.AddCommand(commands.NewPushCmd())
// Execute the root command
if err := rootCmd.Execute(); err != nil {
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
os.Exit(1)
}
}

127
cmd/onxd/main.go Normal file
View File

@ -0,0 +1,127 @@
package main
import (
"fmt"
"log"
"os"
"os/signal"
"path/filepath"
"syscall"
"time"
"git.dws.rip/DWS/onyx/internal/core"
"git.dws.rip/DWS/onyx/internal/daemon"
"github.com/spf13/cobra"
)
var (
version = "0.1.0"
repoPath string
interval time.Duration
debounce time.Duration
pidFile string
)
func main() {
rootCmd := &cobra.Command{
Use: "onxd",
Short: "Onyx Daemon - Transparent versioning daemon",
Long: `The Onyx daemon monitors your repository for changes and automatically
creates snapshots of your work. This enables transparent versioning without
manual commits.`,
Version: version,
RunE: runDaemon,
}
// Add flags
rootCmd.PersistentFlags().StringVarP(&repoPath, "repo", "r", ".", "Path to the Onyx repository")
rootCmd.PersistentFlags().DurationVarP(&interval, "interval", "i", 1*time.Second, "Ticker interval for periodic checks")
rootCmd.PersistentFlags().DurationVarP(&debounce, "debounce", "d", 500*time.Millisecond, "Debounce duration for filesystem events")
if err := rootCmd.Execute(); err != nil {
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
os.Exit(1)
}
}
func runDaemon(cmd *cobra.Command, args []string) error {
// Resolve repository path
absPath, err := filepath.Abs(repoPath)
if err != nil {
return fmt.Errorf("failed to resolve repository path: %w", err)
}
// Check if this is an Onyx repository
if !core.IsOnyxRepo(absPath) {
return fmt.Errorf("not an Onyx repository: %s", absPath)
}
// Open the repository
repo, err := core.Open(absPath)
if err != nil {
return fmt.Errorf("failed to open repository: %w", err)
}
defer repo.Close()
// Create daemon configuration
config := &daemon.Config{
Debounce: debounce,
TickerInterval: interval,
RepoPath: absPath,
}
// Create the daemon
d, err := daemon.New(repo, config)
if err != nil {
return fmt.Errorf("failed to create daemon: %w", err)
}
// Write PID file
pidFile = filepath.Join(repo.GetOnyxPath(), "daemon.pid")
if err := writePIDFile(pidFile); err != nil {
return fmt.Errorf("failed to write PID file: %w", err)
}
defer os.Remove(pidFile)
// Set up signal handlers
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
// Start the daemon
if err := d.Start(); err != nil {
return fmt.Errorf("failed to start daemon: %w", err)
}
log.Printf("Onyx daemon started (PID: %d)", os.Getpid())
log.Printf("Watching repository: %s", absPath)
log.Printf("Debounce: %v, Interval: %v", debounce, interval)
// Wait for shutdown signal
sig := <-sigChan
log.Printf("Received signal: %v", sig)
// Stop the daemon
if err := d.Stop(); err != nil {
return fmt.Errorf("failed to stop daemon: %w", err)
}
return nil
}
// writePIDFile writes the current process ID to a file
func writePIDFile(path string) error {
pid := os.Getpid()
return os.WriteFile(path, []byte(fmt.Sprintf("%d\n", pid)), 0644)
}
// readPIDFile reads the process ID from a file
func readPIDFile(path string) (int, error) {
data, err := os.ReadFile(path)
if err != nil {
return 0, err
}
var pid int
_, err = fmt.Sscanf(string(data), "%d", &pid)
return pid, err
}

33
go.mod Normal file
View File

@ -0,0 +1,33 @@
module git.dws.rip/DWS/onyx
go 1.24.2
require (
github.com/go-git/go-git/v5 v5.16.3
github.com/spf13/cobra v1.10.1
)
require (
dario.cat/mergo v1.0.0 // indirect
github.com/Microsoft/go-winio v0.6.2 // indirect
github.com/ProtonMail/go-crypto v1.1.6 // indirect
github.com/cloudflare/circl v1.6.1 // indirect
github.com/cyphar/filepath-securejoin v0.4.1 // indirect
github.com/emirpasic/gods v1.18.1 // indirect
github.com/fsnotify/fsnotify v1.9.0 // indirect
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
github.com/go-git/go-billy/v5 v5.6.2 // indirect
github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
github.com/inconshreveable/mousetrap v1.1.0 // indirect
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
github.com/kevinburke/ssh_config v1.2.0 // indirect
github.com/pjbgf/sha1cd v0.3.2 // indirect
github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
github.com/skeema/knownhosts v1.3.1 // indirect
github.com/spf13/pflag v1.0.9 // indirect
github.com/xanzy/ssh-agent v0.3.3 // indirect
golang.org/x/crypto v0.37.0 // indirect
golang.org/x/net v0.39.0 // indirect
golang.org/x/sys v0.32.0 // indirect
gopkg.in/warnings.v0 v0.1.2 // indirect
)

112
go.sum Normal file
View File

@ -0,0 +1,112 @@
dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
github.com/ProtonMail/go-crypto v1.1.6 h1:ZcV+Ropw6Qn0AX9brlQLAUXfqLBc7Bl+f/DmNxpLfdw=
github.com/ProtonMail/go-crypto v1.1.6/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
github.com/cloudflare/circl v1.6.1 h1:zqIqSPIndyBh1bjLVVDHMPpVKqp8Su/V+6MeDzzQBQ0=
github.com/cloudflare/circl v1.6.1/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=
github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
github.com/cyphar/filepath-securejoin v0.4.1 h1:JyxxyPEaktOD+GAnqIqTf9A8tHyAG22rowi7HkoSU1s=
github.com/cyphar/filepath-securejoin v0.4.1/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o=
github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE=
github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
github.com/go-git/go-billy/v5 v5.6.2 h1:6Q86EsPXMa7c3YZ3aLAQsMA0VlWmy43r6FHqa/UNbRM=
github.com/go-git/go-billy/v5 v5.6.2/go.mod h1:rcFC2rAsp/erv7CMz9GczHcuD0D32fWzH+MJAU+jaUU=
github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=
github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=
github.com/go-git/go-git/v5 v5.16.3 h1:Z8BtvxZ09bYm/yYNgPKCzgWtaRqDTgIKRgIRHBfU6Z8=
github.com/go-git/go-git/v5 v5.16.3/go.mod h1:4Ge4alE/5gPs30F2H1esi2gPd69R0C39lolkucHBOp8=
github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=
github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4=
github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
github.com/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8=
github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY=
github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE=
golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY=
golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E=
golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.31.0 h1:erwDkOK1Msy6offm1mOgvspSkslFnIGsFnxOKoufg3o=
golang.org/x/term v0.31.0/go.mod h1:R4BeIy7D95HzImkxGkTW1UQTtP54tio2RyHz7PwK0aw=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

141
internal/commands/clone.go Normal file
View File

@ -0,0 +1,141 @@
package commands
import (
"fmt"
"os"
"path/filepath"
"git.dws.rip/DWS/onyx/internal/core"
gogit "github.com/go-git/go-git/v5"
"github.com/spf13/cobra"
)
// NewCloneCmd creates the clone command
func NewCloneCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "clone <url> [directory]",
Short: "Clone a repository and initialize Onyx",
Long: `Clone a repository from a remote URL and initialize Onyx.
This command combines Git's clone functionality with automatic Onyx setup.
The cloned URL is automatically configured as the primary remote.
Examples:
onx clone https://github.com/user/repo.git
onx clone git@github.com:user/repo.git my-project`,
Args: cobra.RangeArgs(1, 2),
RunE: func(cmd *cobra.Command, args []string) error {
url := args[0]
var directory string
if len(args) == 2 {
directory = args[1]
}
return runClone(url, directory)
},
}
return cmd
}
// runClone executes the clone command
func runClone(url, directory string) error {
// If no directory specified, derive from URL
if directory == "" {
directory = deriveDirectoryFromURL(url)
}
// Check if directory already exists
if _, err := os.Stat(directory); err == nil {
return fmt.Errorf("directory '%s' already exists", directory)
}
// Clone the repository using go-git
fmt.Printf("Cloning into '%s'...\n", directory)
_, err := gogit.PlainClone(directory, false, &gogit.CloneOptions{
URL: url,
Progress: os.Stdout,
})
if err != nil {
return fmt.Errorf("failed to clone repository: %w", err)
}
fmt.Println("✓ Clone completed")
// Change to the cloned directory
originalDir, err := os.Getwd()
if err != nil {
return fmt.Errorf("failed to get current directory: %w", err)
}
absDir, err := filepath.Abs(directory)
if err != nil {
return fmt.Errorf("failed to get absolute path: %w", err)
}
if err := os.Chdir(absDir); err != nil {
return fmt.Errorf("failed to change directory: %w", err)
}
defer os.Chdir(originalDir)
// Initialize Onyx in the cloned repository
fmt.Println("Initializing Onyx...")
// Check if .git exists (it should, since we just cloned)
gitDir := filepath.Join(absDir, ".git")
if _, err := os.Stat(gitDir); os.IsNotExist(err) {
return fmt.Errorf("no .git directory found after clone")
}
// Initialize Onyx repository structure (this will create .onx directory)
onyxRepo := &core.OnyxRepository{}
if err := onyxRepo.Init(absDir); err != nil {
return fmt.Errorf("failed to initialize Onyx: %w", err)
}
defer onyxRepo.Close()
// Create default workstream matching the cloned branch
wsManager := core.NewWorkstreamManager(onyxRepo)
if err := wsManager.CreateDefaultWorkstream(); err != nil {
// Don't fail clone if workstream creation fails, just warn
fmt.Fprintf(os.Stderr, "Warning: failed to create default workstream: %v\n", err)
}
// Get the workstream name to display to the user
currentWs, _ := wsManager.GetCurrentWorkstreamName()
if currentWs == "" {
currentWs = "main" // fallback
}
// The remote 'origin' is automatically configured by git clone
// We don't need to do anything extra - it's already the primary remote
fmt.Printf("\n✓ Successfully cloned and initialized Onyx repository in '%s'\n", directory)
fmt.Printf("\n✓ Created workstream '%s' tracking branch '%s'\n", currentWs, currentWs)
fmt.Printf("\nThe remote 'origin' (%s) is configured as your primary remote.\n", url)
fmt.Printf("\nNext steps:\n")
fmt.Printf(" cd %s\n", directory)
fmt.Printf(" onx save -m \"message\" # Save your work\n")
fmt.Printf(" onx new <name> # Create a new workstream\n")
return nil
}
// deriveDirectoryFromURL extracts a directory name from a Git URL
func deriveDirectoryFromURL(url string) string {
// Remove .git suffix if present
name := url
if filepath.Ext(name) == ".git" {
name = name[:len(name)-4]
}
// Extract the last component of the path
name = filepath.Base(name)
// Handle edge cases
if name == "/" || name == "." {
name = "repository"
}
return name
}

232
internal/commands/daemon.go Normal file
View File

@ -0,0 +1,232 @@
package commands
import (
"fmt"
"os"
"os/exec"
"path/filepath"
"strconv"
"syscall"
"git.dws.rip/DWS/onyx/internal/core"
"github.com/spf13/cobra"
)
// NewDaemonCmd creates the daemon command with start, stop, and status subcommands
func NewDaemonCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "daemon",
Short: "Manage the Onyx daemon for transparent versioning",
Long: `The daemon command controls the Onyx background daemon that monitors
your repository for changes and automatically creates snapshots.`,
}
cmd.AddCommand(newDaemonStartCmd())
cmd.AddCommand(newDaemonStopCmd())
cmd.AddCommand(newDaemonStatusCmd())
return cmd
}
// newDaemonStartCmd creates the daemon start subcommand
func newDaemonStartCmd() *cobra.Command {
return &cobra.Command{
Use: "start",
Short: "Start the Onyx daemon",
Long: `Starts the Onyx daemon in the background to monitor the repository.`,
RunE: runDaemonStart,
}
}
// newDaemonStopCmd creates the daemon stop subcommand
func newDaemonStopCmd() *cobra.Command {
return &cobra.Command{
Use: "stop",
Short: "Stop the Onyx daemon",
Long: `Gracefully stops the running Onyx daemon.`,
RunE: runDaemonStop,
}
}
// newDaemonStatusCmd creates the daemon status subcommand
func newDaemonStatusCmd() *cobra.Command {
return &cobra.Command{
Use: "status",
Short: "Check the Onyx daemon status",
Long: `Checks if the Onyx daemon is running and displays its status.`,
RunE: runDaemonStatus,
}
}
// runDaemonStart starts the daemon in the background
func runDaemonStart(cmd *cobra.Command, args []string) error {
// Get current directory
cwd, err := os.Getwd()
if err != nil {
return fmt.Errorf("failed to get current directory: %w", err)
}
// Check if this is an Onyx repository
if !core.IsOnyxRepo(cwd) {
return fmt.Errorf("not an Onyx repository")
}
// Open repository to get .onx path
repo, err := core.Open(cwd)
if err != nil {
return fmt.Errorf("failed to open repository: %w", err)
}
defer repo.Close()
pidFile := filepath.Join(repo.GetOnyxPath(), "daemon.pid")
// Check if daemon is already running
if isDaemonRunning(pidFile) {
return fmt.Errorf("daemon is already running")
}
// Find the onxd binary
onxdPath, err := exec.LookPath("onxd")
if err != nil {
// Try to find it in the same directory as onx
onxPath, err := os.Executable()
if err != nil {
return fmt.Errorf("failed to locate onxd binary: %w", err)
}
onxdPath = filepath.Join(filepath.Dir(onxPath), "onxd")
if _, err := os.Stat(onxdPath); err != nil {
return fmt.Errorf("onxd binary not found. Please ensure it's installed")
}
}
// Start the daemon in the background
daemonCmd := exec.Command(onxdPath, "--repo", cwd)
daemonCmd.Stdout = nil
daemonCmd.Stderr = nil
daemonCmd.SysProcAttr = &syscall.SysProcAttr{
Setsid: true, // Create new session
}
if err := daemonCmd.Start(); err != nil {
return fmt.Errorf("failed to start daemon: %w", err)
}
// Detach the process
if err := daemonCmd.Process.Release(); err != nil {
return fmt.Errorf("failed to release daemon process: %w", err)
}
fmt.Println("Onyx daemon started successfully")
return nil
}
// runDaemonStop stops the running daemon
func runDaemonStop(cmd *cobra.Command, args []string) error {
// Get current directory
cwd, err := os.Getwd()
if err != nil {
return fmt.Errorf("failed to get current directory: %w", err)
}
// Check if this is an Onyx repository
if !core.IsOnyxRepo(cwd) {
return fmt.Errorf("not an Onyx repository")
}
// Open repository to get .onx path
repo, err := core.Open(cwd)
if err != nil {
return fmt.Errorf("failed to open repository: %w", err)
}
defer repo.Close()
pidFile := filepath.Join(repo.GetOnyxPath(), "daemon.pid")
// Read PID from file
pid, err := readPIDFile(pidFile)
if err != nil {
if os.IsNotExist(err) {
return fmt.Errorf("daemon is not running (no PID file found)")
}
return fmt.Errorf("failed to read PID file: %w", err)
}
// Check if process exists
process, err := os.FindProcess(pid)
if err != nil {
return fmt.Errorf("failed to find daemon process: %w", err)
}
// Send SIGTERM to gracefully stop the daemon
if err := process.Signal(syscall.SIGTERM); err != nil {
return fmt.Errorf("failed to stop daemon: %w", err)
}
fmt.Println("Onyx daemon stopped successfully")
return nil
}
// runDaemonStatus checks the daemon status
func runDaemonStatus(cmd *cobra.Command, args []string) error {
// Get current directory
cwd, err := os.Getwd()
if err != nil {
return fmt.Errorf("failed to get current directory: %w", err)
}
// Check if this is an Onyx repository
if !core.IsOnyxRepo(cwd) {
return fmt.Errorf("not an Onyx repository")
}
// Open repository to get .onx path
repo, err := core.Open(cwd)
if err != nil {
return fmt.Errorf("failed to open repository: %w", err)
}
defer repo.Close()
pidFile := filepath.Join(repo.GetOnyxPath(), "daemon.pid")
if isDaemonRunning(pidFile) {
pid, _ := readPIDFile(pidFile)
fmt.Printf("Onyx daemon is running (PID: %d)\n", pid)
} else {
fmt.Println("Onyx daemon is not running")
}
return nil
}
// isDaemonRunning checks if the daemon is running based on the PID file
func isDaemonRunning(pidFile string) bool {
pid, err := readPIDFile(pidFile)
if err != nil {
return false
}
// Check if process exists
process, err := os.FindProcess(pid)
if err != nil {
return false
}
// Send signal 0 to check if process is alive
err = process.Signal(syscall.Signal(0))
return err == nil
}
// readPIDFile reads the PID from a file
func readPIDFile(path string) (int, error) {
data, err := os.ReadFile(path)
if err != nil {
return 0, err
}
pid, err := strconv.Atoi(string(data[:len(data)-1])) // Remove trailing newline
if err != nil {
return 0, fmt.Errorf("invalid PID file: %w", err)
}
return pid, nil
}

231
internal/commands/init.go Normal file
View File

@ -0,0 +1,231 @@
package commands
import (
"fmt"
"os"
"path/filepath"
"git.dws.rip/DWS/onyx/internal/core"
"git.dws.rip/DWS/onyx/internal/storage"
"github.com/go-git/go-git/v5/config"
"github.com/spf13/cobra"
)
// NewInitCmd creates the init command
func NewInitCmd() *cobra.Command {
var remoteURL string
cmd := &cobra.Command{
Use: "init [path]",
Short: "Initialize a new Onyx repository",
Long: `Initialize a new Onyx repository in the specified directory.
If no path is provided, initializes in the current directory.
This command will:
- Create a Git repository (if one doesn't exist)
- Create the .onx directory structure
- Initialize the oplog file
- Create default workstreams.json
- Add .onx to .gitignore
- Optionally configure a remote repository
Example:
onx init
onx init --remote https://git.dws.rip/DWS/onyx.git`,
Args: cobra.MaximumNArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
return runInit(cmd, args, remoteURL)
},
}
cmd.Flags().StringVarP(&remoteURL, "remote", "r", "", "Remote repository URL to configure as 'origin'")
return cmd
}
func runInit(cmd *cobra.Command, args []string, remoteURL string) error {
// Determine the path
path := "."
if len(args) > 0 {
path = args[0]
}
// Resolve to absolute path
absPath, err := filepath.Abs(path)
if err != nil {
return fmt.Errorf("failed to resolve path: %w", err)
}
// Check if already an Onyx repository
if core.IsOnyxRepo(absPath) {
return fmt.Errorf("already an onyx repository: %s", absPath)
}
// Create and initialize repository
repo := &core.OnyxRepository{}
err = repo.Init(absPath)
if err != nil {
return fmt.Errorf("failed to initialize repository: %w", err)
}
// Add remote if specified
if remoteURL != "" {
gitRepo := repo.GetGitRepo()
_, err = gitRepo.CreateRemote(&config.RemoteConfig{
Name: "origin",
URLs: []string{remoteURL},
})
if err != nil {
// Don't fail the init, but warn the user
fmt.Fprintf(os.Stderr, "Warning: failed to add remote: %v\n", err)
} else {
fmt.Printf("Added remote 'origin': %s\n", remoteURL)
}
}
// Create default workstream matching the current Git branch
wsManager := core.NewWorkstreamManager(repo)
if err := wsManager.CreateDefaultWorkstream(); err != nil {
// Don't fail init if workstream creation fails, just warn
fmt.Fprintf(os.Stderr, "Warning: failed to create default workstream: %v\n", err)
}
// Add .onx to .gitignore
gitignorePath := filepath.Join(absPath, ".gitignore")
err = addToGitignore(gitignorePath, ".onx/")
if err != nil {
// Don't fail if we can't update .gitignore, just warn
fmt.Fprintf(os.Stderr, "Warning: failed to update .gitignore: %v\n", err)
}
// Log the init operation to oplog
txn, err := core.NewTransaction(repo)
if err != nil {
// Don't fail if we can't create transaction, repo is already initialized
fmt.Fprintf(os.Stderr, "Warning: failed to log init to oplog: %v\n", err)
} else {
defer txn.Close()
// Execute a no-op function just to log the init
err = txn.ExecuteWithTransaction("init", "Initialized Onyx repository", func() error {
return nil
})
if err != nil {
fmt.Fprintf(os.Stderr, "Warning: failed to log init: %v\n", err)
}
}
// Get the workstream name to display to the user
currentWs, _ := wsManager.GetCurrentWorkstreamName()
if currentWs == "" {
currentWs = "master" // fallback
}
fmt.Printf("Initialized empty Onyx repository in %s\n", filepath.Join(absPath, ".onx"))
fmt.Printf("\n✓ Created workstream '%s' tracking branch '%s'\n", currentWs, currentWs)
if remoteURL != "" {
fmt.Printf("\nYou can now:\n")
fmt.Printf(" onx save -m \"message\" # Save your work\n")
fmt.Printf(" onx push # Push to remote\n")
} else {
fmt.Printf("\nYou can now:\n")
fmt.Printf(" onx save -m \"message\" # Save your work\n")
fmt.Printf(" onx new <name> # Create a new workstream\n")
}
return nil
}
// addToGitignore adds an entry to .gitignore if it doesn't already exist
func addToGitignore(gitignorePath, entry string) error {
// Read existing .gitignore if it exists
var content []byte
if _, err := os.Stat(gitignorePath); err == nil {
content, err = os.ReadFile(gitignorePath)
if err != nil {
return fmt.Errorf("failed to read .gitignore: %w", err)
}
}
// Check if entry already exists
contentStr := string(content)
if len(contentStr) > 0 && contentStr[len(contentStr)-1] != '\n' {
contentStr += "\n"
}
// Add entry if it doesn't exist
needle := entry
if len(needle) > 0 && needle[len(needle)-1] != '\n' {
needle += "\n"
}
// Simple check - not perfect but good enough
if !containsLine(contentStr, entry) {
contentStr += needle
}
// Write back to .gitignore
err := os.WriteFile(gitignorePath, []byte(contentStr), 0644)
if err != nil {
return fmt.Errorf("failed to write .gitignore: %w", err)
}
return nil
}
// containsLine checks if a multi-line string contains a specific line
func containsLine(content, line string) bool {
// Simple implementation - just check if the line exists as a substring
// In the future, we might want to do line-by-line checking
target := line
if len(target) > 0 && target[len(target)-1] == '\n' {
target = target[:len(target)-1]
}
lines := splitLines(content)
for _, l := range lines {
if l == target {
return true
}
}
return false
}
// splitLines splits a string into lines
func splitLines(s string) []string {
if s == "" {
return []string{}
}
var lines []string
start := 0
for i := 0; i < len(s); i++ {
if s[i] == '\n' {
lines = append(lines, s[start:i])
start = i + 1
}
}
// Add the last line if it doesn't end with newline
if start < len(s) {
lines = append(lines, s[start:])
}
return lines
}
// GetOplogWriter creates an oplog writer for the repository at the given path
func GetOplogWriter(path string) (*storage.OplogWriter, error) {
absPath, err := filepath.Abs(path)
if err != nil {
return nil, fmt.Errorf("failed to resolve path: %w", err)
}
if !core.IsOnyxRepo(absPath) {
return nil, fmt.Errorf("not an onyx repository: %s", absPath)
}
oplogPath := filepath.Join(absPath, ".onx", "oplog")
return storage.OpenOplog(oplogPath)
}

196
internal/commands/init_test.go Normal file
View File

@ -0,0 +1,196 @@
package commands
import (
"os"
"path/filepath"
"testing"
"git.dws.rip/DWS/onyx/internal/core"
)
func TestInitCommand(t *testing.T) {
// Create a temporary directory for testing
tempDir := t.TempDir()
// Create a repository instance
repo := &core.OnyxRepository{}
// Initialize the repository
err := repo.Init(tempDir)
if err != nil {
t.Fatalf("Failed to initialize repository: %v", err)
}
// Verify .git directory exists
gitPath := filepath.Join(tempDir, ".git")
if _, err := os.Stat(gitPath); os.IsNotExist(err) {
t.Errorf(".git directory was not created")
}
// Verify .onx directory exists
onyxPath := filepath.Join(tempDir, ".onx")
if _, err := os.Stat(onyxPath); os.IsNotExist(err) {
t.Errorf(".onx directory was not created")
}
// Verify oplog file exists
oplogPath := filepath.Join(onyxPath, "oplog")
if _, err := os.Stat(oplogPath); os.IsNotExist(err) {
t.Errorf("oplog file was not created")
}
// Verify workstreams.json exists
workstreamsPath := filepath.Join(onyxPath, "workstreams.json")
if _, err := os.Stat(workstreamsPath); os.IsNotExist(err) {
t.Errorf("workstreams.json was not created")
}
// Verify rerere_cache directory exists
rererePath := filepath.Join(onyxPath, "rerere_cache")
if _, err := os.Stat(rererePath); os.IsNotExist(err) {
t.Errorf("rerere_cache directory was not created")
}
}
func TestInitCommandInExistingRepo(t *testing.T) {
// Create a temporary directory for testing
tempDir := t.TempDir()
// Initialize once
repo := &core.OnyxRepository{}
err := repo.Init(tempDir)
if err != nil {
t.Fatalf("Failed to initialize repository: %v", err)
}
// Verify it's an Onyx repo
if !core.IsOnyxRepo(tempDir) {
t.Errorf("IsOnyxRepo returned false for initialized repository")
}
}
func TestIsOnyxRepo(t *testing.T) {
tests := []struct {
name string
setup func(string) error
expected bool
}{
{
name: "empty directory",
setup: func(path string) error {
return nil
},
expected: false,
},
{
name: "initialized repository",
setup: func(path string) error {
repo := &core.OnyxRepository{}
return repo.Init(path)
},
expected: true,
},
{
name: "directory with only .git",
setup: func(path string) error {
return os.MkdirAll(filepath.Join(path, ".git"), 0755)
},
expected: false,
},
{
name: "directory with only .onx",
setup: func(path string) error {
return os.MkdirAll(filepath.Join(path, ".onx"), 0755)
},
expected: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tempDir := t.TempDir()
err := tt.setup(tempDir)
if err != nil {
t.Fatalf("Setup failed: %v", err)
}
result := core.IsOnyxRepo(tempDir)
if result != tt.expected {
t.Errorf("IsOnyxRepo() = %v, expected %v", result, tt.expected)
}
})
}
}
func TestAddToGitignore(t *testing.T) {
tests := []struct {
name string
existingContent string
entryToAdd string
shouldContain string
}{
{
name: "add to empty gitignore",
existingContent: "",
entryToAdd: ".onx/",
shouldContain: ".onx/",
},
{
name: "add to existing gitignore",
existingContent: "node_modules/\n*.log\n",
entryToAdd: ".onx/",
shouldContain: ".onx/",
},
{
name: "don't duplicate existing entry",
existingContent: ".onx/\nnode_modules/\n",
entryToAdd: ".onx/",
shouldContain: ".onx/",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tempDir := t.TempDir()
gitignorePath := filepath.Join(tempDir, ".gitignore")
// Create existing content if specified
if tt.existingContent != "" {
err := os.WriteFile(gitignorePath, []byte(tt.existingContent), 0644)
if err != nil {
t.Fatalf("Failed to create test .gitignore: %v", err)
}
}
// Add the entry
err := addToGitignore(gitignorePath, tt.entryToAdd)
if err != nil {
t.Fatalf("addToGitignore failed: %v", err)
}
// Read the result
content, err := os.ReadFile(gitignorePath)
if err != nil {
t.Fatalf("Failed to read .gitignore: %v", err)
}
// Verify the entry is present
if !containsLine(string(content), tt.shouldContain) {
t.Errorf(".gitignore does not contain expected entry %q\nContent:\n%s", tt.shouldContain, string(content))
}
// Count occurrences (should not be duplicated)
lines := splitLines(string(content))
count := 0
for _, line := range lines {
if line == tt.shouldContain {
count++
}
}
if count > 1 {
t.Errorf("Entry %q appears %d times, expected 1", tt.shouldContain, count)
}
})
}
}

191
internal/commands/list.go Normal file
View File

@ -0,0 +1,191 @@
package commands
import (
"fmt"
"os"
"sort"
"strings"
"git.dws.rip/DWS/onyx/internal/core"
"git.dws.rip/DWS/onyx/internal/models"
"github.com/spf13/cobra"
)
// ANSI color codes
const (
colorReset = "\033[0m"
colorGreen = "\033[32m"
colorYellow = "\033[33m"
colorBlue = "\033[34m"
colorGray = "\033[90m"
colorBold = "\033[1m"
)
// NewListCmd creates the list command
func NewListCmd() *cobra.Command {
var showAll bool
cmd := &cobra.Command{
Use: "list",
Short: "List all workstreams",
Long: `List all workstreams in the repository.
Shows the current workstream (marked with *), the number of commits in each
workstream, and the workstream status.
Status indicators:
* active - Currently being worked on (green)
* merged - Has been merged (gray)
* abandoned - No longer being worked on (gray)
* archived - Archived for historical purposes (gray)`,
Aliases: []string{"ls"},
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
return runList(showAll)
},
}
cmd.Flags().BoolVarP(&showAll, "all", "a", false, "Show all workstreams including merged and archived")
return cmd
}
// runList executes the list command
func runList(showAll bool) error {
// Get current directory
cwd, err := os.Getwd()
if err != nil {
return fmt.Errorf("failed to get current directory: %w", err)
}
// Check if this is an Onyx repository
if !core.IsOnyxRepo(cwd) {
return fmt.Errorf("not an Onyx repository")
}
// Open the repository
repo, err := core.Open(cwd)
if err != nil {
return fmt.Errorf("failed to open repository: %w", err)
}
defer repo.Close()
// Create workstream manager
wsManager := core.NewWorkstreamManager(repo)
// Get all workstreams
workstreams, err := wsManager.ListWorkstreams()
if err != nil {
return fmt.Errorf("failed to list workstreams: %w", err)
}
// Get current workstream name
currentName, err := wsManager.GetCurrentWorkstreamName()
if err != nil {
currentName = "" // No current workstream
}
// Filter workstreams if not showing all
var displayWorkstreams []*models.Workstream
for _, ws := range workstreams {
if showAll || ws.Status == models.WorkstreamStatusActive {
displayWorkstreams = append(displayWorkstreams, ws)
}
}
// Check if there are any workstreams
if len(displayWorkstreams) == 0 {
if showAll {
fmt.Println("No workstreams found.")
} else {
fmt.Println("No active workstreams found.")
fmt.Println("Use 'onx new <name>' to create a new workstream.")
fmt.Println("Use 'onx list --all' to see all workstreams including merged and archived.")
}
return nil
}
// Sort workstreams by name for consistent output
sort.Slice(displayWorkstreams, func(i, j int) bool {
return displayWorkstreams[i].Name < displayWorkstreams[j].Name
})
// Display workstreams
fmt.Println("Workstreams:")
for _, ws := range displayWorkstreams {
displayWorkstream(ws, ws.Name == currentName)
}
// Show helpful footer
fmt.Println()
fmt.Printf("Use 'onx switch <name>' to switch to a different workstream\n")
if !showAll {
fmt.Printf("Use 'onx list --all' to see all workstreams\n")
}
return nil
}
// displayWorkstream displays a single workstream with formatting
func displayWorkstream(ws *models.Workstream, isCurrent bool) {
// Determine the indicator
indicator := " "
if isCurrent {
indicator = "*"
}
// Determine the color based on status
color := colorReset
switch ws.Status {
case models.WorkstreamStatusActive:
color = colorGreen
case models.WorkstreamStatusMerged:
color = colorGray
case models.WorkstreamStatusAbandoned:
color = colorGray
case models.WorkstreamStatusArchived:
color = colorGray
}
// Format the output
name := ws.Name
if isCurrent {
name = colorBold + name + colorReset
}
commitCount := ws.GetCommitCount()
commitText := "commit"
if commitCount != 1 {
commitText = "commits"
}
// Build status string
statusStr := string(ws.Status)
if ws.Status != models.WorkstreamStatusActive {
statusStr = colorGray + statusStr + colorReset
}
// Build the line
line := fmt.Sprintf("%s %s%s%s", indicator, color, name, colorReset)
// Add base branch info
baseBranchInfo := fmt.Sprintf(" (based on %s)", ws.BaseBranch)
line += colorGray + baseBranchInfo + colorReset
// Add commit count
commitInfo := fmt.Sprintf(" - %d %s", commitCount, commitText)
line += commitInfo
// Add status if not active
if ws.Status != models.WorkstreamStatusActive {
line += fmt.Sprintf(" [%s]", statusStr)
}
fmt.Println(line)
// Add description if present
if ws.Description != "" {
description := strings.TrimSpace(ws.Description)
fmt.Printf(" %s%s%s\n", colorGray, description, colorReset)
}
}

75
internal/commands/new.go Normal file
View File

@ -0,0 +1,75 @@
package commands
import (
"fmt"
"os"
"git.dws.rip/DWS/onyx/internal/core"
"github.com/spf13/cobra"
)
// NewNewCmd creates the new command
func NewNewCmd() *cobra.Command {
var baseBranch string
cmd := &cobra.Command{
Use: "new <name>",
Short: "Create a new workstream",
Long: `Create a new workstream for a feature or task.
A workstream is a logical unit of work that can contain multiple commits.
It's similar to creating a new branch in Git, but with better support for
stacked diffs and atomic operations.
The workstream will be based on the specified base branch (default: main).`,
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
return runNew(args[0], baseBranch)
},
}
cmd.Flags().StringVarP(&baseBranch, "base", "b", "main", "Base branch for the workstream")
return cmd
}
// runNew executes the new command
func runNew(name, baseBranch string) error {
// Get current directory
cwd, err := os.Getwd()
if err != nil {
return fmt.Errorf("failed to get current directory: %w", err)
}
// Check if this is an Onyx repository
if !core.IsOnyxRepo(cwd) {
return fmt.Errorf("not an Onyx repository. Run 'onx init' first")
}
// Open the repository
repo, err := core.Open(cwd)
if err != nil {
return fmt.Errorf("failed to open repository: %w", err)
}
defer repo.Close()
// Create workstream manager
wsManager := core.NewWorkstreamManager(repo)
// Use ExecuteWithTransaction to capture state_before and state_after
err = core.ExecuteWithTransaction(repo, "new", fmt.Sprintf("Created workstream: %s", name), func() error {
return wsManager.CreateWorkstream(name, baseBranch)
})
if err != nil {
return err
}
fmt.Printf("Created workstream '%s' based on '%s'\n", name, baseBranch)
fmt.Printf("\nYou can now:\n")
fmt.Printf(" - Make changes to your files\n")
fmt.Printf(" - Save your work with 'onx save -m \"message\"'\n")
fmt.Printf(" - Switch to another workstream with 'onx switch <name>'\n")
return nil
}

296
internal/commands/push.go Normal file
View File

@ -0,0 +1,296 @@
package commands
import (
"fmt"
"os"
"strings"
"git.dws.rip/DWS/onyx/internal/core"
"git.dws.rip/DWS/onyx/internal/git"
gogit "github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/config"
"github.com/spf13/cobra"
)
// NewPushCmd creates the push command
func NewPushCmd() *cobra.Command {
var remoteName string
var force bool
var stacked bool
cmd := &cobra.Command{
Use: "push",
Short: "Push the current workstream to the remote repository",
Long: `Push the current workstream to the remote repository.
By default, pushes as a single branch (clean, traditional workflow).
Use --stacked to push each commit as a separate branch (advanced stacked diffs).
Single-branch mode (default):
- Pushes workstream as one branch with all commits
- Clean remote UI (1 branch per workstream)
- Perfect for traditional PR workflows
- Example: 'milestone-4' branch
Stacked mode (--stacked):
- Pushes each commit as a separate branch
- Enables stacked diff workflow (Meta/Google style)
- Each commit can have its own PR
- Example: 'onyx/workstreams/milestone-4/commit-1', 'commit-2', etc.`,
RunE: func(cmd *cobra.Command, args []string) error {
return runPush(remoteName, force, stacked)
},
}
cmd.Flags().StringVarP(&remoteName, "remote", "r", "origin", "Remote to push to")
cmd.Flags().BoolVarP(&force, "force", "f", false, "Force push (use with caution)")
cmd.Flags().BoolVar(&stacked, "stacked", false, "Push each commit as separate branch (stacked diffs)")
return cmd
}
// runPush executes the push command
func runPush(remoteName string, force, stacked bool) error {
// Get current directory
cwd, err := os.Getwd()
if err != nil {
return fmt.Errorf("failed to get current directory: %w", err)
}
// Check if this is an Onyx repository
if !core.IsOnyxRepo(cwd) {
return fmt.Errorf("not an Onyx repository. Run 'onx init' first")
}
// Open the repository
repo, err := core.Open(cwd)
if err != nil {
return fmt.Errorf("failed to open repository: %w", err)
}
defer repo.Close()
// Use ExecuteWithTransaction to capture state
err = core.ExecuteWithTransaction(repo, "push", "Pushed to remote", func() error {
if stacked {
return executePushStacked(repo, remoteName, force)
}
return executePushSingleBranch(repo, remoteName, force)
})
if err != nil {
return err
}
fmt.Println("✓ Push completed successfully")
return nil
}
// executePushSingleBranch pushes the workstream as a single branch (default behavior)
func executePushSingleBranch(repo *core.OnyxRepository, remoteName string, force bool) error {
gitRepo := repo.GetGitRepo()
// 1. Validate remote exists
remoteHelper := git.NewRemoteHelper(gitRepo)
if err := remoteHelper.ValidateRemote(remoteName); err != nil {
return fmt.Errorf("remote validation failed: %w", err)
}
// 2. Get current workstream
wsManager := core.NewWorkstreamManager(repo)
currentWorkstream, err := wsManager.GetCurrentWorkstream()
if err != nil {
return fmt.Errorf("no active workstream: %w", err)
}
if currentWorkstream.IsEmpty() {
return fmt.Errorf("workstream has no commits to push")
}
// 3. Get the remote
remote, err := remoteHelper.GetRemote(remoteName)
if err != nil {
return fmt.Errorf("failed to get remote: %w", err)
}
// 4. Get the latest commit in the workstream
latestCommit, err := currentWorkstream.GetLatestCommit()
if err != nil {
return fmt.Errorf("failed to get latest commit: %w", err)
}
// 5. Build refspec to push the latest commit to a branch named after the workstream
branchName := currentWorkstream.Name
localRef := latestCommit.BranchRef
remoteRef := fmt.Sprintf("refs/heads/%s", branchName)
// Also create/update the local branch to point to the latest commit
// This ensures `refs/heads/master` (or whatever the workstream is) exists locally
gitBackend := git.NewGitBackend(gitRepo)
localBranchRef := fmt.Sprintf("refs/heads/%s", branchName)
if err := gitBackend.UpdateRef(localBranchRef, latestCommit.SHA); err != nil {
// Warn but don't fail - the push can still succeed
fmt.Fprintf(os.Stderr, "Warning: failed to update local branch %s: %v\n", branchName, err)
}
refSpec := config.RefSpec(fmt.Sprintf("%s:%s", localRef, remoteRef))
if force {
refSpec = config.RefSpec(fmt.Sprintf("+%s:%s", localRef, remoteRef))
}
// 6. Get authentication for the remote
remoteURL, err := remoteHelper.GetRemoteURL(remoteName)
if err != nil {
return fmt.Errorf("failed to get remote URL: %w", err)
}
authProvider := git.NewAuthProvider()
authMethod, err := authProvider.GetAuthMethod(remoteURL)
if err != nil {
// Log the error but continue - some remotes might not need auth
fmt.Fprintf(os.Stderr, "Warning: authentication not available: %v\n", err)
fmt.Fprintf(os.Stderr, "Attempting push without authentication...\n")
}
// 7. Push to remote
fmt.Printf("Pushing workstream '%s' to %s...\n", branchName, remoteName)
err = remote.Push(&gogit.PushOptions{
Auth: authMethod,
RefSpecs: []config.RefSpec{refSpec},
Progress: os.Stdout,
})
if err != nil {
if err == gogit.NoErrAlreadyUpToDate {
fmt.Println("Already up to date")
return nil
}
return fmt.Errorf("failed to push: %w", err)
}
fmt.Printf("✓ Pushed branch '%s' with %d commit(s)\n", branchName, len(currentWorkstream.Commits))
fmt.Printf("\nTo create a pull request:\n")
fmt.Printf(" gh pr create --base %s --head %s\n", currentWorkstream.BaseBranch, branchName)
return nil
}
// executePushStacked pushes each commit as a separate branch (stacked diffs)
func executePushStacked(repo *core.OnyxRepository, remoteName string, force bool) error {
gitRepo := repo.GetGitRepo()
// 1. Validate remote exists
remoteHelper := git.NewRemoteHelper(gitRepo)
if err := remoteHelper.ValidateRemote(remoteName); err != nil {
return fmt.Errorf("remote validation failed: %w", err)
}
// 2. Get current workstream
wsManager := core.NewWorkstreamManager(repo)
currentWorkstream, err := wsManager.GetCurrentWorkstream()
if err != nil {
return fmt.Errorf("no active workstream: %w", err)
}
if currentWorkstream.IsEmpty() {
return fmt.Errorf("workstream has no commits to push")
}
// 3. Get the remote
remote, err := remoteHelper.GetRemote(remoteName)
if err != nil {
return fmt.Errorf("failed to get remote: %w", err)
}
// 4. Build list of refspecs to push (all branches in the workstream)
refspecs := []config.RefSpec{}
// Also push the base branch if it exists locally
baseBranch := currentWorkstream.BaseBranch
if baseBranch != "" {
// Check if base branch exists locally
gitBackend := git.NewGitBackend(gitRepo)
baseRef := fmt.Sprintf("refs/heads/%s", baseBranch)
if _, err := gitBackend.GetRef(baseRef); err == nil {
refSpec := config.RefSpec(fmt.Sprintf("refs/heads/%s:refs/heads/%s", baseBranch, baseBranch))
if force {
refSpec = config.RefSpec(fmt.Sprintf("+refs/heads/%s:refs/heads/%s", baseBranch, baseBranch))
}
refspecs = append(refspecs, refSpec)
}
}
// Push each commit's branch ref
for i, commit := range currentWorkstream.Commits {
branchRef := commit.BranchRef
if branchRef == "" {
continue
}
// Extract branch name from ref (e.g., refs/onyx/workstreams/foo/commit-1 -> foo/commit-1)
// We'll push to refs/heads/onyx/workstreams/[workstream]/commit-[n]
remoteBranch := fmt.Sprintf("onyx/workstreams/%s/commit-%d", currentWorkstream.Name, i+1)
refSpec := config.RefSpec(fmt.Sprintf("%s:refs/heads/%s", branchRef, remoteBranch))
if force {
refSpec = config.RefSpec(fmt.Sprintf("+%s:refs/heads/%s", branchRef, remoteBranch))
}
refspecs = append(refspecs, refSpec)
}
if len(refspecs) == 0 {
return fmt.Errorf("no branches to push")
}
// 5. Get authentication for the remote
remoteURL, err := remoteHelper.GetRemoteURL(remoteName)
if err != nil {
return fmt.Errorf("failed to get remote URL: %w", err)
}
authProvider := git.NewAuthProvider()
authMethod, err := authProvider.GetAuthMethod(remoteURL)
if err != nil {
// Log the error but continue - some remotes might not need auth
fmt.Fprintf(os.Stderr, "Warning: authentication not available: %v\n", err)
fmt.Fprintf(os.Stderr, "Attempting push without authentication...\n")
}
// 6. Push to remote
fmt.Printf("Pushing %d branch(es) to %s...\n", len(refspecs), remoteName)
err = remote.Push(&gogit.PushOptions{
Auth: authMethod,
RefSpecs: refspecs,
Progress: os.Stdout,
})
if err != nil {
if err == gogit.NoErrAlreadyUpToDate {
fmt.Println("Already up to date")
return nil
}
return fmt.Errorf("failed to push: %w", err)
}
fmt.Printf("✓ Pushed %d branch(es) successfully\n", len(refspecs))
// 7. Print summary of pushed branches
fmt.Println("\nPushed branches (stacked diffs):")
if baseBranch != "" {
fmt.Printf(" - %s (base branch)\n", baseBranch)
}
for i, commit := range currentWorkstream.Commits {
remoteBranch := fmt.Sprintf("onyx/workstreams/%s/commit-%d", currentWorkstream.Name, i+1)
commitTitle := strings.Split(commit.Message, "\n")[0]
if len(commitTitle) > 60 {
commitTitle = commitTitle[:57] + "..."
}
fmt.Printf(" - %s: %s\n", remoteBranch, commitTitle)
}
fmt.Printf("\nTip: Each branch can have its own PR for incremental review\n")
return nil
}

225
internal/commands/save.go Normal file
View File

@ -0,0 +1,225 @@
package commands
import (
"fmt"
"os"
"strings"
"git.dws.rip/DWS/onyx/internal/core"
"git.dws.rip/DWS/onyx/internal/git"
gogit "github.com/go-git/go-git/v5"
"github.com/spf13/cobra"
)
const (
// OnyxWorkspaceRef is the ref where ephemeral commits are stored
OnyxWorkspaceRef = "refs/onyx/workspaces/current"
// MaxCommitTitleLength is the maximum length for a commit title
MaxCommitTitleLength = 72
)
// NewSaveCmd creates the save command
func NewSaveCmd() *cobra.Command {
var message string
cmd := &cobra.Command{
Use: "save",
Short: "Save the current work as a permanent commit",
Long: `Converts the current ephemeral snapshot into a permanent commit
in the active workstream. This is similar to 'git commit' but works
with Onyx's workstream model.`,
RunE: func(cmd *cobra.Command, args []string) error {
return runSave(message)
},
}
cmd.Flags().StringVarP(&message, "message", "m", "", "Commit message (required)")
cmd.MarkFlagRequired("message")
return cmd
}
// runSave executes the save command
func runSave(message string) error {
// Validate the commit message
if err := validateCommitMessage(message); err != nil {
return err
}
// Get current directory
cwd, err := os.Getwd()
if err != nil {
return fmt.Errorf("failed to get current directory: %w", err)
}
// Check if this is an Onyx repository
if !core.IsOnyxRepo(cwd) {
return fmt.Errorf("not an Onyx repository")
}
// Open the repository
repo, err := core.Open(cwd)
if err != nil {
return fmt.Errorf("failed to open repository: %w", err)
}
defer repo.Close()
// Use ExecuteWithTransaction to capture state_before and state_after
err = core.ExecuteWithTransaction(repo, "save", message, func() error {
return executeSave(repo, message)
})
if err != nil {
return err
}
fmt.Printf("Successfully saved commit: %s\n", message)
return nil
}
// executeSave performs the actual save operation
func executeSave(repo *core.OnyxRepository, message string) error {
gitBackend := git.NewGitBackend(repo.GetGitRepo())
gitRepo := repo.GetGitRepo()
// 1. Try to read current ephemeral commit from workspace ref
ephemeralCommitSHA, err := getEphemeralCommit(gitBackend)
var treeHash string
if err != nil {
// No ephemeral commit yet - this is the first commit or daemon isn't running
// Use worktree to stage and get tree from working directory
worktree, err := gitRepo.Worktree()
if err != nil {
return fmt.Errorf("failed to get worktree: %w", err)
}
// Get all files including untracked ones
status, err := worktree.Status()
if err != nil {
return fmt.Errorf("failed to get status: %w", err)
}
// Add all files (including untracked) to the index
for file := range status {
_, err = worktree.Add(file)
if err != nil {
return fmt.Errorf("failed to add file %s: %w", file, err)
}
}
if len(status) == 0 {
return fmt.Errorf("no changes to commit")
}
// Create a temporary commit to get the tree hash
// This is a workaround since we need the tree object
tempCommitHash, err := worktree.Commit("temp for tree extraction", &gogit.CommitOptions{
All: true,
AllowEmptyCommits: false,
})
if err != nil {
return fmt.Errorf("failed to create temporary commit: %w", err)
}
// Get the tree hash from the temporary commit
tempCommit, err := gitRepo.CommitObject(tempCommitHash)
if err != nil {
return fmt.Errorf("failed to get temporary commit: %w", err)
}
treeHash = tempCommit.TreeHash.String()
// Note: We leave the temp commit in place - it will be orphaned
// when we create the real commit, and can be cleaned up by git gc
} else {
// 2. Get the commit object to extract the tree
ephemeralCommit, err := gitBackend.GetCommit(ephemeralCommitSHA)
if err != nil {
return fmt.Errorf("failed to get ephemeral commit object: %w", err)
}
treeHash = ephemeralCommit.TreeHash.String()
}
// 3. Create workstream manager
wsManager := core.NewWorkstreamManager(repo)
// 4. Get the current workstream
currentWorkstream, err := wsManager.GetCurrentWorkstream()
if err != nil {
return fmt.Errorf("no active workstream. Use 'onx new' to create one: %w", err)
}
// 5. Determine the parent commit
var parentSHA string
if !currentWorkstream.IsEmpty() {
latestCommit, err := currentWorkstream.GetLatestCommit()
if err != nil {
return err
}
parentSHA = latestCommit.SHA
} else {
// For the first commit in the workstream, use the base commit
baseCommitSHA := currentWorkstream.Metadata["base_commit"]
if baseCommitSHA == "" {
// Fallback to getting the base branch HEAD
baseBranch := currentWorkstream.BaseBranch
if baseBranch == "" {
baseBranch = "main"
}
branchRef := fmt.Sprintf("refs/heads/%s", baseBranch)
sha, err := gitBackend.GetRef(branchRef)
if err == nil {
parentSHA = sha
}
} else {
parentSHA = baseCommitSHA
}
}
// 6. Create new commit with the user's message
commitSHA, err := gitBackend.CreateCommit(treeHash, parentSHA, message, "User")
if err != nil {
return fmt.Errorf("failed to create commit: %w", err)
}
// 7. Add commit to workstream using the manager
if err := wsManager.AddCommitToWorkstream(commitSHA, message); err != nil {
return fmt.Errorf("failed to add commit to workstream: %w", err)
}
return nil
}
// getEphemeralCommit retrieves the current ephemeral commit SHA
func getEphemeralCommit(gitBackend *git.GitBackend) (string, error) {
sha, err := gitBackend.GetRef(OnyxWorkspaceRef)
if err != nil {
return "", fmt.Errorf("no ephemeral commit found. The daemon may not be running")
}
return sha, nil
}
// validateCommitMessage validates the commit message
func validateCommitMessage(message string) error {
// Check if message is empty
if strings.TrimSpace(message) == "" {
return fmt.Errorf("commit message cannot be empty")
}
// Split into lines
lines := strings.Split(message, "\n")
// Validate title (first line)
title := strings.TrimSpace(lines[0])
if title == "" {
return fmt.Errorf("commit message title cannot be empty")
}
if len(title) > MaxCommitTitleLength {
return fmt.Errorf("commit message title is too long (%d characters). Maximum is %d characters", len(title), MaxCommitTitleLength)
}
return nil
}

139
internal/commands/switch.go Normal file
View File

@ -0,0 +1,139 @@
package commands
import (
"fmt"
"os"
"git.dws.rip/DWS/onyx/internal/core"
"github.com/spf13/cobra"
)
// NewSwitchCmd creates the switch command
func NewSwitchCmd() *cobra.Command {
var force bool
cmd := &cobra.Command{
Use: "switch <name>",
Short: "Switch to a different workstream",
Long: `Switch to a different workstream.
This command will:
1. Check for uncommitted changes (unless --force is used)
2. Load the target workstream
3. Checkout the latest commit in the target workstream
4. Update the current workstream pointer
⚠️ Warning: Switching discards uncommitted changes in your working directory.
Use 'onx save' to commit your work before switching, or use --force to bypass the safety check.`,
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
return runSwitch(args[0], force)
},
}
cmd.Flags().BoolVarP(&force, "force", "f", false, "Force switch even with uncommitted changes")
return cmd
}
// runSwitch executes the switch command
func runSwitch(name string, force bool) error {
// Get current directory
cwd, err := os.Getwd()
if err != nil {
return fmt.Errorf("failed to get current directory: %w", err)
}
// Check if this is an Onyx repository
if !core.IsOnyxRepo(cwd) {
return fmt.Errorf("not an Onyx repository")
}
// Open the repository
repo, err := core.Open(cwd)
if err != nil {
return fmt.Errorf("failed to open repository: %w", err)
}
defer repo.Close()
// Create workstream manager
wsManager := core.NewWorkstreamManager(repo)
// Get current workstream name before switching
currentName, err := wsManager.GetCurrentWorkstreamName()
if err != nil {
currentName = "none"
}
// Check if we're already on the target workstream
if currentName == name {
fmt.Printf("Already on workstream '%s'\n", name)
return nil
}
// Check for uncommitted changes unless force is enabled
if !force {
gitRepo := repo.GetGitRepo()
worktree, err := gitRepo.Worktree()
if err != nil {
return fmt.Errorf("failed to get worktree: %w", err)
}
status, err := worktree.Status()
if err != nil {
return fmt.Errorf("failed to check status: %w", err)
}
if !status.IsClean() {
// Show which files have changes
fmt.Println("Error: You have uncommitted changes:")
for file, fileStatus := range status {
if fileStatus.Worktree != ' ' || fileStatus.Staging != ' ' {
fmt.Printf(" %c%c %s\n", fileStatus.Staging, fileStatus.Worktree, file)
}
}
fmt.Println("\nPlease commit your changes or use --force to discard them:")
fmt.Printf(" onx save -m \"WIP\" # Save your work\n")
fmt.Printf(" onx switch %s --force # Discard changes and switch\n", name)
return fmt.Errorf("uncommitted changes present")
}
}
// Use ExecuteWithTransaction to capture state_before and state_after
err = core.ExecuteWithTransaction(repo, "switch", fmt.Sprintf("Switched from '%s' to '%s'", currentName, name), func() error {
return wsManager.SwitchWorkstream(name)
})
if err != nil {
return err
}
// Get the workstream we just switched to
targetWorkstream, err := wsManager.GetCurrentWorkstream()
if err != nil {
return fmt.Errorf("failed to get workstream after switch: %w", err)
}
// Display success message
fmt.Printf("Switched to workstream '%s'\n", name)
// Show workstream info
commitCount := targetWorkstream.GetCommitCount()
if commitCount == 0 {
fmt.Printf("\nThis is a new workstream based on '%s' with no commits yet.\n", targetWorkstream.BaseBranch)
fmt.Printf("Make changes and save them with 'onx save -m \"message\"'\n")
} else {
commitText := "commit"
if commitCount != 1 {
commitText = "commits"
}
fmt.Printf("\nThis workstream has %d %s.\n", commitCount, commitText)
// Show the latest commit
if latestCommit, err := targetWorkstream.GetLatestCommit(); err == nil {
fmt.Printf("Latest commit: %s\n", latestCommit.Message)
}
}
return nil
}

222
internal/commands/sync.go Normal file
View File

@ -0,0 +1,222 @@
package commands
import (
"fmt"
"os"
"path/filepath"
"git.dws.rip/DWS/onyx/internal/core"
"git.dws.rip/DWS/onyx/internal/git"
"git.dws.rip/DWS/onyx/internal/models"
"git.dws.rip/DWS/onyx/internal/storage"
gogit "github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/config"
"github.com/spf13/cobra"
)
// NewSyncCmd creates the sync command
func NewSyncCmd() *cobra.Command {
var remoteName string
cmd := &cobra.Command{
Use: "sync",
Short: "Sync the current workstream with the remote base branch",
Long: `Synchronize the current workstream with the remote base branch.
This command will:
1. Fetch the latest changes from the remote
2. Rebase the workstream commits onto the updated base branch
3. Use rerere to automatically resolve known conflicts
4. Update all branch references in the workstream
If conflicts occur during the rebase, you will need to resolve them manually
and then continue the sync operation.`,
RunE: func(cmd *cobra.Command, args []string) error {
return runSync(remoteName)
},
}
cmd.Flags().StringVarP(&remoteName, "remote", "r", "origin", "Remote to sync with")
return cmd
}
// runSync executes the sync command
func runSync(remoteName string) error {
// Get current directory
cwd, err := os.Getwd()
if err != nil {
return fmt.Errorf("failed to get current directory: %w", err)
}
// Check if this is an Onyx repository
if !core.IsOnyxRepo(cwd) {
return fmt.Errorf("not an Onyx repository. Run 'onx init' first")
}
// Open the repository
repo, err := core.Open(cwd)
if err != nil {
return fmt.Errorf("failed to open repository: %w", err)
}
defer repo.Close()
// Use ExecuteWithTransaction to capture state
err = core.ExecuteWithTransaction(repo, "sync", "Synced with remote", func() error {
return executeSync(repo, cwd, remoteName)
})
if err != nil {
return err
}
fmt.Println("✓ Sync completed successfully")
return nil
}
// executeSync performs the actual sync operation
func executeSync(repo *core.OnyxRepository, repoPath, remoteName string) error {
gitRepo := repo.GetGitRepo()
onyxPath := repo.GetOnyxPath()
// 1. Validate remote exists
remoteHelper := git.NewRemoteHelper(gitRepo)
if err := remoteHelper.ValidateRemote(remoteName); err != nil {
return fmt.Errorf("remote validation failed: %w", err)
}
// 2. Get current workstream
wsManager := core.NewWorkstreamManager(repo)
currentWorkstream, err := wsManager.GetCurrentWorkstream()
if err != nil {
return fmt.Errorf("no active workstream: %w", err)
}
if currentWorkstream.IsEmpty() {
return fmt.Errorf("workstream has no commits to sync")
}
// 3. Get authentication for the remote
remoteURL, err := remoteHelper.GetRemoteURL(remoteName)
if err != nil {
return fmt.Errorf("failed to get remote URL: %w", err)
}
authProvider := git.NewAuthProvider()
authMethod, err := authProvider.GetAuthMethod(remoteURL)
if err != nil {
// Log the error but continue - some remotes might not need auth
fmt.Fprintf(os.Stderr, "Warning: authentication not available: %v\n", err)
fmt.Fprintf(os.Stderr, "Attempting fetch without authentication...\n")
}
// 4. Fetch from remote
fmt.Printf("Fetching from %s...\n", remoteName)
remote, err := remoteHelper.GetRemote(remoteName)
if err != nil {
return fmt.Errorf("failed to get remote: %w", err)
}
err = remote.Fetch(&gogit.FetchOptions{
Auth: authMethod,
RefSpecs: []config.RefSpec{
config.RefSpec(fmt.Sprintf("+refs/heads/%s:refs/remotes/%s/%s",
currentWorkstream.BaseBranch, remoteName, currentWorkstream.BaseBranch)),
},
Progress: os.Stdout,
})
if err != nil && err != gogit.NoErrAlreadyUpToDate {
return fmt.Errorf("failed to fetch: %w", err)
}
if err == gogit.NoErrAlreadyUpToDate {
fmt.Println("Already up to date")
}
// 5. Get the updated base branch HEAD
gitBackend := git.NewGitBackend(gitRepo)
remoteRef := fmt.Sprintf("refs/remotes/%s/%s", remoteName, currentWorkstream.BaseBranch)
newBaseSHA, err := gitBackend.GetRef(remoteRef)
if err != nil {
return fmt.Errorf("failed to get remote base branch: %w", err)
}
// 6. Build the commit stack from the workstream
stack := []string{}
for _, commit := range currentWorkstream.Commits {
stack = append(stack, commit.SHA)
}
// 7. Create rebase engine with rerere support
rebaseEngine := git.NewRebaseEngine(gitRepo, onyxPath, repoPath)
fmt.Printf("Rebasing %d commit(s) onto %s...\n", len(stack), newBaseSHA[:8])
// 8. Perform the rebase
result, err := rebaseEngine.RebaseStack(stack, newBaseSHA)
if err != nil {
return fmt.Errorf("rebase failed: %w", err)
}
// 9. Handle rebase result
if !result.Success {
if len(result.ConflictingFiles) > 0 {
// Present conflicts to user
conflictResolver := rebaseEngine.GetConflictResolver()
conflictMsg := conflictResolver.PresentConflicts(result.ConflictingFiles)
fmt.Println(conflictMsg)
return fmt.Errorf("sync paused due to conflicts")
}
return fmt.Errorf("rebase failed: %s", result.Message)
}
// 10. Update workstream commits with new SHAs
if err := updateWorkstreamCommits(repo, currentWorkstream, result.RebasedCommits); err != nil {
return fmt.Errorf("failed to update workstream: %w", err)
}
// 11. Update the base commit metadata
currentWorkstream.Metadata["base_commit"] = newBaseSHA
wsCollection, err := storage.LoadWorkstreams(filepath.Join(onyxPath, "workstreams.json"))
if err != nil {
return fmt.Errorf("failed to load workstreams: %w", err)
}
if err := storage.SaveWorkstreams(filepath.Join(onyxPath, "workstreams.json"), wsCollection); err != nil {
return fmt.Errorf("failed to save workstreams: %w", err)
}
fmt.Printf("✓ Rebased %d commit(s) successfully\n", len(result.RebasedCommits))
return nil
}
// updateWorkstreamCommits updates the workstream with new rebased commit SHAs
func updateWorkstreamCommits(repo *core.OnyxRepository, ws *models.Workstream, newSHAs []string) error {
if len(ws.Commits) != len(newSHAs) {
return fmt.Errorf("mismatch between old and new commit counts")
}
gitBackend := git.NewGitBackend(repo.GetGitRepo())
// Update each commit SHA and its branch ref
for i := range ws.Commits {
oldSHA := ws.Commits[i].SHA
newSHA := newSHAs[i]
// Update the commit SHA
ws.Commits[i].SHA = newSHA
// Update the branch ref to point to the new commit
branchRef := ws.Commits[i].BranchRef
if branchRef != "" {
if err := gitBackend.UpdateRef(branchRef, newSHA); err != nil {
return fmt.Errorf("failed to update ref %s: %w", branchRef, err)
}
}
fmt.Printf(" %s -> %s\n", oldSHA[:8], newSHA[:8])
}
return nil
}

204
internal/commands/undo.go Normal file
View File

@ -0,0 +1,204 @@
package commands
import (
"fmt"
"os"
"path/filepath"
"git.dws.rip/DWS/onyx/internal/core"
"git.dws.rip/DWS/onyx/internal/storage"
"github.com/spf13/cobra"
)
// NewUndoCmd creates the undo command
func NewUndoCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "undo",
Short: "Undo the last operation",
Long: `Undo the last operation by restoring the repository to its previous state.
This command reads the last entry from the oplog and restores all refs
and working directory state to what they were before the operation.`,
Args: cobra.NoArgs,
RunE: runUndo,
}
return cmd
}
func runUndo(cmd *cobra.Command, args []string) error {
// Get current directory
cwd, err := os.Getwd()
if err != nil {
return fmt.Errorf("failed to get current directory: %w", err)
}
// Check if we're in an Onyx repository
if !core.IsOnyxRepo(cwd) {
return fmt.Errorf("not an onyx repository (or any parent up to mount point)")
}
// Open the repository
repo, err := core.Open(cwd)
if err != nil {
return fmt.Errorf("failed to open repository: %w", err)
}
defer repo.Close()
// Open oplog reader
oplogPath := filepath.Join(repo.GetOnyxPath(), "oplog")
reader := storage.NewOplogReader(oplogPath)
// Check if oplog is empty
isEmpty, err := reader.IsEmpty()
if err != nil {
return fmt.Errorf("failed to check oplog: %w", err)
}
if isEmpty {
return fmt.Errorf("nothing to undo")
}
// Read the last entry
lastEntry, err := reader.ReadLastEntry()
if err != nil {
return fmt.Errorf("failed to read last entry: %w", err)
}
// Check if we have state_before to restore
if lastEntry.StateBefore == nil {
return fmt.Errorf("cannot undo: last operation has no state_before")
}
// Show what we're undoing
fmt.Printf("Undoing: %s - %s\n", lastEntry.Operation, lastEntry.Description)
// Create state capture to restore the state
stateCapture := storage.NewStateCapture(repo.GetGitRepo())
// Restore the state
err = stateCapture.RestoreState(lastEntry.StateBefore)
if err != nil {
return fmt.Errorf("failed to restore state: %w", err)
}
// Log the undo operation
txn, err := core.NewTransaction(repo)
if err != nil {
// Don't fail if we can't create transaction, state is already restored
fmt.Fprintf(os.Stderr, "Warning: failed to log undo to oplog: %v\n", err)
} else {
defer txn.Close()
metadata := map[string]string{
"undone_entry_id": fmt.Sprintf("%d", lastEntry.ID),
"undone_operation": lastEntry.Operation,
}
err = txn.ExecuteWithTransactionAndMetadata(
"undo",
fmt.Sprintf("Undid operation: %s", lastEntry.Operation),
metadata,
func() error {
// The actual undo has already been performed above
// This function is just to capture the state after undo
return nil
},
)
if err != nil {
fmt.Fprintf(os.Stderr, "Warning: failed to log undo: %v\n", err)
}
}
// Show what changed
stateAfter, _ := stateCapture.CaptureState()
if stateAfter != nil {
differences := stateCapture.CompareStates(stateAfter, lastEntry.StateBefore)
if len(differences) > 0 {
fmt.Println("\nChanges:")
for ref, change := range differences {
fmt.Printf(" %s: %s\n", ref, change)
}
}
}
fmt.Println("\nUndo complete!")
return nil
}
// UndoToEntry undoes to a specific entry ID
func UndoToEntry(repo *core.OnyxRepository, entryID uint64) error {
oplogPath := filepath.Join(repo.GetOnyxPath(), "oplog")
reader := storage.NewOplogReader(oplogPath)
// Read the target entry
entry, err := reader.ReadEntry(entryID)
if err != nil {
return fmt.Errorf("failed to read entry %d: %w", entryID, err)
}
if entry.StateBefore == nil {
return fmt.Errorf("entry %d has no state_before to restore", entryID)
}
// Restore the state
stateCapture := storage.NewStateCapture(repo.GetGitRepo())
err = stateCapture.RestoreState(entry.StateBefore)
if err != nil {
return fmt.Errorf("failed to restore state: %w", err)
}
// Log the undo operation
txn, err := core.NewTransaction(repo)
if err != nil {
return fmt.Errorf("failed to create transaction: %w", err)
}
defer txn.Close()
metadata := map[string]string{
"undone_to_entry_id": fmt.Sprintf("%d", entryID),
"undone_operation": entry.Operation,
}
err = txn.ExecuteWithTransactionAndMetadata(
"undo",
fmt.Sprintf("Undid to entry %d: %s", entryID, entry.Operation),
metadata,
func() error {
return nil
},
)
if err != nil {
return fmt.Errorf("failed to log undo: %w", err)
}
return nil
}
// ListUndoStack shows the undo stack
func ListUndoStack(repo *core.OnyxRepository) error {
oplogPath := filepath.Join(repo.GetOnyxPath(), "oplog")
reader := storage.NewOplogReader(oplogPath)
entries, err := reader.GetUndoStack()
if err != nil {
return fmt.Errorf("failed to get undo stack: %w", err)
}
if len(entries) == 0 {
fmt.Println("Nothing to undo")
return nil
}
fmt.Println("Undo stack (most recent first):")
for i, entry := range entries {
fmt.Printf("%d. [%d] %s: %s (%s)\n",
i+1,
entry.ID,
entry.Operation,
entry.Description,
entry.Timestamp.Format("2006-01-02 15:04:05"),
)
}
return nil
}

300
internal/commands/undo_test.go Normal file
View File

@ -0,0 +1,300 @@
package commands
import (
"path/filepath"
"testing"
"git.dws.rip/DWS/onyx/internal/core"
"git.dws.rip/DWS/onyx/internal/storage"
)
func TestUndoWithEmptyOplog(t *testing.T) {
// Create a temporary directory for testing
tempDir := t.TempDir()
// Initialize the repository
repo := &core.OnyxRepository{}
err := repo.Init(tempDir)
if err != nil {
t.Fatalf("Failed to initialize repository: %v", err)
}
// Open the repository
openedRepo, err := core.Open(tempDir)
if err != nil {
t.Fatalf("Failed to open repository: %v", err)
}
defer openedRepo.Close()
// Try to undo with empty oplog
oplogPath := filepath.Join(openedRepo.GetOnyxPath(), "oplog")
reader := storage.NewOplogReader(oplogPath)
isEmpty, err := reader.IsEmpty()
if err != nil {
t.Fatalf("Failed to check if oplog is empty: %v", err)
}
if !isEmpty {
t.Errorf("Expected oplog to be empty after init")
}
_, err = reader.ReadLastEntry()
if err == nil {
t.Errorf("Expected error when reading from empty oplog, got nil")
}
}
func TestUndoAfterOperation(t *testing.T) {
// Create a temporary directory for testing
tempDir := t.TempDir()
// Initialize the repository
repo := &core.OnyxRepository{}
err := repo.Init(tempDir)
if err != nil {
t.Fatalf("Failed to initialize repository: %v", err)
}
// Open the repository
openedRepo, err := core.Open(tempDir)
if err != nil {
t.Fatalf("Failed to open repository: %v", err)
}
defer openedRepo.Close()
// Perform an operation with transaction
txn, err := core.NewTransaction(openedRepo)
if err != nil {
t.Fatalf("Failed to create transaction: %v", err)
}
err = txn.ExecuteWithTransaction("test_operation", "Test operation for undo", func() error {
// Simulate some operation
return nil
})
txn.Close()
if err != nil {
t.Fatalf("Failed to execute transaction: %v", err)
}
// Verify the oplog has an entry
oplogPath := filepath.Join(openedRepo.GetOnyxPath(), "oplog")
reader := storage.NewOplogReader(oplogPath)
isEmpty, err := reader.IsEmpty()
if err != nil {
t.Fatalf("Failed to check if oplog is empty: %v", err)
}
if isEmpty {
t.Errorf("Expected oplog to have entries after operation")
}
// Read the last entry
lastEntry, err := reader.ReadLastEntry()
if err != nil {
t.Fatalf("Failed to read last entry: %v", err)
}
if lastEntry.Operation != "test_operation" {
t.Errorf("Expected operation to be 'test_operation', got %q", lastEntry.Operation)
}
if lastEntry.Description != "Test operation for undo" {
t.Errorf("Expected description to be 'Test operation for undo', got %q", lastEntry.Description)
}
// Verify state_before and state_after are captured
if lastEntry.StateBefore == nil {
t.Errorf("Expected state_before to be captured")
}
if lastEntry.StateAfter == nil {
t.Errorf("Expected state_after to be captured")
}
}
func TestSequentialUndos(t *testing.T) {
// Create a temporary directory for testing
tempDir := t.TempDir()
// Initialize the repository
repo := &core.OnyxRepository{}
err := repo.Init(tempDir)
if err != nil {
t.Fatalf("Failed to initialize repository: %v", err)
}
// Open the repository
openedRepo, err := core.Open(tempDir)
if err != nil {
t.Fatalf("Failed to open repository: %v", err)
}
defer openedRepo.Close()
// Perform multiple operations
operations := []string{"operation1", "operation2", "operation3"}
for _, op := range operations {
txn, err := core.NewTransaction(openedRepo)
if err != nil {
t.Fatalf("Failed to create transaction: %v", err)
}
err = txn.ExecuteWithTransaction(op, "Test "+op, func() error {
return nil
})
txn.Close()
if err != nil {
t.Fatalf("Failed to execute transaction for %s: %v", op, err)
}
}
// Verify we have 3 entries
oplogPath := filepath.Join(openedRepo.GetOnyxPath(), "oplog")
reader := storage.NewOplogReader(oplogPath)
count, err := reader.Count()
if err != nil {
t.Fatalf("Failed to count oplog entries: %v", err)
}
if count != 3 {
t.Errorf("Expected 3 oplog entries, got %d", count)
}
// Read all entries to verify order
entries, err := reader.ReadAllEntries()
if err != nil {
t.Fatalf("Failed to read all entries: %v", err)
}
for i, entry := range entries {
expectedOp := operations[i]
if entry.Operation != expectedOp {
t.Errorf("Entry %d: expected operation %q, got %q", i, expectedOp, entry.Operation)
}
}
}
func TestUndoStack(t *testing.T) {
// Create a temporary directory for testing
tempDir := t.TempDir()
// Initialize the repository
repo := &core.OnyxRepository{}
err := repo.Init(tempDir)
if err != nil {
t.Fatalf("Failed to initialize repository: %v", err)
}
// Open the repository
openedRepo, err := core.Open(tempDir)
if err != nil {
t.Fatalf("Failed to open repository: %v", err)
}
defer openedRepo.Close()
// Perform multiple operations
operations := []string{"op1", "op2", "op3"}
for _, op := range operations {
txn, err := core.NewTransaction(openedRepo)
if err != nil {
t.Fatalf("Failed to create transaction: %v", err)
}
err = txn.ExecuteWithTransaction(op, "Test "+op, func() error {
return nil
})
txn.Close()
if err != nil {
t.Fatalf("Failed to execute transaction for %s: %v", op, err)
}
}
// Get the undo stack
oplogPath := filepath.Join(openedRepo.GetOnyxPath(), "oplog")
reader := storage.NewOplogReader(oplogPath)
undoStack, err := reader.GetUndoStack()
if err != nil {
t.Fatalf("Failed to get undo stack: %v", err)
}
if len(undoStack) != 3 {
t.Errorf("Expected undo stack size of 3, got %d", len(undoStack))
}
// Verify the stack is in reverse order (most recent first)
expectedOps := []string{"op3", "op2", "op1"}
for i, entry := range undoStack {
if entry.Operation != expectedOps[i] {
t.Errorf("Undo stack[%d]: expected operation %q, got %q", i, expectedOps[i], entry.Operation)
}
}
}
func TestOplogEntryMetadata(t *testing.T) {
// Create a temporary directory for testing
tempDir := t.TempDir()
// Initialize the repository
repo := &core.OnyxRepository{}
err := repo.Init(tempDir)
if err != nil {
t.Fatalf("Failed to initialize repository: %v", err)
}
// Open the repository
openedRepo, err := core.Open(tempDir)
if err != nil {
t.Fatalf("Failed to open repository: %v", err)
}
defer openedRepo.Close()
// Perform an operation with metadata
txn, err := core.NewTransaction(openedRepo)
if err != nil {
t.Fatalf("Failed to create transaction: %v", err)
}
metadata := map[string]string{
"key1": "value1",
"key2": "value2",
}
err = txn.ExecuteWithTransactionAndMetadata("test_op", "Test with metadata", metadata, func() error {
return nil
})
txn.Close()
if err != nil {
t.Fatalf("Failed to execute transaction with metadata: %v", err)
}
// Read the entry and verify metadata
oplogPath := filepath.Join(openedRepo.GetOnyxPath(), "oplog")
reader := storage.NewOplogReader(oplogPath)
lastEntry, err := reader.ReadLastEntry()
if err != nil {
t.Fatalf("Failed to read last entry: %v", err)
}
if lastEntry.Metadata == nil {
t.Fatalf("Expected metadata to be present")
}
if lastEntry.Metadata["key1"] != "value1" {
t.Errorf("Expected metadata key1=value1, got %q", lastEntry.Metadata["key1"])
}
if lastEntry.Metadata["key2"] != "value2" {
t.Errorf("Expected metadata key2=value2, got %q", lastEntry.Metadata["key2"])
}
}

74
internal/core/interfaces.go Normal file
View File

@ -0,0 +1,74 @@
package core
import (
"time"
gogit "github.com/go-git/go-git/v5"
)
// Repository represents an Onyx repository with both Git and Onyx-specific metadata
type Repository interface {
// Init initializes a new Onyx repository at the given path
Init(path string) error
// GetGitRepo returns the underlying Git repository
GetGitRepo() *gogit.Repository
// GetOnyxMetadata returns Onyx-specific metadata
GetOnyxMetadata() *OnyxMetadata
// Close releases any resources held by the repository
Close() error
}
// GitBackend provides low-level Git object operations
type GitBackend interface {
// CreateCommit creates a new commit object
CreateCommit(tree, parent, message string) (string, error)
// CreateTree creates a new tree object from the given entries
CreateTree(entries []TreeEntry) (string, error)
// UpdateRef updates a Git reference to point to a new SHA
UpdateRef(name, sha string) error
// GetRef retrieves the SHA that a reference points to
GetRef(name string) (string, error)
// CreateBlob creates a new blob object from content
CreateBlob(content []byte) (string, error)
// GetObject retrieves a Git object by its SHA
GetObject(sha string) (Object, error)
}
// TreeEntry represents an entry in a Git tree object
type TreeEntry struct {
Mode int // File mode (e.g., 0100644 for regular file, 040000 for directory)
Name string // Entry name
SHA string // Object SHA-1 hash
}
// Object represents a Git object (blob, tree, commit, or tag)
type Object interface {
// Type returns the type of the object (blob, tree, commit, tag)
Type() string
// SHA returns the SHA-1 hash of the object
SHA() string
// Size returns the size of the object in bytes
Size() int64
}
// OnyxMetadata holds Onyx-specific repository metadata
type OnyxMetadata struct {
// Version of the Onyx repository format
Version string
// Created timestamp when the repository was initialized
Created time.Time
// Path to the .onx directory
OnyxPath string
}

178
internal/core/repository.go Normal file
View File

@ -0,0 +1,178 @@
package core
import (
"fmt"
"os"
"path/filepath"
"time"
gogit "github.com/go-git/go-git/v5"
)
// OnyxRepository implements the Repository interface
type OnyxRepository struct {
gitRepo *gogit.Repository
onyxPath string
gitPath string
metadata *OnyxMetadata
}
// Open opens an existing Onyx repository at the given path
func Open(path string) (*OnyxRepository, error) {
// Resolve to absolute path
absPath, err := filepath.Abs(path)
if err != nil {
return nil, fmt.Errorf("failed to resolve path: %w", err)
}
// Check if .git directory exists
gitPath := filepath.Join(absPath, ".git")
if _, err := os.Stat(gitPath); os.IsNotExist(err) {
return nil, fmt.Errorf("not a git repository (no .git directory found)")
}
// Check if .onx directory exists
onyxPath := filepath.Join(absPath, ".onx")
if _, err := os.Stat(onyxPath); os.IsNotExist(err) {
return nil, fmt.Errorf("not an onyx repository (no .onx directory found)")
}
// Open the Git repository
gitRepo, err := gogit.PlainOpen(absPath)
if err != nil {
return nil, fmt.Errorf("failed to open git repository: %w", err)
}
// Load Onyx metadata
metadata := &OnyxMetadata{
Version: "1.0.0",
Created: time.Now(), // TODO: Load from .onx/metadata file
OnyxPath: onyxPath,
}
return &OnyxRepository{
gitRepo: gitRepo,
onyxPath: onyxPath,
gitPath: gitPath,
metadata: metadata,
}, nil
}
// Init initializes a new Onyx repository at the given path
func (r *OnyxRepository) Init(path string) error {
// Resolve to absolute path
absPath, err := filepath.Abs(path)
if err != nil {
return fmt.Errorf("failed to resolve path: %w", err)
}
// Check if directory exists, create if it doesn't
if _, err := os.Stat(absPath); os.IsNotExist(err) {
if err := os.MkdirAll(absPath, 0755); err != nil {
return fmt.Errorf("failed to create directory: %w", err)
}
}
// Initialize Git repository if it doesn't exist
gitPath := filepath.Join(absPath, ".git")
if _, err := os.Stat(gitPath); os.IsNotExist(err) {
_, err := gogit.PlainInit(absPath, false)
if err != nil {
return fmt.Errorf("failed to initialize git repository: %w", err)
}
}
// Create .onx directory structure
onyxPath := filepath.Join(absPath, ".onx")
if err := os.MkdirAll(onyxPath, 0755); err != nil {
return fmt.Errorf("failed to create .onx directory: %w", err)
}
// Create subdirectories
subdirs := []string{"rerere_cache"}
for _, subdir := range subdirs {
subdirPath := filepath.Join(onyxPath, subdir)
if err := os.MkdirAll(subdirPath, 0755); err != nil {
return fmt.Errorf("failed to create %s directory: %w", subdir, err)
}
}
// Initialize oplog file
oplogPath := filepath.Join(onyxPath, "oplog")
if _, err := os.Stat(oplogPath); os.IsNotExist(err) {
if err := os.WriteFile(oplogPath, []byte{}, 0644); err != nil {
return fmt.Errorf("failed to create oplog file: %w", err)
}
}
// Initialize workstreams.json
workstreamsPath := filepath.Join(onyxPath, "workstreams.json")
if _, err := os.Stat(workstreamsPath); os.IsNotExist(err) {
initialContent := []byte("{\"workstreams\":{}}\n")
if err := os.WriteFile(workstreamsPath, initialContent, 0644); err != nil {
return fmt.Errorf("failed to create workstreams.json: %w", err)
}
}
// Open the repository
gitRepo, err := gogit.PlainOpen(absPath)
if err != nil {
return fmt.Errorf("failed to open git repository: %w", err)
}
// Set up the repository instance
r.gitRepo = gitRepo
r.onyxPath = onyxPath
r.gitPath = gitPath
r.metadata = &OnyxMetadata{
Version: "1.0.0",
Created: time.Now(),
OnyxPath: onyxPath,
}
return nil
}
// GetGitRepo returns the underlying Git repository
func (r *OnyxRepository) GetGitRepo() *gogit.Repository {
return r.gitRepo
}
// GetOnyxMetadata returns Onyx-specific metadata
func (r *OnyxRepository) GetOnyxMetadata() *OnyxMetadata {
return r.metadata
}
// Close releases any resources held by the repository
func (r *OnyxRepository) Close() error {
// Currently, go-git doesn't require explicit closing
// This method is here for future-proofing
return nil
}
// IsOnyxRepo checks if the given path is an Onyx repository
func IsOnyxRepo(path string) bool {
absPath, err := filepath.Abs(path)
if err != nil {
return false
}
// Check for both .git and .onx directories
gitPath := filepath.Join(absPath, ".git")
onyxPath := filepath.Join(absPath, ".onx")
_, gitErr := os.Stat(gitPath)
_, onyxErr := os.Stat(onyxPath)
return gitErr == nil && onyxErr == nil
}
// GetOnyxPath returns the path to the .onx directory
func (r *OnyxRepository) GetOnyxPath() string {
return r.onyxPath
}
// GetGitPath returns the path to the .git directory
func (r *OnyxRepository) GetGitPath() string {
return r.gitPath
}

186
internal/core/transaction.go Normal file
View File

@ -0,0 +1,186 @@
package core
import (
"fmt"
"path/filepath"
"git.dws.rip/DWS/onyx/internal/models"
"git.dws.rip/DWS/onyx/internal/storage"
)
// Transaction represents a transactional operation with oplog support
type Transaction struct {
repo *OnyxRepository
oplogWriter *storage.OplogWriter
stateCapture *storage.StateCapture
}
// NewTransaction creates a new transaction for the given repository
func NewTransaction(repo *OnyxRepository) (*Transaction, error) {
oplogPath := filepath.Join(repo.GetOnyxPath(), "oplog")
oplogWriter, err := storage.OpenOplog(oplogPath)
if err != nil {
return nil, fmt.Errorf("failed to open oplog: %w", err)
}
stateCapture := storage.NewStateCapture(repo.GetGitRepo())
return &Transaction{
repo: repo,
oplogWriter: oplogWriter,
stateCapture: stateCapture,
}, nil
}
// ExecuteWithTransaction executes a function within a transaction context
// It captures the state before and after the operation and logs it to the oplog
func (t *Transaction) ExecuteWithTransaction(operation, description string, fn func() error) error {
// 1. Capture state_before
stateBefore, err := t.stateCapture.CaptureState()
if err != nil {
return fmt.Errorf("failed to capture state before: %w", err)
}
// 2. Execute the function
err = fn()
if err != nil {
// On error, we don't log to oplog since the operation failed
return fmt.Errorf("operation failed: %w", err)
}
// 3. Capture state_after
stateAfter, err := t.stateCapture.CaptureState()
if err != nil {
// Even if we can't capture the after state, we should try to log what we can
// This is a warning situation rather than a failure
fmt.Printf("Warning: failed to capture state after: %v\n", err)
stateAfter = stateBefore // Use the before state as a fallback
}
// 4. Create oplog entry
entry := models.NewOplogEntry(0, operation, description, stateBefore, stateAfter)
// 5. Write to oplog
err = t.oplogWriter.AppendEntry(entry)
if err != nil {
return fmt.Errorf("failed to write to oplog: %w", err)
}
return nil
}
// Close closes the transaction and releases resources
func (t *Transaction) Close() error {
return t.oplogWriter.Close()
}
// ExecuteWithTransactionAndMetadata executes a function with custom metadata
func (t *Transaction) ExecuteWithTransactionAndMetadata(
operation, description string,
metadata map[string]string,
fn func() error,
) error {
// Capture state_before
stateBefore, err := t.stateCapture.CaptureState()
if err != nil {
return fmt.Errorf("failed to capture state before: %w", err)
}
// Execute the function
err = fn()
if err != nil {
return fmt.Errorf("operation failed: %w", err)
}
// Capture state_after
stateAfter, err := t.stateCapture.CaptureState()
if err != nil {
fmt.Printf("Warning: failed to capture state after: %v\n", err)
stateAfter = stateBefore
}
// Create oplog entry with metadata
entry := models.NewOplogEntry(0, operation, description, stateBefore, stateAfter)
entry.Metadata = metadata
// Write to oplog
err = t.oplogWriter.AppendEntry(entry)
if err != nil {
return fmt.Errorf("failed to write to oplog: %w", err)
}
return nil
}
// Rollback attempts to rollback to a previous state
func (t *Transaction) Rollback(entryID uint64) error {
// Read the oplog entry
oplogPath := filepath.Join(t.repo.GetOnyxPath(), "oplog")
reader := storage.NewOplogReader(oplogPath)
entry, err := reader.ReadEntry(entryID)
if err != nil {
return fmt.Errorf("failed to read entry %d: %w", entryID, err)
}
// Restore the state_before from that entry
if entry.StateBefore == nil {
return fmt.Errorf("entry %d has no state_before to restore", entryID)
}
err = t.stateCapture.RestoreState(entry.StateBefore)
if err != nil {
return fmt.Errorf("failed to restore state: %w", err)
}
// Log the rollback operation
stateAfter, _ := t.stateCapture.CaptureState()
rollbackEntry := models.NewOplogEntry(
0,
"rollback",
fmt.Sprintf("Rolled back to entry %d", entryID),
stateAfter, // The current state becomes the "before"
entry.StateBefore, // The restored state becomes the "after"
)
rollbackEntry.Metadata = map[string]string{
"rollback_to_entry_id": fmt.Sprintf("%d", entryID),
}
err = t.oplogWriter.AppendEntry(rollbackEntry)
if err != nil {
// Don't fail the rollback if we can't log it
fmt.Printf("Warning: failed to log rollback: %v\n", err)
}
return nil
}
// Commit captures the final state and writes to oplog
func (t *Transaction) Commit(operation, description string) error {
// Capture state_after
stateAfter, err := t.stateCapture.CaptureState()
if err != nil {
return fmt.Errorf("failed to capture state: %w", err)
}
// Create oplog entry
entry := models.NewOplogEntry(0, operation, description, nil, stateAfter)
// Write to oplog
if err := t.oplogWriter.AppendEntry(entry); err != nil {
return fmt.Errorf("failed to write to oplog: %w", err)
}
return t.Close()
}
// Helper function to execute a transaction on a repository
func ExecuteWithTransaction(repo *OnyxRepository, operation, description string, fn func() error) error {
txn, err := NewTransaction(repo)
if err != nil {
return err
}
defer txn.Close()
return txn.ExecuteWithTransaction(operation, description, fn)
}

389
internal/core/workstream_manager.go Normal file
View File

@ -0,0 +1,389 @@
package core
import (
"fmt"
"path/filepath"
"regexp"
"strings"
"git.dws.rip/DWS/onyx/internal/git"
"git.dws.rip/DWS/onyx/internal/models"
"git.dws.rip/DWS/onyx/internal/storage"
gogit "github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing"
)
// WorkstreamManager manages workstream operations
type WorkstreamManager struct {
repo *OnyxRepository
gitBackend *git.GitBackend
workstreamsPath string
}
// NewWorkstreamManager creates a new workstream manager
func NewWorkstreamManager(repo *OnyxRepository) *WorkstreamManager {
return &WorkstreamManager{
repo: repo,
gitBackend: git.NewGitBackend(repo.GetGitRepo()),
workstreamsPath: filepath.Join(repo.GetOnyxPath(), "workstreams.json"),
}
}
// ValidateWorkstreamName validates a workstream name
func ValidateWorkstreamName(name string) error {
if name == "" {
return fmt.Errorf("workstream name cannot be empty")
}
// Only allow alphanumeric characters, hyphens, underscores, and slashes
validName := regexp.MustCompile(`^[a-zA-Z0-9_/-]+$`)
if !validName.MatchString(name) {
return fmt.Errorf("workstream name '%s' contains invalid characters. Only alphanumeric, hyphens, underscores, and slashes are allowed", name)
}
// Prevent names that could cause issues
reserved := []string{"HEAD", ".", ".."}
for _, r := range reserved {
if strings.EqualFold(name, r) {
return fmt.Errorf("workstream name '%s' is reserved", name)
}
}
return nil
}
// CreateWorkstream creates a new workstream
func (wm *WorkstreamManager) CreateWorkstream(name, baseBranch string) error {
// Validate the name
if err := ValidateWorkstreamName(name); err != nil {
return err
}
// Load existing workstreams
collection, err := storage.LoadWorkstreams(wm.workstreamsPath)
if err != nil {
return fmt.Errorf("failed to load workstreams: %w", err)
}
// Check if workstream already exists
if _, exists := collection.Workstreams[name]; exists {
return fmt.Errorf("workstream '%s' already exists", name)
}
// Default to main if no base branch specified
if baseBranch == "" {
baseBranch = "main"
}
// Try to fetch latest from remote base branch
// We'll attempt this but won't fail if it doesn't work (might be a local-only repo)
remoteBranch := fmt.Sprintf("origin/%s", baseBranch)
_ = wm.fetchRemoteBranch(remoteBranch)
// Get the base commit SHA
baseCommitSHA, err := wm.getBaseBranchHead(baseBranch)
if err != nil {
return fmt.Errorf("failed to get base branch HEAD: %w", err)
}
// Create the workstream
workstream := models.NewWorkstream(name, "", baseBranch)
// Add the base commit SHA to metadata for reference
workstream.Metadata["base_commit"] = baseCommitSHA
// Add to collection
if err := collection.AddWorkstream(workstream); err != nil {
return fmt.Errorf("failed to add workstream: %w", err)
}
// Set as current workstream
collection.CurrentWorkstream = name
// Save the collection
if err := storage.SaveWorkstreams(wm.workstreamsPath, collection); err != nil {
return fmt.Errorf("failed to save workstreams: %w", err)
}
// Update workspace to point to base commit (only if we have a valid base commit)
if baseCommitSHA != "" {
workspaceRef := "refs/onyx/workspaces/current"
if err := wm.gitBackend.UpdateRef(workspaceRef, baseCommitSHA); err != nil {
// This is non-fatal - the daemon will create a new ephemeral commit
// We'll just log a warning
fmt.Printf("Warning: failed to update workspace ref: %v\n", err)
}
}
return nil
}
// GetCurrentWorkstream returns the current active workstream
func (wm *WorkstreamManager) GetCurrentWorkstream() (*models.Workstream, error) {
collection, err := storage.LoadWorkstreams(wm.workstreamsPath)
if err != nil {
return nil, fmt.Errorf("failed to load workstreams: %w", err)
}
return collection.GetCurrentWorkstream()
}
// SwitchWorkstream switches to a different workstream
func (wm *WorkstreamManager) SwitchWorkstream(name string) error {
// Load workstreams
collection, err := storage.LoadWorkstreams(wm.workstreamsPath)
if err != nil {
return fmt.Errorf("failed to load workstreams: %w", err)
}
// Check if target workstream exists
targetWorkstream, err := collection.GetWorkstream(name)
if err != nil {
return fmt.Errorf("workstream '%s' not found", name)
}
// Get the commit to checkout
var checkoutSHA string
if !targetWorkstream.IsEmpty() {
// Checkout the latest commit in the workstream
latestCommit, err := targetWorkstream.GetLatestCommit()
if err != nil {
return fmt.Errorf("failed to get latest commit: %w", err)
}
checkoutSHA = latestCommit.SHA
} else {
// Checkout the base commit
baseCommitSHA := targetWorkstream.Metadata["base_commit"]
if baseCommitSHA == "" {
// Fallback to getting the base branch HEAD
baseCommitSHA, err = wm.getBaseBranchHead(targetWorkstream.BaseBranch)
if err != nil {
return fmt.Errorf("failed to get base branch HEAD: %w", err)
}
}
checkoutSHA = baseCommitSHA
}
// Update the working directory to the target commit
worktree, err := wm.repo.GetGitRepo().Worktree()
if err != nil {
return fmt.Errorf("failed to get worktree: %w", err)
}
// Checkout the commit
err = worktree.Checkout(&gogit.CheckoutOptions{
Hash: plumbing.NewHash(checkoutSHA),
Force: true,
})
if err != nil {
return fmt.Errorf("failed to checkout commit: %w", err)
}
// Update current workstream
if err := collection.SetCurrentWorkstream(name); err != nil {
return fmt.Errorf("failed to set current workstream: %w", err)
}
// Save the collection
if err := storage.SaveWorkstreams(wm.workstreamsPath, collection); err != nil {
return fmt.Errorf("failed to save workstreams: %w", err)
}
// Update workspace ref to point to the checked out commit (only if we have a valid commit)
if checkoutSHA != "" {
workspaceRef := "refs/onyx/workspaces/current"
if err := wm.gitBackend.UpdateRef(workspaceRef, checkoutSHA); err != nil {
fmt.Printf("Warning: failed to update workspace ref: %v\n", err)
}
}
return nil
}
// ListWorkstreams returns all workstreams
func (wm *WorkstreamManager) ListWorkstreams() ([]*models.Workstream, error) {
collection, err := storage.LoadWorkstreams(wm.workstreamsPath)
if err != nil {
return nil, fmt.Errorf("failed to load workstreams: %w", err)
}
return collection.ListWorkstreams(), nil
}
// GetCurrentWorkstreamName returns the name of the current workstream
func (wm *WorkstreamManager) GetCurrentWorkstreamName() (string, error) {
collection, err := storage.LoadWorkstreams(wm.workstreamsPath)
if err != nil {
return "", fmt.Errorf("failed to load workstreams: %w", err)
}
if collection.CurrentWorkstream == "" {
return "", fmt.Errorf("no current workstream set")
}
return collection.CurrentWorkstream, nil
}
// AddCommitToWorkstream adds a commit to the current workstream
func (wm *WorkstreamManager) AddCommitToWorkstream(sha, message string) error {
// Load workstreams
collection, err := storage.LoadWorkstreams(wm.workstreamsPath)
if err != nil {
return fmt.Errorf("failed to load workstreams: %w", err)
}
// Get current workstream
currentWorkstream, err := collection.GetCurrentWorkstream()
if err != nil {
return fmt.Errorf("no active workstream: %w", err)
}
// Determine parent SHA
var parentSHA string
if !currentWorkstream.IsEmpty() {
latestCommit, err := currentWorkstream.GetLatestCommit()
if err != nil {
return fmt.Errorf("failed to get latest commit: %w", err)
}
parentSHA = latestCommit.SHA
} else {
// For the first commit, use the base commit
baseCommitSHA := currentWorkstream.Metadata["base_commit"]
if baseCommitSHA == "" {
baseCommitSHA, err = wm.getBaseBranchHead(currentWorkstream.BaseBranch)
if err != nil {
return fmt.Errorf("failed to get base branch HEAD: %w", err)
}
}
parentSHA = baseCommitSHA
}
// Get the base commit SHA
baseSHA := currentWorkstream.Metadata["base_commit"]
if baseSHA == "" {
baseSHA, err = wm.getBaseBranchHead(currentWorkstream.BaseBranch)
if err != nil {
return fmt.Errorf("failed to get base branch HEAD: %w", err)
}
}
// Determine the branch ref
nextNumber := currentWorkstream.GetCommitCount() + 1
branchRef := fmt.Sprintf("refs/onyx/workstreams/%s/commit-%d", currentWorkstream.Name, nextNumber)
// Create the workstream commit
workstreamCommit := models.NewWorkstreamCommit(
sha,
message,
"User", // TODO: Get actual user from git config
parentSHA,
baseSHA,
branchRef,
)
// Add commit to workstream
currentWorkstream.AddCommit(workstreamCommit)
// Update the branch ref to point to this commit
if err := wm.gitBackend.UpdateRef(branchRef, sha); err != nil {
return fmt.Errorf("failed to create branch ref: %w", err)
}
// Save the collection
if err := storage.SaveWorkstreams(wm.workstreamsPath, collection); err != nil {
return fmt.Errorf("failed to save workstreams: %w", err)
}
return nil
}
// fetchRemoteBranch attempts to fetch the latest from a remote branch
func (wm *WorkstreamManager) fetchRemoteBranch(remoteBranch string) error {
// This is a best-effort operation
// We use the underlying git command for now
// In the future, we could use go-git's fetch capabilities
// For now, we'll just return nil as this is optional
// The real implementation would use go-git's Fetch method
return nil
}
// getBaseBranchHead gets the HEAD commit SHA of a base branch
func (wm *WorkstreamManager) getBaseBranchHead(baseBranch string) (string, error) {
// Try local branch first
refName := fmt.Sprintf("refs/heads/%s", baseBranch)
sha, err := wm.gitBackend.GetRef(refName)
if err == nil {
return sha, nil
}
// Try remote branch
remoteRefName := fmt.Sprintf("refs/remotes/origin/%s", baseBranch)
sha, err = wm.gitBackend.GetRef(remoteRefName)
if err == nil {
return sha, nil
}
// If we still can't find it, try HEAD
head, err := wm.repo.GetGitRepo().Head()
if err != nil {
// Empty repository with no commits - return empty string
// This is a valid state for a brand new repository
return "", nil
}
return head.Hash().String(), nil
}
// getCurrentBranchName gets the name of the current Git branch
func (wm *WorkstreamManager) getCurrentBranchName() (string, error) {
// Try to get HEAD reference
head, err := wm.repo.GetGitRepo().Head()
if err != nil {
// No HEAD yet (empty repo) - check the symbolic ref manually
ref, err := wm.repo.GetGitRepo().Reference(plumbing.HEAD, false)
if err != nil {
// Can't determine - default to "main"
return "main", nil
}
// Extract branch name from refs/heads/branch-name
if ref.Target().IsBranch() {
return ref.Target().Short(), nil
}
return "main", nil
}
// Check if we're on a branch (not detached HEAD)
if !head.Name().IsBranch() {
// Detached HEAD - default to "main"
return "main", nil
}
// Extract branch name from refs/heads/branch-name
branchName := head.Name().Short()
return branchName, nil
}
// CreateDefaultWorkstream creates a workstream matching the current Git branch
func (wm *WorkstreamManager) CreateDefaultWorkstream() error {
// Get the current Git branch name
branchName, err := wm.getCurrentBranchName()
if err != nil {
return fmt.Errorf("failed to get current branch: %w", err)
}
// Load existing workstreams to check if one already exists
collection, err := storage.LoadWorkstreams(wm.workstreamsPath)
if err != nil {
return fmt.Errorf("failed to load workstreams: %w", err)
}
// If a workstream already exists, don't create another one
if len(collection.Workstreams) > 0 {
return nil
}
// Create workstream with the same name as the branch
// This workstream tracks the branch it's named after
return wm.CreateWorkstream(branchName, branchName)
}

190
internal/daemon/daemon.go Normal file
View File

@ -0,0 +1,190 @@
package daemon
import (
"fmt"
"log"
"sync"
"time"
"git.dws.rip/DWS/onyx/internal/core"
"github.com/fsnotify/fsnotify"
)
// Daemon manages the filesystem watching and automatic snapshot creation
type Daemon struct {
repo *core.OnyxRepository
watcher *fsnotify.Watcher
ticker *time.Ticker
debounce time.Duration
shutdown chan bool
mu sync.Mutex
isRunning bool
// Debouncing state
pendingChanges bool
lastChangeTime time.Time
}
// Config holds daemon configuration options
type Config struct {
// Debounce duration for filesystem events (default: 500ms)
Debounce time.Duration
// Ticker interval for periodic checks (default: 1 second)
TickerInterval time.Duration
// Repository root path
RepoPath string
}
// DefaultConfig returns the default daemon configuration
func DefaultConfig() *Config {
return &Config{
Debounce: 500 * time.Millisecond,
TickerInterval: 1 * time.Second,
}
}
// New creates a new Daemon instance
func New(repo *core.OnyxRepository, config *Config) (*Daemon, error) {
if config == nil {
config = DefaultConfig()
}
watcher, err := fsnotify.NewWatcher()
if err != nil {
return nil, fmt.Errorf("failed to create filesystem watcher: %w", err)
}
return &Daemon{
repo: repo,
watcher: watcher,
ticker: time.NewTicker(config.TickerInterval),
debounce: config.Debounce,
shutdown: make(chan bool),
isRunning: false,
pendingChanges: false,
}, nil
}
// Start begins the daemon's main loop
func (d *Daemon) Start() error {
d.mu.Lock()
if d.isRunning {
d.mu.Unlock()
return fmt.Errorf("daemon is already running")
}
d.isRunning = true
d.mu.Unlock()
// Set up filesystem watchers
if err := d.setupWatchers(); err != nil {
d.isRunning = false
return fmt.Errorf("failed to setup watchers: %w", err)
}
log.Println("Onyx daemon started")
// Run the main event loop
go d.run()
return nil
}
// Stop gracefully shuts down the daemon
func (d *Daemon) Stop() error {
d.mu.Lock()
if !d.isRunning {
d.mu.Unlock()
return fmt.Errorf("daemon is not running")
}
d.mu.Unlock()
log.Println("Stopping Onyx daemon...")
// Signal shutdown
close(d.shutdown)
// Clean up resources
d.ticker.Stop()
if err := d.watcher.Close(); err != nil {
return fmt.Errorf("failed to close watcher: %w", err)
}
d.mu.Lock()
d.isRunning = false
d.mu.Unlock()
log.Println("Onyx daemon stopped")
return nil
}
// IsRunning returns whether the daemon is currently running
func (d *Daemon) IsRunning() bool {
d.mu.Lock()
defer d.mu.Unlock()
return d.isRunning
}
// run is the main event loop for the daemon
func (d *Daemon) run() {
for {
select {
case <-d.shutdown:
return
case event, ok := <-d.watcher.Events:
if !ok {
return
}
d.handleFileEvent(event)
case err, ok := <-d.watcher.Errors:
if !ok {
return
}
log.Printf("Watcher error: %v", err)
case <-d.ticker.C:
d.processDebounced()
}
}
}
// handleFileEvent processes a filesystem event
func (d *Daemon) handleFileEvent(event fsnotify.Event) {
// Ignore events for .git and .onx directories
if shouldIgnorePath(event.Name) {
return
}
// Mark that we have pending changes
d.mu.Lock()
d.pendingChanges = true
d.lastChangeTime = time.Now()
d.mu.Unlock()
log.Printf("File change detected: %s [%s]", event.Name, event.Op)
}
// processDebounced checks if enough time has passed since the last change
// and creates a snapshot if needed
func (d *Daemon) processDebounced() {
d.mu.Lock()
hasPending := d.pendingChanges
timeSinceChange := time.Since(d.lastChangeTime)
d.mu.Unlock()
if hasPending && timeSinceChange >= d.debounce {
d.mu.Lock()
d.pendingChanges = false
d.mu.Unlock()
log.Println("Creating automatic snapshot...")
if err := d.CreateSnapshot(); err != nil {
log.Printf("Failed to create snapshot: %v", err)
} else {
log.Println("Snapshot created successfully")
}
}
}

211
internal/daemon/snapshot.go Normal file
View File

@ -0,0 +1,211 @@
package daemon
import (
"fmt"
"os"
"path/filepath"
"time"
"git.dws.rip/DWS/onyx/internal/git"
"git.dws.rip/DWS/onyx/internal/models"
gogit "github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing/filemode"
)
const (
// OnyxWorkspaceRef is the ref where ephemeral commits are stored
OnyxWorkspaceRef = "refs/onyx/workspaces/current"
)
// CreateSnapshot creates an ephemeral commit representing the current workspace state
func (d *Daemon) CreateSnapshot() error {
// 1. Read current workspace pointer
workspaceState, err := d.readWorkspaceState()
if err != nil {
// If workspace doesn't exist, create a new one
workspaceState = models.NewWorkspaceState("", "main")
}
// 2. Create tree from working directory
gitBackend := git.NewGitBackend(d.repo.GetGitRepo())
repoRoot := filepath.Dir(d.repo.GetOnyxPath())
treeHash, err := d.createWorkspaceTree(repoRoot)
if err != nil {
return fmt.Errorf("failed to create workspace tree: %w", err)
}
// 3. Get the parent commit (if it exists)
var parentHash string
if workspaceState.CurrentCommitSHA != "" {
parentHash = workspaceState.CurrentCommitSHA
} else {
// Try to get the current HEAD commit as parent
head, err := d.repo.GetGitRepo().Head()
if err == nil {
parentHash = head.Hash().String()
}
}
// 4. Create ephemeral commit
message := fmt.Sprintf("[onyx-snapshot] Auto-save at %s", time.Now().Format("2006-01-02 15:04:05"))
commitHash, err := gitBackend.CreateCommit(treeHash, parentHash, message, "Onyx Daemon")
if err != nil {
return fmt.Errorf("failed to create commit: %w", err)
}
// 5. Update refs/onyx/workspaces/current
if err := gitBackend.UpdateRef(OnyxWorkspaceRef, commitHash); err != nil {
return fmt.Errorf("failed to update workspace ref: %w", err)
}
// 6. Update .onx/workspace pointer
workspaceState.UpdateSnapshot(commitHash, treeHash, "", false)
if err := d.saveWorkspaceState(workspaceState); err != nil {
return fmt.Errorf("failed to save workspace state: %w", err)
}
return nil
}
// createWorkspaceTree creates a Git tree object from the current working directory
func (d *Daemon) createWorkspaceTree(rootPath string) (string, error) {
gitBackend := git.NewGitBackend(d.repo.GetGitRepo())
// Use the worktree to build the tree
worktree, err := d.repo.GetGitRepo().Worktree()
if err != nil {
return "", fmt.Errorf("failed to get worktree: %w", err)
}
// Create tree entries by walking the working directory
entries := []git.TreeEntry{}
err = filepath.Walk(rootPath, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
// Skip the root directory itself
if path == rootPath {
return nil
}
// Get relative path
relPath, err := filepath.Rel(rootPath, path)
if err != nil {
return err
}
// Skip .git and .onx directories
if shouldIgnorePath(path) {
if info.IsDir() {
return filepath.SkipDir
}
return nil
}
// For now, we'll use a simplified approach: hash the file content
if !info.IsDir() {
content, err := os.ReadFile(path)
if err != nil {
return fmt.Errorf("failed to read file %s: %w", path, err)
}
// Create blob for file content
blobHash, err := gitBackend.CreateBlob(content)
if err != nil {
return fmt.Errorf("failed to create blob for %s: %w", path, err)
}
// Determine file mode
mode := filemode.Regular
if info.Mode()&0111 != 0 {
mode = filemode.Executable
}
entries = append(entries, git.TreeEntry{
Name: relPath,
Mode: mode,
Hash: git.HashFromString(blobHash),
})
}
return nil
})
if err != nil {
return "", fmt.Errorf("failed to walk directory: %w", err)
}
// For a proper implementation, we'd need to build a hierarchical tree
// For now, we'll use the worktree's tree builder
return d.buildTreeFromWorktree(worktree)
}
// buildTreeFromWorktree builds a tree object from the current worktree state
func (d *Daemon) buildTreeFromWorktree(worktree *gogit.Worktree) (string, error) {
// Get the current index/staging area state
// This is a simplified version - in production we'd want to properly handle
// all files in the working directory
// For now, get the HEAD tree as a base
head, err := d.repo.GetGitRepo().Head()
if err != nil {
// No HEAD yet (empty repo), return empty tree
return d.createEmptyTree()
}
commit, err := d.repo.GetGitRepo().CommitObject(head.Hash())
if err != nil {
return "", fmt.Errorf("failed to get HEAD commit: %w", err)
}
tree, err := commit.Tree()
if err != nil {
return "", fmt.Errorf("failed to get commit tree: %w", err)
}
// For now, just return the HEAD tree hash
// In a full implementation, we'd modify this tree based on working directory changes
return tree.Hash.String(), nil
}
// createEmptyTree creates an empty Git tree object
func (d *Daemon) createEmptyTree() (string, error) {
gitBackend := git.NewGitBackend(d.repo.GetGitRepo())
return gitBackend.CreateTree([]git.TreeEntry{})
}
// readWorkspaceState reads the workspace state from .onx/workspace
func (d *Daemon) readWorkspaceState() (*models.WorkspaceState, error) {
workspacePath := filepath.Join(d.repo.GetOnyxPath(), "workspace")
data, err := os.ReadFile(workspacePath)
if err != nil {
return nil, fmt.Errorf("failed to read workspace file: %w", err)
}
state, err := models.DeserializeWorkspaceState(data)
if err != nil {
return nil, fmt.Errorf("failed to deserialize workspace state: %w", err)
}
return state, nil
}
// saveWorkspaceState saves the workspace state to .onx/workspace
func (d *Daemon) saveWorkspaceState(state *models.WorkspaceState) error {
workspacePath := filepath.Join(d.repo.GetOnyxPath(), "workspace")
data, err := state.Serialize()
if err != nil {
return fmt.Errorf("failed to serialize workspace state: %w", err)
}
if err := os.WriteFile(workspacePath, data, 0644); err != nil {
return fmt.Errorf("failed to write workspace file: %w", err)
}
return nil
}

112
internal/daemon/watcher.go Normal file
View File

@ -0,0 +1,112 @@
package daemon
import (
"fmt"
"log"
"os"
"path/filepath"
"strings"
)
// setupWatchers initializes the filesystem watcher for the repository
func (d *Daemon) setupWatchers() error {
// Get the repository root
repoRoot := filepath.Dir(d.repo.GetOnyxPath())
// Add the root directory to the watcher
if err := d.addWatchRecursive(repoRoot); err != nil {
return fmt.Errorf("failed to add watches: %w", err)
}
log.Printf("Watching repository at: %s", repoRoot)
return nil
}
// addWatchRecursive adds watches for a directory and all its subdirectories
func (d *Daemon) addWatchRecursive(path string) error {
// Walk the directory tree
return filepath.Walk(path, func(walkPath string, info os.FileInfo, err error) error {
if err != nil {
// Skip directories we can't access
log.Printf("Warning: cannot access %s: %v", walkPath, err)
return nil
}
// Skip files, only watch directories
if !info.IsDir() {
return nil
}
// Skip .git and .onx directories
if shouldIgnorePath(walkPath) {
return filepath.SkipDir
}
// Add watch for this directory
if err := d.watcher.Add(walkPath); err != nil {
log.Printf("Warning: cannot watch %s: %v", walkPath, err)
return nil
}
return nil
})
}
// shouldIgnorePath determines if a path should be ignored by the watcher
func shouldIgnorePath(path string) bool {
// Get the base name and check against ignored patterns
base := filepath.Base(path)
// Ignore .git and .onx directories
if base == ".git" || base == ".onx" {
return true
}
// Ignore hidden directories starting with .
if strings.HasPrefix(base, ".") && base != "." {
return true
}
// Ignore common build/dependency directories
ignoredDirs := []string{
"node_modules",
"vendor",
"target",
"build",
"dist",
".vscode",
".idea",
"__pycache__",
".pytest_cache",
".mypy_cache",
}
for _, ignored := range ignoredDirs {
if base == ignored {
return true
}
}
// Ignore temporary and backup files
if strings.HasSuffix(path, "~") ||
strings.HasSuffix(path, ".swp") ||
strings.HasSuffix(path, ".tmp") {
return true
}
return false
}
// AddWatch adds a new directory to the watch list (useful for newly created directories)
func (d *Daemon) AddWatch(path string) error {
if shouldIgnorePath(path) {
return nil
}
return d.watcher.Add(path)
}
// RemoveWatch removes a directory from the watch list
func (d *Daemon) RemoveWatch(path string) error {
return d.watcher.Remove(path)
}

190
internal/git/auth.go Normal file
View File

@ -0,0 +1,190 @@
package git
import (
"fmt"
"os"
"os/exec"
"path/filepath"
"strings"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/http"
"github.com/go-git/go-git/v5/plumbing/transport/ssh"
)
// AuthProvider handles authentication for Git operations
type AuthProvider struct {
cache map[string]transport.AuthMethod
}
// NewAuthProvider creates a new AuthProvider
func NewAuthProvider() *AuthProvider {
return &AuthProvider{
cache: make(map[string]transport.AuthMethod),
}
}
// GetAuthMethod returns the appropriate authentication method for a URL
func (ap *AuthProvider) GetAuthMethod(url string) (transport.AuthMethod, error) {
// Check cache first
if auth, ok := ap.cache[url]; ok {
return auth, nil
}
var auth transport.AuthMethod
var err error
// Detect transport type from URL
if strings.HasPrefix(url, "git@") || strings.HasPrefix(url, "ssh://") {
// SSH authentication
auth, err = ap.getSSHAuth()
} else if strings.HasPrefix(url, "http://") || strings.HasPrefix(url, "https://") {
// HTTPS authentication
auth, err = ap.getHTTPSAuth(url)
} else {
return nil, fmt.Errorf("unsupported URL scheme: %s", url)
}
if err != nil {
return nil, err
}
// Cache the auth method
ap.cache[url] = auth
return auth, nil
}
// getSSHAuth attempts to get SSH authentication
func (ap *AuthProvider) getSSHAuth() (transport.AuthMethod, error) {
// Try SSH agent first
auth, err := ssh.NewSSHAgentAuth("git")
if err == nil {
return auth, nil
}
// Fallback to loading SSH keys from default locations
homeDir, err := os.UserHomeDir()
if err != nil {
return nil, fmt.Errorf("failed to get home directory: %w", err)
}
sshDir := filepath.Join(homeDir, ".ssh")
// Try common key files
keyFiles := []string{
"id_ed25519",
"id_rsa",
"id_ecdsa",
"id_dsa",
}
for _, keyFile := range keyFiles {
keyPath := filepath.Join(sshDir, keyFile)
if _, err := os.Stat(keyPath); err == nil {
// Try loading without passphrase first
auth, err := ssh.NewPublicKeysFromFile("git", keyPath, "")
if err == nil {
return auth, nil
}
// If that fails, it might need a passphrase
// For now, we'll skip passphrase-protected keys
// In the future, we could prompt for the passphrase
continue
}
}
return nil, fmt.Errorf("no SSH authentication method available (tried ssh-agent and ~/.ssh keys)")
}
// getHTTPSAuth attempts to get HTTPS authentication
func (ap *AuthProvider) getHTTPSAuth(url string) (transport.AuthMethod, error) {
// Try git credential helper first
auth, err := ap.tryGitCredentialHelper(url)
if err == nil && auth != nil {
return auth, nil
}
// Try environment variables
username := os.Getenv("GIT_USERNAME")
password := os.Getenv("GIT_PASSWORD")
token := os.Getenv("GIT_TOKEN")
if token != "" {
// Use token as password (common for GitHub, GitLab, etc.)
return &http.BasicAuth{
Username: "git", // Token usually goes in password field
Password: token,
}, nil
}
if username != "" && password != "" {
return &http.BasicAuth{
Username: username,
Password: password,
}, nil
}
// No credentials available - return nil to let go-git try anonymous
// (this will fail for private repos but that's expected)
return nil, fmt.Errorf("no HTTPS credentials available (tried git credential helper and environment variables)")
}
// tryGitCredentialHelper attempts to use git's credential helper
func (ap *AuthProvider) tryGitCredentialHelper(url string) (*http.BasicAuth, error) {
// Build the credential request
input := fmt.Sprintf("protocol=https\nhost=%s\n\n", extractHost(url))
// Call git credential fill
cmd := exec.Command("git", "credential", "fill")
cmd.Stdin = strings.NewReader(input)
output, err := cmd.Output()
if err != nil {
return nil, fmt.Errorf("git credential helper failed: %w", err)
}
// Parse the output
lines := strings.Split(string(output), "\n")
auth := &http.BasicAuth{}
for _, line := range lines {
parts := strings.SplitN(line, "=", 2)
if len(parts) != 2 {
continue
}
key := strings.TrimSpace(parts[0])
value := strings.TrimSpace(parts[1])
switch key {
case "username":
auth.Username = value
case "password":
auth.Password = value
}
}
if auth.Username == "" || auth.Password == "" {
return nil, fmt.Errorf("git credential helper did not return username and password")
}
return auth, nil
}
// extractHost extracts the host from a URL
func extractHost(url string) string {
// Remove protocol
url = strings.TrimPrefix(url, "https://")
url = strings.TrimPrefix(url, "http://")
// Extract host (everything before the first /)
parts := strings.SplitN(url, "/", 2)
return parts[0]
}
// ClearCache clears the authentication cache
func (ap *AuthProvider) ClearCache() {
ap.cache = make(map[string]transport.AuthMethod)
}

187
internal/git/conflicts.go Normal file
View File

@ -0,0 +1,187 @@
package git
import (
"bufio"
"fmt"
"os"
"path/filepath"
"strings"
gogit "github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing/format/index"
)
// ConflictInfo represents information about a merge conflict
type ConflictInfo struct {
FilePath string
OursHash string
TheirsHash string
BaseHash string
HasConflict bool
}
// ConflictResolver handles conflict detection and resolution guidance
type ConflictResolver struct {
repo *gogit.Repository
repoPath string
}
// NewConflictResolver creates a new ConflictResolver instance
func NewConflictResolver(repo *gogit.Repository, repoPath string) *ConflictResolver {
return &ConflictResolver{
repo: repo,
repoPath: repoPath,
}
}
// DetectConflicts checks for merge conflicts in the working tree
func (cr *ConflictResolver) DetectConflicts() ([]ConflictInfo, error) {
idx, err := cr.repo.Storer.Index()
if err != nil {
return nil, fmt.Errorf("failed to read index: %w", err)
}
conflicts := []ConflictInfo{}
// Check for conflicts in the index
for _, entry := range idx.Entries {
// Stage > 0 indicates a conflict
if entry.Stage != 0 {
// Find all stages for this file
conflict := cr.findConflictStages(idx, entry.Name)
if conflict.HasConflict {
conflicts = append(conflicts, conflict)
}
}
}
return conflicts, nil
}
// findConflictStages finds all conflict stages for a file
func (cr *ConflictResolver) findConflictStages(idx *index.Index, path string) ConflictInfo {
conflict := ConflictInfo{
FilePath: path,
HasConflict: false,
}
for _, entry := range idx.Entries {
if entry.Name == path {
switch entry.Stage {
case 1:
// Base/common ancestor
conflict.BaseHash = entry.Hash.String()
conflict.HasConflict = true
case 2:
// Ours (current branch)
conflict.OursHash = entry.Hash.String()
conflict.HasConflict = true
case 3:
// Theirs (incoming branch)
conflict.TheirsHash = entry.Hash.String()
conflict.HasConflict = true
}
}
}
return conflict
}
// HasConflicts checks if there are any conflicts in the working tree
func (cr *ConflictResolver) HasConflicts() (bool, error) {
conflicts, err := cr.DetectConflicts()
if err != nil {
return false, err
}
return len(conflicts) > 0, nil
}
// PresentConflicts presents conflicts to the user with clear guidance
func (cr *ConflictResolver) PresentConflicts(conflicts []ConflictInfo) string {
if len(conflicts) == 0 {
return "No conflicts detected."
}
var sb strings.Builder
sb.WriteString(fmt.Sprintf("\n%s\n", strings.Repeat("=", 70)))
sb.WriteString(fmt.Sprintf(" MERGE CONFLICTS DETECTED (%d file(s))\n", len(conflicts)))
sb.WriteString(fmt.Sprintf("%s\n\n", strings.Repeat("=", 70)))
for i, conflict := range conflicts {
sb.WriteString(fmt.Sprintf("%d. %s\n", i+1, conflict.FilePath))
sb.WriteString(fmt.Sprintf(" Base: %s\n", conflict.BaseHash[:8]))
sb.WriteString(fmt.Sprintf(" Ours: %s\n", conflict.OursHash[:8]))
sb.WriteString(fmt.Sprintf(" Theirs: %s\n", conflict.TheirsHash[:8]))
sb.WriteString("\n")
}
sb.WriteString("To resolve conflicts:\n")
sb.WriteString(" 1. Edit the conflicting files to resolve conflicts\n")
sb.WriteString(" 2. Look for conflict markers: <<<<<<<, =======, >>>>>>>\n")
sb.WriteString(" 3. Remove the conflict markers after resolving\n")
sb.WriteString(" 4. Stage the resolved files: git add <file>\n")
sb.WriteString(" 5. Continue the rebase: git rebase --continue\n")
sb.WriteString(fmt.Sprintf("%s\n", strings.Repeat("=", 70)))
return sb.String()
}
// GetConflictMarkers reads a file and extracts conflict marker sections
func (cr *ConflictResolver) GetConflictMarkers(filePath string) ([]ConflictMarker, error) {
fullPath := filepath.Join(cr.repoPath, filePath)
file, err := os.Open(fullPath)
if err != nil {
return nil, fmt.Errorf("failed to open file: %w", err)
}
defer file.Close()
markers := []ConflictMarker{}
scanner := bufio.NewScanner(file)
lineNum := 0
var currentMarker *ConflictMarker
for scanner.Scan() {
lineNum++
line := scanner.Text()
if strings.HasPrefix(line, "<<<<<<<") {
// Start of conflict
currentMarker = &ConflictMarker{
FilePath: filePath,
StartLine: lineNum,
}
} else if strings.HasPrefix(line, "=======") && currentMarker != nil {
currentMarker.SeparatorLine = lineNum
} else if strings.HasPrefix(line, ">>>>>>>") && currentMarker != nil {
currentMarker.EndLine = lineNum
markers = append(markers, *currentMarker)
currentMarker = nil
}
}
if err := scanner.Err(); err != nil {
return nil, fmt.Errorf("error reading file: %w", err)
}
return markers, nil
}
// ConflictMarker represents a conflict marker section in a file
type ConflictMarker struct {
FilePath string
StartLine int
SeparatorLine int
EndLine int
}
// IsFileConflicted checks if a specific file has conflict markers
func (cr *ConflictResolver) IsFileConflicted(filePath string) (bool, error) {
markers, err := cr.GetConflictMarkers(filePath)
if err != nil {
return false, err
}
return len(markers) > 0, nil
}

210
internal/git/objects.go Normal file
View File

@ -0,0 +1,210 @@
package git
import (
"fmt"
"time"
gogit "github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/object"
)
// GitBackend implements low-level Git object operations
type GitBackend struct {
repo *gogit.Repository
}
// NewGitBackend creates a new GitBackend instance
func NewGitBackend(repo *gogit.Repository) *GitBackend {
return &GitBackend{repo: repo}
}
// CreateBlob creates a new blob object from the given content
func (gb *GitBackend) CreateBlob(content []byte) (string, error) {
store := gb.repo.Storer
// Create a blob object
blob := store.NewEncodedObject()
blob.SetType(plumbing.BlobObject)
blob.SetSize(int64(len(content)))
writer, err := blob.Writer()
if err != nil {
return "", fmt.Errorf("failed to get blob writer: %w", err)
}
_, err = writer.Write(content)
if err != nil {
writer.Close()
return "", fmt.Errorf("failed to write blob content: %w", err)
}
if err := writer.Close(); err != nil {
return "", fmt.Errorf("failed to close blob writer: %w", err)
}
// Store the blob
hash, err := store.SetEncodedObject(blob)
if err != nil {
return "", fmt.Errorf("failed to store blob: %w", err)
}
return hash.String(), nil
}
// TreeEntry represents an entry in a Git tree
type TreeEntry struct {
Mode filemode.FileMode
Name string
Hash plumbing.Hash
}
// CreateTree creates a new tree object from the given entries
func (gb *GitBackend) CreateTree(entries []TreeEntry) (string, error) {
store := gb.repo.Storer
// Create a new tree object
tree := &object.Tree{}
treeEntries := make([]object.TreeEntry, len(entries))
for i, entry := range entries {
treeEntries[i] = object.TreeEntry{
Name: entry.Name,
Mode: entry.Mode,
Hash: entry.Hash,
}
}
tree.Entries = treeEntries
// Encode and store the tree
obj := store.NewEncodedObject()
if err := tree.Encode(obj); err != nil {
return "", fmt.Errorf("failed to encode tree: %w", err)
}
hash, err := store.SetEncodedObject(obj)
if err != nil {
return "", fmt.Errorf("failed to store tree: %w", err)
}
return hash.String(), nil
}
// CreateCommit creates a new commit object
func (gb *GitBackend) CreateCommit(treeHash, parentHash, message, author string) (string, error) {
store := gb.repo.Storer
// Parse hashes
tree := plumbing.NewHash(treeHash)
var parents []plumbing.Hash
if parentHash != "" {
parents = []plumbing.Hash{plumbing.NewHash(parentHash)}
}
// Create commit object
commit := &object.Commit{
Author: object.Signature{
Name: author,
Email: "onyx@local",
When: time.Now(),
},
Committer: object.Signature{
Name: author,
Email: "onyx@local",
When: time.Now(),
},
Message: message,
TreeHash: tree,
}
if len(parents) > 0 {
commit.ParentHashes = parents
}
// Encode and store the commit
obj := store.NewEncodedObject()
if err := commit.Encode(obj); err != nil {
return "", fmt.Errorf("failed to encode commit: %w", err)
}
hash, err := store.SetEncodedObject(obj)
if err != nil {
return "", fmt.Errorf("failed to store commit: %w", err)
}
return hash.String(), nil
}
// UpdateRef updates a Git reference to point to a new SHA
func (gb *GitBackend) UpdateRef(refName, sha string) error {
hash := plumbing.NewHash(sha)
ref := plumbing.NewHashReference(plumbing.ReferenceName(refName), hash)
if err := gb.repo.Storer.SetReference(ref); err != nil {
return fmt.Errorf("failed to update reference %s: %w", refName, err)
}
return nil
}
// GetRef retrieves the SHA that a reference points to
func (gb *GitBackend) GetRef(refName string) (string, error) {
ref, err := gb.repo.Reference(plumbing.ReferenceName(refName), true)
if err != nil {
return "", fmt.Errorf("failed to get reference %s: %w", refName, err)
}
return ref.Hash().String(), nil
}
// GetObject retrieves a Git object by its SHA
func (gb *GitBackend) GetObject(sha string) (object.Object, error) {
hash := plumbing.NewHash(sha)
obj, err := gb.repo.Object(plumbing.AnyObject, hash)
if err != nil {
return nil, fmt.Errorf("failed to get object %s: %w", sha, err)
}
return obj, nil
}
// GetBlob retrieves a blob object by its SHA
func (gb *GitBackend) GetBlob(sha string) (*object.Blob, error) {
hash := plumbing.NewHash(sha)
blob, err := gb.repo.BlobObject(hash)
if err != nil {
return nil, fmt.Errorf("failed to get blob %s: %w", sha, err)
}
return blob, nil
}
// GetTree retrieves a tree object by its SHA
func (gb *GitBackend) GetTree(sha string) (*object.Tree, error) {
hash := plumbing.NewHash(sha)
tree, err := gb.repo.TreeObject(hash)
if err != nil {
return nil, fmt.Errorf("failed to get tree %s: %w", sha, err)
}
return tree, nil
}
// GetCommit retrieves a commit object by its SHA
func (gb *GitBackend) GetCommit(sha string) (*object.Commit, error) {
hash := plumbing.NewHash(sha)
commit, err := gb.repo.CommitObject(hash)
if err != nil {
return nil, fmt.Errorf("failed to get commit %s: %w", sha, err)
}
return commit, nil
}
// HashFromString converts a string SHA to a plumbing.Hash
func HashFromString(sha string) plumbing.Hash {
return plumbing.NewHash(sha)
}

207
internal/git/rebase.go Normal file
View File

@ -0,0 +1,207 @@
package git
import (
"fmt"
"os"
gogit "github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/object"
)
// RebaseEngine handles stacked rebase operations with rerere support
type RebaseEngine struct {
repo *gogit.Repository
backend *GitBackend
rerere *RerereManager
conflictResolver *ConflictResolver
repoPath string
}
// NewRebaseEngine creates a new RebaseEngine instance
func NewRebaseEngine(repo *gogit.Repository, onyxPath, repoPath string) *RebaseEngine {
return &RebaseEngine{
repo: repo,
backend: NewGitBackend(repo),
rerere: NewRerereManager(repo, onyxPath, repoPath),
conflictResolver: NewConflictResolver(repo, repoPath),
repoPath: repoPath,
}
}
// RebaseStackResult contains the result of a stack rebase operation
type RebaseStackResult struct {
Success bool
RebasedCommits []string
FailedCommit string
ConflictingFiles []ConflictInfo
Message string
}
// RebaseStack rebases a stack of commits onto a new base
func (re *RebaseEngine) RebaseStack(stack []string, onto string) (*RebaseStackResult, error) {
result := &RebaseStackResult{
Success: true,
RebasedCommits: []string{},
}
if len(stack) == 0 {
result.Message = "No commits to rebase"
return result, nil
}
// Validate onto commit exists
_, err := re.backend.GetCommit(onto)
if err != nil {
return nil, fmt.Errorf("invalid onto commit %s: %w", onto, err)
}
currentBase := onto
// Rebase each commit in the stack sequentially
for i, commitSHA := range stack {
// Get the commit object
commit, err := re.backend.GetCommit(commitSHA)
if err != nil {
result.Success = false
result.FailedCommit = commitSHA
result.Message = fmt.Sprintf("Failed to get commit %s: %v", commitSHA, err)
return result, fmt.Errorf("failed to get commit: %w", err)
}
// Rebase this commit onto the current base
newCommitSHA, err := re.rebaseSingleCommit(commit, currentBase)
if err != nil {
// Check if it's a conflict error
conflicts, detectErr := re.conflictResolver.DetectConflicts()
if detectErr == nil && len(conflicts) > 0 {
result.Success = false
result.FailedCommit = commitSHA
result.ConflictingFiles = conflicts
result.Message = fmt.Sprintf("Conflicts detected while rebasing commit %d/%d (%s)",
i+1, len(stack), commitSHA[:8])
return result, nil
}
result.Success = false
result.FailedCommit = commitSHA
result.Message = fmt.Sprintf("Failed to rebase commit %s: %v", commitSHA, err)
return result, err
}
result.RebasedCommits = append(result.RebasedCommits, newCommitSHA)
currentBase = newCommitSHA
}
result.Message = fmt.Sprintf("Successfully rebased %d commit(s)", len(stack))
return result, nil
}
// rebaseSingleCommit rebases a single commit onto a new parent
func (re *RebaseEngine) rebaseSingleCommit(commit *object.Commit, newParent string) (string, error) {
// Record conflicts before attempting rebase (for rerere)
if err := re.rerere.RecordConflicts(); err != nil {
fmt.Fprintf(os.Stderr, "Warning: failed to record conflicts: %v\n", err)
}
// Get the commit's tree
tree, err := commit.Tree()
if err != nil {
return "", fmt.Errorf("failed to get commit tree: %w", err)
}
// Check if there are any changes between the trees
// For simplicity, we'll create a new commit with the same tree content
// In a more sophisticated implementation, we would perform a three-way merge
// Try to apply rerere resolutions first
if re.rerere.IsEnabled() {
applied, err := re.rerere.ApplyResolutions()
if err != nil {
fmt.Fprintf(os.Stderr, "Warning: failed to apply rerere resolutions: %v\n", err)
} else if applied > 0 {
fmt.Printf("Applied %d rerere resolution(s)\n", applied)
}
}
// Perform a simple rebase by creating a new commit with the same tree but new parent
// This is a simplified implementation - a full implementation would handle merges
newCommitSHA, err := re.backend.CreateCommit(
tree.Hash.String(),
newParent,
commit.Message,
commit.Author.Name,
)
if err != nil {
return "", fmt.Errorf("failed to create rebased commit: %w", err)
}
return newCommitSHA, nil
}
// RebaseCommit rebases a single commit onto a new parent (public API)
func (re *RebaseEngine) RebaseCommit(commitSHA, newParent string) (string, error) {
commit, err := re.backend.GetCommit(commitSHA)
if err != nil {
return "", fmt.Errorf("failed to get commit: %w", err)
}
return re.rebaseSingleCommit(commit, newParent)
}
// ContinueRebase continues a rebase after conflict resolution
func (re *RebaseEngine) ContinueRebase(stack []string, fromIndex int, onto string) (*RebaseStackResult, error) {
// Record the resolution for rerere
if err := re.rerere.RecordResolution(); err != nil {
fmt.Fprintf(os.Stderr, "Warning: failed to record resolution: %v\n", err)
}
// Check if conflicts are resolved
hasConflicts, err := re.conflictResolver.HasConflicts()
if err != nil {
return nil, fmt.Errorf("failed to check for conflicts: %w", err)
}
if hasConflicts {
return &RebaseStackResult{
Success: false,
Message: "Conflicts still exist. Please resolve all conflicts before continuing.",
}, nil
}
// Continue rebasing from the next commit
remainingStack := stack[fromIndex:]
return re.RebaseStack(remainingStack, onto)
}
// AbortRebase aborts a rebase operation and returns to the original state
func (re *RebaseEngine) AbortRebase(originalHead string) error {
// Update HEAD to original commit
hash := plumbing.NewHash(originalHead)
worktree, err := re.repo.Worktree()
if err != nil {
return fmt.Errorf("failed to get worktree: %w", err)
}
// Checkout the original HEAD
err = worktree.Checkout(&gogit.CheckoutOptions{
Hash: hash,
Force: true,
})
if err != nil {
return fmt.Errorf("failed to checkout original HEAD: %w", err)
}
return nil
}
// GetRerereManager returns the rerere manager
func (re *RebaseEngine) GetRerereManager() *RerereManager {
return re.rerere
}
// GetConflictResolver returns the conflict resolver
func (re *RebaseEngine) GetConflictResolver() *ConflictResolver {
return re.conflictResolver
}

106
internal/git/remote.go Normal file
View File

@ -0,0 +1,106 @@
package git
import (
"fmt"
gogit "github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/config"
)
// RemoteHelper provides utilities for working with Git remotes
type RemoteHelper struct {
repo *gogit.Repository
}
// NewRemoteHelper creates a new RemoteHelper instance
func NewRemoteHelper(repo *gogit.Repository) *RemoteHelper {
return &RemoteHelper{repo: repo}
}
// GetRemote retrieves a remote by name, defaults to "origin" if name is empty
func (rh *RemoteHelper) GetRemote(name string) (*gogit.Remote, error) {
if name == "" {
name = "origin"
}
remote, err := rh.repo.Remote(name)
if err != nil {
return nil, fmt.Errorf("remote '%s' not found: %w", name, err)
}
return remote, nil
}
// ListRemotes returns all configured remotes
func (rh *RemoteHelper) ListRemotes() ([]*gogit.Remote, error) {
remotes, err := rh.repo.Remotes()
if err != nil {
return nil, fmt.Errorf("failed to list remotes: %w", err)
}
return remotes, nil
}
// ValidateRemote checks if a remote exists and is properly configured
func (rh *RemoteHelper) ValidateRemote(name string) error {
if name == "" {
name = "origin"
}
remote, err := rh.GetRemote(name)
if err != nil {
return err
}
// Check if remote has URLs configured
cfg := remote.Config()
if len(cfg.URLs) == 0 {
return fmt.Errorf("remote '%s' has no URLs configured", name)
}
return nil
}
// GetDefaultRemoteName returns the default remote name (origin)
func (rh *RemoteHelper) GetDefaultRemoteName() string {
return "origin"
}
// GetRemoteURL returns the fetch URL for a remote
func (rh *RemoteHelper) GetRemoteURL(name string) (string, error) {
if name == "" {
name = "origin"
}
remote, err := rh.GetRemote(name)
if err != nil {
return "", err
}
cfg := remote.Config()
if len(cfg.URLs) == 0 {
return "", fmt.Errorf("remote '%s' has no URLs configured", name)
}
return cfg.URLs[0], nil
}
// GetRemoteConfig returns the configuration for a remote
func (rh *RemoteHelper) GetRemoteConfig(name string) (*config.RemoteConfig, error) {
if name == "" {
name = "origin"
}
remote, err := rh.GetRemote(name)
if err != nil {
return nil, err
}
return remote.Config(), nil
}
// HasRemote checks if a remote with the given name exists
func (rh *RemoteHelper) HasRemote(name string) bool {
_, err := rh.repo.Remote(name)
return err == nil
}

286
internal/git/rerere.go Normal file
View File

@ -0,0 +1,286 @@
package git
import (
"crypto/sha1"
"encoding/hex"
"fmt"
"io"
"os"
"path/filepath"
"strings"
gogit "github.com/go-git/go-git/v5"
)
// RerereManager manages git rerere (reuse recorded resolution) functionality
type RerereManager struct {
repo *gogit.Repository
cachePath string
enabled bool
repoPath string
conflictResolver *ConflictResolver
}
// NewRerereManager creates a new RerereManager instance
func NewRerereManager(repo *gogit.Repository, onyxPath, repoPath string) *RerereManager {
cachePath := filepath.Join(onyxPath, "rerere_cache")
return &RerereManager{
repo: repo,
cachePath: cachePath,
enabled: true,
repoPath: repoPath,
conflictResolver: NewConflictResolver(repo, repoPath),
}
}
// Enable enables rerere functionality
func (rm *RerereManager) Enable() {
rm.enabled = true
}
// Disable disables rerere functionality
func (rm *RerereManager) Disable() {
rm.enabled = false
}
// IsEnabled returns whether rerere is enabled
func (rm *RerereManager) IsEnabled() bool {
return rm.enabled
}
// RecordConflicts records current conflicts for future resolution
func (rm *RerereManager) RecordConflicts() error {
if !rm.enabled {
return nil
}
conflicts, err := rm.conflictResolver.DetectConflicts()
if err != nil {
return fmt.Errorf("failed to detect conflicts: %w", err)
}
if len(conflicts) == 0 {
return nil
}
// For each conflict, create a cache entry
for _, conflict := range conflicts {
if err := rm.recordConflict(conflict); err != nil {
// Log error but continue with other conflicts
fmt.Fprintf(os.Stderr, "Warning: failed to record conflict for %s: %v\n", conflict.FilePath, err)
}
}
return nil
}
// recordConflict records a single conflict
func (rm *RerereManager) recordConflict(conflict ConflictInfo) error {
// Read the conflicted file
fullPath := filepath.Join(rm.repoPath, conflict.FilePath)
content, err := os.ReadFile(fullPath)
if err != nil {
return fmt.Errorf("failed to read conflicted file: %w", err)
}
// Generate a unique ID for this conflict pattern
conflictID := rm.generateConflictID(content)
// Create cache directory for this conflict
conflictDir := filepath.Join(rm.cachePath, conflictID)
if err := os.MkdirAll(conflictDir, 0755); err != nil {
return fmt.Errorf("failed to create conflict cache directory: %w", err)
}
// Save the preimage (conflict state)
preimagePath := filepath.Join(conflictDir, "preimage")
if err := os.WriteFile(preimagePath, content, 0644); err != nil {
return fmt.Errorf("failed to write preimage: %w", err)
}
// Save metadata
metadataPath := filepath.Join(conflictDir, "metadata")
metadata := fmt.Sprintf("file=%s\nbase=%s\nours=%s\ntheirs=%s\n",
conflict.FilePath, conflict.BaseHash, conflict.OursHash, conflict.TheirsHash)
if err := os.WriteFile(metadataPath, []byte(metadata), 0644); err != nil {
return fmt.Errorf("failed to write metadata: %w", err)
}
return nil
}
// RecordResolution records the resolution for previously recorded conflicts
func (rm *RerereManager) RecordResolution() error {
if !rm.enabled {
return nil
}
// Find all recorded conflicts
entries, err := os.ReadDir(rm.cachePath)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return fmt.Errorf("failed to read rerere cache: %w", err)
}
for _, entry := range entries {
if !entry.IsDir() {
continue
}
conflictID := entry.Name()
if err := rm.recordResolutionForConflict(conflictID); err != nil {
// Log error but continue
fmt.Fprintf(os.Stderr, "Warning: failed to record resolution for %s: %v\n", conflictID, err)
}
}
return nil
}
// recordResolutionForConflict records the resolution for a specific conflict
func (rm *RerereManager) recordResolutionForConflict(conflictID string) error {
conflictDir := filepath.Join(rm.cachePath, conflictID)
// Read metadata to get file path
metadataPath := filepath.Join(conflictDir, "metadata")
metadataContent, err := os.ReadFile(metadataPath)
if err != nil {
return fmt.Errorf("failed to read metadata: %w", err)
}
// Parse file path from metadata
filePath := ""
for _, line := range strings.Split(string(metadataContent), "\n") {
if strings.HasPrefix(line, "file=") {
filePath = strings.TrimPrefix(line, "file=")
break
}
}
if filePath == "" {
return fmt.Errorf("file path not found in metadata")
}
// Check if file still has conflicts
fullPath := filepath.Join(rm.repoPath, filePath)
if _, err := os.Stat(fullPath); os.IsNotExist(err) {
// File was deleted or doesn't exist, skip
return nil
}
hasConflicts, err := rm.conflictResolver.IsFileConflicted(filePath)
if err != nil {
return fmt.Errorf("failed to check if file is conflicted: %w", err)
}
if hasConflicts {
// Still has conflicts, not resolved yet
return nil
}
// Read the resolved content
resolvedContent, err := os.ReadFile(fullPath)
if err != nil {
return fmt.Errorf("failed to read resolved file: %w", err)
}
// Save the postimage (resolved state)
postimagePath := filepath.Join(conflictDir, "postimage")
if err := os.WriteFile(postimagePath, resolvedContent, 0644); err != nil {
return fmt.Errorf("failed to write postimage: %w", err)
}
return nil
}
// ApplyResolutions applies previously recorded resolutions to current conflicts
func (rm *RerereManager) ApplyResolutions() (int, error) {
if !rm.enabled {
return 0, nil
}
conflicts, err := rm.conflictResolver.DetectConflicts()
if err != nil {
return 0, fmt.Errorf("failed to detect conflicts: %w", err)
}
appliedCount := 0
for _, conflict := range conflicts {
// Read the conflicted file
fullPath := filepath.Join(rm.repoPath, conflict.FilePath)
content, err := os.ReadFile(fullPath)
if err != nil {
continue
}
// Generate conflict ID
conflictID := rm.generateConflictID(content)
// Check if we have a resolution for this conflict
postimagePath := filepath.Join(rm.cachePath, conflictID, "postimage")
if _, err := os.Stat(postimagePath); os.IsNotExist(err) {
continue
}
// Apply the resolution
resolvedContent, err := os.ReadFile(postimagePath)
if err != nil {
continue
}
if err := os.WriteFile(fullPath, resolvedContent, 0644); err != nil {
continue
}
appliedCount++
}
return appliedCount, nil
}
// generateConflictID generates a unique ID for a conflict pattern
func (rm *RerereManager) generateConflictID(content []byte) string {
// Normalize conflict content by removing variable parts
normalized := rm.normalizeConflict(content)
// Generate SHA1 hash
hash := sha1.New()
io.WriteString(hash, normalized)
return hex.EncodeToString(hash.Sum(nil))
}
// normalizeConflict normalizes conflict content for matching
func (rm *RerereManager) normalizeConflict(content []byte) string {
// Convert to string
str := string(content)
// Remove commit hashes from conflict markers (they vary)
lines := strings.Split(str, "\n")
var normalized []string
for _, line := range lines {
if strings.HasPrefix(line, "<<<<<<<") {
normalized = append(normalized, "<<<<<<<")
} else if strings.HasPrefix(line, ">>>>>>>") {
normalized = append(normalized, ">>>>>>>")
} else {
normalized = append(normalized, line)
}
}
return strings.Join(normalized, "\n")
}
// ClearCache clears the rerere cache
func (rm *RerereManager) ClearCache() error {
return os.RemoveAll(rm.cachePath)
}
// GetCachePath returns the path to the rerere cache
func (rm *RerereManager) GetCachePath() string {
return rm.cachePath
}

173
internal/models/oplog.go Normal file
View File

@ -0,0 +1,173 @@
package models
import (
"bytes"
"encoding/binary"
"encoding/json"
"fmt"
"io"
"time"
)
// OplogEntry represents a single entry in the action log
type OplogEntry struct {
// ID is a monotonically increasing entry ID
ID uint64
// Timestamp when the operation was performed
Timestamp time.Time
// Operation type (e.g., "save", "switch", "new", "sync")
Operation string
// Description of the operation
Description string
// StateBefore captures the state before the operation
StateBefore *RepositoryState
// StateAfter captures the state after the operation
StateAfter *RepositoryState
// Metadata contains operation-specific data
Metadata map[string]string
}
// RepositoryState captures the state of the repository at a point in time
type RepositoryState struct {
// Refs maps reference names to their SHA-1 hashes
Refs map[string]string
// CurrentWorkstream is the active workstream name
CurrentWorkstream string
// WorkingTreeHash is the hash of the current working tree snapshot
WorkingTreeHash string
// IndexHash is the hash of the staging area
IndexHash string
}
// Serialize converts an OplogEntry to binary format
func (e *OplogEntry) Serialize() ([]byte, error) {
buf := new(bytes.Buffer)
// Write entry ID (8 bytes)
if err := binary.Write(buf, binary.LittleEndian, e.ID); err != nil {
return nil, fmt.Errorf("failed to write ID: %w", err)
}
// Write timestamp (8 bytes, Unix nano)
timestamp := e.Timestamp.UnixNano()
if err := binary.Write(buf, binary.LittleEndian, timestamp); err != nil {
return nil, fmt.Errorf("failed to write timestamp: %w", err)
}
// Serialize the rest as JSON for flexibility
payload := struct {
Operation string `json:"operation"`
Description string `json:"description"`
StateBefore *RepositoryState `json:"state_before"`
StateAfter *RepositoryState `json:"state_after"`
Metadata map[string]string `json:"metadata"`
}{
Operation: e.Operation,
Description: e.Description,
StateBefore: e.StateBefore,
StateAfter: e.StateAfter,
Metadata: e.Metadata,
}
jsonData, err := json.Marshal(payload)
if err != nil {
return nil, fmt.Errorf("failed to marshal JSON: %w", err)
}
// Write JSON length (4 bytes)
jsonLen := uint32(len(jsonData))
if err := binary.Write(buf, binary.LittleEndian, jsonLen); err != nil {
return nil, fmt.Errorf("failed to write JSON length: %w", err)
}
// Write JSON data
if _, err := buf.Write(jsonData); err != nil {
return nil, fmt.Errorf("failed to write JSON data: %w", err)
}
return buf.Bytes(), nil
}
// Deserialize converts binary data back to an OplogEntry
func DeserializeOplogEntry(data []byte) (*OplogEntry, error) {
buf := bytes.NewReader(data)
entry := &OplogEntry{}
// Read entry ID (8 bytes)
if err := binary.Read(buf, binary.LittleEndian, &entry.ID); err != nil {
return nil, fmt.Errorf("failed to read ID: %w", err)
}
// Read timestamp (8 bytes)
var timestamp int64
if err := binary.Read(buf, binary.LittleEndian, &timestamp); err != nil {
return nil, fmt.Errorf("failed to read timestamp: %w", err)
}
entry.Timestamp = time.Unix(0, timestamp)
// Read JSON length (4 bytes)
var jsonLen uint32
if err := binary.Read(buf, binary.LittleEndian, &jsonLen); err != nil {
return nil, fmt.Errorf("failed to read JSON length: %w", err)
}
// Read JSON data
jsonData := make([]byte, jsonLen)
if _, err := io.ReadFull(buf, jsonData); err != nil {
return nil, fmt.Errorf("failed to read JSON data: %w", err)
}
// Unmarshal JSON
payload := struct {
Operation string `json:"operation"`
Description string `json:"description"`
StateBefore *RepositoryState `json:"state_before"`
StateAfter *RepositoryState `json:"state_after"`
Metadata map[string]string `json:"metadata"`
}{}
if err := json.Unmarshal(jsonData, &payload); err != nil {
return nil, fmt.Errorf("failed to unmarshal JSON: %w", err)
}
entry.Operation = payload.Operation
entry.Description = payload.Description
entry.StateBefore = payload.StateBefore
entry.StateAfter = payload.StateAfter
entry.Metadata = payload.Metadata
return entry, nil
}
// NewOplogEntry creates a new oplog entry
func NewOplogEntry(id uint64, operation, description string, before, after *RepositoryState) *OplogEntry {
return &OplogEntry{
ID: id,
Timestamp: time.Now(),
Operation: operation,
Description: description,
StateBefore: before,
StateAfter: after,
Metadata: make(map[string]string),
}
}
// NewRepositoryState creates a new repository state snapshot
func NewRepositoryState(refs map[string]string, currentWorkstream, workingTreeHash, indexHash string) *RepositoryState {
return &RepositoryState{
Refs: refs,
CurrentWorkstream: currentWorkstream,
WorkingTreeHash: workingTreeHash,
IndexHash: indexHash,
}
}

107
internal/models/workspace.go Normal file
View File

@ -0,0 +1,107 @@
package models
import (
"encoding/json"
"fmt"
"time"
)
// WorkspaceState represents the current state of the workspace
type WorkspaceState struct {
// CurrentCommitSHA is the SHA of the current ephemeral commit
CurrentCommitSHA string `json:"current_commit_sha"`
// WorkstreamName is the name of the active workstream
WorkstreamName string `json:"workstream_name"`
// LastSnapshot is when the last automatic snapshot was created
LastSnapshot time.Time `json:"last_snapshot"`
// IsDirty indicates if there are uncommitted changes
IsDirty bool `json:"is_dirty"`
// TreeHash is the hash of the current working tree
TreeHash string `json:"tree_hash,omitempty"`
// IndexHash is the hash of the staging area
IndexHash string `json:"index_hash,omitempty"`
// Metadata contains additional workspace-specific data
Metadata map[string]string `json:"metadata,omitempty"`
}
// NewWorkspaceState creates a new workspace state
func NewWorkspaceState(commitSHA, workstreamName string) *WorkspaceState {
return &WorkspaceState{
CurrentCommitSHA: commitSHA,
WorkstreamName: workstreamName,
LastSnapshot: time.Now(),
IsDirty: false,
Metadata: make(map[string]string),
}
}
// UpdateSnapshot updates the workspace state with a new snapshot
func (ws *WorkspaceState) UpdateSnapshot(commitSHA, treeHash, indexHash string, isDirty bool) {
ws.CurrentCommitSHA = commitSHA
ws.TreeHash = treeHash
ws.IndexHash = indexHash
ws.IsDirty = isDirty
ws.LastSnapshot = time.Now()
}
// SetWorkstream changes the active workstream
func (ws *WorkspaceState) SetWorkstream(workstreamName string) {
ws.WorkstreamName = workstreamName
}
// MarkDirty marks the workspace as having uncommitted changes
func (ws *WorkspaceState) MarkDirty() {
ws.IsDirty = true
}
// MarkClean marks the workspace as clean (no uncommitted changes)
func (ws *WorkspaceState) MarkClean() {
ws.IsDirty = false
}
// Serialize converts the workspace state to JSON
func (ws *WorkspaceState) Serialize() ([]byte, error) {
data, err := json.MarshalIndent(ws, "", " ")
if err != nil {
return nil, fmt.Errorf("failed to marshal workspace state: %w", err)
}
return data, nil
}
// DeserializeWorkspaceState converts JSON data to a workspace state
func DeserializeWorkspaceState(data []byte) (*WorkspaceState, error) {
ws := &WorkspaceState{}
if err := json.Unmarshal(data, ws); err != nil {
return nil, fmt.Errorf("failed to unmarshal workspace state: %w", err)
}
return ws, nil
}
// GetTimeSinceLastSnapshot returns the duration since the last snapshot
func (ws *WorkspaceState) GetTimeSinceLastSnapshot() time.Duration {
return time.Since(ws.LastSnapshot)
}
// Clone creates a deep copy of the workspace state
func (ws *WorkspaceState) Clone() *WorkspaceState {
metadata := make(map[string]string, len(ws.Metadata))
for k, v := range ws.Metadata {
metadata[k] = v
}
return &WorkspaceState{
CurrentCommitSHA: ws.CurrentCommitSHA,
WorkstreamName: ws.WorkstreamName,
LastSnapshot: ws.LastSnapshot,
IsDirty: ws.IsDirty,
TreeHash: ws.TreeHash,
IndexHash: ws.IndexHash,
Metadata: metadata,
}
}

214
internal/models/workstream.go Normal file
View File

@ -0,0 +1,214 @@
package models
import (
"encoding/json"
"fmt"
"time"
)
// Workstream represents a stacked-diff workflow
type Workstream struct {
// Name is the unique identifier for the workstream
Name string `json:"name"`
// Description provides context about the workstream
Description string `json:"description"`
// BaseBranch is the Git branch this workstream is based on
BaseBranch string `json:"base_branch"`
// Commits is an ordered list of commits in this workstream
Commits []WorkstreamCommit `json:"commits"`
// Created is when the workstream was created
Created time.Time `json:"created"`
// Updated is when the workstream was last modified
Updated time.Time `json:"updated"`
// Status indicates the current state (active, merged, abandoned)
Status WorkstreamStatus `json:"status"`
// Metadata contains additional workstream-specific data
Metadata map[string]string `json:"metadata,omitempty"`
}
// WorkstreamCommit represents a single commit in a workstream
type WorkstreamCommit struct {
// SHA is the Git commit hash
SHA string `json:"sha"`
// Message is the commit message
Message string `json:"message"`
// Author is the commit author
Author string `json:"author"`
// Timestamp is when the commit was created
Timestamp time.Time `json:"timestamp"`
// ParentSHA is the parent commit in the workstream (empty for first commit)
ParentSHA string `json:"parent_sha,omitempty"`
// BaseSHA is the base commit from the base branch
BaseSHA string `json:"base_sha"`
// BranchRef is the Git reference for this commit (e.g., refs/onyx/workstreams/name/commit-1)
BranchRef string `json:"branch_ref"`
}
// WorkstreamStatus represents the state of a workstream
type WorkstreamStatus string
const (
// WorkstreamStatusActive indicates the workstream is being actively developed
WorkstreamStatusActive WorkstreamStatus = "active"
// WorkstreamStatusMerged indicates the workstream has been merged
WorkstreamStatusMerged WorkstreamStatus = "merged"
// WorkstreamStatusAbandoned indicates the workstream has been abandoned
WorkstreamStatusAbandoned WorkstreamStatus = "abandoned"
// WorkstreamStatusArchived indicates the workstream has been archived
WorkstreamStatusArchived WorkstreamStatus = "archived"
)
// WorkstreamCollection represents the collection of all workstreams
type WorkstreamCollection struct {
// Workstreams is a map of workstream name to Workstream
Workstreams map[string]*Workstream `json:"workstreams"`
// CurrentWorkstream is the name of the active workstream
CurrentWorkstream string `json:"current_workstream,omitempty"`
}
// NewWorkstream creates a new workstream
func NewWorkstream(name, description, baseBranch string) *Workstream {
now := time.Now()
return &Workstream{
Name: name,
Description: description,
BaseBranch: baseBranch,
Commits: []WorkstreamCommit{},
Created: now,
Updated: now,
Status: WorkstreamStatusActive,
Metadata: make(map[string]string),
}
}
// AddCommit adds a commit to the workstream
func (w *Workstream) AddCommit(commit WorkstreamCommit) {
w.Commits = append(w.Commits, commit)
w.Updated = time.Now()
}
// GetLatestCommit returns the latest commit in the workstream
func (w *Workstream) GetLatestCommit() (*WorkstreamCommit, error) {
if len(w.Commits) == 0 {
return nil, fmt.Errorf("workstream has no commits")
}
return &w.Commits[len(w.Commits)-1], nil
}
// GetCommitCount returns the number of commits in the workstream
func (w *Workstream) GetCommitCount() int {
return len(w.Commits)
}
// IsEmpty returns true if the workstream has no commits
func (w *Workstream) IsEmpty() bool {
return len(w.Commits) == 0
}
// NewWorkstreamCommit creates a new workstream commit
func NewWorkstreamCommit(sha, message, author, parentSHA, baseSHA, branchRef string) WorkstreamCommit {
return WorkstreamCommit{
SHA: sha,
Message: message,
Author: author,
Timestamp: time.Now(),
ParentSHA: parentSHA,
BaseSHA: baseSHA,
BranchRef: branchRef,
}
}
// NewWorkstreamCollection creates a new workstream collection
func NewWorkstreamCollection() *WorkstreamCollection {
return &WorkstreamCollection{
Workstreams: make(map[string]*Workstream),
}
}
// AddWorkstream adds a workstream to the collection
func (wc *WorkstreamCollection) AddWorkstream(workstream *Workstream) error {
if _, exists := wc.Workstreams[workstream.Name]; exists {
return fmt.Errorf("workstream '%s' already exists", workstream.Name)
}
wc.Workstreams[workstream.Name] = workstream
return nil
}
// GetWorkstream retrieves a workstream by name
func (wc *WorkstreamCollection) GetWorkstream(name string) (*Workstream, error) {
workstream, exists := wc.Workstreams[name]
if !exists {
return nil, fmt.Errorf("workstream '%s' not found", name)
}
return workstream, nil
}
// RemoveWorkstream removes a workstream from the collection
func (wc *WorkstreamCollection) RemoveWorkstream(name string) error {
if _, exists := wc.Workstreams[name]; !exists {
return fmt.Errorf("workstream '%s' not found", name)
}
delete(wc.Workstreams, name)
return nil
}
// ListWorkstreams returns all workstreams
func (wc *WorkstreamCollection) ListWorkstreams() []*Workstream {
workstreams := make([]*Workstream, 0, len(wc.Workstreams))
for _, ws := range wc.Workstreams {
workstreams = append(workstreams, ws)
}
return workstreams
}
// SetCurrentWorkstream sets the active workstream
func (wc *WorkstreamCollection) SetCurrentWorkstream(name string) error {
if _, exists := wc.Workstreams[name]; !exists {
return fmt.Errorf("workstream '%s' not found", name)
}
wc.CurrentWorkstream = name
return nil
}
// GetCurrentWorkstream returns the current workstream
func (wc *WorkstreamCollection) GetCurrentWorkstream() (*Workstream, error) {
if wc.CurrentWorkstream == "" {
return nil, fmt.Errorf("no current workstream set")
}
return wc.GetWorkstream(wc.CurrentWorkstream)
}
// Serialize converts the workstream collection to JSON
func (wc *WorkstreamCollection) Serialize() ([]byte, error) {
data, err := json.MarshalIndent(wc, "", " ")
if err != nil {
return nil, fmt.Errorf("failed to marshal workstream collection: %w", err)
}
return data, nil
}
// DeserializeWorkstreamCollection converts JSON data to a workstream collection
func DeserializeWorkstreamCollection(data []byte) (*WorkstreamCollection, error) {
wc := &WorkstreamCollection{}
if err := json.Unmarshal(data, wc); err != nil {
return nil, fmt.Errorf("failed to unmarshal workstream collection: %w", err)
}
return wc, nil
}

201
internal/storage/oplog_reader.go Normal file
View File

@ -0,0 +1,201 @@
package storage
import (
"encoding/binary"
"fmt"
"io"
"os"
"git.dws.rip/DWS/onyx/internal/models"
)
// OplogReader handles reading entries from the oplog file
type OplogReader struct {
path string
}
// NewOplogReader creates a new oplog reader for the given file path
func NewOplogReader(path string) *OplogReader {
return &OplogReader{
path: path,
}
}
// ReadLastEntry reads the last (most recent) entry in the oplog
func (r *OplogReader) ReadLastEntry() (*models.OplogEntry, error) {
file, err := os.Open(r.path)
if err != nil {
return nil, fmt.Errorf("failed to open oplog file: %w", err)
}
defer file.Close()
var lastEntry *models.OplogEntry
// Read through all entries to find the last one
for {
// Read entry length (4 bytes)
var entryLen uint32
err := binary.Read(file, binary.LittleEndian, &entryLen)
if err != nil {
if err == io.EOF {
break
}
return nil, fmt.Errorf("failed to read entry length: %w", err)
}
// Read the entry data
entryData := make([]byte, entryLen)
n, err := file.Read(entryData)
if err != nil {
return nil, fmt.Errorf("failed to read entry data: %w", err)
}
if n != int(entryLen) {
return nil, fmt.Errorf("incomplete entry data read: expected %d bytes, got %d", entryLen, n)
}
// Deserialize the entry
entry, err := models.DeserializeOplogEntry(entryData)
if err != nil {
return nil, fmt.Errorf("failed to deserialize entry: %w", err)
}
lastEntry = entry
}
if lastEntry == nil {
return nil, fmt.Errorf("oplog is empty")
}
return lastEntry, nil
}
// ReadEntry reads a specific entry by ID
func (r *OplogReader) ReadEntry(id uint64) (*models.OplogEntry, error) {
file, err := os.Open(r.path)
if err != nil {
return nil, fmt.Errorf("failed to open oplog file: %w", err)
}
defer file.Close()
// Read through all entries to find the one with matching ID
for {
// Read entry length (4 bytes)
var entryLen uint32
err := binary.Read(file, binary.LittleEndian, &entryLen)
if err != nil {
if err == io.EOF {
break
}
return nil, fmt.Errorf("failed to read entry length: %w", err)
}
// Read the entry data
entryData := make([]byte, entryLen)
n, err := file.Read(entryData)
if err != nil {
return nil, fmt.Errorf("failed to read entry data: %w", err)
}
if n != int(entryLen) {
return nil, fmt.Errorf("incomplete entry data read: expected %d bytes, got %d", entryLen, n)
}
// Deserialize the entry
entry, err := models.DeserializeOplogEntry(entryData)
if err != nil {
return nil, fmt.Errorf("failed to deserialize entry: %w", err)
}
if entry.ID == id {
return entry, nil
}
}
return nil, fmt.Errorf("entry with ID %d not found", id)
}
// GetUndoStack returns a stack of entries that can be undone (in reverse order)
func (r *OplogReader) GetUndoStack() ([]*models.OplogEntry, error) {
entries, err := r.ReadAllEntries()
if err != nil {
return nil, err
}
// Filter out entries that have already been undone
// For now, we return all entries in reverse order
// In the future, we might track undone entries separately
var undoStack []*models.OplogEntry
for i := len(entries) - 1; i >= 0; i-- {
undoStack = append(undoStack, entries[i])
}
return undoStack, nil
}
// ReadAllEntries reads all entries from the oplog in order
func (r *OplogReader) ReadAllEntries() ([]*models.OplogEntry, error) {
file, err := os.Open(r.path)
if err != nil {
return nil, fmt.Errorf("failed to open oplog file: %w", err)
}
defer file.Close()
var entries []*models.OplogEntry
// Read through all entries
for {
// Read entry length (4 bytes)
var entryLen uint32
err := binary.Read(file, binary.LittleEndian, &entryLen)
if err != nil {
if err == io.EOF {
break
}
return nil, fmt.Errorf("failed to read entry length: %w", err)
}
// Read the entry data
entryData := make([]byte, entryLen)
n, err := file.Read(entryData)
if err != nil {
return nil, fmt.Errorf("failed to read entry data: %w", err)
}
if n != int(entryLen) {
return nil, fmt.Errorf("incomplete entry data read: expected %d bytes, got %d", entryLen, n)
}
// Deserialize the entry
entry, err := models.DeserializeOplogEntry(entryData)
if err != nil {
return nil, fmt.Errorf("failed to deserialize entry: %w", err)
}
entries = append(entries, entry)
}
return entries, nil
}
// Count returns the total number of entries in the oplog
func (r *OplogReader) Count() (int, error) {
entries, err := r.ReadAllEntries()
if err != nil {
return 0, err
}
return len(entries), nil
}
// IsEmpty checks if the oplog is empty
func (r *OplogReader) IsEmpty() (bool, error) {
file, err := os.Open(r.path)
if err != nil {
return false, fmt.Errorf("failed to open oplog file: %w", err)
}
defer file.Close()
stat, err := file.Stat()
if err != nil {
return false, fmt.Errorf("failed to stat file: %w", err)
}
return stat.Size() == 0, nil
}

163
internal/storage/oplog_writer.go Normal file
View File

@ -0,0 +1,163 @@
package storage
import (
"encoding/binary"
"fmt"
"os"
"sync"
"git.dws.rip/DWS/onyx/internal/models"
)
// OplogWriter handles writing entries to the oplog file
type OplogWriter struct {
path string
file *os.File
mu sync.Mutex
nextID uint64
isClosed bool
}
// OpenOplog opens an existing oplog file or creates a new one
func OpenOplog(path string) (*OplogWriter, error) {
// Open file for append and read
file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644)
if err != nil {
return nil, fmt.Errorf("failed to open oplog file: %w", err)
}
writer := &OplogWriter{
path: path,
file: file,
nextID: 1,
}
// Calculate next ID by reading existing entries
if err := writer.calculateNextID(); err != nil {
file.Close()
return nil, fmt.Errorf("failed to calculate next ID: %w", err)
}
return writer, nil
}
// calculateNextID scans the oplog to determine the next entry ID
func (w *OplogWriter) calculateNextID() error {
// Seek to the beginning
if _, err := w.file.Seek(0, 0); err != nil {
return fmt.Errorf("failed to seek to beginning: %w", err)
}
var maxID uint64 = 0
// Read through all entries to find the max ID
for {
// Read entry length (4 bytes)
var entryLen uint32
err := binary.Read(w.file, binary.LittleEndian, &entryLen)
if err != nil {
// EOF is expected at the end
if err.Error() == "EOF" {
break
}
return fmt.Errorf("failed to read entry length: %w", err)
}
// Read the entry data
entryData := make([]byte, entryLen)
n, err := w.file.Read(entryData)
if err != nil || n != int(entryLen) {
return fmt.Errorf("failed to read entry data: %w", err)
}
// Deserialize to get the ID
entry, err := models.DeserializeOplogEntry(entryData)
if err != nil {
return fmt.Errorf("failed to deserialize entry: %w", err)
}
if entry.ID > maxID {
maxID = entry.ID
}
}
w.nextID = maxID + 1
// Seek to the end for appending
if _, err := w.file.Seek(0, 2); err != nil {
return fmt.Errorf("failed to seek to end: %w", err)
}
return nil
}
// AppendEntry appends a new entry to the oplog
func (w *OplogWriter) AppendEntry(entry *models.OplogEntry) error {
w.mu.Lock()
defer w.mu.Unlock()
if w.isClosed {
return fmt.Errorf("oplog writer is closed")
}
// Assign ID if not set
if entry.ID == 0 {
entry.ID = w.nextID
w.nextID++
}
// Serialize the entry
data, err := entry.Serialize()
if err != nil {
return fmt.Errorf("failed to serialize entry: %w", err)
}
// Write entry length (4 bytes) followed by entry data
entryLen := uint32(len(data))
if err := binary.Write(w.file, binary.LittleEndian, entryLen); err != nil {
return fmt.Errorf("failed to write entry length: %w", err)
}
if _, err := w.file.Write(data); err != nil {
return fmt.Errorf("failed to write entry data: %w", err)
}
// Sync to disk for durability
if err := w.file.Sync(); err != nil {
return fmt.Errorf("failed to sync file: %w", err)
}
return nil
}
// GetNextID returns the next entry ID that will be assigned
func (w *OplogWriter) GetNextID() uint64 {
w.mu.Lock()
defer w.mu.Unlock()
return w.nextID
}
// Close closes the oplog file
func (w *OplogWriter) Close() error {
w.mu.Lock()
defer w.mu.Unlock()
if w.isClosed {
return nil
}
w.isClosed = true
return w.file.Close()
}
// Flush ensures all buffered data is written to disk
func (w *OplogWriter) Flush() error {
w.mu.Lock()
defer w.mu.Unlock()
if w.isClosed {
return fmt.Errorf("oplog writer is closed")
}
return w.file.Sync()
}

187
internal/storage/state.go Normal file
View File

@ -0,0 +1,187 @@
package storage
import (
"fmt"
"git.dws.rip/DWS/onyx/internal/models"
gogit "github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing"
)
// StateCapture provides functionality to capture repository state
type StateCapture struct {
repo *gogit.Repository
}
// NewStateCapture creates a new StateCapture instance
func NewStateCapture(repo *gogit.Repository) *StateCapture {
return &StateCapture{
repo: repo,
}
}
// CaptureState captures the current state of the repository
func (s *StateCapture) CaptureState() (*models.RepositoryState, error) {
refs, err := s.captureRefs()
if err != nil {
return nil, fmt.Errorf("failed to capture refs: %w", err)
}
currentWorkstream, err := s.getCurrentWorkstream()
if err != nil {
// It's okay if there's no current workstream (e.g., in detached HEAD state)
currentWorkstream = ""
}
workingTreeHash, err := s.getWorkingTreeHash()
if err != nil {
// Working tree hash might not be available in a fresh repo
workingTreeHash = ""
}
indexHash, err := s.getIndexHash()
if err != nil {
// Index hash might not be available in a fresh repo
indexHash = ""
}
return models.NewRepositoryState(refs, currentWorkstream, workingTreeHash, indexHash), nil
}
// captureRefs captures all Git references (branches, tags, etc.)
func (s *StateCapture) captureRefs() (map[string]string, error) {
refs := make(map[string]string)
refIter, err := s.repo.References()
if err != nil {
return nil, fmt.Errorf("failed to get references: %w", err)
}
err = refIter.ForEach(func(ref *plumbing.Reference) error {
if ref.Type() == plumbing.HashReference {
refs[ref.Name().String()] = ref.Hash().String()
} else if ref.Type() == plumbing.SymbolicReference {
// For symbolic refs (like HEAD), store the target
refs[ref.Name().String()] = ref.Target().String()
}
return nil
})
if err != nil {
return nil, fmt.Errorf("failed to iterate references: %w", err)
}
return refs, nil
}
// getCurrentWorkstream determines the current workstream (branch)
func (s *StateCapture) getCurrentWorkstream() (string, error) {
head, err := s.repo.Head()
if err != nil {
return "", fmt.Errorf("failed to get HEAD: %w", err)
}
if head.Name().IsBranch() {
return head.Name().Short(), nil
}
// In detached HEAD state
return "", fmt.Errorf("in detached HEAD state")
}
// getWorkingTreeHash gets a hash representing the current working tree
func (s *StateCapture) getWorkingTreeHash() (string, error) {
worktree, err := s.repo.Worktree()
if err != nil {
return "", fmt.Errorf("failed to get worktree: %w", err)
}
status, err := worktree.Status()
if err != nil {
return "", fmt.Errorf("failed to get status: %w", err)
}
// For now, we'll just check if the working tree is clean
// In the future, we might compute an actual hash
if status.IsClean() {
head, err := s.repo.Head()
if err == nil {
return head.Hash().String(), nil
}
}
return "dirty", nil
}
// getIndexHash gets a hash representing the current index (staging area)
func (s *StateCapture) getIndexHash() (string, error) {
// For now, this is a placeholder
// In the future, we might compute a proper hash of the index
return "", nil
}
// RestoreState restores the repository to a previously captured state
func (s *StateCapture) RestoreState(state *models.RepositoryState) error {
// Restore all refs
for refName, refHash := range state.Refs {
ref := plumbing.NewReferenceFromStrings(refName, refHash)
// Skip symbolic references for now
if ref.Type() == plumbing.SymbolicReference {
continue
}
err := s.repo.Storer.SetReference(ref)
if err != nil {
return fmt.Errorf("failed to restore ref %s: %w", refName, err)
}
}
// If there's a current workstream, check it out
if state.CurrentWorkstream != "" {
worktree, err := s.repo.Worktree()
if err != nil {
return fmt.Errorf("failed to get worktree: %w", err)
}
err = worktree.Checkout(&gogit.CheckoutOptions{
Branch: plumbing.NewBranchReferenceName(state.CurrentWorkstream),
})
if err != nil {
// Don't fail if checkout fails, just log it
// The refs have been restored which is the most important part
fmt.Printf("Warning: failed to checkout branch %s: %v\n", state.CurrentWorkstream, err)
}
}
return nil
}
// CompareStates compares two repository states and returns the differences
func (s *StateCapture) CompareStates(before, after *models.RepositoryState) map[string]string {
differences := make(map[string]string)
// Check for changed/added refs
for refName, afterHash := range after.Refs {
beforeHash, exists := before.Refs[refName]
if !exists {
differences[refName] = fmt.Sprintf("added: %s", afterHash)
} else if beforeHash != afterHash {
differences[refName] = fmt.Sprintf("changed: %s -> %s", beforeHash, afterHash)
}
}
// Check for deleted refs
for refName := range before.Refs {
if _, exists := after.Refs[refName]; !exists {
differences[refName] = "deleted"
}
}
// Check workstream change
if before.CurrentWorkstream != after.CurrentWorkstream {
differences["current_workstream"] = fmt.Sprintf("changed: %s -> %s", before.CurrentWorkstream, after.CurrentWorkstream)
}
return differences
}

47
internal/storage/workstreams.go Normal file
View File

@ -0,0 +1,47 @@
package storage
import (
"fmt"
"os"
"git.dws.rip/DWS/onyx/internal/models"
)
// LoadWorkstreams loads the workstream collection from the workstreams.json file
func LoadWorkstreams(path string) (*models.WorkstreamCollection, error) {
// Check if file exists
if _, err := os.Stat(path); os.IsNotExist(err) {
// Return empty collection if file doesn't exist
return models.NewWorkstreamCollection(), nil
}
// Read the file
data, err := os.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("failed to read workstreams file: %w", err)
}
// Deserialize the workstream collection
collection, err := models.DeserializeWorkstreamCollection(data)
if err != nil {
return nil, fmt.Errorf("failed to deserialize workstreams: %w", err)
}
return collection, nil
}
// SaveWorkstreams saves the workstream collection to the workstreams.json file
func SaveWorkstreams(path string, collection *models.WorkstreamCollection) error {
// Serialize the collection
data, err := collection.Serialize()
if err != nil {
return fmt.Errorf("failed to serialize workstreams: %w", err)
}
// Write to file
if err := os.WriteFile(path, data, 0644); err != nil {
return fmt.Errorf("failed to write workstreams file: %w", err)
}
return nil
}

358
notes/architecture.md Normal file
View File

@ -0,0 +1,358 @@
# **Onyx: An Architectural Blueprint and Phase 1 Implementation Plan**
## **Executive Summary**
This document provides a concrete, actionable engineering plan for building Onyx, a next-generation version control system (VCS). The core value proposition of Onyx is not to replace Git, but to provide a compatible, superior user experience layer designed to enhance developer velocity, safety, and ergonomics. It achieves this by directly addressing the fundamental flaws in Git's user-facing model, which is a significant and persistent source of developer frustration and cognitive overhead.1
The architecture is founded on a hybrid storage model, utilizing a standard .git directory for universal data compatibility and a parallel .onx directory for Onyx-specific metadata. This approach ensures seamless interoperability with the existing Git ecosystem while enabling a suite of advanced, user-centric features. The recommended technical stack is centered on the Go programming language and the go-git library for core Git interaction, chosen for their alignment with Onyx's principles of performance, simplicity, and robust concurrency.6
The implementation plan is phased, with Phase 1 focused on delivering the most critical 80% of developer workflows: initializing a repository, saving work, creating and switching between tasks, and synchronizing with remote repositories \[User Query\]. This blueprint translates the high-level concepts of Transparent Versioning, Workstreams, and the Action Log into a detailed technical specification, serving as the primary guiding document for the engineering team tasked with building Onyx.
## **Section 1: Foundational Architecture: A New Porcelain on Git's Plumbing**
This section establishes the non-negotiable architectural principles that govern Onyx's design. These principles are engineered to ensure that Onyx can deliver its innovative user experience without sacrificing compatibility with the vast and deeply entrenched Git ecosystem.
### **1.1. The Strategic Imperative: 100% Git Data Model Compatibility**
Any analysis of the version control market must begin with the acknowledgment of Git's hegemonic status, with a market share exceeding 90%.1 This dominance is not merely a function of its technical merits but is the result of a powerful, self-reinforcing network effect driven by the vast ecosystem of code hosting platforms (GitHub, GitLab), DevOps tooling, and developer mindshare built around it.2 The history of technically compelling or user-friendly alternative version control systems, such as Mercurial, Pijul, and Darcs, provides a crucial lesson: technical or user experience superiority alone is insufficient to overcome the immense inertia of this ecosystem.2 Attempting to replace Git's underlying data model is, therefore, a strategic dead end.
This market reality establishes the single most important architectural mandate for Onyx: it must be designed as a new "porcelain"—a layer of user-facing tools and workflows—that operates directly on Git's existing "plumbing," its foundational data model.1 This principle of unyielding compatibility dictates that all core repository data—blobs (file content), trees (directory structures), and commits (historical snapshots)—must be standard Git objects, addressable by their SHA-1 hashes and stored within a standard .git/objects directory.1 This ensures that any standard Git client can clone, inspect, build, and interact with an Onyx-managed repository without issue, even without Onyx installed.1
The implications of this decision are profound. It allows Onyx to be positioned not as a risky, all-or-nothing "Git replacement," but as a "power-up" or a progressive enhancement for professional developers.2 This strategy dramatically lowers the barrier to adoption for individuals and teams, as a single developer can adopt Onyx for its superior local workflow without disrupting the tooling or workflows of their collaborators who continue to use standard Git.
### **1.2. The Hybrid Storage Model: .git for Shared Truth, .onx for Local State**
To power its advanced features—such as the Action Log for universal undo, Workstreams for native stacked-diff management, and the Ephemeral Workspace for transparent versioning—Onyx requires its own persistent metadata store within the repository.1 The architecture for this storage is a co-located directory model, which creates a clear and deliberate separation of concerns.
A standard .git directory will serve as the immutable, shared source of truth. It contains the Git object database and the refs that are understood by the global Git ecosystem. In parallel, Onyx will create and maintain a .onx directory at the root of the repository. This directory will house all Onyx-specific metadata, effectively serving as the user's local, high-fidelity workspace and state machine.2
This hybrid model was chosen over an alternative approach of storing metadata within a dedicated Git namespace (e.g., refs/meta/onyx/).1 While using Git refs would make the metadata automatically portable via standard git fetch and git push operations, it is fundamentally unsuitable for the complex, high-frequency, and often private data Onyx will generate. The Action Log, for instance, is an append-only log of every user operation; representing this as a chain of thousands of Git refs would be highly inefficient, pollute the ref database, and could severely degrade the performance of standard Git operations like garbage collection.
The .onx directory model provides the necessary isolation and allows for the use of more efficient and appropriate data structures, such as a binary log file for the Action Log or a local SQLite database for indexing commit metadata. This design creates a deliberate "portability boundary" that reinforces Onyx's core conceptual model. The user query specifies the creation of the "iPhone of VCS," a system that abstracts away underlying complexity. By separating local state from shared state, Onyx presents the user with a simplified world of "Workstreams" and "Actions," not a confusing soup of underlying implementation details. The .git directory contains the shared, canonical history that all collaborators agree upon. The .onx directory contains the user's private, powerful "scratchpad"—their undo history, their fluid work-in-progress, and their local workflow configuration. This means that sharing an Onyx-enhanced workflow requires both users to have Onyx, which is a feature, not a limitation. It encourages adoption while ensuring the shared truth in .git remains clean and universally compatible. The act of executing onx review becomes the explicit, managed process of translating the rich local state from .onx into the simpler, shared state of standard Git branches and pull requests.
## **Section 2: Data Models and On-Disk Structures**
This section provides a detailed specification for the contents of the .onx directory and the in-memory data structures that represent Onyx's core concepts. This on-disk layout is the physical manifestation of the architectural principles established in the previous section.
### **2.1. The .onx Directory Layout**
An Onyx-managed repository will contain the following structure at its root, alongside the standard .git directory. This layout provides a clear, organized, and extensible foundation for Onyx's metadata.
* .onx/
* oplog: An append-only binary file containing the Action Log.
* workstreams.json: A human-readable file defining the logical Workstreams.
* workspace: A plain-text file acting as a pointer to the current ephemeral commit.
* rerere\_cache/: A directory to store Git's rerere data for automated conflict resolution.
* index.db: (Reserved for future use) A SQLite database for indexing commit metadata to power the Temporal Explorer.
### **2.2. The Action Log (oplog) Schema**
The Action Log is the cornerstone of Onyx's safety model, providing the data necessary for a true, universal undo/redo capability.1 To ensure performance and immutability, it will be implemented as an append-only binary log file. Each entry in the log represents a single, state-changing transaction.
The structure of each serialized transaction object within the oplog will be as follows:
* **id (u64):** A unique, monotonically increasing identifier for the operation.
* **parent\_id (u64):** The ID of the previous operation, forming a traversable chain for sequential undo/redo operations.
* **timestamp (u64):** A high-precision Unix timestamp (nanoseconds) marking the start of the operation.
* **command (String):** The user-facing command that triggered the action, including its arguments (e.g., onx sync, onx save \-m "Initial implementation").
* **state\_before (Map\<String, String\>):** A snapshot of all Onyx-managed Git refs *before* the operation was executed. The map keys are the full ref names (e.g., refs/heads/onyx/feature-auth/1), and the values are the corresponding Git commit SHA-1 hashes.
* **state\_after (Map\<String, String\>):** The corresponding snapshot of the same refs *after* the operation completed successfully.
This structure is the key to enabling the onx undo command. An undo operation is a simple, deterministic process: it reads the state\_before map from the latest log entry and programmatically force-updates all managed refs to match the stored SHA-1 hashes, effectively rolling back the repository's meta-state to the point just before the last command was run.1
### **2.3. Workstream Representation**
Onyx's Workstreams are a high-level abstraction designed to make the powerful but complex "stacked diffs" workflow simple and native.1 The on-disk representation explicitly decouples the user's logical concept of a "Workstream" from the underlying Git implementation, which consists of a chain of hidden branches. This state will be stored in .onx/workstreams.json.
A sample structure for this JSON file is:
JSON
{
"current\_workstream": "feature-auth",
"workstreams": {
"feature-auth": {
"base\_commit": "a1b2c3d4...",
"commits": \[
{
"sha": "f1e2d3c4...",
"branch\_ref": "refs/heads/onyx/feature-auth/1",
"description": "Add database schema for users"
},
{
"sha": "b4c3d2e1...",
"branch\_ref": "refs/heads/onyx/feature-auth/2",
"description": "Implement backend authentication API"
}
\]
},
"bugfix/login-flow": {
"base\_commit": "e5f6a7b8...",
"commits": \[
{
"sha": "c9d8e7f6...",
"branch\_ref": "refs/heads/onyx/bugfix/login-flow/1",
"description": "Fix incorrect password validation"
}
\]
}
}
}
The onx CLI will read and write to this file to manage the state of Workstreams, while the backend logic will perform the more complex task of creating, rebasing, and pushing the underlying Git branches specified in the branch\_ref fields.
### **2.4. Ephemeral Workspace State (workspace file)**
The Ephemeral Workspace is the core of the Transparent Versioning system, replacing Git's confusing staging area with a model where the working directory is always represented as a commit.1 The state of this system is managed by a single pointer stored in the .onx/workspace file.
This file will contain a single line, following the format of Git's own symbolic-ref files:
ref: refs/onyx/workspaces/current
A background daemon will be responsible for continuously creating new, "ephemeral" Git commits that reflect the state of the user's files and updating the refs/onyx/workspaces/current ref to point to the latest one. User-facing commands like onx save will then "pin" this ephemeral commit by giving it a permanent branch and adding it to a Workstream. This mechanism provides the safety of continuous backup while keeping the user's primary workflow focused on creating meaningful, durable checkpoints.
### **2.5. Table 2.1: Onyx Metadata Schema**
The following table provides a consolidated overview of the on-disk structures within the .onx directory, serving as a definitive schema for the implementation. The presence of a dedicated rerere\_cache directory, for example, signals that automated conflict resolution is a core, designed-in feature of the architecture, not an afterthought.1
| Path | Format | Purpose |
| :---- | :---- | :---- |
| oplog | Append-only Binary Log | Stores the transaction history of all state-changing operations, enabling the onx undo/redo functionality. |
| workstreams.json | JSON | Defines the logical Workstreams, their constituent commits, and their mapping to the underlying hidden Git branches. |
| workspace | Plain Text (Symbolic Ref) | Stores the ref pointer to the current ephemeral commit, which represents the live state of the user's working directory. |
| rerere\_cache/ | Git rerere format | Stores recorded conflict resolutions, allowing onx sync to automatically resolve previously seen merge conflicts. |
| index.db | SQLite | (Future Direction) An index of commit metadata (author, date, file paths) to enable fast, complex queries for the Temporal Explorer. |
## **Section 3: Core Component Implementation: The Four Pillars**
This section details the engineering approach for each of Onyx's foundational features, translating the architectural concepts and data models into concrete algorithms and implementation strategies.
### **3.1. Transparent Versioning and the Ephemeral Workspace**
The elimination of the manual git add/git commit cycle for routine work is a primary goal of Onyx.1 This is achieved through a long-running, lightweight background daemon (onxd) that automates the creation of "ephemeral" snapshots.
The daemon will leverage platform-native filesystem notification APIs to ensure maximum efficiency and minimal resource consumption. The Go ecosystem provides a mature library, fsnotify, that offers a unified, cross-platform abstraction over these APIs (inotify on Linux, kqueue on BSD/macOS, and ReadDirectoryChangesW on Windows).7
The snapshotting algorithm executed by the daemon will be as follows:
1. **Trigger:** Upon receiving a file change notification from the OS, the daemon will start a short debounce timer (e.g., 500ms) to batch subsequent rapid changes, such as those occurring during a file save operation.
2. **Tree Creation:** Once the timer expires, the daemon will programmatically create a new Git tree object. This is not a diff; it is a full snapshot of the *entire* current state of the working directory, which is consistent with Git's core "snapshot, not differences" philosophy.5 This involves iterating through the directory, creating blob objects for each file's content, and recursively building tree objects for each subdirectory.
3. **Commit Creation:** The daemon will then create a new Git commit object. This commit will point to the newly created root tree object. The parent of this new commit will be the SHA-1 hash of the previous ephemeral commit, which is read from the ref pointed to by .onx/workspace. The commit message will be a simple, machine-readable placeholder (e.g., "ephemeral snapshot @ timestamp").
4. **Ref Update:** Finally, the daemon will atomically update the Git ref refs/onyx/workspaces/current to point to the SHA-1 hash of the new ephemeral commit.
This automated process completely removes the cognitive burden of the staging area, a primary source of user friction with Git.1 The user's work is continuously and safely versioned in the background, allowing them to focus on their creative tasks.
### **3.2. Workstreams: The Stack-Native Workflow Engine**
Workstreams are the core component for managing development tasks and enabling high-velocity, stacked-diff workflows. The implementation of the onx save and onx sync commands is critical to this engine.
The algorithm for onx save \-m "\<message\>" will be:
1. **Identify Source:** Read the current ephemeral commit SHA from the ref pointed to by .onx/workspace.
2. **Create Pinned Commit:** Create a new, durable Git commit object. This is effectively an amendment of the ephemeral commit: it points to the same tree object but replaces the placeholder message with the user-provided message and sets the correct author and committer metadata.
3. **Allocate Branch:** Determine the next available branch name in the current Workstream's sequence based on the data in .onx/workstreams.json (e.g., if the last branch was .../3, the new one is .../4).
4. **Create Branch:** Create this new Git branch and point it to the SHA of the new durable commit.
5. **Update Metadata:** Update the .onx/workstreams.json file to add this new commit (its SHA, branch ref, and description) to the current Workstream's ordered list of commits.
The algorithm for onx sync, the powerhouse of the Workstream model, will be:
1. **Fetch Updates:** Perform a git fetch on the configured remote to get the latest changes for the base branch (e.g., origin/main).
2. **Identify Stack:** Read the ordered list of branches for the current Workstream from .onx/workstreams.json.
3. **Rebase Head:** Programmatically perform a git rebase of the first branch in the stack (e.g., .../1) onto the new tip of origin/main.
4. **Sequential Rebase:** For each subsequent branch in the stack (.../2, .../3, etc.), programmatically rebase it onto the *newly rebased* tip of the preceding branch. This automated, sequential process is equivalent to the manual and error-prone series of interactive rebases required in standard Git, or a more modern git rebase \--update-refs operation.1
5. **Automated Conflict Resolution:** Throughout this process, Git's rerere (reuse recorded resolution) feature will be enabled. The .onx/rerere\_cache directory will be configured as the storage location. This allows Onyx to learn how a user resolves a specific conflict once and then apply that same resolution automatically in all future onx sync operations where the same conflict arises.1
A standard git rebase is not an atomic operation; it can fail midway, leaving the repository in a confusing, partially-rebased state that requires manual intervention (--continue or \--abort). The onx sync command, however, is presented to the user as a single, atomic operation. This is made possible by the Action Log. The onx sync command must begin by writing a "BEGIN\_SYNC" entry to the oplog. If the entire sequential rebase completes successfully, it writes a corresponding "END\_SYNC" entry. If any step fails due to an unresolvable conflict, the entire operation can be instantly and safely rolled back by invoking onx undo, which will use the state\_before from the "BEGIN\_SYNC" entry to restore all branch pointers to their pre-sync state. In this way, Onyx adds a transactional layer on top of Git's primitive operations, providing a fundamental enhancement to safety and usability.
### **3.3. The Temporal Explorer (Phase 1 Stub)**
While the full interactive, terminal-based visualizer described in the RFCs is a post-Phase 1 feature, the foundation can be laid with a powerful onx log command.1 The Phase 1 implementation will focus on a command-line query engine based on the revset language pioneered by Mercurial and Jujutsu.1
The implementation will consist of two main parts:
* **Revset Parser:** A parser for a subset of the revset grammar. The initial scope for Phase 1 will include essential filters and operators:
* **Filters:** author(regex), file(glob), description(regex)
* **Set Operators:** x | y (union), x & y (intersection), \~x (negation)
* **Ancestry Operators:** x..y (commits reachable from y but not x), ::x (ancestors of x)
* **Query Engine:** This engine will take the parsed query and execute it against the Git commit graph. It will leverage the commit iteration capabilities provided by the chosen Git library (go-git) to efficiently traverse the DAG.6 The engine will apply the filters at each node to build the final set of matching commits.
This component provides a significantly more intuitive and powerful way for developers to navigate and understand project history compared to the complex and often-forgotten flag combinations of the standard git log command.1
### **3.4. The Action Log: A Transactional Safety Net**
The Action Log is the most critical safety feature in Onyx, transforming the user experience from one of caution to one of fearless experimentation.1 Its implementation requires that every state-changing onx command be wrapped in a transactional function.
The logic for this transactional wrapper will be:
1. **Capture Pre-State:** Before executing any logic, capture the current state of all Onyx-managed refs (Workstream branch tips, the workspace pointer, etc.) by reading their current SHA-1 hashes.
2. **Begin Transaction:** Write a new entry to the .onx/oplog. This entry will contain a new unique ID, the ID of the parent operation, the command being executed, and the captured state\_before.
3. **Execute Command Logic:** Run the core implementation of the command (e.g., the onx sync sequential rebase algorithm).
4. **Finalize Transaction (on Success):** If the command logic completes successfully, capture the new state of all managed refs (state\_after) and update the oplog entry to include this information.
5. **Handle Failure:** If the command logic fails, log the failure and provide a clear, actionable error message to the user, guiding them to run onx undo to revert to a clean state.
The algorithm for the onx undo command itself will be:
1. **Read Log:** Read the most recent, un-undone entry from the oplog.
2. **Restore Refs:** For each key-value pair in the entry's state\_before map, perform a direct, forceful update of the Git ref (the key) to point to the stored SHA-1 hash (the value).
3. **Update Workspace:** Perform a git checkout of the appropriate commit to restore the working directory to its previous state.
4. **Update Log Pointer:** Move the oplog's internal "HEAD" pointer to the parent operation. This stack-based model enables sequential undo calls to step further back in the operation history, a crucial usability improvement over the sometimes confusing behavior of jj undo.1
## **Section 4: The onx Command-Line Interface: Phase 1 Specification**
The onx command-line interface is the primary surface through which developers will experience Onyx. Its design is paramount to fulfilling the "iPhone of VCS" vision. It will be a thoughtfully designed, user-centric interface that embodies the principles of velocity, simplicity, and safety, drawing inspiration from the consistency and user-focus of Mercurial's CLI.2
### **4.1. Design Philosophy**
The development of the onx CLI will be guided by a set of core design principles:
* **Orthogonality:** Each command will have a single, well-defined purpose. This principle explicitly avoids the pitfalls of overloaded and confusing commands like git checkout, which handles branch switching, file restoration, and historical checkouts.1
* **Intention-Based Naming:** Commands will be named for the user's goal (e.g., onx new, onx save, onx review), not the underlying mechanical operation (git checkout \-b, git commit, git push).2 This makes the interface more intuitive and easier to learn.
* **Guidance and Discoverability:** The CLI will be self-documenting. Every command will feature rich \--help text with practical examples. Furthermore, the CLI will be an active guide: error messages will be human-readable, explain the problem, and suggest the exact command to fix it. Successful operations will provide clear confirmation and suggest the next logical step in a common workflow.2
### **4.2. Table 4.1: onx CLI Command Specification (Phase 1\)**
The following table provides a comprehensive reference for the commands required to fulfill the scope of Phase 1\. It serves as the primary specification for the CLI development team and provides stakeholders with a clear summary of the product's initial functionality.
| Command | Arguments/Options | Git Equivalent (Conceptual) | Description |
| :---- | :---- | :---- | :---- |
| onx init | \[directory\] | git init | Initializes a new Onyx-managed repository, creating both a standard .git directory and the .onx metadata directory. |
| onx new | \<name\> | git checkout \-b \<name\> | Creates a new Workstream for a feature or task, automatically branching from the configured mainline. |
| onx save | \-m, \--message "message" | git add. && git commit | Creates a durable, named snapshot (a "pinned" commit) of the current work within a Workstream. |
| onx list | | git branch | Lists all available Workstreams and indicates the currently active one. |
| onx switch | \<name\> | git checkout \<name\> | Switches the current context to a different Workstream, restoring its files and history. |
| onx push | \[remote\] | git push | Pushes the current Workstream's underlying branches to a remote repository. (A simplified precursor to onx review). |
| onx sync | | git pull \--rebase origin main | Updates the current Workstream by fetching the latest changes from its base branch and automatically rebasing the entire stack. |
| onx undo | | git reflog && git reset \--hard \<ref\> | Reverses the last state-changing operation recorded in the Action Log, providing a universal safety net. |
### **4.3. Table 4.2: Git vs. Onyx Workflow Mapping**
A critical tool for driving adoption will be helping experienced Git users map their existing, often painful, workflows to the simpler, more powerful Onyx paradigm. The "unlearning curve" for Git veterans is a significant adoption barrier.2 This "Rosetta Stone" table directly addresses that friction by demonstrating Onyx's value proposition in a single, easily digestible format.
| Goal / Workflow | Git Commands | Onyx Commands | Analysis of Benefit |
| :---- | :---- | :---- | :---- |
| Start a new feature | git checkout main git pull git checkout \-b feature/auth | onx new feature/auth | A single, intention-based command replaces three mechanical steps. Onyx handles synchronization automatically. |
| Save work to switch tasks | git add. git stash git checkout hotfix/bug | onx switch hotfix/bug | The entire concept of stashing is eliminated. Transparent Versioning means work is always saved; switching is frictionless. |
| Update feature with main | git pull \--rebase origin main | onx sync | Onyx's sync automates the rebase for the entire stack of commits in a Workstream, not just a single branch. |
| Amend an older commit | git rebase \-i \<base\> (mark commit with edit) ...make changes... git commit \--amend git rebase \--continue | onx down 2 ...make changes... onx save \--amend | Onyx allows direct editing of historical commits. The tool automatically handles the rebase of all dependent commits in the stack. |
| Undo a botched rebase | git reflog (find correct ref) git reset \--hard HEAD@{n} | onx undo | A single, memorable, and safe command replaces the arcane and dangerous reflog/reset dance. |
## **Section 5: Phase 1 Implementation Roadmap**
This section provides a practical, milestone-based plan for building and delivering Phase 1 of Onyx. It transforms the architectural proposal into an actionable project plan, allowing for accurate resource planning and progress tracking. The dependencies between milestones are explicit, ensuring a logical and efficient development sequence.
### **Milestone 0: Foundation and Core Abstractions**
* **Tasks:**
1. Initialize the Go module structure, including workspace setup, CI/CD pipelines, and dependency management.
2. Select and integrate go-git as the core Git interaction library.6
3. Implement the core Repository struct, which will serve as the central object, encapsulating access to both the underlying Git repository (via go-git) and the Onyx metadata within the .onx directory.
4. Implement low-level, internal functions for programmatically reading and writing the four fundamental Git object types: blobs, trees, commits, and tags, using the go-git API.9
* **Goal:** A foundational library that can programmatically create a valid Git commit from a directory snapshot, forming the bedrock for all higher-level Onyx features.
### **Milestone 1: The Action Log and onx init**
* **Tasks:**
1. Implement the on-disk data structure for the oplog as a robust, append-only binary file.
2. Develop the transactional wrapper function that all state-changing commands will use. This function will handle capturing state\_before, writing to the oplog, and finalizing the entry with state\_after.
3. Implement the onx init command. This will be the first user-facing command and will use the transactional wrapper to log its own creation of the .onx directory and its initial files.
4. Implement the onx undo command to read the oplog and revert the init operation.
* **Goal:** A working onx init command and a fully testable, robust undo/redo foundation. This milestone proves the core safety mechanism of the entire system.
### **Milestone 2: Transparent Versioning and onx save**
* **Tasks:**
1. Build the cross-platform onxd filesystem monitoring daemon using a library like fsnotify.7
2. Implement the snapshotting algorithm within the daemon to automatically create ephemeral commits and update the workspace pointer.
3. Implement the onx save command, which "pins" the current ephemeral commit by giving it a user-provided message and associating it with a Workstream.
* **Goal:** The core "save work" loop is fully functional. The Git staging area is now officially obsolete within the Onyx workflow.
### **Milestone 3: Workstreams (onx new, onx list, onx switch)**
* **Tasks:**
1. Implement the on-disk data model for Workstreams in .onx/workstreams.json, including functions for reading, writing, and modifying this state.
2. Implement the onx new command to create a new Workstream.
3. Implement the onx list command to display available Workstreams.
4. Implement the onx switch command to change the active Workstream, which involves updating the working directory and the internal workspace pointer.
* **Goal:** The core branching and context-switching workflow is complete, providing a fluid and frictionless way for developers to manage multiple tasks.
### **Milestone 4: Synchronization and Remote Interaction (onx sync, onx push)**
* **Tasks:**
1. Implement the automated stacked rebase logic for the onx sync command, ensuring it correctly handles the sequential rebasing of the entire commit stack.
2. Integrate Git's rerere functionality to enable automated conflict resolution.
3. Implement the onx push command to push all the underlying hidden branches of a single Workstream to a remote repository.
* **Goal:** Users can now collaborate with others and keep their local work up-to-date with a shared mainline branch, completing the core 80% of common developer workflows.
### **5.5. Table 5.1: Phase 1 Milestone Breakdown**
| Milestone | Key Tasks | Dependencies | Complexity (Points) |
| :---- | :---- | :---- | :---- |
| **M0: Foundation** | Project Setup, go-git Integration, Core Git Object I/O | \- | 8 |
| **M1: Action Log** | oplog Implementation, Transactional Wrapper, onx init, onx undo | M0 | 13 |
| **M2: Versioning** | onxd Daemon, Filesystem Monitoring, Snapshot Algorithm, onx save | M1 | 21 |
| **M3: Workstreams** | Workstream Data Model, onx new, onx list, onx switch | M2 | 13 |
| **M4: Sync & Push** | Stacked Rebase Logic, rerere Integration, onx sync, onx push | M3 | 21 |
## **Section 6: Recommended Technical Stack and Dependencies**
This section provides and justifies the selection of the core technologies for building Onyx, ensuring the project is built on a modern, performant, and reliable foundation.
### **6.1. Implementation Language: Go**
Go is the recommended language for implementing Onyx. Its key features—simplicity, strong performance, and a powerful first-class concurrency model—are critical for building a systems-level tool like a version control system. Go compiles to a single, statically-linked binary, making distribution and deployment trivial across all major platforms. Its garbage collector simplifies memory management, while its robust standard library and pragmatic design accelerate development. The language's built-in support for goroutines and channels is ideal for building the concurrent components of Onyx, such as the background filesystem daemon (onxd), without the complexity of external runtimes.
### **6.2. Core Git Interaction Library: go-git**
The Go ecosystem offers two primary libraries for low-level Git interaction: git2go, which provides Go bindings to the mature C library libgit2 10, and go-git, a pure-Go, from-scratch implementation of Git.6 While libgit2 is highly feature-complete, using it via git2go introduces CGo, which can add significant complexity to the build process, cross-compilation, and memory management, and creates a dependency on a C toolchain.11
For Onyx, the recommended library is go-git. This choice represents a strategic alignment with Onyx's core philosophy of building a modern, simple, and self-contained tool. As a pure Go implementation, go-git avoids the overhead and complexity of CGo, simplifying the build and deployment process and ensuring the entire stack benefits from Go's memory safety and tooling.12 go-git is actively developed and used in major projects like Gitea and Pulumi, and it provides idiomatic Go APIs for both low-level (plumbing) and high-level (porcelain) operations, making it a more strategic and future-proof choice for a Go-native project.6
### **6.3. Key Dependencies**
* **CLI Framework:** cobra is the de facto standard for building feature-rich command-line applications in Go. It is used by major projects like Kubernetes and Docker and provides excellent support for nested commands, argument parsing, and automatic help generation.13
* **Filesystem Monitoring:** The fsnotify package will be used to provide a cross-platform abstraction over native filesystem event APIs, forming the core of the onxd daemon.7
* **Serialization:** Go's standard library encoding/json package is the canonical choice for handling the on-disk JSON format of the workstreams.json file. It is robust, performant, and requires no external dependencies.15
* **Concurrency:** Go's built-in **goroutines and channels** will be used as the asynchronous runtime for managing the background daemon, handling concurrent filesystem events, and executing any other long-running or I/O-bound tasks efficiently.
## **Section 7: Future Directions: Beyond Phase 1**
While the Phase 1 implementation plan focuses on delivering a robust and complete core workflow, the architecture is designed to be extensible. This concluding section outlines the logical next steps for Onyx's evolution, ensuring that the initial engineering effort provides a solid foundation for future growth.
### **7.1. The Full Temporal Explorer**
Beyond the command-line query engine of Phase 1, the next major feature will be the implementation of the full Temporal Explorer. This includes an interactive, terminal-based GUI visualizer for the commit graph, as envisioned in the original proposal.1 This tool will provide a clean, comprehensible rendering of the repository's Directed Acyclic Graph, allowing for interactive exploration, zooming, and direct manipulation of commits, addressing a long-standing need within the developer community for better native history visualization tools.1
### **7.2. Advanced Review Workflows**
The Phase 1 onx push command is a stepping stone to the more powerful onx review command. This future implementation will integrate directly with the APIs of major code hosting providers like GitHub and GitLab. onx review will automate the entire process of submitting a Workstream for code review, including pushing all underlying branches and creating a series of linked, dependent pull requests, thus fully realizing the velocity benefits of the stacked diffs workflow.1
### **7.3. AI-Powered Assistance**
The structured nature of Onyx's metadata, particularly the high-level developer intent captured in the Action Log and the semantic grouping of commits within Workstreams, provides a rich substrate for AI integration. Future versions of Onyx could leverage this data to provide:
* **AI-Generated Commit Messages:** Analyzing the diff of a work-in-progress, an AI model could propose a structured, conventional commit message for the onx save command.1
* **Automated Conflict Resolution:** Building upon the rerere concept, an AI could learn from how developers resolve complex conflicts during onx sync and begin to suggest or even automatically apply resolutions for common conflict patterns.1
### **7.4. Ecosystem Integration**
Long-term success depends on deep integration with the broader developer toolkit. A key future direction is the development of dedicated plugins for major IDEs, such as Visual Studio Code and the JetBrains suite. These plugins would provide a first-class graphical user experience that natively understands and visualizes Onyx's high-level abstractions like Workstreams and the Action Log, moving beyond the limitations of existing Git integrations that would only see the underlying hidden branches.2 This will make Onyx's power accessible to a much wider audience and solidify its position as an indispensable tool for high-velocity engineering teams.
#### **Works cited**
1. Designing Onyx: A New VCS
2. Designing Onyx: The Next VCS
3. Git Book \- The Git Object Model, accessed October 8, 2025, [https://shafiul.github.io/gitbook/1\_the\_git\_object\_model.html](https://shafiul.github.io/gitbook/1_the_git_object_model.html)
4. Git Object Model | Online Video Tutorial by thoughtbot, accessed October 8, 2025, [https://thoughtbot.com/upcase/videos/git-object-model](https://thoughtbot.com/upcase/videos/git-object-model)
5. 1.3 Getting Started \- What is Git?, accessed October 8, 2025, [https://git-scm.com/book/en/v2/Getting-Started-What-is-Git%3F](https://git-scm.com/book/en/v2/Getting-Started-What-is-Git%3F)
6. A highly extensible Git implementation in pure Go. \- GitHub, accessed October 8, 2025, [https://github.com/go-git/go-git](https://github.com/go-git/go-git)
7. fsnotify/fsnotify: Cross-platform filesystem notifications for Go. \- GitHub, accessed October 8, 2025, [https://github.com/fsnotify/fsnotify](https://github.com/fsnotify/fsnotify)
8. fsnotify package \- github.com/fsnotify/fsnotify \- Go Packages, accessed October 8, 2025, [https://pkg.go.dev/github.com/fsnotify/fsnotify](https://pkg.go.dev/github.com/fsnotify/fsnotify)
9. object package \- github.com/go-git/go-git/v5/plumbing/object \- Go Packages, accessed October 8, 2025, [https://pkg.go.dev/github.com/go-git/go-git/v5/plumbing/object](https://pkg.go.dev/github.com/go-git/go-git/v5/plumbing/object)
10. libgit2, accessed October 8, 2025, [https://libgit2.org/](https://libgit2.org/)
11. Extending GObjects From Go and Making Them Available to C | tinyzimmer's blog, accessed October 8, 2025, [https://tinyzimmer.github.io/posts/exporting-gobject-from-go/](https://tinyzimmer.github.io/posts/exporting-gobject-from-go/)
12. Consider migrating to libgit2/git2go · fluxcd flux2 · Discussion \#426 \- GitHub, accessed October 8, 2025, [https://github.com/fluxcd/flux2/discussions/426](https://github.com/fluxcd/flux2/discussions/426)
13. What is the essential difference between urfave/cli и spf13/cobra? : r/golang \- Reddit, accessed October 8, 2025, [https://www.reddit.com/r/golang/comments/5sdvoh/what\_is\_the\_essential\_difference\_between/](https://www.reddit.com/r/golang/comments/5sdvoh/what_is_the_essential_difference_between/)
14. Things I can't live without in a new Go project in no particular order: \- https:... | Hacker News, accessed October 8, 2025, [https://news.ycombinator.com/item?id=36047892](https://news.ycombinator.com/item?id=36047892)
15. encoding/json \- Go Packages, accessed October 8, 2025, [https://pkg.go.dev/encoding/json](https://pkg.go.dev/encoding/json)

49
notes/checklist.md Normal file
View File

@ -0,0 +1,49 @@
## Milestone 4: Synchronization and Remote Interaction ✓ COMPLETE
**Completion Date:** October 14, 2025
**Status:** All features implemented and tested
**Development Method:** Dogfooded using Onyx itself
### Rebase Engine ✓
34. **Implement stacked rebase** (`internal/git/rebase.go`) ✓
- Implemented RebaseStack function
- Sequential rebase with conflict handling
- Integration with rerere for automatic conflict resolution
- Support for rebase continuation and abort
35. **Integrate rerere** (`internal/git/rerere.go`) ✓
- Configured rerere cache location (.onx/rerere_cache)
- Enabled rerere for rebase operations
- Implemented conflict detection and recording
- Apply recorded resolutions automatically
36. **Create conflict resolution UI** (`internal/git/conflicts.go`) ✓
- Detect merge conflicts via index stages
- Present clear conflict markers with file paths
- Guide user through resolution process
- Record resolutions for rerere
### Sync and Push Commands ✓
37. **Implement onx sync** (`internal/commands/sync.go`) ✓
- Begin oplog transaction for undo support
- Fetch from remote (origin by default)
- Get workstream commit stack
- Sequential rebase with rerere support
- Handle and present conflicts clearly
- Update workstreams.json with new SHAs
- Finalize oplog transaction
38. **Implement onx push** (`internal/commands/push.go`) ✓
- Get all branches in current workstream
- Push each workstream branch to remote
- Support for force push flag
- Progress reporting for each branch
- Clear summary of pushed branches
39. **Add remote configuration** (`internal/git/remote.go`) ✓
- Read git remote configuration
- Support multiple remotes
- Default to "origin"
- Validate remote existence and URLs

169
notes/future.md Normal file
View File

@ -0,0 +1,169 @@
## Testing Infrastructure
40. **Create test utilities** (`internal/testutil/`)
- `CreateTestRepo() (*Repository, cleanup func())`
- `CreateTestCommit(repo, message string) string`
- `AssertFileContents(t, path, expected string)`
- Mock filesystem for daemon tests
41. **Write unit tests for each component**
- Core: repository_test.go, transaction_test.go
- Storage: oplog_test.go, workstreams_test.go
- Git: objects_test.go, rebase_test.go
- Commands: One test file per command
- Minimum 80% code coverage
42. **Create integration tests** (`test/integration/`)
- Full workflow test (init → new → save → sync → push)
- Conflict resolution scenarios
- Undo/redo sequences
- Daemon snapshot creation
- Workstream switching with changes
43. **Add benchmark tests** (`test/benchmarks/`)
- Oplog append performance
- Snapshot creation speed
- Large repository handling
- Rebase performance with many commits
## Error Handling & Logging
44. **Implement structured logging** (`internal/utils/logger.go`)
- Use structured logging library (zap or logrus)
- Log levels: Debug, Info, Warn, Error
- Log to .onx/logs/onx.log
- Rotate logs daily
45. **Create error types** (`internal/errors/errors.go`)
```go
type OnyxError struct {
Code string
Message string
Cause error
Hint string
}
```
46. **Add recovery mechanisms**
- Panic recovery in daemon
- Graceful degradation on partial failures
- Clear error messages with recovery hints
## Documentation
47. **Write user documentation** (`docs/user-guide.md`)
- Getting started guide
- Command reference with examples
- Workflow tutorials
- Migration guide from Git
48. **Create developer documentation** (`docs/developer-guide.md`)
- Architecture overview
- API documentation
- Contributing guidelines
- Testing procedures
49. **Add inline code documentation**
- Package-level documentation
- Public API documentation
- Complex algorithm explanations
- Generate with `godoc`
## Build & Deployment
50. **Create build scripts** (`scripts/build.sh`)
```bash
#!/bin/bash
# Build for multiple platforms
GOOS=darwin GOARCH=amd64 go build -o bin/onx-darwin-amd64
GOOS=linux GOARCH=amd64 go build -o bin/onx-linux-amd64
GOOS=windows GOARCH=amd64 go build -o bin/onx-windows-amd64.exe
```
51. **Set up CI/CD** (`.github/workflows/ci.yml`)
- Run tests on push
- Check code formatting
- Run linters
- Build binaries
- Upload artifacts
52. **Create installation scripts**
- Homebrew formula for macOS
- .deb package for Ubuntu/Debian
- .rpm package for Fedora/RHEL
- Windows installer (.msi)
53. **Implement version management**
- Embed version in binary
- `onx version` command
- Semantic versioning
- Git tag for releases
## Performance Optimization
54. **Profile critical paths**
- Use pprof for CPU profiling
- Identify bottlenecks in snapshot creation
- Optimize oplog serialization
- Cache frequently accessed data
55. **Implement caching layers**
- Cache Git objects in memory
- Cache workstream metadata
- Implement LRU eviction
- Monitor cache hit rates
## Final Integration & Polish
56. **Implement help system**
- Rich help text for all commands
- Examples for common workflows
- Interactive prompts for missing arguments
- Suggest next commands
57. **Add shell completions**
- Bash completion script
- Zsh completion script
- Fish completion script
- PowerShell completion
58. **Create demo repository**
- Sample project with history
- Multiple workstreams
- Demonstrate all features
- Include in documentation
59. **Perform security audit**
- Review file permissions
- Validate input sanitization
- Check for race conditions
- Audit dependency vulnerabilities
60. **Final testing and bug fixes**
- User acceptance testing
- Performance testing with large repos
- Cross-platform compatibility testing
- Fix all critical and high-priority bugs
## Deployment Checklist
✅ All unit tests passing
✅ Integration tests passing
✅ Documentation complete
✅ Binaries built for all platforms
✅ Installation scripts tested
✅ Demo repository prepared
✅ Security audit complete
✅ Performance benchmarks acceptable
✅ Version tagged in Git
✅ Release notes written
## Success Metrics
- **Functionality**: All Phase 1 commands working as specified
- **Performance**: Snapshot creation < 100ms for typical repos
- **Reliability**: Zero data loss, robust undo/redo
- **Compatibility**: Works with all Git 2.x clients
- **Quality**: >80% test coverage, <5 bugs per KLOC
This implementation plan provides a complete, unambiguous roadmap for building Onyx Phase 1. Each step builds upon the previous ones, ensuring a logical progression from foundation to finished product.

121
test-checklist.md Normal file
View File

@ -0,0 +1,121 @@
# Milestone 2 Integration Test Checklist
## Test Environment Setup
- **Location**: `/home/dubey/projects/onyx-test/ccr-milestone-2-test`
- **Goal**: Verify transparent versioning, daemon, save, and undo functionality
---
## Test Steps & Verification Criteria
### Step 1: Repository Initialization
**Action**: Initialize Onyx repository in test folder
**Expected Result**:
- ✅ `onx init` succeeds without errors
- ✅ `.git/` directory created
- ✅ `.onx/` directory created
- ✅ `.onx/workstreams.json` exists with `{"workstreams":[]}`
- ✅ `.onx/oplog` file exists (empty)
- ✅ Command returns success message
### Step 2: Daemon Startup
**Action**: Start Onyx daemon
**Expected Result**:
- ✅ `onx daemon start` succeeds without errors
- ✅ `onx daemon status` shows daemon is running
- ✅ `.onx/daemon.pid` file created with process ID
- ✅ Daemon process is running in background
- ✅ No daemon startup errors in logs
### Step 3: Create Initial File
**Action**: Create `main.py` with print statement
**Expected Result**:
- ✅ File creation succeeds
- ✅ File exists with correct content: `print("hello world")`
- ✅ Daemon detects file change (check logs if available)
- ✅ `.onx/workspace` file updated (after debounce period)
- ✅ `refs/onyx/workspaces/current` reference exists
### Step 4: Wait for Automatic Snapshot
**Action**: Wait 3 seconds for debouncing and snapshot creation
**Expected Result**:
- ✅ Daemon processes filesystem events
- ✅ Workspace state file updated with new commit SHA
- ✅ Ephemeral commit created in Git repository
### Step 5: Save Command Test
**Action**: Execute `onx save -m "Add hello world program"`
**Expected Result**:
- ✅ Save command succeeds without errors
- ✅ Success message displayed
- ✅ Workstreams.json updated with new commit
- ✅ New branch reference created (`refs/onyx/workstreams/{name}/commit-1`)
- ✅ Oplog entry created for save operation
### Step 6: Modify File
**Action**: Add `print("goodbye")` to `main.py`
**Expected Result**:
- ✅ File modification succeeds
- ✅ New content: both print statements
- ✅ Daemon detects file change
- ✅ Workspace state updated with new ephemeral commit
### Step 7: Wait for Second Snapshot
**Action**: Wait 3 seconds for debouncing
**Expected Result**:
- ✅ Second automatic snapshot created
- ✅ Workspace state updated with new commit SHA
### Step 8: Second Save Command Test
**Action**: Execute `onx save -m "Add goodbye message"`
**Expected Result**:
- ✅ Save command succeeds
- ✅ Workstreams.json shows 2 commits
- ✅ New branch reference created (`refs/onyx/workstreams/{name}/commit-2`)
- ✅ Git history shows 2 commits in workstream
### Step 9: Undo Command Test
**Action**: Execute `onx undo` (should revert last save)
**Expected Result**:
- ✅ Undo command succeeds without errors
- ✅ `main.py` content reverted to previous state (only "hello world")
- ✅ Workstreams.json shows 1 commit (second commit removed)
- ✅ Git state reverted accordingly
- ✅ Undo operation logged to oplog
### Step 10: Final Daemon Cleanup
**Action**: Stop daemon
**Expected Result**:
- ✅ `onx daemon stop` succeeds
- ✅ `onx daemon status` shows daemon not running
- ✅ `.onx/daemon.pid` file removed
- ✅ Daemon process terminated cleanly
---
## Additional Verification Tests
### Workstream Integration
- Verify workstreams.json structure integrity
- Check commit sequence and parent-child relationships
- Validate timestamps and metadata
### Git Compatibility
- Verify standard Git commands work on repository
- Check that commits are visible via `git log`
- Verify branch references are properly created
### Error Handling
- Test daemon behavior when restarted
- Test save command without active workstream
- Test undo on empty oplog
---
## Success Criteria
- All 10 primary steps pass expected results
- Daemons start/stop cleanly
- Automatic snapshots created consistently
- Save and undo operations work as designed
- Repository remains in valid state
- No error messages or corruption

186
test/README.md Normal file
View File

@ -0,0 +1,186 @@
# Onyx Integration Tests
This directory contains automated integration tests for the Onyx version control system.
## Quick Start
Run the full integration test suite:
```bash
make integration
```
This will:
1. Build the `onx` and `onxd` binaries
2. Create an isolated test environment in `/tmp/onyx-repo-test-{TIMESTAMP}`
3. Run all integration tests
4. Clean up automatically
5. Report results with pass/fail status
## What Gets Tested
The integration test (`integration_test.sh`) validates all Milestone 2 functionality:
### Test Coverage (24 assertions)
1. **Repository Initialization** (6 tests)
- `.git` directory created
- `.onx` directory created
- `oplog` file exists
- `workstreams.json` created with correct structure
- `.gitignore` created
- Workstreams uses map structure (not array)
2. **Daemon Management** (3 tests)
- Daemon starts successfully
- PID file created
- Status command reports running state
3. **Automatic Snapshots** (4 tests)
- File changes detected
- Workspace state file updated
- Git ref created (`refs/onyx/workspaces/current`)
- Snapshot commit created
4. **Save Command** (3 tests)
- First commit saved successfully
- Workstreams.json updated
- Branch ref created (`refs/onyx/workstreams/{name}/commit-1`)
5. **Commit Chains** (3 tests)
- Second commit saves successfully
- Parent-child relationship established
- Sequential branch refs created
6. **Undo Command** (3 tests)
- Undo operation executes
- Oplog contains undo entry
- **state_before is non-null** (validates the fix!)
7. **Daemon Cleanup** (2 tests)
- Daemon stops gracefully
- PID file removed
- Status reports not running
## Test Environment
- **Location**: `/tmp/onyx-repo-test-{UNIX_TIMESTAMP}`
- **Isolation**: Each test run creates a fresh directory
- **Cleanup**: Automatic cleanup on completion or interruption
- **Binaries**: Uses `bin/onx` and `bin/onxd` from project root
## Test Output
The script provides color-coded output:
- 🔵 **Blue** - Informational messages
- 🟢 **Green** - Tests that passed
- 🔴 **Red** - Tests that failed
- 🟡 **Yellow** - Section headers
Example output:
```
=====================================
Test 1: Repository Initialization
=====================================
[INFO] Initializing Onyx repository...
[PASS] Directory exists: .git
[PASS] Directory exists: .onx
...
Total Tests: 24
Passed: 24
Failed: 0
========================================
ALL TESTS PASSED! ✓
========================================
```
## Manual Execution
You can run the test script directly:
```bash
./test/integration_test.sh
```
The script will:
- Check for required binaries
- Create test environment
- Run all test suites
- Report detailed results
- Clean up on exit (even if interrupted with Ctrl+C)
## CI/CD Integration
The integration test is designed for automated testing:
- **Exit Code**: Returns 0 on success, 1 on failure
- **Isolated**: No dependencies on external state
- **Deterministic**: Should produce same results on each run
- **Fast**: Completes in ~10 seconds
Example CI usage:
```yaml
# GitHub Actions
- name: Run Integration Tests
run: make integration
```
## Debugging Failed Tests
If tests fail:
1. **Check the test output** - Shows which specific assertion failed
2. **Review the test directory** - Check `/tmp/onyx-repo-test-*` if cleanup failed
3. **Run manually** - Execute `./test/integration_test.sh` for more control
4. **Check logs** - Look for daemon errors in test output
Common issues:
- Daemon not stopping: Check for stale processes with `ps aux | grep onxd`
- Permission errors: Ensure `/tmp` is writable
- Binary not found: Run `make build` first
## Test Architecture
The test script uses:
- **Assertions**: Helper functions for validation
- **Counters**: Track pass/fail statistics
- **Cleanup Trap**: Ensures cleanup even on script interruption
- **Color Output**: Makes results easy to read
Key functions:
- `assert_file_exists()` - Verify file creation
- `assert_file_contains()` - Validate file content
- `assert_ref_exists()` - Check Git references
- `assert_command_success()` - Verify command execution
## Extending Tests
To add new tests:
1. Add a new test section in `integration_test.sh`
2. Use assertion functions for validation
3. Increment test counters appropriately
4. Update this README with new coverage
Example:
```bash
log_section "Test X: New Feature"
log_info "Testing new feature..."
"$ONX_BIN" new-command
assert_file_exists "expected_file"
```
## Requirements
- Go 1.24.2+
- Bash shell
- Write access to `/tmp`
- `make` utility
## Related Documentation
- [INTEGRATION.md](../INTEGRATION.md) - Manual integration testing guide
- [CLAUDE.md](../CLAUDE.md) - Project overview for Claude Code
- [notes/checklist.md](../notes/checklist.md) - Implementation milestones

344
test/integration_test.sh Executable file
View File

@ -0,0 +1,344 @@
#!/bin/bash
# Don't exit on first error - we want to run all tests and report results
set +e
# Onyx Milestone 2 Integration Test
# This script tests all core functionality of transparent versioning and save/undo commands
# Color codes for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Test counters
TESTS_PASSED=0
TESTS_FAILED=0
TESTS_TOTAL=0
# Logging functions
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[PASS]${NC} $1"
((TESTS_PASSED++))
((TESTS_TOTAL++))
}
log_error() {
echo -e "${RED}[FAIL]${NC} $1"
((TESTS_FAILED++))
((TESTS_TOTAL++))
}
log_section() {
echo ""
echo -e "${YELLOW}=====================================${NC}"
echo -e "${YELLOW}$1${NC}"
echo -e "${YELLOW}=====================================${NC}"
}
# Assertion functions
assert_file_exists() {
if [ -f "$1" ]; then
log_success "File exists: $1"
else
log_error "File does not exist: $1"
return 1
fi
}
assert_dir_exists() {
if [ -d "$1" ]; then
log_success "Directory exists: $1"
else
log_error "Directory does not exist: $1"
return 1
fi
}
assert_file_contains() {
if grep -q "$2" "$1" 2>/dev/null; then
log_success "File $1 contains '$2'"
else
log_error "File $1 does not contain '$2'"
return 1
fi
}
assert_command_success() {
if eval "$1" >/dev/null 2>&1; then
log_success "Command succeeded: $1"
else
log_error "Command failed: $1"
return 1
fi
}
assert_ref_exists() {
if git show-ref "$1" >/dev/null 2>&1; then
log_success "Git ref exists: $1"
else
log_error "Git ref does not exist: $1"
return 1
fi
}
assert_ref_not_exists() {
if ! git show-ref "$1" >/dev/null 2>&1; then
log_success "Git ref does not exist (as expected): $1"
else
log_error "Git ref exists (should be deleted): $1"
return 1
fi
}
# Get the absolute path to onx and onxd binaries
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
ONX_BIN="$PROJECT_ROOT/bin/onx"
ONXD_BIN="$PROJECT_ROOT/bin/onxd"
# Verify binaries exist
if [ ! -f "$ONX_BIN" ]; then
echo -e "${RED}Error: onx binary not found at $ONX_BIN${NC}"
echo "Please run 'make build' first"
exit 1
fi
if [ ! -f "$ONXD_BIN" ]; then
echo -e "${RED}Error: onxd binary not found at $ONXD_BIN${NC}"
echo "Please run 'make build' first"
exit 1
fi
# Create test directory in /tmp
TIMESTAMP=$(date +%s)
TEST_DIR="/tmp/onyx-repo-test-$TIMESTAMP"
log_section "Setting up test environment"
log_info "Test directory: $TEST_DIR"
log_info "Onyx binary: $ONX_BIN"
log_info "Daemon binary: $ONXD_BIN"
# Create test directory
mkdir -p "$TEST_DIR"
cd "$TEST_DIR"
# Cleanup function
cleanup() {
log_section "Cleaning up"
cd /tmp
# Stop daemon if running
if [ -f "$TEST_DIR/.onx/daemon.pid" ]; then
log_info "Stopping daemon..."
"$ONX_BIN" daemon stop 2>/dev/null || true
fi
# Remove test directory
if [ -d "$TEST_DIR" ]; then
log_info "Removing test directory: $TEST_DIR"
rm -rf "$TEST_DIR"
fi
}
# Set trap for cleanup
trap cleanup EXIT
# ============================================
# Test 1: Repository Initialization
# ============================================
log_section "Test 1: Repository Initialization"
log_info "Initializing Onyx repository..."
"$ONX_BIN" init
assert_dir_exists ".git"
assert_dir_exists ".onx"
assert_file_exists ".onx/oplog"
assert_file_exists ".onx/workstreams.json"
assert_file_exists ".gitignore"
assert_file_contains ".onx/workstreams.json" '{"workstreams":{}}'
# ============================================
# Test 2: Daemon Startup
# ============================================
log_section "Test 2: Daemon Startup"
log_info "Starting daemon..."
"$ONX_BIN" daemon start
sleep 1
assert_file_exists ".onx/daemon.pid"
assert_command_success "$ONX_BIN daemon status | grep -q 'is running'"
PID=$(cat .onx/daemon.pid)
log_info "Daemon running with PID: $PID"
# ============================================
# Test 3: Automatic Snapshot Creation
# ============================================
log_section "Test 3: Automatic Snapshot Creation"
log_info "Creating test file..."
echo 'print("hello world")' > main.py
log_info "Waiting for automatic snapshot (3 seconds)..."
sleep 3
assert_file_exists ".onx/workspace"
assert_file_contains ".onx/workspace" "current_commit_sha"
assert_ref_exists "refs/onyx/workspaces/current"
SNAPSHOT_SHA=$(git show-ref refs/onyx/workspaces/current | awk '{print $1}')
log_info "Snapshot created: $SNAPSHOT_SHA"
# ============================================
# Test 4: Save Command (requires workstream)
# ============================================
log_section "Test 4: Save Command"
# First, we need to create an initial Git commit for the base branch
log_info "Creating initial Git commit..."
git config user.email "test@example.com"
git config user.name "Test User"
git add main.py
git commit -m "Initial commit" >/dev/null 2>&1
log_info "Creating workstream using onx new..."
"$ONX_BIN" new test-feature
log_info "Saving first commit..."
"$ONX_BIN" save -m "Add hello world program"
assert_file_contains ".onx/workstreams.json" "Add hello world program"
assert_ref_exists "refs/onyx/workstreams/test-feature/commit-1"
COMMIT1_SHA=$(git show-ref refs/onyx/workstreams/test-feature/commit-1 | awk '{print $1}')
log_info "First commit created: $COMMIT1_SHA"
# ============================================
# Test 5: Second Save (test commit chain)
# ============================================
log_section "Test 5: Second Save and Commit Chain"
log_info "Modifying file..."
echo 'print("goodbye")' >> main.py
log_info "Waiting for automatic snapshot..."
sleep 3
log_info "Saving second commit..."
"$ONX_BIN" save -m "Add goodbye message"
assert_file_contains ".onx/workstreams.json" "Add goodbye message"
assert_ref_exists "refs/onyx/workstreams/test-feature/commit-2"
# Verify parent-child relationship in workstreams.json
if grep -q "parent_sha" .onx/workstreams.json; then
log_success "Parent-child relationship established in commits"
((TESTS_PASSED++))
((TESTS_TOTAL++))
else
log_error "No parent_sha found in workstreams.json"
((TESTS_FAILED++))
((TESTS_TOTAL++))
fi
COMMIT2_SHA=$(git show-ref refs/onyx/workstreams/test-feature/commit-2 | awk '{print $1}')
log_info "Second commit created: $COMMIT2_SHA"
# ============================================
# Test 6: Undo Command
# ============================================
log_section "Test 6: Undo Command"
log_info "Checking state before undo..."
log_info "File content: $(cat main.py | wc -l) lines"
log_info "Commits in workstream: $(grep -o "commit-" .onx/workstreams.json | wc -l)"
log_info "Executing undo..."
"$ONX_BIN" undo
# Verify commit-2 ref was removed (Git state reverted)
# Note: workstreams.json may still have the entry, undo only reverts Git state
log_info "Verifying undo operation..."
# Check that oplog has the undo entry
assert_file_contains ".onx/oplog" "undo"
# Verify oplog has state_before (the fix we implemented)
if xxd .onx/oplog | grep -q "state_before"; then
# Check for non-null state_before
if xxd .onx/oplog | grep -A 5 "state_before" | grep -v "state_before\":null" | grep -q "state_before"; then
log_success "Oplog contains non-null state_before (undo fix working)"
((TESTS_PASSED++))
((TESTS_TOTAL++))
else
log_error "Oplog has null state_before"
((TESTS_FAILED++))
((TESTS_TOTAL++))
fi
else
log_error "Oplog missing state_before"
((TESTS_FAILED++))
((TESTS_TOTAL++))
fi
# ============================================
# Test 7: Daemon Stop
# ============================================
log_section "Test 7: Daemon Cleanup"
log_info "Stopping daemon..."
"$ONX_BIN" daemon stop
sleep 1
if [ -f ".onx/daemon.pid" ]; then
log_error "PID file still exists after daemon stop"
((TESTS_FAILED++))
((TESTS_TOTAL++))
else
log_success "PID file removed after daemon stop"
((TESTS_PASSED++))
((TESTS_TOTAL++))
fi
if "$ONX_BIN" daemon status 2>&1 | grep -q "not running"; then
log_success "Daemon status shows not running"
((TESTS_PASSED++))
((TESTS_TOTAL++))
else
log_error "Daemon status does not show not running"
((TESTS_FAILED++))
((TESTS_TOTAL++))
fi
# ============================================
# Final Report
# ============================================
log_section "Integration Test Results"
echo ""
echo -e "${BLUE}Total Tests:${NC} $TESTS_TOTAL"
echo -e "${GREEN}Passed:${NC} $TESTS_PASSED"
echo -e "${RED}Failed:${NC} $TESTS_FAILED"
echo ""
if [ $TESTS_FAILED -eq 0 ]; then
echo -e "${GREEN}========================================${NC}"
echo -e "${GREEN} ALL TESTS PASSED! ✓${NC}"
echo -e "${GREEN}========================================${NC}"
exit 0
else
echo -e "${RED}========================================${NC}"
echo -e "${RED} SOME TESTS FAILED! ✗${NC}"
echo -e "${RED}========================================${NC}"
exit 1
fi