alpiecode 9.0.4__tar.gz → 10.0.0__tar.gz

{alpiecode-9.0.4 → alpiecode-10.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 9.0.4
+Version: 10.0.0
 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-9.0.4 → alpiecode-10.0.0}/pyproject.toml

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

{alpiecode-9.0.4 → alpiecode-10.0.0}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 9.0.4
+Version: 10.0.0
 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-9.0.4 → alpiecode-10.0.0}/src/alpiecode.egg-info/SOURCES.txt

@@ -40,7 +40,10 @@ src/codeagent/backends/base.py
 src/codeagent/backends/local_backend.py
 src/codeagent/backends/openai_backend.py
 src/codeagent/extension/alpiecode.vsix
+test/test_audit_fixes.py
+test/test_chat_mode.py
 test/test_claude_codex_capabilities.py
+test/test_offline_mode.py
 test/test_phase1.py
 test/test_phase2.py
 test/test_phase3.py

{alpiecode-9.0.4 → alpiecode-10.0.0}/src/codeagent/__init__.py

@@ -1,6 +1,7 @@
 import warnings
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 warnings.filterwarnings("ignore", category=FutureWarning)
+warnings.filterwarnings("ignore", category=SyntaxWarning, message=r".*invalid escape sequence.*")
 warnings.filterwarnings("ignore", module="jupyter_client.*")
 
 """
@@ -16,7 +17,7 @@ Supports:
 from pathlib import Path
 from typing import Optional, Any, Dict
 
-__version__ = "9.0.4"
+__version__ = "10.0.0"
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):
     """Run an autonomous coding task programmatically."""

{alpiecode-9.0.4 → alpiecode-10.0.0}/src/codeagent/agent.py

@@ -213,11 +213,15 @@ def run_agent(
     # CLI-as-Client check: auto-detect if local/remote server is running
     from .client import AlpieCodeClient
     target_server = server_url or getattr(cfg, "server_url", None)
-    if not target_server:
-        # Check default local server
-        local_client = AlpieCodeClient("http://127.0.0.1:7169")
-        if local_client.health().get("status") == "online":
-            target_server = "http://127.0.0.1:7169"
+    if not target_server and cfg.base_url != "offline" and not getattr(cfg, "offline", False):
+        # Check default local server (online mode only)
+        try:
+            local_client = AlpieCodeClient("http://127.0.0.1:7169")
+            h = local_client.health()
+            if h.get("status") == "online" and h.get("mode") != "offline":
+                target_server = "http://127.0.0.1:7169"
+        except Exception:
+            pass
 
     if target_server:
         client = AlpieCodeClient(target_server)
@@ -234,7 +238,7 @@ def run_agent(
         backend = resolve_backend(cfg)
         orchestrator = AgentOrchestrator(backend)
         session_mgr = SessionManager()
-        session = session_mgr.create_session(workdir, max_tokens=cfg.n_ctx if not backend.is_available else 262_144)
+        session = session_mgr.create_session(workdir, max_tokens=backend.context_window if hasattr(backend, 'context_window') and backend.context_window else (cfg.n_ctx if cfg.base_url == 'offline' else 262_144))
         event_stream = orchestrator.run_task(
             session=session,
             task=task,
@@ -467,7 +471,7 @@ def run_agent(
     return session.context.messages if "session" in locals() else []
 
 
-def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
+def run_chat(workdir: Path, cfg: Config, verbose: bool = True, debug: bool = False) -> None:
     """Run interactive chat session with Rich presentation."""
     workdir = workdir.resolve()
     _ensure_git(workdir)
@@ -475,7 +479,7 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
     backend = resolve_backend(cfg)
     orchestrator = AgentOrchestrator(backend)
     session_mgr = SessionManager()
-    session = session_mgr.create_session(workdir, max_tokens=cfg.n_ctx if not backend.is_available else 262_144)
+    session = session_mgr.create_session(workdir, max_tokens=backend.context_window if hasattr(backend, 'context_window') and backend.context_window else (cfg.n_ctx if cfg.base_url == 'offline' else 262_144))
 
     is_offline = isinstance(backend, LocalBackend) or not backend.is_available
     active_tools = PromptBuilder().get_tools(is_offline=is_offline)
@@ -513,7 +517,50 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
             console.print("Goodbye! 👋")
             break
 
+        # In-chat slash commands
+        if user_input.lower() in ("/clear", "/reset"):
+            session = session_mgr.create_session(
+                workdir,
+                max_tokens=backend.context_window if hasattr(backend, 'context_window') and backend.context_window else (cfg.n_ctx if cfg.base_url == 'offline' else 262_144)
+            )
+            if HAS_RICH:
+                console.print("[bold green]✨ Conversation context reset.[/bold green]")
+            else:
+                print("✨ Conversation context reset.")
+            continue
+
+        if user_input.lower() in ("/info", "/status"):
+            mode_str = "OFFLINE (Local GGUF)" if is_offline else "ONLINE (Cloud API)"
+            ctx_tokens = backend.context_window if hasattr(backend, 'context_window') and backend.context_window else cfg.n_ctx
+            user_turns = len([m for m in session.context.messages if m.get("role") == "user"])
+            info_msg = (
+                f"[bold]AlpieCode Session Info[/bold]\n"
+                f" • Mode: {mode_str}\n"
+                f" • Working Dir: {workdir}\n"
+                f" • Context Window: {ctx_tokens} tokens\n"
+                f" • Session Turns: {user_turns}"
+            )
+            if HAS_RICH:
+                console.print(Panel(info_msg, border_style="cyan", title="ℹ️ Status"))
+            else:
+                print(info_msg)
+            continue
+
+        if user_input.lower() in ("/help", "/?"):
+            help_msg = (
+                "Available commands:\n"
+                " • /clear, /reset  - Reset conversation memory\n"
+                " • /info, /status  - View current model and session diagnostics\n"
+                " • exit, quit, q   - Exit interactive chat"
+            )
+            if HAS_RICH:
+                console.print(Panel(help_msg, border_style="dim", title="Help"))
+            else:
+                print(help_msg)
+            continue
+
         has_streamed_chat = False
+        has_printed_chat = False
         for event in orchestrator.run_task(session, user_input, cfg):
             if event.type == "token":
                 delta = event.data.get("delta", "")
@@ -521,6 +568,7 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                     sys.stdout.write(delta)
                     sys.stdout.flush()
                     has_streamed_chat = True
+                    has_printed_chat = True
 
             elif event.type == "turn_start" and debug:
                 if HAS_RICH:
@@ -532,7 +580,12 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                 _print_reasoning(event.data["content"])
 
             elif event.type == "tool_call" and verbose:
+                if has_streamed_chat:
+                    sys.stdout.write("\n")
+                    sys.stdout.flush()
+                    has_streamed_chat = False
                 _print_tool_call(event.data["turn"], event.data["name"], event.data["arguments"])
+                has_printed_chat = True
 
             elif event.type == "tool_result":
                 if verbose:
@@ -543,8 +596,9 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                 if has_streamed_chat:
                     sys.stdout.write("\n")
                     has_streamed_chat = False
-                else:
+                elif not has_printed_chat:
                     _print_assistant_message(event.data["content"])
+                has_printed_chat = True
                 _checkpoint(workdir, "checkpoint: done")
 
             elif event.type == "error":
@@ -557,6 +611,7 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                 if has_streamed_chat:
                     sys.stdout.write("\n")
                     has_streamed_chat = False
-                elif event.data.get("summary"):
+                elif not has_printed_chat and event.data.get("summary"):
                     _print_assistant_message(event.data["summary"])
+                    has_printed_chat = True
                 break

alpiecode-10.0.0/src/codeagent/backends/local_backend.py

@@ -0,0 +1,314 @@
+"""
+Local GGUF model inference backend.
+"""
+
+from typing import Any, List, Optional
+
+from ..config import Config
+from ..local_model import LocalModel
+from .base import ChatResponse, ToolCall
+
+
+class LocalBackend:
+    """Backend for local GGUF model inference via llama-cpp-python."""
+
+    def __init__(self, cfg: Config):
+        self._cfg = cfg
+        self._model: Optional[LocalModel] = None
+
+    @property
+    def name(self) -> str:
+        return f"Local GGUF ({self._cfg.model_repo})"
+
+    @property
+    def is_available(self) -> bool:
+        return True  # Local model is always available (downloads if missing)
+
+    @property
+    def context_window(self) -> int:
+        return self._cfg.n_ctx
+
+    def _ensure_model(self) -> LocalModel:
+        if self._model is None:
+            self._model = LocalModel(
+                repo_id=self._cfg.model_repo,
+                n_ctx=self._cfg.n_ctx,
+                n_gpu_layers=self._cfg.n_gpu_layers,
+                token=self._cfg.hf_token,
+            )
+        return self._model
+
+    def load_model(self) -> None:
+        """Explicitly load model into VRAM/RAM (warmup)."""
+        model = self._ensure_model()
+        model.load()
+
+    @staticmethod
+    def _sanitize_messages_for_gguf(messages: List[dict]) -> List[dict]:
+        """
+        Sanitize OpenAI-format messages for GGUF Jinja2 chat templates.
+        Fixes 'Can only get item pairs from a mapping' errors by:
+        - Ensuring content is always a string (never None or list)
+        - Stripping tool_calls and tool messages (GGUF templates don't support them)
+        - Removing tool-related role messages
+        """
+        sanitized = []
+        for msg in messages:
+            role = msg.get("role", "")
+            if role == "tool":
+                # Bridge tool execution results into ChatML user turns so local model sees outputs
+                name = msg.get("name") or "tool"
+                raw_content = msg.get("content") or ""
+                if not isinstance(raw_content, str):
+                    raw_content = str(raw_content)
+                # Smart failure-preserving truncation for local offline context
+                from ..tools import _smart_truncate
+                raw_content = _smart_truncate(raw_content, max_chars=1800)
+
+                tool_text = f"[Tool Result for {name}]:\n{raw_content}"
+                if sanitized and sanitized[-1].get("role") == "user":
+                    sanitized[-1]["content"] += "\n\n" + tool_text
+                else:
+                    sanitized.append({"role": "user", "content": tool_text})
+                continue
+
+            clean = {"role": role}
+
+            # Ensure content is always a string
+            content = msg.get("content")
+            if content is None:
+                content = ""
+            elif isinstance(content, list):
+                # Multimodal content (image_url + text blocks) — extract text parts
+                text_parts = []
+                for part in content:
+                    if isinstance(part, dict):
+                        if part.get("type") == "text":
+                            text_parts.append(part.get("text", ""))
+                    elif isinstance(part, str):
+                        text_parts.append(part)
+                content = "\n".join(text_parts) if text_parts else ""
+            elif not isinstance(content, str):
+                content = str(content)
+
+            # For assistant messages with tool_calls, embed tool call info in content text
+            if role == "assistant" and msg.get("tool_calls"):
+                tc_descriptions = []
+                for tc in msg["tool_calls"]:
+                    if isinstance(tc, dict):
+                        fn = tc.get("function", {})
+                        name = fn.get("name", "unknown")
+                        args = fn.get("arguments", "{}")
+                        tc_descriptions.append(f"[Called tool: {name}({args})]")
+                if tc_descriptions:
+                    content = (content + "\n" + "\n".join(tc_descriptions)).strip()
+                # Do NOT include tool_calls key — GGUF template will crash on it
+
+            clean["content"] = content
+            sanitized.append(clean)
+
+        return sanitized
+
+    def chat_completion(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: float = 0.2,
+        max_tokens: int = 2048,
+        enable_thinking: bool = True,
+    ) -> ChatResponse:
+        model = self._ensure_model()
+        sanitized_msgs = self._sanitize_messages_for_gguf(messages)
+        resp = model.create_chat_completion(
+            messages=sanitized_msgs,
+            tools=tools,
+            tool_choice="auto",
+            temperature=temperature,
+            max_tokens=max_tokens,
+            enable_thinking=enable_thinking,
+        )
+        msg = resp.choices[0].message
+
+        tool_calls = None
+        if msg.tool_calls:
+            import json
+            tool_calls = []
+            for tc in msg.tool_calls:
+                args = tc.function.arguments
+                if isinstance(args, str):
+                    try:
+                        args = json.loads(args or "{}")
+                    except Exception:
+                        args = {}
+                tool_calls.append(
+                    ToolCall(
+                        id=tc.id,
+                        name=tc.function.name,
+                        arguments=args if isinstance(args, dict) else {},
+                    )
+                )
+
+        reasoning = getattr(msg, "reasoning", None) or getattr(msg, "reasoning_content", None)
+
+        return ChatResponse(
+            content=msg.content,
+            reasoning=reasoning,
+            tool_calls=tool_calls,
+            raw=resp,
+        )
+
+    def chat_completion_stream(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        enable_thinking: bool = True,
+    ):
+        """
+        Stream local GGUF completion yielding progressive thinking deltas,
+        content tokens, and the final ChatResponse.
+        """
+        import time
+        start_time = time.time()
+        temp = temperature if temperature is not None else getattr(self._cfg, "temperature", 0.2)
+        m_tokens = max_tokens if max_tokens is not None else getattr(self._cfg, "max_tokens", 2048)
+
+        model = self._ensure_model()
+        sanitized_msgs = self._sanitize_messages_for_gguf(messages)
+
+        chunks = model.create_chat_completion(
+            messages=sanitized_msgs,
+            tools=tools,
+            tool_choice="auto" if tools else None,
+            temperature=temp,
+            max_tokens=m_tokens,
+            enable_thinking=enable_thinking,
+            stream=True,
+        )
+
+        try:
+            from .openai_backend import _repair_and_parse_json_arguments
+        except Exception:
+            import json
+            def _repair_and_parse_json_arguments(raw_args: str) -> dict:
+                try:
+                    return json.loads(raw_args or "{}")
+                except Exception:
+                    return {}
+
+        in_think = enable_thinking
+        think_started = False
+        full_content = []
+        full_reasoning = []
+        tool_calls_dict = {}
+
+        for chunk in chunks:
+            if not chunk or not chunk.get("choices"):
+                continue
+            choice = chunk["choices"][0]
+            delta = choice.get("delta") or {}
+
+            explicit_reasoning = delta.get("reasoning") or delta.get("reasoning_content")
+            if explicit_reasoning:
+                if not think_started:
+                    think_started = True
+                    yield ("thinking_start", {"time": start_time})
+                full_reasoning.append(explicit_reasoning)
+                yield ("thinking_delta", {"delta": explicit_reasoning})
+
+            if delta.get("tool_calls"):
+                for tc in delta["tool_calls"]:
+                    idx = tc.get("index", 0)
+                    if idx not in tool_calls_dict:
+                        fn = tc.get("function") or {}
+                        tool_calls_dict[idx] = {
+                            "id": tc.get("id") or f"call_{idx}",
+                            "name": fn.get("name", ""),
+                            "arguments": fn.get("arguments", ""),
+                        }
+                    else:
+                        if tc.get("id"):
+                            tool_calls_dict[idx]["id"] = tc["id"]
+                        fn = tc.get("function") or {}
+                        if fn.get("name"):
+                            tool_calls_dict[idx]["name"] += fn["name"]
+                        if fn.get("arguments"):
+                            tool_calls_dict[idx]["arguments"] += fn["arguments"]
+
+            text = delta.get("content")
+            if text:
+                if in_think:
+                    if not think_started:
+                        think_started = True
+                        yield ("thinking_start", {"time": start_time})
+
+                    if "</think>" in text:
+                        before, after = text.split("</think>", 1)
+                        if before:
+                            full_reasoning.append(before)
+                            yield ("thinking_delta", {"delta": before})
+                        in_think = False
+                        elapsed = time.time() - start_time
+                        yield ("thinking_end", {"duration": round(elapsed, 1), "content": "".join(full_reasoning).strip()})
+                        if after.strip():
+                            full_content.append(after)
+                            yield ("token", {"delta": after})
+                    elif "DONE:" in text:
+                        before, after = text.split("DONE:", 1)
+                        if before:
+                            full_reasoning.append(before)
+                            yield ("thinking_delta", {"delta": before})
+                        in_think = False
+                        elapsed = time.time() - start_time
+                        yield ("thinking_end", {"duration": round(elapsed, 1), "content": "".join(full_reasoning).strip()})
+                        done_chunk = "DONE:" + after
+                        full_content.append(done_chunk)
+                        yield ("token", {"delta": done_chunk})
+                    else:
+                        clean_text = text.replace("<think>", "")
+                        full_reasoning.append(clean_text)
+                        yield ("thinking_delta", {"delta": clean_text})
+                else:
+                    full_content.append(text)
+                    yield ("token", {"delta": text})
+
+        if in_think and think_started:
+            elapsed = time.time() - start_time
+            yield ("thinking_end", {"duration": round(elapsed, 1), "content": "".join(full_reasoning).strip()})
+
+        tool_calls = None
+        if tool_calls_dict:
+            tool_calls = []
+            for idx in sorted(tool_calls_dict.keys()):
+                item = tool_calls_dict[idx]
+                args = _repair_and_parse_json_arguments(item.get("arguments", ""))
+                tool_calls.append(ToolCall(id=item["id"], name=item["name"], arguments=args))
+
+        final_content_str = "".join(full_content).strip()
+        final_reasoning_str = "".join(full_reasoning).strip()
+
+        if not final_content_str and final_reasoning_str:
+            if "DONE:" in final_reasoning_str:
+                idx = final_reasoning_str.find("DONE:")
+                final_content_str = final_reasoning_str[idx:].strip()
+                final_reasoning_str = final_reasoning_str[:idx].strip()
+                yield ("token", {"delta": final_content_str})
+            elif "</think>" in final_reasoning_str:
+                parts = final_reasoning_str.split("</think>", 1)
+                final_reasoning_str = parts[0].strip()
+                final_content_str = parts[1].strip()
+                yield ("token", {"delta": final_content_str})
+
+        chat_resp = ChatResponse(
+            content=final_content_str,
+            reasoning=final_reasoning_str or None,
+            tool_calls=tool_calls,
+            raw=None,
+        )
+        yield ("done", chat_resp)
+
+    def shutdown(self) -> None:
+        if self._model:
+            self._model._llm = None
+            self._model = None

{alpiecode-9.0.4 → alpiecode-10.0.0}/src/codeagent/cli.py

@@ -41,6 +41,10 @@ def _normalize_args():
     if not subcommand and len(sys.argv) > 1:
         subcommand = "run"
         sys.argv.insert(1, "run")
+    elif subcommand and subcommand not in ("-h", "--help", "-v", "--version") and sys.argv[1] != subcommand:
+        # Move subcommand to index 1 so subparsers parse arguments correctly without default override
+        sys.argv.remove(subcommand)
+        sys.argv.insert(1, subcommand)
 
     if subcommand in ("run", "plan", "explain") and len(sys.argv) > 2:
         cmd_idx = sys.argv.index(subcommand)
@@ -82,6 +86,7 @@ def main():
     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")
+    common.add_argument("--offline", "--local", dest="offline", action="store_true", help="Run using local offline GGUF model on GPU without internet")
 
     from . import __version__
     parser = argparse.ArgumentParser(
@@ -145,13 +150,16 @@ def main():
 
     if args.command == "serve":
         _show_banner()
+        if getattr(args, "offline", False):
+            import os
+            os.environ["ALPIECODE_BASE_URL"] = "offline"
         try:
             from .vscode_installer import ensure_vscode_extension
             ensure_vscode_extension()
         except Exception as e:
             pass
         from .server import run_server
-        run_server(host=args.host, port=args.port)
+        run_server(host=args.host, port=args.port, offline=getattr(args, "offline", False))
         return
 
     # Check for auto-updates from GitHub in background
@@ -164,6 +172,12 @@ def main():
 
     cfg = load_config()
 
+    if getattr(args, "offline", False):
+        cfg.base_url = "offline"
+        cfg.n_ctx = 16384
+        import os
+        os.environ["ALPIECODE_BASE_URL"] = "offline"
+
     if getattr(args, "thinking", False):
         cfg.enable_thinking = True
     elif getattr(args, "no_thinking", False):
@@ -188,7 +202,7 @@ def main():
             cfg.max_turns = args.max_turns
         _show_banner()
         from .agent import run_chat
-        run_chat(Path(args.workdir), cfg, verbose=not args.quiet)
+        run_chat(Path(args.workdir), cfg, verbose=not args.quiet, debug=getattr(args, 'debug', False))
 
     elif args.command == "plan":
         plan_task = (

{alpiecode-9.0.4 → alpiecode-10.0.0}/src/codeagent/client.py

@@ -11,7 +11,7 @@ import urllib.parse
 import urllib.request
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, Iterator, Optional
+from typing import Any, Dict, Iterator, List, Optional
 
 from .orchestrator import AgentEvent
 

{alpiecode-9.0.4 → alpiecode-10.0.0}/src/codeagent/config.py

@@ -30,6 +30,8 @@ DEFAULTS = {
     "temperature": 0.1,
     "max_tokens": 8192,
     "enable_thinking": False,  # Reasoning OFF by default
+    "adaptive_thinking": True,  # Adaptive turn-level reasoning dynamics
+    "force_thinking": False,  # Force reasoning on every single turn
     "n_ctx": 32768,  # 32k context window
     "n_gpu_layers": None,  # None = auto-detect GPU
     "config_version": CONFIG_VERSION,
@@ -92,6 +94,8 @@ class Config:
     temperature: float = 0.1
     max_tokens: int = 8192
     enable_thinking: bool = False
+    adaptive_thinking: bool = True
+    force_thinking: bool = False
     n_ctx: int = 32768
     n_gpu_layers: Optional[int] = None
 
@@ -151,11 +155,13 @@ def load_config() -> Config:
         except ValueError:
             pass
 
-    # For offline mode, optimize default context size to 4096 to prevent VRAM/RAM bottleneck
-    # unless explicitly configured by the user
+    # For offline mode, set high-performance 16k context (16384 tokens) for big multi-file projects
+    # Fits completely in 6GB VRAM on RTX 3050 with zero paging
     if data.get("base_url") == "offline" and not any(os.environ.get(v) for v in ("ALPIECODE_N_CTX", "ALPIECODE_CTX_SIZE")):
-        if data.get("n_ctx") == 32768:
-            data["n_ctx"] = 4096
+        if data.get("n_ctx") in (32768, 4096):
+            data["n_ctx"] = 16384
+        if data.get("max_tokens", 8192) > 4096:
+            data["max_tokens"] = 4096
 
     # Filter data to only keys present in Config fields
     valid_keys = {f.name for f in fields(Config)}

{alpiecode-9.0.4 → alpiecode-10.0.0}/src/codeagent/discovery.py

@@ -220,6 +220,11 @@ def scan_repository(workdir: Path) -> dict:
     Designed to run in under 30ms by checking only key indicator files.
     """
     workdir = workdir.resolve()
+    if not workdir.exists():
+        try:
+            workdir.mkdir(parents=True, exist_ok=True)
+        except Exception:
+            pass
 
     has_git = (workdir / ".git").is_dir()
     has_venv = (workdir / ".venv").is_dir() or (workdir / "venv").is_dir()
@@ -407,7 +412,7 @@ def _has_test_files(workdir: Path) -> bool:
         for f in workdir.iterdir():
             if f.is_file() and (f.name.startswith("test_") or f.name.endswith("_test.py")):
                 return True
-    except PermissionError:
+    except (PermissionError, FileNotFoundError):
         pass
     return False
 
@@ -559,6 +564,7 @@ def gather_relevant_context(
     if getattr(task_context, "intent", "") in ("qa",):
         return None
 
+    task_lower = task.lower().strip()
     sections: List[str] = []
     chars_used = 0