tamfis-code 0.6.13__tar.gz → 0.7.0__tar.gz

{tamfis_code-0.6.13/tamfis_code.egg-info → tamfis_code-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamfis-code
-Version: 0.6.13
+Version: 0.7.0
 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.13 → tamfis_code-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tamfis-code"
-version = "0.6.13"
+version = "0.7.0"
 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.7.0/tamfis_code/__init__.py

@@ -0,0 +1,49 @@
+"""Tamfis-Code, a standalone terminal coding agent.
+
+The package keeps import-time side effects deliberately minimal. Public
+components are loaded lazily so a missing optional module cannot prevent the
+CLI or deterministic runtime from starting.
+"""
+from __future__ import annotations
+
+from importlib import import_module
+from typing import Any
+
+__version__ = "0.7.0"
+MIN_COMPATIBLE_API_VERSION = "remote-ai-v2"
+
+_LAZY_EXPORTS: dict[str, tuple[str, str]] = {
+    "ShellCompleter": (".completion", "ShellCompleter"),
+    "MetricsTracker": (".metrics", "MetricsTracker"),
+    "StreamMetrics": (".metrics", "StreamMetrics"),
+    "AgentManager": (".agents", "AgentManager"),
+    "SubAgent": (".agents", "SubAgent"),
+    "CodeAnalyzer": (".agents", "CodeAnalyzer"),
+    "TestGenerator": (".agents", "TestGenerator"),
+    "DocGenerator": (".agents", "DocGenerator"),
+    "MCPServer": (".mcp", "MCPServer"),
+    "ToolDefinition": (".mcp", "ToolDefinition"),
+    "call_tool": (".mcp", "call_tool"),
+    "CodeIndexer": (".indexer", "CodeIndexer"),
+    "CodeSymbol": (".indexer", "CodeSymbol"),
+    "CodeFile": (".indexer", "CodeFile"),
+}
+
+__all__ = ["__version__", "MIN_COMPATIBLE_API_VERSION", *_LAZY_EXPORTS]
+
+
+def __getattr__(name: str) -> Any:
+    target = _LAZY_EXPORTS.get(name)
+    if target is None:
+        raise AttributeError(name)
+    module_name, attribute = target
+    try:
+        module = import_module(module_name, __name__)
+    except ModuleNotFoundError as exc:
+        raise AttributeError(
+            f"Optional Tamfis-Code component {name!r} is unavailable because "
+            f"module {module_name!r} is not installed."
+        ) from exc
+    value = getattr(module, attribute)
+    globals()[name] = value
+    return value

{tamfis_code-0.6.13 → tamfis_code-0.7.0}/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.13 → tamfis_code-0.7.0}/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.7.0/tamfis_code/indexer.py

@@ -0,0 +1,37 @@
+"""Small dependency-free code index used by optional public exports."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from pathlib import Path
+import re
+
+@dataclass(frozen=True)
+class CodeSymbol:
+    name: str
+    kind: str
+    line: int
+
+@dataclass
+class CodeFile:
+    path: str
+    language: str
+    symbols: list[CodeSymbol] = field(default_factory=list)
+
+class CodeIndexer:
+    def __init__(self, root: str | Path): self.root=Path(root).resolve()
+    def index_file(self, path: str | Path) -> CodeFile:
+        p=Path(path).resolve(); text=p.read_text(encoding='utf-8',errors='replace')
+        suffix=p.suffix.lower(); language={'.py':'python','.ts':'typescript','.tsx':'typescript','.js':'javascript','.jsx':'javascript'}.get(suffix,'text')
+        symbols=[]
+        patterns=[('class',re.compile(r'^\s*class\s+([A-Za-z_]\w*)')),('function',re.compile(r'^\s*(?:async\s+)?def\s+([A-Za-z_]\w*)')),('function',re.compile(r'^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)'))]
+        for n,line in enumerate(text.splitlines(),1):
+            for kind,pat in patterns:
+                m=pat.search(line)
+                if m: symbols.append(CodeSymbol(m.group(1),kind,n)); break
+        return CodeFile(str(p),language,symbols)
+    def index(self) -> list[CodeFile]:
+        result=[]
+        for p in self.root.rglob('*'):
+            if p.is_file() and p.suffix.lower() in {'.py','.ts','.tsx','.js','.jsx'} and not any(part.startswith('.') for part in p.relative_to(self.root).parts):
+                try: result.append(self.index_file(p))
+                except OSError: pass
+        return result

{tamfis_code-0.6.13 → tamfis_code-0.7.0}/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
@@ -469,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,
@@ -1294,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,
@@ -1305,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,
@@ -1404,10 +1453,11 @@ async def run_interactive(
                     "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,
@@ -1415,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}")

{tamfis_code-0.6.13 → tamfis_code-0.7.0}/tamfis_code/live_input.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import sys
-from typing import Optional
+from typing import Callable, Optional
 
 from prompt_toolkit.formatted_text import HTML
 
@@ -30,10 +30,19 @@ _CTRL_Y = b"\x19"
 class LiveInputListener:
     """Run a persistent, asynchronous follow-up editor during a task."""
 
-    def __init__(self, *, session_id: int, renderer: StreamRenderer, cli_config: Config) -> None:
+    def __init__(
+        self,
+        *,
+        session_id: int,
+        renderer: StreamRenderer,
+        cli_config: Config,
+        interrupt_callback: Optional[Callable[[str], None]] = None,
+    ) -> None:
         self.session_id = session_id
         self.renderer = renderer
         self.cli_config = cli_config
+        self._interrupt_callback = interrupt_callback
+        self._interrupt_classification: Optional[str] = None
         self._is_tty = bool(getattr(sys.stdin, "isatty", lambda: False)())
         self._input_task: Optional[asyncio.Task] = None
         self._interject_task: Optional[asyncio.Task] = None
@@ -136,11 +145,15 @@ class LiveInputListener:
 
         @bindings.add("escape")
         def _cancel_running_turn(event) -> None:
-            # Match the interrupt affordance offered by other terminal agents:
-            # Escape cancels the active turn, while the prompt remains usable
-            # for subsequent work once the runner reaches a safe boundary.
-            self._enqueue_control("cancel")
-            event.app.exit(result="")
+            # Escape cancels the active turn immediately and returns control
+            # to the ordinary REPL without terminating Tamfis-Code.
+            if self._paused or not self._active:
+                return
+
+            self._request_interrupt("cancel")
+
+            if not event.app.is_done:
+                event.app.exit(result="")
 
         session = PromptSession(key_bindings=bindings)
         self._prompt_session = session
@@ -163,9 +176,44 @@ class LiveInputListener:
                 return
             except EOFError:
                 return
+
+            # Escape sets _paused before exiting the prompt, so its empty
+            # result must not be queued or cause another editor to start.
+            if self._paused:
+                break
+
+            # A genuine line already returned by prompt_async remains valid
+            # even when the listener was deactivated during that prompt.
+            # Queue it first, then let the loop terminate cleanly.
             self._enqueue(text)
+
+            if not self._active:
+                break
+
         self._prompt_session = None
 
+    @property
+    def interrupt_classification(self) -> Optional[str]:
+        return self._interrupt_classification
+
+    def _request_interrupt(self, classification: str) -> None:
+        """Record and immediately propagate one terminal interrupt.
+
+        The durable queue item remains useful for history and recovery, but
+        immediate cancellation is delivered through interrupt_callback so a
+        blocked provider request or long-running tool does not need to reach
+        another orchestration boundary first.
+        """
+        if self._interrupt_classification is not None:
+            return
+
+        self._interrupt_classification = classification
+        self._paused = True
+        self._enqueue_control(classification)
+
+        if self._interrupt_callback is not None:
+            self._interrupt_callback(classification)
+
     def _enqueue_control(self, classification: str) -> None:
         item = local_state.enqueue_instruction(
             self.session_id, "", classification=classification,

{tamfis_code-0.6.13 → tamfis_code-0.7.0}/tamfis_code/orchestrator/engine.py

@@ -10,6 +10,7 @@ from .context import ContextBundle, build_context_bundle
 from .planner import ExecutionPlan, create_plan
 from .protocols import AgentPhase, ToolEnvelope
 from .validator import ValidationReport, validate_completion
+from ..runtime import ExecutionController, GuardDecision, ObservationDecision
 
 
 @dataclass
@@ -26,6 +27,7 @@ class OrchestrationRun:
     route: dict[str, Any] = field(default_factory=dict)
     repair_attempts: int = 0
     reasoning_plan: bool = False
+    runtime: ExecutionController = field(default_factory=ExecutionController)
 
 
 class AgentOrchestrator:
@@ -60,6 +62,7 @@ class AgentOrchestrator:
         if profile.requires_repository_context:
             self.transition(AgentPhase.INSPECT, action="Load or refresh repository context")
         self.run.plan = create_plan(objective, profile)
+        self.run.runtime.start_planning()
         plan_dict = self.run.plan.to_dict() if self.run.plan else None
         self.run.context = build_context_bundle(
             session_id=self.session_id, workspace_root=self.workspace_root,
@@ -85,6 +88,9 @@ class AgentOrchestrator:
         for the "here is the new plan" banner; this only handles state.
         """
         assert self.run is not None
+        if not self.run.runtime.record_plan_revision():
+            self.fail(self.run.runtime.snapshot.failure_reason)
+            return
         saved = local_state.save_plan(
             self.session_id, objective=self.run.objective,
             content="\n".join(f"{s.index}. {s.name}" for s in plan.steps),
@@ -120,46 +126,79 @@ class AgentOrchestrator:
         local_state.save_session_state(self.session_id, selected_provider=provider, selected_model=model)
 
     def start_execution(self) -> None:
+        assert self.run is not None
+        self.run.runtime.start_execution()
         self.transition(AgentPhase.EXECUTE, action="Execute the model/tool loop")
 
+    def guard_tool_call(self, tool_name: str, arguments: dict[str, Any]) -> GuardDecision:
+        assert self.run is not None
+        decision = self.run.runtime.guard_action(tool_name, arguments)
+        if not decision.allowed:
+            self.emit({"event_type": "diagnostics", "payload": {"content": decision.reason}})
+        return decision
+
     def waiting_for_approval(self, purpose: str) -> None:
         self.transition(AgentPhase.WAITING_FOR_APPROVAL, action=purpose)
 
-    def record_tool(self, envelope: ToolEnvelope) -> None:
+    def record_tool(self, envelope: ToolEnvelope) -> ObservationDecision:
         assert self.run is not None
         self.run.tool_records.append(envelope)
         self.transition(AgentPhase.OBSERVE, action=f"Observe {envelope.tool_name} result")
+        result = {
+            "success": bool(envelope.success),
+            "result": {
+                "stdout": envelope.stdout,
+                "stderr": envelope.stderr,
+                "exit_code": envelope.exit_code,
+                "files_changed": list(envelope.files_changed),
+                "path": envelope.arguments.get("path") or envelope.arguments.get("destination"),
+            },
+        }
+        decision = self.run.runtime.observe(envelope.tool_name, envelope.arguments, result)
         state = local_state.get_session_state(self.session_id)
         records = state.completed_actions + [{"type": "tool", **envelope.to_dict()}]
-        local_state.save_session_state(self.session_id, completed_actions=records[-250:])
-        self._advance_plan_step()
-
-    def _advance_plan_step(self) -> None:
-        """Best-effort plan-step progress: each observed tool result is real,
-        concrete evidence that execution has moved forward, so use the
-        running tool-call count to advance a cursor through the plan's
-        steps -- reserving the final step (report/validate) so it is never
-        marked done before completion actually happens. This does not claim
-        precise step-to-action correspondence (see _sync_plan_progress)."""
+        local_state.save_session_state(
+            self.session_id, completed_actions=records[-250:],
+            running_action={
+                "purpose": decision.reason or f"Observed {envelope.tool_name}",
+                "phase": self.run.runtime.snapshot.phase.value,
+                "runtime": self.run.runtime.snapshot.to_dict(),
+            },
+        )
+        self._advance_plan_step(decision)
+        if decision.terminal:
+            self.fail(decision.reason)
+        return decision
+
+    def _advance_plan_step(self, decision: ObservationDecision) -> None:
+        """Advance only when a successful observation gained useful evidence."""
         assert self.run is not None
         if self.run.plan is None or not self.run.plan.steps:
             return
-        steps = self.run.plan.steps
-        cursor = min(len(self.run.tool_records) - 1, max(len(steps) - 2, 0))
-        for step in steps[:cursor]:
-            if step.status not in {"completed", "failed"}:
-                step.status = "completed"
-        if steps[cursor].status not in {"completed", "failed"}:
-            steps[cursor].status = "in_progress"
+        active = next((step for step in self.run.plan.steps if step.status == "in_progress"), None)
+        if active is None:
+            active = next((step for step in self.run.plan.steps if step.status == "pending"), None)
+            if active is not None:
+                active.status = "in_progress"
+        if active is not None and decision.useful:
+            active.status = "completed"
+            active.evidence.extend(item for item in decision.evidence if item not in active.evidence)
+            nxt = next((step for step in self.run.plan.steps if step.status == "pending"), None)
+            if nxt is not None:
+                nxt.status = "in_progress"
         self._sync_plan_progress()
 
     def mark_repair(self, reason: str) -> None:
         assert self.run is not None
         self.run.repair_attempts += 1
+        if not self.run.runtime.record_repair():
+            self.fail(self.run.runtime.snapshot.failure_reason)
+            return
         self.transition(AgentPhase.REPAIR, action=reason)
 
     def validate(self, *, final_text: str, any_mutation: bool) -> ValidationReport:
         assert self.run is not None
+        self.run.runtime.begin_validation()
         self.transition(AgentPhase.VALIDATE, action="Validate evidence and completion claims")
         report = validate_completion(
             profile=self.run.profile,
@@ -200,12 +239,17 @@ class AgentOrchestrator:
                 )
             self._sync_plan_progress()
         self.transition(AgentPhase.REPORT, action="Report only evidence-supported outcomes")
+        if report.severity == "error":
+            self.run.runtime.fail("Completion validation failed.")
+        else:
+            self.run.runtime.complete()
         self.transition(AgentPhase.FAILED if report.severity == "error" else AgentPhase.COMPLETED)
         local_state.checkpoint(self.session_id, reason="orchestrator_complete", summary=final_text[-1000:])
         return report
 
     def fail(self, error: str) -> None:
         if self.run is not None:
+            self.run.runtime.fail(error)
             if self.run.plan is not None:
                 for step in self.run.plan.steps:
                     if step.status == "in_progress":