daytrace 0.1.0__tar.gz

daytrace-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daytrace contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

daytrace-0.1.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: daytrace
+Version: 0.1.0
+Summary: Deterministic daily summaries from ActivityWatch
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: aw-client>=0.5.15,<0.6
+Requires-Dist: tzlocal>=5.4,<6
+Requires-Dist: tzdata>=2026.3 ; sys_platform == 'win32'
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Daytrace
+
+Daytrace is a privacy-first desktop utility that turns a person's day into a
+searchable text journal. Screen, microphone, keyboard activity, and system
+context are independent opt-ins. Captured media is processed ephemerally and
+discarded; the durable record contains text and structured metadata only.
+
+This repository now includes a headless ActivityWatch summary prototype. The
+broader cross-platform capture application remains in the product and
+architecture planning phase.
+
+## ActivityWatch summary prototype
+
+The first executable prototype is a Python CLI that reads a selected day from
+an already-running ActivityWatch instance and produces deterministic Markdown.
+It does not copy raw events or call an LLM.
+
+Prerequisites: install and run ActivityWatch, then install `uv`. On Windows:
+
+```powershell
+winget install --id=astral-sh.uv -e
+```
+
+From a source checkout:
+
+```powershell
+git switch codex/activitywatch-integration-research
+uv sync
+uv run daytrace activitywatch --date 2026-09-10 --output summary.md
+```
+
+Filter the report to records containing a project name:
+
+```powershell
+uv run daytrace activitywatch --date 2026-09-10 --project daytrace --output summary.md
+```
+
+The resulting `summary.md` contains an overview, a chronological timeline, and
+application totals. A day with no matching activity is still a successful
+report and contains `No matching activity.`
+
+After the package is published, the equivalent one-off command will be:
+
+```powershell
+uvx daytrace activitywatch --date 2026-09-10 --output summary.md
+```
+
+Python callers—including a future second-brain integration—can use the same
+deterministic renderer directly:
+
+```python
+from datetime import date
+
+from daytrace.activitywatch import summarize_day
+
+markdown = summarize_day(date(2026, 9, 10), project="daytrace")
+```
+
+Daytrace reads ActivityWatch through `http://127.0.0.1:5600` by default. It
+does not retain images, audio, video, full browser URLs, or a second copy of
+ActivityWatch events. Use `--server` for another ActivityWatch endpoint and
+`--timezone` for an explicit IANA timezone such as `America/Los_Angeles`.
+
+## Product decisions
+
+- Local-first: the database and processing stay on the user's computer unless
+  the user explicitly configures a cloud provider or export destination.
+- All capture sources start off and require separate, informed consent.
+- Tauri 2 and Rust are the recommended desktop stack, with a small React/Vite
+  interface that normally stays hidden behind a tray icon.
+- Accessibility text is preferred over screenshots. OCR is a fallback, and
+  image buffers are destroyed after extraction.
+- Microphone audio is held only in bounded memory, segmented with voice
+  activity detection, transcribed, and discarded.
+- Keyboard capture defaults to activity signals only, not key content. An
+  advanced typed-text mode is a later, separately consented feature with
+  password and deny-list suppression.
+- SQLite, B-tree time dimensions, and FTS5 provide the hierarchical timeline
+  and full-text search. Captured media and vector embeddings are not stored.
+- The first release supports BYOK and local providers. A hosted inference
+  gateway can later fund the project without locking users into the service.
+
+## Plan
+
+- [Implementation plan](docs/IMPLEMENTATION_PLAN.md)
+- [Architecture](docs/ARCHITECTURE.md)
+- [Data model and search](docs/DATA_MODEL.md)
+- [Privacy and security](docs/PRIVACY_SECURITY.md)
+- [Product and UX specification](docs/PRODUCT_UX.md)
+- [Screenpipe reuse audit](docs/SCREENPIPE_REUSE.md)
+- [ActivityWatch integration research](docs/ACTIVITYWATCH_INTEGRATION_RESEARCH.md)
+
+## Proposed repository shape
+
+```text
+apps/
+  desktop/                 Tauri window, tray, onboarding, settings
+crates/
+  daytrace-core/           orchestration, policies, domain events
+  daytrace-capture/        platform-neutral capture traits
+  daytrace-platform-*/     macOS, Windows, and Linux adapters
+  daytrace-extract/        accessibility, OCR, VAD, transcription
+  daytrace-store/          SQLite migrations, FTS, retention
+  daytrace-summary/        segmentation and provider-neutral summaries
+  daytrace-sync/           deterministic export and GitHub sync
+  daytrace-secrets/        OS credential-store abstraction
+extensions/
+  browser/                 optional Chromium/Firefox tab metadata bridge
+docs/
+```
+
+## Target outcome
+
+The v1 release is a signed, auto-updating macOS, Windows, and Linux desktop app
+that can run for an eight-hour day without retaining raw media, recover cleanly
+from sleep and device changes, search a local journal, and create an editable
+end-of-day summary. See the implementation plan for measurable release gates.

daytrace-0.1.0/README.md

@@ -0,0 +1,117 @@
+# Daytrace
+
+Daytrace is a privacy-first desktop utility that turns a person's day into a
+searchable text journal. Screen, microphone, keyboard activity, and system
+context are independent opt-ins. Captured media is processed ephemerally and
+discarded; the durable record contains text and structured metadata only.
+
+This repository now includes a headless ActivityWatch summary prototype. The
+broader cross-platform capture application remains in the product and
+architecture planning phase.
+
+## ActivityWatch summary prototype
+
+The first executable prototype is a Python CLI that reads a selected day from
+an already-running ActivityWatch instance and produces deterministic Markdown.
+It does not copy raw events or call an LLM.
+
+Prerequisites: install and run ActivityWatch, then install `uv`. On Windows:
+
+```powershell
+winget install --id=astral-sh.uv -e
+```
+
+From a source checkout:
+
+```powershell
+git switch codex/activitywatch-integration-research
+uv sync
+uv run daytrace activitywatch --date 2026-09-10 --output summary.md
+```
+
+Filter the report to records containing a project name:
+
+```powershell
+uv run daytrace activitywatch --date 2026-09-10 --project daytrace --output summary.md
+```
+
+The resulting `summary.md` contains an overview, a chronological timeline, and
+application totals. A day with no matching activity is still a successful
+report and contains `No matching activity.`
+
+After the package is published, the equivalent one-off command will be:
+
+```powershell
+uvx daytrace activitywatch --date 2026-09-10 --output summary.md
+```
+
+Python callers—including a future second-brain integration—can use the same
+deterministic renderer directly:
+
+```python
+from datetime import date
+
+from daytrace.activitywatch import summarize_day
+
+markdown = summarize_day(date(2026, 9, 10), project="daytrace")
+```
+
+Daytrace reads ActivityWatch through `http://127.0.0.1:5600` by default. It
+does not retain images, audio, video, full browser URLs, or a second copy of
+ActivityWatch events. Use `--server` for another ActivityWatch endpoint and
+`--timezone` for an explicit IANA timezone such as `America/Los_Angeles`.
+
+## Product decisions
+
+- Local-first: the database and processing stay on the user's computer unless
+  the user explicitly configures a cloud provider or export destination.
+- All capture sources start off and require separate, informed consent.
+- Tauri 2 and Rust are the recommended desktop stack, with a small React/Vite
+  interface that normally stays hidden behind a tray icon.
+- Accessibility text is preferred over screenshots. OCR is a fallback, and
+  image buffers are destroyed after extraction.
+- Microphone audio is held only in bounded memory, segmented with voice
+  activity detection, transcribed, and discarded.
+- Keyboard capture defaults to activity signals only, not key content. An
+  advanced typed-text mode is a later, separately consented feature with
+  password and deny-list suppression.
+- SQLite, B-tree time dimensions, and FTS5 provide the hierarchical timeline
+  and full-text search. Captured media and vector embeddings are not stored.
+- The first release supports BYOK and local providers. A hosted inference
+  gateway can later fund the project without locking users into the service.
+
+## Plan
+
+- [Implementation plan](docs/IMPLEMENTATION_PLAN.md)
+- [Architecture](docs/ARCHITECTURE.md)
+- [Data model and search](docs/DATA_MODEL.md)
+- [Privacy and security](docs/PRIVACY_SECURITY.md)
+- [Product and UX specification](docs/PRODUCT_UX.md)
+- [Screenpipe reuse audit](docs/SCREENPIPE_REUSE.md)
+- [ActivityWatch integration research](docs/ACTIVITYWATCH_INTEGRATION_RESEARCH.md)
+
+## Proposed repository shape
+
+```text
+apps/
+  desktop/                 Tauri window, tray, onboarding, settings
+crates/
+  daytrace-core/           orchestration, policies, domain events
+  daytrace-capture/        platform-neutral capture traits
+  daytrace-platform-*/     macOS, Windows, and Linux adapters
+  daytrace-extract/        accessibility, OCR, VAD, transcription
+  daytrace-store/          SQLite migrations, FTS, retention
+  daytrace-summary/        segmentation and provider-neutral summaries
+  daytrace-sync/           deterministic export and GitHub sync
+  daytrace-secrets/        OS credential-store abstraction
+extensions/
+  browser/                 optional Chromium/Firefox tab metadata bridge
+docs/
+```
+
+## Target outcome
+
+The v1 release is a signed, auto-updating macOS, Windows, and Linux desktop app
+that can run for an eight-hour day without retaining raw media, recover cleanly
+from sleep and device changes, search a local journal, and create an editable
+end-of-day summary. See the implementation plan for measurable release gates.

daytrace-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["uv_build>=0.12.13,<0.13"]
+build-backend = "uv_build"
+
+[project]
+name = "daytrace"
+version = "0.1.0"
+description = "Deterministic daily summaries from ActivityWatch"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = [
+    "aw-client>=0.5.15,<0.6",
+    "tzlocal>=5.4,<6",
+    "tzdata>=2026.3; sys_platform == 'win32'",
+]
+
+[project.scripts]
+daytrace = "daytrace.cli:entrypoint"
+
+[dependency-groups]
+dev = ["pytest>=9.1,<10"]
+
+[tool.pytest.ini_options]
+addopts = "-ra"
+testpaths = ["tests"]

daytrace-0.1.0/pyproject.toml.orig

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["uv_build>=0.12.13,<0.13"]
+build-backend = "uv_build"
+
+[project]
+name = "daytrace"
+version = "0.1.0"
+description = "Deterministic daily summaries from ActivityWatch"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = [
+  "aw-client>=0.5.15,<0.6",
+  "tzlocal>=5.4,<6",
+  "tzdata>=2026.3; sys_platform == 'win32'",
+]
+
+[project.scripts]
+daytrace = "daytrace.cli:entrypoint"
+
+[dependency-groups]
+dev = ["pytest>=9.1,<10"]
+
+[tool.pytest.ini_options]
+addopts = "-ra"
+testpaths = ["tests"]

daytrace-0.1.0/src/daytrace/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

daytrace-0.1.0/src/daytrace/__main__.py

@@ -0,0 +1,3 @@
+from daytrace.cli import entrypoint
+
+entrypoint()

daytrace-0.1.0/src/daytrace/activitywatch.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from datetime import date, timezone
+
+from daytrace.markdown import render_markdown
+from daytrace.normalize import SUPPORTED_BUCKET_TYPES, normalize_events
+from daytrace.report import build_report
+from daytrace.source import ActivitySource, AwClientSource
+from daytrace.time import resolve_day
+from daytrace.transform import filter_project, merge_adjacent, remove_afk
+
+
+DEFAULT_SERVER = "http://127.0.0.1:5600"
+
+
+def summarize_day(
+    day: date,
+    project: str | None = None,
+    *,
+    server: str = DEFAULT_SERVER,
+    timezone_name: str | None = None,
+    source: ActivitySource | None = None,
+    warn: Callable[[str], None] | None = None,
+) -> str:
+    warning = warn or logging.getLogger("daytrace").warning
+    window = resolve_day(day, timezone_name)
+    activity_source = source or AwClientSource.from_url(server)
+    activity_source.get_info()
+    buckets = activity_source.list_buckets()
+    supported = tuple(
+        bucket for bucket in buckets if bucket.type in SUPPORTED_BUCKET_TYPES
+    )
+    unknown_count = len(buckets) - len(supported)
+    if unknown_count:
+        noun = "bucket" if unknown_count == 1 else "buckets"
+        warning(f"ignored {unknown_count} unsupported ActivityWatch {noun}")
+
+    records = tuple(
+        record
+        for bucket in supported
+        for record in normalize_events(
+            bucket,
+            activity_source.get_events(
+                bucket.id,
+                window.start.astimezone(timezone.utc),
+                window.end.astimezone(timezone.utc),
+            ),
+            window,
+            warning,
+        )
+    )
+    transformed = merge_adjacent(filter_project(remove_afk(records), project))
+    return render_markdown(build_report(day, window, transformed, project))

daytrace-0.1.0/src/daytrace/cli.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Sequence
+from datetime import date
+from pathlib import Path
+from typing import NoReturn
+from zoneinfo import ZoneInfoNotFoundError
+
+from daytrace.activitywatch import DEFAULT_SERVER, summarize_day
+from daytrace.source import ActivityWatchConnectionError
+
+
+def _date(value: str) -> date:
+    try:
+        return date.fromisoformat(value)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError("expected YYYY-MM-DD") from exc
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="daytrace")
+    commands = parser.add_subparsers(dest="command", required=True)
+    activitywatch = commands.add_parser(
+        "activitywatch", help="summarize ActivityWatch data"
+    )
+    activitywatch.add_argument("--date", required=True, type=_date)
+    activitywatch.add_argument("--project")
+    activitywatch.add_argument("--server", default=DEFAULT_SERVER)
+    activitywatch.add_argument("--timezone", dest="timezone_name")
+    activitywatch.add_argument("--output", type=Path)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        markdown = summarize_day(
+            args.date,
+            args.project,
+            server=args.server,
+            timezone_name=args.timezone_name,
+            warn=lambda message: print(f"warning: {message}", file=sys.stderr),
+        )
+    except ZoneInfoNotFoundError:
+        print(f"error: invalid timezone {args.timezone_name!r}", file=sys.stderr)
+        return 1
+    except ValueError:
+        print("error: invalid ActivityWatch server URL", file=sys.stderr)
+        return 1
+    except ActivityWatchConnectionError:
+        print(
+            f"error: ActivityWatch is not reachable at {args.server}; "
+            "start ActivityWatch or pass --server",
+            file=sys.stderr,
+        )
+        return 1
+
+    if args.output:
+        try:
+            lf_markdown = markdown.replace("\r\n", "\n").replace("\r", "\n")
+            args.output.write_bytes(lf_markdown.encode("utf-8"))
+        except OSError:
+            print(
+                f"error: could not write output file {str(args.output)!r}",
+                file=sys.stderr,
+            )
+            return 1
+    else:
+        sys.stdout.write(markdown)
+    return 0
+
+
+def entrypoint() -> NoReturn:
+    raise SystemExit(main())

daytrace-0.1.0/src/daytrace/markdown.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import html
+import re
+from zoneinfo import ZoneInfo
+
+from daytrace.models import ActivityRecord, ActivityReport, SourceKind
+
+
+SOURCE_LABEL = {
+    SourceKind.WINDOW: "Current window",
+    SourceKind.EDITOR: "Editor",
+    SourceKind.BROWSER: "Browser",
+}
+
+
+def format_duration(seconds: float) -> str:
+    minutes = max(1, int((seconds + 30) // 60))
+    hours, minutes = divmod(minutes, 60)
+    if hours and minutes:
+        return f"{hours}h {minutes}m"
+    if hours:
+        return f"{hours}h"
+    return f"{minutes}m"
+
+
+def _single_line(value: str) -> str:
+    return " ".join(value.replace("\r", " ").replace("\n", " ").split())
+
+
+def _escape(value: str) -> str:
+    escaped = html.escape(_single_line(value), quote=False).replace("\\", "\\\\")
+    return re.sub(r"([`*_{}\[\]#+|])", r"\\\1", escaped)
+
+
+def _code(value: str) -> str:
+    value = _single_line(value)
+    longest = max((len(run) for run in re.findall(r"`+", value)), default=0)
+    fence = "`" * (longest + 1)
+    padding = " " if value.startswith("`") or value.endswith("`") else ""
+    return f"{fence}{padding}{value}{padding}{fence}"
+
+
+def _basename(value: str | None) -> str | None:
+    return value.rsplit("/", 1)[-1].rsplit("\\", 1)[-1] if value else None
+
+
+def _label(record: ActivityRecord) -> str:
+    if record.kind is SourceKind.WINDOW:
+        values = (record.app, record.title)
+    elif record.kind is SourceKind.BROWSER:
+        values = (record.url_host, record.title)
+    else:
+        values = (_basename(record.project), _basename(record.file), record.language)
+    label = " — ".join(_escape(value) for value in values if value)
+    return label or SOURCE_LABEL[record.kind]
+
+
+def render_markdown(report: ActivityReport) -> str:
+    lines = [f"# Activity summary — {report.day.isoformat()}", ""]
+    if report.project is not None:
+        lines.append(f"Project filter: {_code(report.project)}")
+    lines.extend([f"Timezone: {_code(report.timezone_name)}", "", "## Overview", ""])
+    if not report.timeline:
+        return "\n".join(lines + ["No matching activity.", ""])
+
+    active = (
+        format_duration(report.active_seconds)
+        if report.active_seconds is not None
+        else "Unavailable"
+    )
+    lines.extend(
+        [
+            f"- Active matched time: {active}",
+            f"- Timeline entries: {len(report.timeline)}",
+            f"- Sources: {', '.join(SOURCE_LABEL[item] for item in report.sources)}",
+            "",
+            "## Timeline",
+            "",
+        ]
+    )
+    zone = ZoneInfo(report.timezone_name)
+    for record in report.timeline:
+        start = record.start.astimezone(zone).strftime("%H:%M")
+        end = record.end.astimezone(zone).strftime("%H:%M")
+        lines.append(
+            f"- {start}–{end} ({format_duration(record.duration_seconds)}) — {_label(record)}"
+        )
+    if report.applications:
+        lines.extend(["", "## Applications", ""])
+        lines.extend(
+            f"- {_escape(item.app)} — {format_duration(item.seconds)}"
+            for item in report.applications
+        )
+    return "\n".join(lines) + "\n"

daytrace-0.1.0/src/daytrace/models.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, datetime
+from enum import StrEnum
+from types import MappingProxyType
+from typing import Mapping
+
+
+class SourceKind(StrEnum):
+    WINDOW = "current-window"
+    AFK = "afk"
+    EDITOR = "editor"
+    BROWSER = "browser"
+
+
+@dataclass(frozen=True, slots=True)
+class ServerEndpoint:
+    protocol: str
+    host: str
+    port: int
+
+
+@dataclass(frozen=True, slots=True)
+class ServerInfo:
+    version: str
+    testing: bool
+
+
+@dataclass(frozen=True, slots=True)
+class DayWindow:
+    timezone_name: str
+    start: datetime
+    end: datetime
+
+
+@dataclass(frozen=True, slots=True)
+class RawBucket:
+    id: str
+    type: str
+    client: str
+    hostname: str
+
+
+@dataclass(frozen=True, slots=True)
+class RawEvent:
+    id: str
+    timestamp: datetime
+    duration_seconds: float
+    data: Mapping[str, object]
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "data", MappingProxyType(dict(self.data)))
+
+
+@dataclass(frozen=True, slots=True)
+class ActivityRecord:
+    event_id: str
+    bucket_id: str
+    kind: SourceKind
+    start: datetime
+    end: datetime
+    app: str | None = None
+    title: str | None = None
+    project: str | None = None
+    file: str | None = None
+    url_host: str | None = None
+    language: str | None = None
+    status: str | None = None
+
+    @property
+    def duration_seconds(self) -> float:
+        return (self.end - self.start).total_seconds()
+
+    def content_key(self) -> tuple[object, ...]:
+        return (
+            self.bucket_id,
+            self.kind,
+            self.app,
+            self.title,
+            self.project,
+            self.file,
+            self.url_host,
+            self.language,
+            self.status,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class ApplicationTotal:
+    app: str
+    seconds: float
+
+
+@dataclass(frozen=True, slots=True)
+class ActivityReport:
+    day: date
+    timezone_name: str
+    project: str | None
+    active_seconds: float | None
+    sources: tuple[SourceKind, ...]
+    timeline: tuple[ActivityRecord, ...]
+    applications: tuple[ApplicationTotal, ...]

daytrace-0.1.0/src/daytrace/normalize.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Mapping
+from datetime import timedelta, timezone
+from urllib.parse import urlsplit
+
+from daytrace.models import ActivityRecord, DayWindow, RawBucket, RawEvent, SourceKind
+
+
+ONE_SECOND = timedelta(seconds=1)
+SUPPORTED_BUCKET_TYPES: Mapping[str, SourceKind] = {
+    "currentwindow": SourceKind.WINDOW,
+    "afkstatus": SourceKind.AFK,
+    "app.editor.activity": SourceKind.EDITOR,
+    "web.tab.current": SourceKind.BROWSER,
+}
+
+
+def _text(data: Mapping[str, object], key: str) -> str | None:
+    value = data.get(key)
+    return value if isinstance(value, str) and value else None
+
+
+def _url_host(data: Mapping[str, object]) -> str | None:
+    value = _text(data, "url")
+    if not value:
+        return None
+    try:
+        return urlsplit(value).hostname
+    except ValueError:
+        return None
+
+
+def normalize_events(
+    bucket: RawBucket,
+    events: Iterable[RawEvent],
+    window: DayWindow,
+    warn: Callable[[str], None],
+) -> tuple[ActivityRecord, ...]:
+    kind = SUPPORTED_BUCKET_TYPES[bucket.type]
+    normalized: list[ActivityRecord] = []
+    window_start = window.start.astimezone(timezone.utc)
+    window_end = window.end.astimezone(timezone.utc)
+
+    for event in events:
+        if event.timestamp.tzinfo is None:
+            warn(
+                f"skipped naive timestamp for event {event.id!r} in bucket {bucket.id!r}"
+            )
+            continue
+        raw_start = event.timestamp.astimezone(timezone.utc)
+        start = max(raw_start, window_start)
+        end = min(raw_start + event.duration_seconds * ONE_SECOND, window_end)
+        if end <= start:
+            warn(f"skipped non-positive event {event.id!r} in bucket {bucket.id!r}")
+            continue
+        normalized.append(
+            ActivityRecord(
+                event_id=event.id,
+                bucket_id=bucket.id,
+                kind=kind,
+                start=start,
+                end=end,
+                app=_text(event.data, "app"),
+                title=_text(event.data, "title"),
+                project=_text(event.data, "project"),
+                file=_text(event.data, "file"),
+                url_host=_url_host(event.data),
+                language=_text(event.data, "language"),
+                status=_text(event.data, "status"),
+            )
+        )
+
+    return tuple(
+        sorted(normalized, key=lambda item: (item.start, item.bucket_id, item.event_id))
+    )

daytrace-0.1.0/src/daytrace/report.py

@@ -0,0 +1,54 @@
+from collections import defaultdict
+from datetime import date
+
+from daytrace.models import (
+    ActivityRecord,
+    ActivityReport,
+    ApplicationTotal,
+    DayWindow,
+    SourceKind,
+)
+from daytrace.transform import partition_window_seconds
+
+
+SOURCE_ORDER = {
+    SourceKind.WINDOW: 0,
+    SourceKind.EDITOR: 1,
+    SourceKind.BROWSER: 2,
+}
+
+
+def build_report(
+    day: date,
+    window: DayWindow,
+    records: tuple[ActivityRecord, ...],
+    project: str | None,
+) -> ActivityReport:
+    timeline = tuple(
+        sorted(records, key=lambda item: (item.start, item.bucket_id, item.event_id))
+    )
+    allocation = partition_window_seconds(timeline)
+    app_seconds: dict[str, float] = defaultdict(float)
+    for record, seconds in allocation:
+        app_seconds[record.app or "Unknown application"] += seconds
+    applications = tuple(
+        ApplicationTotal(app, seconds)
+        for app, seconds in sorted(
+            app_seconds.items(),
+            key=lambda item: (-item[1], item[0].casefold(), item[0]),
+        )
+    )
+    sources = tuple(
+        sorted({item.kind for item in timeline}, key=SOURCE_ORDER.__getitem__)
+    )
+    return ActivityReport(
+        day=day,
+        timezone_name=window.timezone_name,
+        project=project,
+        active_seconds=sum(item.seconds for item in applications)
+        if allocation
+        else None,
+        sources=sources,
+        timeline=timeline,
+        applications=applications,
+    )

daytrace-0.1.0/src/daytrace/source.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from datetime import datetime, timedelta
+from typing import Any, Protocol
+from urllib.parse import urlsplit
+
+from aw_client import ActivityWatchClient
+
+from daytrace.models import RawBucket, RawEvent, ServerEndpoint, ServerInfo
+
+
+class ActivityWatchConnectionError(RuntimeError):
+    """A privacy-safe failure while reading ActivityWatch."""
+
+
+class ActivitySource(Protocol):
+    def get_info(self) -> ServerInfo: ...
+
+    def list_buckets(self) -> tuple[RawBucket, ...]: ...
+
+    def get_events(
+        self, bucket_id: str, start: datetime, end: datetime
+    ) -> tuple[RawEvent, ...]: ...
+
+
+def parse_server_url(url: str) -> ServerEndpoint:
+    parsed = urlsplit(url)
+    valid = (
+        parsed.scheme in {"http", "https"}
+        and parsed.hostname is not None
+        and parsed.username is None
+        and parsed.password is None
+        and parsed.path in {"", "/"}
+        and not parsed.query
+        and not parsed.fragment
+    )
+    if not valid:
+        raise ValueError("invalid ActivityWatch server URL")
+    try:
+        port = parsed.port or 5600
+    except ValueError as exc:
+        raise ValueError("invalid ActivityWatch server URL") from exc
+    return ServerEndpoint(parsed.scheme, parsed.hostname, port)
+
+
+class AwClientSource:
+    def __init__(self, client: ActivityWatchClient | Any) -> None:
+        self._client = client
+
+    @classmethod
+    def from_url(cls, url: str) -> AwClientSource:
+        endpoint = parse_server_url(url)
+        client = ActivityWatchClient(
+            "daytrace",
+            host=endpoint.host,
+            port=endpoint.port,
+            protocol=endpoint.protocol,
+        )
+        return cls(client)
+
+    def get_info(self) -> ServerInfo:
+        try:
+            info = self._client.get_info()
+            return ServerInfo(
+                str(info.get("version", "unknown")), bool(info.get("testing"))
+            )
+        except Exception as exc:
+            raise ActivityWatchConnectionError(
+                "ActivityWatch info request failed"
+            ) from exc
+
+    def list_buckets(self) -> tuple[RawBucket, ...]:
+        try:
+            buckets = self._client.get_buckets()
+            return tuple(
+                RawBucket(
+                    id=bucket_id,
+                    type=str(data.get("type", "")),
+                    client=str(data.get("client", "")),
+                    hostname=str(data.get("hostname", "")),
+                )
+                for bucket_id, data in sorted(buckets.items())
+            )
+        except Exception as exc:
+            raise ActivityWatchConnectionError(
+                "ActivityWatch bucket request failed"
+            ) from exc
+
+    def get_events(
+        self, bucket_id: str, start: datetime, end: datetime
+    ) -> tuple[RawEvent, ...]:
+        try:
+            events: Sequence[Any] = self._client.get_events(
+                bucket_id, start=start, end=end
+            )
+            return tuple(
+                RawEvent(
+                    id=str(event.id),
+                    timestamp=event.timestamp,
+                    duration_seconds=(
+                        event.duration.total_seconds()
+                        if isinstance(event.duration, timedelta)
+                        else float(event.duration)
+                    ),
+                    data=event.data,
+                )
+                for event in events
+            )
+        except Exception as exc:
+            raise ActivityWatchConnectionError(
+                f"ActivityWatch event request failed for bucket {bucket_id!r}"
+            ) from exc

daytrace-0.1.0/src/daytrace/time.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from datetime import date, datetime, time, timedelta
+from zoneinfo import ZoneInfo
+
+from tzlocal import get_localzone_name
+
+from daytrace.models import DayWindow
+
+
+def resolve_day(day: date, timezone_name: str | None = None) -> DayWindow:
+    name = timezone_name or get_localzone_name()
+    zone = ZoneInfo(name)
+    start = datetime.combine(day, time.min, zone)
+    end = datetime.combine(day + timedelta(days=1), time.min, zone)
+    return DayWindow(timezone_name=name, start=start, end=end)

daytrace-0.1.0/src/daytrace/transform.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Iterable
+from dataclasses import replace
+from datetime import datetime, timedelta
+
+from daytrace.models import ActivityRecord, SourceKind
+
+
+def _sort(records: Iterable[ActivityRecord]) -> tuple[ActivityRecord, ...]:
+    return tuple(
+        sorted(records, key=lambda item: (item.start, item.bucket_id, item.event_id))
+    )
+
+
+def _union(
+    intervals: Iterable[tuple[datetime, datetime]],
+) -> list[tuple[datetime, datetime]]:
+    merged: list[tuple[datetime, datetime]] = []
+    for start, end in sorted(intervals):
+        if not merged or start > merged[-1][1]:
+            merged.append((start, end))
+        else:
+            merged[-1] = (merged[-1][0], max(merged[-1][1], end))
+    return merged
+
+
+def _subtract_interval(
+    fragments: list[tuple[datetime, datetime]],
+    away_start: datetime,
+    away_end: datetime,
+) -> list[tuple[datetime, datetime]]:
+    output: list[tuple[datetime, datetime]] = []
+    for start, end in fragments:
+        if away_end <= start or away_start >= end:
+            output.append((start, end))
+            continue
+        if start < away_start:
+            output.append((start, away_start))
+        if away_end < end:
+            output.append((away_end, end))
+    return output
+
+
+def remove_afk(records: Iterable[ActivityRecord]) -> tuple[ActivityRecord, ...]:
+    items = tuple(records)
+    away = _union(
+        (item.start, item.end)
+        for item in items
+        if item.kind is SourceKind.AFK and (item.status or "").casefold() == "afk"
+    )
+    output: list[ActivityRecord] = []
+    for item in items:
+        if item.kind is SourceKind.AFK:
+            continue
+        fragments = [(item.start, item.end)]
+        for away_start, away_end in away:
+            fragments = _subtract_interval(fragments, away_start, away_end)
+        output.extend(replace(item, start=start, end=end) for start, end in fragments)
+    return _sort(output)
+
+
+def filter_project(
+    records: Iterable[ActivityRecord], project: str | None
+) -> tuple[ActivityRecord, ...]:
+    if project is None:
+        return _sort(records)
+    needle = project.casefold()
+    return _sort(
+        item
+        for item in records
+        if any(
+            needle in value.casefold()
+            for value in (
+                item.project,
+                item.app,
+                item.title,
+                item.file,
+                item.url_host,
+                item.bucket_id,
+            )
+            if value
+        )
+    )
+
+
+def merge_adjacent(
+    records: Iterable[ActivityRecord],
+    maximum_gap: timedelta = timedelta(seconds=60),
+) -> tuple[ActivityRecord, ...]:
+    by_bucket: dict[str, list[ActivityRecord]] = defaultdict(list)
+    for item in _sort(records):
+        bucket_records = by_bucket[item.bucket_id]
+        if (
+            bucket_records
+            and bucket_records[-1].content_key() == item.content_key()
+            and item.start - bucket_records[-1].end <= maximum_gap
+        ):
+            bucket_records[-1] = replace(
+                bucket_records[-1], end=max(bucket_records[-1].end, item.end)
+            )
+        else:
+            bucket_records.append(item)
+    return _sort(
+        item for bucket_records in by_bucket.values() for item in bucket_records
+    )
+
+
+def partition_window_seconds(
+    records: Iterable[ActivityRecord],
+) -> tuple[tuple[ActivityRecord, float], ...]:
+    windows = tuple(item for item in records if item.kind is SourceKind.WINDOW)
+    boundaries = sorted({point for item in windows for point in (item.start, item.end)})
+    totals: dict[ActivityRecord, float] = defaultdict(float)
+    for start, end in zip(boundaries, boundaries[1:]):
+        candidates = [item for item in windows if item.start < end and item.end > start]
+        if candidates:
+            winner = min(candidates, key=lambda item: (item.bucket_id, item.event_id))
+            totals[winner] += (end - start).total_seconds()
+    return tuple(
+        sorted(totals.items(), key=lambda pair: (pair[0].bucket_id, pair[0].event_id))
+    )