zrb 1.21.29__py3-none-any.whl → 2.0.0a4__py3-none-any.whl

zrb/task/llm/default_workflow/python/workflow.md

@@ -1,160 +0,0 @@
----
-description: "A workflow for developing with Python, including project analysis and best practices."
----
-Follow this workflow to deliver clean, maintainable Python code that follows PEP standards and project conventions.
-
-# Core Mandates
-
-- **PEP 8 Compliance:** Follow Python style guide unless project specifies otherwise
-- **Type Safety:** Use type hints when project supports them
-- **Virtual Environments:** Always work within appropriate Python environments
-- **Testing Excellence:** Write comprehensive tests for all functionality
-
-# Tool Usage Guideline
-- Use `read_from_file` to analyze pyproject.toml, requirements.txt, and source code
-- Use `search_files` to find Python patterns and conventions
-- Use `run_shell_command` for Python toolchain operations
-- Use `list_files` to understand project structure
-
-# Step 1: Project Analysis
-
-1. **Dependency Management:** Examine `pyproject.toml`, `requirements.txt`, `setup.py`
-2. **Virtual Environment:** Check for `.venv`, `venv`, or other environment indicators
-3. **Python Version:** Look for `.python-version` or configuration in `pyproject.toml`
-4. **Linting Configuration:** Check for `ruff.toml`, `.flake8`, `.pylintrc`
-5. **Type Checking:** Look for `mypy.ini`, `pyrightconfig.json`
-6. **Testing Framework:** Analyze `tests/` directory, `pytest.ini`, `tox.ini`
-
-# Step 2: Environment Setup
-
-1. **Activate Virtual Environment:**
-   ```bash
-   source .venv/bin/activate  # Linux/Mac
-   .venv\Scripts\activate     # Windows
-   ```
-2. **Create Environment if Missing:**
-   ```bash
-   python -m venv .venv
-   source .venv/bin/activate
-   pip install -e .  # Install project in development mode
-   ```
-3. **Install Dependencies:** Use appropriate package manager (pip, poetry, pdm)
-
-# Step 3: Understand Conventions
-
-1. **Code Style:** Adhere to project's configured linter (ruff, flake8, pylint)
-2. **Type Hints:** Use type hints if project supports them, following existing patterns
-3. **Import Organization:** Follow project's import sorting (isort, ruff)
-4. **Docstring Format:** Match existing format (Google, NumPy, reStructuredText)
-5. **Testing Patterns:** Follow established pytest or unittest patterns
-
-# Step 4: Implementation Planning
-
-1. **Module Structure:** Plan where new code should be placed
-2. **Class Design:** Design classes following Pythonic principles
-3. **Function Design:** Create focused, single-responsibility functions
-4. **Type Annotations:** Plan appropriate type hints for new code
-5. **Testing Strategy:** Plan comprehensive unit and integration tests
-
-# Step 5: Write Code
-
-## Code Quality Standards
-- **Formatting:** Use black, autopep8, or ruff format with project configuration
-- **Linting:** Address all linter warnings (ruff, flake8, pylint)
-- **Type Hints:** Add comprehensive type annotations
-- **Documentation:** Write clear docstrings following project format
-- **Naming:** Use snake_case for variables/functions, PascalCase for classes
-
-## Pythonic Patterns
-- **List Comprehensions:** Use for simple transformations
-- **Context Managers:** Use `with` statements for resource management
-- **Generators:** Use for large datasets or streaming data
-- **Decorators:** Use for cross-cutting concerns
-- **Data Classes:** Use for simple data containers (Python 3.7+)
-
-# Step 6: Testing and Verification
-
-1. **Write Tests:** Create comprehensive tests using project's test framework
-2. **Run Tests:** Execute `pytest` or `python -m unittest`
-3. **Type Checking:** Run `mypy` or `pyright` if configured
-4. **Linting:** Run `ruff check` or project's linter
-5. **Formatting:** Run `black` or project's formatter
-
-# Step 7: Quality Assurance
-
-## Testing Standards
-- **Test Organization:** Follow project's test structure and naming
-- **Fixtures:** Use pytest fixtures for test setup
-- **Mocking:** Use unittest.mock or pytest-mock appropriately
-- **Coverage:** Aim for high test coverage of business logic
-- **Parametrized Tests:** Use for testing multiple input scenarios
-
-## Code Review Checklist
-- [ ] Code follows PEP 8 and project formatting standards
-- [ ] All tests pass with good coverage
-- [ ] Type checking passes (if configured)
-- [ ] No linter warnings
-- [ ] Docstrings are complete and follow project format
-- [ ] Error handling is appropriate
-- [ ] Performance considerations addressed
-
-# Step 8: Package Management
-
-## Dependency Management
-- **pip:** Add to `requirements.txt` and run `pip install -r requirements.txt`
-- **poetry:** Use `poetry add <package>` and `poetry install`
-- **pdm:** Use `pdm add <package>` and `pdm install`
-
-## Common Commands
-- `python -m pytest`: Run tests with pytest
-- `python -m mypy .`: Run type checking with mypy
-- `python -m black .`: Format code with black
-- `python -m ruff check .`: Lint code with ruff
-- `python -m isort .`: Sort imports with isort
-
-# Step 9: Finalize and Deliver
-
-1. **Verify Environment:** Ensure virtual environment is active and dependencies installed
-2. **Run Full Test Suite:** Verify all existing tests still pass
-3. **Static Analysis:** Address any remaining linting or type issues
-4. **Documentation:** Update relevant documentation, docstrings, and README
-5. **Packaging:** Verify package can be built and installed if applicable
-
-# Advanced Python Features
-
-## Modern Python (3.8+)
-- **Walrus Operator:** Use `:=` for assignment in expressions
-- **Structural Pattern Matching:** Use `match`/`case` for complex conditionals
-- **Positional-only Parameters:** Use `/` in function definitions
-- **Dataclasses:** Use for simple data containers
-
-## Performance Optimization
-- **Profiling:** Use cProfile for performance analysis
-- **Caching:** Use functools.lru_cache for expensive function calls
-- **Async/Await:** Use for I/O-bound operations
-- **C Extensions:** Consider for performance-critical code
-
-## Security Considerations
-- **Input Validation:** Validate and sanitize all user inputs
-- **Dependency Security:** Use tools like safety or bandit
-- **Secret Management:** Never hardcode secrets in code
-- **SQL Injection:** Use parameterized queries
-
-# Risk Assessment Guidelines
-
-## Low Risk (Proceed Directly)
-- Adding tests to existing test suites
-- Implementing utility functions following established patterns
-- Creating new modules in established patterns
-
-## Moderate Risk (Explain and Confirm)
-- Modifying core business logic
-- Changing public API interfaces
-- Adding new dependencies
-- Modifying virtual environment or dependency configuration
-
-## High Risk (Refuse and Explain)
-- Breaking backward compatibility
-- Modifying critical security components
-- Changes affecting multiple packages
-- Operations that could break the virtual environment

zrb/task/llm/default_workflow/researching/workflow.md

@@ -1,153 +0,0 @@
----
-description: "A workflow for finding, synthesizing, and analyzing information from various sources."
----
-Follow this workflow to deliver accurate, well-sourced, and synthesized research findings.
-
-# Core Mandates
-
-- **Unyielding Objectivity:** Report facts, identify biases, never inject opinions
-- **Source Hierarchy:** Prioritize authoritative sources over secondary ones
-- **Synthesis Excellence:** Connect information into coherent narratives
-- **Comprehensive Attribution:** Cite all significant claims and data points
-
-# Tool Usage Guideline
-- Use `search_internet` for web research and information gathering
-- Use `open_web_page` to read and analyze web content
-- Use `read_from_file` to analyze provided documents and materials
-- Use `write_to_file` to organize research findings and notes
-
-# Step 1: Deconstruct and Strategize
-
-1. **Isolate Core Questions:** Break down the user's request into specific, answerable questions
-2. **Develop Search Strategy:** Create precise keywords, phrases, and boolean operators
-3. **Identify Source Types:** Determine what types of sources will be most valuable
-4. **Plan Research Approach:** Outline the sequence of research activities
-
-# Step 2: Source Evaluation and Collection
-
-## Source Hierarchy (The 3 Tiers)
-
-### Tier 1 (Ground Truth)
-- Official documentation and specifications
-- Peer-reviewed academic papers
-- Direct source code and technical specifications
-- Primary legal/government documents
-- Statistical data from authoritative sources
-
-### Tier 2 (Reputable Reporting)
-- Established news organizations
-- Respected industry publications
-- Books by credible authors and experts
-- Conference proceedings from reputable organizations
-
-### Tier 3 (Qualified Sources)
-- Blog posts by known experts
-- Conference talks and presentations
-- Forum answers from high-reputation users
-- **Always qualify these sources** (e.g., "According to a senior engineer at Google...")
-
-## Research Execution
-1. **Iterative Searching:** Start with best queries, refine based on results
-2. **Cross-Reference:** Verify information across multiple sources
-3. **Source Vetting:** Quickly assess source credibility and potential biases
-4. **Information Extraction:** Pull out relevant facts, figures, and arguments
-
-# Step 3: Information Synthesis
-
-1. **Identify Patterns:** Look for consensus, debates, or evolving understanding
-2. **Connect Dots:** Find relationships between different pieces of information
-3. **Identify Gaps:** Note where information is missing or contradictory
-4. **Structure Findings:** Organize information logically for presentation
-
-# Step 4: Analysis and Reporting
-
-## Report Structure
-- **Bottom Line Up Front (BLUF):** Start with direct, concise answer to main question
-- **Supporting Evidence:** Present synthesized facts and data supporting the BLUF
-- **Methodology:** Explain research approach and sources used
-- **Nuance and Limitations:** Acknowledge conflicting information or data gaps
-- **Citations:** Provide clear attribution for all significant claims
-
-## Quality Standards
-- **Accuracy:** Verify all facts and figures before inclusion
-- **Clarity:** Present complex information in accessible language
-- **Completeness:** Address all aspects of the original question
-- **Objectivity:** Present balanced view without personal bias
-
-# Step 5: Task-Specific Execution
-
-## Comparative Analysis
-- **Structured Comparison:** Use tables or detailed bullet points
-- **Like-for-Like Basis:** Compare items on equivalent criteria
-- **Implication Analysis:** Explain what differences mean in practice
-- **Objective Assessment:** Avoid subjective preferences
-
-## Technical Research
-- **Documentation Analysis:** Read and interpret technical specifications
-- **Code Examination:** Analyze source code when available
-- **Performance Data:** Include benchmarks and performance characteristics
-- **Compatibility Analysis:** Consider integration and compatibility factors
-
-## Market/Industry Research
-- **Market Size:** Include relevant statistics and growth projections
-- **Competitive Landscape:** Analyze key players and their positions
-- **Trend Analysis:** Identify emerging patterns and future directions
-- **Regulatory Environment:** Consider legal and compliance factors
-
-# Step 6: Verification and Quality Control
-
-1. **Fact Checking:** Verify all critical information across multiple sources
-2. **Bias Assessment:** Identify and acknowledge potential biases in sources
-3. **Logical Consistency:** Ensure conclusions follow logically from evidence
-4. **Citation Verification:** Confirm all citations are accurate and accessible
-
-# Step 7: Final Presentation
-
-## Formatting Standards
-- **Clear Headings:** Use descriptive section headings
-- **Bulleted Lists:** Present information in scannable format
-- **Citations:** Use consistent format (e.g., `[Source Name](URL)`)
-- **Visual Organization:** Use tables, charts, or diagrams when helpful
-
-## Delivery Considerations
-- **Executive Summary:** Include high-level findings for quick understanding
-- **Detailed Analysis:** Provide comprehensive information for deep dives
-- **Actionable Insights:** Highlight implications and recommended actions
-- **Further Reading:** Suggest additional resources for interested readers
-
-# Risk Assessment Guidelines
-
-## Low Risk (Proceed Directly)
-- Researching publicly available information
-- Synthesizing information from authoritative sources
-- Creating comparative analyses of established products
-
-## Moderate Risk (Explain and Confirm)
-- Research involving proprietary or sensitive information
-- Analysis that could have legal or compliance implications
-- Research requiring access to paid or restricted sources
-
-## High Risk (Refuse and Explain)
-- Research involving personal or private information
-- Analysis that could violate terms of service
-- Activities that could be considered hacking or unauthorized access
-
-# Best Practices
-
-## Research Ethics
-- **Respect Copyright:** Properly attribute all sources
-- **Avoid Plagiarism:** Always cite and paraphrase appropriately
-- **Respect Privacy:** Never research personal or private information
-- **Maintain Integrity:** Report findings honestly, even if unexpected
-
-## Efficiency Techniques
-- **Source Tracking:** Keep organized notes of sources and findings
-- **Template Usage:** Use consistent formats for similar research tasks
-- **Tool Proficiency:** Master research tools and techniques
-- **Time Management:** Allocate research time based on question complexity
-
-## Continuous Improvement
-- **Learn from Results:** Analyze what research approaches work best
-- **Update Methods:** Stay current with new research tools and techniques
-- **Expand Knowledge:** Build expertise in relevant domains
-- **Share Insights:** Document successful research strategies

zrb/task/llm/default_workflow/rust/workflow.md

@@ -1,162 +0,0 @@
----
-description: "A workflow for developing with Rust, including project analysis and best practices."
----
-Follow this workflow to deliver safe, efficient, and idiomatic Rust code that respects project conventions.
-
-# Core Mandates
-
-- **Memory Safety:** Leverage Rust's ownership system for safe code
-- **Zero-Cost Abstractions:** Use Rust's features without runtime overhead
-- **Idiomatic Patterns:** Follow established Rust conventions and practices
-- **Tool Integration:** Use Cargo and Rust tooling effectively
-
-# Tool Usage Guideline
-- Use `read_from_file` to analyze Cargo.toml and source code
-- Use `search_files` to find Rust patterns and conventions
-- Use `run_shell_command` for Cargo operations
-- Use `list_files` to understand project structure
-
-# Step 1: Project Analysis
-
-1. **Crate Information:** Examine `Cargo.toml` for dependencies, features, and workspace members
-2. **Toolchain Version:** Check `rust-toolchain.toml` for Rust version and components
-3. **Formatting Configuration:** Look for `rustfmt.toml` or `.rustfmt.toml`
-4. **Linting Configuration:** Check `clippy.toml` or `[lints]` section in `Cargo.toml`
-5. **Module Structure:** Analyze `src/lib.rs`, `src/main.rs`, and `src/bin/` directory
-6. **Workspace Configuration:** Check for workspace members in `Cargo.toml`
-
-# Step 2: Understand Conventions
-
-1. **Formatting:** `cargo fmt` is mandatory for all code
-2. **Linting:** `cargo clippy` must pass with project configuration
-3. **Safety:** Avoid `unsafe` blocks unless absolutely necessary and documented
-4. **Error Handling:** Follow project's error handling strategy (anyhow, thiserror, etc.)
-5. **Testing:** Use established test patterns and organization
-
-# Step 3: Implementation Planning
-
-1. **Type Design:** Plan structs, enums, and traits based on project patterns
-2. **Ownership Strategy:** Consider ownership, borrowing, and lifetime requirements
-3. **Error Handling:** Plan appropriate error types and handling
-4. **Concurrency:** Consider async/await or threading requirements
-5. **Testing Strategy:** Plan comprehensive unit and integration tests
-
-# Step 4: Write Code
-
-## Code Quality Standards
-- **Formatting:** All code must be `cargo fmt` compliant
-- **Linting:** Address all `cargo clippy` warnings
-- **Documentation:** Add rustdoc comments for public APIs
-- **Naming:** Follow Rust naming conventions (snake_case for variables/functions, PascalCase for types)
-- **Safety:** Write safe Rust without unnecessary `unsafe` blocks
-
-## Rust Idioms
-- **Result and Option:** Use for error and optional value handling
-- **Ownership System:** Leverage borrowing and lifetimes correctly
-- **Iterators:** Prefer iterator methods over manual loops
-- **Pattern Matching:** Use `match` and `if let` for control flow
-- **Traits:** Use for polymorphism and code organization
-
-# Step 5: Testing and Verification
-
-1. **Write Tests:** Create comprehensive tests using `#[cfg(test)]` modules
-2. **Run Tests:** Execute `cargo test` to verify functionality
-3. **Format Code:** Run `cargo fmt` to ensure proper formatting
-4. **Lint Code:** Run `cargo clippy -- -D warnings` to catch issues
-5. **Build Verification:** Run `cargo check` for fast compilation checking
-
-# Step 6: Quality Assurance
-
-## Testing Standards
-- **Unit Tests:** Place in `#[cfg(test)]` modules within source files
-- **Integration Tests:** Create in `tests/` directory for crate-level testing
-- **Documentation Tests:** Include examples in rustdoc comments
-- **Property Testing:** Use proptest or quickcheck for comprehensive testing
-
-## Code Review Checklist
-- [ ] Code follows project formatting standards
-- [ ] All tests pass with good coverage
-- [ ] No clippy warnings
-- [ ] Error handling is appropriate and idiomatic
-- [ ] Documentation is complete for public APIs
-- [ ] Performance considerations addressed
-- [ ] Memory safety verified
-
-# Step 7: Cargo Operations
-
-## Development Commands
-- `cargo check`: Fast compilation checking
-- `cargo build`: Build the project
-- `cargo run`: Build and run the project
-- `cargo test`: Run all tests
-- `cargo fmt`: Format code
-- `cargo clippy`: Run linter
-
-## Dependency Management
-- `cargo add <dependency>`: Add a new dependency
-- `cargo update`: Update dependencies
-- `cargo tree`: Show dependency tree
-- `cargo audit`: Check for security vulnerabilities
-
-# Step 8: Advanced Rust Features
-
-## Async/Await
-- **Async Runtime:** Use tokio, async-std, or smol based on project
-- **Futures:** Understand and use futures appropriately
-- **Concurrency:** Use channels and synchronization primitives
-
-## Macros
-- **Declarative Macros:** Use for code generation when appropriate
-- **Procedural Macros:** Use for advanced metaprogramming
-- **Attribute Macros:** Use for annotations and code transformation
-
-## Unsafe Code (Use Sparingly)
-- **FFI:** For foreign function interface
-- **Memory Management:** For low-level memory operations
-- **Performance Optimization:** Only when measurements justify
-- **Documentation:** Must document safety invariants
-
-# Step 9: Finalize and Deliver
-
-1. **Verify Dependencies:** Ensure dependency versions are appropriate
-2. **Run Full Test Suite:** Verify all existing tests still pass
-3. **Security Audit:** Run `cargo audit` for security vulnerabilities
-4. **Performance Testing:** Benchmark critical code paths if applicable
-5. **Documentation:** Generate and verify rustdoc documentation
-
-# Common Patterns
-
-## Error Handling
-- **thiserror:** For defining custom error types
-- **anyhow:** For application-level error handling
-- **Result Propagation:** Use `?` operator appropriately
-
-## Concurrency
-- **std::thread:** For CPU-bound parallelism
-- **tokio::spawn:** For async task spawning
-- **std::sync:** For synchronization primitives
-- **crossbeam:** For advanced concurrency patterns
-
-## Performance
-- **Profiling:** Use perf, flamegraph, or cargo instruments
-- **Benchmarking:** Use criterion for reliable benchmarks
-- **Optimization:** Focus on measured bottlenecks
-
-# Risk Assessment Guidelines
-
-## Low Risk (Proceed Directly)
-- Adding tests to existing test modules
-- Implementing utility functions following established patterns
-- Creating new modules in established patterns
-
-## Moderate Risk (Explain and Confirm)
-- Modifying core data structures
-- Changing public trait implementations
-- Adding new dependencies
-- Using `unsafe` blocks
-
-## High Risk (Refuse and Explain)
-- Breaking memory safety guarantees
-- Modifying critical system components
-- Changes affecting multiple crates in workspace
-- Operations that could introduce security vulnerabilities