memstack-skill-loader 4.0.3__tar.gz → 4.0.4__tar.gz

{memstack_skill_loader-4.0.3/src/memstack_skill_loader.egg-info → memstack_skill_loader-4.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.0.3
+Version: 4.0.4
 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.3 → memstack_skill_loader-4.0.4}/pyproject.toml

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

{memstack_skill_loader-4.0.3 → memstack_skill_loader-4.0.4}/src/memstack_skill_loader/__init__.py

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

{memstack_skill_loader-4.0.3 → memstack_skill_loader-4.0.4}/src/memstack_skill_loader/agent_runner.py

@@ -12,6 +12,8 @@ import uuid
 from pathlib import Path
 from typing import Optional
 
+import httpx
+
 from .stats import log_agent_invocation
 
 
@@ -26,6 +28,8 @@ AGENT_TIMEOUT = 3600  # seconds per --print invocation (default 60 minutes)
 MAX_ITERATIONS = 2
 
 ANTHROPIC_BASE_URL = os.environ.get("ANTHROPIC_BASE_URL", "")
+API_DEFAULT_MODEL = "claude-sonnet-4-20250514"
+API_MAX_TOKENS = 16000
 
 SYSTEM_PROMPTS = {
     "manager": (
@@ -188,6 +192,7 @@ def _extract_commit_from_reviewer(reviewer_output: str) -> str:
 def _build_env() -> dict:
     """Build environment for subprocess, ensuring Anthropic vars are passed."""
     env = os.environ.copy()
+    env.pop("MEMSTACK_ENABLE_TTS", None)
     if ANTHROPIC_BASE_URL:
         env["ANTHROPIC_BASE_URL"] = ANTHROPIC_BASE_URL
     return env
@@ -254,8 +259,105 @@ def _parse_stream_json(raw: str) -> tuple[str, int, int, float, int]:
     return text, input_tokens, output_tokens, cost_usd, context_tokens
 
 
+# ---------------------------------------------------------------------------
+# Direct API invocation (Manager / Reviewer — no file tools needed)
+# ---------------------------------------------------------------------------
+
+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,
+                      ) -> tuple[str, int, int]:
+    """Call the Anthropic Messages API directly via httpx.
+
+    Returns (text, input_tokens, output_tokens).
+    """
+    api_key = os.environ.get("ANTHROPIC_API_KEY", "")
+    base_url = ANTHROPIC_BASE_URL or "https://api.anthropic.com"
+
+    if not api_key and not ANTHROPIC_BASE_URL:
+        raise RuntimeError(
+            f"{name}: ANTHROPIC_API_KEY not set and no ANTHROPIC_BASE_URL proxy configured"
+        )
+
+    url = f"{base_url.rstrip('/')}/v1/messages"
+    headers = {
+        "content-type": "application/json",
+        "anthropic-version": "2023-06-01",
+    }
+    if api_key:
+        headers["x-api-key"] = api_key
+
+    body = {
+        "model": model or API_DEFAULT_MODEL,
+        "max_tokens": API_MAX_TOKENS,
+        "system": system_prompt,
+        "messages": [{"role": "user", "content": prompt}],
+    }
+
+    if log_path:
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        ts = time.strftime("%H:%M:%S")
+        with open(log_path, "a", encoding="utf-8") as f:
+            f.write(f"[{ts}] === API call: {name} ===\n")
+            f.write(f"[{ts}] Model: {body['model']}\n")
+            f.write(f"[{ts}] Prompt length: {len(prompt)} chars\n")
+
+    try:
+        resp = httpx.post(url, json=body, headers=headers, timeout=timeout)
+        resp.raise_for_status()
+    except httpx.TimeoutException:
+        if log_path:
+            ts = time.strftime("%H:%M:%S")
+            with open(log_path, "a", encoding="utf-8") as f:
+                f.write(f"[{ts}] API timeout after {timeout}s\n")
+        raise subprocess.TimeoutExpired(f"api:{name}", timeout)
+    except httpx.HTTPStatusError as exc:
+        if log_path:
+            ts = time.strftime("%H:%M:%S")
+            with open(log_path, "a", encoding="utf-8") as f:
+                f.write(f"[{ts}] API error {exc.response.status_code}: {exc.response.text[:500]}\n")
+        raise RuntimeError(f"{name} API error {exc.response.status_code}: {exc.response.text[:200]}") from exc
+    except httpx.HTTPError as exc:
+        if log_path:
+            ts = time.strftime("%H:%M:%S")
+            with open(log_path, "a", encoding="utf-8") as f:
+                f.write(f"[{ts}] HTTP error: {exc}\n")
+        raise RuntimeError(f"{name} HTTP error: {exc}") from exc
+
+    data = resp.json()
+    text_parts = []
+    for block in data.get("content", []):
+        if block.get("type") == "text":
+            text_parts.append(block["text"])
+    output = "\n".join(text_parts).strip()
+
+    usage = data.get("usage", {})
+    input_tokens = usage.get("input_tokens", 0)
+    output_tokens = usage.get("output_tokens", 0)
+
+    if log_path:
+        ts = time.strftime("%H:%M:%S")
+        with open(log_path, "a", encoding="utf-8") as f:
+            f.write(f"[{ts}] Response: {len(output)} chars, "
+                    f"in={input_tokens} out={output_tokens}\n")
+
+    try:
+        log_agent_invocation(
+            name, len(prompt), len(output), session_id, "",
+            input_tokens=input_tokens, output_tokens=output_tokens, cost_usd=0.0,
+        )
+    except Exception:
+        pass
+
+    return output, input_tokens, output_tokens
+
+
+# ---------------------------------------------------------------------------
+# CC subprocess invocation (Builder — needs file tools)
+# ---------------------------------------------------------------------------
+
 def _invoke_agent(name: str, prompt: str, working_dir: str, log_path: Optional[Path] = None,
-                   skip_permissions: bool = False, bare: bool = False,
+                   skip_permissions: bool = False,
                    session_id: Optional[str] = None, timeout: int = AGENT_TIMEOUT,
                    model: str = "") -> tuple[str, int, int, int]:
     """Run a single claude --print invocation and return the output."""
@@ -264,8 +366,6 @@ def _invoke_agent(name: str, prompt: str, working_dir: str, log_path: Optional[P
         raise FileNotFoundError("'claude' CLI not found on PATH")
 
     cmd = [claude_bin, "--print", "--verbose", "--output-format", "stream-json"]
-    if bare and os.environ.get("ANTHROPIC_API_KEY"):
-        cmd.append("--bare")
     if skip_permissions:
         cmd.append("--dangerously-skip-permissions")
     if model:
@@ -280,10 +380,16 @@ def _invoke_agent(name: str, prompt: str, working_dir: str, log_path: Optional[P
             f.write(f"[{ts}] === Invoking {name} ===\n")
             f.write(f"[{ts}] Prompt length: {len(prompt)} chars\n")
 
+    prompt_dir = log_path.parent if log_path else Path.home() / ".memstack" / "agent-runner"
+    prompt_dir.mkdir(parents=True, exist_ok=True)
+    prompt_file = prompt_dir / f"{name}_prompt.txt"
+    prompt_file.write_text(prompt, encoding="utf-8")
+
+    stdin_fh = open(prompt_file, "r", encoding="utf-8")  # noqa: SIM115
     global _current_process
     proc = subprocess.Popen(
         cmd,
-        stdin=subprocess.PIPE,
+        stdin=stdin_fh,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         cwd=working_dir,
@@ -291,54 +397,50 @@ def _invoke_agent(name: str, prompt: str, working_dir: str, log_path: Optional[P
         encoding="utf-8",
         errors="replace",
         env=_build_env(),
-        creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0,
+        creationflags=0,
     )
+    stdin_fh.close()
     with _lock:
         _current_process = proc
 
-    stdout_chunks: list[str] = []
-    stderr_chunks: list[str] = []
+    if log_path:
+        with open(log_path, "a", encoding="utf-8") as f:
+            f.write(f"[{ts}] PID: {proc.pid}\n")
 
-    def _reader(stream: object, dest: list[str]) -> None:
-        try:
-            for line in stream:  # type: ignore[union-attr]
-                dest.append(line)
-        except Exception:
-            pass
+    killed_by_watchdog = threading.Event()
+
+    def _watchdog_kill() -> None:
+        killed_by_watchdog.set()
+        proc.kill()
 
-    t_out = threading.Thread(target=_reader, args=(proc.stdout, stdout_chunks), daemon=True)
-    t_err = threading.Thread(target=_reader, args=(proc.stderr, stderr_chunks), daemon=True)
+    watchdog = threading.Timer(timeout, _watchdog_kill)
+    watchdog.daemon = True
+    watchdog.start()
 
     try:
-        if proc.stdin:
-            try:
-                proc.stdin.write(prompt)
-                proc.stdin.close()
-            except OSError:
-                pass
-        t_out.start()
-        t_err.start()
-
-        deadline = time.monotonic() + timeout
-        while True:
-            t_out.join(timeout=30)
-            rc = proc.poll()
-            if rc is not None:
-                break
-            if time.monotonic() > deadline:
-                proc.kill()
-                t_out.join(5)
-                t_err.join(5)
-                raise subprocess.TimeoutExpired(cmd, timeout)
-        t_out.join(5)
-        t_err.join(5)
-        stdout_data = "".join(stdout_chunks)
-        stderr_data = "".join(stderr_chunks)
+        stdout_data, stderr_data = proc.communicate()
+    except Exception as e:
+        watchdog.cancel()
+        with _lock:
+            if _current_process is proc:
+                _current_process = None
+        if log_path:
+            with open(log_path, "a", encoding="utf-8") as f:
+                f.write(f"[{ts}] communicate() error: {e}\n")
+        raise RuntimeError(f"{name} communicate() failed: {e}") from e
     finally:
+        watchdog.cancel()
         with _lock:
             if _current_process is proc:
                 _current_process = None
 
+    if killed_by_watchdog.is_set():
+        raise subprocess.TimeoutExpired(cmd, timeout)
+
+    if log_path:
+        with open(log_path, "a", encoding="utf-8") as f:
+            f.write(f"[{ts}] communicate() returned: stdout={len(stdout_data)} stderr={len(stderr_data)}\n")
+
     raw_stdout = stdout_data or ""
     stderr = stderr_data or ""
     output, input_tokens, output_tokens, cost_usd, context_tokens = _parse_stream_json(raw_stdout)
@@ -515,17 +617,18 @@ 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, m_ctx = _invoke_agent(
-                "manager", manager_prompt, session.working_dir,
+            manager_output, m_in, m_out = _invoke_api_agent(
+                "manager", manager_prompt,
+                system_prompt=SYSTEM_PROMPTS["manager"],
                 log_path=session_log_dir / "manager.log",
-                skip_permissions=True, session_id=session.session_id,
-                timeout=min(180, session.timeout),
+                timeout=min(600, session.timeout),
                 model=session.models.get("manager", ""),
+                session_id=session.session_id,
             )
         except subprocess.TimeoutExpired:
             session.agents["manager"]["status"] = "timeout"
             session.status = "error"
-            session.result = "Manager timed out after 3 minutes. Try a simpler task description or break the task into smaller pieces."
+            session.result = "Manager timed out after 10 minutes. Try a simpler task description or break the task into smaller pieces."
             session._save_state()
             return
         except RuntimeError:
@@ -536,7 +639,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_ctx
+        session.agents["manager"]["context_tokens"] = m_in
         session.agents["manager"]["last_output"] = (manager_output or "")[:500]
 
         session.agents["manager"]["status"] = "done"
@@ -578,7 +681,7 @@ def _orchestrate(session: Session) -> None:
                 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, bare=True, session_id=session.session_id,
+                    skip_permissions=True, session_id=session.session_id,
                     timeout=session.timeout,
                     model=session.models.get("builder", ""),
                 )
@@ -638,12 +741,13 @@ def _orchestrate(session: Session) -> None:
                 + f"\n\nBuilder output (iteration {iteration}):\n{builder_output}"
             )
             try:
-                reviewer_output, r_in, r_out, r_ctx = _invoke_agent(
-                    "reviewer", reviewer_prompt, session.working_dir,
+                reviewer_output, r_in, r_out = _invoke_api_agent(
+                    "reviewer", reviewer_prompt,
+                    system_prompt=SYSTEM_PROMPTS["reviewer"],
                     log_path=session_log_dir / "reviewer.log",
-                    bare=True, session_id=session.session_id,
                     timeout=session.timeout,
                     model=session.models.get("reviewer", ""),
+                    session_id=session.session_id,
                 )
             except subprocess.TimeoutExpired:
                 session.agents["reviewer"]["status"] = "timeout"
@@ -659,7 +763,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_ctx
+            session.agents["reviewer"]["context_tokens"] = r_in
             session.agents["reviewer"]["last_output"] = (reviewer_output or "")[:500]
 
             session.agents["reviewer"]["status"] = "done"
@@ -802,7 +906,7 @@ def start_run(task: str, working_dir: Optional[str] = None, context: Optional[st
     session._save_state()
 
     _orchestration_thread = threading.Thread(
-        target=_orchestrate, args=(session,), daemon=True, name="orchestrator"
+        target=_orchestrate, args=(session,), daemon=False, name="orchestrator"
     )
     _orchestration_thread.start()
 

{memstack_skill_loader-4.0.3 → memstack_skill_loader-4.0.4}/src/memstack_skill_loader/dashboard.html

@@ -1644,6 +1644,20 @@
     </div>
   </div>
 
+  <div class="panel">
+    <h3>Agent Runner Setup</h3>
+    <p style="color:#8b949e;font-size:0.82rem;margin:0 0 0.8rem;">
+      The Agent Runner requires an Anthropic API key for the Manager and Reviewer agents.
+      The Builder uses Claude Code directly. Headroom is optional but recommended for token compression.
+    </p>
+    <div style="display:grid;grid-template-columns:auto 1fr;gap:0.5rem 1rem;font-size:0.82rem;align-items:start;">
+      <span style="color:#8b949e;">API Key</span>
+      <span id="settings-api-key-status" style="color:#c9d1d9;">—</span>
+      <span style="color:#8b949e;">Headroom Proxy</span>
+      <span id="settings-proxy-status" style="color:#c9d1d9;">—</span>
+    </div>
+  </div>
+
   <div class="panel">
     <h3>Dashboard Info</h3>
     <div style="display:grid;grid-template-columns:auto 1fr;gap:0.4rem 1.2rem;font-size:0.82rem;">
@@ -3481,6 +3495,21 @@ async function loadSettings() {
     document.getElementById('settings-pro-dir').textContent = d.pro_skills_dir || '—';
     document.getElementById('settings-stats-db').textContent = d.stats_db || '—';
     document.getElementById('settings-sessions-dir').textContent = d.sessions_dir || '—';
+
+    const apiKeyEl = document.getElementById('settings-api-key-status');
+    if (d.api_key_set) {
+      apiKeyEl.innerHTML = '<span style="color:#3fb950;">&#10003;</span> API key detected';
+    } else {
+      apiKeyEl.innerHTML = '<span style="color:#f85149;">&#10007;</span> Not set &mdash; run <code style="background:#161b22;padding:0.1rem 0.4rem;border-radius:3px;color:#c9d1d9;">set ANTHROPIC_API_KEY=sk-ant-...</code> before starting the dashboard';
+    }
+
+    const proxyEl = document.getElementById('settings-proxy-status');
+    if (d.base_url) {
+      proxyEl.innerHTML = '<span style="color:#3fb950;">&#10003;</span> Headroom proxy active at <code style="background:#161b22;padding:0.1rem 0.4rem;border-radius:3px;color:#c9d1d9;">' + d.base_url.replace(/</g,'&lt;') + '</code>';
+    } else {
+      proxyEl.innerHTML = 'Optional: Install <a href="https://github.com/chopratejas/headroom" target="_blank" style="color:#58a6ff;">Headroom</a> for ~34% token savings';
+    }
+
     loadModelPrefs();
     await loadUserProfile();
     settingsLoaded = true;

{memstack_skill_loader-4.0.3 → memstack_skill_loader-4.0.4}/src/memstack_skill_loader/dashboard.py

@@ -511,6 +511,8 @@ class _Handler(BaseHTTPRequestHandler):
                 "pro_skills_dir": str(home / ".memstack" / "pro-skills"),
                 "stats_db": str(DB_PATH),
                 "sessions_dir": str(home / ".memstack" / "agent-runner" / "sessions"),
+                "api_key_set": bool(os.environ.get("ANTHROPIC_API_KEY")),
+                "base_url": os.environ.get("ANTHROPIC_BASE_URL", ""),
             }
             body = json.dumps(data).encode()
             self._respond(200, "application/json", body)

{memstack_skill_loader-4.0.3 → memstack_skill_loader-4.0.4/src/memstack_skill_loader.egg-info}/PKG-INFO

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