machineconfig 5.64__py3-none-any.whl → 5.66__py3-none-any.whl

machineconfig/scripts/python/agents.py

@@ -3,20 +3,13 @@
 """
 
 from pathlib import Path
-from typing import cast, Iterable, Optional, get_args
+from typing import cast, Optional, get_args
 import typer
 from machineconfig.scripts.python.helpers_fire.fire_agents_helper_types import AGENTS, MATCHINE, MODEL, PROVIDER
 
 
-def _write_list_file(target: Path, files: Iterable[Path]) -> None:
-    target.parent.mkdir(parents=True, exist_ok=True)
-    target.write_text("\n".join(str(f) for f in files), encoding="utf-8")
-
-
 def create(
-    context_path: Optional[Path] = typer.Option(None, help="Path to the context file"),
-    keyword_search: Optional[str] = typer.Option(None, help="Keyword to search in Python files"),
-    filename_pattern: Optional[str] = typer.Option(None, help="Filename pattern to match"),
+    context_path: Path = typer.Argument(..., help="Path to the context file"),
     separator: str = typer.Option("\n", help="Separator for context"),
     tasks_per_prompt: int = typer.Option(13, help="Number of tasks per prompt"),
 
@@ -34,17 +27,11 @@ def create(
 ):
 
     from machineconfig.scripts.python.helpers_fire.fire_agents_help_launch import prep_agent_launch, get_agents_launch_layout
-    from machineconfig.scripts.python.helpers_fire.fire_agents_help_search import search_files_by_pattern, search_python_files
     from machineconfig.scripts.python.helpers_fire.fire_agents_load_balancer import chunk_prompts
     from machineconfig.utils.accessories import get_repo_root, randstr
     import json
 
     # validate mutual exclusive
-    context_options = [context_path, keyword_search, filename_pattern]
-    provided_context = [opt for opt in context_options if opt is not None]
-    if len(provided_context) != 1:
-        raise typer.BadParameter("Exactly one of --context-path, --keyword-search, --filename-pattern must be provided")
-    
     prompt_options = [prompt, prompt_path]
     provided_prompt = [opt for opt in prompt_options if opt is not None]
     if len(provided_prompt) != 1:
@@ -56,33 +43,12 @@ def create(
         raise typer.Exit(1)
     typer.echo(f"Operating @ {repo_root}")
     
-    search_strategy = ""
     prompt_material_path = Path("")
     
-    if context_path is not None:
-        search_strategy = "file_path"
-        target_file_path = context_path.expanduser().resolve()
-        if not target_file_path.exists() or not target_file_path.is_file():
-            raise typer.BadParameter(f"Invalid file path: {target_file_path}")
-        prompt_material_path = target_file_path
-    elif keyword_search is not None:
-        search_strategy = "keyword_search"
-        matching_files = search_python_files(repo_root, keyword_search)
-        if not matching_files:
-            typer.echo(f"💥 No .py files found containing keyword: {keyword_search}")
-            raise typer.Exit(1)
-        target_file_path = repo_root / ".ai" / "target_file.txt"
-        _write_list_file(target_file_path, matching_files)
-        prompt_material_path = target_file_path
-    elif filename_pattern is not None:
-        search_strategy = "filename_pattern"
-        matching_files = search_files_by_pattern(repo_root, filename_pattern)
-        if not matching_files:
-            typer.echo(f"💥 No files found matching pattern: {filename_pattern}")
-            raise typer.Exit(1)
-        target_file_path = repo_root / ".ai" / "target_file.txt"
-        _write_list_file(target_file_path, matching_files)
-        prompt_material_path = target_file_path
+    target_file_path = context_path.expanduser().resolve()
+    if not target_file_path.exists() or not target_file_path.is_file():
+        raise typer.BadParameter(f"Invalid file path: {target_file_path}")
+    prompt_material_path = target_file_path
     
     if prompt_path is not None:
         prompt_prefix = prompt_path.read_text(encoding="utf-8")
@@ -103,8 +69,7 @@ def create(
     layoutfile = get_agents_launch_layout(session_root=agents_dir)    
     regenerate_py_code = f"""
 #!/usr/bin/env uv run --python 3.14 --with machineconfig
-agents create --context-path "{prompt_material_path}" \\
-    --{search_strategy} "{context_path or keyword_search or filename_pattern}" \\
+agents create "{prompt_material_path}" \\
     --prompt-path "{prompt_path or ''}" \\
     --agent "{agent_selected}" \\
     --machine "{machine}" \\
@@ -187,20 +152,19 @@ def init_config():
     from machineconfig.scripts.python.ai.initai import add_ai_configs
     add_ai_configs(repo_root=Path.cwd())
 
-def generate_files():
-    from machineconfig.scripts.python.ai.generate_files import main
-    main()
-
 def get_app():
     agents_app = typer.Typer(help="🤖 AI Agents management subcommands")
     agents_app.command("create", no_args_is_help=True, help="Create agents layout file, ready to run.")(create)
     agents_app.command("collect", no_args_is_help=True, help="Collect all agent materials into a single file.")(collect)
     agents_app.command("make-template", no_args_is_help=False, help="Create a template for fire agents")(template)
     agents_app.command("make-config", no_args_is_help=False, help="Initialize AI configurations in the current repository")(init_config)
-    agents_app.command("make-todo", no_args_is_help=False, help="Generate a markdown file listing all Python files in the repo")(generate_files)
+    from machineconfig.scripts.python.ai.generate_files import main
+    agents_app.command("make-todo", no_args_is_help=True, help="Generate a markdown file listing all Python files in the repo")(main)
+    from machineconfig.scripts.python.ai.generate_files import create_symlink_command
+    agents_app.command(name="make-symlinks", no_args_is_help=True, help="Create symlinks to the current repo in ~/code_copies/")(create_symlink_command)
     return agents_app
 
-def main_from_parser():
+def main():
     agents_app = get_app()
     import sys
     if len(sys.argv) == 1:

machineconfig/scripts/python/ai/generate_files.py

@@ -1,22 +1,38 @@
 #!/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
+from rich.console import Console
+from rich.panel import Panel
+import typer
+import subprocess
 
 
-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"}
+    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 +40,199 @@ 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)
+
 
-    for index, file_path in enumerate(files, start=1):
-        # Remove leading ./ if present
-        clean_path = file_path.lstrip("./")
-        table += f"| {index} | {clean_path} | - [ ] |\n"
+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
 
-    return header + table
 
+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 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 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]
+
+
+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_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"
+
+    content = ""
+
+    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
+
+
+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: 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)
+
+
+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("--strategy", help="Strategy to filter files: 'name' for filename matching, 'keywords' for content matching")] = "name",
+    exclude_init: Annotated[bool, typer.Option("--exclude-init", help="Exclude __init__.py files from the checklist")] = False,
+    include_line_count: Annotated[bool, typer.Option("--line-count", help="Include line count column in the markdown table")] = False,
+    output_path: Annotated[str, typer.Option("--output-path", help="Path to output the markdown file relative to repo root")] = ".ai/todo/all_files_with_index.md",
+) -> None:
+    """Generate markdown 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)
+
+    output_file = repo_path / output_path
 
     # Ensure output directory exists
     output_file.parent.mkdir(parents=True, exist_ok=True)
 
-    # Get Python files
-    python_files = get_python_files(repo_root)
+    # 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"Found {len(python_files)} Python files")
+    print(f"Found {len(shell_files)} Shell script files")
 
     # Generate markdown
-    markdown_content = generate_markdown_table(python_files)
-    print(f"Generated markdown content length: {len(markdown_content)}")
+    markdown_content = generate_markdown_table(python_files, shell_files, repo_path, include_line_count)
 
     # Write to file
     output_file.write_text(markdown_content)
-    print(f"Generated {output_file} with {len(python_files)} Python files")
 
-    # Create 5 symlinks to repo_root at ~/code_copies/${repo_name}_copy_{i}
-    import pathlib
+    console = Console()
+    console.print(Panel(f"""✅ SUCCESS | Markdown checklist generated successfully!
+📄 File Location: {output_file}
+🐍 Python files: {len(python_files)}
+🔧 Shell files: {len(shell_files)}""", border_style="bold blue", expand=False))
 
-    # 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"
-    symlink_dir.mkdir(exist_ok=True)
-    for i in range(1, 6):
-        symlink_path: pathlib.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 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/croshell.py

@@ -62,7 +62,7 @@ except Exception as e:
 
 
 
-def main(
+def croshell(
     python: Annotated[bool, typer.Option("--python", "-p", help="flag to use python over IPython.")] = False,
     fzf: Annotated[bool, typer.Option("--fzf", "-F", help="search with fuzzy finder for python scripts and run them")] = False,
     profile: Annotated[Optional[str], typer.Option("--profile", "-P", help="ipython profile to use, defaults to default profile.")] = None,
@@ -150,16 +150,16 @@ from pathlib import Path
             else:
                 console.print(Panel("❌ Could not determine the local machineconfig repo root. Please ensure the `REPO_ROOT` in `source_of_truth.py` is correctly set to the local path of the machineconfig repo, or do not use the `--local` flag.", title="Error", border_style="red"))
                 return
-        else: ve_line = "--with machineconfig[plot]>=5.6"
+        else: ve_line = "--with machineconfig[plot]>=5.65"
         fire_line = f"uv run --python 3.14 {ve_line} {interpreter} {interactivity} {profile} {str(pyfile)}"
 
     from machineconfig.utils.code import run_shell_script
     run_shell_script(fire_line, clean_env=False)
 
 
-def arg_parser() -> None:
-    typer.run(main)
+def main() -> None:
+    typer.run(croshell)
 
 
 if __name__ == "__main__":
-    arg_parser()
+    main()

machineconfig/scripts/python/devops_helpers/cli_config.py

@@ -48,7 +48,7 @@ def path():
     from pathlib import Path
     path = Path(navigator.__file__).resolve().parent.joinpath("path_manager_tui.py")
     from machineconfig.utils.code import run_shell_script
-    run_shell_script(f"uv run --no-dev --with machineconfig>=5.6,textual {path}")
+    run_shell_script(f"uv run --with machineconfig>=5.65,textual {path}")
 
 @config_apps.command(no_args_is_help=False)
 def pwsh_theme():

machineconfig/scripts/python/devops_helpers/cli_self.py

@@ -31,9 +31,9 @@ def install():
     # main_public_from_parser()
     import platform
     if platform.system() == "Windows":
-        run_shell_script(r"""$HOME\.local\bin\uv.exe tool install machineconfig""")
+        run_shell_script(r"""$HOME\.local\bin\uv.exe tool install machineconfig>=5.65""")
     else:
-        run_shell_script("""$HOME/.local/bin/uv tool install machineconfig""")
+        run_shell_script("""$HOME/.local/bin/uv tool install machineconfig>=5.65""")
 
 @cli_app.command(no_args_is_help=False)
 def navigate():
@@ -42,7 +42,7 @@ def navigate():
     from pathlib import Path
     path = Path(navigator.__file__).resolve().parent.joinpath("devops_navigator.py")
     from machineconfig.utils.code import run_shell_script
-    run_shell_script(f"uv run --no-dev --with machineconfig>=5.6,textual {path}")
+    run_shell_script(f"uv run --with machineconfig>=5.65,textual {path}")
 
 
 @cli_app.command(no_args_is_help=True)