simplicio-cli 0.2.0__py3-none-any.whl

simplicio/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

simplicio/bench.py

@@ -0,0 +1,51 @@
+"""
+bench.py — compara COM vs SEM o pipeline. Numeros REAIS, nada inventado.
+
+Cada caso = {objetivo, alvo, criterios, test_cmd}.
+  SEM:  manda so o objetivo cru pro LLM (baseline).
+  COM:  pipeline completo (precedent + skill + camadas + verify).
+Mede: passou no teste de primeira? quantas tentativas? 
+
+Uso: simplicio bench --cases bench/cases.json --stack angular
+Preenche bench/results.md com a tabela real.
+"""
+import os, json, time, subprocess
+from .prompt import montar
+from .providers import gerar
+
+def _testa(saida, root, test_cmd):
+    os.makedirs(os.path.join(root, ".simplicio"), exist_ok=True)
+    open(os.path.join(root, ".simplicio/bench_out.txt"), "w").write(saida or "")
+    p = subprocess.run(test_cmd, shell=True, cwd=root, capture_output=True, text=True)
+    return p.returncode == 0
+
+def _sem(caso, root):
+    # baseline: objetivo cru, zero contexto montado
+    return gerar(caso["objetivo"])
+
+def _com(caso, root, stack):
+    return gerar(montar(root, stack, caso["objetivo"], caso["alvo"],
+                        caso.get("criterios","- estado verdadeiro\n- estado falso"),
+                        caso.get("restricoes","- build passa")))
+
+def run_bench(root, stack, cases_path):
+    casos = json.load(open(cases_path))
+    linhas, n = [], len(casos)
+    acerto = {"sem": 0, "com": 0}
+    for c in casos:
+        tc = c["test_cmd"]
+        ok_sem = _testa(_sem(c, root), root, tc); acerto["sem"] += ok_sem
+        ok_com = _testa(_com(c, root, stack), root, tc); acerto["com"] += ok_com
+        linhas.append(f"| {c['objetivo'][:40]} | {'✅' if ok_sem else '❌'} | {'✅' if ok_com else '❌'} |")
+    tabela = ("| Tarefa | Sem simplicio | Com simplicio |\n|---|---|---|\n"
+              + "\n".join(linhas)
+              + f"\n\n**Acerto de primeira:** sem = {acerto['sem']}/{n} "
+                f"({100*acerto['sem']//n}%) · com = {acerto['com']}/{n} "
+                f"({100*acerto['com']//n}%)")
+    out = os.path.join(root, "bench", "results.md")
+    os.makedirs(os.path.dirname(out), exist_ok=True)
+    open(out, "w").write(f"# Benchmark (gerado por `simplicio bench`)\n\n"
+                         f"Provider: {os.environ.get('SIMPLICIO_PROVIDER','claude')} · "
+                         f"casos: {n} · data: {time.strftime('%Y-%m-%d')}\n\n{tabela}\n")
+    print(tabela)
+    print(f"\n-> {out}")

simplicio/cache.py

@@ -0,0 +1,59 @@
+"""
+cache.py — cache de embeddings keyed por HASH do conteudo.
+
+Por que por hash e nao por arquivo: se o bloco de codigo nao mudou, o hash
+e o mesmo -> reusa o vetor. Arquivo muda mas o trecho relevante nao? Ainda
+acerta o cache. Trecho muda -> hash novo -> re-embedda SO ele. Granular.
+
+Persistido em .simplicio/emb_cache.npz (vetores) + .json (indice hash->linha).
+"""
+
+import os, json, hashlib
+import numpy as np
+
+class EmbeddingCache:
+    def __init__(self, root):
+        self.dir = os.path.join(root, ".simplicio")
+        os.makedirs(self.dir, exist_ok=True)
+        self.vec_path = os.path.join(self.dir, "emb_cache.npz")
+        self.idx_path = os.path.join(self.dir, "emb_index.json")
+        self.index = {}        # hash -> posicao na matriz
+        self.vectors = None    # np.ndarray [N, dim]
+        self._load()
+
+    @staticmethod
+    def h(texto):
+        return hashlib.sha1(texto.encode("utf-8")).hexdigest()
+
+    def _load(self):
+        if os.path.exists(self.idx_path) and os.path.exists(self.vec_path):
+            self.index = json.load(open(self.idx_path))
+            self.vectors = np.load(self.vec_path)["v"]
+
+    def save(self):
+        json.dump(self.index, open(self.idx_path, "w"))
+        if self.vectors is not None:
+            np.savez_compressed(self.vec_path, v=self.vectors)
+
+    def get_missing(self, textos):
+        """Retorna os textos que NAO estao no cache (precisam embeddar)."""
+        return [t for t in textos if self.h(t) not in self.index]
+
+    def add(self, textos, vetores):
+        """Adiciona novos textos+vetores ao cache."""
+        if not textos:
+            return
+        vetores = np.asarray(vetores)
+        base = 0 if self.vectors is None else self.vectors.shape[0]
+        self.vectors = vetores if self.vectors is None else np.vstack([self.vectors, vetores])
+        for i, t in enumerate(textos):
+            self.index[self.h(t)] = base + i
+
+    def lookup(self, textos):
+        """Devolve matriz de vetores na ordem dos textos (todos ja no cache)."""
+        rows = [self.index[self.h(t)] for t in textos]
+        return self.vectors[rows]
+
+    def stats(self):
+        return {"cached_blocks": len(self.index),
+                "dim": 0 if self.vectors is None else int(self.vectors.shape[1])}

simplicio/cli.py

@@ -0,0 +1,43 @@
+"""cli.py — comandos: index (cacheia repo) e task (roda o pipeline)."""
+import argparse
+from .precedent import index_repo
+from .pipeline import run
+from .bench import run_bench
+from .providers import gerar, info
+
+def main():
+    ap = argparse.ArgumentParser(prog="simplicio")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    pi = sub.add_parser("index", help="indexa/cacheia o repo (1x ou apos mudancas)")
+    pi.add_argument("--root", default="."); pi.add_argument("--stack", default="angular")
+
+    pt = sub.add_parser("task", help="executa uma tarefa")
+    pt.add_argument("objetivo")
+    pt.add_argument("--root", default="."); pt.add_argument("--stack", default="angular")
+    pt.add_argument("--alvo", required=True)
+    pt.add_argument("--criterios", default="- estado verdadeiro\n- estado falso")
+    pt.add_argument("--restricoes", default="- build passa")
+
+
+    pb = sub.add_parser("bench", help="compara com vs sem (numeros reais)")
+    pb.add_argument("--root", default="."); pb.add_argument("--stack", default="angular")
+    pb.add_argument("--cases", default="bench/cases.json")
+
+
+    sub.add_parser("smoke", help="1 chamada de prova: conecta+gera (precisa SIMPLICIO_MODEL+KEY)")
+
+    a = ap.parse_args()
+    if a.cmd == "index":
+        index_repo(a.root, a.stack)
+    elif a.cmd == "smoke":
+        print("provider:", info())
+        out = gerar("Responda exatamente: OK simplicio conectado.")
+        print("resposta do modelo:", out.strip()[:200])
+    elif a.cmd == "bench":
+        run_bench(a.root, a.stack, a.cases)
+    else:
+        run(a.root, a.stack, a.objetivo, a.alvo, a.criterios, a.restricoes)
+
+if __name__ == "__main__":
+    main()

simplicio/pipeline.py

@@ -0,0 +1,28 @@
+"""pipeline.py — monta -> gera -> aplica -> testa -> corrige (loop)."""
+import os, subprocess
+from .prompt import montar
+from .providers import gerar
+
+MAX_TENTATIVAS = 3
+
+def _aplicar_e_testar(saida, root):
+    os.makedirs(os.path.join(root, ".simplicio"), exist_ok=True)
+    open(os.path.join(root, ".simplicio/ultima_saida.txt"), "w").write(saida)
+    # PLUGUE: extrair diff -> git apply; extrair teste. Aqui roda o cmd de teste.
+    cmd = os.environ.get("SIMPLICIO_TEST_CMD", "echo 'configure SIMPLICIO_TEST_CMD'")
+    p = subprocess.run(cmd, shell=True, cwd=root, capture_output=True, text=True)
+    return p.returncode == 0, (p.stdout + p.stderr)[-2000:]
+
+def run(root, stack, objetivo, alvo, criterios, restricoes):
+    prompt = montar(root, stack, objetivo, alvo, criterios, restricoes)
+    feedback = None
+    for t in range(1, MAX_TENTATIVAS + 1):
+        print(f"--- tentativa {t} (provider={os.environ.get('SIMPLICIO_PROVIDER','claude')}) ---")
+        saida = gerar(prompt, feedback)
+        ok, log = _aplicar_e_testar(saida, root)
+        if ok:
+            print("PASSOU no contrato. PRONTO.")
+            return saida
+        print("falhou:", log[:300]); feedback = log
+    print("esgotou tentativas — revisar manual.")
+    return None

simplicio/precedent.py

@@ -0,0 +1,83 @@
+"""
+precedent.py — acha PRECEDENTE usando o cache (so embedda bloco novo).
+"""
+import re, glob, os
+import numpy as np
+from .cache import EmbeddingCache
+
+_emb = None
+def _embedder():
+    global _emb
+    if _emb is None:
+        from sentence_transformers import SentenceTransformer
+        _emb = SentenceTransformer("all-MiniLM-L6-v2")
+    return _emb
+
+PATTERNS = {
+    "angular": [r"\*ngIf", r"\[hidden\]", r"\[disabled\]", r"hasPerm",
+                r"ngxPermission", r"canActivate"],
+    "react":   [r"&&\s*<", r"\?\s*<[A-Z]", r"usePermission", r"\bcan\(",
+                r"hasRole", r"<Protected"],
+    "dotnet":  [r"\[Authorize", r"HasPermission", r"User\.IsInRole",
+                r"\[HasPolicy", r"RequireClaim"],
+}
+EXT = {"angular": (".html", ".ts"), "react": (".tsx", ".jsx", ".ts"),
+       "dotnet": (".cs", ".cshtml", ".razor")}
+SKIP = ("node_modules", "/.git/", "/dist/", "/bin/", "/obj/", "/.angular/", "/.simplicio/")
+
+
+def grep_candidatos(root, stack, janela=1):
+    pats = [re.compile(p) for p in PATTERNS[stack]]
+    exts = EXT[stack]
+    cands = []
+    for fp in glob.glob(f"{root}/**/*", recursive=True):
+        if not os.path.isfile(fp) or not fp.endswith(exts): continue
+        if any(s in fp for s in SKIP): continue
+        try:
+            linhas = open(fp, encoding="utf-8", errors="ignore").read().splitlines()
+        except Exception:
+            continue
+        for i, ln in enumerate(linhas):
+            if any(p.search(ln) for p in pats):
+                bloco = "\n".join(linhas[max(0, i - janela): i + janela + 1])
+                cands.append({"file": fp, "line": i + 1, "code": bloco})
+    return cands
+
+
+def index_repo(root, stack, verbose=True):
+    """Indexa: embedda SO os blocos novos, salva cache. Retorna stats."""
+    cache = EmbeddingCache(root)
+    cands = grep_candidatos(root, stack)
+    textos = list({c["code"] for c in cands})         # dedup
+    faltam = cache.get_missing(textos)
+    if faltam:
+        vetores = _embedder().encode(faltam, show_progress_bar=False)
+        cache.add(faltam, vetores)
+        cache.save()
+    if verbose:
+        print(f"[index] candidatos={len(cands)} novos_embeddados={len(faltam)} "
+              f"cache_total={cache.stats()['cached_blocks']}")
+    return cache, cands
+
+
+def montar_bloco_precedente(root, stack, tarefa, k=2):
+    cache, cands = index_repo(root, stack, verbose=False)
+    if not cands:
+        return "[PRECEDENTE]\n(nenhum padrao similar no repo — gere do zero pela convencao da stack)"
+    textos = [c["code"] for c in cands]
+    vc = cache.lookup(textos)                          # do cache, sem re-embeddar
+    vt = _embedder().encode([tarefa])[0]               # so a tarefa (curta)
+    for c, v in zip(cands, vc):
+        c["score"] = float(np.dot(vt, v) / (np.linalg.norm(vt) * np.linalg.norm(v)))
+    seen, out = set(), []
+    for c in sorted(cands, key=lambda x: x["score"], reverse=True):
+        if c["code"] in seen: continue
+        seen.add(c["code"]); out.append(c)
+    tops = out[:k]
+    linhas = ["[PRECEDENTE]",
+              "Este projeto JA faz algo parecido. Siga ESTA convencao, nao invente:"]
+    for c in tops:
+        rel = os.path.relpath(c["file"], root)
+        linhas.append(f"\n# {rel}:{c['line']}  (similaridade {c['score']:.2f})")
+        linhas.append(c["code"])
+    return "\n".join(linhas)

simplicio/prompt.py

@@ -0,0 +1,25 @@
+"""prompt.py — empilha as 6 camadas."""
+import os, re
+from .precedent import montar_bloco_precedente
+from .skill_router import montar_bloco_skill
+
+def _mapper(root, alvo):
+    try:
+        txt = open(os.path.join(root, alvo), encoding="utf-8", errors="ignore").read()
+    except Exception:
+        return "(mapper: alvo nao lido)"
+    deps = [l for l in txt.splitlines()
+            if l.strip().startswith(("import", "using", "from"))][:15]
+    return f"Arquivo: {alvo}\nDependencias:\n" + "\n".join(deps)
+
+def montar(root, stack, objetivo, alvo, criterios, restricoes):
+    tpl_path = os.path.join(os.path.dirname(__file__), "templates", "simplicio_prompt.md")
+    tpl = open(tpl_path, encoding="utf-8").read()
+    prec = montar_bloco_precedente(root, stack, objetivo, k=2)
+    skill = montar_bloco_skill(root, objetivo)
+    alvo_bloco = f"{alvo}\n\nContexto do alvo:\n{_mapper(root, alvo)}"
+    for s, v in {"{{STACK}}": stack, "{{OBJETIVO}}": objetivo,
+                 "{{ALVO}}": alvo_bloco, "{{PRECEDENTE}}": prec, "{{SKILL}}": skill,
+                 "{{CRITERIOS}}": criterios, "{{RESTRICOES}}": restricoes}.items():
+        tpl = tpl.replace(s, v)
+    return re.sub(r"\{#.*?#\}", "", tpl, flags=re.DOTALL).strip()

simplicio/providers.py

@@ -0,0 +1,62 @@
+"""
+providers.py — agnostico de provider. NAO lista modelos especificos.
+
+Voce define por env (ou flag --model/--base):
+  SIMPLICIO_MODEL     id do modelo, exatamente como o provider espera
+                      ex: "anthropic/claude-opus-4", "openai/gpt-4.1",
+                          "z-ai/glm-4.6", "deepseek/deepseek-chat", "qualquer/coisa"
+  SIMPLICIO_BASE_URL  endpoint OpenAI-compativel
+                      ex OpenRouter: https://openrouter.ai/api/v1
+                      ex GLM:        https://api.z.ai/api/paas/v4
+                      ex local:      http://localhost:11434/v1
+  SIMPLICIO_API_KEY   a chave (qualquer provider)
+
+Caminho nativo Anthropic (sem base_url): se SIMPLICIO_BASE_URL estiver vazio
+E a key for ANTHROPIC_API_KEY, usa o SDK anthropic. Senao, usa cliente
+OpenAI-compativel apontando pro base_url -> serve QUALQUER provider OAI-like.
+"""
+import os
+
+def _cfg():
+    return {
+        "model": os.environ.get("SIMPLICIO_MODEL"),
+        "base":  os.environ.get("SIMPLICIO_BASE_URL"),
+        "key":   os.environ.get("SIMPLICIO_API_KEY")
+                 or os.environ.get("OPENROUTER_API_KEY")
+                 or os.environ.get("ANTHROPIC_API_KEY"),
+    }
+
+def _msgs(prompt, feedback):
+    m = [{"role": "user", "content": prompt}]
+    if feedback:
+        m.append({"role": "user",
+                  "content": f"O teste FALHOU:\n{feedback}\nCorrija. Mesmo formato."})
+    return m
+
+def gerar(prompt, feedback=None, max_tokens=4000):
+    c = _cfg()
+    if not c["model"]:
+        raise SystemExit("defina SIMPLICIO_MODEL (id do modelo do seu provider)")
+    if not c["key"]:
+        raise SystemExit("defina SIMPLICIO_API_KEY (ou OPENROUTER_/ANTHROPIC_API_KEY)")
+
+    # caminho nativo Anthropic: sem base_url
+    if not c["base"]:
+        import anthropic
+        cli = anthropic.Anthropic(api_key=c["key"])
+        r = cli.messages.create(model=c["model"], max_tokens=max_tokens,
+                                messages=_msgs(prompt, feedback))
+        return next((b.text for b in r.content if b.type == "text"), "")
+
+    # qualquer endpoint OpenAI-compativel (OpenRouter, GLM, DeepSeek, local...)
+    from openai import OpenAI
+    cli = OpenAI(base_url=c["base"], api_key=c["key"])
+    r = cli.chat.completions.create(model=c["model"], max_tokens=max_tokens,
+                                    messages=_msgs(prompt, feedback))
+    return r.choices[0].message.content
+
+def info():
+    c = _cfg()
+    return (f"model={c['model'] or '(nao definido)'} "
+            f"base={c['base'] or 'anthropic-nativo'} "
+            f"key={'set' if c['key'] else 'FALTA'}")

simplicio/skill_router.py

@@ -0,0 +1,48 @@
+"""
+skill_router.py — CAMADA 4.5. Seleciona A skill que casa com a tarefa.
+NAO injeta todas (ruido). Ranqueia por sentido, pega top-1.
+
+Fonte das skills: por padrao varre <root>/.mapper/skills/*.md ou
+SIMPLICIO_SKILLS_DIR. Cada skill = arquivo md com 1a linha = descricao.
+Reusa o mesmo cache de embeddings.
+"""
+import os, glob
+import numpy as np
+from .cache import EmbeddingCache
+
+def _skills_dir(root):
+    return os.environ.get("SIMPLICIO_SKILLS_DIR",
+                          os.path.join(root, ".mapper", "skills"))
+
+def _carregar_skills(root):
+    d = _skills_dir(root)
+    out = []
+    for fp in glob.glob(os.path.join(d, "*.md")):
+        try:
+            txt = open(fp, encoding="utf-8", errors="ignore").read()
+        except Exception:
+            continue
+        desc = next((l.strip("# ").strip() for l in txt.splitlines() if l.strip()), "")
+        out.append({"nome": os.path.basename(fp), "desc": desc, "corpo": txt})
+    return out
+
+def montar_bloco_skill(root, tarefa, limiar=0.15):
+    skills = _carregar_skills(root)
+    if not skills:
+        return ""  # sem skills -> camada some, sem ruido
+    from .precedent import _embedder
+    cache = EmbeddingCache(root)
+    descs = [s["desc"] for s in skills]
+    faltam = cache.get_missing(descs)
+    if faltam:
+        cache.add(faltam, _embedder().encode(faltam, show_progress_bar=False))
+        cache.save()
+    vd = cache.lookup(descs)
+    vt = _embedder().encode([tarefa])[0]
+    scores = [float(np.dot(vt, v)/(np.linalg.norm(vt)*np.linalg.norm(v))) for v in vd]
+    i = int(np.argmax(scores))
+    if scores[i] < limiar:
+        return ""  # nada casa o suficiente -> nao força skill irrelevante
+    s = skills[i]
+    return (f"[SKILL RELEVANTE]\nO mapper tem um metodo que casa com esta tarefa "
+            f"(match {scores[i]:.2f}). Siga-o:\n# {s['nome']}\n{s['corpo'][:1200]}")

simplicio/templates/simplicio_prompt.md

@@ -0,0 +1,43 @@
+{# ============================================================
+   SIMPLICIO-PROMPT — 6 camadas. Ordem: fixo (embaixo/cacheável)
+   -> variável (em cima). Preenchido por run_task.py.
+   {{...}} = slots que a toolchain injeta automaticamente.
+   ============================================================ #}
+
+{# ---------- CAMADA 1: PAPEL + STACK (fixo, cacheia) ---------- #}
+Voce e um engenheiro senior trabalhando NESTE projeto.
+Stack: {{STACK}}.
+Convencoes deste projeto sao LEI. Nao traga padrao generico da internet.
+Nao invente arquivo, lib ou abstracao que o projeto nao usa.
+
+{# ---------- CAMADA 2: OBJETIVO (1 linha, zero ambiguidade) ---------- #}
+[OBJETIVO]
+{{OBJETIVO}}
+
+{# ---------- CAMADA 3: ALVO (so os arquivos que se toca) ---------- #}
+[ALVO]
+Toque SOMENTE nestes arquivos:
+{{ALVO}}
+
+{# ---------- CAMADA 4: PRECEDENTE (o ouro — vem do precedent.py) ---------- #}
+{{PRECEDENTE}}
+
+{{SKILL}}
+
+{# ---------- CAMADA 5: CONTRATO (estados testaveis + o que nao quebrar) ---------- #}
+[CONTRATO]
+Pronto QUANDO, e somente quando, TODOS os estados abaixo forem verdade:
+{{CRITERIOS}}
+
+Restricoes (nao quebrar):
+{{RESTRICOES}}
+
+{# ---------- CAMADA 6: SAIDA (formato exato) ---------- #}
+[SAIDA]
+Devolva EXATAMENTE neste formato, nada mais:
+1. DIFF unificado, so dos arquivos do [ALVO].
+2. TESTE: codigo de teste que verifica cada estado do [CONTRATO]
+   (um caso por criterio — estado verdadeiro E falso).
+3. EVIDENCIA: script Playwright que captura print dos estados de UI,
+   se a tarefa for visual. Senao, escreva "N/A".
+Sem explicacao, sem preambulo.

simplicio_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: simplicio-cli
+Version: 0.2.0
+Summary: Portable task-to-code pipeline that works with any LLM. Turn a one-line task into a verified code change — diff + test + verify loop. +54 pts on a 156-check benchmark vs raw prompting.
+Author-email: Wesley Simplicio <wesleybob4@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/wesleysimplicio/simplicio-cli
+Project-URL: Repository, https://github.com/wesleysimplicio/simplicio-cli
+Project-URL: Issues, https://github.com/wesleysimplicio/simplicio-cli/issues
+Project-URL: Changelog, https://github.com/wesleysimplicio/simplicio-cli/releases
+Keywords: llm,ai,agent,code-generation,prompt-engineering,openrouter,openai,anthropic,claude,developer-tools,cli,rag,embeddings,verify-loop,task-automation
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sentence-transformers>=2.2
+Requires-Dist: numpy>=1.23
+Requires-Dist: anthropic>=0.30
+Requires-Dist: openai>=1.30
+Dynamic: license-file
+
+# simplicio-cli
+
+**Turn a one-line task into a verified code change — with any LLM.**
+
+[![PyPI](https://img.shields.io/pypi/v/simplicio-cli.svg)](https://pypi.org/project/simplicio-cli/)
+[![Python](https://img.shields.io/pypi/pyversions/simplicio-cli.svg)](https://pypi.org/project/simplicio-cli/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+> *"hide the Delete button for non-admins"* → diff + test + applied + verified.
+> Works with **OpenRouter, OpenAI, Anthropic, GLM, DeepSeek, Ollama** — one env var.
+
+```bash
+pip install simplicio-cli
+```
+
+---
+
+## Why it works — the numbers
+
+Same model. Same task. Only the prompt changes. **Measured, reproducible, deterministic.**
+
+| Model | Without simplicio | With simplicio | Gain |
+|---|---|---|---|
+| **Llama 3.1 8B Instruct** | 34% | **98%** | **+64 pts** |
+| **Gemma 3 12B IT** | 38% | **94%** | **+56 pts** |
+| **Qwen 2.5 7B Instruct** | 38% | **80%** | **+42 pts** |
+| **Average across 3 models · 10 cases · 156 checks** | **37%** | **91%** | **+54 pts (+145%)** |
+
+### Output-quality signals (rate across all 30 runs)
+
+| Signal | Raw prompt | With simplicio |
+|---|---|---|
+| **DIFF block present** | 0% | **100%** |
+| Target file mentioned | 3% | **96%** |
+| TEST block present | 86% | **93%** |
+
+> A 7B-parameter open model wrapped in simplicio's 6-layer contract outperforms
+> the same model with raw prompting **by 42 to 64 points**. Without changing the
+> model. Without fine-tuning. Without extra tokens at runtime worth mentioning.
+
+Full report: [`bench/results.md`](bench/results.md) · [`bench/results.pdf`](bench/results.pdf) · raw outputs under `.simplicio/bench_runs/`.
+
+---
+
+## How it works
+
+```
+mapper        WHERE   project structure + latest state
+precedent     HOW-1   the real snippet in THIS repo that already does it
+skill-router  HOW-2   the ONE mapper skill that matches (ranked, not all)
+simplicio     BUILD   stacks the 6 layers into one prompt (cache-friendly)
+test          JUDGE   contract written as testable states
+verify        PROOF   ran it — did it actually pass? loop-fix up to 3x
+```
+
+**The idea in one line: don't ask the model to guess — hand it the path.**
+Each layer terminates one decision the model would otherwise hallucinate.
+Relevant > complete — inject the *right* context, never *all* of it.
+
+---
+
+## Install
+
+```bash
+pip install simplicio-cli           # from PyPI
+# or
+pip install -e .                    # from this repo
+```
+
+## Configure — any LLM, nothing hardcoded
+
+| Provider | SIMPLICIO_MODEL | SIMPLICIO_BASE_URL |
+|---|---|---|
+| OpenRouter | `anthropic/claude-opus-4` | `https://openrouter.ai/api/v1` |
+| GLM (z.ai) | `glm-4.6` | `https://api.z.ai/api/paas/v4` |
+| DeepSeek | `deepseek-chat` | `https://api.deepseek.com` |
+| OpenAI | `gpt-4.1` | `https://api.openai.com/v1` |
+| Local (Ollama) | `llama3` | `http://localhost:11434/v1` |
+| Anthropic native | `claude-opus-4-7` | *(leave unset)* |
+
+If `SIMPLICIO_BASE_URL` is unset and the key is `ANTHROPIC_API_KEY`, it uses the
+native Anthropic SDK. Otherwise it uses an OpenAI-compatible client pointed at
+your `base_url` — so **any** OpenAI-like provider works without code changes.
+
+```bash
+simplicio smoke      # prints provider config + one test call
+```
+
+## Use
+
+```bash
+# index once (caches embeddings; re-run after big changes)
+simplicio index --stack angular
+
+# run a task
+simplicio task "hide Delete button for non-admins" \
+  --stack angular \
+  --alvo src/app/screen/screen.component.html \
+  --criterios "- no admin perm: button absent from DOM
+- with admin perm: button present" \
+  --restricoes "- don't touch save flow
+- build passes"
+```
+
+Each `task`: precedent (from cache) → skill match → 6 layers → LLM generates
+(diff + test + Playwright) → apply → run `SIMPLICIO_TEST_CMD` → pass? **done** :
+send the error back → fix → retry (up to 3x).
+
+---
+
+## Cache — why it doesn't re-map every time
+
+Embeddings are keyed by **content hash**, stored in `.simplicio/`. Unchanged
+code block → vector reused. Change one file → only that block re-embeds.
+
+| Run | Blocks embedded | Time |
+|---|---|---|
+| 1st (cold cache) | 3 | ~baseline |
+| 2nd (no change) | **0** | **~instant** |
+| after editing 1 file | **1** | partial |
+
+---
+
+## Benchmark — reproduce in 30 seconds
+
+```bash
+OPENROUTER_API_KEY=… \
+  BENCH_MODELS="qwen/qwen-2.5-7b-instruct,meta-llama/llama-3.1-8b-instruct,google/gemma-3-12b-it" \
+  python3 bench/run_offline.py
+```
+
+No project required, stdlib only, deterministic regex scoring — no LLM judges
+the LLM. Each case runs twice on the **same** model: raw one-line objective vs
+simplicio's 6-layer contract. Outputs scored on target-file mention, DIFF
+block, TEST block, contract-state words. Full numbers in [`bench/results.md`](bench/results.md).
+
+### Full harness (your real project, your real tests)
+
+```bash
+simplicio bench --cases bench/cases.json --stack angular
+```
+
+Runs each case two ways and runs **your real test command** (e.g. `ng test
+--watch=false`) on each output. Writes the true pass-rate to
+[`bench/results.md`](bench/results.md).
+
+---
+
+## Plug points (stubs marked in code)
+
+| File | Replace with |
+|---|---|
+| `prompt.py::_mapper` | your real **llm-project-mapper** |
+| `pipeline.py::_aplicar_e_testar` | extract diff → `git apply` → parse test result |
+| `skill_router.py` | point `SIMPLICIO_SKILLS_DIR` at your mapper's skills |
+
+## Layout
+
+```
+simplicio/
+  cli.py          # index | task | bench | smoke
+  cache.py        # content-hash embedding cache
+  precedent.py    # grep + semantic rank (uses cache)
+  skill_router.py # picks the ONE matching skill
+  prompt.py       # stacks the 6 layers
+  providers.py    # any OpenAI-compatible endpoint + Anthropic native
+  pipeline.py     # generate → test → fix loop
+  bench.py        # with-vs-without harness
+  templates/simplicio_prompt.md
+bench/
+  run_offline.py  # stdlib-only multi-model benchmark
+  cases.json      # your benchmark tasks
+  cases_offline.json
+  results.md      # filled by `simplicio bench` / `run_offline.py`
+  charts/         # SVG: overall, delta, by_case, by_stack
+```
+
+## License
+MIT

simplicio_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+simplicio/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+simplicio/bench.py,sha256=_2zvGRGXtfhv7H1iVLcspxAKz6ibIaLqZU5fhdBGCf4,2334
+simplicio/cache.py,sha256=bUdJerB7myC_CesagzNDBfSk_U4FRrmK_eiI1XTmoRw,2267
+simplicio/cli.py,sha256=fs7o-1Llej_TZXZFjN2ADI-OPhR9-BbadqszV7cgveQ,1675
+simplicio/pipeline.py,sha256=9rZSI-7E9OmCB0fScV8qXXXK25SopMzbt92Us48XfvE,1256
+simplicio/precedent.py,sha256=yQ24gMkmIaAja0DT5HRdR3o8gzQRkw3BdNAnnXF0oaM,3340
+simplicio/prompt.py,sha256=6IyKWNvUe_r7ORatNKZk-U1gVhVuc0icKzr-QiY1aM4,1226
+simplicio/providers.py,sha256=Ngq39yKUVKxGyhhR5fSHoOYY7bM5y_G180EUngKGIvw,2598
+simplicio/skill_router.py,sha256=_91_b74BGu3dRFK_7uoApHLIoY1eVqrRjW27bp80_i8,1858
+simplicio/templates/simplicio_prompt.md,sha256=8i6M_BWJHKkjA-6pQsw8c4eDuxSlNPWDmGQlX7txlIQ,1576
+simplicio_cli-0.2.0.dist-info/licenses/LICENSE,sha256=i0oySk8jwjV1P3a3uskDYmAGpU8DOaIGdO1yEp0UUTQ,816
+simplicio_cli-0.2.0.dist-info/METADATA,sha256=J6_oX6TEmmzH5u_kNGNfswU0IIu_vHe1A-am1RsbHLk,7951
+simplicio_cli-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+simplicio_cli-0.2.0.dist-info/entry_points.txt,sha256=e-QHNyRGjMY8wCdmEcUmKmzKXZ3oxTDToUQTKlghQsE,49
+simplicio_cli-0.2.0.dist-info/top_level.txt,sha256=qDCXq49sOcz28KN7xHwTKhhsXuqZGXrnJ40bjA2Oy1c,10
+simplicio_cli-0.2.0.dist-info/RECORD,,

simplicio_cli-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simplicio_cli-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+simplicio = simplicio.cli:main

simplicio_cli-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,17 @@
+MIT License
+
+Copyright (c) 2026 Wesley Simplicio
+
+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. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY ARISING FROM THE SOFTWARE OR ITS USE.

simplicio_cli-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+simplicio