agents-city 0.3.0-beta.21

package/plugin/scripts/tokens.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Report token spend to the city, from your own agent transcripts.
+
+Claude Code records the usage of every message it makes — input, output, and both
+kinds of cache — in the session transcripts under ~/.claude/projects. This walks
+them, adds them up per day and per model, and reports the totals.
+
+    ./bin/tokens.py                 show what it would send
+    ./bin/tokens.py --push          send it
+    ./bin/tokens.py --days 7        only the last 7 days (default 30)
+
+What leaves your machine: numbers. A day, a model name, and four counts. Never a
+prompt, never a file name, never a project path.
+
+And what the city does with it: a **global** total. Spend is stored per person
+because that is the only way to deduplicate reports, but there is no endpoint
+that ranks people by it and there is not going to be one. A leaderboard changes
+what people do, and what this map is for is the opposite.
+
+Incremental, and carefully so: it remembers the size and mtime of every
+transcript *and the totals it got from it*, so a second run re-reads only what
+changed and still reports the complete picture. Caching only the marks would be
+worse than not caching at all — reports are absolute per day, so a run that
+skipped the other files touched today would overwrite today with a fraction of
+it.
+"""
+import argparse
+import json
+import os
+import sys
+import urllib.request
+from collections import defaultdict
+from datetime import datetime, timedelta, timezone
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import city_env
+
+PROYECTOS = os.path.expanduser('~/.claude/projects')
+ESTADO = os.path.join(city_env.CANAL, 'tokens-state.json')
+
+
+def estado_previo():
+    """{path: {"m": "<size>:<mtime>", "r": {"<day>|<model>": [in, out, cr, cw]}}}"""
+    try:
+        with open(ESTADO) as f:
+            d = json.load(f)
+        return d if isinstance(d, dict) else {}
+    except Exception:
+        return {}
+
+
+def guarda_estado(d):
+    os.makedirs(os.path.dirname(ESTADO), exist_ok=True)
+    with open(ESTADO, 'w') as f:
+        json.dump(d, f)
+
+
+def transcripciones(desde_ts):
+    for raiz, _, ficheros in os.walk(PROYECTOS):
+        for f in ficheros:
+            if not f.endswith('.jsonl'):
+                continue
+            p = os.path.join(raiz, f)
+            try:
+                st = os.stat(p)
+            except OSError:
+                continue
+            if st.st_mtime < desde_ts:
+                continue
+            yield p, st
+
+
+def suma(fichero):
+    """Add up one transcript, returning {"<day>|<model>": [in, out, cr, cw]}.
+
+    Tolerant on purpose: a half-written line at the end of a live session is
+    normal, not an error worth stopping for.
+    """
+    dias = defaultdict(lambda: {'input': 0, 'output': 0, 'cache_read': 0, 'cache_write': 0})
+    try:
+        fh = open(fichero, errors='replace')
+    except OSError:
+        return {}
+    with fh:
+        for linea in fh:
+            if '"usage"' not in linea:
+                continue
+            try:
+                d = json.loads(linea)
+            except Exception:
+                continue
+            m = d.get('message') or {}
+            u = m.get('usage') or d.get('usage')
+            ts = d.get('timestamp') or ''
+            if not u or len(ts) < 10:
+                continue
+            clave = ts[:10] + '|' + (m.get('model') or d.get('model') or '')[:40]
+            a = dias[clave]
+            a['input'] += u.get('input_tokens', 0) or 0
+            a['output'] += u.get('output_tokens', 0) or 0
+            a['cache_read'] += u.get('cache_read_input_tokens', 0) or 0
+            a['cache_write'] += u.get('cache_creation_input_tokens', 0) or 0
+    return {k: [v['input'], v['output'], v['cache_read'], v['cache_write']]
+            for k, v in dias.items()}
+
+
+def acumula(previo, corte):
+    """Every transcript in the window, summed — the cached rows included, because
+    the report is the whole window every time (the city stores it absolutely)."""
+    nuevo = {}
+    total = defaultdict(lambda: [0, 0, 0, 0])
+    leidos = saltados = 0
+    for p, st in transcripciones(corte.timestamp()):
+        marca = f'{st.st_size}:{int(st.st_mtime)}'
+        antes = previo.get(p)
+        if isinstance(antes, dict) and antes.get('m') == marca:
+            filas_f = antes.get('r') or {}
+            saltados += 1
+        else:
+            filas_f = suma(p)
+            leidos += 1
+        nuevo[p] = {'m': marca, 'r': filas_f}
+        for k, v in filas_f.items():
+            t = total[k]
+            for i in range(4):
+                t[i] += v[i]
+    return nuevo, total, leidos, saltados
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--url', default=city_env.url())
+    ap.add_argument('--token', default='')
+    ap.add_argument('--days', type=int, default=30)
+    ap.add_argument('--push', action='store_true')
+    ap.add_argument('--all', action='store_true', help='re-read every transcript, ignoring state')
+    ap.add_argument('--quiet', action='store_true', help='say nothing unless it fails')
+    a = ap.parse_args()
+
+    di = (lambda *a, **k: None) if a.quiet else print
+    if not os.path.isdir(PROYECTOS):
+        di(f'No transcripts at {PROYECTOS}. Nothing to report.')
+        return 0
+
+    corte = datetime.now(timezone.utc) - timedelta(days=a.days)
+    desde = corte.strftime('%Y-%m-%d')
+    previo = {} if a.all else estado_previo()
+    nuevo, total, leidos, saltados = acumula(previo, corte)
+
+    filas = [{'day': k.split('|', 1)[0], 'model': k.split('|', 1)[1],
+              'input': v[0], 'output': v[1], 'cache_read': v[2], 'cache_write': v[3]}
+             for k, v in sorted(total.items()) if k.split('|', 1)[0] >= desde]
+
+    if not filas:
+        di(f'Nothing new in the last {a.days} days. ({saltados} transcripts unchanged.)')
+        return 0
+
+    por_dia = defaultdict(int)
+    for f in filas:
+        por_dia[f['day']] += f['input'] + f['output']
+    di(f'  {leidos} transcripts read, {saltados} unchanged\n')
+    for d in sorted(por_dia)[-10:]:
+        di(f'  {d}   {por_dia[d]:>12,} tokens')
+    total = sum(por_dia.values())
+    di(f'\n  {total:,} tokens across {len(por_dia)} days, {len(filas)} day/model rows')
+
+    if not a.push:
+        guarda_estado(nuevo)   # the reading is the expensive part; keep it either way
+        di('\n  Nothing sent. Add --push when it looks right.')
+        return 0
+    if not a.url:
+        print('\n  No city URL. Pass --url or set AGENTS_CITY_URL.', file=sys.stderr)
+        return 1
+    tk = city_env.token(a.token)
+    if not tk:
+        print('\n  No bus token. Pass --token or set CITY_BUS_TOKEN.', file=sys.stderr)
+        return 1
+
+    req = urllib.request.Request(
+        a.url.rstrip('/') + '/api/tokens',
+        data=json.dumps({'days': filas}).encode(),
+        headers={'content-type': 'application/json', 'authorization': f'Bearer {tk}'})
+    try:
+        with urllib.request.urlopen(req, timeout=60) as r:
+            di('\n  ' + r.read().decode())
+        guarda_estado(nuevo)
+    except Exception as e:
+        print(f'\n  The city refused it: {e}', file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

package/plugin/scripts/trust-repos.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Mark the folders this session is about to open as already trusted.
+
+    trust-repos.py <path> [<path>...]
+
+Without it every tmux window sits on the "do you trust this folder?" dialog and
+you answer them one at a time.
+
+It touches only the `hasTrustDialogAccepted` key of the paths it is given — the
+ones from this person's own card — and nothing else in ~/.claude.json.
+"""
+import json
+import os
+import sys
+import tempfile
+
+CONF = os.path.expanduser("~/.claude.json")
+
+
+def main():
+    rutas = [os.path.realpath(r) for r in sys.argv[1:] if r]
+    if not rutas:
+        return
+
+    try:
+        with open(CONF, encoding="utf-8") as f:
+            d = json.load(f)
+    except FileNotFoundError:
+        d = {}
+    except (ValueError, OSError) as e:
+        print(f"[city] cannot read {CONF}: {e}", file=sys.stderr)
+        return
+
+    proyectos = d.setdefault("projects", {})
+    nuevas = 0
+    for r in rutas:
+        p = proyectos.setdefault(r, {})
+        if not p.get("hasTrustDialogAccepted"):
+            p["hasTrustDialogAccepted"] = True
+            nuevas += 1
+
+    if nuevas == 0:
+        return
+
+    # Written atomically: this file is big, and losing it hurts.
+    carpeta = os.path.dirname(CONF)
+    fd, tmp = tempfile.mkstemp(dir=carpeta, prefix=".claude.json.")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            json.dump(d, f, indent=2, ensure_ascii=False)
+        os.replace(tmp, CONF)
+        print(f"[city] trusted {nuevas} folder(s)", file=sys.stderr)
+    except OSError as e:
+        if os.path.exists(tmp):
+            os.unlink(tmp)
+        print(f"[city] could not save {CONF}: {e}", file=sys.stderr)
+
+
+main()

package/plugin/scripts/ui.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+"""Terminal widgets for the setup wizard. Standard library only, no deps.
+
+Everything here degrades: if there is no TTY — a pipe, CI, an agent running the
+command — each widget falls back to plain prompts or to its default. A wizard
+that only works in a nice terminal is a wizard that breaks in half the places
+people actually run things.
+"""
+import curses
+import os
+import sys
+import textwrap
+
+TTY = sys.stdin.isatty() and sys.stdout.isatty()
+
+# Scripted answers, for tests and for CI. A wizard that can only be exercised by
+# hand is a wizard whose logic nobody checks, and the logic is where the bugs are:
+# every widget takes its answer from here when the file is present.
+_GUION = None
+if os.environ.get('AGENTS_CITY_ANSWERS'):
+    import json as _json
+    with open(os.environ['AGENTS_CITY_ANSWERS']) as _f:
+        _GUION = _json.load(_f)
+    TTY = False
+
+
+def _guionizado(clave, defecto=None):
+    """The scripted answer for this widget, by title.
+
+    A plain value is *the* answer, used however many times the widget asks — which
+    matters because a list is the answer for a multi-select, not a queue of
+    answers. For the widgets asked repeatedly in a loop ("another unit", "another
+    username") wrap it: {"queue": ["a", "b", ""]}.
+    """
+    if _GUION is None:
+        return ('sin guion', None)
+    if clave not in _GUION:
+        return ('falta', defecto)
+    v = _GUION[clave]
+    if isinstance(v, dict) and 'queue' in v:
+        cola = v['queue']
+        return ('ok', cola.pop(0)) if cola else ('agotado', defecto)
+    return ('ok', v)
+
+# ── colours ────────────────────────────────────────────────────────────────
+INK, DIM, ACCENT, GOOD, WARN = 1, 2, 3, 4, 5
+
+
+def _pairs():
+    curses.start_color()
+    curses.use_default_colors()
+    curses.init_pair(INK, curses.COLOR_WHITE, -1)
+    curses.init_pair(DIM, curses.COLOR_BLUE, -1)
+    curses.init_pair(ACCENT, curses.COLOR_YELLOW, -1)
+    curses.init_pair(GOOD, curses.COLOR_GREEN, -1)
+    curses.init_pair(WARN, curses.COLOR_RED, -1)
+
+
+def _chrome(win, title, step, of, hint):
+    """Same frame on every screen: where you are, and which keys work here."""
+    h, w = win.getmaxyx()
+    win.attron(curses.color_pair(ACCENT) | curses.A_BOLD)
+    win.addnstr(0, 2, "AGENTS CITY", w - 4)
+    win.attroff(curses.color_pair(ACCENT) | curses.A_BOLD)
+    if step:
+        win.attron(curses.color_pair(DIM))
+        win.addnstr(0, 15, f"step {step} of {of}", w - 17)
+        win.attroff(curses.color_pair(DIM))
+    win.attron(curses.A_BOLD)
+    win.addnstr(2, 2, title[: w - 4], w - 4)
+    win.attroff(curses.A_BOLD)
+    win.attron(curses.color_pair(DIM))
+    win.addnstr(h - 1, 2, hint[: w - 4], w - 4)
+    win.attroff(curses.color_pair(DIM))
+
+
+def texto(cuerpo, w):
+    """Wrap for the terminal, keeping blank lines as paragraph breaks."""
+    out = []
+    for p in cuerpo.split("\n\n"):
+        out += textwrap.wrap(" ".join(p.split()), max(20, w - 6)) or [""]
+        out.append("")
+    return out[:-1] if out else out
+
+
+def pantalla(titulo, cuerpo, step=None, of=None, hint="enter to continue · q to quit"):
+    """A page of text. Returns False if the person quits."""
+    if not TTY:
+        estado, v = _guionizado(titulo, True)
+        print(f"[{titulo}] {'skipped' if v is False else 'read'}")
+        return True if v is None else bool(v)
+
+    def run(win):
+        curses.curs_set(0)
+        _pairs()
+        while True:
+            win.erase()
+            h, w = win.getmaxyx()
+            _chrome(win, titulo, step, of, hint)
+            for i, l in enumerate(texto(cuerpo, w)[: h - 7]):
+                win.addnstr(4 + i, 2, l, w - 4)
+            win.refresh()
+            k = win.getch()
+            if k in (10, 13, curses.KEY_ENTER, ord(" ")):
+                return True
+            if k in (ord("q"), 27):
+                return False
+
+    return curses.wrapper(run)
+
+
+def elige(titulo, opciones, marcadas=None, step=None, of=None, minimo=0, ayuda=""):
+    """Multi-select with checkboxes. `opciones` is [(id, label, detail)].
+
+    Returns the list of chosen ids, or None if the person quits.
+    """
+    marcadas = set(marcadas or [])
+    if not TTY:
+        estado, v = _guionizado(titulo)
+        elegidas = sorted(marcadas) if v is None else v
+        print(f"[{titulo}] {elegidas}")
+        return elegidas
+
+    def run(win):
+        curses.curs_set(0)
+        _pairs()
+        sel, top, filtro, escribiendo = 0, 0, "", False
+        while True:
+            win.erase()
+            h, w = win.getmaxyx()
+            visibles = [o for o in opciones
+                        if not filtro or filtro.lower() in (o[0] + " " + o[1]).lower()]
+            sel = max(0, min(sel, len(visibles) - 1))
+            filas = h - 8
+            if sel < top:
+                top = sel
+            if sel >= top + filas:
+                top = sel - filas + 1
+
+            hint = ("type to filter · esc clear" if escribiendo else
+                    "↑↓ move · space pick · / filter · a all · n none · enter done · q quit")
+            _chrome(win, titulo, step, of, hint)
+            if ayuda:
+                win.attron(curses.color_pair(DIM))
+                win.addnstr(3, 2, ayuda[: w - 4], w - 4)
+                win.attroff(curses.color_pair(DIM))
+
+            for i, (oid, etiqueta, detalle) in enumerate(visibles[top:top + filas]):
+                y = 5 + i
+                puesto = top + i == sel
+                marca = "[x]" if oid in marcadas else "[ ]"
+                if puesto:
+                    win.attron(curses.A_REVERSE)
+                win.addnstr(y, 2, f" {marca} {etiqueta} ", w - 4)
+                if puesto:
+                    win.attroff(curses.A_REVERSE)
+                if detalle:
+                    x = 2 + len(f" {marca} {etiqueta}  ")
+                    if x < w - 6:
+                        win.attron(curses.color_pair(DIM))
+                        win.addnstr(y, x, detalle[: w - x - 3], w - x - 3)
+                        win.attroff(curses.color_pair(DIM))
+
+            pie = f"{len(marcadas)} picked"
+            if filtro:
+                pie += f" · filter: {filtro}"
+            if minimo and len(marcadas) < minimo:
+                pie += f" · pick at least {minimo}"
+            win.attron(curses.color_pair(ACCENT))
+            win.addnstr(h - 3, 2, pie[: w - 4], w - 4)
+            win.attroff(curses.color_pair(ACCENT))
+            win.refresh()
+
+            k = win.getch()
+            if escribiendo:
+                if k in (10, 13, 27):
+                    escribiendo = False
+                elif k in (curses.KEY_BACKSPACE, 127, 8):
+                    filtro = filtro[:-1]
+                elif 32 <= k < 127:
+                    filtro += chr(k)
+                continue
+            if k in (curses.KEY_UP, ord("k")):
+                sel -= 1
+            elif k in (curses.KEY_DOWN, ord("j")):
+                sel += 1
+            elif k == ord(" ") and visibles:
+                oid = visibles[sel][0]
+                marcadas.symmetric_difference_update({oid})
+            elif k == ord("/"):
+                escribiendo, filtro = True, ""
+            elif k == ord("a"):
+                marcadas.update(o[0] for o in visibles)
+            elif k == ord("n"):
+                marcadas.difference_update(o[0] for o in visibles)
+            elif k in (10, 13, curses.KEY_ENTER):
+                if len(marcadas) >= minimo:
+                    return sorted(marcadas)
+            elif k in (ord("q"), 27):
+                return None
+
+    return curses.wrapper(run)
+
+
+def una(titulo, opciones, step=None, of=None, ayuda=""):
+    """Single choice. Returns the id, or None.
+
+    Unlike `elige`, the cursor wraps: with one thing to pick, running off the end
+    and coming back round is what you want. Which also means an empty list would
+    divide by zero, so nothing to choose returns nothing rather than a traceback.
+    """
+    if not opciones:
+        return None
+    if not TTY:
+        estado, v = _guionizado(titulo)
+        elegida = (v if v is not None else (opciones[0][0] if opciones else None))
+        print(f"[{titulo}] {elegida}")
+        return elegida
+
+    def run(win):
+        curses.curs_set(0)
+        _pairs()
+        sel = 0
+        while True:
+            win.erase()
+            h, w = win.getmaxyx()
+            _chrome(win, titulo, step, of, "↑↓ move · enter pick · q quit")
+            if ayuda:
+                win.attron(curses.color_pair(DIM))
+                for i, l in enumerate(texto(ayuda, w)[:3]):
+                    win.addnstr(3 + i, 2, l, w - 4)
+                win.attroff(curses.color_pair(DIM))
+            for i, (_oid, etiqueta, detalle) in enumerate(opciones[: h - 9]):
+                y = 7 + i
+                if i == sel:
+                    win.attron(curses.A_REVERSE)
+                win.addnstr(y, 2, f" {etiqueta} ", w - 4)
+                if i == sel:
+                    win.attroff(curses.A_REVERSE)
+                if detalle:
+                    x = 4 + len(etiqueta)
+                    if x < w - 6:
+                        win.attron(curses.color_pair(DIM))
+                        win.addnstr(y, x, detalle[: w - x - 3], w - x - 3)
+                        win.attroff(curses.color_pair(DIM))
+            win.refresh()
+            k = win.getch()
+            if k in (curses.KEY_UP, ord("k")):
+                sel = (sel - 1) % len(opciones)
+            elif k in (curses.KEY_DOWN, ord("j")):
+                sel = (sel + 1) % len(opciones)
+            elif k in (10, 13, curses.KEY_ENTER):
+                return opciones[sel][0]
+            elif k in (ord("q"), 27):
+                return None
+
+    return curses.wrapper(run)
+
+
+def pide(pregunta, defecto="", validar=None, ayuda=""):
+    """One line of text, with a default and optional validation."""
+    if not TTY:
+        estado, v = _guionizado(pregunta, defecto)
+        print(f"[{pregunta}] {v!r}")
+        return v
+    while True:
+        curses.endwin() if curses.has_colors() and False else None
+        suf = f" [{defecto}]" if defecto else ""
+        if ayuda:
+            print(f"\n  {ayuda}")
+        try:
+            v = input(f"  {pregunta}{suf}: ").strip() or defecto
+        except (EOFError, KeyboardInterrupt):
+            return None
+        if validar:
+            problema = validar(v)
+            if problema:
+                print(f"  ↳ {problema}")
+                continue
+        return v

package/plugin/scripts/units.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""The one reader and writer of `units.yml` — the districts of a city.
+
+Three places touched this file each in their own way: the seeder parsed it, the
+wizard emitted it, and the seat emitted a one-district version of it. Three copies
+of one format is how `parcels.yml` ended up with a reader that looked for a key no
+writer wrote, so the districts get the same treatment before they get the chance.
+
+The two special districts are part of the format, not of any caller: every city has
+a `lab` (research that does not ship yet, and is needed) and a `none` (what serves
+several units, or none). Writers emit them; readers hand them back like any other.
+"""
+import re
+import parcels  # the field syntax (`key: value ; key: value`) is the same one
+
+
+def lee(ruta):
+    """Every district in the file, `special` ones included, in file order.
+
+    Returns [{'id', 'name', 'color', 'order', 'note'}]. Missing file reads as
+    empty — the caller decides whether an empty city is an error.
+    """
+    try:
+        with open(ruta, encoding='utf-8') as f:
+            txt = f.read()
+    except (OSError, IsADirectoryError):
+        return []
+    fuera = []
+    for linea in txt.splitlines():
+        if linea.strip().startswith('- id:'):
+            c = parcels.campos(linea)
+            ident = c.get('id', '')
+            try:
+                orden = int(c.get('order', 50))
+            except ValueError:
+                orden = 50
+            fuera.append({'id': ident, 'name': c.get('name', ident),
+                          'color': c.get('color', 'c8b48a'), 'order': orden,
+                          'note': None})
+        elif 'note:' in linea and fuera:
+            fuera[-1]['note'] = linea.split('note:')[1].strip().strip('"')
+    return fuera
+
+
+def propias(ruta):
+    """Only the districts the team declared — lab and none filtered out."""
+    return [u for u in lee(ruta) if u['id'] not in ('lab', 'none')]
+
+
+def escribe(ruta, unidades):
+    """Write the whole file: the team's districts plus the two special ones.
+
+    `unidades` is [{'id', 'name', 'color'}] in display order; `order` is assigned
+    from position because that is all it ever meant. Ids are cleaned the same way
+    the wizard cleans them, so a caller cannot write an id the map cannot use.
+    """
+    lineas = ['# Business units — the districts of your city.',
+              '#',
+              '# The map reads this: names, colours and order come from here, not from the',
+              '# code. Change a name and the map redraws itself.',
+              'units:']
+    for i, u in enumerate(unidades, 1):
+        ident = re.sub(r'[^a-z0-9]+', '-', str(u['id']).lower()).strip('-')[:20] or f'u{i}'
+        color = str(u.get('color', 'c8b48a')).lstrip('#').lower()
+        if not re.fullmatch(r'[0-9a-f]{6}', color):
+            color = 'c8b48a'
+        nombre = str(u.get('name', ident)).replace(';', ',')[:20]
+        lineas.append(f'  - id: {ident:<12} ; name: {nombre:<20} ; color: {color} ; order: {i}')
+    lineas += ['',
+               '# These two every city has, whatever the business. The lab does not ship yet',
+               '# and is needed; "none" is what serves several units, or none. Its houses',
+               '# are drawn with permanent scaffolding, and its growth is not compared',
+               '# against the shipping units: few floors there is early, not behind.',
+               'special:',
+               '  - id: lab          ; name: Lab                  ; color: 8fb8c9 ; order: 90',
+               '    note: "doesn\'t ship yet, and it\'s needed"',
+               '  - id: none         ; name: No unit              ; color: c8b48a ; order: 99',
+               '    note: "serves several units, or none"']
+    with open(ruta, 'w', encoding='utf-8') as f:
+        f.write('\n'.join(lineas) + '\n')