stdtel 0.2.3__py3-none-any.whl

stdtel/statusline.py

@@ -0,0 +1,101 @@
+"""A statusline that surfaces data-quality faults while they are still fixable.
+
+Wired via the `statusLine` setting. Claude Code sends session JSON on stdin,
+debounces at 300ms and **cancels an in-flight script** when a new update arrives,
+so this reads local state only — no catalogue parse in the common path, and never
+a network call.
+
+It shows faults you can act on now:
+
+  stdtel ⚠ no ticket · 2 unversioned
+  stdtel PLAT-42
+
+An unattributed branch renamed tomorrow does not retroactively attribute today's
+PRs, which is why this belongs in front of you rather than in a weekly report.
+
+**It deliberately shows no cost or token total.** The payload offers both.
+docs/for-developers.md commits to per-skill analysis rather than individual
+measurement, and a live running total of your own spend in your editor reads as
+surveillance however it is framed — and invites optimising the number rather than
+the work.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+PREFIX = "stdtel"
+
+
+def _off() -> bool:
+    if os.environ.get("STDTEL_STATUSLINE", "").strip().lower() in ("off", "0", "false", "no"):
+        return True
+    from stdtel.hooks.cli import disabled
+    return disabled()
+
+
+def _uncatalogued(state) -> int:
+    """Open skill windows whose name the catalogue does not know.
+
+    Only pays for the catalogue when there are windows to check, which keeps the
+    common render free of a PyYAML parse.
+    """
+    windows = getattr(state, "windows", None) or []
+    if not windows:
+        return 0
+    try:
+        from stdtel.hooks.cli import _catalogue, _resolve
+        cat = _catalogue()
+        return sum(1 for w in windows if _resolve(w.skill, cat)[0] is None)
+    except Exception:                             # noqa: BLE001 - never break the status bar
+        return 0
+
+
+def render(payload: dict) -> str:
+    """The line to display. Empty string when there is nothing worth saying."""
+    if _off():
+        return ""
+    try:
+        session_id = (payload or {}).get("session_id")
+        if not session_id:
+            return ""
+        from stdtel.state import SessionState
+        state = SessionState.load(str(session_id))
+    except Exception:                             # noqa: BLE001
+        return ""
+
+    ticket = (getattr(state, "resource", None) or {}).get("std.ticket.id")
+    faults = []
+    if ticket == "unattributed":
+        faults.append("no ticket")
+    n = _uncatalogued(state)
+    if n:
+        faults.append(f"{n} unversioned")
+    if getattr(state, "last_export_ok", None) is False:
+        faults.append("spans dropping")
+
+    if faults:
+        return f"{PREFIX} ⚠ " + " · ".join(faults)
+    if ticket and ticket != "unattributed":
+        return f"{PREFIX} {ticket}"
+    return ""
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Always exits 0: a broken statusline must never break the status bar."""
+    try:
+        payload = json.load(sys.stdin)
+    except Exception:                             # noqa: BLE001
+        payload = {}
+    try:
+        line = render(payload)
+    except Exception:                             # noqa: BLE001
+        line = ""
+    if line:
+        print(line)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

stdtel/transcript.py

@@ -0,0 +1,174 @@
+"""Incremental Claude Code transcript (JSONL) reader and token attribution.
+
+Attribution rule (design §4.2/§6): tokens from llm requests *after* a skill
+loaded and before the turn ends are the skill's "tail". When several skills
+load in one turn the tail is split proportionally by load order (later skills
+take the remainder after their own start), and a first-skill-only figure is
+kept as a sensitivity check.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+
+TOKEN_KEYS = ("input_tokens", "output_tokens", "cache_read_input_tokens", "cache_creation_input_tokens")
+
+
+@dataclass
+class Usage:
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_read_input_tokens: int = 0
+    cache_creation_input_tokens: int = 0
+
+    def add(self, other: dict | "Usage") -> "Usage":
+        src = other if isinstance(other, dict) else other.__dict__
+        for k in TOKEN_KEYS:
+            setattr(self, k, getattr(self, k) + int(src.get(k, 0) or 0))
+        return self
+
+    @property
+    def total(self) -> int:
+        return sum(getattr(self, k) for k in TOKEN_KEYS)
+
+    def as_attributes(self) -> dict:
+        return {f"gen_ai.usage.{k}": getattr(self, k) for k in TOKEN_KEYS}
+
+
+@dataclass
+class LlmRequest:
+    ts: float
+    model: str
+    usage: Usage
+
+
+@dataclass
+class SkillLoad:
+    ts: float
+    skill: str
+    tool_use_id: str | None
+    load_tokens: int = 0
+    caller: str = ""        # tool_use "caller.type", e.g. "direct"
+
+
+@dataclass
+class TranscriptSlice:
+    requests: list[LlmRequest] = field(default_factory=list)
+    skill_loads: list[SkillLoad] = field(default_factory=list)
+    new_offset: int = 0
+
+    def totals(self) -> Usage:
+        """Every token in the slice, whether or not a skill was loaded.
+
+        This is the denominator for cost-per-PR. Skill tail attribution only sees
+        requests after a skill loads, so a session that never loads one is
+        invisible to it — which is most sessions.
+        """
+        total = Usage()
+        for r in self.requests:
+            total.add(r.usage)
+        return total
+
+    def models(self) -> list[str]:
+        seen = []
+        for r in self.requests:
+            if r.model not in seen:
+                seen.append(r.model)
+        return seen
+
+
+def _ts(entry: dict) -> float:
+    t = entry.get("timestamp")
+    if isinstance(t, (int, float)):
+        return float(t)
+    if isinstance(t, str):
+        from datetime import datetime
+        try:
+            return datetime.fromisoformat(t.replace("Z", "+00:00")).timestamp()
+        except ValueError:
+            pass
+    return 0.0
+
+
+def read_slice(path: Path, offset: int = 0) -> TranscriptSlice:
+    """Read new JSONL lines from byte offset. Tolerates partial trailing line."""
+    out = TranscriptSlice(new_offset=offset)
+    # Path("") is ".", which *exists* as a directory: exists() let it through and
+    # open() then raised IsADirectoryError, which hooks swallow into a silent
+    # no-telemetry state. Require an actual file.
+    if not path.is_file():
+        return out
+    with path.open("rb") as f:
+        f.seek(offset)
+        data = f.read()
+    last_nl = data.rfind(b"\n")
+    if last_nl == -1:
+        return out
+    chunk, out.new_offset = data[: last_nl + 1], offset + last_nl + 1
+    for raw in chunk.splitlines():
+        if not raw.strip():
+            continue
+        try:
+            e = json.loads(raw)
+        except json.JSONDecodeError:
+            continue
+        msg = e.get("message") or {}
+        if e.get("type") == "assistant" and isinstance(msg, dict):
+            usage = msg.get("usage")
+            if usage:
+                out.requests.append(LlmRequest(ts=_ts(e), model=msg.get("model", "unknown"),
+                                               usage=Usage().add(usage)))
+            for block in msg.get("content") or []:
+                if isinstance(block, dict) and block.get("type") == "tool_use" and block.get("name") == "Skill":
+                    inp = block.get("input") or {}
+                    caller = block.get("caller")
+                    out.skill_loads.append(SkillLoad(
+                        ts=_ts(e),
+                        skill=str(inp.get("skill") or inp.get("name") or ""),
+                        tool_use_id=block.get("id"),
+                        caller=str((caller or {}).get("type") or "")))
+        elif e.get("type") == "user" and isinstance(msg, dict):
+            # tool_result for a Skill call: size of returned content approximates load tokens
+            for block in msg.get("content") or []:
+                if isinstance(block, dict) and block.get("type") == "tool_result":
+                    for sl in out.skill_loads:
+                        if sl.tool_use_id and sl.tool_use_id == block.get("tool_use_id"):
+                            content = block.get("content")
+                            text = content if isinstance(content, str) else json.dumps(content or "")
+                            sl.load_tokens = max(1, len(text) // 4)   # chars/4 heuristic
+    return out
+
+
+@dataclass
+class Attribution:
+    skill: str
+    tail: Usage
+    tail_first_only: Usage      # sensitivity check: all tokens after the *first* skill in the turn
+    models: list[str]
+    request_count: int
+
+
+def attribute(sl: TranscriptSlice) -> list[Attribution]:
+    """Assign post-load llm requests to skills in load order."""
+    loads = sorted(sl.skill_loads, key=lambda s: s.ts)
+    reqs = sorted(sl.requests, key=lambda r: r.ts)
+    results: list[Attribution] = []
+    for i, load in enumerate(loads):
+        nxt = loads[i + 1].ts if i + 1 < len(loads) else float("inf")
+        tail = Usage()
+        models: list[str] = []
+        n = 0
+        for r in reqs:
+            if load.ts <= r.ts < nxt:
+                tail.add(r.usage); n += 1
+                if r.model not in models:
+                    models.append(r.model)
+        first_only = Usage()
+        if i == 0:
+            for r in reqs:
+                if r.ts >= load.ts:
+                    first_only.add(r.usage)
+        results.append(Attribution(skill=load.skill, tail=tail, tail_first_only=first_only,
+                                   models=models, request_count=n))
+    return results

stdtel-0.2.3.dist-info/METADATA

@@ -0,0 +1,246 @@
+Metadata-Version: 2.4
+Name: stdtel
+Version: 0.2.3
+Summary: Telemetry and metadata capture for standards-as-skills (Claude Code + Copilot)
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/amiable-dev/skills-telemetry
+Project-URL: Repository, https://github.com/amiable-dev/skills-telemetry
+Project-URL: Issues, https://github.com/amiable-dev/skills-telemetry/issues
+Keywords: telemetry,opentelemetry,claude-code,copilot,skills,governance
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pyyaml>=6
+Requires-Dist: opentelemetry-sdk>=1.25
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.25
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Provides-Extra: warehouse
+Requires-Dist: psycopg[binary]>=3.1; extra == "warehouse"
+Requires-Dist: requests>=2.31; extra == "warehouse"
+
+# standards-telemetry
+
+Telemetry and metadata capture for **standards-as-skills** — attributes token cost and outcomes to
+individual skills across Claude Code and GitHub Copilot, joined to policy (OPA/Rego), delivery
+(Linear/GitHub) and quality data. Design rationale: [docs/design-proposal.md](docs/design-proposal.md).
+
+Metadata only. No prompt, response or file content is ever emitted; the collector drops it again as
+defence in depth. If it runs on your machine, [docs/for-developers.md](docs/for-developers.md) lists
+every field that leaves it — and `export STDTEL_DISABLED=1` turns it off entirely.
+
+## When can I trust these numbers?
+
+Telemetry starts producing plausible-looking ratios on day one. Most of them mean nothing yet. The
+phases below are set by **data volume, not elapsed time** — how long each takes depends entirely on
+team size, and a small team may never leave the first one.
+
+| phase | you have | what it supports | what it does not |
+|---|---|---|---|
+| **Descriptive** | anything below the floor | cost, usage, and finding data-quality faults — `unversioned` skills, `unattributed` branches | any comparison between skills, harnesses, or arms |
+| **Directional** | 30+ merged PRs per arm, 5+ developers | spotting large effects (>40%) as a hypothesis, always with an interval | point estimates, or a keep/deprecate decision |
+| **Inferential** | 150-400+ PRs per arm, depending on effect size | keep / refine / merge / deprecate decisions | detecting effects under 20%, which needs 900+ |
+
+**The hard floor: below 30 merged PRs per arm, or fewer than 5 developers, report descriptively and make no comparative claim.**
+
+Early on, the most valuable thing this data does is find its own faults. A high share of `unversioned`
+skills or `unattributed` tickets bounds every later conclusion, and both are fixable now — see
+[`stdtel-onboard`](skills/stdtel-onboard/SKILL.md) and ticket-prefixed branches.
+
+The failure mode this exists to prevent: reading a scorecard after two weeks, seeing a skill
+"underperform" across nine PRs, and deprecating it. Nine PRs cannot distinguish a bad skill from a
+quiet fortnight. Full derivations and the assumptions behind every figure:
+[docs/evaluation-power.md](docs/evaluation-power.md). Worked examples of asking these
+questions, including the ones the data cannot answer:
+[docs/insight-walkthroughs.md](docs/insight-walkthroughs.md).
+
+## Documentation
+
+| page | for |
+|---|---|
+| [docs/for-developers.md](docs/for-developers.md) | **if this runs on your machine**: exactly what is collected, and how to switch it off |
+| [docs/reference.md](docs/reference.md) | every CLI, its flags and exit codes, and the authoritative `STDTEL_*` table |
+| [docs/skills.md](docs/skills.md) | each skill and the agent — when to use, when not to, what it refuses |
+| [docs/evaluation-power.md](docs/evaluation-power.md) | how much data before a comparison means anything |
+| [docs/insight-walkthroughs.md](docs/insight-walkthroughs.md) | worked examples with real output, including the misreadings |
+| [docs/local-stack.md](docs/local-stack.md) | endpoints, credentials, the verification ladder, and how to reset |
+| [docs/adrs/](docs/adrs/) | why things are the way they are |
+
+## Layout
+
+```
+skills/<name>/SKILL.md      skill catalogue with validated front-matter (the contract)
+stdtel/manifest.py          front-matter parser + `stdtel-validate` CI gate
+stdtel/hooks/cli.py         Claude Code hooks: session-start | pre-tool-use | post-tool-use | stop
+stdtel/transcript.py        incremental JSONL reader + token attribution (tail rule, first-only sensitivity)
+stdtel/exporter.py          std.skill.invocation spans via OTLP/HTTP (content scrubbed)
+stdtel/enrich.py            join keys: std.ticket.id from branch, std.repo, std.team, std.harness
+stdtel/skillmap.py          generates collector/copilot-skill-map.yaml for Copilot tool-call mapping
+collector/otel-collector.yaml  drop content → normalise gen_ai.* → map Copilot skills → pseudonymise → spanmetrics
+deploy/docker-compose.yml   collector + Tempo + Prometheus + Grafana + Postgres; `langfuse` profile optional
+deploy/smoke.sh             eight-hop verification ladder (`mise run smoke`)
+collector/overlay-*.yaml    merged over the base config; `none` is the default no-op, `langfuse` adds an exporter
+warehouse/schema.sql        skill_invocation, session_cost, ticket, pull_request, policy_result, defect, skill_eval
+warehouse/scorecard.sql     weekly per-skill scorecard → keep / refine / review-merge / deprecate
+warehouse/load_traces.py    Tempo → Postgres loader
+eval/run_eval.py            offline with/without-skill eval, real OPA grading (`--dry-run` is a smoke test)
+eval/power.py               generates every table in docs/evaluation-power.md; CI checks it is current
+policies/                   Rego behind the primary metric: logging.*, telemetry.manifest_valid
+agents/                     skill-scorecard-analyst: keep / refine / merge / deprecate from the data
+warehouse/load_delivery.py  GitHub → ticket / pull_request / defect; policy_result from a CI artefact
+examples/settings.*.json    hook + OTel wiring: `global` installs once, `project` overrides per repo
+docs/adrs/                  six ADRs: distribution, delivery data, hook constraints, identity, integrity, Langfuse
+plugin.json                 Agent Plugins v1 manifest (portable `skills/` is the shared half)
+.claude-plugin/             Claude Code plugin + marketplace manifest
+hooks/, com.github.copilot/ per-harness hook manifests, generated from stdtel/install.py::EVENTS
+stdtel/install.py           `stdtel-install`: absolute-path resolution + settings merge
+mise.toml                   toolchain (Python 3.13) + `.venv` + tasks wrapping the Makefile
+```
+
+## Quick start
+
+Two separate jobs: **install the harness wiring once for your user**, then **onboard each project** you
+want attributed telemetry from. Skipping the second step still gives you spans — the skills just come
+through as `unversioned`, with `std.team=unknown`.
+
+### 1. Install once, globally
+
+```bash
+uv tool install stdtel        # or: pipx install stdtel
+stdtel-install settings       # merges hooks into ~/.claude/settings.json
+```
+
+> **Not published yet.** `stdtel` is not on PyPI until the first release
+> ([docs/releasing.md](docs/releasing.md)). Until then install from a checkout:
+> `uv tool install /path/to/skills-telemetry`. This matters more than it looks: the plugin's hooks
+> call a launcher that exits silently when it cannot find the CLI, so an uninstalled package produces
+> **no data and no error**. `stdtel-doctor` says so explicitly.
+
+`stdtel-install` resolves the **absolute path** of the `stdtel-hook` it was installed alongside and
+writes that into the config. This is not cosmetic: hook processes get a non-login `sh -c` and inherit
+whatever PATH launched the harness, so a bare `stdtel-hook` is unresolvable whenever a version manager
+(mise, asdf, pyenv) or an activated venv is what put it there. The same reason pre-commit bakes
+`sys.executable` into the git hook it generates. `stdtel-install where` prints the path it will use;
+`--dry-run` shows the JSON without writing.
+
+Claude Code also **strips `OTEL_*` from every subprocess it spawns**, so point the exporter at your
+collector with the `STDTEL_`-namespaced variables, which survive:
+
+```bash
+export STDTEL_OTLP_ENDPOINT=http://collector.internal:4318   # default: http://localhost:4318
+export STDTEL_OTLP_TIMEOUT=2                                 # seconds; bounds a dead-collector stall
+```
+
+With no `STDTEL_SKILLS_ROOT` set, the catalogue is read from `~/.claude/skills`. Symlink your
+standards there and every project gets versioned spans:
+
+```bash
+ln -s "$PWD/skills/structured-logging" ~/.claude/skills/structured-logging
+stdtel-validate ~/.claude/skills      # same contract gate CI runs
+```
+
+#### As a plugin
+
+The repo is laid out for three loaders at once (ADR-001), so it installs as a plugin without a
+separate packaging step:
+
+```bash
+/plugin marketplace add amiable-dev/skills-telemetry
+/plugin install stdtel@amiable-standards
+```
+
+The shipped `hooks/hooks.json` carries the bare command name, because a distributed manifest cannot
+know your install path — run `stdtel-install settings` afterwards to bind it to an absolute one.
+
+#### Copilot
+
+Copilot needs **no code from us**. It emits first-party OpenTelemetry with per-tool-call spans and
+token counts; point it at the same collector (user settings, `COPILOT_OTEL_*` env vars, or the
+enterprise `managed-settings.json` `telemetry` block for a fleet).
+
+If you do run our hooks on Copilot as well, install them from `com.github.copilot/hooks/hooks.json`,
+which sets `STDTEL_HARNESS` per hook. That is load-bearing: VS Code Copilot **reads
+`~/.claude/settings.json`**, and its snake_case payload dialect is indistinguishable from Claude
+Code's — without that env block, Copilot activity is recorded as `claude-code`.
+
+### 2. Onboard a project
+
+Per-project overrides go in `<project>/.claude/settings.json` — Claude Code merges them over the user
+file, so repeat only what differs. Do **not** repeat the `hooks` block: it is already registered globally
+and a second copy fires each hook twice.
+
+```bash
+cd ~/projects/payments-api
+mkdir -p .claude && cp ~/projects/skills-telemetry/examples/settings.project.json .claude/settings.json
+$EDITOR .claude/settings.json      # STDTEL_TEAM is the one you must set
+git checkout -b feature/PLAT-123-add-audit-log   # ticket prefix -> std.ticket.id join key
+```
+
+| variable | where | meaning |
+|---|---|---|
+| `STDTEL_TEAM` | project | owning team on every span; `unknown` until you set it |
+| `STDTEL_HARNESS_MODE` | project | `agent` / `interactive` — keeps the Claude Code vs Copilot split fair |
+| `STDTEL_SKILLS_ROOT` | project | extra catalogue root(s), `os.pathsep`-separated. A relative path resolves against the project directory; `~/.claude/skills` is always searched last, and the earliest root wins a name collision |
+| `STDTEL_HARNESS`, `OTEL_*` | global | harness label and collector endpoint |
+
+Then verify the loop end to end:
+
+```bash
+claude                                     # invoke a skill in the project
+cat ~/.stdtel/sessions/*.json              # a window with skill, version, tool_use_id
+curl -s 'http://localhost:3200/api/search?tags=name%3Dstd.skill.invocation' | jq '.traces[0]'
+```
+
+A `std.skill.version` of `unversioned` means the name in the transcript matched no `SKILL.md` in any root
+— check `STDTEL_SKILLS_ROOT` and that the skill's front-matter `name` matches what you invoked.
+
+Copilot: enable managed OTel export (VS Code / CLI) pointing at the same collector with resource attributes
+`std.harness=copilot-vscode`, `std.team=<team>`; `collector/otel-collector.yaml` maps catalogued skill
+tool-calls onto `std.skill.*`.
+
+## Span schema
+
+Two span types, emitted at `Stop`. **They overlap by design and must never be summed:**
+`std.session.cost` is the session's total spend, `std.skill.invocation` attributes a *share* of that
+total to one skill. Use session cost as the denominator for cost-per-PR; use invocation tail tokens to
+compare skills with each other.
+
+### `std.session.cost`
+
+Emitted once per turn that made any LLM request, **whether or not a skill was loaded** — a session that
+never loads a skill is still spend, and excluding it would silently understate cost per PR.
+
+| attribute | source |
+|---|---|
+| `gen_ai.usage.{input,output,cache_read_input,cache_creation_input}_tokens` | whole transcript slice |
+| `std.session.llm_requests`, `gen_ai.request.model` | transcript |
+| `std.session.tool_calls`, `std.session.tool_failures` | every tool call in the turn |
+| `std.session.tool.<name>.{calls,failures}` | per tool; `failures` omitted when zero |
+| `std.ticket.id`, `std.repo`, `std.team`, `std.harness` | resource (SessionStart) |
+
+### `std.skill.invocation`
+
+| attribute | source |
+|---|---|
+| `std.skill.name/version/trigger`, `std.standard_id`, `std.policy.ids` | hook + manifest |
+| `std.skill.invoked_as`, `std.skill.plugin` | raw invocation string (plugin skills are namespaced) |
+| `std.skill.load_tokens`, `std.skill.tail_tokens`, `std.skill.tail_tokens_first_only`, `std.skill.llm_requests` | transcript attribution |
+| `gen_ai.usage.{input,output,cache_read_input,cache_creation_input}_tokens`, `gen_ai.request.model` | transcript |
+| `std.ticket.id`, `std.repo`, `std.team`, `std.harness`, `std.harness.mode` | resource (SessionStart) |
+| `std.user.hash` | collector (pseudonymised) |
+
+## Known limitations
+
+- Tool counts are counts only. `PostToolUse` fires for **every** tool, so `tool_input` and
+  `tool_response` carry commands, file contents and diffs — `scrub()` refuses those attribute names
+  outright and a test asserts nothing leaks.
+- Skill name is parsed from the Skill tool input in hooks (the field is `skill`, verified against 120 real invocations). Parsing is isolated in `hooks/cli.py::_skill_from_payload`.
+- `std.skill.trigger` reports the transcript's `caller.type` where present, else `unknown` — it is never guessed.
+- Tail attribution splits by load order; when several skills load in one turn compare against `tail_tokens_first_only`.
+- Copilot granularity is per turn; use Claude Code's finer data for within-harness tuning only.
+- `load_tokens` uses a chars/4 heuristic on the Skill tool result.
+- `gen_ai.*` conventions are still *Development* upstream; extend `transform/normalise` as names move.

stdtel-0.2.3.dist-info/RECORD

@@ -0,0 +1,24 @@
+eval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eval/power.py,sha256=TrxW0_we9iGocQW6BboDbRuw4Tso5M8TV4eRB_lZYXM,8124
+eval/run_eval.py,sha256=5PpAdNE7C1DuyzVEwpR8p0KH8vOP8Kx_ZqzBv2S95Fg,7035
+eval/fixtures/fastapi-min/app/main.py,sha256=OrUN28lophHXcdkThQyZEqUayoBVVAByKtKx-ncJ1VA,295
+stdtel/__init__.py,sha256=P2lKoLuBR4I0Fq0zto7C5ZxCSHhKbILOSVesJsyC9jo,70
+stdtel/doctor.py,sha256=A9jXXieZ8OVZxTgihuX1VkOTKDln9jNKHYsbDgYiaI4,9294
+stdtel/enrich.py,sha256=ZDNS2p0LXEd8CAl2-vg98QWZvqIhKVtIikGdmA-qahs,2489
+stdtel/exporter.py,sha256=agux9opqr0xqa9yl3AXxVwrIoDpvO_YUq4uw89XwPNU,4833
+stdtel/install.py,sha256=FMhJ9D48aiUO9VPezFkGHpI5u-x-gYYZRdQIocDsS58,7093
+stdtel/manifest.py,sha256=YpTg6jGiiCbB2F24O-yphhrcPAKS8RgiCgtvuwc-01Q,7987
+stdtel/policy_report.py,sha256=e_niGxaTMIG4_cr3U8Z72o-QehLj3D0EpxCGoDdxI6Y,5362
+stdtel/skillmap.py,sha256=beOqxsWK97Y7RCLTAxqVKq7-fvcOMKYX3r5jqsp4zHE,568
+stdtel/spool.py,sha256=T35kDvUrhoQ659gbKGh8rfxI0UqzhBk6UW-IwOft2tY,3932
+stdtel/spool_export.py,sha256=4dp15E5I3Qsvj_EF4ZAPHliLQ9cZhqhOp1zN1wzk8MI,3195
+stdtel/state.py,sha256=beYLfy7nHX1sMHsucYWtTHATGtQ_S6JdkQxqgCgKBsY,4860
+stdtel/statusline.py,sha256=fHxwXSNo8xR5nHKk4tJj3vI2o5xk5sc8TKxNECBsado,3251
+stdtel/transcript.py,sha256=mkxXqHfb9VCMvXlVRiTfC5EUulze9uBnfMmqTECrPS0,6254
+stdtel/hooks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stdtel/hooks/cli.py,sha256=EKC0goOpliSgneapMRTzA4a7KwEcX2Xtejcx5zQ_Z7Q,13233
+stdtel-0.2.3.dist-info/METADATA,sha256=N5DY1fhj8cYk5Nz1FX_3Y8j3Df96U0A5Z8wCquPICRg,14568
+stdtel-0.2.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+stdtel-0.2.3.dist-info/entry_points.txt,sha256=tk3APT1LKC73AkH7jR9gME0LLnv9r2YiYB6akEA9rac,330
+stdtel-0.2.3.dist-info/top_level.txt,sha256=prBM2zwjJr9B3uMWyJJNLPWLqTDEwOxYkwcie3i637w,12
+stdtel-0.2.3.dist-info/RECORD,,

stdtel-0.2.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

stdtel-0.2.3.dist-info/entry_points.txt

@@ -0,0 +1,9 @@
+[console_scripts]
+stdtel-doctor = stdtel.doctor:main
+stdtel-eval = eval.run_eval:main
+stdtel-export = stdtel.spool_export:main
+stdtel-hook = stdtel.hooks.cli:main
+stdtel-install = stdtel.install:main
+stdtel-policy-report = stdtel.policy_report:main
+stdtel-statusline = stdtel.statusline:main
+stdtel-validate = stdtel.manifest:cli

stdtel-0.2.3.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+eval
+stdtel