machineconfig 3.99__py3-none-any.whl → 7.66__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/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,25 +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
-# uv add typer --dev
-
-"""
-            import subprocess
-
-            subprocess.run(command_to_run, shell=True, check=True)
-        else:
-            print("Terminating initai ...")
-            return
-
     dot_ai_dir = repo_root.joinpath(".ai")
     dot_ai_dir.mkdir(parents=True, exist_ok=True)
     dot_scripts_dir = repo_root.joinpath(".scripts")
@@ -40,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)
@@ -47,12 +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:
-    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

@@ -66,9 +66,8 @@ uv run -m cleanpy .
 uv run -m ruff clean
 # uv run -m ruff format .
 uv run -m ruff check . --fix
-uv run --no-dev --project $HOME/code/machineconfig -m machineconfig.scripts.python.ai.generate_files
 
-New-Item -ItemType Directory -Force -Path .linters | Out-Null
+New-Item -ItemType Directory -Force -Path .ai/linters | Out-Null
 
 Write-Host "${GREEN}🧹 Code cleanup complete!${NC}"
 Write-Host
@@ -78,38 +77,38 @@ 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 ./.linters/pyright_result.md -ErrorAction SilentlyContinue
-uv run pyright . | Out-File -FilePath ./.linters/pyright_result.md
-Write-Host "${GREEN}✅ Results saved to ${UNDERLINE}./.linters/pyright_result.md${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 ./.linters/mypy_result.md -ErrorAction SilentlyContinue
-uv run mypy . | Out-File -FilePath ./.linters/mypy_result.md
-Write-Host "${GREEN}✅ Results saved to ${UNDERLINE}./.linters/mypy_result.md${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 ./.linters/pylint_result.md -ErrorAction SilentlyContinue
-uv run pylint ./src/ | Out-File -FilePath ./.linters/pylint_result.md
-Write-Host "${GREEN}✅ Results saved to ${UNDERLINE}./.linters/pylint_result.md${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 ./.linters/pyrefly_result.md -ErrorAction SilentlyContinue
-uv run pyrefly check . | Out-File -FilePath ./.linters/pyrefly_result.md
-Write-Host "${GREEN}✅ Results saved to ${UNDERLINE}./.linters/pyrefly_result.md${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 ./.linters/ruff_result.md -ErrorAction SilentlyContinue
-uv run ruff check . | Out-File -FilePath ./.linters/ruff_result.md
-Write-Host "${GREEN}✅ Results saved to ${UNDERLINE}./.linters/ruff_result.md${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}.linters${NC}${BOLD}${GREEN} directory for detailed results.${NC}"
+Write-Host "${BOLD}${GREEN}📁 Check the ${UNDERLINE}.ai/linters${NC}${BOLD}${GREEN} directory for detailed results.${NC}"

machineconfig/scripts/python/ai/scripts/lint_and_type_check.sh

@@ -70,9 +70,8 @@ uv run -m cleanpy .
 uv run -m ruff clean
 # uv run -m ruff format .
 uv run -m ruff check . --fix
-uv run --no-dev --project $HOME/code/machineconfig -m machineconfig.scripts.python.ai.generate_files
 
-mkdir .linters
+mkdir .ai/linters
 
 echo -e "${GREEN}🧹 Code cleanup complete!${NC}"
 echo
@@ -82,38 +81,38 @@ draw_box "🔍 TYPE CHECKERS & LINTERS 🔍" "${BOLD}${PURPLE}"
 ((CURRENT_STEP++))
 draw_progress $CURRENT_STEP $TOTAL_STEPS "Pyright Type Checker"
 echo -e "${BLUE}📋 Analyzing types with Pyright...${NC}"
-rm ./.linters/pyright_result.md || true
-uv run pyright . > ./.linters/pyright_result.md
-echo -e "${GREEN}✅ Results saved to ${UNDERLINE}./.linters/pyright_result.md${NC}"
+rm ./.ai/linters/issues_pyright.md || true
+uv run pyright . > ./.ai/linters/issues_pyright.md
+echo -e "${GREEN}✅ Results saved to ${UNDERLINE}./.ai/linters/issues_pyright.md${NC}"
 
 ((CURRENT_STEP++))
 draw_progress $CURRENT_STEP $TOTAL_STEPS "MyPy Type Checker"
 echo -e "${BLUE}📋 Analyzing types with MyPy...${NC}"
-rm ./.linters/mypy_result.md || true
-uv run mypy . > ./.linters/mypy_result.md
-echo -e "${GREEN}✅ Results saved to ${UNDERLINE}./.linters/mypy_result.md${NC}"
+rm ./.ai/linters/issues_mypy.md || true
+uv run mypy . > ./.ai/linters/issues_mypy.md
+echo -e "${GREEN}✅ Results saved to ${UNDERLINE}./.ai/linters/issues_mypy.md${NC}"
 
 ((CURRENT_STEP++))
 draw_progress $CURRENT_STEP $TOTAL_STEPS "Pylint Code Analysis"
 echo -e "${BLUE}📋 Analyzing code quality with Pylint...${NC}"
-rm ./.linters/pylint_result.md || true
-uv run pylint ./src/ > ./.linters/pylint_result.md
-echo -e "${GREEN}✅ Results saved to ${UNDERLINE}./.linters/pylint_result.md${NC}"
+rm ./.ai/linters/issues_pylint.md || true
+uv run pylint ./src/ > ./.ai/linters/issues_pylint.md
+echo -e "${GREEN}✅ Results saved to ${UNDERLINE}./.ai/linters/issues_pylint.md${NC}"
 
 ((CURRENT_STEP++))
 draw_progress $CURRENT_STEP $TOTAL_STEPS "Pyrefly Type Checker"
 echo -e "${BLUE}📋 Analyzing types with Pyrefly...${NC}"
-rm ./.linters/pyrefly_result.md || true
-uv run pyrefly check . > ./.linters/pyrefly_result.md
-echo -e "${GREEN}✅ Results saved to ${UNDERLINE}./.linters/pyrefly_result.md${NC}"
+rm ./.ai/linters/issues_pyrefly.md || true
+uv run pyrefly check . > ./.ai/linters/issues_pyrefly.md
+echo -e "${GREEN}✅ Results saved to ${UNDERLINE}./.ai/linters/issues_pyrefly.md${NC}"
 
 ((CURRENT_STEP++))
 draw_progress $CURRENT_STEP $TOTAL_STEPS "Ruff Linter"
 echo -e "${BLUE}📋 Checking code style with Ruff...${NC}"
-rm ./.linters/ruff_result.md || true
-uv run ruff check . > ./.linters/ruff_result.md
-echo -e "${GREEN}✅ Results saved to ${UNDERLINE}./.linters/ruff_result.md${NC}"
+rm ./.ai/linters/issues_ruff.md || true
+uv run ruff check . > ./.ai/linters/issues_ruff.md
+echo -e "${GREEN}✅ Results saved to ${UNDERLINE}./.ai/linters/issues_ruff.md${NC}"
 
 echo
 draw_box "🎉 ALL CHECKS COMPLETED! 🎉" "${BOLD}${GREEN}"
-echo -e "${BOLD}${GREEN}📁 Check the ${UNDERLINE}.linters${NC}${BOLD}${GREEN} directory for detailed results.${NC}"
+echo -e "${BOLD}${GREEN}📁 Check the ${UNDERLINE}.ai/linters${NC}${BOLD}${GREEN} directory for detailed results.${NC}"

machineconfig/scripts/python/ai/solutions/_shared.py

@@ -2,4 +2,12 @@ from pathlib import Path
 from machineconfig.utils.source_of_truth import LIBRARY_ROOT
 
 def get_generic_instructions_path() -> Path:
-    return LIBRARY_ROOT.joinpath("scripts/python/ai/solutions/copilot/instructions/python/dev.instructions.md")
+    path = LIBRARY_ROOT.joinpath("scripts/python/ai/solutions/copilot/instructions/python/dev.instructions.md")
+    text = path.read_text(encoding="utf-8")
+    import platform
+    if platform.system().lower() == "windows":
+        text = text.replace("bash", "powershell").replace(".sh", ".ps1")
+    import tempfile
+    temp_path = Path(tempfile.gettempdir()).joinpath("generic_instructions.md")
+    temp_path.write_text(data=text, encoding="utf-8")
+    return temp_path

machineconfig/scripts/python/ai/solutions/copilot/instructions/python/dev.instructions.md

@@ -34,7 +34,7 @@ applyTo: "**/*.py"
 * when finished, run a linting static analysis check against files you touched, Any fix any mistakes.
 * Please run `uv run -m pyright $file_touched` and address all issues. if `pyright is not there, first run `uv add pyright --dev`.
 * For all type checkers and linters, like mypy, pyright, pyrefly and pylint, there are config files at different levels of the repo all the way up to home directory level. You don't need to worry about them, just be mindful that they exist. The tools themselves will respect the configs therein.
-* If you want to run all linters and pycheckers agains the entire project to make sure everything is clean, I prepared a nice shell script, you can run it from the repo root as `./.scripts/lint_and_typecheck.sh`. It will produce markdown files that are you are meant to look at @ ./.linters/*.md
+* If you want to run all linters and pycheckers agains the entire project to make sure everything is clean, I prepared a nice shell script, you can run it from the repo root as `./.ai/scripts/lint_and_type_check.sh`. It will produce markdown files that are you are meant to look at @ ./.ai/linters/*.md
 
 # General Programming Ethos:
 * Make sure all the code is rigorous, no lazy stuff.

machineconfig/scripts/python/ai/solutions/copilot/prompts/pyright_fix.md

@@ -0,0 +1,16 @@
+---
+mode: agent
+---
+
+
+$PYRIGHT_ISSUES_FILE = "./.ai/linters/issues_pyright.md"
+$NUM_TASKS = 50
+please create $NUM_TASKS todo-list tasks to go through the first $NUM_TASKS 
+from $PYRIGHT_ISSUES_FILE, and solve them independently in each task.
+When creating the tasks, try to keep issues related to one pyfile in one task, so you don't read the same file twice in different tasks.
+
+once you solved them, you will have 2 months break from work.
+
+Start by runing `./.ai/scripts/lint_and_type_check.sh` to generate $PYRIGHT_ISSUES_FILE only once.
+
+