machineconfig 5.65__tar.gz → 5.67__tar.gz

{machineconfig-5.65/src/machineconfig.egg-info → machineconfig-5.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 5.65
+Version: 5.67
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0

{machineconfig-5.65 → machineconfig-5.67}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "machineconfig"
-version = "5.65"
+version = "5.67"
 description = "Dotfiles management package"
 readme = "README.md"
 license = {text = "Apache 2.0"}

{machineconfig-5.65 → machineconfig-5.67}/src/machineconfig/scripts/python/agents.py

@@ -3,28 +3,19 @@
 """
 
 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"),
+    agent: AGENTS = typer.Option(default=..., help=f"Agent type. One of {', '.join(get_args(AGENTS)[:3])}"),
+    machine: MATCHINE = typer.Option(default=..., help=f"Machine to run agents on. One of {', '.join(get_args(MATCHINE))}"),
+    model: MODEL = typer.Option(default=..., help=f"Model to use (for crush agent). One of {', '.join(get_args(MODEL)[:3])}"),
+    provider: PROVIDER = typer.Option(default=..., help=f"Provider to use (for crush agent). One of {', '.join(get_args(PROVIDER)[:3])}"),
+    context_path: Optional[Path] = typer.Option(None, help="Path to the context file/folder, defaults to .ai/todo/"),
     separator: str = typer.Option("\n", help="Separator for context"),
     tasks_per_prompt: int = typer.Option(13, help="Number of tasks per prompt"),
-
-    agent: AGENTS = typer.Option(..., help=f"Agent type. One of {', '.join(get_args(AGENTS))}"),
-    machine: MATCHINE = typer.Option(..., help=f"Machine to run agents on. One of {', '.join(get_args(MATCHINE))}"),
-    model: MODEL = typer.Option(..., help=f"Model to use (for crush agent). One of {', '.join(get_args(MODEL))}"),
-    provider: PROVIDER = typer.Option(..., help=f"Provider to use (for crush agent). One of {', '.join(get_args(PROVIDER))}"),
-
     prompt: Optional[str] = typer.Option(None, help="Prompt prefix as string"),
     prompt_path: Optional[Path] = typer.Option(None, help="Path to prompt file"),
     job_name: str = typer.Option("AI_Agents", help="Job name"),
@@ -34,17 +25,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 +41,23 @@ def create(
         raise typer.Exit(1)
     typer.echo(f"Operating @ {repo_root}")
     
-    search_strategy = ""
-    prompt_material_path = Path("")
+    if context_path is None:
+        context_path = repo_root / ".ai" / "todo"
+        
+    context_path_resolved = context_path.expanduser().resolve()
+    if not context_path_resolved.exists():
+        raise typer.BadParameter(f"Path does not exist: {context_path_resolved}")
     
-    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
+    if context_path_resolved.is_file():
+        prompt_material_re_splitted = chunk_prompts(context_path_resolved, tasks_per_prompt=tasks_per_prompt, joiner=separator)
+    elif context_path_resolved.is_dir():
+        files = [f for f in context_path_resolved.rglob("*") if f.is_file()]
+        if not files:
+            raise typer.BadParameter(f"No files found in directory: {context_path_resolved}")
+        concatenated = separator.join(f.read_text(encoding="utf-8") for f in files)
+        prompt_material_re_splitted = [concatenated]
+    else:
+        raise typer.BadParameter(f"Path is neither file nor directory: {context_path_resolved}")
     
     if prompt_path is not None:
         prompt_prefix = prompt_path.read_text(encoding="utf-8")
@@ -90,7 +65,6 @@ def create(
         prompt_prefix = cast(str, prompt)
     agent_selected = agent
     keep_material_in_separate_file_input = separate_prompt_from_context
-    prompt_material_re_splitted = chunk_prompts(prompt_material_path, tasks_per_prompt=tasks_per_prompt, joiner=separator)
     if agents_dir is None: agents_dir = repo_root / ".ai" / f"tmp_prompts/{job_name}_{randstr()}"
     else:
         import shutil
@@ -103,8 +77,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 "{context_path_resolved}" \\
     --prompt-path "{prompt_path or ''}" \\
     --agent "{agent_selected}" \\
     --machine "{machine}" \\
@@ -187,27 +160,32 @@ 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 = typer.Typer(help="🤖 AI Agents management subcommands", no_args_is_help=True)
+    sep = "\n"
+    agents_full_help = f"""
+Create agents layout file, ready to run.
+{sep}
+PROVIDER options: {', '.join(get_args(PROVIDER))}
+{sep}
+AGENT options: {', '.join(get_args(AGENTS))}
+{sep}
+MODEL options: {sep.join(get_args(MODEL))}
+"""
+    agents_app.command("create", no_args_is_help=True, help=agents_full_help)(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():
     agents_app = get_app()
-    import sys
-    if len(sys.argv) == 1:
-        agents_app(["--help"])
-    else:
-        agents_app()
-
+    agents_app()
 
 if __name__ == "__main__":  # pragma: no cover
     pass

machineconfig-5.67/src/machineconfig/scripts/python/ai/generate_files.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+"""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, 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 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 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))
+
+    return sorted(filtered_files)
+
+
+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]
+
+
+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("./")
+        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()
+
+
+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 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 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]
+
+
+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: 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("-s", "--strategy", help="Strategy to filter files: 'name' for filename matching, 'keywords' for content matching")] = "name",
+    exclude_init: Annotated[bool, typer.Option("-e", "--exclude-init", help="Exclude __init__.py files from the checklist")] = False,
+    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", help="Split output into multiple files, each containing at most this many results")] = None,
+    split_to: Annotated[Optional[int], typer.Option("--split-to", 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__":
+    typer.run(main)
+    # typer.run(create_symlink_command)

{machineconfig-5.65 → machineconfig-5.67}/src/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.65,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-5.65 → machineconfig-5.67}/src/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.65,textual {path}")
+    run_shell_script(f"uv run --with machineconfig>=5.65,textual {path}")
 
 
 @cli_app.command(no_args_is_help=True)

machineconfig-5.67/src/machineconfig/scripts/python/devops_navigator.py

@@ -0,0 +1,10 @@
+"""
+TUI for navigating through machineconfig command structure using Textual.
+"""
+
+from machineconfig.scripts.python.helper_navigator import CommandNavigatorApp
+
+
+if __name__ == "__main__":
+    app = CommandNavigatorApp()
+    app.run()

machineconfig-5.67/src/machineconfig/scripts/python/helper_navigator/__init__.py

@@ -0,0 +1,20 @@
+"""
+Helper modules for the devops navigator TUI application.
+"""
+
+from machineconfig.scripts.python.helper_navigator.data_models import CommandInfo, ArgumentInfo
+from machineconfig.scripts.python.helper_navigator.command_builder import CommandBuilderScreen
+from machineconfig.scripts.python.helper_navigator.command_tree import CommandTree
+from machineconfig.scripts.python.helper_navigator.command_detail import CommandDetail
+from machineconfig.scripts.python.helper_navigator.search_bar import SearchBar
+from machineconfig.scripts.python.helper_navigator.main_app import CommandNavigatorApp
+
+__all__ = [
+    "CommandInfo",
+    "ArgumentInfo",
+    "CommandBuilderScreen",
+    "CommandTree",
+    "CommandDetail",
+    "SearchBar",
+    "CommandNavigatorApp",
+]