18bc64b36d
Implements the foundational infrastructure for Timmy's self-modification capability:
## New Services
1. **GitSafety** (src/self_coding/git_safety.py)
- Atomic git operations with rollback capability
- Snapshot/restore for safe experimentation
- Feature branch management (timmy/self-edit/{timestamp})
- Merge to main only after tests pass
2. **CodebaseIndexer** (src/self_coding/codebase_indexer.py)
- AST-based parsing of Python source files
- Extracts classes, functions, imports, docstrings
- Builds dependency graph for blast radius analysis
- SQLite storage with hash-based incremental indexing
- get_summary() for LLM context (<4000 tokens)
- get_relevant_files() for task-based file discovery
3. **ModificationJournal** (src/self_coding/modification_journal.py)
- Persistent log of all self-modification attempts
- Tracks outcomes: success, failure, rollback
- find_similar() for learning from past attempts
- Success rate metrics and recent failure tracking
- Supports vector embeddings (Phase 2)
4. **ReflectionService** (src/self_coding/reflection.py)
- LLM-powered analysis of modification attempts
- Generates lessons learned from successes and failures
- Fallback templates when LLM unavailable
- Supports context from similar past attempts
## Test Coverage
- 104 new tests across 7 test files
- 95% code coverage on self_coding module
- Green path tests: full workflow integration
- Red path tests: errors, rollbacks, edge cases
- Safety constraint tests: test coverage requirements, protected files
## Usage
from self_coding import GitSafety, CodebaseIndexer, ModificationJournal
git = GitSafety(repo_path=/path/to/repo)
indexer = CodebaseIndexer(repo_path=/path/to/repo)
journal = ModificationJournal()
Phase 2 will build the Self-Edit MCP Tool that orchestrates these services.
264 lines
13 KiB
Python
264 lines
13 KiB
Python
"""Error path tests for Git Safety Layer.
|
|
|
|
Tests timeout handling, git failures, merge conflicts, and edge cases.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import subprocess
|
|
import tempfile
|
|
from pathlib import Path
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
|
|
from self_coding.git_safety import (
|
|
GitNotRepositoryError,
|
|
GitOperationError,
|
|
GitSafety,
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
class TestGitSafetyErrors:
|
|
"""Git operation error handling."""
|
|
|
|
async def test_invalid_repo_path(self):
|
|
"""Should raise GitNotRepositoryError for non-repo."""
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
with pytest.raises(GitNotRepositoryError):
|
|
GitSafety(repo_path=tmpdir)
|
|
|
|
async def test_git_command_failure(self):
|
|
"""Should raise GitOperationError on git failure."""
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
repo_path = Path(tmpdir)
|
|
subprocess.run(["git", "init"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.name", "Test"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
safety = GitSafety(repo_path=repo_path)
|
|
|
|
# Try to checkout non-existent branch
|
|
with pytest.raises(GitOperationError):
|
|
await safety._run_git("checkout", "nonexistent-branch")
|
|
|
|
async def test_merge_conflict_detection(self):
|
|
"""Should handle merge conflicts gracefully."""
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
repo_path = Path(tmpdir)
|
|
subprocess.run(["git", "init"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.name", "Test"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
# Create initial file
|
|
(repo_path / "file.txt").write_text("original")
|
|
subprocess.run(["git", "add", "."], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "commit", "-m", "Initial"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "branch", "-M", "main"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
safety = GitSafety(repo_path=repo_path)
|
|
|
|
# Create branch A with changes
|
|
await safety.create_branch("branch-a")
|
|
(repo_path / "file.txt").write_text("branch-a changes")
|
|
await safety.commit("Branch A changes")
|
|
|
|
# Go back to main, create branch B with conflicting changes
|
|
await safety._run_git("checkout", "main")
|
|
await safety.create_branch("branch-b")
|
|
(repo_path / "file.txt").write_text("branch-b changes")
|
|
await safety.commit("Branch B changes")
|
|
|
|
# Try to merge branch-a into branch-b (will conflict)
|
|
with pytest.raises(GitOperationError):
|
|
await safety._run_git("merge", "branch-a")
|
|
|
|
async def test_rollback_after_merge(self):
|
|
"""Should be able to rollback even after merge."""
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
repo_path = Path(tmpdir)
|
|
subprocess.run(["git", "init"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.name", "Test"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
safety = GitSafety(repo_path=repo_path)
|
|
|
|
# Initial commit
|
|
(repo_path / "file.txt").write_text("v1")
|
|
subprocess.run(["git", "add", "."], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "commit", "-m", "v1"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
snapshot = await safety.snapshot(run_tests=False)
|
|
|
|
# Make changes and commit
|
|
(repo_path / "file.txt").write_text("v2")
|
|
await safety.commit("v2")
|
|
|
|
# Rollback
|
|
await safety.rollback(snapshot)
|
|
|
|
# Verify
|
|
content = (repo_path / "file.txt").read_text()
|
|
assert content == "v1"
|
|
|
|
async def test_snapshot_with_failing_tests(self):
|
|
"""Snapshot should capture failing test status."""
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
repo_path = Path(tmpdir)
|
|
subprocess.run(["git", "init"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.name", "Test"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
# Need an initial commit for HEAD to exist
|
|
(repo_path / "initial.txt").write_text("initial")
|
|
subprocess.run(["git", "add", "."], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "commit", "-m", "Initial"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
# Create failing test
|
|
(repo_path / "test_fail.py").write_text("def test_fail(): assert False")
|
|
|
|
safety = GitSafety(
|
|
repo_path=repo_path,
|
|
test_command="python -m pytest test_fail.py -v",
|
|
)
|
|
|
|
snapshot = await safety.snapshot(run_tests=True)
|
|
|
|
assert snapshot.test_status is False
|
|
assert "FAILED" in snapshot.test_output or "failed" in snapshot.test_output.lower()
|
|
|
|
async def test_get_diff_between_commits(self):
|
|
"""Should get diff between any two commits."""
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
repo_path = Path(tmpdir)
|
|
subprocess.run(["git", "init"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.name", "Test"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
safety = GitSafety(repo_path=repo_path)
|
|
|
|
# Commit 1
|
|
(repo_path / "file.txt").write_text("version 1")
|
|
subprocess.run(["git", "add", "."], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "commit", "-m", "v1"], cwd=repo_path, check=True, capture_output=True)
|
|
commit1 = await safety.get_current_commit()
|
|
|
|
# Commit 2
|
|
(repo_path / "file.txt").write_text("version 2")
|
|
await safety.commit("v2")
|
|
commit2 = await safety.get_current_commit()
|
|
|
|
# Get diff
|
|
diff = await safety.get_diff(commit1, commit2)
|
|
|
|
assert "version 1" in diff
|
|
assert "version 2" in diff
|
|
|
|
async def test_is_clean_with_untracked_files(self):
|
|
"""is_clean should return False with untracked files (they count as changes)."""
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
repo_path = Path(tmpdir)
|
|
subprocess.run(["git", "init"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.name", "Test"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
# Need an initial commit for HEAD to exist
|
|
(repo_path / "initial.txt").write_text("initial")
|
|
subprocess.run(["git", "add", "."], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "commit", "-m", "Initial"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
safety = GitSafety(repo_path=repo_path)
|
|
|
|
# Verify clean state first
|
|
assert await safety.is_clean() is True
|
|
|
|
# Create untracked file
|
|
(repo_path / "untracked.txt").write_text("untracked")
|
|
|
|
# is_clean returns False when there are untracked files
|
|
# (git status --porcelain shows ?? for untracked)
|
|
assert await safety.is_clean() is False
|
|
|
|
async def test_empty_commit_allowed(self):
|
|
"""Should allow empty commits when requested."""
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
repo_path = Path(tmpdir)
|
|
subprocess.run(["git", "init"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.name", "Test"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
# Initial commit
|
|
(repo_path / "file.txt").write_text("content")
|
|
subprocess.run(["git", "add", "."], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "commit", "-m", "Initial"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
safety = GitSafety(repo_path=repo_path)
|
|
|
|
# Empty commit
|
|
commit_hash = await safety.commit("Empty commit message", allow_empty=True)
|
|
|
|
assert len(commit_hash) == 40
|
|
|
|
async def test_modified_files_detection(self):
|
|
"""Should detect which files were modified."""
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
repo_path = Path(tmpdir)
|
|
subprocess.run(["git", "init"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.name", "Test"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
safety = GitSafety(repo_path=repo_path)
|
|
|
|
# Initial commits
|
|
(repo_path / "file1.txt").write_text("content1")
|
|
(repo_path / "file2.txt").write_text("content2")
|
|
subprocess.run(["git", "add", "."], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "commit", "-m", "Initial"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
base_commit = await safety.get_current_commit()
|
|
|
|
# Modify only file1
|
|
(repo_path / "file1.txt").write_text("modified content")
|
|
await safety.commit("Modify file1")
|
|
|
|
# Get modified files
|
|
modified = await safety.get_modified_files(base_commit)
|
|
|
|
assert "file1.txt" in modified
|
|
assert "file2.txt" not in modified
|
|
|
|
async def test_branch_switching(self):
|
|
"""Should handle switching between branches."""
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
repo_path = Path(tmpdir)
|
|
subprocess.run(["git", "init"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "config", "user.name", "Test"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
# Initial commit on master (default branch name)
|
|
(repo_path / "main.txt").write_text("main branch content")
|
|
subprocess.run(["git", "add", "."], cwd=repo_path, check=True, capture_output=True)
|
|
subprocess.run(["git", "commit", "-m", "Initial"], cwd=repo_path, check=True, capture_output=True)
|
|
# Rename to main for consistency
|
|
subprocess.run(["git", "branch", "-M", "main"], cwd=repo_path, check=True, capture_output=True)
|
|
|
|
safety = GitSafety(repo_path=repo_path, main_branch="main")
|
|
|
|
# Create feature branch
|
|
await safety.create_branch("feature")
|
|
(repo_path / "feature.txt").write_text("feature content")
|
|
await safety.commit("Add feature")
|
|
|
|
# Switch back to main
|
|
await safety._run_git("checkout", "main")
|
|
|
|
# Verify main doesn't have feature.txt
|
|
assert not (repo_path / "feature.txt").exists()
|
|
|
|
# Switch to feature
|
|
await safety._run_git("checkout", "feature")
|
|
|
|
# Verify feature has feature.txt
|
|
assert (repo_path / "feature.txt").exists()
|