lab-kit-cli 0.1.0__py3-none-any.whl

lab_kit/commands/setup.py

@@ -0,0 +1,126 @@
+"""`lab-kit init`: lab.yaml, ops/, experiments/, .lab/, the skills and the agent roles, and the lab pack on.
+
+Before a folio library exists, `lab-kit init` installs only the method, the skills and the roles,
+so the set-up-lab skill is there to read: it creates the library and runs `lab-kit init --library` again.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+from pathlib import Path
+
+from folio import library as folio_library
+from folio.commands.charter_cmds import pack_on
+from folio.errors import FolioError
+
+from .. import __version__, data
+from ..errors import LabError
+from ..frozen import FROZEN
+from ..lab import LAB_YAML
+from ..ops import MISSIONS, STATE
+
+_LAB_YAML = """\
+lab-kit: {version}               # the version this lab is checked with
+library: {library}                # where folio.yaml is; "." for the root
+front:                       # the front door's id: a project document
+frozen: []                   # surfaces never edited in place; record each with `lab-kit freeze`
+tools: []                    # lab-wide scripts; each must pass --selftest
+rederive_timeout: 120        # seconds per re-derive command
+"""
+
+_STATE = """\
+# State
+
+Active mission: none
+
+Next: the operator's first objective, planned through the plan-mission skill.
+"""
+
+
+def _link(root: Path, link: str, wanted: str) -> list[str]:
+    path = root / link
+    if path.is_symlink():
+        if os.readlink(path) != wanted:
+            raise LabError(f"{link} links to {os.readlink(path)}, not {wanted}; move it aside first")
+        return []
+    if path.exists():
+        raise LabError(f"{link} exists and is not a link to {wanted}; move it aside first")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.symlink_to(wanted)
+    return [f"linked {link} -> {wanted}"]
+
+
+def install(root: Path) -> list[str]:
+    """Copy the method, the skills and the roles into the lab, as this version ships them."""
+    changed: list[str] = []
+    for src, dest in data.shipped_files():
+        target = root / dest
+        if target.is_file() and target.read_bytes() == src.read_bytes():
+            continue
+        existed = target.exists()
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(src, target)
+        changed.append(f"{'updated' if existed else 'created'} {dest}")
+    changed.extend(_link(root, ".claude/skills", os.path.join("..", ".agents", "skills")))
+    changed.extend(_link(root, ".claude/agents", os.path.join("..", ".agents", "agents")))
+    return changed
+
+
+def _write_new(root: Path, rel: str, text: str) -> list[str]:
+    path = root / rel
+    if path.exists():
+        return []
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text, encoding="utf-8")
+    return [f"created {rel}"]
+
+
+SKILLS_ONLY = ("No folio library here yet: installed lab-kit's method, skills and roles only. "
+               "Next: read .agents/skills/set-up-lab/SKILL.md and follow it.")
+
+
+def init(root: Path, library: str | None) -> list[str]:
+    root = root.resolve()
+    existing = root / LAB_YAML
+    changed: list[str] = []
+    if library is None and not existing.is_file() and not (root / "folio.yaml").is_file():
+        return install(root) + [SKILLS_ONLY]
+    library = library or "."
+    if existing.is_file():
+        text = existing.read_text(encoding="utf-8")
+        updated = re.sub(r"(?m)^lab-kit:\s*\S+", f"lab-kit: {__version__}", text, count=1)
+        if updated != text:
+            existing.write_text(updated, encoding="utf-8")
+            changed.append(f"updated {LAB_YAML}: lab-kit {__version__}")
+        library = _library_of(updated)
+    lib_dir = (root / library).resolve()
+    if not (lib_dir / "folio.yaml").is_file():
+        raise LabError(f"`{library}` holds no folio.yaml; set the library up with folio first")
+    try:
+        lib = folio_library.load_at(lib_dir)
+    except FolioError as exc:
+        raise LabError(f"the library in `{library}` does not load: {exc}") from exc
+    if lib.charter.root_dir != root:
+        depth = len(lib_dir.relative_to(root).parts)
+        raise LabError(f"{library}/folio.yaml: `root` resolves to {lib.charter.root_dir}, not the lab root; "
+                       f"run `folio config set root {'/'.join(['..'] * depth) or '.'}` in the library first")
+    if not existing.is_file():
+        changed.extend(_write_new(root, LAB_YAML, _LAB_YAML.format(version=__version__, library=library)))
+    changed.extend(_write_new(root, STATE, _STATE))
+    changed.extend(_write_new(root, f"{MISSIONS}/.gitkeep", ""))
+    changed.extend(_write_new(root, "experiments/.gitkeep", ""))
+    changed.extend(_write_new(root, FROZEN, ""))
+    changed.extend(install(root))
+    if "lab" not in lib.charter.pack_names:
+        lines = pack_on(lib, "lab").splitlines()
+        changed.extend(f"{line} (in {library})" if library not in (".", "") else line for line in lines)
+    return changed
+
+
+def _library_of(text: str) -> str:
+    match = re.search(r"(?m)^library:\s*(\S+)", text)
+    if match is None:
+        raise LabError(f"{LAB_YAML} names no `library`")
+    return match.group(1)

lab_kit/commands/status.py

@@ -0,0 +1,26 @@
+"""`lab-kit status`: the state, the active mission, live and orphaned runs, and protocols by status."""
+
+from __future__ import annotations
+
+from .. import ops, records
+from ..lab import Lab
+
+
+def status(lab: Lab) -> list[str]:
+    lines: list[str] = []
+    state = lab.root / ops.STATE
+    if state.is_file():
+        text = state.read_text(encoding="utf-8")
+        lines.append(f"Active mission: {ops.active_mission(text) or 'not named in ' + ops.STATE}")
+        lines.append(f"State ({ops.STATE}):")
+        lines.extend("  " + line for line in text.strip().splitlines())
+    else:
+        lines.append(f"No {ops.STATE}.")
+    live = [r for r in records.runs(lab) if r.state in ("running", "orphaned")]
+    lines.append("Live and orphaned runs:" if live else "Live and orphaned runs: none")
+    lines.extend(f"  {r.slug}/{r.run_id}  {r.state}  started {r.data.get('started')}" for r in live)
+    protocols = [d for d in lab.library().documents if d.is_a("protocol")]
+    for wanted in ("draft", "locked"):
+        found = sorted(d.id for d in protocols if d.status == wanted)
+        lines.append(f"Protocols {wanted}: {', '.join(found) if found else 'none'}")
+    return lines

lab_kit/data.py

@@ -0,0 +1,49 @@
+"""Where lab-kit's shipped method, skills and agent roles live."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .errors import LabError
+
+SKILLS = ("set-up-lab", "plan-mission", "run-mission", "experiment", "review")
+AGENTS = ("scout", "runner", "reviewer", "reporter")
+METHOD = ("DISCIPLINE.md", "LADDER.md")
+
+
+def data_root() -> Path:
+    """The folder holding `method/`, `skills/` and `agents/`.
+
+    An installed wheel carries them in `lab_kit/_data/`; a source checkout has
+    them at the repository root, two levels above this package.
+    """
+    packaged = Path(__file__).resolve().parent / "_data"
+    if (packaged / "method").is_dir():
+        return packaged
+    checkout = Path(__file__).resolve().parents[2]
+    if (checkout / "method").is_dir():
+        return checkout
+    raise LabError(f"cannot find lab-kit's shipped method: looked in {packaged} and {checkout}")
+
+
+def shipped(name: str) -> Path:
+    if name not in ("method", "skills", "agents"):
+        raise ValueError(name)
+    return data_root() / name
+
+
+def shipped_files() -> list[tuple[Path, str]]:
+    """Every shipped file a lab carries, as (source, path in the lab from its root)."""
+    out: list[tuple[Path, str]] = []
+    for name in METHOD:
+        out.append((shipped("method") / name, f".lab/method/{name}"))
+    for skill in SKILLS:
+        folder = shipped("skills") / skill
+        for src in sorted(p for p in folder.rglob("*") if p.is_file()):
+            out.append((src, f".agents/skills/{skill}/{src.relative_to(folder).as_posix()}"))
+    for agent in AGENTS:
+        out.append((shipped("agents") / f"{agent}.md", f".agents/agents/{agent}.md"))
+    for src, _ in out:
+        if not src.is_file():
+            raise LabError(f"lab-kit's shipped file {src} is missing")
+    return out

lab_kit/errors.py

@@ -0,0 +1,2 @@
+class LabError(Exception):
+    """A problem lab-kit cannot work around. The command line prints it and exits 2."""

lab_kit/frozen.py

@@ -0,0 +1,48 @@
+"""Frozen surfaces: the hashes `lab-kit freeze` records in `.lab/frozen.sha256`."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from . import records
+from .errors import LabError
+from .lab import Lab
+
+FROZEN = ".lab/frozen.sha256"
+
+
+def surface_hashes(lab: Lab, surface: str) -> dict[str, str]:
+    """Every file of a surface (a file, or a folder and all it holds), by its path from the lab root."""
+    target = lab.root / surface
+    if not target.exists():
+        raise LabError(f"frozen surface `{surface}` does not exist")
+    return records.tree_hashes(target, lab.root)
+
+
+def belongs(path: str, surface: str) -> bool:
+    surface = surface.rstrip("/")
+    return path == surface or path.startswith(surface + "/")
+
+
+def recorded(lab: Lab) -> dict[str, str]:
+    path = lab.root / FROZEN
+    if not path.is_file():
+        return {}
+    return records.parse_hashes(path.read_text(encoding="utf-8"), FROZEN)
+
+
+def freeze(lab: Lab, surface: str) -> list[str]:
+    """Record a surface's hashes, replacing what was recorded for it before."""
+    surface = Path(surface).as_posix().rstrip("/")
+    listed = [s.rstrip("/") for s in lab.settings.frozen]
+    if surface not in listed:
+        raise LabError(f"`{surface}` is not listed under `frozen:` in lab.yaml; list it there first")
+    hashes = surface_hashes(lab, surface)
+    if not hashes:
+        raise LabError(f"frozen surface `{surface}` holds no file")
+    kept = {p: d for p, d in recorded(lab).items() if not belongs(p, surface)}
+    kept.update(hashes)
+    out = lab.root / FROZEN
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(records.format_hashes(kept), encoding="utf-8")
+    return [f"updated {FROZEN}: recorded {len(hashes)} file(s) of {surface}"]

lab_kit/gitlog.py

@@ -0,0 +1,55 @@
+"""Read the history of a lab file from git: each committed version, oldest first, then the working tree."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+from .errors import LabError
+
+WORKING = "working tree"
+
+
+def _git(root: Path, *args: str, check: bool = True) -> subprocess.CompletedProcess[str]:
+    result = subprocess.run(["git", "-C", str(root), *args], capture_output=True, text=True, check=False)
+    if check and result.returncode != 0:
+        raise LabError(f"git {' '.join(args)} failed: {result.stderr.strip()}")
+    return result
+
+
+def in_git(root: Path) -> bool:
+    if shutil.which("git") is None:
+        return False
+    return _git(root, "rev-parse", "--is-inside-work-tree", check=False).stdout.strip() == "true"
+
+
+def _has_head(root: Path) -> bool:
+    return _git(root, "rev-parse", "--verify", "-q", "HEAD", check=False).returncode == 0
+
+
+def tracked(root: Path, folder: str) -> list[str]:
+    """Every path under `folder` that any commit touched, from `root`, including deleted ones."""
+    if not _has_head(root):
+        return []
+    out = _git(root, "log", "--format=", "--name-only", "--relative", "--", folder).stdout
+    return sorted({line.strip() for line in out.splitlines() if line.strip()})
+
+
+def versions(root: Path, path: str) -> list[tuple[str, str | None]]:
+    """(commit, text) for every commit that touched `path`, oldest first, then the working tree if it differs.
+
+    The text is None where the file did not exist.
+    """
+    out: list[tuple[str, str | None]] = []
+    if _has_head(root):
+        shas = _git(root, "log", "--format=%H", "--", path).stdout.split()
+        for sha in reversed(shas):
+            shown = _git(root, "show", f"{sha}:./{path}", check=False)
+            out.append((sha, shown.stdout if shown.returncode == 0 else None))
+    target = root / path
+    now = target.read_text(encoding="utf-8") if target.is_file() else None
+    if not out or out[-1][1] != now:
+        if out or now is not None:
+            out.append((WORKING, now))
+    return out

lab_kit/lab.py

@@ -0,0 +1,135 @@
+"""A lab: its root, its settings in `lab.yaml`, and the folio library beside them."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+from folio import library as folio_library
+from folio.errors import FolioError
+from folio.library import Library
+
+from .errors import LabError
+
+LAB_YAML = "lab.yaml"
+_KEYS = ("lab-kit", "library", "front", "frozen", "tools", "rederive_timeout")
+
+
+@dataclass
+class Settings:
+    version: str
+    library: str
+    front: str | None
+    frozen: list[str]
+    tools: list[str]
+    rederive_timeout: int
+
+
+@dataclass
+class Lab:
+    root: Path
+    settings: Settings
+    cache: dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def library_dir(self) -> Path:
+        return (self.root / self.settings.library).resolve()
+
+    def library(self) -> Library:
+        """The folio library, loaded once. Its charter's `root` must be the lab root."""
+        if "library" not in self.cache:
+            try:
+                lib = folio_library.load_at(self.library_dir)
+            except FolioError as exc:
+                raise LabError(f"the library in `{self.settings.library}` does not load: {exc}") from exc
+            if lib.charter.root_dir != self.root:
+                raise LabError(
+                    f"{self.settings.library}/folio.yaml: `root` resolves to {lib.charter.root_dir}, not the lab "
+                    f"root {self.root}; set it with `folio config set root {_relative_root(self)}` in the library")
+            self.cache["library"] = lib
+        return self.cache["library"]
+
+    def reload(self) -> Library:
+        self.cache.pop("library", None)
+        return self.library()
+
+    def rel(self, path: Path) -> str:
+        """A path from the lab root, with forward slashes."""
+        return path.resolve().relative_to(self.root).as_posix()
+
+    def doc_path(self, doc_file_path: str) -> str:
+        """A library file's path from the lab root."""
+        if self.settings.library in (".", ""):
+            return doc_file_path
+        return f"{Path(self.settings.library).as_posix().rstrip('/')}/{doc_file_path}"
+
+    @property
+    def experiments(self) -> Path:
+        return self.root / "experiments"
+
+    def experiment_slugs(self) -> list[str]:
+        if not self.experiments.is_dir():
+            return []
+        return sorted(p.name for p in self.experiments.iterdir() if p.is_dir() and not p.name.startswith("."))
+
+
+def _relative_root(lab: Lab) -> str:
+    depth = len(Path(lab.settings.library).parts)
+    return "/".join([".."] * depth) or "."
+
+
+def find_root(start: Path) -> Path:
+    here = start.resolve()
+    for folder in (here, *here.parents):
+        if (folder / LAB_YAML).is_file():
+            return folder
+    raise LabError(f"no {LAB_YAML} at or above {here}; run `lab-kit init` in the lab's root first")
+
+
+def parse_settings(raw: Any, where: str) -> Settings:
+    if not isinstance(raw, dict):
+        raise LabError(f"{where}: must be a mapping")
+    unknown = sorted(set(raw) - set(_KEYS))
+    if unknown:
+        raise LabError(f"{where}: unknown key(s) {', '.join(unknown)}; the keys are {', '.join(_KEYS)}")
+    version = raw.get("lab-kit")
+    if not isinstance(version, str) or not version:
+        raise LabError(f"{where}: `lab-kit` must name the version this lab is checked with, as a string")
+    library = raw.get("library")
+    if not isinstance(library, str) or not library:
+        raise LabError(f"{where}: `library` must name the folder holding folio.yaml (\".\" for the root)")
+    front = raw.get("front")
+    if front is not None and not isinstance(front, str):
+        raise LabError(f"{where}: `front` must be a document id")
+    lists = {}
+    for key in ("frozen", "tools"):
+        value = raw.get(key) or []
+        if not isinstance(value, list) or not all(isinstance(v, str) and v for v in value):
+            raise LabError(f"{where}: `{key}` must be a list of paths from the lab root")
+        for v in value:
+            if Path(v).is_absolute() or ".." in Path(v).parts:
+                raise LabError(f"{where}: `{key}` path `{v}` must stay inside the lab")
+        lists[key] = value
+    timeout = raw.get("rederive_timeout", 120)
+    if not isinstance(timeout, int) or isinstance(timeout, bool) or timeout <= 0:
+        raise LabError(f"{where}: `rederive_timeout` must be a positive whole number of seconds")
+    return Settings(version, library, front or None, lists["frozen"], lists["tools"], timeout)
+
+
+def load_at(root: Path) -> Lab:
+    root = root.resolve()
+    path = root / LAB_YAML
+    try:
+        raw = yaml.safe_load(path.read_text(encoding="utf-8"))
+    except yaml.YAMLError as exc:
+        raise LabError(f"{LAB_YAML}: not valid YAML: {exc}") from exc
+    lab = Lab(root, parse_settings(raw, LAB_YAML))
+    if not (lab.library_dir / "folio.yaml").is_file():
+        raise LabError(f"{LAB_YAML}: `library: {lab.settings.library}` holds no folio.yaml")
+    return lab
+
+
+def load(start: Path) -> Lab:
+    return load_at(find_root(start))

lab_kit/ops.py

@@ -0,0 +1,94 @@
+"""The operator's files: `ops/STATE.md` and the missions under `ops/missions/`."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from folio.errors import FolioError
+from folio.frontmatter import split
+
+from .errors import LabError
+from .lab import Lab
+
+STATE = "ops/STATE.md"
+MISSIONS = "ops/missions"
+LOG_HEADING = re.compile(r"^## Log[ \t]*$", re.M)
+ACTIVE = re.compile(r"^\s*Active mission:\s*(.+?)\s*$", re.M | re.I)
+
+
+@dataclass
+class Mission:
+    path: str  # from the lab root
+    meta: dict[str, Any]
+    text: str
+
+    @property
+    def cap(self) -> float | None:
+        cap = self.meta.get("cap")
+        if isinstance(cap, (int, float)) and not isinstance(cap, bool):
+            return float(cap)
+        return None
+
+    @property
+    def approved(self) -> str:
+        return str(self.meta.get("approved") or "").strip()
+
+    @property
+    def status(self) -> str:
+        return str(self.meta.get("status") or "").strip()
+
+    def approval_problem(self) -> str | None:
+        """Why this mission may not run, or None when it is approved and active."""
+        if self.status == "draft":
+            return (f"{self.path} is a draft: nothing runs under a mission until the operator approves it "
+                    "(the plan-mission skill records `approved` and sets `status: active`)")
+        if self.status != "active":
+            return f"{self.path} has status `{self.status or '(none)'}`, not `active`: a run needs an active mission"
+        if not approved_names_a_date(self.approved):
+            return f"{self.path} records no approval with who and when (`approved:`); nothing runs before it"
+        return None
+
+
+STATUSES = ("draft", "active", "concluded")
+DATE = re.compile(r"\b\d{4}-\d{2}-\d{2}\b")
+
+
+def approved_names_a_date(approved: str) -> bool:
+    """`approved` says who and when: some words, and a date as YYYY-MM-DD."""
+    return bool(DATE.search(approved)) and bool(DATE.sub("", approved).strip(" ,;:.-"))
+
+
+def mission_files(lab: Lab) -> list[Path]:
+    folder = lab.root / MISSIONS
+    return sorted(folder.glob("*.md")) if folder.is_dir() else []
+
+
+def read_mission(lab: Lab, path: Path) -> Mission:
+    where = lab.rel(path)
+    text = path.read_text(encoding="utf-8")
+    try:
+        meta, _ = split(text, where)
+    except FolioError as exc:
+        raise LabError(str(exc)) from exc
+    return Mission(where, meta or {}, text)
+
+
+def log_of(text: str) -> str | None:
+    """The mission log: everything after the `## Log` heading, or None without one."""
+    match = LOG_HEADING.search(text)
+    return text[match.end():] if match else None
+
+
+def active_mission(text: str) -> str | None:
+    """What `Active mission:` names in the state file: a path, `none`, or None when the line is missing."""
+    match = ACTIVE.search(text)
+    if match is None:
+        return None
+    value = match.group(1).strip().strip("`*")
+    link = re.match(r"^\[[^\]]*\]\(([^)]+)\)$", value)
+    if link:
+        value = link.group(1)
+    return value.strip("`")

lab_kit/protocol.py

@@ -0,0 +1,100 @@
+"""A protocol as lab-kit reads it: its file, status, hash with the status set aside, pins and ids."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+from folio.documents import Document
+from folio.frontmatter import front_block, sections, split
+from folio.errors import FolioError
+
+from .errors import LabError
+from .lab import Lab
+
+_STATUS_LINE = re.compile(r"^status:[^\n]*\n?", re.M)
+_ITEM_ID = re.compile(r"^\s*[-*]\s+([PD]\d+)\b", re.M)
+_YAML_FENCE = re.compile(r"^(```|~~~)\s*ya?ml\s*\n(.*?)^\1\s*$", re.S | re.M)
+
+CONFIG_HEADING = "Pinned configuration"
+PREDICTIONS_HEADING = "Predictions"
+RULES_HEADING = "Decision rules"
+
+
+@dataclass
+class Protocol:
+    slug: str
+    doc: Document
+    path: str  # from the lab root
+    abspath: Path
+
+    @property
+    def status(self) -> str:
+        return self.doc.status
+
+    def text(self) -> str:
+        return self.abspath.read_text(encoding="utf-8")
+
+
+def find(lab: Lab, slug: str) -> Protocol | None:
+    docs = lab.library().find(slug, "protocol")
+    if not docs:
+        return None
+    doc = docs[0]
+    main = doc.main
+    if main is None:
+        return None
+    return Protocol(doc.id, doc, lab.doc_path(main.path), main.abspath)
+
+
+def require(lab: Lab, slug: str) -> Protocol:
+    proto = find(lab, slug)
+    if proto is None:
+        raise LabError(f"no protocol `{slug}` in the library; draft it with folio's write skill first")
+    return proto
+
+
+def hash_text(text: str) -> str:
+    """The sha256 of a protocol's text with its front matter's `status` line set aside."""
+    span = front_block(text)
+    if span is not None:
+        start, end = span
+        text = text[:start] + _STATUS_LINE.sub("", text[start:end]) + text[end:]
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def _section(text: str, heading: str, where: str) -> str:
+    try:
+        _, body = split(text, where)
+    except FolioError as exc:
+        raise LabError(str(exc)) from exc
+    for name, content in sections(body):
+        if name.strip() == heading:
+            return content
+    raise LabError(f"{where}: has no `## {heading}` section")
+
+
+def pinned_config(text: str, where: str) -> Any:
+    """The parsed `yaml` block under `## Pinned configuration`."""
+    blocks = _YAML_FENCE.findall(_section(text, CONFIG_HEADING, where))
+    if len(blocks) != 1:
+        raise LabError(f"{where}: `## {CONFIG_HEADING}` must hold exactly one fenced yaml block")
+    try:
+        return yaml.safe_load(blocks[0][1])
+    except yaml.YAMLError as exc:
+        raise LabError(f"{where}: the pinned configuration is not valid YAML: {exc}") from exc
+
+
+def scored_ids(text: str, where: str) -> list[str]:
+    """The prediction ids (`P1`...) and decision-rule ids (`D1`...) the protocol names, in order."""
+    found: list[str] = []
+    for heading, prefix in ((PREDICTIONS_HEADING, "P"), (RULES_HEADING, "D")):
+        ids = [i for i in _ITEM_ID.findall(_section(text, heading, where)) if i.startswith(prefix)]
+        if not ids:
+            raise LabError(f"{where}: `## {heading}` names no {prefix}-id")
+        found.extend(ids)
+    return found