adelie-ai 0.3.5 → 0.3.7

package/README.md

@@ -13,7 +13,7 @@
   <a href="https://www.npmjs.com/package/adelie-ai"><img src="https://img.shields.io/npm/v/adelie-ai?style=flat-square&logo=npm&color=CB3837" alt="npm version" /></a>
   <img src="https://img.shields.io/badge/python-3.10+-3776AB?style=flat-square&logo=python&logoColor=white" alt="Python" />
   <img src="https://img.shields.io/badge/LLM-Gemini%20│%20Ollama-FF6F00?style=flat-square" alt="LLM" />
-  <img src="https://img.shields.io/badge/tests-748%20passing-2EA043?style=flat-square" alt="Tests" />
+  <img src="https://img.shields.io/badge/tests-750%20passing-2EA043?style=flat-square" alt="Tests" />
   <a href="./LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue?style=flat-square" alt="License" /></a>
 </p>
 
@@ -35,7 +35,7 @@
 Adelie is an autonomous AI orchestrator that plans, codes, reviews, tests, deploys, and evolves software projects through a coordinated multi-agent loop. It ships as a single CLI (`npm install -g adelie-ai`) and requires only an LLM provider — no cloud backend, no account.
 
 ```
-    (o_    Adelie v0.3.0
+    (o_    Adelie v0.3.5
     //\    gemini · gemini-2.5-pro
     V_/_   Phase: mid_1 | 🛡️3 📡🟢 🧠12/5
 ```

package/adelie/__init__.py

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

package/adelie/agents/expert_ai.py

@@ -267,178 +267,229 @@ def _get_scaffolding_need() -> str:
     if not project_root.exists():
         return ""
 
-    # Gather existing files for detection
-    existing = set()
-    for f in project_root.iterdir():
-        if f.is_file():
-            existing.add(f.name.lower())
-    src_dir = project_root / "src"
-    if src_dir.exists():
-        for f in src_dir.iterdir():
-            if f.is_file():
-                existing.add(f"src/{f.name}".lower())
-
-    # Define scaffolding checks per project type
     checks: list[dict] = []
 
-    has_tsx = any(f.suffix in (".tsx", ".jsx") for f in project_root.rglob("*") if f.is_file())
-    has_ts = any(f.suffix == ".ts" for f in project_root.rglob("*") if f.is_file())
-    has_pkg = "package.json" in existing
-
-    # ── Framework-aware scaffolding checks ────────────────────────────
-    framework = _detect_framework(project_root)
-
-    if framework == "nextjs":
-        # Next.js needs: package.json, next.config.*, src/app/layout.tsx or pages/
-        entry_files = {
-            "package.json": "Node.js dependencies and scripts (npm run dev, npm run build)",
-        }
-        # Check for app router or pages router
-        has_app_router = (
-            (src_dir / "app" / "layout.tsx").exists()
-            or (src_dir / "app" / "layout.ts").exists()
-            or (src_dir / "app" / "layout.jsx").exists()
-            or (project_root / "app" / "layout.tsx").exists()
-        )
-        has_pages_router = (
-            (src_dir / "pages").exists()
-            or (project_root / "pages").exists()
-        )
-        if not has_app_router and not has_pages_router:
-            entry_files["src/app/layout.tsx"] = "Next.js App Router root layout"
-            entry_files["src/app/page.tsx"] = "Next.js App Router home page"
-
-        for fname, desc in entry_files.items():
-            path = project_root / fname
-            if not path.exists():
-                checks.append({"file": fname, "desc": desc})
-
-    elif framework == "nuxt":
-        entry_files = {
-            "package.json": "Node.js dependencies and scripts",
-        }
-        has_app_vue = (project_root / "app.vue").exists()
-        has_pages = (project_root / "pages").exists()
-        if not has_app_vue and not has_pages:
-            entry_files["app.vue"] = "Nuxt root App component"
-
-        for fname, desc in entry_files.items():
-            path = project_root / fname
-            if not path.exists():
-                checks.append({"file": fname, "desc": desc})
-
-    elif framework == "sveltekit":
-        entry_files = {
-            "package.json": "Node.js dependencies and scripts",
-        }
-        has_routes = (src_dir / "routes").exists()
-        if not has_routes:
-            entry_files["src/routes/+page.svelte"] = "SvelteKit root page"
-
-        for fname, desc in entry_files.items():
-            path = project_root / fname
-            if not path.exists():
-                checks.append({"file": fname, "desc": desc})
-
-    elif framework in ("remix", "angular"):
-        # Minimal checks — just package.json
-        if not (project_root / "package.json").exists():
-            checks.append({"file": "package.json", "desc": "Node.js dependencies and scripts"})
-
-    elif has_tsx or has_ts or has_pkg:
-        # Default: Vite / vanilla React project (original behavior)
-        entry_files = {
-            "index.html": "Vite entry point — must reference src/main.tsx",
-            "package.json": "Node.js dependencies and scripts (npm run build, npm run dev)",
-            "tsconfig.json": "TypeScript compiler configuration",
-        }
-        # Check src/main.tsx or src/main.ts
-        has_main = (
-            (src_dir / "main.tsx").exists()
-            or (src_dir / "main.ts").exists()
-            or (src_dir / "main.jsx").exists()
-            or (src_dir / "main.js").exists()
-            or (src_dir / "index.tsx").exists()
-            or (src_dir / "index.ts").exists()
-        )
-        if not has_main:
-            entry_files["src/main.tsx"] = "React root render — ReactDOM.createRoot + App import"
-
-        has_vite_cfg = (
-            (project_root / "vite.config.ts").exists()
-            or (project_root / "vite.config.js").exists()
-        )
-        if not has_vite_cfg:
-            entry_files["vite.config.ts"] = "Vite build configuration with React plugin"
-
-        for fname, desc in entry_files.items():
-            path = project_root / fname
-            if not path.exists():
-                checks.append({"file": fname, "desc": desc})
-
-    # Python project detection
-    has_py = any(f.suffix == ".py" for f in project_root.rglob("*") if f.is_file())
-    if has_py and not (has_tsx or has_ts or has_pkg):
-        py_entries = {
-            "requirements.txt": "Python dependencies",
-        }
-        for fname, desc in py_entries.items():
-            if not (project_root / fname).exists():
-                checks.append({"file": fname, "desc": desc})
-
-    # ── tsconfig.json deep validation ─────────────────────────────────
-    tsconfig_path = project_root / "tsconfig.json"
-    if tsconfig_path.exists():
+    # Detect workspaces
+    workspaces = []
+    pkg_path = project_root / "package.json"
+    if pkg_path.exists():
         try:
-            # Strip comments (tsconfig allows // comments)
-            raw = tsconfig_path.read_text(encoding="utf-8")
-            # Remove single-line comments
-            import re as _re
-            cleaned = _re.sub(r'//.*$', '', raw, flags=_re.MULTILINE)
-            tsconfig = json.loads(cleaned)
-
-            # Check "references" — e.g. [{"path": "./tsconfig.node.json"}]
-            for ref in tsconfig.get("references", []):
-                ref_path = ref.get("path", "")
-                if ref_path:
-                    ref_file = project_root / ref_path
-                    # If path is a directory, tsconfig.json is implied
-                    if not ref_file.exists() and not ref_file.with_suffix(".json").exists():
-                        checks.append({
-                            "file": ref_path,
-                            "desc": f"Referenced by tsconfig.json — must exist or build fails (TS6053)",
-                        })
+            pkg = json.loads(pkg_path.read_text(encoding="utf-8"))
+            workspaces = pkg.get("workspaces", [])
+            if isinstance(workspaces, dict):
+                workspaces = workspaces.get("packages", [])
+        except Exception:
+            pass
 
-            # Check "extends" — e.g. "./tsconfig.node.json"
-            extends = tsconfig.get("extends", "")
-            if extends and not extends.startswith("@"):
-                ext_file = project_root / extends
-                if not ext_file.exists():
-                    checks.append({
-                        "file": extends,
-                        "desc": f"Extended by tsconfig.json — must exist or build fails",
-                    })
-
-            # Check "compilerOptions.types" → need @types/* in package.json
-            types_list = tsconfig.get("compilerOptions", {}).get("types", [])
-            if types_list and has_pkg:
-                try:
-                    pkg = json.loads((project_root / "package.json").read_text(encoding="utf-8"))
-                    all_deps = set(pkg.get("dependencies", {}).keys())
-                    all_deps |= set(pkg.get("devDependencies", {}).keys())
+    # If no explicit workspaces, check common folders
+    if not workspaces:
+        for folder in ["client", "server", "frontend", "backend"]:
+            if (project_root / folder).exists() and (project_root / folder).is_dir():
+                workspaces.append(folder)
+
+    # We will perform check on each workspace root, or on the project_root if no workspaces
+    targets = []
+    if workspaces:
+        for ws in workspaces:
+            # simple wildcards resolution
+            if "*" in ws or "?" in ws:
+                import glob
+                matched = glob.glob(str(project_root / ws))
+                for m in matched:
+                    targets.append(Path(m))
+            else:
+                ws_path = project_root / ws
+                if ws_path.exists() and ws_path.is_dir():
+                    targets.append(ws_path)
+    
+    if not targets:
+        targets = [project_root]
+
+    for target in targets:
+        # Resolve path relative to project_root to report
+        rel_prefix = ""
+        if target != project_root:
+            rel_prefix = f"{target.relative_to(project_root).as_posix()}/"
+
+        existing = set()
+        for f in target.iterdir():
+            if f.is_file():
+                existing.add(f.name.lower())
+        src_dir = target / "src"
+        if src_dir.exists() and src_dir.is_dir():
+            for f in src_dir.iterdir():
+                if f.is_file():
+                    existing.add(f"src/{f.name}".lower())
+
+        # Check project type for this target
+        has_tsx = any(f.suffix in (".tsx", ".jsx") for f in target.rglob("*") if f.is_file())
+        has_ts = any(f.suffix == ".ts" for f in target.rglob("*") if f.is_file())
+        has_pkg = "package.json" in existing
+
+        framework = _detect_framework(target)
+
+        # If it is a server-only workspace in a monorepo, only check package.json and tsconfig.json
+        is_server_ws = target != project_root and any(x in target.name.lower() for x in ["server", "backend", "api"])
+
+        if is_server_ws:
+            server_files = {
+                "package.json": "Node.js dependencies and scripts",
+            }
+            if has_ts:
+                server_files["tsconfig.json"] = "TypeScript compiler configuration"
+                # Check for src/index.ts or src/main.ts
+                has_server_main = (
+                    (src_dir / "index.ts").exists()
+                    or (src_dir / "main.ts").exists()
+                    or (src_dir / "server.ts").exists()
+                )
+                if not has_server_main:
+                    server_files["src/index.ts"] = "Server entry point"
+
+            for fname, desc in server_files.items():
+                path = target / fname
+                if not path.exists():
+                    checks.append({"file": f"{rel_prefix}{fname}", "desc": desc})
+
+        elif framework == "nextjs":
+            entry_files = {
+                "package.json": "Node.js dependencies and scripts (npm run dev, npm run build)",
+            }
+            has_app_router = (
+                (src_dir / "app" / "layout.tsx").exists()
+                or (src_dir / "app" / "layout.ts").exists()
+                or (src_dir / "app" / "layout.jsx").exists()
+                or (target / "app" / "layout.tsx").exists()
+            )
+            has_pages_router = (
+                (src_dir / "pages").exists()
+                or (target / "pages").exists()
+            )
+            if not has_app_router and not has_pages_router:
+                entry_files["src/app/layout.tsx"] = "Next.js App Router root layout"
+                entry_files["src/app/page.tsx"] = "Next.js App Router home page"
+
+            for fname, desc in entry_files.items():
+                path = target / fname
+                if not path.exists():
+                    checks.append({"file": f"{rel_prefix}{fname}", "desc": desc})
+
+        elif framework == "nuxt":
+            entry_files = {
+                "package.json": "Node.js dependencies and scripts",
+            }
+            has_app_vue = (target / "app.vue").exists()
+            has_pages = (target / "pages").exists()
+            if not has_app_vue and not has_pages:
+                entry_files["app.vue"] = "Nuxt root App component"
+
+            for fname, desc in entry_files.items():
+                path = target / fname
+                if not path.exists():
+                    checks.append({"file": f"{rel_prefix}{fname}", "desc": desc})
+
+        elif framework == "sveltekit":
+            entry_files = {
+                "package.json": "Node.js dependencies and scripts",
+            }
+            has_routes = (src_dir / "routes").exists()
+            if not has_routes:
+                entry_files["src/routes/+page.svelte"] = "SvelteKit root page"
+
+            for fname, desc in entry_files.items():
+                path = target / fname
+                if not path.exists():
+                    checks.append({"file": f"{rel_prefix}{fname}", "desc": desc})
+
+        elif framework in ("remix", "angular"):
+            if not (target / "package.json").exists():
+                checks.append({"file": f"{rel_prefix}package.json", "desc": "Node.js dependencies and scripts"})
+
+        elif has_tsx or has_ts or has_pkg:
+            entry_files = {
+                "index.html": "Vite entry point — must reference src/main.tsx",
+                "package.json": "Node.js dependencies and scripts (npm run build, npm run dev)",
+                "tsconfig.json": "TypeScript compiler configuration",
+            }
+            has_main = (
+                (src_dir / "main.tsx").exists()
+                or (src_dir / "main.ts").exists()
+                or (src_dir / "main.jsx").exists()
+                or (src_dir / "main.js").exists()
+                or (src_dir / "index.tsx").exists()
+                or (src_dir / "index.ts").exists()
+            )
+            if not has_main:
+                entry_files["src/main.tsx"] = "React root render — ReactDOM.createRoot + App import"
 
-                    for type_name in types_list:
-                        types_pkg = f"@types/{type_name}"
-                        if types_pkg not in all_deps:
+            has_vite_cfg = (
+                (target / "vite.config.ts").exists()
+                or (target / "vite.config.js").exists()
+            )
+            if not has_vite_cfg:
+                entry_files["vite.config.ts"] = "Vite build configuration with React plugin"
+
+            for fname, desc in entry_files.items():
+                path = target / fname
+                if not path.exists():
+                    checks.append({"file": f"{rel_prefix}{fname}", "desc": desc})
+
+        # Python project detection
+        has_py = any(f.suffix == ".py" for f in target.rglob("*") if f.is_file())
+        if has_py and not (has_tsx or has_ts or has_pkg):
+            py_entries = {
+                "requirements.txt": "Python dependencies",
+            }
+            for fname, desc in py_entries.items():
+                if not (target / fname).exists():
+                    checks.append({"file": f"{rel_prefix}{fname}", "desc": desc})
+
+        # tsconfig.json deep validation
+        tsconfig_path = target / "tsconfig.json"
+        if tsconfig_path.exists():
+            try:
+                raw = tsconfig_path.read_text(encoding="utf-8")
+                import re as _re
+                cleaned = _re.sub(r'//.*$', '', raw, flags=_re.MULTILINE)
+                tsconfig = json.loads(cleaned)
+
+                for ref in tsconfig.get("references", []):
+                    ref_path = ref.get("path", "")
+                    if ref_path:
+                        ref_file = target / ref_path
+                        if not ref_file.exists() and not ref_file.with_suffix(".json").exists():
                             checks.append({
-                                "file": f"package.json (add {types_pkg})",
-                                "desc": f"tsconfig requires types '{type_name}' but {types_pkg} not in dependencies (TS2688)",
+                                "file": f"{rel_prefix}{ref_path}",
+                                "desc": f"Referenced by tsconfig.json — must exist or build fails (TS6053)",
                             })
-                except Exception:
-                    pass
 
-        except Exception:
-            pass  # tsconfig parse error — skip validation
+                extends = tsconfig.get("extends", "")
+                if extends and not extends.startswith("@"):
+                    ext_file = target / extends
+                    if not ext_file.exists():
+                        checks.append({
+                            "file": f"{rel_prefix}{extends}",
+                            "desc": f"Extended by tsconfig.json — must exist or build fails",
+                        })
+
+                types_list = tsconfig.get("compilerOptions", {}).get("types", [])
+                if types_list and has_pkg:
+                    try:
+                        pkg = json.loads((target / "package.json").read_text(encoding="utf-8"))
+                        all_deps = set(pkg.get("dependencies", {}).keys())
+                        all_deps |= set(pkg.get("devDependencies", {}).keys())
+
+                        for type_name in types_list:
+                            types_pkg = f"@types/{type_name}"
+                            if types_pkg not in all_deps:
+                                checks.append({
+                                    "file": f"{rel_prefix}package.json (add {types_pkg})",
+                                    "desc": f"tsconfig requires types '{type_name}' but {types_pkg} not in dependencies (TS2688)",
+                                })
+                    except Exception:
+                        pass
+            except Exception:
+                pass
 
     if not checks:
         return ""

package/adelie/cli.py

@@ -87,6 +87,8 @@ def main() -> None:
     )
     parser.add_argument("-v", "--version", action="version",
                         version=f"adelie {__version__}")
+    parser.add_argument("--update", action="store_true",
+                        help="Check npm registry and update Adelie to the latest version")
     subparsers = parser.add_subparsers(dest="command", help="Available commands")
 
     # ── help ──────────────────────────────────────────────────────────────────
@@ -279,6 +281,17 @@ def main() -> None:
     # ── Splash screen (no command) ────────────────────────────────────────────
     args = parser.parse_args()
 
+    if getattr(args, "update", False):
+        from adelie.updater import check_for_update, do_update
+        console.print("[cyan]🔍 Checking for updates...[/cyan]")
+        up = check_for_update(__version__, timeout=4.0)
+        if up:
+            console.print(f"[bold yellow]🐧 A new version has been found! (v{up['current']} → v{up['latest']})[/bold yellow]")
+            sys.exit(do_update())
+        else:
+            console.print(f"[green]✅ You are already running the latest version! (v{__version__})[/green]")
+            sys.exit(0)
+
     if not args.command:
         art = Text(_PENGUIN, no_wrap=True)
         info = (
@@ -289,6 +302,16 @@ def main() -> None:
             f"  [dim]adelie <command> --help[/dim]\n"
         )
         console.print(Columns([Padding(art, (0, 1)), info]))
+        
+        # Check for updates with a fast 1.0s timeout to avoid blocking startup
+        try:
+            from adelie.updater import check_for_update, format_update_notice
+            up = check_for_update(__version__, timeout=1.0)
+            if up:
+                console.print(format_update_notice(up["current"], up["latest"]))
+        except Exception:
+            pass
+
         parser.print_help()
         return
 

package/adelie/interactive.py

@@ -229,6 +229,17 @@ class AdelieApp:
             workspace=str(cfg.PROJECT_ROOT),
         )
 
+        # Start async update check in the background
+        try:
+            from adelie import __version__
+            from adelie.updater import check_for_update_async, format_update_notice
+            def _update_callback(result):
+                if result:
+                    self._real_console.print(format_update_notice(result["current"], result["latest"]))
+            check_for_update_async(__version__, _update_callback)
+        except Exception:
+            pass
+
         # Start dashboard server FIRST (so _setup_logger can reference it)
         self._start_dashboard(cfg)
 

package/adelie/updater.py

@@ -62,11 +62,11 @@ def format_update_notice(current: str, latest: str) -> str:
     """Return a cute, Rich-markup update notification string."""
     return (
         f"\n"
-        f"  [bold yellow]꼬르르... 🐧 새 버전이 나왔어요![/bold yellow]\n"
+        f"  [bold yellow]Brrr... 🐧 A new version is available![/bold yellow]\n"
         f"  [dim]v{current}[/dim] → [bold cyan]v{latest}[/bold cyan]  "
-        f"[dim](최신 Adelie 펭귄이 기다리고 있어요)[/dim]\n"
+        f"[dim](A fresh Adelie penguin is waiting for you)[/dim]\n"
         f"\n"
-        f"  [bold]adelie --update[/bold]  [dim]로 업데이트할 수 있어요 ✨[/dim]\n"
+        f"  Run [bold]adelie --update[/bold] to update now ✨\n"
     )
 
 
@@ -80,7 +80,7 @@ def do_update() -> int:
     from rich.console import Console
 
     console = Console()
-    console.print("\n[bold cyan]🐧 Adelie 업데이트 중...[/bold cyan]")
+    console.print("\n[bold cyan]🐧 Updating Adelie...[/bold cyan]")
     console.print("[dim]npm install -g adelie-ai@latest[/dim]\n")
 
     try:
@@ -89,13 +89,13 @@ def do_update() -> int:
             check=False,
         )
         if result.returncode == 0:
-            console.print("\n[bold green]✅ 업데이트 완료! 가장 귀여운 버전이 됐어요 🐧✨[/bold green]")
-            console.print("[dim]다시 실행: adelie --version[/dim]\n")
+            console.print("\n[bold green]✅ Update complete! You are now running the cutest version 🐧✨[/bold green]")
+            console.print("[dim]Check version: adelie --version[/dim]\n")
         else:
-            console.print("\n[bold red]❌ 업데이트 실패했어요.[/bold red]")
-            console.print("[dim]직접 실행해보세요: npm install -g adelie-ai@latest[/dim]\n")
+            console.print("\n[bold red]❌ Update failed.[/bold red]")
+            console.print("[dim]Try running: npm install -g adelie-ai@latest[/dim]\n")
         return result.returncode
     except FileNotFoundError:
-        console.print("[bold red]❌ npm을 찾을 수 없어요.[/bold red]")
-        console.print("[dim]Node.js를 설치한 뒤 다시 시도해주세요: https://nodejs.org[/dim]\n")
+        console.print("[bold red]❌ npm command not found.[/bold red]")
+        console.print("[dim]Please install Node.js and try again: https://nodejs.org[/dim]\n")
         return 1

package/package.json

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