life-pulse 1.0.0

package/dist/contacts.js

@@ -0,0 +1,88 @@
+/**
+ * Contact name resolution from macOS AddressBook.
+ * Builds a phone/email → name lookup by reading SQLite databases.
+ */
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, readdirSync } from 'fs';
+import { openDb, safeQuery } from './db.js';
+let _cache = null;
+function normalizePhone(raw) {
+    const digits = raw.replace(/\D/g, '');
+    return digits.length >= 10 ? digits.slice(-10) : digits;
+}
+export function buildContactMap() {
+    if (_cache)
+        return _cache;
+    const map = new Map();
+    const abDir = join(homedir(), 'Library/Application Support/AddressBook/Sources');
+    if (!existsSync(abDir)) {
+        _cache = map;
+        return map;
+    }
+    try {
+        const sources = readdirSync(abDir);
+        for (const source of sources) {
+            const dbPath = join(abDir, source, 'AddressBook-v22.abcddb');
+            const db = openDb(dbPath);
+            if (!db)
+                continue;
+            try {
+                // Phone numbers
+                const phones = safeQuery(db, `SELECT r.ZFIRSTNAME as first, r.ZLASTNAME as last, p.ZFULLNUMBER as phone
+           FROM ZABCDRECORD r
+           JOIN ZABCDPHONENUMBER p ON p.ZOWNER = r.Z_PK
+           WHERE p.ZFULLNUMBER IS NOT NULL`);
+                for (const row of phones) {
+                    const name = [row.first, row.last].filter(Boolean).join(' ').trim();
+                    if (!name)
+                        continue;
+                    const normalized = normalizePhone(row.phone);
+                    if (normalized.length >= 7)
+                        map.set(normalized, name);
+                    map.set(row.phone.trim(), name);
+                }
+                // Email addresses
+                const emails = safeQuery(db, `SELECT r.ZFIRSTNAME as first, r.ZLASTNAME as last, e.ZADDRESS as email
+           FROM ZABCDRECORD r
+           JOIN ZABCDEMAILADDRESS e ON e.ZOWNER = r.Z_PK
+           WHERE e.ZADDRESS IS NOT NULL`);
+                for (const row of emails) {
+                    const name = [row.first, row.last].filter(Boolean).join(' ').trim();
+                    if (name)
+                        map.set(row.email.toLowerCase().trim(), name);
+                }
+            }
+            finally {
+                db.close();
+            }
+        }
+    }
+    catch { }
+    _cache = map;
+    return map;
+}
+/** Resolve a phone number or email to a contact name */
+export function resolveName(handle) {
+    if (!handle)
+        return 'Unknown';
+    const map = buildContactMap();
+    // Direct lookup
+    if (map.has(handle))
+        return map.get(handle);
+    // Normalize phone and try
+    const normalized = normalizePhone(handle);
+    if (normalized.length >= 7 && map.has(normalized))
+        return map.get(normalized);
+    // Try without country code prefix
+    if (handle.startsWith('+1')) {
+        const without = normalizePhone(handle.slice(2));
+        if (map.has(without))
+            return map.get(without);
+    }
+    // Email lowercased
+    if (handle.includes('@') && map.has(handle.toLowerCase())) {
+        return map.get(handle.toLowerCase());
+    }
+    return handle;
+}

package/dist/db.d.ts

@@ -0,0 +1,9 @@
+import Database from 'better-sqlite3';
+/**
+ * Open a SQLite database safely by copying to /tmp first.
+ * Many macOS databases are locked by running processes — copying
+ * the file (+ WAL if present) avoids SQLITE_BUSY errors.
+ */
+export declare function openDb(dbPath: string, readonly?: boolean): Database.Database | null;
+/** Run a query safely, returning empty array on error */
+export declare function safeQuery<T = Record<string, unknown>>(db: Database.Database, sql: string, params?: unknown[]): T[];

package/dist/db.js

@@ -0,0 +1,50 @@
+import Database from 'better-sqlite3';
+import { existsSync, copyFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { randomBytes } from 'crypto';
+/**
+ * Open a SQLite database safely by copying to /tmp first.
+ * Many macOS databases are locked by running processes — copying
+ * the file (+ WAL if present) avoids SQLITE_BUSY errors.
+ */
+export function openDb(dbPath, readonly = true) {
+    if (!existsSync(dbPath))
+        return null;
+    const tmpPath = join(tmpdir(), `lp-${randomBytes(4).toString('hex')}.db`);
+    try {
+        copyFileSync(dbPath, tmpPath);
+        // Copy WAL/SHM if they exist
+        if (existsSync(dbPath + '-wal')) {
+            copyFileSync(dbPath + '-wal', tmpPath + '-wal');
+        }
+        if (existsSync(dbPath + '-shm')) {
+            copyFileSync(dbPath + '-shm', tmpPath + '-shm');
+        }
+        const db = new Database(tmpPath, { readonly });
+        // Ensure WAL checkpoint so we see latest data
+        try {
+            db.pragma('wal_checkpoint(PASSIVE)');
+        }
+        catch { }
+        return db;
+    }
+    catch (e) {
+        // If copy fails (permissions), try opening directly
+        try {
+            return new Database(dbPath, { readonly: true });
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/** Run a query safely, returning empty array on error */
+export function safeQuery(db, sql, params = []) {
+    try {
+        return db.prepare(sql).all(...params);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export interface CollectionResult {
+    generated: string;
+    hostname: string;
+    sources: string[];
+    unavailable: string[];
+    data: Record<string, unknown>;
+}
+/** Collect raw data from all macOS sources */
+export declare function collectAll(): Promise<CollectionResult>;

package/dist/index.js

@@ -0,0 +1,42 @@
+import { hostname } from 'os';
+import dayjs from 'dayjs';
+// Collectors — pure data extraction, no heuristics
+import * as imessage from './collectors/imessage.js';
+import * as screenTime from './collectors/screen-time.js';
+import * as safari from './collectors/safari.js';
+import * as chrome from './collectors/chrome.js';
+import * as calendar from './collectors/calendar.js';
+import * as calls from './collectors/calls.js';
+import * as notes from './collectors/notes.js';
+import * as notifications from './collectors/notifications.js';
+import * as shellHistory from './collectors/shell-history.js';
+import * as mail from './collectors/mail.js';
+import * as findmy from './collectors/findmy.js';
+import * as recentFiles from './collectors/recent-files.js';
+import * as apps from './collectors/apps.js';
+const ALL_COLLECTORS = [
+    imessage, screenTime, safari, chrome, calendar,
+    calls, notes, notifications, shellHistory, mail,
+    findmy, recentFiles, apps,
+];
+/** Collect raw data from all macOS sources */
+export async function collectAll() {
+    const settled = await Promise.allSettled(ALL_COLLECTORS.map(c => c.collect()));
+    const results = [];
+    for (const r of settled) {
+        if (r.status === 'fulfilled')
+            results.push(r.value);
+    }
+    const available = results.filter(r => r.available);
+    const unavailable = results.filter(r => !r.available);
+    const data = {};
+    for (const r of available)
+        data[r.source] = r.data;
+    return {
+        generated: dayjs().format('YYYY-MM-DD HH:mm:ss'),
+        hostname: hostname(),
+        sources: available.map(r => r.source),
+        unavailable: unavailable.map(r => r.source),
+        data,
+    };
+}

package/dist/profile.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Auto-discover user profile from system data.
+ * No config needed — derives everything from macOS databases + filesystem.
+ */
+export interface ContactTier {
+    name: string;
+    tier: 'T1' | 'T2' | 'T3' | 'T4';
+    msgs30d: number;
+}
+export interface UserProfile {
+    name: string;
+    topContacts: ContactTier[];
+    projects: string[];
+}
+/** Get the real name of the current macOS user */
+export declare function getUserName(): string;
+/** Build full user profile from system data. Cached for session. */
+export declare function buildProfile(): UserProfile;

package/dist/profile.js

@@ -0,0 +1,88 @@
+/**
+ * Auto-discover user profile from system data.
+ * No config needed — derives everything from macOS databases + filesystem.
+ */
+import { execSync } from 'child_process';
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, readdirSync } from 'fs';
+import { openDb, safeQuery } from './db.js';
+import { resolveName } from './contacts.js';
+import dayjs from 'dayjs';
+const APPLE_EPOCH = 978307200;
+let _name = null;
+let _profile = null;
+/** Get the real name of the current macOS user */
+export function getUserName() {
+    if (_name)
+        return _name;
+    try {
+        const raw = execSync('dscl . -read /Users/$(whoami) RealName', {
+            encoding: 'utf-8', timeout: 3000,
+        });
+        // Output format: "RealName:\n First Last"
+        const lines = raw.trim().split('\n');
+        const name = lines.length > 1 ? lines[1].trim() : lines[0].replace('RealName:', '').trim();
+        if (name && name !== 'RealName:') {
+            _name = name;
+            return _name;
+        }
+    }
+    catch { }
+    _name = process.env.USER || 'User';
+    return _name;
+}
+/** Build full user profile from system data. Cached for session. */
+export function buildProfile() {
+    if (_profile)
+        return _profile;
+    const name = getUserName();
+    const topContacts = discoverContacts();
+    const projects = discoverProjects();
+    _profile = { name, topContacts, projects };
+    return _profile;
+}
+function discoverContacts() {
+    const home = homedir();
+    const db = openDb(join(home, 'Library/Messages/chat.db'));
+    if (!db)
+        return [];
+    const ago30Nano = (BigInt(dayjs().subtract(30, 'day').unix() - APPLE_EPOCH) * BigInt(1e9)).toString();
+    const handles = safeQuery(db, 'SELECT ROWID, id FROM handle');
+    const counts = new Map();
+    for (const h of handles) {
+        const msgs = safeQuery(db, `SELECT COUNT(*) as c FROM message WHERE handle_id = ? AND date > ?`, [h.ROWID, ago30Nano]);
+        const count = msgs[0]?.c || 0;
+        if (count < 3)
+            continue;
+        const name = resolveName(h.id);
+        if (name === 'Unknown' || name === h.id)
+            continue;
+        counts.set(name, (counts.get(name) || 0) + count);
+    }
+    db.close();
+    const sorted = [...counts.entries()].sort((a, b) => b[1] - a[1]);
+    return sorted.slice(0, 30).map(([name, msgs30d]) => ({
+        name,
+        tier: msgs30d > 100 ? 'T1' : msgs30d > 30 ? 'T2' : msgs30d > 10 ? 'T3' : 'T4',
+        msgs30d,
+    }));
+}
+function discoverProjects() {
+    const projectsDir = join(homedir(), 'Projects');
+    if (!existsSync(projectsDir))
+        return [];
+    try {
+        return readdirSync(projectsDir).filter(f => {
+            try {
+                return existsSync(join(projectsDir, f, '.git'));
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}

package/dist/progress.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Live terminal progress renderer.
+ * Shows parallel workers with individual spinners, tool calls, and elapsed times.
+ */
+export interface ProgressSink {
+    thinking(): void;
+    toolStart(name: string): void;
+    toolDone(name: string): void;
+    workerStart(id: string, label: string): void;
+    workerTool(id: string, tool: string): void;
+    workerDone(id: string): void;
+    workerFail(id: string): void;
+    pause(): void;
+    resume(): void;
+}
+export declare class ProgressRenderer implements ProgressSink {
+    private tools;
+    private workers;
+    private frame;
+    private timer;
+    private prevLines;
+    private isThinking;
+    private auqWaiting;
+    start(): void;
+    thinking(): void;
+    toolStart(name: string): void;
+    toolDone(name: string): void;
+    workerStart(id: string, label: string): void;
+    workerTool(id: string, tool: string): void;
+    workerDone(id: string): void;
+    workerFail(id: string): void;
+    private s;
+    private ms;
+    private spin;
+    private paint;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    clear(): void;
+}

package/dist/progress.js

@@ -0,0 +1,204 @@
+/**
+ * Live terminal progress renderer.
+ * Shows parallel workers with individual spinners, tool calls, and elapsed times.
+ */
+import chalk from 'chalk';
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const TICK_MS = 80;
+const SHORT = {
+    search_all_messages: 'search',
+    get_conversation: 'conversation',
+    profile_contact: 'profile',
+    get_messages: 'messages',
+    get_unanswered_messages: 'unanswered',
+    get_screen_time: 'screen_time',
+    get_browsing: 'browsing',
+    get_calls: 'calls',
+    scan_sources: 'scan',
+    lookup_contact: 'lookup',
+    get_email_summary: 'email',
+    get_git_activity: 'git',
+    get_recent_files: 'files',
+    get_shell_history: 'shell',
+    get_notes: 'notes',
+    get_claude_history: 'claude',
+    get_interests_for_plans: 'interests',
+};
+export class ProgressRenderer {
+    tools = [];
+    workers = [];
+    frame = 0;
+    timer = null;
+    prevLines = 0;
+    isThinking = false;
+    auqWaiting = false;
+    start() {
+        process.stderr.write('\x1B[?25l');
+        this.timer = setInterval(() => {
+            this.frame = (this.frame + 1) % FRAMES.length;
+            this.paint();
+        }, TICK_MS);
+    }
+    thinking() { this.isThinking = true; }
+    toolStart(name) {
+        this.isThinking = false;
+        if (name === 'ask_user') {
+            this.auqWaiting = true;
+            return;
+        }
+        this.tools.push({ name, done: false, startTime: Date.now() });
+    }
+    toolDone(name) {
+        if (name === 'ask_user') {
+            this.auqWaiting = false;
+            return;
+        }
+        const t = this.tools.find(t => t.name === name && !t.done);
+        if (t) {
+            t.done = true;
+            t.endTime = Date.now();
+        }
+    }
+    workerStart(id, label) {
+        this.isThinking = false;
+        this.workers.push({
+            id, label: label.slice(0, 48), tool: null,
+            done: false, failed: false,
+            startTime: Date.now(), toolCount: 0,
+        });
+    }
+    workerTool(id, tool) {
+        const w = this.workers.find(w => w.id === id);
+        if (w) {
+            w.tool = tool;
+            w.toolCount++;
+        }
+    }
+    workerDone(id) {
+        const w = this.workers.find(w => w.id === id);
+        if (w) {
+            w.done = true;
+            w.endTime = Date.now();
+            w.tool = null;
+        }
+    }
+    workerFail(id) {
+        const w = this.workers.find(w => w.id === id);
+        if (w) {
+            w.done = true;
+            w.failed = true;
+            w.endTime = Date.now();
+            w.tool = null;
+        }
+    }
+    s(name) { return SHORT[name] || name; }
+    ms(t) { return (t / 1000).toFixed(1) + 's'; }
+    spin(offset = 0) { return chalk.cyan(FRAMES[(this.frame + offset) % FRAMES.length]); }
+    paint() {
+        const lines = [''];
+        lines.push(chalk.bold('  life pulse ') + chalk.dim('─'.repeat(34)));
+        lines.push('');
+        // Direct tools
+        const allDone = this.tools.length > 0 && this.tools.every(t => t.done);
+        if (this.tools.length > 0) {
+            if (allDone) {
+                const names = this.tools.map(t => this.s(t.name));
+                const maxMs = Math.max(...this.tools.map(t => (t.endTime - t.startTime)));
+                lines.push(`  ${chalk.green('✓')} ${chalk.dim(names.join(' · '))}  ${chalk.dim(this.ms(maxMs))}`);
+            }
+            else {
+                for (let i = 0; i < this.tools.length; i++) {
+                    const t = this.tools[i];
+                    if (t.done) {
+                        lines.push(`  ${chalk.green('✓')} ${chalk.dim(this.s(t.name))}`);
+                    }
+                    else {
+                        lines.push(`  ${this.spin(i)} ${this.s(t.name)}`);
+                    }
+                }
+            }
+            lines.push('');
+        }
+        // Workers
+        if (this.workers.length > 0) {
+            const done = this.workers.filter(w => w.done).length;
+            const total = this.workers.length;
+            const active = total - done;
+            const hdr = active > 0
+                ? `  ${chalk.dim('workers')} ${chalk.cyan(String(done))}${chalk.dim('/')}${chalk.white(String(total))}`
+                : `  ${chalk.dim('workers')} ${chalk.green(total + '/' + total)}`;
+            lines.push(hdr);
+            for (let i = 0; i < this.workers.length; i++) {
+                const w = this.workers[i];
+                if (w.done) {
+                    const el = this.ms((w.endTime - w.startTime));
+                    const icon = w.failed ? chalk.red('✗') : chalk.green('✓');
+                    lines.push(`  ${icon} ${chalk.dim(w.label)}  ${chalk.dim(w.toolCount + ' calls')}  ${chalk.dim(el)}`);
+                }
+                else {
+                    const tool = w.tool ? chalk.dim(` → ${this.s(w.tool)}`) : '';
+                    lines.push(`  ${this.spin(i * 3)} ${chalk.white(w.label)}${tool}`);
+                }
+            }
+            lines.push('');
+        }
+        // AUQ waiting for user answers
+        if (this.auqWaiting) {
+            lines.push(`  ${this.spin()} ${chalk.yellow('waiting for answers')} ${chalk.dim("— run 'auq' in another terminal")}`);
+            lines.push('');
+        }
+        // Thinking / synthesizing
+        if (this.isThinking) {
+            const hasWorkers = this.workers.length > 0 && this.workers.every(w => w.done);
+            const label = hasWorkers ? 'synthesizing decisions...' : 'thinking...';
+            lines.push(`  ${this.spin()} ${chalk.dim(label)}`);
+            lines.push('');
+        }
+        // Clear previous render
+        if (this.prevLines > 0) {
+            process.stderr.write(`\x1B[${this.prevLines}A`);
+            for (let i = 0; i < this.prevLines; i++) {
+                process.stderr.write('\x1B[2K\n');
+            }
+            process.stderr.write(`\x1B[${this.prevLines}A`);
+        }
+        process.stderr.write(lines.join('\n') + '\n');
+        this.prevLines = lines.length;
+    }
+    pause() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.clear();
+        process.stderr.write('\x1B[?25h');
+    }
+    resume() {
+        if (!this.timer) {
+            process.stderr.write('\x1B[?25l');
+            this.prevLines = 0;
+            this.timer = setInterval(() => {
+                this.frame = (this.frame + 1) % FRAMES.length;
+                this.paint();
+            }, TICK_MS);
+        }
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.paint();
+        process.stderr.write('\x1B[?25h');
+    }
+    clear() {
+        if (this.prevLines > 0) {
+            process.stderr.write(`\x1B[${this.prevLines}A`);
+            for (let i = 0; i < this.prevLines; i++) {
+                process.stderr.write('\x1B[2K\n');
+            }
+            process.stderr.write(`\x1B[${this.prevLines}A`);
+            this.prevLines = 0;
+        }
+    }
+}

package/dist/state.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Persistent state for cross-run tracking.
+ * Stores previous analysis so we can surface deltas and avoid repeating ourselves.
+ */
+export interface RunState {
+    lastRun: string;
+    lastAnalysis: Record<string, unknown>;
+    /** Rolling history of key observations for trend detection */
+    history: {
+        date: string;
+        key: string;
+        value: string;
+    }[];
+}
+export declare function loadState(): RunState;
+export declare function saveState(analysis: Record<string, unknown>): void;
+/** Build context string for LLM about what's changed since last run */
+export declare function buildDeltaContext(): string;

package/dist/state.js

@@ -0,0 +1,101 @@
+/**
+ * Persistent state for cross-run tracking.
+ * Stores previous analysis so we can surface deltas and avoid repeating ourselves.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import dayjs from 'dayjs';
+const STATE_DIR = join(homedir(), 'Library/Application Support/life-pulse');
+const STATE_FILE = join(STATE_DIR, 'state.json');
+function defaultState() {
+    return {
+        lastRun: '',
+        lastAnalysis: {},
+        history: [],
+    };
+}
+export function loadState() {
+    try {
+        if (existsSync(STATE_FILE)) {
+            return JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
+        }
+    }
+    catch { }
+    return defaultState();
+}
+export function saveState(analysis) {
+    try {
+        if (!existsSync(STATE_DIR))
+            mkdirSync(STATE_DIR, { recursive: true });
+        const prev = loadState();
+        const now = dayjs().format('YYYY-MM-DD HH:mm:ss');
+        // Extract key observations for history (keep last 50)
+        const newEntries = [];
+        const decisions = analysis.decisions;
+        if (decisions) {
+            for (const d of decisions) {
+                if (d.title)
+                    newEntries.push({ date: now, key: 'decision', value: d.title });
+            }
+        }
+        const intel = analysis.intel;
+        if (intel) {
+            for (const v of intel)
+                newEntries.push({ date: now, key: 'intel', value: v });
+        }
+        // Legacy format support
+        const right_now = analysis.right_now;
+        if (right_now) {
+            for (const v of right_now)
+                newEntries.push({ date: now, key: 'right_now', value: v });
+        }
+        const history = [...prev.history, ...newEntries].slice(-50);
+        const state = { lastRun: now, lastAnalysis: analysis, history };
+        writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+    }
+    catch { }
+}
+/** Build context string for LLM about what's changed since last run */
+export function buildDeltaContext() {
+    const state = loadState();
+    if (!state.lastRun)
+        return '';
+    const lines = [];
+    lines.push(`\n--- PREVIOUS RUN (${state.lastRun}) ---`);
+    lines.push('Last time you presented:');
+    const a = state.lastAnalysis;
+    const decisions = a.decisions;
+    if (decisions?.length) {
+        lines.push('DECISIONS: ' + decisions.map(d => d.title || '').filter(Boolean).join(' | '));
+    }
+    const handled = a.handled;
+    if (handled?.length) {
+        lines.push('HANDLED: ' + handled.join(' | '));
+    }
+    const intel = a.intel;
+    if (intel?.length) {
+        lines.push('INTEL: ' + intel.join(' | '));
+    }
+    // Legacy fallback
+    const right_now = a.right_now;
+    if (right_now?.length) {
+        lines.push('RIGHT NOW: ' + right_now.join(' | '));
+    }
+    if (state.history.length > 5) {
+        lines.push('\nRecurring themes from past runs:');
+        // Find repeated observations
+        const counts = new Map();
+        for (const h of state.history) {
+            const key = h.value.slice(0, 60).toLowerCase();
+            counts.set(key, (counts.get(key) || 0) + 1);
+        }
+        const recurring = [...counts.entries()].filter(([, c]) => c > 1).sort((a, b) => b[1] - a[1]).slice(0, 5);
+        for (const [obs, count] of recurring) {
+            lines.push(`  (${count}x) ${obs}`);
+        }
+    }
+    lines.push('--- END PREVIOUS RUN ---');
+    lines.push('IMPORTANT: Don\'t repeat the same observations. Surface what\'s NEW and what\'s CHANGED. If something was flagged before and still isn\'t resolved, escalate it.');
+    return lines.join('\n');
+}