machineconfig 7.53__py3-none-any.whl → 7.69__py3-none-any.whl

machineconfig/scripts/python/helpers/repo_rag.py

@@ -0,0 +1,325 @@
+# #!/usr/bin/env python3
+# from pathlib import Path
+# from typing import Annotated
+# import subprocess
+# import typer
+# from rich.console import Console
+# from rich.progress import Progress, SpinnerColumn, TextColumn
+# from rich.table import Table
+# from rich.syntax import Syntax
+
+# import chromadb
+# from chromadb.config import Settings
+# from sentence_transformers import SentenceTransformer
+
+
+# app = typer.Typer(help="Semantic search over your repository using local RAG")
+# console = Console()
+
+
+# DEFAULT_EXTENSIONS = [".py", ".sh", ".ps1", ".md", ".toml", ".yaml", ".yml", ".json"]
+# DEFAULT_MODEL = "all-MiniLM-L6-v2"
+# DEFAULT_DB_PATH = Path.home() / ".cache" / "repo_rag"
+
+
+# class RepoRAG:
+#     def __init__(self, db_path: Path, model_name: str = DEFAULT_MODEL) -> None:
+#         self.db_path = db_path
+#         self.db_path.mkdir(parents=True, exist_ok=True)
+        
+#         with console.status(f"[bold green]Loading embedding model: {model_name}..."):
+#             self.model = SentenceTransformer(model_name)
+        
+#         self.client = chromadb.PersistentClient(
+#             path=str(db_path),
+#             settings=Settings(anonymized_telemetry=False)
+#         )
+        
+#     def _get_or_create_collection(self, repo_path: Path) -> chromadb.Collection:
+#         collection_name = f"repo_{repo_path.name}".replace("-", "_").replace(".", "_")
+#         return self.client.get_or_create_collection(
+#             name=collection_name,
+#             metadata={"repo_path": str(repo_path)}
+#         )
+    
+#     def _chunk_file_content(self, content: str, chunk_size: int = 500, overlap: int = 50) -> list[str]:
+#         lines = content.split("\n")
+#         chunks: list[str] = []
+#         current_chunk: list[str] = []
+#         current_size = 0
+        
+#         for line in lines:
+#             line_size = len(line)
+#             if current_size + line_size > chunk_size and current_chunk:
+#                 chunks.append("\n".join(current_chunk))
+#                 overlap_lines = current_chunk[-overlap:] if len(current_chunk) > overlap else current_chunk
+#                 current_chunk = overlap_lines
+#                 current_size = sum(len(line_text) for line_text in current_chunk)
+            
+#             current_chunk.append(line)
+#             current_size += line_size
+        
+#         if current_chunk:
+#             chunks.append("\n".join(current_chunk))
+        
+#         return chunks if chunks else [content]
+    
+#     def index_repo(self, repo_path: Path, extensions: list[str], max_file_size_kb: int = 500) -> None:
+#         collection = self._get_or_create_collection(repo_path)
+        
+#         files_to_index: list[Path] = []
+#         for ext in extensions:
+#             files_to_index.extend(repo_path.rglob(f"*{ext}"))
+        
+#         files_to_index = [
+#             f for f in files_to_index 
+#             if not any(part.startswith('.') for part in f.relative_to(repo_path).parts[:-1])
+#             and f.stat().st_size < max_file_size_kb * 1024
+#         ]
+        
+#         console.print(f"[bold cyan]Found {len(files_to_index)} files to index")
+        
+#         with Progress(
+#             SpinnerColumn(),
+#             TextColumn("[progress.description]{task.description}"),
+#             console=console
+#         ) as progress:
+#             task = progress.add_task("Indexing files...", total=len(files_to_index))
+            
+#             for file_path in files_to_index:
+#                 try:
+#                     content = file_path.read_text(encoding="utf-8", errors="ignore")
+#                     rel_path = str(file_path.relative_to(repo_path))
+                    
+#                     chunks = self._chunk_file_content(content)
+                    
+#                     for i, chunk in enumerate(chunks):
+#                         doc_id = f"{rel_path}::chunk_{i}"
+#                         embedding = self.model.encode(chunk).tolist()
+                        
+#                         collection.upsert(
+#                             ids=[doc_id],
+#                             embeddings=[embedding],
+#                             documents=[chunk],
+#                             metadatas=[{
+#                                 "file_path": rel_path,
+#                                 "chunk_index": i,
+#                                 "total_chunks": len(chunks),
+#                                 "extension": file_path.suffix
+#                             }]
+#                         )
+                    
+#                 except Exception as e:
+#                     console.print(f"[yellow]Warning: Failed to index {file_path}: {e}")
+                
+#                 progress.advance(task)
+        
+#         console.print("[bold green]✓ Indexing complete!")
+    
+#     def search(self, repo_path: Path, query: str, n_results: int = 20) -> list[dict[str, str | dict[str, str | int]]]:
+#         collection = self._get_or_create_collection(repo_path)
+        
+#         with console.status("[bold green]Searching..."):
+#             query_embedding = self.model.encode(query).tolist()
+#             results = collection.query(
+#                 query_embeddings=[query_embedding],
+#                 n_results=n_results
+#             )
+        
+#         if not results["ids"] or not results["ids"][0]:
+#             return []
+        
+#         search_results: list[dict[str, str | dict[str, str | int]]] = []
+#         for i, doc_id in enumerate(results["ids"][0]):
+#             search_results.append({
+#                 "id": doc_id,
+#                 "file_path": results["metadatas"][0][i]["file_path"],
+#                 "content": results["documents"][0][i],
+#                 "distance": results["distances"][0][i] if results.get("distances") else 0.0,
+#                 "metadata": results["metadatas"][0][i]
+#             })
+        
+#         return search_results
+    
+#     def delete_index(self, repo_path: Path) -> None:
+#         collection_name = f"repo_{repo_path.name}".replace("-", "_").replace(".", "_")
+#         try:
+#             self.client.delete_collection(name=collection_name)
+#             console.print(f"[bold green]✓ Deleted index for {repo_path.name}")
+#         except Exception as e:
+#             console.print(f"[bold red]Error deleting index: {e}")
+
+
+# @app.command()
+# def index(
+#     repo_path: Annotated[Path, typer.Argument(help="Path to repository to index")] = Path.cwd(),
+#     extensions: Annotated[str, typer.Option("--ext", "-e", help="Comma-separated list of extensions")] = ",".join(DEFAULT_EXTENSIONS),
+#     model: Annotated[str, typer.Option("--model", "-m", help="Sentence transformer model name")] = DEFAULT_MODEL,
+#     db_path: Annotated[Path, typer.Option("--db", help="Database path")] = DEFAULT_DB_PATH,
+#     max_size_kb: Annotated[int, typer.Option("--max-size", help="Max file size in KB")] = 500,
+# ) -> None:
+#     repo_path = repo_path.resolve()
+    
+#     if not repo_path.exists():
+#         console.print(f"[bold red]Error: Repository path does not exist: {repo_path}")
+#         raise typer.Exit(1)
+    
+#     ext_list = [ext.strip() if ext.startswith(".") else f".{ext.strip()}" for ext in extensions.split(",")]
+    
+#     console.print(f"[bold cyan]Repository:[/] {repo_path}")
+#     console.print(f"[bold cyan]Extensions:[/] {', '.join(ext_list)}")
+#     console.print(f"[bold cyan]Model:[/] {model}")
+#     console.print(f"[bold cyan]Database:[/] {db_path}")
+#     console.print()
+    
+#     rag = RepoRAG(db_path, model)
+#     rag.index_repo(repo_path, ext_list, max_size_kb)
+
+
+# @app.command()
+# def search(
+#     query: Annotated[str, typer.Argument(help="Search query")],
+#     repo_path: Annotated[Path, typer.Option("--repo", "-r", help="Path to repository")] = Path.cwd(),
+#     n_results: Annotated[int, typer.Option("--num", "-n", help="Number of results")] = 20,
+#     model: Annotated[str, typer.Option("--model", "-m", help="Sentence transformer model name")] = DEFAULT_MODEL,
+#     db_path: Annotated[Path, typer.Option("--db", help="Database path")] = DEFAULT_DB_PATH,
+#     use_fzf: Annotated[bool, typer.Option("--fzf", help="Use fzf for interactive selection")] = True,
+#     show_content: Annotated[bool, typer.Option("--content", "-c", help="Show content snippets")] = True,
+# ) -> None:
+#     repo_path = repo_path.resolve()
+    
+#     if not repo_path.exists():
+#         console.print(f"[bold red]Error: Repository path does not exist: {repo_path}")
+#         raise typer.Exit(1)
+    
+#     rag = RepoRAG(db_path, model)
+#     results = rag.search(repo_path, query, n_results)
+    
+#     if not results:
+#         console.print("[yellow]No results found")
+#         raise typer.Exit(0)
+    
+#     if use_fzf:
+#         _search_with_fzf(results, repo_path, show_content)
+#     else:
+#         _display_results(results, show_content)
+
+
+# def _display_results(results: list[dict[str, str | dict[str, str | int]]], show_content: bool) -> None:
+#     table = Table(title="Search Results", show_header=True, header_style="bold magenta")
+#     table.add_column("#", style="cyan", width=4)
+#     table.add_column("File", style="green")
+#     table.add_column("Chunk", style="yellow", width=8)
+#     table.add_column("Score", style="blue", width=8)
+#     if show_content:
+#         table.add_column("Content Preview", style="white", width=60)
+    
+#     for i, result in enumerate(results, 1):
+#         file_path = str(result["file_path"])
+#         metadata = result["metadata"]
+#         chunk_info = f"{int(metadata['chunk_index']) + 1}/{int(metadata['total_chunks'])}"
+#         score = f"{float(result['distance']):.3f}"
+        
+#         row = [str(i), file_path, chunk_info, score]
+        
+#         if show_content:
+#             content = str(result["content"])
+#             preview = content[:200].replace("\n", " ") + ("..." if len(content) > 200 else "")
+#             row.append(preview)
+        
+#         table.add_row(*row)
+    
+#     console.print(table)
+
+
+# def _search_with_fzf(results: list[dict[str, str | dict[str, str | int]]], repo_path: Path, show_content: bool) -> None:
+#     try:
+#         fzf_input_lines: list[str] = []
+#         for i, result in enumerate(results, 1):
+#             file_path = str(result["file_path"])
+#             metadata = result["metadata"]
+#             chunk_info = f"{int(metadata['chunk_index']) + 1}/{int(metadata['total_chunks'])}"
+#             score = f"{float(result['distance']):.3f}"
+            
+#             if show_content:
+#                 content = str(result["content"]).replace("\n", " ")[:100]
+#                 line = f"{i:3d} │ {score:6s} │ {chunk_info:5s} │ {file_path:60s} │ {content}"
+#             else:
+#                 line = f"{i:3d} │ {score:6s} │ {chunk_info:5s} │ {file_path}"
+            
+#             fzf_input_lines.append(line)
+        
+#         fzf_input = "\n".join(fzf_input_lines)
+        
+#         result = subprocess.run(
+#             ["fzf", "--ansi", "--multi", "--reverse", "--header=Select files to open (TAB for multi-select)"],
+#             input=fzf_input.encode(),
+#             capture_output=True
+#         )
+        
+#         if result.returncode != 0:
+#             console.print("[yellow]Selection cancelled")
+#             return
+        
+#         selected_lines = result.stdout.decode().strip().split("\n")
+        
+#         for line in selected_lines:
+#             if not line:
+#                 continue
+            
+#             parts = line.split("│")
+#             if len(parts) < 4:
+#                 continue
+            
+#             file_path_str = parts[3].strip().split()[0]
+            
+#             idx = int(parts[0].strip()) - 1
+#             if idx < len(results):
+#                 content = str(results[idx]["content"])
+                
+#                 console.print(f"\n[bold green]File:[/] {file_path_str}")
+#                 console.print("[bold cyan]Content:[/]")
+                
+#                 syntax = Syntax(content, "python", theme="monokai", line_numbers=True)
+#                 console.print(syntax)
+#                 console.print("\n" + "─" * 80 + "\n")
+    
+#     except FileNotFoundError:
+#         console.print("[bold red]Error: fzf not found. Install fzf or use --no-fzf flag")
+#         _display_results(results, show_content)
+
+
+# @app.command()
+# def delete(
+#     repo_path: Annotated[Path, typer.Argument(help="Path to repository")] = Path.cwd(),
+#     db_path: Annotated[Path, typer.Option("--db", help="Database path")] = DEFAULT_DB_PATH,
+#     model: Annotated[str, typer.Option("--model", "-m", help="Sentence transformer model name")] = DEFAULT_MODEL,
+# ) -> None:
+#     repo_path = repo_path.resolve()
+#     rag = RepoRAG(db_path, model)
+#     rag.delete_index(repo_path)
+
+
+# @app.command()
+# def info() -> None:
+#     console.print("[bold cyan]Repo RAG - Semantic Code Search[/]\n")
+    
+#     info_table = Table(show_header=False, box=None)
+#     info_table.add_column("Key", style="cyan")
+#     info_table.add_column("Value", style="white")
+    
+#     info_table.add_row("Embedding Model", DEFAULT_MODEL)
+#     info_table.add_row("Vector Store", "ChromaDB (embedded)")
+#     info_table.add_row("Default Extensions", ", ".join(DEFAULT_EXTENSIONS))
+#     info_table.add_row("Database Path", str(DEFAULT_DB_PATH))
+    
+#     console.print(info_table)
+    
+#     console.print("\n[bold green]Quick Start:[/]")
+#     console.print("1. Index your repo:     [yellow]repo-rag index[/]")
+#     console.print("2. Search semantically: [yellow]repo-rag search 'your query'[/]")
+#     console.print("3. Delete index:        [yellow]repo-rag delete[/]")
+
+
+# if __name__ == "__main__":
+#     app()

machineconfig/scripts/python/helpers/symantic_search.py

@@ -0,0 +1,25 @@
+"""
+please fully read docs of https://github.com/meilisearch/meilisearch-python
+
+then make a cli using typer in this file
+
+I want commands to
+create-index (pass name of index)
+command to populate the index with files in folder
+command is add-to-index
+--directory [str] and --extensions .py,.ps1,.sh
+
+command to rebuild index
+
+coimmand to search
+command show stats and rop index
+
+learn from my style of building apps like this #file:msearch.py 
+
+and add option when building index to say --symantic (means use ai locall embedding to build the index)
+
+in all cases we should be able to pass
+MEILI_URL="http://localhost:7700" (default)
+MEILI_MASTER_KEY="YOUR_MASTER_KEY"
+
+"""

machineconfig/scripts/python/helpers_cloud/cloud_copy.py

@@ -2,26 +2,24 @@
 CC
 """
 
-from machineconfig.utils.path_extended import PathExtended
-from tenacity import retry, stop_after_attempt, wait_chain, wait_fixed
-import getpass
-import os
 from typing import Optional, Annotated
-
 import typer
 
-from machineconfig.scripts.python.helpers_cloud.helpers2 import parse_cloud_source_target
-from machineconfig.scripts.python.helpers_cloud.cloud_helpers import ArgsDefaults, Args
-from rich.console import Console
-from rich.panel import Panel
-from rich.progress import Progress
-from machineconfig.utils.accessories import pprint
+from tenacity import retry, stop_after_attempt, wait_chain, wait_fixed
 
-console = Console()
 
 
 @retry(stop=stop_after_attempt(3), wait=wait_chain(wait_fixed(1), wait_fixed(4), wait_fixed(9)))
 def get_securely_shared_file(url: Optional[str] = None, folder: Optional[str] = None) -> None:
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.progress import Progress
+    import getpass
+    import os
+    from machineconfig.utils.path_extended import PathExtended
+
+    console = Console()
+
     console.print(Panel("🚀 Secure File Downloader", title="[bold blue]Downloader[/bold blue]", border_style="blue"))
 
     folder_obj = PathExtended.cwd() if folder is None else PathExtended(folder)
@@ -62,21 +60,30 @@ def get_securely_shared_file(url: Optional[str] = None, folder: Optional[str] =
                 tmp_folder.delete()
 
 
+
 def main(
     source: Annotated[str, typer.Argument(help="📂 file/folder path to be taken from here.")],
     target: Annotated[str, typer.Argument(help="🎯 file/folder path to be be sent to here.")],
-    overwrite: Annotated[bool, typer.Option("--overwrite", "-o", help="✍️ Overwrite existing file.")] = ArgsDefaults.overwrite,
-    share: Annotated[bool, typer.Option("--share", "-s", help="🔗 Share file / directory")] = ArgsDefaults.share,
-    rel2home: Annotated[bool, typer.Option("--relative2home", "-r", help="🏠 Relative to `myhome` folder")] = ArgsDefaults.rel2home,
-    root: Annotated[Optional[str], typer.Option("--root", "-R", help="🌳 Remote root. None is the default, unless rel2home is raied, making the default `myhome`.")] = ArgsDefaults.root,
-    key: Annotated[Optional[str], typer.Option("--key", "-k", help="🔑 Key for encryption")] = ArgsDefaults.key,
-    pwd: Annotated[Optional[str], typer.Option("--password", "-p", help="🔒 Password for encryption")] = ArgsDefaults.pwd,
-    encrypt: Annotated[bool, typer.Option("--encrypt", "-e", help="🔐 Encrypt before sending.")] = ArgsDefaults.encrypt,
-    zip_: Annotated[bool, typer.Option("--zip", "-z", help="📦 unzip after receiving.")] = ArgsDefaults.zip_,
-    os_specific: Annotated[bool, typer.Option("--os-specific", "-O", help="💻 choose path specific for this OS.")] = ArgsDefaults.os_specific,
+    overwrite: Annotated[bool, typer.Option("--overwrite", "-o", help="✍️ Overwrite existing file.")] = False,
+    share: Annotated[bool, typer.Option("--share", "-s", help="🔗 Share file / directory")] = False,
+    rel2home: Annotated[bool, typer.Option("--relative2home", "-r", help="🏠 Relative to `myhome` folder")] = False,
+    root: Annotated[Optional[str], typer.Option("--root", "-R", help="🌳 Remote root. None is the default, unless rel2home is raied, making the default `myhome`.")] = None,
+    key: Annotated[Optional[str], typer.Option("--key", "-k", help="🔑 Key for encryption")] = None,
+    pwd: Annotated[Optional[str], typer.Option("--password", "-p", help="🔒 Password for encryption")] = None,
+    encrypt: Annotated[bool, typer.Option("--encrypt", "-e", help="🔐 Encrypt before sending.")] = False,
+    zip_: Annotated[bool, typer.Option("--zip", "-z", help="📦 unzip after receiving.")] = False,
+    os_specific: Annotated[bool, typer.Option("--os-specific", "-O", help="💻 choose path specific for this OS.")] = False,
     config: Annotated[Optional[str], typer.Option("--config", "-c", help="⚙️ path to cloud.json file.")] = None,
 ) -> None:
     """📤 Upload or 📥 Download files/folders to/from cloud storage services like Google Drive, Dropbox, OneDrive, etc."""
+    from rich.console import Console
+    from rich.panel import Panel
+    from machineconfig.utils.path_extended import PathExtended
+    from machineconfig.scripts.python.helpers_cloud.helpers2 import parse_cloud_source_target
+    from machineconfig.scripts.python.helpers_cloud.cloud_helpers import Args
+    from machineconfig.utils.accessories import pprint
+
+    console = Console()
     console.print(Panel("☁️  Cloud Copy Utility", title="[bold blue]Cloud Copy[/bold blue]", border_style="blue", width=152))
     args_obj = Args(
         overwrite=overwrite,

machineconfig/scripts/python/helpers_cloud/cloud_helpers.py

@@ -12,6 +12,7 @@ from dataclasses import dataclass
 console = Console()
 
 
+
 class ArgsDefaults:
     # source: str=None
     # target: str=None
@@ -25,7 +26,6 @@ class ArgsDefaults:
     key = None
     pwd = None
 
-
 @dataclass
 class Args:
     cloud: Optional[str] = None

machineconfig/scripts/python/helpers_cloud/cloud_sync.py

@@ -2,16 +2,9 @@
 TODO: use typer or typed-argument-parser to parse args
 """
 
-from machineconfig.scripts.python.helpers_cloud.helpers2 import parse_cloud_source_target
-from machineconfig.scripts.python.helpers_cloud.cloud_helpers import Args
-from machineconfig.scripts.python.helpers_cloud.cloud_mount import get_mprocs_mount_txt
 
 from typing import Annotated, Optional
 import typer
-from rich.console import Console
-from rich.panel import Panel
-
-console = Console()
 
 
 def main(
@@ -27,6 +20,14 @@ def main(
     delete: Annotated[bool, typer.Option("--delete", "-D", help="Delete files in remote that are not in local.")] = False,
     verbose: Annotated[bool, typer.Option("--verbose", "-v", help="Verbosity of mprocs to show details of syncing.")] = False,
 ) -> None:
+
+    from machineconfig.scripts.python.helpers_cloud.helpers2 import parse_cloud_source_target
+    from machineconfig.scripts.python.helpers_cloud.cloud_helpers import Args
+    from machineconfig.scripts.python.helpers_cloud.cloud_mount import get_mprocs_mount_txt
+    from rich.console import Console
+    from rich.panel import Panel
+    console = Console()
+
     title = "☁️  Cloud Sync Utility"
     console.print(Panel(title, title_align="left", border_style="blue"))
 

machineconfig/scripts/python/helpers_croshell/crosh.py

@@ -20,9 +20,9 @@ def get_read_data_pycode(path: str):
     from rich.panel import Panel
     from rich.text import Text
     from rich.console import Console
-    from machineconfig.utils.path_extended import PathExtended
+    from pathlib import Path
     console = Console()
-    p = PathExtended(path).absolute()
+    p = Path(path).absolute()
     try:
         from machineconfig.utils.files.read import Read
         from machineconfig.utils.accessories import pprint

machineconfig/scripts/python/helpers_devops/cli_config_dotfile.py

@@ -12,7 +12,9 @@ def main(
     method: Annotated[Literal["symlink", "s", "copy", "c"], typer.Option(..., "--method", "-m", help="Method to use for linking files")] = "copy",
     on_conflict: Annotated[ON_CONFLICT_LOOSE, typer.Option(..., "--on-conflict", "-o", help="Action to take on conflict")] = "throw-error",
     sensitivity: Annotated[Literal["private", "v", "public", "b"], typer.Option(..., "--sensitivity", "-s", help="Sensitivity of the config file.")] = "private",
-    destination: Annotated[str, typer.Option("--destination", "-d", help="destination folder (override the default, use at your own risk)")] = "",) -> None:
+    destination: Annotated[str, typer.Option("--destination", "-d", help="destination folder (override the default, use at your own risk)")] = "",
+    shared: Annotated[bool, typer.Option("--shared", "-sh", help="Whether the config file is shared across destinations directory.")] = False,
+    ) -> None:
     from rich.console import Console
     from rich.panel import Panel
     from machineconfig.utils.links import symlink_map, copy_map
@@ -27,26 +29,33 @@ def main(
     console = Console()
     orig_path = Path(file).expanduser().absolute()
     if destination == "":
-        new_path = backup_root.joinpath(orig_path.relative_to(Path.home()))
-        new_path.parent.mkdir(parents=True, exist_ok=True)
+        if shared:
+            new_path = backup_root.joinpath("shared").joinpath(orig_path.name)
+            new_path.parent.mkdir(parents=True, exist_ok=True)
+        else:
+            new_path = backup_root.joinpath(orig_path.relative_to(Path.home()))
+            new_path.parent.mkdir(parents=True, exist_ok=True)
     else:
-        dest_path = Path(destination).expanduser().absolute()
-        dest_path.mkdir(parents=True, exist_ok=True)
-        new_path = dest_path.joinpath(orig_path.name)
-
-
-    from machineconfig.utils.path_extended import PathExtended
+        if shared:
+            dest_path = Path(destination).expanduser().absolute()
+            dest_path.mkdir(parents=True, exist_ok=True)
+            new_path = dest_path.joinpath("shared").joinpath(orig_path.name)
+            new_path.parent.mkdir(parents=True, exist_ok=True)
+        else:
+            dest_path = Path(destination).expanduser().absolute()
+            dest_path.mkdir(parents=True, exist_ok=True)
+            new_path = dest_path.joinpath(orig_path.name)
     match method:
         case "copy" | "c":
             try:
-                copy_map(config_file_default_path=PathExtended(orig_path), self_managed_config_file_path=PathExtended(new_path), on_conflict=ON_CONFLICT_MAPPER[on_conflict])
+                copy_map(config_file_default_path=orig_path, self_managed_config_file_path=new_path, on_conflict=ON_CONFLICT_MAPPER[on_conflict])  # type: ignore[arg-type]
             except Exception as e:
                 typer.echo(f"[red]Error:[/] {e}")
                 typer.Exit(code=1)
                 return
         case "symlink" | "s":
             try:
-                symlink_map(config_file_default_path=PathExtended(orig_path), self_managed_config_file_path=PathExtended(new_path), on_conflict=ON_CONFLICT_MAPPER[on_conflict])
+                symlink_map(config_file_default_path=orig_path, self_managed_config_file_path=new_path, on_conflict=ON_CONFLICT_MAPPER[on_conflict])  # type: ignore[arg-type]
             except Exception as e:
                 typer.echo(f"[red]Error:[/] {e}")
                 typer.Exit(code=1)
@@ -56,10 +65,10 @@ def main(
 
     # mapper_snippet = "\n".join(
     #     [
-    #         f"[bold]📝 Edit configuration file:[/] [cyan]nano {PathExtended(CONFIG_ROOT)}/symlinks/mapper.toml[/cyan]",
+    #         f"[bold]📝 Edit configuration file:[/] [cyan]nano {Path(CONFIG_ROOT)}/symlinks/mapper.toml[/cyan]",
     #         "",
     #         f"[{new_path.parent.name}]",
-    #         f"{orig_path.name.split('.')[0]} = {{ this = '{orig_path.collapseuser().as_posix()}', to_this = '{new_path.collapseuser().as_posix()}' }}",
+    #         f"{orig_path.name.split('.')[0]} = {{ this = '{orig_path.as_posix()}', to_this = '{new_path.as_posix()}' }}",
     #     ]
     # )
     # console.print(

machineconfig/scripts/python/helpers_devops/cli_self.py

@@ -30,7 +30,8 @@ uv tool install --upgrade machineconfig
     if platform.system() == "Windows":
         from machineconfig.utils.code import exit_then_run_shell_script, get_uv_command_executing_python_script
         from machineconfig.utils.meta import lambda_to_python_script
-        python_script = lambda_to_python_script(lambda: copy_both_assets(), in_global=True, import_module=False)
+        python_script = lambda_to_python_script(lambda: copy_both_assets(),
+                                                in_global=True, import_module=False)
         uv_command, _py_file = get_uv_command_executing_python_script(python_script=python_script, uv_with=["machineconfig"], uv_project_dir=None)
         exit_then_run_shell_script(shell_script + "\n" + uv_command, strict=True)
     else:
@@ -52,9 +53,9 @@ def install(no_copy_assets: Annotated[bool, typer.Option("--no-assets-copy", "-n
     else:
         import platform
         if platform.system() == "Windows":
-            run_shell_script(r"""& "$HOME\.local\bin\uv.exe" tool install --upgrade "machineconfig>=7.53" """)
+            run_shell_script(r"""& "$HOME\.local\bin\uv.exe" tool install --upgrade "machineconfig>=7.69" """)
         else:
-            run_shell_script("""$HOME/.local/bin/uv tool install --upgrade "machineconfig>=7.53" """)
+            run_shell_script("""$HOME/.local/bin/uv tool install --upgrade "machineconfig>=7.69" """)
     from machineconfig.profile.create_shell_profile import create_default_shell_profile
     if not no_copy_assets:
         create_default_shell_profile()   # involves copying assets too
@@ -77,10 +78,10 @@ def navigate():
     import machineconfig.scripts.python as navigator
     from pathlib import Path
     path = Path(navigator.__file__).resolve().parent.joinpath("devops_navigator.py")
-    from machineconfig.utils.code import run_shell_script
+    from machineconfig.utils.code import exit_then_run_shell_script
     if Path.home().joinpath("code/machineconfig").exists(): executable = f"""--project "{str(Path.home().joinpath("code/machineconfig"))}" --with textual"""
-    else: executable = """--with "machineconfig>=7.53,textual" """
-    run_shell_script(f"""uv run {executable} {path}""")
+    else: executable = """--with "machineconfig>=7.69,textual" """
+    exit_then_run_shell_script(f"""uv run {executable} {path}""")
 
 
 def run_python(ip: Annotated[str, typer.Argument(..., help="Python command to run in the machineconfig environment")],

machineconfig/scripts/python/helpers_devops/cli_share_file.py

@@ -12,7 +12,7 @@ Usage examples:
     devops network receive -- --relay 10.17.62.206:443 7121-donor-olympic-bicycle
     devops network receive -- croc --relay 10.17.62.206:443 7121-donor-olympic-bicycle
 """
-    from machineconfig.utils.installer_utils.installer import install_if_missing
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
     install_if_missing(which="croc")
     import platform
     import sys
@@ -100,7 +100,7 @@ def share_file_send(path: Annotated[str, typer.Argument(help="Path to the file o
                     qrcode: Annotated[bool, typer.Option("--qrcode", "--qr", help="Show receive code as a qrcode")] = False,
                     ) -> None:
     """Send a file using croc with relay server."""
-    from machineconfig.utils.installer_utils.installer import install_if_missing
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
     install_if_missing(which="croc")
     # Get relay server IP from environment or use default
     import socket

machineconfig/scripts/python/helpers_devops/cli_share_server.py

@@ -40,7 +40,7 @@ def web_file_explorer(
     over_internet: Annotated[bool, typer.Option("--over-internet", "-i", help="Expose the share server over the internet using ngrok")] = False,
     backend: Annotated[str, typer.Option("--backend", "-b", help="Backend to use: filebrowser (default), miniserve, or easy-sharing")] = "filebrowser"
 ) -> None:
-    from machineconfig.utils.installer_utils.installer import install_if_missing
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
     
     if backend not in ["filebrowser", "miniserve", "easy-sharing"]:
         typer.echo(f"❌ ERROR: Invalid backend '{backend}'. Must be one of: filebrowser, miniserve, easy-sharing", err=True)

machineconfig/scripts/python/helpers_devops/cli_terminal.py

@@ -60,7 +60,7 @@ def main(
     ssl_ca: Annotated[Optional[str], typer.Option("--ssl-ca", "-A", help="SSL CA file path for client certificate verification")] = None,
     over_internet: Annotated[bool, typer.Option("--over-internet", "-i", help="Expose the terminal over the internet using ngrok")] = False
 ) -> None:
-    from machineconfig.utils.installer_utils.installer import install_if_missing
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
     install_if_missing("ttyd")
     if over_internet: install_if_missing("ngrok")