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

machineconfig/scripts/python/{env_manager → helper_env}/path_manager_tui.py

@@ -2,7 +2,7 @@
 # /// script
 # requires-python = ">=3.13"
 # dependencies = [
-#     "machineconfig>=6.81",
+#     "machineconfig>=8.51",
 #     "textual",
 #     "pyperclip",
 # ]
@@ -18,7 +18,7 @@ from textual.binding import Binding
 from textual.containers import Horizontal, Vertical
 from textual.widgets import Footer, Header, Label, ListItem, ListView, Static
 
-from machineconfig.scripts.python.env_manager.path_manager_backend import get_directory_contents, get_path_entries, get_platform
+from machineconfig.scripts.python.helpers.helper_env.path_manager_backend import get_directory_contents, get_path_entries, get_platform
 
 
 class DirectoryPreview(Static):

machineconfig/scripts/python/helpers/helper_env/env_manager_tui.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "machineconfig>=8.51",
+#     "textual",
+#     "pyperclip",
+# ]
+# ///
+
+
+
+import os
+import platform
+from collections.abc import Mapping
+from typing import Final
+
+from rich.text import Text
+from textual import on
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Footer, Header, Label, ListItem, ListView, Static
+
+
+VALUE_PREVIEW_LIMIT: Final[int] = 4096
+SUMMARY_LIMIT: Final[int] = 96
+
+
+def truncate_text(text: str, limit: int) -> tuple[str, int]:
+    length = len(text)
+    if length <= limit:
+        return text, 0
+    return text[:limit], length - limit
+
+
+def format_summary(env_key: str, env_value: str, limit: int) -> str:
+    sanitized = env_value.replace("\n", "\\n").replace("\t", "\\t")
+    preview, remainder = truncate_text(sanitized, limit)
+    if preview == "":
+        base = f"{env_key} = <empty>"
+    else:
+        base = f"{env_key} = {preview}"
+    if remainder == 0:
+        return base
+    return f"{base}... (+{remainder} chars)"
+
+
+def collect_environment(env: Mapping[str, str]) -> list[tuple[str, str]]:
+    return sorted(env.items(), key=lambda pair: pair[0].lower())
+
+
+class EnvListItem(ListItem):
+    def __init__(self, env_key: str, summary: str) -> None:
+        super().__init__(Label(summary))
+        self._env_key = env_key
+
+    def env_key(self) -> str:
+        return self._env_key
+
+
+class EnvValuePreview(Static):
+    def __init__(self, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]
+        super().__init__(*args, **kwargs)
+        self.border_title = "Environment Value"
+
+    def show_value(self, env_key: str, env_value: str) -> None:
+        preview, remainder = truncate_text(env_value, VALUE_PREVIEW_LIMIT)
+        text = Text()
+        text.append(f"{env_key}\n\n", style="bold cyan")
+        if preview == "":
+            text.append("<empty>", style="dim")
+        else:
+            text.append(preview)
+        if remainder > 0:
+            text.append(f"\n... truncated {remainder} characters", style="yellow")
+        self.update(text)
+
+
+class StatusBar(Static):
+    def __init__(self, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]
+        super().__init__(*args, **kwargs)
+        self.border_title = "Status"
+
+    def show_message(self, message: str, level: str) -> None:
+        palette = {
+            "info": "cyan",
+            "success": "green",
+            "warning": "yellow",
+            "error": "red",
+        }
+        color = palette.get(level, "white")
+        self.update(f"[{color}]{message}[/{color}]")
+
+
+class EnvExplorerApp(App[None]):
+    CSS = """
+    Screen { background: $surface; }
+    Header { background: $primary; color: $text; }
+    Footer { background: $panel; }
+    #main-container { height: 100%; }
+    #left-panel { width: 50%; height: 100%; border: solid $primary; padding: 1; }
+    #right-panel { width: 50%; height: 100%; border: solid $accent; padding: 1; }
+    ListView { height: 1fr; border: solid $accent; background: $surface; }
+    ListView > ListItem { padding: 0 1; }
+    EnvValuePreview { height: 1fr; border: solid $primary; background: $surface; padding: 1; overflow-y: auto; }
+    StatusBar { height: 3; border: solid $success; background: $surface; padding: 1; }
+    Label { padding: 0 1; height: auto; }
+    """
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit", show=True),
+        Binding("r", "refresh", "Refresh", show=True),
+        Binding("c", "copy_entry", "Copy", show=True),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._env_pairs: list[tuple[str, str]] = []
+        self._env_lookup: dict[str, str] = {}
+        self._selected_key: str = ""
+
+    def compose(self) -> ComposeResult:
+        platform_name = platform.system()
+        yield Header(show_clock=True)
+        with Horizontal(id="main-container"):
+            with Vertical(id="left-panel"):
+                yield Label(f"🌐 Environment Variables ({platform_name})")
+                yield ListView(id="env-list")
+            with Vertical(id="right-panel"):
+                yield EnvValuePreview(id="preview")
+                yield StatusBar(id="status")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.title = "Environment Explorer"
+        self.sub_title = f"Platform: {platform.system()}"
+        self._reload_environment()
+        self._status().show_message("Ready. Select a variable to preview its value.", "info")
+
+    def _reload_environment(self) -> None:
+        self._env_pairs = collect_environment(os.environ)
+        self._env_lookup = dict(self._env_pairs)
+        self._populate_list()
+
+    def _populate_list(self) -> None:
+        list_view = self.query_one("#env-list", ListView)
+        list_view.clear()
+        for env_key, env_value in self._env_pairs:
+            summary = format_summary(env_key, env_value, SUMMARY_LIMIT)
+            list_view.append(EnvListItem(env_key, summary))
+        self._status().show_message(f"Loaded {len(self._env_pairs)} environment variables.", "success")
+
+    def _status(self) -> StatusBar:
+        return self.query_one("#status", StatusBar)
+
+    def _preview(self) -> EnvValuePreview:
+        return self.query_one("#preview", EnvValuePreview)
+
+    @on(ListView.Highlighted)
+    def handle_highlight(self, event: ListView.Highlighted) -> None:
+        if not isinstance(event.item, EnvListItem):
+            return
+        env_key = event.item.env_key()
+        env_value = self._env_lookup.get(env_key, "")
+        self._preview().show_value(env_key, env_value)
+        self._status().show_message(f"Previewing {env_key}", "info")
+
+    @on(ListView.Selected)
+    def handle_selection(self, event: ListView.Selected) -> None:
+        if not isinstance(event.item, EnvListItem):
+            return
+        env_key = event.item.env_key()
+        self._selected_key = env_key
+        env_value = self._env_lookup.get(env_key, "")
+        self._preview().show_value(env_key, env_value)
+        self._status().show_message(f"Selected {env_key}", "success")
+
+    def action_refresh(self) -> None:
+        self._reload_environment()
+        self._status().show_message("Environment reloaded.", "success")
+
+    def action_copy_entry(self) -> None:
+        if self._selected_key == "":
+            self._status().show_message("No variable selected.", "warning")
+            return
+        env_value = self._env_lookup.get(self._selected_key, "")
+        payload = f"{self._selected_key}={env_value}"
+        try:
+            import pyperclip  # type: ignore[import]
+
+            pyperclip.copy(payload)
+            self._status().show_message(f"Copied {self._selected_key} to clipboard.", "success")
+        except ImportError:
+            self._status().show_message("pyperclip unavailable. Install it for clipboard support.", "warning")
+
+
+def main() -> None:
+    app = EnvExplorerApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

machineconfig/scripts/python/helpers/helper_env/path_manager_tui.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "machineconfig>=8.51",
+#     "textual",
+#     "pyperclip",
+# ]
+# ///
+
+"""Cross-platform PATH explorer with Textual TUI."""
+
+from pathlib import Path
+
+from textual import on
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Footer, Header, Label, ListItem, ListView, Static
+
+from machineconfig.scripts.python.helpers.helper_env.path_manager_backend import get_directory_contents, get_path_entries, get_platform
+
+
+class DirectoryPreview(Static):
+    """Widget to display directory contents."""
+
+    def __init__(self, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]
+        super().__init__(*args, **kwargs)
+        self.border_title = "📂 Directory Preview"
+
+    def update_preview(self, directory: str) -> None:
+        """Update the preview with directory contents."""
+        if not directory:
+            self.update("Select a PATH entry to preview its contents")
+            return
+
+        contents = get_directory_contents(directory, max_items=30)
+        preview_text = f"[bold cyan]{directory}[/bold cyan]\n\n"
+        preview_text += "\n".join(contents)
+        self.update(preview_text)
+
+
+class StatusBar(Static):
+    """Status bar to show messages."""
+
+    def __init__(self, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]
+        super().__init__(*args, **kwargs)
+        self.border_title = "ℹ️  Status"
+
+    def show_message(self, message: str, message_type: str = "info") -> None:
+        """Display a status message."""
+        color = {"info": "cyan", "success": "green", "error": "red", "warning": "yellow"}.get(message_type, "white")
+        self.update(f"[{color}]{message}[/{color}]")
+
+
+class PathExplorerApp(App[None]):
+    """A Textual app to explore PATH entries."""
+
+    CSS = """
+    Screen {
+        background: $surface;
+    }
+
+    Header {
+        background: $primary;
+        color: $text;
+    }
+
+    Footer {
+        background: $panel;
+    }
+
+    #main-container {
+        height: 100%;
+    }
+
+    #left-panel {
+        width: 50%;
+        height: 100%;
+        border: solid $primary;
+        padding: 1;
+    }
+
+    #right-panel {
+        width: 50%;
+        height: 100%;
+        border: solid $accent;
+        padding: 1;
+    }
+
+    ListView {
+        height: 1fr;
+        border: solid $accent;
+        background: $surface;
+    }
+
+    ListView > ListItem {
+        padding: 0 1;
+    }
+
+    ListView > ListItem.--highlight {
+        background: $accent 20%;
+    }
+
+    DirectoryPreview {
+        height: 1fr;
+        border: solid $primary;
+        background: $surface;
+        padding: 1;
+        overflow-y: auto;
+    }
+
+    StatusBar {
+        height: 3;
+        border: solid $success;
+        background: $surface;
+        padding: 1;
+    }
+
+    Label {
+        padding: 0 1;
+        height: auto;
+    }
+    """
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit", show=True),
+        Binding("r", "refresh", "Refresh", show=True),
+        Binding("c", "copy_path", "Copy Path", show=True),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.selected_path: str = ""
+
+    def compose(self) -> ComposeResult:
+        """Create child widgets for the app."""
+        platform_name = get_platform()
+        yield Header(show_clock=True)
+        
+        with Horizontal(id="main-container"):
+            with Vertical(id="left-panel"):
+                yield Label(f"🔧 PATH Entries ({platform_name})")
+                yield ListView(id="path-list")
+                
+            with Vertical(id="right-panel"):
+                yield DirectoryPreview(id="preview")
+                yield StatusBar(id="status")
+
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Initialize the app when mounted."""
+        self.title = "PATH Explorer"
+        self.sub_title = f"Platform: {get_platform()}"
+        self.refresh_path_list()
+        self.query_one("#status", StatusBar).show_message("Ready. Select a PATH entry to preview its contents.", "info")
+
+    def refresh_path_list(self) -> None:
+        """Refresh the list of PATH entries."""
+        list_view = self.query_one("#path-list", ListView)
+        list_view.clear()
+        
+        entries = get_path_entries()
+        for entry in entries:
+            path = Path(entry)
+            exists = path.exists()
+            icon = "✅" if exists else "❌"
+            item = ListItem(Label(f"{icon} {entry}"))
+            item.set_class(exists, "--valid")
+            list_view.append(item)
+        
+        self.query_one("#status", StatusBar).show_message(f"Loaded {len(entries)} PATH entries", "success")
+
+    @on(ListView.Highlighted)
+    def handle_highlight(self, event: ListView.Highlighted) -> None:
+        """Handle highlighting of a PATH entry (scroll preview)."""
+        if event.item is None:
+            return
+        label = event.item.query_one(Label)
+        text = label.render()
+        # Remove the icon prefix
+        highlighted_path = str(text).split(" ", 1)[1] if " " in str(text) else str(text)
+        
+        preview = self.query_one("#preview", DirectoryPreview)
+        preview.update_preview(highlighted_path)
+        
+        self.query_one("#status", StatusBar).show_message(f"Previewing: {highlighted_path}", "info")
+
+    @on(ListView.Selected)
+    def handle_selection(self, event: ListView.Selected) -> None:
+        """Handle selection of a PATH entry (Enter key)."""
+        label = event.item.query_one(Label)
+        text = label.render()
+        # Remove the icon prefix
+        self.selected_path = str(text).split(" ", 1)[1] if " " in str(text) else str(text)
+        
+        preview = self.query_one("#preview", DirectoryPreview)
+        preview.update_preview(self.selected_path)
+        
+        self.query_one("#status", StatusBar).show_message(f"Selected: {self.selected_path}", "success")
+
+    def action_refresh(self) -> None:
+        """Refresh the PATH list."""
+        self.refresh_path_list()
+
+    def action_copy_path(self) -> None:
+        """Copy selected path to clipboard."""
+        if not self.selected_path:
+            self.query_one("#status", StatusBar).show_message("No PATH entry selected", "warning")
+            return        
+        # # Try to copy to clipboard
+        # try:
+        #     import pyperclip
+        #     pyperclip.copy(self.selected_path)
+        #     self.query_one("#status", StatusBar).show_message(f"Copied to clipboard: {self.selected_path}", "success")
+        # except ImportError:
+        #     self.query_one("#status", StatusBar).show_message("pyperclip not available. Install it to enable clipboard support.", "warning")
+
+
+def main() -> None:
+    """Run the PATH Explorer TUI."""
+    app = PathExplorerApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

machineconfig/scripts/python/{helpers_fire → helpers/helpers_agents}/agentic_frameworks/fire_crush.json

@@ -7,7 +7,7 @@
         }
     },
     "providers": {
-        "openrouter": {
+        "{provider}": {
             "api_key": "{api_key}"
         }
     }

machineconfig/scripts/python/helpers/helpers_agents/agentic_frameworks/fire_crush.py

@@ -0,0 +1,39 @@
+
+from pathlib import Path
+# import shlex
+from machineconfig.scripts.python.helpers.helpers_agents.fire_agents_helper_types import AI_SPEC
+
+
+def fire_crush(ai_spec: AI_SPEC, prompt_path: Path, repo_root: Path) -> str:
+    match ai_spec["machine"]:
+        case "local":
+            cmd = f"""
+crush run {prompt_path}
+"""
+        case "docker":
+            assert ai_spec["api_spec"]["api_key"] is not None, "API key is required for Crush agent in docker mode."
+            json_path = Path(__file__).parent / "fire_crush.json"
+            json_template = json_path.read_text(encoding="utf-8")
+            api_key = ai_spec["api_spec"]["api_key"]
+            json_filled = json_template.replace("{api_key}", api_key)
+            json_filled = json_filled.replace("{model}", ai_spec["model"])
+            if ai_spec["provider"] == "google":
+                provider = "gemini"  # weird crush way of naming.
+            else:
+                provider = ai_spec["provider"]
+            json_filled = json_filled.replace("{provider}", provider)
+            from machineconfig.utils.accessories import randstr
+            temp_config_file_local = Path.home().joinpath("tmp_results/tmp_files/crush_" + randstr(8) + ".json")
+            temp_config_file_local.parent.mkdir(parents=True, exist_ok=True)
+            Path(temp_config_file_local).write_text(json_filled, encoding="utf-8")            
+            cmd = f"""
+
+docker run -it --rm \
+  -v "{repo_root}:/workspace/{repo_root.name}" \
+  -v "{temp_config_file_local}:/root/.local/share/crush/crush.json" \
+  -w "/workspace/{repo_root.name}" \
+  statistician/machineconfig-ai:latest \
+  bash -i -c "source ~/.bashrc && cd /workspace/{repo_root.name} && cat /root/.local/share/crush/crush.json && crush run 'Please act on contents of this prompt ./{prompt_path.relative_to(repo_root)}'"
+
+"""
+    return cmd

machineconfig/scripts/python/{helpers_fire → helpers/helpers_agents}/agentic_frameworks/fire_cursor_agents.py

@@ -2,11 +2,10 @@
 
 from pathlib import Path
 # import shlex
-from machineconfig.scripts.python.helpers_fire.fire_agents_helper_types import HOST
-from typing import Optional
+from machineconfig.scripts.python.helpers.helpers_agents.fire_agents_helper_types import AI_SPEC
 
-def fire_cursor(api_key: Optional[str], prompt_path: Path, machine: HOST) -> str:
-    match machine:
+def fire_cursor(ai_spec: AI_SPEC, prompt_path: Path) -> str:
+    match ai_spec["machine"]:
         case "local":
             # Export the environment variable so it's available to subshells
             cmd = f"""

machineconfig/scripts/python/helpers/helpers_agents/agentic_frameworks/fire_gemini.py

@@ -0,0 +1,55 @@
+
+from pathlib import Path
+import shlex
+from machineconfig.scripts.python.helpers.helpers_agents.fire_agents_helper_types import AI_SPEC
+
+
+def fire_gemini(ai_spec: AI_SPEC, prompt_path: Path, repo_root: Path) -> str:
+    _ = ai_spec["provider"]
+    # model = "gemini-2.5-flash-lite"
+    # model = None  # auto-select
+    # if model is None:
+    #     model_arg = ""
+    # else:
+    model_arg = f"--model {shlex.quote(ai_spec['model'])}"
+    # Need a real shell for the pipeline; otherwise '| gemini ...' is passed as args to 'cat'
+    safe_path = shlex.quote(str(prompt_path))
+    settings_dot_json = {
+   "security": {
+    "auth": {
+      "selectedType": "gemini-api-key"
+    }
+  }
+}
+    # settings_path = Path.home().joinpath(".gemini", "settings.json")
+    from machineconfig.utils.accessories import randstr
+    settings_tmp_path = Path.home().joinpath("tmp_results", "tmp_files", "agents", f"gemini_settings_{randstr()}.json")
+    settings_tmp_path.parent.mkdir(parents=True, exist_ok=True)
+    import json
+    settings_tmp_path.write_text(json.dumps(settings_dot_json, indent=2), encoding="utf-8")
+    match ai_spec["machine"]:
+        case "local":
+            # Export the environment variable so it's available to subshells
+            api_key = ai_spec["api_spec"]["api_key"]
+            if api_key is not None:
+                define_api_key = f"""export GEMINI_API_KEY="{shlex.quote(api_key)}" """
+            else:
+                define_api_key = "echo 'Warning: No GEMINI_API_KEY provided, hoping it is set in the environment.'"
+            cmd = f"""
+{define_api_key}
+echo "Using Gemini API key $GEMINI_API_KEY"
+gemini {model_arg} --yolo --prompt {safe_path}
+"""
+
+        case "docker":
+            api_key = ai_spec["api_spec"]["api_key"]
+            assert api_key is not None, "When using docker, api_key must be provided."
+            cmd = f"""
+docker run -it --rm \
+  -v {settings_tmp_path}:/root/.gemini/settings.json \
+  -v "{repo_root}:/workspace/{repo_root.name}" \
+  -w "/workspace/{repo_root.name}" \
+  statistician/machineconfig-ai:latest  \
+  bash -c '. ~/.bashrc; export GEMINI_API_KEY="{api_key}"; gemini --model {shlex.quote(ai_spec['model'])} --yolo {prompt_path.relative_to(repo_root)}'
+  """
+    return cmd

machineconfig/scripts/python/helpers/helpers_agents/agentic_frameworks/fire_qwen.py

@@ -0,0 +1,30 @@
+
+from pathlib import Path
+import shlex
+from machineconfig.scripts.python.helpers.helpers_agents.fire_agents_helper_types import AI_SPEC
+
+
+def fire_qwen(ai_spec: AI_SPEC, prompt_path: Path, repo_root: Path, config_dir: str | None) -> str:
+    _ = ai_spec["provider"]
+    safe_path = shlex.quote(str(prompt_path))
+    match ai_spec["machine"]:
+        case "local":
+            cmd = f"""
+qwen --yolo --prompt {safe_path}
+    """
+        case "docker":
+            assert config_dir is not None, "When using docker, config_dir must be provided."
+            assert Path(config_dir).exists(), f"Provided config_dir {config_dir} does not exist."
+            oauth_creds = Path(config_dir).joinpath("oauth_creds.json")
+            settings = Path(config_dir).joinpath("settings.json")
+
+            cmd = f"""
+docker run -it --rm \
+  -v "{repo_root}:/workspace/{repo_root.name}" \
+  -v {shlex.quote(str(oauth_creds))}:/root/.qwen/oauth_creds.json \
+  -v {shlex.quote(str(settings))}:/root/.qwen/settings.json \
+  -w "/workspace/{repo_root.name}" \
+  statistician/machineconfig-ai:latest \
+  qwen --prompt "$PATH_PROMPT"
+"""
+    return cmd