tamfis-code 0.2.3__py3-none-any.whl

tamfis_code/completion.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""Shell completion for TAMFIS-CODE"""
+
+import os
+import sys
+import argparse
+from pathlib import Path
+from typing import List, Dict, Optional
+
+class ShellCompleter:
+    """Dynamic shell completion generator"""
+    
+    SUPPORTED_SHELLS = ['bash', 'zsh', 'fish', 'powershell']
+    
+    COMMANDS = {
+        'chat': 'Start an interactive chat session',
+        'run': 'Execute a command with context',
+        'edit': 'Edit files with AI assistance',
+        'review': 'Review code changes',
+        'plan': 'Create an execution plan',
+        'ingest': 'Ingest documents for context',
+        'session': 'Manage sessions',
+        'config': 'View/Edit configuration',
+        'doctor': 'Run diagnostics',
+        'version': 'Show version',
+    }
+    
+    FILE_COMMANDS = ['edit', 'review', 'ingest']
+    
+    @classmethod
+    def generate_bash(cls) -> str:
+        return '''_tamfis_code_completion() {
+    local cur prev opts files
+    COMPREPLY=()
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    prev="${COMP_WORDS[COMP_CWORD-1]}"
+    
+    opts="chat run edit review plan ingest session config doctor version"
+    
+    case "${prev}" in
+        edit|review|ingest)
+            COMPREPLY=( $(compgen -f -- "${cur}") )
+            return 0
+            ;;
+        *)
+            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+            return 0
+            ;;
+    esac
+}
+complete -F _tamfis_code_completion tamfis-code
+'''
+    
+    @classmethod
+    def generate_zsh(cls) -> str:
+        return '''#compdef tamfis-code
+
+_tamfis_code() {
+    local -a commands
+    commands=(
+        'chat:Start interactive chat session'
+        'run:Execute command with context'
+        'edit:Edit files with AI assistance'
+        'review:Review code changes'
+        'plan:Create execution plan'
+        'ingest:Ingest documents for context'
+        'session:Manage sessions'
+        'config:View/Edit configuration'
+        'doctor:Run diagnostics'
+        'version:Show version'
+    )
+    
+    _arguments -C \\
+        '1: :->command' \\
+        '*:: :->args'
+    
+    case $state in
+        command)
+            _describe 'commands' commands
+            ;;
+        args)
+            case $line[1] in
+                edit|review|ingest)
+                    _files
+                    ;;
+            esac
+            ;;
+    esac
+}
+compdef _tamfis_code tamfis-code
+'''
+    
+    @classmethod
+    def generate_fish(cls) -> str:
+        return '''function __fish_tamfis_code_needs_file
+    set cmd (commandline -opc)
+    contains -- $cmd[2] edit review ingest
+end
+
+complete -c tamfis-code -f
+complete -c tamfis-code -n "__fish_use_subcommand" -a chat -d "Start interactive chat session"
+complete -c tamfis-code -n "__fish_use_subcommand" -a run -d "Execute command with context"
+complete -c tamfis-code -n "__fish_use_subcommand" -a edit -d "Edit files with AI assistance"
+complete -c tamfis-code -n "__fish_use_subcommand" -a review -d "Review code changes"
+complete -c tamfis-code -n "__fish_use_subcommand" -a plan -d "Create execution plan"
+complete -c tamfis-code -n "__fish_use_subcommand" -a ingest -d "Ingest documents"
+complete -c tamfis-code -n "__fish_use_subcommand" -a session -d "Manage sessions"
+complete -c tamfis-code -n "__fish_use_subcommand" -a config -d "View/Edit configuration"
+complete -c tamfis-code -n "__fish_use_subcommand" -a doctor -d "Run diagnostics"
+complete -c tamfis-code -n "__fish_use_subcommand" -a version -d "Show version"
+
+complete -c tamfis-code -n "__fish_tamfis_code_needs_file" -a "(__fish_complete_path)"
+'''
+    
+    @classmethod
+    def generate_powershell(cls) -> str:
+        return '''function _tamfis_code_completion {
+    param(
+        $commandName,
+        $parameterName,
+        $wordToComplete,
+        $commandAst,
+        $fakeBoundParameters
+    )
+    
+    $commands = @(
+        "chat", "run", "edit", "review", "plan", 
+        "ingest", "session", "config", "doctor", "version"
+    )
+    
+    if ($parameterName -eq "command") {
+        $commands | Where-Object { $_ -like "$wordToComplete*" }
+    }
+}
+
+Register-ArgumentCompleter -Native -CommandName "tamfis-code" -ScriptBlock _tamfis_code_completion
+'''

tamfis_code/config.py

@@ -0,0 +1,199 @@
+"""Configuration and credential storage for TamfisGPT Code.
+
+Precedence (highest wins): CLI flag > environment variable > project-local
+.tamfis/config.toml > user ~/.config/tamfis-code/config.toml > built-in
+default. Only fields the CLI actually gives distinct behaviour to are
+supported here -- see docs/REMOTE_AGENT_MASTER_SPEC.md Phase 21's full
+configuration wishlist for what is intentionally deferred.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+APPROVAL_MODES = (
+    "ask", "safe", "auto", "read-only", "plan-only",
+    "suggest", "workspace", "full-auto", "never",
+    "accept-edits",
+)
+
+# Short, user-facing names for /mode -- map to the policy values above.
+# "ask" is this CLI's actual default/manual mode, "accept-edits" behaves
+# like "safe" (auto-approve unless the server classifies the action
+# dangerous, which covers ordinary file edits without covering a
+# destructive shell command), "plan" is "plan-only", "auto" is itself.
+MODE_ALIASES = {
+    "manual": "ask",
+    "plan": "plan-only",
+    "accept-edits": "accept-edits",
+    "auto": "auto",
+}
+
+CONFIG_DIR = Path(os.environ.get("TAMFIS_CODE_CONFIG_HOME", "") or (Path.home() / ".config" / "tamfis-code"))
+CREDENTIALS_PATH = CONFIG_DIR / "credentials.json"
+USER_CONFIG_PATH = CONFIG_DIR / "config.toml"
+PROJECT_CONFIG_RELATIVE = Path(".tamfis") / "config.toml"
+
+DEFAULT_API_BASE = "http://127.0.0.1:9500"
+
+
+def _load_toml(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        return {}
+    try:
+        with path.open("rb") as fh:
+            return tomllib.load(fh)
+    except (OSError, tomllib.TOMLDecodeError):
+        return {}
+
+
+@dataclass
+class Config:
+    api_base: str = DEFAULT_API_BASE
+    approval_policy: str = "ask"
+    colour: bool = True
+    output_mode: str = "text"
+    timeout_seconds: float = 120.0
+    debug: bool = False
+    # Real (LLM-backed) subagent delegation is opt-in: concurrent sessions
+    # against the Remote backend have open questions (rate limiting, approval
+    # prompts interleaving across sessions, concurrent state.json writers)
+    # that need validating against a live backend before being on by default.
+    enable_subagent_delegation: bool = False
+    # "standalone" (default): call a provider directly, no TamfisGPT backend.
+    # "remote": use the TamfisGPT Remote Workspace backend for every command
+    # without needing --remote on each invocation -- set this once (via
+    # `tamfis-code login` writing it, or manually in config.toml) for a paid
+    # TamfisGPT tenant who wants that be the default, the same way Claude
+    # Code/Codex/kimi-code default to their respective hosted accounts.
+    default_backend: str = "standalone"
+    sources: dict[str, str] = field(default_factory=dict)  # field -> where it came from, for `doctor`/`config`
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "api_base": self.api_base,
+            "approval_policy": self.approval_policy,
+            "colour": self.colour,
+            "output_mode": self.output_mode,
+            "timeout_seconds": self.timeout_seconds,
+            "debug": self.debug,
+            "enable_subagent_delegation": self.enable_subagent_delegation,
+            "default_backend": self.default_backend,
+        }
+
+
+def load_config(project_root: Optional[Path] = None) -> Config:
+    cfg = Config()
+    cfg.sources = {k: "default" for k in cfg.as_dict()}
+
+    layers: list[tuple[str, dict[str, Any]]] = [
+        ("user config", _load_toml(USER_CONFIG_PATH)),
+    ]
+    if project_root is not None:
+        layers.append(("project config", _load_toml(project_root / PROJECT_CONFIG_RELATIVE)))
+
+    for source_name, data in layers:
+        if "api_base" in data:
+            cfg.api_base = str(data["api_base"])
+            cfg.sources["api_base"] = source_name
+        if "approval_policy" in data and data["approval_policy"] in APPROVAL_MODES:
+            cfg.approval_policy = str(data["approval_policy"])
+            cfg.sources["approval_policy"] = source_name
+        if "colour" in data:
+            cfg.colour = bool(data["colour"])
+            cfg.sources["colour"] = source_name
+        if "output_mode" in data:
+            cfg.output_mode = str(data["output_mode"])
+            cfg.sources["output_mode"] = source_name
+        if "timeout_seconds" in data:
+            cfg.timeout_seconds = float(data["timeout_seconds"])
+            cfg.sources["timeout_seconds"] = source_name
+        if "enable_subagent_delegation" in data:
+            cfg.enable_subagent_delegation = bool(data["enable_subagent_delegation"])
+            cfg.sources["enable_subagent_delegation"] = source_name
+        if data.get("default_backend") in ("standalone", "remote"):
+            cfg.default_backend = str(data["default_backend"])
+            cfg.sources["default_backend"] = source_name
+
+    env_api_base = os.environ.get("TAMFIS_CODE_API_BASE")
+    if env_api_base:
+        cfg.api_base = env_api_base
+        cfg.sources["api_base"] = "env TAMFIS_CODE_API_BASE"
+
+    env_approval = os.environ.get("TAMFIS_CODE_APPROVAL_POLICY")
+    if env_approval in APPROVAL_MODES:
+        cfg.approval_policy = env_approval
+        cfg.sources["approval_policy"] = "env TAMFIS_CODE_APPROVAL_POLICY"
+
+    env_delegation = os.environ.get("TAMFIS_CODE_ENABLE_SUBAGENT_DELEGATION")
+    if env_delegation is not None:
+        cfg.enable_subagent_delegation = env_delegation.lower() in {"1", "true", "yes"}
+        cfg.sources["enable_subagent_delegation"] = "env TAMFIS_CODE_ENABLE_SUBAGENT_DELEGATION"
+
+    env_backend = os.environ.get("TAMFIS_CODE_DEFAULT_BACKEND")
+    if env_backend in ("standalone", "remote"):
+        cfg.default_backend = env_backend
+        cfg.sources["default_backend"] = "env TAMFIS_CODE_DEFAULT_BACKEND"
+
+    return cfg
+
+
+@dataclass
+class Credentials:
+    access_token: str
+    refresh_token: Optional[str] = None
+    user_id: Optional[str] = None
+    email: Optional[str] = None
+
+
+def load_credentials() -> Optional[Credentials]:
+    env_token = os.environ.get("TAMFIS_CODE_TOKEN")
+    if env_token:
+        return Credentials(access_token=env_token)
+
+    if not CREDENTIALS_PATH.is_file():
+        return None
+    try:
+        data = json.loads(CREDENTIALS_PATH.read_text())
+    except (OSError, json.JSONDecodeError):
+        return None
+    access_token = data.get("access_token")
+    if not access_token:
+        return None
+    return Credentials(
+        access_token=access_token,
+        refresh_token=data.get("refresh_token"),
+        user_id=data.get("user_id"),
+        email=data.get("email"),
+    )
+
+
+def save_credentials(creds: Credentials) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    # Only chmod when needed -- see the identical fix in state.py's
+    # _save_raw for why doing this unconditionally is a landmine (raises
+    # PermissionError the moment CONFIG_DIR is ever owned by a different user
+    # than the caller).
+    if stat.S_IMODE(os.stat(CONFIG_DIR).st_mode) != stat.S_IRWXU:
+        os.chmod(CONFIG_DIR, stat.S_IRWXU)  # 0700 -- owner-only, matches spec's "restrictive permissions"
+    payload = {
+        "access_token": creds.access_token,
+        "refresh_token": creds.refresh_token,
+        "user_id": creds.user_id,
+        "email": creds.email,
+    }
+    CREDENTIALS_PATH.write_text(json.dumps(payload))
+    os.chmod(CREDENTIALS_PATH, stat.S_IRUSR | stat.S_IWUSR)  # 0600
+
+
+def clear_credentials() -> bool:
+    if CREDENTIALS_PATH.is_file():
+        CREDENTIALS_PATH.unlink()
+        return True
+    return False

tamfis_code/doctor.py

@@ -0,0 +1,173 @@
+"""`tamfis-code doctor` -- connectivity/auth/workspace checks.
+
+Reports PASS/WARNING/FAIL per Phase 21. Deliberately checks the things that
+were the actual break points found during this project's Remote-workspace
+audit (see docs/REMOTE_AGENT_MASTER_SPEC.md and the linked memory notes) --
+API reachability, auth, and workspace-scope enforcement really working, not
+just "is the process up."
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Optional
+
+import httpx
+from rich.console import Console
+
+from .api_client import AuthRequiredError, RemoteAPIClient, RemoteAPIError
+from .config import Config, load_credentials
+
+
+@dataclass
+class CheckResult:
+    name: str
+    status: str  # "PASS" | "WARNING" | "FAIL"
+    detail: str = ""
+
+
+_STATUS_STYLE = {"PASS": "green", "WARNING": "yellow", "FAIL": "red"}
+
+_REUSABLE_SESSION_STATUSES = {"idle", "active"}
+
+
+def check_event_sequence_integrity(events: list[dict[str, Any]]) -> CheckResult:
+    """Pure check over a window of a session's RemoteEvent replay (as
+    returned by GET .../thread): sequence numbers must be unique and, within
+    the returned window, contiguous. A duplicate is a real replay-safety
+    bug (the same event could be rendered/acted on twice by a client that
+    resumes from `last_event_id`); a gap is either dropped events or just
+    this window being truncated by the endpoint's own `limit` -- reported
+    as a WARNING, not a FAIL, since it can't be told apart from here.
+    """
+    if not events:
+        return CheckResult("Event replay integrity", "WARNING", "no events yet for this session")
+    sequences = [e.get("sequence") for e in events if isinstance(e.get("sequence"), int)]
+    if len(sequences) != len(events):
+        return CheckResult("Event replay integrity", "FAIL", "one or more events are missing a sequence number")
+    sequences.sort()
+    duplicates = {s for s in sequences if sequences.count(s) > 1}
+    if duplicates:
+        return CheckResult("Event replay integrity", "FAIL", f"duplicate sequence number(s): {sorted(duplicates)[:5]}")
+    gaps = [b for a, b in zip(sequences, sequences[1:]) if b != a + 1]
+    if gaps:
+        return CheckResult(
+            "Event replay integrity", "WARNING",
+            f"{len(gaps)} gap(s) in {len(sequences)} events checked (sequence {sequences[0]}-{sequences[-1]}) "
+            "-- may just be this check's window, or a dropped event",
+        )
+    return CheckResult("Event replay integrity", "PASS", f"{len(sequences)} events, sequence {sequences[0]}-{sequences[-1]}, no gaps or duplicates")
+
+
+async def _diagnose_session(client: RemoteAPIClient, session_id: int, workspace_root: Optional[Path]) -> list[CheckResult]:
+    """Session/workspace-snapshot/event-replay health for the *active*
+    session -- distinct from the generic connectivity checks above, this is
+    the "am I actually in the state I think I'm in" self-diagnosis."""
+    results: list[CheckResult] = []
+    try:
+        session = await client.get_session(session_id)
+    except (AuthRequiredError, RemoteAPIError) as e:
+        results.append(CheckResult("Active session", "FAIL", f"session {session_id}: {e}"))
+        return results
+
+    status = str(session.get("status") or "")
+    if status in _REUSABLE_SESSION_STATUSES:
+        results.append(CheckResult("Active session", "PASS", f"session {session_id} status={status}"))
+    else:
+        results.append(CheckResult("Active session", "WARNING", f"session {session_id} status={status} (not idle/active)"))
+
+    server_wd = session.get("working_directory")
+    if workspace_root is not None and server_wd:
+        if str(workspace_root.resolve()) == server_wd:
+            results.append(CheckResult("Session cwd matches local cwd", "PASS", server_wd))
+        else:
+            results.append(CheckResult(
+                "Session cwd matches local cwd", "WARNING",
+                f"server has {server_wd!r}, local cwd is {str(workspace_root.resolve())!r}",
+            ))
+
+    snapshot = session.get("workspace_snapshot")
+    if snapshot is None:
+        results.append(CheckResult("Workspace snapshot", "WARNING", "not scanned yet -- will populate on the first AI task"))
+    else:
+        detail = (
+            f"v{snapshot.get('file_index_version')}, "
+            f"repo={snapshot.get('repository_type')}, "
+            f"branch={snapshot.get('git_branch') or '-'}, "
+            f"last scan={snapshot.get('last_scan_at') or 'unknown'} "
+            f"(reason: {snapshot.get('scan_reason') or 'unknown'})"
+        )
+        results.append(CheckResult("Workspace snapshot", "PASS", detail))
+
+    try:
+        thread = await client.get_thread(session_id, after_sequence=0)
+        results.append(check_event_sequence_integrity(thread.get("events") or []))
+    except (AuthRequiredError, RemoteAPIError) as e:
+        results.append(CheckResult("Event replay integrity", "FAIL", str(e)))
+
+    return results
+
+
+async def run_doctor(
+    config: Config,
+    console: Console,
+    workspace_root: Optional[Path] = None,
+    *,
+    session_id: Optional[int] = None,
+) -> bool:
+    results: list[CheckResult] = []
+
+    results.append(CheckResult("Config", "PASS", f"api_base={config.api_base}"))
+
+    creds = load_credentials()
+    if creds is None:
+        results.append(CheckResult("Authentication", "FAIL", "No credentials -- run `tamfis-code login`"))
+    else:
+        results.append(CheckResult("Authentication", "PASS", f"credentials present for {creds.email or creds.user_id or 'unknown user'}"))
+
+    client = RemoteAPIClient(config, creds)
+    try:
+        try:
+            servers = await client.list_servers()
+            results.append(CheckResult("Remote API (Tier III, port 9500)", "PASS", f"{len(servers)} registered server(s)"))
+        except AuthRequiredError as e:
+            results.append(CheckResult("Remote API (Tier III, port 9500)", "FAIL", str(e)))
+            servers = None
+        except (RemoteAPIError, httpx.HTTPError) as e:
+            results.append(CheckResult("Remote API (Tier III, port 9500)", "FAIL", str(e)))
+            servers = None
+
+        if servers is not None:
+            local_server = next((s for s in servers if s.get("transport_type") == "local"), None)
+            if local_server is not None:
+                results.append(CheckResult("Local transport server", "PASS", f"server_id={local_server['id']}"))
+            else:
+                results.append(CheckResult("Local transport server", "WARNING", "none registered yet -- `tamfis-code init` will create one"))
+
+        if workspace_root is not None:
+            wr = str(workspace_root.resolve())
+            if workspace_root.is_dir():
+                results.append(CheckResult("Workspace directory", "PASS", wr))
+            else:
+                results.append(CheckResult("Workspace directory", "FAIL", f"{wr} is not a directory"))
+
+        # Tier IV reachability is inferred, not probed directly -- there is
+        # no public health endpoint on port 9555 to hit from here without
+        # a session already existing; a real ai-task submission is what
+        # actually proves the whole chain, which `doctor` deliberately does
+        # not do (it would create session/task rows as a side effect of a
+        # health check).
+        results.append(CheckResult("Tier IV (agent runtime)", "WARNING", "not directly probed -- verified indirectly via a real `tamfis-code ask`"))
+
+        if session_id is not None:
+            results.extend(await _diagnose_session(client, session_id, workspace_root))
+
+    finally:
+        await client.aclose()
+
+    for result in results:
+        style = _STATUS_STYLE[result.status]
+        console.print(f"[{style}]{result.status:8}[/{style}] {result.name}  [dim]{result.detail}[/dim]")
+
+    return all(r.status != "FAIL" for r in results)