adelie-ai 0.2.11 → 0.2.12

package/adelie/__init__.py

@@ -13,4 +13,4 @@ def _get_version() -> str:
         pass
     return "0.0.0"
 
-__version__ = "0.2.11"
+__version__ = "0.2.12"

package/adelie/agents/coder_ai.py

@@ -238,12 +238,20 @@ def run_coder(
         if not filepath or not content:
             continue
 
-        # Sanitize — prevent writing outside workspace
+        # Sanitize — prevent writing outside staging area
+        # Check both Unix absolute paths (/...) and Windows (C:\...)
         if filepath.startswith("/") or ".." in filepath:
             console.print(
                 f"[yellow]⚠️  Skipped unsafe path: {filepath}[/yellow]"
             )
             continue
+        # Resolve-based check: ensure the final path is under STAGING_ROOT
+        resolved_out = (STAGING_ROOT / filepath).resolve()
+        if not str(resolved_out).startswith(str(STAGING_ROOT.resolve())):
+            console.print(
+                f"[yellow]⚠️  Skipped path escaping staging: {filepath}[/yellow]"
+            )
+            continue
 
         out_path = STAGING_ROOT / filepath
         out_path.parent.mkdir(parents=True, exist_ok=True)

package/adelie/agents/runner_ai.py

@@ -57,7 +57,7 @@ DEPLOY_COMMANDS = RUN_COMMANDS + [
 BLOCKED_FLAGS = {"-c", "--eval", "eval", "exec", "--exec", "-e"}
 
 # Dangerous shell metacharacters
-BLOCKED_CHARS = {";", "|", "&&", "||", "`", "$(", ">>", "<<"}
+BLOCKED_CHARS = {";", "|", "&", "&&", "||", "`", "$(", ">", ">>", "<<"}
 
 EXEC_TIMEOUT_BUILD = 120
 EXEC_TIMEOUT_RUN = 10  # Short timeout — we just check if it starts

package/adelie/agents/tester_ai.py

@@ -44,7 +44,7 @@ ALLOWED_COMMANDS = [
 BLOCKED_FLAGS = {"-c", "--eval", "eval", "exec", "--exec", "-e"}
 
 # Dangerous shell metacharacters
-BLOCKED_CHARS = {";", "|", "&&", "||", "`", "$(", ">>", "<<"}
+BLOCKED_CHARS = {";", "|", "&", "&&", "||", "`", "$(", ">", ">>", "<<"}
 
 EXEC_TIMEOUT = 60  # seconds
 

package/adelie/agents/writer_ai.py

@@ -301,13 +301,17 @@ Remember: output ONLY a valid JSON array.
                 ratio = min(len_existing, len_new) / max(len_existing, len_new)
                 if ratio > 0.90:
                     # Check first 200 chars — if very similar, skip
-                    common_start = 0
-                    for a, b in zip(existing_body[:200], new_body[:200]):
-                        if a == b:
-                            common_start += 1
-                    if common_start / min(200, len(existing_body[:200])) > 0.7:
-                        console.print(f"[dim]  ⏭  Skipped {cat}/{filename} (similar content)[/dim]")
-                        continue
+                    compare_len = min(200, len(existing_body), len(new_body))
+                    if compare_len < 20:
+                        pass  # Too short to compare meaningfully
+                    else:
+                        common_start = 0
+                        for a, b in zip(existing_body[:compare_len], new_body[:compare_len]):
+                            if a == b:
+                                common_start += 1
+                        if common_start / compare_len > 0.7:
+                            console.print(f"[dim]  ⏭  Skipped {cat}/{filename} (similar content)[/dim]")
+                            continue
 
         # Prepend a frontmatter header for human readability
         header = (

package/adelie/env_strategy.py

@@ -20,8 +20,10 @@ Strategy selection follows the project phase:
 
 from __future__ import annotations
 
+import os
 import shutil
 import subprocess
+import sys
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
@@ -124,6 +126,7 @@ def detect_env(project_root: Path) -> EnvProfile:
     # ── Python environments ───────────────────────────────────────────────
 
     # Standard venv
+    _is_win = sys.platform == "win32"
     for venv_dir in [".venv", "venv"]:
         venv_path = project_root / venv_dir
         if venv_path.is_dir():
@@ -133,7 +136,12 @@ def detect_env(project_root: Path) -> EnvProfile:
             if bin_dir.exists():
                 profile.python_bin = str(bin_dir / "python")
                 profile.pip_bin = str(bin_dir / "pip")
-                profile.shell_wrapper = f"source {venv_path / 'bin' / 'activate'}"
+                # Windows: use activate.bat; Unix: source activate
+                if _is_win:
+                    activate_script = bin_dir / "activate.bat"
+                    profile.shell_wrapper = f"{activate_script} &&"
+                else:
+                    profile.shell_wrapper = f"source {bin_dir / 'activate'}"
                 profile.env_type = "venv"
                 detected.append("venv")
                 break
@@ -164,7 +172,7 @@ def detect_env(project_root: Path) -> EnvProfile:
     node_modules_bin = project_root / "node_modules" / ".bin"
     if node_modules_bin.is_dir():
         profile.node_bin = str(node_modules_bin / "node") if (node_modules_bin / "node").exists() else None
-        profile.npm_prefix = str(node_modules_bin) + "/"
+        profile.npm_prefix = str(node_modules_bin) + os.sep
         if profile.env_type == "system":
             profile.env_type = "npm"
         detected.append("npm")
@@ -475,11 +483,16 @@ def _wrap_resolver(cmd: str, profile: EnvProfile) -> str:
     elif profile.env_type == "poetry":
         return f"poetry run {cmd}"
 
-    # For standard venv: use bash -c with activation
-    if profile.shell_wrapper and "source" in profile.shell_wrapper:
-        # Escape single quotes in cmd
-        escaped_cmd = cmd.replace("'", "'\\''")
-        return f"bash -c '{profile.shell_wrapper} && {escaped_cmd}'"
+    # For standard venv: wrap with activation
+    if profile.shell_wrapper:
+        if sys.platform == "win32" and profile.shell_wrapper.endswith("&&"):
+            # Windows: cmd /c "activate.bat && command"
+            escaped_cmd = cmd.replace('"', '\\"')
+            return f'cmd /c "{profile.shell_wrapper} {escaped_cmd}"'
+        elif "source" in profile.shell_wrapper:
+            # Unix: bash -c "source activate && command"
+            escaped_cmd = cmd.replace("'", "'\\''")
+            return f"bash -c '{profile.shell_wrapper} && {escaped_cmd}'"
 
     # Fallback to direct if no resolver available
     return _wrap_direct(cmd, profile)

package/adelie/kb/retriever.py

@@ -77,7 +77,7 @@ def list_categories() -> dict[str, int]:
     """Return a dict of {category_name: file_count} for all KB categories."""
     ensure_workspace()
     return {
-        cat: len(list((WORKSPACE_PATH / cat).glob("*")))
+        cat: len(list((WORKSPACE_PATH / cat).glob("*.md")))
         for cat in KB_CATEGORIES
     }
 

package/adelie/llm_client.py

@@ -32,6 +32,7 @@ console = Console()
 
 # ── Token usage tracking ─────────────────────────────────────────────────────
 _usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0, "calls": 0}
+_usage_lock = threading.Lock()
 
 # Per-agent usage tracking (agent_name -> {prompt_tokens, completion_tokens, total_tokens, calls, time})
 _agent_usage: dict[str, dict] = {}
@@ -58,17 +59,19 @@ def _get_current_agent() -> str:
 
 def reset_usage() -> None:
     """Reset token counters (call at start of each loop)."""
-    _usage["prompt_tokens"] = 0
-    _usage["completion_tokens"] = 0
-    _usage["total_tokens"] = 0
-    _usage["calls"] = 0
+    with _usage_lock:
+        _usage["prompt_tokens"] = 0
+        _usage["completion_tokens"] = 0
+        _usage["total_tokens"] = 0
+        _usage["calls"] = 0
     with _agent_usage_lock:
         _agent_usage.clear()
 
 
 def get_usage() -> dict:
     """Return current accumulated token usage."""
-    return dict(_usage)
+    with _usage_lock:
+        return dict(_usage)
 
 
 def get_agent_usage() -> dict[str, dict]:
@@ -78,10 +81,11 @@ def get_agent_usage() -> dict[str, dict]:
 
 
 def _record_usage(prompt: int, completion: int) -> None:
-    _usage["prompt_tokens"] += prompt
-    _usage["completion_tokens"] += completion
-    _usage["total_tokens"] += prompt + completion
-    _usage["calls"] += 1
+    with _usage_lock:
+        _usage["prompt_tokens"] += prompt
+        _usage["completion_tokens"] += completion
+        _usage["total_tokens"] += prompt + completion
+        _usage["calls"] += 1
 
     # Also record per-agent
     agent = _get_current_agent()

package/adelie/orchestrator.py

@@ -16,6 +16,7 @@ import json
 from typing import Callable, Optional
 import signal
 import sys
+import threading
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
@@ -94,6 +95,10 @@ class Orchestrator:
         # Process supervisor for spawned commands
         self.supervisor = ProcessSupervisor(max_concurrent=5)
 
+        # Lock to protect staging directory operations from race conditions
+        # between the tester thread (Phase 3) and the main orchestrator thread.
+        self._staging_lock = threading.Lock()
+
 
 
         # Graceful shutdown on Ctrl+C or SIGTERM
@@ -390,8 +395,15 @@ class Orchestrator:
         Verify staged files with lightweight syntax checks before promotion.
         Returns (passed, failed) file lists.
         """
+        import shutil
         import subprocess
         staging_root = ADELIE_ROOT / "staging"
+        # On Windows, 'python3' may resolve to the Microsoft Store stub
+        # (WindowsApps/python3.EXE) which doesn't work. Prefer sys.executable.
+        if sys.platform == "win32":
+            python_bin = sys.executable
+        else:
+            python_bin = shutil.which("python3") or shutil.which("python") or sys.executable
         passed: list[dict] = []
         failed: list[dict] = []
 
@@ -410,7 +422,7 @@ class Orchestrator:
             if ext == ".py":
                 try:
                     result = subprocess.run(
-                        ["python3", "-m", "py_compile", str(staged_path)],
+                        [python_bin, "-m", "py_compile", str(staged_path)],
                         capture_output=True, text=True, timeout=10,
                     )
                     if result.returncode != 0:
@@ -931,9 +943,13 @@ class Orchestrator:
                         score = review.get("overall_score", 5)
                         self._review_score_history.append(score)
 
-                        if review.get("approved", True) or retry >= MAX_REVIEW_RETRIES:
+                        if review.get("approved", True):
                             reviewer_approved = True
                             break
+                        if retry >= MAX_REVIEW_RETRIES:
+                            # Retry limit reached — use actual review result (do NOT force approve)
+                            reviewer_approved = False
+                            break
 
                         # Feed review back to coder for retry
                         console.print(f"  [yellow]🔄 Retry {retry+1}/{MAX_REVIEW_RETRIES} — sending feedback to coder[/yellow]")
@@ -988,8 +1004,9 @@ class Orchestrator:
 
         # ── Promote staged files to project (after review) ────────────────
         if all_written_files and reviewer_approved:
-            self._promote_staged_files(all_written_files)
-            self._cleanup_staging()
+            with self._staging_lock:
+                self._promote_staged_files(all_written_files)
+                self._cleanup_staging()
 
             # ── Git auto-commit (MID_1+) ──────────────────────────────────────
             if self.phase in ("mid_1", "mid_2", "late", "evolve"):
@@ -1080,8 +1097,9 @@ class Orchestrator:
                                     new_files = self._collect_staged_files(fix_start_time)
                                     if new_files:
                                         _files = new_files
-                                    self._promote_staged_files(_files)
-                                    self._cleanup_staging()
+                                    with self._staging_lock:
+                                        self._promote_staged_files(_files)
+                                        self._cleanup_staging()
                             except Exception as ce:
                                 console.print(f"[red]❌ Coder fix error: {ce}[/red]")
                                 break

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adelie-ai",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "description": "Adelie — Self-Communicating Autonomous AI Loop CLI",
   "bin": {
     "adelie": "bin/adelie.js"