machineconfig 7.50__py3-none-any.whl → 8.12__py3-none-any.whl

machineconfig/scripts/python/helpers_utils/download.py

@@ -0,0 +1,150 @@
+
+
+from typing import Annotated, Optional
+import typer
+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,
+    output_dir: Annotated[Optional[str], typer.Option("--output-dir", help="Directory to place the downloaded file in.")] = None,
+) -> Optional["Path"]:
+    import subprocess
+    from urllib.parse import parse_qs, unquote, urlparse
+    from requests import Response
+    import requests
+    from pathlib import Path
+    if url is None:
+        typer.echo("❌ Error: URL is required.", err=True)
+        return None
+    if output is not None and output_dir is not None:
+        typer.echo("❌ Error: --output and --output-dir cannot be used together.", err=True)
+        return None
+    typer.echo(f"📥 Downloading from: {url}")
+
+    def _sanitize_candidate_filename(name: str) -> Optional[str]:
+        candidate = Path(name).name.strip()
+        if not candidate or candidate in {".", ".."}:
+            return None
+        return candidate
+
+    def _filename_from_content_disposition(header_value: Optional[str]) -> Optional[str]:
+        if header_value is None:
+            return None
+        parts = [segment.strip() for segment in header_value.split(";")]
+        for part in parts:
+            lower = part.lower()
+            if lower.startswith("filename*="):
+                value = part.split("=", 1)[1]
+                value = value.strip().strip('"')
+                if "''" in value:
+                    value = value.split("''", 1)[1]
+                decoded = unquote(value)
+                sanitized = _sanitize_candidate_filename(decoded)
+                if sanitized is not None:
+                    return sanitized
+            if lower.startswith("filename="):
+                value = part.split("=", 1)[1].strip().strip('"')
+                decoded = unquote(value)
+                sanitized = _sanitize_candidate_filename(decoded)
+                if sanitized is not None:
+                    return sanitized
+        return None
+
+    def _filename_from_url(source_url: str) -> Optional[str]:
+        parsed = urlparse(source_url)
+        url_candidate = _sanitize_candidate_filename(unquote(Path(parsed.path).name))
+        if url_candidate is not None:
+            return url_candidate
+        query_params = parse_qs(parsed.query, keep_blank_values=True)
+        for key, values in query_params.items():
+            lower_key = key.lower()
+            if "name" in lower_key or "file" in lower_key:
+                for value in values:
+                    sanitized = _sanitize_candidate_filename(unquote(value))
+                    if sanitized is not None:
+                        return sanitized
+        return None
+
+    def _resolve_download_path(request_url: str, response: Response, requested_output: Optional[str], requested_output_dir: Optional[str]) -> Path:
+        if requested_output is not None:
+            return Path(requested_output)
+        header_candidate = _filename_from_content_disposition(response.headers.get("content-disposition"))
+        if header_candidate is None:
+            header_candidate = _filename_from_url(response.url)
+        if header_candidate is None:
+            header_candidate = _filename_from_url(request_url)
+        if header_candidate is None:
+            header_candidate = "downloaded_file"
+        if requested_output_dir is not None:
+            return Path(requested_output_dir) / header_candidate
+        return Path(header_candidate)
+
+    try:
+        with requests.get(url, allow_redirects=True, stream=True, timeout=60) as response:
+            response.raise_for_status()
+            download_path = _resolve_download_path(url, response, output, output_dir)
+            download_path.parent.mkdir(parents=True, exist_ok=True)
+            total_size_header = response.headers.get("content-length", "0")
+            try:
+                total_size = int(total_size_header)
+            except (TypeError, ValueError):
+                total_size = 0
+            if total_size <= 0:
+                with open(download_path, "wb") as file_handle:
+                    file_handle.write(response.content)
+            else:
+                downloaded = 0
+                chunk_size = 8192 * 40
+                with open(download_path, "wb") as file_handle:
+                    for chunk in response.iter_content(chunk_size=chunk_size):
+                        if not chunk:
+                            continue
+                        file_handle.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()
+    except requests.exceptions.RequestException as exception:
+        typer.echo(f"❌ Download failed: {exception}", err=True)
+        return None
+    except OSError as exception:
+        typer.echo(f"❌ File write error: {exception}", err=True)
+        return None
+
+    typer.echo(f"✅ Downloaded to: {download_path}")
+    result_path: Path = download_path
+    if decompress:
+        typer.echo(f"📦 Decompressing: {download_path}")
+        base_name = download_path.name.split(".", maxsplit=1)[0]  # ouch decompresses all (e.g. .tar.gz) in one go.
+        if base_name in {"", ".", ".."}:
+            base_name = "extracted"
+        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}")
+            result_path = extract_dir
+        except subprocess.CalledProcessError as exception:
+            typer.echo(f"❌ Decompression failed: {exception.stderr}", err=True)
+            return None
+        except FileNotFoundError:
+            typer.echo("❌ Error: ouch command not found. Please install ouch.", err=True)
+            typer.echo("💡 Install with: cargo install ouch", err=True)
+            return None
+
+    return result_path.resolve()
+
+
+if __name__ == "__main__":
+    pass

machineconfig/scripts/python/helpers_utils/pdf.py

@@ -0,0 +1,96 @@
+
+
+import typer
+from typing import Annotated, Optional
+
+
+def merge_pdfs(
+        pdfs: Annotated[list[str], typer.Argument(..., help="Paths to the PDF files to merge.")],
+        output: Annotated[Optional[str], typer.Option("--output", "-o", help="Output merged PDF file path.")] = None,
+        compress: Annotated[bool, typer.Option("--compress", "-c", help="Compress the output PDF.")] = False,
+    ) -> None:
+    def merge_pdfs_internal(pdfs: list[str], output: str | None, compress: bool) -> None:
+        from pypdf import PdfReader, PdfWriter
+        writer = PdfWriter()
+        for pdf_path in pdfs:
+            reader = PdfReader(pdf_path)
+            for page in reader.pages:
+                writer.add_page(page)
+        output_path = output if output else "merged.pdf"
+        if compress:
+            try:
+                for p in writer.pages:
+                    try:
+                        # PageObject.compress_content_streams exists in pypdf
+                        p.compress_content_streams()
+                    except Exception:
+                        # best-effort: ignore per-page compression failures
+                        continue
+            except Exception:
+                pass
+            try:
+                writer.compress_identical_objects()
+            except Exception:
+                # non-fatal if this fails
+                pass
+        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)
+    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)
+
+
+def compress_pdf(
+        pdf_input: Annotated[str, typer.Argument(..., help="Path to the input PDF file to compress.")],
+        output: Annotated[Optional[str], typer.Option("--output", "-o", help="Output compressed PDF file path.")] = None,
+        quality: Annotated[int, typer.Option("--quality", "-q", help="JPEG quality for image compression (0-100, 0=no change, 100=best).")] = 85,
+        image_dpi: Annotated[int, typer.Option("--image-dpi", "-d", help="Target DPI for image resampling. If set, images above this DPI will be downsampled.")] = 0,
+        # remove_images: Annotated[bool, typer.Option("--remove-images", "-r", help="Remove all images from the PDF.")] = False,
+        compress_streams: Annotated[bool, typer.Option("--compress-streams", "-c", help="Compress uncompressed streams.")] = True,
+        use_objstms: Annotated[bool, typer.Option("--object-streams", "-s", help="Use object streams for additional compression.")] = True,
+    ) -> None:
+    def compress_pdf_internal(pdf_input: str, output: str | None, quality: int, image_dpi: int, compress_streams: bool, use_objstms: bool) -> None:
+        import pymupdf
+        from pathlib import Path
+        output_path = output if output else pdf_input.replace(".pdf", "_compressed.pdf")
+        doc = pymupdf.open(pdf_input)
+        try:
+            # if remove_images:
+            #     for page in doc:
+            #         page.remove_images()
+            if quality > 0 or image_dpi > 0:
+                doc.rewrite_images(
+                    dpi_threshold=image_dpi if image_dpi > 0 else None,
+                    dpi_target=max(72, image_dpi - 10) if image_dpi > 72 else 72,
+                    quality=quality,
+                    lossy=True,
+                    lossless=True,
+                )
+            doc.save(
+                output_path,
+                deflate=compress_streams,
+                garbage=3,
+                use_objstms=1 if use_objstms else 0,
+            )
+            input_size = Path(pdf_input).stat().st_size
+            output_size = Path(output_path).stat().st_size
+            ratio = (1 - output_size / input_size) * 100
+            print(f"✅ Compressed PDF saved to: {output_path}")
+            print(f"   Original: {input_size / 1024 / 1024:.2f} MB")
+            print(f"   Compressed: {output_size / 1024 / 1024:.2f} MB")
+            print(f"   Reduction: {ratio:.1f}%")
+        finally:
+            doc.close()
+    from machineconfig.utils.meta import lambda_to_python_script
+    code = lambda_to_python_script(
+        lambda: compress_pdf_internal(pdf_input=pdf_input, output=output, quality=quality, image_dpi=image_dpi, compress_streams=compress_streams, use_objstms=use_objstms),
+        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=["pymupdf"], uv_project_dir=None)
+    run_shell_script(uv_command)
+

machineconfig/scripts/python/helpers_utils/python.py

@@ -0,0 +1,187 @@
+from tempfile import tempdir
+import typer
+from typing import Optional, Annotated, Literal, TypedDict, cast
+
+
+def tui_env(which: Annotated[Literal["PATH", "p", "ENV", "e"], typer.Argument(help="Which environment variable to display.")] = "ENV") -> None:
+    """📚 NAVIGATE PATH variable with TUI"""
+    from machineconfig.scripts.python import env_manager as navigator
+    from pathlib import Path
+
+    match which:
+        case "PATH" | "p":
+            path = Path(navigator.__file__).resolve().parent.joinpath("path_manager_tui.py")
+        case "ENV" | "e":
+            path = Path(navigator.__file__).resolve().parent.joinpath("env_manager_tui.py")
+    from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
+
+    uv_with = ["textual"]
+    uv_project_dir = None
+    if not Path.home().joinpath("code/machineconfig").exists():
+        uv_with.append("machineconfig>=8.12")
+    else:
+        uv_project_dir = str(Path.home().joinpath("code/machineconfig"))
+    run_shell_script(
+        get_uv_command_executing_python_script(python_script=path.read_text(encoding="utf-8"), uv_with=uv_with, uv_project_dir=uv_project_dir)[0]
+    )
+
+
+def init_project(
+    name: Annotated[Optional[str], typer.Option("--name", "-n", help="Name of the project.")] = None,
+    tmp_dir: Annotated[bool, typer.Option("--tmp-dir", "-t", help="Use a temporary directory for the project initialization.")] = False,
+    python: Annotated[
+        Literal["3.11", "3.12", "3.13", "3.14"], typer.Option("--python", "-p", help="Python sub version for the uv virtual environment.")
+    ] = "3.13",
+    libraries: Annotated[
+        Optional[str], typer.Option("--libraries", "-l", help="Additional packages to include in the uv virtual environment (space separated).")
+    ] = None,
+    group: Annotated[
+        Optional[str], typer.Option("--group", "-g", help="group of packages names (no separation) p:plot, t:types, l:linting, i:interactive, d:data")
+    ] = "ptlid",
+) -> None:
+    if libraries is not None:
+        packages_add_line = f"uv add {libraries}"
+    else:
+        packages_add_line = ""
+    from pathlib import Path
+
+    if not tmp_dir:
+        repo_root = Path.cwd()
+        if not (repo_root / "pyproject.toml").exists():
+            typer.echo(f"❌ Error: pyproject.toml not found in {repo_root}", err=True)
+            raise typer.Exit(code=1)
+        starting_code = ""
+    else:
+        if name is not None:
+            from machineconfig.utils.accessories import randstr
+
+            repo_root = Path.home().joinpath(f"tmp_results/tmp_projects/{name}")
+        else:
+            from machineconfig.utils.accessories import randstr
+
+            repo_root = Path.home().joinpath(f"tmp_results/tmp_projects/{randstr(6)}")
+        repo_root.mkdir(parents=True, exist_ok=True)
+        print(f"Using temporary directory for project initialization: {repo_root}")
+        starting_code = f"""
+cd {repo_root}
+uv init --python {python}
+uv venv
+"""
+    print(f"Adding group `{group}` with common data science and plotting packages...")
+    total_packages: list[str] = []
+    if group is not None:
+        if "t" in group:
+            total_packages.append(
+                "types-python-dateutil types-pyyaml types-requests types-tqdm types-mysqlclient types-paramiko types-pytz types-sqlalchemy types-toml types-urllib3"
+            )
+        if "l" in group:
+            total_packages.append("mypy pyright ruff pylint pyrefly cleanpy ipdb pudb")
+        if "i" in group:
+            total_packages.append("ipython ipykernel jupyterlab nbformat marimo")
+        if "p" in group:
+            total_packages.append("python-magic matplotlib plotly kaleido")
+        if "d" in group:
+            total_packages.append("numpy pandas polars duckdb-engine sqlalchemy  psycopg2-binary pyarrow tqdm openpyxl")
+    from machineconfig.utils.ve import get_ve_activate_line
+
+    script = f"""
+{starting_code}
+{packages_add_line}
+uv add --group {group} {" ".join(total_packages)}
+{get_ve_activate_line(ve_root=str(repo_root.joinpath(".venv")))}
+ls
+"""
+    from machineconfig.utils.code import exit_then_run_shell_script, run_shell_script
+    # exit_then_run_shell_script(script)
+    _ = exit_then_run_shell_script
+    run_shell_script(script)
+    if tempdir:
+        from machineconfig.scripts.python.ai.initai import add_ai_configs
+        add_ai_configs(repo_root=repo_root)
+
+
+def edit_file_with_hx(
+    path: Annotated[Optional[str], typer.Argument(..., help="The root directory of the project to edit, or a file path.")] = None,
+) -> None:
+    from pathlib import Path
+
+    if path is None:
+        root_path = Path.cwd()
+        print(f"No path provided. Using current working directory: {root_path}")
+    else:
+        root_path = Path(path).expanduser().resolve()
+        print(f"Using provided path: {root_path}")
+    from machineconfig.utils.accessories import get_repo_root
+
+    repo_root = get_repo_root(root_path)
+    if repo_root is not None and repo_root.joinpath("pyproject.toml").exists():
+        code = f"""
+cd {repo_root}
+uv add --dev pylsp-mypy python-lsp-server[all] pyright ruff-lsp  # for helix editor.
+source ./.venv/bin/activate
+"""
+    else:
+        code = ""
+    if root_path.is_file():
+        code += f"hx {root_path}"
+    else:
+        code += "hx"
+    from machineconfig.utils.code import exit_then_run_shell_script
+
+    exit_then_run_shell_script(code)
+
+
+class MachineSpecs(TypedDict):
+    system: Literal["Windows", "Linux", "Darwin"]
+    distro: str
+    home_dir: str
+    hostname: str
+    release: str
+    version: str
+    machine: str
+    processor: str
+    python_version: str
+    user: str
+
+
+def get_machine_specs() -> MachineSpecs:
+    """Write print and return the local machine specs."""
+    import platform
+    from machineconfig.utils.code import get_uv_run_command
+
+    uv_run_cmd = get_uv_run_command(platform=platform.system())  # type: ignore
+    command = f"""{uv_run_cmd} --with distro python -c "import distro; print(distro.name(pretty=True))" """
+    import subprocess
+    from pathlib import Path
+    import socket
+    import os
+
+    distro = subprocess.run(command, shell=True, capture_output=True, text=True).stdout.strip()
+    system = platform.system()
+    if system not in {"Windows", "Linux", "Darwin"}:
+        system = "Linux"
+    specs: MachineSpecs = {
+        "system": cast(Literal["Windows", "Linux", "Darwin"], system),
+        "distro": distro,
+        "home_dir": str(Path.home()),
+        "hostname": socket.gethostname(),
+        "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",
+    }
+    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
+
+
+if __name__ == "__main__":
+    get_machine_specs()

machineconfig/scripts/python/interactive.py

@@ -19,9 +19,7 @@ for better user experience with checkbox selections.
 
 import sys
 from pathlib import Path
-# from typing import cast
 import platform
-
 import questionary
 from questionary import Choice
 from rich.console import Console
@@ -29,12 +27,11 @@ from rich.panel import Panel
 from rich.text import Text
 from machineconfig.utils.code import run_shell_script
 
-# _ = cast
 console = Console()
 
 
 def display_header() -> None:
-    from machineconfig.utils.installer import get_machineconfig_version
+    from machineconfig.utils.installer_utils.installer_runner import get_machineconfig_version
     from rich.align import Align
 
     # Fancy ASCII art header
@@ -96,35 +93,29 @@ def display_dotfiles_instructions() -> None:
 def get_installation_choices() -> list[str]:
     """Get user choices for installation options."""
     choices = [
-        Choice(value="install_machineconfig", title="🐍 Install machineconfig.", checked=False),
-        Choice(value="ESSENTIAL_SYSTEM", title="📥 Install Essential System Packages.", checked=False),
-        Choice(value="ESSENTIAL", title="⚡ Install CLI apps essentials", checked=False),
-        Choice(value="DEV_SYSTEM", title="🛠️  Install CLI apps development.", checked=False),
-        Choice(value="TerminalEyeCandy", title="🎨 Install CLI apps terminal eye candy.", checked=False),
-        Choice(value="install_ssh_server", title="🔒 Install SSH Server", checked=False),
-        Choice(value="install_shell_profile", title="🐚 Configure Shell Profile.", checked=False),
-        Choice(value="retrieve_repositories", title="📚 Retrieve Repositories", checked=False),
-        Choice(value="retrieve_data", title="💾 Retrieve Data.", checked=False),
+        Choice(value="install_machineconfig", title="🐍 Install machineconfig cli.", checked=False),
+        Choice(value="sysabc", title="📥 Install System Package Manager (Needed for other apps to be installed).", checked=False),
+        Choice(value="termabc", title="⚡ Install Terminal CLI apps essentials (group `termabc`)", checked=False),
+        Choice(value="install_shell_profile", title="🐚 Configure Shell Profile And Map Other Configs.", checked=False),
+        Choice(value="install_ssh_server", title="🔒 [ADVANCED] Configure SSH Server", checked=False),
+        Choice(value="retrieve_repositories", title="📚 [ADVANCED] Retrieve Repositories", checked=False),
+        Choice(value="retrieve_data", title="💾 [ADVANCED] Retrieve Data.", checked=False),
     ]
-    # Add Windows-specific options
-    if platform.system() == "Windows":
-        choices.append(Choice(value="install_windows_desktop", title="💻 Install Windows Desktop Apps   - Install nerd fonts and set WT config.", checked=False))
     selected = questionary.checkbox("Select the installation options you want to execute:", choices=choices, show_description=True).ask()
     return selected or []
 
 
 def execute_installations(selected_options: list[str]) -> None:
     for maybe_a_group in selected_options:
-        if maybe_a_group in ("ESSENTIAL", "DEV", "ESSENTIAL_SYSTEM", "DEV_SYSTEM", "TerminalEyeCandy"):
+        if maybe_a_group in ("termabc", "sysabc"):
             console.print(Panel("⚡ [bold bright_yellow]CLI APPLICATIONS[/bold bright_yellow]\n[italic]Command-line tools installation[/italic]", border_style="bright_yellow"))
             console.print("🔧 Installing CLI applications", style="bold cyan")
             try:
-                from machineconfig.utils.installer_utils.installer import main as devops_devapps_install_main
+                from machineconfig.utils.installer_utils.installer_cli import main_installer_cli as devops_devapps_install_main
                 devops_devapps_install_main(group=True, which=maybe_a_group, interactive=False)
                 console.print("✅ CLI applications installed successfully", style="bold green")
             except Exception as e:
                 console.print(f"❌ Error installing CLI applications: {e}", style="bold red")
-            import platform
             if platform.system() != "Windows":
                 run_shell_script(". $HOME/.bashrc")
 
@@ -135,7 +126,6 @@ def execute_installations(selected_options: list[str]) -> None:
 
     if "install_ssh_server" in selected_options:
         console.print(Panel("🔒 [bold red]SSH SERVER[/bold red]\n[italic]Remote access setup[/italic]", border_style="red"))
-        import platform
         if platform.system() == "Windows":
             powershell_script = """Write-Host "🔧 Installing and configuring SSH server..."
 Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0
@@ -152,6 +142,13 @@ Set-Service -Name sshd -StartupType 'Automatic'"""
             from machineconfig.profile.create_shell_profile import create_default_shell_profile
             create_default_shell_profile()
             console.print("✅ Shell profile configured successfully", style="bold green")
+            from machineconfig.profile.create_links_export import main_public_from_parser
+            main_public_from_parser(method="copy", on_conflict="overwrite-default-path", which="all", interactive=False)
+            if platform.system() == "Windows":
+                from machineconfig.jobs.installer.python_scripts.nerfont_windows_helper import install_nerd_fonts
+                install_nerd_fonts()
+                from machineconfig.settings.wt.set_wt_settings import main as set_wt_settings_main
+                set_wt_settings_main()
         except Exception as e:
             console.print(f"❌ Error configuring shell profile: {e}", style="bold red")
 
@@ -170,12 +167,6 @@ Set-Service -Name sshd -StartupType 'Automatic'"""
         except Exception as e:
             console.print(f"❌ Error retrieving backup data: {e}", style="bold red")
 
-    if "install_windows_desktop" in selected_options:
-        from machineconfig.jobs.installer.custom_dev.nerfont_windows_helper import install_nerd_fonts
-        install_nerd_fonts()
-        from machineconfig.setup_windows.wt_and_pwsh.set_wt_settings import main as set_wt_settings_main
-        set_wt_settings_main()
-
 
 def main() -> None:
     display_header()

machineconfig/scripts/python/{machineconfig.py → mcfg_entry.py}

@@ -8,7 +8,6 @@ from machineconfig.scripts.python.utils import get_app as get_utils_app
 from machineconfig.scripts.python.ftpx import ftpx as ftpx_func
 from machineconfig.scripts.python.croshell import croshell as croshell_func
 from machineconfig.scripts.python.fire_jobs import fire as get_fire_jobs_app
-from machineconfig.scripts.python.define import get_app as get_define_app
 from machineconfig.scripts.python.terminal import get_app as get_terminal_app
 
 def get_app():
@@ -42,10 +41,6 @@ def get_app():
     app.add_typer(utils_app, name="utils", help="[u] Utility commands", no_args_is_help=True)
     app.add_typer(utils_app, name="u", hidden=True)  # short alias
 
-    define_app = get_define_app()
-    app.add_typer(define_app, name="define", help="[df] Define and manage configurations", no_args_is_help=True)
-    app.add_typer(define_app, name="df", hidden=True)  # short alias
-
 
     terminal_app = get_terminal_app()
     app.add_typer(terminal_app, name="terminal", help="[t] Terminal management commands", no_args_is_help=True)
@@ -57,3 +52,7 @@ def get_app():
 def main():
     app = get_app()
     app()
+
+
+if __name__ == "__main__":
+    main()

machineconfig/scripts/python/msearch.py

@@ -1,21 +1,72 @@
 
 import typer
+from typing import Annotated
 
 
-def machineconfig_find():
+def machineconfig_search(
+        directory: Annotated[str, typer.Option(..., "--directory", "-d", help="The directory to search")] = ".",
+        ast: Annotated[bool, typer.Option(..., "--ast", "-a", help="The abstract syntax tree search/ tree sitter search of symbols")] = False,
+        symantic: Annotated[bool, typer.Option(..., "--symantic", "-s", help="The symantic search of symbols")] = False,
+        extension: Annotated[str, typer.Option(..., "--extension", "-e", help="File extension to filter by (e.g., .py, .js)")] = "",
+        file: Annotated[bool, typer.Option(..., "--file", "-f", help="File search using fzf")] = False,
+        no_dotfiles: Annotated[bool, typer.Option(..., "--no-dotfiles", "-D", help="Exclude dotfiles from search")] = False,
+        rga: Annotated[bool, typer.Option(..., "--rga", "-A", help="Use ripgrep-all for searching all (non text files) instead of ripgrep")] = False,
+        install_dependencies: Annotated[bool, typer.Option(..., "--install-req", "-p", help="Install required dependencies if missing")] = False
+        ):
+    """machineconfig search helper"""
+    if install_dependencies:
+        from machineconfig.utils.installer_utils.installer_cli import install_if_missing
+        install_if_missing("fzf")
+        install_if_missing("tv")
+        install_if_missing("bat")
+        install_if_missing("fd")
+        install_if_missing("rg")  # ripgrep
+        install_if_missing("rga")  # ripgrep-all
+        # install_if_missing("tree-sitter-cli")
+        return
+    if symantic:
+        script = ""
+        for an_ex in extension.split(","):
+            script = script + f"""\nparse *.{an_ex} """
+        from machineconfig.utils.code import run_shell_script
+        run_shell_script(script=script)
+        return
+    if ast:
+        from machineconfig.scripts.python.helpers.ast_search import get_repo_symbols
+        symbols = get_repo_symbols(directory)
+        from machineconfig.utils.options import choose_from_options
+        try:
+            res = choose_from_options(options=symbols, msg="Select a symbol to search for:", tv=True, multi=False)
+            from rich import print_json
+            import json
+            res_json = json.dumps(res, indent=4)
+            print_json(res_json)
+            return None
+        except Exception as e:
+            print(f"❌ Error during selection: {e}")
+            return None
+    if file:
+        script = """fzf --ansi --preview-window 'right:60%' --preview 'bat --color=always --style=numbers,grid,header --line-range :300 {}' """
+        if no_dotfiles:
+            script = "fd | " + script
+        from machineconfig.utils.code import run_shell_script
+        run_shell_script(script=script)
+        return
     from machineconfig.scripts.python.helpers_msearch import FZFG_LINUX_PATH, FZFG_WINDOWS_PATH
     import platform
-    if platform.system() == "Linux":
-        script_path = FZFG_LINUX_PATH
+    if platform.system() == "Linux" or platform.system() == "Darwin":
+        script = FZFG_LINUX_PATH.read_text(encoding="utf-8")
     elif platform.system() == "Windows":
-        script_path = FZFG_WINDOWS_PATH
+        script = FZFG_WINDOWS_PATH.read_text(encoding="utf-8")
     else:
         raise RuntimeError("Unsupported platform")
+    if rga:
+        script = script.replace("rg ", "rga ").replace("ripgrep", "ripgrep-all")
     from machineconfig.utils.code import exit_then_run_shell_script
-    exit_then_run_shell_script(script=script_path.read_text(encoding="utf-8"), strict=False)
+    exit_then_run_shell_script(script=script, strict=False)
 
 
 def main():
     app = typer.Typer(add_completion=False, no_args_is_help=True)
-    app.command(name="msearch", help="machineconfig search helper", no_args_is_help=False)(machineconfig_find)
+    app.command(name="msearch", help=machineconfig_search.__doc__, short_help="machineconfig search helper", no_args_is_help=False)(machineconfig_search)
     app()