memstack-skill-loader 4.0.6__tar.gz → 4.1.0__tar.gz

{memstack_skill_loader-4.0.6/src/memstack_skill_loader.egg-info → memstack_skill_loader-4.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.0.6
+Version: 4.1.0
 Summary: MCP server that vector-indexes MemStack Pro skills for on-demand loading
 Requires-Python: >=3.10
 Requires-Dist: mcp>=1.0.0

{memstack_skill_loader-4.0.6 → memstack_skill_loader-4.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memstack-skill-loader"
-version = "4.0.6"
+version = "4.1.0"
 description = "MCP server that vector-indexes MemStack Pro skills for on-demand loading"
 requires-python = ">=3.10"
 dependencies = [

{memstack_skill_loader-4.0.6 → memstack_skill_loader-4.1.0}/src/memstack_skill_loader/__init__.py

@@ -1,3 +1,3 @@
 """MemStack Skill Loader — MCP server for semantic skill search."""
 
-__version__ = "4.0.6"
+__version__ = "4.1.0"

{memstack_skill_loader-4.0.6 → memstack_skill_loader-4.1.0}/src/memstack_skill_loader/agent_runner.py

@@ -28,9 +28,15 @@ AGENT_TIMEOUT = 3600  # seconds per --print invocation (default 60 minutes)
 MAX_ITERATIONS = 2
 
 ANTHROPIC_BASE_URL = os.environ.get("ANTHROPIC_BASE_URL", "")
+API_KEY_FILE = Path.home() / ".memstack" / "api_key"
 API_DEFAULT_MODEL = "claude-sonnet-4-20250514"
 API_MAX_TOKENS = 16000
 
+if not os.environ.get("ANTHROPIC_API_KEY") and API_KEY_FILE.is_file():
+    _stored_key = API_KEY_FILE.read_text(encoding="utf-8").strip()
+    if _stored_key:
+        os.environ["ANTHROPIC_API_KEY"] = _stored_key
+
 SYSTEM_PROMPTS = {
     "manager": (
         "You are a Manager agent. You receive a task and project context (directory listing "
@@ -109,30 +115,105 @@ def discover_mcp_servers(workdir: str) -> list[str]:
         return []
 
 
+_VALID_GIT_WORKFLOWS = ("auto", "single_branch", "dev_to_default", "feature_branch")
+
+
+def _migrate_config(cfg: dict) -> dict:
+    """Migrate per-project values from plain arrays to objects with blocked_mcp key."""
+    changed = False
+    for key, val in list(cfg.items()):
+        if key.startswith("_"):
+            continue
+        if isinstance(val, list):
+            cfg[key] = {"blocked_mcp": val}
+            changed = True
+    if changed:
+        save_builder_tools_config(cfg)
+    return cfg
+
+
 def load_builder_tools_config() -> dict:
-    """Load per-project blocked MCP server lists from ~/.memstack/builder-tools-config.json."""
+    """Load per-project config from ~/.memstack/builder-tools-config.json, migrating if needed."""
     try:
         if BUILDER_TOOLS_CONFIG_FILE.is_file():
-            return json.loads(BUILDER_TOOLS_CONFIG_FILE.read_text(encoding="utf-8"))
+            cfg = json.loads(BUILDER_TOOLS_CONFIG_FILE.read_text(encoding="utf-8"))
+            return _migrate_config(cfg)
     except Exception:
         pass
     return {}
 
 
 def save_builder_tools_config(config: dict) -> None:
-    """Save per-project blocked MCP server config."""
+    """Save per-project config."""
     BUILDER_TOOLS_CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
     BUILDER_TOOLS_CONFIG_FILE.write_text(json.dumps(config, indent=2), encoding="utf-8")
 
 
+def _get_project_config(cfg: dict, workdir: str) -> dict:
+    """Return the project config dict for workdir, or empty dict."""
+    val = cfg.get(workdir)
+    if isinstance(val, dict):
+        return val
+    return {}
+
+
 def get_blocked_servers_for_project(workdir: str) -> list[str]:
     """Return blocked MCP servers for a project, falling back to global defaults."""
     cfg = load_builder_tools_config()
-    if workdir in cfg:
-        return cfg[workdir]
+    proj = _get_project_config(cfg, workdir)
+    if proj:
+        return proj.get("blocked_mcp", [])
     return cfg.get("_global_defaults", [])
 
 
+def get_git_workflow_for_project(workdir: str) -> tuple[str, bool]:
+    """Return (workflow, is_project_config) for a working directory."""
+    cfg = load_builder_tools_config()
+    proj = _get_project_config(cfg, workdir)
+    if proj and "git_workflow" in proj:
+        wf = proj["git_workflow"]
+        if wf in _VALID_GIT_WORKFLOWS:
+            return wf, True
+    global_wf = cfg.get("_git_workflow", "auto")
+    if global_wf not in _VALID_GIT_WORKFLOWS:
+        global_wf = "auto"
+    return global_wf, False
+
+
+_VALID_AGENT_MODES = ("api", "subscription")
+
+
+def _default_agent_modes() -> dict:
+    """Return default execution modes based on whether an API key is available."""
+    has_key = bool(os.environ.get("ANTHROPIC_API_KEY") or ANTHROPIC_BASE_URL)
+    if has_key:
+        return {"manager": "api", "builder": "subscription", "reviewer": "api"}
+    return {"manager": "subscription", "builder": "subscription", "reviewer": "subscription"}
+
+
+def load_agent_modes() -> dict:
+    """Load agent execution modes from config, falling back to defaults."""
+    cfg = load_builder_tools_config()
+    stored = cfg.get("_agent_modes", {})
+    defaults = _default_agent_modes()
+    modes = {}
+    for agent in ("manager", "builder", "reviewer"):
+        val = stored.get(agent, "")
+        modes[agent] = val if val in _VALID_AGENT_MODES else defaults[agent]
+    return modes
+
+
+def save_agent_modes(modes: dict) -> None:
+    """Save agent execution modes to config."""
+    cfg = load_builder_tools_config()
+    clean = {}
+    for agent in ("manager", "builder", "reviewer"):
+        val = modes.get(agent, "")
+        clean[agent] = val if val in _VALID_AGENT_MODES else "subscription"
+    cfg["_agent_modes"] = clean
+    save_builder_tools_config(cfg)
+
+
 # ---------------------------------------------------------------------------
 # Project context gathering
 # ---------------------------------------------------------------------------
@@ -190,6 +271,24 @@ def _extract_task_text(raw: str) -> str:
     return result[:72]
 
 
+def _clean_task_description(task: str) -> str:
+    """Strip Working directory/Branch boilerplate, returning the user's task description."""
+    import re
+    _BOILERPLATE_LINE = re.compile(
+        r'^(working\s+directory:|branch:|read\s+all\s+files\s+before\s+modifying\.?)',
+        re.IGNORECASE
+    )
+    lines = task.splitlines()
+    start = 0
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+        if not stripped or _BOILERPLATE_LINE.match(stripped):
+            start = i + 1
+        else:
+            break
+    return "\n".join(lines[start:]).strip()
+
+
 def _extract_commit_from_reviewer(reviewer_output: str) -> str:
     """Extract a commit-friendly summary from the reviewer's APPROVED message."""
     import re
@@ -334,6 +433,7 @@ def _extract_text_from_stream_line(line: str) -> Optional[str]:
 def _invoke_api_agent(name: str, prompt: str, system_prompt: str,
                       log_path: Optional[Path] = None, timeout: int = 600,
                       model: str = "", session_id: Optional[str] = None,
+                      working_dir: str = "",
                       ) -> tuple[str, int, int]:
     """Call the Anthropic Messages API directly via httpx.
 
@@ -411,7 +511,7 @@ def _invoke_api_agent(name: str, prompt: str, system_prompt: str,
 
     try:
         log_agent_invocation(
-            name, len(prompt), len(output), session_id, "",
+            name, len(prompt), len(output), session_id, working_dir,
             input_tokens=input_tokens, output_tokens=output_tokens, cost_usd=0.0,
         )
     except Exception:
@@ -646,6 +746,7 @@ class Session:
             meta = {
                 "session_id": self.session_id,
                 "task": self.task,
+                "task_description": _clean_task_description(self.task),
                 "status": self.status,
                 "started_at": self.started_at,
                 "iteration": self.iteration,
@@ -707,6 +808,14 @@ def _orchestrate(session: Session) -> None:
     session_log_dir = STATE_DIR / "sessions" / session.session_id
 
     try:
+        # Load execution modes for this run
+        agent_modes = load_agent_modes()
+        has_api_key = bool(os.environ.get("ANTHROPIC_API_KEY") or ANTHROPIC_BASE_URL)
+        for _ag in ("manager", "builder", "reviewer"):
+            if agent_modes[_ag] == "api" and not has_api_key:
+                agent_modes[_ag] = "subscription"
+                print(f"[agent-runner] {_ag}: mode=api but no API key set, falling back to subscription", file=sys.stderr)
+
         # Step 1: Manager analyzes the task
         session.agents["manager"]["status"] = "busy"
         session.agents["manager"]["started_at"] = time.strftime("%Y-%m-%dT%H:%M:%S")
@@ -721,14 +830,25 @@ def _orchestrate(session: Session) -> None:
         if session.user_name:
             manager_prompt = f"The user's name is {session.user_name}.\n\n" + manager_prompt
         try:
-            manager_output, m_in, m_out = _invoke_api_agent(
-                "manager", manager_prompt,
-                system_prompt=SYSTEM_PROMPTS["manager"],
-                log_path=session_log_dir / "manager.log",
-                timeout=min(600, session.timeout),
-                model=session.models.get("manager", ""),
-                session_id=session.session_id,
-            )
+            if agent_modes["manager"] == "api":
+                manager_output, m_in, m_out = _invoke_api_agent(
+                    "manager", manager_prompt,
+                    system_prompt=SYSTEM_PROMPTS["manager"],
+                    log_path=session_log_dir / "manager.log",
+                    timeout=min(600, session.timeout),
+                    model=session.models.get("manager", ""),
+                    session_id=session.session_id,
+                    working_dir=session.working_dir,
+                )
+                m_ctx = m_in
+            else:
+                manager_output, m_in, m_out, m_ctx = _invoke_agent(
+                    "manager", manager_prompt, session.working_dir,
+                    log_path=session_log_dir / "manager.log",
+                    skip_permissions=True, session_id=session.session_id,
+                    timeout=min(600, session.timeout),
+                    model=session.models.get("manager", ""),
+                )
         except subprocess.TimeoutExpired:
             session.agents["manager"]["status"] = "timeout"
             session.status = "error"
@@ -743,7 +863,7 @@ def _orchestrate(session: Session) -> None:
             return
         session.agents["manager"]["input_tokens"] += m_in
         session.agents["manager"]["output_tokens"] += m_out
-        session.agents["manager"]["context_tokens"] = m_in
+        session.agents["manager"]["context_tokens"] = m_ctx
         session.agents["manager"]["last_output"] = (manager_output or "")[:500]
 
         session.agents["manager"]["status"] = "done"
@@ -783,15 +903,27 @@ def _orchestrate(session: Session) -> None:
             if session.user_name:
                 builder_prompt = f"The user's name is {session.user_name}.\n\n" + builder_prompt
             try:
-                builder_output, b_in, b_out, b_ctx = _invoke_agent(
-                    "builder", builder_prompt, session.working_dir,
-                    log_path=session_log_dir / "builder.log",
-                    skip_permissions=True, session_id=session.session_id,
-                    timeout=session.timeout,
-                    model=session.models.get("builder", ""),
-                    disallowed_tools=session.blocked_mcp_servers,
-                    session=session,
-                )
+                if agent_modes["builder"] == "subscription":
+                    builder_output, b_in, b_out, b_ctx = _invoke_agent(
+                        "builder", builder_prompt, session.working_dir,
+                        log_path=session_log_dir / "builder.log",
+                        skip_permissions=True, session_id=session.session_id,
+                        timeout=session.timeout,
+                        model=session.models.get("builder", ""),
+                        disallowed_tools=session.blocked_mcp_servers,
+                        session=session,
+                    )
+                else:
+                    builder_output, b_in, b_out = _invoke_api_agent(
+                        "builder", builder_prompt,
+                        system_prompt=SYSTEM_PROMPTS["builder"].format(working_dir=session.working_dir),
+                        log_path=session_log_dir / "builder.log",
+                        timeout=session.timeout,
+                        model=session.models.get("builder", ""),
+                        session_id=session.session_id,
+                        working_dir=session.working_dir,
+                    )
+                    b_ctx = b_in
             except subprocess.TimeoutExpired:
                 session.agents["builder"]["status"] = "timeout"
                 session.status = "error"
@@ -849,14 +981,25 @@ def _orchestrate(session: Session) -> None:
                 + f"\n\nBuilder output (iteration {iteration}):\n{builder_output}"
             )
             try:
-                reviewer_output, r_in, r_out = _invoke_api_agent(
-                    "reviewer", reviewer_prompt,
-                    system_prompt=SYSTEM_PROMPTS["reviewer"],
-                    log_path=session_log_dir / "reviewer.log",
-                    timeout=session.timeout,
-                    model=session.models.get("reviewer", ""),
-                    session_id=session.session_id,
-                )
+                if agent_modes["reviewer"] == "api":
+                    reviewer_output, r_in, r_out = _invoke_api_agent(
+                        "reviewer", reviewer_prompt,
+                        system_prompt=SYSTEM_PROMPTS["reviewer"],
+                        log_path=session_log_dir / "reviewer.log",
+                        timeout=session.timeout,
+                        model=session.models.get("reviewer", ""),
+                        session_id=session.session_id,
+                        working_dir=session.working_dir,
+                    )
+                    r_ctx = r_in
+                else:
+                    reviewer_output, r_in, r_out, r_ctx = _invoke_agent(
+                        "reviewer", reviewer_prompt, session.working_dir,
+                        log_path=session_log_dir / "reviewer.log",
+                        skip_permissions=True, session_id=session.session_id,
+                        timeout=session.timeout,
+                        model=session.models.get("reviewer", ""),
+                    )
             except subprocess.TimeoutExpired:
                 session.agents["reviewer"]["status"] = "timeout"
                 session.status = "error"
@@ -871,7 +1014,7 @@ def _orchestrate(session: Session) -> None:
                 return
             session.agents["reviewer"]["input_tokens"] += r_in
             session.agents["reviewer"]["output_tokens"] += r_out
-            session.agents["reviewer"]["context_tokens"] = r_in
+            session.agents["reviewer"]["context_tokens"] = r_ctx
             session.agents["reviewer"]["last_output"] = (reviewer_output or "")[:500]
 
             session.agents["reviewer"]["status"] = "done"