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

machineconfig/scripts/python/helpers/ast_search.py

@@ -0,0 +1,74 @@
+
+import ast
+import os
+from typing import TypedDict
+
+
+class SymbolInfo(TypedDict):
+    """Represents a symbol (module, class, or function) in the repository."""
+    type: str
+    name: str
+    path: str
+    # line: int | None
+    # column: int | None
+    docstring: str
+
+
+def _get_docstring(node: ast.AsyncFunctionDef | ast.FunctionDef | ast.ClassDef | ast.Module) -> str:
+    """Extract docstring from an AST node."""
+    return ast.get_docstring(node) or ""
+
+
+def _extract_symbols(tree: ast.AST, module_path: str, source: str) -> list[SymbolInfo]:
+    """Extract symbols from an AST tree."""
+    symbols: list[SymbolInfo] = []
+    
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            symbol: SymbolInfo = {
+                "type": "function",
+                "name": node.name,
+                "path": f"{module_path}.{node.name}",
+                "docstring": _get_docstring(node),
+            }
+            symbols.append(symbol)
+        elif isinstance(node, ast.ClassDef):
+            symbol: SymbolInfo = {
+                "type": "class",
+                "name": node.name,
+                "path": f"{module_path}.{node.name}",
+                "docstring": _get_docstring(node),
+            }
+            symbols.append(symbol)
+    
+    return symbols
+
+
+def get_repo_symbols(repo_path: str) -> list[SymbolInfo]:
+    skip_dirs = {'.venv', 'venv', '__pycache__', '.mypy_cache', '.pytest_cache', '.git'}
+    results: list[SymbolInfo] = []
+    counter: int = 0
+    for root, dirs, files in os.walk(repo_path):
+        dirs[:] = [d for d in dirs if d not in skip_dirs and not d.startswith('.')]
+        for file in files:
+            if not file.endswith(".py"):
+                continue
+            file_path = os.path.join(root, file)
+            module_path = (
+                os.path.relpath(file_path, repo_path)
+                .replace(os.sep, ".")
+                .removesuffix(".py")
+            )
+            try:
+                if counter % 100 == 0: print(f"🔍 Parsing {counter}: {file_path}...")
+                with open(file_path, encoding="utf-8") as f:
+                    source = f.read()
+                tree = ast.parse(source, filename=file_path)
+                symbols = _extract_symbols(tree, module_path, source)
+                results.extend(symbols)
+            except Exception as e:
+                print(f"⚠️ Error parsing {file_path}: {e}")
+                continue
+            counter += 1
+
+    return results

machineconfig/scripts/python/helpers/qr_code.py

@@ -0,0 +1,166 @@
+
+
+from typing import Literal
+
+
+def generate_qrcode_grid(
+    strings: list[str],
+    output_path: str,
+    per_row: int = 3,
+    qr_size: int = 200,
+    label_height: int = 30,
+    padding: int = 20,
+    label_max_chars: int = 25,
+    format: Literal["svg", "png"] = "svg",
+) -> str:
+    from pathlib import Path
+    if not strings:
+        raise ValueError("strings list cannot be empty")
+
+    output_path_obj = Path(output_path)
+    output_path_obj.parent.mkdir(parents=True, exist_ok=True)
+
+    if format == "svg":
+        return _generate_svg(strings, output_path, per_row, qr_size, label_height, padding, label_max_chars)
+    elif format == "png":
+        return _generate_png(strings, output_path, per_row, qr_size, label_height, padding, label_max_chars)
+    else:
+        raise ValueError(f"Unsupported format: {format}")
+
+
+def _generate_svg(
+    strings: list[str],
+    output_path: str,
+    per_row: int,
+    qr_size: int,
+    label_height: int,
+    padding: int,
+    label_max_chars: int,
+) -> str:
+    num_items = len(strings)
+    num_rows = (num_items + per_row - 1) // per_row
+
+    cell_width = qr_size
+    cell_height = qr_size + label_height
+    total_width = per_row * cell_width + (per_row + 1) * padding
+    total_height = num_rows * cell_height + (num_rows + 1) * padding
+
+    from xml.etree import ElementTree as ET
+
+    import qrcode
+    svg_root = ET.Element(
+        "svg",
+        xmlns="http://www.w3.org/2000/svg",
+        width=str(total_width),
+        height=str(total_height),
+        viewBox=f"0 0 {total_width} {total_height}",
+    )
+
+    _bg_rect = ET.SubElement(svg_root, "rect", width=str(total_width), height=str(total_height), fill="white")
+
+    for idx, text in enumerate(strings):
+        row = idx // per_row
+        col = idx % per_row
+
+        x_offset = padding + col * (cell_width + padding)
+        y_offset = padding + row * (cell_height + padding)
+
+        qr = qrcode.QRCode(version=1, error_correction=qrcode.ERROR_CORRECT_L, box_size=10, border=2, image_factory=qrcode.image.svg.SvgPathImage)  # type: ignore
+        qr.add_data(text)
+        qr.make(fit=True)
+
+        qr_img = qr.make_image()
+        qr_svg_string = qr_img.to_string(encoding="unicode")
+
+        qr_tree = ET.fromstring(qr_svg_string)
+
+        group = ET.SubElement(svg_root, "g", transform=f"translate({x_offset}, {y_offset})")
+
+        qr_group = ET.SubElement(group, "g")
+        for child in qr_tree:
+            qr_group.append(child)
+
+        label_text = text[:label_max_chars] if len(text) > label_max_chars else text
+        text_y = qr_size + label_height // 2
+
+        text_elem = ET.SubElement(
+            group,
+            "text",
+            x=str(qr_size // 2),
+            y=str(text_y),
+            fill="black",
+            attrib={
+                "font-family": "monospace",
+                "font-size": "12",
+                "text-anchor": "middle",
+                "dominant-baseline": "middle",
+            },
+        )
+        text_elem.text = label_text
+
+    tree = ET.ElementTree(svg_root)
+    ET.indent(tree, space="  ")
+    tree.write(output_path, encoding="unicode", xml_declaration=True)
+
+    return output_path
+
+
+def _generate_png(
+    strings: list[str],
+    output_path: str,
+    per_row: int,
+    qr_size: int,
+    label_height: int,
+    padding: int,
+    label_max_chars: int,
+) -> str:
+    num_items = len(strings)
+    num_rows = (num_items + per_row - 1) // per_row
+
+    cell_width = qr_size
+    cell_height = qr_size + label_height
+    total_width = per_row * cell_width + (per_row + 1) * padding
+    total_height = num_rows * cell_height + (num_rows + 1) * padding
+
+    import qrcode
+    import qrcode.image.pil
+    from PIL import Image, ImageDraw, ImageFont
+    img = Image.new("RGB", (total_width, total_height), color="white")
+    draw = ImageDraw.Draw(img)
+
+    try:
+        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf", 12)
+    except OSError:
+        try:
+            font = ImageFont.truetype("arial.ttf", 12)
+        except OSError:
+            font = ImageFont.load_default()
+
+    for idx, text in enumerate(strings):
+        row = idx // per_row
+        col = idx % per_row
+
+        x_offset = padding + col * (cell_width + padding)
+        y_offset = padding + row * (cell_height + padding)
+
+        qr = qrcode.QRCode(version=1, error_correction=qrcode.ERROR_CORRECT_L, box_size=10, border=2, image_factory=qrcode.image.pil.PilImage)
+        qr.add_data(text)
+        qr.make(fit=True)
+
+        qr_img = qr.make_image(fill_color="black", back_color="white")
+        qr_img_resized = qr_img.resize((qr_size, qr_size), Image.Resampling.LANCZOS)
+
+        img.paste(qr_img_resized, (x_offset, y_offset))
+
+        label_text = text[:label_max_chars] if len(text) > label_max_chars else text
+
+        bbox = draw.textbbox((0, 0), label_text, font=font)
+        text_width = bbox[2] - bbox[0]
+        text_x = x_offset + (qr_size - text_width) // 2
+        text_y = y_offset + qr_size + label_height // 2 - 6
+
+        draw.text((text_x, text_y), label_text, fill="black", font=font)
+
+    img.save(output_path, format="PNG")
+
+    return output_path

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/run_py_script.py

@@ -0,0 +1,79 @@
+
+
+import typer
+from typing import Annotated, Optional, Literal
+
+
+def run_py_script(name: Annotated[str, typer.Argument(help="Name of the python script to run, e.g., 'a' for a.py")],
+                  where: Annotated[Literal["all", "private", "public", "tmp"], typer.Option("--where", "-w", help="Where to look for the script: any, private, public, tmp")] = "all",
+                  command: Annotated[Optional[bool], typer.Option(..., "--command", "-c", help="Run as command")] = False,
+                #   use_machineconfig_env: Annotated[bool, typer.Option(..., "--use-machineconfig-env/--no-use-machineconfig-env", "-m/-nm", help="Whether to use the machineconfig python environment")] = False
+                ) -> None:
+    """
+    Run a temporary python script stored in machineconfig/scripts/python/helpers/tmp_py_scripts.
+    """
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT
+    from pathlib import Path
+    if command:
+        exec(name)
+        return
+    if Path(name).is_file():
+        import machineconfig
+        import subprocess
+        import sys
+        subprocess.run([sys.executable, name], cwd=machineconfig.__path__[0])
+        return
+
+    target_py_file: Optional[Path] = None
+    if where in ["all", "private"]:
+        result = Path.home().joinpath("dotfiles/scripts/python").joinpath(f"{name}.py")
+        if result.exists():
+            target_py_file = result
+    if target_py_file is None and where in ["all", "public"]:
+        result = CONFIG_ROOT.joinpath("scripts_python").joinpath(f"{name}.py")
+        if result.exists():
+            target_py_file = result
+    if target_py_file is None and where in ["all", "tmp"]:
+        url = f"""https://raw.githubusercontent.com/thisismygitrepo/machineconfig/refs/heads/main/src/machineconfig/scripts/python/helpers/tmp_py_scripts/{name}.py"""
+        print(f"Fetching temporary script from {url} ...")
+        import requests
+        response = requests.get(url)
+        if response.status_code != 200:
+            print(f"❌ ERROR: Could not fetch script '{name}.py' from repository. Status Code: {response.status_code}")
+            raise RuntimeError(f"Could not fetch script '{name}.py' from repository.")
+        script_content = response.text
+        from machineconfig.utils.code import get_uv_command_executing_python_script, exit_then_run_shell_script
+        shell_script, _shell_script_path = get_uv_command_executing_python_script(python_script=script_content, uv_project_dir=None, uv_with=None, prepend_print=False)
+        exit_then_run_shell_script(script=shell_script)
+
+
+
+def copy_script_to_local(name: Annotated[str, typer.Argument(help="Name of the temporary python script to copy, e.g., 'a' for a.py")],
+                         alias: Annotated[Optional[str], typer.Option("--alias", "-a", help="Whether to create call it a different name locally")] = None
+                         ) -> None:
+    """
+    Copy a temporary python script stored in machineconfig/scripts/python/helpers/tmp_py_scripts to the local machine.
+    """
+    url = f"""https://raw.githubusercontent.com/thisismygitrepo/machineconfig/refs/heads/main/src/machineconfig/scripts/python/helpers/tmp_py_scripts/{name}.py"""
+    import requests
+    response = requests.get(url)
+    if response.status_code != 200:
+        print(f"❌ ERROR: Could not fetch script '{name}.py' from repository. Status Code: {response.status_code}")
+        raise RuntimeError(f"Could not fetch script '{name}.py' from repository.")
+    script_content = response.text
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT
+    local_path = CONFIG_ROOT.joinpath(f"scripts_python/{alias or name}.py")
+    with open(local_path, "w") as f:
+        f.write(script_content)
+    print(f"✅ Script '{name}.py' has been copied to '{local_path}'.")
+
+
+def get_app():
+    app = typer.Typer(
+        name="run-tmp-script",
+        help="Helper to run temporary python scripts stored in machineconfig/scripts/python/helpers/tmp_py_scripts",
+        no_args_is_help=True,
+    )
+    from machineconfig.scripts.python.helpers.tmp_py_scripts import a
+    app.command()(a.main)
+    return 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"
+
+"""