anchi-toolkit 1.2.0 → 1.2.2

package/dist/.antigravity/skills/repomix/scripts/tests/test_repomix_batch.py

@@ -0,0 +1,531 @@
+"""
+Tests for repomix_batch.py
+
+Run with: pytest test_repomix_batch.py -v --cov=repomix_batch --cov-report=term-missing
+"""
+
+import os
+import sys
+import json
+import subprocess
+from pathlib import Path
+from unittest.mock import Mock, patch, mock_open, MagicMock
+import pytest
+
+# Add parent directory to path to import the module
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from repomix_batch import (
+    RepomixConfig,
+    EnvLoader,
+    RepomixBatchProcessor,
+    load_repositories_from_file,
+    main
+)
+
+
+class TestRepomixConfig:
+    """Test RepomixConfig dataclass."""
+
+    def test_default_values(self):
+        """Test default configuration values."""
+        config = RepomixConfig()
+        assert config.style == "xml"
+        assert config.output_dir == "repomix-output"
+        assert config.remove_comments is False
+        assert config.include_pattern is None
+        assert config.ignore_pattern is None
+        assert config.no_security_check is False
+        assert config.verbose is False
+
+    def test_custom_values(self):
+        """Test custom configuration values."""
+        config = RepomixConfig(
+            style="markdown",
+            output_dir="custom-output",
+            remove_comments=True,
+            include_pattern="src/**",
+            ignore_pattern="tests/**",
+            no_security_check=True,
+            verbose=True
+        )
+        assert config.style == "markdown"
+        assert config.output_dir == "custom-output"
+        assert config.remove_comments is True
+        assert config.include_pattern == "src/**"
+        assert config.ignore_pattern == "tests/**"
+        assert config.no_security_check is True
+        assert config.verbose is True
+
+
+class TestEnvLoader:
+    """Test EnvLoader class."""
+
+    def test_parse_env_file_basic(self, tmp_path):
+        """Test parsing basic .env file."""
+        env_file = tmp_path / ".env"
+        env_file.write_text("KEY1=value1\nKEY2=value2\n")
+
+        result = EnvLoader._parse_env_file(env_file)
+        assert result == {"KEY1": "value1", "KEY2": "value2"}
+
+    def test_parse_env_file_with_quotes(self, tmp_path):
+        """Test parsing .env file with quoted values."""
+        env_file = tmp_path / ".env"
+        env_file.write_text('KEY1="value with spaces"\nKEY2=\'single quotes\'\n')
+
+        result = EnvLoader._parse_env_file(env_file)
+        assert result == {"KEY1": "value with spaces", "KEY2": "single quotes"}
+
+    def test_parse_env_file_with_comments(self, tmp_path):
+        """Test parsing .env file with comments."""
+        env_file = tmp_path / ".env"
+        env_file.write_text("# Comment\nKEY1=value1\n\n# Another comment\nKEY2=value2\n")
+
+        result = EnvLoader._parse_env_file(env_file)
+        assert result == {"KEY1": "value1", "KEY2": "value2"}
+
+    def test_parse_env_file_with_empty_lines(self, tmp_path):
+        """Test parsing .env file with empty lines."""
+        env_file = tmp_path / ".env"
+        env_file.write_text("KEY1=value1\n\n\nKEY2=value2\n")
+
+        result = EnvLoader._parse_env_file(env_file)
+        assert result == {"KEY1": "value1", "KEY2": "value2"}
+
+    def test_parse_env_file_with_equals_in_value(self, tmp_path):
+        """Test parsing .env file with equals sign in value."""
+        env_file = tmp_path / ".env"
+        env_file.write_text("KEY1=value=with=equals\n")
+
+        result = EnvLoader._parse_env_file(env_file)
+        assert result == {"KEY1": "value=with=equals"}
+
+    def test_parse_env_file_invalid(self, tmp_path):
+        """Test parsing invalid .env file."""
+        env_file = tmp_path / ".env"
+        env_file.write_text("INVALID LINE WITHOUT EQUALS\n")
+
+        result = EnvLoader._parse_env_file(env_file)
+        assert result == {}
+
+    def test_parse_env_file_not_found(self, tmp_path):
+        """Test parsing non-existent .env file."""
+        env_file = tmp_path / "nonexistent.env"
+        result = EnvLoader._parse_env_file(env_file)
+        assert result == {}
+
+    @patch.dict(os.environ, {"PROCESS_VAR": "from_process"}, clear=True)
+    def test_load_env_files_process_env_priority(self):
+        """Test that process environment has highest priority."""
+        with patch.object(Path, 'exists', return_value=False):
+            env_vars = EnvLoader.load_env_files()
+            assert env_vars.get("PROCESS_VAR") == "from_process"
+
+
+class TestRepomixBatchProcessor:
+    """Test RepomixBatchProcessor class."""
+
+    def test_init(self):
+        """Test processor initialization."""
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+        assert processor.config == config
+        assert isinstance(processor.env_vars, dict)
+
+    @patch("subprocess.run")
+    def test_check_repomix_installed_success(self, mock_run):
+        """Test checking if repomix is installed (success)."""
+        mock_run.return_value = Mock(returncode=0)
+
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+        assert processor.check_repomix_installed() is True
+
+        mock_run.assert_called_once()
+        args = mock_run.call_args
+        assert args[0][0] == ["repomix", "--version"]
+
+    @patch("subprocess.run")
+    def test_check_repomix_installed_failure(self, mock_run):
+        """Test checking if repomix is installed (failure)."""
+        mock_run.return_value = Mock(returncode=1)
+
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+        assert processor.check_repomix_installed() is False
+
+    @patch("subprocess.run")
+    def test_check_repomix_installed_not_found(self, mock_run):
+        """Test checking if repomix is not found."""
+        mock_run.side_effect = FileNotFoundError()
+
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+        assert processor.check_repomix_installed() is False
+
+    def test_get_extension(self):
+        """Test getting file extension for style."""
+        assert RepomixBatchProcessor._get_extension("xml") == "xml"
+        assert RepomixBatchProcessor._get_extension("markdown") == "md"
+        assert RepomixBatchProcessor._get_extension("json") == "json"
+        assert RepomixBatchProcessor._get_extension("plain") == "txt"
+        assert RepomixBatchProcessor._get_extension("unknown") == "xml"
+
+    def test_build_command_local(self):
+        """Test building command for local repository."""
+        config = RepomixConfig(style="markdown", remove_comments=True)
+        processor = RepomixBatchProcessor(config)
+
+        output_file = Path("output.md")
+        cmd = processor._build_command("/path/to/repo", output_file, is_remote=False)
+
+        assert cmd[0] == "repomix"
+        assert "/path/to/repo" in cmd
+        assert "--style" in cmd
+        assert "markdown" in cmd
+        assert "--remove-comments" in cmd
+        assert "-o" in cmd
+
+    def test_build_command_remote(self):
+        """Test building command for remote repository."""
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+
+        output_file = Path("output.xml")
+        cmd = processor._build_command("owner/repo", output_file, is_remote=True)
+
+        assert cmd[0] == "npx"
+        assert "repomix" in cmd
+        assert "--remote" in cmd
+        assert "owner/repo" in cmd
+
+    def test_build_command_with_patterns(self):
+        """Test building command with include/ignore patterns."""
+        config = RepomixConfig(
+            include_pattern="src/**/*.ts",
+            ignore_pattern="tests/**"
+        )
+        processor = RepomixBatchProcessor(config)
+
+        output_file = Path("output.xml")
+        cmd = processor._build_command("/path/to/repo", output_file, is_remote=False)
+
+        assert "--include" in cmd
+        assert "src/**/*.ts" in cmd
+        assert "-i" in cmd
+        assert "tests/**" in cmd
+
+    def test_build_command_verbose(self):
+        """Test building command with verbose flag."""
+        config = RepomixConfig(verbose=True)
+        processor = RepomixBatchProcessor(config)
+
+        output_file = Path("output.xml")
+        cmd = processor._build_command("/path/to/repo", output_file, is_remote=False)
+
+        assert "--verbose" in cmd
+
+    def test_build_command_no_security_check(self):
+        """Test building command with security check disabled."""
+        config = RepomixConfig(no_security_check=True)
+        processor = RepomixBatchProcessor(config)
+
+        output_file = Path("output.xml")
+        cmd = processor._build_command("/path/to/repo", output_file, is_remote=False)
+
+        assert "--no-security-check" in cmd
+
+    @patch("subprocess.run")
+    @patch("pathlib.Path.mkdir")
+    def test_process_repository_success(self, mock_mkdir, mock_run):
+        """Test processing repository successfully."""
+        mock_run.return_value = Mock(returncode=0)
+
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+
+        success, message = processor.process_repository("/path/to/repo")
+
+        assert success is True
+        assert "Successfully processed" in message
+        mock_mkdir.assert_called_once()
+        mock_run.assert_called_once()
+
+    @patch("subprocess.run")
+    @patch("pathlib.Path.mkdir")
+    def test_process_repository_failure(self, mock_mkdir, mock_run):
+        """Test processing repository with failure."""
+        mock_run.return_value = Mock(
+            returncode=1,
+            stderr="Error message",
+            stdout=""
+        )
+
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+
+        success, message = processor.process_repository("/path/to/repo")
+
+        assert success is False
+        assert "Failed to process" in message
+        assert "Error message" in message
+
+    @patch("subprocess.run")
+    @patch("pathlib.Path.mkdir")
+    def test_process_repository_timeout(self, mock_mkdir, mock_run):
+        """Test processing repository with timeout."""
+        mock_run.side_effect = subprocess.TimeoutExpired(cmd=[], timeout=300)
+
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+
+        success, message = processor.process_repository("/path/to/repo")
+
+        assert success is False
+        assert "Timeout" in message
+
+    @patch("subprocess.run")
+    @patch("pathlib.Path.mkdir")
+    def test_process_repository_exception(self, mock_mkdir, mock_run):
+        """Test processing repository with exception."""
+        mock_run.side_effect = Exception("Unexpected error")
+
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+
+        success, message = processor.process_repository("/path/to/repo")
+
+        assert success is False
+        assert "Error processing" in message
+        assert "Unexpected error" in message
+
+    @patch("subprocess.run")
+    @patch("pathlib.Path.mkdir")
+    def test_process_repository_with_custom_output(self, mock_mkdir, mock_run):
+        """Test processing repository with custom output name."""
+        mock_run.return_value = Mock(returncode=0)
+
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+
+        success, message = processor.process_repository(
+            "/path/to/repo",
+            output_name="custom-output.xml"
+        )
+
+        assert success is True
+        assert "custom-output.xml" in message
+
+    @patch("subprocess.run")
+    @patch("pathlib.Path.mkdir")
+    def test_process_repository_remote(self, mock_mkdir, mock_run):
+        """Test processing remote repository."""
+        mock_run.return_value = Mock(returncode=0)
+
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+
+        success, message = processor.process_repository(
+            "owner/repo",
+            is_remote=True
+        )
+
+        assert success is True
+        cmd = mock_run.call_args[0][0]
+        assert "npx" in cmd
+        assert "--remote" in cmd
+
+    @patch.object(RepomixBatchProcessor, "process_repository")
+    def test_process_batch_success(self, mock_process):
+        """Test processing batch of repositories."""
+        mock_process.return_value = (True, "Success")
+
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+
+        repositories = [
+            {"path": "/repo1"},
+            {"path": "/repo2", "output": "custom.xml"},
+            {"path": "owner/repo", "remote": True}
+        ]
+
+        results = processor.process_batch(repositories)
+
+        assert len(results["success"]) == 3
+        assert len(results["failed"]) == 0
+        assert mock_process.call_count == 3
+
+    @patch.object(RepomixBatchProcessor, "process_repository")
+    def test_process_batch_with_failures(self, mock_process):
+        """Test processing batch with some failures."""
+        mock_process.side_effect = [
+            (True, "Success 1"),
+            (False, "Failed"),
+            (True, "Success 2")
+        ]
+
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+
+        repositories = [
+            {"path": "/repo1"},
+            {"path": "/repo2"},
+            {"path": "/repo3"}
+        ]
+
+        results = processor.process_batch(repositories)
+
+        assert len(results["success"]) == 2
+        assert len(results["failed"]) == 1
+
+    def test_process_batch_missing_path(self):
+        """Test processing batch with missing path."""
+        config = RepomixConfig()
+        processor = RepomixBatchProcessor(config)
+
+        repositories = [
+            {"output": "custom.xml"}  # Missing 'path'
+        ]
+
+        results = processor.process_batch(repositories)
+
+        assert len(results["success"]) == 0
+        assert len(results["failed"]) == 1
+        assert "Missing 'path'" in results["failed"][0]
+
+
+class TestLoadRepositoriesFromFile:
+    """Test load_repositories_from_file function."""
+
+    def test_load_valid_json(self, tmp_path):
+        """Test loading valid JSON file."""
+        json_file = tmp_path / "repos.json"
+        repos = [
+            {"path": "/repo1"},
+            {"path": "owner/repo", "remote": True}
+        ]
+        json_file.write_text(json.dumps(repos))
+
+        result = load_repositories_from_file(str(json_file))
+        assert result == repos
+
+    def test_load_invalid_json(self, tmp_path):
+        """Test loading invalid JSON file."""
+        json_file = tmp_path / "invalid.json"
+        json_file.write_text("not valid json {")
+
+        result = load_repositories_from_file(str(json_file))
+        assert result == []
+
+    def test_load_non_array_json(self, tmp_path):
+        """Test loading JSON file with non-array content."""
+        json_file = tmp_path / "object.json"
+        json_file.write_text('{"path": "/repo"}')
+
+        result = load_repositories_from_file(str(json_file))
+        assert result == []
+
+    def test_load_nonexistent_file(self):
+        """Test loading non-existent file."""
+        result = load_repositories_from_file("/nonexistent/file.json")
+        assert result == []
+
+
+class TestMain:
+    """Test main function."""
+
+    @patch("sys.argv", ["repomix_batch.py", "/repo1", "/repo2"])
+    @patch.object(RepomixBatchProcessor, "check_repomix_installed", return_value=True)
+    @patch.object(RepomixBatchProcessor, "process_batch")
+    def test_main_with_repos(self, mock_process_batch, mock_check):
+        """Test main function with repository arguments."""
+        mock_process_batch.return_value = {"success": ["msg1", "msg2"], "failed": []}
+
+        result = main()
+
+        assert result == 0
+        mock_check.assert_called_once()
+        mock_process_batch.assert_called_once()
+
+        # Verify repositories passed
+        call_args = mock_process_batch.call_args[0][0]
+        assert len(call_args) == 2
+        assert call_args[0]["path"] == "/repo1"
+        assert call_args[1]["path"] == "/repo2"
+
+    @patch("sys.argv", ["repomix_batch.py", "-f", "repos.json"])
+    @patch.object(RepomixBatchProcessor, "check_repomix_installed", return_value=True)
+    @patch.object(RepomixBatchProcessor, "process_batch")
+    @patch("repomix_batch.load_repositories_from_file")
+    def test_main_with_file(self, mock_load, mock_process_batch, mock_check):
+        """Test main function with file argument."""
+        mock_load.return_value = [{"path": "/repo1"}]
+        mock_process_batch.return_value = {"success": ["msg1"], "failed": []}
+
+        result = main()
+
+        assert result == 0
+        mock_load.assert_called_once_with("repos.json")
+        mock_process_batch.assert_called_once()
+
+    @patch("sys.argv", ["repomix_batch.py"])
+    @patch.object(RepomixBatchProcessor, "check_repomix_installed", return_value=True)
+    def test_main_no_repos(self, mock_check):
+        """Test main function with no repositories."""
+        result = main()
+        assert result == 1
+
+    @patch("sys.argv", ["repomix_batch.py", "/repo1"])
+    @patch.object(RepomixBatchProcessor, "check_repomix_installed", return_value=False)
+    def test_main_repomix_not_installed(self, mock_check):
+        """Test main function when repomix is not installed."""
+        result = main()
+        assert result == 1
+
+    @patch("sys.argv", ["repomix_batch.py", "/repo1"])
+    @patch.object(RepomixBatchProcessor, "check_repomix_installed", return_value=True)
+    @patch.object(RepomixBatchProcessor, "process_batch")
+    def test_main_with_failures(self, mock_process_batch, mock_check):
+        """Test main function with processing failures."""
+        mock_process_batch.return_value = {
+            "success": ["msg1"],
+            "failed": ["error1"]
+        }
+
+        result = main()
+        assert result == 1
+
+    @patch("sys.argv", [
+        "repomix_batch.py",
+        "/repo1",
+        "--style", "markdown",
+        "--remove-comments",
+        "--verbose"
+    ])
+    @patch.object(RepomixBatchProcessor, "check_repomix_installed", return_value=True)
+    @patch.object(RepomixBatchProcessor, "process_batch")
+    def test_main_with_options(self, mock_process_batch, mock_check):
+        """Test main function with various options."""
+        mock_process_batch.return_value = {"success": ["msg1"], "failed": []}
+
+        result = main()
+        assert result == 0
+
+        # Verify config passed to processor
+        # The processor is created inside main, so we check it was called
+        mock_process_batch.assert_called_once()
+
+    @patch("sys.argv", ["repomix_batch.py", "/repo1", "--remote"])
+    @patch.object(RepomixBatchProcessor, "check_repomix_installed", return_value=True)
+    @patch.object(RepomixBatchProcessor, "process_batch")
+    def test_main_with_remote_flag(self, mock_process_batch, mock_check):
+        """Test main function with --remote flag."""
+        mock_process_batch.return_value = {"success": ["msg1"], "failed": []}
+
+        result = main()
+        assert result == 0
+
+        # Verify remote flag is set
+        call_args = mock_process_batch.call_args[0][0]
+        assert call_args[0]["remote"] is True

package/dist/.antigravity/skills/research/SKILL.md

@@ -0,0 +1,168 @@
+---
+name: research
+description: Use when you need to research, analyze, and plan technical solutions that are scalable, secure, and maintainable.
+license: MIT
+---
+
+# Research
+
+## Research Methodology
+
+Always honoring **YAGNI**, **KISS**, and **DRY** principles.
+**Be honest, be brutal, straight to the point, and be concise.**
+
+### Phase 1: Scope Definition
+
+First, you will clearly define the research scope by:
+- Identifying key terms and concepts to investigate
+- Determining the recency requirements (how current must information be)
+- Establishing evaluation criteria for sources
+- Setting boundaries for the research depth
+
+### Phase 2: Systematic Information Gathering
+
+You will employ a multi-source research strategy:
+
+1. **Search Strategy**:
+   - Check if `gemini` bash command is available, if so, execute `gemini -m gemini-2.5-flash -p "...your search prompt..."` bash command (timeout: 10 minutes) and save the output to `./plans/<plan-name>/reports/YYMMDD-<your-research-topic>.md` file (including all citations).
+   - If `gemini` bash command is not available, fallback to `WebSearch` tool.
+   - Run multiple `gemini` bash commands or `WebSearch` tools in parallel to search for relevant information.
+   - Craft precise search queries with relevant keywords
+   - Include terms like "best practices", "2024", "latest", "security", "performance"
+   - Search for official documentation, GitHub repositories, and authoritative blogs
+   - Prioritize results from recognized authorities (official docs, major tech companies, respected developers)
+   - **IMPORTANT:** You are allowed to perform at most **5 researches (max 5 tool calls)**, user might request less than this amount, **strictly respect it**, think carefully based on the task before performing each related research topic.
+
+2. **Deep Content Analysis**:
+   - When you found a potential Github repository URL, use `docs-seeker` skill to find read it.
+   - Focus on official documentation, API references, and technical specifications
+   - Analyze README files from popular GitHub repositories
+   - Review changelog and release notes for version-specific information
+
+3. **Video Content Research**:
+   - Prioritize content from official channels, recognized experts, and major conferences
+   - Focus on practical demonstrations and real-world implementations
+
+4. **Cross-Reference Validation**:
+   - Verify information across multiple independent sources
+   - Check publication dates to ensure currency
+   - Identify consensus vs. controversial approaches
+   - Note any conflicting information or debates in the community
+
+### Phase 3: Analysis and Synthesis
+
+You will analyze gathered information by:
+- Identifying common patterns and best practices
+- Evaluating pros and cons of different approaches
+- Assessing maturity and stability of technologies
+- Recognizing security implications and performance considerations
+- Determining compatibility and integration requirements
+
+### Phase 4: Report Generation
+
+**Notes:** 
+- Research reports are saved in `./plans/<plan-name>/reports/YYMMDD-<your-research-topic>.md`.
+- If you are not given a plan name, ask main agent to provide it and continue the process.
+
+You will create a comprehensive markdown report with the following structure:
+
+```markdown
+# Research Report: [Topic]
+
+## Executive Summary
+[2-3 paragraph overview of key findings and recommendations]
+
+## Research Methodology
+- Sources consulted: [number]
+- Date range of materials: [earliest to most recent]
+- Key search terms used: [list]
+
+## Key Findings
+
+### 1. Technology Overview
+[Comprehensive description of the technology/topic]
+
+### 2. Current State & Trends
+[Latest developments, version information, adoption trends]
+
+### 3. Best Practices
+[Detailed list of recommended practices with explanations]
+
+### 4. Security Considerations
+[Security implications, vulnerabilities, and mitigation strategies]
+
+### 5. Performance Insights
+[Performance characteristics, optimization techniques, benchmarks]
+
+## Comparative Analysis
+[If applicable, comparison of different solutions/approaches]
+
+## Implementation Recommendations
+
+### Quick Start Guide
+[Step-by-step getting started instructions]
+
+### Code Examples
+[Relevant code snippets with explanations]
+
+### Common Pitfalls
+[Mistakes to avoid and their solutions]
+
+## Resources & References
+
+### Official Documentation
+- [Linked list of official docs]
+
+### Recommended Tutorials
+- [Curated list with descriptions]
+
+### Community Resources
+- [Forums, Discord servers, Stack Overflow tags]
+
+### Further Reading
+- [Advanced topics and deep dives]
+
+## Appendices
+
+### A. Glossary
+[Technical terms and definitions]
+
+### B. Version Compatibility Matrix
+[If applicable]
+
+### C. Raw Research Notes
+[Optional: detailed notes from research process]
+```
+
+## Quality Standards
+
+You will ensure all research meets these criteria:
+- **Accuracy**: Information is verified across multiple sources
+- **Currency**: Prioritize information from the last 12 months unless historical context is needed
+- **Completeness**: Cover all aspects requested by the user
+- **Actionability**: Provide practical, implementable recommendations
+- **Clarity**: Use clear language, define technical terms, provide examples
+- **Attribution**: Always cite sources and provide links for verification
+
+## Special Considerations
+
+- When researching security topics, always check for recent CVEs and security advisories
+- For performance-related research, look for benchmarks and real-world case studies
+- When investigating new technologies, assess community adoption and support levels
+- For API documentation, verify endpoint availability and authentication requirements
+- Always note deprecation warnings and migration paths for older technologies
+
+## Output Requirements
+
+Your final report must:
+1. Be saved as a markdown file with a descriptive filename in `./plans/<plan-name>/reports/YYMMDD-<your-research-topic>.md`
+2. Include a timestamp of when the research was conducted
+3. Provide clear section navigation with a table of contents for longer reports
+4. Use code blocks with appropriate syntax highlighting
+5. Include diagrams or architecture descriptions where helpful (in mermaid or ASCII art)
+6. Conclude with specific, actionable next steps
+
+**IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
+**IMPORTANT:** In reports, list any unresolved questions at the end, if any.
+
+**Remember:** You are not just collecting information, but providing strategic technical intelligence that enables informed decision-making. Your research should anticipate follow-up questions and provide comprehensive coverage of the topic while remaining focused and practical.