upii 0.7.0__tar.gz

upii-0.7.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maddy
+
+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.

upii-0.7.0/PKG-INFO

@@ -0,0 +1,199 @@
+Metadata-Version: 2.4
+Name: upii
+Version: 0.7.0
+Summary: Local-first memory for AI: cited answers over your own documents, 100% on-device
+Author-email: Maddy <maddy@datafrontier.co>
+License: MIT
+Project-URL: Homepage, https://github.com/maddymaster/UPII
+Project-URL: Repository, https://github.com/maddymaster/UPII
+Project-URL: Issues, https://github.com/maddymaster/UPII/issues
+Keywords: rag,local-first,memory,llm,privacy,vector-search,knowledge-base,ollama
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Indexing
+Requires-Python: <3.13,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: click<8.2
+Requires-Dist: rich>=13.0
+Requires-Dist: pydantic>=2.5
+Requires-Dist: lancedb>=0.5.0
+Requires-Dist: pyarrow>=14.0.2
+Requires-Dist: numpy<2
+Requires-Dist: sentence-transformers>=2.3.1
+Requires-Dist: ollama>=0.1.6
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: watchdog>=4.0.0
+Requires-Dist: tenacity>=8.2
+Requires-Dist: pypdf>=3.17.0
+Provides-Extra: overlay
+Requires-Dist: pynput>=1.7; extra == "overlay"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: psutil; extra == "dev"
+Requires-Dist: pyinstaller; extra == "dev"
+Requires-Dist: sqlite-utils>=3.36; extra == "dev"
+Requires-Dist: tomli; python_version < "3.11" and extra == "dev"
+Dynamic: license-file
+
+# UPII — your memory, on your machine
+
+**Local-first memory for AI. Ingest your notes and documents, ask questions, get answers with citations — and no byte of your corpus ever leaves your device.**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Python 3.10–3.12](https://img.shields.io/badge/python-3.10%E2%80%933.12-blue.svg)](https://www.python.org/downloads/)
+
+```
+$ upii ask "What did we agree with ICEYE on resolution and latency?"
+
+  Answer: You agreed on 0.5 m resolution imagery with a 6-hour delivery
+  SLA, with latency relaxed to 12 hours during the pilot phase.
+
+  Sources:
+    [1] meetings/2026-03-14_iceye_sync.md   (chunk a3f2c9)
+    [2] contracts/iceye_pilot_terms.md      (chunk 77d01b)
+```
+
+<!-- TODO: replace with demo.gif — 15s: ingest a folder, ask, cited answer, unplug wifi, ask again -->
+
+> **Status:** early preview. The core capture, retrieval and ambient stack works
+> and is tested, but interfaces are still moving.
+>
+> **Known gaps — worth knowing before you judge the claims above:**
+> - **The relational retrieval signal is off by default.** Ingestion now populates
+>   a local knowledge graph (people/orgs/projects) and `upii knowledge --graph`
+>   renders it, but on the retrieval eval, letting the relational signal re-rank is
+>   not yet net-positive (it can boost a chunk that merely *mentions* a query entity
+>   over a better semantic match), so its fusion weight defaults to 0. Retrieval
+>   today is effectively semantic + (recency-weighted) temporal; raise the signal
+>   per query with `upii ask --w-relational`. Tuning it to help is ongoing.
+
+## Why UPII
+
+Most RAG and "second brain" tools upload your corpus to someone else's cloud and rent your own memory back to you. UPII inverts that:
+
+- **100% local.** Embeddings ([sentence-transformers](https://www.sbert.net/) MiniLM), vector store ([LanceDB](https://lancedb.com/)), metadata (SQLite), and reasoning ([Ollama](https://ollama.com)) all run on-device. A remote LLM (Gemini) is optional and swappable — never required.
+- **Every answer is cited.** Answers are attributed to source chunks by content-addressed ID. Retrieval is verifiable, not just plausible.
+- **Deterministic, reproducible memory.** Chunk IDs are a pure function of content + config. Re-ingesting the same corpus reproduces 100% of chunk hashes — validated by tests and benchmarks. Citations stay stable across re-indexes; re-embedding is cache-safe.
+- **More than cosine similarity.** The Context Rehydrator is built to fuse three signals — semantic (vectors), temporal ("what was I working on last week"), and relational (a local knowledge graph of people, projects, orgs, populated on ingest) — into one ranked context window, with per-signal contributions visible via `upii ask --debug`. Measured, not asserted: **Recall@10 = 0.958** on a committed labelled set ([reproduce it](eval/README.md)). The relational signal is live but weight-0 by default until it's tuned to help (see [Status](#status)); the score above is from semantic + temporal.
+- **Consent-gated ambient capture.** A filesystem watcher keeps memory current, but sources are explicitly enabled and ambient events pass through an approval inbox before entering durable memory.
+- **Graceful degradation.** No GPU, no API key, no internet? Retrieval still works and the system still answers.
+
+## Quickstart
+
+Requires Python 3.10–3.12.
+
+```bash
+pip install upii            # or: pipx install upii
+
+upii doctor                 # verify the local stack (db, vectors, model, disk)
+upii ingest ./notes --recursive
+upii search "satellite latency"
+upii ask "What did we agree with ICEYE on resolution and latency?"
+```
+
+First run downloads the embedding model (`all-MiniLM-L6-v2`, ~90 MB) — the only download UPII ever needs. For local reasoning, install [Ollama](https://ollama.com) and `ollama pull llama3.2`; without it, UPII falls back to retrieval + a deterministic mock, so it always responds.
+
+### From source
+
+```bash
+git clone https://github.com/<you>/upii && cd upii
+python3 -m venv venv && source venv/bin/activate   # Windows: venv\Scripts\activate
+pip install -e ".[dev]"
+pytest tests/ -q
+```
+
+## Usage
+
+```bash
+upii ingest ./notes --recursive   # build memory from a directory (idempotent)
+upii search "satellite latency"   # semantic + attributed retrieval
+upii ask "…"                      # cited answer over your corpus
+upii write "follow-up" --target email   # synthesize in your voice
+upii watch ./inbox                # ambient capture (consent-gated)
+upii inbox                        # approve/reject ambient captures
+upii knowledge --graph            # render the local knowledge graph to HTML
+upii sources list                 # manage enabled sources
+upii metrics show                 # observability
+upii doctor                       # health check
+```
+
+Run `upii --help` for the full command set.
+
+## How it works
+
+```mermaid
+graph TD
+    User[User / Ambient Sources] -->|ingest| IngestionEngine
+    User -->|ask / search| Rehydrator
+
+    subgraph "Everything runs locally"
+        IngestionEngine -->|hash + dedup| MetadataStore[(SQLite — source of truth)]
+        IngestionEngine -->|deterministic chunking| Chunker
+        Chunker -->|local embeddings| Embedder
+        Embedder -->|store vectors| VectorStore[(LanceDB)]
+
+        Rehydrator -->|semantic| VectorStore
+        Rehydrator -->|temporal + relational| MetadataStore
+        Rehydrator -->|fused context| LLM[Ollama local / optional remote]
+        LLM -->|attributed answer| User
+    end
+```
+
+Every write path — `ingest`, watch-approve, demo seed — flows through a single deterministic pipeline (`src/upii/ingestion/pipeline.py`):
+
+- **Identity is content-addressed.** `doc_id = hash(content)`, `chunk_id = hash(chunk_text, config)`. No random UUIDs, no wall-clock, no path dependence. Same input ⇒ same memory state.
+- **Dedup** — re-ingesting unchanged bytes is a no-op.
+- **Edit** — a changed file re-chunks only what changed; unchanged chunk hashes stay stable; the prior version (chunks + vectors + metadata) is purged.
+- **Delete** — removal cleans chunks, vectors, and metadata together.
+
+Reproduce it yourself:
+
+```bash
+bash scripts/demo/repro_demo.sh                          # ingest → re-ingest → identical state
+python scripts/bench/scale_check.py --docs 500 --paras 60   # scale + hash-reproducibility report
+```
+
+## How UPII compares
+
+| | UPII | Cloud RAG / memory APIs | Typical local RAG |
+|---|---|---|---|
+| Corpus stays on device | ✅ always | ❌ | ✅ |
+| Cited, chunk-level attribution | ✅ | varies | rarely |
+| Reproducible ingestion (stable hashes) | ✅ 100% | ❌ | ❌ |
+| Temporal + relational retrieval signals | ✅ both built; relational off by default ([status](#status)) | ❌ | ❌ cosine only |
+| Works fully offline | ✅ | ❌ | usually |
+| Consent-gated ambient capture | ✅ | ❌ | ❌ |
+
+## Roadmap
+
+- **Tune the relational signal to net-positive** — it re-ranks on knowledge-graph entity overlap but currently isn't a clear win on the eval, so it ships weight-0; make it help before enabling by default
+- **Batched vector writes** — remove the per-document LanceDB append that caps ingestion throughput
+- **MCP server** — expose `upii_search` / `upii_ask` as local MCP tools so Claude, Cursor, and other agents can use your private, cited memory ([scope](docs/mcp_server_scope.md))
+- Mail + calendar connectors (consent-gated)
+- Answer verification / abstention
+- Signed installers for macOS, Windows, Linux
+- `upii forget` — user-facing verified deletion
+
+## Contributing
+
+Issues and PRs welcome. Start with:
+
+```bash
+pip install -e ".[dev]" && pytest tests/ -q
+```
+
+Hard constraints for any change: local-first (no required cloud dependency), deterministic ingestion (same input ⇒ same chunk hashes), and consent-gating for any ambient capture path. See `tests/test_chunk_determinism.py` for the invariants that must hold.
+
+## License
+
+MIT © 2026 Maddy

upii-0.7.0/README.md

@@ -0,0 +1,152 @@
+# UPII — your memory, on your machine
+
+**Local-first memory for AI. Ingest your notes and documents, ask questions, get answers with citations — and no byte of your corpus ever leaves your device.**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Python 3.10–3.12](https://img.shields.io/badge/python-3.10%E2%80%933.12-blue.svg)](https://www.python.org/downloads/)
+
+```
+$ upii ask "What did we agree with ICEYE on resolution and latency?"
+
+  Answer: You agreed on 0.5 m resolution imagery with a 6-hour delivery
+  SLA, with latency relaxed to 12 hours during the pilot phase.
+
+  Sources:
+    [1] meetings/2026-03-14_iceye_sync.md   (chunk a3f2c9)
+    [2] contracts/iceye_pilot_terms.md      (chunk 77d01b)
+```
+
+<!-- TODO: replace with demo.gif — 15s: ingest a folder, ask, cited answer, unplug wifi, ask again -->
+
+> **Status:** early preview. The core capture, retrieval and ambient stack works
+> and is tested, but interfaces are still moving.
+>
+> **Known gaps — worth knowing before you judge the claims above:**
+> - **The relational retrieval signal is off by default.** Ingestion now populates
+>   a local knowledge graph (people/orgs/projects) and `upii knowledge --graph`
+>   renders it, but on the retrieval eval, letting the relational signal re-rank is
+>   not yet net-positive (it can boost a chunk that merely *mentions* a query entity
+>   over a better semantic match), so its fusion weight defaults to 0. Retrieval
+>   today is effectively semantic + (recency-weighted) temporal; raise the signal
+>   per query with `upii ask --w-relational`. Tuning it to help is ongoing.
+
+## Why UPII
+
+Most RAG and "second brain" tools upload your corpus to someone else's cloud and rent your own memory back to you. UPII inverts that:
+
+- **100% local.** Embeddings ([sentence-transformers](https://www.sbert.net/) MiniLM), vector store ([LanceDB](https://lancedb.com/)), metadata (SQLite), and reasoning ([Ollama](https://ollama.com)) all run on-device. A remote LLM (Gemini) is optional and swappable — never required.
+- **Every answer is cited.** Answers are attributed to source chunks by content-addressed ID. Retrieval is verifiable, not just plausible.
+- **Deterministic, reproducible memory.** Chunk IDs are a pure function of content + config. Re-ingesting the same corpus reproduces 100% of chunk hashes — validated by tests and benchmarks. Citations stay stable across re-indexes; re-embedding is cache-safe.
+- **More than cosine similarity.** The Context Rehydrator is built to fuse three signals — semantic (vectors), temporal ("what was I working on last week"), and relational (a local knowledge graph of people, projects, orgs, populated on ingest) — into one ranked context window, with per-signal contributions visible via `upii ask --debug`. Measured, not asserted: **Recall@10 = 0.958** on a committed labelled set ([reproduce it](eval/README.md)). The relational signal is live but weight-0 by default until it's tuned to help (see [Status](#status)); the score above is from semantic + temporal.
+- **Consent-gated ambient capture.** A filesystem watcher keeps memory current, but sources are explicitly enabled and ambient events pass through an approval inbox before entering durable memory.
+- **Graceful degradation.** No GPU, no API key, no internet? Retrieval still works and the system still answers.
+
+## Quickstart
+
+Requires Python 3.10–3.12.
+
+```bash
+pip install upii            # or: pipx install upii
+
+upii doctor                 # verify the local stack (db, vectors, model, disk)
+upii ingest ./notes --recursive
+upii search "satellite latency"
+upii ask "What did we agree with ICEYE on resolution and latency?"
+```
+
+First run downloads the embedding model (`all-MiniLM-L6-v2`, ~90 MB) — the only download UPII ever needs. For local reasoning, install [Ollama](https://ollama.com) and `ollama pull llama3.2`; without it, UPII falls back to retrieval + a deterministic mock, so it always responds.
+
+### From source
+
+```bash
+git clone https://github.com/<you>/upii && cd upii
+python3 -m venv venv && source venv/bin/activate   # Windows: venv\Scripts\activate
+pip install -e ".[dev]"
+pytest tests/ -q
+```
+
+## Usage
+
+```bash
+upii ingest ./notes --recursive   # build memory from a directory (idempotent)
+upii search "satellite latency"   # semantic + attributed retrieval
+upii ask "…"                      # cited answer over your corpus
+upii write "follow-up" --target email   # synthesize in your voice
+upii watch ./inbox                # ambient capture (consent-gated)
+upii inbox                        # approve/reject ambient captures
+upii knowledge --graph            # render the local knowledge graph to HTML
+upii sources list                 # manage enabled sources
+upii metrics show                 # observability
+upii doctor                       # health check
+```
+
+Run `upii --help` for the full command set.
+
+## How it works
+
+```mermaid
+graph TD
+    User[User / Ambient Sources] -->|ingest| IngestionEngine
+    User -->|ask / search| Rehydrator
+
+    subgraph "Everything runs locally"
+        IngestionEngine -->|hash + dedup| MetadataStore[(SQLite — source of truth)]
+        IngestionEngine -->|deterministic chunking| Chunker
+        Chunker -->|local embeddings| Embedder
+        Embedder -->|store vectors| VectorStore[(LanceDB)]
+
+        Rehydrator -->|semantic| VectorStore
+        Rehydrator -->|temporal + relational| MetadataStore
+        Rehydrator -->|fused context| LLM[Ollama local / optional remote]
+        LLM -->|attributed answer| User
+    end
+```
+
+Every write path — `ingest`, watch-approve, demo seed — flows through a single deterministic pipeline (`src/upii/ingestion/pipeline.py`):
+
+- **Identity is content-addressed.** `doc_id = hash(content)`, `chunk_id = hash(chunk_text, config)`. No random UUIDs, no wall-clock, no path dependence. Same input ⇒ same memory state.
+- **Dedup** — re-ingesting unchanged bytes is a no-op.
+- **Edit** — a changed file re-chunks only what changed; unchanged chunk hashes stay stable; the prior version (chunks + vectors + metadata) is purged.
+- **Delete** — removal cleans chunks, vectors, and metadata together.
+
+Reproduce it yourself:
+
+```bash
+bash scripts/demo/repro_demo.sh                          # ingest → re-ingest → identical state
+python scripts/bench/scale_check.py --docs 500 --paras 60   # scale + hash-reproducibility report
+```
+
+## How UPII compares
+
+| | UPII | Cloud RAG / memory APIs | Typical local RAG |
+|---|---|---|---|
+| Corpus stays on device | ✅ always | ❌ | ✅ |
+| Cited, chunk-level attribution | ✅ | varies | rarely |
+| Reproducible ingestion (stable hashes) | ✅ 100% | ❌ | ❌ |
+| Temporal + relational retrieval signals | ✅ both built; relational off by default ([status](#status)) | ❌ | ❌ cosine only |
+| Works fully offline | ✅ | ❌ | usually |
+| Consent-gated ambient capture | ✅ | ❌ | ❌ |
+
+## Roadmap
+
+- **Tune the relational signal to net-positive** — it re-ranks on knowledge-graph entity overlap but currently isn't a clear win on the eval, so it ships weight-0; make it help before enabling by default
+- **Batched vector writes** — remove the per-document LanceDB append that caps ingestion throughput
+- **MCP server** — expose `upii_search` / `upii_ask` as local MCP tools so Claude, Cursor, and other agents can use your private, cited memory ([scope](docs/mcp_server_scope.md))
+- Mail + calendar connectors (consent-gated)
+- Answer verification / abstention
+- Signed installers for macOS, Windows, Linux
+- `upii forget` — user-facing verified deletion
+
+## Contributing
+
+Issues and PRs welcome. Start with:
+
+```bash
+pip install -e ".[dev]" && pytest tests/ -q
+```
+
+Hard constraints for any change: local-first (no required cloud dependency), deterministic ingestion (same input ⇒ same chunk hashes), and consent-gating for any ambient capture path. See `tests/test_chunk_determinism.py` for the invariants that must hold.
+
+## License
+
+MIT © 2026 Maddy

upii-0.7.0/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "upii"
+version = "0.7.0"
+authors = [
+  { name = "Maddy", email = "maddy@datafrontier.co" },
+]
+description = "Local-first memory for AI: cited answers over your own documents, 100% on-device"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10,<3.13"
+keywords = ["rag", "local-first", "memory", "llm", "privacy", "vector-search", "knowledge-base", "ollama"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: End Users/Desktop",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Text Processing :: Indexing",
+]
+dependencies = [
+    "typer>=0.9.0",
+    "click<8.2",              # typer 0.9.x incompatible with click>=8.2
+    "rich>=13.0",
+    "pydantic>=2.5",
+    "lancedb>=0.5.0",
+    "pyarrow>=14.0.2",        # >=17 required for Python 3.13+ wheels if ceiling is lifted
+    "numpy<2",                # pyarrow 14.x / lancedb 0.5.x are not numpy-2 safe
+    "sentence-transformers>=2.3.1",
+    "ollama>=0.1.6",
+    "PyYAML>=6.0",
+    "watchdog>=4.0.0",
+    "tenacity>=8.2",
+    "pypdf>=3.17.0",
+]
+
+[project.optional-dependencies]
+overlay = [
+    "pynput>=1.7",            # Cmd+Shift+K capture overlay (desktop only)
+]
+dev = [
+    "pytest>=7.4",
+    "psutil",                 # tests/perf/test_long_running.py
+    "pyinstaller",            # standalone binary builds
+    "sqlite-utils>=3.36",     # DB inspection during development
+    "tomli; python_version < '3.11'",   # tests/test_version.py; tomllib is stdlib from 3.11
+]
+
+[project.urls]
+Homepage = "https://github.com/maddymaster/UPII"
+Repository = "https://github.com/maddymaster/UPII"
+Issues = "https://github.com/maddymaster/UPII/issues"
+
+[project.scripts]
+upii = "upii.cli:app"
+
+[tool.setuptools.packages.find]
+where = ["src"]

upii-0.7.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

upii-0.7.0/src/upii/__init__.py

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

upii-0.7.0/src/upii/ambient/calendar_connector.py

@@ -0,0 +1,106 @@
+import os
+import re
+import datetime
+import uuid
+from typing import List, Dict, Generator
+from upii.core.logger import logger
+from upii.storage.db import DB
+
+class CalendarConnector:
+    """
+    Parses .ics files and ingests metadata into LTM.
+    Focus: Title, Start, End, Participants.
+    """
+    
+    def __init__(self):
+        self.db = DB()
+        
+    def process_file(self, file_path: str) -> int:
+        """Parses an ICS file and saves events. Returns count."""
+        if not os.path.exists(file_path):
+            logger.error(f"Calendar file not found: {file_path}")
+            return 0
+            
+        count = 0
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                
+            events = self._parse_ics(content)
+            self.db.init_db()
+            
+            for event in events:
+                event['source_file'] = os.path.basename(file_path)
+                self.db.add_calendar_event(event)
+                count += 1
+                
+            logger.info(f"Ingested {count} calendar events from {file_path}")
+        except Exception as e:
+            logger.error(f"Failed to process calendar {file_path}: {e}")
+            
+        return count
+
+    def _parse_ics(self, content: str) -> List[Dict]:
+        """
+        Robust-ish Regex parser for ICS. 
+        (Production would use `icalendar` lib, but we avoid deps here).
+        """
+        events = []
+        # Split by VEVENT
+        raw_events = re.findall(r'BEGIN:VEVENT(.*?)END:VEVENT', content, re.DOTALL)
+        
+        for raw in raw_events:
+            try:
+                # 1. Title (SUMMARY)
+                summary_match = re.search(r'SUMMARY:(.*)', raw)
+                title = summary_match.group(1).strip() if summary_match else "Untitled Event"
+                
+                # 2. Date (DTSTART/DTEND)
+                # Formats: 20230101T120000Z or ;TZID=...:2023...
+                dtstart_match = re.search(r'DTSTART.*?:(\d{8}T\d{6}Z|\d{8}T\d{6}|\d{8})', raw)
+                dtend_match = re.search(r'DTEND.*?:(\d{8}T\d{6}Z|\d{8}T\d{6}|\d{8})', raw)
+                
+                start_str = dtstart_match.group(1) if dtstart_match else None
+                end_str = dtend_match.group(1) if dtend_match else None
+                
+                if not start_str: continue # Skip if no time
+                
+                # Normalize Time
+                start_time = self._parse_ical_date(start_str)
+                end_time = self._parse_ical_date(end_str) if end_str else start_time
+                
+                # 3. Participants (ATTENDEE)
+                # ATTENDEE;CN="Alice Smith":mailto:alice@example.com
+                attendees = []
+                for line in raw.split('\n'):
+                    if line.startswith('ATTENDEE'):
+                        # Extract email or CN
+                        if 'mailto:' in line:
+                            email = line.split('mailto:')[-1].strip()
+                            attendees.append(email)
+                        elif 'CN=' in line:
+                            cn = line.split('CN=')[1].split(':')[0].replace('"','').strip()
+                            attendees.append(cn)
+                
+                events.append({
+                    "event_id": str(uuid.uuid4()),
+                    "title": title,
+                    "start_time": start_time,
+                    "end_time": end_time,
+                    "participants": attendees
+                })
+                
+            except Exception as e:
+                logger.warning(f"Failed to parse event: {e}")
+                
+        return events
+
+    def _parse_ical_date(self, date_str: str) -> str:
+        """Converts ICS date/datetime to ISO8601 string."""
+        # YYYYMMDD
+        if len(date_str) == 8:
+            return f"{date_str[:4]}-{date_str[4:6]}-{date_str[6:]}T00:00:00"
+        
+        # YYYYMMDDTHHMMSS(Z)
+        clean = date_str.replace('Z', '')
+        return f"{clean[:4]}-{clean[4:6]}-{clean[6:8]}T{clean[9:11]}:{clean[11:13]}:{clean[13:]}"

upii-0.7.0/src/upii/ambient/dummy_sources.py

@@ -0,0 +1,54 @@
+import time
+import random
+from upii.ambient.sources import Source, registry
+from upii.core.concurrency import SafeRunner
+from upii.core.logger import logger
+
+class BrowserSource(Source):
+    """Simulates capturing high-dwell web pages."""
+    def __init__(self):
+        super().__init__("browser", "Captures metadata from high-dwell browser tabs.")
+        self.thread = None
+        
+    def start(self):
+        self.is_running = True
+        self.thread = SafeRunner.run_daemon(self._loop, name="BrowserWatcher")
+        
+    def stop(self):
+        self.is_running = False
+        
+    def _loop(self):
+        while self.is_running:
+            time.sleep(10) # Simulate infrequent capture
+            # In a real app, this would poll a browser extension API
+            # Here we just randomly decide to 'capture' something if enabled
+            if random.random() < 0.1: # 10% chance per loop
+                 logger.info("BrowserSource: simulating capture")
+                 fake_url = "https://example.com/interesting-article"
+                 self.storage.add_event("browser_visit", fake_url)
+                 self.storage.log_audit(self.name, "capture", {"url": fake_url, "dwell_time": 120})
+
+class CalendarSource(Source):
+    """Simulates capturing calendar metadata."""
+    def __init__(self):
+        super().__init__("calendar", "Ingests event titles and participants.")
+        
+    def start(self):
+        self.is_running = True
+        # Calendar might be poll-once or interval
+        self.thread = SafeRunner.run_daemon(self._loop, name="CalendarWatcher")
+        
+    def stop(self):
+        self.is_running = False
+        
+    def _loop(self):
+        while self.is_running:
+            time.sleep(20)
+            if random.random() < 0.1:
+                logger.info("CalendarSource: simulating capture")
+                self.storage.add_event("calendar_event", "Meeting with Omega Team")
+                self.storage.log_audit(self.name, "capture", {"summary": "Meeting", "participants": ["alice@example.com"]})
+
+# Register
+registry.register(BrowserSource())
+registry.register(CalendarSource())