life-pulse 1.0.0

package/dist/auq.js

@@ -0,0 +1,61 @@
+/**
+ * Lightweight AUQ session protocol client.
+ * Speaks the same file protocol as auq-mcp-server so the `auq` TUI picks up questions.
+ */
+import { join } from 'path';
+import { homedir, platform } from 'os';
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'fs';
+import { randomUUID } from 'crypto';
+const SESSION_DIR = process.env.AUQ_SESSION_DIR
+    || (platform() === 'darwin'
+        ? join(homedir(), 'Library', 'Application Support', 'auq', 'sessions')
+        : join(homedir(), '.local', 'share', 'auq', 'sessions'));
+export function createSession(questions) {
+    const sessionId = randomUUID();
+    const dir = join(SESSION_DIR, sessionId);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const now = new Date().toISOString();
+    writeFileSync(join(dir, 'request.json'), JSON.stringify({
+        questions, sessionId, status: 'pending', timestamp: now,
+    }, null, 2), { mode: 0o600 });
+    writeFileSync(join(dir, 'status.json'), JSON.stringify({
+        sessionId, status: 'pending', totalQuestions: questions.length,
+        createdAt: now, lastModified: now,
+    }, null, 2), { mode: 0o600 });
+    return sessionId;
+}
+async function waitForAnswers(sessionId, timeoutMs) {
+    const answersPath = join(SESSION_DIR, sessionId, 'answers.json');
+    const statusPath = join(SESSION_DIR, sessionId, 'status.json');
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (existsSync(statusPath)) {
+            try {
+                const st = JSON.parse(readFileSync(statusPath, 'utf-8'));
+                if (st.status === 'rejected' || st.status === 'abandoned' || st.status === 'timed_out')
+                    return null;
+            }
+            catch { }
+        }
+        if (existsSync(answersPath)) {
+            try {
+                return JSON.parse(readFileSync(answersPath, 'utf-8'));
+            }
+            catch { }
+        }
+        await new Promise(r => setTimeout(r, 500));
+    }
+    return null;
+}
+export async function ask(questions, timeoutMs = 300_000) {
+    const sessionId = createSession(questions);
+    const answers = await waitForAnswers(sessionId, timeoutMs);
+    if (!answers)
+        return '(user did not answer — session timed out or was rejected)';
+    return answers.answers.map(a => {
+        const q = questions[a.questionIndex];
+        const label = q?.title || `Q${a.questionIndex + 1}`;
+        const value = a.selectedOptions?.join(', ') || a.selectedOption || '(no answer)';
+        return `${label}: ${value}`;
+    }).join('\n');
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+import { collectAll } from './index.js';
+import { runAgent } from './agent.js';
+import { analyzeWithLLM } from './analyze.js';
+import { saveState } from './state.js';
+import { ProgressRenderer } from './progress.js';
+import { addTodo, resolveTodos, pruneOld, renderTodoList } from './todo.js';
+import chalk from 'chalk';
+import { createInterface } from 'readline';
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+function loadEnvFile(path) {
+    if (!existsSync(path))
+        return;
+    for (const line of readFileSync(path, 'utf-8').split('\n')) {
+        const m = line.match(/^(\w+)=(.*)$/);
+        if (m && !process.env[m[1]])
+            process.env[m[1]] = m[2];
+    }
+}
+// Project-local .env first (dev), then ~/.config/life-pulse/.env (npm users)
+loadEnvFile(join(dirname(fileURLToPath(import.meta.url)), '..', '.env'));
+loadEnvFile(join(homedir(), '.config', 'life-pulse', '.env'));
+const API_KEY = process.env.OPENROUTER_API_KEY || process.env.LLM_API_KEY || '';
+const ANTHROPIC_KEY = process.env.ANTHROPIC_API_KEY || '';
+function renderList(items, bullet) {
+    for (const item of items) {
+        console.log(`  ${bullet} ${item}`);
+    }
+}
+async function main() {
+    const jsonMode = process.argv.includes('--json');
+    const rawMode = process.argv.includes('--raw');
+    const legacyMode = process.argv.includes('--legacy');
+    const key = process.argv.find(a => a.startsWith('--key='))?.split('=')[1] || API_KEY;
+    if (rawMode) {
+        const collected = await collectAll();
+        console.log(JSON.stringify(collected, null, 2));
+        return;
+    }
+    if (!key && !ANTHROPIC_KEY) {
+        console.log(chalk.red('\n\n  No API key. Set ANTHROPIC_API_KEY or OPENROUTER_API_KEY.\n'));
+        process.exit(1);
+    }
+    // Legacy mode: single-shot LLM call (old behavior)
+    if (legacyMode) {
+        if (!jsonMode)
+            process.stdout.write(chalk.dim('\n  scanning...'));
+        const collected = await collectAll();
+        if (!jsonMode)
+            process.stdout.write(chalk.dim(` ${collected.sources.length} sources → thinking...`));
+        const analysis = await analyzeWithLLM(collected.data, key);
+        if (jsonMode) {
+            console.log(JSON.stringify({ collected, analysis }, null, 2));
+            return;
+        }
+        renderAnalysis(analysis, collected.sources.length, collected.generated);
+        saveState(analysis);
+        return;
+    }
+    // Agent mode (default): multi-turn investigation with Anthropic
+    if (!ANTHROPIC_KEY) {
+        console.log(chalk.red('\n\n  Agent mode requires ANTHROPIC_API_KEY. Use --legacy for OpenRouter mode.\n'));
+        process.exit(1);
+    }
+    const renderer = jsonMode ? undefined : new ProgressRenderer();
+    renderer?.start();
+    // Track streamed cards so we don't double-show from final output
+    const streamedTitles = new Set();
+    let cardCount = 0;
+    let headerShown = false;
+    const onCard = jsonMode ? undefined : async (card) => {
+        if (!headerShown) {
+            console.log();
+            console.log(chalk.bold('  LIFE PULSE'));
+            console.log();
+            headerShown = true;
+        }
+        cardCount++;
+        streamedTitles.add(card.title);
+        return presentCard(card, cardCount);
+    };
+    const analysis = await runAgent(ANTHROPIC_KEY, renderer, onCard);
+    renderer?.stop();
+    renderer?.clear();
+    if (jsonMode) {
+        console.log(JSON.stringify(analysis, null, 2));
+        return;
+    }
+    // Resolve previous todos the agent confirmed done
+    if (analysis.resolved_todos?.length)
+        resolveTodos(analysis.resolved_todos);
+    pruneOld();
+    // Show header if no cards were streamed
+    if (!headerShown) {
+        console.log();
+        console.log(chalk.bold('  LIFE PULSE'));
+        console.log();
+    }
+    // Greeting from final synthesis
+    if (analysis.greeting) {
+        console.log(`  ${analysis.greeting}`);
+        console.log();
+    }
+    // Walk any remaining decisions not already streamed
+    const remaining = (analysis.decisions || []).filter(d => !streamedTitles.has(d.title));
+    if (remaining.length) {
+        await walkDecisions(remaining);
+    }
+    // Add handled items as done todos
+    for (const h of (analysis.handled || [])) {
+        addTodo(h, 'handled', 'today', true);
+    }
+    // Upcoming
+    if (analysis.upcoming?.length) {
+        console.log(chalk.bold.cyan('  UPCOMING'));
+        console.log();
+        renderList(analysis.upcoming, chalk.cyan('▸'));
+        console.log();
+    }
+    // Intel
+    if (analysis.intel?.length) {
+        console.log(chalk.bold.magenta('  INTEL'));
+        console.log();
+        renderList(analysis.intel, chalk.magenta('~'));
+        console.log();
+    }
+    // Full todo list
+    renderTodoList();
+    saveState(analysis);
+}
+function renderCard(d) {
+    const urgencyColor = d.urgency === 'now' ? chalk.red : d.urgency === 'today' ? chalk.yellow : chalk.dim;
+    const tag = d.fyi ? chalk.dim('[fyi]') : urgencyColor(`[${d.urgency}]`);
+    console.log(`  ${d.title || d.ask} ${tag}`);
+    if (d.fyi) {
+        if (d.context)
+            console.log(`  ${chalk.dim('── ' + d.context)}`);
+    }
+    else if (d.options?.length) {
+        for (let j = 0; j < d.options.length; j++) {
+            const letter = String.fromCharCode(97 + j);
+            const opt = d.options[j];
+            const marker = j === 0 ? chalk.green('▸') : ' ';
+            console.log(`     ${marker}${chalk.bold(letter)}) ${opt.label} ${chalk.dim('— ' + opt.description)}`);
+        }
+    }
+    else {
+        // Legacy fallback
+        if (d.context)
+            console.log(`     ${chalk.dim(d.context)}`);
+        if (d.draft)
+            console.log(`     ${chalk.cyan('draft:')} ${d.draft}`);
+    }
+    console.log();
+}
+async function askOne(hint) {
+    if (!process.stdin.isTTY)
+        return '';
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const suffix = hint ? chalk.dim('  (a/b/c, Enter=rec, s=skip)') : '';
+    return new Promise(resolve => {
+        rl.question(chalk.dim('  → ') + suffix, answer => {
+            rl.close();
+            resolve(answer.trim().toLowerCase());
+        });
+    });
+}
+async function presentCard(card, num) {
+    console.log(chalk.dim(`  ─── ${num} ${'─'.repeat(37)}`));
+    console.log();
+    renderCard(card);
+    if (card.fyi || !card.options?.length) {
+        addTodo(card.title, 'noted', card.urgency || 'today', true);
+        return 'noted';
+    }
+    if (!process.stdin.isTTY) {
+        addTodo(card.title, card.options[0].label, card.urgency || 'today');
+        return card.options[0].label;
+    }
+    const answer = await askOne(num === 1);
+    let optIdx;
+    if (!answer) {
+        optIdx = 0;
+    }
+    else if (answer === 's' || answer === '-') {
+        console.log(chalk.dim('  skipped'));
+        console.log();
+        return 'skipped';
+    }
+    else {
+        const match = answer.match(/^([a-d])$/);
+        if (!match) {
+            console.log(chalk.dim('  skipped'));
+            console.log();
+            return 'skipped';
+        }
+        optIdx = match[1].charCodeAt(0) - 97;
+    }
+    const opt = card.options[optIdx];
+    if (!opt) {
+        console.log(chalk.dim('  skipped'));
+        console.log();
+        return 'skipped';
+    }
+    console.log(`  ${chalk.green('✓')} ${opt.label}`);
+    console.log();
+    addTodo(card.title, opt.label, card.urgency || 'today');
+    return opt.label;
+}
+async function walkDecisions(decisions) {
+    const total = decisions.length;
+    let firstPrompt = true;
+    for (let i = 0; i < total; i++) {
+        const d = decisions[i];
+        console.log(chalk.dim(`  ─── ${i + 1}/${total} ${'─'.repeat(34)}`));
+        console.log();
+        renderCard(d);
+        // FYI items: auto-add as done, no prompt
+        if (d.fyi) {
+            addTodo(d.title, 'noted', d.urgency || 'today', true);
+            continue;
+        }
+        // No options or not interactive
+        if (!d.options?.length || !process.stdin.isTTY)
+            continue;
+        const answer = await askOne(firstPrompt);
+        firstPrompt = false;
+        // Determine selection
+        let optIdx;
+        if (!answer) {
+            // Enter = pick recommendation
+            optIdx = 0;
+        }
+        else if (answer === 's' || answer === '-') {
+            console.log(chalk.dim('  skipped'));
+            console.log();
+            continue;
+        }
+        else {
+            const match = answer.match(/^([a-d])$/);
+            if (!match) {
+                console.log(chalk.dim('  skipped'));
+                console.log();
+                continue;
+            }
+            optIdx = match[1].charCodeAt(0) - 97;
+        }
+        const opt = d.options[optIdx];
+        if (!opt) {
+            console.log(chalk.dim('  skipped'));
+            console.log();
+            continue;
+        }
+        console.log(`  ${chalk.green('✓')} ${opt.label}`);
+        console.log();
+        addTodo(d.title, opt.label, d.urgency || 'today');
+    }
+}
+function renderAnalysis(analysis, sourceCount, generated) {
+    console.log();
+    console.log(chalk.bold('  LIFE PULSE'));
+    console.log();
+    console.log(`  ${analysis.greeting}`);
+    console.log();
+    // New executor format
+    if (analysis.decisions?.length) {
+        console.log(chalk.bold.red('  DECISIONS'));
+        console.log();
+        for (let i = 0; i < analysis.decisions.length; i++) {
+            renderCard(analysis.decisions[i]);
+        }
+    }
+    if (analysis.upcoming?.length) {
+        console.log(chalk.bold.cyan('  UPCOMING'));
+        console.log();
+        renderList(analysis.upcoming, chalk.cyan('▸'));
+        console.log();
+    }
+    if (analysis.handled?.length) {
+        console.log(chalk.bold.green('  HANDLED'));
+        console.log();
+        renderList(analysis.handled, chalk.green('✓'));
+        console.log();
+    }
+    if (analysis.intel?.length) {
+        console.log(chalk.bold.magenta('  INTEL'));
+        console.log();
+        renderList(analysis.intel, chalk.magenta('~'));
+        console.log();
+    }
+    // Legacy format fallback
+    if (analysis.right_now?.length) {
+        console.log(chalk.bold.red('  RIGHT NOW'));
+        console.log();
+        renderList(analysis.right_now, chalk.red('→'));
+        console.log();
+    }
+    if (analysis.today?.length) {
+        console.log(chalk.bold.yellow('  TODAY'));
+        console.log();
+        renderList(analysis.today, chalk.yellow('·'));
+        console.log();
+    }
+    if (analysis.this_week?.length) {
+        console.log(chalk.bold('  THIS WEEK'));
+        console.log();
+        renderList(analysis.this_week, chalk.dim('·'));
+        console.log();
+    }
+    if (analysis.heads_up?.length) {
+        console.log(chalk.bold.cyan('  HEADS UP'));
+        console.log();
+        renderList(analysis.heads_up, chalk.cyan('!'));
+        console.log();
+    }
+    if (analysis.noticed?.length) {
+        console.log(chalk.bold.magenta('  NOTICED'));
+        console.log();
+        renderList(analysis.noticed, chalk.magenta('~'));
+        console.log();
+    }
+    if (sourceCount) {
+        console.log(chalk.dim(`  ${sourceCount} sources · ${generated}`));
+        console.log();
+    }
+}
+main().catch(e => {
+    console.error(chalk.red('\n  Error:'), e.message);
+    process.exit(1);
+});

package/dist/collectors/apps.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Collector: Installed applications via ~/Library/Application Support/
+ */
+import type { CollectorResult } from '../types.js';
+export declare function collect(): Promise<CollectorResult>;

package/dist/collectors/apps.js

@@ -0,0 +1,59 @@
+/**
+ * Collector: Installed applications via ~/Library/Application Support/
+ */
+import { homedir } from 'os';
+import { join } from 'path';
+import { readdirSync } from 'fs';
+const CATEGORIES = {
+    'dev tools': ['Xcode', 'JetBrains', 'Visual Studio Code', 'Windsurf', 'Zed', 'Sublime Text', 'Docker', 'TablePlus', 'Tower', 'Ghostty', 'iTerm2', 'Warp', 'Linear', 'Cursor', 'Codex'],
+    browsers: ['Google Chrome', 'Firefox', 'Arc', 'Brave Browser', 'Safari'],
+    productivity: ['Notion', 'Obsidian', 'Raycast', 'Alfred', 'Superhuman', 'Granola', 'Fantastical', '1Password', 'Bitwarden'],
+    messaging: ['Slack', 'Discord', 'Telegram', 'WhatsApp', 'Signal', 'Zoom', 'Microsoft Teams'],
+    creative: ['Figma', 'Screen Studio', 'Adobe', 'Sketch', 'Pixelmator', 'DaVinci Resolve', 'Final Cut Pro'],
+    finance: ['Copilot', 'YNAB', 'Quicken', 'Mint'],
+    ai: ['ChatGPT', 'LM Studio', 'Ollama', 'Claude'],
+};
+// Flatten for quick lookup: lowercase name → category
+const APP_MAP = new Map();
+for (const [cat, apps] of Object.entries(CATEGORIES)) {
+    for (const app of apps)
+        APP_MAP.set(app.toLowerCase(), cat);
+}
+export async function collect() {
+    const appSupport = join(homedir(), 'Library/Application Support');
+    let dirs;
+    try {
+        dirs = readdirSync(appSupport);
+    }
+    catch {
+        return { source: 'apps', available: false, data: {}, insights: [], todos: [] };
+    }
+    const found = {};
+    const unknown = [];
+    for (const dir of dirs) {
+        const key = dir.toLowerCase();
+        // Check exact match or prefix match
+        let matched = APP_MAP.get(key);
+        if (!matched) {
+            for (const [name, cat] of APP_MAP) {
+                if (key.includes(name) || name.includes(key)) {
+                    matched = cat;
+                    break;
+                }
+            }
+        }
+        if (matched) {
+            (found[matched] ||= []).push(dir);
+        }
+    }
+    return {
+        source: 'apps',
+        available: true,
+        data: {
+            categorized: found,
+            totalScanned: dirs.length,
+        },
+        insights: [],
+        todos: [],
+    };
+}

package/dist/collectors/calendar.d.ts

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

package/dist/collectors/calendar.js

@@ -0,0 +1,115 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { openDb, safeQuery } from '../db.js';
+import { APPLE_EPOCH } from '../types.js';
+import dayjs from 'dayjs';
+const DB_PATH = join(homedir(), 'Library/Calendars/Calendar.sqlitedb');
+export async function collect() {
+    const db = openDb(DB_PATH);
+    if (!db) {
+        return { source: 'Calendar', available: false, data: {}, insights: [], todos: [] };
+    }
+    const insights = [];
+    const todos = [];
+    try {
+        const now = dayjs();
+        const nowApple = now.unix() - APPLE_EPOCH;
+        const weekAgoApple = now.subtract(7, 'day').unix() - APPLE_EPOCH;
+        const weekAheadApple = now.add(7, 'day').unix() - APPLE_EPOCH;
+        // Past week events
+        const pastEvents = safeQuery(db, `SELECT ci.summary, ci.start_date, ci.end_date, ci.location,
+              c.title as calendar_title
+       FROM CalendarItem ci
+       LEFT JOIN Calendar c ON ci.calendar_id = c.ROWID
+       WHERE ci.start_date BETWEEN ? AND ?
+       ORDER BY ci.start_date`, [weekAgoApple, nowApple]);
+        // Upcoming events
+        const upcoming = safeQuery(db, `SELECT ci.summary, ci.start_date, ci.end_date, ci.location,
+              c.title as calendar_title
+       FROM CalendarItem ci
+       LEFT JOIN Calendar c ON ci.calendar_id = c.ROWID
+       WHERE ci.start_date BETWEEN ? AND ?
+       ORDER BY ci.start_date`, [nowApple, weekAheadApple]);
+        // Meeting load analysis
+        let totalMeetingMinutes = 0;
+        for (const evt of pastEvents) {
+            if (evt.start_date && evt.end_date) {
+                const duration = (evt.end_date - evt.start_date) / 60;
+                if (duration > 0 && duration < 480)
+                    totalMeetingMinutes += duration;
+            }
+        }
+        const meetingHoursWeek = +(totalMeetingMinutes / 60).toFixed(1);
+        const meetingHoursDay = +(meetingHoursWeek / 5).toFixed(1);
+        // Today's events
+        const todayStart = now.startOf('day').unix() - APPLE_EPOCH;
+        const todayEnd = now.endOf('day').unix() - APPLE_EPOCH;
+        const todayEvents = upcoming.filter(e => e.start_date >= todayStart && e.start_date <= todayEnd);
+        // Tomorrow's events
+        const tomorrowStart = now.add(1, 'day').startOf('day').unix() - APPLE_EPOCH;
+        const tomorrowEnd = now.add(1, 'day').endOf('day').unix() - APPLE_EPOCH;
+        const tomorrowEvents = upcoming.filter(e => e.start_date >= tomorrowStart && e.start_date <= tomorrowEnd);
+        insights.push({
+            category: 'work',
+            severity: 'info',
+            title: `${meetingHoursWeek}h in meetings last week`,
+            detail: `${meetingHoursDay}h/day avg. ${pastEvents.length} events total.`
+        });
+        if (meetingHoursDay > 4) {
+            insights.push({
+                category: 'work',
+                severity: 'warning',
+                title: 'Heavy meeting load',
+                detail: `${meetingHoursDay}h/day in meetings leaves limited deep work time.`
+            });
+            todos.push({
+                priority: 'high',
+                title: 'Block focus time on calendar',
+                reason: `${meetingHoursDay}h/day meetings — you need protected deep work blocks`,
+                source: 'Calendar'
+            });
+        }
+        if (todayEvents.length > 0) {
+            const nextEvent = todayEvents[0];
+            const startTime = dayjs.unix(nextEvent.start_date + APPLE_EPOCH);
+            insights.push({
+                category: 'work',
+                severity: 'info',
+                title: `${todayEvents.length} events today`,
+                detail: `Next: ${nextEvent.summary || 'Untitled'} at ${startTime.format('h:mm A')}`
+            });
+        }
+        if (tomorrowEvents.length > 0) {
+            insights.push({
+                category: 'work',
+                severity: 'info',
+                title: `${tomorrowEvents.length} events tomorrow`,
+                detail: tomorrowEvents.map(e => e.summary || 'Untitled').join(', ')
+            });
+        }
+        db.close();
+        return {
+            source: 'Calendar',
+            available: true,
+            data: {
+                meetingHoursWeek,
+                meetingHoursDay,
+                pastEventCount: pastEvents.length,
+                todayCount: todayEvents.length,
+                tomorrowCount: tomorrowEvents.length,
+                upcomingEvents: upcoming.slice(0, 10).map(e => ({
+                    summary: e.summary,
+                    start: dayjs.unix(e.start_date + APPLE_EPOCH).format('ddd h:mm A'),
+                    location: e.location,
+                    calendar: e.calendar_title
+                }))
+            },
+            insights,
+            todos
+        };
+    }
+    catch (e) {
+        db.close();
+        return { source: 'Calendar', available: false, data: { error: String(e) }, insights: [], todos: [] };
+    }
+}

package/dist/collectors/calls.d.ts

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

package/dist/collectors/calls.js

@@ -0,0 +1,52 @@
+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/Application Support/CallHistoryDB/CallHistory.storedata');
+const APPLE_EPOCH = 978307200;
+export async function collect() {
+    const db = openDb(DB_PATH);
+    if (!db)
+        return { source: 'Calls', available: false, data: {}, insights: [], todos: [] };
+    try {
+        const monthAgoApple = dayjs().subtract(30, 'day').unix() - APPLE_EPOCH;
+        const calls = safeQuery(db, `SELECT ZADDRESS as address, ZDURATION as duration,
+              ZDATE as date, ZCALLTYPE as call_type
+       FROM ZCALLRECORD WHERE ZDATE > ? ORDER BY ZDATE DESC`, [monthAgoApple]);
+        const missed = calls.filter(c => c.call_type === 3);
+        const incoming = calls.filter(c => c.call_type === 1);
+        const outgoing = calls.filter(c => c.call_type === 2);
+        const totalMinutes = Math.round(calls.reduce((s, c) => s + (c.duration || 0), 0) / 60);
+        // Missed calls not returned
+        const missedNotReturned = missed
+            .filter(m => !outgoing.some(o => o.address === m.address))
+            .map(m => ({
+            name: resolveName(m.address),
+            when: dayjs.unix(m.date + APPLE_EPOCH).format('ddd MMM D h:mm A')
+        }));
+        // Frequent callers
+        const callerCounts = new Map();
+        for (const c of calls)
+            callerCounts.set(c.address, (callerCounts.get(c.address) || 0) + 1);
+        const topCallers = [...callerCounts.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([addr, count]) => ({ name: resolveName(addr), calls: count }));
+        db.close();
+        return {
+            source: 'Calls',
+            available: true,
+            data: {
+                total: calls.length, incoming: incoming.length,
+                outgoing: outgoing.length, missed: missed.length,
+                totalMinutes, missedNotReturned, topCallers,
+            },
+            insights: [], todos: []
+        };
+    }
+    catch (e) {
+        db.close();
+        return { source: 'Calls', available: false, data: { error: String(e) }, insights: [], todos: [] };
+    }
+}

package/dist/collectors/chrome.d.ts

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