mycode-cli 0.9.4__tar.gz → 0.10.0__tar.gz

{mycode_cli-0.9.4 → mycode_cli-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-cli
-Version: 0.9.4
+Version: 0.10.0
 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
@@ -21,13 +21,13 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development
 Requires-Python: >=3.12
-Requires-Dist: fastapi>0.137
-Requires-Dist: mycode-sdk==0.9.4
-Requires-Dist: prompt-toolkit>=3.0.0
-Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: fastapi>=0.139.0
+Requires-Dist: mycode-sdk==0.10.0
+Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: rich>=15.0.0
-Requires-Dist: typer>=0.26.0
-Requires-Dist: uvicorn[standard]>=0.49.0
+Requires-Dist: typer>=0.26.8
+Requires-Dist: uvicorn[standard]>=0.51.0
 Description-Content-Type: text/markdown
 
 # mycode

{mycode_cli-0.9.4 → mycode_cli-0.10.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling>=1.31.0"]
 build-backend = "hatchling.build"
 
 [project]
 name = "mycode-cli"
-version = "0.9.4"
+version = "0.10.0"
 description = "Minimal coding agent CLI and web UI built on mycode-sdk."
 requires-python = ">=3.12"
 license = "MIT"
@@ -26,13 +26,13 @@ classifiers = [
 ]
 keywords = ["agent", "cli", "llm", "coding-agent", "fastapi"]
 dependencies = [
-    "mycode-sdk==0.9.4",
-    "fastapi>0.137",
-    "uvicorn[standard]>=0.49.0",
+    "mycode-sdk==0.10.0",
+    "fastapi>=0.139.0",
+    "uvicorn[standard]>=0.51.0",
     "rich>=15.0.0",
-    "prompt-toolkit>=3.0.0",
-    "typer>=0.26.0",
-    "pyyaml>=6.0.0",
+    "prompt-toolkit>=3.0.52",
+    "typer>=0.26.8",
+    "pyyaml>=6.0.3",
 ]
 
 [project.scripts]

{mycode_cli-0.9.4 → mycode_cli-0.10.0}/src/mycode_cli/config.py

@@ -413,7 +413,7 @@ def get_settings(cwd: str | None = None) -> Settings:
             if "type" in raw:
                 merged["type"] = raw.get("type") or "anthropic"
             if "models" in raw:
-                merged["models"] = _normalize_models(raw.get("models"))
+                merged["models"] = raw.get("models")
             if "api_key" in raw:
                 api_key, api_key_env_var = _parse_config_api_key(raw.get("api_key"))
                 merged["api_key"] = api_key
@@ -465,7 +465,7 @@ def _load_json(path: Path) -> dict[str, Any] | None:
         return None
     try:
         data = json.loads(path.read_text(encoding="utf-8"))
-    except Exception:
+    except (OSError, UnicodeError, json.JSONDecodeError):
         return None
     return data if isinstance(data, dict) else None
 
@@ -483,9 +483,6 @@ def _normalize_models(value: Any) -> dict[str, ModelConfig]:
         model_id = model.strip()
         if not model_id:
             continue
-        if isinstance(raw, ModelConfig):
-            models[model_id] = raw
-            continue
         raw_config = raw if isinstance(raw, dict) else {}
         models[model_id] = ModelConfig(
             context_window=as_int(raw_config.get("context_window")),
@@ -548,7 +545,7 @@ def provider_has_api_key(provider: ProviderConfig) -> bool:
     """Return whether a configured provider can authenticate right now."""
 
     if provider.api_key_env_var:
-        return bool(_config_api_key_from_env_var(provider))
+        return bool((os.environ.get(provider.api_key_env_var) or "").strip())
     return bool(provider.api_key or provider_api_key_from_env(provider.type))
 
 
@@ -613,20 +610,6 @@ def resolve_provider_choices(settings: Settings) -> list[ResolvedProvider]:
     return choices
 
 
-def _config_api_key_from_env_var(provider: ProviderConfig, *, require: bool = False) -> str | None:
-    env_name = provider.api_key_env_var
-    if not env_name:
-        return None
-
-    value = (os.environ.get(env_name) or "").strip()
-    if value:
-        return value
-
-    if require:
-        raise ValueError(f"missing API key env var {env_name!r} referenced by provider {provider.name!r}")
-    return None
-
-
 def _available_provider_references(settings: Settings) -> list[str]:
     """Return usable provider names with the configured default first."""
 
@@ -723,8 +706,12 @@ def _resolve_provider_runtime(
 
     resolved_api_key = api_key
     if not resolved_api_key and provider_config:
-        if provider_config.api_key_env_var:
-            resolved_api_key = _config_api_key_from_env_var(provider_config, require=True)
+        if env_name := provider_config.api_key_env_var:
+            resolved_api_key = (os.environ.get(env_name) or "").strip()
+            if not resolved_api_key:
+                raise ValueError(
+                    f"missing API key env var {env_name!r} referenced by provider {provider_config.name!r}"
+                )
         elif provider_config.api_key:
             resolved_api_key = provider_config.api_key
     if not resolved_api_key:

{mycode_cli-0.9.4 → mycode_cli-0.10.0}/src/mycode_cli/main.py

@@ -7,7 +7,7 @@ import os
 import sys
 from contextlib import suppress
 from dataclasses import dataclass, replace
-from typing import Annotated, Any
+from typing import Annotated, Any, Literal
 from uuid import uuid4
 
 import typer
@@ -44,8 +44,8 @@ class ResolvedSession:
 
     session_id: str
     session: dict[str, Any]
-    messages: list[dict[str, Any]]
-    mode: str
+    messages: list[ConversationMessage]
+    mode: Literal["new", "resumed"]
 
 
 async def resolve_session(
@@ -59,26 +59,26 @@ async def resolve_session(
 
     if requested_session_id:
         data = await store.load_session(requested_session_id)
-        if not data or not data.get("session"):
+        if data is None:
             raise ValueError(f"Unknown session: {requested_session_id}")
         return ResolvedSession(
             requested_session_id,
-            data.get("session") or {},
-            data.get("messages") or [],
+            data["session"],
+            data["messages"],
             "resumed",
         )
 
     if continue_last:
         latest = await store.latest_session(cwd=cwd)
-        if latest and latest.get("id"):
+        if latest:
             session_id = str(latest["id"])
             data = await store.load_session(session_id)
-            if not data:
+            if data is None:
                 raise ValueError(f"Unknown session: {session_id}")
             return ResolvedSession(
                 session_id,
-                data.get("session") or latest,
-                data.get("messages") or [],
+                data["session"],
+                data["messages"],
                 "resumed",
             )
 
@@ -225,8 +225,7 @@ def chat(
 ) -> None:
     """Interactive coding agent."""
 
-    if version:
-        return
+    del version  # Consumed by the eager --version callback before the body runs.
 
     if ctx.invoked_subcommand is not None:
         return

{mycode_cli-0.9.4 → mycode_cli-0.10.0}/src/mycode_cli/server/app.py

@@ -63,6 +63,3 @@ def create_web_app() -> FastAPI:
 def create_api_app() -> FastAPI:
     """Create the API-only app."""
     return create_app(serve_web=False, cors_origins=DEV_CORS_ORIGINS)
-
-
-app = create_app()

{mycode_cli-0.9.4 → mycode_cli-0.10.0}/src/mycode_cli/server/deps.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import os
-from functools import lru_cache
+from functools import cache
 from typing import Annotated
 
 from fastapi import Depends, HTTPException
@@ -22,14 +22,14 @@ def resolve_workspace_cwd(raw: str | None) -> str:
     return cwd
 
 
-@lru_cache
+@cache
 def get_store() -> SessionStore:
     """Return the shared session store for server requests."""
 
     return SessionStore(data_dir=resolve_sessions_dir())
 
 
-@lru_cache
+@cache
 def get_run_manager() -> RunManager:
     """Return the shared in-process run manager."""
 

{mycode_cli-0.9.4 → mycode_cli-0.10.0}/src/mycode_cli/server/routers/chat.py

@@ -20,6 +20,7 @@ from mycode.attachments import (
     detect_document_mime_type,
     detect_image_mime_type,
 )
+from mycode.compact import has_compactable_history
 from mycode.messages import (
     ConversationMessage,
     build_message,
@@ -42,27 +43,62 @@ from mycode_cli.config import (
 from mycode_cli.permissions import ToolReviewDecision, ToolReviewRequest
 from mycode_cli.runtime import build_agent
 from mycode_cli.server.deps import RunManagerDep, StoreDep, resolve_workspace_cwd
-from mycode_cli.server.run_manager import ActiveRunError, RunManager
+from mycode_cli.server.run_manager import ActiveRunError
 from mycode_cli.server.schemas import (
     CancelRunResponse,
     ChatRequest,
     ChatResponse,
+    CompactRequest,
+    CompactResponse,
     DecideRequest,
     RunInfo,
     StatusResponse,
     StreamEvent,
 )
+from mycode_cli.system_prompt import build_skill_snapshot_blocks, discover_slash_skills
 
 router = APIRouter()
 
 
+def _resolve_workspace_attachment_path(rel_path: str, *, cwd: str) -> Path:
+    base = Path(resolve_path(".", cwd=cwd))
+    path = Path(resolve_path(rel_path, cwd=cwd))
+    if base != path and not path.is_relative_to(base):
+        raise HTTPException(status_code=400, detail=f"path outside workspace: {rel_path}")
+    return path
+
+
+def _read_workspace_text_attachment(rel_path: str, *, name: str | None, cwd: str) -> list[dict[str, Any]]:
+    """Read a workspace text file selected via the @ menu into a `<file>` block.
+
+    Re-validates the path at send time: it must resolve inside ``cwd`` (guards
+    against a symlink swapped in after selection), be a regular file, and be
+    UTF-8 text (image/PDF go through image/document path blocks instead).
+    """
+    path = _resolve_workspace_attachment_path(rel_path, cwd=cwd)
+    if not path.is_file():
+        raise HTTPException(status_code=400, detail=f"text file not found: {rel_path}")
+    if detect_image_mime_type(path) or detect_document_mime_type(path):
+        raise HTTPException(status_code=400, detail=f"not a text file: {rel_path}")
+    try:
+        return build_attachment_blocks([Attachment.path(path, name=name or rel_path)], cwd=cwd)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+
 async def _build_user_message(chat: ChatRequest, cwd: str) -> ConversationMessage:
     if not chat.input:
-        return build_message("user", [text_block(str(chat.message or "").strip())])
+        text = str(chat.message or "").strip()
+        snapshots = await asyncio.to_thread(build_skill_snapshot_blocks, text, cwd)
+        return build_message("user", [*snapshots, text_block(text)])
 
     blocks: list[dict[str, Any]] = []
+    visible_text: list[str] = []
     for block in chat.input:
         if block.type == "text":
+            if block.path:
+                blocks.extend(_read_workspace_text_attachment(block.path, name=block.name, cwd=cwd))
+                continue
             text = block.text or ""
             if block.is_attachment:
                 blocks.extend(
@@ -72,6 +108,7 @@ async def _build_user_message(chat: ChatRequest, cwd: str) -> ConversationMessag
                     )
                 )
             elif text:
+                visible_text.append(text)
                 blocks.append(text_block(text))
             continue
 
@@ -87,7 +124,12 @@ async def _build_user_message(chat: ChatRequest, cwd: str) -> ConversationMessag
 
         # Server-side path: read the bytes and validate the sniffed MIME matches
         # the declared block.type so a request for an "image" can't ship a PDF.
-        path = Path(resolve_path(cast(str, block.path), cwd=cwd))
+        rel_path = cast(str, block.path)
+        path = (
+            _resolve_workspace_attachment_path(rel_path, cwd=cwd)
+            if block.is_attachment
+            else Path(resolve_path(rel_path, cwd=cwd))
+        )
         if not path.is_file():
             raise HTTPException(status_code=400, detail=f"{block.type} file not found: {block.path}")
         detect = detect_image_mime_type if block.type == "image" else detect_document_mime_type
@@ -99,6 +141,8 @@ async def _build_user_message(chat: ChatRequest, cwd: str) -> ConversationMessag
 
     if not blocks:
         raise HTTPException(status_code=400, detail="input must include at least one non-empty block")
+    snapshots = await asyncio.to_thread(build_skill_snapshot_blocks, "\n".join(visible_text), cwd)
+    blocks[:0] = snapshots
     return build_message("user", blocks)
 
 
@@ -196,6 +240,15 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep) -> ChatR
             created = await store.create_session(session_id, cwd=cwd)
             session = created["session"]
 
+        async def review(request: ToolReviewRequest) -> ToolReviewDecision:
+            # Bridge before_tool review waits to SSE events on the active run.
+            return await runs.request_decision(
+                session_id=session_id,
+                tool_call_id=request.tool_call_id,
+                tool_name=request.tool_name,
+                preview=request.preview,
+            )
+
         agent = await asyncio.to_thread(
             build_agent,
             store=store,
@@ -204,7 +257,7 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep) -> ChatR
             resolved_provider=resolved,
             session_id=session_id,
             reasoning_effort=reasoning_effort,
-            review=_make_review(runs, session_id),
+            review=review,
         )
 
         try:
@@ -268,24 +321,63 @@ async def decide_run(
     return StatusResponse(status="ok")
 
 
-def _make_review(runs: RunManager, session_id: str):
-    """Bridge before_tool review waits to SSE events on the active run."""
+@router.post("/sessions/{session_id}/compact")
+async def compact_session(
+    session_id: Annotated[str, PathParam(min_length=1)],
+    body: CompactRequest,
+    store: StoreDep,
+    runs: RunManagerDep,
+) -> CompactResponse:
+    """Start a compact run: summarize the session and append one compact marker."""
+
+    async with runs.session_operation(session_id):
+        active = await runs.active_run_info(session_id)
+        if active:
+            raise HTTPException(
+                status_code=409,
+                detail={"message": "session already has a running task", "run": active},
+            )
+
+        data = await store.load_session(session_id)
+        if data is None:
+            raise HTTPException(status_code=404, detail="session not found")
+        if not has_compactable_history(data["messages"]):
+            raise HTTPException(status_code=400, detail="nothing to compact")
+
+        cwd = str(data["session"]["cwd"])
+        settings = await asyncio.to_thread(get_settings, cwd)
+        resolved = resolve_provider(settings, provider_name=body.provider, model=body.model)
 
-    async def review(request: ToolReviewRequest) -> ToolReviewDecision:
-        return await runs.request_decision(
+        agent = await asyncio.to_thread(
+            build_agent,
+            store=store,
+            cwd=cwd,
+            settings=settings,
+            resolved_provider=resolved,
             session_id=session_id,
-            tool_call_id=request.tool_call_id,
-            tool_name=request.tool_name,
-            preview=request.preview,
         )
 
-    return review
+        try:
+            run = await runs.start_compact(
+                session_id=session_id,
+                base_messages=agent.messages,
+                agent=agent,
+            )
+        except ActiveRunError as exc:
+            existing = await runs.get_run(exc.run_id)
+            detail: dict[str, Any] = {"message": "session already has a running task"}
+            if existing:
+                detail["run"] = existing.info()
+            raise HTTPException(status_code=409, detail=detail) from exc
+
+    return CompactResponse(run=RunInfo.model_validate(run))
 
 
 @router.get("/config")
 async def get_config(cwd: Annotated[str | None, Query()] = None) -> dict[str, Any]:
     resolved_cwd = os.path.abspath(cwd or os.getcwd())
     settings = await asyncio.to_thread(get_settings, resolved_cwd)
+    skills = await asyncio.to_thread(discover_slash_skills, resolved_cwd)
     resolved: ResolvedProvider | None = None
     setup_error: dict[str, str] | None = None
     try:
@@ -360,5 +452,6 @@ async def get_config(cwd: Annotated[str | None, Query()] = None) -> dict[str, An
         "cwd_exists": os.path.isdir(resolved_cwd),
         "project": settings.project,
         "config_paths": settings.config_paths,
+        "skills": [{"name": skill.name, "description": skill.description} for skill in skills],
         "setup_error": setup_error,
     }

{mycode_cli-0.9.4 → mycode_cli-0.10.0}/src/mycode_cli/server/routers/sessions.py

@@ -45,7 +45,7 @@ async def list_sessions(
 ) -> dict[str, Any]:
     sessions = await store.list_sessions(cwd=cwd)
     for session in sessions:
-        session_id = str(session.get("id") or "")
+        session_id = str(session["id"])
         session["is_running"] = await runs.has_active_run(session_id)
     return {"sessions": sessions}
 
@@ -57,22 +57,21 @@ async def load_session(
     """Load a session, overlaying any active in-memory run state."""
 
     data = await store.load_session(session_id)
-    session = data.get("session") if data else None
     active = await runs.snapshot_session(session_id)
     if active:
         return {
-            "session": session,
+            "session": data["session"] if data else None,
             "messages": _redact_document_data(active["messages"]),
             "active_run": active["run"],
             "pending_events": active["pending_events"],
         }
 
-    if not data:
+    if data is None:
         return {"session": None, "messages": [], "active_run": None, "pending_events": []}
 
     return {
-        "session": session,
-        "messages": _redact_document_data(data.get("messages") or []),
+        "session": data["session"],
+        "messages": _redact_document_data(data["messages"]),
         "active_run": None,
         "pending_events": [],
     }

{mycode_cli-0.9.4 → mycode_cli-0.10.0}/src/mycode_cli/server/routers/settings.py

@@ -105,12 +105,13 @@ def _env_presence(raw: dict[str, Any]) -> dict[str, bool]:
 
 def _build_response(path: Path) -> dict[str, Any]:
     raw = _read_raw_config(path)
+    provider_types = list_supported_providers()
     return {
         "path": str(path),
         "exists": path.is_file(),
         "config": _present_config(raw),
         "options": {
-            "provider_types": list(list_supported_providers()),
+            "provider_types": provider_types,
             "permission_levels": list(PERMISSION_LEVEL_OPTIONS),
             "permission_modes": list(PERMISSION_MODE_OPTIONS),
             "reasoning_efforts": list(REASONING_EFFORT_OPTIONS),
@@ -118,13 +119,11 @@ def _build_response(path: Path) -> dict[str, Any]:
         "env": _env_presence(raw),
         "provider_type_env_vars": {
             ptype: list(provider_env_api_key_names(ptype))
-            for ptype in list_supported_providers()
+            for ptype in provider_types
             if provider_env_api_key_names(ptype)
         },
         "provider_type_default_models": {
-            ptype: list(provider_default_models(ptype))
-            for ptype in list_supported_providers()
-            if provider_default_models(ptype)
+            ptype: list(provider_default_models(ptype)) for ptype in provider_types if provider_default_models(ptype)
         },
     }
 

{mycode_cli-0.9.4 → mycode_cli-0.10.0}/src/mycode_cli/server/routers/workspaces.py

@@ -6,8 +6,13 @@ from typing import Annotated
 
 from fastapi import APIRouter, Query
 
+from mycode.attachments import detect_document_mime_type, detect_image_mime_type
+
 router = APIRouter(prefix="/workspaces", tags=["workspaces"])
 
+# Cap on entries returned by /files so a huge directory can't flood the client.
+_FILE_LIST_LIMIT = 100
+
 
 def _parse_workspace_roots() -> list[Path]:
     """Parse allowed workspace roots from environment variables."""
@@ -43,22 +48,14 @@ def browse_workspaces(
     path: Annotated[str | None, Query()] = None,
 ) -> dict[str, object]:
     """Browse directories within a workspace root."""
-    root_path = None
-    requested_root = Path(root).expanduser().resolve(strict=False)
-    for allowed_root in _parse_workspace_roots():
-        if requested_root == allowed_root:
-            root_path = allowed_root
-            break
-
-    if not root_path:
+    root_path = Path(root).expanduser().resolve(strict=False)
+    if root_path not in _parse_workspace_roots():
         return {"root": root, "path": "", "current": "", "entries": [], "error": "Invalid root"}
 
     rel_path = Path(path) if path else Path()
     target = (root_path / rel_path).resolve(strict=False)
 
-    try:
-        target.relative_to(root_path)
-    except ValueError:
+    if not target.is_relative_to(root_path):
         return {
             "root": str(root_path),
             "path": "",
@@ -95,3 +92,66 @@ def get_cwd() -> dict[str, object]:
     """Get current working directory."""
     cwd = os.getcwd()
     return {"cwd": cwd, "exists": Path(cwd).exists()}
+
+
+def _classify_entry(path: Path) -> str:
+    """Coarse attachment kind by magic bytes / extension for the @ menu."""
+    if detect_image_mime_type(path):
+        return "image"
+    if detect_document_mime_type(path):
+        return "document"
+    return "text"
+
+
+@router.get("/files")
+def list_workspace_files(
+    cwd: Annotated[str, Query(min_length=1)],
+    dir: Annotated[str, Query()] = "",
+    prefix: Annotated[str, Query()] = "",
+) -> dict[str, object]:
+    """List files and directories under ``cwd/dir`` for @ attachment completion.
+
+    Directories first, then files, both sorted by name. Dotfiles are included
+    (`.env`, `.github` matter when coding). Entries are filtered by ``prefix``
+    on the server, then capped at 100 with a ``truncated`` flag.
+    """
+    base = Path(cwd).expanduser().resolve(strict=False)
+    if not base.is_dir():
+        return {"entries": [], "truncated": False, "error": "cwd does not exist"}
+
+    target = (base / dir).resolve(strict=False)
+    # Reject traversal outside cwd after resolving symlinks.
+    if target != base and not target.is_relative_to(base):
+        return {"entries": [], "truncated": False, "error": "path outside workspace"}
+    if not target.is_dir():
+        return {"entries": [], "truncated": False, "error": "not a directory"}
+
+    matches: list[tuple[Path, bool]] = []
+    try:
+        for entry in target.iterdir():
+            if prefix and not entry.name.startswith(prefix):
+                continue
+            try:
+                resolved = entry.resolve()
+                if resolved != base and not resolved.is_relative_to(base):
+                    continue
+                is_dir = entry.is_dir()
+            except OSError:
+                continue
+            matches.append((entry, is_dir))
+    except OSError as exc:
+        return {"entries": [], "truncated": False, "error": str(exc)}
+
+    matches.sort(key=lambda item: (not item[1], item[0].name.lower()))
+    truncated = len(matches) > _FILE_LIST_LIMIT
+    entries = []
+    for entry, is_dir in matches[:_FILE_LIST_LIMIT]:
+        rel = entry.relative_to(base).as_posix()
+        entries.append(
+            {
+                "name": entry.name,
+                "path": f"{rel}/" if is_dir else rel,
+                "kind": "directory" if is_dir else _classify_entry(entry),
+            }
+        )
+    return {"entries": entries, "truncated": truncated, "error": ""}