mycode-cli 0.14.2__py3-none-any.whl → 0.15.0__py3-none-any.whl

mycode_cli/config.py

@@ -187,7 +187,7 @@ def parse_compact_threshold(value: Any) -> float | None:
         return None
     threshold = float(value)
 
-    if threshold < 0 or threshold > 1:
+    if not 0 <= threshold <= 1:
         return None
     return threshold
 
@@ -504,45 +504,37 @@ def get_settings(cwd: str | None = None) -> Settings:
         if resolved_path not in config_paths:
             config_paths.append(resolved_path)
 
-        for name, raw in (data.get("providers") or {}).items():
-            if not isinstance(name, str) or not isinstance(raw, dict):
-                continue
-
+        for name, raw in data.get("providers", {}).items():
             merged = dict(raw_providers.get(name, {}))
 
             if "type" in raw:
-                merged["type"] = raw.get("type") or "anthropic"
+                merged["type"] = raw["type"]
             if "models" in raw:
-                merged["models"] = raw.get("models")
+                merged["models"] = raw["models"]
             if "api_key" in raw:
-                api_key, api_key_env_var = _parse_config_api_key(raw.get("api_key"))
+                api_key, api_key_env_var = _parse_config_api_key(raw["api_key"])
                 merged["api_key"] = api_key
                 merged["api_key_env_var"] = api_key_env_var
             if "base_url" in raw:
-                merged["base_url"] = raw.get("base_url") or None
+                merged["base_url"] = raw["base_url"]
             if "supports_reasoning_effort" in raw:
-                merged["supports_reasoning_effort"] = raw.get("supports_reasoning_effort")
+                merged["supports_reasoning_effort"] = raw["supports_reasoning_effort"]
 
             raw_providers[name] = merged
 
-        default = data.get("default")
-        if isinstance(default, dict):
-            if "provider" in default:
-                v = default.get("provider")
-                default_provider = v if isinstance(v, str) else None
-            if "model" in default:
-                v = default.get("model")
-                default_model = v if isinstance(v, str) else None
-            if "compact_threshold" in default:
-                parsed_threshold = parse_compact_threshold(default.get("compact_threshold"))
-                if parsed_threshold is not None:
-                    compact_threshold = parsed_threshold
+        default = data.get("default", {})
+        if "provider" in default:
+            default_provider = default["provider"]
+        if "model" in default:
+            default_model = default["model"]
+        if "compact_threshold" in default:
+            compact_threshold = float(default["compact_threshold"])
 
         if "permission" in data:
             permission = parse_permission(data.get("permission"), permission)
 
-        if data.get("web") is not None:
-            web = _validate_web_config(data["web"])
+        if "web" in data:
+            web = data["web"]
             for key in ("fetch", "search"):
                 if key in web:
                     raw_web[key] = web[key]
@@ -768,14 +760,12 @@ def _available_provider_references(settings: Settings) -> list[str]:
 
     add(settings.default_provider)
 
-    for name, provider in settings.providers.items():
-        if provider_is_available(provider):
-            add(name)
+    for name in settings.providers:
+        add(name)
 
     for provider_id in list_env_discoverable_providers():
-        if provider_id in configured_types_with_credentials or not provider_api_key_from_env(provider_id):
-            continue
-        add(provider_id)
+        if provider_id not in configured_types_with_credentials:
+            add(provider_id)
 
     return available
 

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, Literal
+from typing import TYPE_CHECKING, Annotated, Any, Literal
 from uuid import uuid4
 
 import typer
@@ -28,8 +28,9 @@ from mycode_cli.permissions import PERMISSION_DENIED_BY_USER_OUTPUT, PERMISSION_
 from mycode_cli.sessions import SessionStore
 
 from .runtime import build_agent
-from .tui.chat import TerminalChat
-from .tui.render import TerminalView
+
+if TYPE_CHECKING:
+    from .tui.render import TerminalView
 
 app = typer.Typer(add_completion=False, pretty_exceptions_enable=False)
 session_app = typer.Typer(help="Session management")
@@ -157,6 +158,8 @@ def _bootstrap(
 ) -> _BootstrapContext:
     """Shared setup for the chat and run commands."""
 
+    from .tui.render import TerminalView
+
     if session and continue_last:
         raise typer.BadParameter("--session and --continue are mutually exclusive")
 
@@ -244,6 +247,8 @@ def chat(
     if ctx.invoked_subcommand is not None:
         return
 
+    from .tui.chat import TerminalChat
+
     setup = _bootstrap(
         provider=provider,
         model=model,
@@ -323,6 +328,7 @@ def web(
     resolved_port = port or settings.port
 
     import uvicorn
+    from uvicorn.config import LOGGING_CONFIG
 
     app_factory = "mycode_cli.server.app:create_web_app"
     if dev:
@@ -334,6 +340,11 @@ def web(
         port=resolved_port,
         reload=dev,
         factory=True,
+        timeout_graceful_shutdown=5,
+        log_config={
+            **LOGGING_CONFIG,
+            "root": {"handlers": ["default"], "level": "INFO"},
+        },
     )
 
 
@@ -343,6 +354,8 @@ def session_list(
 ) -> None:
     """List saved sessions."""
 
+    from .tui.render import TerminalView
+
     cwd = os.path.abspath(os.getcwd())
     store = SessionStore(data_dir=resolve_sessions_dir())
     view = TerminalView()

mycode_cli/permissions.py

@@ -13,7 +13,6 @@ from mycode_cli.config import PermissionConfig, PermissionLevel, Settings
 from mycode_cli.system_prompt import discover_skills
 from mycode_cli.workspace import CliDeps, resolve_path
 
-PermissionTier = Literal["readonly", "safe", "standard", "yolo"]
 PermissionDecision = Literal["allow", "ask", "deny"]
 ToolReviewDecision = Literal["allow", "deny"]
 
@@ -54,7 +53,7 @@ _FIND_DANGEROUS_FLAGS = {
 
 
 class PermissionCheck(NamedTuple):
-    tier: PermissionTier
+    tier: PermissionLevel
     preview: str
 
 
@@ -102,10 +101,8 @@ def build_permission_hooks(
     return hooks
 
 
-def permission_decision(permission: PermissionConfig, tier: PermissionTier) -> PermissionDecision:
-    if permission.level == "yolo":
-        return "allow"
-    if tier != "yolo" and _LEVEL_RANK[tier] <= _LEVEL_RANK[permission.level]:
+def permission_decision(permission: PermissionConfig, tier: PermissionLevel) -> PermissionDecision:
+    if _LEVEL_RANK[tier] <= _LEVEL_RANK[permission.level]:
         return "allow"
     return permission.mode
 
@@ -147,7 +144,7 @@ def classify_tool(
     return PermissionCheck("yolo", ctx.tool_name)
 
 
-def _classify_bash(command: str) -> PermissionTier:
+def _classify_bash(command: str) -> PermissionLevel:
     if not command:
         return "yolo"
     # Newlines and shell expansion bypass static analysis; treat as compound.

mycode_cli/runtime.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from mycode.agent import Agent
 from mycode_cli.config import ResolvedProvider, Settings
 from mycode_cli.permissions import ToolReviewCallback, build_permission_hooks
-from mycode_cli.sessions import SessionStore
+from mycode_cli.sessions import SessionStore, sum_session_cost
 from mycode_cli.system_prompt import build_system_prompt
 from mycode_cli.tools import DEFAULT_TOOLS
 from mycode_cli.web_tools import build_web_tools
@@ -24,18 +24,7 @@ async def load_session_cost(store: SessionStore, session_id: str) -> float | Non
     discarded by rewind. Records without a cost are skipped.
     """
 
-    total: float | None = None
-    for message in await store.load_raw_messages(session_id):
-        if message.get("role") not in {"assistant", "compact"}:
-            continue
-        meta = message.get("meta") or {}
-        cost = meta.get("cost")
-        if not isinstance(cost, dict):
-            continue
-        request_total = cost.get("total")
-        if isinstance(request_total, int | float):
-            total = sum_known_costs(total, float(request_total))
-    return total
+    return sum_session_cost(await store.load_raw_messages(session_id))
 
 
 def build_agent(

mycode_cli/server/app.py

@@ -1,20 +1,24 @@
 """FastAPI application entry point."""
 
+import asyncio
 import logging
-from collections.abc import Sequence
+from collections.abc import AsyncGenerator, Sequence
+from contextlib import asynccontextmanager
 from pathlib import Path
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 
+from mycode_cli.config import resolve_sessions_dir
 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
+from mycode_cli.server.run_manager import RunManager
+from mycode_cli.sessions import SessionStore
 
 logger = logging.getLogger(__name__)
-logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
 DEV_CORS_ORIGINS = ("http://localhost:5173", "http://127.0.0.1:5173")
 
 
@@ -24,9 +28,20 @@ def web_static_path() -> Path:
     return Path(__file__).resolve().parent / "static"
 
 
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None]:
+    app.state.store = await asyncio.to_thread(SessionStore, data_dir=resolve_sessions_dir())
+    runs = RunManager()
+    app.state.runs = runs
+    try:
+        yield
+    finally:
+        await runs.aclose()
+
+
 def create_app(*, serve_web: bool = True, cors_origins: Sequence[str] = ()) -> FastAPI:
     """Create the FastAPI app."""
-    application = FastAPI(title="mycode")
+    application = FastAPI(title="mycode", lifespan=lifespan)
 
     if cors_origins:
         application.add_middleware(

mycode_cli/server/deps.py

@@ -3,12 +3,10 @@
 from __future__ import annotations
 
 import os
-from functools import cache
-from typing import Annotated
+from typing import Annotated, cast
 
-from fastapi import Depends, HTTPException
+from fastapi import Depends, HTTPException, Request
 
-from mycode_cli.config import resolve_sessions_dir
 from mycode_cli.server.run_manager import RunManager
 from mycode_cli.sessions import SessionStore
 
@@ -22,18 +20,16 @@ def resolve_workspace_cwd(raw: str | None) -> str:
     return cwd
 
 
-@cache
-def get_store() -> SessionStore:
-    """Return the shared session store for server requests."""
+async def get_store(request: Request) -> SessionStore:
+    """Return this application's session store."""
 
-    return SessionStore(data_dir=resolve_sessions_dir())
+    return cast(SessionStore, request.app.state.store)
 
 
-@cache
-def get_run_manager() -> RunManager:
-    """Return the shared in-process run manager."""
+async def get_run_manager(request: Request) -> RunManager:
+    """Return this application's run manager."""
 
-    return RunManager()
+    return cast(RunManager, request.app.state.runs)
 
 
 StoreDep = Annotated[SessionStore, Depends(get_store)]

mycode_cli/server/routers/chat.py

@@ -63,7 +63,7 @@ router = APIRouter()
 def _resolve_workspace_attachment_path(rel_path: str, *, cwd: str) -> Path:
     base = resolve_path(".", cwd=cwd)
     path = resolve_path(rel_path, cwd=cwd)
-    if base != path and not path.is_relative_to(base):
+    if not path.is_relative_to(base):
         raise HTTPException(status_code=400, detail=f"path outside workspace: {rel_path}")
     return path
 
@@ -97,7 +97,9 @@ async def _build_user_message(chat: ChatRequest, cwd: str) -> ConversationMessag
     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))
+                blocks.extend(
+                    await asyncio.to_thread(_read_workspace_text_attachment, block.path, name=block.name, cwd=cwd)
+                )
                 continue
             text = block.text or ""
             if block.is_attachment:
@@ -145,11 +147,8 @@ def _validate_rewind_request(
     *,
     session: dict[str, Any] | None,
     messages: list[ConversationMessage],
-    rewind_to: int | None,
+    rewind_to: int,
 ) -> None:
-    if rewind_to is None:
-        return
-
     if session is None:
         raise HTTPException(status_code=400, detail="rewind_to requires an existing session")
 
@@ -236,10 +235,11 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep) -> ChatR
                 detail={"message": "session already has a running task", "run": active},
             )
 
-        data = await store.load_session(session_id)
-        session = cast(dict[str, Any] | None, data["session"] if data else None)
-        existing_messages = data["messages"] if data else []
-        _validate_rewind_request(session=session, messages=existing_messages, rewind_to=chat.rewind_to)
+        if chat.rewind_to is not None:
+            data = await store.load_session(session_id)
+            session = cast(dict[str, Any] | None, data["session"] if data else None)
+            existing_messages = data["messages"] if data else []
+            _validate_rewind_request(session=session, messages=existing_messages, rewind_to=chat.rewind_to)
 
         # All validation passed. Land the rewind marker (if any) and register
         # the user turn in the catalog: first turn creates the entry and sets
@@ -374,6 +374,7 @@ async def compact_session(
                 session_id=session_id,
                 base_messages=agent.messages,
                 agent=agent,
+                session_cost_base=data["session_cost"],
                 on_complete=store.touch,
             )
         except ActiveRunError as exc:

mycode_cli/server/routers/sessions.py

@@ -9,7 +9,6 @@ from fastapi import APIRouter, HTTPException, Query
 from fastapi import Path as PathParam
 
 from mycode.messages import ConversationMessage
-from mycode_cli.runtime import load_session_cost
 from mycode_cli.server.deps import RunManagerDep, StoreDep, resolve_workspace_cwd
 from mycode_cli.server.schemas import SessionCreateRequest, StatusResponse
 
@@ -57,19 +56,18 @@ async def load_session(
 ) -> dict[str, Any]:
     """Load a session, overlaying any active in-memory run state."""
 
-    data = await store.load_session(session_id)
-    # Folded from the raw JSONL: counts everything persisted so far, including
-    # rewound-away turns. During an active run the SSE usage events supersede it.
-    session_cost = await load_session_cost(store, session_id)
-    active = await runs.snapshot_session(session_id)
-    if active:
-        return {
-            "session": data["session"] if data else None,
-            "messages": _redact_document_data(active["messages"]),
-            "session_cost": session_cost,
-            "active_run": active["run"],
-            "pending_events": active["pending_events"],
-        }
+    async with runs.session_operation(session_id):
+        active = await runs.snapshot_session(session_id)
+        if active:
+            return {
+                "session": await store.load_metadata(session_id),
+                "messages": _redact_document_data(active["messages"]),
+                "session_cost": active["session_cost"],
+                "active_run": active["run"],
+                "pending_events": active["pending_events"],
+            }
+
+        data = await store.load_session(session_id)
 
     if data is None:
         return {"session": None, "messages": [], "session_cost": None, "active_run": None, "pending_events": []}
@@ -77,7 +75,7 @@ async def load_session(
     return {
         "session": data["session"],
         "messages": _redact_document_data(data["messages"]),
-        "session_cost": session_cost,
+        "session_cost": data["session_cost"],
         "active_run": None,
         "pending_events": [],
     }

mycode_cli/server/routers/settings.py

@@ -168,14 +168,16 @@ def put_settings_endpoint(payload: SettingsRequest) -> dict[str, Any]:
     # Three-state api_key merge: when the UI sends null / omits it, we copy the
     # existing literal forward so secrets survive a save without round-tripping.
     existing_providers = existing.get("providers") or {}
-    for name, entry in (incoming.get("providers") or {}).items():
-        if not isinstance(entry, dict) or entry.get("api_key") is not None:
-            continue
-        prior = existing_providers.get(name) if isinstance(existing_providers, dict) else None
-        if isinstance(prior, dict) and "api_key" in prior:
-            entry["api_key"] = prior["api_key"]
-        else:
-            entry.pop("api_key", None)
+    incoming_providers = incoming.get("providers")
+    if isinstance(incoming_providers, dict):
+        for name, entry in incoming_providers.items():
+            if not isinstance(entry, dict) or entry.get("api_key") is not None:
+                continue
+            prior = existing_providers.get(name) if isinstance(existing_providers, dict) else None
+            if isinstance(prior, dict) and "api_key" in prior:
+                entry["api_key"] = prior["api_key"]
+            else:
+                entry.pop("api_key", None)
 
     existing_web = existing.get("web") or {}
     incoming_web = incoming.get("web") or {}

mycode_cli/server/routers/workspaces.py

@@ -121,7 +121,7 @@ def list_workspace_files(
 
     target = (base / dir).resolve(strict=False)
     # Reject traversal outside cwd after resolving symlinks.
-    if target != base and not target.is_relative_to(base):
+    if 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"}
@@ -133,7 +133,7 @@ def list_workspace_files(
                 continue
             try:
                 resolved = entry.resolve()
-                if resolved != base and not resolved.is_relative_to(base):
+                if not resolved.is_relative_to(base):
                     continue
                 is_dir = entry.is_dir()
             except OSError:

mycode_cli/server/run_manager.py

@@ -6,15 +6,17 @@ import asyncio
 import copy
 import time
 from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable
-from contextlib import asynccontextmanager, suppress
+from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from typing import Any, Literal, Protocol
 from uuid import uuid4
+from weakref import WeakValueDictionary
 
 from mycode.agent import Event
 from mycode.messages import ConversationMessage
 from mycode_cli.permissions import ToolReviewDecision
 from mycode_cli.runtime import sum_known_costs
+from mycode_cli.sessions import sum_session_cost
 
 RunStatus = Literal["running", "completed", "failed", "cancelled"]
 RunKind = Literal["chat", "compact"]
@@ -60,9 +62,9 @@ class RunState:
     agent: RunAgent
     kind: RunKind = "chat"
     user_message: ConversationMessage | None = None
-    # Session cost before this run (folded from the session JSONL by the chat
-    # router); None means unknown. Composed with each usage event's turn cost.
+    # Fixed history cost, combined with cumulative turn costs on each update.
     session_cost_base: float | None = None
+    session_cost: float | None = None
     on_complete: RunCompletionCallback | None = None
     status: RunStatus = "running"
     error: str | None = None
@@ -97,7 +99,7 @@ class RunManager:
         self._lock = asyncio.Lock()
         self._active_by_session: dict[str, RunState] = {}
         self._runs_by_id: dict[str, RunState] = {}
-        self._session_locks: dict[str, asyncio.Lock] = {}
+        self._session_locks: WeakValueDictionary[str, asyncio.Lock] = WeakValueDictionary()
 
     async def start_run(
         self,
@@ -123,6 +125,7 @@ class RunManager:
         session_id: str,
         base_messages: list[ConversationMessage],
         agent: RunAgent,
+        session_cost_base: float | None = None,
         on_complete: RunCompletionCallback | None = None,
     ) -> dict[str, Any]:
         return await self._start(
@@ -131,6 +134,7 @@ class RunManager:
             user_message=None,
             base_messages=base_messages,
             agent=agent,
+            session_cost_base=session_cost_base,
             on_complete=on_complete,
         )
 
@@ -158,6 +162,7 @@ class RunManager:
                 kind=kind,
                 user_message=copy.deepcopy(user_message),
                 session_cost_base=session_cost_base,
+                session_cost=session_cost_base,
                 base_messages=copy.deepcopy(base_messages),
                 agent=agent,
                 on_complete=on_complete,
@@ -182,6 +187,8 @@ class RunManager:
             return None
 
         async with state.condition:
+            if state.status != "running":
+                return None
             messages = copy.deepcopy(state.base_messages)
             if state.user_message is not None:
                 messages.append(copy.deepcopy(state.user_message))
@@ -189,10 +196,12 @@ class RunManager:
                 "run": state.info(),
                 "messages": messages,
                 "pending_events": list(state.events),
+                "session_cost": state.session_cost,
             }
 
     @asynccontextmanager
     async def session_operation(self, session_id: str) -> AsyncGenerator[None]:
+        # Keep a strong reference while waiting and holding the session lock.
         async with self._lock:
             lock = self._session_locks.get(session_id)
             if lock is None:
@@ -217,18 +226,21 @@ class RunManager:
         last_seq = max(0, after)
         while True:
             async with state.condition:
-                pending = [event for event in state.events if int(event.get("seq") or 0) > last_seq]
+                pending = []
+                for event in reversed(state.events):
+                    if event["seq"] <= last_seq:
+                        break
+                    pending.append(event)
+                pending.reverse()
                 finished = state.status != "running"
 
                 if not pending and not finished:
-                    # Wake on the next event or re-poll after the timeout; both just re-loop.
-                    with suppress(TimeoutError):
-                        await asyncio.wait_for(state.condition.wait(), timeout=0.5)
+                    await state.condition.wait()
                     continue
 
             for payload in pending:
                 yield payload
-                last_seq = int(payload.get("seq") or last_seq)
+                last_seq = payload["seq"]
 
             if finished:
                 break
@@ -237,14 +249,35 @@ class RunManager:
         state = await self.get_run(run_id)
         if not state:
             return None
+        self._request_cancel(state)
+        if state.task is not None:
+            # Request cancellation must not interrupt the run's own cleanup.
+            await asyncio.shield(state.task)
+        return state.info()
+
+    def _request_cancel(self, state: RunState) -> None:
+        # Repeated task.cancel() can interrupt a tool's cancellation cleanup.
+        if state.cancel_requested or state.status != "running":
+            return
         state.cancel_requested = True
         state.agent.cancel()
         for fut in state.pending_decisions.values():
             if not fut.done():
                 fut.cancel()
-        if state.task is not None:
-            await state.task
-        return state.info()
+
+    async def aclose(self) -> None:
+        """Cancel and await owned runs after the application stops handling requests."""
+
+        async with self._lock:
+            tasks = []
+            for state in self._runs_by_id.values():
+                if state.task is not None and not state.task.done():
+                    self._request_cancel(state)
+                    tasks.append(state.task)
+        await asyncio.gather(*tasks)
+        self._runs_by_id.clear()
+        self._active_by_session.clear()
+        self._session_locks.clear()
 
     async def has_active_run(self, session_id: str) -> bool:
         async with self._lock:
@@ -287,8 +320,7 @@ class RunManager:
         try:
             decision = await future
             if decision == "deny":
-                state.cancel_requested = True
-                state.agent.cancel()
+                self._request_cancel(state)
             return decision
         except asyncio.CancelledError:
             # Treat cancellation as deny so the agent loop unwinds via its own cancel check.
@@ -323,15 +355,20 @@ class RunManager:
     async def _run(self, state: RunState) -> None:
         """Run the agent and store streamed events."""
 
+        # Agent entrypoints reset their cancellation flags for a new turn.
+        if state.cancel_requested:
+            await self._finish_run(state, status="cancelled")
+            return
+
         last_error: str | None = None
 
         try:
             if state.kind == "compact":
                 # The agent persists the compact marker before this returns.
-                await state.agent.acompact()
+                marker = await state.agent.acompact()
                 if state.on_complete is not None:
                     await state.on_complete(state.session_id)
-                await self._append_event(state, Event("compact", {}))
+                await self._append_event(state, Event("compact", {}), compact_cost=sum_session_cost([marker]))
             else:
                 assert state.user_message is not None
                 async for event in state.agent.achat(state.user_message):
@@ -339,22 +376,6 @@ class RunManager:
                         continue
                     if event.type == "error":
                         last_error = str(event.data.get("message") or "unknown error")
-                    elif event.type == "usage":
-                        turn_cost = event.data.get("turn_cost")
-                        turn_total = turn_cost.get("total") if isinstance(turn_cost, dict) else None
-                        session_cost = sum_known_costs(
-                            state.session_cost_base,
-                            turn_total,
-                        )
-                        event = Event(
-                            "usage",
-                            {
-                                **event.data,
-                                "context_window": state.agent.context_window,
-                                "model": state.agent.model,
-                                "session_cost": session_cost,
-                            },
-                        )
                     await self._append_event(state, event)
         except asyncio.CancelledError:
             # BaseException, not caught by ``except Exception`` — without this
@@ -377,8 +398,24 @@ class RunManager:
 
         await self._finish_run(state, status="completed")
 
-    async def _append_event(self, state: RunState, event: Event) -> None:
+    async def _append_event(self, state: RunState, event: Event, *, compact_cost: float | None = None) -> None:
         async with state.condition:
+            if event.type == "usage":
+                turn_cost = event.data.get("turn_cost")
+                turn_total = turn_cost.get("total") if isinstance(turn_cost, dict) else None
+                state.session_cost = sum_known_costs(state.session_cost_base, turn_total)
+                event = Event(
+                    "usage",
+                    {
+                        **event.data,
+                        "context_window": state.agent.context_window,
+                        "model": state.agent.model,
+                        "session_cost": state.session_cost,
+                    },
+                )
+            elif event.type == "compact" and state.kind == "compact":
+                state.session_cost = sum_known_costs(state.session_cost_base, compact_cost)
+
             if event.type == "tool_done":
                 tool_use_id = event.data.get("tool_use_id")
                 retained = [

mycode_cli/sessions.py

@@ -23,12 +23,14 @@ import asyncio
 import json
 import os
 import shutil
+from collections.abc import Iterable
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import TypedDict
 
 from mycode.messages import ConversationMessage
 from mycode.session import SessionStore as TimelineStore
+from mycode.session import apply_rewind
 
 DEFAULT_SESSION_TITLE = "New chat"
 _META_KEYS = ("cwd", "title", "created_at", "updated_at")
@@ -39,6 +41,23 @@ SessionMetaDict = dict[str, object]
 class SessionData(TypedDict):
     session: SessionMetaDict
     messages: list[ConversationMessage]
+    session_cost: float | None
+
+
+def sum_session_cost(messages: Iterable[ConversationMessage]) -> float | None:
+    """Sum known request costs, including compact markers and rewound turns."""
+
+    total: float | None = None
+    for message in messages:
+        if message.get("role") not in {"assistant", "compact"}:
+            continue
+        cost = (message.get("meta") or {}).get("cost")
+        if not isinstance(cost, dict):
+            continue
+        request_total = cost.get("total")
+        if isinstance(request_total, int | float):
+            total = (total if total is not None else 0.0) + float(request_total)
+    return total
 
 
 def _now() -> str:
@@ -185,16 +204,27 @@ class SessionStore(TimelineStore):
         sessions = await self.list_sessions(cwd=cwd)
         return sessions[0] if sessions else None
 
+    async def load_metadata(self, session_id: str) -> SessionMetaDict | None:
+        """Load a catalog entry without reading its message timeline."""
+
+        def load() -> SessionMetaDict | None:
+            meta = self._read_meta(session_id)
+            return self._summary(session_id, meta) if meta is not None else None
+
+        return await asyncio.to_thread(load)
+
     async def load_session(self, session_id: str) -> SessionData | None:
-        """Load one cataloged session's meta and visible messages."""
+        """Load metadata, visible messages, and cost from one raw timeline read."""
 
         def load() -> SessionData | None:
             meta = self._read_meta(session_id)
             if meta is None:
                 return None
+            raw = self.load_raw_messages_sync(session_id)
             return {
                 "session": self._summary(session_id, meta),
-                "messages": self.load_messages_sync(session_id),
+                "messages": apply_rewind(raw),
+                "session_cost": sum_session_cost(raw),
             }
 
         return await asyncio.to_thread(load)

mycode_cli/system_prompt.py

@@ -323,13 +323,14 @@ def discover_slash_skills(cwd: str) -> list[Skill]:
 def build_skill_snapshot_blocks(text: str, cwd: str) -> list[ContentBlock]:
     """Expand standalone ``/<skill-name>`` references in first-use order."""
 
+    names = [token[1:] for token in text.split() if token.startswith("/")]
+    if not names:
+        return []
+
     skills = {skill.name: skill for skill in discover_slash_skills(cwd)}
     blocks: list[ContentBlock] = []
     seen: set[str] = set()
-    for token in text.split():
-        if not token.startswith("/"):
-            continue
-        name = token[1:]
+    for name in names:
         skill = skills.get(name)
         if not skill or name in seen:
             continue

mycode_cli/tools.py

@@ -20,6 +20,7 @@ from dataclasses import dataclass
 from difflib import SequenceMatcher, unified_diff
 from pathlib import Path
 from typing import BinaryIO
+from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -162,16 +163,18 @@ def read_tool(
 
 
 def _atomic_write_text(path: Path, content: str, *, newline: str | None = None) -> None:
-    tmp = path.with_suffix(path.suffix + ".tmp")
-    if newline is None:
-        tmp.write_text(content, encoding="utf-8")
-    else:
-        normalized = content.replace("\r\n", "\n")
+    if newline is not None:
+        content = content.replace("\r\n", "\n")
         if newline == "\r\n":
-            normalized = normalized.replace("\n", "\r\n")
-        with tmp.open("w", encoding="utf-8", newline="") as file:
-            file.write(normalized)
-    tmp.replace(path)
+            content = content.replace("\n", "\r\n")
+    tmp = path.with_name(f".{uuid4().hex}.tmp")
+    file = tmp.open("x", encoding="utf-8", newline=None if newline is None else "")
+    try:
+        with file:
+            file.write(content)
+        tmp.replace(path)
+    finally:
+        tmp.unlink(missing_ok=True)
 
 
 @tool(
@@ -238,21 +241,21 @@ def _closest_line_hint(text: str, needle: str) -> str | None:
 def _normalize_text(text: str) -> tuple[str, list[int]]:
     """Normalize text while preserving a map back to original offsets."""
 
-    chars: list[str] = []
+    parts: list[str] = []
     imap: list[int] = []
     pos = 0
     for line in text.splitlines(keepends=True):
         content = line.rstrip("\r\n")
         trimmed = content.rstrip(" \t")
-        chars.extend(trimmed)
+        parts.append(trimmed)
         imap.extend(range(pos, pos + len(trimmed)))
         eol = line[len(content) :]
         if eol:
-            chars.append("\n")
+            parts.append("\n")
             imap.append(pos + len(content))
         pos += len(line)
 
-    return "".join(chars), imap
+    return "".join(parts), imap
 
 
 @tool(
@@ -362,10 +365,13 @@ def edit_tool(ctx: ToolContext[CliDeps], path: str, edits: list[EditEntry]) -> T
                 is_error=True,
             )
 
-    # Apply replacements back-to-front so earlier offsets stay valid.
-    updated = text
-    for start, end, new_text, _ in reversed(matches):
-        updated = updated[:start] + new_text + updated[end:]
+    parts: list[str] = []
+    cursor = 0
+    for start, end, new_text, _ in matches:
+        parts.extend((text[cursor:start], new_text))
+        cursor = end
+    parts.append(text[cursor:])
+    updated = "".join(parts)
 
     if updated == text:
         return ToolExecutionResult(output="error: edits produced no changes", is_error=True)
@@ -570,10 +576,6 @@ class _BashOutputAccumulator:
 
     def _trim_tail(self) -> None:
         encoded = self.tail_text.encode("utf-8")
-        if len(encoded) <= DEFAULT_MAX_BYTES * 2:
-            self.tail_bytes = len(encoded)
-            return
-
         start = len(encoded) - DEFAULT_MAX_BYTES * 2
         while start < len(encoded) and encoded[start] & 0xC0 == 0x80:
             start += 1

mycode_cli/tui/chat.py

@@ -6,7 +6,6 @@ import asyncio
 import re
 import shlex
 from collections.abc import Iterable
-from contextlib import suppress
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, override
@@ -62,19 +61,18 @@ from .theme import ERROR, ERROR_MARKER, MUTED, PROMPT_CHAR, TERMINAL_THEME, TOOL
 
 _PROMPT = ANSI(f"\033[1m\033[34m{PROMPT_CHAR}\033[0m ")
 
-# (command, help usage, description) — the completer offers `command`, help prints `usage`.
 _COMMANDS = (
-    ("/clear", "/c, /clear", "Clear conversation"),
-    ("/compact", "/compact", "Compact conversation context"),
-    ("/new", "/new", "New session"),
-    ("/resume", "/resume", "Switch session"),
-    ("/rewind", "/rewind", "Rewind to a previous message"),
-    ("/provider", "/provider [name]", "Switch provider"),
-    ("/model", "/model [name]", "Switch model"),
-    ("/effort", "/effort [level]", "Set reasoning effort"),
-    ("/q", "/q", "Quit"),
+    ("/clear", "Clear conversation"),
+    ("/compact", "Compact conversation context"),
+    ("/new", "New session"),
+    ("/resume", "Switch session"),
+    ("/rewind", "Rewind to a previous message"),
+    ("/provider", "Switch provider"),
+    ("/model", "Switch model"),
+    ("/effort", "Set reasoning effort"),
+    ("/q", "Quit"),
 )
-_SLASH_COMMANDS = tuple(command for command, _, _ in _COMMANDS)
+_SLASH_COMMANDS = tuple(command for command, _ in _COMMANDS)
 # Only treat `@path` as a reference when it starts a standalone token.
 _AT_PATH_RE = re.compile(r"""(?<!\S)@(?:'(?P<single>[^']*)'?$|"(?P<double>[^"]*)"?$|(?P<plain>[^\s'"]*))$""")
 _SKILL_TOKEN_RE = re.compile(r"(?<!\S)/(?P<name>[a-zA-Z0-9_-]*)$")
@@ -151,7 +149,7 @@ class _PromptCompleter(Completer):
 
         text = text_before_cursor.lstrip()
         if re.fullmatch(r"/\S*", text):
-            for cmd, _usage, desc in _COMMANDS:
+            for cmd, desc in _COMMANDS:
                 if cmd.startswith(text):
                     yield Completion(cmd, start_position=-len(text), display_meta=desc)
 
@@ -195,10 +193,9 @@ class _PromptCompleter(Completer):
 
         if not base_dir.is_dir():
             return
-        for entry in sorted(base_dir.iterdir(), key=lambda item: (not item.is_dir(), item.name.lower())):
-            if partial and not entry.name.startswith(partial):
-                continue
-            candidate = f"{base_prefix}{entry.name}{'/' if entry.is_dir() else ''}"
+        entries = [(entry, entry.is_dir()) for entry in base_dir.iterdir() if entry.name.startswith(partial)]
+        for entry, is_dir in sorted(entries, key=lambda item: (not item[1], item[0].name.lower())):
+            candidate = f"{base_prefix}{entry.name}{'/' if is_dir else ''}"
             if quote:
                 replacement = f"@{quote}{candidate}{quote}"
             elif any(ch.isspace() for ch in candidate):
@@ -209,7 +206,7 @@ class _PromptCompleter(Completer):
                 replacement,
                 start_position=-len(match.group(0)),
                 display="@" + candidate,
-                display_meta="dir" if entry.is_dir() else "file",
+                display_meta="dir" if is_dir else "file",
             )
 
 
@@ -332,7 +329,6 @@ class ProviderOption:
     name: str
     provider: str
     models: tuple[str, ...]
-    api_base: str | None
 
 
 def clone_agent(agent: Agent, *, store: SessionStore, session_id: str, cwd: str) -> Agent:
@@ -376,7 +372,6 @@ def list_provider_options(settings: Settings) -> list[ProviderOption]:
                 name=name,
                 provider=config.type,
                 models=tuple(config.models),
-                api_base=config.base_url,
             )
         )
         if provider_is_available(config):
@@ -390,7 +385,6 @@ def list_provider_options(settings: Settings) -> list[ProviderOption]:
                 name=provider_name,
                 provider=provider_name,
                 models=provider_default_models(provider_name),
-                api_base=None,
             )
         )
 
@@ -548,11 +542,10 @@ class TerminalChat:
             except (KeyboardInterrupt, asyncio.CancelledError):
                 self.agent.cancel()
                 renderer.cancel()
-                # Python 3.11+: uncancel the task so the loop can continue after Ctrl+C.
+                # Uncancel the task so the loop can continue after Ctrl+C.
                 task = asyncio.current_task()
                 if task is not None:
-                    with suppress(AttributeError):
-                        task.uncancel()
+                    task.uncancel()
             finally:
                 self._current_renderer = None
 
@@ -655,14 +648,6 @@ class TerminalChat:
 
         return True
 
-    def _print_help(self) -> None:
-        self.view.console.print()
-        for _command, usage, desc in _COMMANDS:
-            line = Text()
-            line.append(f"  {usage:<20}", style="bold")
-            line.append(desc, style=MUTED)
-            self.view.console.print(line)
-
     def _print_runtime_status(self, action: str, value: str, *, changed: bool) -> None:
         """Print the result of a runtime-only change."""
 
@@ -690,11 +675,10 @@ class TerminalChat:
             return
         except (KeyboardInterrupt, asyncio.CancelledError):
             self.agent.cancel()
-            # Python 3.11+: uncancel the task so the loop can continue after Ctrl+C.
+            # Uncancel the task so the loop can continue after Ctrl+C.
             task = asyncio.current_task()
             if task is not None:
-                with suppress(AttributeError):
-                    task.uncancel()
+                task.uncancel()
             self.view.console.print(Text("cancelled", style=MUTED))
             return
         except Exception as exc:
@@ -815,7 +799,7 @@ class TerminalChat:
         """Prompt for a configured provider and apply it to the active agent."""
 
         options = list_provider_options(self.settings)
-        current = get_provider_option(self.settings, provider_name=self.provider_name)
+        current = next((option for option in options if option.name == self.provider_name), None)
 
         choices: list[tuple[str, str]] = []
         for option in options:
@@ -919,10 +903,7 @@ class TerminalChat:
 
     def _restore_effort(self) -> None:
         saved = self.effort_preferences.get(self._effort_key())
-        if saved is None:
-            self.agent.reasoning_effort = None
-            return
-        if saved == "auto":
+        if saved is None or saved == "auto":
             self.agent.reasoning_effort = None
             return
         if self.agent.supports_reasoning_effort and saved in self.reasoning_efforts:

mycode_cli/tui/render.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import time
+from collections import deque
 from datetime import datetime
 from typing import Any, ClassVar, override
 
@@ -357,7 +358,7 @@ class ReplyRenderer:
         self._context_window = context_window
         self._session_cost_base = session_cost_base
         self._live: Live | None = None
-        self._reasoning: list[str] = []
+        self._reasoning: deque[str] = deque(maxlen=31)
         self._text: list[str] = []
         self._text_started = False
         # Reasoning & stats
@@ -719,7 +720,7 @@ class ReplyRenderer:
         # Thinking in progress: show rolling preview of reasoning content.
         # Join only the tail to avoid O(full_length) work on every frame.
         if self._reasoning and not self._text:
-            tail = "".join(self._reasoning[-30:])
+            tail = "".join(list(self._reasoning)[-30:])
             content = " ".join(tail.split())
             if content:
                 preview = content[-80:].strip()

{mycode_cli-0.14.2.dist-info → mycode_cli-0.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mycode-cli
-Version: 0.14.2
+Version: 0.15.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
@@ -25,7 +25,7 @@ Requires-Dist: beautifulsoup4>=4.15.0
 Requires-Dist: fastapi>=0.139.0
 Requires-Dist: httpx2>=2.10.0
 Requires-Dist: markdownify>=1.2.3
-Requires-Dist: mycode-sdk==0.14.2
+Requires-Dist: mycode-sdk==0.15.0
 Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pydantic>=2.13.4
 Requires-Dist: pyyaml>=6.0.3

{mycode_cli-0.14.2.dist-info → mycode_cli-0.15.0.dist-info}/RECORD

@@ -1,23 +1,23 @@
 mycode_cli/__init__.py,sha256=K9OoBd9T-1JdpfLnjTgRoVyv8gSnA4telBRzYSl23OE,231
-mycode_cli/config.py,sha256=CM1G7393pRLEYvqnr3y9kpzL84tsZnYsp5XrRrPTv2U,30887
-mycode_cli/main.py,sha256=p2kehJ-aIN36N-RnbchaE1YvTGDB3kynfwvlmUPzMhc,11636
-mycode_cli/permissions.py,sha256=uzwDFnb3cskpAKy-DKHYwCg0rGeTdIOvFMtk5CsNjho,7904
-mycode_cli/runtime.py,sha256=hs4XLD6_c2zknD4flxpmOVDfH_KJYwp3ZaZujl8UGxA,3099
-mycode_cli/sessions.py,sha256=jSC9I7PqLcTVLsfJLoY2Ldl4GRwuIzT2y-wYr409Lw4,7231
-mycode_cli/system_prompt.py,sha256=yvCEv1-POT8axUPFy-8q8jLOvLtK7Z7ZxUwHd_WQDTU,12773
-mycode_cli/tools.py,sha256=P2zabvGSTG0ri-riESbJYAHsNCUKcBigq-7iOlUTGzs,26520
+mycode_cli/config.py,sha256=B_kL9vijHM20JA0DrFdEN_SuBzgjozPeqtJE-PZjHJw,30274
+mycode_cli/main.py,sha256=TMuD5HAH53F2XFtifd4lQeDx3RnLtmE_GsOz76fbgOI,11972
+mycode_cli/permissions.py,sha256=GESSo6YxMLudE_WI_XtAHHih4sgREsIlNnXirkoR1G4,7765
+mycode_cli/runtime.py,sha256=UG-ZQ3aGLC0j9LbcxK6bxG9DTA8wRo7xdjB3GkfcbMc,2702
+mycode_cli/sessions.py,sha256=g97vpaTIZw5xhh1hKV0pz91496H5hBS3rMKhZ0_v5gw,8434
+mycode_cli/system_prompt.py,sha256=S9ehciURi4kZgeKBOfXpUeuI1NRMKomekHdWMQDhIL8,12793
+mycode_cli/tools.py,sha256=jwvQiu8U95qMj6KPI5qMJyBr73M6lX7qMOJhZWuL_hc,26476
 mycode_cli/web_tools.py,sha256=vIcrPEeUs8VmdNec9ikpqh6NxudX_TXBla4RqRqSmQQ,17936
 mycode_cli/workspace.py,sha256=n139AXmrJyfuErpfDViSzGeZE_VQz2Q3ixibmqO2NqI,961
 mycode_cli/server/__init__.py,sha256=Bt8J0HJdkPdE2VQl7zjnEjofriUHksen5tHQ8agw7RM,32
-mycode_cli/server/app.py,sha256=oBMPaHVJsLcv4bfj2bQ4N3_qD6s2ZxRch2UTlUhqRt8,2243
-mycode_cli/server/deps.py,sha256=qPJN2sqNwws0Q2W4rjZYyeTEL87JHhTCbBqpAYvTJeY,1073
-mycode_cli/server/run_manager.py,sha256=QQRY0NeY6aDtoMqCVsGWucPSnqcvpkSEDCoM5LStZk8,15427
+mycode_cli/server/app.py,sha256=v1jdOv8qJ8FyQwd8dd8UMSvbUOIJ5i4ejjgT9M0ZC_Q,2687
+mycode_cli/server/deps.py,sha256=MKwd89W0Vv954xThrbcOPyqEySCO5YJtP_WS91nUqpk,1050
+mycode_cli/server/run_manager.py,sha256=qB7cxGnMtnR7O3qZh3-UAuAo9--FcpFosImcCe_unf8,16896
 mycode_cli/server/schemas.py,sha256=ZXN2L1pBqDiGDDZmHgsLoPNUFWS_SNEOz_imkX-eUFU,4999
 mycode_cli/server/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mycode_cli/server/routers/chat.py,sha256=DP6Ab-ez2yvcX7fla365e4ZojHikrwfrdHSnp_qbc2E,18298
-mycode_cli/server/routers/sessions.py,sha256=bGoZZQvHz03Rv4YZ9wtVvF0ohoU77sxxpf3WfObXG20,3850
-mycode_cli/server/routers/settings.py,sha256=jhEhBZpt4ajRoeIYyhpkmOhlA804viGKhKh1RjxKII4,6904
-mycode_cli/server/routers/workspaces.py,sha256=XAzIOMaB6GEP1yDzAn96rEproyw6DeC2qA2eaY3Y6Wo,5508
+mycode_cli/server/routers/chat.py,sha256=6qj96sWjAgcNHqFa90JYsDy_Qrcw_xPCW6wiAhS0oaU,18406
+mycode_cli/server/routers/sessions.py,sha256=hod6havxtTE81kv88cOi7PKlPHIkG1GnApQ49aoQMBo,3692
+mycode_cli/server/routers/settings.py,sha256=9fqltbqpezH5LgZKw_7tjU2nRnwfHuU3gLFi4Poe2fU,7017
+mycode_cli/server/routers/workspaces.py,sha256=lPm48yLWszazi0sOODj5alqcwrollKxOFf3NCA89hwc,5468
 mycode_cli/server/static/favicon_slashes.svg,sha256=bxMiM7G7NR1zLWyUWnFBCa1FSu0AzFiDW2YY6DtcOWQ,504
 mycode_cli/server/static/index.html,sha256=rxhif41gyfCseX02a8F085uwJrDF9tNxo9G4vqDhDVI,1265
 mycode_cli/server/static/assets/EditDiff-DOjxGJl-.js,sha256=6y0JCwtOGrYKdmM0j0OT2VaE57J38IbLSiUIjc01XLU,251313
@@ -398,12 +398,12 @@ mycode_cli/server/static/fonts/OFL.txt,sha256=5ntCh7US9uFmOUyAp0oMbVNwk26XBuNd-d
 mycode_cli/server/static/fonts/SourceCodePro-Variable.woff2,sha256=i3dKqlE3o470D0rJ0225pe7hUrL2ZYnf3IL_AH_IcTU,22044
 mycode_cli/server/static/fonts/SourceSans3-Variable.woff2,sha256=ehmnAn4SUlfTEMbb14rjowteoeN5TWCxK7KCJ6ADv9o,28740
 mycode_cli/tui/__init__.py,sha256=5sPlJS3c8HdNEBwcF0bUuj8f8brAD-_6MNmF4Q_1Edg,69
-mycode_cli/tui/chat.py,sha256=uRqdxJgy0y_xhFYSm_TSIr8TOGoJiZ0EjdWkqsTTwZw,36118
-mycode_cli/tui/render.py,sha256=rTpES5SLHy23SE3Buhx9LTPXrt9-nRGcPOXm1SDnXtU,26175
+mycode_cli/tui/chat.py,sha256=RwiWM0k53xC8T93yvIWuv5DImYUmvaQBIty4fBSpAlQ,35282
+mycode_cli/tui/render.py,sha256=kdmYWts__qYllA_mfLkXYLDtgTIEcyo8ZRXWGJdINhQ,26226
 mycode_cli/tui/state.py,sha256=vtG1NJQl6e7hI6ovlbyIsgckQiKbApnYPbRT0N0ybS0,1175
 mycode_cli/tui/theme.py,sha256=HS3C1kSoIONrSaiSx22AWRLk1n6-T-Tn5iohCMewAg4,3455
-mycode_cli-0.14.2.dist-info/METADATA,sha256=u0jgvauO43NzX2Z6hPiMhWu2xbxYL3Vlf3UD8KvXf98,4907
-mycode_cli-0.14.2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-mycode_cli-0.14.2.dist-info/entry_points.txt,sha256=1R7YN8dxJUy5AMC4q2J5Ly9xuEom3ZbTaa8xXwxuZyk,48
-mycode_cli-0.14.2.dist-info/licenses/LICENSE,sha256=DSE6T-B9WhrWypr6H7y2kTZzoF1tef5xf7veUyImQsM,1064
-mycode_cli-0.14.2.dist-info/RECORD,,
+mycode_cli-0.15.0.dist-info/METADATA,sha256=yn4sJVBEDJe2piB2t-XuIy7jMfgWp_cmusjpsn0GUAg,4907
+mycode_cli-0.15.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+mycode_cli-0.15.0.dist-info/entry_points.txt,sha256=1R7YN8dxJUy5AMC4q2J5Ly9xuEom3ZbTaa8xXwxuZyk,48
+mycode_cli-0.15.0.dist-info/licenses/LICENSE,sha256=DSE6T-B9WhrWypr6H7y2kTZzoF1tef5xf7veUyImQsM,1064
+mycode_cli-0.15.0.dist-info/RECORD,,