tamfis-code 0.6.8__tar.gz → 0.6.14__tar.gz

{tamfis_code-0.6.8/tamfis_code.egg-info → tamfis_code-0.6.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamfis-code
-Version: 0.6.8
+Version: 0.6.14
 Summary: TamfisGPT Code -- portable subscription-backed terminal coding agent with local tools, PTY, plans, queues, and approvals
 Project-URL: Homepage, https://github.com/tamfitronics/tamfis-code
 Project-URL: Repository, https://github.com/tamfitronics/tamfis-code

tamfis_code-0.6.14/USAGE_INSTALL_RELEASE.md

@@ -0,0 +1,85 @@
+# Install and release TamfisGPT Code
+
+## Install on any server
+
+Use the isolated installer so the CLI does not depend on the host Python
+environment or a server-specific checkout:
+
+```bash
+./install.sh
+# Root installation: /usr/local/lib/tamfis-code + /usr/local/bin/tamfis-code
+# User installation: ~/.local/share/tamfis-code + ~/.local/bin/tamfis-code
+# Custom location:
+TAMFIS_CODE_PREFIX=/opt/tamfis-code TAMFIS_CODE_BIN_DIR=/usr/local/bin ./install.sh
+```
+
+The same package is portable to macOS and Windows. On Windows, create a
+virtual environment with `py -m venv`, install the project with `py -m pip
+install .`, and expose the virtualenv's `Scripts` directory on PATH. No
+machine-specific checkout path is compiled into the package.
+
+When managing several local projects, configure only the approved roots:
+
+```toml
+workspace_roots = ["/path/to/project-a", "/path/to/project-b"]
+```
+
+Place that in the user's `config.toml`, or use the portable environment
+variable `TAMFIS_CODE_WORKSPACE_ROOTS` (path-separated). The launch directory
+is always discovered automatically; other roots are allowed only when listed
+or explicitly approved with `tamfis-code workspace add <path>`.
+
+The runtime stores session state in the platform's user configuration
+directory. It does not require a TamfisGPT server process on the same host.
+
+## Configure the TamfisGPT subscription API
+
+Create an API key from the TamfisGPT account connected to the user's active
+iOS subscription, then set:
+
+```bash
+export TAMFIS_API_KEY='tamfis_sk_live_...'
+export TAMFIS_API_BASE='https://gpt.tamfitronics.com/api/v1/openai'
+tamfis-code doctor
+```
+
+The API key is the user's entitlement boundary. Admin credentials are not
+needed for ordinary subscribers. The API handles model access and billing;
+the installed CLI keeps workspace files, commands, PTYs, approvals, and the
+mutation ledger on the local machine.
+
+## Interactive follow-up input
+
+While a task is running, the `message>` editor remains available in the same
+terminal. Type normally and press Enter; the line is echoed with a durable
+queue ID, then applied at the next safe model-round boundary. Multiple queued
+updates are processed in order. A second terminal can enqueue the same session
+with:
+
+```bash
+tamfis-code queue "also inspect the authentication flow" --classification follow_up
+```
+
+`/queue` lists pending requests in the interactive REPL. `Ctrl+C` remains the
+interrupt/exit control. No special Ctrl+Y shortcut is required.
+
+## Build and publish a release
+
+Run the full checks, build a clean distribution, and inspect it before
+publishing:
+
+```bash
+python3 -m pytest -q
+python3 -m build
+python3 -m twine check dist/*
+```
+
+Publishing requires an account token configured in the release environment:
+
+```bash
+python3 -m twine upload dist/*
+```
+
+The GitHub repository should receive the same source revision and release
+notes as the PyPI upload. Never commit API keys, subscription tokens, local
+session state, or generated build artifacts.

{tamfis_code-0.6.8 → tamfis_code-0.6.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tamfis-code"
-version = "0.6.8"
+version = "0.6.14"
 description = "TamfisGPT Code -- portable subscription-backed terminal coding agent with local tools, PTY, plans, queues, and approvals"
 readme = "README.md"
 requires-python = ">=3.10"

{tamfis_code-0.6.8 → tamfis_code-0.6.14}/tamfis_code/__init__.py

@@ -17,7 +17,7 @@ See docs/REMOTE_AGENT_MASTER_SPEC.md, Phase 21, for the original --remote
 architecture's spec.
 """
 
-__version__ = "0.6.8"
+__version__ = "0.6.14"
 
 # Bumped whenever a CLI release requires a minimum backend Remote API
 # contract version. Only meaningful for --remote; the standalone path has no

{tamfis_code-0.6.8 → tamfis_code-0.6.14}/tamfis_code/agents.py

@@ -128,6 +128,8 @@ class CodeAnalyzer(SubAgent):
         return issues
 
 class TestGenerator(SubAgent):
+    # Application component, not a pytest test container.
+    __test__ = False
     """Generates tests for code"""
     
     def __init__(self):

{tamfis_code-0.6.8 → tamfis_code-0.6.14}/tamfis_code/cli.py

@@ -2381,3 +2381,7 @@ from .enforcer import TestEnforcer, run_enforcer, add_enforcer_command
 # flags wired to _run_shell_checks/_run_type_checks, neither of which exist on
 # TestEnforcer -- using those flags raised AttributeError at runtime.
 add_enforcer_command(cli)
+
+# Familiar GitHub CLI command surface, delegated to the installed `gh` binary.
+from .github_commands import register_github_commands
+register_github_commands(cli)

{tamfis_code-0.6.8 → tamfis_code-0.6.14}/tamfis_code/config.py

@@ -146,6 +146,11 @@ class Config:
     # 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"
+    # Additional local roots that may be used by this installation. The
+    # launch directory is always included separately; these roots make a
+    # multi-project service practical without granting access to the whole
+    # filesystem.
+    workspace_roots: list[str] = field(default_factory=list)
     sources: dict[str, str] = field(default_factory=dict)  # field -> where it came from, for `doctor`/`config`
 
     def as_dict(self) -> dict[str, Any]:
@@ -158,6 +163,7 @@ class Config:
             "debug": self.debug,
             "enable_subagent_delegation": self.enable_subagent_delegation,
             "default_backend": self.default_backend,
+            "workspace_roots": self.workspace_roots,
         }
 
 
@@ -193,6 +199,14 @@ def load_config(project_root: Optional[Path] = None) -> Config:
         if data.get("default_backend") in ("standalone", "remote"):
             cfg.default_backend = str(data["default_backend"])
             cfg.sources["default_backend"] = source_name
+        configured_roots = data.get("workspace_roots")
+        if isinstance(configured_roots, list):
+            cfg.workspace_roots = [
+                str(Path(item).expanduser().resolve())
+                for item in configured_roots
+                if isinstance(item, str) and item.strip()
+            ]
+            cfg.sources["workspace_roots"] = source_name
 
     env_api_base = os.environ.get("TAMFIS_CODE_API_BASE")
     if env_api_base:
@@ -214,6 +228,15 @@ def load_config(project_root: Optional[Path] = None) -> Config:
         cfg.default_backend = env_backend
         cfg.sources["default_backend"] = "env TAMFIS_CODE_DEFAULT_BACKEND"
 
+    env_roots = os.environ.get("TAMFIS_CODE_WORKSPACE_ROOTS")
+    if env_roots:
+        cfg.workspace_roots = [
+            str(Path(item.strip()).expanduser().resolve())
+            for item in env_roots.split(os.pathsep)
+            if item.strip()
+        ]
+        cfg.sources["workspace_roots"] = "env TAMFIS_CODE_WORKSPACE_ROOTS"
+
     return cfg
 
 

{tamfis_code-0.6.8 → tamfis_code-0.6.14}/tamfis_code/enforcer.py

@@ -20,6 +20,8 @@ except ImportError:
 
 
 class TestEnforcer:
+    # Application component, not a pytest test container.
+    __test__ = False
     """Detects and runs the current workspace's own test/build commands."""
 
     def __init__(self, workspace_root: Optional[Path] = None):

tamfis_code-0.6.14/tamfis_code/github_commands.py

@@ -0,0 +1,65 @@
+"""GitHub CLI parity commands.
+
+Tamfis-Code exposes the familiar ``gh`` command surface without reimplementing
+GitHub authentication or API semantics. Each command delegates directly to the
+installed GitHub CLI, preserves the current working directory, streams PTY/TTY
+I/O unchanged, and returns the exact child exit code.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from typing import Iterable
+
+import click
+
+GITHUB_COMMANDS: tuple[str, ...] = (
+    "alias", "api", "auth", "browse", "cache", "co", "codespace",
+    "completion", "config", "extension", "gist", "gpg-key", "issue",
+    "label", "org", "pr", "project", "release", "repo", "ruleset",
+    "run", "search", "secret", "ssh-key", "status", "variable", "workflow",
+)
+
+
+def _gh_binary() -> str:
+    binary = shutil.which("gh")
+    if not binary:
+        raise click.ClickException(
+            "GitHub CLI (`gh`) is not installed or is not available in PATH."
+        )
+    return binary
+
+
+def run_gh(subcommand: str, args: Iterable[str]) -> None:
+    """Execute one gh subcommand with transparent terminal behaviour."""
+    command = [_gh_binary(), subcommand, *args]
+    completed = subprocess.run(command, cwd=os.getcwd(), check=False)
+    if completed.returncode:
+        raise click.exceptions.Exit(completed.returncode)
+
+
+def register_github_commands(root: click.Group) -> None:
+    """Register all requested gh-compatible top-level commands."""
+    existing = set(root.commands)
+    for command_name in GITHUB_COMMANDS:
+        # Tamfis-Code owns a richer native command with the same name.
+        # Keep that native implementation rather than shadowing it.
+        if command_name in existing:
+            continue
+
+        def callback(args: tuple[str, ...], _name: str = command_name) -> None:
+            run_gh(_name, args)
+
+        command = click.Command(
+            name=command_name,
+            callback=callback,
+            params=[click.Argument(["args"], nargs=-1, type=click.UNPROCESSED)],
+            context_settings={
+                "ignore_unknown_options": True,
+                "allow_extra_args": True,
+                "help_option_names": [],
+            },
+            help=f"Delegate to `gh {command_name}` with full PTY/TTY passthrough.",
+        )
+        root.add_command(command)

{tamfis_code-0.6.8 → tamfis_code-0.6.14}/tamfis_code/interactive.py

@@ -6,6 +6,7 @@ management.
 
 from __future__ import annotations
 
+import asyncio
 import re
 from pathlib import Path
 from typing import Optional
@@ -43,7 +44,13 @@ from .custom_commands import (
 from .doctor import run_doctor
 from .live_input import LiveInputListener
 from .render import StreamRenderer, print_banner, print_error, print_recent_thread, print_resume_plan_status, print_unified_diff
-from .runner import resolve_approval_decision_async, retry_task_and_stream, run_ai_task_and_stream, run_shell_command
+from .runner import (
+    TaskOutcome,
+    resolve_approval_decision_async,
+    retry_task_and_stream,
+    run_ai_task_and_stream,
+    run_shell_command,
+)
 from .runner_local import run_local_agent_turn, run_local_shell_command
 from .pty import LocalPtyBroker
 from .safety import revert_mutation as local_revert_mutation
@@ -61,6 +68,48 @@ from .workspace import (
 # those tools only collapse genuinely large pastes.
 PASTE_COLLAPSE_LINE_THRESHOLD = 3
 
+async def _run_cancellable_local_turn(
+    *,
+    session_id: int,
+    renderer: StreamRenderer,
+    config: Config,
+    turn_coro,
+) -> TaskOutcome:
+    """Run one standalone agent turn with immediate terminal cancellation."""
+
+    agent_task = asyncio.create_task(turn_coro)
+
+    def _interrupt(_classification: str) -> None:
+        if not agent_task.done():
+            agent_task.cancel()
+
+    live_input = LiveInputListener(
+        session_id=session_id,
+        renderer=renderer,
+        cli_config=config,
+        interrupt_callback=_interrupt,
+    )
+    live_input.start()
+
+    try:
+        return await agent_task
+    except asyncio.CancelledError:
+        classification = live_input.interrupt_classification or "cancel"
+
+        if classification == "exit":
+            return TaskOutcome(
+                status="exited",
+                error="Exit requested by user",
+            )
+
+        return TaskOutcome(
+            status="cancelled",
+            error="Task cancelled by user.",
+        )
+    finally:
+        live_input.stop()
+
+
 HELP_TEXT = """\
 Natural-language text submits a full coding-agent task (mode: coding).
 $ <command>            explicit shell command
@@ -111,7 +160,7 @@ $ <command>            explicit shell command
 /mode <name>         switch mode: manual | accept-edits | auto | plan
 Shift+Tab            cycle mode without typing a command (shown in the prompt as [mode]);
                      also works while a task is already running, not just at this prompt
-Ctrl+Y               while a task is running: open the "queue next" input editor (configurable)
+message>             while a task is running: type a message and press Enter
 /model               show the active model route
 /model list [route]  list coding models (route: hf or openrouter)
 /model auto          restore Hugging Face -> OpenRouter automatic routing
@@ -372,10 +421,8 @@ async def run_interactive(
     )
     console.print(
         "[dim]Type /help for commands. Paste up to 1,000,000 characters; Alt+Enter adds a newline. "
-        "Shift+Tab cycles mode (manual/accept-edits/auto/plan) -- works while a task is running too, "
-        "not just at this prompt. Ctrl+Y opens a visible `queue next>` editor while a task is running; "
-        "your submitted text is acknowledged with a queue id and applied at the next safe round boundary. "
-        "The queue shortcut defaults to Ctrl+Y (Ctrl+T is reserved by Termius); Ctrl+D or Ctrl+C exits.[/dim]\n"
+        "While a task runs, a normal message prompt remains available: type and press Enter; "
+        "your text is queued without a special shortcut. Shift+Tab cycles mode. Ctrl+D or Ctrl+C exits.[/dim]\n"
     )
 
     CONFIG_DIR.mkdir(parents=True, exist_ok=True)
@@ -471,19 +518,19 @@ async def run_interactive(
         model_state = local_state.get_session_state(workspace.session_id)
         plan_objective = local_state.plan_execution_objective(plan)
         if standalone:
-            live_input = LiveInputListener(session_id=workspace.session_id, renderer=renderer, cli_config=config)
-            live_input.start()
-            try:
-                outcome = await run_local_agent_turn(
+            outcome = await _run_cancellable_local_turn(
+                session_id=workspace.session_id,
+                renderer=renderer,
+                config=config,
+                turn_coro=run_local_agent_turn(
                     provider_manager, provider_type, model,
                     [*conversation_history, {"role": "user", "content": plan_objective}],
                     console, renderer,
                     workspace_root=workspace.workspace_root, session_id=workspace.session_id,
                     approval_policy=config.approval_policy, interactive=True, cli_config=config,
                     allow_swarm_tool=True,
-                )
-            finally:
-                live_input.stop()
+                ),
+            )
             _append_turn_to_history(
                 conversation_history, objective=plan_objective,
                 answer=outcome.summary if outcome.status == "completed" else None,
@@ -990,7 +1037,7 @@ async def run_interactive(
                     "/mode auto           auto-approves everything, never prompts (server safeguards still apply)\n"
                     "/mode plan           read-only: propose without executing\n"
                     "Shift+Tab            cycle manual -> accept-edits -> auto -> plan without typing a command\n"
-                    "                     (also works mid-task, not just here); Ctrl+Y mid-task queues a follow-up\n"
+                    "                     (also works mid-task, not just here); type in the message prompt to queue work\n"
                     "Other raw policy values also work directly (--approval-only, no short alias): safe, workspace,\n"
                     "read-only, plan-only, suggest, full-auto, and 'never' -- note 'never' means DENY everything\n"
                     "(the opposite of what it sounds like; it is not a synonym for 'auto').[/dim]"
@@ -1296,10 +1343,11 @@ async def run_interactive(
                     print_error(console, "Existing uncommitted changes detected; retry is blocked to preserve user edits.")
                     continue
                 renderer = StreamRenderer(console, mode_label=mode_label_for_policy(config.approval_policy))
-                live_input = LiveInputListener(session_id=workspace.session_id, renderer=renderer, cli_config=config)
-                live_input.start()
-                try:
-                    outcome = await run_local_agent_turn(
+                outcome = await _run_cancellable_local_turn(
+                    session_id=workspace.session_id,
+                    renderer=renderer,
+                    config=config,
+                    turn_coro=run_local_agent_turn(
                         provider_manager, provider_type, model,
                         [*conversation_history, {"role": "user", "content": objective}],
                         console, renderer,
@@ -1307,9 +1355,8 @@ async def run_interactive(
                         approval_policy=config.approval_policy, interactive=True,
                         read_only=mode in {"chat", "audit", "plan"}, cli_config=config,
                         allow_swarm_tool=True,
-                    )
-                finally:
-                    live_input.stop()
+                    ),
+                )
                 renderer.finish()
                 _append_turn_to_history(
                     conversation_history, objective=objective,
@@ -1319,6 +1366,10 @@ async def run_interactive(
                     last_response_text = outcome.summary
                 if outcome.status == "completed" and outcome.summary and not renderer.streamed_final_text:
                     console.print(Markdown(outcome.summary))
+                if outcome.status == "exited":
+                    if local_pty is not None:
+                        local_pty.close()
+                    break
                 if outcome.status != "completed":
                     print_error(console, outcome.error or f"task {outcome.status}")
                 console.print()
@@ -1343,6 +1394,10 @@ async def run_interactive(
                     last_response_text = outcome.summary
                 if outcome.status == "completed" and outcome.summary and not renderer.streamed_final_text:
                     console.print(Markdown(outcome.summary))
+                if outcome.status == "exited":
+                    if local_pty is not None:
+                        local_pty.close()
+                    break
                 if outcome.status != "completed":
                     print_error(console, outcome.error or f"task {outcome.status}")
             except (AuthRequiredError, RemoteAPIError) as e:
@@ -1363,6 +1418,7 @@ async def run_interactive(
                 or reply_state.turn_checkpoint or reply_state.conversation_history
             ),
         )
+        submitted_text = text
         intent = parse_intent(text, custom_commands=custom_commands)
         try:
             if intent.kind == "shell":
@@ -1392,11 +1448,16 @@ async def run_interactive(
                         continue
                 renderer = StreamRenderer(console, mode_label=mode_label_for_policy(config.approval_policy))
                 model_state = local_state.get_session_state(workspace.session_id)
+                renderer.handle_event({
+                    "event_type": "user_message",
+                    "payload": {"content": submitted_text},
+                })
                 if standalone:
-                    live_input = LiveInputListener(session_id=workspace.session_id, renderer=renderer, cli_config=config)
-                    live_input.start()
-                    try:
-                        outcome = await run_local_agent_turn(
+                    outcome = await _run_cancellable_local_turn(
+                        session_id=workspace.session_id,
+                        renderer=renderer,
+                        config=config,
+                        turn_coro=run_local_agent_turn(
                             provider_manager, provider_type, model,
                             [*conversation_history, {"role": "user", "content": intent.objective}],
                             console, renderer,
@@ -1404,15 +1465,18 @@ async def run_interactive(
                             approval_policy=config.approval_policy, interactive=True,
                             read_only=intent.mode in {"chat", "audit", "plan"}, cli_config=config,
                             allow_swarm_tool=True,
-                        )
-                    finally:
-                        live_input.stop()
+                        ),
+                    )
                     renderer.finish()
                     _append_turn_to_history(
                         conversation_history, objective=intent.objective,
                         answer=outcome.summary if outcome.status == "completed" else None,
                     )
                     last_turn = (intent.objective, intent.mode)
+                    if outcome.status == "exited":
+                        if local_pty is not None:
+                            local_pty.close()
+                        break
                     if intent.mode == "plan" and outcome.status == "completed" and outcome.summary:
                         saved = local_state.save_plan(workspace.session_id, objective=intent.objective, content=outcome.summary)
                         console.print(f"[green]Plan saved[/green] · {saved.id}")