cilydian 0.1.3__tar.gz

cilydian-0.1.3/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-0.1.3/PKG-INFO

@@ -0,0 +1,271 @@
+Metadata-Version: 2.4
+Name: cilydian
+Version: 0.1.3
+Summary: Self-hosted agentic CI pipeline with spec-driven codegen
+Author-email: sleepti3ht <sleepti3ht@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sleepti3ht/CiLydian
+Project-URL: Repository, https://github.com/sleepti3ht/CiLydian
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langgraph>=1.0
+Requires-Dist: langchain-ollama>=1.0
+Requires-Dist: langchain-openai>=1.0
+Dynamic: license-file
+
+<div align="center">
+
+# CiLydian
+
+[![python](https://img.shields.io/badge/Python-3.12%2B-fdf6e3?style=flat&logo=python&logoColor=657b83)](https://python.org)
+[![langgraph](https://img.shields.io/badge/LangGraph-1.0%2B-b58900?style=flat)](https://langchain-ai.github.io/langgraph/)
+[![status](https://img.shields.io/badge/status-active-859900?style=flat)](https://github.com)
+[![license](https://img.shields.io/badge/license-MIT-fdf6e3?style=flat)](LICENSE)
+
+</div>
+
+> Self-hosted agentic CI pipeline on LangGraph: **spec → coder → LLM judge (advisory) → deterministic gates (ruff + pytest)**, with a bounded repair loop and human escalation. Models are pluggable per role — local Ollama or any OpenAI-compatible endpoint.
+
+---
+
+## Why CiLydian?
+
+Most multi-agent coding tools stop at "generate and hope." CiLydian treats LLM output as untrusted input: mechanical gates (ruff, pytest) are the source of truth, the LLM judge is advisory feedback, and the loop is bounded. If the pipeline can't converge in `MAX_ITER`, it exits with a status code and the full log — never hangs, never burns tokens indefinitely.
+
+Compared to AutoGen Studio or CrewAI: those are chat-orchestration frameworks. CiLydian is a **CI primitive** — it runs, exits with a status code, and can be wired into git hooks, GitHub Actions, or cron.
+
+---
+
+## Quick Start
+
+```bash
+# Clone and setup
+git clone https://github.com/sleepti3ht/cilydian.git
+cd cilydian
+
+# Unix / macOS
+python -m venv .venv && source .venv/bin/activate
+# Windows (PowerShell)
+python -m venv .venv; .\.venv\Scripts\Activate.ps1
+
+pip install -r requirements.txt
+
+# Run with local Ollama (default)
+python pipeline.py "Your task description"
+
+# Or use cloud profile (free tiers)
+cp config.cloud.toml.example config.toml
+cp .env.example .env  # fill with OpenRouter/Groq keys
+python pipeline.py "Your task description"
+```
+
+Stack: `langgraph`, `langchain-ollama`, `langchain-openai`, `ruff`, `pytest`. See `requirements.txt`.
+
+---
+
+## Features
+
+### Core
+- **Spec-driven generation**: turn one-line ideas into a `SPEC.md` and a `test_candidate.py` skeleton before any code is written
+- **Bounded repair loop**: coder iterates on judge feedback up to `MAX_ITER` times, then escalates to a human
+- **Advisory LLM judge**: semantic review that never blocks on its own verdict (see [Design notes](#design-notes))
+- **Deterministic gates**: `ruff` (auto-fix + check) and `pytest`; these are what actually block the pipeline
+- **Short-circuit**: pytest is skipped if ruff fails, saves 10–20s per failed cycle
+- **Config-driven models**: mix Ollama local and OpenAI-compatible cloud per role
+- **Rate-limit resilience**: exponential backoff for 429s on free tiers
+- **UTF-8 on Windows**: subprocess encoding prevents `cp1251` mojibake in logs
+
+### Reliability
+- **Defensive JSON parsing**: judge verdicts normalized via `try: int(float(raw))`
+- **Programmatic guardrail**: `score < 4` with `verdict="pass"` is auto-downgraded to `fail` (see [Design notes](#design-notes))
+- **Markdown fence stripping**: handles LLM code wrapped in \`\`\` fences
+- **Log rotation**: 5 MB cap with atomic `os.replace()`; single writer, no race
+- **Isolated gates**: `logs/ruff.toml` and `logs/pytest.ini` are auto-created on first run to prevent parent-config bleed
+- **Preflight checks**: verifies `ruff` / `pytest` are on PATH and the coder endpoint is reachable before spending a single token
+
+---
+
+## Design notes
+
+**The judge is advisory, the guardrails are not.** Local 7B–14B judges drift beyond SPEC — they request absent features, over- or under-rate code, and sometimes contradict themselves. So the LLM's verdict alone never blocks the pipeline. A separate programmatic rule handles one specific pathological case: if the LLM outputs `verdict="pass"` while scoring below 4, the guardrail downgrades it to `fail`. That's not the judge blocking — it's a deterministic check that doesn't trust a self-contradicting model. Mechanical gates (ruff, pytest) remain the ultimate source of truth.
+
+**The repair loop is bounded on purpose.** `MAX_ITER` (default 3) caps attempts. Exhaustion means human escalation, not a hang. On complex tasks this may give up earlier than a human reviewer would prefer — acceptable for CI, where the cost of a false-negative is a re-run, not a lost afternoon.
+
+**Mechanical fixes belong to the tool.** `ruff --fix` runs before `ruff check` and auto-corrects imports and formatting. LLM tokens are too expensive for style fixes a Rust binary does in 40 milliseconds.
+
+---
+
+## Architecture
+
+```mermaid
+flowchart LR
+    classDef solarizedBase3 fill:#fdf6e3,stroke:#93a1a1,color:#657b83,stroke-width:1px
+    classDef solarizedBase02 fill:#eee8d5,stroke:#93a1a1,color:#586e75,stroke-width:1px
+    classDef solarizedYellow fill:#b58900,stroke:#b58900,color:#fdf6e3,stroke-width:2px
+    classDef solarizedOrange fill:#cb4b16,stroke:#cb4b16,color:#fdf6e3,stroke-width:2px
+    classDef solarizedGreen fill:#859900,stroke:#859900,color:#fdf6e3,stroke-width:2px
+    classDef solarizedBlue fill:#268bd2,stroke:#268bd2,color:#fdf6e3,stroke-width:2px
+    classDef solarizedCyan fill:#2aa198,stroke:#2aa198,color:#fdf6e3,stroke-width:2px
+
+    A[idea]:::solarizedYellow
+    S[spec_writer<br>role: spec]:::solarizedBlue
+    C[coder<br>role: coder]:::solarizedGreen
+    J[judge<br>advisory]:::solarizedOrange
+    T[tester<br>ruff + pytest]:::solarizedCyan
+    E[final verdict<br>exit code]:::solarizedBase02
+
+    A --> S
+    S --> C
+    C --> J
+    J -->|advisory| T
+    T -->|fail and iter < max_iter| C
+    T -->|pass or budget exhausted| E
+```
+
+---
+
+## Configuration
+
+### Local Ollama profile (default)
+
+```toml
+# config.toml
+[pipeline]
+max_iter = 3
+judge_blocking = false
+
+[roles.spec]
+provider = "ollama"
+model = "qwen2.5-coder:7b"
+
+[roles.coder]
+provider = "ollama"
+model = "qwen2.5-coder:7b"
+
+[roles.judge]
+provider = "ollama"
+model = "qwen2.5:14b"
+```
+
+### Cloud hybrid profile (free tiers)
+
+```toml
+# config.cloud.toml.example
+[pipeline]
+max_iter = 3
+judge_blocking = false
+
+[roles.spec]
+provider = "openai_compat"
+base_url = "https://openrouter.ai/api/v1"
+model = "deepseek/deepseek-chat"
+api_key_env = "OPENROUTER_API_KEY"
+
+[roles.coder]
+provider = "openai_compat"
+base_url = "https://openrouter.ai/api/v1"
+model = "deepseek/deepseek-chat"
+api_key_env = "OPENROUTER_API_KEY"
+
+[roles.judge]
+provider = "openai_compat"
+base_url = "https://api.groq.com/openai/v1"
+model = "llama-3.3-70b-versatile"
+api_key_env = "GROQ_API_KEY"
+```
+
+```bash
+# .env
+OPENROUTER_API_KEY=your_key_here
+GROQ_API_KEY=your_key_here
+```
+
+> ⚠️ Never commit `.env` — keep secrets private. Config references env var names, not values.
+
+---
+
+## Performance
+
+| Metric | Local (7B coder) | Cloud (frontier) |
+|---|---|---|
+| Coder throughput | ~15 tok/s | ~50–100 tok/s |
+| Judge throughput | ~3–6 tok/s (partial CPU offload) | ~30–60 tok/s |
+| Full cycle wall time | 4–15 min | 1–3 min |
+| Exit code | 0 = gates passed, 1 = failed | 0 = gates passed, 1 = failed |
+
+**Typical run:**
+
+```log
+[preflight] ruff: OK
+[preflight] pytest: OK
+[preflight] coder endpoint: reachable
+[spec] Generated SPEC.md + test_candidate.py (1.2s)
+[coder] Iteration 1/3 — wrote candidate.py (3.4s)
+[judge] score=3, verdict=fail (advisory)
+[tester] ruff rc=0, pytest rc=1 (fail)
+[coder] Iteration 2/3 — fixed issues (2.8s)
+[judge] score=4, verdict=pass (advisory)
+[tester] ruff rc=0, pytest rc=0 (pass)
+✓ Pipeline completed: gates passed (exit code 0)
+```
+
+---
+
+## Honest Limitations
+
+- **Local models (7b-14b) fail convergence** on mid-complexity tasks (e.g., sliding-window rate limiter with exact boolean return) within 3 iterations.
+- **Cloud free-tier models (Groq gpt-oss-120b)** provide better judge quality but have rate limits (200K tokens/day).
+- **CiLydian is an experiment and portfolio artifact**, not a daily development tool. For production code, use manual multi-vendor workflow (DeepSeek/Qwen for prompting, Claude for architecture, Gemini for review, local ruff/pytest for gates).
+
+---
+
+## Screenshot
+
+![CiLydian Terminal](screenshots/terminal.png)
+
+---
+
+## Roadmap
+
+- [ ] **GitHub Actions integration** — trigger CiLydian on issue labels
+- [ ] **Multi-language support** — extend beyond Python (JavaScript, Go)
+- [ ] **Persistent state** — resume interrupted runs from checkpoint
+- [ ] **Web dashboard** — visualize pipeline runs and logs
+- [ ] **Plugin system** — custom gates beyond ruff/pytest (mypy, bandit)
+
+---
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a PR.
+
+### Development setup
+
+```bash
+git clone https://github.com/sleepti3ht/cilydian.git
+cd cilydian
+
+# Unix / macOS
+python -m venv .venv && source .venv/bin/activate
+# Windows (PowerShell)
+python -m venv .venv; .\.venv\Scripts\Activate.ps1
+
+pip install -r requirements.txt
+pip install pre-commit
+pre-commit install  # enforces ruff + pytest on commit
+
+# Run the pipeline on a sample task
+python pipeline.py "Test task"
+```
+
+### Code style
+
+- Commit messages: Conventional Commits (`feat(pipeline): ...`, `fix(tester): ...`)
+- Run `ruff check` and `pytest` before pushing (enforced by pre-commit)
+
+---
+
+## License
+
+MIT

cilydian-0.1.3/README.md

@@ -0,0 +1,255 @@
+<div align="center">
+
+# CiLydian
+
+[![python](https://img.shields.io/badge/Python-3.12%2B-fdf6e3?style=flat&logo=python&logoColor=657b83)](https://python.org)
+[![langgraph](https://img.shields.io/badge/LangGraph-1.0%2B-b58900?style=flat)](https://langchain-ai.github.io/langgraph/)
+[![status](https://img.shields.io/badge/status-active-859900?style=flat)](https://github.com)
+[![license](https://img.shields.io/badge/license-MIT-fdf6e3?style=flat)](LICENSE)
+
+</div>
+
+> Self-hosted agentic CI pipeline on LangGraph: **spec → coder → LLM judge (advisory) → deterministic gates (ruff + pytest)**, with a bounded repair loop and human escalation. Models are pluggable per role — local Ollama or any OpenAI-compatible endpoint.
+
+---
+
+## Why CiLydian?
+
+Most multi-agent coding tools stop at "generate and hope." CiLydian treats LLM output as untrusted input: mechanical gates (ruff, pytest) are the source of truth, the LLM judge is advisory feedback, and the loop is bounded. If the pipeline can't converge in `MAX_ITER`, it exits with a status code and the full log — never hangs, never burns tokens indefinitely.
+
+Compared to AutoGen Studio or CrewAI: those are chat-orchestration frameworks. CiLydian is a **CI primitive** — it runs, exits with a status code, and can be wired into git hooks, GitHub Actions, or cron.
+
+---
+
+## Quick Start
+
+```bash
+# Clone and setup
+git clone https://github.com/sleepti3ht/cilydian.git
+cd cilydian
+
+# Unix / macOS
+python -m venv .venv && source .venv/bin/activate
+# Windows (PowerShell)
+python -m venv .venv; .\.venv\Scripts\Activate.ps1
+
+pip install -r requirements.txt
+
+# Run with local Ollama (default)
+python pipeline.py "Your task description"
+
+# Or use cloud profile (free tiers)
+cp config.cloud.toml.example config.toml
+cp .env.example .env  # fill with OpenRouter/Groq keys
+python pipeline.py "Your task description"
+```
+
+Stack: `langgraph`, `langchain-ollama`, `langchain-openai`, `ruff`, `pytest`. See `requirements.txt`.
+
+---
+
+## Features
+
+### Core
+- **Spec-driven generation**: turn one-line ideas into a `SPEC.md` and a `test_candidate.py` skeleton before any code is written
+- **Bounded repair loop**: coder iterates on judge feedback up to `MAX_ITER` times, then escalates to a human
+- **Advisory LLM judge**: semantic review that never blocks on its own verdict (see [Design notes](#design-notes))
+- **Deterministic gates**: `ruff` (auto-fix + check) and `pytest`; these are what actually block the pipeline
+- **Short-circuit**: pytest is skipped if ruff fails, saves 10–20s per failed cycle
+- **Config-driven models**: mix Ollama local and OpenAI-compatible cloud per role
+- **Rate-limit resilience**: exponential backoff for 429s on free tiers
+- **UTF-8 on Windows**: subprocess encoding prevents `cp1251` mojibake in logs
+
+### Reliability
+- **Defensive JSON parsing**: judge verdicts normalized via `try: int(float(raw))`
+- **Programmatic guardrail**: `score < 4` with `verdict="pass"` is auto-downgraded to `fail` (see [Design notes](#design-notes))
+- **Markdown fence stripping**: handles LLM code wrapped in \`\`\` fences
+- **Log rotation**: 5 MB cap with atomic `os.replace()`; single writer, no race
+- **Isolated gates**: `logs/ruff.toml` and `logs/pytest.ini` are auto-created on first run to prevent parent-config bleed
+- **Preflight checks**: verifies `ruff` / `pytest` are on PATH and the coder endpoint is reachable before spending a single token
+
+---
+
+## Design notes
+
+**The judge is advisory, the guardrails are not.** Local 7B–14B judges drift beyond SPEC — they request absent features, over- or under-rate code, and sometimes contradict themselves. So the LLM's verdict alone never blocks the pipeline. A separate programmatic rule handles one specific pathological case: if the LLM outputs `verdict="pass"` while scoring below 4, the guardrail downgrades it to `fail`. That's not the judge blocking — it's a deterministic check that doesn't trust a self-contradicting model. Mechanical gates (ruff, pytest) remain the ultimate source of truth.
+
+**The repair loop is bounded on purpose.** `MAX_ITER` (default 3) caps attempts. Exhaustion means human escalation, not a hang. On complex tasks this may give up earlier than a human reviewer would prefer — acceptable for CI, where the cost of a false-negative is a re-run, not a lost afternoon.
+
+**Mechanical fixes belong to the tool.** `ruff --fix` runs before `ruff check` and auto-corrects imports and formatting. LLM tokens are too expensive for style fixes a Rust binary does in 40 milliseconds.
+
+---
+
+## Architecture
+
+```mermaid
+flowchart LR
+    classDef solarizedBase3 fill:#fdf6e3,stroke:#93a1a1,color:#657b83,stroke-width:1px
+    classDef solarizedBase02 fill:#eee8d5,stroke:#93a1a1,color:#586e75,stroke-width:1px
+    classDef solarizedYellow fill:#b58900,stroke:#b58900,color:#fdf6e3,stroke-width:2px
+    classDef solarizedOrange fill:#cb4b16,stroke:#cb4b16,color:#fdf6e3,stroke-width:2px
+    classDef solarizedGreen fill:#859900,stroke:#859900,color:#fdf6e3,stroke-width:2px
+    classDef solarizedBlue fill:#268bd2,stroke:#268bd2,color:#fdf6e3,stroke-width:2px
+    classDef solarizedCyan fill:#2aa198,stroke:#2aa198,color:#fdf6e3,stroke-width:2px
+
+    A[idea]:::solarizedYellow
+    S[spec_writer<br>role: spec]:::solarizedBlue
+    C[coder<br>role: coder]:::solarizedGreen
+    J[judge<br>advisory]:::solarizedOrange
+    T[tester<br>ruff + pytest]:::solarizedCyan
+    E[final verdict<br>exit code]:::solarizedBase02
+
+    A --> S
+    S --> C
+    C --> J
+    J -->|advisory| T
+    T -->|fail and iter < max_iter| C
+    T -->|pass or budget exhausted| E
+```
+
+---
+
+## Configuration
+
+### Local Ollama profile (default)
+
+```toml
+# config.toml
+[pipeline]
+max_iter = 3
+judge_blocking = false
+
+[roles.spec]
+provider = "ollama"
+model = "qwen2.5-coder:7b"
+
+[roles.coder]
+provider = "ollama"
+model = "qwen2.5-coder:7b"
+
+[roles.judge]
+provider = "ollama"
+model = "qwen2.5:14b"
+```
+
+### Cloud hybrid profile (free tiers)
+
+```toml
+# config.cloud.toml.example
+[pipeline]
+max_iter = 3
+judge_blocking = false
+
+[roles.spec]
+provider = "openai_compat"
+base_url = "https://openrouter.ai/api/v1"
+model = "deepseek/deepseek-chat"
+api_key_env = "OPENROUTER_API_KEY"
+
+[roles.coder]
+provider = "openai_compat"
+base_url = "https://openrouter.ai/api/v1"
+model = "deepseek/deepseek-chat"
+api_key_env = "OPENROUTER_API_KEY"
+
+[roles.judge]
+provider = "openai_compat"
+base_url = "https://api.groq.com/openai/v1"
+model = "llama-3.3-70b-versatile"
+api_key_env = "GROQ_API_KEY"
+```
+
+```bash
+# .env
+OPENROUTER_API_KEY=your_key_here
+GROQ_API_KEY=your_key_here
+```
+
+> ⚠️ Never commit `.env` — keep secrets private. Config references env var names, not values.
+
+---
+
+## Performance
+
+| Metric | Local (7B coder) | Cloud (frontier) |
+|---|---|---|
+| Coder throughput | ~15 tok/s | ~50–100 tok/s |
+| Judge throughput | ~3–6 tok/s (partial CPU offload) | ~30–60 tok/s |
+| Full cycle wall time | 4–15 min | 1–3 min |
+| Exit code | 0 = gates passed, 1 = failed | 0 = gates passed, 1 = failed |
+
+**Typical run:**
+
+```log
+[preflight] ruff: OK
+[preflight] pytest: OK
+[preflight] coder endpoint: reachable
+[spec] Generated SPEC.md + test_candidate.py (1.2s)
+[coder] Iteration 1/3 — wrote candidate.py (3.4s)
+[judge] score=3, verdict=fail (advisory)
+[tester] ruff rc=0, pytest rc=1 (fail)
+[coder] Iteration 2/3 — fixed issues (2.8s)
+[judge] score=4, verdict=pass (advisory)
+[tester] ruff rc=0, pytest rc=0 (pass)
+✓ Pipeline completed: gates passed (exit code 0)
+```
+
+---
+
+## Honest Limitations
+
+- **Local models (7b-14b) fail convergence** on mid-complexity tasks (e.g., sliding-window rate limiter with exact boolean return) within 3 iterations.
+- **Cloud free-tier models (Groq gpt-oss-120b)** provide better judge quality but have rate limits (200K tokens/day).
+- **CiLydian is an experiment and portfolio artifact**, not a daily development tool. For production code, use manual multi-vendor workflow (DeepSeek/Qwen for prompting, Claude for architecture, Gemini for review, local ruff/pytest for gates).
+
+---
+
+## Screenshot
+
+![CiLydian Terminal](screenshots/terminal.png)
+
+---
+
+## Roadmap
+
+- [ ] **GitHub Actions integration** — trigger CiLydian on issue labels
+- [ ] **Multi-language support** — extend beyond Python (JavaScript, Go)
+- [ ] **Persistent state** — resume interrupted runs from checkpoint
+- [ ] **Web dashboard** — visualize pipeline runs and logs
+- [ ] **Plugin system** — custom gates beyond ruff/pytest (mypy, bandit)
+
+---
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a PR.
+
+### Development setup
+
+```bash
+git clone https://github.com/sleepti3ht/cilydian.git
+cd cilydian
+
+# Unix / macOS
+python -m venv .venv && source .venv/bin/activate
+# Windows (PowerShell)
+python -m venv .venv; .\.venv\Scripts\Activate.ps1
+
+pip install -r requirements.txt
+pip install pre-commit
+pre-commit install  # enforces ruff + pytest on commit
+
+# Run the pipeline on a sample task
+python pipeline.py "Test task"
+```
+
+### Code style
+
+- Commit messages: Conventional Commits (`feat(pipeline): ...`, `fix(tester): ...`)
+- Run `ruff check` and `pytest` before pushing (enforced by pre-commit)
+
+---
+
+## License
+
+MIT

cilydian-0.1.3/cilydian.egg-info/PKG-INFO

@@ -0,0 +1,271 @@
+Metadata-Version: 2.4
+Name: cilydian
+Version: 0.1.3
+Summary: Self-hosted agentic CI pipeline with spec-driven codegen
+Author-email: sleepti3ht <sleepti3ht@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sleepti3ht/CiLydian
+Project-URL: Repository, https://github.com/sleepti3ht/CiLydian
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langgraph>=1.0
+Requires-Dist: langchain-ollama>=1.0
+Requires-Dist: langchain-openai>=1.0
+Dynamic: license-file
+
+<div align="center">
+
+# CiLydian
+
+[![python](https://img.shields.io/badge/Python-3.12%2B-fdf6e3?style=flat&logo=python&logoColor=657b83)](https://python.org)
+[![langgraph](https://img.shields.io/badge/LangGraph-1.0%2B-b58900?style=flat)](https://langchain-ai.github.io/langgraph/)
+[![status](https://img.shields.io/badge/status-active-859900?style=flat)](https://github.com)
+[![license](https://img.shields.io/badge/license-MIT-fdf6e3?style=flat)](LICENSE)
+
+</div>
+
+> Self-hosted agentic CI pipeline on LangGraph: **spec → coder → LLM judge (advisory) → deterministic gates (ruff + pytest)**, with a bounded repair loop and human escalation. Models are pluggable per role — local Ollama or any OpenAI-compatible endpoint.
+
+---
+
+## Why CiLydian?
+
+Most multi-agent coding tools stop at "generate and hope." CiLydian treats LLM output as untrusted input: mechanical gates (ruff, pytest) are the source of truth, the LLM judge is advisory feedback, and the loop is bounded. If the pipeline can't converge in `MAX_ITER`, it exits with a status code and the full log — never hangs, never burns tokens indefinitely.
+
+Compared to AutoGen Studio or CrewAI: those are chat-orchestration frameworks. CiLydian is a **CI primitive** — it runs, exits with a status code, and can be wired into git hooks, GitHub Actions, or cron.
+
+---
+
+## Quick Start
+
+```bash
+# Clone and setup
+git clone https://github.com/sleepti3ht/cilydian.git
+cd cilydian
+
+# Unix / macOS
+python -m venv .venv && source .venv/bin/activate
+# Windows (PowerShell)
+python -m venv .venv; .\.venv\Scripts\Activate.ps1
+
+pip install -r requirements.txt
+
+# Run with local Ollama (default)
+python pipeline.py "Your task description"
+
+# Or use cloud profile (free tiers)
+cp config.cloud.toml.example config.toml
+cp .env.example .env  # fill with OpenRouter/Groq keys
+python pipeline.py "Your task description"
+```
+
+Stack: `langgraph`, `langchain-ollama`, `langchain-openai`, `ruff`, `pytest`. See `requirements.txt`.
+
+---
+
+## Features
+
+### Core
+- **Spec-driven generation**: turn one-line ideas into a `SPEC.md` and a `test_candidate.py` skeleton before any code is written
+- **Bounded repair loop**: coder iterates on judge feedback up to `MAX_ITER` times, then escalates to a human
+- **Advisory LLM judge**: semantic review that never blocks on its own verdict (see [Design notes](#design-notes))
+- **Deterministic gates**: `ruff` (auto-fix + check) and `pytest`; these are what actually block the pipeline
+- **Short-circuit**: pytest is skipped if ruff fails, saves 10–20s per failed cycle
+- **Config-driven models**: mix Ollama local and OpenAI-compatible cloud per role
+- **Rate-limit resilience**: exponential backoff for 429s on free tiers
+- **UTF-8 on Windows**: subprocess encoding prevents `cp1251` mojibake in logs
+
+### Reliability
+- **Defensive JSON parsing**: judge verdicts normalized via `try: int(float(raw))`
+- **Programmatic guardrail**: `score < 4` with `verdict="pass"` is auto-downgraded to `fail` (see [Design notes](#design-notes))
+- **Markdown fence stripping**: handles LLM code wrapped in \`\`\` fences
+- **Log rotation**: 5 MB cap with atomic `os.replace()`; single writer, no race
+- **Isolated gates**: `logs/ruff.toml` and `logs/pytest.ini` are auto-created on first run to prevent parent-config bleed
+- **Preflight checks**: verifies `ruff` / `pytest` are on PATH and the coder endpoint is reachable before spending a single token
+
+---
+
+## Design notes
+
+**The judge is advisory, the guardrails are not.** Local 7B–14B judges drift beyond SPEC — they request absent features, over- or under-rate code, and sometimes contradict themselves. So the LLM's verdict alone never blocks the pipeline. A separate programmatic rule handles one specific pathological case: if the LLM outputs `verdict="pass"` while scoring below 4, the guardrail downgrades it to `fail`. That's not the judge blocking — it's a deterministic check that doesn't trust a self-contradicting model. Mechanical gates (ruff, pytest) remain the ultimate source of truth.
+
+**The repair loop is bounded on purpose.** `MAX_ITER` (default 3) caps attempts. Exhaustion means human escalation, not a hang. On complex tasks this may give up earlier than a human reviewer would prefer — acceptable for CI, where the cost of a false-negative is a re-run, not a lost afternoon.
+
+**Mechanical fixes belong to the tool.** `ruff --fix` runs before `ruff check` and auto-corrects imports and formatting. LLM tokens are too expensive for style fixes a Rust binary does in 40 milliseconds.
+
+---
+
+## Architecture
+
+```mermaid
+flowchart LR
+    classDef solarizedBase3 fill:#fdf6e3,stroke:#93a1a1,color:#657b83,stroke-width:1px
+    classDef solarizedBase02 fill:#eee8d5,stroke:#93a1a1,color:#586e75,stroke-width:1px
+    classDef solarizedYellow fill:#b58900,stroke:#b58900,color:#fdf6e3,stroke-width:2px
+    classDef solarizedOrange fill:#cb4b16,stroke:#cb4b16,color:#fdf6e3,stroke-width:2px
+    classDef solarizedGreen fill:#859900,stroke:#859900,color:#fdf6e3,stroke-width:2px
+    classDef solarizedBlue fill:#268bd2,stroke:#268bd2,color:#fdf6e3,stroke-width:2px
+    classDef solarizedCyan fill:#2aa198,stroke:#2aa198,color:#fdf6e3,stroke-width:2px
+
+    A[idea]:::solarizedYellow
+    S[spec_writer<br>role: spec]:::solarizedBlue
+    C[coder<br>role: coder]:::solarizedGreen
+    J[judge<br>advisory]:::solarizedOrange
+    T[tester<br>ruff + pytest]:::solarizedCyan
+    E[final verdict<br>exit code]:::solarizedBase02
+
+    A --> S
+    S --> C
+    C --> J
+    J -->|advisory| T
+    T -->|fail and iter < max_iter| C
+    T -->|pass or budget exhausted| E
+```
+
+---
+
+## Configuration
+
+### Local Ollama profile (default)
+
+```toml
+# config.toml
+[pipeline]
+max_iter = 3
+judge_blocking = false
+
+[roles.spec]
+provider = "ollama"
+model = "qwen2.5-coder:7b"
+
+[roles.coder]
+provider = "ollama"
+model = "qwen2.5-coder:7b"
+
+[roles.judge]
+provider = "ollama"
+model = "qwen2.5:14b"
+```
+
+### Cloud hybrid profile (free tiers)
+
+```toml
+# config.cloud.toml.example
+[pipeline]
+max_iter = 3
+judge_blocking = false
+
+[roles.spec]
+provider = "openai_compat"
+base_url = "https://openrouter.ai/api/v1"
+model = "deepseek/deepseek-chat"
+api_key_env = "OPENROUTER_API_KEY"
+
+[roles.coder]
+provider = "openai_compat"
+base_url = "https://openrouter.ai/api/v1"
+model = "deepseek/deepseek-chat"
+api_key_env = "OPENROUTER_API_KEY"
+
+[roles.judge]
+provider = "openai_compat"
+base_url = "https://api.groq.com/openai/v1"
+model = "llama-3.3-70b-versatile"
+api_key_env = "GROQ_API_KEY"
+```
+
+```bash
+# .env
+OPENROUTER_API_KEY=your_key_here
+GROQ_API_KEY=your_key_here
+```
+
+> ⚠️ Never commit `.env` — keep secrets private. Config references env var names, not values.
+
+---
+
+## Performance
+
+| Metric | Local (7B coder) | Cloud (frontier) |
+|---|---|---|
+| Coder throughput | ~15 tok/s | ~50–100 tok/s |
+| Judge throughput | ~3–6 tok/s (partial CPU offload) | ~30–60 tok/s |
+| Full cycle wall time | 4–15 min | 1–3 min |
+| Exit code | 0 = gates passed, 1 = failed | 0 = gates passed, 1 = failed |
+
+**Typical run:**
+
+```log
+[preflight] ruff: OK
+[preflight] pytest: OK
+[preflight] coder endpoint: reachable
+[spec] Generated SPEC.md + test_candidate.py (1.2s)
+[coder] Iteration 1/3 — wrote candidate.py (3.4s)
+[judge] score=3, verdict=fail (advisory)
+[tester] ruff rc=0, pytest rc=1 (fail)
+[coder] Iteration 2/3 — fixed issues (2.8s)
+[judge] score=4, verdict=pass (advisory)
+[tester] ruff rc=0, pytest rc=0 (pass)
+✓ Pipeline completed: gates passed (exit code 0)
+```
+
+---
+
+## Honest Limitations
+
+- **Local models (7b-14b) fail convergence** on mid-complexity tasks (e.g., sliding-window rate limiter with exact boolean return) within 3 iterations.
+- **Cloud free-tier models (Groq gpt-oss-120b)** provide better judge quality but have rate limits (200K tokens/day).
+- **CiLydian is an experiment and portfolio artifact**, not a daily development tool. For production code, use manual multi-vendor workflow (DeepSeek/Qwen for prompting, Claude for architecture, Gemini for review, local ruff/pytest for gates).
+
+---
+
+## Screenshot
+
+![CiLydian Terminal](screenshots/terminal.png)
+
+---
+
+## Roadmap
+
+- [ ] **GitHub Actions integration** — trigger CiLydian on issue labels
+- [ ] **Multi-language support** — extend beyond Python (JavaScript, Go)
+- [ ] **Persistent state** — resume interrupted runs from checkpoint
+- [ ] **Web dashboard** — visualize pipeline runs and logs
+- [ ] **Plugin system** — custom gates beyond ruff/pytest (mypy, bandit)
+
+---
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a PR.
+
+### Development setup
+
+```bash
+git clone https://github.com/sleepti3ht/cilydian.git
+cd cilydian
+
+# Unix / macOS
+python -m venv .venv && source .venv/bin/activate
+# Windows (PowerShell)
+python -m venv .venv; .\.venv\Scripts\Activate.ps1
+
+pip install -r requirements.txt
+pip install pre-commit
+pre-commit install  # enforces ruff + pytest on commit
+
+# Run the pipeline on a sample task
+python pipeline.py "Test task"
+```
+
+### Code style
+
+- Commit messages: Conventional Commits (`feat(pipeline): ...`, `fix(tester): ...`)
+- Run `ruff check` and `pytest` before pushing (enforced by pre-commit)
+
+---
+
+## License
+
+MIT

cilydian-0.1.3/cilydian.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pipeline.py
+pyproject.toml
+cilydian.egg-info/PKG-INFO
+cilydian.egg-info/SOURCES.txt
+cilydian.egg-info/dependency_links.txt
+cilydian.egg-info/entry_points.txt
+cilydian.egg-info/requires.txt
+cilydian.egg-info/top_level.txt

cilydian-0.1.3/cilydian.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cilydian-0.1.3/cilydian.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cilydian = pipeline:main

cilydian-0.1.3/cilydian.egg-info/requires.txt

@@ -0,0 +1,3 @@
+langgraph>=1.0
+langchain-ollama>=1.0
+langchain-openai>=1.0

cilydian-0.1.3/cilydian.egg-info/top_level.txt

@@ -0,0 +1 @@
+pipeline

cilydian-0.1.3/pipeline.py

@@ -0,0 +1,379 @@
+"""CiLydian: self-hosted agentic CI pipeline.
+
+Flow: spec -> coder -> LLM judge (advisory by default) -> deterministic gates
+(ruff + pytest), with a bounded repair loop and human escalation.
+
+Models are pluggable per role via config.toml: local Ollama or any
+OpenAI-compatible endpoint (OpenRouter, Groq, Gemini compat, DeepSeek, vLLM).
+API keys are never stored in config: roles reference environment variable names.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import tomllib
+from typing import Literal, TypedDict
+
+from langchain_ollama import ChatOllama
+from langchain_openai import ChatOpenAI
+from langgraph.graph import END, StateGraph
+
+LOG_DIR = "logs"
+LOG_CAP = 5_000_000  # rotate a log once it exceeds this many bytes
+DEFAULT_IDEA = "Rate limiter on asyncio.Semaphore for CVE scanner"
+_FENCE_BLOCK = re.compile(r"```[\w-]*[ \t]*\n(.*?)\n[ \t]*```", re.DOTALL)
+
+# Populated by init_models(); graph nodes read these globals at call time.
+SPEC_LLM = None
+CODER = None
+JUDGE = None
+MAX_ITER = 3
+JUDGE_BLOCKING = False
+
+
+def load_dotenv(path: str = ".env") -> None:
+    """Minimal .env loader; avoids a python-dotenv dependency."""
+    if not os.path.exists(path):
+        return
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            key, _, value = line.partition("=")
+            os.environ.setdefault(key.strip(), value.strip().strip('"').strip("'"))
+
+
+def build_llm(cfg: dict):
+    """Instantiate a chat model for one pipeline role.
+
+    provider = "ollama"        -> local Ollama server
+    provider = "openai_compat" -> any OpenAI-compatible API (OpenRouter, Groq,
+                                  Gemini compat, DeepSeek, vLLM, ...)
+    """
+    provider = cfg.get("provider", "ollama")
+    if provider == "ollama":
+        return ChatOllama(
+            model=cfg["model"],
+            base_url=cfg.get("base_url", "http://localhost:11434"),
+            num_ctx=cfg.get("num_ctx", 4096),
+        )
+    if provider == "openai_compat":
+        key_env = cfg.get("api_key_env", "")
+        api_key = os.environ.get(key_env, "")
+        if not api_key:
+            raise SystemExit(
+                f"[config] role needs env var {key_env!r} but it is not set. "
+                f"Copy .env.example to .env and fill it in."
+            )
+        return ChatOpenAI(
+            model=cfg["model"],
+            base_url=cfg["base_url"],
+            api_key=api_key,
+            temperature=cfg.get("temperature", 0.2),
+            max_retries=3,  # exponential backoff on 429 (free-tier rate limits)
+        )
+    raise SystemExit(f"[config] unknown provider: {provider!r}")
+
+
+def load_config(path: str) -> dict:
+    try:
+        with open(path, "rb") as f:
+            return tomllib.load(f)
+    except FileNotFoundError:
+        raise SystemExit(f"[config] {path} not found; see config.toml in repo root")
+
+
+def init_models(cfg: dict) -> None:
+    global SPEC_LLM, CODER, JUDGE
+    roles = cfg.get("roles", {})
+    for role in ("spec", "coder", "judge"):
+        if role not in roles:
+            raise SystemExit(f"[config] missing [roles.{role}] section")
+    SPEC_LLM = build_llm(roles["spec"])
+    CODER = build_llm(roles["coder"])
+    JUDGE = build_llm(roles["judge"])
+
+
+def strip_fences(text: str) -> str:
+    """Extract the first fenced code block; models append prose after it."""
+    m = _FENCE_BLOCK.search(text)
+    if m:
+        return m.group(1)
+    t = text.strip()
+    if t.startswith("```"):
+        t = t.split("\n", 1)[1] if "\n" in t else t[3:]
+        if "```" in t:  # closing fence with prose after it
+            t = t.split("```", 1)[0]
+        return t.rstrip()
+    return t
+
+
+def log(agent: str, msg: str) -> None:
+    path = os.path.join(LOG_DIR, f"{agent}.log")
+    if os.path.exists(path) and os.path.getsize(path) > LOG_CAP:
+        os.replace(path, path + ".old")  # atomic on Windows; single writer, no race
+    with open(path, "a", encoding="utf-8") as f:
+        f.write(msg + "\n")
+
+
+def reset_logs() -> None:
+    """Truncate per run: live-tail panels stay alive, history = one cycle."""
+    os.makedirs(LOG_DIR, exist_ok=True)
+    for agent in ("spec", "coder", "judge", "tester"):
+        open(os.path.join(LOG_DIR, f"{agent}.log"), "w", encoding="utf-8").close()
+
+
+def ensure_isolation() -> None:
+    """Stop ruff/pytest from inheriting the parent project's configs."""
+    os.makedirs(LOG_DIR, exist_ok=True)  # ← Добавленная строка
+    if not os.path.exists(os.path.join(LOG_DIR, "ruff.toml")):
+        open(os.path.join(LOG_DIR, "ruff.toml"), "w", encoding="utf-8").close()
+    if not os.path.exists(os.path.join(LOG_DIR, "pytest.ini")):
+        with open(os.path.join(LOG_DIR, "pytest.ini"), "w", encoding="utf-8") as f:
+            f.write("[pytest]\nasyncio_mode = auto\n")
+
+
+def run(cmd: list[str], cwd: str) -> subprocess.CompletedProcess:
+    """Run a gate tool; force UTF-8 decoding (Windows locales default to cp1251)."""
+    return subprocess.run(
+        cmd,
+        check=False,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        cwd=cwd,
+    )
+
+
+def preflight() -> None:
+    for tool in ("ruff", "pytest"):
+        if shutil.which(tool) is None:
+            raise SystemExit(
+                f"[preflight] {tool} not found on PATH (see requirements.txt)"
+            )
+    try:
+        CODER.invoke("ping")
+    except Exception as exc:
+        raise SystemExit(f"[preflight] coder endpoint unreachable: {exc}") from exc
+
+
+class State(TypedDict):
+    idea: str
+    spec: str
+    code: str
+    verdict: dict
+    iteration: int
+
+
+def spec_writer(s: State):
+    """Stage 0: turn a one-line idea into a SPEC plus a pytest skeleton."""
+    spec = SPEC_LLM.invoke(
+        "Turn this idea into a MINIMAL SPEC. Include ONLY what the idea states.\n"
+        "Sections: Role; Interface (exact PYTHON class/method signatures the "
+        "implementation MUST expose - never Java/Go/other languages); Constraints; "
+        "Measurable Acceptance Criteria (max 5, unit-testable); Test Plan (max 5 "
+        "tests, 1:1 mapping to criteria).\n"
+        "If the task involves time, windows, or delays: the Interface MUST include "
+        "an injectable clock parameter (e.g. clock: Callable[[], float] = "
+        "time.monotonic), and the Test Plan MUST drive time through a fake clock. "
+        "Real sleeps and wall-clock measurements are FORBIDDEN in tests.\n"
+        "FORBIDDEN unless the idea explicitly requests them: security compliance, "
+        "abuse prevention, authentication, monitoring, logging, UAT, post-release "
+        "monitoring, performance measurement, config files, documentation.\n"
+        f"Idea: {s['idea']}"
+    ).content
+    tests = CODER.invoke(
+        f"Generate a pytest file for this spec:\n{spec}\n"
+        "Write only test functions, no implementation. "
+        "Import the module under test as `from candidate import ...`, "
+        "NOT as `from logs.candidate import ...`. "
+        "Output raw python code only, no markdown fences."
+        "Tests must call ONLY the class and methods listed in the SPEC Interface "
+        "section, with exact names and signatures. No invented API.\n"
+        "Tests must NEVER call time.sleep or measure wall-clock time. If the SPEC "
+        "defines an injectable clock, construct a fake clock and advance it "
+        "explicitly to simulate window expiry.\n"
+    ).content
+    with open(os.path.join(LOG_DIR, "test_candidate.py"), "w", encoding="utf-8") as f:
+        f.write(strip_fences(tests))
+    log("spec", spec)
+    return {"spec": spec}
+
+
+def coder(s: State):
+    """Generate/repair the implementation; tests are the naming contract."""
+    feedback = s["verdict"].get("issues", [])
+    prompt = f"SPEC:\n{s['spec']}\n"
+    try:
+        with open(os.path.join(LOG_DIR, "test_candidate.py"), encoding="utf-8") as f:
+            prompt += (
+                f"TESTS that must pass (match names/signatures exactly):\n{f.read()}\n"
+            )
+    except OSError:
+        pass
+    prompt += (
+        f"Issues to fix: {feedback}\n"
+        "Write only the Python implementation for module `candidate`. "
+        "Raw code only, no markdown fences, no tests. "
+        "NO explanations, NO headers, NO prose after the code."
+    )
+    code = strip_fences(CODER.invoke(prompt).content)
+    log("coder", code)
+    return {"code": code, "iteration": s["iteration"] + 1}
+
+
+def judge(s: State):
+    """LLM review with defensive parsing: models ignore JSON schemas regularly."""
+    raw = JUDGE.invoke(
+        "Rate 1-5: correctness, security, simplicity. Judge ONLY against "
+        "the SPEC's measurable acceptance criteria; do not request features "
+        f"beyond the SPEC. Check against SPEC:\n{s['spec']}\nCODE:\n{s['code']}\n"
+        'Return JSON only: {"score": int, "verdict": "pass"|"fail", "issues": [str]}\n\n'
+        'CRITICAL: Output ONLY raw JSON. NO markdown fences.\n'
+        'CORRECT: {"score": 4, "verdict": "pass", "issues": []}\n'
+        'WRONG: ```json{"score": 4, "verdict": "pass", "issues": []}```'
+    ).content
+    a, b = raw.find("{"), raw.rfind("}")
+    try:
+        verdict = json.loads(raw[a : b + 1]) if a != -1 else {}
+    except json.JSONDecodeError:
+        verdict = {}
+    if not isinstance(verdict, dict):
+        verdict = {}
+    verdict.setdefault("issues", [])
+    raw_score = verdict.get("score", 5)
+    try:
+        score = int(float(raw_score))
+    except (TypeError, ValueError):
+        score = 0
+        verdict["issues"].append(f"Unparseable score: {raw_score!r}")
+    verdict["verdict"] = str(verdict.get("verdict", "fail")).lower()
+    if verdict["verdict"] not in ("pass", "fail"):
+        verdict["verdict"] = "fail"
+    if score < 4 and verdict["verdict"] == "pass":
+        verdict["verdict"] = "fail"
+        verdict["issues"].append(f"Auto-downgraded: score={score} contradicts 'pass'.")
+    verdict["gate"] = "judge"
+    log("judge", json.dumps(verdict, ensure_ascii=False))
+    return {"verdict": verdict}
+
+
+def tester(s: State):
+    """Deterministic gates: ruff (auto-fix then check) and pytest. These block."""
+    candidate = os.path.join(LOG_DIR, "candidate.py")
+    with open(candidate, "w", encoding="utf-8") as f:
+        f.write(s["code"])
+    with open(os.path.join(LOG_DIR, "conftest.py"), "w", encoding="utf-8") as f:
+        f.write("import sys, os\nsys.path.insert(0, os.path.dirname(__file__))\n")
+    run(["ruff", "check", "--fix", "candidate.py"], LOG_DIR)
+    with open(candidate, encoding="utf-8") as f:
+        fixed = f.read()  # State must match the artifact on disk after --fix
+    ruff = run(["ruff", "check", "candidate.py"], LOG_DIR)
+    if ruff.returncode != 0:
+        # Short-circuit: no point running pytest on code that fails lint/syntax.
+        log("tester", f"ruff rc={ruff.returncode}\n{ruff.stdout[:500]}")
+        return {
+            "code": fixed,
+            "verdict": {
+                **s["verdict"],
+                "gate": "ruff+pytest",
+                "verdict": "fail",
+                "issues": s["verdict"].get("issues", [])
+                + [f"ruff:{ruff.stdout[:300]}"],
+            },
+        }
+    pytest_run = run(["pytest", "test_candidate.py", "-q", "--tb=short"], LOG_DIR)
+    ok = pytest_run.returncode == 0
+    log(
+        "tester",
+        f"ruff rc=0\npytest rc={pytest_run.returncode}\n{pytest_run.stdout[-500:]}",
+    )
+    extra_issues = [] if ok else [f"pytest:{pytest_run.stdout[:300]}"]
+    return {
+        "code": fixed,
+        "verdict": {
+            **s["verdict"],
+            "gate": "ruff+pytest",
+            "verdict": "pass" if ok else "fail",
+            "issues": s["verdict"].get("issues", []) + extra_issues,
+        },
+    }
+
+
+def route(s: State) -> Literal["coder", "tester"]:
+    """Judge is advisory by default; flip JUDGE_BLOCKING to make it a gate."""
+    if (
+        JUDGE_BLOCKING
+        and s["verdict"]["verdict"] == "fail"
+        and s["iteration"] < MAX_ITER
+    ):
+        return "coder"
+    return "tester"
+
+
+def route_tester(s: State) -> Literal["coder", "end"]:
+    """Deterministic failures loop back to coder, bounded by MAX_ITER."""
+    if s["verdict"]["verdict"] == "fail" and s["iteration"] < MAX_ITER:
+        return "coder"
+    return "end"
+
+
+g = StateGraph(State)
+g.add_node("spec", spec_writer)
+g.add_node("coder", coder)
+g.add_node("judge", judge)
+g.add_node("tester", tester)
+g.set_entry_point("spec")
+g.add_edge("spec", "coder")
+g.add_edge("coder", "judge")
+g.add_conditional_edges("judge", route, {"coder": "coder", "tester": "tester"})
+g.add_conditional_edges("tester", route_tester, {"coder": "coder", "end": END})
+app = g.compile()
+
+
+def main() -> int:
+    global MAX_ITER, JUDGE_BLOCKING
+    parser = argparse.ArgumentParser(
+        description="Agentic CI pipeline: spec -> coder -> judge -> deterministic gates"
+    )
+    parser.add_argument(
+        "idea",
+        nargs="?",
+        default=DEFAULT_IDEA,
+        help="One-line task description (e.g., 'Async rate limiter with token bucket')",
+    )
+    parser.add_argument(
+        "--config",
+        default="config.toml",
+        help="path to role/model config (default: config.toml)",
+    )
+    args = parser.parse_args()
+
+    load_dotenv()
+    cfg = load_config(args.config)
+    init_models(cfg)
+    pipe = cfg.get("pipeline", {})
+    MAX_ITER = int(pipe.get("max_iter", 3))
+    JUDGE_BLOCKING = bool(pipe.get("judge_blocking", False))
+
+    preflight()
+    ensure_isolation()
+    reset_logs()
+    result = app.invoke(
+        {"idea": args.idea, "spec": "", "code": "", "verdict": {}, "iteration": 0}
+    )
+    print(json.dumps(result["verdict"], ensure_ascii=False, indent=2))
+    return (
+        0 if result["verdict"].get("verdict") == "pass" else 1
+    )  # CI-friendly exit code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cilydian-0.1.3/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=77.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cilydian"
+version = "0.1.3"
+description = "Self-hosted agentic CI pipeline with spec-driven codegen"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+authors = [
+    {name = "sleepti3ht", email = "sleepti3ht@gmail.com"}
+]
+dependencies = [
+    "langgraph>=1.0",
+    "langchain-ollama>=1.0",
+    "langchain-openai>=1.0",
+]
+
+[project.scripts]
+cilydian = "pipeline:main"
+
+[project.urls]
+Homepage = "https://github.com/sleepti3ht/CiLydian"
+Repository = "https://github.com/sleepti3ht/CiLydian"
+
+[tool.setuptools]
+py-modules = ["pipeline"]

cilydian-0.1.3/setup.cfg

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