mycode-cli 0.8.2__tar.gz → 0.8.4__tar.gz

{mycode_cli-0.8.2 → mycode_cli-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-cli
-Version: 0.8.2
+Version: 0.8.4
 Summary: Minimal coding agent CLI and web UI built on mycode-sdk.
 Project-URL: Homepage, https://github.com/legibet/mycode
 Project-URL: Repository, https://github.com/legibet/mycode
@@ -22,7 +22,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development
 Requires-Python: >=3.12
 Requires-Dist: fastapi>=0.115.0
-Requires-Dist: mycode-sdk==0.8.2
+Requires-Dist: mycode-sdk==0.8.4
 Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: rich>=14.2.0

{mycode_cli-0.8.2 → mycode_cli-0.8.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mycode-cli"
-version = "0.8.2"
+version = "0.8.4"
 description = "Minimal coding agent CLI and web UI built on mycode-sdk."
 requires-python = ">=3.12"
 license = "MIT"
@@ -26,7 +26,7 @@ classifiers = [
 ]
 keywords = ["agent", "cli", "llm", "coding-agent", "fastapi"]
 dependencies = [
-    "mycode-sdk==0.8.2",
+    "mycode-sdk==0.8.4",
     "fastapi>=0.115.0",
     "uvicorn[standard]>=0.32.0",
     "rich>=14.2.0",

{mycode_cli-0.8.2 → mycode_cli-0.8.4}/src/mycode_cli/config.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import json
-import logging
 import os
 import re
 from dataclasses import dataclass, field
@@ -60,15 +59,6 @@ class ModelConfig:
     supports_pdf_input: bool | None = None
 
 
-_MODEL_OVERRIDE_KEYS = (
-    "context_window",
-    "max_output_tokens",
-    "supports_reasoning",
-    "supports_image_input",
-    "supports_pdf_input",
-)
-
-
 @dataclass(frozen=True)
 class ProviderConfig:
     name: str
@@ -110,6 +100,7 @@ class ResolvedProvider:
     api_base: str | None
     reasoning_effort: str | None
     provider_name: str | None = None
+    model_config: ModelConfig | None = None
 
 
 def _load_json(path: Path) -> dict[str, Any] | None:
@@ -571,170 +562,5 @@ def _resolve_provider_runtime(
         api_key=resolved_api_key,
         api_base=resolved_api_base,
         reasoning_effort=reasoning_effort,
+        model_config=model_config,
     )
-
-
-def is_api_key_env_ref(value: str) -> str | None:
-    """Return the env var name when ``value`` is a ``${NAME}`` reference."""
-
-    match = _API_KEY_ENV_REF_RE.fullmatch(value.strip())
-    return match.group(1) if match else None
-
-
-def _optional_string(raw: dict[str, Any], key: str, label: str) -> str | None:
-    """Read an optional string field. Returns the trimmed value, or ``None`` when
-    absent / null / empty so callers can simply skip the key."""
-
-    if key not in raw:
-        return None
-    value = raw[key]
-    if value is None or value == "":
-        return None
-    if not isinstance(value, str):
-        raise ValueError(f"{label} must be a string")
-    return value.strip() or None
-
-
-def _validate_default(raw: Any) -> dict[str, Any]:
-    if not isinstance(raw, dict):
-        raise ValueError("default must be an object")
-
-    out: dict[str, Any] = {}
-    for key in ("provider", "model"):
-        value = _optional_string(raw, key, f"default.{key}")
-        if value:
-            out[key] = value
-
-    effort = raw.get("reasoning_effort")
-    if effort not in (None, ""):
-        normalize_reasoning_effort(effort)
-        out["reasoning_effort"] = effort
-
-    ct = raw.get("compact_threshold")
-    if ct is False:
-        out["compact_threshold"] = False
-    elif ct is not None:
-        if isinstance(ct, bool) or not isinstance(ct, int | float) or not 0 <= ct <= 1:
-            raise ValueError("default.compact_threshold must be a number in [0, 1] or false")
-        out["compact_threshold"] = float(ct)
-
-    return out
-
-
-def _validate_permission(raw: Any) -> Any:
-    if isinstance(raw, str):
-        return normalize_permission_level(raw)
-    if not isinstance(raw, dict):
-        raise ValueError("permission must be a string or object")
-
-    out: dict[str, Any] = {}
-    if "level" in raw:
-        out["level"] = normalize_permission_level(raw.get("level"))
-    if "mode" in raw:
-        out["mode"] = normalize_permission_mode(raw.get("mode"))
-    return out
-
-
-def _validate_provider(name: str, raw: Any) -> dict[str, Any]:
-    if not isinstance(raw, dict):
-        raise ValueError(f"provider {name!r} must be an object")
-
-    out: dict[str, Any] = {}
-
-    raw_type = raw.get("type")
-    if raw_type in (None, ""):
-        # Built-in name → type fallback; otherwise the user must spell it out.
-        if not is_supported_provider(name):
-            raise ValueError(f"provider {name!r} must set 'type'")
-    elif not isinstance(raw_type, str):
-        raise ValueError(f"provider {name!r}: type must be a string")
-    elif not is_supported_provider(raw_type):
-        supported = ", ".join(list_supported_providers())
-        raise ValueError(f"provider {name!r}: unsupported type {raw_type!r}; supported: {supported}")
-    else:
-        out["type"] = raw_type
-
-    for key in ("api_key", "base_url"):
-        value = _optional_string(raw, key, f"provider {name!r}: {key}")
-        if value:
-            out[key] = value
-
-    effort = raw.get("reasoning_effort")
-    if effort not in (None, ""):
-        normalize_reasoning_effort(effort)
-        out["reasoning_effort"] = effort
-
-    raw_models = raw.get("models")
-    if raw_models is not None:
-        models = _validate_models(name, raw_models)
-        if models:
-            out["models"] = models
-
-    return out
-
-
-def _validate_models(name: str, raw: Any) -> dict[str, dict[str, Any]]:
-    # Both list (ids only) and dict (id → metadata overrides) are accepted; we
-    # always normalise to the dict form for storage.
-    if isinstance(raw, list):
-        items: list[tuple[Any, Any]] = [(m, None) for m in raw]
-    elif isinstance(raw, dict):
-        items = list(raw.items())
-    else:
-        raise ValueError(f"provider {name!r}: models must be a list or object")
-
-    out: dict[str, dict[str, Any]] = {}
-    for model_id, overrides in items:
-        if not isinstance(model_id, str) or not model_id.strip():
-            raise ValueError(f"provider {name!r}: model id must be a non-empty string")
-        key = model_id.strip()
-        if overrides is None:
-            out[key] = {}
-        elif isinstance(overrides, dict):
-            out[key] = {k: v for k, v in overrides.items() if k in _MODEL_OVERRIDE_KEYS and v is not None}
-        else:
-            raise ValueError(f"provider {name!r}: model {key!r} config must be an object")
-    return out
-
-
-def validate_global_config(data: Any) -> dict[str, Any]:
-    """Validate a raw global config payload. Returns a cleaned dict ready to persist.
-
-    Empty / null fields are dropped. Raises ``ValueError`` on invalid input.
-    """
-
-    if data is None:
-        return {}
-    if not isinstance(data, dict):
-        raise ValueError("config must be an object")
-
-    out: dict[str, Any] = {}
-
-    if data.get("default") is not None:
-        default = _validate_default(data["default"])
-        if default:
-            out["default"] = default
-
-    if data.get("permission") is not None:
-        out["permission"] = _validate_permission(data["permission"])
-
-    raw_providers = data.get("providers")
-    if raw_providers is not None:
-        if not isinstance(raw_providers, dict):
-            raise ValueError("providers must be an object")
-        providers: dict[str, dict[str, Any]] = {}
-        for name, raw in raw_providers.items():
-            if not isinstance(name, str) or not name.strip():
-                raise ValueError("provider name must be a non-empty string")
-            cleaned = name.strip()
-            providers[cleaned] = _validate_provider(cleaned, raw)
-        if providers:
-            out["providers"] = providers
-
-    return out
-
-
-def setup_logging() -> None:
-    """Configure default logging."""
-
-    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")

{mycode_cli-0.8.2 → mycode_cli-0.8.4}/src/mycode_cli/main.py

@@ -6,7 +6,8 @@ import asyncio
 import os
 import sys
 from dataclasses import dataclass, replace
-from typing import Annotated
+from typing import Annotated, Any
+from uuid import uuid4
 
 import typer
 
@@ -24,7 +25,7 @@ from mycode_cli.config import (
 )
 from mycode_cli.permissions import PERMISSION_DENIED_BY_USER_OUTPUT, PERMISSION_DENIED_OUTPUT
 
-from .runtime import ResolvedSession, build_agent, resolve_session
+from .runtime import build_agent
 from .tui.chat import TerminalChat
 from .tui.render import TerminalView
 
@@ -33,6 +34,58 @@ session_app = typer.Typer(help="Session management")
 app.add_typer(session_app, name="session")
 
 
+@dataclass
+class ResolvedSession:
+    """The session selected for the current CLI run.
+
+    `mode` is either `"new"` or `"resumed"`.
+    """
+
+    session_id: str
+    session: dict[str, Any]
+    messages: list[dict[str, Any]]
+    mode: str
+
+
+async def resolve_session(
+    *,
+    store: SessionStore,
+    cwd: str,
+    requested_session_id: str | None,
+    continue_last: bool,
+) -> ResolvedSession:
+    """Resolve which session the CLI should load before starting."""
+
+    if requested_session_id:
+        data = await store.load_session(requested_session_id)
+        if not data or not data.get("session"):
+            raise ValueError(f"Unknown session: {requested_session_id}")
+        return ResolvedSession(
+            requested_session_id,
+            data.get("session") or {},
+            data.get("messages") or [],
+            "resumed",
+        )
+
+    if continue_last:
+        latest = await store.latest_session(cwd=cwd)
+        if latest and latest.get("id"):
+            session_id = str(latest["id"])
+            data = await store.load_session(session_id)
+            if not data:
+                raise ValueError(f"Unknown session: {session_id}")
+            return ResolvedSession(
+                session_id,
+                data.get("session") or latest,
+                data.get("messages") or [],
+                "resumed",
+            )
+
+    # New sessions: the id is allocated here; the on-disk session is created
+    # lazily by Agent.achat on the first persist.
+    return ResolvedSession(uuid4().hex, {}, [], "new")
+
+
 def _show_version(value: bool) -> None:
     if not value:
         return

mycode_cli-0.8.4/src/mycode_cli/runtime.py

@@ -0,0 +1,51 @@
+"""Build an Agent from CLI settings — shared by both the TUI and the web server."""
+
+from __future__ import annotations
+
+from mycode.agent import Agent
+from mycode.session import SessionStore
+from mycode.tools import DEFAULT_TOOL_SPECS
+from mycode_cli.config import ResolvedProvider, Settings
+from mycode_cli.permissions import ToolReviewCallback, build_permission_hooks
+from mycode_cli.system_prompt import build_system_prompt
+
+
+def build_agent(
+    *,
+    store: SessionStore,
+    cwd: str,
+    settings: Settings,
+    resolved_provider: ResolvedProvider,
+    session_id: str,
+    max_turns: int | None = None,
+    reasoning_effort: str | None = None,
+    review: ToolReviewCallback | None = None,
+) -> Agent:
+    """Build an agent from the resolved provider, honoring model config overrides.
+
+    History is auto-loaded from disk when ``session_id`` already exists under
+    the store; callers never pass messages explicitly.
+    """
+
+    model_config = resolved_provider.model_config
+    agent = Agent(
+        model=resolved_provider.model,
+        provider=resolved_provider.provider,
+        cwd=cwd,
+        session_dir=store.data_dir,
+        session_id=session_id,
+        api_key=resolved_provider.api_key,
+        api_base=resolved_provider.api_base,
+        reasoning_effort=reasoning_effort if reasoning_effort is not None else resolved_provider.reasoning_effort,
+        max_tokens=model_config.max_output_tokens if model_config else None,
+        context_window=model_config.context_window if model_config else None,
+        supports_reasoning=model_config.supports_reasoning if model_config else None,
+        supports_image_input=model_config.supports_image_input if model_config else None,
+        supports_pdf_input=model_config.supports_pdf_input if model_config else None,
+        compact_threshold=settings.compact_threshold,
+        max_turns=max_turns,
+        system=build_system_prompt(cwd, settings),
+        tools=DEFAULT_TOOL_SPECS,
+    )
+    agent.hooks = build_permission_hooks(settings, review=review, on_user_denied=agent.cancel)
+    return agent

{mycode_cli-0.8.2 → mycode_cli-0.8.4}/src/mycode_cli/server/app.py

@@ -7,13 +7,10 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 
-from mycode_cli.config import setup_logging
-from mycode_cli.server.routers import (
-    chat_router,
-    sessions_router,
-    settings_router,
-    workspaces_router,
-)
+from mycode_cli.server.routers.chat import router as chat_router
+from mycode_cli.server.routers.sessions import router as sessions_router
+from mycode_cli.server.routers.settings import router as settings_router
+from mycode_cli.server.routers.workspaces import router as workspaces_router
 
 logger = logging.getLogger(__name__)
 
@@ -26,7 +23,7 @@ def web_static_path() -> Path:
 
 def create_app(*, serve_web: bool = True) -> FastAPI:
     """Create the FastAPI app."""
-    setup_logging()
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
     application = FastAPI(title="mycode")
 
     application.add_middleware(

{mycode_cli-0.8.2 → mycode_cli-0.8.4}/src/mycode_cli/server/routers/chat.py

@@ -95,7 +95,12 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep):
     if chat.message and chat.input:
         raise HTTPException(status_code=400, detail="message and input are mutually exclusive")
 
-    if chat.input:
+    if not chat.input:
+        message_text = str(chat.message or "").strip()
+        if not message_text:
+            raise HTTPException(status_code=400, detail="message or input is required")
+        user_message = build_message("user", [text_block(message_text)])
+    else:
         blocks: list[dict[str, Any]] = []
         for block in chat.input:
             if block.type == "text":
@@ -110,59 +115,45 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep):
                     )
                 elif text:
                     blocks.append(text_block(text))
-                continue
 
-            if block.type == "document":
+            elif block.type == "document":
                 if block.data:
                     mime_type = block.mime_type or "application/pdf"
                     if mime_type != "application/pdf":
                         raise HTTPException(status_code=400, detail="unsupported document mime_type")
                     blocks.append(document_block(block.data, mime_type=mime_type, name=block.name or "document.pdf"))
-                    continue
-
-                if not block.path:
-                    raise HTTPException(status_code=400, detail="document input requires path or data")
-                document_path = Path(resolve_path(block.path, cwd=cwd))
-                if not document_path.is_file():
-                    raise HTTPException(status_code=400, detail=f"document file not found: {block.path}")
-                mime_type = block.mime_type or detect_document_mime_type(document_path)
-                if mime_type != "application/pdf":
-                    raise HTTPException(status_code=400, detail=f"unsupported document file: {block.path}")
-                document_data = b64encode(document_path.read_bytes()).decode("utf-8")
-                blocks.append(
-                    document_block(
-                        document_data,
-                        mime_type=mime_type,
-                        name=block.name or document_path.name,
-                    )
-                )
-                continue
-
-            if block.data:
-                if not block.mime_type:
-                    raise HTTPException(status_code=400, detail="image data requires mime_type")
-                blocks.append(image_block(block.data, mime_type=block.mime_type, name=block.name or "image"))
-                continue
+                else:
+                    if not block.path:
+                        raise HTTPException(status_code=400, detail="document input requires path or data")
+                    path = Path(resolve_path(block.path, cwd=cwd))
+                    if not path.is_file():
+                        raise HTTPException(status_code=400, detail=f"document file not found: {block.path}")
+                    mime_type = block.mime_type or detect_document_mime_type(path)
+                    if mime_type != "application/pdf":
+                        raise HTTPException(status_code=400, detail=f"unsupported document file: {block.path}")
+                    data = b64encode(path.read_bytes()).decode("utf-8")
+                    blocks.append(document_block(data, mime_type=mime_type, name=block.name or path.name))
 
-            if not block.path:
-                raise HTTPException(status_code=400, detail="image input requires path or data")
-            image_path = Path(resolve_path(block.path, cwd=cwd))
-            if not image_path.is_file():
-                raise HTTPException(status_code=400, detail=f"image file not found: {block.path}")
-            mime_type = block.mime_type or detect_image_mime_type(image_path)
-            if not mime_type:
-                raise HTTPException(status_code=400, detail=f"unsupported image file: {block.path}")
-            image_data = b64encode(image_path.read_bytes()).decode("utf-8")
-            blocks.append(image_block(image_data, mime_type=mime_type, name=block.name or image_path.name))
+            else:  # image
+                if block.data:
+                    if not block.mime_type:
+                        raise HTTPException(status_code=400, detail="image data requires mime_type")
+                    blocks.append(image_block(block.data, mime_type=block.mime_type, name=block.name or "image"))
+                else:
+                    if not block.path:
+                        raise HTTPException(status_code=400, detail="image input requires path or data")
+                    path = Path(resolve_path(block.path, cwd=cwd))
+                    if not path.is_file():
+                        raise HTTPException(status_code=400, detail=f"image file not found: {block.path}")
+                    mime_type = block.mime_type or detect_image_mime_type(path)
+                    if not mime_type:
+                        raise HTTPException(status_code=400, detail=f"unsupported image file: {block.path}")
+                    data = b64encode(path.read_bytes()).decode("utf-8")
+                    blocks.append(image_block(data, mime_type=mime_type, name=block.name or path.name))
 
         if not blocks:
             raise HTTPException(status_code=400, detail="input must include at least one non-empty block")
         user_message = build_message("user", blocks)
-    else:
-        message_text = str(chat.message or "").strip()
-        if not message_text:
-            raise HTTPException(status_code=400, detail="message or input is required")
-        user_message = build_message("user", [text_block(message_text)])
 
     data = await store.load_session(session_id)
     session = (data or {}).get("session")
@@ -197,8 +188,7 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep):
 
     # Capability check before any disk mutation — a failed check must not
     # leave an empty session on disk or land a premature rewind marker.
-    provider_config = settings.providers.get(resolved.provider_name or "")
-    model_config = provider_config.models.get(resolved.model) if provider_config else None
+    model_config = resolved.model_config
     model_meta = resolve_model_metadata(
         provider=resolved.provider,
         model=resolved.model,