agents-city 0.4.0 → 0.5.2

package/plugin/scripts/doctor.py

@@ -22,6 +22,7 @@ import sys
 
 GUIONES = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, GUIONES)
+import arnes  # noqa: E402  what we do to the CLIs somebody already had
 from dataclasses import dataclass
 from typing import Callable
 
@@ -188,15 +189,23 @@ def revisa_entorno():
     fuera.append(('python', True, _sys.version.split()[0]))
     # Every one of these spells its version flag differently, and tmux answers
     # `--version` with an error that reads like a working version string.
-    for programa, bandera, obligatorio in (('tmux', '-V', True), ('bash', '--version', True),
-                                           ('git', '--version', True),
-                                           ('node', '--version', True),
-                                           ('gh', '--version', False)):
-        v = _version_de(programa, bandera)
+    #
+    # Five independent subprocesses: asked together, the wait is the slowest one
+    # rather than the sum of five. A doctor that takes half a second to say
+    # everything is fine gets run; one that takes two does not.
+    programas = (('tmux', '-V', True), ('bash', '--version', True),
+                 ('git', '--version', True), ('node', '--version', True),
+                 ('gh', '--version', False))
+    from concurrent.futures import ThreadPoolExecutor  # noqa: PLC0415
+
+    with ThreadPoolExecutor(max_workers=len(programas)) as piscina:
+        versiones = list(piscina.map(lambda p: _version_de(p[0], p[1]), programas))
+    for (programa, _bandera, obligatorio), v in zip(programas, versiones, strict=True):
         fuera.append((programa, bool(v) if obligatorio else (True if v else None),
                       v or ('missing' if obligatorio else 'not installed (optional)')))
 
-    motores = [m for m in ('claude', 'codex', 'opencode', 'kimi') if _sh.which(m)]
+    # The declaration owns which runtimes exist and what each is called on disk.
+    motores = [e['binario'] for e in arnes.informe() if e['instalado']]
     fuera.append(('runtimes', bool(motores),
                   ', '.join(motores) if motores else 'none — a city needs at least one CLI'))
 
@@ -257,22 +266,88 @@ def informe_entorno():
     return 1 if roto else 0
 
 
-def main():
+def _diario(empaqueta, resto):
+    """`doctor --log` reads the journal; `doctor --report` bundles it to send.
+
+    The report is the thing that was missing. When this breaks on somebody
+    else's machine, the useful answer is not "tell me what you did" — it is a
+    file they can attach without reading it first. So it carries the journal and
+    the environment report, and nothing else: `diario` redacts credentials on
+    the way in, so what lands here was never a secret to begin with.
+    """
+    import cities  # noqa: PLC0415
+    import diario  # noqa: PLC0415
+
+    datos = cities.actual()
+    try:
+        cuantas = int(resto[0]) if resto else (2000 if empaqueta else 60)
+    except ValueError:
+        cuantas = 60
+    lineas = diario.lee(datos, cuantas)
+    if not empaqueta:
+        print(f'\n  {diario.ruta(datos)}\n')
+        if not lineas:
+            print('  Nothing recorded yet. The Hall writes here as you use it.\n')
+            return 0
+        for l in lineas:
+            resto_l = {k: v for k, v in l.items() if k not in ('t', 'tipo')}
+            detalle = json.dumps(resto_l, ensure_ascii=False)[:160]
+            print(f"  {l.get('t', '')}  {l.get('tipo', ''):8} {detalle}")
+        print()
+        return 0
+
+    import io  # noqa: PLC0415
+    from contextlib import redirect_stdout  # noqa: PLC0415
+
+    entorno = io.StringIO()
+    with redirect_stdout(entorno):
+        informe_entorno()
+    destino = os.path.join(os.path.expanduser('~'), 'agents-city-report.txt')
+    with open(destino, 'w', encoding='utf-8') as f:
+        f.write('# agents-city report\n\n')
+        f.write('## this machine\n')
+        f.write(entorno.getvalue())
+        f.write(f'\n## the journal ({len(lineas)} entries)\n\n')
+        for l in lineas:
+            f.write(json.dumps(l, ensure_ascii=False) + '\n')
+    print(f'\n  Written to {destino}\n')
+    print('  It holds what this machine is and what the town hall did.')
+    print('  Credentials are stripped as they are recorded, so it is safe to attach.\n')
+    return 0
+
+
+def main(argv=None):
+    # The arguments are a parameter so this door can be knocked on from a test
+    # without a subprocess: `doctor --config` is the command that backs a claim
+    # about somebody's machine, and it deserves to be checked like one.
+    argv = list(sys.argv if argv is None else argv)
     # `doctor` with no file is the environment report — what a person means by
     # the word. The config migration keeps its own path, unchanged.
-    if len(sys.argv) == 1 or sys.argv[1] in ('-h', '--help', 'help'):
-        if len(sys.argv) > 1:
-            print('  usage: agents-city doctor [config.json [--fix]]\n\n'
-                  '  With no arguments: check this machine — tools, runtimes, the\n'
-                  '  cage, the selected city, and whether a newer version is out.\n'
-                  '  With a config file: detect, explain and migrate an old shape.')
-            return 0
+    if len(argv) > 1 and argv[1] in ('-h', '--help', 'help'):
+        print(
+            '  usage: agents-city doctor [--config] [config.json [--fix]]\n\n'
+            '  With no arguments: check this machine — tools, runtimes, the\n'
+            '  cage, the selected city, and whether a newer version is out.\n'
+            '  --config: what this product does to the CLIs you already have —\n'
+            '  what it adds, what it inherits from your own settings, and what\n'
+            '  it leaves alone. Add --json for the same thing as data.\n'
+            '  With a config file: detect, explain and migrate an old shape.'
+        )
+        return 0
+    if len(argv) == 1:
         return informe_entorno()
+    # The claim this product makes about somebody else's machine, printed so it
+    # can be checked instead of believed.
+    if argv[1] in ('--config', 'config'):
+        return arnes.main(argv[2:])
+    # What happened, and something to attach to an issue.
+    if argv[1] in ('--log', 'log', '--report', 'report'):
+        return _diario(argv[1] in ('--report', 'report'), argv[2:])
     p = argparse.ArgumentParser(description='Detect, explain and migrate an old config shape.')
     p.add_argument('fichero', help='the config JSON file to check')
     p.add_argument('--fix', action='store_true', help='rewrite (default is dry-run report)')
     p.add_argument('--stamp', default='manual', help='backup suffix (tests pass a fixed value)')
-    args = p.parse_args()
+    args = p.parse_args(argv[1:])
     try:
         reporte = cura_fichero(args.fichero, args.stamp, dry_run=not args.fix)
     except (OSError, json.JSONDecodeError) as e:

package/plugin/scripts/read-card.py

@@ -5,6 +5,9 @@
     read-card.py <card.md> repos     -> comma-separated list
     read-card.py --window <repo>     -> canonical tmux/bus actor slug
     read-card.py --actor-role <card.md> <actor> -> safe operating role or blank
+    read-card.py --varios <card.md> f1 f2 ...   -> one line per field, in order
+    read-card.py --ventana <card.md> <window>   -> everything the launcher needs
+                                                   for that window, one per line
 
 A thin front on card.py, which is where the parsing lives. It used to hold its own
 copy, and that copy is why the tmux session asked for `agente` — a field no card in
@@ -19,6 +22,16 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import card  # noqa: E402
 
 
+def _campo(texto, campo):
+    valor = card.campo(texto, campo)
+    # A bracketed value is a list everywhere else in this product — `repos:`,
+    # `agents:`, `mounts.<agent>:` — and the shell wants one line. Deciding by
+    # SHAPE rather than by a list of blessed field names is what stopped this
+    # from having to be edited every time the card grew another list.
+    esLista = valor.strip().startswith('[') and valor.strip().endswith(']')
+    return ','.join(card.lista(valor)) if esLista else valor
+
+
 def main():
     if len(sys.argv) == 3 and sys.argv[1] == '--window':
         print(card.ventana(sys.argv[2]))
@@ -31,10 +44,43 @@ def main():
         actor = card.ventana(sys.argv[3])
         print(card.rol_seguro(card.campo(texto, f'role.{actor}')))
         return
+    # Everything one window needs, in one interpreter.
+    #
+    # The launcher used to ask three times per window — the operating role, what
+    # runs there, and the engine — each a fresh Python start re-reading the same
+    # small card. Six lines, in a fixed order, because the shell reads them with
+    # `sed -n Np` and a named format would mean parsing on that side too:
+    #
+    #   1 role   2 runs   3 model.<window>   4 model   5 effort.<window>   6 effort
+    if len(sys.argv) == 4 and sys.argv[1] == '--ventana':
+        try:
+            with open(sys.argv[2], encoding='utf-8') as f:
+                texto = f.read()
+        except OSError as e:
+            sys.exit(f'cannot read {sys.argv[2]}: {e}')
+        win = card.ventana(sys.argv[3])
+        print(card.rol_seguro(card.campo(texto, f'role.{win}')))
+        for campo in (f'runs.{win}', f'model.{win}', 'model', f'effort.{win}', 'effort'):
+            print(_campo(texto, campo))
+        return
+
+    # Several fields, one interpreter. The launcher asks for a window's model
+    # and effort — with the card default behind each — which was four processes
+    # re-parsing the same small file, per window, before tmux even attached.
+    if len(sys.argv) > 3 and sys.argv[1] == '--varios':
+        try:
+            with open(sys.argv[2], encoding='utf-8') as f:
+                texto = f.read()
+        except OSError as e:
+            sys.exit(f'cannot read {sys.argv[2]}: {e}')
+        for campo in sys.argv[3:]:
+            print(_campo(texto, campo))
+        return
     if len(sys.argv) < 3:
         sys.exit(
             'usage: read-card.py <card.md> <field> | --window <repo> | '
-            '--actor-role <card.md> <actor>'
+            '--actor-role <card.md> <actor> | --varios <card.md> <field>... | '
+            '--ventana <card.md> <window>'
         )
     ruta, campo = sys.argv[1], sys.argv[2]
     try:
@@ -42,13 +88,7 @@ def main():
             texto = f.read()
     except OSError as e:
         sys.exit(f'cannot read {ruta}: {e}')
-    valor = card.campo(texto, campo)
-    # A bracketed value is a list everywhere else in this product — `repos:`,
-    # `agents:`, `mounts.<agent>:` — and the shell wants one line. Deciding by
-    # SHAPE rather than by a list of blessed field names is what stopped this
-    # from having to be edited every time the card grew another list.
-    esLista = valor.strip().startswith('[') and valor.strip().endswith(']')
-    print(','.join(card.lista(valor)) if esLista else valor)
+    print(_campo(texto, campo))
 
 
 if __name__ == '__main__':