alpiecode 5.0.0__tar.gz → 5.1.1__tar.gz

{alpiecode-5.0.0 → alpiecode-5.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 5.0.0
+Version: 5.1.1
 Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-5.0.0 → alpiecode-5.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "5.0.0"
+version = "5.1.1"
 description = "AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM"
 requires-python = ">=3.9"
 dependencies = [

{alpiecode-5.0.0 → alpiecode-5.1.1}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 5.0.0
+Version: 5.1.1
 Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-5.0.0 → alpiecode-5.1.1}/src/alpiecode.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ src/codeagent/client.py
 src/codeagent/compaction.py
 src/codeagent/config.py
 src/codeagent/context.py
+src/codeagent/discovery.py
 src/codeagent/doctor.py
 src/codeagent/executor.py
 src/codeagent/github.py

{alpiecode-5.0.0 → alpiecode-5.1.1}/src/codeagent/agent.py

@@ -156,6 +156,7 @@ def run_agent(
     github_repo: str = None,
     server_url: str = None,
     complexity: str = None,
+    debug: bool = False,
 ) -> list:
     """Run non-interactive agent task with Rich presentation."""
     workdir = workdir.resolve()
@@ -200,8 +201,27 @@ def run_agent(
     _checkpoint(workdir, "checkpoint: start")
 
     current_turn = 0
+    last_discovery = {}
+
     for event in event_stream:
-        if event.type == "start" and verbose:
+        if event.type == "discovery" and verbose:
+            last_discovery = event.data
+            if debug and HAS_RICH:
+                console.print(Panel(
+                    f"[bold cyan]🔍 Autonomous Discovery Engine[/bold cyan]\n"
+                    f"• Intent: [bold]{event.data.get('intent')}[/bold]\n"
+                    f"• Complexity: [bold]{event.data.get('complexity')}[/bold]\n"
+                    f"• OS: {event.data.get('os')} | Shell: {event.data.get('shell')}\n"
+                    f"• Project: {event.data.get('project_type')} ({event.data.get('file_count', 0)} files)\n"
+                    f"• Frameworks: {', '.join(event.data.get('frameworks', [])) or 'None'}",
+                    title="Pre-Execution Intelligence",
+                    border_style="dim cyan",
+                    padding=(0, 1)
+                ))
+            elif debug:
+                print(f"[Discovery] intent={event.data.get('intent')}, complexity={event.data.get('complexity')}, shell={event.data.get('shell')}, project={event.data.get('project_type')}")
+
+        elif event.type == "start" and verbose:
             data = event.data
             if HAS_RICH:
                 console.rule("[bold blue]Agent Started[/bold blue]")
@@ -223,6 +243,10 @@ def run_agent(
                 comp_label = {"qa": "Q&A (instant)", "low": "Low (fast)", "medium": "Medium (balanced)", "high": "High (thorough)"}.get(comp, comp)
                 comp_color = {"qa": "cyan", "low": "green", "medium": "yellow", "high": "red"}.get(comp, "white")
                 console.print(f"⚡ Complexity: [bold {comp_color}]{comp_label}[/bold {comp_color}]", style="dim")
+                if last_discovery:
+                    intent_str = last_discovery.get('intent', 'create').title()
+                    proj_str = last_discovery.get('project_type', 'empty')
+                    console.print(f"🔍 Discovery: {intent_str} on {proj_str} project ({last_discovery.get('shell', 'bash')})", style="dim")
                 if cfg.enable_thinking:
                     console.print(f"🧠 Reasoning: [bold green]ON[/bold green]", style="dim")
             else:

{alpiecode-5.0.0 → alpiecode-5.1.1}/src/codeagent/cli.py

@@ -81,6 +81,7 @@ def main():
     common.add_argument("--no-thinking", "--non-thinking", dest="no_thinking", action="store_true", help="Disable VLM reasoning mode")
     common.add_argument("--no-update", action="store_true", help="Skip automatic update check")
     common.add_argument("--quiet", action="store_true", help="Suppress per-turn logging")
+    common.add_argument("--debug", action="store_true", help="Show autonomous discovery and debug diagnostics")
 
     parser = argparse.ArgumentParser(
         prog="alpiecode",
@@ -170,6 +171,7 @@ def main():
             video_path=getattr(args, "video", None),
             url=getattr(args, "url", None),
             github_repo=getattr(args, "github", None),
+            debug=getattr(args, "debug", False),
         )
 
     elif args.command == "chat":
@@ -196,6 +198,7 @@ def main():
             video_path=getattr(args, "video", None),
             url=getattr(args, "url", None),
             github_repo=getattr(args, "github", None),
+            debug=getattr(args, "debug", False),
         )
 
     elif args.command == "doctor":
@@ -231,6 +234,7 @@ def main():
             video_path=getattr(args, "video", None),
             url=getattr(args, "url", None),
             github_repo=getattr(args, "github", None),
+            debug=getattr(args, "debug", False),
         )
 
     elif args.command == "diff":

{alpiecode-5.0.0 → alpiecode-5.1.1}/src/codeagent/config.py

@@ -18,7 +18,7 @@ CONFIG_DIR = Path.home() / ".alpiecode"
 CONFIG_PATH = CONFIG_DIR / "config.json"
 
 # Config version — bump this when defaults change to trigger auto-migration
-CONFIG_VERSION = 6  # v6: smart flow, max_turns 20, complexity-aware
+CONFIG_VERSION = 7  # v7: autonomous discovery engine (zero-flag flow)
 
 DEFAULTS = {
     "base_url": "http://20.245.200.125:8000/v1",  # Primary endpoint

alpiecode-5.1.1/src/codeagent/discovery.py

@@ -0,0 +1,572 @@
+"""
+Discovery Engine for AlpieCode -- Zero-LLM Pre-Execution Intelligence.
+
+Runs in under 50ms before the agent turn loop starts. Detects:
+  - Task intent (qa, create, modify, debug, explain)
+  - Environment (OS, shell, Python version, venv, git)
+  - Repository state (project type, frameworks, file count, entry points)
+  - Smart complexity (from intent + repo state combined)
+
+All detection is heuristic/filesystem-based -- no LLM calls, no network.
+"""
+
+import json
+import os
+import platform
+import re
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+
+# -- Task Context ----------------------------------------------------------
+
+@dataclass
+class TaskContext:
+    """Pre-computed intelligence about the task and environment."""
+
+    # Intent
+    intent: str = "create"           # qa, create, modify, debug, explain
+    complexity: str = "low"          # qa, low, medium, high
+
+    # Environment
+    os_name: str = "linux"           # linux, darwin, windows
+    shell: str = "bash"             # bash, powershell, cmd, sh, wsl
+    python_cmd: str = "python3"     # python3 or python (platform-dependent)
+    python_version: str = ""        # e.g. "3.11.2"
+    has_venv: bool = False
+    has_git: bool = False
+
+    # Repository
+    project_type: str = "empty"     # python, node, rust, go, java, empty, unknown
+    frameworks: List[str] = field(default_factory=list)
+    file_count: int = 0
+    has_tests: bool = False
+    entry_points: List[str] = field(default_factory=list)
+    dependencies: List[str] = field(default_factory=list)
+
+    # Budget (computed from complexity)
+    max_turns: int = 10
+    max_tokens: int = 8192
+    tool_set: str = "core"          # none, core, full
+    enable_thinking: bool = False
+
+
+# -- Intent Detection ------------------------------------------------------
+
+# Question patterns -- user wants an answer, not code
+_QA_STARTERS = [
+    "what is", "what are", "what\'s", "what does", "what do",
+    "explain", "how does", "how do", "why does", "why do", "why is",
+    "describe", "define", "compare", "difference between",
+    "tell me about", "who invented", "who created", "when was",
+    "can you explain", "could you explain", "please explain",
+    "what\'s the difference", "is it possible", "is there a way",
+]
+
+# Action verbs that indicate code generation
+_ACTION_VERBS = [
+    "build", "create", "write", "make", "implement", "develop",
+    "generate", "code", "script", "program", "design", "set up",
+    "setup", "scaffold", "bootstrap", "initialize", "init",
+]
+
+# Modification verbs
+_MODIFY_VERBS = [
+    "fix", "add", "modify", "change", "update", "remove", "delete",
+    "refactor", "migrate", "upgrade", "downgrade", "rename",
+    "move", "restructure", "reorganize", "optimize", "improve",
+    "convert", "transform", "replace", "swap",
+]
+
+# Debug verbs
+_DEBUG_VERBS = [
+    "debug", "investigate", "diagnose", "troubleshoot", "trace",
+    "find the bug", "find the error", "find the issue",
+    "why is this", "what\'s wrong", "what is wrong",
+]
+
+# Explain verbs (when target is a file or code)
+_EXPLAIN_VERBS = [
+    "explain this", "explain the", "walk me through",
+    "how does this work", "what does this do",
+    "analyze this", "review this", "read this",
+]
+
+
+def detect_intent(task: str) -> str:
+    """Classify task intent: qa, create, modify, debug, or explain.
+
+    Returns one of: 'qa', 'create', 'modify', 'debug', 'explain'
+    """
+    t = task.lower().strip()
+
+    # Q&A: starts with a question pattern AND has no action verbs
+    all_action = _ACTION_VERBS + _MODIFY_VERBS
+    if any(t.startswith(pat) for pat in _QA_STARTERS):
+        if not any(re.search(r"\b" + re.escape(av) + r"\b", t) for av in all_action):
+            return "qa"
+
+    if t.endswith("?") and not any(re.search(r"\b" + re.escape(av) + r"\b", t) for av in all_action):
+        return "qa"
+
+    # Check if task starts with a create verb ("build a...", "create a...", "write a...")
+    if any(t.startswith(cv) for cv in ["build", "create", "write", "make", "implement", "develop", "generate", "code", "design"]):
+        return "create"
+
+    # Debug: explicitly asking to debug/investigate
+    if any(re.search(r"\b" + re.escape(dv) + r"\b", t) for dv in _DEBUG_VERBS):
+        return "debug"
+
+    # Explain: asking to explain existing code
+    if any(re.search(r"\b" + re.escape(ev) + r"\b", t) for ev in _EXPLAIN_VERBS):
+        return "explain"
+
+    # Modify: acting on existing code (e.g. "refactor", "fix", "update")
+    if any(re.search(r"\b" + re.escape(mv) + r"\b", t) for mv in ["refactor", "migrate", "fix", "update", "modify", "change", "delete", "remove", "rename"]):
+        return "modify"
+
+    # Create: building something new
+    if any(re.search(r"\b" + re.escape(av) + r"\b", t) for av in _ACTION_VERBS):
+        return "create"
+
+    if any(re.search(r"\b" + re.escape(mv) + r"\b", t) for mv in _MODIFY_VERBS):
+        return "modify"
+
+    if t.endswith("?"):
+        return "qa"
+
+    return "create"
+
+
+# -- Environment Detection -------------------------------------------------
+
+def detect_environment() -> dict:
+    """Detect OS, shell, Python version, and runtime environment.
+
+    Returns dict with: os_name, shell, python_cmd, python_version
+    """
+    os_name = platform.system().lower()
+    if os_name == "linux":
+        # Check if we are inside WSL
+        try:
+            with open("/proc/version", "r") as f:
+                version_info = f.read().lower()
+            if "microsoft" in version_info or "wsl" in version_info:
+                os_name = "wsl"
+        except (FileNotFoundError, PermissionError):
+            pass
+
+    # Shell detection
+    shell = _detect_shell(os_name)
+
+    # Python command
+    python_cmd = "python" if os_name == "windows" else "python3"
+
+    # Python version
+    python_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+
+    return {
+        "os_name": os_name if os_name != "wsl" else "linux",
+        "shell": "wsl" if os_name == "wsl" else shell,
+        "python_cmd": python_cmd,
+        "python_version": python_version,
+    }
+
+
+def _detect_shell(os_name: str) -> str:
+    """Detect available shell, preferring WSL on Windows like Claude/Codex agents."""
+
+    if os_name == "windows":
+        # On Windows: prefer WSL (like Claude, Codex, Gemini agents do)
+        if _is_wsl_available():
+            return "wsl"
+        # Fallback to PowerShell
+        if shutil.which("powershell") or shutil.which("pwsh"):
+            return "powershell"
+        return "cmd"
+
+    if os_name in ("linux", "wsl"):
+        return "bash"  # Standard on Linux/WSL
+
+    if os_name == "darwin":
+        return "bash"  # Our commands work on both bash and zsh
+
+    return "sh"
+
+
+def _is_wsl_available() -> bool:
+    """Check if WSL is installed and has at least one working distro."""
+    try:
+        result = subprocess.run(
+            ["wsl", "--list", "--quiet"],
+            capture_output=True, text=True, timeout=3,
+        )
+        return result.returncode == 0 and bool(result.stdout.strip())
+    except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
+        return False
+
+
+# -- Repository Scanner ----------------------------------------------------
+
+def scan_repository(workdir: Path) -> dict:
+    """Quick scan of repository to detect project type, frameworks, etc.
+
+    Designed to run in under 30ms by checking only key indicator files.
+    """
+    workdir = workdir.resolve()
+
+    has_git = (workdir / ".git").is_dir()
+    has_venv = (workdir / ".venv").is_dir() or (workdir / "venv").is_dir()
+
+    # Quick file count (capped scan)
+    file_count = _quick_file_count(workdir, max_files=500)
+
+    # Detect project type and frameworks by checking indicator files
+    project_type, frameworks = _detect_project(workdir)
+
+    # Find entry points
+    entry_points = _find_entry_points(workdir, project_type)
+
+    # Check for tests
+    has_tests = _has_test_files(workdir)
+
+    # Read key dependencies (fast -- just reads manifest files)
+    dependencies = _read_dependencies(workdir, project_type)
+
+    return {
+        "has_git": has_git,
+        "has_venv": has_venv,
+        "file_count": file_count,
+        "project_type": project_type,
+        "frameworks": frameworks,
+        "entry_points": entry_points,
+        "has_tests": has_tests,
+        "dependencies": dependencies,
+    }
+
+
+def _quick_file_count(workdir: Path, max_files: int = 500) -> int:
+    """Count tracked files quickly, respecting .gitignore if possible."""
+    try:
+        result = subprocess.run(
+            ["git", "ls-files", "--cached", "--others", "--exclude-standard"],
+            cwd=workdir, capture_output=True, text=True, timeout=3,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return len(result.stdout.strip().splitlines())
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        pass
+
+    # Fallback: walk directory
+    count = 0
+    skip_dirs = {".git", "node_modules", "__pycache__", ".venv", "venv",
+                 ".tox", "dist", "build", ".eggs", ".mypy_cache"}
+    for root, dirs, files in os.walk(workdir):
+        dirs[:] = [d for d in dirs if d not in skip_dirs and not d.startswith(".")]
+        count += len(files)
+        if count >= max_files:
+            return count
+    return count
+
+
+def _detect_project(workdir: Path) -> Tuple[str, List[str]]:
+    """Detect project type and frameworks from indicator files."""
+    frameworks = []
+
+    # Python indicators
+    has_pyproject = (workdir / "pyproject.toml").exists()
+    has_setup_py = (workdir / "setup.py").exists()
+    has_requirements = (workdir / "requirements.txt").exists()
+    has_pipfile = (workdir / "Pipfile").exists()
+
+    if has_pyproject or has_setup_py or has_requirements or has_pipfile:
+        frameworks = _detect_python_frameworks(workdir)
+        return "python", frameworks
+
+    # Node.js indicators
+    if (workdir / "package.json").exists():
+        frameworks = _detect_node_frameworks(workdir)
+        return "node", frameworks
+
+    # Rust
+    if (workdir / "Cargo.toml").exists():
+        return "rust", []
+
+    # Go
+    if (workdir / "go.mod").exists():
+        return "go", []
+
+    # Java
+    if (workdir / "pom.xml").exists() or (workdir / "build.gradle").exists():
+        return "java", []
+
+    # Check if there are any source files at all
+    for ext in (".py", ".js", ".ts", ".rs", ".go", ".java", ".c", ".cpp"):
+        for _ in workdir.glob(f"*{ext}"):
+            return "unknown", []
+
+    return "empty", []
+
+
+def _detect_python_frameworks(workdir: Path) -> List[str]:
+    """Detect Python frameworks from requirements/pyproject."""
+    frameworks = []
+    content = ""
+
+    for manifest in ["requirements.txt", "pyproject.toml", "setup.py", "Pipfile"]:
+        path = workdir / manifest
+        if path.exists():
+            try:
+                content += path.read_text(errors="replace").lower()
+            except Exception:
+                pass
+
+    framework_map = {
+        "fastapi": "fastapi",
+        "flask": "flask",
+        "django": "django",
+        "pytest": "pytest",
+        "sqlalchemy": "sqlalchemy",
+        "pydantic": "pydantic",
+        "celery": "celery",
+        "redis": "redis",
+        "pymongo": "mongodb",
+        "torch": "pytorch",
+        "tensorflow": "tensorflow",
+        "numpy": "numpy",
+        "pandas": "pandas",
+        "streamlit": "streamlit",
+        "gradio": "gradio",
+    }
+
+    for pkg, name in framework_map.items():
+        if pkg in content:
+            frameworks.append(name)
+
+    return frameworks
+
+
+def _detect_node_frameworks(workdir: Path) -> List[str]:
+    """Detect Node.js frameworks from package.json."""
+    frameworks = []
+    pkg_path = workdir / "package.json"
+    try:
+        data = json.loads(pkg_path.read_text(errors="replace"))
+        all_deps = {}
+        all_deps.update(data.get("dependencies", {}))
+        all_deps.update(data.get("devDependencies", {}))
+
+        framework_map = {
+            "react": "react", "next": "nextjs", "vue": "vue",
+            "angular": "angular", "express": "express",
+            "fastify": "fastify", "nest": "nestjs",
+            "jest": "jest", "mocha": "mocha",
+            "typescript": "typescript",
+        }
+        for pkg, name in framework_map.items():
+            if any(pkg in dep for dep in all_deps):
+                frameworks.append(name)
+    except Exception:
+        pass
+    return frameworks
+
+
+def _find_entry_points(workdir: Path, project_type: str) -> List[str]:
+    """Find likely entry point files."""
+    entry_names = [
+        "main.py", "app.py", "server.py", "manage.py", "run.py",
+        "index.py", "cli.py", "__main__.py",
+        "index.js", "index.ts", "app.js", "app.ts", "server.js", "server.ts",
+        "main.go", "main.rs", "Main.java",
+    ]
+    found = []
+    for name in entry_names:
+        if (workdir / name).exists():
+            found.append(name)
+        # Also check src/ directory
+        if (workdir / "src" / name).exists():
+            found.append(f"src/{name}")
+    return found[:5]
+
+
+def _has_test_files(workdir: Path) -> bool:
+    """Check if the project has test files."""
+    test_indicators = ["tests", "test", "__tests__", "spec"]
+    for d in test_indicators:
+        if (workdir / d).is_dir():
+            return True
+
+    # Check for test_*.py or *_test.py files in root
+    try:
+        for f in workdir.iterdir():
+            if f.is_file() and (f.name.startswith("test_") or f.name.endswith("_test.py")):
+                return True
+    except PermissionError:
+        pass
+    return False
+
+
+def _read_dependencies(workdir: Path, project_type: str) -> List[str]:
+    """Read top-level dependency names (fast, no resolution)."""
+    deps = []
+    if project_type == "python":
+        req_path = workdir / "requirements.txt"
+        if req_path.exists():
+            try:
+                for line in req_path.read_text(errors="replace").splitlines():
+                    line = line.strip()
+                    if line and not line.startswith("#") and not line.startswith("-"):
+                        name = re.split(r"[=<>!~;\[]", line)[0].strip()
+                        if name:
+                            deps.append(name)
+            except Exception:
+                pass
+    return deps[:20]
+
+
+# -- Complexity Engine ------------------------------------------------------
+
+def compute_complexity(intent: str, repo_info: dict, task: str) -> str:
+    """Compute task complexity from intent + repo state + task text.
+
+    This is smarter than pure keyword matching because it considers
+    the actual project context.
+
+    Returns: 'qa', 'low', 'medium', or 'high'
+    """
+    if intent == "qa":
+        return "qa"
+
+    task_lower = task.lower()
+    file_count = repo_info.get("file_count", 0)
+    frameworks = repo_info.get("frameworks", [])
+    project_type = repo_info.get("project_type", "empty")
+
+    # -- HIGH: explicitly complex multi-component tasks --
+    high_keywords = [
+        "full stack", "fullstack", "full-stack",
+        "microservice", "e-commerce", "ecommerce",
+        "docker", "kubernetes", "ci/cd", "pipeline",
+        "machine learning", "deep learning", "neural network",
+        "train a model", "training pipeline",
+        "authentication", "oauth", "jwt auth",
+        "database migration", "schema migration",
+    ]
+    if any(kw in task_lower for kw in high_keywords):
+        return "high"
+
+    # Large codebase + modify/debug -> high
+    if intent in ("modify", "debug") and file_count > 50:
+        if any(kw in task_lower for kw in ["refactor", "restructure", "redesign", "rewrite", "migrate"]):
+            return "high"
+
+    # -- MEDIUM: multi-step tasks --
+    medium_keywords = [
+        "api", "rest api", "graphql", "server",
+        "game", "snake", "tetris", "chess", "pong", "sudoku",
+        "website", "web page", "web app", "webapp",
+        "test suite", "unit tests", "integration test",
+        "dashboard", "portfolio",
+        "react", "vue", "angular", "next.js",
+        "django", "flask app", "fastapi app",
+    ]
+    if any(kw in task_lower for kw in medium_keywords):
+        return "medium"
+
+    # Modify/debug on existing project with frameworks -> medium
+    if intent in ("modify", "debug") and frameworks:
+        return "medium"
+
+    # Modify/debug on project with 10+ files -> medium
+    if intent in ("modify", "debug") and file_count > 10:
+        return "medium"
+
+    # Create on existing project (adding to it) -> medium
+    if intent == "create" and project_type not in ("empty", "unknown") and file_count > 5:
+        return "medium"
+
+    # -- LOW: everything else --
+    return "low"
+
+
+# -- Complexity Configuration -----------------------------------------------
+
+COMPLEXITY_CONFIG = {
+    "qa": {
+        "max_turns": 3,
+        "max_tokens": 4096,
+        "tool_set": "none",
+        "enable_thinking": False,
+    },
+    "low": {
+        "max_turns": 10,
+        "max_tokens": 8192,
+        "tool_set": "core",
+        "enable_thinking": False,
+    },
+    "medium": {
+        "max_turns": 20,
+        "max_tokens": 8192,
+        "tool_set": "full",
+        "enable_thinking": False,
+    },
+    "high": {
+        "max_turns": 40,
+        "max_tokens": 16384,
+        "tool_set": "full",
+        "enable_thinking": True,
+    },
+}
+
+
+# -- Main Entry Point -------------------------------------------------------
+
+def build_task_context(task: str, workdir: Path) -> TaskContext:
+    """Build complete TaskContext by running all discovery phases.
+
+    This is the single entry point -- call this from the orchestrator.
+    Runs in under 50ms total, no LLM calls, no network.
+    """
+    # Phase 1: Intent
+    intent = detect_intent(task)
+
+    # Phase 2: Environment
+    env = detect_environment()
+
+    # Phase 3: Repository scan
+    repo = scan_repository(workdir)
+
+    # Phase 4: Complexity (uses intent + repo)
+    complexity = compute_complexity(intent, repo, task)
+
+    # Phase 5: Budget from complexity
+    budget = COMPLEXITY_CONFIG[complexity]
+
+    return TaskContext(
+        # Intent
+        intent=intent,
+        complexity=complexity,
+        # Environment
+        os_name=env["os_name"],
+        shell=env["shell"],
+        python_cmd=env["python_cmd"],
+        python_version=env["python_version"],
+        has_venv=repo["has_venv"],
+        has_git=repo["has_git"],
+        # Repository
+        project_type=repo["project_type"],
+        frameworks=repo["frameworks"],
+        file_count=repo["file_count"],
+        has_tests=repo["has_tests"],
+        entry_points=repo["entry_points"],
+        dependencies=repo["dependencies"],
+        # Budget
+        max_turns=budget["max_turns"],
+        max_tokens=budget["max_tokens"],
+        tool_set=budget["tool_set"],
+        enable_thinking=budget["enable_thinking"],
+    )

{alpiecode-5.0.0 → alpiecode-5.1.1}/src/codeagent/orchestrator.py

@@ -14,7 +14,8 @@ from .backends.openai_backend import OpenAIBackend
 from .cache import get_cache
 from .config import Config, is_server_reachable
 from .memory import extract_and_save_memories
-from .prompt import PromptBuilder, classify_task, COMPLEXITY_CONFIG
+from .discovery import build_task_context, COMPLEXITY_CONFIG
+from .prompt import PromptBuilder, classify_task
 from .session import Session, SessionManager
 
 
@@ -55,15 +56,25 @@ class AgentOrchestrator:
     ) -> Iterator[AgentEvent]:
         """Run full agent task loop. Yields AgentEvents."""
 
-        # ── Auto-classify complexity if not provided ──
-        if complexity is None:
-            complexity = classify_task(task)
+        # ── Phase 0: Discovery — pre-compute task intelligence ──
+        task_context = build_task_context(task, session.workdir)
+        complexity = task_context.complexity
+
+        yield AgentEvent("discovery", {
+            "intent": task_context.intent,
+            "complexity": task_context.complexity,
+            "os": task_context.os_name,
+            "shell": task_context.shell,
+            "project_type": task_context.project_type,
+            "frameworks": task_context.frameworks,
+            "file_count": task_context.file_count,
+        })
 
         comp_cfg = COMPLEXITY_CONFIG.get(complexity, COMPLEXITY_CONFIG["low"])
 
         # ── Determine effective max_turns and max_tokens ──
-        effective_max_turns = min(cfg.max_turns, comp_cfg["max_turns"])
-        effective_max_tokens = comp_cfg["max_tokens"]
+        effective_max_turns = task_context.max_turns
+        effective_max_tokens = task_context.max_tokens
 
         # User override: if they set --max-turns explicitly, respect it
         if cfg.max_turns != 20:  # 20 is new default, so non-default = explicit
@@ -102,7 +113,8 @@ class AgentOrchestrator:
         # ── Configure tools & system prompt based on complexity ──
         active_tools = self.prompt_builder.get_tools(is_offline=is_offline, complexity=complexity)
         system_prompt = self.prompt_builder.build_system_prompt(
-            session.workdir, is_offline=is_offline, complexity=complexity
+            session.workdir, is_offline=is_offline, complexity=complexity,
+            task_context=task_context,
         )
         session.context.set_system_prompt(system_prompt)
 
@@ -126,7 +138,7 @@ class AgentOrchestrator:
         })
 
         # ── Adaptive thinking ──
-        enable_thinking = cfg.enable_thinking
+        enable_thinking = cfg.enable_thinking or task_context.enable_thinking
         if enable_thinking and complexity in ("qa", "low"):
             enable_thinking = False
             yield AgentEvent("adaptive_mode", {"message": "Simple task detected, skipping deep reasoning."})

{alpiecode-5.0.0 → alpiecode-5.1.1}/src/codeagent/prompt.py

@@ -359,6 +359,89 @@ COMPLEXITY_CONFIG = {
 }
 
 
+
+
+# -- Shell-Aware Prompt Fragments ------------------------------------------
+
+BASH_RULES = """\
+## Shell Environment: Bash (Linux/macOS)
+- You are ALREADY in the project root directory. NEVER run `cd /home/...` or `cd /testbed`
+- Use `&&` to chain commands
+- Use `export VAR=value` for environment variables
+- Use `python3` (not `python` which may be Python 2)
+- For testing python code without extra packages, use `python3 -m unittest`
+- Background processes: `command &` (but AVOID for servers -- use TestClient)
+- File paths use `/` forward slashes
+"""
+
+WSL_RULES = """\
+## Shell Environment: WSL Bash (Windows Subsystem for Linux)
+- You are ALREADY in the project root directory. NEVER run `cd /home/...` or `cd /testbed`
+- Use bash syntax: `&&` to chain, `export VAR=value` for env vars
+- Use `python3` (not `python`)
+- For testing python code, use `python3 -m unittest`
+- The working directory is a Linux path (e.g. /home/user/project)
+- Do NOT use PowerShell or Windows commands (no `dir`, `type`, `$env:`)
+- File paths use `/` forward slashes
+- Network: `localhost` in WSL may differ from Windows -- use `127.0.0.1`
+"""
+
+POWERSHELL_RULES = """\
+## Shell Environment: PowerShell (Windows)
+- Use `;` to chain commands, NOT `&&` (PowerShell does not support `&&`)
+- Use `$env:VAR = "value"` for environment variables, NOT `export VAR=value`
+- Use `python` (not `python3`)
+- Do NOT use `echo -e` or ANSI escapes -- use `Write-Output`
+- Do NOT use `grep` -- use `Select-String` or `findstr`
+- Do NOT use `&` for background processes -- they will fail
+- File paths use `\\` but `/` also works in most cases
+- Do NOT use `curl` -- use `Invoke-WebRequest` or Python's requests/httpx
+"""
+
+REPO_CONTEXT_TEMPLATE = """\
+## Current Project Context
+- Project type: {project_type}
+- Frameworks: {frameworks}
+- Tracked files: {file_count}
+- Entry points: {entry_points}
+- Has tests: {has_tests}
+{extra}"""
+
+INTENT_CREATE = """\
+## Task Intent: Create New Code
+- Write the COMPLETE, WORKING code on Turn 1 using write_file
+- Do NOT explore the filesystem first -- start coding immediately
+- Include ALL imports, ALL functions, ALL logic -- no stubs, no TODOs
+- After writing, run with bash to verify
+- Fix any errors with edit_file, then re-run
+- When everything works: DONE: <summary>
+"""
+
+INTENT_MODIFY = """\
+## Task Intent: Modify Existing Code
+- Turn 1: Use read_file to read the relevant file(s)
+- Turn 2: Use edit_file to make targeted changes
+- Turn 3: Use bash to test the changes
+- Fix any regressions, then: DONE: <summary>
+"""
+
+INTENT_DEBUG = """\
+## Task Intent: Debug / Investigate
+- Turn 1: Reproduce the issue -- run the failing command/test
+- Turn 2: Read error output carefully, use read_file to examine source
+- Turn 3: Fix the root cause with edit_file (not the symptom)
+- Turn 4: Re-run to verify the fix
+- DONE: <summary of what was wrong and how it was fixed>
+"""
+
+INTENT_EXPLAIN = """\
+## Task Intent: Explain / Analyze
+- Read the relevant file(s) with read_file
+- Provide a clear, structured explanation
+- Do NOT modify any files unless explicitly asked
+- DONE: <explanation>
+"""
+
 class PromptBuilder:
     """Constructs system prompts and user content."""
 
@@ -367,7 +450,9 @@ class PromptBuilder:
         workdir: Path,
         is_offline: bool = False,
         complexity: str = "low",
+        task_context=None,
     ) -> str:
+        """Build system prompt, optionally enhanced with TaskContext discovery."""
         if is_offline:
             prompt = OFFLINE_SYSTEM_PROMPT
         elif complexity == "high":
@@ -375,6 +460,47 @@ class PromptBuilder:
         else:
             prompt = SYSTEM_PROMPT
 
+        # -- Inject shell-aware rules from TaskContext --
+        if task_context is not None:
+            shell = getattr(task_context, "shell", "bash")
+            if shell == "powershell":
+                prompt += "\n\n" + POWERSHELL_RULES
+            elif shell == "wsl":
+                prompt += "\n\n" + WSL_RULES
+            elif shell == "bash":
+                prompt += "\n\n" + BASH_RULES
+
+            # Inject repo context (if not an empty dir)
+            if getattr(task_context, "project_type", "empty") != "empty":
+                frameworks_str = ", ".join(task_context.frameworks) if task_context.frameworks else "none detected"
+                entry_str = ", ".join(task_context.entry_points) if task_context.entry_points else "none found"
+                extra_lines = []
+                if task_context.has_venv:
+                    extra_lines.append("- Virtual environment: detected (.venv)")
+                if task_context.dependencies:
+                    extra_lines.append(f"- Key dependencies: {', '.join(task_context.dependencies[:8])}")
+                extra = "\n".join(extra_lines)
+                prompt += "\n\n" + REPO_CONTEXT_TEMPLATE.format(
+                    project_type=task_context.project_type,
+                    frameworks=frameworks_str,
+                    file_count=task_context.file_count,
+                    entry_points=entry_str,
+                    has_tests="yes" if task_context.has_tests else "no",
+                    extra=extra,
+                )
+
+            # Inject intent-specific workflow
+            intent = getattr(task_context, "intent", "create")
+            if intent == "create":
+                prompt += "\n\n" + INTENT_CREATE
+            elif intent == "modify":
+                prompt += "\n\n" + INTENT_MODIFY
+            elif intent == "debug":
+                prompt += "\n\n" + INTENT_DEBUG
+            elif intent == "explain":
+                prompt += "\n\n" + INTENT_EXPLAIN
+            # qa intent: no extra prompt needed (model answers directly)
+
         memories = format_memories_for_prompt(workdir)
         if memories:
             prompt += f"\n\n{memories}"