tamfis-code 0.2.3__py3-none-any.whl

tamfis_code/workspace.py

@@ -0,0 +1,329 @@
+"""Resolves the launch directory into a Remote session, idempotently.
+
+Implements Phase 21's "CLI entry behaviour": running `tamfis-code` from a
+directory treats that directory as workspace_root, never scans the wider
+box, and reuses (rather than re-creates) the local server/session pair for
+repeated runs from the same directory.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+import subprocess
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+from .api_client import RemoteAPIClient
+from . import state as local_state
+
+REUSABLE_STATUSES = {"idle", "active"}
+INSTRUCTION_NAMES = {"AGENTS.md", "CLAUDE.md", "CODEX.md", "CONTRIBUTING.md", "README.md"}
+REPORT_RE = re.compile(
+    r"(report|audit|analysis|architecture|implementation|codex|claude|tamfis[-_ ]?code|"
+    r"terminal|agent|roadmap|plan|findings|gaps|status|handover|review)", re.I,
+)
+REPORT_SUFFIXES = {".md", ".txt", ".json", ".yaml", ".yml", ".toml", ".log", ".pdf", ".docx"}
+IGNORED_PARTS = {".git", "node_modules", ".venv", "venv", "dist", "build", "__pycache__"}
+DISPOSABLE_UNTRACKED_PARTS = {
+    "__pycache__", ".pytest_cache", ".mypy_cache", ".ruff_cache",
+    ".tox", ".nox", ".coverage", "htmlcov", ".DS_Store",
+}
+MAX_INDEX_FILES = 20_000
+
+
+@dataclass
+class WorkspaceContext:
+    session_id: int
+    workspace_root: str
+    # None for a purely local session (see resolve_local_workspace) -- only
+    # meaningful for the legacy Remote-backend path (resolve_workspace),
+    # which this field exists to support until that path is retired.
+    server_id: Optional[int] = None
+
+
+def _next_local_session_id() -> int:
+    known = local_state.all_known_session_ids()
+    return (max(known) + 1) if known else 1
+
+
+def resolve_local_workspace(cwd: Optional[Path] = None, *, discover: bool = True) -> WorkspaceContext:
+    """Resolve a launch directory into a purely local session -- no network
+    calls, no RemoteAPIClient, no remote-assigned session/server id.
+
+    Reuses a prior session for the same workspace_root (matched by
+    `primary_workspace`, the same durable-root concept `resolve_workspace`
+    already used) rather than minting a new one on every invocation; a
+    fresh id is allocated via `_next_local_session_id()` (one past the
+    highest session id state.py already knows about) when no match exists.
+    """
+    workspace_root = str((cwd or Path.cwd()).resolve())
+
+    local_match = next((
+        sid for sid in reversed(local_state.all_known_session_ids())
+        if local_state.get_session_state(sid).primary_workspace == workspace_root
+    ), None)
+    session_id = local_match if local_match is not None else _next_local_session_id()
+
+    local_state.save_session_state(session_id, workspace_root=workspace_root)
+    if discover:
+        discover_local_repository(session_id, Path(workspace_root))
+    return WorkspaceContext(session_id=session_id, workspace_root=workspace_root)
+
+
+async def _get_or_create_local_server(client: RemoteAPIClient) -> dict:
+    servers = await client.list_servers()
+    for server in servers:
+        if server.get("transport_type") == "local":
+            return server
+    created = await client.register_local_server("local-vps")
+    return created["server"]
+
+
+async def resolve_workspace(
+    client: RemoteAPIClient, cwd: Optional[Path] = None, *, discover: bool = True,
+) -> WorkspaceContext:
+    workspace_root = str((cwd or Path.cwd()).resolve())
+
+    server = await _get_or_create_local_server(client)
+    server_id = server["id"]
+
+    # A session can move to an explicitly approved sibling workspace. Reuse
+    # it by its durable primary root rather than creating a new conversation
+    # just because its current working directory changed.
+    local_match = next((
+        sid for sid in reversed(local_state.all_known_session_ids())
+        if local_state.get_session_state(sid).primary_workspace == workspace_root
+    ), None)
+    if local_match is not None:
+        try:
+            detail = await client.get_session(local_match)
+        except Exception:
+            detail = None
+        if detail and str(detail.get("status", "")).lower() in REUSABLE_STATUSES:
+            state = local_state.get_session_state(local_match)
+            current = str(detail.get("working_directory") or state.current_working_directory or workspace_root)
+            local_state.save_session_state(
+                local_match, workspace_root=workspace_root,
+                current_working_directory=current,
+            )
+            if discover:
+                discover_local_repository(local_match, Path(current))
+            return WorkspaceContext(session_id=local_match, server_id=server_id, workspace_root=current)
+
+    sessions = await client.list_sessions()
+    existing = next(
+        (
+            s for s in sessions
+            if s.get("server_id") == server_id
+            and s.get("working_directory") == workspace_root
+            and str(s.get("status", "")).lower() in REUSABLE_STATUSES
+        ),
+        None,
+    )
+    if existing is not None:
+        local_state.save_session_state(existing["id"], workspace_root=workspace_root)
+        if discover:
+            discover_local_repository(existing["id"], Path(workspace_root))
+        return WorkspaceContext(session_id=existing["id"], server_id=server_id, workspace_root=workspace_root)
+
+    created = await client.create_session(server_id, workspace_root)
+    local_state.save_session_state(created["id"], workspace_root=workspace_root)
+    if discover:
+        discover_local_repository(created["id"], Path(workspace_root))
+    return WorkspaceContext(session_id=created["id"], server_id=server_id, workspace_root=workspace_root)
+
+
+async def context_from_session(client: RemoteAPIClient, session_id: int) -> WorkspaceContext:
+    """Builds a WorkspaceContext from an existing session_id -- used by
+    `/resume` and `tamfis-code resume`. Raises RemoteAPIError (404) if the
+    session does not exist or is not owned by the authenticated user, same
+    ownership check every other Remote endpoint already enforces."""
+    detail = await client.get_session(session_id)
+    workspace_root = detail.get("working_directory") or ""
+    local_state.save_session_state(session_id, workspace_root=workspace_root)
+    if workspace_root:
+        discover_local_repository(session_id, Path(workspace_root))
+    return WorkspaceContext(
+        session_id=detail["id"],
+        server_id=detail["server_id"],
+        workspace_root=workspace_root,
+    )
+
+
+async def find_resumable_session(client: RemoteAPIClient, *, exclude_session_id: Optional[int] = None) -> Optional[dict]:
+    """Most recent non-closed session other than the one already active --
+    `list_sessions()` is ordered by created_at desc server-side."""
+    sessions = await client.list_sessions()
+    for session in sessions:
+        if exclude_session_id is not None and session.get("id") == exclude_session_id:
+            continue
+        if str(session.get("status", "")).lower() in REUSABLE_STATUSES:
+            return session
+    return None
+
+
+def _git(root: Path, *args: str) -> str:
+    """Run a bounded, argument-safe Git query (never through a shell)."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(root), *args], capture_output=True, text=True,
+            timeout=5, check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return ""
+    return result.stdout.strip() if result.returncode == 0 else ""
+
+
+def _indexable_files(root: Path) -> list[Path]:
+    output = _git(root, "ls-files", "-co", "--exclude-standard")
+    if output:
+        return [root / item for item in output.splitlines()[:MAX_INDEX_FILES]]
+    found: list[Path] = []
+    for path in root.rglob("*"):
+        if any(part in IGNORED_PARTS for part in path.parts):
+            continue
+        if path.is_file():
+            found.append(path)
+            if len(found) >= MAX_INDEX_FILES:
+                break
+    return found
+
+
+def blocking_dirty_files(status_lines: list[str]) -> list[str]:
+    """Return entries that may represent user-authored work.
+
+    Tracked changes always block execute mode. Only untracked, well-known
+    disposable test/interpreter artefacts are ignored.
+    """
+    blocking: list[str] = []
+    for raw in status_lines:
+        line = str(raw).rstrip()
+        if not line:
+            continue
+        status = line[:2]
+        path_text = line[3:].strip() if len(line) > 3 else ""
+        parts = {part for part in Path(path_text).parts if part not in {".", ""}}
+        if status == "??" and parts.intersection(DISPOSABLE_UNTRACKED_PARTS):
+            continue
+        blocking.append(line)
+    return blocking
+
+
+def _report_title(path: Path) -> str:
+    if path.suffix.lower() in {".md", ".txt"}:
+        try:
+            for line in path.read_text(encoding="utf-8", errors="replace").splitlines()[:40]:
+                if line.lstrip().startswith("#"):
+                    return line.lstrip("# ").strip()
+        except OSError:
+            pass
+    return path.stem.replace("_", " ").replace("-", " ")
+
+
+def discover_local_repository(session_id: int, workspace_root: Path, *, force: bool = False) -> dict[str, Any]:
+    """Cache local CLI context until Git HEAD or dirty-file count changes.
+
+    The model-facing server snapshot remains authoritative. This lightweight
+    index powers offline `/context` and `/reports`, and records the worktree
+    state that existed before a task begins.
+    """
+    root_text = _git(workspace_root, "rev-parse", "--show-toplevel")
+    root = Path(root_text).resolve() if root_text else workspace_root.resolve()
+    branch = _git(root, "branch", "--show-current") or None
+    head = _git(root, "rev-parse", "HEAD") or "no-head"
+    dirty_lines = _git(root, "status", "--short").splitlines()
+    fingerprint = hashlib.sha256(
+        f"{root}|{head}|{'|'.join(dirty_lines)}".encode()
+    ).hexdigest()
+    current = local_state.get_session_state(session_id)
+    if not force and current.discovery_fingerprint == fingerprint and current.repository_context:
+        return current.repository_context
+
+    files = _indexable_files(root)
+    instructions: list[str] = []
+    reports: list[dict[str, Any]] = []
+    for path in files:
+        if path.name in INSTRUCTION_NAMES:
+            instructions.append(str(path))
+        if path.suffix.lower() in REPORT_SUFFIXES and REPORT_RE.search(path.name):
+            try:
+                modified = datetime.fromtimestamp(path.stat().st_mtime, timezone.utc).isoformat()
+            except OSError:
+                modified = ""
+            reports.append({
+                "path": str(path), "title": _report_title(path), "modified_at": modified,
+                "scope": "repository", "verification": "unverified",
+            })
+
+    context = {
+        "repository_root": str(root), "working_directory": str(workspace_root.resolve()),
+        "branch": branch, "head": None if head == "no-head" else head,
+        "dirty": bool(dirty_lines), "dirty_files": dirty_lines[:100],
+        "blocking_dirty_files": blocking_dirty_files(dirty_lines)[:100],
+        "instruction_files": sorted(instructions), "indexed_file_count": len(files),
+        "indexed_at": datetime.now(timezone.utc).isoformat(),
+    }
+    local_state.save_session_state(
+        session_id, repository_root=str(root), current_working_directory=str(workspace_root.resolve()),
+        active_branch=branch, repository_context=context,
+        discovered_reports=sorted(reports, key=lambda item: item["modified_at"], reverse=True),
+        discovery_fingerprint=fingerprint,
+    )
+    return context
+
+
+# Total instruction-file content budget for the system prompt -- generous
+# enough for a real AGENTS.md/CLAUDE.md, bounded so a huge README doesn't
+# blow the context window before the actual objective is even sent.
+MAX_INSTRUCTION_CHARS = 12_000
+
+
+def build_system_prompt(session_id: int, workspace_root: Path, *, force_discovery: bool = False) -> str:
+    """Build the standalone agent loop's system prompt from real local
+    workspace awareness (git branch/dirty status, instruction file
+    contents) -- replacing the context tamgpt6 used to assemble server-side.
+    Reuses discover_local_repository's existing fingerprint-cached scan
+    rather than re-walking the repo on every call.
+    """
+    context = discover_local_repository(session_id, workspace_root, force=force_discovery)
+    lines = [
+        "You are a coding agent working directly in a real local repository via tool calls. "
+        "Verify with tools before claiming something is done or correct. Prefer minimal, "
+        "targeted changes over broad rewrites.",
+        f"Workspace root: {context['working_directory']}",
+    ]
+    # discover_local_repository always sets repository_root (falling back to
+    # workspace_root itself when `git rev-parse --show-toplevel` fails) --
+    # `head` is the real "is this actually a Git repo" signal, since it's
+    # only None when that git call failed (see its `"no-head"` sentinel).
+    if context.get("head"):
+        lines.append(f"Git repository root: {context['repository_root']}  branch: {context.get('branch') or '(detached HEAD)'}")
+        if context.get("dirty"):
+            lines.append(
+                f"The working tree already has {len(context.get('dirty_files') or [])} uncommitted change(s) -- "
+                "be careful not to conflate your own edits with pre-existing ones when reporting what changed."
+            )
+    else:
+        lines.append("This directory is not a Git repository.")
+
+    instruction_files = context.get("instruction_files") or []
+    remaining_budget = MAX_INSTRUCTION_CHARS
+    instruction_blocks = []
+    for path_str in instruction_files:
+        if remaining_budget <= 0:
+            break
+        try:
+            content = Path(path_str).read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+        snippet = content[:remaining_budget]
+        remaining_budget -= len(snippet)
+        truncated = " (truncated)" if len(snippet) < len(content) else ""
+        instruction_blocks.append(f"--- {path_str}{truncated} ---\n{snippet}")
+    if instruction_blocks:
+        lines.append("\nProject instructions found in this repository:\n" + "\n\n".join(instruction_blocks))
+
+    return "\n".join(lines)

tamfis_code-0.2.3.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: tamfis-code
+Version: 0.2.3
+Summary: TamfisGPT Code -- standalone terminal coding agent (calls HF/NVIDIA NIM/OpenRouter/Ollama directly; --remote for the legacy TamfisGPT Remote backend)
+Project-URL: Homepage, https://github.com/tamfitronics/tamfis-code
+Project-URL: Repository, https://github.com/tamfitronics/tamfis-code
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.1
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13.0
+Requires-Dist: prompt_toolkit>=3.0
+Requires-Dist: openai>=1.30
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+
+# tamfis-code
+
+A standalone terminal coding agent. By default it calls an LLM provider
+directly — Hugging Face, NVIDIA NIM, OpenRouter, or Ollama — and runs its
+own agent loop, tool execution, and local risk/approval/mutation-ledger
+safety layer, with no separate backend process required.
+
+`--remote` (or a persistent `default_backend = "remote"` config setting)
+switches to the original architecture: a thin client to the TamfisGPT
+Remote Workspace backend, for TamfisGPT tenants using their hosted account
+the same way Codex CLI uses a ChatGPT/OpenAI account, kimi-code uses a Kimi
+account, or Claude Code uses a Claude account.
+
+## Install
+
+```
+pipx install tamfis-code
+```
+
+See [USAGE_INSTALL_RELEASE.md](./USAGE_INSTALL_RELEASE.md) for installing
+from source, using a TamfisGPT tenancy, and the release process.
+
+## Quick start
+
+```
+export OLLAMA_BASE_URL=http://localhost:11434/v1   # or set HF_TOKEN / NVIDIA_API_KEY / OPENROUTER_API_KEY
+tamfis-code doctor                                  # check provider connectivity
+tamfis-code ask "explain what this repo does"
+tamfis-code agent "add a health-check endpoint"     # full read/write/execute loop
+tamfis-code                                         # interactive REPL
+```
+
+## Providers
+
+| Provider | Env var | Notes |
+|---|---|---|
+| Ollama | `OLLAMA_BASE_URL` (default `http://localhost:11434/v1`) | Runs fully on-device, no API key |
+| Hugging Face | `HF_TOKEN` | |
+| NVIDIA NIM | `NVIDIA_API_KEY` | |
+| OpenRouter | `OPENROUTER_API_KEY` | |
+
+Select one explicitly with `--provider hf|nvidia|openrouter|ollama`, or
+leave it as `auto` (default) to pick the best configured one.
+
+## Safety model
+
+Every mutating tool call (`write_file`, `edit_file`, `execute_command`) is
+risk-classified locally (`tamfis_code/safety.py`), gated by
+`--approval-policy` (or the `/mode` REPL command), and recorded in a local
+mutation ledger — see `tamfis-code diffs` / `tamfis-code diff` /
+`tamfis-code revert`. There is no sandboxing beyond risk classification;
+review dangerous commands yourself before approving them.
+
+## License
+
+TBD — decide before the first public PyPI release (a public package still
+needs a stated license; "all rights reserved"/proprietary is a valid choice
+if you don't want redistribution/modification, but it should be explicit
+rather than absent).

tamfis_code-0.2.3.dist-info/RECORD

@@ -0,0 +1,32 @@
+tamfis_code/__init__.py,sha256=3jsx8RkmYrqwqAy5VValfJC52IJ8UdfNq531s6erOOE,2175
+tamfis_code/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+tamfis_code/agents.py,sha256=LGahD4L42zqL2BG_d81T7-0mga0dvkENxf07YwjyU38,14068
+tamfis_code/api_client.py,sha256=kKiiM25giwYpttlxFm4uwvPox1iGsQ85-TGDVEYgAIE,19989
+tamfis_code/cli.py,sha256=I7nX-MdEOZ-8Qyl7zVSKKEwMrW0_JmuvWYoZp6OzV5A,112492
+tamfis_code/completion.py,sha256=qp_CWE4fNZCPSnN4MgbaLommso_RQfOg7EBP13bJu1I,4170
+tamfis_code/config.py,sha256=5FH24a3xr4cPCKywHdpNRtMdy9nVgh7Uta0FaHgf8xQ,7642
+tamfis_code/doctor.py,sha256=G0U73C5ZMsePJV5DqVSz0fL5vvv9vmVRfXefAONFInw,7848
+tamfis_code/enforcer.py,sha256=RraE0YtETN-sk3T8vy1098ttYq9LExcdZJOU7mMzY2Y,12584
+tamfis_code/indexer.py,sha256=lQWAWQK_eDkEYwiv4vCS9H81vm6MXytK7GhHwSSlxmg,20685
+tamfis_code/instructions.py,sha256=iXL-28K8A2Or04OCfyT84yH342NW6DDgs3vpNGvvmos,3296
+tamfis_code/interactive.py,sha256=x2WjPz-V0zuSDVyGGfyw92ZzjoHmtKieoxxk_axm1Pg,55034
+tamfis_code/local_chat.py,sha256=s6A1avg5vLTxXyWgw8VRbf9tkD7ONa9gyTwP7thdjJ4,4860
+tamfis_code/local_tools.py,sha256=ixQ7UZ0LzAGtRjAuhHwUAXDY7ZmnWFw-UaSYBvSzyWA,3594
+tamfis_code/mcp.py,sha256=4RdGAQfZfQ9WO-1iqbINM9vycm7JzBLb5czpuKa8uIc,22230
+tamfis_code/metrics.py,sha256=H-WEJVQ1n767hEx7t22Wq8GpUWAYUi78zUzC6JcxThM,3588
+tamfis_code/providers.py,sha256=oFgsVAgiyGMHOjFt2cYAJLnbgw9B8LYqE9MMlJ_EY2w,15986
+tamfis_code/references.py,sha256=gOG59W-hMw0xPklHSGdFoK28OGIQ3YRr4mdtwj25SNg,12864
+tamfis_code/render.py,sha256=fgcHVkd5lyHt5osHaQwYaLgE7KvdkadzbCfmSehwi7Q,27016
+tamfis_code/runner.py,sha256=yprlHDcMH7OdJCc1BZ5hMwO4vjG48wT2u-bRQl7gfw4,27751
+tamfis_code/runner_local.py,sha256=G0hLGYdE0Hc432oRSZMWGF8UrCVRE0dLg3jsFyK9l80,18111
+tamfis_code/safety.py,sha256=kgDfFJN_NSvtLs689tsoxtj5933oCwE3bs0Zd8B2q-I,7088
+tamfis_code/screenshot.py,sha256=oHlnDIPmfRN713wA0hW_CP3kuDaICrxsfs4KwBj1FXM,13411
+tamfis_code/sessions.py,sha256=N-Y3iA5pzp6-dFM8RYuVHY7wSJCQxOMH6AWT0ipKJEw,8833
+tamfis_code/state.py,sha256=6kht9yxqKW2e7RXX8FoKSkYPXyIMD2_0xy3QnpTQqrQ,18215
+tamfis_code/tasks.py,sha256=6BreOmRIEW5Qrb5HHdCmDCcBw2lr_J5z7H_BlPcaMB4,1630
+tamfis_code/workspace.py,sha256=mCTpvtnvXGjCKBndLI9aY-PCzIrhmBqdCEIlyuZ_lv4,14383
+tamfis_code-0.2.3.dist-info/METADATA,sha256=9ZzvdhWVRU_7zIqBYHq6CHWAXrM8rmn4sK6S3fhApFE,3084
+tamfis_code-0.2.3.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+tamfis_code-0.2.3.dist-info/entry_points.txt,sha256=NctCDdh_oXnVhmrXaSJF93pFFDdt0qX93z1rAOI1PPI,118
+tamfis_code-0.2.3.dist-info/top_level.txt,sha256=P9MDS_iv9fvIMpEbGmhbOnie8ifa40owxjCiq4sk_vg,12
+tamfis_code-0.2.3.dist-info/RECORD,,

tamfis_code-0.2.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tamfis_code-0.2.3.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+tamfis = tamfis_code.cli:main
+tamfis-code = tamfis_code.cli:main
+tamgpt-code = tamfis_code.cli:main

tamfis_code-0.2.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+tamfis_code