life-pulse 1.0.0

package/dist/collectors/chrome.js

@@ -0,0 +1,49 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { openDb, safeQuery } from '../db.js';
+import dayjs from 'dayjs';
+const CHROME_EPOCH = 11644473600;
+function findChromeDb() {
+    const base = join(homedir(), 'Library/Application Support/Google/Chrome');
+    for (const profile of ['Default', 'Profile 1']) {
+        const p = join(base, profile, 'History');
+        if (existsSync(p))
+            return p;
+    }
+    return null;
+}
+export async function collect() {
+    const dbPath = findChromeDb();
+    if (!dbPath)
+        return { source: 'Chrome', available: false, data: {}, insights: [], todos: [] };
+    const db = openDb(dbPath);
+    if (!db)
+        return { source: 'Chrome', available: false, data: {}, insights: [], todos: [] };
+    try {
+        const monthAgoChrome = (dayjs().subtract(30, 'day').unix() + CHROME_EPOCH) * 1_000_000;
+        const history = safeQuery(db, `SELECT title, url FROM urls
+       WHERE last_visit_time > ? ORDER BY last_visit_time DESC LIMIT 1000`, [monthAgoChrome]);
+        const domainCounts = new Map();
+        for (const row of history) {
+            try {
+                domainCounts.set(new URL(row.url).hostname.replace('www.', ''), (domainCounts.get(new URL(row.url).hostname.replace('www.', '')) || 0) + 1);
+            }
+            catch { }
+        }
+        db.close();
+        return {
+            source: 'Chrome',
+            available: true,
+            data: {
+                totalVisits: history.length,
+                topDomains: [...domainCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 15).map(([d, c]) => ({ domain: d, visits: c })),
+            },
+            insights: [], todos: []
+        };
+    }
+    catch (e) {
+        db.close();
+        return { source: 'Chrome', available: false, data: { error: String(e) }, insights: [], todos: [] };
+    }
+}

package/dist/collectors/findmy.d.ts

@@ -0,0 +1,2 @@
+import { CollectorResult } from '../types.js';
+export declare function collect(): Promise<CollectorResult>;

package/dist/collectors/findmy.js

@@ -0,0 +1,67 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { execSync } from 'child_process';
+const DEVICES_PATH = join(homedir(), 'Library/Caches/com.apple.findmy.fmipcore/Devices.data');
+const ITEMS_PATH = join(homedir(), 'Library/Caches/com.apple.findmy.fmipcore/Items.data');
+export async function collect() {
+    const insights = [];
+    if (!existsSync(DEVICES_PATH) && !existsSync(ITEMS_PATH)) {
+        return { source: 'Find My', available: false, data: {}, insights: [], todos: [] };
+    }
+    try {
+        const devices = [];
+        const items = [];
+        if (existsSync(DEVICES_PATH)) {
+            try {
+                const out = execSync(`plutil -convert json -o - "${DEVICES_PATH}"`, { encoding: 'utf-8', timeout: 5000 });
+                const parsed = JSON.parse(out);
+                if (Array.isArray(parsed))
+                    devices.push(...parsed);
+            }
+            catch { }
+        }
+        if (existsSync(ITEMS_PATH)) {
+            try {
+                const out = execSync(`plutil -convert json -o - "${ITEMS_PATH}"`, { encoding: 'utf-8', timeout: 5000 });
+                const parsed = JSON.parse(out);
+                if (Array.isArray(parsed))
+                    items.push(...parsed);
+            }
+            catch { }
+        }
+        const deviceNames = devices
+            .filter((d) => d.name)
+            .map((d) => ({
+            name: d.name,
+            batteryLevel: d.batteryLevel != null ? Math.round(d.batteryLevel * 100) : null,
+            batteryStatus: d.batteryStatus,
+        }));
+        // Low battery warnings
+        const lowBattery = deviceNames.filter(d => d.batteryLevel != null && d.batteryLevel < 20);
+        if (lowBattery.length > 0) {
+            insights.push({
+                category: 'system',
+                severity: 'warning',
+                title: `Low battery: ${lowBattery.map(d => `${d.name} (${d.batteryLevel}%)`).join(', ')}`,
+                detail: 'Charge soon to avoid losing tracking'
+            });
+        }
+        insights.push({
+            category: 'system',
+            severity: 'info',
+            title: `${deviceNames.length} devices, ${items.length} items tracked`,
+            detail: deviceNames.map(d => d.name).join(', ')
+        });
+        return {
+            source: 'Find My',
+            available: true,
+            data: { devices: deviceNames, items: items.length },
+            insights,
+            todos: []
+        };
+    }
+    catch (e) {
+        return { source: 'Find My', available: false, data: { error: String(e) }, insights: [], todos: [] };
+    }
+}

package/dist/collectors/imessage.d.ts

@@ -0,0 +1,2 @@
+import type { CollectorResult } from '../types.js';
+export declare function collect(): Promise<CollectorResult>;

package/dist/collectors/imessage.js

@@ -0,0 +1,125 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { openDb, safeQuery } from '../db.js';
+import { resolveName } from '../contacts.js';
+import dayjs from 'dayjs';
+const DB_PATH = join(homedir(), 'Library/Messages/chat.db');
+const APPLE_EPOCH = 978307200;
+export async function collect() {
+    const db = openDb(DB_PATH);
+    if (!db)
+        return { source: 'iMessage', available: false, data: {}, insights: [], todos: [] };
+    try {
+        const now = dayjs();
+        const monthAgoNano = BigInt(now.subtract(30, 'day').unix() - APPLE_EPOCH) * BigInt(1_000_000_000);
+        // Get handles
+        const handles = safeQuery(db, 'SELECT ROWID, id FROM handle');
+        const handleMap = new Map(handles.map(h => [h.ROWID, h.id]));
+        // Try to get display names from chat_handle_join + chat table
+        const chatNames = safeQuery(db, `SELECT chj.handle_id, c.display_name
+       FROM chat_handle_join chj
+       JOIN chat c ON c.ROWID = chj.chat_id
+       WHERE c.display_name IS NOT NULL AND c.display_name != ''`);
+        const nameMap = new Map();
+        for (const cn of chatNames) {
+            if (cn.display_name)
+                nameMap.set(cn.handle_id, cn.display_name);
+        }
+        // Messages last 7 days with text
+        const msgs = safeQuery(db, `SELECT text, date, is_from_me, handle_id FROM message
+       WHERE date > ? ORDER BY date DESC`, [monthAgoNano.toString()]);
+        // Per-contact aggregation
+        const contacts = new Map();
+        for (const m of msgs) {
+            const rawHandle = handleMap.get(m.handle_id) || `unknown-${m.handle_id}`;
+            const displayName = nameMap.get(m.handle_id) || resolveName(rawHandle);
+            const c = contacts.get(rawHandle) || {
+                name: displayName, sent: 0, received: 0,
+                lastInbound: null, lastOutbound: null, recentTexts: []
+            };
+            const dateSeconds = Number(BigInt(m.date) / BigInt(1_000_000_000)) + APPLE_EPOCH;
+            const when = dayjs.unix(dateSeconds).format('ddd MMM D h:mm A');
+            const raw = (m.text || '');
+            // Skip tapback reactions
+            if (/^(Loved|Liked|Laughed at|Disliked|Emphasized|Questioned) (".*"|".*"|an? .+)$/.test(raw.trim()))
+                continue;
+            const text = raw.slice(0, 120);
+            if (m.is_from_me) {
+                c.sent++;
+                if (!c.lastOutbound && text)
+                    c.lastOutbound = { text, when };
+            }
+            else {
+                c.received++;
+                if (!c.lastInbound && text)
+                    c.lastInbound = { text, when };
+            }
+            if (text && c.recentTexts.length < 5)
+                c.recentTexts.push(text.slice(0, 80));
+            contacts.set(rawHandle, c);
+        }
+        // Unanswered: they sent last, >24h ago, with actual content
+        const unanswered = [...contacts.entries()]
+            .filter(([, c]) => {
+            if (!c.lastInbound)
+                return false;
+            // Their last message is more recent than our last reply
+            if (c.lastOutbound) {
+                const inDate = msgs.find(m => !m.is_from_me && handleMap.get(m.handle_id) === [...contacts.entries()].find(([, v]) => v === c)?.[0])?.date;
+                const outDate = msgs.find(m => m.is_from_me && handleMap.get(m.handle_id) === [...contacts.entries()].find(([, v]) => v === c)?.[0])?.date;
+                if (inDate && outDate && inDate <= outDate)
+                    return false;
+            }
+            return c.lastInbound.text.length > 0;
+        })
+            .map(([handle, c]) => ({
+            name: c.name,
+            lastMsg: c.lastInbound.text,
+            when: c.lastInbound.when,
+            conversationVolume: c.sent + c.received
+        }))
+            .sort((a, b) => b.conversationVolume - a.conversationVolume)
+            .slice(0, 15);
+        // Top contacts by volume
+        const topContacts = [...contacts.values()]
+            .sort((a, b) => (b.sent + b.received) - (a.sent + a.received))
+            .slice(0, 25)
+            .map(c => ({
+            name: c.name,
+            sent: c.sent,
+            received: c.received,
+            lastInbound: c.lastInbound,
+            lastOutbound: c.lastOutbound,
+        }));
+        // Hourly distribution
+        const hourCounts = new Array(24).fill(0);
+        for (const m of msgs) {
+            const dateSeconds = Number(BigInt(m.date) / BigInt(1_000_000_000)) + APPLE_EPOCH;
+            const hour = dayjs.unix(dateSeconds).hour();
+            hourCounts[hour]++;
+        }
+        const peakHour = hourCounts.indexOf(Math.max(...hourCounts));
+        const totalSent = msgs.filter(m => m.is_from_me).length;
+        const totalReceived = msgs.filter(m => !m.is_from_me).length;
+        db.close();
+        return {
+            source: 'iMessage',
+            available: true,
+            data: {
+                totalMessages: msgs.length,
+                sent: totalSent,
+                received: totalReceived,
+                uniqueContacts: contacts.size,
+                peakHour: `${peakHour}:00`,
+                topContacts,
+                unanswered,
+                lateNight: hourCounts.slice(23).concat(hourCounts.slice(0, 5)).reduce((a, b) => a + b, 0),
+            },
+            insights: [], todos: []
+        };
+    }
+    catch (e) {
+        db.close();
+        return { source: 'iMessage', available: false, data: { error: String(e) }, insights: [], todos: [] };
+    }
+}

package/dist/collectors/mail.d.ts

@@ -0,0 +1,2 @@
+import type { CollectorResult } from '../types.js';
+export declare function collect(): Promise<CollectorResult>;

package/dist/collectors/mail.js

@@ -0,0 +1,49 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { openDb, safeQuery } from '../db.js';
+import dayjs from 'dayjs';
+function findMailDb() {
+    for (const v of ['V10', 'V9', 'V8']) {
+        const p = join(homedir(), `Library/Mail/${v}/MailData/Envelope Index`);
+        if (existsSync(p))
+            return p;
+    }
+    return null;
+}
+export async function collect() {
+    const dbPath = findMailDb();
+    if (!dbPath)
+        return { source: 'Mail', available: false, data: {}, insights: [], todos: [] };
+    const db = openDb(dbPath);
+    if (!db)
+        return { source: 'Mail', available: false, data: {}, insights: [], todos: [] };
+    try {
+        const monthAgo = dayjs().subtract(30, 'day').unix();
+        const unread = safeQuery(db, 'SELECT COUNT(*) as count FROM messages WHERE read = 0');
+        const flagged = safeQuery(db, 'SELECT COUNT(*) as count FROM messages WHERE flagged = 1');
+        const recent = safeQuery(db, 'SELECT COUNT(*) as count FROM messages WHERE date_received > ?', [monthAgo]);
+        // Top senders (unread) — join addresses table for actual email
+        const topSenders = safeQuery(db, `SELECT a.address as sender, COUNT(*) as cnt
+       FROM messages m
+       JOIN addresses a ON m.sender = a.ROWID
+       WHERE m.read = 0
+       GROUP BY a.address ORDER BY cnt DESC LIMIT 15`);
+        db.close();
+        return {
+            source: 'Mail',
+            available: true,
+            data: {
+                recentCount: recent[0]?.count || 0,
+                unreadCount: unread[0]?.count || 0,
+                flaggedCount: flagged[0]?.count || 0,
+                topUnreadSenders: topSenders.map(s => ({ sender: s.sender, count: s.cnt })),
+            },
+            insights: [], todos: []
+        };
+    }
+    catch (e) {
+        db.close();
+        return { source: 'Mail', available: false, data: { error: String(e) }, insights: [], todos: [] };
+    }
+}

package/dist/collectors/notes.d.ts

@@ -0,0 +1,2 @@
+import type { CollectorResult } from '../types.js';
+export declare function collect(): Promise<CollectorResult>;

package/dist/collectors/notes.js

@@ -0,0 +1,42 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { openDb, safeQuery } from '../db.js';
+const DB_PATH = join(homedir(), 'Library/Containers/com.apple.Notes/Data/Library/Notes/NotesV7.storedata');
+const APPLE_EPOCH = 978307200;
+export async function collect() {
+    const db = openDb(DB_PATH);
+    if (!db)
+        return { source: 'Notes', available: false, data: {}, insights: [], todos: [] };
+    try {
+        const notes = safeQuery(db, `SELECT ZTITLE2 as title,
+              datetime(ZMODIFICATIONDATE1 + ${APPLE_EPOCH}, 'unixepoch', 'localtime') as modified,
+              datetime(ZCREATIONDATE3 + ${APPLE_EPOCH}, 'unixepoch', 'localtime') as created
+       FROM ZICNOTEDATA WHERE ZTITLE2 IS NOT NULL
+       ORDER BY ZMODIFICATIONDATE1 DESC LIMIT 30`);
+        // Fallback column names
+        if (notes.length === 0) {
+            notes.push(...safeQuery(db, `SELECT ZTITLE as title,
+                datetime(ZMODIFICATIONDATE1 + ${APPLE_EPOCH}, 'unixepoch', 'localtime') as modified,
+                datetime(ZCREATIONDATE + ${APPLE_EPOCH}, 'unixepoch', 'localtime') as created
+         FROM ZICNOTEDATA WHERE ZTITLE IS NOT NULL
+         ORDER BY ZMODIFICATIONDATE1 DESC LIMIT 30`));
+        }
+        db.close();
+        return {
+            source: 'Notes',
+            available: true,
+            data: {
+                recentNotes: notes.map(n => ({
+                    title: n.title,
+                    modified: n.modified,
+                    created: n.created,
+                }))
+            },
+            insights: [], todos: []
+        };
+    }
+    catch (e) {
+        db.close();
+        return { source: 'Notes', available: false, data: { error: String(e) }, insights: [], todos: [] };
+    }
+}

package/dist/collectors/notifications.d.ts

@@ -0,0 +1,2 @@
+import type { CollectorResult } from '../types.js';
+export declare function collect(): Promise<CollectorResult>;

package/dist/collectors/notifications.js

@@ -0,0 +1,37 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { openDb, safeQuery } from '../db.js';
+import dayjs from 'dayjs';
+const DB_PATH = join(homedir(), 'Library/Group Containers/group.com.apple.usernoted/db2/db');
+export async function collect() {
+    const db = openDb(DB_PATH);
+    if (!db)
+        return { source: 'Notifications', available: false, data: {}, insights: [], todos: [] };
+    try {
+        const monthAgo = dayjs().subtract(30, 'day').unix();
+        const notifs = safeQuery(db, `SELECT app_id, title, body,
+              datetime(delivered_date, 'unixepoch', 'localtime') as delivered
+       FROM record WHERE delivered_date > ?
+       ORDER BY delivered_date DESC LIMIT 5000`, [monthAgo]);
+        const appCounts = new Map();
+        for (const n of notifs) {
+            const app = n.app_id || 'unknown';
+            appCounts.set(app, (appCounts.get(app) || 0) + 1);
+        }
+        const topApps = [...appCounts.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 15)
+            .map(([bundle, count]) => ({ bundle, count }));
+        db.close();
+        return {
+            source: 'Notifications',
+            available: true,
+            data: { total: notifs.length, dailyAvg: Math.round(notifs.length / 30), topApps },
+            insights: [], todos: []
+        };
+    }
+    catch (e) {
+        db.close();
+        return { source: 'Notifications', available: false, data: { error: String(e) }, insights: [], todos: [] };
+    }
+}

package/dist/collectors/recent-files.d.ts

@@ -0,0 +1,2 @@
+import type { CollectorResult } from '../types.js';
+export declare function collect(): Promise<CollectorResult>;

package/dist/collectors/recent-files.js

@@ -0,0 +1,46 @@
+import { execSync } from 'child_process';
+import { homedir } from 'os';
+import { statSync } from 'fs';
+import { join, extname } from 'path';
+import dayjs from 'dayjs';
+export async function collect() {
+    try {
+        const downloads = execSync(`ls -t "${join(homedir(), 'Downloads')}" | head -30`, { encoding: 'utf-8', timeout: 5000 }).trim().split('\n').filter(Boolean);
+        const desktop = execSync(`ls -t "${join(homedir(), 'Desktop')}" | head -30`, { encoding: 'utf-8', timeout: 5000 }).trim().split('\n').filter(Boolean);
+        // Age of downloads
+        let oldCount = 0;
+        const downloadDetails = [];
+        for (const f of downloads.slice(0, 15)) {
+            try {
+                const stat = statSync(join(homedir(), 'Downloads', f));
+                const age = dayjs().diff(dayjs(stat.mtime), 'day');
+                if (age > 7)
+                    oldCount++;
+                downloadDetails.push({ name: f, age: `${age}d` });
+            }
+            catch { }
+        }
+        // Extensions
+        const extCounts = new Map();
+        for (const f of downloads) {
+            const ext = extname(f).toLowerCase() || '(none)';
+            extCounts.set(ext, (extCounts.get(ext) || 0) + 1);
+        }
+        return {
+            source: 'Files',
+            available: true,
+            data: {
+                downloadsCount: downloads.length,
+                desktopCount: desktop.length,
+                oldDownloads: oldCount,
+                recentDownloads: downloadDetails,
+                desktopItems: desktop.slice(0, 15),
+                fileTypes: [...extCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8),
+            },
+            insights: [], todos: []
+        };
+    }
+    catch (e) {
+        return { source: 'Files', available: false, data: { error: String(e) }, insights: [], todos: [] };
+    }
+}

package/dist/collectors/safari.d.ts

@@ -0,0 +1,2 @@
+import type { CollectorResult } from '../types.js';
+export declare function collect(): Promise<CollectorResult>;

package/dist/collectors/safari.js

@@ -0,0 +1,85 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { openDb, safeQuery } from '../db.js';
+import dayjs from 'dayjs';
+const DB_PATH = join(homedir(), 'Library/Safari/History.db');
+const APPLE_EPOCH = 978307200;
+export async function collect() {
+    const db = openDb(DB_PATH);
+    if (!db)
+        return { source: 'Safari', available: false, data: {}, insights: [], todos: [] };
+    try {
+        const monthAgoApple = dayjs().subtract(30, 'day').unix() - APPLE_EPOCH;
+        const history = safeQuery(db, `SELECT hi.url, hv.title,
+              datetime(hv.visit_time + ${APPLE_EPOCH}, 'unixepoch', 'localtime') as visited
+       FROM history_visits hv
+       JOIN history_items hi ON hv.history_item = hi.id
+       WHERE hv.visit_time > ?
+       LIMIT 5000
+       ORDER BY hv.visit_time DESC`, [monthAgoApple]);
+        // Domain frequency
+        const domainCounts = new Map();
+        for (const row of history) {
+            try {
+                const domain = new URL(row.url).hostname.replace('www.', '');
+                domainCounts.set(domain, (domainCounts.get(domain) || 0) + 1);
+            }
+            catch { }
+        }
+        const topDomains = [...domainCounts.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 25)
+            .map(([domain, count]) => ({ domain, visits: count }));
+        // Search queries
+        const searches = [];
+        for (const row of history) {
+            try {
+                const u = new URL(row.url);
+                const q = u.searchParams.get('q') || u.searchParams.get('query') || u.searchParams.get('search_query');
+                if (q && (u.hostname.includes('google') || u.hostname.includes('bing') || u.hostname.includes('duckduckgo') || u.hostname.includes('youtube'))) {
+                    searches.push({ query: q, when: row.visited });
+                }
+            }
+            catch { }
+        }
+        // Dedupe searches but keep chronology
+        const seen = new Set();
+        const uniqueSearches = searches.filter(s => {
+            const key = s.query.toLowerCase();
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        }).slice(0, 40);
+        // Recent page titles (interesting ones, not just google/blank)
+        const interestingPages = history
+            .filter(h => h.title && h.title.length > 10 && !h.title.startsWith('Google'))
+            .slice(0, 30)
+            .map(h => ({ title: h.title, url: new URL(h.url).hostname, when: h.visited }));
+        // Hourly pattern
+        const hourCounts = new Array(24).fill(0);
+        for (const h of history) {
+            if (h.visited) {
+                const hour = parseInt(h.visited.split(' ')[1]?.split(':')[0] || '0');
+                hourCounts[hour]++;
+            }
+        }
+        db.close();
+        return {
+            source: 'Safari',
+            available: true,
+            data: {
+                totalVisits: history.length,
+                topDomains,
+                searches: uniqueSearches,
+                recentPages: interestingPages,
+                peakBrowsingHour: `${hourCounts.indexOf(Math.max(...hourCounts))}:00`,
+            },
+            insights: [], todos: []
+        };
+    }
+    catch (e) {
+        db.close();
+        return { source: 'Safari', available: false, data: { error: String(e) }, insights: [], todos: [] };
+    }
+}

package/dist/collectors/screen-time.d.ts

@@ -0,0 +1,2 @@
+import type { CollectorResult } from '../types.js';
+export declare function collect(): Promise<CollectorResult>;

package/dist/collectors/screen-time.js

@@ -0,0 +1,72 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { openDb, safeQuery } from '../db.js';
+import dayjs from 'dayjs';
+const DB_PATH = join(homedir(), 'Library/Application Support/Knowledge/knowledgeC.db');
+const APPLE_EPOCH = 978307200;
+export async function collect() {
+    const db = openDb(DB_PATH);
+    if (!db)
+        return { source: 'Screen Time', available: false, data: {}, insights: [], todos: [] };
+    try {
+        const monthAgoApple = dayjs().subtract(30, 'day').unix() - APPLE_EPOCH;
+        const usage = safeQuery(db, `SELECT ZOBJECT.ZVALUESTRING as app,
+              (ZOBJECT.ZENDDATE - ZOBJECT.ZSTARTDATE) as duration,
+              datetime(ZOBJECT.ZSTARTDATE + ${APPLE_EPOCH}, 'unixepoch', 'localtime') as start_time
+       FROM ZOBJECT
+       WHERE ZSTREAMNAME = '/app/usage'
+         AND ZOBJECT.ZSTARTDATE > ?
+         AND ZOBJECT.ZVALUESTRING IS NOT NULL
+       ORDER BY ZOBJECT.ZSTARTDATE DESC`, [monthAgoApple]);
+        // Per-app totals
+        const appTotals = new Map();
+        const hourlyTotal = new Array(24).fill(0);
+        const dailyTotal = new Map(); // day -> seconds
+        for (const row of usage) {
+            if (!row.app || row.duration <= 0 || row.duration > 86400)
+                continue;
+            appTotals.set(row.app, (appTotals.get(row.app) || 0) + row.duration);
+            if (row.start_time) {
+                const parts = row.start_time.split(' ');
+                const hour = parseInt(parts[1]?.split(':')[0] || '0');
+                hourlyTotal[hour] += row.duration;
+                const day = parts[0];
+                dailyTotal.set(day, (dailyTotal.get(day) || 0) + row.duration);
+            }
+        }
+        const ranked = [...appTotals.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .map(([bundle, secs]) => ({
+            app: bundle.replace(/^com\./, '').replace(/\./g, ' '),
+            bundle,
+            hours: +(secs / 3600).toFixed(1),
+        }));
+        const totalHours = ranked.reduce((s, r) => s + r.hours, 0);
+        // Late night: 11pm-5am
+        const lateNightHours = +([23, 0, 1, 2, 3, 4].reduce((s, h) => s + hourlyTotal[h], 0) / 3600).toFixed(1);
+        // Peak usage hour
+        const peakHour = hourlyTotal.indexOf(Math.max(...hourlyTotal));
+        // Daily breakdown
+        const dailyBreakdown = [...dailyTotal.entries()]
+            .sort()
+            .map(([day, secs]) => ({ day, hours: +(secs / 3600).toFixed(1) }));
+        db.close();
+        return {
+            source: 'Screen Time',
+            available: true,
+            data: {
+                totalHours: +totalHours.toFixed(1),
+                dailyAvgHours: +(totalHours / 30).toFixed(1),
+                lateNightHours,
+                peakHour: `${peakHour}:00`,
+                topApps: ranked.slice(0, 20),
+                dailyBreakdown,
+            },
+            insights: [], todos: []
+        };
+    }
+    catch (e) {
+        db.close();
+        return { source: 'Screen Time', available: false, data: { error: String(e) }, insights: [], todos: [] };
+    }
+}

package/dist/collectors/shell-history.d.ts

@@ -0,0 +1,2 @@
+import type { CollectorResult } from '../types.js';
+export declare function collect(): Promise<CollectorResult>;

package/dist/collectors/shell-history.js

@@ -0,0 +1,44 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { readFileSync, existsSync } from 'fs';
+export async function collect() {
+    const zshPath = join(homedir(), '.zsh_history');
+    const bashPath = join(homedir(), '.bash_history');
+    const histPath = existsSync(zshPath) ? zshPath : existsSync(bashPath) ? bashPath : null;
+    if (!histPath)
+        return { source: 'Shell', available: false, data: {}, insights: [], todos: [] };
+    try {
+        const raw = readFileSync(histPath, 'utf-8');
+        const lines = raw.split('\n').filter(Boolean);
+        const commands = [];
+        for (const line of lines.slice(-2000)) {
+            const match = line.match(/^: (\d+):\d+;(.*)/);
+            if (match)
+                commands.push({ ts: parseInt(match[1]), cmd: match[2] });
+            else if (!line.startsWith(':'))
+                commands.push({ cmd: line });
+        }
+        // Frequency
+        const cmdCounts = new Map();
+        for (const c of commands) {
+            const base = c.cmd.split(/\s+/)[0];
+            if (base)
+                cmdCounts.set(base, (cmdCounts.get(base) || 0) + 1);
+        }
+        // Recent unique commands (last 50)
+        const recentUnique = [...new Set(commands.slice(-100).map(c => c.cmd))].slice(-30);
+        return {
+            source: 'Shell',
+            available: true,
+            data: {
+                total: commands.length,
+                topCommands: [...cmdCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 15).map(([cmd, n]) => ({ cmd, count: n })),
+                recentCommands: recentUnique,
+            },
+            insights: [], todos: []
+        };
+    }
+    catch (e) {
+        return { source: 'Shell', available: false, data: { error: String(e) }, insights: [], todos: [] };
+    }
+}

package/dist/contacts.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Contact name resolution from macOS AddressBook.
+ * Builds a phone/email → name lookup by reading SQLite databases.
+ */
+export declare function buildContactMap(): Map<string, string>;
+/** Resolve a phone number or email to a contact name */
+export declare function resolveName(handle: string | null | undefined): string;