wirenote 0.1.0__py3-none-any.whl

wirenote/config/secrets.py

@@ -0,0 +1,98 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""secrets.toml (mode 600): the Claude API key and calendar links.
+
+Calendar links are secret too: anyone with an ICS link can read the calendar.
+Kept out of config.toml so that file can be shared or committed.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import tomllib
+from pathlib import Path
+
+from .settings import config_dir
+
+
+def secrets_path() -> Path:
+    return config_dir() / "secrets.toml"
+
+
+def load_secrets() -> dict:
+    try:
+        return tomllib.loads(secrets_path().read_text())
+    except FileNotFoundError:
+        return {}
+
+
+def save_secrets(data: dict) -> None:
+    """Write strings and string lists; JSON strings are valid TOML basic strings."""
+    lines = ["# wirenote secrets: keep private (mode 600)."]
+    for key, value in data.items():
+        if isinstance(value, str):
+            lines.append(f"{key} = {json.dumps(value, ensure_ascii=False)}")
+        elif isinstance(value, list):
+            lines.append(f"{key} = [")
+            lines += [f"  {json.dumps(str(v), ensure_ascii=False)}," for v in value]
+            lines.append("]")
+    path = secrets_path()
+    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w") as f:
+        f.write("\n".join(lines) + "\n")
+    tmp.replace(path)
+
+
+def calendar_sources(configured: tuple[str, ...]) -> tuple[str, ...]:
+    """Calendar links from config.toml plus those added with `wirenote calendar add`."""
+    extra = tuple(load_secrets().get("calendar_urls", []))
+    return tuple(dict.fromkeys(configured + extra))
+
+
+def with_config_value(text: str, key: str, toml_value: str) -> str:
+    """config.toml text with one top-level key set. Replaces its live line, with
+    every line of a value that spans several (a list, a multi-line string), else
+    its commented-out line, else appends it."""
+    line = f"{key} = {toml_value}\n"
+    lines = text.splitlines(keepends=True)
+    live = re.compile(rf"^[ \t]*{re.escape(key)}[ \t]*=")
+    commented = re.compile(rf"^[ \t]*#[ \t]*{re.escape(key)}[ \t]*=")
+    for i, current in enumerate(lines):
+        if live.match(current):
+            return "".join(lines[:i]) + line + "".join(lines[_value_end(lines, i):])
+    for i, current in enumerate(lines):
+        if commented.match(current):
+            return "".join(lines[:i]) + line + "".join(lines[i + 1:])
+    return text + f"\n{line}"
+
+
+def _value_end(lines: list[str], i: int) -> int:
+    """Index after the last line of the key = value that starts on line i."""
+    for k in range(i + 1, len(lines) + 1):
+        try:
+            tomllib.loads("".join(lines[i:k]))
+            return k
+        except tomllib.TOMLDecodeError:
+            continue
+    return i + 1
+
+
+def write_config_atomic(path: Path, text: str) -> None:
+    """Replace path with text in one step, private to this user (mode 600)."""
+    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w") as f:
+        f.write(text)
+    os.chmod(tmp, 0o600)
+    tmp.replace(path)
+
+
+def set_config_value(path: Path, key: str, toml_value: str) -> None:
+    """Set one top-level key in config.toml, replacing its (commented) line if present."""
+    text = path.read_text() if path.exists() else ""
+    write_config_atomic(path, with_config_value(text, key, toml_value))

wirenote/config/settings.py

@@ -0,0 +1,176 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""config.toml: every default comes from docs/dev/PLAN.md › Defaults."""
+
+from __future__ import annotations
+
+import os
+import tomllib
+from dataclasses import dataclass, fields, replace
+from pathlib import Path
+
+APP = "wirenote"
+
+
+def config_dir() -> Path:
+    return Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / APP
+
+
+def state_dir() -> Path:
+    return Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local/state")) / APP
+
+
+def data_dir() -> Path:
+    return Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local/share")) / APP
+
+
+@dataclass(frozen=True)
+class Settings:
+    # docs/dev/PLAN.md › Defaults › Change detection: PipeWire events + 1 s reconcile
+    reconcile_s: float = 1.0
+    # › Disappearance grace
+    grace_s: float = 4.0
+    # › Dwell before prompt, meeting app
+    dwell_meeting_s: float = 2.0
+    # › Dwell before prompt, browser
+    dwell_browser_s: float = 5.0
+    # › After dismiss: silent until the app's stream ends, then 60 s
+    cooldown_s: float = 60.0
+    # › Min app runtime before auto-stop (a guess, tune from M1 logs)
+    min_app_runtime_s: float = 20.0
+    # › Min recording age before auto-stop
+    min_recording_age_s: float = 30.0
+    # › Max recording length
+    max_recording_s: float = 4 * 3600.0
+    # › Opt-out nudge: dismisses of one app before offering "ignore"
+    nudge_after_dismisses: int = 5
+    # docs/dev/PLAN.md › Capture: our own streams carry this node.name prefix
+    own_node_prefix: str = "wirenote-"
+
+    # Capture (M2) -----------------------------------------------------------
+    # docs/dev/PLAN.md › Defaults › Capture heartbeat: 5 s per track
+    heartbeat_s: float = 5.0
+    # "" means ~/.local/share/wirenote/recordings
+    recordings_dir: str = ""
+    # Record this output's monitor instead of following the default sink ("" = default)
+    system_target: str = ""
+    # Copied to the clipboard on Record when set (docs/dev/PLAN.md › Prompt: consent line)
+    consent_line: str = ""
+
+    # Transcript (M3) --------------------------------------------------------
+    # docs/dev/PLAN.md › Processing: faster-whisper; model chosen in docs/dev/m2-m4-design.md
+    whisper_model: str = "large-v3-turbo"
+    whisper_language: str = "auto"     # or "de", "en", ...
+    # Consecutive lines of one speaker closer than this join into a paragraph
+    merge_gap_s: float = 2.0
+    # Echo dedupe (docs/dev/m2-m4-design.md › M3): overlap share and text similarity
+    echo_overlap: float = 0.5
+    echo_similarity: float = 0.8
+    # Who spoke when on the Others track (docs/dev/features-2-design.md › Speakers).
+    # Model and threshold picked on a 3-speaker test: 3 found, 87% of speech right.
+    diarize: bool = True
+    diarize_model: str = "nemo_en_titanet_small.onnx"
+    diarize_threshold: float = 0.9
+    # Cosine similarity at which a speaker counts as a remembered voice
+    # (same voice measured 0.66-0.88, different voices <= 0.32).
+    voice_match: float = 0.55
+    notes_dir: str = "~/Meetings"
+    # docs/dev/PLAN.md › Processing: delete audio after 30 days
+    audio_retention_days: int = 30
+
+    # Summary (M4) -----------------------------------------------------------
+    summary_backend: str = "ollama"    # ollama | anthropic | none
+    ollama_url: str = "http://127.0.0.1:11434"
+    ollama_model: str = "qwen3:4b"
+    anthropic_model: str = "claude-opus-5-5"
+    # docs/dev/PLAN.md › Processing: long calls are summarized in chunks of about 15 min
+    summary_chunk_s: float = 900.0
+    summary_language: str = "auto"     # "auto": the transcript's language
+
+    # Calendar (M4) ----------------------------------------------------------
+    calendar_urls: tuple = ()          # ICS URLs or file paths
+    # docs/dev/PLAN.md › Defaults › Calendar refresh: every 5 min
+    calendar_refresh_s: float = 300.0
+    # › Calendar window: starts in <=10 min, started <=5 min ago, or in progress
+    calendar_before_s: float = 600.0
+    calendar_after_start_s: float = 300.0
+
+    # UI (docs/dev/ui-design.md): local web app on 127.0.0.1
+    ui_port: int = 8765
+
+    def recordings_path(self) -> Path:
+        return Path(self.recordings_dir).expanduser() if self.recordings_dir \
+            else data_dir() / "recordings"
+
+    def notes_path(self) -> Path:
+        return Path(self.notes_dir).expanduser()
+
+
+DEFAULT_CONFIG_TOML = """# wirenote settings. Defaults come from docs/dev/PLAN.md › Defaults; uncomment to change.
+# reconcile_s = 1.0            # 1 s reconcile next to PipeWire events
+# grace_s = 4.0                # app may drop the mic this long without counting as gone
+# dwell_meeting_s = 2.0        # mic use before prompting, meeting apps
+# dwell_browser_s = 5.0        # mic use before prompting, browsers
+# cooldown_s = 60.0            # after Ignore: silent until the stream ends, then this long
+# min_app_runtime_s = 20.0     # no auto-stop before the app has used the mic this long
+# min_recording_age_s = 30.0   # no auto-stop for younger recordings
+# max_recording_s = 14400.0    # hard stop after 4 h
+# nudge_after_dismisses = 5    # offer "always ignore" after this many dismisses
+
+# Capture
+# heartbeat_s = 5.0            # a track whose file stops growing this long is reported
+# recordings_dir = ""          # default ~/.local/share/wirenote/recordings
+# system_target = ""           # record this output instead of the default one
+# consent_line = ""            # copied to the clipboard on Record, e.g.
+#                              # "Heads-up: I'm recording this call for my notes. OK for everyone?"
+
+# Transcript
+# whisper_model = "large-v3-turbo"   # or "small", "medium", ...
+# whisper_language = "auto"          # or "de", "en"
+# diarize = true                     # tell the other speakers apart
+# diarize_threshold = 0.9            # higher: fewer speakers; lower: more
+# voice_match = 0.55                 # how close a voice must be to a remembered one
+# merge_gap_s = 2.0
+# echo_overlap = 0.5
+# echo_similarity = 0.8
+# notes_dir = "~/Meetings"
+# audio_retention_days = 30          # audio is deleted this long after the note
+
+# Summary
+# summary_backend = "ollama"         # ollama | anthropic | none
+# ollama_url = "http://127.0.0.1:11434"
+# ollama_model = "qwen3:4b"
+# anthropic_model = "claude-opus-5-5"  # API key: ~/.config/wirenote/secrets.toml
+# summary_chunk_s = 900.0
+# summary_language = "auto"          # or "German", "English"
+
+# Calendar
+# calendar_urls = []                 # ICS URLs or files; none means no calendar matching
+# calendar_refresh_s = 300.0
+# calendar_before_s = 600.0
+# calendar_after_start_s = 300.0
+
+# UI
+# ui_port = 8765                     # wirenote ui serves http://127.0.0.1:<port>/
+"""
+
+
+def parse_settings(text: str) -> Settings:
+    data = tomllib.loads(text)
+    known = {f.name: f.type for f in fields(Settings)}
+    unknown = set(data) - set(known)
+    if unknown:
+        raise ValueError(f"config.toml: unknown setting(s) {sorted(unknown)}")
+    base = Settings()
+    coerced = {}
+    for k, v in data.items():
+        default = getattr(base, k)
+        coerced[k] = v if isinstance(default, bool) else type(default)(v)
+    return replace(base, **coerced)
+
+
+def load_settings(path: Path) -> Settings:
+    if not path.exists():
+        path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        path.write_text(DEFAULT_CONFIG_TOML)
+    return parse_settings(path.read_text())

wirenote/config/vocabulary.py

@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""vocabulary.txt: names and terms Whisper should spell right (one per line, # comments)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .settings import config_dir
+
+MAX_TERMS = 200
+
+
+def vocabulary_path() -> Path:
+    return config_dir() / "vocabulary.txt"
+
+
+def load_vocabulary() -> list[str]:
+    try:
+        lines = vocabulary_path().read_text().splitlines()
+    except FileNotFoundError:
+        return []
+    terms = [l.strip() for l in lines if l.strip() and not l.lstrip().startswith("#")]
+    return list(dict.fromkeys(terms))[:MAX_TERMS]
+
+
+def save_vocabulary(terms: list[str]) -> list[str]:
+    clean = list(dict.fromkeys(t.strip() for t in terms if t.strip()))[:MAX_TERMS]
+    path = vocabulary_path()
+    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    path.write_text("# Names and terms for the transcript, one per line.\n" + "\n".join(clean) + "\n")
+    return clean

wirenote/data/wirenote-ui.service

@@ -0,0 +1,15 @@
+# Written by `wirenote setup install`; remove with `wirenote setup uninstall`.
+# The meetings web app on 127.0.0.1 (this user only); open it with `wirenote open`.
+[Unit]
+Description=Wirenote web app (past calls, transcripts, summaries)
+After=graphical-session.target
+PartOf=graphical-session.target
+
+[Service]
+ExecStart=@EXEC@ ui
+UMask=0077
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=graphical-session.target

wirenote/data/wirenote.desktop

@@ -0,0 +1,10 @@
+[Desktop Entry]
+Type=Application
+Name=Wirenote
+GenericName=Meeting notes
+Comment=Past calls: transcripts, summaries and action items
+Exec=@EXEC@ open
+Icon=wirenote
+Terminal=false
+Categories=Office;AudioVideo;
+Keywords=meeting;notes;transcript;call;

wirenote/data/wirenote.service

@@ -0,0 +1,15 @@
+# Written by `wirenote setup install`; remove with `wirenote setup uninstall`.
+# Logs: journalctl --user -u wirenote -f   (events: ~/.local/state/wirenote/detector.jsonl)
+[Unit]
+Description=Wirenote meeting detector
+After=pipewire.service pipewire-pulse.service graphical-session.target
+PartOf=graphical-session.target
+
+[Service]
+ExecStart=@EXEC@ run
+UMask=0077
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=graphical-session.target

wirenote/detector/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav

wirenote/detector/core.py

@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""Synchronous detector: graph mirror -> mic streams -> app identity -> tracker.
+
+No I/O besides the injected ProcReader, so tests replay recorded batches
+against a fake clock. The asyncio daemon wraps this.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from ..config.apps import AppRules
+from ..config.settings import Settings
+from .graph import Graph
+from .identity import Identity, ProcReader, gather_evidence, resolve
+from .streams import MicStream, mic_streams
+from .tracker import Action, Observation, Tracker
+
+
+@dataclass(frozen=True)
+class Identified:
+    """First sight of a client on the mic, with the evidence behind its identity."""
+    client_serial: int | None
+    key: str | None          # None: no rule matched, so it never prompts
+    kind: str | None
+    matched_by: str | None
+    evidence: dict
+
+
+DetectorEvent = Action | Identified
+
+IDENTITY_CACHE_MAX = 256
+
+
+class Detector:
+    def __init__(self, settings: Settings, rules: AppRules, proc: ProcReader,
+                 own_pids: set[int], ignored: set[str] | None = None,
+                 dismisses: dict[str, int] | None = None) -> None:
+        self.settings = settings
+        self.rules = rules
+        self.proc = proc
+        self.own_pids = own_pids
+        self.ignored: set[str] = set(ignored or ())
+        self.graph = Graph()
+        self.tracker = Tracker(settings, dismisses)
+        self._identities: dict[int | None, Identity] = {}
+        # Capture sources each app on the mic is linked to (node.name), for the recorder.
+        self.app_sources: dict[str, tuple[str, ...]] = {}
+        # True while a calendar event with a call link is in its window: browsers
+        # then get the meeting dwell (docs/dev/PLAN.md › Browsers).
+        self.calendar_hint: Callable[[], bool] = lambda: False
+
+    def apply_batch(self, batch: list[dict], now: float) -> list[DetectorEvent]:
+        self.graph.apply(batch)
+        return self.tick(now)
+
+    def reset_graph(self) -> None:
+        """pw-dump restarted; its first batch will be the full graph again."""
+        self.graph.clear()
+
+    def tick(self, now: float) -> list[DetectorEvent]:
+        events: list[DetectorEvent] = []
+        obs = self.observations(events)
+        events += self.tracker.update(now, obs)
+        if len(self._identities) > IDENTITY_CACHE_MAX:
+            self._prune_identities()
+        return events
+
+    def _prune_identities(self) -> None:
+        """Forget clients that left the graph; the daemon runs for weeks."""
+        live = {self.graph.props(c["id"]).get("object.serial")
+                for c in self.graph.of_type(":Client")}
+        self._identities = {k: v for k, v in self._identities.items() if k in live}
+
+    def observations(self, events: list[DetectorEvent] | None = None) -> dict[str, Observation]:
+        by_app: dict[str, list[MicStream]] = {}
+        for stream in mic_streams(self.graph, self.own_pids, self.settings.own_node_prefix):
+            ident = self._identify(stream, events)
+            if ident.rule is None or ident.rule.kind == "ignore" or ident.key in self.ignored:
+                continue
+            by_app.setdefault(ident.key, []).append(stream)
+
+        out = {}
+        hint = None
+        for key, streams in by_app.items():
+            rule = self.rules.get(key)
+            kind, service, room = rule.kind, None, None
+            for s in streams:
+                hit = rule.title_match(s.media_name)
+                if hit:
+                    kind, (service, room) = "meeting", hit
+                    break
+            if kind == "browser":
+                hint = self.calendar_hint() if hint is None else hint
+                if hint:
+                    kind = "meeting"
+            out[key] = Observation(key, rule.name, kind,
+                                   frozenset(s.serial for s in streams), service, room)
+        self.app_sources = {key: tuple(sorted({n for s in streams for n in s.source_names}))
+                            for key, streams in by_app.items()}
+        return out
+
+    def _identify(self, stream: MicStream, events: list[DetectorEvent] | None) -> Identity:
+        cache_key = stream.client_serial if stream.client_serial is not None else -stream.serial
+        ident = self._identities.get(cache_key)
+        if ident is None:
+            ev = gather_evidence(stream.client_props, stream.node_props, self.proc)
+            ident = self._identities[cache_key] = resolve(ev, self.rules)
+            if events is not None:
+                events.append(Identified(stream.client_serial, ident.key,
+                                         ident.rule.kind if ident.rule else None,
+                                         ident.matched_by, ev.as_dict()))
+        return ident