oh-my-customcode 0.1.4 → 0.2.0

package/templates/agents/manager/supplier/refs/guides/python/zen-of-python.md

@@ -1,79 +0,0 @@
-# The Zen of Python (PEP 20)
-
-> Source: https://peps.python.org/pep-0020/
-
-Long time Pythoneer Tim Peters succinctly channels the BDFL's guiding principles for Python's design into 20 aphorisms, only 19 of which have been written down.
-
-```
->>> import this
-```
-
-## The 19 Aphorisms
-
-1. **Beautiful is better than ugly.**
-   - Write elegant, readable code
-
-2. **Explicit is better than implicit.**
-   - Don't hide behavior; make intentions clear
-
-3. **Simple is better than complex.**
-   - Choose straightforward solutions
-
-4. **Complex is better than complicated.**
-   - When complexity is needed, keep it manageable
-
-5. **Flat is better than nested.**
-   - Avoid deep nesting; keep structures flat
-
-6. **Sparse is better than dense.**
-   - Don't pack too much into one line
-
-7. **Readability counts.**
-   - Code is read more often than written
-
-8. **Special cases aren't special enough to break the rules.**
-   - Consistency matters
-
-9. **Although practicality beats purity.**
-   - Be pragmatic when needed
-
-10. **Errors should never pass silently.**
-    - Handle or propagate errors explicitly
-
-11. **Unless explicitly silenced.**
-    - Intentional suppression is acceptable
-
-12. **In the face of ambiguity, refuse the temptation to guess.**
-    - Ask for clarification; don't assume
-
-13. **There should be one-- and preferably only one --obvious way to do it.**
-    - Python favors one canonical approach
-
-14. **Although that way may not be obvious at first unless you're Dutch.**
-    - (A nod to Guido van Rossum)
-
-15. **Now is better than never.**
-    - Don't over-plan; start implementing
-
-16. **Although never is often better than *right* now.**
-    - But don't rush without thought
-
-17. **If the implementation is hard to explain, it's a bad idea.**
-    - Complexity is a warning sign
-
-18. **If the implementation is easy to explain, it may be a good idea.**
-    - Simplicity suggests good design
-
-19. **Namespaces are one honking great idea -- let's do more of those!**
-    - Organize code into clear namespaces
-
-## Application
-
-When writing Python code, ask yourself:
-- Is this beautiful or ugly?
-- Is this explicit or implicit?
-- Is this simple or complex?
-- Is this readable?
-- Could I easily explain this to someone else?
-
-The Zen of Python is not just style guidance—it's a philosophy for writing maintainable, understandable code.

package/templates/agents/manager/supplier/refs/guides/rust/error-handling.md

@@ -1,262 +0,0 @@
-# Rust Error Handling
-
-> Reference for error handling patterns in Rust
-
-## Result Type
-
-```rust
-enum Result<T, E> {
-    Ok(T),
-    Err(E),
-}
-```
-
-### Basic Usage
-
-```rust
-use std::fs::File;
-
-fn main() {
-    let f = File::open("hello.txt");
-
-    let f = match f {
-        Ok(file) => file,
-        Err(error) => panic!("Problem opening file: {:?}", error),
-    };
-}
-```
-
-### Matching Different Errors
-
-```rust
-use std::fs::File;
-use std::io::ErrorKind;
-
-fn main() {
-    let f = File::open("hello.txt");
-
-    let f = match f {
-        Ok(file) => file,
-        Err(error) => match error.kind() {
-            ErrorKind::NotFound => match File::create("hello.txt") {
-                Ok(fc) => fc,
-                Err(e) => panic!("Problem creating file: {:?}", e),
-            },
-            other_error => panic!("Problem opening file: {:?}", other_error),
-        },
-    };
-}
-```
-
-### Shortcuts
-
-```rust
-// unwrap: panics on error
-let f = File::open("hello.txt").unwrap();
-
-// expect: panics with custom message
-let f = File::open("hello.txt").expect("Failed to open hello.txt");
-
-// unwrap_or: provides default value
-let f = File::open("hello.txt").unwrap_or(default_file);
-
-// unwrap_or_else: computes default on error
-let f = File::open("hello.txt").unwrap_or_else(|error| {
-    panic!("Problem opening file: {:?}", error)
-});
-```
-
-## Propagating Errors
-
-### With match
-
-```rust
-use std::fs::File;
-use std::io::{self, Read};
-
-fn read_username() -> Result<String, io::Error> {
-    let f = File::open("hello.txt");
-
-    let mut f = match f {
-        Ok(file) => file,
-        Err(e) => return Err(e),
-    };
-
-    let mut s = String::new();
-
-    match f.read_to_string(&mut s) {
-        Ok(_) => Ok(s),
-        Err(e) => Err(e),
-    }
-}
-```
-
-### With ? Operator
-
-```rust
-use std::fs::File;
-use std::io::{self, Read};
-
-fn read_username() -> Result<String, io::Error> {
-    let mut f = File::open("hello.txt")?;
-    let mut s = String::new();
-    f.read_to_string(&mut s)?;
-    Ok(s)
-}
-
-// Chained version
-fn read_username_chained() -> Result<String, io::Error> {
-    let mut s = String::new();
-    File::open("hello.txt")?.read_to_string(&mut s)?;
-    Ok(s)
-}
-```
-
-## Custom Error Types
-
-### Simple Custom Error
-
-```rust
-use std::fmt;
-
-#[derive(Debug)]
-struct MyError {
-    message: String,
-}
-
-impl fmt::Display for MyError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.message)
-    }
-}
-
-impl std::error::Error for MyError {}
-```
-
-### Error Enum
-
-```rust
-use std::io;
-use std::num::ParseIntError;
-
-#[derive(Debug)]
-enum AppError {
-    Io(io::Error),
-    Parse(ParseIntError),
-    Custom(String),
-}
-
-impl fmt::Display for AppError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            AppError::Io(e) => write!(f, "IO error: {}", e),
-            AppError::Parse(e) => write!(f, "Parse error: {}", e),
-            AppError::Custom(msg) => write!(f, "{}", msg),
-        }
-    }
-}
-
-impl std::error::Error for AppError {}
-
-impl From<io::Error> for AppError {
-    fn from(error: io::Error) -> Self {
-        AppError::Io(error)
-    }
-}
-
-impl From<ParseIntError> for AppError {
-    fn from(error: ParseIntError) -> Self {
-        AppError::Parse(error)
-    }
-}
-```
-
-## Option Type
-
-```rust
-enum Option<T> {
-    Some(T),
-    None,
-}
-```
-
-### Usage
-
-```rust
-fn divide(a: f64, b: f64) -> Option<f64> {
-    if b == 0.0 {
-        None
-    } else {
-        Some(a / b)
-    }
-}
-
-// Pattern matching
-match divide(10.0, 2.0) {
-    Some(result) => println!("Result: {}", result),
-    None => println!("Cannot divide by zero"),
-}
-
-// Combinators
-let result = divide(10.0, 2.0)
-    .map(|x| x * 2.0)
-    .unwrap_or(0.0);
-```
-
-## Panic
-
-### When to Panic
-
-```rust
-// Unrecoverable errors
-panic!("crash and burn");
-
-// Assertion failures
-assert!(x > 0, "x must be positive");
-assert_eq!(a, b, "values must be equal");
-
-// Unreachable code
-unreachable!("this should never happen");
-```
-
-### Panic vs Result
-
-- Use `Result` for recoverable errors
-- Use `panic!` for unrecoverable errors
-- Library code should return `Result`
-- `main` can panic or return `Result`
-
-## Best Practices
-
-```rust
-// 1. Use ? for propagation
-fn process() -> Result<Data, Error> {
-    let input = read_input()?;
-    let parsed = parse(input)?;
-    Ok(transform(parsed))
-}
-
-// 2. Add context with map_err
-let file = File::open(&path)
-    .map_err(|e| format!("Failed to open {}: {}", path, e))?;
-
-// 3. Use anyhow for applications
-use anyhow::{Context, Result};
-
-fn main() -> Result<()> {
-    let config = read_config()
-        .context("Failed to read configuration")?;
-    Ok(())
-}
-
-// 4. Use thiserror for libraries
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum DataError {
-    #[error("Invalid input: {0}")]
-    InvalidInput(String),
-    #[error("IO error")]
-    Io(#[from] std::io::Error),
-}
-```

package/templates/agents/manager/supplier/refs/guides/rust/index.yaml

@@ -1,26 +0,0 @@
-# Rust Guide
-
-metadata:
-  name: rust
-  description: Rust language reference documentation
-
-source:
-  type: external
-  origin: rust-lang.org
-  urls:
-    - https://doc.rust-lang.org/book/
-    - https://rust-lang.github.io/api-guidelines/
-    - https://doc.rust-lang.org/nightly/style-guide/
-  last_fetched: "2026-01-22"
-
-documents:
-  - name: ownership
-    path: ./ownership.md
-    description: Ownership, borrowing, and lifetimes
-
-  - name: error-handling
-    path: ./error-handling.md
-    description: Error handling patterns in Rust
-
-used_by:
-  - rust-expert

package/templates/agents/manager/supplier/refs/guides/rust/ownership.md

@@ -1,180 +0,0 @@
-# Rust Ownership
-
-> Reference for ownership, borrowing, and lifetimes
-
-## Ownership Rules
-
-1. Each value has exactly one owner
-2. When the owner goes out of scope, the value is dropped
-3. Values can be moved or borrowed
-
-## Move Semantics
-
-```rust
-// Move ownership
-let s1 = String::from("hello");
-let s2 = s1; // s1 is moved to s2
-// s1 is no longer valid
-
-// Clone to copy
-let s1 = String::from("hello");
-let s2 = s1.clone(); // s1 is still valid
-
-// Copy types (stack-only data)
-let x = 5;
-let y = x; // x is still valid (i32 implements Copy)
-```
-
-## Borrowing
-
-### Immutable References
-
-```rust
-fn main() {
-    let s1 = String::from("hello");
-    let len = calculate_length(&s1); // borrow s1
-    println!("The length of '{}' is {}.", s1, len);
-}
-
-fn calculate_length(s: &String) -> usize {
-    s.len()
-}
-```
-
-### Mutable References
-
-```rust
-fn main() {
-    let mut s = String::from("hello");
-    change(&mut s);
-}
-
-fn change(some_string: &mut String) {
-    some_string.push_str(", world");
-}
-```
-
-### Borrowing Rules
-
-```rust
-// Rule 1: At any time, either ONE mutable reference
-// OR any number of immutable references
-let mut s = String::from("hello");
-
-let r1 = &s; // OK
-let r2 = &s; // OK
-// let r3 = &mut s; // ERROR: cannot borrow as mutable
-
-let r3 = &mut s; // OK after r1 and r2 are done
-```
-
-## Lifetimes
-
-### Basic Syntax
-
-```rust
-// Lifetime annotation
-fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
-    if x.len() > y.len() {
-        x
-    } else {
-        y
-    }
-}
-```
-
-### Struct Lifetimes
-
-```rust
-struct ImportantExcerpt<'a> {
-    part: &'a str,
-}
-
-impl<'a> ImportantExcerpt<'a> {
-    fn level(&self) -> i32 {
-        3
-    }
-
-    fn announce_and_return_part(&self, announcement: &str) -> &str {
-        println!("Attention please: {}", announcement);
-        self.part
-    }
-}
-```
-
-### Lifetime Elision
-
-```rust
-// These are equivalent:
-fn first_word(s: &str) -> &str { ... }
-fn first_word<'a>(s: &'a str) -> &'a str { ... }
-
-// Elision rules:
-// 1. Each reference parameter gets its own lifetime
-// 2. If exactly one input lifetime, it's assigned to all outputs
-// 3. If &self or &mut self, its lifetime is assigned to outputs
-```
-
-### Static Lifetime
-
-```rust
-// 'static: lives for entire program duration
-let s: &'static str = "I have a static lifetime.";
-
-// All string literals have 'static lifetime
-```
-
-## Common Patterns
-
-### Returning References
-
-```rust
-// Cannot return reference to local variable
-fn dangle() -> &String { // ERROR
-    let s = String::from("hello");
-    &s // s goes out of scope!
-}
-
-// Return owned value instead
-fn no_dangle() -> String {
-    let s = String::from("hello");
-    s
-}
-```
-
-### Struct with References
-
-```rust
-// Struct holding reference must have lifetime
-struct Config<'a> {
-    query: &'a str,
-    filename: &'a str,
-}
-
-// Implementation with lifetime
-impl<'a> Config<'a> {
-    fn new(args: &'a [String]) -> Config<'a> {
-        Config {
-            query: &args[1],
-            filename: &args[2],
-        }
-    }
-}
-```
-
-### Multiple Lifetimes
-
-```rust
-fn longest_with_announcement<'a, 'b>(
-    x: &'a str,
-    y: &'a str,
-    ann: &'b str,
-) -> &'a str {
-    println!("Announcement: {}", ann);
-    if x.len() > y.len() {
-        x
-    } else {
-        y
-    }
-}
-```