wup 0.2.34__tar.gz → 0.2.37__tar.gz

{wup-0.2.34/wup.egg-info → wup-0.2.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wup
-Version: 0.2.34
+Version: 0.2.37
 Summary: WUP (What's Up) - Intelligent file watcher for regression testing in large projects
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0
@@ -31,17 +31,17 @@ Dynamic: license-file
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.34-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$2.68-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-18.7h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.37-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$2.71-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-19.5h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $2.6840 (44 commits)
-- 👤 **Human dev:** ~$1867 (18.7h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $2.7096 (47 commits)
+- 👤 **Human dev:** ~$1947 (19.5h @ $100/h, 30min dedup)
 
-Generated on 2026-05-21 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+Generated on 2026-05-22 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.34-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.37-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 **WUP (What's Up)** - Intelligent file watcher for regression testing in large projects.
 

{wup-0.2.34 → wup-0.2.37}/README.md

@@ -3,17 +3,17 @@
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.34-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$2.68-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-18.7h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.37-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$2.71-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-19.5h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $2.6840 (44 commits)
-- 👤 **Human dev:** ~$1867 (18.7h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $2.7096 (47 commits)
+- 👤 **Human dev:** ~$1947 (19.5h @ $100/h, 30min dedup)
 
-Generated on 2026-05-21 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+Generated on 2026-05-22 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.34-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.37-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 **WUP (What's Up)** - Intelligent file watcher for regression testing in large projects.
 

{wup-0.2.34 → wup-0.2.37}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wup"
-version = "0.2.34"
+version = "0.2.37"
 description = "WUP (What's Up) - Intelligent file watcher for regression testing in large projects"
 readme = "README.md"
 requires-python = ">=3.9"

{wup-0.2.34 → wup-0.2.37}/wup/__init__.py

@@ -7,7 +7,7 @@ WUP monitors file changes and runs intelligent regression tests using a 3-layer
 3. Detail Layer: Full tests with blame reports (only on failure)
 """
 
-__version__ = "0.2.34"
+__version__ = "0.2.37"
 __author__ = "Tom Sapletta"
 
 from .config import load_config, save_config, get_default_config
@@ -21,7 +21,6 @@ from .models.config import (
     TestQLConfig,
     NotifyConfig,
 )
-from .testql_watcher import TestQLWatcher
 
 __all__ = [
     "WupWatcher",
@@ -37,3 +36,11 @@ __all__ = [
     "TestQLConfig",
     "NotifyConfig",
 ]
+
+
+def __getattr__(name: str):
+    """Lazy import for TestQLWatcher to avoid circular dependency."""
+    if name == "TestQLWatcher":
+        from .testql_watcher import TestQLWatcher
+        return TestQLWatcher
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{wup-0.2.34 → wup-0.2.37}/wup/cli.py

@@ -678,5 +678,86 @@ def version():
     console.print(f"[bold cyan]WUP[/bold cyan] version [green]{__version__}[/green]")
 
 
+@app.command("init-cli")
+def init_cli(
+    project: str = typer.Argument(".", help="Path to the project root directory"),
+    output_config: Optional[str] = typer.Option(None, "--output-config", "-c", help="Path for wup.yaml output"),
+    output_scenarios: Optional[str] = typer.Option(None, "--output-scenarios", "-s", help="Path for testql-scenarios directory"),
+    merge: bool = typer.Option(False, "--merge", "-m", help="Merge with existing wup.yaml"),
+    infer_args: bool = typer.Option(True, "--infer-args/--no-infer-args", help="Infer command arguments by inspection"),
+):
+    """
+    Automatically generate wup.yaml configuration and TestQL scenarios for CLI/shell services.
+
+    Scans the project for CLI commands (entry points, setup.py, pyproject.toml) and generates:
+    - wup.yaml with shell service configuration
+    - TestQL scenarios in testql-scenarios/ directory
+
+    Example:
+        wup init-cli ./my-project
+        wup init-cli ./my-project --merge
+    """
+    from pathlib import Path
+    from .cli_scanner import CLIScanner
+    from .cli_config_generator import CLIConfigGenerator
+    from .testql_cli_generator import TestQLCLIGenerator
+
+    project_path = Path(project).resolve()
+
+    if not project_path.exists():
+        console.print(f"[red]Error: Project path '{project}' does not exist[/red]")
+        raise typer.Exit(1)
+
+    console.print(f"[cyan]🔍 Scanning project for CLI commands...[/cyan]")
+    console.print(f"[dim]Project: {project_path}[/dim]\n")
+
+    try:
+        # Scan for CLI commands
+        scanner = CLIScanner(str(project_path))
+        packages = scanner.scan()
+
+        if not packages:
+            console.print("[yellow]⚠ No CLI packages found in project[/yellow]")
+            console.print("[dim]Looking for: setup.py, pyproject.toml, or packages with __main__.py[/dim]")
+            raise typer.Exit(1)
+
+        console.print(f"[green]✓ Found {len(packages)} package(s)[/green]")
+        for pkg in packages:
+            console.print(f"  [cyan]{pkg.name}[/cyan]: {len(pkg.commands)} command(s)")
+            for cmd in pkg.commands:
+                console.print(f"    - {cmd.name} -> {cmd.entry_point}")
+        console.print()
+
+        # Generate wup.yaml
+        config_generator = CLIConfigGenerator(str(project_path))
+        config_output = Path(output_config) if output_config else None
+        config = config_generator.generate(output_path=config_output, merge_existing=merge)
+        config_generator.print_summary(config)
+
+        # Generate TestQL scenarios
+        console.print()
+        console.print(f"[cyan]🧪 Generating TestQL scenarios...[/cyan]")
+        scenarios_output = Path(output_scenarios) if output_scenarios else None
+        testql_generator = TestQLCLIGenerator(str(project_path))
+        generated_files = testql_generator.generate(
+            output_dir=scenarios_output,
+            infer_args=infer_args,
+        )
+        testql_generator.print_summary(generated_files)
+
+        console.print()
+        console.print("[bold green]✅ CLI testing setup complete![/bold green]")
+        console.print()
+        console.print("[dim]Next steps:[/dim]")
+        console.print("  1. Review generated wup.yaml")
+        console.print("  2. Review testql-scenarios/*.testql.toon.yaml")
+        console.print("  3. Run: wup watch . --mode testql")
+        console.print("  4. Or run individual scenario: testql run testql-scenarios/cli-smoke.testql.toon.yaml")
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
 if __name__ == "__main__":
     app()

wup-0.2.37/wup/cli_config_generator.py

@@ -0,0 +1,223 @@
+"""Generator for wup.yaml configuration for CLI/shell services."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import yaml
+
+from .cli_scanner import CLIScanner, CLIPackage, CLICommand
+from .models.config import (
+    ProjectConfig,
+    ServiceConfig,
+    ServiceTestConfig,
+    TestQLConfig,
+    TestStrategyConfig,
+    WatchConfig,
+    WupConfig,
+)
+
+
+class CLIConfigGenerator:
+    """Generate wup.yaml configuration for CLI/shell services."""
+
+    def __init__(self, project_root: str):
+        self.project_root = Path(project_root).resolve()
+        self.scanner = CLIScanner(project_root)
+
+    def generate(
+        self,
+        output_path: Optional[Path] = None,
+        merge_existing: bool = False,
+    ) -> WupConfig:
+        """Generate wup.yaml configuration for CLI services.
+
+        Args:
+            output_path: Path to save the configuration (default: wup.yaml)
+            merge_existing: If True, merge with existing wup.yaml
+
+        Returns:
+            Generated WupConfig object
+        """
+        # Scan for CLI commands
+        packages = self.scanner.scan()
+
+        if not packages:
+            raise ValueError("No CLI packages found in project")
+
+        # Load existing config if merging
+        existing_config = None
+        if merge_existing:
+            from .config import load_config
+            existing_config = load_config(self.project_root)
+
+        # Generate configuration
+        config = self._generate_config(packages, existing_config)
+
+        # Save configuration
+        if output_path is None:
+            output_path = self.project_root / "wup.yaml"
+
+        self._save_config(config, output_path)
+
+        return config
+
+    def _generate_config(
+        self,
+        packages: List[CLIPackage],
+        existing_config: Optional[WupConfig] = None,
+    ) -> WupConfig:
+        """Generate WupConfig from scanned packages."""
+        if existing_config:
+            config = existing_config
+        else:
+            config = WupConfig(
+                project=ProjectConfig(
+                    name=self.project_root.name,
+                    description=f"CLI testing for {self.project_root.name}",
+                ),
+                watch=WatchConfig(
+                    paths=["**/*.py"],
+                    exclude_patterns=["*.md", "tests/**", ".venv/**", "venv/**"],
+                    file_types=[".py"],
+                ),
+                test_strategy=TestStrategyConfig(
+                    quick={"debounce_s": 2, "max_queue": 5, "timeout_s": 30},
+                    detail={"debounce_s": 10, "max_queue": 1, "timeout_s": 60},
+                ),
+                testql=TestQLConfig(
+                    scenario_dir="testql-scenarios",
+                    smoke_scenario="cli-smoke.testql.toon.yaml",
+                    output_format="json",
+                    probe_interval_s=60,
+                ),
+            )
+
+        # Add shell services for each package
+        for package in packages:
+            service = self._create_shell_service(package)
+            
+            # Check if service already exists
+            existing_service = next(
+                (s for s in config.services if s.name == service.name),
+                None,
+            )
+            
+            if existing_service:
+                # Update existing service
+                existing_service.type = service.type
+                existing_service.quick_tests = service.quick_tests
+                existing_service.detail_tests = service.detail_tests
+            else:
+                # Add new service
+                config.services.append(service)
+
+        return config
+
+    def _create_shell_service(self, package: CLIPackage) -> ServiceConfig:
+        """Create a shell service configuration from a CLI package."""
+        # Calculate max_endpoints based on number of commands
+        command_count = len(package.commands)
+        quick_max = min(command_count, 5)
+        detail_max = min(command_count * 2, 20)
+
+        service = ServiceConfig(
+            name=f"{package.name}-shell",
+            type="shell",
+            paths=[],  # Auto-detect
+            root=str(self.project_root),
+            quick_tests=ServiceTestConfig(
+                scope="all",
+                max_endpoints=quick_max,
+            ),
+            detail_tests=ServiceTestConfig(
+                scope="all",
+                max_endpoints=detail_max,
+            ),
+        )
+
+        return service
+
+    def _save_config(self, config: WupConfig, output_path: Path) -> None:
+        """Save configuration to YAML file."""
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Convert to dict
+        config_dict = {
+            "project": {
+                "name": config.project.name,
+                "description": config.project.description,
+            },
+            "watch": {
+                "paths": config.watch.paths,
+                "exclude_patterns": config.watch.exclude_patterns,
+                "file_types": config.watch.file_types,
+            },
+            "services": [
+                {
+                    "name": svc.name,
+                    "type": svc.type,
+                    "paths": svc.paths,
+                    "root": svc.root,
+                    "quick_tests": {
+                        "scope": svc.quick_tests.scope,
+                        "max_endpoints": svc.quick_tests.max_endpoints,
+                    },
+                    "detail_tests": {
+                        "scope": svc.detail_tests.scope,
+                        "max_endpoints": svc.detail_tests.max_endpoints,
+                    },
+                }
+                for svc in config.services
+            ],
+            "test_strategy": {
+                "quick": config.test_strategy.quick,
+                "detail": config.test_strategy.detail,
+            },
+            "testql": {
+                "scenario_dir": config.testql.scenario_dir,
+                "smoke_scenario": config.testql.smoke_scenario,
+                "output_format": config.testql.output_format,
+                "probe_interval_s": config.testql.probe_interval_s,
+            },
+        }
+
+        # Add header
+        header = f"""# WUP Configuration for CLI Testing
+# Generated automatically by wup init-cli
+# Project: {config.project.name}
+
+"""
+
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(header)
+            yaml.dump(config_dict, f, default_flow_style=False, sort_keys=False)
+
+    def print_summary(self, config: WupConfig) -> None:
+        """Print summary of generated configuration."""
+        from rich.console import Console
+        from rich.table import Table
+
+        console = Console()
+
+        console.print("\n[bold green]✓ Generated wup.yaml configuration[/bold green]\n")
+
+        table = Table(title="Shell Services")
+        table.add_column("Service", style="cyan")
+        table.add_column("Type", style="green")
+        table.add_column("Quick Tests", style="yellow")
+        table.add_column("Detail Tests", style="yellow")
+
+        for svc in config.services:
+            if svc.type == "shell":
+                table.add_row(
+                    svc.name,
+                    svc.type,
+                    str(svc.quick_tests.max_endpoints),
+                    str(svc.detail_tests.max_endpoints),
+                )
+
+        console.print(table)
+        console.print(f"\nTestQL scenarios directory: {config.testql.scenario_dir}")
+        console.print(f"Smoke scenario: {config.testql.smoke_scenario}")

wup-0.2.37/wup/cli_scanner.py

@@ -0,0 +1,302 @@
+"""CLI scanner for detecting CLI commands and entry points."""
+
+from __future__ import annotations
+
+import ast
+import json
+import re
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+
+@dataclass
+class CLICommand:
+    """Represents a detected CLI command."""
+    name: str
+    entry_point: str
+    module: str
+    function: str
+    description: str = ""
+    args: List[str] = field(default_factory=list)
+
+
+@dataclass
+class CLIPackage:
+    """Represents a detected CLI package."""
+    name: str
+    commands: List[CLICommand] = field(default_factory=list)
+    entry_points: Dict[str, str] = field(default_factory=dict)
+    setup_files: List[Path] = field(default_factory=list)
+
+
+class CLIScanner:
+    """Scanner for detecting CLI commands in a project."""
+
+    def __init__(self, project_root: str):
+        self.project_root = Path(project_root).resolve()
+        self.packages: List[CLIPackage] = []
+
+    def scan(self) -> List[CLIPackage]:
+        """Scan project for CLI packages and commands."""
+        self.packages = []
+
+        # Scan for setup.py
+        setup_py = self.project_root / "setup.py"
+        if setup_py.exists():
+            self._scan_setup_py(setup_py)
+
+        # Scan for setup.cfg
+        setup_cfg = self.project_root / "setup.cfg"
+        if setup_cfg.exists():
+            self._scan_setup_cfg(setup_cfg)
+
+        # Scan for pyproject.toml
+        pyproject_toml = self.project_root / "pyproject.toml"
+        if pyproject_toml.exists():
+            self._scan_pyproject_toml(pyproject_toml)
+
+        # Scan for package directory with __main__.py
+        self._scan_main_modules()
+
+        return self.packages
+
+    def _scan_setup_py(self, setup_py: Path) -> None:
+        """Scan setup.py for entry points."""
+        try:
+            content = setup_py.read_text(encoding="utf-8")
+            
+            # Extract entry_points from setup() call
+            entry_points_match = re.search(
+                r'entry_points\s*=\s*{([^}]+)}',
+                content,
+                re.DOTALL
+            )
+            if entry_points_match:
+                self._parse_entry_points_dict(entry_points_match.group(1), setup_py)
+        except Exception:
+            pass
+
+    def _scan_setup_cfg(self, setup_cfg: Path) -> None:
+        """Scan setup.cfg for entry points."""
+        try:
+            content = setup_cfg.read_text(encoding="utf-8")
+            
+            # Parse [options.entry_points] section
+            in_entry_points = False
+            current_section = None
+            
+            for line in content.splitlines():
+                line = line.strip()
+                
+                if line.startswith("[options.entry_points"):
+                    in_entry_points = True
+                    continue
+                
+                if in_entry_points:
+                    if line.startswith("[") and not line.startswith("[options.entry_points"):
+                        in_entry_points = False
+                        continue
+                    
+                    if "=" in line and not line.startswith("#"):
+                        entry_point, value = line.split("=", 1)
+                        entry_point = entry_point.strip()
+                        value = value.strip()
+                        
+                        if current_section is None:
+                            current_section = "console_scripts"
+                        
+                        self._add_entry_point(entry_point, value, current_section, setup_cfg)
+        except Exception:
+            pass
+
+    def _scan_pyproject_toml(self, pyproject_toml: Path) -> None:
+        """Scan pyproject.toml for entry points."""
+        try:
+            content = pyproject_toml.read_text(encoding="utf-8")
+            
+            # Parse [project.scripts] section (PEP 621)
+            scripts_match = re.search(
+                r'\[project\.scripts\](.*?)(?=\n\[|\Z)',
+                content,
+                re.DOTALL
+            )
+            if scripts_match:
+                scripts_section = scripts_match.group(1)
+                for line in scripts_section.splitlines():
+                    line = line.strip()
+                    if "=" in line and not line.startswith("#"):
+                        name, value = line.split("=", 1)
+                        name = name.strip()
+                        value = value.strip().strip('"').strip("'")
+                        self._add_entry_point(name, value, "console_scripts", pyproject_toml)
+
+            # Also check for [tool.setuptools.dynamic] dependencies
+            # This handles newer setuptools configurations
+        except Exception:
+            pass
+
+    def _scan_main_modules(self) -> None:
+        """Scan for packages with __main__.py files."""
+        for pkg_dir in self.project_root.iterdir():
+            if pkg_dir.is_dir() and not pkg_dir.name.startswith("_"):
+                main_py = pkg_dir / "__main__.py"
+                if main_py.exists():
+                    # This package can be run as python -m package
+                    self._add_entry_point(
+                        pkg_dir.name,
+                        f"{pkg_dir.name}.__main__:main",
+                        "console_scripts",
+                        main_py
+                    )
+
+    def _parse_entry_points_dict(self, dict_str: str, source: Path) -> None:
+        """Parse entry points dictionary string."""
+        try:
+            # Simple parsing for entry points like:
+            # 'console_scripts': ['cmd1 = module:function', 'cmd2 = module2:function']
+            
+            # Extract console_scripts section
+            console_match = re.search(
+                r'["\']console_scripts["\']\s*:\s*\[([^\]]+)\]',
+                dict_str,
+                re.DOTALL
+            )
+            if console_match:
+                entries = console_match.group(1)
+                for entry in re.findall(r'["\']([^"\']+)["\']\s*=\s*["\']([^"\']+)["\']', entries):
+                    name, value = entry
+                    self._add_entry_point(name, value, "console_scripts", source)
+        except Exception:
+            pass
+
+    def _add_entry_point(self, name: str, value: str, section: str, source: Path) -> None:
+        """Add an entry point to the packages list."""
+        if section != "console_scripts":
+            return
+
+        # Parse module:function
+        if ":" in value:
+            module, function = value.rsplit(":", 1)
+        else:
+            module = value
+            function = "main"
+
+        # Find or create package
+        package_name = self.project_root.name
+        package = next((p for p in self.packages if p.name == package_name), None)
+        
+        if package is None:
+            package = CLIPackage(name=package_name)
+            package.setup_files.append(source)
+            self.packages.append(package)
+
+        # Add command
+        command = CLICommand(
+            name=name,
+            entry_point=value,
+            module=module,
+            function=function
+        )
+        package.commands.append(command)
+        package.entry_points[name] = value
+
+    def infer_command_args(self, command: CLICommand) -> List[str]:
+        """Infer command arguments by inspecting the module."""
+        try:
+            module_path = self._find_module_path(command.module)
+            if not module_path:
+                return []
+
+            # Try to parse the module and extract function arguments
+            content = module_path.read_text(encoding="utf-8")
+            tree = ast.parse(content)
+
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef) and node.name == command.function:
+                    args = []
+                    for arg in node.args.args:
+                        args.append(arg.arg)
+                    return args
+
+            # Try running --help to get arguments
+            return self._get_help_arguments(command.name)
+        except Exception:
+            return []
+
+    def _find_module_path(self, module: str) -> Optional[Path]:
+        """Find the Python file for a given module."""
+        parts = module.replace(".", "/")
+        
+        # Try .py file
+        py_path = self.project_root / f"{parts}.py"
+        if py_path.exists():
+            return py_path
+
+        # Try __init__.py in package
+        init_path = self.project_root / parts / "__init__.py"
+        if init_path.exists():
+            return init_path
+
+        # Try in package directories
+        for pkg_dir in self.project_root.iterdir():
+            if pkg_dir.is_dir() and not pkg_dir.name.startswith("_"):
+                py_path = pkg_dir / f"{parts}.py"
+                if py_path.exists():
+                    return py_path
+
+                init_path = pkg_dir / parts / "__init__.py"
+                if init_path.exists():
+                    return init_path
+
+        return None
+
+    def _get_help_arguments(self, command_name: str) -> List[str]:
+        """Get command arguments by running --help."""
+        try:
+            result = subprocess.run(
+                [command_name, "--help"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                cwd=str(self.project_root)
+            )
+            
+            if result.returncode == 0:
+                # Parse help output for arguments
+                args = []
+                for line in result.stdout.splitlines():
+                    line = line.strip()
+                    if line.startswith("--") or line.startswith("-"):
+                        # Extract argument name
+                        arg_match = re.match(r'^(-{1,2}[\w-]+)', line)
+                        if arg_match:
+                            args.append(arg_match.group(1))
+                return args
+        except Exception:
+            pass
+
+        return []
+
+    def to_dict(self) -> Dict:
+        """Convert scan results to dictionary."""
+        return {
+            "packages": [
+                {
+                    "name": pkg.name,
+                    "commands": [
+                        {
+                            "name": cmd.name,
+                            "entry_point": cmd.entry_point,
+                            "module": cmd.module,
+                            "function": cmd.function,
+                            "args": cmd.args,
+                        }
+                        for cmd in pkg.commands
+                    ],
+                    "entry_points": pkg.entry_points,
+                }
+                for pkg in self.packages
+            ]
+        }

{wup-0.2.34 → wup-0.2.37}/wup/planfile_reporter.py

@@ -6,9 +6,11 @@ import hashlib
 import json
 import re
 import subprocess
+import time
 from pathlib import Path
 from typing import Any, Optional
 
+import yaml
 from rich.console import Console
 
 from .models.config import PlanfileConfig
@@ -85,6 +87,9 @@ class PlanfileReporter:
         self._save_dedupe(remaining)
 
     def _create_ticket(self, *, name: str, description: str, track_file: str = "") -> Optional[tuple[str, str]]:
+        if not self._wait_for_planfile_store_ready():
+            return None
+
         cmd = [
             self.config.command,
             "ticket",
@@ -123,9 +128,41 @@ class PlanfileReporter:
             self.console.print(f"[yellow]planfile ticket creation failed: {detail}[/yellow]")
             return None
 
+        if not self._wait_for_planfile_store_ready(timeout_s=10.0):
+            self.console.print("[yellow]planfile ticket created, but sprint YAML did not become readable[/yellow]")
+            return None
+
         ticket_id = self._parse_ticket_id(stdout) or self._parse_ticket_id(stderr) or "unknown"
         return ticket_id, stdout
 
+    def _wait_for_planfile_store_ready(self, timeout_s: float = 30.0) -> bool:
+        """Wait until the current sprint YAML is readable and not mid-write."""
+        sprint_path = self.project_root / ".planfile" / "sprints" / f"{self.config.sprint}.yaml"
+        if not sprint_path.exists():
+            return True
+
+        deadline = time.time() + timeout_s
+        last_signature: tuple[int, int] | None = None
+        while time.time() < deadline:
+            try:
+                stat = sprint_path.stat()
+                signature = (stat.st_size, stat.st_mtime_ns)
+                yaml.safe_load(sprint_path.read_text(encoding="utf-8")) or {}
+            except (OSError, yaml.YAMLError):
+                time.sleep(0.25)
+                last_signature = None
+                continue
+
+            if signature == last_signature:
+                return True
+            last_signature = signature
+            time.sleep(0.25)
+
+        self.console.print(
+            f"[yellow]planfile ticket creation skipped: {sprint_path} is not stable/readable[/yellow]"
+        )
+        return False
+
     def _load_dedupe(self) -> dict[str, dict[str, Any]]:
         if not self.dedupe_path.exists():
             return {}

wup-0.2.37/wup/testql_cli_generator.py

@@ -0,0 +1,215 @@
+"""Generator for TestQL scenarios for CLI testing."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from .cli_scanner import CLIScanner, CLIPackage, CLICommand
+
+
+class TestQLCLIGenerator:
+    """Generate TestQL scenarios for CLI command testing."""
+
+    def __init__(self, project_root: str):
+        self.project_root = Path(project_root).resolve()
+        self.scanner = CLIScanner(project_root)
+
+    def generate(
+        self,
+        output_dir: Optional[Path] = None,
+        infer_args: bool = True,
+    ) -> List[Path]:
+        """Generate TestQL scenarios for CLI commands.
+
+        Args:
+            output_dir: Directory to save scenarios (default: testql-scenarios/)
+            infer_args: If True, infer command arguments by inspection
+
+        Returns:
+            List of generated scenario file paths
+        """
+        # Scan for CLI commands
+        packages = self.scanner.scan()
+
+        if not packages:
+            raise ValueError("No CLI packages found in project")
+
+        # Set output directory
+        if output_dir is None:
+            output_dir = self.project_root / "testql-scenarios"
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        generated_files = []
+
+        # Generate smoke test scenario
+        smoke_file = self._generate_smoke_scenario(packages, output_dir)
+        generated_files.append(smoke_file)
+
+        # Generate individual command scenarios
+        for package in packages:
+            for command in package.commands:
+                if infer_args:
+                    command.args = self.scanner.infer_command_args(command)
+
+                command_file = self._generate_command_scenario(
+                    package, command, output_dir
+                )
+                generated_files.append(command_file)
+
+        return generated_files
+
+    def _generate_smoke_scenario(
+        self, packages: List[CLIPackage], output_dir: Path
+    ) -> Path:
+        """Generate smoke test scenario for all commands."""
+        output_path = output_dir / "cli-smoke.testql.toon.yaml"
+
+        lines = [
+            "# SCENARIO: CLI Smoke Tests",
+            "# TYPE: cli",
+            "# GENERATED: true",
+            "",
+            "CONFIG[2]{key, value}:",
+            f"  cli_command, {packages[0].commands[0].name if packages and packages[0].commands else 'python -m'}",
+            "  timeout_ms, 15000",
+            "",
+        ]
+
+        # Add basic tests for each command
+        for package in packages:
+            for command in package.commands:
+                lines.extend([
+                    "",
+                    f"# Test: {command.name} --help",
+                    f'SHELL "{command.name} --help" 5000',
+                    "ASSERT_EXIT_CODE 0",
+                    "ASSERT_STDOUT_CONTAINS \"usage\"",
+                ])
+
+                lines.extend([
+                    "",
+                    f"# Test: {command.name} --version",
+                    f'SHELL "{command.name} --version" 5000',
+                    "ASSERT_EXIT_CODE 0",
+                ])
+
+        output_path.write_text("\n".join(lines), encoding="utf-8")
+        return output_path
+
+    def _generate_command_scenario(
+        self, package: CLIPackage, command: CLICommand, output_dir: Path
+    ) -> Path:
+        """Generate detailed test scenario for a single command."""
+        safe_name = command.name.replace("-", "_").replace(" ", "_")
+        output_path = output_dir / f"cli-{safe_name}.testql.toon.yaml"
+
+        lines = [
+            f"# SCENARIO: {command.name} Command Tests",
+            "# TYPE: cli",
+            "# GENERATED: true",
+            "",
+            "CONFIG[2]{key, value}:",
+            f"  cli_command, {command.name}",
+            "  timeout_ms, 30000",
+            "",
+            f"# Test 1: {command.name} --help",
+            f'SHELL "{command.name} --help" 5000',
+            "ASSERT_EXIT_CODE 0",
+            "ASSERT_STDOUT_CONTAINS \"usage\"",
+            "",
+            f"# Test 2: {command.name} --version",
+            f'SHELL "{command.name} --version" 5000',
+            "ASSERT_EXIT_CODE 0",
+            "",
+        ]
+
+        # Add tests for inferred arguments
+        if command.args:
+            lines.extend([
+                f"# Test 3: {command.name} with arguments",
+            ])
+            
+            # Test with first few arguments
+            for arg in command.args[:3]:
+                if arg.startswith("-"):
+                    lines.extend([
+                        f'SHELL "{command.name} {arg}" 10000',
+                        "ASSERT_EXIT_CODE 0",
+                    ])
+
+        # Add test for invalid flag (should fail)
+        lines.extend([
+            "",
+            f"# Test: {command.name} with invalid flag (should fail)",
+            f'SHELL "{command.name} --invalid-flag-xyz123" 5000',
+            "ASSERT_EXIT_CODE != 0",
+        ])
+
+        output_path.write_text("\n".join(lines), encoding="utf-8")
+        return output_path
+
+    def generate_custom_scenario(
+        self,
+        commands: List[str],
+        scenario_name: str = "custom-cli",
+        output_dir: Optional[Path] = None,
+    ) -> Path:
+        """Generate custom TestQL scenario for specific commands.
+
+        Args:
+            commands: List of command strings to test
+            scenario_name: Name for the scenario file
+            output_dir: Directory to save scenario
+
+        Returns:
+            Path to generated scenario file
+        """
+        if output_dir is None:
+            output_dir = self.project_root / "testql-scenarios"
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+        output_path = output_dir / f"{scenario_name}.testql.toon.yaml"
+
+        lines = [
+            f"# SCENARIO: {scenario_name}",
+            "# TYPE: cli",
+            "# GENERATED: true",
+            "",
+            "CONFIG[2]{key, value}:",
+            "  cli_command, custom",
+            "  timeout_ms, 30000",
+            "",
+        ]
+
+        for i, cmd in enumerate(commands, 1):
+            lines.extend([
+                "",
+                f"# Test {i}: {cmd}",
+                f'SHELL "{cmd}" 15000',
+                "ASSERT_EXIT_CODE 0",
+            ])
+
+        output_path.write_text("\n".join(lines), encoding="utf-8")
+        return output_path
+
+    def print_summary(self, generated_files: List[Path]) -> None:
+        """Print summary of generated scenarios."""
+        from rich.console import Console
+        from rich.table import Table
+
+        console = Console()
+
+        console.print("\n[bold green]✓ Generated TestQL scenarios[/bold green]\n")
+
+        table = Table(title="Generated Scenarios")
+        table.add_column("File", style="cyan")
+        table.add_column("Type", style="green")
+
+        for file_path in generated_files:
+            file_type = "Smoke" if "smoke" in file_path.name else "Command"
+            table.add_row(file_path.name, file_type)
+
+        console.print(table)
+        console.print(f"\nOutput directory: {generated_files[0].parent if generated_files else 'N/A'}")

{wup-0.2.34 → wup-0.2.37}/wup/testql_monitor.py

@@ -179,33 +179,69 @@ def _service_path_patterns(services: Sequence[ServiceConfig]) -> Dict[str, List[
     return patterns
 
 
+def _find_service_by_name(services: Sequence[ServiceConfig], name: str) -> Optional[str]:
+    """Find a service by case-insensitive name match."""
+    name_lower = name.lower()
+    for svc in services:
+        if svc.name.lower() == name_lower:
+            return svc.name
+    return None
+
+
+def _find_service_by_token(services: Sequence[ServiceConfig], token: str) -> Optional[str]:
+    """Find a service by checking if token is in its name."""
+    token_lower = token.lower()
+    for svc in services:
+        if token_lower in svc.name.lower():
+            return svc.name
+    return None
+
+
+def _assign_by_port_8101(services: Sequence[ServiceConfig]) -> Optional[str]:
+    """Assign probe to backend service for port 8101."""
+    return _find_service_by_name(services, "backend")
+
+
+def _assign_by_port_8202(services: Sequence[ServiceConfig]) -> Optional[str]:
+    """Assign probe to firmware service for port 8202."""
+    return _find_service_by_token(services, "firmware")
+
+
+def _assign_by_port_8100(
+    services: Sequence[ServiceConfig], path_lower: str
+) -> Optional[str]:
+    """Assign probe for port 8100 (frontend proxy)."""
+    if path_lower.startswith("/firmware"):
+        return _find_service_by_token(services, "firmware")
+    return _find_service_by_name(services, "frontend")
+
+
+def _assign_by_connect_backend(
+    services: Sequence[ServiceConfig], path_lower: str
+) -> Optional[str]:
+    """Assign probe to connect-* backend services."""
+    for svc in services:
+        token = svc.name.lower().replace("_", "-")
+        if token.startswith("connect-") and token.replace("connect-", "") in path_lower:
+            return svc.name
+    return None
+
+
 def _assign_http_probe(
     probe: ProbeTarget, services: Sequence[ServiceConfig], path_lower: str
 ) -> Optional[str]:
     """Map an HTTP probe to a service based on port and path."""
-    wup_names = {s.name.lower() for s in services}
     parsed = urlparse(probe.url)
     port = parsed.port
 
-    if port == 8101 and "backend" in wup_names:
-        return next(s.name for s in services if s.name.lower() == "backend")
+    if port == 8101:
+        return _assign_by_port_8101(services)
     if port == 8202:
-        for svc in services:
-            if "firmware" in svc.name.lower():
-                return svc.name
+        return _assign_by_port_8202(services)
     if port == 8100:
-        if path_lower.startswith("/firmware"):
-            for svc in services:
-                if "firmware" in svc.name.lower():
-                    return svc.name
-        if "frontend" in wup_names:
-            return next(s.name for s in services if s.name.lower() == "frontend")
-    # Connect-* backends on 8103+ — only if a matching WUP service exists
-    for svc in services:
-        token = svc.name.lower().replace("_", "-")
-        if token.startswith("connect-") and token.replace("connect-", "") in path_lower:
-            return svc.name
-    return None
+        return _assign_by_port_8100(services, path_lower)
+    
+    return _assign_by_connect_backend(services, path_lower)
 
 
 def _assign_by_longest_token(

{wup-0.2.34 → wup-0.2.37}/wup/testql_watcher.py

@@ -15,7 +15,6 @@ from urllib import error, request
 from .config import load_config
 from .core import WupWatcher
 from .models.config import WupConfig, ServiceConfig
-from .testql_monitor import TestQLMonitor
 from .visual_diff import VisualDiffer
 from .web_client import WebClient
 
@@ -97,6 +96,7 @@ class TestQLWatcher(WupWatcher):
         self.health_state_path.parent.mkdir(parents=True, exist_ok=True)
         self.service_health = self._load_service_health()
         self.config = config
+        from .testql_monitor import TestQLMonitor
         self.monitor = TestQLMonitor(self.project_root, config) if config else None
         self.visual_differ = VisualDiffer(project_root, config.visual_diff) if config and config.visual_diff else None
         self.web_client = WebClient(config.web) if config and getattr(config, "web", None) else WebClient()

{wup-0.2.34 → wup-0.2.37/wup.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wup
-Version: 0.2.34
+Version: 0.2.37
 Summary: WUP (What's Up) - Intelligent file watcher for regression testing in large projects
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0
@@ -31,17 +31,17 @@ Dynamic: license-file
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.34-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$2.68-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-18.7h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.37-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$2.71-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-19.5h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $2.6840 (44 commits)
-- 👤 **Human dev:** ~$1867 (18.7h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $2.7096 (47 commits)
+- 👤 **Human dev:** ~$1947 (19.5h @ $100/h, 30min dedup)
 
-Generated on 2026-05-21 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+Generated on 2026-05-22 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.34-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.37-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 **WUP (What's Up)** - Intelligent file watcher for regression testing in large projects.
 

{wup-0.2.34 → wup-0.2.37}/wup.egg-info/SOURCES.txt

@@ -15,11 +15,14 @@ wup/anomaly_detector.py
 wup/anomaly_models.py
 wup/assistant.py
 wup/cli.py
+wup/cli_config_generator.py
+wup/cli_scanner.py
 wup/config.py
 wup/core.py
 wup/dependency_mapper.py
 wup/monitoring_manifest.py
 wup/planfile_reporter.py
+wup/testql_cli_generator.py
 wup/testql_discovery.py
 wup/testql_monitor.py
 wup/testql_watcher.py