@topy-ai/maggie 0.8.0 → 0.8.1

package/bundled-tools/runtime/maggie_dash_pg.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""PostgreSQL backend for the MaggieDash content store.
+
+A thin compatibility shim that mimics the subset of the stdlib sqlite3
+connection API that MaggieDashStore uses, so the same store code runs on
+Postgres unchanged. It translates `?` placeholders to `%s`, intercepts the few
+SQLite-only statements (PRAGMA foreign_keys / table_info / user_version and
+`sqlite_master`), and returns rows that support both name and positional access
+plus `dict(row)` — exactly like `sqlite3.Row`.
+
+Used when a Postgres DSN is supplied (ONEMAN forbids SQLite anywhere); the
+SQLite path in MaggieDashStore is untouched. Requires psycopg2 (imported
+lazily, only when a Postgres backend is actually requested).
+"""
+from __future__ import annotations
+
+import re
+from typing import Any, Sequence
+
+
+class Row(dict):
+    """A dict that also supports positional access and `dict(row)`, like sqlite3.Row."""
+    __slots__ = ("_cols",)
+
+    def __init__(self, cols: Sequence[str], values: Sequence[Any]):
+        super().__init__(zip(cols, values))
+        self._cols = list(cols)
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            return super().__getitem__(self._cols[key])
+        return super().__getitem__(key)
+
+
+class Result:
+    """Cursor-like result supporting fetchone/fetchall/iteration over Row objects."""
+    def __init__(self, rows: list[Row]):
+        self._rows = rows
+        self._idx = 0
+
+    def fetchone(self):
+        if self._idx < len(self._rows):
+            row = self._rows[self._idx]
+            self._idx += 1
+            return row
+        return None
+
+    def fetchall(self):
+        rows = self._rows[self._idx:]
+        self._idx = len(self._rows)
+        return rows
+
+    def __iter__(self):
+        rows = self._rows[self._idx:]
+        self._idx = len(self._rows)
+        return iter(rows)
+
+
+_PRAGMA_TABLE_INFO = re.compile(r"PRAGMA\s+table_info\s*\(\s*([^)]+?)\s*\)", re.IGNORECASE)
+_USER_VERSION_SET = re.compile(r"PRAGMA\s+user_version\s*=\s*(\d+)", re.IGNORECASE)
+
+
+class PgConnection:
+    """sqlite3.Connection-compatible shim backed by psycopg2."""
+    def __init__(self, dsn: str):
+        import psycopg2  # lazy: only when a Postgres backend is requested
+        self._conn = psycopg2.connect(dsn)
+        self._conn.autocommit = False
+
+    # -- the sqlite3.Connection surface MaggieDashStore relies on --
+    def execute(self, sql: str, params: Sequence[Any] | None = None) -> Result:
+        s = sql.strip()
+        up = s.upper()
+        if up.startswith("PRAGMA FOREIGN_KEYS"):
+            return Result([])
+        m = _PRAGMA_TABLE_INFO.search(s)
+        if m:
+            table = m.group(1).strip().strip('"').strip("'")
+            rows = self._run(
+                "SELECT column_name FROM information_schema.columns "
+                "WHERE table_schema='public' AND table_name=%s ORDER BY ordinal_position",
+                (table,))
+            # sqlite PRAGMA table_info columns: (cid, name, ...) -> row[1] is the name
+            return Result([Row(["cid", "name"], [i, r[0]]) for i, r in enumerate(rows)])
+        m = _USER_VERSION_SET.search(s)
+        if m:
+            self._run("CREATE TABLE IF NOT EXISTS maggiedash_meta (key TEXT PRIMARY KEY, value TEXT)")
+            self._run("INSERT INTO maggiedash_meta (key,value) VALUES ('user_version',%s) "
+                      "ON CONFLICT (key) DO UPDATE SET value=EXCLUDED.value", (str(m.group(1)),))
+            return Result([])
+        if "FROM SQLITE_MASTER" in up:
+            rows = self._run("SELECT table_name FROM information_schema.tables WHERE table_schema='public'")
+            return Result([Row(["name"], [r[0]]) for r in rows])
+        # ordinary statement: translate placeholders and run
+        query = s.replace("?", "%s")
+        cur = self._conn.cursor()
+        try:
+            cur.execute(query, tuple(params) if params else None)
+            if cur.description is None:
+                return Result([])
+            cols = [d[0] for d in cur.description]
+            return Result([Row(cols, rec) for rec in cur.fetchall()])
+        finally:
+            cur.close()
+
+    def executescript(self, script: str) -> None:
+        cur = self._conn.cursor()
+        try:
+            cur.execute(script)        # psycopg2 runs multiple ';'-separated statements
+        finally:
+            cur.close()
+
+    def _run(self, query: str, params: Sequence[Any] | None = None) -> list[tuple]:
+        cur = self._conn.cursor()
+        try:
+            cur.execute(query, tuple(params) if params else None)
+            return cur.fetchall() if cur.description is not None else []
+        finally:
+            cur.close()
+
+    def commit(self) -> None:
+        self._conn.commit()
+
+    def close(self) -> None:
+        if not self._conn.closed:
+            self._conn.close()

package/bundled-tools/runtime/maggie_dash_store.py

@@ -38,11 +38,23 @@ def checksum(value: dict[str, Any]) -> str:
 
 
 class MaggieDashStore:
-    def __init__(self, path: Path):
-        self.path = path.resolve()
-        self.path.parent.mkdir(parents=True, exist_ok=True)
-        self.connection = sqlite3.connect(self.path)
-        self.connection.row_factory = sqlite3.Row
+    def __init__(self, path: Path | None = None, *, dsn: str | None = None):
+        # Postgres backend (ONEMAN forbids SQLite) when a DSN is supplied;
+        # otherwise the stdlib SQLite backend, unchanged.
+        if dsn:
+            from maggie_dash_pg import PgConnection
+            self.backend = "postgres"
+            self.path = dsn
+            # Never expose credentials in contracts/reports/CLI output.
+            self.storage_label = "env:MAGGIEDASH_DATABASE_URL"
+            self.connection = PgConnection(dsn)
+        else:
+            self.backend = "sqlite"
+            self.path = path.resolve()
+            self.storage_label = str(self.path)
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.connection = sqlite3.connect(self.path)
+            self.connection.row_factory = sqlite3.Row
         self.connection.execute("PRAGMA foreign_keys = ON")
         self.connection.executescript(
             """

package/bundled-tools/runtime/spirit_agent.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+"""Animate the Core-Agent faces through the 32-state system.
+
+The agent's face (hair / eyes / prop) is the fixed identity; its ONEMAN O-rim
+is the animatable ring — it reuses the exact motion vocabulary + palette +
+badges from sprite_system.CATALOG (thinking sweeps, loading fills, critical
+blinks, success turns green, awaiting shows the clock badge, …). `speaking`
+also opens the mouth. Emits a PNG frame strip + still per state, a sprite sheet
+and states.json per agent, into brand/<role>/.
+"""
+import sys, os, json, math
+HERE=os.path.dirname(os.path.abspath(__file__)); sys.path.insert(0,HERE)
+OUT_BASE=HERE
+import spirit_face as F
+from spirit_base import CATALOG, GLYPH, palette, GROUPS
+from PIL import Image
+
+W,H,cx,cy=F.W,F.H,F.cx,F.cy
+R_IN,R_OUT=F.R_IN,F.R_OUT
+shade=F.shade; OUT=F.OUT
+
+# rim cells (annulus) ordered by angle from top, clockwise
+RIM=[]
+for y in range(H):
+    for x in range(W):
+        d=math.hypot(x-cx,y-cy)
+        if R_IN-0.5<=d<=R_OUT: RIM.append((x,y))
+def _ang(p): return (math.atan2(p[1]-cy,p[0]-cx)+math.pi/2)%(2*math.pi)
+RIM.sort(key=_ang)
+ANG={p:_ang(p) for p in RIM}
+
+BX,BY=22,0
+def put_badge(px,name,bg,fg):
+    for yy in range(0,6):
+        for xx in range(21,27): px[(xx,yy)]=None
+    g=GLYPH[name]
+    for r in range(5):
+        for c in range(5): px[(BX+c,BY+r)]=fg if g[r][c]=="1" else bg
+def tri(t,nf): x=(2*t/nf); return x if x<=1 else 2-x
+
+WHT=F.WHT; EYE=F.EYE
+EYEPROPS={"glasses","shades","monocle"}     # cover the eyes -> don't redraw eyes under them
+MOUTHPROPS={"cigar"}                         # at the mouth -> keep base mouth
+
+# ---- expression layer: per-state face animation (generic, reusable) ----
+# state -> (eye-mode, mouth-mode). Blink is added automatically on longer loops.
+EXPR={
+ "off":("closed","flat"),"booting":("wake","small"),"idle":("open","smile_s"),
+ "active":("open","smile_s"),"paused":("half","flat"),"offline":("closed","flat"),
+ "thinking":("up","small"),"loading":("open","flat"),"syncing":("dart","flat"),
+ "writing":("down","small"),"streaming":("open","talk"),"queued":("open","flat"),
+ "scanning":("dart","flat"),"deploying":("determined","flat"),
+ "speaking":("open","talk"),"listening":("side","small"),
+ "notification":("wide","small"),"mention":("side","smile"),"recording":("open","flat"),
+ "success":("happy","grin"),"warning":("worried","frown"),"critical":("wide","frown"),
+ "blocked":("side","flat"),"error":("x","frown"),"retrying":("determined","flat"),
+ "awaiting":("up","small"),"approved":("happy","smile"),"rejected":("worried","frown"),
+ "secure":("open","smile_s"),"vulnerable":("worried","frown"),"maintenance":("down","flat"),
+ "celebrating":("happy","grin"),
+}
+def _clear(px,x0,y0,x1,y1,SK):
+    for y in range(y0,y1+1):
+        for x in range(x0,x1+1): px[(x,y)]=SK
+def draw_eyes_expr(px,mode,t,nf,SK,lash,blink):
+    for s in(-1,1):
+        _clear(px,cx+s*3 if s>0 else cx-6, cy-3, cx+6 if s>0 else cx-3, cy, SK)
+    if blink: mode="closed"
+    def whites(s):
+        for x in(cx+s*3,cx+s*4,cx+s*5): px[(x,cy-2)]=WHT; px[(x,cy-1)]=WHT
+    def lashmark(s):
+        if lash: px[(cx+s*6,cy-2)]=OUT; px[(cx+s*5,cy-3)]=OUT
+    for s in(-1,1):
+        if mode=="closed":
+            for x in(cx+s*3,cx+s*4,cx+s*5): px[(x,cy-1)]=OUT
+            lashmark(s); continue
+        if mode=="half":
+            for x in(cx+s*3,cx+s*4,cx+s*5): px[(x,cy-1)]=WHT
+            px[(cx+s*4,cy-1)]=EYE
+            for x in(cx+s*3,cx+s*4,cx+s*5): px[(x,cy-2)]=OUT
+            continue
+        if mode=="happy":
+            px[(cx+s*5,cy-1)]=OUT; px[(cx+s*4,cy-2)]=OUT; px[(cx+s*3,cy-1)]=OUT; continue
+        if mode=="x":
+            px[(cx+s*3,cy-2)]=OUT; px[(cx+s*4,cy-1)]=OUT; px[(cx+s*5,cy)]=OUT
+            px[(cx+s*5,cy-2)]=OUT; px[(cx+s*3,cy)]=OUT; continue
+        whites(s); lashmark(s)
+        pdx, pdy = 0, 0
+        if mode=="up": pdy=-1
+        elif mode=="down": pdy=0; px[(cx+s*3,cy-2)]=EYE  # lowered lid feel
+        elif mode=="side": pdx=1
+        elif mode=="dart": pdx=1 if (t%2==0) else -1
+        elif mode=="wide": pass
+        elif mode=="worried": px[(cx+s*4 if s<0 else cx+s*3,cy-3)]=OUT  # inner brow down
+        elif mode=="determined": px[(cx+s*5,cy-3)]=OUT                   # outer brow
+        px[(cx+s*(4+pdx), cy-1+pdy)]=EYE
+        if mode not in("wide","up"): px[(cx+s*4, cy-2)]=EYE if pdy==0 else WHT
+        if mode=="wake" and t< nf//2:
+            for x in(cx+s*3,cx+s*4,cx+s*5): px[(x,cy-1)]=OUT; px[(x,cy-2)]=SK
+def draw_mouth_expr(px,mode,t,SK,mcol):
+    _clear(px,cx-2,cy+3,cx+2,cy+5,SK)
+    if mode=="smile" or mode=="smile_s":
+        px[(cx-2,cy+4)]=OUT;px[(cx-1,cy+5)]=OUT;px[(cx,cy+5)]=OUT;px[(cx+1,cy+5)]=OUT;px[(cx+2,cy+4)]=OUT
+    elif mode=="grin":
+        px[(cx-2,cy+4)]=OUT;px[(cx+2,cy+4)]=OUT
+        for x in range(cx-1,cx+2): px[(x,cy+4)]=OUT; px[(x,cy+5)]=WHT
+    elif mode=="flat":
+        for x in range(cx-2,cx+2): px[(x,cy+4)]=OUT
+    elif mode=="frown":
+        px[(cx-2,cy+5)]=OUT;px[(cx-1,cy+4)]=OUT;px[(cx,cy+4)]=OUT;px[(cx+1,cy+4)]=OUT;px[(cx+2,cy+5)]=OUT
+    elif mode=="small":
+        px[(cx,cy+4)]=OUT; px[(cx-1,cy+4)]=OUT
+    elif mode=="talk":
+        if t%2:
+            for x in range(cx-1,cx+2): px[(x,cy+4)]=OUT;px[(x,cy+5)]=OUT
+            px[(cx,cy+5)]=F._rgb('7a1a12')
+        else:
+            for x in range(cx-1,cx+2): px[(x,cy+4)]=OUT
+    if mcol and mode in("smile","smile_s","flat","grin"):     # lipstick tint
+        for x in range(cx-2,cx+3):
+            if px.get((x,cy+4))==OUT: px[(x,cy+4)]=mcol
+
+# ---- per-agent signature micro-animation on the prop (always-on identity) ----
+def prop_anim(px,prop,t,nf,propcol):
+    ph=t%max(1,nf); frac=t/max(1,nf); rgb=F._rgb
+    if prop=="cigar":
+        for k in range(2):                                  # smoke curl rising
+            yy=(cy+2)-((ph+k*2)%6); xx=cx+9+((ph+k)%2)
+            if yy>=cy-4: px[(xx,yy)]=rgb('9a9aa8') if k==0 else rgb('6a6a7a')
+        px[(cx+8,cy+4)]=rgb('ff4422') if ph%2==0 else rgb('ff7a44')   # ember flicker
+    elif prop=="headset":
+        px[(cx-6,cy+4)]=rgb('ff4422') if ph%2==0 else rgb('5a1a10')   # mic light blink
+    elif prop in("shades","glasses"):
+        gx=cx-5+int(frac*11)                                # glint sweeps both lenses
+        for lx0,lx1 in((cx-5,cx-1),(cx+2,cx+6)):
+            if lx0<=gx<=lx1: px[(gx,cy-1)]=WHT
+    elif prop=="monocle":
+        gx=cx+2+int(frac*4)
+        if cx+2<=gx<=cx+6: px[(gx,cy-1)]=WHT
+        px[(cx+4+(1 if ph%2 else 0),cy+2)]=rgb('d4af37')     # chain sway
+    elif prop=="pen":
+        if ph%2==0: px[(cx+8,cy-1)]=rgb('f2c75a')            # write spark at the nib
+    elif prop=="earbuds":
+        w=rgb('9fe8ff')
+        if ph%2==0: px[(cx-10,cy)]=w; px[(cx+10,cy)]=w        # sound waves pulse out
+        else: px[(cx-11,cy-1)]=w; px[(cx+11,cy-1)]=w
+    elif prop=="bandana":
+        dy=1 if ph%2 else 0; BC=rgb(propcol or 'ef4444')
+        px[(cx-11,cy+dy)]=BC; px[(cx-11,cy+1+dy)]=shade(BC,-22)  # tail flutter
+
+def founder_anim(px,t,nf):
+    rgb=F._rgb; ph=t%max(1,nf); frac=t/max(1,nf)
+    gx=cx-5+int(frac*11)                                 # glasses glint sweep
+    for lx0,lx1 in((cx-5,cx-3),(cx+3,cx+5)):
+        if lx0<=gx<=lx1: px[(gx,cy-1)]=WHT
+    GL = rgb('39d353') if ph%2==0 else rgb('1f7a3a')     # green mask-vent pulse
+    for k in range(3): px[(cx+3,cy+4+k)]=GL
+    BC=rgb('e23b3b'); BCd=shade(BC,-24); w=1 if ph%2 else 0   # right-side tails ripple in the wind
+    for strand in(0,1):
+        for k in range(2,6):
+            xx=cx+8+k; yy=(cy-2-strand*2)-(k*2)//3-(w if k>=3 else 0)
+            if 0<=xx<W and 0<=yy<H: px[(xx,yy)]=BC if k<3 else BCd
+
+NF={"breathe":10,"breathe_slow":10,"pulse":8,"blink":2,"arc":12,"scan":12,"spin":10,
+    "dualarc":12,"fill":12,"boot":10,"dots":6,"sparkout":4,"sparkin":4,"celebrate":8}
+
+def frames(base, rim_live, state, P, ctx):
+    grp,role,motion,badge,fps=CATALOG[state]
+    col=P[role] if role in P else P["accent"]
+    nf=NF[motion]; out=[]
+    SK=F.SKINS[ctx["skin"]]; lash=(ctx["gender"]=="f")
+    eyemode,mouthmode=EXPR[state]
+    for t in range(nf):
+        px=dict(base)
+        def setrim(fn):
+            for i,p in enumerate(rim_live): px[p]=fn(i,p)
+        n=len(rim_live)
+        if motion in("breathe","breathe_slow"):
+            cc=shade(col,(10 if motion=="breathe_slow" else 16)*tri(t,nf)); setrim(lambda i,p:cc)
+        elif motion=="pulse":
+            cc=shade(col,42*tri(t,nf)); setrim(lambda i,p:cc)
+        elif motion=="blink":
+            cc=col if t%2==0 else shade(col,-60); setrim(lambda i,p:cc)
+        elif motion in("arc","scan","spin"):
+            win={"arc":80,"scan":34,"spin":54}[motion]; a0=(t/nf)*2*math.pi; w=math.radians(win)
+            setrim(lambda i,p:(P["acc_hot"] if min((ANG[p]-a0)%(2*math.pi),(a0-ANG[p])%(2*math.pi))<=w/2 else P["acc_dim"]))
+        elif motion in("fill","boot"):
+            prog=(t+1)/nf; setrim(lambda i,p:(col if (i/max(1,n))<=prog else P["acc_dim"]))
+        elif motion=="dualarc":
+            a0=(t/nf)*2*math.pi; w=math.radians(70)
+            def cm(i,p):
+                for b in(a0,a0+math.pi):
+                    if min((ANG[p]-b)%(2*math.pi),(b-ANG[p])%(2*math.pi))<=w/2: return P["acc_hot"]
+                return P["acc_dim"]
+            setrim(cm)
+        elif motion=="dots":
+            cc=shade(col,14*tri(t,nf)); setrim(lambda i,p:cc)
+        elif motion=="sparkin":
+            cc=shade(col,16*tri(t,nf)); setrim(lambda i,p:cc)
+        elif motion=="celebrate":
+            cyc=[P["green"],P["amber"],P["accent"],P["acc_spark"]]; cc=cyc[t%len(cyc)]; setrim(lambda i,p:cc)
+        else:  # sparkout + fallbacks: steady rim
+            setrim(lambda i,p:col)
+        # ---- personalized expression (eyes + mouth per state) ----
+        blink = (nf>=6 and t==nf-1)                      # a blink each loop on longer states
+        eyeCov=(ctx["prop"] in EYEPROPS) or ctx.get("specs")
+        mouthCov=(ctx["prop"] in MOUTHPROPS) or ctx.get("mask")
+        if not eyeCov:
+            draw_eyes_expr(px,eyemode,t,nf,SK,lash,blink)
+        if not mouthCov:
+            mcol=F._rgb('c0392b') if ctx.get("mouth")=="lips" else None
+            draw_mouth_expr(px,mouthmode,t,SK,mcol)
+        if ctx.get("founder"): founder_anim(px,t,nf)             # founder signature anim
+        else: prop_anim(px, ctx["prop"], t, nf, ctx.get("propcol"))
+        if badge:
+            nm,bg,fg=badge; put_badge(px,nm,P[bg],P[fg])
+        out.append(px)
+    return out, fps
+
+def gen_agent(role, accent, gender, params, scale=8):
+    P=palette(accent)
+    base=F.face(accent, gender=gender, **params)
+    rim_live=[p for p in RIM if base.get(p) in (F._rgb(accent), shade(F._rgb(accent),-30))]
+    ctx={"skin":params.get("skin","mid"),"gender":gender,"prop":params.get("prop"),
+         "mouth":params.get("mouth"),"propcol":params.get("propcol"),
+         "specs":params.get("specs"),"mask":params.get("mask"),"founder":(role=="founder")}
+    out=os.path.join(OUT_BASE, role); os.makedirs(out, exist_ok=True)
+    # wipe old O+1 agent files
+    for fn in os.listdir(out):
+        if fn.endswith(('.png','.svg','.json')): os.remove(os.path.join(out,fn))
+    meta={"title":role.upper(),"accent":accent,"gender":gender,"W":W,"H":H,"scale":scale,"groups":GROUPS,"states":{}}
+    def render(px): return F.render(px,scale)
+    for s in CATALOG:
+        frs,fps=frames(base,rim_live,s,P,ctx)
+        imgs=[render(px) for px in frs]
+        w=sum(i.width for i in imgs); strip=Image.new("RGBA",(w,imgs[0].height),(0,0,0,0)); x=0
+        for i in imgs: strip.paste(i,(x,0)); x+=i.width
+        strip.save(os.path.join(out,f"anim-{s}.png"))
+        render(frs[0]).save(os.path.join(out,f"still-{s}.png"))
+        grp,role_,motion,badge,_=CATALOG[s]
+        meta["states"][s]={"group":grp,"frames":len(frs),"fps":fps,"motion":motion,"badge":badge[0] if badge else None}
+    # sprite sheet (8x4, representative frame)
+    def rep(m,n): return {"blink":0,"fill":int(n*.62),"boot":int(n*.62),"arc":n//4,"scan":n//4,"spin":n//4,"dualarc":n//4,"dots":1}.get(m,n//2)
+    cols,rows,cell=8,4,6
+    tw=W*cell*0+W; # overview uses small renders
+    cellimg=lambda px: F.render(px, 5)
+    order=[s for g in GROUPS for s in CATALOG if CATALOG[s][0]==g]
+    tile=W*5; pad=6
+    sheet=Image.new("RGBA",(cols*tile+(cols+1)*pad, rows*(H*5)+(rows+1)*pad),(16,16,24,255))
+    for i,s in enumerate(order):
+        frs,_=frames(base,rim_live,s,P,ctx); im=cellimg(frs[rep(CATALOG[s][2],len(frs))])
+        X=pad+(i%cols)*(tile+pad); Y=pad+(i//cols)*(H*5+pad); sheet.paste(im,(X,Y),im)
+    sheet.save(os.path.join(out,"sprite-sheet.png"))
+    json.dump(meta, open(os.path.join(out,"states.json"),"w"), indent=1)
+    return meta
+
+if __name__=="__main__":
+    only=sys.argv[1] if len(sys.argv)>1 else None
+    for role,acc,g,p in list(F.CAST)+[F.FOUNDER]:
+        r=role.lower()
+        if only and r!=only: continue
+        m=gen_agent(r,acc,g,p)
+        print(f"{role} {acc} {g}: {len(m['states'])} states -> brand/{r}/")