machineconfig 2.9__tar.gz → 2.95__tar.gz

{machineconfig-2.9/src/machineconfig.egg-info → machineconfig-2.95}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 2.9
+Version: 2.95
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0

{machineconfig-2.9 → machineconfig-2.95}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "machineconfig"
-version = "2.9"
+version = "2.95"
 description = "Dotfiles management package"
 readme = "README.md"
 license = {text = "Apache 2.0"}
@@ -86,6 +86,7 @@ dev = [
     "ipykernel>=6.30.1",
     "ipython>=9.5.0",
     "mypy>=1.18.2",
+    "pre-commit>=4.3.0",
     "pudb>=2025.1",
     "pylint>=3.3.8",
     "pyrefly>=0.33.1",

{machineconfig-2.9 → machineconfig-2.95}/src/machineconfig/cluster/sessions_managers/zellij_local_manager.py

@@ -24,16 +24,8 @@ TMP_SERIALIZATION_DIR = Path.home().joinpath("tmp_results", "session_manager", "
 class ZellijLocalManager:
     """Manages multiple local zellij sessions and monitors their tabs and processes."""
 
-    def __init__(self, session_layouts: list[LayoutConfig], session_name_prefix: str = "LocalJobMgr"):
-        """
-        Initialize the local zellij manager.
-
-        Args:
-            session_layouts: Dict mapping session names to their layout configs
-                Format: {session_name: LayoutConfig, ...}
-            session_name_prefix: Prefix for session names
-        """
-        self.session_name_prefix = session_name_prefix
+    def __init__(self, session_layouts: list[LayoutConfig], ):
+        self.session_name_prefix = "LocalJobMgr"
         self.session_layouts = session_layouts  # Store the original config
         self.managers: List[ZellijLayoutGenerator] = []
 
@@ -368,16 +360,8 @@ class ZellijLocalManager:
         with open(config_file, "r", encoding="utf-8") as f:
             session_layouts = json.load(f)
 
-        # Load metadata
-        metadata_file = session_dir / "metadata.json"
-        session_name_prefix = "LocalJobMgr"  # default fallback
-        if metadata_file.exists():
-            with open(metadata_file, "r", encoding="utf-8") as f:
-                metadata = json.load(f)
-                session_name_prefix = metadata.get("session_name_prefix", "LocalJobMgr")
-
         # Create new instance
-        instance = cls(session_layouts=session_layouts, session_name_prefix=session_name_prefix)
+        instance = cls(session_layouts=session_layouts)
 
         # Load saved manager states
         managers_dir = session_dir / "managers"
@@ -498,7 +482,7 @@ if __name__ == "__main__":
     ]
     try:
         # Create the local manager
-        manager = ZellijLocalManager(sample_sessions, session_name_prefix="DevEnv")
+        manager = ZellijLocalManager(sample_sessions,)
         print(f"✅ Local manager created with {len(manager.managers)} sessions")
 
         # Show session names

{machineconfig-2.9 → machineconfig-2.95}/src/machineconfig/scripts/python/ai/mcinit.py

@@ -1,6 +1,6 @@
-from pathlib import Path
-from typing import Optional
 
+from pathlib import Path
+from machineconfig.utils.ve import get_repo_root
 
 installations = """
 uv add --upgrade-package pylint pyright mypy pyrefly ty --dev  # linters and type checkers
@@ -8,18 +8,6 @@ uv add --upgrade-package pytest --dev
 """
 
 
-def get_repo_root(path: Path) -> Optional[Path]:
-    from git import Repo, InvalidGitRepositoryError
-
-    try:
-        repo = Repo(path, search_parent_directories=True)
-        root = repo.working_tree_dir
-        if root is not None:
-            return Path(root)
-    except InvalidGitRepositoryError:
-        pass
-    return None
-
 
 def add_ai_configs(repo_root: Path) -> None:
     import machineconfig as mc

{machineconfig-2.9 → machineconfig-2.95}/src/machineconfig/scripts/python/devops_update_repos.py

@@ -73,8 +73,6 @@ def _display_summary(results: list[RepositoryUpdateResult]) -> None:
             changes = []
             if result["pyproject_changed"]:
                 changes.append("pyproject.toml")
-            if result["uv_lock_changed"]:
-                changes.append("uv.lock")
             print(f"      📋 Dependencies changed: {', '.join(changes)}")
             
         if result["uv_sync_ran"]:
@@ -156,7 +154,6 @@ def main(verbose: bool = True, allow_password_prompt: bool = False) -> None:
                 "commit_after": "",
                 "commits_changed": False,
                 "pyproject_changed": False,
-                "uv_lock_changed": False,
                 "dependencies_changed": False,
                 "uv_sync_ran": False,
                 "uv_sync_success": False,
@@ -171,7 +168,7 @@ def main(verbose: bool = True, allow_password_prompt: bool = False) -> None:
 Exception: {ex}
 {"-" * 50}""")
     
-    # Run uv sync for repositories where pyproject.toml or uv.lock changed but sync wasn't run yet
+    # Run uv sync for repositories where pyproject.toml changed but sync wasn't run yet
     for repo_path in repos_with_changes:
         run_uv_sync(repo_path)
     

machineconfig-2.95/src/machineconfig/scripts/python/fire_agents.py

@@ -0,0 +1,150 @@
+"""Utility to launch multiple AI agent prompts in a Zellij session.
+
+Improved design notes:
+  * Clear separation of: input collection, prompt preparation, agent launch.
+  * Configurable max agent cap (default 15) with interactive confirmation if exceeded.
+  * Added type aliases + docstrings for maintainability.
+  * Preserves original core behavior & command generation for each agent type.
+"""
+
+from pathlib import Path
+from typing import cast, get_args, Iterable, TypeAlias, Literal
+import json
+import sys
+
+from machineconfig.scripts.python.fire_agents_help_launch import prep_agent_launch, get_agents_launch_layout, AGENTS
+from machineconfig.scripts.python.fire_agents_help_search import search_files_by_pattern, search_python_files
+from machineconfig.scripts.python.fire_agents_load_balancer import chunk_prompts, SPLITTING_STRATEGY, DEFAULT_AGENT_CAP
+from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+from machineconfig.utils.options import choose_one_option
+from machineconfig.utils.ve import get_repo_root
+
+SEARCH_STRATEGIES: TypeAlias = Literal["file_path", "keyword_search", "filename_pattern"]
+
+
+def _write_list_file(target: Path, files: Iterable[Path]) -> None:
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text("\n".join(str(f) for f in files), encoding="utf-8")
+
+
+def get_prompt_material(search_strategy: SEARCH_STRATEGIES, repo_root: Path) -> tuple[Path, str]:
+    if search_strategy == "file_path":
+        file_path_input = input("Enter path to target file: ").strip()
+        if not file_path_input:
+            print("No file path provided. Exiting.")
+            sys.exit(1)
+        target_file_path = Path(file_path_input).expanduser().resolve()
+        if not target_file_path.exists() or not target_file_path.is_file():
+            print(f"Invalid file path: {target_file_path}")
+            sys.exit(1)
+        separator = input("Enter separator [\\n]: ").strip() or "\n"
+    elif search_strategy == "keyword_search":
+        keyword = input("Enter keyword to search recursively for all .py files containing it: ").strip()
+        if not keyword:
+            print("No keyword supplied. Exiting.")
+            sys.exit(1)
+        matching_files = search_python_files(repo_root, keyword)
+        if not matching_files:
+            print(f"💥 No .py files found containing keyword: {keyword}")
+            sys.exit(1)
+        for idx, mf in enumerate(matching_files):
+            print(f"{idx:>3}: {mf}")
+        print(f"\nFound {len(matching_files)} .py files containing keyword: {keyword}")
+        target_file_path = repo_root / ".ai" / "target_file.txt"
+        _write_list_file(target_file_path, matching_files)
+        separator = "\n"
+    elif search_strategy == "filename_pattern":
+        pattern = input("Enter filename pattern (e.g., '*.py', '*test*', 'config.*'): ").strip()
+        if not pattern:
+            print("No pattern supplied. Exiting.")
+            sys.exit(1)
+        matching_files = search_files_by_pattern(repo_root, pattern)
+        if not matching_files:
+            print(f"💥 No files found matching pattern: {pattern}")
+            sys.exit(1)
+        for idx, mf in enumerate(matching_files):
+            print(f"{idx:>3}: {mf}")
+        print(f"\nFound {len(matching_files)} files matching pattern: {pattern}")
+        target_file_path = repo_root / ".ai" / "target_file.txt"
+        _write_list_file(target_file_path, matching_files)
+        separator = "\n"
+    else:
+        raise ValueError(f"Unknown search strategy: {search_strategy}")
+    return target_file_path, separator
+
+
+def main():  # noqa: C901 - (complexity acceptable for CLI glue)
+    repo_root = get_repo_root(Path.cwd())
+    if repo_root is None:
+        print("💥 Could not determine the repository root. Please run this script from within a git repository.")
+        sys.exit(1)
+    print(f"Operating @ {repo_root}")
+
+    search_strategy = cast(SEARCH_STRATEGIES, choose_one_option(header="Choose search strategy:", options=get_args(SEARCH_STRATEGIES)))
+    splitting_strategy = cast(SPLITTING_STRATEGY, choose_one_option(header="Choose prompt splitting strategy:", options=get_args(SPLITTING_STRATEGY)))
+    agent_selected = cast(AGENTS, choose_one_option(header="Select agent type", options=get_args(AGENTS)))
+    print("Enter prefix prompt (end with Ctrl-D / Ctrl-Z):")
+    prompt_prefix = "\n".join(sys.stdin.readlines())
+    job_name = input("Enter job name [AI_AGENTS]: ") or "AI_Agents"
+    keep_material_in_separate_file_input = input("Keep prompt material in separate file? [y/N]: ").strip().lower() == "y"
+
+    prompt_material_path, separator = get_prompt_material(search_strategy=search_strategy, repo_root=repo_root)
+    match splitting_strategy:
+        case "agent_cap":
+            agent_cap_input = input(f"Enter maximum number of agents/splits [default: {DEFAULT_AGENT_CAP}]: ").strip()
+            agent_cap = int(agent_cap_input) if agent_cap_input else DEFAULT_AGENT_CAP
+            task_rows = None
+        case "task_rows":
+            task_rows_input: str = input("Enter number of rows/tasks per agent [13]: ").strip() or "13"
+            task_rows = int(task_rows_input)
+            agent_cap = None
+    prompt_material_re_splitted = chunk_prompts(prompt_material_path, splitting_strategy, agent_cap=agent_cap, task_rows=task_rows, joiner=separator)
+
+    agents_dir = prep_agent_launch(repo_root=repo_root, prompts_material=prompt_material_re_splitted, keep_material_in_separate_file=keep_material_in_separate_file_input, prompt_prefix=prompt_prefix, agent=agent_selected, job_name=job_name)
+    layoutfile = get_agents_launch_layout(session_root=agents_dir)
+
+    regenerate_py_code = f"""
+#!/usr/bin/env uv run --python 3.13 --with machineconfig
+#!/usr/bin/env uv run --project $HOME/code/machineconfig
+
+from machineconfig.scripts.python.fire_agents import *
+
+repo_root = Path("{repo_root}")
+search_strategy = "{search_strategy}"
+splitting_strategy = "{splitting_strategy}"
+agent_selected = "{agent_selected}"
+prompt_prefix = '''{prompt_prefix}'''
+job_name = "{job_name}"
+keep_material_in_separate_file_input = {keep_material_in_separate_file_input}
+separator = "{separator}"
+prompt_material_path = Path("{prompt_material_path}")
+agent_cap = {agent_cap}
+task_rows = {task_rows}
+
+prompt_material_re_splitted = chunk_prompts(prompt_material_path, splitting_strategy, agent_cap=agent_cap, task_rows=task_rows, joiner=separator)
+agents_dir = prep_agent_launch(repo_root=repo_root, prompts_material=prompt_material_re_splitted, keep_material_in_separate_file=keep_material_in_separate_file_input, prompt_prefix=prompt_prefix, agent=agent_selected, job_name=job_name)
+layout = get_agents_launch_layout(session_root=agents_dir)
+
+(agents_dir / "aa_agents_relaunch.py").write_text(data=regenerate_py_code, encoding="utf-8")
+(agents_dir / "layout.json").write_text(data=json.dumps(layout, indent=2), encoding="utf-8")
+
+if len(layout["layoutTabs"]) > 25:
+    print("Too many agents (>25) to launch. Skipping launch.")
+    sys.exit(0)
+manager = ZellijLocalManager(session_layouts=[layout])
+manager.start_all_sessions()
+manager.run_monitoring_routine()
+
+"""
+    (agents_dir / "aa_agents_relaunch.py").write_text(data=regenerate_py_code, encoding="utf-8")
+    (agents_dir / "layout.json").write_text(data=json.dumps(layoutfile, indent=2), encoding="utf-8")
+    if len(layoutfile["layouts"][0]["layoutTabs"]) > 25:
+        print("Too many agents (>25) to launch. Skipping launch.")
+        sys.exit(0)
+    manager = ZellijLocalManager(session_layouts=layoutfile["layouts"])
+    manager.start_all_sessions()
+    manager.run_monitoring_routine()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

machineconfig-2.95/src/machineconfig/scripts/python/fire_agents_help_launch.py

@@ -0,0 +1,142 @@
+
+from machineconfig.utils.utils2 import randstr
+
+import random
+import shlex
+from pathlib import Path
+from typing import Literal, TypeAlias
+
+
+AGENTS: TypeAlias = Literal[
+    "cursor-agent", "gemini", "crush", "q", "onlyPrepPromptFiles"
+    # warp terminal
+]
+AGENT_NAME_FORMATTER = "agent_{idx}_cmd.sh"  # e.g., agent_0_cmd.sh
+
+
+def get_gemini_api_keys() -> list[str]:
+    from machineconfig.utils.utils2 import read_ini
+    config = read_ini(Path.home().joinpath("dotfiles/creds/llm/gemini/api_keys.ini"))
+    res: list[str] = []
+    for a_section_name in list(config.sections()):
+        a_section = config[a_section_name]
+        if "api_key" in a_section:
+            api_key = a_section["api_key"].strip()
+            if api_key:
+                res.append(api_key)
+    print(f"Found {len(res)} Gemini API keys configured.")
+    return res
+
+def prep_agent_launch(repo_root: Path, prompts_material: list[str], prompt_prefix: str, keep_material_in_separate_file: bool,  agent: AGENTS, *, job_name: str) -> Path:
+    session_root = repo_root / ".ai" / f"tmp_prompts/{job_name}_{randstr()}"
+    session_root.mkdir(parents=True, exist_ok=True)
+    prompt_folder = session_root / "prompts"
+    prompt_folder.mkdir(parents=True, exist_ok=True)
+
+    all_materials_scripts: list[Path] = []
+    for idx, a_prompt_material in enumerate(prompts_material):
+        prompt_root = prompt_folder / f"agent_{idx}"
+        prompt_root.mkdir(parents=True, exist_ok=True)
+        prompt_path = prompt_root / f"agent_{idx}_prompt.txt"
+        if keep_material_in_separate_file:
+            prompt_material_path = prompt_root / f"agent_{idx}_material.txt"
+            prompt_material_path.write_text(a_prompt_material, encoding="utf-8")
+            prompt_path.write_text(prompt_prefix + f"""\nPlease only look @ {prompt_material_path}. You don't need to do any other work beside the content of this material file.""", encoding="utf-8")
+            all_materials_scripts.append(prompt_material_path)
+        else:
+            prompt_material_path = prompt_path
+            prompt_path.write_text(prompt_prefix + """\nPlease only look @ the following:\n""" + a_prompt_material, encoding="utf-8")
+
+        agent_cmd_launch_path = prompt_root / AGENT_NAME_FORMATTER.format(idx=idx)  # e.g., agent_0_cmd.sh
+        random_sleep_time = random.uniform(0, 5)
+        cmd_prefix = f"""
+#!/usr/bin/env bash
+
+# AGENT-{idx}-LAUNCH-SCRIPT
+# Auto-generated by fire_agents.py
+
+export FIRE_AGENTS_AGENT_NAME="{agent}"
+export FIRE_AGENTS_JOB_NAME="{job_name}"
+export FIRE_AGENTS_PROMPT_FILE="{prompt_path}"
+export FIRE_AGENTS_MATERIAL_FILE="{prompt_material_path}"
+export FIRE_AGENTS_AGENT_LAUNCHER="{agent_cmd_launch_path}"
+
+echo "Sleeping for {random_sleep_time:.2f} seconds to stagger agent startups..."
+sleep {random_sleep_time:.2f}
+echo "Launching agent {agent} with prompt from {prompt_path}"
+echo "Launching agent {agent} with command from {agent_cmd_launch_path}"
+echo "--------START OF AGENT OUTPUT--------"
+sleep 0.1
+
+"""
+        match agent:
+            case "gemini":
+                model = "gemini-2.5-pro"
+                # model = "gemini-2.5-flash-lite"
+                # model = None  # auto-select
+                if model is None:
+                    model_arg = ""
+                else:
+                    model_arg = f"--model {shlex.quote(model)}"
+                # Need a real shell for the pipeline; otherwise '| gemini ...' is passed as args to 'cat'
+                safe_path = shlex.quote(str(prompt_path))
+                api_keys = get_gemini_api_keys()
+                api_key = api_keys[idx % len(api_keys)] if api_keys else ""
+                # Export the environment variable so it's available to subshells
+                cmd = f"""
+export GEMINI_API_KEY={shlex.quote(api_key)}
+echo "Using Gemini API key $GEMINI_API_KEY"
+bash -lc 'cat {safe_path} | gemini {model_arg} --yolo --prompt'
+"""
+            case "cursor-agent":
+                # As originally implemented
+                cmd = f"""
+
+cursor-agent --print --output-format text < {prompt_path}
+
+"""
+            case "crush":
+                cmd = f"""
+crush run {prompt_path}
+"""
+            case "q":
+                cmd = f"""
+q chat --no-interactive --trust-all-tools {prompt_path}
+"""
+            case "onlyPrepPromptFiles":
+                cmd = f"""
+echo "Prepared prompt file at {prompt_path}"
+"""
+            case _:
+                raise ValueError(f"Unsupported agent type: {agent}")
+        cmd_postfix = """
+sleep 0.1
+echo "---------END OF AGENT OUTPUT---------"
+"""
+        agent_cmd_launch_path.write_text(cmd_prefix + cmd + cmd_postfix, encoding="utf-8")
+
+
+    # print(f"Launching a template with #{len(tab_config)} agents")
+    if len(all_materials_scripts) > 0:
+        all_materials_list_path = session_root / "all_materials_redistributed.txt"
+        all_materials_list_path.write_text("\n".join(str(p) for p in all_materials_scripts), encoding="utf-8")
+        print(f"All prompt materials listed @ {all_materials_list_path}")
+    return session_root
+
+
+def get_agents_launch_layout(session_root: Path):
+    from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig, LayoutsFile
+    tab_config: list[TabConfig] = []
+    prompt_root = session_root / "prompts"
+    all_dirs_under_prompts = [d for d in prompt_root.iterdir() if d.is_dir()]
+    launch_agents_squentially = ""
+    for a_prompt_dir in all_dirs_under_prompts:
+        idx = a_prompt_dir.name.split("_")[-1]  # e.g., agent_0 -> 0
+        agent_cmd_path = a_prompt_dir / AGENT_NAME_FORMATTER.format(idx=idx)
+        fire_cmd = f"bash {shlex.quote(str(agent_cmd_path))}"
+        tab_config.append(TabConfig(tabName=f"Agent{idx}", startDir=str(session_root.parent.parent.parent), command=fire_cmd))
+        launch_agents_squentially += f". {shlex.quote(str(agent_cmd_path))}\n"
+    layout = LayoutConfig(layoutName="Agents", layoutTabs=tab_config)
+    (session_root / "launch_all_agents_sequentially.sh").write_text(launch_agents_squentially, encoding="utf-8")
+    layouts_file: LayoutsFile = LayoutsFile(version="1.0", layouts=[layout])
+    return layouts_file

{machineconfig-2.9 → machineconfig-2.95}/src/machineconfig/scripts/python/fire_agents_help_search.py

@@ -1,6 +1,5 @@
-from machineconfig.utils.source_of_truth import EXCLUDE_DIRS
-
 
+from machineconfig.utils.source_of_truth import EXCLUDE_DIRS
 import fnmatch
 from pathlib import Path
 

machineconfig-2.95/src/machineconfig/scripts/python/fire_agents_load_balancer.py

@@ -0,0 +1,52 @@
+
+
+from typing import Literal, TypeAlias
+from math import ceil
+from pathlib import Path
+
+
+SPLITTING_STRATEGY: TypeAlias = Literal[
+    "agent_cap",  # User decides number of agents, rows/tasks determined automatically
+    "task_rows"   # User decides number of rows/tasks, number of agents determined automatically
+]
+DEFAULT_AGENT_CAP = 6
+
+
+def chunk_prompts(prompt_material_path: Path, strategy: SPLITTING_STRATEGY, joiner: str, *, agent_cap: int | None, task_rows: int | None) -> list[str]:
+    """Chunk prompts based on splitting strategy.
+    
+    Args:
+        prompts: List of prompts to chunk
+        strategy: Either 'agent_cap' or 'task_rows'  
+        agent_cap: Maximum number of agents (used with 'agent_cap' strategy)
+        task_rows: Number of rows/tasks per agent (used with 'task_rows' strategy)
+    """
+    prompts = [p for p in prompt_material_path.read_text(encoding="utf-8", errors="ignore").split(joiner) if p.strip() != ""]  # drop blank entries
+    
+    if strategy == "agent_cap":
+        if agent_cap is None:
+            raise ValueError("agent_cap must be provided when using 'agent_cap' strategy")
+        
+        if len(prompts) <= agent_cap:
+            return prompts
+        
+        print(f"Chunking {len(prompts)} prompts into groups for up to {agent_cap} agents because it exceeds the cap.")
+        chunk_size = ceil(len(prompts) / agent_cap)
+        grouped: list[str] = []
+        for i in range(0, len(prompts), chunk_size):
+            grouped.append(joiner.join(prompts[i : i + chunk_size]))
+        return grouped
+    
+    elif strategy == "task_rows":
+        if task_rows is None:
+            raise ValueError("task_rows must be provided when using 'task_rows' strategy")
+        if task_rows >= len(prompts):
+            return prompts
+        print(f"Chunking {len(prompts)} prompts into groups of {task_rows} rows/tasks each.")
+        grouped: list[str] = []
+        for i in range(0, len(prompts), task_rows):
+            grouped.append(joiner.join(prompts[i : i + task_rows]))
+        return grouped
+    
+    else:
+        raise ValueError(f"Unknown splitting strategy: {strategy}")

{machineconfig-2.9 → machineconfig-2.95}/src/machineconfig/scripts/python/fire_jobs.py

@@ -21,6 +21,7 @@ from machineconfig.utils.utils2 import randstr, read_toml
 from machineconfig.scripts.python.fire_jobs_args_helper import get_args, FireJobArgs, extract_kwargs
 import platform
 from typing import Optional
+from pathlib import Path
 # import os
 
 
@@ -42,7 +43,7 @@ def route(args: FireJobArgs) -> None:
         choice_file = PathExtended(choice_file)
     else:
         choice_file = path_obj
-    repo_root = get_repo_root(str(choice_file))
+    repo_root = get_repo_root(Path(choice_file))
     print(f"💾 Selected file: {choice_file}.\nRepo root: {repo_root}")
     ve_root_from_file, ipy_profile = get_ve_path_and_ipython_profile(choice_file)
     if ipy_profile is None:

{machineconfig-2.9 → machineconfig-2.95}/src/machineconfig/scripts/python/repos_helper_update.py

@@ -15,7 +15,6 @@ class RepositoryUpdateResult(TypedDict):
     commit_after: str
     commits_changed: bool
     pyproject_changed: bool
-    uv_lock_changed: bool
     dependencies_changed: bool
     uv_sync_ran: bool
     uv_sync_success: bool
@@ -80,7 +79,6 @@ def update_repository(repo: git.Repo, auto_sync: bool, allow_password_prompt: bo
         "commit_after": "",
         "commits_changed": False,
         "pyproject_changed": False,
-        "uv_lock_changed": False,
         "dependencies_changed": False,
         "uv_sync_ran": False,
         "uv_sync_success": False,
@@ -104,33 +102,18 @@ def update_repository(repo: git.Repo, auto_sync: bool, allow_password_prompt: bo
         result["uncommitted_files"] = changed_files
         print(f"⚠️  Repository has uncommitted changes: {', '.join(changed_files)}")
 
-        # Check if the only change is uv.lock
-        if len(changed_files) == 1 and changed_files[0] == "uv.lock":
-            print("🔒 Only uv.lock has changes, resetting it...")
-            try:
-                # Reset uv.lock file
-                subprocess.run(["git", "checkout", "HEAD", "--", "uv.lock"], cwd=repo_path, check=True)
-                print("✅ uv.lock has been reset")
-            except subprocess.CalledProcessError as e:
-                result["status"] = "error"
-                result["error_message"] = f"Failed to reset uv.lock: {e}"
-                print(f"❌ Failed to reset uv.lock: {e}")
-                return result
-        else:
-            # Multiple files or files other than uv.lock have changes
-            result["status"] = "error"
-            result["error_message"] = f"Cannot update repository - there are pending changes in: {', '.join(changed_files)}. Please commit or stash your changes first."
-            raise RuntimeError(result["error_message"])
+        # Repository has uncommitted changes - cannot update
+        result["status"] = "error"
+        result["error_message"] = f"Cannot update repository - there are pending changes in: {', '.join(changed_files)}. Please commit or stash your changes first."
+        raise RuntimeError(result["error_message"])
     else:
         print("✅ Repository is clean")
 
-    # Check if this repo has pyproject.toml or uv.lock
+    # Check if this repo has pyproject.toml
     pyproject_path = repo_path / "pyproject.toml"
-    uv_lock_path = repo_path / "uv.lock"
 
     # Get hashes before pull
     pyproject_hash_before = get_file_hash(pyproject_path)
-    uv_lock_hash_before = get_file_hash(uv_lock_path)
 
     # Get current commit hash before pull
     result["commit_before"] = repo.head.commit.hexsha
@@ -239,20 +222,14 @@ def update_repository(repo: git.Repo, auto_sync: bool, allow_password_prompt: bo
                 print(f"⚠️  Failed to pull from {remote.name}: {e}")
                 continue
 
-        # Check if pyproject.toml or uv.lock changed after pull
+        # Check if pyproject.toml changed after pull
         pyproject_hash_after = get_file_hash(pyproject_path)
-        uv_lock_hash_after = get_file_hash(uv_lock_path)
 
         if pyproject_hash_before != pyproject_hash_after:
             print("📋 pyproject.toml has changed")
             result["pyproject_changed"] = True
             result["dependencies_changed"] = True
 
-        if uv_lock_hash_before != uv_lock_hash_after:
-            print("🔒 uv.lock has changed")
-            result["uv_lock_changed"] = True
-            result["dependencies_changed"] = True
-
         # Special handling for machineconfig repository
         if result["is_machineconfig_repo"]:
             print("🛠  Special handling for machineconfig repository...")

machineconfig-2.95/src/machineconfig/utils/schemas/fire_agents/fire_agents_input.py

@@ -0,0 +1,70 @@
+"""TypedDict definitions for fire_agents.py inputs.
+
+This module defines the structured input types for the fire_agents main function,
+capturing all user inputs collected during interactive execution.
+"""
+
+from pathlib import Path
+from typing import TypedDict, Literal, NotRequired
+from machineconfig.scripts.python.fire_agents_load_balancer import SPLITTING_STRATEGY
+from machineconfig.scripts.python.fire_agents_help_launch import AGENTS
+
+SEARCH_STRATEGIES = Literal["file_path", "keyword_search", "filename_pattern"]
+
+
+class FilePathSearchInput(TypedDict):
+    """Input for file_path search strategy."""
+    file_path: str
+    separator: str  # Default: "\n"
+
+
+class KeywordSearchInput(TypedDict):
+    """Input for keyword_search strategy."""
+    keyword: str
+
+
+class FilenamePatternSearchInput(TypedDict):
+    """Input for filename_pattern search strategy."""
+    pattern: str  # e.g., '*.py', '*test*', 'config.*'
+
+
+class AgentCapSplittingInput(TypedDict):
+    """Input for agent_cap splitting strategy."""
+    agent_cap: int  # Default: 6
+
+
+class TaskRowsSplittingInput(TypedDict):
+    """Input for task_rows splitting strategy."""
+    task_rows: int  # Default: 13
+
+
+class FireAgentsMainInput(TypedDict):
+    """Complete input structure for fire_agents main function."""
+    
+    # Core configuration
+    repo_root: Path
+    search_strategy: SEARCH_STRATEGIES
+    splitting_strategy: SPLITTING_STRATEGY
+    agent_selected: AGENTS
+    prompt_prefix: str
+    job_name: str  # Default: "AI_Agents"
+    keep_material_in_separate_file: bool  # Default: False
+    max_agents: int  # Default: 25
+    
+    # Search strategy specific inputs (only one will be present based on search_strategy)
+    file_path_input: NotRequired[FilePathSearchInput]
+    keyword_search_input: NotRequired[KeywordSearchInput]
+    filename_pattern_input: NotRequired[FilenamePatternSearchInput]
+    
+    # Splitting strategy specific inputs (only one will be present based on splitting_strategy)
+    agent_cap_input: NotRequired[AgentCapSplittingInput]
+    task_rows_input: NotRequired[TaskRowsSplittingInput]
+
+
+class FireAgentsRuntimeData(TypedDict):
+    """Runtime data derived from inputs during execution."""
+    
+    prompt_material: str
+    separator: str
+    prompt_material_re_splitted: list[str]
+    random_name: str  # 3-character random string for session naming

{machineconfig-2.9 → machineconfig-2.95}/src/machineconfig/utils/schemas/layouts/layout_types.py

@@ -17,7 +17,6 @@ class TabConfig(TypedDict):
 
 class LayoutConfig(TypedDict):
     """Configuration for a complete layout with its tabs."""
-
     layoutName: str
     layoutTabs: List[TabConfig]