agents-city 0.3.0-beta.21 → 0.3.0

package/plugin/scripts/doctor.py

@@ -19,6 +19,9 @@ import argparse
 import json
 import os
 import sys
+
+GUIONES = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, GUIONES)
 from dataclasses import dataclass
 from typing import Callable
 
@@ -145,7 +148,126 @@ def cura_fichero(ruta, marca, dry_run=False):
     return reporte
 
 
+# ── the machine, not just the config ─────────────────────────────────────────
+#
+# `doctor` used to answer one narrow question — is this config file an old
+# shape? — behind no command at all. What a person means by "doctor" is: tell
+# me whether this thing can work here, and if not, which part. So it answers
+# that too, and every line is derived: what is installed, what the kernel will
+# grant, which city is selected. Nothing here writes.
+
+
+def _version_de(programa, bandera='--version'):
+    import shutil as _sh
+    import subprocess as _sp
+
+    ruta = _sh.which(programa)
+    if not ruta:
+        return ''
+    try:
+        r = _sp.run([ruta, bandera], capture_output=True, text=True, timeout=10)
+    except (OSError, _sp.SubprocessError):
+        return 'installed'
+    primera = (r.stdout or r.stderr).strip().splitlines()
+    return primera[0].strip() if primera else 'installed'
+
+
+def revisa_entorno():
+    """Every check as `(area, ok, detail)`. `ok` is None for "not applicable".
+
+    A list rather than printed lines, so the Hall could show the same answers
+    the terminal does without either of them re-deciding what healthy means.
+    """
+    import shutil as _sh
+    import sys as _sys
+
+    import cage as _cage
+    import cities as _cities
+
+    fuera = []
+    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)
+        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)]
+    fuera.append(('runtimes', bool(motores),
+                  ', '.join(motores) if motores else 'none — a city needs at least one CLI'))
+
+    if _sys.platform == 'darwin':
+        detalle = ('seatbelt' if _sh.which('sandbox-exec') else 'sandbox-exec missing')
+    elif _sys.platform.startswith('linux'):
+        if not _sh.which('bwrap'):
+            detalle = 'bubblewrap not installed — agents run uncaged (apt install bubblewrap)'
+        elif not _cage.bwrap_sirve():
+            detalle = ('bubblewrap present but the kernel refuses unprivileged '
+                       'namespaces — agents run uncaged')
+        else:
+            detalle = 'bubblewrap'
+    else:
+        detalle = f'no cage on {_sys.platform}'
+    fuera.append(('cage', _cage.disponible(), detalle))
+
+    try:
+        usuario = _cities.usuario_actual()
+        datos = _cities.actual(usuario, crear=False)
+        if datos:
+            fuera.append(('city', True, _cities.direccion(usuario, datos)))
+            ficha = os.path.join(datos, f'{usuario}.md')
+            fuera.append(('card', os.path.isfile(ficha),
+                          ficha if os.path.isfile(ficha) else f'no card at {ficha}'))
+        else:
+            fuera.append(('city', None, 'none selected yet — agents-city seat creates one'))
+    except (OSError, ValueError) as e:
+        fuera.append(('city', False, str(e)))
+
+    hall = os.path.join(os.path.dirname(os.path.dirname(GUIONES)),
+                        'city', 'web', 'dist-hall', 'hall.js')
+    fuera.append(('hall bundle', os.path.isfile(hall),
+                  'built' if os.path.isfile(hall) else 'not built — ./bin/hall builds it'))
+    return fuera
+
+
+def informe_entorno():
+    """Print the environment report. Returns 0 when nothing is broken."""
+    import actualiza
+
+    print('\n  Agents City doctor\n')
+    roto = 0
+    for area, bien, detalle in revisa_entorno():
+        marca = '·' if bien is None else ('ok' if bien else 'XX')
+        if bien is False:
+            roto += 1
+        print(f'  {marca:>2}  {area:<12} {detalle}')
+    instalada, ultima, hay = actualiza.comprueba()
+    if ultima:
+        print(f'  {"!!" if hay else "ok":>2}  {"version":<12} {instalada}'
+              + (f' — {ultima} is out: agents-city update' if hay else ' (current)'))
+    else:
+        print(f'  {"·":>2}  {"version":<12} {instalada} (registry not checked)')
+    print()
+    if roto:
+        print(f'  {roto} thing(s) need attention.\n')
+    return 1 if roto else 0
+
+
 def main():
+    # `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
+        return informe_entorno()
     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)')

package/plugin/scripts/find-repos.sh

@@ -1,111 +1,18 @@
 #!/usr/bin/env bash
-# Index the git repos already cloned on this machine, wherever they are, and
-# cache it. One line each:  <name-on-the-remote><TAB><local-path>
+# The git half of the disk index, for the shell callers.
 #
-#   find-repos.sh            uses the cache while it is less than a day old
-#   find-repos.sh --refresh  rebuilds it
-#   find-repos.sh <repo>     prints that repo's path, or nothing
+# The scanner itself is `busca.py`: one implementation, in the language the rest
+# of the tooling already needs, so it also runs where there is no bash. This is
+# the shim that keeps `city-session.sh` and anything else in a pipeline talking
+# to it the way they always did — one line each, <name><TAB><local-path>.
 #
-# The name comes from the `origin` remote and not from the folder name, so it
-# finds the repo even when the folder is called something else — which is the
-# normal case for anybody with more than ten of them.
-#
-#   AGENTS_CITY_ORG     only index repos of this organisation. Unset = all of
-#                       them; the filter is for machines that also hold work
-#                       from somewhere else.
-#   CITY_SEARCH_IN      colon-separated roots to search instead of the defaults
-#   CITY_SEARCH_DEPTH   how deep to go under each root (default 4)
-
+#   find-repos.sh            the cache, rebuilt if it is more than a day old
+#   find-repos.sh --refresh  rebuild it now
+#   find-repos.sh <repo>     that repo's path, or nothing
 set -uo pipefail
-
-ORG="${AGENTS_CITY_ORG:-}"
-CACHE_DIR="${XDG_CACHE_HOME:-$HOME/.cache}/agents-city"
-CACHE="$CACHE_DIR/repos.tsv"
-RAICES_DEF="$HOME/codigo:$HOME/code:$HOME/dev:$HOME/src:$HOME/projects:$HOME/proyectos:$HOME/work:$HOME/trabajo:$HOME/repos:$HOME/git:$HOME/Documents:$HOME/Desktop:$HOME/Developer:$HOME"
-RAICES="${CITY_SEARCH_IN:-$RAICES_DEF}"
-PROFUNDIDAD="${CITY_SEARCH_DEPTH:-4}"
-
-construir() {
-  mkdir -p "$CACHE_DIR"
-  local tmp="$CACHE.tmp.$$"
-  : > "$tmp"
-  local vistos=""
-  local IFS=':'
-  for raiz in $RAICES; do
-    unset IFS
-    [ -d "$raiz" ] || continue
-    # Do not walk a root another one already covered.
-    case ":$vistos:" in *":$raiz:"*) continue ;; esac
-    vistos="$vistos:$raiz"
-
-    # `.git` is a directory in a normal clone and a FILE in a linked worktree —
-    # and a worktree is exactly the folder an isolated agent works in, so missing
-    # them missed the people using agents the most. Both are indexed; a worktree
-    # is named `repo@branch` so the two are distinct things to pick.
-    find "$raiz" -maxdepth "$PROFUNDIDAD" \( -type d -o -type f \) -name .git \
-      -not -path "*/node_modules/*" \
-      -not -path "*/Library/*" \
-      -not -path "*/.Trash/*" \
-      -not -path "*/vendor/*" \
-      -not -path "*/.cache/*" \
-      -not -path "*/plugins/cache/*" \
-      -not -path "*/.cargo/*" -not -path "*/.asdf/*" -not -path "*/miniconda3/*" \
-      -not -path "*/.rbenv/*" -not -path "*/.pyenv/*" -not -path "*/.nvm/*" \
-      2>/dev/null \
-    | while read -r g; do
-        repo="$(dirname "$g")"
-        url="$(git -C "$repo" remote get-url origin 2>/dev/null)" || continue
-        [ -z "$url" ] && continue
-        # git@host:org/name.git  |  https://host/org/name(.git)
-        # The version excluded by an organisation whose default was the literal
-        # "<your-org>", so the index came back empty for everybody who never set
-        # the variable. Unset now means: index what is there.
-        if [ -n "$ORG" ]; then
-          case "$url" in
-            *[:/]"$ORG"/*) ;;
-            *) continue ;;
-          esac
-        fi
-        nombre="$(basename "$url" .git)"
-        if [ -f "$g" ]; then
-          rama="$(git -C "$repo" branch --show-current 2>/dev/null)"
-          [ -z "$rama" ] && rama="$(basename "$repo")"
-          nombre="$nombre@$rama"
-        fi
-        [ -n "$nombre" ] && printf '%s\t%s\n' "$nombre" "$repo"
-      done >> "$tmp"
-    IFS=':'
-  done
-  unset IFS
-  # First one wins on a duplicate: the roots run from most specific to least.
-  sort -u -t$'\t' -k1,1 "$tmp" > "$CACHE"
-  rm -f "$tmp"
-}
-
-caduca() {
-  [ ! -f "$CACHE" ] && return 0
-  [ -n "$(find "$CACHE" -mtime +1 2>/dev/null)" ] && return 0   # older than a day
-  return 1
-}
-
+GUION="$(dirname "$0")/busca.py"
 case "${1:-}" in
-  --refresh|--refrescar)
-    echo "Looking for cloned repos…" >&2
-    construir
-    echo "$(wc -l < "$CACHE" | tr -d ' ') repos indexed in $CACHE" >&2
-    ;;
-  "")
-    caduca && construir
-    cat "$CACHE"
-    ;;
-  *)
-    caduca && construir
-    ruta="$(awk -F'\t' -v n="$1" '$1==n {print $2; exit}' "$CACHE")"
-    # Not there? It may have been cloned a minute ago: rebuild once and retry.
-    if [ -z "$ruta" ]; then
-      construir
-      ruta="$(awk -F'\t' -v n="$1" '$1==n {print $2; exit}' "$CACHE")"
-    fi
-    [ -n "$ruta" ] && printf '%s\n' "$ruta"
-    ;;
+  --refresh|--refrescar) exec python3 "$GUION" --refresh --repos ;;
+  "")                    exec python3 "$GUION" --repos ;;
+  *)                     exec python3 "$GUION" "$1" ;;
 esac

package/plugin/scripts/read-card.py

@@ -43,8 +43,12 @@ def main():
     except OSError as e:
         sys.exit(f'cannot read {ruta}: {e}')
     valor = card.campo(texto, campo)
-    # `repos` comes back as a list everywhere else; the shell wants one line.
-    print(','.join(card.lista(valor)) if campo == 'repos' else valor)
+    # 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)
 
 
 if __name__ == '__main__':

package/plugin/scripts/report.py

@@ -28,6 +28,7 @@ import sys
 import urllib.request
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import busca  # the one disk scanner, shared with the seat and the Hall
 import city_env
 import parcels  # the one reader of parcels.yml, shared with the seeder
 
@@ -49,14 +50,12 @@ def donde_esta(repo):
 
     `parcels.yml` deliberately holds no local paths: the same file is shared by a
     whole team and the same repo sits somewhere different on every machine. That is
-    what find-repos.sh is for, and it caches its index for a day.
+    what `busca` is for, and it caches its index for a day.
     """
     if repo not in _DONDE:
-        guion = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'find-repos.sh')
         try:
-            r = subprocess.run([guion, repo], capture_output=True, text=True, timeout=300)
-            _DONDE[repo] = r.stdout.strip()
-        except (OSError, subprocess.TimeoutExpired):
+            _DONDE[repo] = busca.ruta_de(repo)
+        except OSError:
             _DONDE[repo] = ''
     return _DONDE[repo]
 
@@ -142,7 +141,7 @@ def explica_vacio(di, datos, todas, por_defecto):
         di(f'{len(perdidas)} of {len(todas)} parcels are not cloned on this '
            f'machine, so there is no folder to run anything in:')
         di('  ' + ', '.join(sorted(set(perdidas))[:10]))
-        di('Clone them, or run ./plugin/scripts/find-repos.sh --refresh if they '
+        di('Clone them, or run ./plugin/scripts/busca.py --refresh if they '
            'are here under another folder name.')
     elif not por_defecto:
         di('The folders are here, but nothing says how growth is counted. Put '

package/plugin/scripts/reset.py

@@ -151,28 +151,64 @@ def reinicia(datos, usuario="", dry_run=False):
     return ctx["backup"]
 
 
+def _resuelve_todas(pedidas, usuario):
+    """Every requested city as a path, or (None, complaint).
+
+    `all` means every managed city this owner has. Names resolve one by one and
+    a single unknown name aborts the WHOLE run: resetting three of four cities
+    and then stopping on a typo is the worst possible outcome of a destructive
+    command, so nothing starts until every name is known.
+    """
+    if len(pedidas) == 1 and pedidas[0].lower() == "all":
+        todas = [c["ruta"] for c in cities.lista(usuario)]
+        if not todas:
+            return None, "there are no cities here to reset"
+        return todas, ""
+    fuera, desconocidas = [], []
+    for nombre in pedidas:
+        datos = cities.resuelve(nombre, usuario)
+        if datos:
+            if datos not in fuera:
+                fuera.append(datos)
+        else:
+            desconocidas.append(nombre)
+    if desconocidas:
+        conocidas = ", ".join(c["slug"] for c in cities.lista(usuario)) or "none"
+        return None, (f"no city called {', '.join(repr(d) for d in desconocidas)}. "
+                      f"Known here: {conocidas}. Nothing was reset.")
+    return fuera, ""
+
+
 def main():
     ap = argparse.ArgumentParser(
-        description="Reset one city to onboarding; repos stay untouched and data is backed up"
+        description="Reset cities to onboarding; repos stay untouched and data is backed up"
     )
-    ap.add_argument("city", help="city name or path (required)")
+    ap.add_argument("city", nargs="+",
+                    help="one or more city names or paths, space separated — or `all`")
     ap.add_argument("--dry-run", action="store_true", help="show every effect, change nothing")
     a = ap.parse_args()
     usuario = cities.usuario_actual()
-    datos = cities.resuelve(a.city, usuario)
-    if not datos:
-        conocidas = ", ".join(c["slug"] for c in cities.lista(usuario)) or "none"
-        print(f"  No city called {a.city!r}. Known here: {conocidas}.", file=sys.stderr)
-        return 1
-    try:
-        backup = reinicia(datos, usuario, a.dry_run)
-    except ValueError as e:
-        print(f"  {e}", file=sys.stderr)
+    objetivo, queja = _resuelve_todas(a.city, usuario)
+    if not objetivo:
+        print(f"  {queja}", file=sys.stderr)
         return 1
+    # More than one city at once is a bigger gesture than the command's name
+    # suggests, so it says out loud what it is about to do before doing it.
+    if len(objetivo) > 1 and not a.dry_run:
+        print(f"  Resetting {len(objetivo)} cities: "
+              f"{', '.join(cities.slug_ciudad(d) for d in objetivo)}")
+    for datos in objetivo:
+        try:
+            backup = reinicia(datos, usuario, a.dry_run)
+        except ValueError as e:
+            print(f"  {cities.slug_ciudad(datos)}: {e}", file=sys.stderr)
+            return 1
+        if not a.dry_run:
+            corto = backup.replace(os.path.expanduser("~"), "~")
+            print(f"  City `{cities.slug_ciudad(datos)}` reset. Recovery copy: {corto}")
     if not a.dry_run:
-        corto = backup.replace(os.path.expanduser("~"), "~")
-        print(f"  City `{cities.slug_ciudad(datos)}` reset. Recovery copy: {corto}")
-        print(f"  Run `agents-city seat --city {cities.slug_ciudad(datos)}` for onboarding.")
+        primera = cities.slug_ciudad(objetivo[0])
+        print(f"  Run `agents-city seat --city {primera}` for onboarding.")
     return 0