tactus 0.28.0__tar.gz → 0.29.1__tar.gz

tactus-0.29.1/.github/workflows/release.yml

@@ -0,0 +1,177 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - '**'
+  pull_request:
+    branches:
+      - '**'
+
+permissions:
+  contents: read
+
+jobs:
+  quality-checks:
+    name: Quality Checks
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+          cache: 'pip'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Run ruff linting
+        run: ruff check tactus/ tests/ features/steps/
+
+      - name: Run black formatting check
+        run: black --check tactus/ tests/ features/steps/
+
+      - name: Run pytest tests
+        run: pytest tests/ -v --tb=short -m "not integration" -n0
+
+      - name: Run behave BDD tests
+        run: behave
+
+  release:
+    name: Semantic Release
+    runs-on: ubuntu-latest
+    needs: quality-checks
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GH_TOKEN }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+          cache: 'pip'
+
+      - name: Install python-semantic-release
+        run: |
+          python -m pip install --upgrade pip
+          pip install python-semantic-release
+
+      - name: Python Semantic Release
+        env:
+          GH_TOKEN: ${{ secrets.GH_TOKEN }}
+          PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          semantic-release version
+          semantic-release publish
+
+      - name: Publish to PyPI
+        if: success() && hashFiles('dist/*') != ''
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+        run: |
+          pip install twine
+          twine upload --skip-existing dist/*
+
+  desktop-builds:
+    name: Build Desktop Apps
+    runs-on: ${{ matrix.os }}
+    needs: release
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    strategy:
+      matrix:
+        os: [macos-latest, windows-latest, ubuntu-latest]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install Python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pyinstaller
+          pip install -e .
+
+      - name: Install Node dependencies (Desktop)
+        working-directory: ./tactus-desktop
+        run: npm install
+
+      - name: Build Frontend
+        working-directory: ./tactus-desktop
+        run: npm run build:frontend
+
+      - name: Build Backend
+        working-directory: ./tactus-desktop
+        run: npm run build:backend
+
+      - name: Build Electron
+        working-directory: ./tactus-desktop
+        run: npm run build
+
+      - name: Package Application (macOS)
+        if: matrix.os == 'macos-latest'
+        working-directory: ./tactus-desktop
+        run: npm run package:mac
+
+      - name: Package Application (Windows)
+        if: matrix.os == 'windows-latest'
+        working-directory: ./tactus-desktop
+        run: npm run package:win
+
+      - name: Package Application (Linux)
+        if: matrix.os == 'ubuntu-latest'
+        working-directory: ./tactus-desktop
+        run: npm run package:linux
+
+      - name: Upload Desktop Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: desktop-${{ matrix.os }}
+          path: tactus-desktop/dist-electron/*
+
+      - name: Get latest release tag
+        id: version
+        run: |
+          # Get the latest tag created by semantic-release
+          git fetch --tags
+          LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+        shell: bash
+
+      - name: Attach Desktop Builds to Release
+        if: success()
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ steps.version.outputs.tag }}
+          files: tactus-desktop/dist-electron/*
+          fail_on_unmatched_files: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}

{tactus-0.28.0 → tactus-0.29.1}/AGENTS.md

@@ -158,6 +158,63 @@ make generate-typescript-parser
 - `tactus/validation/generated/*.py` - Python parser
 - `tactus-ide/frontend/src/validation/generated/*.ts` - TypeScript parser
 
+## Container Development Mode
+
+**IMPORTANT**: The sandbox container uses development mode to avoid constant rebuilds during active development.
+
+### What is Development Mode?
+
+Development mode (`dev_mode: true`) mounts your live Tactus source code into the container at runtime. This means:
+- Code changes are **instantly available** in containers
+- No rebuilding needed after changes
+- No version mismatch errors between host and container
+
+### How It Works
+
+The IDE automatically enables dev mode. The system finds your Tactus repository via:
+1. `TACTUS_DEV_PATH` environment variable (if set)
+2. Python module location (`tactus.__file__` when installed with `pip install -e .`)
+3. Current working directory (if it contains `tactus/` and `pyproject.toml`)
+
+### For Tactus Developers (Typical Workflow)
+
+If you installed Tactus with `pip install -e .` from a repo clone:
+- ✅ Dev mode works automatically everywhere
+- ✅ No manual configuration needed
+- ✅ No need to be in repo directory
+
+### Initial Container Build
+
+Build the container once initially:
+```bash
+docker build -t tactus-sandbox:local -f tactus/docker/Dockerfile .
+```
+
+After that, code changes are instantly available with dev mode enabled.
+
+### When Dev Mode Activates
+
+You'll see this log message:
+```
+INFO:tactus.sandbox.container_runner:[DEV MODE] Mounting live Tactus source from: /path/to/Tactus
+```
+
+If it can't find the source (e.g., PyPI-installed Tactus), you'll see:
+```
+WARNING:tactus.sandbox.container_runner:[DEV MODE] Could not locate Tactus source directory, using baked-in version
+```
+
+### When to Rebuild Container
+
+Only rebuild when:
+- Changing dependencies in `pyproject.toml`
+- Updating base system packages in Dockerfile
+- Dev mode cannot find your source (rare)
+
+**Never rebuild for regular code changes** - that's what dev mode prevents.
+
+See [docs/development-mode.md](docs/development-mode.md) for complete details.
+
 ## Tactus IDE Development
 
 When working on the Tactus IDE:

{tactus-0.28.0 → tactus-0.29.1}/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 <!-- version list -->
 
+## v0.29.1 (2026-01-15)
+
+### Bug Fixes
+
+- Add type module to tactus-desktop package.json for ES module support
+  ([`7b0bdaa`](https://github.com/AnthusAI/Tactus/commit/7b0bdaa8272f010be73137ed1f727b0bfad48827))
+
+
+## v0.29.0 (2026-01-15)
+
+### Code Style
+
+- Run black formatter on container_runner.py
+  ([`9338945`](https://github.com/AnthusAI/Tactus/commit/93389452b4a059607e4d50535b8bac348c085ab1))
+
+### Features
+
+- **desktop**: Integrate Electron desktop builds into semantic-release workflow
+  ([`77a1fbe`](https://github.com/AnthusAI/Tactus/commit/77a1fbe2e9807c1e6a6ad12c574cdae6f1687f73))
+
+
 ## v0.28.0 (2026-01-14)
 
 ### Bug Fixes

{tactus-0.28.0 → tactus-0.29.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tactus
-Version: 0.28.0
+Version: 0.29.1
 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

tactus-0.29.1/docs/development-mode.md

@@ -0,0 +1,128 @@
+# Development Mode for Sandbox Container
+
+## Problem
+
+During development, the Tactus sandbox container has the Tactus code baked in at build time. This means:
+- Every code change requires rebuilding the container
+- Forgetting to rebuild causes obscure errors from version mismatches
+- Development iteration is slow
+
+## Solution: Development Mode with Live Mounting
+
+Development mode (`dev_mode: true`) mounts your local Tactus source code into the container at runtime instead of using the baked-in version.
+
+### How It Works
+
+When `dev_mode` is enabled, the container runner:
+1. Detects the location of your Tactus repository
+2. Mounts the `tactus/` directory into the container at `/app/tactus`
+3. Python's editable install (`pip install -e .`) picks up the live code
+
+This means code changes are **immediately available** in the container without rebuilding.
+
+### Automatic Repository Detection
+
+**Important:** The detection happens on the **host machine** (where `tactus` CLI or IDE is running), not inside the container.
+
+The system automatically finds your Tactus repository in this order:
+
+1. **`TACTUS_DEV_PATH` environment variable** (explicit override)
+   ```bash
+   export TACTUS_DEV_PATH=/path/to/Tactus
+   ```
+
+2. **Python module location** (if installed with `pip install -e .`)
+   - When you run `pip install -e .` from a Tactus repo, Python remembers where the source is
+   - The code reads `tactus.__file__` which points to the actual `.py` file location
+   - Example: If `tactus` was installed from `/Users/you/Projects/Tactus`, then:
+     - `tactus.__file__` → `/Users/you/Projects/Tactus/tactus/__init__.py`
+     - Repo root → `/Users/you/Projects/Tactus`
+   - This works **even if you run from a different directory**
+
+3. **Current working directory** (if it contains `tactus/` and `pyproject.toml`)
+   - Only used if methods 1 and 2 fail
+
+### How Does This Work Remotely?
+
+**Scenario 1: Development from Tactus repo**
+- You: Clone Tactus, run `pip install -e .`, start IDE from anywhere
+- Detection: Method #2 finds it via `tactus.__file__`
+- Result: ✅ Dev mode works
+
+**Scenario 2: Installed from PyPI (`pip install tactus`)**
+- You: Client project, no Tactus repo nearby
+- Detection: `tactus.__file__` points to site-packages (not a repo)
+- Result: ❌ Dev mode cannot find source, falls back to baked-in version
+
+**Scenario 3: Multiple Tactus clones**
+- You: Have Tactus installed in multiple locations
+- Detection: Uses whichever one Python loads (first in `sys.path`)
+- Override: Set `TACTUS_DEV_PATH` to choose explicitly
+
+### When Dev Mode is Enabled
+
+**IDE (tactus-ide)**: Dev mode is **automatically enabled** by default.
+
+**CLI**: Enable via config or environment:
+```bash
+# Via environment variable
+export TACTUS_SANDBOX_DEV_MODE=true
+tactus run procedure.tac
+
+# Via config file (.tactus.toml)
+[sandbox]
+dev_mode = true
+```
+
+### When to Use Each Mode
+
+| Mode | Use Case | Rebuild Needed? |
+|------|----------|----------------|
+| **Dev Mode (dev_mode: true)** | Active development, testing changes | No - code is live mounted |
+| **Production Mode (dev_mode: false)** | Released containers, CI/CD, client usage | Yes - code is baked in |
+
+### Limitations
+
+**Dev mode only works when:**
+- Tactus was installed via `pip install -e .` from a repo clone
+- Or `TACTUS_DEV_PATH` environment variable is set
+- Or running from within a Tactus repository directory
+
+**If running from a client project with PyPI-installed Tactus:**
+- Dev mode cannot find the source (no repo exists)
+- Gracefully falls back to using the baked-in version
+- Container must be rebuilt to update (but this is expected for production use)
+
+**The key benefit:** For Tactus developers (using `pip install -e .`), dev mode works **everywhere** - you don't need to `cd` into the repo or rebuild containers during development.
+
+### Logs
+
+When dev mode activates, you'll see:
+```
+INFO:tactus.sandbox.container_runner:[DEV MODE] Mounting live Tactus source from: /path/to/Tactus
+```
+
+If it can't find the source:
+```
+WARNING:tactus.sandbox.container_runner:[DEV MODE] Could not locate Tactus source directory, using baked-in version
+```
+
+## Initial Container Build
+
+You still need to build the container once initially to get the base dependencies:
+```bash
+docker build -t tactus-sandbox:local -f tactus/docker/Dockerfile .
+```
+
+But after that, code changes are instantly available with dev mode enabled.
+
+## Future Enhancement: Published Containers
+
+For production use cases, Tactus could publish versioned containers to Docker Hub:
+- `anthus/tactus-sandbox:0.26.0`
+- `anthus/tactus-sandbox:latest`
+
+Users would then:
+- Pull the appropriate version: `docker pull anthus/tactus-sandbox:0.26.0`
+- Set `sandbox.image: "anthus/tactus-sandbox:0.26.0"` in their config
+- Never need to build containers themselves

{tactus-0.28.0 → tactus-0.29.1}/pyproject.toml

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

{tactus-0.28.0 → tactus-0.29.1}/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.28.0"
+__version__ = "0.29.1"
 
 # Core exports
 from tactus.core.runtime import TactusRuntime

{tactus-0.28.0 → tactus-0.29.1}/tactus/ide/server.py

@@ -770,7 +770,8 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                     from tactus.sandbox import is_docker_available, SandboxConfig, ContainerRunner
 
                     docker_available, docker_reason = is_docker_available()
-                    sandbox_config = SandboxConfig()
+                    # Enable dev_mode by default in IDE for live code mounting
+                    sandbox_config = SandboxConfig(dev_mode=True)
                     use_sandbox = docker_available and not sandbox_config.is_explicitly_disabled()
 
                     if use_sandbox:

{tactus-0.28.0 → tactus-0.29.1}/tactus/sandbox/config.py

@@ -111,6 +111,12 @@ class SandboxConfig(BaseModel):
         description="Maximum execution time in seconds before container is killed",
     )
 
+    # Development mode: mount live Tactus source code
+    dev_mode: bool = Field(
+        default=False,
+        description="Enable development mode: mount live Tactus source code instead of using baked-in version",
+    )
+
     def get_mcp_servers_path(self) -> Path:
         """Get the expanded MCP servers path."""
         return Path(self.mcp_servers_path).expanduser()

{tactus-0.28.0 → tactus-0.29.1}/tactus/sandbox/container_runner.py

@@ -171,6 +171,44 @@ class ContainerRunner:
         else:
             logger.debug("Sandbox is up to date")
 
+    def _find_tactus_source_dir(self) -> Optional[Path]:
+        """
+        Find the Tactus source directory for development mode.
+
+        Searches in order:
+        1. TACTUS_DEV_PATH environment variable
+        2. Directory containing the tactus module (via __file__)
+        3. Current working directory if it contains tactus/ subdirectory
+
+        Returns:
+            Path to Tactus repository root, or None if not found.
+        """
+        # Option 1: Explicit environment variable
+        env_path = os.environ.get("TACTUS_DEV_PATH")
+        if env_path:
+            path = Path(env_path).resolve()
+            if path.exists() and (path / "tactus").is_dir():
+                return path
+
+        # Option 2: Find via the tactus module location
+        try:
+            import tactus
+
+            tactus_module_path = Path(tactus.__file__).resolve()
+            # Go up from tactus/__init__.py to the repo root
+            repo_root = tactus_module_path.parent.parent
+            if (repo_root / "tactus").is_dir() and (repo_root / "pyproject.toml").exists():
+                return repo_root
+        except Exception:
+            pass
+
+        # Option 3: Check current working directory
+        cwd = Path.cwd()
+        if (cwd / "tactus").is_dir() and (cwd / "pyproject.toml").exists():
+            return cwd
+
+        return None
+
     def _build_docker_command(
         self,
         working_dir: Path,
@@ -222,6 +260,17 @@ class ContainerRunner:
         if mcp_servers_path and mcp_servers_path.exists():
             cmd.extend(["-v", f"{mcp_servers_path}:/mcp-servers:ro"])
 
+        # Development mode: mount live Tactus source code
+        if self.config.dev_mode:
+            tactus_src_dir = self._find_tactus_source_dir()
+            if tactus_src_dir:
+                logger.info(f"[DEV MODE] Mounting live Tactus source from: {tactus_src_dir}")
+                cmd.extend(["-v", f"{tactus_src_dir}/tactus:/app/tactus:ro"])
+            else:
+                logger.warning(
+                    "[DEV MODE] Could not locate Tactus source directory, using baked-in version"
+                )
+
         # Additional user-configured volumes
         for volume in self.config.volumes:
             cmd.extend(["-v", self._normalize_volume_spec(volume, base_dir=volume_base_dir)])