glyphsteer 0.3.0__py3-none-any.whl

glyphsteer/__init__.py

@@ -0,0 +1,36 @@
+"""GlyphSteer — dual-regime retrieval steering via compiled in-band glyph annotations.
+
+A compiled controlled vocabulary of glyph markers, written onto a corpus by an LLM
+annotation pass, steers retrieval in BOTH regimes at once — lexical (a rare glyph is a
+maximal-IDF exact-match facet) and dense (a glyph carries a learned direction that
+nudges the chunk vector) — while being STRIPPED from the returned text (the sidecar
+split: indexed-form ≠ returned-form). HoneyC pointed at the index instead of Prolog.
+
+The dense layer (`dense`, `eval.magnitude_probe`) needs the optional `dense` extra;
+everything else (vocab, encode, the lexical index, the steer math) is dependency-light.
+"""
+from __future__ import annotations
+
+__version__ = "0.3.0"
+
+from .annotate import Annotation, Annotator, LLMAnnotator, RuleAnnotator
+from .encode import Chunk, annotate_chunk, check_hidden, indexed_form, returned_form
+from .index import assert_hidden, build_index, facet_only, search
+from .legend import (author, from_legend, load_legend, merge, render_legend,
+                     save_legend, to_legend)
+from .grammar import GlyphGrammar, GlyphLint
+from .steer import cosine, rerank, sim_eff, unit
+from .vocab import (GRADE, GRADE_RANK, SENTIMENT, SEP, Axis, Vocabulary,
+                    grade_label, is_lexically_clean)
+
+__all__ = [
+    "Axis", "Vocabulary", "SENTIMENT", "GRADE", "GRADE_RANK", "grade_label",
+    "SEP", "is_lexically_clean",
+    "Annotation", "Annotator", "RuleAnnotator", "LLMAnnotator",
+    "Chunk", "indexed_form", "returned_form", "annotate_chunk", "check_hidden",
+    "build_index", "search", "facet_only", "assert_hidden",
+    "to_legend", "from_legend", "author", "merge", "save_legend", "load_legend",
+    "render_legend", "GlyphGrammar", "GlyphLint",
+    "sim_eff", "cosine", "rerank", "unit",
+    "__version__",
+]

glyphsteer/annotate.py

@@ -0,0 +1,73 @@
+"""The annotation pass — the LLM/judge half that writes the glyph sidecar.
+
+An `Annotator` reads a chunk's clean text and returns the axes that apply. Two
+implementations:
+
+  RuleAnnotator  — deterministic predicates (no LLM). Reproducible; the CI/test pass.
+  LLMAnnotator   — an injectable judge callable. The real research pass; the judge
+                   returns a glyph-code string which is parsed back THROUGH the
+                   vocabulary (unknown glyphs dropped — the vocab is the gate).
+
+The annotation pass over a whole corpus is a ChainCompiler skillchain (SC); these
+classes are the per-chunk step it runs.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Protocol
+
+from .vocab import Vocabulary
+
+
+@dataclass(frozen=True)
+class Annotation:
+    """One applied axis: which axis fired and the glyph it contributes."""
+    axis: str
+    glyph: str
+
+
+class Annotator(Protocol):
+    def annotate(self, text: str) -> list[Annotation]: ...
+
+
+class RuleAnnotator:
+    """Deterministic annotation by predicate. `rules: {glyph: text -> bool}`."""
+
+    def __init__(self, vocab: Vocabulary, rules: dict[str, Callable[[str], bool]]):
+        self.vocab = vocab
+        unknown = [g for g in rules if vocab.by_glyph(g) is None]
+        if unknown:
+            raise ValueError(f"rules reference glyphs not in the vocabulary: {unknown}")
+        self.rules = rules
+
+    def annotate(self, text: str) -> list[Annotation]:
+        out: list[Annotation] = []
+        for glyph, pred in self.rules.items():
+            if pred(text):
+                axis = self.vocab.by_glyph(glyph)
+                out.append(Annotation(axis.name, glyph))
+        return out
+
+    @classmethod
+    def keyword(cls, vocab: Vocabulary, keywords: dict[str, list[str]]) -> "RuleAnnotator":
+        """Convenience: `{glyph: [words]}` → case-insensitive substring rules."""
+        def make(words: list[str]) -> Callable[[str], bool]:
+            low = [w.lower() for w in words]
+            return lambda t, low=low: any(w in t.lower() for w in low)
+        return cls(vocab, {g: make(ws) for g, ws in keywords.items()})
+
+
+class LLMAnnotator:
+    """Annotation by an injected judge: `judge(text, vocab) -> glyph_code_str`."""
+
+    def __init__(self, vocab: Vocabulary, judge: Callable[[str, Vocabulary], str]):
+        self.vocab = vocab
+        self.judge = judge
+
+    def annotate(self, text: str) -> list[Annotation]:
+        code = self.judge(text, self.vocab)
+        out: list[Annotation] = []
+        for g in self.vocab.parse(code or ""):
+            axis = self.vocab.by_glyph(g)
+            out.append(Annotation(axis.name, g))
+        return out

glyphsteer/cli.py

@@ -0,0 +1,69 @@
+"""GlyphSteer CLI — annotate / index / search / probe."""
+from __future__ import annotations
+
+import json
+import sys
+
+import click
+
+from .annotate import RuleAnnotator
+from .encode import Chunk, annotate_chunk, indexed_form, returned_form
+from .index import build_index, search
+from .vocab import SENTIMENT
+
+
+def _load_chunks(path: str) -> list[Chunk]:
+    """JSONL of {id, text} → chunks."""
+    out = []
+    for line in open(path, encoding="utf-8"):
+        line = line.strip()
+        if line:
+            d = json.loads(line)
+            out.append(Chunk(d["id"], d["text"], d.get("code", ""), d.get("meta", {})))
+    return out
+
+
+@click.group()
+def main() -> None:
+    """GlyphSteer — dual-regime retrieval steering via glyph annotations."""
+
+
+@main.command()
+@click.argument("corpus")
+@click.option("--keyword", "-k", multiple=True, metavar="GLYPH=word,word",
+              help="keyword rule, e.g. -k 😊=great,love")
+def annotate(corpus: str, keyword: tuple[str, ...]) -> None:
+    """Annotate a JSONL corpus with the sentiment vocabulary (keyword rules)."""
+    kw: dict[str, list[str]] = {}
+    for spec in keyword:
+        g, _, words = spec.partition("=")
+        kw[g] = [w for w in words.split(",") if w]
+    ann = RuleAnnotator.keyword(SENTIMENT, kw) if kw else RuleAnnotator(SENTIMENT, {})
+    for c in _load_chunks(corpus):
+        ac = annotate_chunk(c, ann, SENTIMENT)
+        click.echo(json.dumps({"id": ac.id, "text": ac.text, "code": ac.code,
+                               "indexed": indexed_form(ac),
+                               "returned": returned_form(ac, SENTIMENT)},
+                              ensure_ascii=False))
+
+
+@main.command()
+@click.argument("corpus")
+@click.argument("query")
+@click.option("--facet", "-f", default=None, help="glyph to facet on")
+def query(corpus: str, query: str, facet: str | None) -> None:
+    """Index an (already-annotated) JSONL corpus and search it; returns CLEAN text."""
+    con = build_index(_load_chunks(corpus))
+    for h in search(con, query, facet=facet):
+        click.echo(json.dumps(h, ensure_ascii=False))
+
+
+@main.command()
+def vocab() -> None:
+    """Print the built-in sentiment vocabulary."""
+    for a in SENTIMENT.axes:
+        click.echo(f"{a.glyph}  {a.name:10s}  {a.description}")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())

glyphsteer/dense.py

@@ -0,0 +1,122 @@
+"""The dense layer — embeddings + anchor measurement, via a pluggable backend.
+
+The heavy neural runtime is OFF the host by default: GlyphSteer talks to the
+`glyphsteer-serve` container (ONNX/fastembed, no torch) over HTTP. The host import
+stays dependency-light (the remote backend is stdlib-only urllib). Local backends
+exist as fallbacks.
+
+Backend resolution (override with `backend=`):
+  1. "remote"    — POST to $GLYPHSTEER_EMBED_URL/embed  (default if the env var is set)
+  2. "fastembed" — local ONNX runtime (the `dense` extra: `fastembed`)
+  3. "st"        — local sentence-transformers (the `st` extra: `sentence-transformers`, heavy)
+
+`measure_anchor(glyph)` returns the glyph's learned direction — the â_k that
+`steer.sim_eff` uses to reshape the metric, and what `eval.magnitude_probe` measures.
+"""
+from __future__ import annotations
+
+import json
+import os
+import urllib.request
+from functools import lru_cache
+
+import numpy as np
+
+_DEFAULT_MODEL = os.environ.get("GLYPHSTEER_MODEL", "BAAI/bge-small-en-v1.5")
+_ENV_URL = "GLYPHSTEER_EMBED_URL"
+
+
+def _default_backend() -> str:
+    if os.environ.get(_ENV_URL):
+        return "remote"
+    try:
+        import fastembed  # noqa: F401
+        return "fastembed"
+    except ImportError:
+        return "st"
+
+
+# ---- remote (the container; stdlib only) ------------------------------------
+def _remote_embed(texts: list[str], url: str | None = None) -> np.ndarray:
+    base = (url or os.environ[_ENV_URL]).rstrip("/")
+    payload = json.dumps({"texts": list(texts)}).encode("utf-8")
+    req = urllib.request.Request(base + "/embed", data=payload,
+                                 headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=120) as r:
+        out = json.load(r)
+    return np.asarray(out["vectors"], dtype=np.float32)
+
+
+# ---- fastembed (local ONNX) -------------------------------------------------
+@lru_cache(maxsize=4)
+def _fe(model: str):
+    try:
+        from fastembed import TextEmbedding
+    except ImportError as e:  # pragma: no cover
+        raise ImportError("backend 'fastembed' needs fastembed (the 'dense' extra): pip install fastembed") from e
+    return TextEmbedding(model)
+
+
+def _fastembed_embed(texts: list[str], model: str) -> np.ndarray:
+    return np.asarray(list(_fe(model).embed(list(texts))), dtype=np.float32)
+
+
+# ---- sentence-transformers (local, heavy) -----------------------------------
+@lru_cache(maxsize=4)
+def _st(model: str):
+    try:
+        from sentence_transformers import SentenceTransformer
+    except ImportError as e:  # pragma: no cover
+        raise ImportError("backend 'st' needs sentence-transformers (the 'st' extra): "
+                          "pip install sentence-transformers") from e
+    return SentenceTransformer(model)
+
+
+def _st_embed(texts: list[str], model: str) -> np.ndarray:
+    return np.asarray(_st(model).encode(list(texts), normalize_embeddings=False),
+                      dtype=np.float32)
+
+
+# ---- public API -------------------------------------------------------------
+def embed(texts: list[str], *, backend: str | None = None,
+          model: str = _DEFAULT_MODEL, url: str | None = None) -> np.ndarray:
+    """Embed texts → (n, dim) float32 array, via the resolved backend."""
+    backend = backend or _default_backend()
+    if backend == "remote":
+        return _remote_embed(texts, url)
+    if backend == "fastembed":
+        return _fastembed_embed(texts, model)
+    if backend == "st":
+        return _st_embed(texts, model)
+    raise ValueError(f"unknown embed backend {backend!r} (remote|fastembed|st)")
+
+
+def measure_anchor(glyph: str, **kw) -> np.ndarray:
+    """The glyph's learned direction = its embedding (the â_k for steer.sim_eff)."""
+    return embed([glyph], **kw)[0]
+
+
+def measure_anchors(glyphs: list[str], **kw) -> np.ndarray:
+    """Stack of anchor directions for a list of glyphs → (k, dim)."""
+    return embed(list(glyphs), **kw)
+
+
+def health(url: str | None = None) -> dict:
+    """Ping the remote embedding service."""
+    base = (url or os.environ[_ENV_URL]).rstrip("/")
+    with urllib.request.urlopen(base + "/health", timeout=10) as r:
+        return json.load(r)
+
+
+def active_model(model: str = _DEFAULT_MODEL, url: str | None = None) -> str:
+    """The model name actually serving embeddings, for honest reporting.
+
+    With the remote backend the sidecar decides the model (the local `model` arg is
+    ignored), so we ask it; otherwise the local model name is authoritative.
+    """
+    if _default_backend() == "remote":
+        try:
+            return health(url).get("model", model)
+        except Exception:
+            return model
+    return model

glyphsteer/encode.py

@@ -0,0 +1,62 @@
+"""The sidecar split — the keystone of GlyphSteer.
+
+A chunk has TWO representations that are deliberately NOT the same string:
+
+  indexed-form  = clean_text ⊕ SEP ⊕ glyph_code     → embedded / FTS5-indexed (MATCH)
+  returned-form = clean_text                          → handed to the reader (READ)
+
+The glyph code lives ONLY in the indexed-form. It steers retrieval (lexical facet +
+dense direction) and then disappears: `returned_form` is provably glyph-free. This
+module owns that contract and the invariant that proves it.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .vocab import SEP, Vocabulary
+
+
+@dataclass
+class Chunk:
+    """A unit of the corpus. `text` is ALWAYS clean; `code` is the glyph sidecar."""
+    id: str
+    text: str
+    code: str = ""
+    meta: dict = field(default_factory=dict)
+
+
+def indexed_form(chunk: Chunk) -> str:
+    """What gets embedded / FTS5-indexed: clean text + the glyph code."""
+    return f"{chunk.text}{SEP}{chunk.code}" if chunk.code else chunk.text
+
+
+def returned_form(chunk: Chunk, vocab: Vocabulary) -> str:
+    """What the reader/generator sees: clean text, guaranteed glyph-free."""
+    return vocab.strip(chunk.text)
+
+
+def annotate_chunk(chunk: Chunk, annotator, vocab: Vocabulary, grammar=None) -> Chunk:
+    """Run the annotation pass over a chunk and attach its glyph code.
+
+    The chunk's `text` is first stripped of any stray vocabulary glyphs so the
+    sidecar is the ONLY source of markers (keeps the hide-invariant total).
+
+    If a `grammar` (glyphsteer.grammar.GlyphGrammar) is given, the code is gated for
+    syntax consistency via rulecatcher: `syntax_break` raises; `orthogonal` is repaired
+    to canonical order. `grammar=None` ⇒ unchanged behaviour.
+    """
+    clean = vocab.strip(chunk.text)
+    glyphs = [a.glyph for a in annotator.annotate(clean)]
+    code = vocab.code(glyphs)
+    if grammar is not None:
+        lint = grammar.lint(code)
+        if lint.verdict == "syntax_break":
+            raise ValueError(f"syntax_break in annotated code {code!r}: {lint.violations}")
+        if lint.verdict == "orthogonal":
+            code = lint.fix
+    return Chunk(id=chunk.id, text=clean, code=code, meta=dict(chunk.meta))
+
+
+def check_hidden(chunk: Chunk, vocab: Vocabulary) -> bool:
+    """The hide invariant: no vocabulary glyph survives into the returned-form."""
+    return vocab.glyphs_in(returned_form(chunk, vocab)) == []

glyphsteer/eval.py

@@ -0,0 +1,104 @@
+"""The evaluation harness — produces the numbers the claim lives or dies on.
+
+Q1 alignment   : cos(glyph, aligned_word) ≫ cos(glyph, unrelated_word)?
+Q2 magnitude   : injecting a glyph into a neutral chunk moves its vector by Δcos toward
+                 the axis — big enough to reorder, or a toy?
+Q3 projection  : does the steer.py anchor reshape amplify Q2?
+Q4 retrieval   : on labeled data, does annotate→steer beat the no-annotation baseline
+                 (MRR / recall@k), lexically and densely?
+
+The dense part (Q1–Q3) needs a dense backend — the sidecar, or the `dense` or `st` extra
+(`dense.py`); the lexical arm of Q4 runs with zero deps. ASPIRATIONAL: the dense arm of Q4.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from .encode import Chunk, annotate_chunk
+from .index import build_index, search
+from .steer import cosine, sim_eff
+from .vocab import Vocabulary
+
+
+# ---- retrieval metrics -------------------------------------------------------
+def mrr(ranked_ids: list, relevant: set) -> float:
+    for i, rid in enumerate(ranked_ids, 1):
+        if rid in relevant:
+            return 1.0 / i
+    return 0.0
+
+
+def recall_at_k(ranked_ids: list, relevant: set, k: int) -> float:
+    if not relevant:
+        return 0.0
+    hit = len(set(ranked_ids[:k]) & relevant)
+    return hit / len(relevant)
+
+
+# ---- Q1/Q2/Q3 : the dense probe ---------------------------------------------
+def magnitude_probe(vocab: Vocabulary, *, aligned: dict[str, str],
+                    unrelated: dict[str, str], neutral: str,
+                    model: str | None = None) -> dict:
+    """Answer Q1–Q3 for each glyph.
+
+    `aligned`/`unrelated`: {glyph: word}. `neutral`: a sentence to inject into.
+    Returns a per-glyph report with cos-alignment, the Δcos injection nudge, and the
+    projected (steered) nudge.
+    """
+    from . import dense  # lazy — needs the extra
+    # report the model ACTUALLY serving embeddings (the remote sidecar may differ from
+    # any local default), so the results JSON never carries a stale/wrong model label.
+    model = dense.active_model() if model is None else model
+    rows = []
+    nvec = dense.embed([neutral], model=model)[0]
+    for a in vocab.axes:
+        g = a.glyph
+        gvec = dense.measure_anchor(g, model=model)
+        aw = aligned.get(g)
+        uw = unrelated.get(g)
+        cos_aligned = cos_unrelated = None
+        if aw:
+            cos_aligned = float(cosine(dense.embed([aw], model=model)[0],
+                                       gvec[None, :])[0])
+        if uw:
+            cos_unrelated = float(cosine(dense.embed([uw], model=model)[0],
+                                         gvec[None, :])[0])
+        injected = dense.embed([f"{neutral} {g}"], model=model)[0]
+        # Q2: how much did injecting g move the chunk toward g's own direction?
+        delta_cos = float(cosine(gvec, injected[None, :])[0]
+                          - cosine(gvec, nvec[None, :])[0])
+        # Q3: the steered (projected) view of the same nudge
+        steered = float(sim_eff(gvec, injected[None, :], gvec[None, :], [1.0])[0]
+                        - sim_eff(gvec, nvec[None, :], gvec[None, :], [1.0])[0])
+        rows.append({"glyph": g, "axis": a.name,
+                     "cos_aligned": cos_aligned, "cos_unrelated": cos_unrelated,
+                     "Q1_separation": (None if cos_aligned is None or cos_unrelated is None
+                                       else cos_aligned - cos_unrelated),
+                     "Q2_delta_cos": delta_cos, "Q3_steered_delta": steered})
+    return {"model": model, "neutral": neutral, "glyphs": rows}
+
+
+# ---- Q4 : retrieval lift -----------------------------------------------------
+def retrieval_lift_lexical(corpus: list[Chunk], queries: list[dict],
+                           annotator, vocab: Vocabulary, *, k: int = 5) -> dict:
+    """Lexical Q4: MRR/recall with vs without the glyph sidecar.
+
+    `queries`: [{"text": str, "facet": glyph|None, "relevant": set[id]}].
+    Baseline indexes clean text; steered indexes annotated chunks and faceting on.
+    """
+    base_chunks = [Chunk(c.id, c.text) for c in corpus]
+    ann_chunks = [annotate_chunk(c, annotator, vocab) for c in corpus]
+    base_con = build_index(base_chunks, vocab)
+    ann_con = build_index(ann_chunks, vocab)
+
+    def run(con, use_facet):
+        mrrs, recs = [], []
+        for q in queries:
+            facet = q.get("facet") if use_facet else None
+            hits = search(con, q["text"], facet=facet, vocab=vocab, limit=k)
+            ids = [h["id"] for h in hits]
+            mrrs.append(mrr(ids, q["relevant"]))
+            recs.append(recall_at_k(ids, q["relevant"], k))
+        return {"mrr": float(np.mean(mrrs)), f"recall@{k}": float(np.mean(recs))}
+
+    return {"baseline": run(base_con, False), "steered": run(ann_con, True), "k": k}

glyphsteer/grammar.py

@@ -0,0 +1,138 @@
+"""Syntax consistency for glyph codes — rulecatcher under GlyphSteer.
+
+A glyph code is a little DSL (a chain of axis markers). ChainCompiler's discipline is
+that every DSL goes through **rulecatcher** (lint/gate) for syntax — so GlyphSteer's codes
+do too, via `chaincompiler.bridge` (which wraps rulecatcher + HoneyC). This composes the
+same engine the `*CC` compilers use; GlyphSteer doesn't reimplement linting.
+
+Codes are gated on their **ASCII tag** rendering, never the emoji — rulecatcher's tokenizer
+drops emoji exactly as FTS5 does (same lesson as the dense layer), so the lexical *tag* is
+the syntactic unit. Three verdicts, mirroring rulecatcher's own:
+
+  ok           — well-formed, canonical order
+  orthogonal   — known tags, wrong order (steerable → `canonicalize` reorders to vocab order)
+  syntax_break — foreign content (fatal; reject)
+
+rulecatcher owns `syntax_break` over a raw tag chain (`lint_chain`; its strength: foreign-token
+detection). Over a glyph code (`lint`), foreign content is caught first, directly: whatever is left
+once the vocabulary's glyphs and the separator are stripped is foreign, since the tag chain is built
+from the known glyphs alone. The partial-order `orthogonal` check is deterministic here (vocab order)
+because n-gram grammars express a partial order poorly. Needs ChainCompiler and rulecatcher installed beside
+GlyphSteer — ChainCompiler's `./install.sh` installs both.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .vocab import Vocabulary
+
+
+@dataclass
+class GlyphLint:
+    """The verdict for one code: ok | orthogonal | syntax_break, plus the rulecatcher
+    violations and (for orthogonal) the canonical fix."""
+    verdict: str
+    violations: list
+    fix: str | None = None
+
+    @property
+    def ok(self) -> bool:
+        return self.verdict == "ok"
+
+
+def _deps():
+    try:
+        from chaincompiler import bridge
+        from rulecatcher import db
+    except ImportError as e:  # pragma: no cover - environment-dependent
+        raise ImportError(
+            "syntax gating needs ChainCompiler + rulecatcher installed beside GlyphSteer.\n"
+            "From a ChainCompiler checkout, ./install.sh installs both.\n"
+            "(rulecatcher is ChainCompiler's lint/gate engine.)"
+        ) from e
+    return bridge, db
+
+
+def canonical_examples(vocab: Vocabulary) -> list[str]:
+    """Teach rulecatcher the shape of a valid code: KEYWORD (-> KEYWORD)* over the tag
+    alphabet, in vocab order. Full chain + adjacent pairs + singletons."""
+    tags = vocab.tags
+    ex: list[str] = []
+    if tags:
+        ex.append(" -> ".join(tags))
+    ex += [f"{tags[i]} -> {tags[i + 1]}" for i in range(len(tags) - 1)]
+    ex += list(tags)
+    return ex
+
+
+def _raw_order(vocab: Vocabulary, code: str) -> list[str]:
+    """Known glyphs in the order they appear in the code string (matched as the vocabulary matches them)."""
+    return vocab.in_code_order(code)
+
+
+class GlyphGrammar:
+    """A rulecatcher-backed syntax gate for one vocabulary's codes.
+
+    Learns the grammar of canonical codes once, then `lint`s any code or tag-chain.
+    Holds a rulecatcher connection for its lifetime; use as a context manager or `close()`.
+    """
+
+    def __init__(self, vocab: Vocabulary, *, scope: str = "glyphsteer",
+                 db_path: str = ":memory:"):
+        self.vocab = vocab
+        self.scope = scope
+        self._bridge, _db = _deps()
+        self._cm = _db.connect(db_path)
+        self.conn = self._cm.__enter__()
+        self.rules = self._bridge.learn(
+            self.conn, canonical_examples(vocab), scope=scope, keywords=tuple(vocab.tags))
+
+    # ---- gating --------------------------------------------------------------
+    def lint_chain(self, chain: str) -> GlyphLint:
+        """Gate a raw ASCII tag-chain (e.g. `gsxpositive -> gsxurgent`) — this is where
+        rulecatcher catches foreign tokens (`syntax_break`)."""
+        if not chain.strip():
+            return GlyphLint("ok", [])
+        violations, _ = self._bridge.gate(self.conn, chain, scope=self.scope)
+        if any(getattr(v, "verdict", None) == "syntax_break" for v in violations):
+            return GlyphLint("syntax_break", violations)
+        return GlyphLint("ok", violations)
+
+    def lint(self, code: str) -> GlyphLint:
+        """Gate a glyph code: foreign content (`syntax_break`), then canonical order
+        (`orthogonal`) via vocab order.
+
+        Foreign content is caught here, before the tag chain is built: `code_tags` keeps only the
+        vocabulary's glyphs, so anything else in the code — an unknown glyph, a word — would never
+        reach rulecatcher (whose tokenizer drops emoji besides)."""
+        residue = self.vocab.strip(code).strip()
+        if residue:
+            return GlyphLint("syntax_break", [f"foreign content {residue!r} is not in the vocabulary"])
+        chain = " -> ".join(self.vocab.code_tags(code))
+        base = self.lint_chain(chain)
+        if base.verdict == "syntax_break":
+            return base
+        present = self.vocab.parse(code)
+        if _raw_order(self.vocab, code) != present:        # known tags, wrong order
+            return GlyphLint("orthogonal", base.violations, fix=self.canonicalize(code))
+        return GlyphLint("ok", base.violations)
+
+    def canonicalize(self, code: str) -> str:
+        """Reorder a code's glyphs into canonical (vocabulary) order — the orthogonal fix."""
+        return self.vocab.code(self.vocab.parse(code))
+
+    def consistent(self, code: str) -> bool:
+        return self.lint(code).ok
+
+    # ---- lifecycle -----------------------------------------------------------
+    def close(self) -> None:
+        try:
+            self._cm.__exit__(None, None, None)
+        except Exception:  # pragma: no cover
+            pass
+
+    def __enter__(self) -> "GlyphGrammar":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()

glyphsteer/index.py

@@ -0,0 +1,84 @@
+"""The lexical index — FTS5/BM25 with the glyph axes as ASCII-sentinel facets.
+
+This is the zero-dependency half of GlyphSteer and it proves the whole pipeline:
+annotate → encode (sidecar) → index → facet/search → return CLEAN. Every hit returns
+`clean` text — the hide is enforced at the read boundary, structurally.
+
+FINDING (verified): FTS5's unicode61 tokenizer DROPS emoji, so the lexical facet
+cannot be the emoji itself — it is the axis's ASCII sentinel `tag` (e.g. `gsxnegative`),
+a rare single token ⇒ maximal IDF ⇒ exact, deterministic rank-pin, no embeddings. The
+emoji's job is the dense regime; the tag's job is the lexical one. Same axis, two
+renderings. Faceting takes a GLYPH and translates it to its tag internally.
+"""
+from __future__ import annotations
+
+import re
+import sqlite3
+
+from .encode import Chunk
+from .vocab import SENTIMENT, Vocabulary
+
+_FTS_TERMS = re.compile(r"\w+")
+
+
+def build_index(chunks: list[Chunk], vocab: Vocabulary = SENTIMENT,
+                db_path: str = ":memory:") -> sqlite3.Connection:
+    """Index chunks. `body` = clean prose (lexical match); `code` = space-joined ASCII
+    sentinel tags (faceting); `clean` is stored UNINDEXED to return it on a hit."""
+    con = sqlite3.connect(db_path)
+    # `code` = ASCII tags (INDEXED, for faceting); `glyphs` = the emoji code (UNINDEXED,
+    # for human display) — FTS5 can't match the emoji but we still want to return it.
+    con.execute("CREATE VIRTUAL TABLE chunks USING fts5("
+                "id UNINDEXED, body, code, clean UNINDEXED, glyphs UNINDEXED)")
+    con.executemany(
+        "INSERT INTO chunks(id, body, code, clean, glyphs) VALUES (?,?,?,?,?)",
+        [(c.id, c.text, " ".join(vocab.code_tags(c.code)), c.text, c.code) for c in chunks])
+    con.commit()
+    return con
+
+
+def _fts_query(q: str) -> str:
+    # quote each term as a literal so FTS5 operators in user text (OR/AND/NOT/NEAR)
+    # are treated as words, not syntax
+    terms = _FTS_TERMS.findall(q)
+    # a query with no word is one FTS5 string, its quotes doubled (FTS5's escape), so it matches nothing, never crashes
+    return " OR ".join(f'"{t}"' for t in terms) if terms else '"' + q.replace('"', '""') + '"'
+
+
+def _facet_tag(facet: str, vocab: Vocabulary) -> str:
+    """Accept either a glyph or a tag; resolve to the indexed ASCII tag."""
+    return vocab.tag_for(facet) or facet
+
+
+def search(con: sqlite3.Connection, query: str, *, facet: str | None = None,
+           vocab: Vocabulary = SENTIMENT, limit: int = 10) -> list[dict]:
+    """BM25-ranked lexical search. `facet` (a glyph) adds an exact-match constraint.
+
+    Every hit's `text` is the CLEAN, glyph-free form — the hide, enforced here.
+    """
+    where = ["chunks MATCH ?"]
+    params: list = [_fts_query(query)]
+    if facet:
+        where.append("code MATCH ?")
+        params.append(_facet_tag(facet, vocab))
+    sql = (f"SELECT id, clean, glyphs, bm25(chunks) AS score FROM chunks "
+           f"WHERE {' AND '.join(where)} ORDER BY score LIMIT ?")
+    params.append(limit)
+    return [{"id": r[0], "text": r[1], "code": r[2], "score": r[3]}
+            for r in con.execute(sql, params)]
+
+
+def facet_only(con: sqlite3.Connection, facet: str, *, vocab: Vocabulary = SENTIMENT,
+               limit: int = 100) -> list[dict]:
+    """Pure faceted retrieval: every chunk carrying `facet` (glyph or tag), no query."""
+    sql = ("SELECT id, clean, glyphs FROM chunks WHERE code MATCH ? LIMIT ?")
+    return [{"id": r[0], "text": r[1], "code": r[2]}
+            for r in con.execute(sql, [_facet_tag(facet, vocab), limit])]
+
+
+def assert_hidden(hits: list[dict], vocab: Vocabulary) -> None:
+    """Guard: no hit's returned text may contain a vocabulary glyph."""
+    for h in hits:
+        leaked = vocab.glyphs_in(h["text"])
+        if leaked:
+            raise AssertionError(f"glyph leak in returned text of {h['id']!r}: {leaked}")

glyphsteer/legend.py

@@ -0,0 +1,80 @@
+"""The legend — persist & accumulate LLM-authored glyph vocabularies.
+
+A vocabulary is a *language the LLM invents*: it picks glyphs, says what each means, and
+we auto-derive the lexical sentinel tag. The **legend** is that language written down —
+the glyph ↔ meaning ↔ tag table — so it survives a session, travels with an index, and is
+shown to whoever reads the results. `keep a legend of all` = `merge` several authored
+vocabularies into one master legend.
+
+A legend entry is `{name, glyph, tag, description}`. The tag is reproducible from the name,
+so a legend round-trips exactly.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .vocab import Axis, Vocabulary
+
+
+def to_legend(vocab: Vocabulary) -> list[dict]:
+    """Serialize a vocabulary to a legend (list of glyph↔meaning↔tag entries)."""
+    return [{"name": a.name, "glyph": a.glyph, "tag": a.tag, "description": a.description}
+            for a in vocab.axes]
+
+
+def from_legend(entries: list[dict]) -> Vocabulary:
+    """Rebuild a vocabulary from a legend."""
+    return Vocabulary([Axis(e["name"], e["glyph"], e.get("description", ""), e.get("tag", ""))
+                       for e in entries])
+
+
+def author(specs: list[dict]) -> Vocabulary:
+    """LLM-authoring entrypoint: the model proposes {name, glyph, description?}; we derive
+    the tag and validate. Raises on glyph/tag collisions — the vocabulary is the gate."""
+    return Vocabulary([Axis(s["name"], s["glyph"], s.get("description", "")) for s in specs])
+
+
+def merge(*vocabs: Vocabulary) -> Vocabulary:
+    """Accumulate vocabularies into one master legend (later wins on a name, glyph or tag clash —
+    deterministic, last-author-priority). Skips entries that would break validation."""
+    by_name: dict[str, Axis] = {}
+    by_glyph: dict[str, str] = {}     # glyph -> name (to detect cross-name reuse)
+    by_tag: dict[str, str] = {}       # tag -> name (two names can derive one tag: `risk` and `Risk!` → gsxrisk)
+
+    def unindex(name: str) -> None:
+        """Forget the glyph and tag of the axis a name holds now, so they no longer point at it."""
+        old = by_name.get(name)
+        if old is not None:
+            if by_glyph.get(old.glyph) == name:
+                del by_glyph[old.glyph]
+            if by_tag.get(old.tag) == name:
+                del by_tag[old.tag]
+
+    for v in vocabs:
+        for a in v.axes:
+            unindex(a.name)                         # a name given a new glyph no longer holds its old one
+            # drop a prior axis that used this glyph or this tag under a different name
+            for clash in (by_glyph.get(a.glyph), by_tag.get(a.tag)):
+                if clash and clash != a.name:
+                    unindex(clash)
+                    by_name.pop(clash, None)
+            by_name[a.name] = a
+            by_glyph[a.glyph] = a.name
+            by_tag[a.tag] = a.name
+    return Vocabulary(list(by_name.values()))
+
+
+def save_legend(vocab: Vocabulary, path: str | Path) -> None:
+    Path(path).write_text(json.dumps(to_legend(vocab), indent=2, ensure_ascii=False),
+                          encoding="utf-8")
+
+
+def load_legend(path: str | Path) -> Vocabulary:
+    return from_legend(json.loads(Path(path).read_text(encoding="utf-8")))
+
+
+def render_legend(vocab: Vocabulary) -> str:
+    """Human-readable legend block (for showing alongside search results)."""
+    rows = [f"  {a.glyph}  {a.tag:16s} {a.name} — {a.description}" for a in vocab.axes]
+    return "LEGEND\n" + "\n".join(rows)

glyphsteer/steer.py

@@ -0,0 +1,54 @@
+"""The dense steering math — a rank-k bilinear reshape of the similarity metric.
+
+This is the part that turns an *inherited* glyph direction into a *controllable,
+query-time-weighted* axis. Given anchor directions â_k (unit vectors, one per glyph,
+measured once by `dense.measure_anchor`) and per-query weights w_k:
+
+    sim_eff(q, d) = cos(q, d) + Σ_k w_k · ⟨q, â_k⟩ · ⟨d, â_k⟩
+
+w_k = 0 recovers plain cosine. Raising w_k for a chosen glyph makes that semantic
+axis dominate the distance for *this* query only — dynamically reshaping the
+embedding geometry without retraining.
+
+Pure numpy: takes vectors, needs no model. (`dense.py` produces the vectors.)
+"""
+from __future__ import annotations
+
+import numpy as np
+
+
+def unit(v: np.ndarray) -> np.ndarray:
+    n = np.linalg.norm(v, axis=-1, keepdims=True)
+    return v / np.clip(n, 1e-12, None)
+
+
+def cosine(q: np.ndarray, d: np.ndarray) -> np.ndarray:
+    """Cosine of a single query vector against a (n, dim) doc matrix."""
+    return unit(np.atleast_2d(d)) @ unit(q)
+
+
+def sim_eff(q: np.ndarray, d: np.ndarray, anchors: np.ndarray | None = None,
+            weights: np.ndarray | list[float] | None = None) -> np.ndarray:
+    """Bilinear-reshaped similarity of query `q` vs doc matrix `d` (n, dim).
+
+    `anchors` is (k, dim); `weights` is length-k. Returns length-n scores.
+    """
+    d2 = np.atleast_2d(d)
+    base = cosine(q, d2)                                   # (n,)
+    if anchors is None or weights is None or len(weights) == 0:
+        return base
+    A = unit(np.atleast_2d(anchors))                      # (k, dim)
+    w = np.asarray(weights, dtype=float)                 # (k,)
+    qa = A @ unit(q)                                      # (k,) query·anchor
+    da = unit(d2) @ A.T                                   # (n, k) doc·anchor
+    correction = (da * (w * qa)).sum(axis=1)             # (n,)
+    return base + correction
+
+
+def rerank(q: np.ndarray, docs: np.ndarray, *, anchors=None, weights=None,
+           ids: list | None = None) -> list[dict]:
+    """Score docs by `sim_eff` and return them sorted best-first."""
+    scores = sim_eff(q, docs, anchors, weights)
+    order = np.argsort(-scores)
+    ids = ids if ids is not None else list(range(len(scores)))
+    return [{"id": ids[i], "score": float(scores[i])} for i in order]

glyphsteer/vocab.py

@@ -0,0 +1,198 @@
+"""The controlled glyph vocabulary — the language half of GlyphSteer.
+
+A `Vocabulary` maps named axes to glyph markers. A glyph is chosen to be (a) rare
+in prose so it is a clean lexical routing key (maximal IDF, no collision with a
+word), and (b) — for the dense regime — semantically aligned with its axis so its
+*learned direction* nudges the chunk vector the way we intend.
+
+The vocabulary is the gate: an annotation code is only as valid as the glyphs the
+vocabulary knows. Unknown glyphs are dropped on parse (the same "syntax-only"
+discipline the ChainCompiler `*CC` compilers use — we validate the form, never the
+content). A code is a HoneyC chain, so `to_honeyc` emits chain notation.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+# the in-band separator between clean text and the glyph code (rare, non-prose)
+SEP = " ⁣"  # INVISIBLE SEPARATOR — present in the byte stream, unobtrusive
+
+
+@dataclass(frozen=True)
+class Axis:
+    """One steerable dimension with TWO regime-appropriate renderings.
+
+    `glyph`  — the dense marker (an emoji). The embedding model tokenizes it and it
+               carries a learned direction; it is non-ASCII so it never collides with
+               a prose word.
+    `tag`    — the lexical marker (an ASCII sentinel, e.g. `gsxnegative`). FTS5's
+               unicode61 tokenizer DROPS emoji (verified), so the lexical facet must
+               be an ASCII single-token sentinel. Auto-derived from `name` if omitted.
+    """
+    name: str
+    glyph: str
+    description: str = ""
+    tag: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.tag:
+            object.__setattr__(self, "tag", default_tag(self.name))
+
+
+@dataclass
+class Vocabulary:
+    """A set of axes. Validates glyph uniqueness and lexical-cleanliness."""
+    axes: list[Axis] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        self.validate()
+
+    # ---- lookups -------------------------------------------------------------
+    @property
+    def glyphs(self) -> list[str]:
+        return [a.glyph for a in self.axes]
+
+    def by_glyph(self, glyph: str) -> Axis | None:
+        return next((a for a in self.axes if a.glyph == glyph), None)
+
+    def by_name(self, name: str) -> Axis | None:
+        return next((a for a in self.axes if a.name == name), None)
+
+    def by_tag(self, tag: str) -> Axis | None:
+        return next((a for a in self.axes if a.tag == tag), None)
+
+    @property
+    def tags(self) -> list[str]:
+        return [a.tag for a in self.axes]
+
+    def tag_for(self, glyph: str) -> str | None:
+        a = self.by_glyph(glyph)
+        return a.tag if a else None
+
+    def code_tags(self, code: str) -> list[str]:
+        """The ASCII lexical sentinels for the glyphs present in `code`."""
+        return [self.by_glyph(g).tag for g in self.parse(code)]
+
+    # ---- validation ----------------------------------------------------------
+    def validate(self) -> None:
+        seen: set[str] = set()
+        tags: set[str] = set()
+        for a in self.axes:
+            if not a.glyph:
+                raise ValueError(f"axis {a.name!r} has an empty glyph")
+            if a.glyph in seen:
+                raise ValueError(f"duplicate glyph {a.glyph!r} (axis {a.name!r})")
+            seen.add(a.glyph)
+            if not is_lexically_clean(a.glyph):
+                raise ValueError(
+                    f"glyph {a.glyph!r} (axis {a.name!r}) is not lexically clean: "
+                    "a marker must be non-ASCII / non-alphanumeric so it never "
+                    "collides with a prose token in the lexical index")
+            if not is_fts_token(a.tag):
+                raise ValueError(
+                    f"tag {a.tag!r} (axis {a.name!r}) is not a single FTS token: it "
+                    "must be one ASCII-alphanumeric run (FTS5 indexes it; emoji don't)")
+            if a.tag in tags:
+                raise ValueError(f"duplicate tag {a.tag!r} (axis {a.name!r})")
+            tags.add(a.tag)
+
+    # ---- code (de)serialization ---------------------------------------------
+    def code(self, glyphs: list[str]) -> str:
+        """Join glyphs into a compact, order-preserving, de-duplicated code."""
+        out: list[str] = []
+        for g in glyphs:
+            if self.by_glyph(g) and g not in out:
+                out.append(g)
+        return "".join(out)
+
+    def _pattern(self) -> re.Pattern | None:
+        """One alternation over the glyphs, the longest first — a glyph that is part of another (an emoji and its
+        variation-selector or skin-tone form) is tried after the longer one at every place."""
+        if not self.axes:
+            return None
+        return re.compile("|".join(re.escape(g) for g in sorted(self.glyphs, key=len, reverse=True)))
+
+    def _matches(self, text: str) -> list[str]:
+        """Every vocabulary glyph in `text`, left to right: at each place the longest glyph that starts there, and
+        never two that overlap — so a glyph inside a longer one is not found there."""
+        pattern = self._pattern()
+        return [m.group(0) for m in pattern.finditer(text)] if pattern else []
+
+    def parse(self, code: str) -> list[str]:
+        """Extract the known glyphs from a code string, in vocabulary order (unknown glyphs dropped)."""
+        found = set(self._matches(code))
+        return [g for g in self.glyphs if g in found]
+
+    def glyphs_in(self, text: str) -> list[str]:
+        """Which vocabulary glyphs appear anywhere in `text` (order of vocab), matched as `parse` matches them."""
+        return self.parse(text)
+
+    def in_code_order(self, code: str) -> list[str]:
+        """The known glyphs in the order the code holds them — each at the first place it stands."""
+        return list(dict.fromkeys(self._matches(code)))
+
+    def strip(self, text: str) -> str:
+        """Remove every vocabulary glyph, whole, and the separator — its space with it — from `text`, until a pass
+        removes nothing: removing one glyph can join what stood either side of it into another."""
+        pattern = self._pattern()
+        while True:
+            stripped = pattern.sub("", text) if pattern else text
+            stripped = stripped.replace(SEP, "").replace(SEP.strip(), "")
+            if stripped == text:
+                return text
+            text = stripped
+
+    def to_honeyc(self, code: str) -> str:
+        """Render a code as a HoneyC chain (`a→b→c`) in the code's own order — the compiler bridge; a chain is
+        order-significant."""
+        return "→".join(self.in_code_order(code))
+
+
+def is_lexically_clean(glyph: str) -> bool:
+    """A glyph is clean iff it contains no ASCII alphanumeric character.
+
+    That guarantees it can never tokenize to (or collide with) a prose word — it is
+    near-orthogonal to prose in the dense regime and inert in the lexical one.
+    """
+    return bool(glyph) and not any(c.isascii() and c.isalnum() for c in glyph)
+
+
+def is_fts_token(tag: str) -> bool:
+    """A lexical sentinel must be a single ASCII-alphanumeric run (one FTS5 token)."""
+    return bool(tag) and tag.isascii() and tag.isalnum()
+
+
+def default_tag(name: str) -> str:
+    """Derive a rare single-token ASCII sentinel from an axis name (`gsx<name>`)."""
+    return "gsx" + "".join(c for c in name.lower() if c.isascii() and c.isalnum())
+
+
+# A ready-made sentiment vocabulary — the strongest dense case (emoji *are* how
+# humans encode sentiment, so the learned directions are clean; Novak 2015).
+SENTIMENT = Vocabulary([
+    Axis("positive", "\U0001F60A", "positive / approving / happy sentiment"),
+    Axis("negative", "\U0001F621", "negative / angry / disapproving sentiment"),
+    Axis("urgent",   "\U0001F525", "urgent / hot / high-priority"),
+    Axis("question", "❓",      "open question / unresolved"),
+    Axis("caution",  "⚠️", "warning / caution / risk"),
+])
+
+# A ready-made QUALITY-GRADE vocabulary — an ordered set of grades an LLM assigns to
+# corpus chunks ("what's good and what isn't"). This is a *lexical-facet* axis: grading
+# is a label you filter & display by, NOT a sentiment/semantic direction (a correct chunk
+# can be grim; an upbeat chunk can be junk). Each grade has an integer `rank` for ordering.
+GRADE = Vocabulary([
+    Axis("excellent", "\U0001F3C6", "authoritative, correct, well-supported — A"),  # 🏆
+    Axis("good",      "✅",     "solid and usable — B"),                          # ✅
+    Axis("fair",      "⚠️", "usable with caveats / unverified — C"),        # ⚠️
+    Axis("poor",      "❌",     "wrong, unsafe, or misleading — D/F"),            # ❌
+])
+# grade ordering (best→worst), by glyph — for sorting/Display, not validation
+GRADE_RANK = {"\U0001F3C6": 0, "✅": 1, "⚠️": 2, "❌": 3}
+
+
+def grade_label(vocab: Vocabulary, code: str) -> str:
+    """Human badge for a chunk's grade code, e.g. '🏆 excellent'."""
+    parts = [f"{g} {vocab.by_glyph(g).name}" for g in vocab.parse(code)]
+    return ", ".join(parts) if parts else "(ungraded)"

glyphsteer-0.3.0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: glyphsteer
+Version: 0.3.0
+Summary: Dual-regime retrieval steering via compiled in-band glyph annotations
+Requires-Python: >=3.11
+Requires-Dist: click
+Requires-Dist: numpy
+Provides-Extra: dense
+Requires-Dist: fastembed; extra == "dense"
+Provides-Extra: st
+Requires-Dist: sentence-transformers; extra == "st"
+Provides-Extra: serve
+Requires-Dist: fastapi; extra == "serve"
+Requires-Dist: uvicorn; extra == "serve"
+Requires-Dist: fastembed; extra == "serve"
+Provides-Extra: grammar
+Requires-Dist: rulecatcher==0.3.0; extra == "grammar"
+Requires-Dist: chaincompiler==0.3.0; extra == "grammar"

glyphsteer-0.3.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+glyphsteer/__init__.py,sha256=k0BSa3Cbs6hxV1un96C7NMa9hPjGWyHXHo2-kapn3VA,1842
+glyphsteer/annotate.py,sha256=-k-w2Up2Mh47G_DIRuUGvg8MXPy8s5HJJYusJy_YTY8,2699
+glyphsteer/cli.py,sha256=KK8JaXQUwmIt4Tz4wg-4Z7AuoQcwGVa22bYRT-vawcA,2345
+glyphsteer/dense.py,sha256=85QU3sSGZGkBVBI9l-d-WOiE7tco-lT3Sk9DHgWmGBM,4687
+glyphsteer/encode.py,sha256=3eWgA4aaYySWBmqq3Gj_lRbQhCIwG9EndMb3obhwPbQ,2450
+glyphsteer/eval.py,sha256=4P4QFKECgLk6i_Q4T1NKl4HHgD5NY6gTqk6p1lm79h4,4847
+glyphsteer/grammar.py,sha256=Xg9aCUn9heoG7d5XUwkZ2XnA6nYHJ3r5yAOCjvUAWM8,5946
+glyphsteer/index.py,sha256=6UlZ4zQVjsXJh0OQaVYIuHI9ZoN6iGNrHC9ajt6Q4Yg,3897
+glyphsteer/legend.py,sha256=b-JxQ7pTXHOpPk-B_hwi8EetBHMsBqTwfXDHiLUEPnE,3529
+glyphsteer/steer.py,sha256=1uaPIujlpG085qP8DOkZRsu6yNyxNr6lTfNmU9czdLA,2325
+glyphsteer/vocab.py,sha256=fDEK2Kh7dpL9vx6wK2QF_qAPRlpt4oIOlJpITDEsXW8,9068
+glyphsteer-0.3.0.dist-info/METADATA,sha256=UD3Rcqeq-NTMhIm29Qth_vtxemEddZUq2l6hRMlfDTk,616
+glyphsteer-0.3.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+glyphsteer-0.3.0.dist-info/entry_points.txt,sha256=8b3k8aKny4u8EPlE09U-iT8CNHCqsET0_1v4HFC_j1A,51
+glyphsteer-0.3.0.dist-info/top_level.txt,sha256=7ErtQKoPBieCpsyTk6J529Amq9dbAkVDz5fSmvlyaoM,11
+glyphsteer-0.3.0.dist-info/RECORD,,

glyphsteer-0.3.0.dist-info/WHEEL

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

glyphsteer-0.3.0.dist-info/entry_points.txt

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

glyphsteer-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+glyphsteer