algitex 0.1.3

Progressive algorithmization toolchain — from LLM to deterministic code, from proxy to tickets

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

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

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

from algitex import Workflow

wf = Workflow("./refactor-v1.md")
wf.execute()   # runs propact:shell, propact:rest, propact:llm blocks

CLI

# 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

# Fix Authentication Module

Analyze current state:

```propact:shell
code2llm ./src/auth -f toon --json

Ask LLM for a fix plan:

POST http://localhost:4000/v1/chat/completions
{"model": "balanced", "messages": [{"role": "user", "content": "Fix auth"}]}

Validate the result:

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.

Licensed under Apache-2.0.

Apache License 2.0

Author

Tom Sapletta

Tom Sapletta

Tom Sapletta

Created by Tom Sapletta — [e-mail]

Part of the semcod / wronai ecosystem.