anvil-dev-framework 0.1.6 → 0.1.7

package/global/tests/test_git_utils.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""
+Unit tests for git_utils.py
+
+Run with: python3 -m pytest global/tests/test_git_utils.py -v
+Or:       python3 global/tests/test_git_utils.py
+"""
+
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent / "lib"))
+
+from git_utils import (
+    get_current_branch,
+    get_repo_status,
+    get_divergence_status,
+    list_stashes,
+    run_git,
+)
+
+
+class TestRunGit:
+    """Tests for the run_git helper."""
+
+    def test_run_git_returns_tuple(self):
+        code, stdout, stderr = run_git('--version')
+        assert isinstance(code, int)
+        assert isinstance(stdout, str)
+        assert isinstance(stderr, str)
+
+    def test_run_git_version_succeeds(self):
+        code, stdout, _ = run_git('--version')
+        assert code == 0
+        assert 'git version' in stdout
+
+
+class TestGetCurrentBranch:
+    """Tests for get_current_branch()."""
+
+    def test_returns_string_in_git_repo(self):
+        branch = get_current_branch()
+        # Should return a non-empty string when in a git repo
+        assert isinstance(branch, str)
+        assert len(branch) > 0
+
+    def test_returns_expected_format(self):
+        branch = get_current_branch()
+        # Branch names shouldn't have newlines
+        assert '\n' not in branch
+
+
+class TestGetRepoStatus:
+    """Tests for get_repo_status()."""
+
+    def test_returns_dict_with_expected_keys(self):
+        status = get_repo_status()
+        expected_keys = [
+            'has_changes',
+            'has_staged',
+            'has_unstaged',
+            'has_untracked',
+            'changed_files',
+            'untracked_files',
+            'current_branch',
+        ]
+        for key in expected_keys:
+            assert key in status, f"Missing key: {key}"
+
+    def test_has_changes_is_boolean(self):
+        status = get_repo_status()
+        assert isinstance(status['has_changes'], bool)
+
+    def test_changed_files_is_list(self):
+        status = get_repo_status()
+        assert isinstance(status['changed_files'], list)
+
+    def test_current_branch_matches_get_current_branch(self):
+        status = get_repo_status()
+        branch = get_current_branch()
+        assert status['current_branch'] == branch
+
+
+class TestGetDivergenceStatus:
+    """Tests for get_divergence_status()."""
+
+    def test_returns_dict_with_expected_keys(self):
+        div = get_divergence_status()
+        expected_keys = ['ahead', 'behind', 'diverged', 'remote_branch']
+        for key in expected_keys:
+            assert key in div, f"Missing key: {key}"
+
+    def test_ahead_behind_are_integers(self):
+        div = get_divergence_status()
+        assert isinstance(div['ahead'], int)
+        assert isinstance(div['behind'], int)
+
+    def test_diverged_is_boolean(self):
+        div = get_divergence_status()
+        assert isinstance(div['diverged'], bool)
+
+    def test_diverged_logic_is_correct(self):
+        div = get_divergence_status()
+        # diverged should be True only if both ahead > 0 and behind > 0
+        expected = div['ahead'] > 0 and div['behind'] > 0
+        assert div['diverged'] == expected
+
+
+class TestListStashes:
+    """Tests for list_stashes()."""
+
+    def test_returns_list(self):
+        stashes = list_stashes()
+        assert isinstance(stashes, list)
+
+    def test_stash_items_have_expected_keys(self):
+        stashes = list_stashes()
+        if stashes:  # Only test if there are stashes
+            stash = stashes[0]
+            assert 'index' in stash
+            assert 'branch' in stash
+            assert 'message' in stash
+
+
+def run_tests():
+    """Run all tests manually if pytest not available."""
+    test_classes = [
+        TestRunGit,
+        TestGetCurrentBranch,
+        TestGetRepoStatus,
+        TestGetDivergenceStatus,
+        TestListStashes,
+    ]
+    passed = 0
+    failed = 0
+
+    for test_class in test_classes:
+        instance = test_class()
+        for method_name in dir(instance):
+            if method_name.startswith("test_"):
+                try:
+                    getattr(instance, method_name)()
+                    print(f"  ✓ {test_class.__name__}.{method_name}")
+                    passed += 1
+                except AssertionError as e:
+                    print(f"  ✗ {test_class.__name__}.{method_name}: {e}")
+                    failed += 1
+                except Exception as e:
+                    print(f"  ✗ {test_class.__name__}.{method_name}: {type(e).__name__}: {e}")
+                    failed += 1
+
+    print(f"\nResults: {passed} passed, {failed} failed")
+    return failed == 0
+
+
+if __name__ == "__main__":
+    print("Running git_utils tests...\n")
+    success = run_tests()
+    sys.exit(0 if success else 1)

package/global/tests/test_issue_models.py

@@ -267,6 +267,46 @@ class TestIssue:
         )
         assert "[agent-xyz]" in str(issue)
 
+    # Dict-style access tests (ANV-260)
+    def test_getitem_returns_field_value(self):
+        issue = Issue(id="1", identifier="TEST-001", title="Test")
+        assert issue["identifier"] == "TEST-001"
+        assert issue["title"] == "Test"
+        assert issue["status"] == IssueStatus.TODO
+
+    def test_getitem_raises_keyerror_for_unknown_field(self):
+        issue = Issue(id="1", identifier="TEST-001", title="Test")
+        try:
+            _ = issue["nonexistent"]
+            raise AssertionError("Should have raised KeyError")
+        except KeyError as e:
+            assert "nonexistent" in str(e)
+
+    def test_get_returns_field_value(self):
+        issue = Issue(id="1", identifier="TEST-001", title="Test")
+        assert issue.get("identifier") == "TEST-001"
+        assert issue.get("title") == "Test"
+
+    def test_get_returns_default_for_unknown_field(self):
+        issue = Issue(id="1", identifier="TEST-001", title="Test")
+        assert issue.get("nonexistent") is None
+        assert issue.get("nonexistent", "default") == "default"
+
+    def test_dict_style_access_matches_attribute_access(self):
+        issue = Issue(
+            id="1",
+            identifier="TEST-001",
+            title="Test",
+            status=IssueStatus.IN_PROGRESS,
+            priority=Priority.HIGH
+        )
+        # All fields should be accessible both ways
+        assert issue["id"] == issue.id
+        assert issue["identifier"] == issue.identifier
+        assert issue["title"] == issue.title
+        assert issue["status"] == issue.status
+        assert issue["priority"] == issue.priority
+
 
 def run_tests():
     """Run all tests manually if pytest not available."""

package/global/tests/test_linear_provider.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""
+Unit tests for linear_provider.py
+
+Run with: python3 -m pytest global/tests/test_linear_provider.py -v
+Or:       python3 global/tests/test_linear_provider.py
+"""
+
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent / "lib"))
+
+from linear_provider import LinearProvider
+
+
+class TestLinearProviderInit:
+    """Tests for LinearProvider initialization validation (ANV-260)."""
+
+    def test_init_without_team_raises_valueerror(self):
+        """LinearProvider() without team_key or team_id should fail fast."""
+        try:
+            LinearProvider()
+            raise AssertionError("Should have raised ValueError")
+        except ValueError as e:
+            assert "team_key or team_id" in str(e)
+            assert "LinearProvider(team_key='ANV')" in str(e)
+
+    def test_init_with_team_key_succeeds(self):
+        """LinearProvider(team_key='ANV') should work."""
+        lp = LinearProvider(team_key='ANV')
+        assert lp.team_key == 'ANV'
+
+    def test_init_with_team_id_succeeds(self):
+        """LinearProvider(team_id='...') should work."""
+        lp = LinearProvider(team_id='some-uuid-123')
+        assert lp._team_id == 'some-uuid-123'
+
+    def test_init_with_both_succeeds(self):
+        """LinearProvider with both team_key and team_id should work."""
+        lp = LinearProvider(team_key='ANV', team_id='uuid-123')
+        assert lp.team_key == 'ANV'
+        assert lp._team_id == 'uuid-123'
+
+    def test_error_message_is_helpful(self):
+        """Error message should include example usage."""
+        try:
+            LinearProvider()
+        except ValueError as e:
+            error_msg = str(e)
+            # Should mention what's required
+            assert "requires" in error_msg.lower()
+            # Should give an example
+            assert "team_key='ANV'" in error_msg
+
+
+def run_tests():
+    """Run all tests manually if pytest not available."""
+    test_classes = [TestLinearProviderInit]
+    passed = 0
+    failed = 0
+
+    for test_class in test_classes:
+        instance = test_class()
+        for method_name in dir(instance):
+            if method_name.startswith("test_"):
+                try:
+                    getattr(instance, method_name)()
+                    print(f"  ✓ {test_class.__name__}.{method_name}")
+                    passed += 1
+                except AssertionError as e:
+                    print(f"  ✗ {test_class.__name__}.{method_name}: {e}")
+                    failed += 1
+                except Exception as e:
+                    print(f"  ✗ {test_class.__name__}.{method_name}: {type(e).__name__}: {e}")
+                    failed += 1
+
+    print(f"\nResults: {passed} passed, {failed} failed")
+    return failed == 0
+
+
+if __name__ == "__main__":
+    print("Running linear_provider tests...\n")
+    success = run_tests()
+    sys.exit(0 if success else 1)

package/global/tools/anvil-memory/src/__tests__/commands.test.ts

@@ -15,8 +15,9 @@ import { handleObserve, parseObserveArgs } from '../commands/observe';
 import { handleSearch, parseSearchArgs } from '../commands/search';
 import { handleGet, parseGetArgs } from '../commands/get';
 import { handleCheckpoint, parseCheckpointArgs } from '../commands/checkpoint';
+import { handleRalphIteration, parseRalphIterationArgs } from '../commands/ralph-iteration';
 import { AnvilMemoryDb } from '../db';
-import type { Observation, Checkpoint } from '../types';
+import type { Observation, Session, Checkpoint, RalphIteration } from '../types';
 
 // Type definitions for command result data
 interface InitResultData {
@@ -51,6 +52,11 @@ interface CheckpointResultData {
   observation?: Observation;
 }
 
+interface RalphIterationResultData {
+  ralph_iteration?: RalphIteration;
+  observation?: Observation;
+}
+
 // Test database path
 const TEST_DB_DIR = join(tmpdir(), 'anvil-memory-cmd-tests');
 const getTestDbPath = () => join(TEST_DB_DIR, `cmd-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
@@ -629,6 +635,237 @@ describe('checkpoint command', () => {
   });
 });
 
+describe('ralph-iteration command', () => {
+  let testDbPath: string;
+
+  beforeAll(async () => {
+    if (!existsSync(TEST_DB_DIR)) {
+      mkdirSync(TEST_DB_DIR, { recursive: true });
+    }
+    testDbPath = getTestDbPath();
+    await handleInit(['--path', testDbPath]);
+  });
+
+  afterAll(() => {
+    cleanupDb(testDbPath);
+  });
+
+  test('parseRalphIterationArgs parses required options', () => {
+    const opts = parseRalphIterationArgs(['--session', 'ralph-abc123', '--iteration', '5', '--status', 'running']);
+    expect(opts.session).toBe('ralph-abc123');
+    expect(opts.iteration).toBe('5');
+    expect(opts.status).toBe('running');
+  });
+
+  test('parseRalphIterationArgs parses short options', () => {
+    const opts = parseRalphIterationArgs(['-s', 'ralph-xyz', '-i', '10', '-t', 'completed']);
+    expect(opts.session).toBe('ralph-xyz');
+    expect(opts.iteration).toBe('10');
+    expect(opts.status).toBe('completed');
+  });
+
+  test('parseRalphIterationArgs parses optional fields', () => {
+    const opts = parseRalphIterationArgs([
+      '--session', 'ralph-test',
+      '--iteration', '3',
+      '--status', 'checkpointed',
+      '--items-completed', '8',
+      '--items-total', '10',
+      '--checkpoint-id', '42',
+      '--linear', 'ANV-203',
+    ]);
+    expect(opts.itemsCompleted).toBe('8');
+    expect(opts.itemsTotal).toBe('10');
+    expect(opts.checkpointId).toBe('42');
+    expect(opts.linear).toBe('ANV-203');
+  });
+
+  test('handleRalphIteration requires --session', async () => {
+    const result = await handleRalphIteration(['--iteration', '1', '--status', 'running', '--path', testDbPath]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('--session');
+  });
+
+  test('handleRalphIteration requires --iteration', async () => {
+    const result = await handleRalphIteration(['--session', 'ralph-test', '--status', 'running', '--path', testDbPath]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('--iteration');
+  });
+
+  test('handleRalphIteration requires --status', async () => {
+    const result = await handleRalphIteration(['--session', 'ralph-test', '--iteration', '1', '--path', testDbPath]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('--status');
+  });
+
+  test('handleRalphIteration validates status', async () => {
+    const result = await handleRalphIteration([
+      '--session', 'ralph-test',
+      '--iteration', '1',
+      '--status', 'invalid-status',
+      '--path', testDbPath,
+    ]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Invalid status');
+  });
+
+  test('handleRalphIteration validates iteration is numeric', async () => {
+    const result = await handleRalphIteration([
+      '--session', 'ralph-test',
+      '--iteration', 'not-a-number',
+      '--status', 'running',
+      '--path', testDbPath,
+    ]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Invalid iteration');
+  });
+
+  test('handleRalphIteration validates items-completed is numeric', async () => {
+    const result = await handleRalphIteration([
+      '--session', 'ralph-test',
+      '--iteration', '1',
+      '--status', 'running',
+      '--items-completed', 'abc',
+      '--path', testDbPath,
+    ]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Invalid items-completed');
+  });
+
+  test('handleRalphIteration validates items-total is numeric', async () => {
+    const result = await handleRalphIteration([
+      '--session', 'ralph-test',
+      '--iteration', '1',
+      '--status', 'running',
+      '--items-total', 'xyz',
+      '--path', testDbPath,
+    ]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Invalid items-total');
+  });
+
+  test('handleRalphIteration rejects negative iteration', async () => {
+    const result = await handleRalphIteration([
+      '--session', 'ralph-test',
+      '--iteration', '-1',
+      '--status', 'running',
+      '--path', testDbPath,
+    ]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Invalid iteration');
+  });
+
+  test('handleRalphIteration creates ralph iteration record', async () => {
+    const result = await handleRalphIteration([
+      '--session', 'ralph-abc123',
+      '--iteration', '5',
+      '--status', 'running',
+      '--path', testDbPath,
+    ]);
+    const data = result.data as RalphIterationResultData;
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('iteration 5');
+    expect(result.message).toContain('running');
+    expect(data?.ralph_iteration?.session_id).toBe('ralph-abc123');
+    expect(data?.ralph_iteration?.iteration).toBe(5);
+    expect(data?.ralph_iteration?.status).toBe('running');
+  });
+
+  test('handleRalphIteration handles all valid statuses', async () => {
+    const statuses = ['running', 'completed', 'failed', 'checkpointed'] as const;
+
+    for (const status of statuses) {
+      const result = await handleRalphIteration([
+        '--session', `ralph-${status}`,
+        '--iteration', '1',
+        '--status', status,
+        '--path', testDbPath,
+      ]);
+      const data = result.data as RalphIterationResultData;
+      expect(result.success).toBe(true);
+      expect(data?.ralph_iteration?.status).toBe(status);
+    }
+  });
+
+  test('handleRalphIteration stores items-completed and items-total', async () => {
+    const result = await handleRalphIteration([
+      '--session', 'ralph-items-test',
+      '--iteration', '3',
+      '--status', 'completed',
+      '--items-completed', '8',
+      '--items-total', '10',
+      '--path', testDbPath,
+    ]);
+    const data = result.data as RalphIterationResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.ralph_iteration?.items_completed).toBe(8);
+    expect(data?.ralph_iteration?.items_total).toBe(10);
+  });
+
+  test('handleRalphIteration stores checkpoint-id', async () => {
+    // First create a checkpoint to link to
+    const checkpointResult = await handleCheckpoint([
+      '--level', 'L2',
+      '--percent', '90',
+      '--path', testDbPath,
+    ]);
+    const checkpointData = checkpointResult.data as CheckpointResultData;
+    const checkpointId = checkpointData?.checkpoint?.id;
+
+    const result = await handleRalphIteration([
+      '--session', 'ralph-checkpoint-test',
+      '--iteration', '7',
+      '--status', 'checkpointed',
+      '--checkpoint-id', String(checkpointId),
+      '--path', testDbPath,
+    ]);
+    const data = result.data as RalphIterationResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.ralph_iteration?.checkpoint_id).toBe(checkpointId);
+  });
+
+  test('handleRalphIteration creates linked observation with --linear', async () => {
+    const result = await handleRalphIteration([
+      '--session', 'ralph-observation-test',
+      '--iteration', '2',
+      '--status', 'completed',
+      '--items-completed', '5',
+      '--items-total', '5',
+      '--linear', 'ANV-203',
+      '--path', testDbPath,
+    ]);
+    const data = result.data as RalphIterationResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.observation).toBeDefined();
+    expect(data?.observation?.type).toBe('ralph_iteration');
+    expect(data?.observation?.linear_issue).toBe('ANV-203');
+  });
+
+  test('handleRalphIteration fails when database does not exist', async () => {
+    const result = await handleRalphIteration([
+      '--session', 'ralph-test',
+      '--iteration', '1',
+      '--status', 'running',
+      '--path', '/tmp/nonexistent-db-12345.db',
+    ]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Database not found');
+  });
+});
+
 describe('Command error handling', () => {
   test('observe fails when database does not exist', async () => {
     const result = await handleObserve([