tamfis-code 0.2.3__py3-none-any.whl

tamfis_code/local_chat.py

@@ -0,0 +1,117 @@
+"""Offline/local chat: talk to a directly-configured LLM provider with no
+TamfisGPT backend, account, or network round-trip to tamgpt6 at all.
+
+This is a deliberately separate, second model-routing path from the Remote
+Workspace backend's Tier IV orchestration -- see providers.py's module
+docstring. It exists for genuine offline/local use (Ollama needs no API key
+and runs fully on-device); it does not replicate the backend's model
+health/fallback/quota-tracking, and it never exposes mutating tools (see
+local_tools.py). Real conversational value only: read-only repo inspection
+via tool-calling, no file writes, no shell execution, no approval gate
+(nothing here can mutate anything, so none is needed).
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, AsyncIterator, Dict, List, Optional
+
+from rich.console import Console
+
+from .local_tools import READ_ONLY_TOOL_SCHEMAS, LocalReadOnlyTools
+from .providers import ProviderManager, ProviderType
+
+MAX_TOOL_ROUNDS = 5
+
+_PROVIDER_ALIASES = {
+    "hf": ProviderType.HF, "huggingface": ProviderType.HF,
+    "nvidia": ProviderType.NVIDIA, "nvidia_nim": ProviderType.NVIDIA,
+    "or": ProviderType.OPENROUTER, "openrouter": ProviderType.OPENROUTER,
+    "ollama": ProviderType.OLLAMA,
+    "auto": ProviderType.AUTO,
+}
+
+
+def resolve_provider_type(name: Optional[str]) -> ProviderType:
+    key = (name or "auto").strip().lower()
+    if key not in _PROVIDER_ALIASES:
+        raise ValueError(f"Unknown local provider: {name!r}. Choose one of: {', '.join(sorted(_PROVIDER_ALIASES))}")
+    return _PROVIDER_ALIASES[key]
+
+
+async def run_local_turn(
+    manager: ProviderManager,
+    provider: ProviderType,
+    messages: List[Dict[str, Any]],
+    model: Optional[str],
+    console: Console,
+    *,
+    use_tools: bool = True,
+) -> str:
+    """Run one user turn to completion, resolving any read-only tool calls
+    the model requests along the way. Returns the final assistant text.
+
+    Non-streaming by design: accumulating partial tool_call fragments across
+    a streamed response is real complexity this conservative first pass
+    intentionally skips (see module docstring's scope note) -- a user still
+    sees the final answer, just not token-by-token for turns with tool use.
+    """
+    tools_client = LocalReadOnlyTools() if use_tools else None
+    working_messages = list(messages)
+
+    for _ in range(MAX_TOOL_ROUNDS):
+        client = manager.get_client(provider)
+        if not client:
+            raise RuntimeError(f"Provider {provider.value} is not available (no client / no valid credentials).")
+        config = manager.PROVIDERS[provider if provider != ProviderType.AUTO else manager._select_best_provider()]
+        resolved_model = model or config.default_model
+
+        kwargs: Dict[str, Any] = {}
+        if tools_client is not None:
+            kwargs["tools"] = READ_ONLY_TOOL_SCHEMAS
+            kwargs["tool_choice"] = "auto"
+
+        response = await client.chat.completions.create(
+            model=resolved_model, messages=working_messages, stream=False,
+            temperature=0.2, max_tokens=4096, **kwargs,
+        )
+        if not response.choices:
+            return ""
+        choice = response.choices[0]
+        message = choice.message
+        tool_calls = getattr(message, "tool_calls", None)
+
+        if not tool_calls:
+            return message.content or ""
+
+        working_messages.append({
+            "role": "assistant", "content": message.content or "",
+            "tool_calls": [
+                {"id": tc.id, "type": "function",
+                 "function": {"name": tc.function.name, "arguments": tc.function.arguments}}
+                for tc in tool_calls
+            ],
+        })
+        for tc in tool_calls:
+            console.print(f"[dim]· {tc.function.name}({tc.function.arguments})[/dim]")
+            try:
+                arguments = json.loads(tc.function.arguments or "{}")
+                result = await tools_client.call(tc.function.name, arguments)
+                content = json.dumps(result, default=str)
+            except Exception as exc:
+                content = json.dumps({"error": str(exc)})
+            working_messages.append({"role": "tool", "tool_call_id": tc.id, "content": content})
+
+    return "(Stopped after exhausting the local tool-call round limit -- try a narrower question.)"
+
+
+async def stream_local_turn(
+    manager: ProviderManager,
+    provider: ProviderType,
+    messages: List[Dict[str, Any]],
+    model: Optional[str],
+) -> AsyncIterator[str]:
+    """Plain streaming, no tools -- used when the caller already knows this
+    turn needs no repo inspection (kept separate from run_local_turn so the
+    common single-shot/no-tools case still gets real token streaming)."""
+    async for chunk in manager.chat_completion(provider, messages, model=model, stream=True):
+        yield chunk

tamfis_code/local_tools.py

@@ -0,0 +1,93 @@
+"""Read-only local filesystem tools for tamfis-code's offline/local chat mode.
+
+Local mode has no server-side approval gate, safety classifier, or mutation-
+ledger/audit trail (that infrastructure lives in tamgpt6's Remote Workspace
+backend for good reason). Without it, offering anything that mutates state --
+writing files, running shell commands -- would be a real safety regression,
+not a feature. This module therefore wraps only the read-only subset of
+MCPServer's native tools (tamfis_code/mcp.py): read_file, list_directory,
+search_code, get_git_info. write_file/execute_command/browser are
+intentionally never exposed here.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from .mcp import MCPServer
+
+READ_ONLY_TOOL_SCHEMAS: List[Dict[str, Any]] = [
+    {
+        "type": "function",
+        "function": {
+            "name": "read_file",
+            "description": "Read the contents of a local file (read-only).",
+            "parameters": {
+                "type": "object",
+                "properties": {"path": {"type": "string", "description": "File path"}},
+                "required": ["path"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "list_directory",
+            "description": "List the contents of a local directory (read-only).",
+            "parameters": {
+                "type": "object",
+                "properties": {"path": {"type": "string", "description": "Directory path", "default": "."}},
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "search_code",
+            "description": "Search local file contents using ripgrep (read-only).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Search pattern"},
+                    "path": {"type": "string", "description": "Search directory", "default": "."},
+                    "file_pattern": {"type": "string", "description": "Optional glob filter, e.g. '*.py'"},
+                },
+                "required": ["query"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_git_info",
+            "description": "Read local git repository metadata: branch, latest commit, dirty status (read-only).",
+            "parameters": {
+                "type": "object",
+                "properties": {"path": {"type": "string", "description": "Repository path", "default": "."}},
+            },
+        },
+    },
+]
+
+_READ_ONLY_NAMES = {schema["function"]["name"] for schema in READ_ONLY_TOOL_SCHEMAS}
+
+
+class LocalReadOnlyTools:
+    """Dispatches only read_file/list_directory/search_code/get_git_info.
+
+    Any other tool name (in particular write_file/execute_command/browser,
+    which MCPServer also implements) is refused -- this is the enforcement
+    point for local mode's read-only boundary, not just documentation of it.
+    """
+
+    def __init__(self) -> None:
+        self._server = MCPServer()
+
+    async def call(self, name: str, arguments: Dict[str, Any]) -> Any:
+        if name not in _READ_ONLY_NAMES:
+            raise ValueError(
+                f"'{name}' is not available in local/offline mode -- only read-only tools "
+                f"({', '.join(sorted(_READ_ONLY_NAMES))}) are exposed without a server-side "
+                "approval gate and audit trail."
+            )
+        handler = getattr(self._server, f"_{name}")
+        return await handler(**arguments)