agentram 0.1.39 → 0.1.43

package/agentram/cli.py

@@ -13,7 +13,7 @@ import time
 from pathlib import Path
 from typing import Any
 
-from .config import default_ram_root
+from .config import default_ram_root, global_agent_profile_enabled
 from .mcp_server import McpContext, call_tool
 from .orchestration import AgentModelEndpoint, MultiModelCodingOrchestrator
 
@@ -612,6 +612,7 @@ def run_textual_tui(context: McpContext) -> bool:
                 modalities=["text"],
             )
             self.context.profile_store.set_agent(slot, endpoint)
+            set_global_agent_if_available(self.context, slot, endpoint)
             if saved_env_name:
                 return f"{slot}={provider}:{model} key=.env:{saved_env_name}"
             return f"{slot}={provider}:{model}"
@@ -1248,6 +1249,16 @@ def bind_model_text(context: McpContext, options: dict[str, object]) -> str:
     return f"Bound model: {endpoint.get('id')} provider={endpoint.get('provider')} model={endpoint.get('model')} role={endpoint.get('role')}"
 
 
+def set_global_agent_if_available(context: McpContext, slot: str, endpoint: AgentModelEndpoint) -> bool:
+    if not global_agent_profile_enabled():
+        return False
+    try:
+        context.global_profile_store.set_agent(slot, endpoint)
+        return True
+    except OSError:
+        return False
+
+
 def bind_agent_text(context: McpContext, options: dict[str, object]) -> str:
     slot = str(options.get("slot", "")).strip().lower()
     if slot not in {"supervisor", "main", "small"}:
@@ -1265,7 +1276,9 @@ def bind_agent_text(context: McpContext, options: dict[str, object]) -> str:
         modalities=["text"],
     )
     context.profile_store.set_agent(slot, endpoint)
-    return f"Bound {slot} agent: provider={endpoint.provider} model={endpoint.model} role={endpoint.role}"
+    global_saved = set_global_agent_if_available(context, slot, endpoint)
+    scope = "project+global" if global_saved else "project"
+    return f"Bound {slot} agent: provider={endpoint.provider} model={endpoint.model} role={endpoint.role} scope={scope}"
 
 def workflow_text(context: McpContext) -> str:
     agents = context.profile_store.list_agents()

package/agentram/config.py

@@ -20,6 +20,19 @@ def default_ram_root(cwd: str | Path | None = None) -> Path:
     base = Path.cwd() if cwd is None else Path(cwd)
     return base / DEFAULT_RAM_DIR_NAME
 
+def global_agent_profile_path() -> Path:
+    override = os.getenv("AGENTRAM_GLOBAL_PROFILE_PATH")
+    if override:
+        return Path(override)
+    base = os.getenv("APPDATA")
+    if base:
+        return Path(base) / "AgentRAM" / "agent_profile.jsonl"
+    return Path.home() / ".agentram" / "agent_profile.jsonl"
+
+def global_agent_profile_enabled() -> bool:
+    value = os.getenv("AGENTRAM_DISABLE_GLOBAL_PROFILE", "").strip().lower()
+    return value not in {"1", "true", "yes", "on"}
+
 def load_env_file(path: str | Path = ".env") -> dict[str, str]:
     env_path = Path(path)
     if not env_path.exists():

package/agentram/mcp_server.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from typing import Any
 
 from .adapter import HeuristicMemoryAdapter
-from .config import default_ram_root
+from .config import default_ram_root, global_agent_profile_enabled, global_agent_profile_path
 from .merger import MemoryMerger
 from .orchestration import AgentModelEndpoint, CodingOrchestrationRequest, MultiModelCodingOrchestrator
 from .retriever import MemoryRetriever
@@ -46,7 +46,12 @@ class McpContext:
 
     @property
     def profile_store(self) -> JsonAgentProfileStore:
-        return JsonAgentProfileStore(self.ram_root / "agent_profile.jsonl")
+        fallback = global_agent_profile_path() if global_agent_profile_enabled() else None
+        return JsonAgentProfileStore(self.ram_root / "agent_profile.jsonl", fallback_path=fallback)
+
+    @property
+    def global_profile_store(self) -> JsonAgentProfileStore:
+        return JsonAgentProfileStore(global_agent_profile_path())
 
     @property
     def merger(self) -> MemoryMerger:

package/agentram/orchestration.py

@@ -3,12 +3,12 @@
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass, field
 import json
-import os
-from pathlib import Path
-import re
-import shlex
-import subprocess
-import tempfile
+import os
+from pathlib import Path
+import re
+import shlex
+import subprocess
+import tempfile
 import urllib.error
 import urllib.request
 from typing import Any, Callable
@@ -46,7 +46,7 @@ def normalize_provider_name(provider: str) -> str:
     return PROVIDER_ALIASES.get(normalized, normalized)
 
 
-def split_cli_command(command: str) -> list[str]:
+def split_cli_command(command: str) -> list[str]:
     cleaned = command.strip().strip('"')
     if not cleaned:
         return []
@@ -59,23 +59,23 @@ def split_cli_command(command: str) -> list[str]:
                 program = cleaned[:end]
                 rest = cleaned[end:].strip()
                 return [program, *shlex.split(rest)] if rest else [program]
-    return shlex.split(cleaned)
-
-def env_value(name: str) -> str:
-    value = os.getenv(name, "")
-    if value:
-        return value
-    env_path = Path(".env")
-    if not env_path.exists():
-        return ""
-    for line in env_path.read_text(encoding="utf-8", errors="ignore").splitlines():
-        stripped = line.strip()
-        if not stripped or stripped.startswith("#") or "=" not in stripped:
-            continue
-        key, raw_value = stripped.split("=", 1)
-        if key.strip() == name:
-            return raw_value.strip().strip('"').strip("'")
-    return ""
+    return shlex.split(cleaned)
+
+def env_value(name: str) -> str:
+    value = os.getenv(name, "")
+    if value:
+        return value
+    env_path = Path(".env")
+    if not env_path.exists():
+        return ""
+    for line in env_path.read_text(encoding="utf-8", errors="ignore").splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or "=" not in stripped:
+            continue
+        key, raw_value = stripped.split("=", 1)
+        if key.strip() == name:
+            return raw_value.strip().strip('"').strip("'")
+    return ""
 
 
 @dataclass(frozen=True)
@@ -182,7 +182,7 @@ class MultiModelCodingOrchestrator:
         raise ValueError(f"Unsupported provider for execution: {endpoint.provider}")
 
     def _call_openai_compatible(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
-        api_key = env_value(endpoint.api_key_env) if endpoint.api_key_env else ""
+        api_key = env_value(endpoint.api_key_env) if endpoint.api_key_env else ""
         if not endpoint.base_url:
             raise ValueError("base_url is required")
         if endpoint.api_key_env and not api_key:
@@ -204,20 +204,20 @@ class MultiModelCodingOrchestrator:
             if error.code == 404:
                 hint += " | base_url should include /v1 but not /chat/completions; verify provider URL and model name"
             raise RuntimeError(f"{hint} | response={body[:500]}") from error
-        try:
-            data = json.loads(raw)
-        except json.JSONDecodeError as error:
-            mixed_json = parse_openai_mixed_json(raw)
-            if mixed_json:
-                return extract_openai_message(mixed_json)
-            streamed = parse_openai_sse(raw)
-            if streamed:
-                return streamed
-            raise RuntimeError(f"OpenAI-compatible returned non-JSON at {url} | response={raw[:500]}") from error
-        return extract_openai_message(data)
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError as error:
+            mixed_json = parse_openai_mixed_json(raw)
+            if mixed_json:
+                return extract_openai_message(mixed_json)
+            streamed = parse_openai_sse(raw)
+            if streamed:
+                return streamed
+            raise RuntimeError(f"OpenAI-compatible returned non-JSON at {url} | response={raw[:500]}") from error
+        return extract_openai_message(data)
 
     def _call_anthropic(self, endpoint: AgentModelEndpoint, prompt: str) -> str:
-        api_key = env_value(endpoint.api_key_env) if endpoint.api_key_env else ""
+        api_key = env_value(endpoint.api_key_env) if endpoint.api_key_env else ""
         if endpoint.api_key_env and not api_key:
             raise ValueError(f"missing API key env: {endpoint.api_key_env}")
         base_url = endpoint.base_url.rstrip("/") if endpoint.base_url else "https://api.anthropic.com/v1"
@@ -252,13 +252,13 @@ class MultiModelCodingOrchestrator:
             ]
         )
         try:
-            process = subprocess.run(
-                [*args, "-p", subagent_prompt],
-                check=False,
-                stdin=subprocess.DEVNULL,
-                capture_output=True,
-                encoding="utf-8",
-                timeout=300,
+            process = subprocess.run(
+                [*args, "-p", subagent_prompt],
+                check=False,
+                stdin=subprocess.DEVNULL,
+                capture_output=True,
+                encoding="utf-8",
+                timeout=300,
             )
         except FileNotFoundError as error:
             raise RuntimeError(f"Claude Code command not found: {args[0]}. Install Claude Code CLI or set base_url to the full command path.") from error
@@ -275,45 +275,46 @@ class MultiModelCodingOrchestrator:
             raise ValueError("codex command is required")
         if len(args) == 1:
             args.append("exec")
-        codex_prompt = "\n".join(
-            [
-                f"You are AgentRAM {endpoint.role} agent running through Codex CLI.",
+        args = ensure_codex_skip_git_repo_check(args)
+        codex_prompt = "\n".join(
+            [
+                f"You are AgentRAM {endpoint.role} agent running through Codex CLI.",
                 f"Model hint: {endpoint.model}",
                 "If role is coder/main, inspect and edit files as needed in the current repo. If role is memory/small, do not edit files; write notes only.",
                 "Return concise result, changed files, tests/verification, and blockers.",
                 "",
-                prompt,
-            ]
-        )
-        prompt_path = ""
-        try:
-            with tempfile.NamedTemporaryFile(
-                "w",
-                encoding="utf-8",
-                delete=False,
-                dir=os.getcwd(),
-                prefix=".agentram_codex_prompt_",
-                suffix=".txt",
-            ) as prompt_file:
-                prompt_file.write(codex_prompt)
-                prompt_path = prompt_file.name
-            short_prompt = f"Read AgentRAM task from file and execute it: {prompt_path}"
-            process = subprocess.run(
-                [*args, short_prompt],
-                check=False,
-                stdin=subprocess.DEVNULL,
-                capture_output=True,
-                encoding="utf-8",
-                timeout=int(os.getenv("AGENTRAM_CLI_TIMEOUT", "900")),
-            )
+                prompt,
+            ]
+        )
+        prompt_path = ""
+        try:
+            with tempfile.NamedTemporaryFile(
+                "w",
+                encoding="utf-8",
+                delete=False,
+                dir=os.getcwd(),
+                prefix=".agentram_codex_prompt_",
+                suffix=".txt",
+            ) as prompt_file:
+                prompt_file.write(codex_prompt)
+                prompt_path = prompt_file.name
+            short_prompt = f"Read AgentRAM task from file and execute it: {prompt_path}"
+            process = subprocess.run(
+                [*args, short_prompt],
+                check=False,
+                stdin=subprocess.DEVNULL,
+                capture_output=True,
+                encoding="utf-8",
+                timeout=int(os.getenv("AGENTRAM_CLI_TIMEOUT", "900")),
+            )
         except FileNotFoundError as error:
-            raise RuntimeError(f"Codex CLI command not found: {args[0]}. Install Codex CLI or set base_url to the full command path.") from error
-        finally:
-            if prompt_path:
-                try:
-                    os.remove(prompt_path)
-                except OSError:
-                    pass
+            raise RuntimeError(f"Codex CLI command not found: {args[0]}. Install Codex CLI or set base_url to the full command path.") from error
+        finally:
+            if prompt_path:
+                try:
+                    os.remove(prompt_path)
+                except OSError:
+                    pass
         output = (process.stdout or "").strip()
         error = (process.stderr or "").strip()
         if process.returncode != 0:
@@ -321,7 +322,15 @@ class MultiModelCodingOrchestrator:
         return output or error
 
 
-def parse_openai_sse(raw: str) -> str:
+def ensure_codex_skip_git_repo_check(args: list[str]) -> list[str]:
+    if "--skip-git-repo-check" in args:
+        return args
+    if len(args) >= 2 and args[1] == "exec":
+        return [args[0], args[1], "--skip-git-repo-check", *args[2:]]
+    return args
+
+
+def parse_openai_sse(raw: str) -> str:
     parts: list[str] = []
     for line in raw.splitlines():
         stripped = line.strip()
@@ -348,39 +357,39 @@ def parse_openai_sse(raw: str) -> str:
         message = choice.get("message", {})
         if isinstance(message, dict) and message.get("content"):
             parts.append(str(message.get("content")))
-    return strip_thinking_blocks("".join(parts)).strip()
-
-def parse_openai_mixed_json(raw: str) -> dict[str, Any]:
-    stripped = raw.strip()
-    if not stripped.startswith("{"):
-        return {}
-    for marker in ("\ndata:", "\r\ndata:"):
-        if marker not in stripped:
-            continue
-        candidate = stripped.split(marker, 1)[0].strip()
-        try:
-            value = json.loads(candidate)
-        except json.JSONDecodeError:
-            return {}
-        return value if isinstance(value, dict) else {}
-    return {}
-
-def extract_openai_message(data: dict[str, Any]) -> str:
-    choices = data.get("choices", [])
-    if not choices or not isinstance(choices, list):
-        return ""
-    first = choices[0]
-    if not isinstance(first, dict):
-        return ""
-    message = first.get("message", {})
-    if isinstance(message, dict):
-        return strip_thinking_blocks(str(message.get("content", ""))).strip()
-    delta = first.get("delta", {})
-    if isinstance(delta, dict):
-        return strip_thinking_blocks(str(delta.get("content", ""))).strip()
-    return ""
-
-def strip_thinking_blocks(text: str) -> str:
+    return strip_thinking_blocks("".join(parts)).strip()
+
+def parse_openai_mixed_json(raw: str) -> dict[str, Any]:
+    stripped = raw.strip()
+    if not stripped.startswith("{"):
+        return {}
+    for marker in ("\ndata:", "\r\ndata:"):
+        if marker not in stripped:
+            continue
+        candidate = stripped.split(marker, 1)[0].strip()
+        try:
+            value = json.loads(candidate)
+        except json.JSONDecodeError:
+            return {}
+        return value if isinstance(value, dict) else {}
+    return {}
+
+def extract_openai_message(data: dict[str, Any]) -> str:
+    choices = data.get("choices", [])
+    if not choices or not isinstance(choices, list):
+        return ""
+    first = choices[0]
+    if not isinstance(first, dict):
+        return ""
+    message = first.get("message", {})
+    if isinstance(message, dict):
+        return strip_thinking_blocks(str(message.get("content", ""))).strip()
+    delta = first.get("delta", {})
+    if isinstance(delta, dict):
+        return strip_thinking_blocks(str(delta.get("content", ""))).strip()
+    return ""
+
+def strip_thinking_blocks(text: str) -> str:
     text = re.sub(r"<thinking>.*?</thinking>", "", text, flags=re.DOTALL | re.IGNORECASE)
     text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL | re.IGNORECASE)
     text = re.sub(r"^\s*</?(thinking|think)>\s*", "", text, flags=re.IGNORECASE)

package/agentram/storage.py

@@ -76,8 +76,9 @@ class JsonGoalStore:
 
 
 class JsonAgentProfileStore:
-    def __init__(self, path: str | Path) -> None:
+    def __init__(self, path: str | Path, fallback_path: str | Path | None = None) -> None:
         self.path = Path(path)
+        self.fallback_path = Path(fallback_path) if fallback_path else None
         self.path.parent.mkdir(parents=True, exist_ok=True)
 
     def default_payload(self) -> dict[str, object]:
@@ -93,18 +94,33 @@ class JsonAgentProfileStore:
         data.setdefault("agents", {})
         return data
 
+    def is_empty_payload(self, data: dict[str, object]) -> bool:
+        return not data.get("endpoints") and not data.get("router") and not data.get("agents")
+
+    def load_fallback(self) -> dict[str, object] | None:
+        if not self.fallback_path or self.fallback_path == self.path or not self.fallback_path.exists():
+            return None
+        lines = [line.strip() for line in self.fallback_path.read_text(encoding="utf-8").splitlines() if line.strip()]
+        if not lines:
+            return None
+        data = self.normalize_payload(json.loads(lines[-1]))
+        return data if not self.is_empty_payload(data) else None
+
     def load(self) -> dict[str, object]:
         if self.path.exists():
             lines = [line.strip() for line in self.path.read_text(encoding="utf-8").splitlines() if line.strip()]
             if not lines:
-                return self.default_payload()
-            return self.normalize_payload(json.loads(lines[-1]))
+                return self.load_fallback() or self.default_payload()
+            data = self.normalize_payload(json.loads(lines[-1]))
+            if self.is_empty_payload(data):
+                return self.load_fallback() or data
+            return data
         legacy = self.legacy_json_path()
         if legacy.exists() and legacy != self.path:
             data = self.normalize_payload(json.loads(legacy.read_text(encoding="utf-8")))
             self.write_snapshot(data)
             return data
-        return self.default_payload()
+        return self.load_fallback() or self.default_payload()
 
     def write_snapshot(self, payload: dict[str, object]) -> None:
         self.path.parent.mkdir(parents=True, exist_ok=True)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentram",
-  "version": "0.1.39",
+  "version": "0.1.43",
   "description": "Async, model-agnostic Working RAM for coding agents.",
   "license": "MIT",
   "homepage": "https://github.com/trancongnghia/AGENT_RAM#readme",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentram"
-version = "0.1.39"
+version = "0.1.43"
 description = "Async, model-agnostic RAM layer for agentic coding tools."
 readme = "README.md"
 license = "MIT"