gemini-computer-use 0.4.3 → 0.4.5

package/core/agent_harness.py

@@ -1,67 +0,0 @@
-import os
-import uuid
-from typing import Optional, List
-from google.antigravity import LocalAgentConfig, types
-from core.hooks import get_mesh_hooks
-from core.triggers import create_mesh_watchdog_trigger, create_config_trigger
-from core.policies import get_mesh_policies, ALLOWED_WORKSPACES
-from core.subagents import get_mesh_subagents, get_root_capabilities_config
-
-# Derived from the coordinator workspace so the harness works wherever that root
-# is: the documented /root/agy-gdrive-runner on Linux, %USERPROFILE%\agy-gdrive-runner
-# on Windows. A hardcoded POSIX literal was rejected there by the SDK
-# ("app_data_dir must be an absolute path") because os.path.isabs('/root/...') is
-# False on Windows. os.path.abspath keeps it absolute even if the operator pointed
-# MESH_COORDINATOR_WORKSPACE at a relative path.
-_COORDINATOR_ROOT = os.path.abspath(ALLOWED_WORKSPACES[0])
-DEFAULT_SAVE_DIR = os.path.join(_COORDINATOR_ROOT, ".state", "sessions")
-DEFAULT_APP_DATA_DIR = os.path.join(_COORDINATOR_ROOT, ".state", "artifacts")
-
-ROOT_SYSTEM_INSTRUCTIONS = (
-    "You are the Root Orchestrator for the Antigravity Remote Execution Mesh. "
-    "Execute commands strictly through native tools and verified subagents. "
-    "Adhere to Zero Drive Queue Policy and Hard Error Halt invariants."
-)
-
-def create_agent_config(
-    conversation_id: Optional[str] = None,
-    save_dir: Optional[str] = None,
-    app_data_dir: Optional[str] = None,
-    interactive: bool = True,
-    max_model_calls: int = 30,
-) -> LocalAgentConfig:
-    resolved_save_dir = save_dir or DEFAULT_SAVE_DIR
-    resolved_app_data_dir = app_data_dir or DEFAULT_APP_DATA_DIR
-    resolved_conv_id = conversation_id or str(uuid.uuid4())
-
-    os.makedirs(resolved_save_dir, exist_ok=True)
-    os.makedirs(resolved_app_data_dir, exist_ok=True)
-
-    hooks = get_mesh_hooks()
-    triggers = [
-        create_mesh_watchdog_trigger(interval_seconds=60.0),
-        create_config_trigger(path="server_facts.json"),
-    ]
-    policies = get_mesh_policies()
-    subagents = get_mesh_subagents()
-    capabilities = get_root_capabilities_config()
-    
-    budget = types.BudgetConfig(
-        max_model_calls=max_model_calls,
-        max_tool_calls=60,
-        max_total_tokens=200_000,
-    )
-
-    return LocalAgentConfig(
-        system_instructions=ROOT_SYSTEM_INSTRUCTIONS,
-        conversation_id=resolved_conv_id,
-        save_dir=resolved_save_dir,
-        app_data_dir=resolved_app_data_dir,
-        hooks=hooks,
-        triggers=triggers,
-        policies=policies,
-        subagents=subagents,
-        capabilities=capabilities,
-        workspaces=ALLOWED_WORKSPACES,
-        budget_config=budget,
-    )

package/core/code_cache.py

@@ -1,244 +0,0 @@
-import ast
-import os
-import json
-from typing import List, Dict, Optional, Any
-from pydantic import BaseModel, Field
-
-
-def _index_key(path: str) -> str:
-    """Canonical, platform-stable key for a file inside the index.
-
-    ``os.path.normpath`` returns backslashes on Windows, so the same repository
-    produced ``core\\schemas.py`` there and ``core/schemas.py`` on Linux: the
-    cache written on one platform did not match on the other and symbols were
-    reported with a separator the model could not paste back into a command.
-    Forward slashes work for every Windows API too, so they are used everywhere.
-    """
-    return os.path.normpath(path).replace("\\", "/")
-
-class CodeSymbol(BaseModel):
-    name: str
-    kind: str  # "class", "function", "async_function"
-    file_path: str
-    line_start: int
-    line_end: int
-    docstring: Optional[str] = None
-
-class FileEntry(BaseModel):
-    path: str
-    mtime: float
-    size: int
-    symbols: List[CodeSymbol] = Field(default_factory=list)
-
-class CodeIndex:
-    IGNORE_DIRS = {
-        ".git",
-        "__pycache__",
-        ".pytest_cache",
-        ".state",
-        "live_logs",
-        "node_modules",
-        ".gemini",
-        ".agents",
-    }
-
-    def __init__(self, root_dir: str = ".", cache_file: str = ".state/code_index.json"):
-        self.root_dir = root_dir
-        self.cache_file = cache_file
-        self.files: Dict[str, FileEntry] = {}
-        self.symbol_map: Dict[str, List[CodeSymbol]] = {}
-        self._content_cache: Dict[str, tuple[float, List[str]]] = {}
-        self._load_cache()
-
-    def _load_cache(self) -> None:
-        if os.path.exists(self.cache_file):
-            try:
-                with open(self.cache_file, "r", encoding="utf-8") as f:
-                    data = json.load(f)
-                for path, entry_data in data.get("files", {}).items():
-                    entry = FileEntry.model_validate(entry_data)
-                    self.files[path] = entry
-                    for sym in entry.symbols:
-                        self.symbol_map.setdefault(sym.name, []).append(sym)
-            except Exception:
-                self.files = {}
-                self.symbol_map = {}
-
-    def _save_cache(self) -> None:
-        try:
-            os.makedirs(os.path.dirname(os.path.abspath(self.cache_file)), exist_ok=True)
-            data = {
-                "files": {k: v.model_dump() for k, v in self.files.items()}
-            }
-            tmp_file = self.cache_file + ".tmp"
-            with open(tmp_file, "w", encoding="utf-8") as f:
-                json.dump(data, f, indent=2)
-            os.replace(tmp_file, self.cache_file)
-        except Exception:
-            pass
-
-    def _parse_py_file(self, file_path: str) -> List[CodeSymbol]:
-        symbols: List[CodeSymbol] = []
-        try:
-            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
-                code = f.read()
-            tree = ast.parse(code, filename=file_path)
-            for node in ast.iter_child_nodes(tree):
-                if isinstance(node, ast.ClassDef):
-                    doc = ast.get_docstring(node)
-                    end_lineno = getattr(node, "end_lineno", node.lineno)
-                    symbols.append(CodeSymbol(
-                        name=node.name,
-                        kind="class",
-                        file_path=file_path,
-                        line_start=node.lineno,
-                        line_end=end_lineno,
-                        docstring=doc,
-                    ))
-                    for item in node.body:
-                        if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                            m_doc = ast.get_docstring(item)
-                            m_end = getattr(item, "end_lineno", item.lineno)
-                            symbols.append(CodeSymbol(
-                                name=f"{node.name}.{item.name}",
-                                kind="method",
-                                file_path=file_path,
-                                line_start=item.lineno,
-                                line_end=m_end,
-                                docstring=m_doc,
-                            ))
-                elif isinstance(node, ast.AsyncFunctionDef):
-                    doc = ast.get_docstring(node)
-                    end_lineno = getattr(node, "end_lineno", node.lineno)
-                    symbols.append(CodeSymbol(
-                        name=node.name,
-                        kind="async_function",
-                        file_path=file_path,
-                        line_start=node.lineno,
-                        line_end=end_lineno,
-                        docstring=doc,
-                    ))
-                elif isinstance(node, ast.FunctionDef):
-                    doc = ast.get_docstring(node)
-                    end_lineno = getattr(node, "end_lineno", node.lineno)
-                    symbols.append(CodeSymbol(
-                        name=node.name,
-                        kind="function",
-                        file_path=file_path,
-                        line_start=node.lineno,
-                        line_end=end_lineno,
-                        docstring=doc,
-                    ))
-        except Exception:
-            pass
-        return symbols
-
-    def build_or_update(self) -> Dict[str, int]:
-        total_files = 0
-        parsed_files = 0
-        cache_hits = 0
-        current_seen: set[str] = set()
-
-        for root, dirs, files in os.walk(self.root_dir):
-            dirs[:] = [d for d in dirs if d not in self.IGNORE_DIRS]
-            for file in files:
-                if not file.endswith(".py"):
-                    continue
-                file_path = _index_key(os.path.join(root, file))
-                current_seen.add(file_path)
-                total_files += 1
-
-                try:
-                    stat = os.stat(file_path)
-                except OSError:
-                    continue
-
-                if file_path in self.files and self.files[file_path].mtime == stat.st_mtime:
-                    cache_hits += 1
-                else:
-                    parsed_files += 1
-                    symbols = self._parse_py_file(file_path)
-                    self.files[file_path] = FileEntry(
-                        path=file_path,
-                        mtime=stat.st_mtime,
-                        size=stat.st_size,
-                        symbols=symbols,
-                    )
-
-        # Remove deleted files
-        for old_path in list(self.files.keys()):
-            if old_path not in current_seen:
-                del self.files[old_path]
-
-        # Rebuild symbol map
-        self.symbol_map.clear()
-        for entry in self.files.values():
-            for sym in entry.symbols:
-                self.symbol_map.setdefault(sym.name, []).append(sym)
-
-        self._save_cache()
-        return {
-            "total_files": total_files,
-            "parsed_files": parsed_files,
-            "cache_hits": cache_hits,
-        }
-
-    def find_symbol(self, name: str, exact: bool = True) -> List[CodeSymbol]:
-        if exact:
-            return self.symbol_map.get(name, [])
-        matches: List[CodeSymbol] = []
-        name_lower = name.lower()
-        for sym_name, sym_list in self.symbol_map.items():
-            if name_lower in sym_name.lower():
-                matches.extend(sym_list)
-        return matches
-
-    def get_file_outline(self, file_path: str) -> List[CodeSymbol]:
-        norm = _index_key(file_path)
-        for path, entry in self.files.items():
-            if norm == path or norm.endswith(path) or path.endswith(norm):
-                return entry.symbols
-        return []
-
-    def get_cached_chunk(self, file_path: str, start_line: int = 1, end_line: int = 100) -> str:
-        norm = _index_key(file_path)
-        try:
-            stat = os.stat(norm)
-            mtime = stat.st_mtime
-        except OSError:
-            return f"Error: File '{file_path}' not found."
-
-        cached = self._content_cache.get(norm)
-        if cached is None or cached[0] != mtime:
-            try:
-                with open(norm, "r", encoding="utf-8", errors="replace") as f:
-                    lines = f.readlines()
-                self._content_cache[norm] = (mtime, lines)
-            except Exception as e:
-                return f"Error reading file '{file_path}': {e}"
-        else:
-            lines = cached[1]
-
-        total = len(lines)
-        s = max(1, start_line) - 1
-        e = min(total, end_line)
-        slice_lines = lines[s:e]
-        return f"[{norm} | Lines {s+1}-{e} of {total}]\n" + "".join(slice_lines)
-
-    def get_sitemap(self) -> Dict[str, Any]:
-        sitemap = {}
-        for path, entry in sorted(self.files.items()):
-            sitemap[path] = [
-                {"name": s.name, "kind": s.kind, "lines": f"{s.line_start}-{s.line_end}"}
-                for s in entry.symbols
-            ]
-        return sitemap
-
-_GLOBAL_INDEX: Optional[CodeIndex] = None
-
-def get_code_index(root_dir: str = ".") -> CodeIndex:
-    global _GLOBAL_INDEX
-    if _GLOBAL_INDEX is None:
-        _GLOBAL_INDEX = CodeIndex(root_dir=root_dir)
-        _GLOBAL_INDEX.build_or_update()
-    return _GLOBAL_INDEX