cilydian-studio 0.1.0__tar.gz

cilydian_studio-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 sleepti3ht
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cilydian_studio-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: cilydian-studio
+Version: 0.1.0
+Summary: Textual TUI client for CiLydian: human-in-the-loop agentic CI
+Author-email: sleepti3ht <sleepti3ht@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sleepti3ht/cilydian-studio
+Project-URL: Repository, https://github.com/sleepti3ht/cilydian-studio
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cilydian>=0.2.1
+Requires-Dist: textual>=0.80
+Requires-Dist: langgraph-checkpoint-sqlite>=2.0
+Dynamic: license-file
+
+# cilydian-studio
+
+Textual TUI client for [CiLydian](https://github.com/sleepti3ht/CiLydian): human-in-the-loop agentic CI pipeline.
+
+## Installation
+
+```bash
+pip install cilydian-studio
+```
+
+## Usage
+
+```bash
+cilydian-studio "Sliding-window rate limiter: max 5 requests per 10s window"
+```
+
+The TUI will pause at interrupt points:
+- **After SPEC generation**: review spec, type `continue`, `edit <new spec>`, or `reject`
+- **At escalation** (when bounded loop exhausted): type `accept`, `retry <feedback>`, or `abort`
+
+## Commands
+
+| Command | Action |
+|---|---|
+| `continue` | Proceed to next stage |
+| `edit <text>` | Replace spec with `<text>` |
+| `reject` | Discard spec, regenerate |
+| `accept` | Accept failing gates (escalation only) |
+| `retry <feedback>` | Send feedback to coder, retry (escalation only) |
+| `abort` | Stop execution (escalation only) |
+
+## Architecture
+
+Studio is a thin client over CiLydian core:
+- **cilydian** (PyPI package): graph, gates, memory
+- **cilydian-studio**: Textual TUI + interrupt/resume loop
+
+Interrupt points use LangGraph checkpointing: state persists in SQLite, any client can resume.
+
+## Requirements
+
+- Python >= 3.12
+- cilydian >= 0.2.0 (installed automatically)
+- Local Ollama or cloud API keys (same as CiLydian)
+
+## License
+
+MIT

cilydian_studio-0.1.0/README.md

@@ -0,0 +1,48 @@
+# cilydian-studio
+
+Textual TUI client for [CiLydian](https://github.com/sleepti3ht/CiLydian): human-in-the-loop agentic CI pipeline.
+
+## Installation
+
+```bash
+pip install cilydian-studio
+```
+
+## Usage
+
+```bash
+cilydian-studio "Sliding-window rate limiter: max 5 requests per 10s window"
+```
+
+The TUI will pause at interrupt points:
+- **After SPEC generation**: review spec, type `continue`, `edit <new spec>`, or `reject`
+- **At escalation** (when bounded loop exhausted): type `accept`, `retry <feedback>`, or `abort`
+
+## Commands
+
+| Command | Action |
+|---|---|
+| `continue` | Proceed to next stage |
+| `edit <text>` | Replace spec with `<text>` |
+| `reject` | Discard spec, regenerate |
+| `accept` | Accept failing gates (escalation only) |
+| `retry <feedback>` | Send feedback to coder, retry (escalation only) |
+| `abort` | Stop execution (escalation only) |
+
+## Architecture
+
+Studio is a thin client over CiLydian core:
+- **cilydian** (PyPI package): graph, gates, memory
+- **cilydian-studio**: Textual TUI + interrupt/resume loop
+
+Interrupt points use LangGraph checkpointing: state persists in SQLite, any client can resume.
+
+## Requirements
+
+- Python >= 3.12
+- cilydian >= 0.2.0 (installed automatically)
+- Local Ollama or cloud API keys (same as CiLydian)
+
+## License
+
+MIT

cilydian_studio-0.1.0/cilydian_studio.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: cilydian-studio
+Version: 0.1.0
+Summary: Textual TUI client for CiLydian: human-in-the-loop agentic CI
+Author-email: sleepti3ht <sleepti3ht@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sleepti3ht/cilydian-studio
+Project-URL: Repository, https://github.com/sleepti3ht/cilydian-studio
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cilydian>=0.2.1
+Requires-Dist: textual>=0.80
+Requires-Dist: langgraph-checkpoint-sqlite>=2.0
+Dynamic: license-file
+
+# cilydian-studio
+
+Textual TUI client for [CiLydian](https://github.com/sleepti3ht/CiLydian): human-in-the-loop agentic CI pipeline.
+
+## Installation
+
+```bash
+pip install cilydian-studio
+```
+
+## Usage
+
+```bash
+cilydian-studio "Sliding-window rate limiter: max 5 requests per 10s window"
+```
+
+The TUI will pause at interrupt points:
+- **After SPEC generation**: review spec, type `continue`, `edit <new spec>`, or `reject`
+- **At escalation** (when bounded loop exhausted): type `accept`, `retry <feedback>`, or `abort`
+
+## Commands
+
+| Command | Action |
+|---|---|
+| `continue` | Proceed to next stage |
+| `edit <text>` | Replace spec with `<text>` |
+| `reject` | Discard spec, regenerate |
+| `accept` | Accept failing gates (escalation only) |
+| `retry <feedback>` | Send feedback to coder, retry (escalation only) |
+| `abort` | Stop execution (escalation only) |
+
+## Architecture
+
+Studio is a thin client over CiLydian core:
+- **cilydian** (PyPI package): graph, gates, memory
+- **cilydian-studio**: Textual TUI + interrupt/resume loop
+
+Interrupt points use LangGraph checkpointing: state persists in SQLite, any client can resume.
+
+## Requirements
+
+- Python >= 3.12
+- cilydian >= 0.2.0 (installed automatically)
+- Local Ollama or cloud API keys (same as CiLydian)
+
+## License
+
+MIT

cilydian_studio-0.1.0/cilydian_studio.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+cilydian_studio.egg-info/PKG-INFO
+cilydian_studio.egg-info/SOURCES.txt
+cilydian_studio.egg-info/dependency_links.txt
+cilydian_studio.egg-info/entry_points.txt
+cilydian_studio.egg-info/requires.txt
+cilydian_studio.egg-info/top_level.txt
+studio/__init__.py
+studio/app.py
+studio/session.py

cilydian_studio-0.1.0/cilydian_studio.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cilydian_studio-0.1.0/cilydian_studio.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cilydian-studio = studio.app:main_entry

cilydian_studio-0.1.0/cilydian_studio.egg-info/requires.txt

@@ -0,0 +1,3 @@
+cilydian>=0.2.1
+textual>=0.80
+langgraph-checkpoint-sqlite>=2.0

cilydian_studio-0.1.0/cilydian_studio.egg-info/top_level.txt

@@ -0,0 +1 @@
+studio

cilydian_studio-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cilydian-studio"
+version = "0.1.0"
+description = "Textual TUI client for CiLydian: human-in-the-loop agentic CI"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+authors = [{name = "sleepti3ht", email = "sleepti3ht@gmail.com"}]
+dependencies = [
+    "cilydian>=0.2.1",
+    "textual>=0.80",
+    "langgraph-checkpoint-sqlite>=2.0",
+]
+
+[project.scripts]
+cilydian-studio = "studio.app:main_entry"
+
+[project.urls]
+Homepage = "https://github.com/sleepti3ht/cilydian-studio"
+Repository = "https://github.com/sleepti3ht/cilydian-studio"
+
+[tool.setuptools]
+packages = ["studio"]

cilydian_studio-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cilydian_studio-0.1.0/studio/__init__.py

@@ -0,0 +1 @@
+"""CiLydian Studio: Textual TUI client for human-in-the-loop agentic CI."""

cilydian_studio-0.1.0/studio/app.py

@@ -0,0 +1,122 @@
+"""Minimal Textual TUI: chat with the pipeline at interrupt points."""
+
+import argparse
+
+from textual.app import App, ComposeResult
+from textual.widgets import Footer, Header, Input, RichLog
+
+from studio.session import StudioSession
+
+
+class StudioApp(App):
+    """Textual TUI for CiLydian human-in-the-loop sessions."""
+
+    CSS = """
+    RichLog {
+        height: 1fr;
+        border: solid green;
+    }
+    Input {
+        dock: bottom;
+    }
+    """
+
+    def __init__(
+        self, idea: str, run_id: str | None = None, config_path: str = "config.toml"
+    ):
+        super().__init__()
+        self.session = StudioSession(run_id=run_id, idea=idea, config_path=config_path)
+        self.title = f"CiLydian Studio: {idea[:40]}"
+        self._session_finished = False
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        self.rich_log = RichLog(markup=True, max_lines=5000)
+        yield self.rich_log
+        yield Input(
+            placeholder="continue | edit <spec> | retry <feedback> | accept | reject | abort"
+        )
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Start session and poll events."""
+        try:
+            self.session.start()
+        except Exception as exc:  # noqa: BLE001
+            self.rich_log.write(f"[red]Failed to start session:[/red] {exc}")
+            self._session_finished = True
+            return
+        self.set_interval(0.2, self._poll)
+        self.rich_log.write("[blue]Session started. Waiting for interrupt...[/blue]")
+
+    def _poll(self) -> None:
+        """Check for events from graph worker."""
+        if self._session_finished:
+            return
+
+        while not self.session.events.empty():
+            ev = self.session.events.get()
+            if ev["type"] == "interrupt":
+                payload = ev["payload"]
+                stage = payload.get("stage", "?").upper()
+                self.rich_log.write(f"[yellow]== {stage} awaits decision ==[/yellow]")
+
+                if "spec" in payload:
+                    self.rich_log.write(f"[dim]SPEC:[/dim]\n{payload['spec'][:1000]}")
+                if "verdict" in payload:
+                    self.rich_log.write(f"[dim]VERDICT:[/dim] {payload['verdict']}")
+
+                actions = payload.get("actions", [])
+                self.rich_log.write(f"[cyan]actions: {actions}[/cyan]")
+
+            elif ev["type"] == "done":
+                self.rich_log.write(f"[green]DONE[/green] {ev['verdict']}")
+                self.rich_log.write(
+                    "[dim]Session finished. Press Ctrl+C to exit.[/dim]"
+                )
+                self._session_finished = True
+
+            elif ev["type"] == "error":
+                self.rich_log.write(f"[red]ERROR:[/red] {ev['message']}")
+                self.rich_log.write("[dim]Session failed. Press Ctrl+C to exit.[/dim]")
+                self._session_finished = True
+
+    def on_input_submitted(self, msg: Input.Submitted) -> None:
+        self.rich_log.write(f"[blue]> {msg.value}[/blue]")
+        if self._session_finished:
+            self.rich_log.write("[yellow]session is over; command ignored[/yellow]")
+        elif not self.session.awaiting_decision.is_set():
+            self.rich_log.write("[yellow]no pending decision; command ignored[/yellow]")
+        else:
+            self.session.send(msg.value)
+        msg.input.value = ""
+
+    def on_exit(self) -> None:
+        """Called when TUI closes."""
+        self.session.stop()
+
+
+def main_entry() -> None:
+    """CLI entry point: cilydian-studio [--config PATH] [--run-id ID] "idea" """
+    parser = argparse.ArgumentParser(
+        description="Textual TUI for CiLydian human-in-the-loop sessions"
+    )
+    parser.add_argument("idea", nargs="+", help="one-line task description")
+    parser.add_argument(
+        "--config",
+        default="config.toml",
+        help="path to role/model config (default: config.toml in CWD)",
+    )
+    parser.add_argument(
+        "--run-id",
+        default=None,
+        help="artifact dir under runs/ (default: studio-<uuid>)",
+    )
+    args = parser.parse_args()
+    StudioApp(
+        idea=" ".join(args.idea), config_path=args.config, run_id=args.run_id
+    ).run()
+
+
+if __name__ == "__main__":
+    main_entry()

cilydian_studio-0.1.0/studio/session.py

@@ -0,0 +1,150 @@
+"""Interrupt/resume session bridge: worker thread runs the graph, TUI talks to human."""
+
+import queue
+import sqlite3
+import threading
+import uuid
+from typing import Any
+
+import cilydian.pipeline as core
+from langgraph.checkpoint.sqlite import SqliteSaver
+from langgraph.types import Command
+
+
+class StudioSession:
+    """Wraps CiLydian graph with interrupt/resume for human-in-the-loop."""
+
+    def __init__(
+        self, idea: str, run_id: str | None = None, config_path: str = "config.toml"
+    ):
+        self.run_id = run_id or f"studio-{uuid.uuid4().hex[:8]}"
+        self.idea = idea
+        self.events: queue.Queue = queue.Queue()
+        self.commands: queue.Queue = queue.Queue()
+        self.awaiting_decision = threading.Event()
+        self._worker: threading.Thread | None = None
+        self._stop_requested = threading.Event()
+
+        # Initialize core pipeline
+        core.init_from_config(config_path, hitl=True)
+        core.preflight()
+        core.begin_run(self.run_id)
+
+        # Checkpointer for interrupt/resume
+        self._db_conn = sqlite3.connect(
+            f"studio-{self.run_id}.db", check_same_thread=False
+        )
+        self.checkpointer = SqliteSaver(self._db_conn)
+        self.graph = core.build_app(checkpointer=self.checkpointer)
+        self.thread_config = {"configurable": {"thread_id": self.run_id}}
+
+    def _log(self, msg: str) -> None:
+        """Write directly to a file, bypassing Textual's stdout capture."""
+        with open("force_debug.log", "a", encoding="utf-8") as f:
+            f.write(f"{msg}\n")
+
+    def start(self) -> None:
+        """Start graph execution in worker thread."""
+        self._log("--- START CALLED ---")
+        self._spawn(None)
+
+    def _spawn(self, resume: Any) -> None:
+        self._worker = threading.Thread(target=self._run, args=(resume,), daemon=True)
+        self._worker.start()
+
+    def is_alive(self) -> bool:
+        return self._worker is not None and self._worker.is_alive()
+
+    def stop(self) -> None:
+        """Signal the graph to stop and close the DB connection."""
+        self._log("--- STOP CALLED ---")
+        self._stop_requested.set()
+        self.commands.put(None)  # Unblock get()
+        if hasattr(self, "_db_conn"):
+            try:
+                self._db_conn.close()
+            except Exception:
+                pass
+
+    def _initial_state(self) -> dict:
+        return {
+            "idea": self.idea,
+            "spec": "",
+            "spec_path": "",
+            "code": "",
+            "verdict": {},
+            "iteration": 0,
+            "human_action": "",
+            "code_hash": "",
+            "prev_code_hash": "",
+        }
+
+    def _run(self, resume: Any) -> None:
+        """Run graph; catch interrupts, wait for human decision, resume."""
+        self._log(f"--- RUN STARTED, resume={resume} ---")
+        try:
+            if resume is not None:
+                payload = Command(resume=resume)
+            else:
+                payload = self._initial_state()
+
+            self._log("Calling graph.invoke()...")
+            result = self.graph.invoke(payload, config=self.thread_config)
+            self._log("graph.invoke() returned.")
+
+            state = self.graph.get_state(self.thread_config)
+            if state.next:  # paused at an interrupt point
+                self._log("Graph paused at interrupt.")
+                value = {}
+                if state.tasks and state.tasks[0].interrupts:
+                    value = state.tasks[0].interrupts[0].value
+
+                self.events.put({"type": "interrupt", "payload": value})
+                self.awaiting_decision.set()
+
+                # Wait for command without timing out the user
+                while not self._stop_requested.is_set():
+                    try:
+                        answer = self.commands.get(timeout=0.5)
+                        if answer is None:  # Stop signal
+                            self._log("Received None command (stop). Exiting.")
+                            return
+                        self._log(f"Received command: {answer}")
+                        self.awaiting_decision.clear()
+                        self._spawn(answer)
+                        return
+                    except queue.Empty:
+                        continue
+
+                self._log("Stop requested while waiting. Exiting.")
+                return
+            else:
+                self._log("Graph finished.")
+                verdict = (
+                    (result or {}).get("verdict", {})
+                    if isinstance(result, dict)
+                    else {}
+                )
+                self.events.put({"type": "done", "verdict": verdict})
+
+        except Exception as exc:  # noqa: BLE001
+            self._log(f"EXCEPTION in _run: {type(exc).__name__}: {exc}")
+            self.events.put(
+                {"type": "error", "message": f"{type(exc).__name__}: {exc}"}
+            )
+
+    def send(self, raw: str) -> None:
+        """Parse human input and send to graph."""
+        if not self.awaiting_decision.is_set():
+            return
+
+        raw = raw.strip()
+        if raw.startswith("edit "):
+            value = {"action": "edit", "spec": raw[5:]}
+        elif raw.startswith("retry"):
+            value = {"action": "retry", "feedback": raw[5:].strip()}
+        elif raw in ("reject", "abort", "accept", "continue"):
+            value = {"action": raw}
+        else:
+            value = {"action": "continue"}
+        self.commands.put(value)