alpiecode 10.0.1__tar.gz → 10.0.2__tar.gz

{alpiecode-10.0.1 → alpiecode-10.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.0.1
+Version: 10.0.2
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-10.0.1 → alpiecode-10.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "10.0.1"
+version = "10.0.2"
 description = "AlpieCode"
 requires-python = ">=3.9"
 dependencies = [

{alpiecode-10.0.1 → alpiecode-10.0.2}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.0.1
+Version: 10.0.2
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-10.0.1 → alpiecode-10.0.2}/src/alpiecode.egg-info/SOURCES.txt

@@ -26,12 +26,14 @@ src/codeagent/ipython_ext.py
 src/codeagent/local_model.py
 src/codeagent/media.py
 src/codeagent/memory.py
+src/codeagent/metrics.py
 src/codeagent/orchestrator.py
 src/codeagent/progress.py
 src/codeagent/prompt.py
 src/codeagent/rephraser.py
 src/codeagent/server.py
 src/codeagent/session.py
+src/codeagent/system1.py
 src/codeagent/tools.py
 src/codeagent/updater.py
 src/codeagent/vscode_installer.py
@@ -41,9 +43,14 @@ src/codeagent/backends/local_backend.py
 src/codeagent/backends/openai_backend.py
 src/codeagent/extension/alpiecode.vsix
 test/test_audit_fixes.py
+test/test_benchmark_system1.py
+test/test_cache_reads.py
 test/test_chat_mode.py
 test/test_claude_codex_capabilities.py
+test/test_context_filter.py
+test/test_metrics.py
 test/test_offline_mode.py
 test/test_phase1.py
 test/test_phase2.py
-test/test_phase3.py
+test/test_phase3.py
+test/test_system1.py

{alpiecode-10.0.1 → alpiecode-10.0.2}/src/codeagent/__init__.py

@@ -17,7 +17,7 @@ Supports:
 from pathlib import Path
 from typing import Optional, Any, Dict
 
-__version__ = "10.0.1"
+__version__ = "10.0.2"
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):
     """Run an autonomous coding task programmatically."""

{alpiecode-10.0.1 → alpiecode-10.0.2}/src/codeagent/agent.py

@@ -432,6 +432,43 @@ def run_agent(
                     style="dim"
                 )
 
+        elif event.type == "system1_intervention" and verbose:
+            data = event.data
+            action = data.get("action", "")
+            err_type = data.get("error_type", "")
+            directive = data.get("directive", "")
+            if HAS_RICH:
+                console.print(Panel(
+                    f"[bold yellow]⚡ System 1 (Jev) Intervention[/bold yellow] (Turn {data.get('turn')})\n"
+                    f"• Action: [cyan]{action}[/cyan] | Error Type: [red]{err_type}[/red]\n"
+                    f"• Directive: {directive}",
+                    border_style="yellow",
+                    padding=(0, 1)
+                ))
+            else:
+                print(f"\n⚡ [System 1 Intervention] {action}: {directive}")
+
+        elif event.type == "metrics" and verbose:
+            data = event.data
+            if HAS_RICH:
+                console.print(Panel(
+                    f"⏱️  [bold]Latency:[/bold] {data.get('total_task_latency_s', 0)}s  |  "
+                    f"🧠 [bold]LLM Calls:[/bold] {data.get('llm_call_count', 0)} ({data.get('llm_inference_time_ms', 0)}ms)\n"
+                    f"🛠️  [bold]Tools Time:[/bold] {data.get('total_tool_execution_ms', 0)}ms ({data.get('tool_call_count', 0)} calls)  |  "
+                    f"📦 [bold]Context Prep:[/bold] {data.get('context_prep_time_ms', 0)}ms  |  "
+                    f"⚡ [bold]Cache Hits:[/bold] {data.get('cache_hits', 0)}",
+                    title="📊 Task Performance Summary",
+                    border_style="cyan",
+                    padding=(0, 1)
+                ))
+            else:
+                print(
+                    f"\n📊 [Metrics] Task Latency: {data.get('total_task_latency_s')}s | "
+                    f"LLM Calls: {data.get('llm_call_count')} | "
+                    f"Tools Time: {data.get('total_tool_execution_ms')}ms | "
+                    f"Cache Hits: {data.get('cache_hits')}"
+                )
+
         elif event.type == "safety_ceiling" and verbose:
             if HAS_RICH:
                 console.print(

{alpiecode-10.0.1 → alpiecode-10.0.2}/src/codeagent/cache.py

@@ -193,3 +193,120 @@ def get_cache() -> ResponseCache:
     if _CACHE is None:
         _CACHE = ResponseCache()
     return _CACHE
+
+
+# ── File Read & Test Result Caching ─────────────────────────────────────
+
+class FileReadCache:
+    """In-memory cache for repeated file reads keyed by (path, mtime, size, start_line, end_line)."""
+
+    def __init__(self, max_entries: int = 1000):
+        self.max_entries = max_entries
+        self._cache: Dict[str, Dict[str, Any]] = {}
+        self.hits = 0
+        self.misses = 0
+
+    def get(self, file_path: Path, start_line: Optional[int] = None, end_line: Optional[int] = None) -> Optional[str]:
+        try:
+            st = file_path.stat()
+            key = f"{file_path.resolve()}:{st.st_mtime}:{st.st_size}:{start_line}:{end_line}"
+        except OSError:
+            return None
+
+        entry = self._cache.get(key)
+        if entry is not None:
+            self.hits += 1
+            return entry["content"]
+
+        self.misses += 1
+        return None
+
+    def put(self, file_path: Path, content: str, start_line: Optional[int] = None, end_line: Optional[int] = None) -> None:
+        try:
+            st = file_path.stat()
+            key = f"{file_path.resolve()}:{st.st_mtime}:{st.st_size}:{start_line}:{end_line}"
+        except OSError:
+            return
+
+        if len(self._cache) >= self.max_entries:
+            keys = list(self._cache.keys())[: max(1, self.max_entries // 5)]
+            for k in keys:
+                self._cache.pop(k, None)
+
+        self._cache[key] = {"content": content, "cached_at": time.time()}
+
+    def invalidate(self, file_path: Optional[Path] = None) -> None:
+        if file_path is None:
+            self._cache.clear()
+            return
+        prefix = f"{file_path.resolve()}:"
+        keys_to_del = [k for k in self._cache if k.startswith(prefix)]
+        for k in keys_to_del:
+            self._cache.pop(k, None)
+
+
+class TestResultCache:
+    """Caches test command execution results when workspace files are unchanged."""
+    __test__ = False
+
+    def __init__(self, max_entries: int = 100):
+        self.max_entries = max_entries
+        self._cache: Dict[str, Dict[str, Any]] = {}
+        self._workspace_versions: Dict[str, float] = {}
+        self.hits = 0
+        self.misses = 0
+
+    def _is_test_cmd(self, cmd: str) -> bool:
+        c = cmd.strip().lower()
+        return (
+            "pytest" in c
+            or "unittest" in c
+            or "npm test" in c
+            or "cargo test" in c
+            or "go test" in c
+        )
+
+    def get(self, workdir: Path, cmd: str) -> Optional[str]:
+        if not self._is_test_cmd(cmd):
+            return None
+        version = self._workspace_versions.get(str(workdir.resolve()), 0.0)
+        key = f"{workdir.resolve()}:{cmd.strip()}:{version}"
+        entry = self._cache.get(key)
+        if entry is not None:
+            self.hits += 1
+            return f"[Cached test result]\n{entry['content']}"
+        self.misses += 1
+        return None
+
+    def put(self, workdir: Path, cmd: str, result: str) -> None:
+        if not self._is_test_cmd(cmd):
+            return
+        version = self._workspace_versions.get(str(workdir.resolve()), 0.0)
+        key = f"{workdir.resolve()}:{cmd.strip()}:{version}"
+        self._cache[key] = {"content": result, "cached_at": time.time()}
+
+    def invalidate(self, workdir: Optional[Path] = None) -> None:
+        if workdir is None:
+            self._cache.clear()
+            self._workspace_versions.clear()
+            return
+        w_key = str(workdir.resolve())
+        self._workspace_versions[w_key] = time.time()
+
+
+_FILE_CACHE: Optional[FileReadCache] = None
+_TEST_CACHE: Optional[TestResultCache] = None
+
+
+def get_file_cache() -> FileReadCache:
+    global _FILE_CACHE
+    if _FILE_CACHE is None:
+        _FILE_CACHE = FileReadCache()
+    return _FILE_CACHE
+
+
+def get_test_cache() -> TestResultCache:
+    global _TEST_CACHE
+    if _TEST_CACHE is None:
+        _TEST_CACHE = TestResultCache()
+    return _TEST_CACHE

{alpiecode-10.0.1 → alpiecode-10.0.2}/src/codeagent/context.py

@@ -1,3 +1,4 @@
+import re
 """
 Conversation context manager for AlpieCode.
 
@@ -198,10 +199,11 @@ class ContextManager:
     ) -> None:
         """Append a tool execution result and record metadata."""
         self.invalidate_cache()
+        filtered_content = filter_noisy_tool_output(content, tool_name=tool_name)
         msg = {
             "role": "tool",
             "tool_call_id": tool_call_id,
-            "content": content,
+            "content": filtered_content,
         }
         self._messages.append(dict(msg))
         self._raw_messages.append(copy.deepcopy(msg))
@@ -415,3 +417,33 @@ class ContextManager:
             self._cached_summary = extract_conversation_summary(self._messages, self._metadata)
             return True
         return False
+
+def filter_noisy_tool_output(content: str, tool_name: Optional[str] = None) -> str:
+    """
+    Filter noisy tool output to conserve LLM context window.
+    Extracts relevant errors/failures and condenses passing test spam.
+    """
+    if not content or len(content) < 300:
+        return content
+
+    # 1. Pytest / Unittest clean pass compression
+    if "passed in" in content and ("test session starts" in content or "collected" in content):
+        if "FAILED" not in content and "ERROR" not in content and "failed" not in content:
+            m = re.search(r"(=+\s*\d+\s+passed.*in\s+[\d\.]+s\s*=+)", content)
+            if m:
+                return f"[Clean Test Output]\n{m.group(1)}"
+        else:
+            # Tests had failures: strip passing test lines, keep failure traceback
+            lines = content.splitlines()
+            filtered = [
+                line for line in lines
+                if not (" PASSED" in line and ("[" in line and "%]" in line))
+            ]
+            return "\n".join(filtered)
+
+    if "Ran " in content and " tests in " in content and "OK" in content and "FAILED" not in content:
+        m = re.search(r"(Ran \d+ tests? in [\d\.]+s\s+OK)", content)
+        if m:
+            return f"[Clean Test Output]\n{m.group(1)}"
+
+    return content

alpiecode-10.0.2/src/codeagent/metrics.py

@@ -0,0 +1,83 @@
+"""
+Performance metrics tracking for AlpieCode.
+
+Tracks per-task metrics:
+  - LLM call count
+  - Total task latency
+  - Tool execution time
+  - Context preparation time
+  - Cache hits
+"""
+
+import time
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class TaskMetrics:
+    task_id: str = ""
+    start_time: float = field(default_factory=time.time)
+    end_time: Optional[float] = None
+    llm_call_count: int = 0
+    total_task_latency_ms: float = 0.0
+    total_tool_execution_ms: float = 0.0
+    context_prep_time_ms: float = 0.0
+    llm_inference_time_ms: float = 0.0
+    tool_call_count: int = 0
+    cache_hits: int = 0
+    errors_encountered: int = 0
+
+    def start(self) -> "TaskMetrics":
+        self.start_time = time.time()
+        return self
+
+    def finish(self) -> "TaskMetrics":
+        self.end_time = time.time()
+        self.total_task_latency_ms = (self.end_time - self.start_time) * 1000.0
+        return self
+
+    def record_llm_call(self, duration_ms: float = 0.0) -> None:
+        self.llm_call_count += 1
+        self.llm_inference_time_ms += duration_ms
+
+    def record_tool_call(self, duration_ms: float = 0.0) -> None:
+        self.tool_call_count += 1
+        self.total_tool_execution_ms += duration_ms
+
+    def record_context_prep(self, duration_ms: float = 0.0) -> None:
+        self.context_prep_time_ms += duration_ms
+
+    def record_cache_hit(self) -> None:
+        self.cache_hits += 1
+
+    def record_error(self) -> None:
+        self.errors_encountered += 1
+
+    def summary(self) -> Dict[str, Any]:
+        latency_ms = self.total_task_latency_ms
+        if self.end_time is None:
+            latency_ms = (time.time() - self.start_time) * 1000.0
+
+        return {
+            "task_id": self.task_id,
+            "llm_call_count": self.llm_call_count,
+            "tool_call_count": self.tool_call_count,
+            "cache_hits": self.cache_hits,
+            "total_task_latency_ms": round(latency_ms, 2),
+            "total_task_latency_s": round(latency_ms / 1000.0, 2),
+            "total_tool_execution_ms": round(self.total_tool_execution_ms, 2),
+            "context_prep_time_ms": round(self.context_prep_time_ms, 2),
+            "llm_inference_time_ms": round(self.llm_inference_time_ms, 2),
+            "errors_encountered": self.errors_encountered,
+        }
+
+    def format_log_line(self) -> str:
+        s = self.summary()
+        return (
+            f"📊 [Metrics] Task completed in {s['total_task_latency_s']}s | "
+            f"LLM calls: {s['llm_call_count']} ({s['llm_inference_time_ms']}ms) | "
+            f"Tools: {s['tool_call_count']} ({s['total_tool_execution_ms']}ms) | "
+            f"Context prep: {s['context_prep_time_ms']}ms | "
+            f"Cache hits: {s['cache_hits']}"
+        )

{alpiecode-10.0.1 → alpiecode-10.0.2}/src/codeagent/orchestrator.py

@@ -54,6 +54,9 @@ from .progress import ProgressMonitor
 from .rephraser import PromptRephraser
 from .prompt import PromptBuilder, classify_task
 from .session import Session, SessionManager
+from .metrics import TaskMetrics
+from .system1 import get_system1_controller, ActionCategory
+import time
 
 
 @dataclass
@@ -145,6 +148,9 @@ class AgentOrchestrator:
         """Run full agent task loop. Yields AgentEvents."""
 
         # ── Phase 0: Discovery — pre-compute task intelligence ──
+        task_metrics = TaskMetrics(task_id=session.id).start()
+        system1 = get_system1_controller()
+        system1.reset()
         task_context = build_task_context(task, session.workdir)
         complexity = complexity or task_context.complexity
 
@@ -191,6 +197,9 @@ class AgentOrchestrator:
                 if cached.get("reasoning"):
                     yield AgentEvent("thinking", {"content": cached["reasoning"]})
                 yield AgentEvent("message", {"content": cached["response"]})
+                task_metrics.record_cache_hit()
+                task_metrics.finish()
+                yield AgentEvent("metrics", task_metrics.summary())
                 yield AgentEvent("done", {"summary": cached["response"]})
                 return
 
@@ -338,6 +347,7 @@ class AgentOrchestrator:
                 else:
                     max_tokens = 2048 if is_offline else effective_max_tokens
 
+                llm_call_start = time.time()
                 if hasattr(task_backend, "chat_completion_stream"):
                     resp = None
                     for event_type, data in task_backend.chat_completion_stream(
@@ -444,6 +454,7 @@ class AgentOrchestrator:
                     # Execute final tool calls before finishing
                     results = session.executor.execute_tool_calls(tool_calls)
                     for res in results:
+                        task_metrics.record_tool_call(res.duration_ms)
                         yield AgentEvent("tool_result", {
                             "turn": turn,
                             "id": res.tool_call_id,
@@ -567,6 +578,8 @@ class AgentOrchestrator:
                     except Exception:
                         pass
 
+                task_metrics.finish()
+                yield AgentEvent("metrics", task_metrics.summary())
                 yield AgentEvent("done", {"summary": resp.content})
                 return
 
@@ -585,6 +598,7 @@ class AgentOrchestrator:
                 results = session.executor.execute_tool_calls(tool_calls)
 
                 for res in results:
+                    task_metrics.record_tool_call(res.duration_ms)
                     yield AgentEvent("tool_result", {
                         "turn": turn,
                         "id": res.tool_call_id,
@@ -594,6 +608,26 @@ class AgentOrchestrator:
                     })
                     session.context.add_tool_result(res.tool_call_id, res.content)
 
+                # ── System 1 Jev Decision Plane Evaluation ──
+                for tc, res in zip(tool_calls, results):
+                    tc_args = tc.arguments if isinstance(tc.arguments, dict) else {}
+                    if isinstance(tc.arguments, str):
+                        try:
+                            import json as _json
+                            tc_args = _json.loads(tc.arguments)
+                        except Exception:
+                            tc_args = {}
+                    decision = system1.evaluate_turn(tc.name, tc_args, res.content, turn)
+                    if decision.directive:
+                        session.context.add_user_message(decision.directive)
+                        yield AgentEvent("system1_intervention", {
+                            "turn": turn,
+                            "action": decision.action.value,
+                            "error_type": decision.error_type.value,
+                            "directive": decision.directive,
+                            "confidence": decision.confidence,
+                        })
+
                 # Track touched files and commands for walkthrough
                 for tc in tool_calls:
                     if tc.name in ("write_file", "edit_file", "apply_patch"):
@@ -641,11 +675,15 @@ class AgentOrchestrator:
                     yield AgentEvent("message", {"content": resp.content})
 
                 extract_and_save_memories(session.workdir, getattr(session.context, 'all_messages', session.context.messages))
+                task_metrics.finish()
+                yield AgentEvent("metrics", task_metrics.summary())
                 yield AgentEvent("done", {"summary": resp.content})
                 return
 
             # Empty response
             extract_and_save_memories(session.workdir, getattr(session.context, 'all_messages', session.context.messages))
+            task_metrics.finish()
+            yield AgentEvent("metrics", task_metrics.summary())
             yield AgentEvent("done", {"summary": "Task completed."})
             return