tactus 0.24.0__tar.gz → 0.26.0__tar.gz

{tactus-0.24.0 → tactus-0.26.0}/.gitignore

@@ -42,3 +42,4 @@ examples/output/
 
 *storybook.log
 storybook-static
+*.bak

{tactus-0.24.0 → tactus-0.26.0}/AGENTS.md

@@ -109,6 +109,25 @@ When writing commit messages:
 - Include detailed explanations in the commit body when necessary
 - Follow the Angular Commit Message Convention for the subject line
 
+## Git Branching Strategy
+
+**Branch naming conventions** - Use these prefixes for all branches:
+
+- `feature/` - New features or enhancements (e.g., `feature/preferences-ui`, `feature/mcp-server-config`)
+- `fix/` - Bug fixes (e.g., `fix/config-cascade-merge`)
+- `docs/` - Documentation changes (e.g., `docs/update-api-guide`)
+- `refactor/` - Code refactoring (e.g., `refactor/config-manager`)
+- `test/` - Test additions or improvements (e.g., `test/add-preferences-e2e`)
+
+**IMPORTANT**: Always use `feature/` prefix for feature branches, NOT `feat/` or `feat-`.
+
+**Branch workflow**:
+1. Create feature branch from `main`: `git checkout -b feature/my-feature`
+2. Make changes and commit following commit message guidelines
+3. Push to remote: `git push -u origin feature/my-feature`
+4. Create pull request to `main` branch
+5. After approval and merge, delete feature branch
+
 ## Parser Generation Requirements
 
 **IMPORTANT**: Tactus uses ANTLR4 to generate parsers from the Lua grammar for both Python and TypeScript.

{tactus-0.24.0 → tactus-0.26.0}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 <!-- version list -->
 
+## v0.26.0 (2026-01-11)
+
+### Features
+
+- Improve logging UX and fs helpers (#26) ([#26](https://github.com/AnthusAI/Tactus/pull/26),
+  [`a2a8704`](https://github.com/AnthusAI/Tactus/commit/a2a8704c1a0ab3b2cad45b9514af2152d12faa3b))
+
+
+## v0.25.0 (2026-01-11)
+
+### Features
+
+- Add IDE preferences UI with config source tracking (#25)
+  ([#25](https://github.com/AnthusAI/Tactus/pull/25),
+  [`cedf64d`](https://github.com/AnthusAI/Tactus/commit/cedf64d87f1707305283d073710ee3c6b674c44a))
+
+
 ## v0.24.0 (2026-01-11)
 
 ### Code Style

{tactus-0.24.0 → tactus-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tactus
-Version: 0.24.0
+Version: 0.26.0
 Summary: Tactus: Lua-based DSL for agentic workflows
 Project-URL: Homepage, https://github.com/AnthusAI/Tactus
 Project-URL: Documentation, https://github.com/AnthusAI/Tactus/tree/main/docs
@@ -1488,6 +1488,21 @@ tactus run workflow.tac  # If procedure has required inputs, you'll be prompted
 tactus run workflow.tac --storage file --storage-path ./data
 ```
 
+#### Logging Options
+
+The `run` command supports filtering and formatting logs:
+
+```bash
+# Show less/more output
+tactus run workflow.tac --log-level warning
+tactus run workflow.tac --log-level debug
+
+# Choose a log format
+tactus run workflow.tac --log-format rich      # default, grouped timestamps
+tactus run workflow.tac --log-format terminal  # no timestamps, higher-signal terminal output
+tactus run workflow.tac --log-format raw       # one-line-per-record, timestamped (CloudWatch-friendly)
+```
+
 The CLI automatically parses parameter types:
 - **Strings**: Direct values or quoted strings
 - **Numbers**: Integers or floats are auto-detected

{tactus-0.24.0 → tactus-0.26.0}/README.md

@@ -1437,6 +1437,21 @@ tactus run workflow.tac  # If procedure has required inputs, you'll be prompted
 tactus run workflow.tac --storage file --storage-path ./data
 ```
 
+#### Logging Options
+
+The `run` command supports filtering and formatting logs:
+
+```bash
+# Show less/more output
+tactus run workflow.tac --log-level warning
+tactus run workflow.tac --log-level debug
+
+# Choose a log format
+tactus run workflow.tac --log-format rich      # default, grouped timestamps
+tactus run workflow.tac --log-format terminal  # no timestamps, higher-signal terminal output
+tactus run workflow.tac --log-format raw       # one-line-per-record, timestamped (CloudWatch-friendly)
+```
+
 The CLI automatically parses parameter types:
 - **Strings**: Direct values or quoted strings
 - **Numbers**: Integers or floats are auto-detected

{tactus-0.24.0 → tactus-0.26.0}/SPECIFICATION.md

@@ -2457,6 +2457,24 @@ File.write(path, contents)
 File.exists(path)
 ```
 
+### Filesystem Helpers (stdlib)
+
+Workflows sometimes need to enumerate files within the sandboxed working directory (for example, iterating over documents to lint or review). Use the filesystem helper module:
+
+```lua
+local fs = require("tactus.io.fs")
+
+-- List entries in a directory (relative paths)
+local entries = fs.list_dir("chapters", {files_only = true, sort = true})
+
+-- Glob files (relative paths)
+local qmd_files = fs.glob("chapters/*.qmd", {sort = true})
+```
+
+**Security model:** Paths are restricted to the procedure working directory; absolute paths and path traversal (`..`) are rejected.
+
+**Determinism:** Filesystem contents can change between runs; wrap file enumeration and reads in `Step.checkpoint()` for durable workflows.
+
 ---
 
 ## Matchers

{tactus-0.24.0 → tactus-0.26.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tactus"
-version = "0.24.0"
+version = "0.26.0"
 description = "Tactus: Lua-based DSL for agentic workflows"
 readme = "README.md"
 requires-python = ">=3.11"

{tactus-0.24.0 → tactus-0.26.0}/tactus/__init__.py

@@ -5,7 +5,7 @@ Tactus provides a declarative workflow engine for AI agents with pluggable
 backends for storage, HITL, and chat recording.
 """
 
-__version__ = "0.24.0"
+__version__ = "0.26.0"
 
 # Core exports
 from tactus.core.runtime import TactusRuntime

{tactus-0.24.0 → tactus-0.26.0}/tactus/adapters/cli_hitl.py

@@ -32,7 +32,7 @@ class CLIHITLHandler:
             console: Rich Console instance (creates new one if not provided)
         """
         self.console = console or Console()
-        logger.info("CLIHITLHandler initialized")
+        logger.debug("CLIHITLHandler initialized")
 
     def request_interaction(self, procedure_id: str, request: HITLRequest) -> HITLResponse:
         """
@@ -45,7 +45,7 @@ class CLIHITLHandler:
         Returns:
             HITLResponse with user's response
         """
-        logger.info(f"HITL request: {request.request_type} - {request.message}")
+        logger.debug(f"HITL request: {request.request_type} - {request.message}")
 
         # Display the request in a panel
         self.console.print()

tactus-0.26.0/tactus/adapters/cost_collector_log.py

@@ -0,0 +1,56 @@
+"""
+Cost-only log handler for headless/sandbox runs.
+
+Collects CostEvent instances so the runtime can report total_cost/total_tokens,
+without enabling streaming UI behavior.
+"""
+
+from __future__ import annotations
+
+import logging
+import json
+from typing import List
+
+from tactus.protocols.models import CostEvent, LogEvent
+
+logger = logging.getLogger(__name__)
+
+
+class CostCollectorLogHandler:
+    """
+    Minimal LogHandler for sandbox runs.
+
+    This is useful in environments like Docker sandboxes where stdout is reserved
+    for protocol output, but we still want:
+    - accurate cost accounting (CostEvent)
+    - basic procedure logging (LogEvent) via stderr/Python logging
+    """
+
+    supports_streaming = False
+
+    def __init__(self):
+        self.cost_events: List[CostEvent] = []
+        logger.debug("CostCollectorLogHandler initialized")
+
+    def log(self, event: LogEvent) -> None:
+        if isinstance(event, CostEvent):
+            self.cost_events.append(event)
+            return
+
+        # Preserve useful procedure logs even when no IDE callback is present.
+        if isinstance(event, LogEvent):
+            event_logger = logging.getLogger(event.logger_name or "procedure")
+
+            msg = event.message
+            if event.context:
+                msg = f"{msg}\nContext: {json.dumps(event.context, indent=2, default=str)}"
+
+            level = (event.level or "INFO").upper()
+            if level == "DEBUG":
+                event_logger.debug(msg)
+            elif level in ("WARN", "WARNING"):
+                event_logger.warning(msg)
+            elif level == "ERROR":
+                event_logger.error(msg)
+            else:
+                event_logger.info(msg)

{tactus-0.24.0 → tactus-0.26.0}/tactus/cli/app.py

@@ -134,15 +134,92 @@ def load_tactus_config():
         return {}
 
 
-def setup_logging(verbose: bool = False):
-    """Setup logging with rich handler."""
-    level = logging.DEBUG if verbose else logging.INFO
-
-    logging.basicConfig(
-        level=level,
-        format="%(message)s",
-        handlers=[RichHandler(console=console, show_path=False, rich_tracebacks=True)],
-    )
+_LOG_LEVELS = {
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warning": logging.WARNING,
+    "warn": logging.WARNING,
+    "error": logging.ERROR,
+    "critical": logging.CRITICAL,
+}
+
+_LOG_FORMATS = {"rich", "terminal", "raw"}
+
+
+class _TerminalLogHandler(logging.Handler):
+    """Minimal, high-signal terminal logger (no timestamps/levels)."""
+
+    def __init__(self, console: Console):
+        super().__init__()
+        self._console = console
+        self.setFormatter(logging.Formatter("%(message)s"))
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            message = self.format(record)
+
+            # Make procedure-level logs the most prominent.
+            if record.name.startswith("procedure"):
+                style = "bold"
+            elif record.levelno >= logging.ERROR:
+                style = "bold red"
+            elif record.levelno >= logging.WARNING:
+                style = "yellow"
+            elif record.levelno <= logging.DEBUG:
+                style = "dim"
+            else:
+                style = ""
+
+            self._console.print(message, style=style, markup=False, highlight=False)
+        except Exception:
+            self.handleError(record)
+
+
+def setup_logging(
+    verbose: bool = False,
+    log_level: Optional[str] = None,
+    log_format: str = "rich",
+) -> None:
+    """Setup CLI logging (level + format)."""
+    if log_level is None:
+        level = logging.DEBUG if verbose else logging.INFO
+    else:
+        key = str(log_level).strip().lower()
+        if key not in _LOG_LEVELS:
+            raise typer.BadParameter(
+                f"Invalid --log-level '{log_level}'. "
+                f"Use one of: {', '.join(sorted(_LOG_LEVELS.keys()))}"
+            )
+        level = _LOG_LEVELS[key]
+
+    fmt = (log_format or "rich").strip().lower()
+    if fmt not in _LOG_FORMATS:
+        raise typer.BadParameter(
+            f"Invalid --log-format '{log_format}'. Use one of: {', '.join(sorted(_LOG_FORMATS))}"
+        )
+
+    # Default: rich logs (group repeated timestamps).
+    if fmt == "rich":
+        handler: logging.Handler = RichHandler(
+            console=console,
+            show_path=False,
+            rich_tracebacks=True,
+            omit_repeated_times=True,
+        )
+        handler.setFormatter(logging.Formatter("%(message)s"))
+        logging.basicConfig(level=level, format="%(message)s", handlers=[handler], force=True)
+        return
+
+    # Raw logs: one line per entry, CloudWatch-friendly.
+    if fmt == "raw":
+        handler = logging.StreamHandler(stream=sys.stderr)
+        handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s"))
+        logging.basicConfig(level=level, handlers=[handler], force=True)
+        return
+
+    # Terminal logs: no timestamps/levels, color by signal.
+    handler = _TerminalLogHandler(console)
+    logging.basicConfig(level=level, handlers=[handler], force=True)
 
 
 def _parse_value(value_str: str, field_type: str) -> Any:
@@ -352,6 +429,12 @@ def run(
         None, envvar="OPENAI_API_KEY", help="OpenAI API key"
     ),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+    log_level: Optional[str] = typer.Option(
+        None, "--log-level", help="Log level: debug, info, warning, error, critical"
+    ),
+    log_format: str = typer.Option(
+        "rich", "--log-format", help="Log format: rich (default), terminal, raw"
+    ),
     param: Optional[list[str]] = typer.Option(None, help="Parameters in format key=value"),
     interactive: bool = typer.Option(
         False, "--interactive", "-i", help="Interactively prompt for all inputs"
@@ -399,7 +482,7 @@ def run(
         # Use real implementation for specific tools while mocking others
         tactus run workflow.tac --mock-all --real done
     """
-    setup_logging(verbose)
+    setup_logging(verbose=verbose, log_level=log_level, log_format=log_format)
 
     # Check if file exists
     if not workflow_file.exists():
@@ -530,6 +613,12 @@ def run(
         sandbox_config_dict["enabled"] = sandbox
     sandbox_config = SandboxConfig(**sandbox_config_dict)
 
+    # Pass logging preferences through to the sandbox container so container stderr matches CLI UX.
+    sandbox_config.env.setdefault(
+        "TACTUS_LOG_LEVEL", str(log_level or ("debug" if verbose else "info"))
+    )
+    sandbox_config.env.setdefault("TACTUS_LOG_FORMAT", str(log_format))
+
     # Check Docker availability
     docker_available, docker_reason = is_docker_available()
 
@@ -1179,6 +1268,7 @@ def test(
             ("aws", "access_key_id"): "AWS_ACCESS_KEY_ID",
             ("aws", "secret_access_key"): "AWS_SECRET_ACCESS_KEY",
             ("aws", "default_region"): "AWS_DEFAULT_REGION",
+            ("aws", "profile"): "AWS_PROFILE",
         }
 
         for config_key, env_key in env_mappings.items():