adelie-ai 0.3.3 → 0.3.5

package/adelie/__init__.py

@@ -12,4 +12,4 @@ def _get_version() -> str:
     except Exception:
         pass
     return "0.0.0"
-__version__ = "0.3.3"
+__version__ = "0.3.5"

package/adelie/agents/coder_manager.py

@@ -36,7 +36,13 @@ _STOP_WORDS = {
 }
 
 _DEDUP_THRESHOLD = 0.6  # Jaccard similarity >= 60% → duplicate
-MAX_CODERS_PER_FILE = 3
+MAX_CODERS_PER_FILE = 5
+
+# Keywords that indicate a "fix/patch" task (bypass per-file limit)
+_FIX_KEYWORDS = {
+    "fix", "patch", "hotfix", "repair", "resolve", "debug",
+    "error", "bug", "broken", "typo", "incorrect", "wrong",
+}
 
 
 def _tokenize(text: str) -> set[str]:
@@ -89,17 +95,20 @@ def _find_duplicate_coder(
 def _count_file_modifications(registry: dict, files: list[str]) -> int:
     """
     주어진 파일 목록과 겹치는 기존 코더 수를 반환.
-    coder task description 내 파일 경로 매칭 기반.
+    coder task description 내 **전체 파일 경로** 매칭 기반.
+    (basename 매칭은 다른 경로의 동일 이름 파일을 오탐하므로 fullpath 사용)
     """
     if not files:
         return 0
 
-    file_basenames = {f.rsplit("/", 1)[-1].lower() for f in files}
+    # Use full path for matching to avoid collisions
+    # e.g. "quests/create/page.tsx" and "login/page.tsx" are different files
+    file_fullpaths = {f.lower() for f in files}
     count = 0
 
     for coder in registry.get("coders", []):
         task_lower = coder.get("last_task", "").lower()
-        if any(basename in task_lower for basename in file_basenames):
+        if any(fp in task_lower for fp in file_fullpaths):
             count += 1
 
     return count
@@ -270,7 +279,10 @@ def run_coders(
                 name = existing_name
 
             # ── Per-file limit ─────────────────────────────────────
-            if relevant and _count_file_modifications(registry, relevant) >= MAX_CODERS_PER_FILE:
+            # Fix/patch tasks bypass per-file limit — they MUST be able
+            # to modify files that need correction (Bug #8b)
+            is_fix_task = bool(_FIX_KEYWORDS & _tokenize(task_desc))
+            if relevant and not is_fix_task and _count_file_modifications(registry, relevant) >= MAX_CODERS_PER_FILE:
                 console.print(
                     f"  [yellow]⏭ Skipped '{name}': target files modified "
                     f"{MAX_CODERS_PER_FILE}+ times already[/yellow]"

package/adelie/orchestrator.py

@@ -12,6 +12,7 @@ State machine:
 
 from __future__ import annotations
 
+import copy
 import json
 from typing import Callable, Optional
 import signal
@@ -115,6 +116,9 @@ class Orchestrator:
         # Track coder/reviewer results for next cycle's Expert AI context (Bug #4)
         self._last_coder_result: dict | None = None
 
+        # Track consecutive zero-file coder cycles for emergency reset (Bug #10)
+        self._zero_file_streak: int = 0
+
         # Auto-scan: if KB is empty and project has existing code, scan first
         self._auto_scan_done = False
 
@@ -663,6 +667,7 @@ class Orchestrator:
                 # Force state transition on critical loops
                 if self.state.value in ("new_logic", "error"):
                     console.print("[bold yellow]🔧 Forcing transition to NORMAL state[/bold yellow]")
+                    self._archive_errors()  # Clear outstanding errors to prevent stale context loop
                     self.state = LoopState.NORMAL
                     system_state["situation"] = "normal"
             else:
@@ -1147,10 +1152,56 @@ class Orchestrator:
             except Exception as e:
                 console.print(f"[dim]⚠️ PolicyGate error: {e}[/dim]")
 
-        # ── Promote staged files to project (after review + policy) ───────
+        # ── Syntax validation with Coder Retry Loop (before promotion) ───
+        syntax_passed = True
         if all_written_files and reviewer_approved and policy_passed:
+            passed_files, failed_files = self._verify_staged_files(all_written_files)
+            if failed_files:
+                syntax_passed = False
+                console.print(
+                    f"[yellow]⚠️  Syntax validation failed for {len(failed_files)} file(s) — "
+                    f"initiating retry[/yellow]"
+                )
+                if coder_tasks and self.phase != "initial":
+                    from adelie.agents.coder_manager import run_coders
+                    from adelie.phases import PHASE_INFO
+                    phase_info = PHASE_INFO.get(self.phase, {})
+                    max_layer = phase_info.get("max_coder_layer", 0)
+
+                    # Build compiler failure feedback
+                    error_feedback = "## ⚠️ SYNTAX/COMPILATION FAILURE — FIX THESE ERRORS\n"
+                    for f in failed_files:
+                        error_feedback += f"### File: `{f.get('filepath')}`\n"
+                        error_feedback += f"Error: {f.get('error', 'Syntax error')}\n\n"
+                    error_feedback += "Fix the code to resolve all syntax, compile, and parse errors."
+
+                    for task in coder_tasks:
+                        task["feedback"] = error_feedback
+
+                    try:
+                        fix_start_time = time.time()
+                        run_coders(coder_tasks, max_active_layer=max_layer)
+                        new_files = self._collect_staged_files(fix_start_time)
+                        if new_files:
+                            all_written_files = new_files
+                            # Re-verify after retry
+                            passed_files, failed_files = self._verify_staged_files(all_written_files)
+                            if not failed_files:
+                                syntax_passed = True
+                                console.print("[bold green]✅ Syntax validation passed after retry[/bold green]")
+                            else:
+                                console.print(
+                                    f"[red]❌ Syntax validation still failed for {len(failed_files)} file(s) "
+                                    f"after retry[/red]"
+                                )
+                    except Exception as se:
+                        console.print(f"[dim]⚠️ Syntax retry exception: {se}[/dim]")
+
+        # ── Promote staged files to project (after review + policy + syntax check) ───────
+        promoted_count = 0
+        if all_written_files and reviewer_approved and policy_passed and syntax_passed:
             with self._staging_lock:
-                self._promote_staged_files(all_written_files)
+                promoted_count = self._promote_staged_files(all_written_files)
                 self._cleanup_staging()
 
             # ── Git auto-commit (MID_1+) ──────────────────────────────────────
@@ -1165,6 +1216,36 @@ class Orchestrator:
                 except Exception as e:
                     console.print(f"[dim]⚠️ Git commit error: {e}[/dim]")
 
+        # ── Bug #10: Zero-file streak detection & emergency registry reset ────
+        # Zero-file streak triggers when coder tasks exist but promoted_count is 0
+        # (covers coder writing 0 files OR files being written but blocked/rejected before promotion)
+        if promoted_count == 0 and coder_tasks:
+            self._zero_file_streak += 1
+            if self._zero_file_streak >= 3:
+                console.print(
+                    f"[bold yellow]🔓 Emergency: {self._zero_file_streak} consecutive"
+                    f" zero-promoted cycles — resetting coder registry[/bold yellow]"
+                )
+                try:
+                    from adelie.agents.coder_manager import REGISTRY_PATH
+                    if REGISTRY_PATH.exists():
+                        import json as _json
+                        reg = _json.loads(REGISTRY_PATH.read_text(encoding="utf-8"))
+                        old_count = len(reg.get("coders", []))
+                        reg["coders"] = []
+                        REGISTRY_PATH.write_text(
+                            _json.dumps(reg, indent=2, ensure_ascii=False),
+                            encoding="utf-8",
+                        )
+                        console.print(
+                            f"  [yellow]Cleared {old_count} coder(s) from registry[/yellow]"
+                        )
+                except Exception as e:
+                    console.print(f"  [dim]⚠️ Registry reset error: {e}[/dim]")
+                self._zero_file_streak = 0
+        else:
+            self._zero_file_streak = 0
+
         # ══════════════════════════════════════════════════════════════════════
         # PHASE 3: Tester AI + Runner AI (PARALLEL)
         # After code is promoted, testing and building are independent.
@@ -1191,13 +1272,14 @@ class Orchestrator:
                 parallel_names.append("Runner")
             console.print(f"[dim]  ⚡ Phase 3: parallel execution [{', '.join(parallel_names)}][/dim]")
 
+            import copy
             with ThreadPoolExecutor(max_workers=len(parallel_names), thread_name_prefix="adelie-p3") as pool:
                 futures = {}
 
                 if run_tester:
                     _test_pass_results = []
                     _test_metrics = {}
-                    _p3_coder_tasks = list(coder_tasks)  # Copy for thread safety
+                    _p3_coder_tasks = copy.deepcopy(coder_tasks)  # Thread-safe deep copy to prevent shared mutations
                     _p3_all_files = list(all_written_files)
 
                     def _run_tester():
@@ -1241,7 +1323,11 @@ class Orchestrator:
                                 if coder_result.get("total_files", 0) > 0:
                                     new_files = self._collect_staged_files(fix_start_time)
                                     if new_files:
-                                        _files = new_files
+                                        # Merge new_files into _files by filepath to keep all original targets in validation
+                                        existing_paths = {f["filepath"] for f in _files}
+                                        for nf in new_files:
+                                            if nf["filepath"] not in existing_paths:
+                                                _files.append(nf)
                                     with self._staging_lock:
                                         self._promote_staged_files(_files)
                                         self._cleanup_staging()
@@ -1527,6 +1613,19 @@ class Orchestrator:
             if self._recover_count >= self.MAX_RECOVER_RETRIES:
                 console.print(f"[yellow]⚠️  Max recovery retries ({self.MAX_RECOVER_RETRIES}) reached — entering maintenance.[/yellow]")
                 self._archive_errors()
+                
+                # Checkpoint Rollback: Revert to the latest safe state
+                try:
+                    from adelie.checkpoint import CheckpointManager
+                    cp_mgr = CheckpointManager()
+                    cps = cp_mgr.list_checkpoints()
+                    if cps:
+                        latest_id = cps[0].checkpoint_id
+                        console.print(f"[bold yellow]🔄 Self-Healing: Rolling back project files to checkpoint {latest_id}...[/bold yellow]")
+                        cp_mgr.restore(latest_id)
+                except Exception as cpe:
+                    console.print(f"[dim]⚠️ Rollback failed during recovery limit: {cpe}[/dim]")
+                
                 self.state = LoopState.MAINTENANCE
             else:
                 console.print(f"[yellow]🔄 Recovery attempt {self._recover_count}/{self.MAX_RECOVER_RETRIES} — clearing errors and returning to normal.[/yellow]")
@@ -1549,9 +1648,8 @@ class Orchestrator:
                         f"[yellow]⚠️  Max new_logic cycles ({self.MAX_NEW_LOGIC_CYCLES}) reached — "
                         f"transitioning to normal.[/yellow]"
                     )
-                    self.state = LoopState.NORMAL
+                    next_situation = "normal"
                     self._new_logic_count = 0
-                    return
             else:
                 self._new_logic_count = 0
 

package/adelie/utils/dep_sync.py

@@ -174,7 +174,25 @@ def sync_package_json(missing: list[str], project_root: Path) -> int:
     dev_deps = pkg.get("devDependencies", {})
     added = 0
 
+    # Known-invalid package name patterns — common LLM hallucinations
+    _INVALID_PKG_NAMES = {
+        "requested", "response", "result", "data", "config",
+        "utils", "helpers", "types", "models", "services",
+        "app", "main", "index", "test", "error", "handler",
+        "component", "module", "function", "class", "object",
+        "input", "output", "value", "item", "list", "array",
+        "string", "number", "boolean", "null", "undefined",
+        "client", "server", "api", "route", "page", "layout",
+    }
+
     for name in missing:
+        # Skip hallucinated/generic package names
+        name_lower = name.lower()
+        if name_lower in _INVALID_PKG_NAMES:
+            continue
+        # npm packages must be lowercase, start with letter/@, no spaces
+        if not re.match(r'^(@[a-z0-9-~][a-z0-9-._~]*/)?[a-z0-9][a-z0-9._-]*$', name):
+            continue
         if name not in deps and name not in dev_deps:
             # Heuristic: testing/dev tools go to devDependencies
             if any(kw in name.lower() for kw in ["test", "jest", "vitest", "eslint", "prettier", "lint"]):

package/package.json

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