tilde-agent 0.1.1__py3-none-any.whl

tilde/__init__.py

@@ -0,0 +1,32 @@
+"""
+tilde - A production-grade, terminal-based AI/Agentic coding harness.
+
+This package provides a Python implementation of an AI coding agent with:
+- Enhanced security (7-Pillar architecture)
+- Rich terminal UI (Rich + Textual)
+- Multi-provider LLM support
+- Built-in tools (read, write, bash, search, etc.)
+- Web search and browser capabilities
+- GitHub operations
+- System monitoring
+- Security auditing
+- MCP support
+- Subagents
+- Plan mode
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("tilde-agent")
+except PackageNotFoundError:  # source checkout without install
+    __version__ = "0.0.0+dev"
+
+__author__ = "tilde Team"
+__description__ = "Terminal-based AI/Agentic coding harness"
+
+# Import key modules for convenience
+from tilde.cli import app
+from tilde.main import main
+
+__all__ = ["__version__", "app", "main"]

tilde/cli.py

@@ -0,0 +1,283 @@
+"""
+tilde CLI module.
+
+This module defines the command-line interface for tilde using Typer.
+It handles argument parsing, mode selection, and application initialization.
+"""
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from tilde.logging import configure_logging, get_logger
+from tilde.tracing import setup_tracing
+
+# Module logger (configured at startup in main())
+logger = get_logger(__name__)
+
+
+# Create the Typer app
+app = typer.Typer(
+    name="tilde",
+    help="A production-grade, terminal-based AI/Agentic coding harness",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+
+@app.command()
+def main(
+    # Model selection
+    model: Annotated[
+        str | None,
+        typer.Option(
+            "--model",
+            "-m",
+            help="Model to use (e.g., 'gpt-4', 'claude-3-5-sonnet', 'llama-3.1-70b')",
+        ),
+    ] = None,
+    # Provider selection
+    provider: Annotated[
+        str | None,
+        typer.Option(
+            "--provider",
+            "-p",
+            help="LLM provider (e.g., 'openai', 'anthropic', 'openrouter')",
+        ),
+    ] = None,
+    # Session management
+    session: Annotated[
+        str | None,
+        typer.Option(
+            "--session",
+            "-s",
+            help="Session name or ID to continue",
+        ),
+    ] = None,
+    continue_session: Annotated[
+        bool,
+        typer.Option(
+            "--continue",
+            "-c",
+            help="Continue the most recent session",
+        ),
+    ] = False,
+    no_session: Annotated[
+        bool,
+        typer.Option(
+            "--no-session",
+            help="Run in ephemeral mode without saving session",
+        ),
+    ] = False,
+    # Context files
+    context_files: Annotated[
+        bool,
+        typer.Option(
+            "--no-context-files",
+            "-nc",
+            help="Disable loading of AGENTS.md and other context files",
+        ),
+    ] = True,  # Default to loading context files
+    # Mode selection
+    mode: Annotated[
+        str | None,
+        typer.Option(
+            "--mode",
+            help="Execution mode: 'interactive' (default), 'json', 'rpc', 'print'",
+        ),
+    ] = None,
+    # TUI mode
+    tui_mode: Annotated[
+        str | None,
+        typer.Option(
+            "--tui-mode",
+            help="TUI mode: 'alternate' (default), 'regular' (main-screen)",
+        ),
+    ] = None,
+    # Thinking level
+    thinking: Annotated[
+        str | None,
+        typer.Option(
+            "--thinking",
+            help="Thinking level: 'off', 'minimal', 'low', 'medium', 'high', 'max'",
+        ),
+    ] = None,
+    # Accept-edits mode (spec section 26.5)
+    accept_edits: Annotated[
+        bool,
+        typer.Option(
+            "--accept-edits",
+            help="Auto-approve project-local write/edit calls (bash still asks)",
+        ),
+    ] = False,
+    # Plan mode (read-only research + plan output)
+    plan: Annotated[
+        bool,
+        typer.Option(
+            "--plan",
+            help="Plan mode: read-only, write/edit/bash are refused",
+        ),
+    ] = False,
+    # Verbose output
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose",
+            "-v",
+            help="Enable verbose output",
+        ),
+    ] = False,
+    # Files to attach (repeatable option; only messages are positional)
+    files: Annotated[
+        list[Path] | None,
+        typer.Option(
+            "--file",
+            help="Files to attach to the prompt (repeatable, use @ prefix)",
+        ),
+    ] = None,
+    # Messages
+    messages: Annotated[
+        list[str] | None,
+        typer.Argument(
+            help="Initial messages/prompts",
+        ),
+    ] = None,
+) -> None:
+    """
+    Main tilde command.
+
+    This is the primary entry point for the tilde CLI. It handles:
+    - Model and provider selection
+    - Session management
+    - Context file loading
+    - Mode selection (interactive, JSON, RPC, print)
+    - File attachments
+    - Initial messages
+
+    Examples:
+        tilde "Fix the bug in auth.py"
+        tilde --model gpt-4 --provider openai "Review this PR"
+        tilde --continue
+        tilde --mode json "List all files"
+        tilde @src/auth.py "What does this do?"
+    """
+
+    # Initialize logging and tracing (once, for the whole app).
+    # Tracing stays off outside interactive mode so span output
+    # never pollutes machine-readable stdout (json/rpc/print).
+    configure_logging(verbose=verbose, json_format=(mode in ("json", "rpc")))
+    setup_tracing(enabled=(mode == "interactive"))
+
+    # Discover MCP tools before any mode builds tool schemas.
+    # Failures are logged, never fatal: MCP is optional.
+    import asyncio
+
+    from tilde.runtime import mcp as mcp_integration
+    from tilde.runtime import skills
+
+    try:
+        skills.discover()
+    except Exception as exc:
+        logger.error(f"Skill discovery failed: {exc}")
+
+    try:
+        discovered = asyncio.run(mcp_integration.discover())
+    except Exception as exc:
+        logger.error(f"MCP discovery failed: {exc}")
+        discovered = []
+    if discovered:
+        logger.info(f"MCP tools registered: {', '.join(discovered)}")
+
+    # Normalize optional list arguments (Typer defaults are None)
+    files = files or []
+    messages = messages or []
+
+    logger.debug(f"Starting tilde with model={model}, provider={provider}, mode={mode}")
+
+    # Determine execution mode
+    if mode == "json":
+        # JSON event stream mode
+        from tilde.runtime.modes.json_mode import run_json_mode
+
+        run_json_mode(
+            model=model,
+            provider=provider,
+            messages=messages,
+            files=files,
+            thinking=thinking,
+            accept_edits=accept_edits,
+            plan_mode=plan,
+        )
+    elif mode == "rpc":
+        # RPC mode (stdin/stdout)
+        from tilde.runtime.modes.rpc_mode import run_rpc_mode
+
+        run_rpc_mode(
+            model=model,
+            provider=provider,
+            thinking=thinking,
+            accept_edits=accept_edits,
+            plan_mode=plan,
+        )
+    elif mode == "print":
+        # Print mode (single response, then exit)
+        from tilde.runtime.modes.print_mode import run_print_mode
+
+        run_print_mode(
+            model=model,
+            provider=provider,
+            messages=messages,
+            files=files,
+            thinking=thinking,
+            accept_edits=accept_edits,
+            plan_mode=plan,
+            verbose=verbose,
+        )
+    else:
+        # Interactive TUI mode (default)
+        from tilde.runtime.modes.interactive import run_interactive_mode
+
+        run_interactive_mode(
+            model=model,
+            provider=provider,
+            session=session,
+            continue_session=continue_session,
+            no_session=no_session,
+            context_files=context_files,
+            tui_mode=tui_mode,
+            thinking=thinking,
+            files=files,
+            messages=messages,
+            accept_edits=accept_edits,
+            plan_mode=plan,
+        )
+
+
+def version_callback(value: bool) -> None:
+    """Callback for version flag."""
+    if value:
+        from tilde import __version__
+
+        typer.echo(f"tilde version {__version__}")
+        raise typer.Exit()
+
+
+# Add version flag
+@app.callback()
+def common(
+    version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            callback=version_callback,
+            is_eager=True,
+            help="Show version and exit",
+        ),
+    ] = False,
+) -> None:
+    pass
+
+
+if __name__ == "__main__":
+    app()

tilde/logging.py

@@ -0,0 +1,74 @@
+"""
+Central logging setup for tilde.
+
+One function to configure logging for the whole app.
+Uses structlog so every log line carries the same fields
+(name, level, timestamp) in plain text or JSON.
+
+Usage:
+    from tilde.logging import configure_logging, get_logger
+
+    configure_logging(verbose=True)   # once, at startup (cli.py does this)
+    log = get_logger(__name__)        # in any module
+    log.info("agent started", model="gpt-4")
+"""
+
+import logging
+
+import structlog
+
+_configured = False
+
+
+def configure_logging(verbose: bool = False, json_format: bool = False) -> None:
+    """
+    Set up logging once at startup. Safe to call more than once.
+
+    Args:
+        verbose: True for DEBUG output, False for INFO.
+        json_format: True for machine-readable JSON lines (for
+            the `json` / `rpc` runtime modes and log collectors).
+    """
+    global _configured
+
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(level=level)
+    logging.getLogger().setLevel(level)
+
+    renderer = (
+        structlog.processors.JSONRenderer()
+        if json_format
+        else structlog.dev.ConsoleRenderer(colors=False)
+    )
+
+    structlog.configure(
+        processors=[
+            structlog.contextvars.merge_contextvars,
+            structlog.stdlib.add_log_level,
+            structlog.stdlib.PositionalArgumentsFormatter(),
+            structlog.processors.TimeStamper(fmt="iso"),
+            structlog.processors.StackInfoRenderer(),
+            structlog.processors.format_exc_info,
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=True,
+    )
+
+    formatter = structlog.stdlib.ProcessorFormatter(
+        processor=renderer,
+        foreign_pre_chain=[
+            structlog.stdlib.add_log_level,
+            structlog.processors.TimeStamper(fmt="iso"),
+        ],
+    )
+    handler = logging.getLogger().handlers[0]
+    handler.setFormatter(formatter)
+
+    _configured = True
+
+
+def get_logger(name: str) -> structlog.stdlib.BoundLogger:
+    """Return a logger for the given module name."""
+    return structlog.get_logger(name)

tilde/main.py

@@ -0,0 +1,29 @@
+"""
+tilde main entry point.
+
+This module provides the main entry point for the tilde CLI application.
+It initializes the application and handles the command-line interface.
+"""
+
+from tilde.cli import app
+
+
+def main() -> None:
+    """
+    Main entry point for the tilde command.
+
+    This function is called when the user runs `tilde` from the command line.
+    It initializes the CLI application and executes it.
+
+    The CLI application handles:
+    - Command-line argument parsing
+    - Application initialization
+    - TUI or non-interactive mode selection
+    - Error handling and exit codes
+    """
+    # Execute the CLI application
+    app()
+
+
+if __name__ == "__main__":
+    main()

tilde/runtime/__init__.py

@@ -0,0 +1,16 @@
+"""
+Agent Runtime package.
+
+This package contains the core agent runtime components:
+- agent: Main agent class and runtime
+- model: LLM provider integrations
+- tools: Built-in tool implementations
+- session: Session management and compaction
+- queue: Message queue for steering/follow-up
+- context: Context file loading
+- policy: Security policies and permissions
+"""
+
+from tilde.runtime.agent import AgentRuntime
+
+__all__ = ["AgentRuntime"]

tilde/runtime/_streaming.py

@@ -0,0 +1,261 @@
+"""Streaming response parsing helpers (split from agent.py).
+
+Zero behavior change: moved verbatim. Imports only stdlib +
+logging + tool types, never agent.py (no circular import).
+"""
+
+import json
+import re
+import uuid
+from typing import Any
+
+from tilde.logging import get_logger
+from tilde.runtime.tools.base import ToolCall
+
+log = get_logger(__name__)
+
+
+def _as_tool_call(tool_call: ToolCall | dict) -> ToolCall:
+    """
+    Normalize a tool call to a ToolCall.
+
+    Providers and the streaming parser produce plain dicts;
+    internal code uses ToolCall objects. Accept either.
+    Model arguments arrive as JSON strings; tools need dicts.
+    """
+    if isinstance(tool_call, ToolCall):
+        if isinstance(tool_call.arguments, str):
+            tool_call = ToolCall(
+                id=tool_call.id,
+                name=tool_call.name,
+                arguments=_parse_arguments(tool_call.arguments),
+            )
+        return tool_call
+    raw_arguments = tool_call.get("arguments", {})
+    return ToolCall(
+        id=tool_call.get("id", ""),
+        name=tool_call.get("name", ""),
+        arguments=_parse_arguments(raw_arguments),
+    )
+
+
+def _parse_arguments(raw: Any) -> dict:
+    """Parse JSON-string arguments to a dict; pass dicts through."""
+    if isinstance(raw, dict):
+        return raw
+    if isinstance(raw, str) and raw.strip():
+        try:
+            parsed = json.loads(raw)
+            return parsed if isinstance(parsed, dict) else {}
+        except (json.JSONDecodeError, ValueError):
+            return {}
+    return {}
+
+
+class StreamingResponseParser:
+    """
+    Parser for streaming model responses that may contain tool calls.
+
+    This class buffers streaming chunks and attempts to parse tool calls
+    from the response as it arrives. It handles:
+    - Buffering partial JSON responses
+    - Detecting complete tool call objects
+    - Parsing tool calls from various model response formats
+    - Error recovery for malformed JSON
+    """
+
+    # Maximum buffer size to prevent memory issues
+    MAX_BUFFER_SIZE = 100000  # 100KB
+
+    def __init__(self) -> None:
+        """Initialize the parser."""
+        self._buffer = ""
+        self._tool_calls: list[dict] = []
+        self._complete = False
+        self._current_chunk_type = None  # 'text' or 'tool_call'
+        self._error: str | None = None
+
+    def add_chunk(self, chunk: str) -> list[dict]:
+        """
+        Add a chunk of response text and parse any tool calls.
+
+        Args:
+            chunk: Chunk of text from the streaming response
+
+        Returns:
+            List of parsed tool calls (if any)
+        """
+        if not chunk:
+            return []
+
+        # Truncate buffer if it gets too large
+        self._buffer += chunk
+        if len(self._buffer) > self.MAX_BUFFER_SIZE:
+            # Keep the last 50KB to avoid losing context
+            self._buffer = self._buffer[-50000:]
+
+        # Try to parse tool calls from the buffer
+        try:
+            new_tool_calls = self._try_parse_tool_calls()
+            if new_tool_calls:
+                self._tool_calls.extend(new_tool_calls)
+            return new_tool_calls
+        except Exception as e:
+            # Log the error but don't fail
+            self._error = f"Parse error: {e!s}"
+            return []
+
+    def _try_parse_tool_calls(self) -> list[dict]:
+        """
+        Try to parse tool calls from the buffered content.
+
+        This handles different model response formats:
+        - OpenAI: tool_calls in message
+        - Anthropic: tool_use blocks
+        - Generic: JSON with tool_calls field
+
+        Returns:
+            List of parsed tool calls
+        """
+        tool_calls = []
+
+        # Try to find complete JSON objects in the buffer
+        # Look for patterns like: {"tool_calls": [...]}
+        # Or Anthropic format: {"type": "tool_use", ...}
+
+        # Pattern 1: OpenAI/Generic format - look for tool_calls
+        tool_call_pattern = r'"tool_calls"\s*:\s*\[([^\]]*)\]'
+        match = re.search(tool_call_pattern, self._buffer)
+        if match:
+            try:
+                # Extract the tool_calls array
+                tool_calls_str = match.group(1)
+                # Try to parse it as JSON
+                if tool_calls_str.strip():
+                    # This is a simplified parser - in production, use a proper JSON parser
+                    # that can handle partial JSON
+                    tool_calls = self._parse_tool_calls_array(tool_calls_str)
+            except Exception:
+                # Partial chunks routinely fail to parse; debug only
+                log.debug("tool_calls_parse_retry")
+
+        # Pattern 2: Anthropic format - look for tool_use
+        tool_use_pattern = r'"type"\s*:\s*"tool_use"[^}]+\}'
+        matches = re.findall(tool_use_pattern, self._buffer)
+        for match in matches:
+            try:
+                tool_call = self._parse_anthropic_tool_call(match)
+                if tool_call:
+                    tool_calls.append(tool_call)
+            except Exception:
+                log.debug("anthropic_tool_parse_retry")
+
+        return tool_calls
+
+    def _parse_tool_calls_array(self, array_str: str) -> list[dict]:
+        """
+        Parse a tool_calls JSON array string.
+
+        Args:
+            array_str: String containing a JSON array of tool calls
+
+        Returns:
+            List of parsed tool call dicts
+        """
+        # Simple parsing - in production, use a streaming JSON parser
+        tool_calls = []
+
+        # Try to parse as JSON
+        try:
+            import json
+
+            parsed = json.loads(f"[{array_str}]")
+            if isinstance(parsed, list):
+                for item in parsed:
+                    if isinstance(item, dict):
+                        tool_calls.append(self._normalize_tool_call(item))
+        except Exception:
+            # If parsing fails, try to extract individual tool calls
+            # This is a fallback for partial JSON
+            log.debug("tool_array_parse_retry")
+
+        return tool_calls
+
+    def _parse_anthropic_tool_call(self, tool_use_str: str) -> dict | None:
+        """
+        Parse an Anthropic tool_use block.
+
+        Args:
+            tool_use_str: String containing a tool_use JSON object
+
+        Returns:
+            Parsed tool call dict or None
+        """
+        try:
+            import json
+
+            # Add braces if needed
+            if not tool_use_str.startswith("{"):
+                tool_use_str = "{" + tool_use_str
+            if not tool_use_str.endswith("}"):
+                tool_use_str = tool_use_str + "}"
+
+            parsed = json.loads(tool_use_str)
+            return self._normalize_tool_call(parsed)
+        except Exception:
+            return None
+
+    def _normalize_tool_call(self, tool_call: dict) -> dict:
+        """
+        Normalize a tool call dict to our internal format.
+
+        Args:
+            tool_call: Raw tool call dict from model
+
+        Returns:
+            Normalized tool call dict
+        """
+        # Handle OpenAI format
+        if "function" in tool_call:
+            return {
+                "id": tool_call.get("id", str(uuid.uuid4())),
+                "name": tool_call["function"].get("name", ""),
+                "arguments": tool_call["function"].get("arguments", {}),
+            }
+
+        # Handle Anthropic format
+        if tool_call.get("type") == "tool_use":
+            return {
+                "id": tool_call.get("id", str(uuid.uuid4())),
+                "name": tool_call.get("name", ""),
+                "arguments": tool_call.get("input", {}),
+            }
+
+        # Handle generic format
+        return {
+            "id": tool_call.get("id", str(uuid.uuid4())),
+            "name": tool_call.get("name", ""),
+            "arguments": tool_call.get("arguments", {}),
+        }
+
+    def get_tool_calls(self) -> list[dict]:
+        """
+        Get all parsed tool calls.
+
+        Returns:
+            List of all tool calls found so far
+        """
+        return self._tool_calls.copy()
+
+    def is_complete(self) -> bool:
+        """
+        Check if the response is complete.
+
+        Returns:
+            True if the response is complete
+        """
+        return self._complete
+
+    def mark_complete(self) -> None:
+        """Mark the response as complete."""
+        self._complete = True