functualize-inline 0.1.0__tar.gz

functualize_inline-0.1.0/.gitignore

@@ -0,0 +1,101 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg-info/
+*.egg
+dist/
+build/
+*.whl
+
+# Agents
+.spec/archive/
+.spec/features/
+.spec/scrutiny-reports/
+.spec/.agentic-coding
+.spec/STATE.md
+.spec/PROJECT.md
+.spec/REQUIREMENTS.md
+.spec/ROADMAP.md
+.opencode/
+
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# Testing
+.coverage
+.pytest_cache/
+htmlcov/
+.hypothesis/
+snapshot_report.html
+_*_result*.txt
+_debug.txt
+_tui_debug.txt
+_tui_eval_debug.txt
+
+# IDE
+.idea/
+*.swp
+*.swo
+*~
+*.code-workspace
+
+# Coding-agent tooling state (guards — these dirs are not part of the repo)
+.kiro/
+.moai/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment / secrets
+.env
+.env.*
+!.env.example
+
+# Agent scratch space (test output, temp scripts)
+tmp/
+
+# Local-only files (not for the repo)
+*.local.md
+*.local.*
+
+# Personal notes
+HUMAN_NOTE.md
+
+# Distribution
+dist/
+
+# Documentation site build output
+site/
+
+# uv
+.python-version
+.functualize/cache.json
+.functualize_cache.json
+.todos/
+.sidecar/
+.sidecar-agent
+.sidecar-task
+.sidecar-pr
+.sidecar-start.sh
+.sidecar-base
+.td-root
+.functualize/
+.import_linter_cache/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+
+# OmO / OpenCode agent run-continuation scratch state
+.omo/
+.mcp.json
+.agentsroom/handoff-transcript-*.txt
+.agentsroom/handoff-summary-*.md
+
+# Internal pre-release audit reports (contain session IDs / local infra notes)
+.release/

functualize_inline-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: functualize-inline
+Version: 0.1.0
+Summary: Textual inline interactivity plugin for functualize prompts
+Author-email: Mohammad Hakim Adiprasetya <viltohmyst@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: functualize<1.0.0,>=0.1.0
+Requires-Dist: textual>=0.40.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# functualize-inline
+
+> **Status: Published** — Independently installable from PyPI.
+
+Textual-based inline interactivity provider for the functualize framework. This plugin renders rich terminal widgets (confirmations, selections, text inputs, progress bars) inline within the terminal using [Textual's](https://textual.textualize.io/) inline mode — without taking over the full screen. When Textual is unavailable (non-TTY, CI environments), it gracefully falls back to plain CLI `input()` prompts.
+
+## Installation
+
+```bash
+pip install functualize-inline
+```
+
+## Quick Start
+
+```python
+from functualize.plugin import PromptIntent, PromptRequest
+from functualize_inline import InlinePlugin
+
+plugin = InlinePlugin()
+
+request = PromptRequest(
+    intent=PromptIntent.CONFIRM_NEUTRAL,
+    question="Deploy to staging?",
+    default=True,
+)
+response = plugin.collect(request)
+print(f"User answered: {response.value} (source: {response.source})")
+```
+
+## Features
+
+- **Rich inline widgets** — Confirmation dialogs, single/multi-select lists, text inputs, secret inputs, and acknowledgment prompts rendered with Textual styling
+- **Automatic CLI fallback** — Detects non-TTY environments and falls back to plain `input()` prompts so jobs run unattended in CI
+- **Structured output rendering** — Implements `OutputRenderer` protocol with `render_log`, `render_phase`, and `render_progress` for formatted terminal output with icons and progress bars
+- **Timeout support** — Prompts can auto-dismiss after a configurable timeout, returning the default value
+- **Entry-point auto-discovery** — Install the package and it registers itself as an interactivity provider via the `functualize.interactivity_providers` entry point
+
+## API Reference
+
+Public classes and functions exported by this plugin:
+
+### `functualize_inline` (top-level)
+
+- `InlinePlugin` — Main plugin class implementing `InputProvider` and `OutputRenderer` protocols. Entry point for prompt collection and terminal output rendering.
+
+### `functualize_inline.apps`
+
+- `InlinePromptApp` — A short-lived Textual `App` (inline mode) that mounts a prompt widget and returns the user's response as a `(value, source)` tuple.
+
+### `functualize_inline.widgets`
+
+- `PromptResult` — Textual `Message` posted by widgets when the user provides a response. Carries `.value` and `.source` attributes.
+- `ConfirmDestructiveWidget` — Red-bordered widget requiring the user to type "yes" to confirm dangerous actions.
+- `ConfirmNeutralWidget` — Standard Y/n confirmation widget with keyboard shortcuts.
+- `SelectWidget` — Single-select `OptionList` widget (max 12 visible items).
+- `MultiSelectWidget` — Checkbox-style multi-select widget with toggle and submit.
+- `TextInputWidget` — Free-text input with optional placeholder and default value.
+- `SecretInputWidget` — Masked password input widget.
+- `AcknowledgeWidget` — Press-any-key dismiss widget for informational prompts.
+
+## Development
+
+Run plugin tests:
+
+```bash
+uv run pytest plugins/functualize-inline/tests/ -v
+```
+
+Run linting and formatting:
+
+```bash
+uv run ruff check plugins/functualize-inline/
+uv run ruff format plugins/functualize-inline/
+```

functualize_inline-0.1.0/README.md

@@ -0,0 +1,74 @@
+# functualize-inline
+
+> **Status: Published** — Independently installable from PyPI.
+
+Textual-based inline interactivity provider for the functualize framework. This plugin renders rich terminal widgets (confirmations, selections, text inputs, progress bars) inline within the terminal using [Textual's](https://textual.textualize.io/) inline mode — without taking over the full screen. When Textual is unavailable (non-TTY, CI environments), it gracefully falls back to plain CLI `input()` prompts.
+
+## Installation
+
+```bash
+pip install functualize-inline
+```
+
+## Quick Start
+
+```python
+from functualize.plugin import PromptIntent, PromptRequest
+from functualize_inline import InlinePlugin
+
+plugin = InlinePlugin()
+
+request = PromptRequest(
+    intent=PromptIntent.CONFIRM_NEUTRAL,
+    question="Deploy to staging?",
+    default=True,
+)
+response = plugin.collect(request)
+print(f"User answered: {response.value} (source: {response.source})")
+```
+
+## Features
+
+- **Rich inline widgets** — Confirmation dialogs, single/multi-select lists, text inputs, secret inputs, and acknowledgment prompts rendered with Textual styling
+- **Automatic CLI fallback** — Detects non-TTY environments and falls back to plain `input()` prompts so jobs run unattended in CI
+- **Structured output rendering** — Implements `OutputRenderer` protocol with `render_log`, `render_phase`, and `render_progress` for formatted terminal output with icons and progress bars
+- **Timeout support** — Prompts can auto-dismiss after a configurable timeout, returning the default value
+- **Entry-point auto-discovery** — Install the package and it registers itself as an interactivity provider via the `functualize.interactivity_providers` entry point
+
+## API Reference
+
+Public classes and functions exported by this plugin:
+
+### `functualize_inline` (top-level)
+
+- `InlinePlugin` — Main plugin class implementing `InputProvider` and `OutputRenderer` protocols. Entry point for prompt collection and terminal output rendering.
+
+### `functualize_inline.apps`
+
+- `InlinePromptApp` — A short-lived Textual `App` (inline mode) that mounts a prompt widget and returns the user's response as a `(value, source)` tuple.
+
+### `functualize_inline.widgets`
+
+- `PromptResult` — Textual `Message` posted by widgets when the user provides a response. Carries `.value` and `.source` attributes.
+- `ConfirmDestructiveWidget` — Red-bordered widget requiring the user to type "yes" to confirm dangerous actions.
+- `ConfirmNeutralWidget` — Standard Y/n confirmation widget with keyboard shortcuts.
+- `SelectWidget` — Single-select `OptionList` widget (max 12 visible items).
+- `MultiSelectWidget` — Checkbox-style multi-select widget with toggle and submit.
+- `TextInputWidget` — Free-text input with optional placeholder and default value.
+- `SecretInputWidget` — Masked password input widget.
+- `AcknowledgeWidget` — Press-any-key dismiss widget for informational prompts.
+
+## Development
+
+Run plugin tests:
+
+```bash
+uv run pytest plugins/functualize-inline/tests/ -v
+```
+
+Run linting and formatting:
+
+```bash
+uv run ruff check plugins/functualize-inline/
+uv run ruff format plugins/functualize-inline/
+```

functualize_inline-0.1.0/examples/README.md

@@ -0,0 +1,22 @@
+# functualize-inline Examples
+
+Inline Textual widgets for prompts, selections, and progress — rendered under your shell prompt during job runs.
+
+| Directory | Demonstrates |
+|-----------|--------------|
+| [`prompted_deploy/`](prompted_deploy/) | A job that pauses for a confirmation and a selection, rendered as inline terminal widgets |
+
+## Manual verification (interactive widgets aren't headless-testable)
+
+```bash
+cd plugins/functualize-inline/examples/prompted_deploy
+func deploy.py run
+```
+
+Expected behavior:
+
+1. A destructive-styled confirmation widget appears inline ("Deploy to production?") — y / n.
+2. On confirm, a selection list of regions appears — pick with arrows + Enter.
+3. The job continues, logging the chosen region; the widgets collapse back into the scrollback.
+
+In a headless run (CI, pipe), the same prompts resolve from their defaults instead of blocking. To drive that path in a test, substitute `AutoPrompt` from `functualize.testing`.

functualize_inline-0.1.0/examples/prompted_deploy/deploy.py

@@ -0,0 +1,26 @@
+"""A job that asks for confirmation and a region via inline widgets.
+
+With functualize-inline installed, `rc.prompt` renders real terminal
+widgets; headless runs resolve from defaults.
+
+Run with:
+    func deploy.py run
+"""
+
+from functualize.job import RunContext
+
+
+def run(rc: RunContext) -> str:
+    """Deploy after an interactive confirmation and region pick."""
+    if not rc.prompt_confirm("Deploy to production?", destructive=True, default=False):
+        rc.log("Deploy cancelled")
+        return "cancelled"
+
+    region = rc.prompt_choice(
+        "Which region?",
+        ["us-east-1", "eu-west-1", "ap-southeast-1"],
+        default="us-east-1",
+    )
+    rc.log(f"Deploying to {region}...")
+    rc.log("Deploy complete")
+    return region

functualize_inline-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "functualize-inline"
+version = "0.1.0"
+description = "Textual inline interactivity plugin for functualize prompts"
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Mohammad Hakim Adiprasetya", email = "viltohmyst@gmail.com" }
+]
+requires-python = ">=3.11"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+dependencies = [
+    "functualize>=0.1.0,<1.0.0",
+    "textual>=0.40.0",
+]
+
+[project.entry-points."functualize.interactivity_providers"]
+inline = "functualize_inline:InlinePlugin"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4.0",
+    "pytest-cov>=4.1.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.uv.sources]
+functualize = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/functualize_inline"]

functualize_inline-0.1.0/src/functualize_inline/__init__.py

@@ -0,0 +1,5 @@
+"""Functualize Inline Plugin - Textual inline interactivity for terminal prompts."""
+
+from functualize_inline.plugin import InlinePlugin
+
+__all__ = ["InlinePlugin"]

functualize_inline-0.1.0/src/functualize_inline/apps.py

@@ -0,0 +1,74 @@
+"""Textual inline applications for prompt rendering.
+
+Uses Textual's `inline=True` mode to render widgets inline within the terminal
+without taking over the full screen. Each prompt spawns a short-lived inline app
+that returns the user's response.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual import on
+from textual.app import App, ComposeResult
+
+from functualize_inline.widgets import (
+    PromptResult,
+)
+
+
+class InlinePromptApp(App[tuple[Any, str]]):
+    """A short-lived Textual app that renders a prompt widget inline.
+
+    Returns a tuple of (value, source) when the user interacts with the widget.
+    The app runs in inline mode and exits once a PromptResult message is received.
+    """
+
+    CSS = """
+    Screen {
+        layout: vertical;
+        overflow-y: auto;
+    }
+    """
+
+    BINDINGS = [
+        ("ctrl+c", "force_cancel", "Cancel"),
+    ]
+
+    def __init__(
+        self,
+        widget_class: type,
+        widget_kwargs: dict[str, Any],
+        timeout: float | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(inline=True, **kwargs)
+        self._widget_class = widget_class
+        self._widget_kwargs = widget_kwargs
+        self._timeout = timeout
+        self._timeout_timer: Any = None
+
+    def compose(self) -> ComposeResult:
+        yield self._widget_class(**self._widget_kwargs)
+
+    def on_mount(self) -> None:
+        """Start timeout timer if configured."""
+        if self._timeout is not None and self._timeout > 0:
+            self._timeout_timer = self.set_timer(self._timeout, self._on_timeout)
+
+    def _on_timeout(self) -> None:
+        """Auto-dismiss on timeout."""
+        self.exit((None, "timeout"))
+
+    @on(PromptResult)
+    def _on_prompt_result(self, message: PromptResult) -> None:
+        """Handle result from the prompt widget."""
+        if self._timeout_timer is not None:
+            self._timeout_timer.stop()
+        self.exit((message.value, message.source))
+
+    def action_force_cancel(self) -> None:
+        """Handle Ctrl+C."""
+        if self._timeout_timer is not None:
+            self._timeout_timer.stop()
+        self.exit((None, "cancelled"))