runspec 0.76.0__tar.gz → 0.76.2__tar.gz

{runspec-0.76.0 → runspec-0.76.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runspec
-Version: 0.76.0
+Version: 0.76.2
 Summary: A language-agnostic, TOML-based interface specification for anything runnable
 Author-email: Jason Finestone <jason@finestone.dev>
 Project-URL: Homepage, https://runspec.app

{runspec-0.76.0 → runspec-0.76.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "runspec"
-version = "0.76.0"
+version = "0.76.2"
 description = "A language-agnostic, TOML-based interface specification for anything runnable"
 readme = "README.md"
 license = { file = "../../LICENSE" }

{runspec-0.76.0 → runspec-0.76.2}/runspec/cli.py

@@ -1188,6 +1188,11 @@ def cmd_logs(args: list[str]) -> None:
         if verb == "view":
             if not runnable:
                 print("✗  A runnable is required: runspec logs <runnable>")
+                names = _logs.runnables_with_logs(_logs.scope_dirs(parsed.scope.value, destructive=False) or _logs.log_dirs())
+                if names:
+                    print("   Runnables with logs: " + ", ".join(names))
+                else:
+                    print("   No runnable has logs here yet.")
                 sys.exit(1)
             since = _logs.parse_duration(parsed.since.value) if parsed.since.value else None
             _logs.view(

{runspec-0.76.0 → runspec-0.76.2}/runspec/logs.py

@@ -266,7 +266,8 @@ def collect_records(
 ) -> list[tuple[dict[str, Any], str]]:
     """Merge a runnable's files into one timestamp-sorted list of (record, raw).
 
-    Filters: ``since`` (records newer than now-since), ``run`` (one run_id),
+    Filters: ``since`` (records newer than now-since), ``run`` (one run_id, or
+    a unique prefix of one — the 8 characters the text view prints are enough),
     ``user`` (every record of any run that user launched — resolved from the
     run_summary's ``extra.user``).
     """
@@ -293,6 +294,9 @@ def collect_records(
             user_of_run[extra["run_id"]] = extra.get("user", "")
         parsed.append((rec, ln))
 
+    if run:
+        run = resolve_run_id(run, (_line_extra(rec).get("run_id", "") for rec, _ in parsed), runnable)
+
     cutoff = datetime.now(timezone.utc) - since if since else None
 
     def keep(rec: dict[str, Any]) -> bool:
@@ -313,6 +317,65 @@ def collect_records(
     return parsed
 
 
+def _line_extra(rec: dict[str, Any]) -> dict[str, Any]:
+    extra = rec.get("extra")
+    return extra if isinstance(extra, dict) else {}
+
+
+def resolve_run_id(run: str, run_ids: Iterable[str], runnable: str | None = None) -> str:
+    """The full run id ``run`` names among ``run_ids``: an exact id, else the one
+    id it is a prefix of (case-insensitive, like the hex it is). Raises
+    ``ValueError`` when the prefix matches several runs (naming them) or none."""
+    ids = {rid for rid in run_ids if rid}
+    if run in ids:
+        return run
+    want = run.strip().lower()
+    matches = sorted(rid for rid in ids if want and rid.lower().startswith(want))
+    if len(matches) == 1:
+        return matches[0]
+    where = f" in {runnable}'s logs" if runnable else ""
+    if not matches:
+        raise ValueError(f"no run matching {run!r}{where}")
+    shown = ", ".join(matches[:10]) + (f" (+{len(matches) - 10} more)" if len(matches) > 10 else "")
+    raise ValueError(f"{run!r} matches {len(matches)} runs{where}: {shown} — give more of the id")
+
+
+def runnables_with_logs(dirs: Iterable[Path]) -> list[str]:
+    """Sorted names of the runnables that have log files in ``dirs`` (per-run,
+    archive or single-mode, including the inbox) — what ``runspec logs`` can show.
+
+    ``~/logs`` is shared with whatever else logs there, so a plain ``{name}.log``
+    counts only when it holds runspec records (see :func:`_is_runspec_log`);
+    per-run files and archives are known by their names."""
+    names: set[str] = set()
+    for f in _discover(dirs, None, include_inbox=True):
+        name = _runnable_of(f)
+        if name and name not in names and (_is_managed(f) or _is_runspec_log(f)):
+            names.add(name)
+    return sorted(names)
+
+
+def _is_runspec_log(path: Path, *, max_lines: int = 5) -> bool:
+    """True when one of the first ``max_lines`` lines of ``path`` is a runspec
+    JSON record — an object with ``ts``/``level``/``message`` and an
+    ``extra.run_id``, which runspec stamps on every record it writes."""
+    try:
+        with path.open("r", encoding="utf-8", errors="replace") as fh:
+            for _ in range(max_lines):
+                line = fh.readline(65536)
+                if not line:
+                    return False
+                try:
+                    rec = json.loads(line)
+                except ValueError:
+                    continue
+                if isinstance(rec, dict) and {"ts", "level", "message"} <= rec.keys() and _line_extra(rec).get("run_id"):
+                    return True
+    except OSError:
+        pass
+    return False
+
+
 def _file_run_id(name: str) -> str | None:
     from .inbox import file_run_id
 
@@ -411,6 +474,10 @@ def view(
         out.flush()
         if not follow:
             return
+        if run and records:
+            # Keep following the run the prefix named, even if a later run's id
+            # happens to share it.
+            run = _line_extra(records[0][0]).get("run_id") or run
         seen = {(r.get("ts", ""), r.get("extra", {}).get("run_id", ""), r.get("message", "")) for r, _ in records}
         while True:
             time.sleep(poll_interval)

{runspec-0.76.0 → runspec-0.76.2}/runspec/runspec.toml

@@ -276,6 +276,7 @@ autonomy    = "autonomous"
 examples = [
   {cmd = "runspec logs deploy",                          description = "Merged view of every invocation, as one stream"},
   {cmd = "runspec logs deploy --since 1h --user alice",  description = "Filter by recency and operator"},
+  {cmd = "runspec logs deploy --run 3f2a9c1e",           description = "One invocation, by the run id prefix shown after run="},
   {cmd = "runspec logs deploy --follow",                 description = "Live tail across invocations"},
   {cmd = "runspec logs deploy --json",                   description = "Raw JSON lines (for jq)"},
   {cmd = "runspec logs status",                          description = "Per-runnable file count + disk usage inventory"},
@@ -295,7 +296,7 @@ runnable       = {type = "str",  description = "Runnable to status/prune/compact
 follow         = {type = "flag", description = "Live tail across invocations (view)", short = "-f", default = false}
 since          = {type = "str",  description = "Only show records newer than this (view), e.g. 1h, 30m, 7d", required = false}
 user           = {type = "str",  description = "Only show runs launched by this user (view)", short = "-u", required = false}
-run            = {type = "str",  description = "Only show one invocation by run_id (view)", required = false}
+run            = {type = "str",  description = "Only show one invocation (view): its run id, or a unique prefix of it such as the 8 characters after run= in the output", required = false}
 json           = {type = "flag", description = "Emit JSON instead of formatted text (view / status / prune / compact / share)", default = false}
 older-than     = {type = "str",  description = "Age threshold for prune/compact, e.g. 7d, 90d, 24h", required = false}
 max-files      = {type = "int",  description = "Keep only the newest N files per runnable (prune)", required = false}

{runspec-0.76.0 → runspec-0.76.2}/runspec.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runspec
-Version: 0.76.0
+Version: 0.76.2
 Summary: A language-agnostic, TOML-based interface specification for anything runnable
 Author-email: Jason Finestone <jason@finestone.dev>
 Project-URL: Homepage, https://runspec.app

{runspec-0.76.0 → runspec-0.76.2}/tests/test_logs.py

@@ -112,6 +112,37 @@ class TestView:
         recs = logs.collect_records([tmp_path], "deploy", run=_id("r2"))
         assert [r["extra"]["run_id"] for r, _ in recs] == [_id("r2")]
 
+    def test_run_filter_accepts_the_printed_prefix(self, tmp_path):
+        _write_run(tmp_path, "deploy", "r1", "20260601T100000Z", _summary("r1", "deploy", ts="2026-06-01T10:00:00+00:00"))
+        _write_run(tmp_path, "deploy", "r2", "20260601T110000Z", _summary("r2", "deploy", ts="2026-06-01T11:00:00+00:00"))
+        recs = logs.collect_records([tmp_path], "deploy", run=_id("r2")[:8].upper())
+        assert [r["extra"]["run_id"] for r, _ in recs] == [_id("r2")]
+
+    def test_run_filter_unknown_prefix_is_an_error(self, tmp_path):
+        _write_run(tmp_path, "deploy", "r1", "20260601T100000Z", _summary("r1", "deploy", ts="2026-06-01T10:00:00+00:00"))
+        with pytest.raises(ValueError, match="no run matching 'zzzz' in deploy's logs"):
+            logs.collect_records([tmp_path], "deploy", run="zzzz")
+
+    def test_resolve_run_id(self):
+        ids = ["3f2a9c1e-aaaa", "3f2a0000-bbbb", "77777777-cccc"]
+        assert logs.resolve_run_id("77", ids) == "77777777-cccc"
+        assert logs.resolve_run_id("3f2a9", ids) == "3f2a9c1e-aaaa"
+        assert logs.resolve_run_id("3f2a0000-bbbb", ids) == "3f2a0000-bbbb"
+        with pytest.raises(ValueError, match="matches 2 runs: 3f2a0000-bbbb, 3f2a9c1e-aaaa"):
+            logs.resolve_run_id("3f2a", ids)
+
+    def test_runnables_with_logs(self, tmp_path):
+        _write_run(tmp_path, "deploy", "r1", "20260601T100000Z", _summary("r1", "deploy", ts="2026-06-01T10:00:00+00:00"))
+        _write_run(tmp_path, "backup.web", "r2", "20260601T100000Z", _summary("r2", "backup.web", ts="2026-06-01T10:00:00+00:00"))
+        (tmp_path / "single.log").write_text(_line(_id("r3"), "hi", ts="2026-06-01T10:00:00+00:00") + "\n", encoding="utf-8")
+        (tmp_path / "audit.jsonl").write_text("", encoding="utf-8")
+        # Other scripts' logs (shared ~/logs) aren't runnables: plain text, JSON
+        # without a run id, empty.
+        (tmp_path / "backup-script.log").write_text("2026-06-01 10:00 starting backup\n", encoding="utf-8")
+        (tmp_path / "other.log").write_text(json.dumps({"ts": "x", "level": "INFO", "message": "m"}) + "\n", encoding="utf-8")
+        (tmp_path / "empty.log").write_text("", encoding="utf-8")
+        assert logs.runnables_with_logs([tmp_path]) == ["backup.web", "deploy", "single"]
+
     def test_json_passthrough(self, tmp_path):
         raw = _summary(_id("r1"), "deploy", ts="2026-06-01T10:00:00+00:00")
         _write_run(tmp_path, "deploy", "r1", "20260601T100000Z", raw)