simplicio-cli 0.2.2__tar.gz → 0.2.3__tar.gz

{simplicio_cli-0.2.2/simplicio_cli.egg-info → simplicio_cli-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-cli
-Version: 0.2.2
+Version: 0.2.3
 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. +55 pts on a 156-check benchmark, 21% faster, ~same tokens.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT
@@ -147,10 +147,10 @@ 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
+  --target src/app/screen/screen.component.html \
+  --criteria "- no admin perm: button absent from DOM
 - with admin perm: button present" \
-  --restricoes "- don't touch save flow
+  --constraints "- don't touch save flow
 - build passes"
 ```
 

{simplicio_cli-0.2.2 → simplicio_cli-0.2.3}/README.md

@@ -112,10 +112,10 @@ 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
+  --target src/app/screen/screen.component.html \
+  --criteria "- no admin perm: button absent from DOM
 - with admin perm: button present" \
-  --restricoes "- don't touch save flow
+  --constraints "- don't touch save flow
 - build passes"
 ```
 

{simplicio_cli-0.2.2 → simplicio_cli-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simplicio-cli"
-version = "0.2.2"
+version = "0.2.3"
 description = "Portable task-to-code pipeline that works with any LLM. Turn a one-line task into a verified code change — diff + test + verify loop. +55 pts on a 156-check benchmark, 21% faster, ~same tokens."
 readme = "README.md"
 license = { text = "MIT" }

simplicio_cli-0.2.3/simplicio/bench.py

@@ -0,0 +1,51 @@
+"""
+bench.py — compares WITH vs WITHOUT the pipeline. REAL numbers, nothing made up.
+
+Each case = {goal, target, criteria, test_cmd}.
+  WITHOUT: sends only the raw goal to the LLM (baseline).
+  WITH:    full pipeline (precedent + skill + layers + verify).
+Measures: did it pass the test on the first try? how many attempts?
+
+Usage: simplicio bench --cases bench/cases.json --stack angular
+Writes bench/results.md with the real table.
+"""
+import os, json, time, subprocess
+from .prompt import build_prompt
+from .providers import generate
+
+def _test(output, root, test_cmd):
+    os.makedirs(os.path.join(root, ".simplicio"), exist_ok=True)
+    open(os.path.join(root, ".simplicio/bench_out.txt"), "w").write(output or "")
+    p = subprocess.run(test_cmd, shell=True, cwd=root, capture_output=True, text=True)
+    return p.returncode == 0
+
+def _baseline(case, root):
+    # baseline: raw goal, zero built context
+    return generate(case["goal"])
+
+def _pipeline(case, root, stack):
+    return generate(build_prompt(root, stack, case["goal"], case["target"],
+                                 case.get("criteria","- true state\n- false state"),
+                                 case.get("constraints","- build passes")))
+
+def run_bench(root, stack, cases_path):
+    cases = json.load(open(cases_path))
+    rows, n = [], len(cases)
+    hits = {"without": 0, "with": 0}
+    for c in cases:
+        tc = c["test_cmd"]
+        ok_without = _test(_baseline(c, root), root, tc); hits["without"] += ok_without
+        ok_with = _test(_pipeline(c, root, stack), root, tc); hits["with"] += ok_with
+        rows.append(f"| {c['goal'][:40]} | {'PASS' if ok_without else 'FAIL'} | {'PASS' if ok_with else 'FAIL'} |")
+    table = ("| Task | Without simplicio | With simplicio |\n|---|---|---|\n"
+             + "\n".join(rows)
+             + f"\n\n**First-try pass rate:** without = {hits['without']}/{n} "
+               f"({100*hits['without']//n}%) · with = {hits['with']}/{n} "
+               f"({100*hits['with']//n}%)")
+    out = os.path.join(root, "bench", "results.md")
+    os.makedirs(os.path.dirname(out), exist_ok=True)
+    open(out, "w").write(f"# Benchmark (generated by `simplicio bench`)\n\n"
+                         f"Provider: {os.environ.get('SIMPLICIO_PROVIDER','claude')} · "
+                         f"cases: {n} · date: {time.strftime('%Y-%m-%d')}\n\n{table}\n")
+    print(table)
+    print(f"\n-> {out}")

{simplicio_cli-0.2.2 → simplicio_cli-0.2.3}/simplicio/cache.py

@@ -1,11 +1,11 @@
 """
-cache.py — cache de embeddings keyed por HASH do conteudo.
+cache.py — embedding cache keyed by content HASH.
 
-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.
+Why hash, not file: if a code block didn't change, the hash is the same ->
+reuse the vector. File changes but the relevant snippet didn't? Still a
+cache hit. Snippet changes -> new hash -> only that one is re-embedded. Granular.
 
-Persistido em .simplicio/emb_cache.npz (vetores) + .json (indice hash->linha).
+Persisted in .simplicio/emb_cache.npz (vectors) + .json (hash->row index).
 """
 
 import os, json, hashlib
@@ -17,13 +17,13 @@ class EmbeddingCache:
         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.index = {}        # hash -> row position in the matrix
         self.vectors = None    # np.ndarray [N, dim]
         self._load()
 
     @staticmethod
-    def h(texto):
-        return hashlib.sha1(texto.encode("utf-8")).hexdigest()
+    def h(text):
+        return hashlib.sha1(text.encode("utf-8")).hexdigest()
 
     def _load(self):
         if os.path.exists(self.idx_path) and os.path.exists(self.vec_path):
@@ -35,23 +35,23 @@ class EmbeddingCache:
         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 get_missing(self, texts):
+        """Returns the texts NOT in the cache (need embedding)."""
+        return [t for t in texts if self.h(t) not in self.index]
 
-    def add(self, textos, vetores):
-        """Adiciona novos textos+vetores ao cache."""
-        if not textos:
+    def add(self, texts, vectors):
+        """Adds new texts+vectors to the cache."""
+        if not texts:
             return
-        vetores = np.asarray(vetores)
+        vectors = np.asarray(vectors)
         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.vectors = vectors if self.vectors is None else np.vstack([self.vectors, vectors])
+        for i, t in enumerate(texts):
             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]
+    def lookup(self, texts):
+        """Returns a matrix of vectors in the texts' order (all already cached)."""
+        rows = [self.index[self.h(t)] for t in texts]
         return self.vectors[rows]
 
     def stats(self):

simplicio_cli-0.2.3/simplicio/cli.py

@@ -0,0 +1,43 @@
+"""cli.py — commands: index (cache repo), task (run pipeline), bench, smoke."""
+import argparse
+from .precedent import index_repo
+from .pipeline import run
+from .bench import run_bench
+from .providers import generate, info
+
+def main():
+    ap = argparse.ArgumentParser(prog="simplicio")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    pi = sub.add_parser("index", help="index/cache the repo (once, or after changes)")
+    pi.add_argument("--root", default="."); pi.add_argument("--stack", default="angular")
+
+    pt = sub.add_parser("task", help="run a task")
+    pt.add_argument("goal")
+    pt.add_argument("--root", default="."); pt.add_argument("--stack", default="angular")
+    pt.add_argument("--target", required=True)
+    pt.add_argument("--criteria", default="- true state\n- false state")
+    pt.add_argument("--constraints", default="- build passes")
+
+
+    pb = sub.add_parser("bench", help="compare with vs without (real numbers)")
+    pb.add_argument("--root", default="."); pb.add_argument("--stack", default="angular")
+    pb.add_argument("--cases", default="bench/cases.json")
+
+
+    sub.add_parser("smoke", help="one proof call: connect+generate (needs 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 = generate("Reply exactly: OK simplicio connected.")
+        print("model reply:", out.strip()[:200])
+    elif a.cmd == "bench":
+        run_bench(a.root, a.stack, a.cases)
+    else:
+        run(a.root, a.stack, a.goal, a.target, a.criteria, a.constraints)
+
+if __name__ == "__main__":
+    main()

simplicio_cli-0.2.3/simplicio/pipeline.py

@@ -0,0 +1,28 @@
+"""pipeline.py — build -> generate -> apply -> test -> fix (loop)."""
+import os, subprocess
+from .prompt import build_prompt
+from .providers import generate
+
+MAX_ATTEMPTS = 3
+
+def _apply_and_test(output, root):
+    os.makedirs(os.path.join(root, ".simplicio"), exist_ok=True)
+    open(os.path.join(root, ".simplicio/last_output.txt"), "w").write(output)
+    # PLUG: extract diff -> git apply; extract test. Here we run the test command.
+    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, goal, target, criteria, constraints):
+    prompt = build_prompt(root, stack, goal, target, criteria, constraints)
+    feedback = None
+    for t in range(1, MAX_ATTEMPTS + 1):
+        print(f"--- attempt {t} (provider={os.environ.get('SIMPLICIO_PROVIDER','claude')}) ---")
+        output = generate(prompt, feedback)
+        ok, log = _apply_and_test(output, root)
+        if ok:
+            print("PASSED the contract. DONE.")
+            return output
+        print("failed:", log[:300]); feedback = log
+    print("attempts exhausted — manual review needed.")
+    return None

{simplicio_cli-0.2.2 → simplicio_cli-0.2.3}/simplicio/precedent.py

@@ -1,5 +1,5 @@
 """
-precedent.py — acha PRECEDENTE usando o cache (so embedda bloco novo).
+precedent.py — finds PRECEDENT using the cache (only embeds new blocks).
 """
 import re, glob, os
 import numpy as np
@@ -26,7 +26,7 @@ EXT = {"angular": (".html", ".ts"), "react": (".tsx", ".jsx", ".ts"),
 SKIP = ("node_modules", "/.git/", "/dist/", "/bin/", "/obj/", "/.angular/", "/.simplicio/")
 
 
-def grep_candidatos(root, stack, janela=1):
+def grep_candidates(root, stack, window=1):
     pats = [re.compile(p) for p in PATTERNS[stack]]
     exts = EXT[stack]
     cands = []
@@ -34,39 +34,39 @@ def grep_candidatos(root, stack, janela=1):
         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()
+            lines = open(fp, encoding="utf-8", errors="ignore").read().splitlines()
         except Exception:
             continue
-        for i, ln in enumerate(linhas):
+        for i, ln in enumerate(lines):
             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})
+                block = "\n".join(lines[max(0, i - window): i + window + 1])
+                cands.append({"file": fp, "line": i + 1, "code": block})
     return cands
 
 
 def index_repo(root, stack, verbose=True):
-    """Indexa: embedda SO os blocos novos, salva cache. Retorna stats."""
+    """Index: embed ONLY new blocks, persist cache. Returns 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)
+    cands = grep_candidates(root, stack)
+    texts = list({c["code"] for c in cands})         # dedup
+    missing = cache.get_missing(texts)
+    if missing:
+        vectors = _embedder().encode(missing, show_progress_bar=False)
+        cache.add(missing, vectors)
         cache.save()
     if verbose:
-        print(f"[index] candidatos={len(cands)} novos_embeddados={len(faltam)} "
+        print(f"[index] candidates={len(cands)} newly_embedded={len(missing)} "
               f"cache_total={cache.stats()['cached_blocks']}")
     return cache, cands
 
 
-def montar_bloco_precedente(root, stack, tarefa, k=2):
+def build_precedent_block(root, stack, task, 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)
+        return "[PRECEDENT]\n(no similar pattern in repo — generate from scratch using stack convention)"
+    texts = [c["code"] for c in cands]
+    vc = cache.lookup(texts)                           # from cache, no re-embed
+    vt = _embedder().encode([task])[0]                 # only the task (short)
     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(), []
@@ -74,10 +74,10 @@ def montar_bloco_precedente(root, stack, tarefa, k=2):
         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:"]
+    lines = ["[PRECEDENT]",
+             "This project ALREADY does something similar. Follow THIS convention, don't invent:"]
     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)
+        lines.append(f"\n# {rel}:{c['line']}  (similarity {c['score']:.2f})")
+        lines.append(c["code"])
+    return "\n".join(lines)

simplicio_cli-0.2.3/simplicio/prompt.py

@@ -0,0 +1,25 @@
+"""prompt.py — stacks the 6 layers."""
+import os, re
+from .precedent import build_precedent_block
+from .skill_router import build_skill_block
+
+def _mapper(root, target):
+    try:
+        txt = open(os.path.join(root, target), encoding="utf-8", errors="ignore").read()
+    except Exception:
+        return "(mapper: target not read)"
+    deps = [l for l in txt.splitlines()
+            if l.strip().startswith(("import", "using", "from"))][:15]
+    return f"File: {target}\nDependencies:\n" + "\n".join(deps)
+
+def build_prompt(root, stack, goal, target, criteria, constraints):
+    tpl_path = os.path.join(os.path.dirname(__file__), "templates", "simplicio_prompt.md")
+    tpl = open(tpl_path, encoding="utf-8").read()
+    prec = build_precedent_block(root, stack, goal, k=2)
+    skill = build_skill_block(root, goal)
+    target_block = f"{target}\n\nTarget context:\n{_mapper(root, target)}"
+    for s, v in {"{{STACK}}": stack, "{{GOAL}}": goal,
+                 "{{TARGET}}": target_block, "{{PRECEDENT}}": prec, "{{SKILL}}": skill,
+                 "{{CRITERIA}}": criteria, "{{CONSTRAINTS}}": constraints}.items():
+        tpl = tpl.replace(s, v)
+    return re.sub(r"\{#.*?#\}", "", tpl, flags=re.DOTALL).strip()

simplicio_cli-0.2.3/simplicio/providers.py

@@ -0,0 +1,63 @@
+"""
+providers.py — provider-agnostic. Does NOT list specific models.
+
+Configure via env (or --model/--base flags):
+  SIMPLICIO_MODEL     model id, exactly as the provider expects
+                      e.g. "anthropic/claude-opus-4", "openai/gpt-4.1",
+                           "z-ai/glm-4.6", "deepseek/deepseek-chat", "any/thing"
+  SIMPLICIO_BASE_URL  OpenAI-compatible endpoint
+                      OpenRouter: https://openrouter.ai/api/v1
+                      GLM:        https://api.z.ai/api/paas/v4
+                      local:      http://localhost:11434/v1
+  SIMPLICIO_API_KEY   the key (any provider)
+
+Native Anthropic path (no base_url): if SIMPLICIO_BASE_URL is empty AND the
+key is ANTHROPIC_API_KEY, the anthropic SDK is used. Otherwise an
+OpenAI-compatible client is used pointing at base_url — works for ANY
+OpenAI-like provider.
+"""
+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"The test FAILED:\n{feedback}\nFix it. Same output format."})
+    return m
+
+def generate(prompt, feedback=None, max_tokens=4000):
+    c = _cfg()
+    if not c["model"]:
+        raise SystemExit("set SIMPLICIO_MODEL (model id for your provider)")
+    if not c["key"]:
+        raise SystemExit("set SIMPLICIO_API_KEY (or OPENROUTER_/ANTHROPIC_API_KEY)")
+
+    # native Anthropic path: no 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"), "")
+
+    # any OpenAI-compatible endpoint (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 '(unset)'} "
+            f"base={c['base'] or 'anthropic-native'} "
+            f"key={'set' if c['key'] else 'MISSING'}")

simplicio_cli-0.2.3/simplicio/skill_router.py

@@ -0,0 +1,48 @@
+"""
+skill_router.py — LAYER 4.5. Picks THE skill that matches the task.
+Does NOT inject all of them (noise). Ranks by meaning, takes top-1.
+
+Skill source: by default scans <root>/.mapper/skills/*.md or
+SIMPLICIO_SKILLS_DIR. Each skill = md file whose first line is the description.
+Reuses the same embedding cache.
+"""
+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 _load_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({"name": os.path.basename(fp), "desc": desc, "body": txt})
+    return out
+
+def build_skill_block(root, task, threshold=0.15):
+    skills = _load_skills(root)
+    if not skills:
+        return ""  # no skills -> layer disappears, no noise
+    from .precedent import _embedder
+    cache = EmbeddingCache(root)
+    descs = [s["desc"] for s in skills]
+    missing = cache.get_missing(descs)
+    if missing:
+        cache.add(missing, _embedder().encode(missing, show_progress_bar=False))
+        cache.save()
+    vd = cache.lookup(descs)
+    vt = _embedder().encode([task])[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] < threshold:
+        return ""  # nothing matches enough -> don't force an irrelevant skill
+    s = skills[i]
+    return (f"[RELEVANT SKILL]\nThe mapper has a method that matches this task "
+            f"(match {scores[i]:.2f}). Follow it:\n# {s['name']}\n{s['body'][:1200]}")

simplicio_cli-0.2.3/simplicio/templates/simplicio_prompt.md

@@ -0,0 +1,43 @@
+{# ============================================================
+   SIMPLICIO-PROMPT — 6 layers. Order: fixed (bottom/cache-friendly)
+   -> variable (top). Filled in by run_task.py.
+   {{...}} = slots the toolchain injects automatically.
+   ============================================================ #}
+
+{# ---------- LAYER 1: ROLE + STACK (fixed, cached) ---------- #}
+You are a senior engineer working IN THIS project.
+Stack: {{STACK}}.
+Project conventions are LAW. Do not bring generic patterns from the internet.
+Do not invent files, libraries, or abstractions the project does not use.
+
+{# ---------- LAYER 2: GOAL (1 line, zero ambiguity) ---------- #}
+[GOAL]
+{{GOAL}}
+
+{# ---------- LAYER 3: TARGET (only the files you may touch) ---------- #}
+[TARGET]
+Touch ONLY these files:
+{{TARGET}}
+
+{# ---------- LAYER 4: PRECEDENT (the gold — from precedent.py) ---------- #}
+{{PRECEDENT}}
+
+{{SKILL}}
+
+{# ---------- LAYER 5: CONTRACT (testable states + what not to break) ---------- #}
+[CONTRACT]
+Done WHEN, and only when, ALL of the states below are true:
+{{CRITERIA}}
+
+Constraints (do not break):
+{{CONSTRAINTS}}
+
+{# ---------- LAYER 6: OUTPUT (exact shape) ---------- #}
+[OUTPUT]
+Return EXACTLY in this shape, nothing else:
+1. Unified DIFF, target files only.
+2. TEST: test code that verifies each state of the [CONTRACT]
+   (one case per criterion — true AND false state).
+3. EVIDENCE: Playwright script that captures screenshots of the UI states,
+   if the task is visual. Otherwise, write "N/A".
+No prose, no preamble.

{simplicio_cli-0.2.2 → simplicio_cli-0.2.3/simplicio_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-cli
-Version: 0.2.2
+Version: 0.2.3
 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. +55 pts on a 156-check benchmark, 21% faster, ~same tokens.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT
@@ -147,10 +147,10 @@ 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
+  --target src/app/screen/screen.component.html \
+  --criteria "- no admin perm: button absent from DOM
 - with admin perm: button present" \
-  --restricoes "- don't touch save flow
+  --constraints "- don't touch save flow
 - build passes"
 ```
 

simplicio_cli-0.2.2/simplicio/bench.py

@@ -1,51 +0,0 @@
-"""
-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_cli-0.2.2/simplicio/cli.py

@@ -1,43 +0,0 @@
-"""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_cli-0.2.2/simplicio/pipeline.py

@@ -1,28 +0,0 @@
-"""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_cli-0.2.2/simplicio/prompt.py

@@ -1,25 +0,0 @@
-"""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_cli-0.2.2/simplicio/providers.py

@@ -1,62 +0,0 @@
-"""
-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_cli-0.2.2/simplicio/skill_router.py

@@ -1,48 +0,0 @@
-"""
-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_cli-0.2.2/simplicio/templates/simplicio_prompt.md

@@ -1,43 +0,0 @@
-{# ============================================================
-   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.