adelie-ai 0.3.7 → 0.3.9

package/adelie/__init__.py

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

package/adelie/agents/monitor_ai.py

@@ -176,17 +176,35 @@ def run_health_check(
         f"- Active: {len(active_services)}/{len(http_results)}\n"
     )
 
-    # 2. Process Checks — clean up dead processes
+    # 2. Process Checks — clean up dead processes AND verify HTTP health
     processes = _load_tracked_processes()
     alive = 0
     dead = 0
     alive_procs = []
+    process_http_issues = []
     for proc in processes:
         pid = proc.get("pid")
         if pid and _check_process(pid):
             alive += 1
             alive_procs.append(proc)
             console.print(f"  [green]✅ PID {pid}[/green] — {proc.get('description', '?')}")
+
+            # If the process has a port, verify HTTP health too
+            port = proc.get("port")
+            if port:
+                http_check = _check_http(f"http://localhost:{port}", timeout=3)
+                if http_check["status"] == "healthy":
+                    console.print(f"    [green]✅ HTTP :{port}[/green] — {http_check['response_ms']}ms")
+                elif http_check["status"] == "down":
+                    console.print(f"    [yellow]⚠️  HTTP :{port} not responding (process may still be starting)[/yellow]")
+                    process_http_issues.append(
+                        f"PID {pid} alive but HTTP :{port} not responding — {proc.get('description', '?')}"
+                    )
+                else:
+                    console.print(f"    [red]❌ HTTP :{port} — {http_check['status']}[/red]")
+                    process_http_issues.append(
+                        f"PID {pid} HTTP :{port} {http_check['status']} — {proc.get('description', '?')}"
+                    )
         else:
             dead += 1
 
@@ -196,9 +214,14 @@ def run_health_check(
         process_file = RUNNER_ROOT / "processes.json"
         process_file.write_text(json.dumps(alive_procs, indent=2), encoding="utf-8")
 
+    # Add HTTP issues to alerts
+    alerts.extend(process_http_issues)
+
     report_parts.append(
         f"### Processes\n"
-        f"- Alive: {alive} | Cleaned: {dead}\n"
+        f"- Alive: {alive} | Cleaned: {dead}"
+        + (f" | HTTP issues: {len(process_http_issues)}" if process_http_issues else "")
+        + "\n"
     )
 
     # 3. Log Error Scan

package/adelie/agents/reviewer_ai.py

@@ -31,11 +31,101 @@ console = Console()
 REVIEW_ROOT = WORKSPACE_PATH.parent / "reviews"
 
 _FALLBACK_PROMPT = """You are Reviewer AI — a senior code reviewer in an autonomous AI loop.
-Output a single valid JSON object with overall_score, issues, summary, and approved fields."""
+Output a single valid JSON object with overall_score, issues, summary, and approved fields.
+
+CROSS-FILE VALIDATION (CRITICAL):
+- Check that ALL import/require references match the actual API signatures
+  of the imported files (provided as "Related Files" context below).
+- Mismatched function signatures, missing exports, wrong parameter counts,
+  or incompatible types are CRITICAL severity issues.
+- If a function is called with arguments that don't match its definition,
+  that is a CRITICAL bug."""
 
 SYSTEM_PROMPT = load_prompt("reviewer", _FALLBACK_PROMPT)
 
 
+def _read_imported_files(
+    written_files: list[dict],
+    workspace_root: Path,
+) -> list[str]:
+    """
+    Find and read files that are imported/required by the review targets.
+    This enables cross-file interface validation.
+
+    Returns list of "--- filepath ---\ncontent" strings for related files.
+    """
+    import re as _re
+
+    # Collect all import targets from the written files
+    import_patterns = [
+        # ES6: import ... from './path' or "./path"
+        _re.compile(r"from\s+['\"](\.{1,2}/[^'\"]+)['\"]"),
+        # require: require('./path')
+        _re.compile(r"require\s*\(\s*['\"](\.{1,2}/[^'\"]+)['\"]\s*\)"),
+        # Python: from .module import ...
+        _re.compile(r"from\s+\.(\w+)\s+import"),
+    ]
+
+    # Track which files we've already included to avoid duplicates
+    written_paths = {f.get("filepath", "") for f in written_files}
+    related_contents: list[str] = []
+    seen_paths: set[str] = set()
+
+    for finfo in written_files:
+        fp = finfo.get("filepath", "")
+        full_path = workspace_root / fp
+        if not full_path.exists():
+            continue
+
+        try:
+            source = full_path.read_text(encoding="utf-8")
+        except Exception:
+            continue
+
+        file_dir = full_path.parent
+
+        for pattern in import_patterns:
+            for match in pattern.finditer(source):
+                import_path = match.group(1)
+
+                # Resolve the import to an actual file
+                candidate_base = file_dir / import_path
+                candidates = [
+                    candidate_base,
+                    candidate_base.with_suffix(".ts"),
+                    candidate_base.with_suffix(".tsx"),
+                    candidate_base.with_suffix(".js"),
+                    candidate_base.with_suffix(".jsx"),
+                    candidate_base.with_suffix(".py"),
+                    candidate_base / "index.ts",
+                    candidate_base / "index.js",
+                ]
+
+                for candidate in candidates:
+                    if candidate.exists() and candidate.is_file():
+                        try:
+                            rel = candidate.relative_to(workspace_root).as_posix()
+                        except ValueError:
+                            continue
+
+                        if rel in written_paths or rel in seen_paths:
+                            break  # Already in review context
+
+                        try:
+                            content = candidate.read_text(encoding="utf-8")
+                            # Only include first 2000 chars to avoid token overflow
+                            related_contents.append(
+                                f"--- {rel} (RELATED — imported by {fp}) ---\n"
+                                f"{content[:2000]}"
+                            )
+                            seen_paths.add(rel)
+                        except Exception:
+                            pass
+                        break
+
+    return related_contents[:10]  # Cap at 10 related files
+
+
 def run_review(
     coder_name: str,
     written_files: list[dict],
@@ -90,9 +180,21 @@ def run_review(
         f"## Coder: {coder_name}\n"
         f"## Files to Review\n\n"
         + "\n\n".join(file_contents)
-        + f"\n\n{get_context_prompt_section()}{get_rules_prompt_section()}{get_skills_prompt_section('reviewer')}"
+    )
+
+    # Add cross-file context: files imported by the review targets
+    related_files = _read_imported_files(written_files, workspace_root)
+    if related_files:
+        user_prompt += (
+            f"\n\n## Related Files (imported by review targets — check interface compatibility)\n\n"
+            + "\n\n".join(related_files)
+        )
+
+    user_prompt += (
+        f"\n\n{get_context_prompt_section()}{get_rules_prompt_section()}{get_skills_prompt_section('reviewer')}"
         + policy_section
-        + "\n\nReview these files and output a JSON object."
+        + "\n\nReview these files. Check that function calls match their definitions "
+        "in the Related Files. Output a JSON object."
     )
 
     try:

package/adelie/agents/runner_ai.py

@@ -59,9 +59,11 @@ DEPLOY_COMMANDS = RUN_COMMANDS + [
 BLOCKED_FLAGS = {"-c", "--eval", "eval", "exec", "--exec", "-e"}
 
 # Dangerous shell metacharacters
-BLOCKED_CHARS = {";", "|", "&", "&&", "||", "`", "$(", ">", ">>", "<<"}
+# NOTE: With shell=False (subprocess.run with list args), these are harmless
+# string literals. We only block truly dangerous injection patterns.
+BLOCKED_CHARS = {";", "`", "$("}
 
-EXEC_TIMEOUT_BUILD = 120
+EXEC_TIMEOUT_BUILD = 180  # Increased for large monorepo installs
 EXEC_TIMEOUT_RUN = 10  # Short timeout — we just check if it starts
 EXEC_TIMEOUT_DEPLOY = 180
 
@@ -547,6 +549,25 @@ def run_pipeline(
                 if result["pid"]:
                     _save_process(result["pid"], cmd, desc)
             else:
+                # ── Auto-recovery: clean retry for npm install failures ──
+                is_npm_install = cmd.strip().startswith("npm") and "install" in cmd
+                if is_npm_install and tier == "build":
+                    console.print(f"  [yellow]🔄 npm install failed — cleaning node_modules and retrying…[/yellow]")
+                    nm_path = cwd / "node_modules"
+                    if nm_path.exists():
+                        shutil.rmtree(nm_path, ignore_errors=True)
+                    # Retry with clean state
+                    retry_result = _execute(cmd, cwd, timeout, background)
+                    if retry_result["returncode"] == 0:
+                        succeeded += 1
+                        console.print(f"  [green]✅ OK (clean retry)[/green]")
+                        log_entries.append({
+                            "tier": tier, "command": cmd,
+                            "description": desc + " (clean retry)",
+                            "result": retry_result,
+                        })
+                        continue  # Skip the error recording below
+
                 failed += 1
                 console.print(f"  [red]❌ Failed (rc={result['returncode']})[/red]")
                 if result["stderr"]:

package/adelie/agents/tester_ai.py

@@ -41,7 +41,8 @@ ALLOWED_COMMANDS = [
 BLOCKED_FLAGS = {"-c", "--eval", "eval", "exec", "--exec", "-e"}
 
 # Dangerous shell metacharacters
-BLOCKED_CHARS = {";", "|", "&", "&&", "||", "`", "$(", ">", ">>", "<<"}
+# NOTE: With shell=False (subprocess.run with list args), most are harmless.
+BLOCKED_CHARS = {";", "`", "$("}
 
 EXEC_TIMEOUT = 60  # seconds
 
@@ -73,9 +74,96 @@ RULES:
 - Use relative imports when possible
 - Tests should assert expected behavior, not just run without checking
 - Keep tests focused and fast
+
+CRITICAL DEPENDENCY RULES:
+- You will be told which test runner and devDependencies are available.
+- ONLY import packages that are listed as available. Do NOT assume packages exist.
+- If NO test framework (vitest/jest/mocha) is installed, write tests using ONLY:
+  * Node.js built-in `assert` module (const assert = require('assert');)
+  * Node.js built-in `test` module if Node >= 18 (const { test } = require('node:test');)
+  * Direct require() of the source file being tested
+- Do NOT import @testing-library/react, enzyme, or any DOM testing library unless
+  explicitly listed as available.
+- For TypeScript source files, write tests in plain JavaScript (.js) using require()
+  UNLESS vitest or jest with ts-jest is available.
+- Test files MUST have .js extension unless a test runner supporting .ts is available.
+- Do NOT use `npx tsx` or `ts-node` to run tests — use the detected test runner.
 """
 
 
+def _detect_test_runner(workspace_root: Path) -> dict:
+    """
+    Detect available test runners in the project.
+
+    Returns dict with:
+      - runner: 'vitest' | 'jest' | 'pytest' | 'none'
+      - bin_path: absolute path to the runner binary (or empty)
+    """
+    import shutil
+
+    # Check node_modules/.bin for JS/TS test runners
+    bin_dir = workspace_root / "node_modules" / ".bin"
+
+    # Check all workspace subdirs too (monorepo support)
+    bin_dirs = [bin_dir]
+    pkg_path = workspace_root / "package.json"
+    if pkg_path.exists():
+        try:
+            pkg = json.loads(pkg_path.read_text(encoding="utf-8"))
+            for ws in pkg.get("workspaces", []):
+                if "*" not in ws:
+                    ws_bin = workspace_root / ws / "node_modules" / ".bin"
+                    if ws_bin.exists():
+                        bin_dirs.append(ws_bin)
+        except Exception:
+            pass
+
+    for bd in bin_dirs:
+        vitest_bin = bd / "vitest"
+        if vitest_bin.exists():
+            return {"runner": "vitest", "bin_path": str(vitest_bin)}
+        jest_bin = bd / "jest"
+        if jest_bin.exists():
+            return {"runner": "jest", "bin_path": str(jest_bin)}
+
+    # Check for pytest
+    if shutil.which("pytest"):
+        return {"runner": "pytest", "bin_path": shutil.which("pytest") or "pytest"}
+
+    return {"runner": "none", "bin_path": ""}
+
+
+def _get_available_devdeps(workspace_root: Path) -> list[str]:
+    """
+    Read package.json devDependencies and dependencies to tell the LLM
+    which packages are actually available for import.
+    """
+    all_deps: set[str] = set()
+
+    # Read root package.json
+    for pkg_file in [workspace_root / "package.json"]:
+        if pkg_file.exists():
+            try:
+                pkg = json.loads(pkg_file.read_text(encoding="utf-8"))
+                all_deps.update(pkg.get("dependencies", {}).keys())
+                all_deps.update(pkg.get("devDependencies", {}).keys())
+
+                # Also check workspace package.json files
+                for ws in pkg.get("workspaces", []):
+                    if "*" not in ws:
+                        ws_pkg = workspace_root / ws / "package.json"
+                        if ws_pkg.exists():
+                            ws_data = json.loads(ws_pkg.read_text(encoding="utf-8"))
+                            all_deps.update(ws_data.get("dependencies", {}).keys())
+                            all_deps.update(ws_data.get("devDependencies", {}).keys())
+            except Exception:
+                pass
+
+    # Filter out build tools that aren't importable in tests
+    non_importable = {"typescript", "vite", "@vitejs/plugin-react", "concurrently"}
+    return sorted(all_deps - non_importable)
+
+
 def _is_command_allowed(cmd: str) -> bool:
     """Check if a command is safe to execute."""
     # Block shell metacharacters in raw command string
@@ -161,12 +249,16 @@ def run_tests(
         f"generating tests for {len(source_files)} file(s)"
     )
 
-    # ── Environment Strategy ──────────────────────────────────────────────
+    # ── Environment Strategy ────────────────────────────────────────────────────────
     from adelie.env_strategy import detect_env, select_strategy, wrap_command, get_current_phase, ensure_env
     env_profile = detect_env(workspace_root)
     env_profile = ensure_env(env_profile, workspace_root)
     env_strategy = select_strategy(env_profile, phase=get_current_phase())
 
+    # ── Detect test runner and available devDependencies ─────────────────
+    test_runner_info = _detect_test_runner(workspace_root)
+    available_devdeps = _get_available_devdeps(workspace_root)
+
     # Read source files for context
     file_contents = []
     for finfo in source_files:
@@ -179,7 +271,20 @@ def run_tests(
             except Exception:
                 pass
 
+    # Build runner info section for prompt
+    runner_section = "## Available Test Environment\n"
+    runner_section += f"Test runner: {test_runner_info['runner']}\n"
+    runner_section += f"Available devDependencies: {', '.join(available_devdeps) if available_devdeps else 'NONE'}\n"
+    runner_section += f"IMPORTANT: You can ONLY import packages listed above. Do NOT import anything else.\n"
+    if test_runner_info['runner'] == 'none':
+        runner_section += (
+            "No test framework is installed. Write tests using ONLY Node.js built-in 'assert' module.\n"
+            "Use require() to import source files with relative paths from the project root.\n"
+            "Test files MUST have .js extension.\n"
+        )
+
     user_prompt = (
+        f"{runner_section}\n"
         f"## Source Files to Test\n\n"
         + "\n\n".join(file_contents)
         + f"\n\n## Max Test Layer: {max_test_layer}\n"
@@ -272,11 +377,23 @@ def run_tests(
             run_cmd = f'{python} -m pytest "{script_path}" -v --tb=short'
         elif lang in ("javascript", "js", "typescript", "ts"):
             ext = script_path.suffix.lower()
-            if ext in (".ts", ".tsx", ".jsx"):
-                # TypeScript/JSX: use npx tsx to execute directly
-                # (vitest's include patterns conflict with Tester AI naming)
-                run_cmd = f'npx tsx "{script_path}"'
+            runner = test_runner_info.get("runner", "none")
+            runner_bin = test_runner_info.get("bin_path", "")
+
+            if runner == "vitest" and runner_bin:
+                run_cmd = f'{runner_bin} run "{script_path}"'
+            elif runner == "jest" and runner_bin:
+                run_cmd = f'{runner_bin} --testMatch "{script_path}"'
+            elif ext in (".ts", ".tsx", ".jsx"):
+                # No test runner for TS/JSX — cannot execute directly.
+                # Skip this test and log a warning.
+                console.print(
+                    f"  [yellow]⚠️  Skipping {name}: .ts/.tsx/.jsx test requires "
+                    f"vitest or jest (not installed)[/yellow]"
+                )
+                continue
             else:
+                # Plain .js — run with node directly
                 run_cmd = f'node "{script_path}"'
         else:
             # Fall back to LLM-provided command if language unknown

package/adelie/env_strategy.py

@@ -245,6 +245,10 @@ def _bootstrap_npm(project_root: Path) -> bool:
       2. npm install --legacy-peer-deps  (dependency conflicts)
       3. npm install --force             (last resort)
 
+    Between each attempt, corrupt node_modules are removed so the next
+    install starts from a clean state (prevents half-installed packages
+    like date-fns with only .d.ts stubs).
+
     Returns True if any attempt succeeded.
     """
     import sys
@@ -255,7 +259,14 @@ def _bootstrap_npm(project_root: Path) -> bool:
         ("npm install --force", "npm install --force"),
     ]
 
-    for label, cmd in strategies:
+    for idx, (label, cmd) in enumerate(strategies):
+        # Clean corrupt node_modules before retry attempts
+        if idx > 0:
+            node_modules = project_root / "node_modules"
+            if node_modules.exists():
+                console.print("  [dim]  🗑️  Removing corrupt node_modules before retry…[/dim]")
+                shutil.rmtree(node_modules, ignore_errors=True)
+
         console.print(f"  [dim]  ▶ {label}…[/dim]")
         try:
             if _win:
@@ -276,8 +287,13 @@ def _bootstrap_npm(project_root: Path) -> bool:
                     timeout=180,
                 )
             if result.returncode == 0:
-                console.print(f"  [green]  ✅ {label} succeeded[/green]")
-                return True
+                # Verify the install actually produced valid modules
+                node_modules = project_root / "node_modules"
+                if node_modules.is_dir():
+                    console.print(f"  [green]  ✅ {label} succeeded[/green]")
+                    return True
+                else:
+                    console.print(f"  [dim]  ⚠️ {label} exited 0 but node_modules missing[/dim]")
             else:
                 stderr_short = result.stderr.strip()[-200:] if result.stderr else ""
                 console.print(f"  [dim]  ⚠️ {label} failed — trying fallback…[/dim]")

package/adelie/harness_manager.py

@@ -129,13 +129,14 @@ CODER TASK RULES FOR MID PHASE:
 - Each task should be self-contained — the coder creates files from scratch.
 - Be SPECIFIC: include exact filenames, tech stack, data models in task descriptions.""",
             "transition_criteria": {
-                "description": "Transition to MID_1 when: core features are implemented, basic tests pass, implementation_plan tasks are mostly complete.",
+                "description": "Transition to MID_1 when: core features are implemented, basic tests pass (>=30%), build succeeds, implementation_plan tasks are mostly complete.",
                 "conditions": {
                     "min_loops": 15,
                     "min_kb_files": 8,
                     "required_files": ["implementation", "test"],
-                    "min_test_pass_rate": 0.0,
+                    "min_test_pass_rate": 0.3,
                     "min_review_score": 4,
+                    "require_build_success": True,
                 },
             },
             "next_phase": "mid_1",
@@ -170,13 +171,14 @@ Your decision criteria in this phase:
 - Use EXPORT for test results and roadmap updates
 - If roadmap has gaps, request updates via kb_updates_needed""",
             "transition_criteria": {
-                "description": "Transition to MID_2 when: tests pass, roadmap is updated, no critical duplicates, operational guide exists.",
+                "description": "Transition to MID_2 when: tests pass (>=50%), build succeeds, roadmap is updated, no critical duplicates, operational guide exists.",
                 "conditions": {
                     "min_loops": 20,
                     "min_kb_files": 10,
                     "required_files": ["operations", "test_result"],
-                    "min_test_pass_rate": 0.3,
+                    "min_test_pass_rate": 0.5,
                     "min_review_score": 5,
+                    "require_build_success": True,
                 },
             },
             "next_phase": "mid_2",
@@ -579,6 +581,7 @@ class HarnessManager:
         test_pass_rate: float = 0.0,
         avg_review_score: float = 0.0,
         loop_multiplier: float = 1.0,
+        build_success: bool = False,
     ) -> str | None:
         """
         Check if conditions for the next phase are met.
@@ -622,6 +625,10 @@ class HarnessManager:
         if avg_review_score < conditions.get("min_review_score", 0):
             return None
 
+        # Check require_build_success
+        if conditions.get("require_build_success", False) and not build_success:
+            return None
+
         return next_phase
 
     def get_phase_order(self) -> list[str]:

package/adelie/orchestrator.py

@@ -276,6 +276,7 @@ class Orchestrator:
             test_pass_rate=test_pass_rate,
             avg_review_score=avg_review_score,
             loop_multiplier=loop_mult,
+            build_success=not bool(self._last_build_errors),
         )
 
     def _save_state(self) -> None:

package/package.json

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