machineconfig 3.7__py3-none-any.whl → 7.69__py3-none-any.whl

machineconfig/scripts/python/ai/generate_files.py

@@ -1,22 +1,39 @@
 #!/usr/bin/env python3
-"""Script to generate a markdown table with checkboxes for all Python files in the repo."""
+"""Script to generate a markdown table with checkboxes for all Python and shell files in the repo."""
 
 from pathlib import Path
+from typing import Annotated, Literal, Optional
+from rich.console import Console
+from rich.panel import Panel
+import typer
+import subprocess
+import shutil
 
 
-def get_python_files(repo_root: Path) -> list[str]:
+def get_python_files(repo_root: Path, exclude_init: bool = False) -> list[str]:
     """Get all Python files relative to repo root."""
+    excluded_parts = {".venv", "__pycache__", ".git", "build", "dist", ".ai"}
+    excluded_patterns = {"*.egg-info"}
+
     # Get all .py files recursively
     py_files = list(repo_root.glob("**/*.py"))
 
-    # Filter out files in .venv and __pycache__ directories
+    # Filter out files in excluded directories
     filtered_files = []
     for file_path in py_files:
         relative_path = file_path.relative_to(repo_root)
         path_parts = relative_path.parts
 
-        # Skip files in .venv or __pycache__ directories
-        if any(part in {".venv", "__pycache__"} for part in path_parts):
+        # Skip files in excluded directories
+        if any(part in excluded_parts for part in path_parts):
+            continue
+
+        # Skip files matching excluded patterns
+        if any(file_path.match(f"**/{pattern}/**") for pattern in excluded_patterns):
+            continue
+
+        # Skip __init__.py files if requested
+        if exclude_init and file_path.name == "__init__.py":
             continue
 
         filtered_files.append(str(relative_path))
@@ -24,60 +41,308 @@ def get_python_files(repo_root: Path) -> list[str]:
     return sorted(filtered_files)
 
 
-def generate_markdown_table(files: list[str]) -> str:
-    """Generate markdown table with checkboxes."""
-    header = "# Python Files Checklist\n\n"
-    table = "| Index | File Path | Status |\n|-------|-----------|--------|\n"
+def get_shell_files(repo_root: Path) -> list[str]:
+    """Get all shell script files relative to repo root."""
+    excluded_parts = {".venv", "__pycache__", ".git", "build", "dist"}
+    excluded_patterns = {"*.egg-info"}
+
+    # Get all .sh files recursively
+    sh_files = list(repo_root.glob("**/*.sh"))
+
+    # Filter out files in excluded directories
+    filtered_files = []
+    for file_path in sh_files:
+        relative_path = file_path.relative_to(repo_root)
+        path_parts = relative_path.parts
+
+        # Skip files in excluded directories
+        if any(part in excluded_parts for part in path_parts):
+            continue
+
+        # Skip files matching excluded patterns
+        if any(file_path.match(f"**/{pattern}/**") for pattern in excluded_patterns):
+            continue
+
+        filtered_files.append(str(relative_path))
+
+    return sorted(filtered_files)
+
+
+def count_lines(file_path: Path) -> int:
+    """Count the number of lines in a file."""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return sum(1 for _ in f)
+    except (IOError, UnicodeDecodeError):
+        return 0
+
+
+def is_git_repository(path: Path) -> bool:
+    """Check if the given path is part of a git repository."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--git-dir"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            check=False
+        )
+        return result.returncode == 0
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return False
+
+
+def filter_files_by_name(files: list[str], pattern: str) -> list[str]:
+    """Filter files by filename containing the pattern."""
+    return [f for f in files if pattern in f]
+
 
-    for index, file_path in enumerate(files, start=1):
-        # Remove leading ./ if present
+def filter_files_by_content(repo_root: Path, files: list[str], keyword: str) -> list[str]:
+    """Filter files by content containing the keyword."""
+    filtered_files = []
+    for file_path in files:
+        full_path = repo_root / file_path
+        try:
+            with open(full_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                if keyword in content:
+                    filtered_files.append(file_path)
+        except (IOError, UnicodeDecodeError):
+            # Skip files that can't be read
+            continue
+    return filtered_files
+
+
+def generate_csv_content(python_files: list[str], shell_files: list[str], repo_root: Path, include_line_count: bool = False) -> str:
+    """Generate CSV content with file information."""
+    import csv
+    import io
+    
+    output = io.StringIO()
+    writer = csv.writer(output)
+    
+    # Write header
+    if include_line_count:
+        writer.writerow(["Type", "Index", "File Path", "Line Count", "Status"])
+    else:
+        writer.writerow(["Type", "Index", "File Path", "Status"])
+    
+    # Write Python files
+    for index, file_path in enumerate(python_files, start=1):
         clean_path = file_path.lstrip("./")
-        table += f"| {index} | {clean_path} | - [ ] |\n"
+        if include_line_count:
+            line_count = count_lines(repo_root / file_path)
+            writer.writerow(["Python", index, clean_path, line_count, "[ ]"])
+        else:
+            writer.writerow(["Python", index, clean_path, "[ ]"])
+    
+    # Write shell files
+    for index, file_path in enumerate(shell_files, start=1):
+        clean_path = file_path.lstrip("./")
+        if include_line_count:
+            line_count = count_lines(repo_root / file_path)
+            writer.writerow(["Shell", index, clean_path, line_count, "[ ]"])
+        else:
+            writer.writerow(["Shell", index, clean_path, "[ ]"])
+    
+    return output.getvalue()
 
-    return header + table
 
+def generate_txt_content(python_files: list[str], shell_files: list[str]) -> str:
+    """Generate plain text content with file paths."""
+    all_files = python_files + shell_files
+    return "\n".join(file.lstrip("./") for file in all_files)
 
-def main() -> None:
-    """Main function."""
-    repo_root = Path.cwd()
-    if not repo_root.joinpath("pyproject.toml").exists():
-        raise RuntimeError(f" {repo_root} Not a repo root")
-    output_file = repo_root / ".ai" / "all_files_with_index.md"
 
-    print(f"Repo root: {repo_root}")
-    print(f"Output file: {output_file}")
+def generate_markdown_table(python_files: list[str], shell_files: list[str], repo_root: Path, include_line_count: bool = False) -> str:
+    """Generate markdown table with checkboxes."""
+    header = "# File Checklist\n\n"
 
-    # Ensure output directory exists
-    output_file.parent.mkdir(parents=True, exist_ok=True)
+    content = ""
 
-    # Get Python files
-    python_files = get_python_files(repo_root)
-    print(f"Found {len(python_files)} Python files")
+    if python_files:
+        content += "## Python Files\n\n"
+        if include_line_count:
+            # Calculate line counts and sort by descending line count
+            python_with_counts = [(file, count_lines(repo_root / file)) for file in python_files]
+            python_with_counts.sort(key=lambda x: x[1], reverse=True)
+            python_files = [file for file, _ in python_with_counts]
+            
+            content += "| Index | File Path | Line Count | Status |\n|-------|-----------|------------|--------|\n"
+        else:
+            content += "| Index | File Path | Status |\n|-------|-----------|--------|\n"
+        for index, file_path in enumerate(python_files, start=1):
+            clean_path = file_path.lstrip("./")
+            if include_line_count:
+                line_count = count_lines(repo_root / file_path)
+                content += f"| {index} | {clean_path} | {line_count} | - [ ] |\n"
+            else:
+                content += f"| {index} | {clean_path} | - [ ] |\n"
+
+    if shell_files:
+        content += "\n## Shell Script Files\n\n"
+        if include_line_count:
+            # Calculate line counts and sort by descending line count
+            shell_with_counts = [(file, count_lines(repo_root / file)) for file in shell_files]
+            shell_with_counts.sort(key=lambda x: x[1], reverse=True)
+            shell_files = [file for file, _ in shell_with_counts]
+            
+            content += "| Index | File Path | Line Count | Status |\n|-------|-----------|------------|--------|\n"
+        else:
+            content += "| Index | File Path | Status |\n|-------|-----------|--------|\n"
+        for index, file_path in enumerate(shell_files, start=1):
+            clean_path = file_path.lstrip("./")
+            if include_line_count:
+                line_count = count_lines(repo_root / file_path)
+                content += f"| {index} | {clean_path} | {line_count} | - [ ] |\n"
+            else:
+                content += f"| {index} | {clean_path} | - [ ] |\n"
+
+    return header + content
 
-    # Generate markdown
-    markdown_content = generate_markdown_table(python_files)
-    print(f"Generated markdown content length: {len(markdown_content)}")
 
-    # Write to file
-    output_file.write_text(markdown_content)
-    print(f"Generated {output_file} with {len(python_files)} Python files")
+def split_files_into_chunks(all_files: list[str], split_every: Optional[int] = None, split_to: Optional[int] = None) -> list[list[str]]:
+    """Split files into chunks based on split_every or split_to."""
+    if split_every is not None:
+        # Split into chunks of split_every files each
+        return [all_files[i:i + split_every] for i in range(0, len(all_files), split_every)]
+    elif split_to is not None:
+        # Split into exactly split_to chunks
+        if split_to <= 0:
+            return [all_files]
+        chunk_size = max(1, len(all_files) // split_to)
+        chunks = []
+        for i in range(split_to):
+            start = i * chunk_size
+            end = start + chunk_size if i < split_to - 1 else len(all_files)
+            chunks.append(all_files[start:end])
+        return chunks
+    else:
+        # No splitting
+        return [all_files]
 
-    # Create 5 symlinks to repo_root at ~/code_copies/${repo_name}_copy_{i}
-    import pathlib
 
-    # import os
-    repo_root = pathlib.Path.cwd().resolve()
-    repo_name: str = pathlib.Path(repo_root).name
-    symlink_dir: pathlib.Path = pathlib.Path.home() / "code_copies"
+def generate_content(python_files: list[str], shell_files: list[str], repo_root: Path, 
+                    format_type: str, include_line_count: bool) -> str:
+    """Generate content based on format type."""
+    if format_type == "csv":
+        return generate_csv_content(python_files, shell_files, repo_root, include_line_count)
+    elif format_type == "md":
+        return generate_markdown_table(python_files, shell_files, repo_root, include_line_count)
+    elif format_type == "txt":
+        return generate_txt_content(python_files, shell_files)
+    else:
+        raise ValueError(f"Unsupported format: {format_type}")
+
+
+def create_repo_symlinks(repo_root: Path) -> None:
+    """Create 5 symlinks to repo_root at ~/code_copies/${repo_name}_copy_{i}."""
+    repo_name: str = repo_root.name
+    symlink_dir: Path = Path.home() / "code_copies"
     symlink_dir.mkdir(exist_ok=True)
     for i in range(1, 6):
-        symlink_path: pathlib.Path = symlink_dir / f"{repo_name}_copy_{i}"
+        symlink_path: Path = symlink_dir / f"{repo_name}_copy_{i}"
         if symlink_path.exists() or symlink_path.is_symlink():
             symlink_path.unlink()
         symlink_path.symlink_to(repo_root, target_is_directory=True)
-    # Windows equivalent (comment):
-    # for /l %i in (1,1,5) do mklink /D "%USERPROFILE%\code_copies\{repo_name}_copy_%i" "C:\path\to\repo_root"
 
 
+def main(
+    pattern: Annotated[str, typer.Argument(help="Pattern or keyword to match files by")],
+    repo: Annotated[str, typer.Argument(help="Repository path. Can be any directory within a git repository.")] = str(Path.cwd()),
+    strategy: Annotated[Literal["name", "keywords"], typer.Option("-s", "--strategy", help="Strategy to filter files: 'name' for filename matching, 'keywords' for content matching")] = "name",
+    exclude_init: Annotated[bool, typer.Option("-x", "--exclude-init", help="Exclude __init__.py files from the checklist")] = True,
+    include_line_count: Annotated[bool, typer.Option("-l", "--line-count", help="Include line count column in the output")] = False,
+    output_path: Annotated[str, typer.Option("-o", "--output-path", help="Base path for output files relative to repo root")] = ".ai/todo/files",
+    format_type: Annotated[Literal["csv", "md", "txt"], typer.Option("-f", "--format", help="Output format: csv, md (markdown), or txt")] = "md",
+    split_every: Annotated[Optional[int], typer.Option("--split-every", "-e", help="Split output into multiple files, each containing at most this many results")] = None,
+    split_to: Annotated[Optional[int], typer.Option("--split-to", "-t", help="Split output into exactly this many files")] = None,
+) -> None:
+    """Generate checklist with Python and shell script files in the repository filtered by pattern."""
+    repo_path = Path(repo).expanduser().absolute()
+    if not is_git_repository(repo_path):
+        console = Console()
+        console.print(Panel(f"❌ ERROR | Not a git repository or not in a git repository: {repo_path}", border_style="bold red", expand=False))
+        raise typer.Exit(code=1)
+
+    # Delete .ai/todo directory at the start
+    todo_dir = repo_path / ".ai" / "todo"
+    if todo_dir.exists():
+        shutil.rmtree(todo_dir)
+
+    output_base = repo_path / output_path
+
+    # Ensure output directory exists
+    output_base.parent.mkdir(parents=True, exist_ok=True)
+
+    # Get Python and shell files
+    python_files = get_python_files(repo_path, exclude_init=exclude_init)
+    shell_files = get_shell_files(repo_path)
+
+    # Apply filtering based on strategy
+    if strategy == "name":
+        python_files = filter_files_by_name(python_files, pattern)
+        shell_files = filter_files_by_name(shell_files, pattern)
+    elif strategy == "keywords":
+        python_files = filter_files_by_content(repo_path, python_files, pattern)
+        shell_files = filter_files_by_content(repo_path, shell_files, pattern)
+
+    print(f"Repo path: {repo_path}")
+    print(f"Strategy: {strategy}")
+    print(f"Pattern: {pattern}")
+    print(f"Format: {format_type}")
+    print(f"Found {len(python_files)} Python files")
+    print(f"Found {len(shell_files)} Shell script files")
+
+    # Combine all files for splitting
+    all_files = python_files + shell_files
+    
+    # Split files into chunks
+    file_chunks = split_files_into_chunks(all_files, split_every, split_to)
+    
+    # Determine file extension based on format
+    extension = {"csv": ".csv", "md": ".md", "txt": ".txt"}[format_type]
+    
+    output_files = []
+    for i, chunk in enumerate(file_chunks):
+        # Split chunk back into python and shell files
+        chunk_python = [f for f in chunk if f in python_files]
+        chunk_shell = [f for f in chunk if f in shell_files]
+        
+        # Generate content for this chunk
+        content = generate_content(chunk_python, chunk_shell, repo_path, format_type, include_line_count)
+        
+        # Determine output file path
+        if len(file_chunks) == 1:
+            output_file = output_base.with_suffix(extension)
+        else:
+            output_file = output_base.parent / f"{output_base.name}_{i+1}{extension}"
+        
+        # Write to file
+        output_file.write_text(content)
+        output_files.append(output_file)
+
+    console = Console()
+    success_msg = f"""✅ SUCCESS | Files generated successfully!
+📄 Output files: {', '.join(str(f.relative_to(repo_path)) for f in output_files)}
+🐍 Python files: {len(python_files)}
+🔧 Shell files: {len(shell_files)}
+📊 Total chunks: {len(file_chunks)}"""
+    
+    console.print(Panel(success_msg, border_style="bold blue", expand=False))
+
+
+def create_symlink_command(num: Annotated[int, typer.Argument(help="Number of symlinks to create (1-5).")] = 5) -> None:
+    """Create 5 symlinks to repo_root at ~/code_copies/${repo_name}_copy_{i}."""
+    if num < 1 or num > 5:
+        console = Console()
+        console.print(Panel("❌ ERROR | Number of symlinks must be between 1 and 5.", border_style="bold red", expand=False))
+        raise typer.Exit(code=1)
+    repo_root = Path.cwd().absolute()
+    create_repo_symlinks(repo_root)
+    console = Console()
+    console.print(Panel(f"✅ SUCCESS | Created {num} symlinks to {repo_root} in ~/code_copies/", border_style="bold green", expand=False))
+
 if __name__ == "__main__":
-    main()
+    typer.run(main)
+    # typer.run(create_symlink_command)

machineconfig/scripts/python/ai/{mcinit.py → initai.py}

@@ -7,6 +7,7 @@ from machineconfig.scripts.python.ai.solutions.copilot import github_copilot
 from machineconfig.scripts.python.ai.solutions.crush import crush
 from machineconfig.scripts.python.ai.solutions.cursor import cursors
 from machineconfig.scripts.python.ai.solutions.gemini import gemini
+from machineconfig.scripts.python.ai.vscode_tasks import add_lint_and_type_check_task
 from machineconfig.utils.accessories import get_repo_root
 
 
@@ -14,24 +15,6 @@ def add_ai_configs(repo_root: Path) -> None:
     repo_root_resolved = get_repo_root(repo_root)
     if repo_root_resolved is not None:
         repo_root = repo_root_resolved  # this means you can run the command from any subdirectory of the repo.
-
-    if repo_root.joinpath("pyproject.toml").exists() is False:
-        uv_init = input(f"{repo_root} does not seem to be a python project (no pyproject.toml found), would you like to initialize one? (y/n) ")
-        if uv_init.strip().lower() == "y":
-            command_to_run = """
-uv init --python 3.13
-uv venv
-uv add --upgrade-package pylint pyright mypy pyrefly ty --dev  # linters and type checkers
-uv add --upgrade-package pytest --dev
-
-"""
-            import subprocess
-
-            subprocess.run(command_to_run, shell=True, check=True)
-        else:
-            print("Terminating mcinit ...")
-            return
-
     dot_ai_dir = repo_root.joinpath(".ai")
     dot_ai_dir.mkdir(parents=True, exist_ok=True)
     dot_scripts_dir = repo_root.joinpath(".scripts")
@@ -39,6 +22,8 @@ uv add --upgrade-package pytest --dev
     generic.create_dot_scripts(repo_root=repo_root)
     generic.adjust_gitignore(repo_root=repo_root)
 
+    add_lint_and_type_check_task(repo_root=repo_root)
+
     github_copilot.build_configuration(repo_root=repo_root)
     cursors.build_configuration(repo_root=repo_root)
     gemini.build_configuration(repo_root=repo_root)
@@ -46,23 +31,3 @@ uv add --upgrade-package pytest --dev
     crush.build_configuration(repo_root=repo_root)
     cline.build_configuration(repo_root=repo_root)
 
-
-
-def main() -> None:
-    # import argparse
-
-    # parser = argparse.ArgumentParser(description="Add AI configurations to a Python project.")
-    # parser.add_argument(
-    #     "--repo-root",
-    #     type=str,
-    #     default=".",
-    #     help="Path to the root of the repository. Defaults to the current working directory.",
-    # )
-    # args = parser.parse_args()
-    # repo_root = Path(args.repo_root).resolve()
-    repo_root = Path.cwd()
-    add_ai_configs(repo_root=repo_root)
-
-
-if __name__ == "__main__":
-    add_ai_configs(repo_root=Path.cwd())

machineconfig/scripts/python/ai/scripts/lint_and_type_check.ps1

@@ -0,0 +1,114 @@
+# gotch1: make sure we are in the right directory: repo root. Solution: check if .pyproject.toml exists, otherwise stop.
+if (!(Test-Path "./pyproject.toml")) {
+    Write-Host "Error: pyproject.toml not found in the current directory. Please run this script from the root of a Python project." -ForegroundColor Red
+    exit 1
+}
+
+# Color definitions (using ANSI escape sequences for cross-platform compatibility)
+$RED = "`e[0;31m"
+$GREEN = "`e[0;32m"
+$YELLOW = "`e[1;33m"
+$BLUE = "`e[0;34m"
+$PURPLE = "`e[0;35m"
+$CYAN = "`e[0;36m"
+$WHITE = "`e[1;37m"
+$BOLD = "`e[1m"
+$UNDERLINE = "`e[4m"
+$NC = "`e[0m" # No Color
+
+# Box drawing functions
+function Draw-Box {
+    param([string]$text, [string]$color)
+    $width = 60
+    $padding = [math]::Floor(($width - $text.Length) / 2)
+    $line = "─" * $width
+
+    Write-Host "${color}┌${line}┐${NC}"
+    Write-Host ("${color}│" + (" " * $padding) + $text + (" " * $padding) + "│${NC}")
+    Write-Host "${color}└${line}┘${NC}"
+}
+
+function Draw-Progress {
+    param([int]$current, [int]$total, [string]$description)
+    Write-Host "${CYAN}┌────────────────────────────────────────────────────────────┐${NC}"
+    $padding = 50 - $description.Length - 8
+    Write-Host ("${CYAN}│${NC} ${BOLD}${WHITE}Step ${current}/${total}:${NC} ${description}" + (" " * $padding) + "${CYAN}│${NC}")
+    Write-Host "${CYAN}└────────────────────────────────────────────────────────────┘${NC}"
+}
+
+$TOTAL_STEPS = 7
+$CURRENT_STEP = 0
+
+Draw-Box "🚀 LINTING & TYPE CHECKING SUITE 🚀" "${BOLD}${CYAN}"
+Write-Host
+
+$CURRENT_STEP++
+Draw-Progress $CURRENT_STEP $TOTAL_STEPS "Environment Setup"
+Write-Host "${BLUE}🔧 Installing and updating development dependencies...${NC}"
+# uv add pylint pyright mypy pyrefly ruff ty --dev  # linters and type checkers
+# uv add --dev cleanpy pylint pyright mypy pyrefly --upgrade-package cleanpy pylint pyright mypy pyrefly
+uv add --dev pyright --upgrade-package pyright
+uv add --dev pylint --upgrade-package pylint
+uv add --dev mypy --upgrade-package mypy
+uv add --dev pyrefly --upgrade-package pyrefly
+uv add --dev cleanpy --upgrade-package cleanpy
+
+uv add types-requests types-toml types-PyYAML types-pytz types-paramiko types-urllib3 --dev
+uv add types-mysqlclient types-SQLAlchemy --dev
+
+Write-Host "${GREEN}✅ Environment setup complete!${NC}"
+Write-Host
+
+$CURRENT_STEP++
+Draw-Progress $CURRENT_STEP $TOTAL_STEPS "Code Cleanup"
+Write-Host "${YELLOW}🧹 Cleaning and formatting code...${NC}"
+uv run -m cleanpy .
+uv run -m ruff clean
+# uv run -m ruff format .
+uv run -m ruff check . --fix
+
+New-Item -ItemType Directory -Force -Path .ai/linters | Out-Null
+
+Write-Host "${GREEN}🧹 Code cleanup complete!${NC}"
+Write-Host
+
+Draw-Box "🔍 TYPE CHECKERS & LINTERS 🔍" "${BOLD}${PURPLE}"
+
+$CURRENT_STEP++
+Draw-Progress $CURRENT_STEP $TOTAL_STEPS "Pyright Type Checker"
+Write-Host "${BLUE}📋 Analyzing types with Pyright...${NC}"
+Remove-Item ./.ai/linters/issues_pyright.md -ErrorAction SilentlyContinue
+uv run pyright . | Out-File -FilePath ./.ai/linters/issues_pyright.md
+Write-Host "${GREEN}✅ Results saved to ${UNDERLINE}./.ai/linters/issues_pyright.md${NC}"
+
+$CURRENT_STEP++
+Draw-Progress $CURRENT_STEP $TOTAL_STEPS "MyPy Type Checker"
+Write-Host "${BLUE}📋 Analyzing types with MyPy...${NC}"
+Remove-Item ./.ai/linters/issues_mypy.md -ErrorAction SilentlyContinue
+uv run mypy . | Out-File -FilePath ./.ai/linters/issues_mypy.md
+Write-Host "${GREEN}✅ Results saved to ${UNDERLINE}./.ai/linters/issues_mypy.md${NC}"
+
+$CURRENT_STEP++
+Draw-Progress $CURRENT_STEP $TOTAL_STEPS "Pylint Code Analysis"
+Write-Host "${BLUE}📋 Analyzing code quality with Pylint...${NC}"
+Remove-Item ./.ai/linters/issues_pylint.md -ErrorAction SilentlyContinue
+uv run pylint ./src/ | Out-File -FilePath ./.ai/linters/issues_pylint.md
+Write-Host "${GREEN}✅ Results saved to ${UNDERLINE}./.ai/linters/issues_pylint.md${NC}"
+
+$CURRENT_STEP++
+Draw-Progress $CURRENT_STEP $TOTAL_STEPS "Pyrefly Type Checker"
+Write-Host "${BLUE}📋 Analyzing types with Pyrefly...${NC}"
+Remove-Item ./.ai/linters/issues_pyrefly.md -ErrorAction SilentlyContinue
+uv run pyrefly check . | Out-File -FilePath ./.ai/linters/issues_pyrefly.md
+Write-Host "${GREEN}✅ Results saved to ${UNDERLINE}./.ai/linters/issues_pyrefly.md${NC}"
+
+$CURRENT_STEP++
+Draw-Progress $CURRENT_STEP $TOTAL_STEPS "Ruff Linter"
+Write-Host "${BLUE}📋 Checking code style with Ruff...${NC}"
+Remove-Item ./.ai/linters/issues_ruff.md -ErrorAction SilentlyContinue
+uv run ruff check . | Out-File -FilePath ./.ai/linters/issues_ruff.md
+Write-Host "${GREEN}✅ Results saved to ${UNDERLINE}./.ai/linters/issues_ruff.md${NC}"
+
+Write-Host
+Draw-Box "🎉 ALL CHECKS COMPLETED! 🎉" "${BOLD}${GREEN}"
+Write-Host "${BOLD}${GREEN}📁 Check the ${UNDERLINE}.ai/linters${NC}${BOLD}${GREEN} directory for detailed results.${NC}"