micro-cc 0.2.0__tar.gz → 0.2.2__tar.gz

{micro_cc-0.2.0 → micro_cc-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: micro-cc
-Version: 0.2.0
+Version: 0.2.2
 Summary: Harness that gives frontier models full system access — shell, filesystem, browser, MCP — running directly on the metal.
 Author: George Salapa
 License-Expression: MIT

{micro_cc-0.2.0 → micro_cc-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "micro-cc"
-version = "0.2.00"
+version = "0.2.02"
 description = "Harness that gives frontier models full system access — shell, filesystem, browser, MCP — running directly on the metal."
 readme = "README.md"
 requires-python = ">=3.12"

{micro_cc-0.2.0 → micro_cc-0.2.2}/src/micro_cc/claude_loop_.py

@@ -11,6 +11,7 @@ from micro_cc.execute_tool import execute_tool_call
 from micro_cc.models.schema import function_to_schema
 from micro_cc.models.anthropic import a_model_call
 from micro_cc.models.litellm import l_model_call
+from micro_cc.models.ollama import o_model_call
 from micro_cc.skills.skill_loader import get_skill_summary
 from micro_cc.tools.bash_tool import bash_
 from micro_cc.tools.file_tools_ import read_, write_, edit_, glob_, grep_
@@ -28,7 +29,7 @@ from micro_cc.tools.search_tool_ import (
 from micro_cc.tools.vision_tools_ import vision
 from micro_cc.tools.mcp_client_ import resolve_mcp_for_litellm, call_mcp_tool
 from micro_cc.utils.msg_store_ import load_summary
-from micro_cc.utils.tokenization_simple import token_cutter
+from micro_cc.utils.tokenization_simple import token_cutter, token_stats
 from micro_cc.utils.helpers import tokenizer
 from micro_cc.utils.claude_md_loader import load_claude_md_file
 from micro_cc.utils.helpers import get_endpoint
@@ -47,10 +48,10 @@ async def claude_loop(
     project_dir,
     watcher=None,
     model="sonnet-4.6",
+    max_tokens=80000,
 ):
     """micro cc"""
 
-    max_tokens = 80000
     end_resp = get_endpoint()
     redis_state = RedisStateManager()
 
@@ -191,7 +192,16 @@ make_plan, update_step, show_full_plan, add_step
         trimmed_loop_msgs = system_context + plan_msg + trimmed_loop_msgs
 
         try:
-            if end_resp == "LiteLLM":
+            if end_resp == "Ollama":
+                stream = await o_model_call(
+                    input=trimmed_loop_msgs,
+                    model=model,
+                    tools=tool_schemas,
+                    mcp_openai_tools=mcp_openai_tools or None,
+                    thinking=True,
+                    stream=True,
+                )
+            elif end_resp == "LiteLLM":
                 stream = await l_model_call(
                     input=trimmed_loop_msgs,
                     model=model,
@@ -215,6 +225,7 @@ make_plan, update_step, show_full_plan, add_step
                 break
 
             response = None
+            api_usage = {}
             async for event in stream:
                 if event["type"] == "text_delta":
                     yield {"type": "text_delta", "content": event["text"]}
@@ -222,6 +233,12 @@ make_plan, update_step, show_full_plan, add_step
                     yield {"type": "thinking_delta", "content": event["thinking"]}
                 elif event["type"] == "response":
                     response = event["response"]
+                    api_usage = event.get("usage", {})
+
+            if api_usage.get("input"):
+                token_stats["input"] = api_usage["input"]
+            if api_usage.get("output"):
+                token_stats["output"] += api_usage["output"]
 
             if response is None:
                 yield {"type": "error", "message": "model call failed after retries"}

{micro_cc-0.2.0 → micro_cc-0.2.2}/src/micro_cc/models/anthropic.py

@@ -34,9 +34,15 @@ async def _wrap_stream(raw_stream):
     thinking_signature = ""
     tool_blocks = []
     current_tool = None
+    usage = {}
 
     async for event in raw_stream:
-        if event.type == "content_block_start":
+        if event.type == "message_start":
+            u = getattr(event.message, "usage", None)
+            if u:
+                usage["input"] = getattr(u, "input_tokens", 0)
+
+        elif event.type == "content_block_start":
             if event.content_block.type == "tool_use":
                 current_tool = {"id": event.content_block.id, "name": event.content_block.name, "input_json": ""}
 
@@ -59,6 +65,11 @@ async def _wrap_stream(raw_stream):
                 tool_blocks.append(current_tool | {"input": args})
                 current_tool = None
 
+        elif event.type == "message_delta":
+            u = getattr(event, "usage", None)
+            if u:
+                usage["output"] = getattr(u, "output_tokens", 0)
+
     blocks = []
     if thinking:
         blocks.append(ContentBlock(type="thinking", thinking=thinking, signature=thinking_signature))
@@ -67,7 +78,7 @@ async def _wrap_stream(raw_stream):
     for tb in tool_blocks:
         blocks.append(ContentBlock(type="tool_use", name=tb["name"], input=tb["input"], id=tb["id"]))
 
-    yield {"type": "response", "response": Response(content=blocks)}
+    yield {"type": "response", "response": Response(content=blocks), "usage": usage}
 
 async def a_model_call(
     input: Union[List[Dict[str, Any]], str],

{micro_cc-0.2.0 → micro_cc-0.2.2}/src/micro_cc/models/litellm.py

@@ -218,6 +218,7 @@ async def _wrap_stream(openai_stream):
     thinking = ""
     thinking_signature = ""
     tool_calls = {}  # index -> {id, name, arguments_str}
+    usage = {}
 
     async for chunk in openai_stream:
         delta = chunk.choices[0].delta
@@ -246,6 +247,12 @@ async def _wrap_stream(openai_stream):
                 if tc.function and tc.function.arguments:
                     tool_calls[idx]["args"] += tc.function.arguments
 
+        # Usage — LiteLLM sends it on the final chunk
+        u = getattr(chunk, "usage", None)
+        if u:
+            usage["input"] = getattr(u, "prompt_tokens", 0)
+            usage["output"] = getattr(u, "completion_tokens", 0)
+
     # Stream done — build final Response for claude_loop_
     blocks = []
     if thinking:
@@ -262,7 +269,7 @@ async def _wrap_stream(openai_stream):
             ContentBlock(type="tool_use", name=tc["name"], input=args, id=tc["id"])
         )
 
-    yield {"type": "response", "response": Response(content=blocks)}
+    yield {"type": "response", "response": Response(content=blocks), "usage": usage}
 
 
 # ---------------------------------------------------------------------------
@@ -332,6 +339,9 @@ async def l_model_call(
         "messages": messages,
     }
 
+    if stream:
+        api_params["stream_options"] = {"include_usage": True}
+
     if thinking:
         api_params["reasoning_effort"] = "high"
 

micro_cc-0.2.2/src/micro_cc/models/ollama.py

@@ -0,0 +1,372 @@
+"""Ollama model caller — fully standalone.
+
+Talks to a locally running Ollama daemon via its OpenAI-compatible
+endpoint at http://localhost:11434/v1.
+
+Handled internally — no dependency on other model callers:
+- Anthropic message format → OpenAI chat format conversion
+- Tool schema conversion (Anthropic shape → OpenAI function shape)
+- Streaming wrapper that yields Anthropic-shaped events
+- Ollama-specific quirks:
+    * thinking field is `reasoning` (not `reasoning_content` like LiteLLM/DeepSeek)
+    * final stream chunk with include_usage has empty `choices` list
+    * `think: True` passed via extra_body toggles reasoning mode
+    * `num_ctx` passed via extra_body.options overrides the 4K default
+
+Env vars:
+    OLLAMA_BASE_URL   default http://localhost:11434/v1
+    OLLAMA_MODEL      user picks any tag pulled via `ollama pull <tag>`
+    OLLAMA_NUM_CTX    default 32768 — fits Qwen3-14B KV cache in ~5GB
+    OLLAMA_MAX_OUTPUT default 4096  — generation budget per response
+"""
+
+from typing import List, Dict, Any, Optional, Union
+from openai import AsyncOpenAI
+from dotenv import load_dotenv
+from dataclasses import dataclass, field
+import asyncio
+import json
+import os
+
+load_dotenv(os.path.expanduser("~/.micro-cc/.env"))
+load_dotenv()
+
+
+# ---------------------------------------------------------------------------
+# Response shape — same as Anthropic SDK so claude_loop_.py works unchanged
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ContentBlock:
+    type: str
+    text: str = ""
+    thinking: str = ""
+    signature: str = ""
+    name: str = ""
+    input: dict = field(default_factory=dict)
+    id: str = ""
+
+
+@dataclass
+class Response:
+    content: list = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Converters — Anthropic format → OpenAI chat format
+# ---------------------------------------------------------------------------
+
+def _tools_to_openai(anthropic_tools, mcp_openai_tools=None):
+    """Anthropic tool schemas + MCP tools → OpenAI function-calling format."""
+    out = []
+    for t in anthropic_tools:
+        out.append({
+            "type": "function",
+            "function": {
+                "name": t["name"],
+                "description": t.get("description", ""),
+                "parameters": t.get("input_schema", {}),
+            },
+        })
+    if mcp_openai_tools:
+        out.extend(mcp_openai_tools)
+    return out or None
+
+
+def _msgs_to_openai(anthropic_msgs):
+    """Convert Anthropic-format message list to OpenAI chat format.
+
+    Handles: system, user (string/multimodal/tool_result),
+    assistant (string/tool_use blocks). Thinking blocks are dropped —
+    local models can't replay signed thinking, and Ollama's OpenAI-compat
+    endpoint doesn't accept them on the resend path.
+    """
+    out = []
+    for msg in anthropic_msgs:
+        role = msg.get("role")
+        content = msg.get("content", "")
+
+        if role == "system":
+            out.append({"role": "system", "content": content})
+            continue
+
+        # --- Assistant with content blocks ---
+        if role == "assistant" and isinstance(content, list):
+            text_parts = []
+            tool_calls = []
+            for block in content:
+                if not isinstance(block, dict):
+                    continue
+                btype = block.get("type")
+                if btype == "text":
+                    text_parts.append(block["text"])
+                elif btype == "tool_use":
+                    tool_calls.append({
+                        "id": block["id"],
+                        "type": "function",
+                        "function": {
+                            "name": block["name"],
+                            "arguments": json.dumps(block["input"]),
+                        },
+                    })
+                # thinking blocks: intentionally skipped for Ollama
+
+            m = {
+                "role": "assistant",
+                "content": "\n".join(text_parts) if text_parts else None,
+            }
+            if tool_calls:
+                m["tool_calls"] = tool_calls
+            out.append(m)
+            continue
+
+        # --- User with content blocks (tool_result, text, image, document) ---
+        if role == "user" and isinstance(content, list):
+            tool_results = []
+            other_parts = []
+
+            for block in content:
+                if not isinstance(block, dict):
+                    continue
+                btype = block.get("type")
+                if btype == "tool_result":
+                    tool_results.append({
+                        "role": "tool",
+                        "tool_call_id": block["tool_use_id"],
+                        "content": block.get("content", ""),
+                    })
+                elif btype == "text":
+                    other_parts.append({"type": "text", "text": block["text"]})
+                elif btype == "image":
+                    source = block.get("source", {})
+                    media = source.get("media_type", "image/jpeg")
+                    other_parts.append({
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:{media};base64,{source.get('data', '')}",
+                        },
+                    })
+                elif btype == "document":
+                    other_parts.append({
+                        "type": "text",
+                        "text": "[PDF document attached]",
+                    })
+
+            out.extend(tool_results)
+
+            if other_parts:
+                if len(other_parts) == 1 and other_parts[0].get("type") == "text":
+                    out.append({"role": "user", "content": other_parts[0]["text"]})
+                else:
+                    out.append({"role": "user", "content": other_parts})
+            continue
+
+        # --- Simple string content ---
+        out.append({"role": role, "content": content})
+
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Response wrappers — OpenAI shape → Anthropic-like Response
+# ---------------------------------------------------------------------------
+
+def _extract_reasoning(obj) -> str:
+    """Ollama surfaces thinking on `reasoning` via model_dump; OpenAI client
+    doesn't type that attribute, so fall back to model_dump().get('reasoning')."""
+    rc = getattr(obj, "reasoning", None)
+    if rc:
+        return rc
+    try:
+        dumped = obj.model_dump()
+        return dumped.get("reasoning") or ""
+    except Exception:
+        return ""
+
+
+def _wrap_response(openai_resp):
+    """Non-streaming OpenAI ChatCompletion → Anthropic-like Response."""
+    choice = openai_resp.choices[0]
+    msg = choice.message
+    blocks = []
+
+    reasoning = _extract_reasoning(msg)
+    if reasoning:
+        blocks.append(ContentBlock(type="thinking", thinking=reasoning, signature=""))
+
+    if msg.content:
+        blocks.append(ContentBlock(type="text", text=msg.content))
+
+    if msg.tool_calls:
+        for tc in msg.tool_calls:
+            try:
+                args = json.loads(tc.function.arguments)
+            except (json.JSONDecodeError, TypeError):
+                args = {}
+            blocks.append(ContentBlock(
+                type="tool_use",
+                name=tc.function.name,
+                input=args,
+                id=tc.id,
+            ))
+
+    return Response(content=blocks)
+
+
+async def _wrap_stream(openai_stream):
+    """Accumulate OpenAI chunks, yield Anthropic-shaped events,
+    finish with a final Response containing all content blocks."""
+    text = ""
+    thinking = ""
+    tool_calls = {}  # index → {id, name, args}
+    usage = {}
+
+    async for chunk in openai_stream:
+        # Final usage-only chunks have empty choices (Ollama sends this
+        # when stream_options.include_usage is on).
+        if not chunk.choices:
+            u = getattr(chunk, "usage", None)
+            if u:
+                usage["input"] = getattr(u, "prompt_tokens", 0)
+                usage["output"] = getattr(u, "completion_tokens", 0)
+            continue
+
+        delta = chunk.choices[0].delta
+
+        # Visible text
+        if delta.content:
+            text += delta.content
+            yield {"type": "text_delta", "text": delta.content}
+
+        # Thinking — Ollama uses `reasoning`, not `reasoning_content`
+        rc = _extract_reasoning(delta)
+        if rc:
+            thinking += rc
+            yield {"type": "thinking_delta", "thinking": rc}
+
+        # Tool calls — must buffer arguments across chunks
+        if delta.tool_calls:
+            for tc in delta.tool_calls:
+                idx = tc.index
+                if idx not in tool_calls:
+                    tool_calls[idx] = {
+                        "id": tc.id or "",
+                        "name": tc.function.name if tc.function else "",
+                        "args": "",
+                    }
+                if tc.function and tc.function.arguments:
+                    tool_calls[idx]["args"] += tc.function.arguments
+
+        # Some Ollama builds attach usage on the final non-empty chunk
+        u = getattr(chunk, "usage", None)
+        if u:
+            usage["input"] = getattr(u, "prompt_tokens", 0)
+            usage["output"] = getattr(u, "completion_tokens", 0)
+
+    blocks = []
+    if thinking:
+        blocks.append(ContentBlock(type="thinking", thinking=thinking, signature=""))
+    if text:
+        blocks.append(ContentBlock(type="text", text=text))
+    for tc in tool_calls.values():
+        args = json.loads(tc["args"]) if tc["args"] else {}
+        blocks.append(ContentBlock(type="tool_use", name=tc["name"], input=args, id=tc["id"]))
+
+    yield {"type": "response", "response": Response(content=blocks), "usage": usage}
+
+
+# ---------------------------------------------------------------------------
+# Main entry point — same signature pattern as models/anthropic.py
+# ---------------------------------------------------------------------------
+
+async def o_model_call(
+    input: Union[List[Dict[str, Any]], str],
+    model: str = None,
+    encoded_image: Optional[Union[str, List[str]]] = None,
+    tools: Optional[List[Dict[str, Any]]] = None,
+    mcp_openai_tools: list = None,
+    stream: bool = False,
+    thinking: bool = False,
+    max_tokens: int = None,
+    client_timeout: int = 480,
+    pdf: str = None,
+    retries: int = 3,
+):
+    base_url = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434/v1")
+    model = model or os.getenv("OLLAMA_MODEL")
+    num_ctx = int(os.getenv("OLLAMA_NUM_CTX", "32768"))
+    if max_tokens is None:
+        max_tokens = int(os.getenv("OLLAMA_MAX_OUTPUT", "4096"))
+
+    client = AsyncOpenAI(
+        base_url=base_url,
+        api_key="ollama",  # dummy — Ollama ignores the key
+        timeout=client_timeout,
+    )
+    base_sleep = 2
+
+    # ---- Build messages ----
+    messages = []
+    if pdf:
+        messages = [{"role": "user", "content": f"[PDF document attached]\n\n{input}"}]
+    elif encoded_image:
+        content = []
+        imgs = [encoded_image] if isinstance(encoded_image, str) else encoded_image
+        for img in imgs:
+            content.append({
+                "type": "image_url",
+                "image_url": {"url": f"data:image/jpeg;base64,{img}"},
+            })
+        content.append({"type": "text", "text": input})
+        messages = [{"role": "user", "content": content}]
+    elif isinstance(input, str):
+        messages = [{"role": "user", "content": input}]
+    else:
+        messages = _msgs_to_openai(input)
+
+    # ---- API parameters ----
+    # Ollama-specific: num_ctx in extra_body.options, think toggle at root
+    extra_body = {"options": {"num_ctx": num_ctx}}
+    if thinking:
+        extra_body["think"] = True
+
+    api_params = {
+        "model": model,
+        "max_tokens": max_tokens,
+        "stream": stream,
+        "messages": messages,
+        "extra_body": extra_body,
+    }
+
+    if stream:
+        api_params["stream_options"] = {"include_usage": True}
+
+    if tools:
+        openai_tools = _tools_to_openai(tools, mcp_openai_tools=mcp_openai_tools)
+        if openai_tools:
+            api_params["tools"] = openai_tools
+            api_params["tool_choice"] = "auto"
+
+    # ---- Call with retries ----
+    for attempt in range(retries):
+        try:
+            response = await client.chat.completions.create(**api_params)
+            if stream:
+                return _wrap_stream(response)
+            else:
+                return _wrap_response(response)
+
+        except Exception as e:
+            import traceback
+            print(f"\n[ollama model_call]: {e}", flush=True)
+            traceback.print_exc()
+            if attempt < retries - 1:
+                sleep_time = base_sleep * (2 ** attempt)
+                print(
+                    f"\n[ollama model_call]: Retrying in {sleep_time}s (attempt {attempt + 1}/{retries})..."
+                )
+                await asyncio.sleep(sleep_time)
+            else:
+                print(f"\n[ollama model_call]: Failed after {retries} attempts")
+
+    return None

{micro_cc-0.2.0 → micro_cc-0.2.2}/src/micro_cc/screens/microcc-styles.tcss

@@ -24,12 +24,16 @@ PromptInput {
     border-left: none;
     border-right: none;
 }
+PromptInput > .text-area--cursor {
+    color: $background;
+    background: white;
+}
 #loader {
     height: 1;
     display: none;
     color: orange;
 }
-#model-picker {
+#model-picker, #rewind-picker, #slash-picker {
     display: none;
     height: auto;
     max-height: 6;

{micro_cc-0.2.0 → micro_cc-0.2.2}/src/micro_cc/screens/window_overlay_.py

@@ -14,7 +14,7 @@ BANNER = """\
 [dim]───────[/] [bold]on the metal[/] [dim]─────────────────────[/]
 [dim italic]Knowledge work is by extension a coding problem.[/]
 
-[white]enter[/] [dim]submit[/] [dim]·[/] [white]esc[/] [dim]interrupt[/] [dim]·[/] [white]/model[/] [dim]switch[/] [dim]·[/] [white]/copy[/] [dim]clipboard[/] [dim]·[/] [white]/clear[/] [dim]reset[/] [dim]·[/] [white]/exit[/] [dim]quit[/]
+[white]enter[/] [dim]submit[/] [dim]·[/] [white]esc[/] [dim]interrupt[/] [dim]·[/] [white]/model[/] [dim]switch[/] [dim]·[/] [white]/rewind[/] [dim]undo[/] [dim]·[/] [white]/copy[/] [dim]clipboard[/] [dim]·[/] [white]/clear[/] [dim]reset[/] [dim]·[/] [white]/exit[/] [dim]quit[/]
 """
 
 
@@ -37,6 +37,8 @@ class MessageRow(Static):
         t = msg["type"]
         if t == "user":
             return Text(f"› {msg['content']}", style="bold")
+        elif t == "user_queued":
+            return Text(f"⋯queued {msg['content']}", style="dim italic #ffA500")
         elif t == "text":
             return render_md(msg["content"])
         elif t == "thinking":
@@ -45,19 +47,50 @@ class MessageRow(Static):
                 render_md(msg["content"], dim=True),
             )
         elif t == "tool_call":
-            if msg.get("result") is None:
-                return Text(f"⟐ {msg['name']} ⋯", style="yellow")
-            else:
-                return Group(
-                    Text(f"⟐ {msg['name']}", style="green"),
-                    Text(f"  {msg.get('result', '')}", style="dim"),
-                )
+            name = msg['name']
+            result = msg.get('result')
+            if result is None:
+                return Text(f"⟐ {name} ⋯", style="yellow")
+            return Text(f"⟐ {name} → {str(result)[:40]}…", style="dim")
         elif t == "error":
             return Text(f"△ {msg['content']}", style="red")
         elif t == "approval":
+            inp = msg.get('input', {})
+            name = msg['name']
+            _sep = Text("·" * 40, style="dim")
+            if name == "bash_":
+                code = inp.get('command', str(inp))
+                return Group(
+                    Text(f"◇ {name}  [y/N]", style="bold yellow"),
+                    render_md(f"```bash\n{code}\n```"),
+                    _sep,
+                )
+            elif name == "edit_":
+                parts = [Text(f"◇ {name}  [y/N]", style="bold yellow")]
+                fp = inp.get('file_path', '')
+                if fp:
+                    parts.append(Text(f"  {fp}", style="dim"))
+                old = inp.get('old_string', '')
+                new = inp.get('new_string', '')
+                if old or new:
+                    diff = f"```diff\n- {old}\n+ {new}\n```" if old else f"```\n{new}\n```"
+                    parts.append(render_md(diff))
+                parts.append(_sep)
+                return Group(*parts)
+            elif name == "write_":
+                parts = [Text(f"◇ {name}  [y/N]", style="bold yellow")]
+                fp = inp.get('file_path', '')
+                if fp:
+                    parts.append(Text(f"  {fp}", style="dim"))
+                content = inp.get('content', '')
+                if content:
+                    preview = content[:500] + ("…" if len(content) > 500 else "")
+                    parts.append(render_md(f"```\n{preview}\n```"))
+                parts.append(_sep)
+                return Group(*parts)
             return Group(
-                Text(f"◇ {msg['name']}  [y/N]", style="bold yellow"),
-                Text(f"  {msg.get('input', {})}", style="dim"),
+                Text(f"◇ {name}  [y/N]", style="bold yellow"),
+                Text(f"  {str(inp)[:80]}…", style="dim"),
             )
         return Text("")