@andespindola/crow-skills 0.19.0 → 0.20.0

package/crow_skills/__init__.py

@@ -1,3 +1,3 @@
 """Portable, local-first installer for the crow-skills catalogue."""
 
-__version__ = "0.19.0"
+__version__ = "0.20.0"

package/crow_skills/autoupdate.py

@@ -319,6 +319,69 @@ def broken_projections(agent, home, store, rows):
     return [{"name": n, "status": "uniflow_link_modified", "fix": broken_fix(n)} for n in sorted(names)]
 
 
+
+def catalog_gap(agent, home, source, rows, projected, broken):
+    """What this agent is missing from the catalog, and whether upgrade may install it.
+
+    WHY THIS EXISTS. `upgrade` only ever touched skills already RECORDED for the agent, so a skill
+    that is new in the catalog was published and never arrived: 0.17.0 shipped crow-be-human, every
+    CLI reported "atualizadas" and `doctor` stayed healthy while the skill existed nowhere on disk.
+    A release that the command the user runs cannot deliver is not delivered.
+
+    Returns {"missing": [names], "install": [names]}. The decision is per skill and read from the
+    GROUPS, because "has everything else" is vacuous — the set of missing names is by definition
+    everything it does not have. A missing skill is installed when some group of it is otherwise
+    COMPLETE here: the user took that group wholesale, and a new member belongs to it. A skill whose
+    every group is partial was curated by hand, so it is only reported, with the command.
+    """
+    if source is None:
+        return {"missing": [], "install": []}
+    present = {r.get("name") for r in rows if r.get("name")}
+    present |= set(projected or [])
+    present |= {k.get("name") for k in (broken or []) if isinstance(k, dict) and k.get("name")}
+    missing = sorted(set(source.catalog) - present)
+    if not missing:
+        return {"missing": [], "install": []}
+    try:
+        from . import groups as groups_mod
+        available = [g for g in groups_mod.load(source) if g["name"] != groups_mod.ALL]
+    except (CrowError, OSError, ValueError, KeyError):
+        available = []
+    install = []
+    for name in missing:
+        for group in available:
+            members = [s for s in group["skills"] if s != name]
+            if name in group["skills"] and members and all(m in present for m in members):
+                install.append(name)
+                break
+    return {"missing": missing, "install": install}
+
+
+def install_new(home, entry, names, agent, dry_run, trust):
+    """Install catalog skills the agent is missing — only when it already has every other one.
+
+    The decision is read from the machine, not assumed: an agent holding the whole catalog minus the
+    new names has said "all of them", so a new skill belongs there. An agent with a SUBSET chose that
+    subset, and adding to it would be deciding for the user, so those names are only reported.
+    """
+    if not names:
+        return
+    argv = ["install", *names, "--agents", agent, "--global", "--json", "--home", str(home),
+            "--dry-run" if dry_run else "--yes"]
+    if not trust:
+        argv.append("--no-trust")
+    from .cli import parser, run as cli_run
+    try:
+        data = cli_run(parser().parse_args(argv))
+    except CrowError as exc:
+        entry["newInCatalogError"] = {"code": exc.code, "message": str(exc)}
+        return
+    done = [c["name"] for c in data.get("changes") or [] if c.get("action") != "unchanged"]
+    entry["installedNew"] = sorted(done)
+    entry["updated"] = sorted({*entry.get("updated", []), *done})
+    if data.get("transaction"):
+        entry["newTransaction"] = data["transaction"]
+
 def reinstall_behaviour(home, entry, dry_run, trust):
     """Codex without a working crow-behaviour (its projection is broken, no native copy): install it natively,
     as setup does, so the guide and hooks keep a coordinator to point to."""
@@ -402,6 +465,9 @@ def skills_update(home, trust=True, dry_run=False):
                 from . import machine
                 entry = {"agent": agent, "target": target["path"], "updated": [], "unchanged": 0, "kept": list(broken), "error": None,
                          "via_uniflow": projected}
+                gap = catalog_gap(agent, home, current, rows, projected, broken)
+                if gap["missing"]:
+                    entry["newInCatalog"] = gap["missing"]
                 if dry_run:
                     entry["dry_run"] = True
                 try:
@@ -413,6 +479,8 @@ def skills_update(home, trust=True, dry_run=False):
                     entry["error"] = {"code": exc.code, "message": str(exc)}
                 except (OSError, ValueError, KeyError, TypeError):
                     entry["error"] = {"code": "io_error", "message": "Falha de leitura/gravação; nada concluído para este agente."}
+                if gap["install"] and not entry.get("error"):
+                    install_new(home, entry, gap["install"], agent, dry_run, trust)
                 if agent == "codex" and not entry.get("error"):
                     # Ramo mais provável de quem vinha da 0.14.0: no diretório do Codex só há links do
                     # Uniflow, e TODAS as cópias do codex estão na pasta compartilhada. Sem migrar aqui,
@@ -431,6 +499,9 @@ def skills_update(home, trust=True, dry_run=False):
                 names.append(r["name"])
         entry = {"agent": agent, "target": target["path"], "updated": [], "unchanged": 0, "kept": kept + list(broken),
                  "error": None, "via_uniflow": projected}
+        gap = catalog_gap(agent, home, current, rows, projected, broken)
+        if gap["missing"]:
+            entry["newInCatalog"] = gap["missing"]
         if dry_run:
             entry["dry_run"] = True
         if agent == "codex":
@@ -462,6 +533,8 @@ def skills_update(home, trust=True, dry_run=False):
                 entry["error"] = {"code": exc.code, "message": str(exc)}
             except (OSError, ValueError, KeyError, TypeError):
                 entry["error"] = {"code": "io_error", "message": "Falha de leitura/gravação; nada concluído para este agente."}
+        if gap["install"] and not entry.get("error"):
+            install_new(home, entry, gap["install"], agent, dry_run, trust)
         if agent == "codex" and not entry.get("error"):
             # Mesma migração do setup, e pelo mesmo motivo: sem isto, uma máquina que só roda
             # autoupdate/upgrade mantém a pasta compartilhada antiga para sempre. Depois da

package/crow_skills/broadcast.py

@@ -352,6 +352,14 @@ def edit_paths(host, tool, tool_input, cwd):
 GIT_WORD = re.compile(r"^(?:\S*/)?git$")
 DIR_WORD = re.compile(r"(?:^|[\s;&|()])(?:cd|[^\s;&|()]*/?git)(?:\s|$)")
 TREE_SUBCOMMANDS = ("checkout", "switch", "rebase", "stash", "merge", "pull", "cherry-pick", "bisect", "restore", "clean")
+# A git call is not by itself a sign of working in a clone: `git log`, `git status` and `git diff`
+# are reading. Measured right after shipping occupancy(): a peer session that only INSPECTED two
+# clones was still published as occupying them, because any git verb marked the clone as driven.
+# Everything outside this list keeps marking occupancy, so an unknown verb errs toward warning.
+READ_SUBCOMMANDS = ("log", "status", "diff", "show", "rev-parse", "rev-list", "ls-tree", "ls-files",
+                    "ls-remote", "cat-file", "describe", "blame", "shortlog", "for-each-ref",
+                    "name-rev", "merge-base", "symbolic-ref", "whatchanged", "grep", "count-objects",
+                    "check-ignore", "verify-commit", "verify-tag", "var", "help", "version")
 
 
 def tree_command(host, tool, tool_input, cwd=None):
@@ -423,7 +431,7 @@ def _note(visited, directory, source="cd"):
     if visited is None or not directory or not directory.startswith("/"):
         return
     if directory in visited:
-        if source == "git":
+        if source == "git":  # working outranks reading and the incidental cd
             visited[directory] = "git"
         return
     if len(visited) < MAX_PATTERNS:
@@ -488,7 +496,8 @@ def _segment(words, here, targets, depth=0, visited=None):
     if i >= len(words):
         return here
     sub, rest = words[i], words[i + 1:]
-    _note(visited, directory, "git")  # any git call names the clone the session is working in
+    # "git" means the session WORKS in that clone; a read-only verb means it only looked.
+    _note(visited, directory, "read" if sub in READ_SUBCOMMANDS else "git")
     if sub in TREE_SUBCOMMANDS or (sub == "reset" and "--hard" in rest):
         if directory and directory not in targets:
             targets.append(directory)
@@ -703,14 +712,21 @@ def fold(snap, event, touched=(), now=None, ppid=None, cli_pid=None, tty_runner=
         repos = [r for r in repos if r["root"] != found["root"]]
         entry = {"id": found["id"], "root": found["root"], "ts": now_iso(now),
                  "hits": int((previous or {}).get("hits") or 0) + 1}
-        if (previous or {}).get("driven") or (isinstance(dirs, dict) and dirs.get(directory) == "git"):
+        source = dirs.get(directory) if isinstance(dirs, dict) else None
+        # TWO different questions about the same clone. `driven`: a git call named it, which is a
+        # stronger signal than an incidental `cd` and wins the eviction contest — a `git log` counts.
+        # `working`: the verb CHANGES something there, which is what occupancy() may warn about.
+        if (previous or {}).get("driven") or source in ("git", "read"):
             entry["driven"] = True
+        if (previous or {}).get("working") or source == "git":
+            entry["working"] = True
         repos.append(entry)
     if repos or presence.get("repos") is not None:
         # Eviction is not FIFO: a clone a git command actually drove, and one visited many times,
         # outrank the incidental `cd` that would otherwise push it out of the eight slots.
-        keep = sorted(repos, key=lambda r: (bool(r.get("driven")), int(r.get("hits") or 0),
-                                            parse_time(r.get("ts")) or 0), reverse=True)[:MAX_REPOS]
+        keep = sorted(repos, key=lambda r: (bool(r.get("working")), bool(r.get("driven")),
+                                            int(r.get("hits") or 0), parse_time(r.get("ts")) or 0),
+                      reverse=True)[:MAX_REPOS]
         presence["repos"] = [r for r in repos if r in keep]
     snap["presence"] = presence
     return snap
@@ -929,8 +945,8 @@ def occupancy(snap, now=None, window=None):
             ids.add(repo["id"])
         if repo.get("root"):
             roots.add(repo["root"])
-    for entry in presence.get("repos") or []:  # only the clones a git command drove
-        if not isinstance(entry, dict) or not entry.get("driven"):
+    for entry in presence.get("repos") or []:  # only the clones a WRITING git command drove
+        if not isinstance(entry, dict) or not entry.get("working"):
             continue
         if now - (parse_time(entry.get("ts")) or 0) > window:
             continue

package/crow_skills/machine.py

@@ -778,6 +778,17 @@ def upgrade_summary(skills, dry_run):
                                           k["name"] + " --agents " + agent + " --global --yes")
             else:
                 item["needs_user"].append(k["name"] + ": " + k["status"])
+        # Skill nova no catálogo: instalada quando o agente já tinha todas as outras, e NOMEADA com o
+        # comando quando ele tem um subconjunto escolhido. Antes disto o upgrade dizia "atualizadas" e
+        # a skill não existia em disco em lugar nenhum.
+        item["installed_new"] = s.get("installedNew") or []
+        pending = [n for n in (s.get("newInCatalog") or []) if n not in item["installed_new"]]
+        if pending:
+            item["needs_user"].append(str(len(pending)) + " skill(s) nova(s) no catálogo não instalada(s) aqui (" +
+                                      ", ".join(pending[:3]) + "); este agente tem um subconjunto escolhido. Para instalar: "
+                                      "crow-skills install " + " ".join(pending[:3]) + " --agents " + agent + " --global --yes")
+        if s.get("newInCatalogError"):
+            item["needs_user"].insert(0, "skill nova do catálogo não instalada: " + s["newInCatalogError"]["message"])
         if s.get("error"):
             item["needs_user"].insert(0, s["error"]["message"])
         item["state"] = "fail" if s.get("error") else ("warn" if item["needs_user"] else ("plan" if dry_run and (item["changed"] or item["removed"]) else "ok"))
@@ -904,9 +915,14 @@ def render_upgrade(data, stream=None):
         changed = ", ".join(item["changed"]) if len(item["changed"]) <= 3 else str(len(item["changed"])) + " skills"
         removed = ((" · " if changed else "") + str(len(item["removed"])) + (" a remover" if dry else " removidas") +
                    " (duplicavam o Uniflow)") if item.get("removed") else ""
+        fresh = item.get("installed_new") or []
+        # Dito na própria linha do CLI: uma skill nova do catálogo não é "atualizada", é instalada
+        # agora — e foi exatamente isso que faltou quando a 0.17.0 publicou a crow-be-human.
+        new_text = ((" · " if changed or removed else "") + (("instalaria " if dry else "instaladas ") +
+                    ("novas: " + ", ".join(fresh[:3]) if len(fresh) <= 3 else str(len(fresh)) + " novas"))) if fresh else ""
         rows.append([ui.mark(STATE_MARK[item["state"]], stream), item["label"],
-                     ((("a atualizar: " if dry else "atualizadas: ") + changed) if changed else ("" if removed else "sem mudanças"))
-                     + removed,
+                     ((("a atualizar: " if dry else "atualizadas: ") + changed) if changed else ("" if removed or new_text else "sem mudanças"))
+                     + removed + new_text,
                      str(item["unchanged"]), str(item.get("via_uniflow", 0)), str(len(item["kept"]))])
     if rows:
         lines.append("")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/crow-skills",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "Versioned, complementary agent skills with a protected multi-agent installer",
   "license": "UNLICENSED",
   "repository": {

package/release.json

@@ -18,7 +18,7 @@
     "crow_skills/__init__.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "7720abacfffca6315ecfee7b1dfced20c3c6e7387f00113ce2c437ed63f8e0bc"
+      "sha256": "430c470bc3c5bc90aecb240c2756f9d1d7465a1e8828c36e01451eb15b211dbd"
     },
     "crow_skills/__main__.py": {
       "executable": false,
@@ -33,12 +33,12 @@
     "crow_skills/autoupdate.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "8de4a6f3f7ce773dafb4c4f9b217d399becbd98b0b0638a80e27e13450e3a0f6"
+      "sha256": "f5a994f8eb47ed77861cf2e512d7660654ba3e8cf9381229add678180ae14e0d"
     },
     "crow_skills/broadcast.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "998cdd9bc67d52e63dfcde5528c5caaa04c509ec6e1e7d6afb298c8bcf4a442f"
+      "sha256": "135fb80925dea8e6c0790ee830c6b7e440cc5c0f116a4c9dcc4cf36bab1c22e3"
     },
     "crow_skills/cli.py": {
       "executable": false,
@@ -73,7 +73,7 @@
     "crow_skills/machine.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "8b7187afae9ad85369fdc8a918e19b32bab9d95776246cda6670a963dff19df3"
+      "sha256": "83d3f6fa0e296b4de87d90ff90ff50784241cf346bc1947ab78dd415409ebc0d"
     },
     "crow_skills/npm_entry.py": {
       "executable": false,
@@ -128,7 +128,7 @@
     "package.json": {
       "executable": false,
       "kind": "file",
-      "sha256": "b70074096ec8ed3994a6cff3eeb2b72885ec366d01269f9006d0e492fccf649a"
+      "sha256": "84ebc44ccadb19d2e6b1640994476d016c6ebef62bb0e2d79fdd14e6643f5141"
     },
     "skills/crow-accessibility/SKILL.md": {
       "executable": false,
@@ -721,7 +721,7 @@
       "sha256": "e37132ef8b060548191fbf14a5a18a9dd3acd84ea9a35e802174455b9e374d3d"
     }
   },
-  "revision": "9c7d5fe418c5c993eef7df75790263b3c77d400d",
+  "revision": "4c059d58b0bff2c5c3cfcf019667bb1ee93cd08d",
   "schema_version": 1,
-  "version": "0.19.0"
+  "version": "0.20.0"
 }