@regression-io/claude-config 0.14.16

package/templates/frameworks/python-cli/rules/commands.md

@@ -0,0 +1,103 @@
+# CLI Command Patterns
+
+## Command Definition
+```python
+# src/my_cli/commands/init.py
+import typer
+from pathlib import Path
+from rich.console import Console
+
+app = typer.Typer(help="Initialize a new project")
+console = Console()
+
+@app.command()
+def project(
+    name: str = typer.Argument(..., help="Project name"),
+    path: Path = typer.Option(".", "--path", "-p", help="Target directory"),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing"),
+):
+    """Initialize a new project with the given name."""
+    target = path / name
+
+    if target.exists() and not force:
+        console.print(f"[red]Error:[/red] {target} already exists. Use --force to overwrite.")
+        raise typer.Exit(1)
+
+    # Create project structure
+    target.mkdir(parents=True, exist_ok=True)
+    (target / "README.md").write_text(f"# {name}\n")
+
+    console.print(f"[green]✓[/green] Created project at {target}")
+```
+
+## Arguments and Options
+```python
+@app.command()
+def process(
+    # Required argument
+    input_file: Path = typer.Argument(..., help="Input file to process"),
+
+    # Optional argument with default
+    output: Path = typer.Argument("output.txt", help="Output file"),
+
+    # Options
+    verbose: bool = typer.Option(False, "--verbose", "-v"),
+    count: int = typer.Option(10, "--count", "-n", min=1, max=100),
+    format: str = typer.Option("json", "--format", "-f", help="Output format"),
+):
+    ...
+```
+
+## Choice Options
+```python
+from enum import Enum
+
+class OutputFormat(str, Enum):
+    json = "json"
+    yaml = "yaml"
+    text = "text"
+
+@app.command()
+def export(
+    format: OutputFormat = typer.Option(OutputFormat.json, "--format", "-f"),
+):
+    if format == OutputFormat.json:
+        ...
+```
+
+## Interactive Prompts
+```python
+@app.command()
+def configure():
+    name = typer.prompt("Project name")
+    description = typer.prompt("Description", default="")
+    confirm = typer.confirm("Create project?")
+
+    if not confirm:
+        raise typer.Abort()
+
+    # Create project...
+```
+
+## Progress and Output
+```python
+from rich.progress import track
+from rich.table import Table
+
+@app.command()
+def process_files(files: list[Path] = typer.Argument(...)):
+    results = []
+    for file in track(files, description="Processing..."):
+        result = process_file(file)
+        results.append(result)
+
+    # Display results table
+    table = Table(title="Results")
+    table.add_column("File")
+    table.add_column("Status")
+
+    for r in results:
+        table.add_row(r.file, r.status)
+
+    console.print(table)
+```

package/templates/frameworks/python-cli/rules/output.md

@@ -0,0 +1,107 @@
+# CLI Output Best Practices
+
+## Rich Console Output
+```python
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+console = Console()
+
+# Colors and styles
+console.print("[green]Success![/green] Operation completed.")
+console.print("[red]Error:[/red] Something went wrong.")
+console.print("[yellow]Warning:[/yellow] Proceed with caution.")
+console.print("[bold]Important:[/bold] Read this carefully.")
+
+# Panels for grouped info
+console.print(Panel("This is important information", title="Notice"))
+
+# Code highlighting
+code = Syntax(source_code, "python", theme="monokai")
+console.print(code)
+```
+
+## Structured Output
+```python
+from rich.table import Table
+
+def show_results(items: list[Item]):
+    table = Table(title="Results", show_header=True)
+    table.add_column("ID", style="cyan")
+    table.add_column("Name")
+    table.add_column("Status", justify="center")
+
+    for item in items:
+        status_color = "green" if item.active else "red"
+        table.add_row(
+            str(item.id),
+            item.name,
+            f"[{status_color}]{'Active' if item.active else 'Inactive'}[/]"
+        )
+
+    console.print(table)
+```
+
+## Progress Indicators
+```python
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+# Simple progress
+for item in track(items, description="Processing..."):
+    process(item)
+
+# Custom progress
+with Progress(
+    SpinnerColumn(),
+    TextColumn("[progress.description]{task.description}"),
+) as progress:
+    task = progress.add_task("Loading...", total=None)
+    result = long_running_operation()
+    progress.update(task, completed=True)
+```
+
+## JSON/Machine Output
+```python
+import json
+
+@app.command()
+def list_items(
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    items = get_items()
+
+    if json_output:
+        # Machine-readable output
+        print(json.dumps([i.dict() for i in items], indent=2))
+    else:
+        # Human-readable output
+        show_results(items)
+```
+
+## Exit Codes
+```python
+# Success
+raise typer.Exit(0)
+
+# General error
+raise typer.Exit(1)
+
+# User abort
+raise typer.Abort()
+
+# Specific exit codes
+EXIT_SUCCESS = 0
+EXIT_ERROR = 1
+EXIT_USAGE = 2
+EXIT_CONFIG = 3
+```
+
+## Error Messages
+```python
+def handle_error(e: Exception):
+    console.print(f"[red]Error:[/red] {e}")
+    if verbose:
+        console.print_exception()
+    raise typer.Exit(1)
+```

package/templates/frameworks/python-cli/rules/structure.md

@@ -0,0 +1,91 @@
+# Python CLI Project Structure
+
+## Directory Layout
+```
+my-cli/
+├── src/
+│   └── my_cli/
+│       ├── __init__.py
+│       ├── __main__.py        # Entry point
+│       ├── cli.py             # CLI definition
+│       ├── commands/
+│       │   ├── __init__.py
+│       │   ├── init.py
+│       │   └── run.py
+│       ├── config.py
+│       └── utils.py
+├── tests/
+│   └── test_commands.py
+├── pyproject.toml
+└── README.md
+```
+
+## Main Entry Point
+```python
+# src/my_cli/__main__.py
+from .cli import app
+
+if __name__ == "__main__":
+    app()
+```
+
+## CLI Definition (Typer)
+```python
+# src/my_cli/cli.py
+import typer
+from typing import Optional
+
+from .commands import init, run
+
+app = typer.Typer(
+    name="my-cli",
+    help="My CLI tool description",
+    add_completion=False,
+)
+
+# Add subcommands
+app.add_typer(init.app, name="init")
+app.add_typer(run.app, name="run")
+
+@app.callback()
+def main(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
+    config: Optional[str] = typer.Option(None, "--config", "-c", help="Config file"),
+):
+    """My CLI tool - does useful things."""
+    if verbose:
+        # Set up verbose logging
+        pass
+```
+
+## pyproject.toml
+```toml
+[project]
+name = "my-cli"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = [
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+]
+
+[project.scripts]
+my-cli = "my_cli.cli:app"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+]
+```
+
+## Installation
+```bash
+# Development install
+pip install -e ".[dev]"
+
+# Run
+my-cli --help
+my-cli init
+my-cli run --verbose
+```

package/templates/frameworks/python-cli/template.json

@@ -0,0 +1,6 @@
+{
+  "name": "python-cli",
+  "description": "Python CLI application",
+  "includes": ["universal", "languages/python"],
+  "mcpDefaults": ["github", "filesystem"]
+}

package/templates/frameworks/react-js/rules/components.md

@@ -0,0 +1,84 @@
+# React JavaScript Component Rules
+
+## Component Structure
+```javascript
+// Functional components only
+export function UserCard({ user, onEdit, className }) {
+  return (
+    <div className={className}>
+      <h3>{user.name}</h3>
+      {onEdit && <button onClick={() => onEdit(user)}>Edit</button>}
+    </div>
+  );
+}
+
+// PropTypes for runtime validation
+import PropTypes from 'prop-types';
+
+UserCard.propTypes = {
+  user: PropTypes.shape({
+    id: PropTypes.number.isRequired,
+    name: PropTypes.string.isRequired,
+  }).isRequired,
+  onEdit: PropTypes.func,
+  className: PropTypes.string,
+};
+
+UserCard.defaultProps = {
+  className: '',
+};
+```
+
+## File Organization
+```
+src/
+├── components/
+│   ├── ui/              # Generic reusable (Button, Input, Modal)
+│   ├── features/        # Feature-specific (UserCard, OrderList)
+│   └── layout/          # Layout (Header, Sidebar, Footer)
+├── hooks/               # Custom hooks
+├── pages/               # Route pages
+├── services/            # API calls
+└── utils/               # Helper functions
+```
+
+## Naming Conventions
+- Components: `PascalCase` - `UserCard.jsx`
+- Hooks: `useCamelCase` - `useAuth.js`
+- Utils: `camelCase` - `formatDate.js`
+- Files: Match component name
+
+## Props Pattern
+```javascript
+// Destructure props with defaults
+export function Button({
+  variant = 'primary',
+  loading = false,
+  children,
+  ...props
+}) {
+  return (
+    <button disabled={loading} {...props}>
+      {loading ? <Spinner /> : children}
+    </button>
+  );
+}
+
+Button.propTypes = {
+  variant: PropTypes.oneOf(['primary', 'secondary']),
+  loading: PropTypes.bool,
+  children: PropTypes.node.isRequired,
+};
+```
+
+## JSDoc for Type Hints
+```javascript
+/**
+ * @param {Object} props
+ * @param {import('../types').User} props.user
+ * @param {(user: import('../types').User) => void} [props.onEdit]
+ */
+export function UserCard({ user, onEdit }) {
+  // IDE gets type hints from JSDoc
+}
+```

package/templates/frameworks/react-js/rules/hooks.md

@@ -0,0 +1,98 @@
+# React Hooks Rules (JavaScript)
+
+## Rules of Hooks
+- Only call hooks at the top level
+- Only call hooks from React functions
+- Custom hooks must start with `use`
+
+## useState
+```javascript
+// Simple state
+const [count, setCount] = useState(0);
+const [user, setUser] = useState(null);
+
+// Lazy initialization for expensive values
+const [data, setData] = useState(() => computeExpensiveValue());
+
+// Functional updates
+setCount(prev => prev + 1);
+```
+
+## useEffect
+```javascript
+// Fetch data
+useEffect(() => {
+  let cancelled = false;
+
+  fetchUser(userId).then(data => {
+    if (!cancelled) setUser(data);
+  });
+
+  return () => { cancelled = true; };
+}, [userId]);
+
+// Event listener
+useEffect(() => {
+  const handler = (e) => setSize({ width: e.target.innerWidth });
+  window.addEventListener('resize', handler);
+  return () => window.removeEventListener('resize', handler);
+}, []);
+```
+
+## useMemo & useCallback
+```javascript
+// Expensive calculation
+const sortedList = useMemo(
+  () => items.sort((a, b) => a.name.localeCompare(b.name)),
+  [items]
+);
+
+// Stable callback reference
+const handleClick = useCallback(
+  () => { onClick(id); },
+  [onClick, id]
+);
+```
+
+## Custom Hooks
+```javascript
+// Reusable data fetching
+function useFetch(url) {
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    setLoading(true);
+
+    fetch(url)
+      .then(res => res.json())
+      .then(data => {
+        if (!cancelled) {
+          setData(data);
+          setLoading(false);
+        }
+      })
+      .catch(err => {
+        if (!cancelled) {
+          setError(err);
+          setLoading(false);
+        }
+      });
+
+    return () => { cancelled = true; };
+  }, [url]);
+
+  return { data, loading, error };
+}
+
+// Usage
+function UserProfile({ userId }) {
+  const { data: user, loading, error } = useFetch(`/api/users/${userId}`);
+
+  if (loading) return <Spinner />;
+  if (error) return <Error message={error.message} />;
+  return <UserCard user={user} />;
+}
+```

package/templates/frameworks/react-js/template.json

@@ -0,0 +1,6 @@
+{
+  "name": "react-js",
+  "description": "React with JavaScript framework",
+  "includes": ["universal", "languages/javascript"],
+  "mcpDefaults": ["github", "filesystem", "puppeteer"]
+}

package/templates/frameworks/react-ts/rules/components.md

@@ -0,0 +1,72 @@
+# React TypeScript Component Rules
+
+## Component Structure
+```typescript
+// Functional components only (no class components)
+interface UserCardProps {
+  user: User;
+  onEdit?: (user: User) => void;
+  className?: string;
+}
+
+export function UserCard({ user, onEdit, className }: UserCardProps) {
+  return (
+    <div className={className}>
+      <h3>{user.name}</h3>
+      {onEdit && <button onClick={() => onEdit(user)}>Edit</button>}
+    </div>
+  );
+}
+```
+
+## File Organization
+```
+src/
+├── components/
+│   ├── ui/              # Generic reusable (Button, Input, Modal)
+│   ├── features/        # Feature-specific (UserCard, OrderList)
+│   └── layout/          # Layout (Header, Sidebar, Footer)
+├── hooks/               # Custom hooks
+├── pages/               # Route pages
+├── services/            # API calls
+├── types/               # TypeScript types
+└── utils/               # Helper functions
+```
+
+## Naming Conventions
+- Components: `PascalCase` - `UserCard.tsx`
+- Hooks: `useCamelCase` - `useAuth.ts`
+- Utils: `camelCase` - `formatDate.ts`
+- Types: `PascalCase` - `User`, `UserCardProps`
+
+## Props Typing
+```typescript
+// Define props interface
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+  variant?: 'primary' | 'secondary';
+  loading?: boolean;
+  children: React.ReactNode;
+}
+
+// Use children explicitly
+export function Button({ variant = 'primary', loading, children, ...props }: ButtonProps) {
+  return (
+    <button disabled={loading} {...props}>
+      {loading ? <Spinner /> : children}
+    </button>
+  );
+}
+```
+
+## Event Handlers
+```typescript
+// Type event handlers properly
+function handleChange(e: React.ChangeEvent<HTMLInputElement>) {
+  setValue(e.target.value);
+}
+
+function handleSubmit(e: React.FormEvent<HTMLFormElement>) {
+  e.preventDefault();
+  // ...
+}
+```

package/templates/frameworks/react-ts/rules/hooks.md

@@ -0,0 +1,87 @@
+# React Hooks Rules
+
+## Rules of Hooks
+- Only call hooks at the top level (not in loops, conditions, or nested functions)
+- Only call hooks from React functions (components or custom hooks)
+- Custom hooks must start with `use`
+
+## useState
+```typescript
+// Type inference works for primitives
+const [count, setCount] = useState(0);
+
+// Explicit typing for complex types
+const [user, setUser] = useState<User | null>(null);
+
+// Use functional updates for derived state
+setCount(prev => prev + 1);
+```
+
+## useEffect
+```typescript
+// Always specify dependencies
+useEffect(() => {
+  fetchUser(userId).then(setUser);
+}, [userId]);
+
+// Cleanup subscriptions
+useEffect(() => {
+  const subscription = api.subscribe(handleUpdate);
+  return () => subscription.unsubscribe();
+}, []);
+
+// Avoid useEffect for:
+// - Transforming data (use useMemo)
+// - Handling events (use event handlers)
+// - Initializing state (use initializer function)
+```
+
+## useMemo & useCallback
+```typescript
+// useMemo for expensive calculations
+const sortedItems = useMemo(
+  () => items.sort((a, b) => a.name.localeCompare(b.name)),
+  [items]
+);
+
+// useCallback for stable function references
+const handleSubmit = useCallback(
+  (data: FormData) => {
+    submitForm(data);
+  },
+  [submitForm]
+);
+```
+
+## Custom Hooks
+```typescript
+// Extract reusable logic
+function useAsync<T>(asyncFn: () => Promise<T>, deps: unknown[] = []) {
+  const [state, setState] = useState<{
+    data: T | null;
+    loading: boolean;
+    error: Error | null;
+  }>({ data: null, loading: true, error: null });
+
+  useEffect(() => {
+    setState(s => ({ ...s, loading: true }));
+    asyncFn()
+      .then(data => setState({ data, loading: false, error: null }))
+      .catch(error => setState({ data: null, loading: false, error }));
+  }, deps);
+
+  return state;
+}
+
+// Usage
+function UserProfile({ userId }: { userId: string }) {
+  const { data: user, loading, error } = useAsync(
+    () => fetchUser(userId),
+    [userId]
+  );
+
+  if (loading) return <Spinner />;
+  if (error) return <Error message={error.message} />;
+  return <UserCard user={user!} />;
+}
+```