adelie-ai 0.3.2 → 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.2"
+__version__ = "0.3.5"

package/adelie/agents/coder_ai.py

@@ -44,6 +44,41 @@ Output a single valid JSON array of files to create/update."""
 SYSTEM_PROMPT = load_prompt("coder", _FALLBACK_PROMPT)
 
 
+def _get_framework_guidelines(framework: str) -> str:
+    """Return framework-specific coding rules to inject into coder prompt."""
+    guidelines = {
+        "nextjs": (
+            "\n## ⚠️ Next.js App Router — MANDATORY Rules\n"
+            "- Any component using useState, useEffect, onClick, or other client hooks "
+            "MUST start with `'use client';` as the FIRST line.\n"
+            "- `layout.tsx` is a SERVER component — NEVER use client-side hooks, "
+            "context providers, or event handlers in it without `'use client'`.\n"
+            "- Dynamic routes use `[param]`, `[...catch]`, `[[...optional]]` syntax — "
+            "these are valid directory names.\n"
+            "- API routes go in `src/app/api/` as `route.ts` files.\n"
+            "- Use `next/navigation` (not `next/router`) for App Router.\n"
+            "- The package name for lucide icons is `lucide-react` (NOT `@lucide/react`).\n\n"
+        ),
+        "nuxt": (
+            "\n## ⚠️ Nuxt 3 — MANDATORY Rules\n"
+            "- Use `<script setup lang='ts'>` for composition API.\n"
+            "- Auto-imports: `ref`, `computed`, `useRoute` etc. are auto-imported.\n"
+            "- Pages go in `pages/`, layouts in `layouts/`.\n\n"
+        ),
+        "sveltekit": (
+            "\n## ⚠️ SvelteKit — MANDATORY Rules\n"
+            "- Pages go in `src/routes/` as `+page.svelte`.\n"
+            "- Server-only code uses `+page.server.ts` or `+server.ts`.\n"
+            "- Layouts use `+layout.svelte`.\n\n"
+        ),
+        "vite": (
+            "\n## ⚠️ Vite + React — MANDATORY Rules\n"
+            "- Entry point is `index.html` referencing `src/main.tsx`.\n"
+            "- Use `vite.config.ts` with `@vitejs/plugin-react`.\n\n"
+        ),
+    }
+    return guidelines.get(framework, "")
+
 def _get_coder_log_dir(layer: int, coder_name: str) -> Path:
     """Get or create the log directory for a coder."""
     log_dir = CODER_ROOT / "layer" / str(layer) / coder_name
@@ -174,6 +209,16 @@ def run_coder(
         f"## Lower Layer Coder Logs\n{lower_logs}\n\n"
     )
 
+    # Bug #7: Inject framework-specific coding rules to prevent common mistakes
+    try:
+        from adelie.agents.expert_ai import _detect_framework
+        fw = _detect_framework(workspace_root)
+        fw_guidelines = _get_framework_guidelines(fw)
+        if fw_guidelines:
+            user_prompt += fw_guidelines
+    except Exception:
+        pass
+
     if feedback:
         user_prompt += (
             f"## ⚠️ REVIEWER FEEDBACK (FIX THESE ISSUES)\n{feedback}\n\n"

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/agents/expert_ai.py

@@ -444,8 +444,9 @@ def _get_scaffolding_need() -> str:
         return ""
 
     lines = [
-        "⚠️ CRITICAL: The following entry files are MISSING. Without them, the build WILL FAIL.",
-        "Create a 'project_scaffolding' coder task (layer 0) to generate these BEFORE any feature tasks:",
+        "ℹ️ SCAFFOLDING NOTE: The following entry files are missing.",
+        "If no scaffolding coder has been created yet, create ONE scaffolding task (layer 0).",
+        "If scaffolding was ALREADY attempted in a previous cycle, SKIP this and focus on feature tasks:",
     ]
     for c in checks:
         lines.append(f"  - {c['file']}: {c['desc']}")

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
@@ -112,6 +113,12 @@ class Orchestrator:
         self._last_assembled_contexts: list | None = None
         self._last_build_errors: list[dict] = []
 
+        # 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
 
@@ -181,6 +188,10 @@ class Orchestrator:
         # Include recent build errors for Expert AI context
         if self._last_build_errors:
             state["build_errors"] = self._last_build_errors[:3]  # 최대 3개
+        # Include last cycle's coder/reviewer result so Expert AI can avoid
+        # re-issuing tasks that previously failed (Bug #4)
+        if self._last_coder_result:
+            state["last_coder_result"] = self._last_coder_result
         return state
 
     def get_agent_context(self, agent_type: AgentType | str) -> dict:
@@ -656,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:
@@ -976,7 +988,10 @@ class Orchestrator:
                     )] or all_written_files
 
                     for retry in range(MAX_REVIEW_RETRIES + 1):
-                        review = run_review(coder_name=name, written_files=task_files)
+                        # Bug #6: pass STAGING_ROOT so reviewer reads files from
+                        # staging (where Coder wrote them), not PROJECT_ROOT.
+                        from adelie.agents.coder_ai import STAGING_ROOT as _REVIEW_STAGING
+                        review = run_review(coder_name=name, written_files=task_files, workspace_root=_REVIEW_STAGING)
                         score = review.get("overall_score", 5)
                         self._review_score_history.append(score)
 
@@ -1005,6 +1020,44 @@ class Orchestrator:
                 self._emit_agent_end("Reviewer", f"error: {e}")
             else:
                 self._emit_agent_end("Reviewer", "approved" if reviewer_approved else "rejected")
+
+            # Bug #3: Log review failures to KB so Expert AI avoids re-issuing
+            # the exact same task that was rejected.
+            if not reviewer_approved and all_written_files:
+                failed_files = [f.get("filepath", "") for f in all_written_files]
+                review_summary = review.get("summary", "N/A") if review else "N/A"
+                review_issues = ""
+                if review:
+                    for issue in review.get("issues", [])[:5]:
+                        review_issues += f"- [{issue.get('severity')}] {issue.get('title')}: {issue.get('suggestion', '')}\n"
+                failure_note = (
+                    f"# Review Failure Log (Cycle #{self.loop_iteration})\n\n"
+                    f"The following files were rejected by Reviewer AI after "
+                    f"{MAX_REVIEW_RETRIES + 1} attempts:\n"
+                    + "\n".join(f"- `{f}`" for f in failed_files) + "\n\n"
+                    f"**Review Summary**: {review_summary}\n\n"
+                    f"**Issues**:\n{review_issues}\n"
+                    f"Expert AI should NOT re-assign the same task until "
+                    f"the underlying issue is resolved.\n"
+                )
+                failure_path = WORKSPACE_PATH / "errors" / f"review_failure_{self.loop_iteration}.md"
+                failure_path.parent.mkdir(parents=True, exist_ok=True)
+                failure_path.write_text(failure_note, encoding="utf-8")
+                retriever.update_index(
+                    f"errors/{failure_path.name}",
+                    tags=["error", "review-failure"],
+                    summary=f"Review rejected cycle #{self.loop_iteration}: {', '.join(failed_files[:3])}",
+                )
+                console.print(f"[yellow]📝 Review failure logged to KB for Expert AI awareness[/yellow]")
+
+            # Bug #4: Record coder/reviewer results for next cycle context
+            self._last_coder_result = {
+                "cycle": self.loop_iteration,
+                "files_written": len(all_written_files),
+                "reviewer_approved": reviewer_approved,
+                "review_score": review.get("overall_score", 0) if review else 0,
+                "review_summary": review.get("summary", "")[:300] if review else "",
+            }
         elif all_written_files and self.phase != "initial":
             # Reviewer not scheduled this cycle — auto-approve staged files
             reviewer_approved = True
@@ -1099,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+) ──────────────────────────────────────
@@ -1117,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.
@@ -1143,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():
@@ -1193,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()
@@ -1479,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]")
@@ -1501,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.2",
+  "version": "0.3.5",
   "description": "Adelie — Self-Communicating Autonomous AI Loop CLI",
   "bin": {
     "adelie": "bin/adelie.js"