machineconfig 6.82__py3-none-any.whl → 7.98__py3-none-any.whl

machineconfig/scripts/python/helpers_devops/cli_utils.py

@@ -1,80 +1,7 @@
 
 
 import typer
-from typing import Annotated, Literal, Optional, TypedDict
-from pathlib import Path
-
-
-def download(
-    url: Annotated[Optional[str], typer.Argument(..., help="The URL to download the file from.")] = None,
-    decompress: Annotated[bool, typer.Option("--decompress", "-d", help="Decompress the file if it's an archive.")] = False,
-    output: Annotated[Optional[str], typer.Option("--output", "-o", help="The output file path.")] = None,
-) -> None:
-    if url is None:
-        typer.echo("❌ Error: URL is required.", err=True)
-        raise typer.Exit(code=1)
-    typer.echo(f"📥 Downloading from: {url}")    
-    download_path = Path(output) if output else Path(url.split("/")[-1])
-    import requests
-    import subprocess
-    try:
-        response = requests.get(url, allow_redirects=True, stream=True, timeout=60)
-        response.raise_for_status()
-        
-        total_size = int(response.headers.get('content-length', 0))
-        
-        with open(download_path, 'wb') as f:
-            if total_size == 0:
-                f.write(response.content)
-            else:
-                downloaded = 0
-                chunk_size = 8192
-                for chunk in response.iter_content(chunk_size=chunk_size):
-                    if chunk:
-                        f.write(chunk)
-                        downloaded += len(chunk)
-                        progress = (downloaded / total_size) * 100
-                        typer.echo(f"\r⏬ Progress: {progress:.1f}% ({downloaded}/{total_size} bytes)", nl=False)
-                typer.echo()
-        
-        typer.echo(f"✅ Downloaded to: {download_path}")
-    except requests.exceptions.RequestException as e:
-        typer.echo(f"❌ Download failed: {e}", err=True)
-        raise typer.Exit(code=1)
-    except OSError as e:
-        typer.echo(f"❌ File write error: {e}", err=True)
-        raise typer.Exit(code=1)
-    
-    if decompress:
-        typer.echo(f"📦 Decompressing: {download_path}")
-        
-        base_name = download_path.name
-        parts = base_name.split('.')
-        base_name = parts[0] if parts else download_path.stem
-        
-        extract_dir = download_path.parent / base_name
-        extract_dir.mkdir(parents=True, exist_ok=True)
-        
-        try:
-            subprocess.run(
-                ["ouch", "decompress", str(download_path), "--dir", str(extract_dir)],
-                check=True,
-                capture_output=True,
-                text=True
-            )
-            typer.echo(f"✅ Decompressed to: {extract_dir}")
-            
-            if download_path.exists():
-                download_path.unlink()
-                typer.echo(f"🗑️  Removed archive: {download_path}")
-                
-        except subprocess.CalledProcessError as e:
-            typer.echo(f"❌ Decompression failed: {e.stderr}", err=True)
-            raise typer.Exit(code=1)
-        except FileNotFoundError:
-            typer.echo("❌ Error: ouch command not found. Please install ouch.", err=True)
-            typer.echo("💡 Install with: cargo install ouch", err=True)
-            raise typer.Exit(code=1)
+from typing import Annotated, Optional
 
 
 def merge_pdfs(
@@ -109,7 +36,8 @@ def merge_pdfs(
         writer.write(output_path)
         print(f"✅ Merged PDF saved to: {output_path}")
     from machineconfig.utils.meta import lambda_to_python_script
-    code = lambda_to_python_script(lambda : merge_pdfs_internal(pdfs=pdfs, output=output, compress=compress), in_global=True, import_module=False)
+    code = lambda_to_python_script(lambda : merge_pdfs_internal(pdfs=pdfs, output=output, compress=compress),
+                                   in_global=True, import_module=False)
     from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
     uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=["pypdf"], uv_project_dir=None)
     run_shell_script(uv_command)
@@ -166,56 +94,3 @@ def compress_pdf(
     uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=["pymupdf"], uv_project_dir=None)
     run_shell_script(uv_command)
 
-
-class MachineSpecs(TypedDict):
-    system: str
-    distro: str
-    home_dir: str
-def get_machine_specs() -> MachineSpecs:
-    """Write print and return the local machine specs."""
-    import platform
-    UV_RUN_CMD = "$HOME/.local/bin/uv run" if platform.system() != "Windows" else """& "$env:USERPROFILE/.local/bin/uv" run"""
-    command = f"""{UV_RUN_CMD} --with distro python -c "import distro; print(distro.name(pretty=True))" """
-    import subprocess
-    distro = subprocess.run(command, shell=True, capture_output=True, text=True).stdout.strip()
-    specs: MachineSpecs = {
-        "system": platform.system(),
-        "distro": distro,
-        "home_dir": str(Path.home()),
-    }
-    print(specs)
-    from machineconfig.utils.source_of_truth import CONFIG_ROOT
-    path = CONFIG_ROOT.joinpath("machine_specs.json")
-    CONFIG_ROOT.mkdir(parents=True, exist_ok=True)
-    import json
-    path.write_text(json.dumps(specs, indent=4), encoding="utf-8")
-    return specs
-
-
-def init_project(python: Annotated[Literal["3.13", "3.14"], typer.Option("--python", "-p", help="Python version for the uv virtual environment.")]= "3.13") -> None:
-    _ = python
-    repo_root = Path.cwd()
-    if not (repo_root / "pyproject.toml").exists():
-        typer.echo("❌ Error: pyproject.toml not found.", err=True)
-        raise typer.Exit(code=1)
-    print(f"Adding group `plot` with common data science and plotting packages...")
-    script = """
-uv add --group plot \
-    # Data & computation
-    numpy pandas polars duckdb-engine python-magic \
-    # Plotting / visualization
-    matplotlib plotly kaleido \
-    # Notebooks / interactive
-    ipython ipykernel jupyterlab nbformat marimo \
-    # Code analysis / type checking / linting
-    mypy pyright ruff pylint pyrefly \
-    # Packaging / build / dev
-    cleanpy \
-    # CLI / debugging / utilities
-    ipdb pudb \
-    # Type hints for packages
-    types-python-dateutil types-pyyaml types-requests types-tqdm \
-    types-mysqlclient types-paramiko types-pytz types-sqlalchemy types-toml types-urllib3 \
-"""
-    from machineconfig.utils.code import run_shell_script
-    run_shell_script(script)

machineconfig/scripts/python/helpers_devops/devops_backup_retrieve.py

@@ -2,7 +2,6 @@
 
 # import subprocess
 from machineconfig.utils.io import read_ini
-from machineconfig.utils.path_extended import PathExtended
 from machineconfig.utils.source_of_truth import LIBRARY_ROOT, DEFAULTS_PATH
 from machineconfig.utils.code import print_code
 from machineconfig.utils.options import choose_cloud_interactively, choose_from_options
@@ -11,6 +10,7 @@ from platform import system
 from typing import Any, Literal, Optional
 from rich.console import Console
 from rich.panel import Panel
+from pathlib import Path
 import tomllib
 
 
@@ -56,13 +56,13 @@ def main_backup_retrieve(direction: OPTIONS, which: Optional[str], cloud: Option
         flags += "e" if item["encrypt"] == "True" else ""
         flags += "r" if item["rel2home"] == "True" else ""
         flags += "o" if system().lower() in item_name else ""
-        console.print(Panel(f"📦 PROCESSING: {item_name}\n📂 Path: {PathExtended(item['path']).as_posix()}\n🏳️  Flags: {flags or 'None'}", title=f"[bold blue]Processing Item: {item_name}[/bold blue]", border_style="blue"))
+        console.print(Panel(f"📦 PROCESSING: {item_name}\n📂 Path: {Path(item['path']).as_posix()}\n🏳️  Flags: {flags or 'None'}", title=f"[bold blue]Processing Item: {item_name}[/bold blue]", border_style="blue"))
         if flags:
             flags = "-" + flags
         if direction == "BACKUP":
-            program += f"""\ncloud_copy "{PathExtended(item["path"]).as_posix()}" $cloud {flags}\n"""
+            program += f"""\ncloud_copy "{Path(item["path"]).as_posix()}" $cloud {flags}\n"""
         elif direction == "RETRIEVE":
-            program += f"""\ncloud_copy $cloud "{PathExtended(item["path"]).as_posix()}" {flags}\n"""
+            program += f"""\ncloud_copy $cloud "{Path(item["path"]).as_posix()}" {flags}\n"""
         else:
             console.print(Panel('❌ ERROR: INVALID DIRECTION\n⚠️  Direction must be either "BACKUP" or "RETRIEVE"', title="[bold red]Error: Invalid Direction[/bold red]", border_style="red"))
             raise RuntimeError(f"Unknown direction: {direction}")

machineconfig/scripts/python/helpers_devops/devops_status.py

@@ -17,22 +17,6 @@ from machineconfig.utils.source_of_truth import CONFIG_ROOT, DEFAULTS_PATH, LIBR
 console = Console()
 
 
-def _check_system_info() -> dict[str, str]:
-    """Gather basic system information."""
-    import socket
-    import os
-
-    return {
-        "hostname": socket.gethostname(),
-        "system": platform.system(),
-        "release": platform.release(),
-        "version": platform.version(),
-        "machine": platform.machine(),
-        "processor": platform.processor() or "Unknown",
-        "python_version": platform.python_version(),
-        "user": os.getenv("USER") or os.getenv("USERNAME") or "Unknown",
-    }
-
 
 def _check_shell_profile_status() -> dict[str, Any]:
     """Check shell profile configuration status."""
@@ -480,10 +464,14 @@ def main() -> None:
     console.print("\n")
     console.print(Panel(Text("📊 Machine Status Report", justify="center", style="bold white"), style="bold blue", padding=(1, 2)))
     console.print("\n")
-
-    system_info = _check_system_info()
+    
+    # system_info = _check_system_info()
+    # from machineconfig.scripts.python.helpers_devops.devops_system_info import _check_system_info
+    from machineconfig.scripts.python.helpers_utils.path import get_machine_specs
+    system_info = get_machine_specs()
+    from typing import cast
+    system_info = cast(dict[str, str], system_info)
     _display_system_info(system_info)
-
     shell_status = _check_shell_profile_status()
     _display_shell_status(shell_status)
 

machineconfig/scripts/python/helpers_devops/themes/choose_wezterm_theme.py

@@ -45,7 +45,7 @@ schemes_list = [
 
 def main2():
     console.print(Panel("🎨 WezTerm Theme Selector", title_align="left", border_style="green"))
-    option = choose_from_options(multi=False, options=schemes_list, header="Choose a theme for Wezterm", fzf=True, msg="Use arrow keys to navigate, Enter to select a theme")
+    option = choose_from_options(multi=False, options=schemes_list, header="Choose a theme for Wezterm", tv=True, msg="Use arrow keys to navigate, Enter to select a theme")
     set_theme(option)
     print(f"✅ Theme set to: {option}")
 

machineconfig/scripts/python/{helpers_fire/helpers4.py → helpers_fire_command/file_wrangler.py}

@@ -1,24 +1,7 @@
-
 from typing import Optional
 import os
-from machineconfig.utils.path_extended import PathExtended
-
-
-def search_for_files_of_interest(path_obj: PathExtended):
-    if path_obj.joinpath(".venv").exists():
-        path_objects = path_obj.search("*", not_in=[".venv"])
-        files: list[PathExtended] = []
-        for a_path_obj in path_objects:
-            files += search_for_files_of_interest(path_obj=a_path_obj)
-        return files
-    if path_obj.is_file():
-        return [path_obj]
-    py_files = path_obj.search(pattern="*.py", not_in=["__init__.py"], r=True)
-    ps_files = path_obj.search(pattern="*.ps1", r=True)
-    sh_files = path_obj.search(pattern="*.sh", r=True)
-    files = py_files + ps_files + sh_files
-    return files
-
+from pathlib import Path
+import platform
 
 
 def parse_pyfile(file_path: str):
@@ -29,7 +12,7 @@ def parse_pyfile(file_path: str):
     func_args: list[list[args_spec]] = [[]]  # this firt prepopulated dict is for the option 'RUN AS MAIN' which has no args
     import ast
 
-    parsed_ast = ast.parse(PathExtended(file_path).read_text(encoding="utf-8"))
+    parsed_ast = ast.parse(Path(file_path).read_text(encoding="utf-8"))
     functions = [node for node in ast.walk(parsed_ast) if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))]
     module__doc__ = ast.get_docstring(parsed_ast)
     main_option = f"RUN AS MAIN -- {module__doc__ if module__doc__ is not None else 'NoDocs'}"
@@ -110,3 +93,56 @@ def get_import_module_code(module_path: str):
         module_name = "IncorrectModuleName"
     # TODO: use py_compile to check if the statement is valid code to avoid syntax errors that can't be caught.
     return f"from {module_name} import *"
+
+
+def wrap_import_in_try_except(import_line: str, pyfile: str, repo_root: Optional[str] = None) -> None:
+    try:
+        exec(import_line)  # type: ignore
+    except (ImportError, ModuleNotFoundError) as ex:
+        print(fr"❌ Failed to import `{pyfile}` as a module: {ex} ")
+        print("⚠️ Attempting import with ad-hoc `$PATH` manipulation. DO NOT pickle any objects in this session as correct deserialization cannot be guaranteed.")
+        import sys
+        sys.path.append(str(Path(pyfile).parent))
+        if repo_root is not None:
+            sys.path.append(repo_root)
+        exec(f"from {Path(pyfile).stem} import *")
+        print(fr"✅ Successfully imported `{pyfile}`")
+
+
+def add_to_path(path_variable: str, directory: str) -> str:
+    """
+    Generate shell script to add directory to path_variable.
+    Handles both Windows (cmd) and Unix-like systems (bash/zsh).
+    Checks if variable exists before appending, otherwise creates it.
+    """
+    system = platform.system()
+    
+    if system == "Windows":
+        script = f"""# Check if {path_variable} is defined
+if (Test-Path env:{path_variable}) {{
+    Write-Host "Adding {directory} to existing {path_variable}"
+    $currentValue = [Environment]::GetEnvironmentVariable("{path_variable}", "User")
+    $newValue = "$currentValue;{directory}"
+    [Environment]::SetEnvironmentVariable("{path_variable}", $newValue, "User")
+    $env:{path_variable} = $newValue
+}} else {{
+    Write-Host "Creating new {path_variable} variable"
+    [Environment]::SetEnvironmentVariable("{path_variable}", "{directory}", "User")
+    $env:{path_variable} = "{directory}"
+}}
+Write-Host "{path_variable} is now: $env:{path_variable}\""""
+        return script
+    else:
+        script = f"""#!/bin/bash
+# Check if {path_variable} is defined and not empty
+if [ -z "${{{path_variable}}}" ]; then
+    echo "Creating new {path_variable} variable"
+    export {path_variable}="{directory}"
+else
+    echo "Adding {directory} to existing {path_variable}"
+    export {path_variable}="${{{path_variable}}}:{directory}"
+fi
+echo "{path_variable} is now: ${{{path_variable}}}"
+"""
+        return script
+

machineconfig/scripts/python/helpers_fire_command/fire_jobs_route_helper.py

@@ -5,11 +5,10 @@ from typing import Optional
 import tomllib
 from pathlib import Path
 from machineconfig.utils.accessories import randstr
-from machineconfig.utils.path_extended import PathExtended
 from machineconfig.utils.options import choose_from_options
 
 
-def choose_function_or_lines(choice_file: PathExtended, kwargs_dict: dict[str, object]) -> tuple[Optional[str], PathExtended, dict[str, object]]:
+def choose_function_or_lines(choice_file: Path, kwargs_dict: dict[str, object]) -> tuple[Optional[str], Path, dict[str, object]]:
     """
     Choose a function to run from a Python file or lines from a shell script.
     
@@ -22,9 +21,9 @@ def choose_function_or_lines(choice_file: PathExtended, kwargs_dict: dict[str, o
     choice_function: Optional[str] = None
     
     if choice_file.suffix == ".py":
-        from machineconfig.scripts.python.helpers_fire.helpers4 import parse_pyfile
+        from machineconfig.scripts.python.helpers_fire_command.file_wrangler import parse_pyfile
         options, func_args = parse_pyfile(file_path=str(choice_file))
-        choice_function_tmp = choose_from_options(msg="Choose a function to run", options=options, fzf=True, multi=False)
+        choice_function_tmp = choose_from_options(msg="Choose a function to run", options=options, tv=True, multi=False)
         assert isinstance(choice_function_tmp, str), f"choice_function must be a string. Got {type(choice_function_tmp)}"
         choice_index = options.index(choice_function_tmp)
         choice_function = choice_function_tmp.split(" -- ")[0]
@@ -45,8 +44,8 @@ def choose_function_or_lines(choice_file: PathExtended, kwargs_dict: dict[str, o
             if line.startswith("echo"):
                 continue
             options.append(line)
-        chosen_lines = choose_from_options(msg="Choose a line to run", options=options, fzf=True, multi=True)
-        choice_file = PathExtended.tmpfile(suffix=".sh")
+        chosen_lines = choose_from_options(msg="Choose a line to run", options=options, tv=True, multi=True)
+        choice_file = Path.home().joinpath(f"tmp_results/tmp_scripts/shell/{randstr(10)}.sh")
         choice_file.parent.mkdir(parents=True, exist_ok=True)
         choice_file.write_text("\n".join(chosen_lines), encoding="utf-8")
         choice_function = None
@@ -55,15 +54,13 @@ def choose_function_or_lines(choice_file: PathExtended, kwargs_dict: dict[str, o
 
 
 def get_command_streamlit(choice_file: Path, environment: str, repo_root: Optional[Path]) -> str:
-    import socket
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    try:
-        s.connect(("8.8.8.8", 1))
-        local_ip_v4 = s.getsockname()[0]
-    except Exception:
-        local_ip_v4 = socket.gethostbyname(socket.gethostname())
-    finally:
-        s.close()
+    # from machineconfig.scripts.python.helpers_utils.path import get_machine_specs
+    from machineconfig.scripts.python.helpers_network.address import select_lan_ipv4
+    res = select_lan_ipv4(prefer_vpn=False)
+    if res is None:
+        raise RuntimeError("Could not determine local LAN IPv4 address for streamlit app.")
+    local_ip_v4 = res
+
     computer_name = platform.node()
     port = 8501
     toml_path: Optional[Path] = None
@@ -82,7 +79,7 @@ def get_command_streamlit(choice_file: Path, environment: str, repo_root: Option
                 port = config["server"]["port"]
         secrets_path = toml_path.with_name("secrets.toml")
         if repo_root is not None:
-            secrets_template_path = Path.home().joinpath(f"dotfiles/creds/streamlit/{PathExtended(repo_root).name}/{choice_file.name}/secrets.toml")
+            secrets_template_path = Path.home().joinpath(f"dotfiles/creds/streamlit/{Path(repo_root).name}/{choice_file.name}/secrets.toml")
             if environment != "" and not secrets_path.exists() and secrets_template_path.exists():
                 secrets_template = tomllib.loads(secrets_template_path.read_text(encoding="utf-8"))
                 if environment == "ip":
@@ -101,6 +98,19 @@ def get_command_streamlit(choice_file: Path, environment: str, repo_root: Option
                 except Exception as ex:
                     print(ex)
                     raise ex
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
+    install_if_missing("qrterminal")
+    script = f"""
+qrterminal "http://{local_ip_v4}:{port}"
+echo "http://{local_ip_v4}:{port}"
+qrterminal "http://{computer_name}:{port}"
+echo "http://{computer_name}:{port}"
+"""
+    # from machineconfig.utils.code import run_shell_script
+    # run_shell_script(script)
+    from machineconfig.utils.code import print_code
+    print_code(code=script, lexer="shell", desc="Streamlit QR Codes and URLs")
+
     message = f"🚀 Streamlit app is running @:\n1- http://{local_ip_v4}:{port}\n2- http://{computer_name}:{port}\n3- http://localhost:{port}"
     from rich.panel import Panel
     from rich import print as rprint

machineconfig/scripts/python/helpers_msearch/__init__.py

@@ -0,0 +1,5 @@
+
+from pathlib import Path
+
+FZFG_LINUX_PATH = Path(__file__).parent.joinpath("scripts_linux", "fzfg")
+FZFG_WINDOWS_PATH = Path(__file__).parent.joinpath("scripts_windows", "fzfg.ps1")

machineconfig/scripts/{linux → python/helpers_msearch/scripts_linux}/fzfg

@@ -13,11 +13,11 @@ IFS=: read -ra selected < <(
       --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
       --bind "ctrl-f:unbind(change,ctrl-f)+change-prompt(2. fzf> )+enable-search+clear-query+rebind(ctrl-r)" \
       --bind "ctrl-r:unbind(ctrl-r)+change-prompt(1. ripgrep> )+disable-search+reload($RG_PREFIX {q} || true)+rebind(change,ctrl-f)" \
-      --prompt '1. Ripgrep> ' \
+      --prompt '1. ripgrep> ' \
       --delimiter : \
-      --header '╱ CTRL-R (Ripgrep mode) ╱ CTRL-F (fzf mode) ╱' \
+      --header '╱ CTRL-R (ripgrep mode) ╱ CTRL-F (fzf mode) ╱' \
       --preview 'bat --color=always {1} --highlight-line {2}' \
       --preview-window 'up,60%,border-bottom,+{2}+3/3,~3'
 )
-[ -n "${selected[0]}" ] && lvim "${selected[0]}" "+${selected[1]}
+[ -n "${selected[0]}" ] && hx "${selected[0]}:${selected[1]}:${selected[2]}"
 "

machineconfig/scripts/python/helpers_msearch/scripts_windows/fzfg.ps1

@@ -0,0 +1,59 @@
+#!/usr/bin/env pwsh
+[CmdletBinding()]
+param(
+    [Parameter(ValueFromRemainingArguments = $true)]
+    [string[]]$QueryTokens
+)
+
+if ($null -eq $QueryTokens) {
+    $QueryTokens = @()
+}
+
+$initialQuery = if ($QueryTokens.Count -gt 0) { [string]::Join(' ', $QueryTokens) } else { '' }
+$rgPrefix = 'rg --column --line-number --no-heading --color=always --smart-case '
+
+$escapedDefault = if ($initialQuery.Length -gt 0) {
+    $rgPrefix + '"' + $initialQuery.Replace('"', '""') + '" || type nul'
+} else {
+    'type nul'
+}
+
+$previousDefault = $env:FZF_DEFAULT_COMMAND
+$env:FZF_DEFAULT_COMMAND = $escapedDefault
+
+$reloadBinding = "change:reload:$rgPrefix{q} || type nul"
+$ctrlFBinding = 'ctrl-f:unbind(change,ctrl-f)+change-prompt(2. fzf> )+enable-search+clear-query+rebind(ctrl-r)'
+$ctrlRBinding = "ctrl-r:unbind(ctrl-r)+change-prompt(1. ripgrep> )+disable-search+reload($rgPrefix{q} || type nul)+rebind(change,ctrl-f)"
+
+try {
+    $selectionRaw = & fzf --ansi `
+        --color 'hl:-1:underline,hl+:-1:underline:reverse' `
+        --disabled `
+        --query $initialQuery `
+        --bind $reloadBinding `
+        --bind $ctrlFBinding `
+        --bind $ctrlRBinding `
+        --prompt '1. ripgrep> ' `
+        --delimiter ':' `
+        --header 'CTRL-R (ripgrep mode) | CTRL-F (fzf mode)' `
+        --preview 'bat --color=always {1} --highlight-line {2}' `
+        --preview-window 'up,60%,border-bottom,+{2}+3/3,~3'
+}
+finally {
+    if ($null -ne $previousDefault) {
+        $env:FZF_DEFAULT_COMMAND = $previousDefault
+    } else {
+        Remove-Item Env:FZF_DEFAULT_COMMAND -ErrorAction SilentlyContinue
+    }
+}
+
+if ($LASTEXITCODE -ne 0 -or [string]::IsNullOrWhiteSpace($selectionRaw)) {
+    exit
+}
+
+if ($selectionRaw -match '^(?<path>.+?):(?<line>\d+):(?<column>\d+):') {
+    $path = $Matches['path']
+    $line = [int]$Matches['line']
+    $column = [int]$Matches['column']
+    & hx ("{0}:{1}:{2}" -f $path,$line,$column)
+}

machineconfig/scripts/python/helpers_navigator/command_tree.py

@@ -188,15 +188,7 @@ class CommandTree(Tree[CommandInfo]):
             description="Configure your shell profile",
             command="devops config shell",
             parent="config",
-            help_text="devops config shell <copy|reference>"
-        ))
-
-        config_node.add("🔗 path - Navigate PATH variable", data=CommandInfo(
-            name="path",
-            description="Navigate PATH variable with TUI",
-            command="devops config path",
-            parent="config",
-            help_text="devops config path"
+            help_text="devops config shell --which <default|nushell>"
         ))
 
         config_node.add("🔗 starship-theme - Select starship theme", data=CommandInfo(
@@ -560,7 +552,23 @@ class CommandTree(Tree[CommandInfo]):
             description="Choose a process to kill interactively",
             command="utils kill-process",
             parent="utils",
-            help_text="utils kill-process"
+            help_text="utils kill-process --interactive"
+        ))
+
+        utils_node.add("📚 path - Navigate PATH variable", data=CommandInfo(
+            name="path",
+            description="Navigate PATH variable with TUI",
+            command="utils path",
+            parent="utils",
+            help_text="utils path"
+        ))
+
+        utils_node.add("⬆️ upgrade-packages - Upgrade dependencies", data=CommandInfo(
+            name="upgrade-packages",
+            description="Upgrade project dependencies",
+            command="utils upgrade-packages",
+            parent="utils",
+            help_text="utils upgrade-packages"
         ))
 
         utils_node.add("⬇️ download - Download file", data=CommandInfo(
@@ -571,18 +579,42 @@ class CommandTree(Tree[CommandInfo]):
             help_text="utils download <url> --destination <path> --decompress"
         ))
 
-        utils_node.add("📄 merge-pdfs - Merge PDF files", data=CommandInfo(
-            name="merge-pdfs",
-            description="Merge two PDF files into one",
-            command="utils merge-pdfs",
-            parent="utils",
-            help_text="utils merge-pdfs <file1> <file2> --output <file>"
-        ))
-
         utils_node.add("🖥️ get-machine-specs - Get machine specifications", data=CommandInfo(
             name="get-machine-specs",
             description="Get machine specifications",
             command="utils get-machine-specs",
             parent="utils",
             help_text="utils get-machine-specs"
+        ))
+
+        utils_node.add("🚀 init-project - Initialize project", data=CommandInfo(
+            name="init-project",
+            description="Initialize a project with a uv virtual environment and install dev packages",
+            command="utils init-project",
+            parent="utils",
+            help_text="utils init-project"
+        ))
+
+        utils_node.add("✏️ edit - Open file in editor", data=CommandInfo(
+            name="edit",
+            description="Open a file in the default editor",
+            command="utils edit",
+            parent="utils",
+            help_text="utils edit <file>"
+        ))
+
+        utils_node.add("📄 pdf-merge - Merge PDF files", data=CommandInfo(
+            name="pdf-merge",
+            description="Merge two PDF files into one",
+            command="utils pdf-merge",
+            parent="utils",
+            help_text="utils pdf-merge <file1> <file2> --output <file>"
+        ))
+
+        utils_node.add("� pdf-compress - Compress PDF file", data=CommandInfo(
+            name="pdf-compress",
+            description="Compress a PDF file",
+            command="utils pdf-compress",
+            parent="utils",
+            help_text="utils pdf-compress <file> --output <file>"
         ))