timing-cli 0.1.0__py3-none-any.whl

timing_cli/serve.py

@@ -0,0 +1,207 @@
+"""FastMCP server exposing the local Timing database to agents.
+
+The server runs on the machine where the Timing database lives, so agents (e.g.
+the Hermes personal agent) can query real local app usage and push time entries
+WITHOUT ever copying or sharing the raw ``SQLite.db``.
+
+Run it via ``timing serve`` (stdio by default, or ``--transport http``).
+"""
+
+from __future__ import annotations
+
+import secrets
+from datetime import date, datetime, time, timedelta
+from typing import Any
+
+from fastmcp import FastMCP
+from fastmcp.server.auth import AccessToken, TokenVerifier
+
+from timing_cli.analysis import aggregate, summarize_by_project
+from timing_cli.api import TimingApiClient, TimingApiError
+from timing_cli.config import load_config
+from timing_cli.db import (
+    date_range,
+    list_app_usage,
+    list_projects,
+    list_timing_predicate_rules,
+    open_db,
+)
+from timing_cli.rules import Classifier
+
+mcp: FastMCP = FastMCP("timing-cli")
+
+
+class StaticBearerTokenVerifier(TokenVerifier):
+    """Validate MCP HTTP requests against one configured bearer token."""
+
+    def __init__(self, token: str) -> None:
+        super().__init__()
+        self._token = token
+
+    async def verify_token(self, token: str) -> AccessToken | None:
+        if not secrets.compare_digest(token, self._token):
+            return None
+        return AccessToken(
+            token=token,
+            client_id="timing-cli-local",
+            scopes=[],
+            expires_at=None,
+        )
+
+
+def _day_window(day: str | None) -> tuple[datetime, datetime]:
+    d = date.fromisoformat(day) if day else date.today()
+    start = datetime.combine(d, time.min).astimezone()
+    return start, start + timedelta(days=1)
+
+
+def _window(day: str | None, start: str | None, end: str | None) -> tuple[datetime, datetime]:
+    if start or end:
+        lo = datetime.fromisoformat(start).astimezone() if start else _day_window(day)[0]
+        hi = datetime.fromisoformat(end).astimezone() if end else datetime.now().astimezone()
+        return lo, hi
+    return _day_window(day)
+
+
+@mcp.tool
+def list_timing_projects(include_archived: bool = False) -> list[dict[str, Any]]:
+    """List Timing projects from the local database."""
+    cfg = load_config()
+    with open_db(cfg.db_path) as conn:
+        projects = list_projects(conn, include_archived=include_archived)
+    return [p.model_dump() for p in projects]
+
+
+@mcp.tool
+def list_app_usage_tool(
+    day: str | None = None,
+    start: str | None = None,
+    end: str | None = None,
+    project_id: int | None = None,
+) -> list[dict[str, Any]]:
+    """Return raw automatically tracked app usage for a local day or window.
+
+    Provide either ``day`` (YYYY-MM-DD, defaults to today) or an explicit
+    ``start``/``end`` ISO-8601 window.
+    """
+    cfg = load_config()
+    lo, hi = _window(day, start, end)
+    with open_db(cfg.db_path) as conn:
+        slices = list_app_usage(conn, lo, hi, project_id=project_id)
+    return [s.model_dump(mode="json") for s in slices]
+
+
+@mcp.tool
+def daily_project_summary(
+    day: str | None = None,
+    include_unassigned: bool = True,
+) -> list[dict[str, Any]]:
+    """Total tracked time per project for a local day (defaults to today)."""
+    cfg = load_config()
+    lo, hi = _day_window(day)
+    with open_db(cfg.db_path) as conn:
+        slices = list_app_usage(conn, lo, hi)
+        timing_rules = list_timing_predicate_rules(conn)
+    classifier = Classifier(cfg.rules, timing_rules=timing_rules)
+    summaries = summarize_by_project(slices, classifier, include_unassigned=include_unassigned)
+    return [s.model_dump() for s in summaries]
+
+
+@mcp.tool
+def suggest_time_entries(
+    day: str | None = None,
+    start: str | None = None,
+    end: str | None = None,
+    include_unassigned: bool = False,
+) -> list[dict[str, Any]]:
+    """Aggregate app usage into suggested time entries. Read-only (does not write)."""
+    cfg = load_config()
+    lo, hi = _window(day, start, end)
+    with open_db(cfg.db_path) as conn:
+        slices = list_app_usage(conn, lo, hi)
+        timing_rules = list_timing_predicate_rules(conn)
+    classifier = Classifier(cfg.rules, timing_rules=timing_rules)
+    suggestions = aggregate(
+        slices,
+        classifier,
+        min_block_seconds=cfg.min_block_seconds,
+        gap_merge_seconds=cfg.gap_merge_seconds,
+        include_unassigned=include_unassigned,
+    )
+    return [s.model_dump(mode="json") for s in suggestions]
+
+
+@mcp.tool
+def create_time_entry(
+    start: str,
+    end: str,
+    title: str,
+    project_title: str | None = None,
+    notes: str = "",
+    replace_existing: bool = False,
+) -> dict[str, Any]:
+    """Create a single time entry via the Timing Web API (write operation).
+
+    ``start``/``end`` are ISO-8601 datetimes. When ``project_title`` is given it
+    must resolve to one unique Web-API project, optionally through
+    ``project_mappings`` in the config.
+    """
+    try:
+        cfg = load_config()
+        lo = datetime.fromisoformat(start).astimezone()
+        hi = datetime.fromisoformat(end).astimezone()
+        if hi <= lo:
+            return {"error": "end must be after start"}
+        with TimingApiClient(cfg.api_base_url, cfg.resolved_token()) as client:
+            project_ref = None
+            if project_title:
+                project_ref = client.resolve_project_ref(
+                    project_title,
+                    title_chain=[project_title],
+                    overrides=cfg.project_mappings,
+                )
+                if project_ref is None:
+                    return {"error": f"Could not map Timing project '{project_title}'"}
+            return client.create_time_entry(
+                start=lo,
+                end=hi,
+                project_ref=project_ref,
+                title=title,
+                notes=notes,
+                replace_existing=replace_existing,
+            )
+    except (TimingApiError, ValueError) as exc:
+        return {"error": str(exc)}
+
+
+@mcp.tool
+def recorded_date_range() -> dict[str, str] | None:
+    """Return the earliest and latest recorded activity timestamps."""
+    cfg = load_config()
+    with open_db(cfg.db_path) as conn:
+        rng = date_range(conn)
+    if rng is None:
+        return None
+    return {"start": rng[0].isoformat(), "end": rng[1].isoformat()}
+
+
+def run_server(transport: str = "stdio", host: str = "127.0.0.1", port: int = 8321) -> None:
+    """Start the MCP server over the requested transport."""
+    if transport == "stdio":
+        mcp.auth = None
+        mcp.run()
+    elif transport in ("http", "streamable-http"):
+        cfg = load_config()
+        token = cfg.resolved_mcp_http_token()
+        if not token:
+            raise ValueError(
+                "HTTP transport requires TIMING_MCP_TOKEN or mcp_http_token in the config"
+            )
+        mcp.auth = StaticBearerTokenVerifier(token)
+        mcp.run(transport="http", host=host, port=port)
+    else:
+        raise ValueError(f"Unknown transport: {transport}")
+
+
+if __name__ == "__main__":
+    run_server()

timing_cli/timing_predicates.py

@@ -0,0 +1,229 @@
+"""Decode and apply Timing.app project predicate rules.
+
+Timing stores project auto-assignment predicates as a protobuf-like binary wire
+format in ``Project.predicate``. The format is undocumented, so the decoder here
+is intentionally conservative: it extracts recognized field/value conditions and
+ignores unknown structure.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterator
+from dataclasses import dataclass
+
+from timing_cli.models import AppUsage
+
+RECOGNIZED_FIELDS = {
+    "applicationID",
+    "bundleIdentifier",
+    "executable",
+    "filePath",
+    "keywords",
+    "path",
+    "title",
+    "webDomain",
+}
+
+
+@dataclass(frozen=True)
+class TimingPredicateCondition:
+    field: str
+    values: tuple[str, ...] = ()
+    int_values: tuple[int, ...] = ()
+
+    def matches(self, usage: AppUsage) -> bool:
+        if self.field == "applicationID":
+            return usage.application_id in self.int_values
+
+        haystacks = _haystacks_for_field(self.field, usage)
+        if not haystacks:
+            return False
+        if self.field == "keywords":
+            return any(
+                _keyword_matches(value, haystack)
+                for value in self.values
+                for haystack in haystacks
+            )
+        return any(
+            value.lower() in haystack
+            for value in self.values
+            for haystack in haystacks
+            if value
+        )
+
+
+@dataclass(frozen=True)
+class TimingPredicateRule:
+    project_id: int
+    project_title: str
+    project_title_chain: tuple[str, ...]
+    conditions: tuple[TimingPredicateCondition, ...]
+
+    def matches(self, usage: AppUsage) -> bool:
+        return any(condition.matches(usage) for condition in self.conditions)
+
+
+def decode_timing_predicate(blob: bytes | None) -> tuple[TimingPredicateCondition, ...]:
+    """Extract recognized conditions from a Timing predicate blob."""
+    if not blob:
+        return ()
+
+    conditions: list[TimingPredicateCondition] = []
+    seen: set[TimingPredicateCondition] = set()
+    for condition in _extract_conditions(blob):
+        if condition not in seen:
+            conditions.append(condition)
+            seen.add(condition)
+    return tuple(conditions)
+
+
+def _haystacks_for_field(field: str, usage: AppUsage) -> tuple[str, ...]:
+    if field == "applicationID":
+        return ()
+    if field == "bundleIdentifier":
+        values = (usage.bundle_id,)
+    elif field in {"filePath", "path"}:
+        values = (usage.path, usage.title)
+    elif field == "executable":
+        values = (usage.app, usage.bundle_id)
+    else:
+        values = (usage.title, usage.path, usage.app, usage.bundle_id)
+    return tuple(value.lower() for value in values if value)
+
+
+def _keyword_matches(value: str, haystack: str) -> bool:
+    keyword = value.strip().lower()
+    if len(keyword) < 3:
+        return False
+    if not re.search(r"\w", keyword):
+        return False
+    if re.search(r"\s", keyword):
+        return keyword in haystack
+    return re.search(rf"(?<!\w){re.escape(keyword)}(?!\w)", haystack) is not None
+
+
+def _extract_conditions(data: bytes) -> Iterator[TimingPredicateCondition]:
+    try:
+        fields = list(_decode_fields(data))
+    except ValueError:
+        return
+
+    field_names: list[str] = []
+    text_values: list[str] = []
+    int_values: list[int] = []
+
+    for field_number, wire_type, value in fields:
+        if wire_type != 2 or not isinstance(value, bytes):
+            continue
+        if field_number == 3:
+            field_names.extend(_recognized_strings(value))
+        elif field_number == 4:
+            text_values.extend(_value_strings(value))
+            int_values.extend(_value_ints(value))
+
+    for field_name in field_names:
+        if field_name == "applicationID":
+            values = tuple(v for v in int_values if v >= 0)
+            if values:
+                yield TimingPredicateCondition(field_name, int_values=values)
+        else:
+            values = tuple(_dedupe(text_values))
+            if values:
+                yield TimingPredicateCondition(field_name, values=values)
+
+    for _field_number, wire_type, value in fields:
+        if wire_type == 2 and isinstance(value, bytes):
+            yield from _extract_conditions(value)
+
+
+def _decode_fields(data: bytes) -> Iterator[tuple[int, int, int | bytes]]:
+    index = 0
+    while index < len(data):
+        key, index = _read_varint(data, index)
+        field_number = key >> 3
+        wire_type = key & 0x07
+        if field_number == 0:
+            raise ValueError("invalid protobuf field number")
+
+        if wire_type == 0:
+            value, index = _read_varint(data, index)
+            yield field_number, wire_type, value
+        elif wire_type == 2:
+            length, index = _read_varint(data, index)
+            end = index + length
+            if end > len(data):
+                raise ValueError("length-delimited field exceeds message")
+            yield field_number, wire_type, data[index:end]
+            index = end
+        else:
+            raise ValueError(f"unsupported protobuf wire type: {wire_type}")
+
+
+def _read_varint(data: bytes, index: int) -> tuple[int, int]:
+    shift = 0
+    value = 0
+    while index < len(data):
+        byte = data[index]
+        index += 1
+        value |= (byte & 0x7F) << shift
+        if not byte & 0x80:
+            return value, index
+        shift += 7
+        if shift > 63:
+            raise ValueError("varint too large")
+    raise ValueError("truncated varint")
+
+
+def _recognized_strings(data: bytes) -> list[str]:
+    return [value for value in _all_printable_strings(data) if value in RECOGNIZED_FIELDS]
+
+
+def _value_strings(data: bytes) -> list[str]:
+    return [
+        value
+        for value in _all_printable_strings(data)
+        if value not in RECOGNIZED_FIELDS and len(value) >= 2
+    ]
+
+
+def _value_ints(data: bytes) -> list[int]:
+    ints: list[int] = []
+    try:
+        fields = list(_decode_fields(data))
+    except ValueError:
+        return ints
+
+    for _field_number, wire_type, value in fields:
+        if wire_type == 0 and isinstance(value, int):
+            ints.append(value)
+        elif wire_type == 2 and isinstance(value, bytes):
+            ints.extend(_value_ints(value))
+    return ints
+
+
+def _all_printable_strings(data: bytes) -> list[str]:
+    values: list[str] = []
+    values.extend(
+        match.group(0).decode("utf-8", errors="ignore")
+        for match in re.finditer(rb"[\x20-\x7e]{2,}", data)
+    )
+
+    try:
+        fields = list(_decode_fields(data))
+    except ValueError:
+        return values
+
+    for _field_number, wire_type, value in fields:
+        if wire_type == 2 and isinstance(value, bytes):
+            values.extend(_all_printable_strings(value))
+    return list(_dedupe(values))
+
+
+def _dedupe(values: list[str]) -> Iterator[str]:
+    seen: set[str] = set()
+    for value in values:
+        if value in seen:
+            continue
+        seen.add(value)
+        yield value

timing_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.4
+Name: timing-cli
+Version: 0.1.0
+Summary: CLI + MCP server for the Timing.app macOS time tracker - reads the local activity database and generates/pushes time entries via the Timing Web API
+Project-URL: Homepage, https://github.com/sussdorff/timing-cli
+Project-URL: Repository, https://github.com/sussdorff/timing-cli
+Project-URL: Issues, https://github.com/sussdorff/timing-cli/issues
+Project-URL: Changelog, https://github.com/sussdorff/timing-cli/blob/main/CHANGELOG.md
+Author: Malte Sussdorff
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,macos,mcp,productivity,time-tracking,timing
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Utilities
+Requires-Python: >=3.12
+Requires-Dist: fastmcp>=2.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=1.23.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.15.0
+Description-Content-Type: text/markdown
+
+# timing-cli
+
+A command-line interface **and MCP server** for [Timing.app](https://timingapp.com/)
+on macOS. Unlike the Timing Web API — which cannot see your locally recorded app
+usage — `timing-cli` reads Timing's **local activity database directly**
+(read-only) and turns real app usage into aggregated time entries, which it can
+then push back to Timing via the Web API.
+
+Because it ships an embedded MCP server, agents (e.g. the Hermes personal agent)
+can query your activity and create entries **without ever copying or exposing
+the raw `SQLite.db`** — the server runs locally, next to the database.
+
+> **Not affiliated with Timing.** Independent tool. It only ever *reads* the
+> local database; all writes go through the official Web API.
+
+## What it does
+
+- **Reads** the local Timing store (`~/Library/Application Support/info.eurocomp.Timing2/SQLite.db`)
+  read-only: automatic app activity, window titles, document paths, projects.
+- **Classifies** unassigned activity onto projects with your own rules (Timing's
+  built-in predicate rules only cover ~15% of activity). It also reuses decoded
+  Timing project predicate rules from the local database when Timing did not
+  already assign a slice.
+- **Aggregates** consecutive same-project slices into clean time blocks
+  (gap-merging + minimum-duration filtering).
+- **Pushes** the resulting suggestions to Timing as real time entries via the
+  Web API (with a safe dry-run default).
+- **Serves** all of this over MCP (`timing serve`) for agents.
+
+## Quickstart
+
+```bash
+# Install (globally, via uv)
+uv tool install timing-cli
+
+# See what's in your local database
+timing info
+
+# Daily project summary and suggested entries (read-only)
+timing summary --date 2026-07-05
+timing suggest --date 2026-07-05
+
+# Push suggestions to Timing (dry-run first, then --yes)
+export TIMING_API_KEY=...    # from https://web.timingapp.com/integrations/tokens
+timing push --date 2026-07-05          # dry-run
+timing push --date 2026-07-05 --yes    # actually create entries
+
+# Run the MCP server (for Hermes / other agents)
+timing serve                                  # stdio
+export TIMING_MCP_TOKEN=...
+timing serve --transport http                 # HTTP on 127.0.0.1:8321
+```
+
+`timing push --yes` resolves every non-unassigned suggestion to a unique Web-API
+project before creating anything. If a project is ambiguous or unmapped, the push
+fails before the first write; add a `[project_mappings]` override. Re-running the
+same push skips matching existing entries unless `--replace` is passed.
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `timing info` | Database location, recorded date range, token status |
+| `timing projects [--remote] [--archived]` | List projects (local DB or Web API) |
+| `timing usage [--date/--from/--to] [--project ID]` | Raw automatically tracked app usage |
+| `timing summary [--date/--from/--to]` | Total time per project |
+| `timing suggest [--date/--from/--to]` | Aggregated time-entry suggestions (read-only) |
+| `timing push [--date/--from/--to] [--yes] [--replace]` | Create entries via Web API (dry-run by default) |
+| `timing serve [--transport] [--host] [--port]` | Run the MCP server |
+
+## Daily workflow
+
+```bash
+# 1. Inspect the day without writing anything.
+timing summary --date 2026-07-05
+timing suggest --date 2026-07-05
+
+# 2. If push projects are unmapped, inspect remote project references.
+export TIMING_API_KEY=...
+timing projects --remote
+
+# 3. Add missing [project_mappings] entries, then dry-run again.
+timing push --date 2026-07-05
+
+# 4. Create entries once the dry-run looks right.
+timing push --date 2026-07-05 --yes
+```
+
+Re-running step 4 for the same day skips matching existing entries. Use
+`--replace` only when you deliberately want Timing's API to replace overlapping
+entries in the target window.
+
+## Configuration
+
+Optional config at `~/.config/timing-cli/config.toml`:
+
+```toml
+# Override the database path if Timing lives elsewhere.
+# db_path = "~/Library/Application Support/info.eurocomp.Timing2/SQLite.db"
+
+api_base_url = "https://web.timingapp.com/api/v1"
+# api_token = "..."   # prefer the TIMING_API_KEY env var instead
+# mcp_http_token = "..."   # prefer the TIMING_MCP_TOKEN env var instead
+
+min_block_seconds = 120    # drop aggregated blocks shorter than this
+gap_merge_seconds = 300    # merge same-project slices split by a gap up to this
+
+# Optional overrides from local Timing projects to Web-API project references.
+# Keys can be a local id ("id:42"), a full title chain, or a leaf title.
+[project_mappings]
+"Client / Polaris" = "/projects/123"
+"id:42" = "/projects/456"
+
+# Classification rules: map unassigned activity onto projects.
+# First match wins. `app`/`bundle_id` are case-insensitive substrings;
+# `title`/`path` are regexes.
+[[rules]]
+project = "Polaris"
+title = "polaris"
+
+[[rules]]
+project = "Cognovis"
+path = "code/mira"
+```
+
+### Cognovis example
+
+This is a real-world shape for Malte's local setup. Fill the Web-API project
+references from `timing projects --remote`; local project ids can be discovered
+with `timing projects`.
+
+```toml
+api_base_url = "https://web.timingapp.com/api/v1"
+min_block_seconds = 120
+gap_merge_seconds = 300
+
+[project_mappings]
+"cognovis Verwaltung" = "/projects/REMOTE_COGNOVIS_VERWALTUNG"
+"]project-open[" = "/projects/REMOTE_PROJECT_OPEN"
+"Home Electronic" = "/projects/REMOTE_HOME_ELECTRONIC"
+
+[[rules]]
+project = "cognovis Verwaltung"
+title = "(timing|collmex|paperless|invoice|rechnung)"
+
+[[rules]]
+project = "cognovis Verwaltung"
+path = "code/(cli-tools|library)"
+
+[[rules]]
+project = "]project-open["
+app = "Mail"
+title = "project-open"
+```
+
+Timing's own project predicates are loaded from the local `Project.predicate`
+column automatically and applied after explicit config rules. Keep local rules
+for repository paths, editor titles, and project-specific conventions that
+Timing itself does not classify well.
+
+## MCP tools
+
+`timing serve` exposes: `list_timing_projects`, `list_app_usage_tool`,
+`daily_project_summary`, `suggest_time_entries`, `create_time_entry` (write),
+`recorded_date_range`.
+
+HTTP transport requires bearer-token authentication via `TIMING_MCP_TOKEN` or
+`mcp_http_token` in the config. Stdio transport remains local and does not require
+an MCP token.
+
+## Release
+
+The repository includes a GitHub Actions release workflow at
+`.github/workflows/release.yml`. Tag pushes run tests and lint only; published
+GitHub releases or manual dispatches build the package and publish to PyPI using
+Trusted Publishing. Configure a PyPI trusted publisher for the repository and
+the `pypi` environment before running the publish job.
+
+## Requirements
+
+- macOS with Timing.app installed
+- Python 3.12+ (installed automatically by `uv tool install`)
+- A Timing Web API token for pushing entries (read-only commands need no token)
+
+## License
+
+MIT

timing_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+timing_cli/__init__.py,sha256=hY-GD8CkECLw70dtykPj53acjuJAzojiE5JlyGEpgKI,108
+timing_cli/analysis.py,sha256=pfuZMXaK2G2sL0xHIHzTlsGlGBzkM3WB8F5sUunH1R0,5839
+timing_cli/api.py,sha256=A-spEnd2Jml012DqTjZXRdGGB5Ql_DaQEkJ4Y8NBx9E,11207
+timing_cli/cli.py,sha256=LWlE_l3ZWN21rONd1q02SM9T5f9BvPCVeIjZPLyws-g,12256
+timing_cli/config.py,sha256=sAF4yNpYX5Hdxl52BvOajrJFvtyHc-Z3QqdWTHHWwQQ,3103
+timing_cli/db.py,sha256=cohc57l_4fovYfD8Awx2cZ5hNODeKZ7aEWgqyq3oHRY,10076
+timing_cli/models.py,sha256=DXurP-4lDlLDBOlsDXfsN6R4ZCntm8LC7h9CwoQuhWE,2779
+timing_cli/output.py,sha256=-VmJmkgIrXZR9n7bYVC0Qv6cMoFQ8RMumfqS3CBxnAE,2546
+timing_cli/rules.py,sha256=VtivHjbMV5Y8MV1eZfiTUD6ROg5Mwjsd8cAjDmZPohA,3654
+timing_cli/serve.py,sha256=jFh7kW8u-hVAT--TRgmIVr9ykTJw2200LxVXKZ8J6xk,7020
+timing_cli/timing_predicates.py,sha256=pr_wWOF-G_lwazvVjdgzUBb9otExXSEJYVN49L6BQGE,6977
+timing_cli-0.1.0.dist-info/METADATA,sha256=Xf4CK4NUOqzFhd35sw0BOQFVqtvdZMOKqjN_NgjJwgY,8147
+timing_cli-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+timing_cli-0.1.0.dist-info/entry_points.txt,sha256=NFLU0ZwwXYA_JFJkV8YVxN9Wj_4blhE5NQtaxbBs8Aw,46
+timing_cli-0.1.0.dist-info/licenses/LICENSE,sha256=m95-uSx9Hd54_EmMYstMjv6GCB-1u2lpYJRzyLpkcQ8,1072
+timing_cli-0.1.0.dist-info/RECORD,,

timing_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

timing_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+timing = timing_cli.cli:app