algitex 0.1.2__tar.gz

algitex-0.1.2/LICENSE

@@ -0,0 +1,15 @@
+Apache License 2.0
+
+Copyright 2026 Tom Sapletta
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

algitex-0.1.2/PKG-INFO

@@ -0,0 +1,280 @@
+Metadata-Version: 2.4
+Name: algitex
+Version: 0.1.2
+Summary: Progressive algorithmization toolchain — from LLM to deterministic code, from proxy to tickets
+Author-email: Tom Sapletta <tom@sapletta.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/semcod/algitex
+Project-URL: Repository, https://github.com/semcod/algitex
+Keywords: llm,devtools,proxy,tickets,progressive-algorithmization,mcp,propact,code-analysis,automation,workflow
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.12
+Requires-Dist: pydantic>=2.0
+Provides-Extra: all
+Requires-Dist: proxym; extra == "all"
+Requires-Dist: planfile; extra == "all"
+Requires-Dist: llx; extra == "all"
+Requires-Dist: vallm; extra == "all"
+Requires-Dist: code2llm; extra == "all"
+Requires-Dist: redup; extra == "all"
+Provides-Extra: proxy
+Requires-Dist: proxym; extra == "proxy"
+Provides-Extra: tickets
+Requires-Dist: planfile; extra == "tickets"
+Provides-Extra: analysis
+Requires-Dist: code2llm; extra == "analysis"
+Requires-Dist: vallm; extra == "analysis"
+Requires-Dist: redup; extra == "analysis"
+Provides-Extra: routing
+Requires-Dist: llx; extra == "routing"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: license-file
+
+# algitex
+
+**Progressive algorithmization toolchain — from LLM to deterministic code, from proxy to tickets.**
+
+> The only framework that automates the path from "LLM handles everything"
+> to "most traffic runs deterministically, LLM only for edge cases."
+
+```
+pip install algitex
+algitex init ./my-app
+algitex go
+```
+
+## Why "algitex"?
+
+The name reflects the core cycle: **analyze → plan → execute → validate → repeat**. Each iteration makes your codebase healthier and your LLM usage cheaper. The progressive algorithmization loop gradually replaces LLM calls with deterministic rules.
+
+## Name alternatives considered
+
+| Name | Why it works | Why we picked algitex |
+|------|-------------|----------------------|
+| **algitex** | Core concept: the continuous improvement loop | Clear, memorable, tech-neutral |
+| prollama | "progressive" + llama vibes | Ties too much to one model family |
+| codefact | Code + factory/fact | Sounds like a trivia app |
+| algopact | Algorithm + Propact | Hard to pronounce |
+| loopcode | Loop + code | Reverse reads awkward |
+| prodev | Progressive + dev | Too generic, SEO nightmare |
+
+## Three layers, one command
+
+### Layer 1: Code Quality Loop
+```python
+from algitex import Project
+
+p = Project("./my-app")
+p.analyze()    # code2llm + vallm + redup → health report
+p.plan()       # auto-generate tickets from analysis
+p.execute()    # LLM handles tasks via proxym
+p.status()     # health + tickets + budget + cost ledger
+```
+
+### Layer 2: Progressive Algorithmization
+```python
+from algitex import Loop
+
+loop = Loop("./my-app")
+loop.discover()        # Stage 1: collect all LLM traces
+loop.extract()         # Stage 2: find repeating patterns
+loop.generate_rules()  # Stage 3: AI writes its own replacement
+loop.route()           # Stage 4: rules vs LLM by confidence
+loop.optimize()        # Stage 5: monitor, minimize LLM usage
+print(loop.report())   # "42% deterministic, $12.50 saved"
+```
+
+### Layer 3: Propact Workflows
+```python
+from algitex import Workflow
+
+wf = Workflow("./refactor-v1.md")
+wf.execute()   # runs propact:shell, propact:rest, propact:llm blocks
+```
+
+## CLI
+
+```bash
+# Core loop
+algitex init ./my-app         # initialize project
+algitex analyze               # health check
+algitex plan --sprints 3      # generate sprint strategy + tickets
+algitex go                    # full pipeline
+algitex status                # dashboard
+
+# Progressive algorithmization
+algitex algo discover         # start trace collection
+algitex algo extract          # find patterns in traces
+algitex algo rules            # generate deterministic replacements
+algitex algo report           # show % deterministic vs LLM
+
+# Propact workflows
+algitex workflow run fix.md   # execute Markdown workflow
+algitex workflow validate f.md
+
+# Tickets
+algitex ticket add "Fix auth" --priority high
+algitex ticket list
+algitex ticket board
+algitex sync                  # push to GitHub/Jira
+
+# Quick queries
+algitex ask "Explain this race condition" --tier premium
+algitex tools                 # show installed tools
+```
+
+## The 5-Stage Progressive Algorithmization
+
+```
+Stage 1: Discovery     → LLM handles 100%, collect traces
+Stage 2: Extraction    → identify hot paths + repeating patterns
+Stage 3: Rules         → AI generates deterministic replacements
+Stage 4: Hybrid        → confidence-based: known patterns → rules, unknown → LLM
+Stage 5: Optimization  → most traffic deterministic, LLM for edge cases only
+```
+
+No existing framework automates this path. DSPy goes LLM→smaller LLM. algitex goes LLM→algorithm.
+
+## Propact: Markdown as Workflow
+
+```markdown
+# Fix Authentication Module
+
+Analyze current state:
+
+```propact:shell
+code2llm ./src/auth -f toon --json
+```
+
+Ask LLM for a fix plan:
+
+```propact:rest
+POST http://localhost:4000/v1/chat/completions
+{"model": "balanced", "messages": [{"role": "user", "content": "Fix auth"}]}
+```
+
+Validate the result:
+
+```propact:shell
+vallm batch ./src/auth --recursive
+```
+```
+
+## Planfile-Aware Proxy Headers
+
+Every LLM request through algitex carries context:
+
+```
+X-Planfile-Ref: my-project/current/DLP-0042
+X-Workflow-Ref: refactor-v1.md
+X-Task-Tier: complex
+X-Inject-Context: true
+```
+
+Proxym logs cost/model/latency **per ticket**. The cost ledger shows exactly what each task costs.
+
+## Installation
+
+```bash
+pip install algitex                # core
+pip install algitex[all]           # + all tools
+pip install algitex[proxy]         # + proxym
+pip install algitex[analysis]      # + code2llm, vallm, redup
+pip install algitex[tickets]       # + planfile
+pip install algitex[routing]       # + llx
+```
+
+## Architecture
+
+```
+src/algitex/
+├── __init__.py           # Project, Loop, Workflow, Config, Pipeline
+├── config.py             # Unified config (env + YAML)
+├── project.py            # Main Project class (expanded)
+├── cli.py                # Typer CLI (all commands)
+├── algo/                 # Progressive algorithmization
+│   ├── __init__.py       # Loop, TraceEntry, Pattern, Rule, LoopState
+│   └── loop.py           # Re-export
+├── propact/              # Markdown workflow engine
+│   ├── __init__.py       # Workflow, WorkflowStep, WorkflowResult
+│   └── workflow.py       # Re-export
+├── tools/
+│   ├── __init__.py       # Tool discovery
+│   ├── proxy.py          # proxym wrapper + planfile headers
+│   ├── analysis.py       # code2llm + vallm + redup
+│   └── tickets.py        # planfile wrapper + cost ledger
+└── workflows/
+    ├── __init__.py        # Pipeline (composable steps)
+    └── pipeline.py        # Re-export
+```
+
+## How it connects to the ecosystem
+
+```
+┌─────────────────────────────────────────────────────┐
+│                     algitex                         │
+│            (orchestration layer)                    │
+├─────────────────────────────────────────────────────┤
+│                                                     │
+│  analyze()   plan()   execute()   algo.discover()   │
+│     │          │         │            │             │
+│  code2llm   planfile   proxym      trace →          │
+│  vallm      tickets    llx         patterns →       │
+│  redup      strategy   models      rules →          │
+│                                    hybrid routing    │
+│                                                     │
+│  run_workflow("fix.md")                             │
+│     │                                               │
+│  propact:shell → subprocess                         │
+│  propact:rest  → httpx                              │
+│  propact:llm   → proxym                             │
+│  propact:mcp   → MCP tool call                      │
+│                                                     │
+└─────────────────────────────────────────────────────┘
+```
+
+## Tool Roles
+
+| Tool | What | Install |
+|------|------|---------|
+| **proxym** | LLM gateway, 10 providers, routing, budget | `pip install proxym` |
+| **planfile** | Sprint planning, tickets, GitHub/Jira sync | `pip install planfile` |
+| **llx** | Metric-driven model selection, MCP server | `pip install llx` |
+| **code2llm** | Static analysis → .toon diagnostics | `pip install code2llm` |
+| **vallm** | 4-tier code validation | `pip install vallm` |
+| **redup** | Duplication detection | `pip install redup` |
+
+## License
+
+Licensed under Apache-2.0.
+
+
+Licensed under Apache-2.0.
+
+
+Apache License 2.0
+
+## Author
+
+Tom Sapletta
+
+
+Tom Sapletta
+
+
+Created by **Tom Sapletta** — [tom@sapletta.com](mailto:tom@sapletta.com)
+
+Part of the [semcod](https://github.com/semcod) / [wronai](https://github.com/wronai) ecosystem.

algitex-0.1.2/README.md

@@ -0,0 +1,235 @@
+# algitex
+
+**Progressive algorithmization toolchain — from LLM to deterministic code, from proxy to tickets.**
+
+> The only framework that automates the path from "LLM handles everything"
+> to "most traffic runs deterministically, LLM only for edge cases."
+
+```
+pip install algitex
+algitex init ./my-app
+algitex go
+```
+
+## Why "algitex"?
+
+The name reflects the core cycle: **analyze → plan → execute → validate → repeat**. Each iteration makes your codebase healthier and your LLM usage cheaper. The progressive algorithmization loop gradually replaces LLM calls with deterministic rules.
+
+## Name alternatives considered
+
+| Name | Why it works | Why we picked algitex |
+|------|-------------|----------------------|
+| **algitex** | Core concept: the continuous improvement loop | Clear, memorable, tech-neutral |
+| prollama | "progressive" + llama vibes | Ties too much to one model family |
+| codefact | Code + factory/fact | Sounds like a trivia app |
+| algopact | Algorithm + Propact | Hard to pronounce |
+| loopcode | Loop + code | Reverse reads awkward |
+| prodev | Progressive + dev | Too generic, SEO nightmare |
+
+## Three layers, one command
+
+### Layer 1: Code Quality Loop
+```python
+from algitex import Project
+
+p = Project("./my-app")
+p.analyze()    # code2llm + vallm + redup → health report
+p.plan()       # auto-generate tickets from analysis
+p.execute()    # LLM handles tasks via proxym
+p.status()     # health + tickets + budget + cost ledger
+```
+
+### Layer 2: Progressive Algorithmization
+```python
+from algitex import Loop
+
+loop = Loop("./my-app")
+loop.discover()        # Stage 1: collect all LLM traces
+loop.extract()         # Stage 2: find repeating patterns
+loop.generate_rules()  # Stage 3: AI writes its own replacement
+loop.route()           # Stage 4: rules vs LLM by confidence
+loop.optimize()        # Stage 5: monitor, minimize LLM usage
+print(loop.report())   # "42% deterministic, $12.50 saved"
+```
+
+### Layer 3: Propact Workflows
+```python
+from algitex import Workflow
+
+wf = Workflow("./refactor-v1.md")
+wf.execute()   # runs propact:shell, propact:rest, propact:llm blocks
+```
+
+## CLI
+
+```bash
+# Core loop
+algitex init ./my-app         # initialize project
+algitex analyze               # health check
+algitex plan --sprints 3      # generate sprint strategy + tickets
+algitex go                    # full pipeline
+algitex status                # dashboard
+
+# Progressive algorithmization
+algitex algo discover         # start trace collection
+algitex algo extract          # find patterns in traces
+algitex algo rules            # generate deterministic replacements
+algitex algo report           # show % deterministic vs LLM
+
+# Propact workflows
+algitex workflow run fix.md   # execute Markdown workflow
+algitex workflow validate f.md
+
+# Tickets
+algitex ticket add "Fix auth" --priority high
+algitex ticket list
+algitex ticket board
+algitex sync                  # push to GitHub/Jira
+
+# Quick queries
+algitex ask "Explain this race condition" --tier premium
+algitex tools                 # show installed tools
+```
+
+## The 5-Stage Progressive Algorithmization
+
+```
+Stage 1: Discovery     → LLM handles 100%, collect traces
+Stage 2: Extraction    → identify hot paths + repeating patterns
+Stage 3: Rules         → AI generates deterministic replacements
+Stage 4: Hybrid        → confidence-based: known patterns → rules, unknown → LLM
+Stage 5: Optimization  → most traffic deterministic, LLM for edge cases only
+```
+
+No existing framework automates this path. DSPy goes LLM→smaller LLM. algitex goes LLM→algorithm.
+
+## Propact: Markdown as Workflow
+
+```markdown
+# Fix Authentication Module
+
+Analyze current state:
+
+```propact:shell
+code2llm ./src/auth -f toon --json
+```
+
+Ask LLM for a fix plan:
+
+```propact:rest
+POST http://localhost:4000/v1/chat/completions
+{"model": "balanced", "messages": [{"role": "user", "content": "Fix auth"}]}
+```
+
+Validate the result:
+
+```propact:shell
+vallm batch ./src/auth --recursive
+```
+```
+
+## Planfile-Aware Proxy Headers
+
+Every LLM request through algitex carries context:
+
+```
+X-Planfile-Ref: my-project/current/DLP-0042
+X-Workflow-Ref: refactor-v1.md
+X-Task-Tier: complex
+X-Inject-Context: true
+```
+
+Proxym logs cost/model/latency **per ticket**. The cost ledger shows exactly what each task costs.
+
+## Installation
+
+```bash
+pip install algitex                # core
+pip install algitex[all]           # + all tools
+pip install algitex[proxy]         # + proxym
+pip install algitex[analysis]      # + code2llm, vallm, redup
+pip install algitex[tickets]       # + planfile
+pip install algitex[routing]       # + llx
+```
+
+## Architecture
+
+```
+src/algitex/
+├── __init__.py           # Project, Loop, Workflow, Config, Pipeline
+├── config.py             # Unified config (env + YAML)
+├── project.py            # Main Project class (expanded)
+├── cli.py                # Typer CLI (all commands)
+├── algo/                 # Progressive algorithmization
+│   ├── __init__.py       # Loop, TraceEntry, Pattern, Rule, LoopState
+│   └── loop.py           # Re-export
+├── propact/              # Markdown workflow engine
+│   ├── __init__.py       # Workflow, WorkflowStep, WorkflowResult
+│   └── workflow.py       # Re-export
+├── tools/
+│   ├── __init__.py       # Tool discovery
+│   ├── proxy.py          # proxym wrapper + planfile headers
+│   ├── analysis.py       # code2llm + vallm + redup
+│   └── tickets.py        # planfile wrapper + cost ledger
+└── workflows/
+    ├── __init__.py        # Pipeline (composable steps)
+    └── pipeline.py        # Re-export
+```
+
+## How it connects to the ecosystem
+
+```
+┌─────────────────────────────────────────────────────┐
+│                     algitex                         │
+│            (orchestration layer)                    │
+├─────────────────────────────────────────────────────┤
+│                                                     │
+│  analyze()   plan()   execute()   algo.discover()   │
+│     │          │         │            │             │
+│  code2llm   planfile   proxym      trace →          │
+│  vallm      tickets    llx         patterns →       │
+│  redup      strategy   models      rules →          │
+│                                    hybrid routing    │
+│                                                     │
+│  run_workflow("fix.md")                             │
+│     │                                               │
+│  propact:shell → subprocess                         │
+│  propact:rest  → httpx                              │
+│  propact:llm   → proxym                             │
+│  propact:mcp   → MCP tool call                      │
+│                                                     │
+└─────────────────────────────────────────────────────┘
+```
+
+## Tool Roles
+
+| Tool | What | Install |
+|------|------|---------|
+| **proxym** | LLM gateway, 10 providers, routing, budget | `pip install proxym` |
+| **planfile** | Sprint planning, tickets, GitHub/Jira sync | `pip install planfile` |
+| **llx** | Metric-driven model selection, MCP server | `pip install llx` |
+| **code2llm** | Static analysis → .toon diagnostics | `pip install code2llm` |
+| **vallm** | 4-tier code validation | `pip install vallm` |
+| **redup** | Duplication detection | `pip install redup` |
+
+## License
+
+Licensed under Apache-2.0.
+
+
+Licensed under Apache-2.0.
+
+
+Apache License 2.0
+
+## Author
+
+Tom Sapletta
+
+
+Tom Sapletta
+
+
+Created by **Tom Sapletta** — [tom@sapletta.com](mailto:tom@sapletta.com)
+
+Part of the [semcod](https://github.com/semcod) / [wronai](https://github.com/wronai) ecosystem.

algitex-0.1.2/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "algitex"
+version = "0.1.2"
+description = "Progressive algorithmization toolchain — from LLM to deterministic code, from proxy to tickets"
+readme = "README.md"
+license = {text = "Apache-2.0"}
+requires-python = ">=3.10"
+authors = [{name = "Tom Sapletta", email = "tom@sapletta.com"}]
+keywords = [
+    "llm", "devtools", "proxy", "tickets", "progressive-algorithmization",
+    "mcp", "propact", "code-analysis", "automation", "workflow",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Quality Assurance",
+]
+
+dependencies = [
+    "pyyaml>=6.0",
+    "httpx>=0.27",
+    "rich>=13.0",
+    "typer>=0.12",
+    "pydantic>=2.0",
+]
+
+[project.optional-dependencies]
+all = ["proxym", "planfile", "llx", "vallm", "code2llm", "redup"]
+proxy = ["proxym"]
+tickets = ["planfile"]
+analysis = ["code2llm", "vallm", "redup"]
+routing = ["llx"]
+dev = ["pytest", "ruff", "mypy"]
+
+[project.scripts]
+algitex = "algitex.cli:app"
+
+[project.urls]
+Homepage = "https://github.com/semcod/algitex"
+Repository = "https://github.com/semcod/algitex"
+
+[tool.setuptools.packages.find]
+where = ["src"]

algitex-0.1.2/setup.cfg

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

algitex-0.1.2/src/algitex/__init__.py

@@ -0,0 +1,36 @@
+"""algitex — Progressive algorithmization toolchain.
+
+From LLM to deterministic code. From proxy to tickets. One loop.
+
+    from algitex import Project, Loop, Workflow
+
+    # Simple: 4 methods
+    p = Project("./my-app")
+    p.analyze()           # code2llm + vallm + redup
+    p.plan()              # strategy → tickets
+    p.execute()           # llx picks model, proxym routes
+    p.status()            # health + tickets + budget + cost ledger
+
+    # Progressive: extract patterns, replace LLM with rules
+    loop = Loop("./my-app")
+    loop.discover()       # LLM handles 100%, collect traces
+    loop.extract()        # identify hot paths + patterns
+    loop.generate_rules() # AI writes its own replacement
+    loop.route()          # confidence-based: rules vs LLM
+    loop.optimize()       # monitor, detect regressions
+
+    # Workflow: Propact Markdown workflows
+    wf = Workflow("./refactor-v1.md")
+    wf.execute()          # run propact:rest, propact:shell blocks
+    wf.status()           # step-by-step progress
+"""
+
+__version__ = "0.1.2"
+
+from algitex.project import Project
+from algitex.config import Config
+from algitex.workflows.pipeline import Pipeline
+from algitex.algo.loop import Loop
+from algitex.propact.workflow import Workflow
+
+__all__ = ["Project", "Config", "Pipeline", "Loop", "Workflow"]