@c4t4/heyamigo 0.1.18 → 0.5.0

package/dist/memory/journal-nudger.js

@@ -0,0 +1,282 @@
+import { spawn } from 'child_process';
+import { config } from '../config.js';
+import { initiate } from '../gateway/outgoing.js';
+import { logger } from '../logger.js';
+import { logPrompt } from '../promptlog.js';
+import { readLast } from '../store/messages.js';
+import { canSendProactive } from '../wa/whitelist.js';
+import { isInQuietHours, nextFireTs, parseCadence, } from './journal-cadence.js';
+import { listJournals, loadNudgeState, readEntries, saveNudgeState, } from './journals.js';
+// Default nudge target: owner's self-DM. Group/other-chat nudges would require
+// explicit opt-in via access.json; we don't schedule those automatically in v1.
+function defaultNudgeJid() {
+    if (!config.owner.number)
+        return null;
+    return `${config.owner.number}@s.whatsapp.net`;
+}
+async function spawnComposer(prompt) {
+    const args = [
+        '-p',
+        '--output-format',
+        'json',
+        '--model',
+        config.claude.model,
+        '--permission-mode',
+        'acceptEdits',
+    ];
+    const startedAt = Date.now();
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn('claude', args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            cwd: process.cwd(),
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (c) => {
+            stdout += c.toString('utf-8');
+        });
+        child.stderr.on('data', (c) => {
+            stderr += c.toString('utf-8');
+        });
+        const logFail = (error) => void logPrompt({
+            ts: Math.floor(startedAt / 1000),
+            caller: 'journal-nudger',
+            args,
+            input: prompt,
+            error,
+            durationMs: Date.now() - startedAt,
+        });
+        child.on('error', (err) => {
+            logFail(`spawn failed: ${err.message}`);
+            rejectPromise(err);
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                logFail(`exit ${code}: ${stderr.slice(0, 300)}`);
+                return rejectPromise(new Error(`nudger exit ${code}`));
+            }
+            try {
+                const parsed = JSON.parse(stdout);
+                if (parsed.is_error ||
+                    parsed.subtype !== 'success' ||
+                    !parsed.result) {
+                    logFail(`bad output: ${parsed.result ?? stderr.slice(0, 200)}`);
+                    return rejectPromise(new Error('nudger bad output'));
+                }
+                const output = parsed.result.trim();
+                void logPrompt({
+                    ts: Math.floor(startedAt / 1000),
+                    caller: 'journal-nudger',
+                    args,
+                    input: prompt,
+                    output,
+                    durationMs: Date.now() - startedAt,
+                });
+                resolvePromise(output);
+            }
+            catch (err) {
+                logFail(`parse failed: ${err.message}`);
+                rejectPromise(err);
+            }
+        });
+        child.stdin.write(prompt);
+        child.stdin.end();
+    });
+}
+function formatMsg(m) {
+    const who = m.direction === 'out' ? 'assistant' : m.pushName || m.senderNumber || 'user';
+    return `${who}: ${m.text}`;
+}
+function buildPrompt(params) {
+    const { journal, kind, nowLocal, recentEntries, recentMessages } = params;
+    const kindDescription = kind === 'checkin'
+        ? "This is a scheduled recurring check-in for this journal. Ask the owner to log whatever belongs in the journal right now (e.g. for a health journal at night: how did you sleep, any symptoms, anything else)."
+        : "The owner has been silent on this journal's topic for a while. Send a gentle, natural nudge asking how things are going. Do not list every field; pick one thread.";
+    const lines = [
+        `You are composing a proactive WhatsApp message to the owner from their personal assistant bot.`,
+        ``,
+        `CONTEXT:`,
+        `- Journal: ${journal.name} (slug: ${journal.slug})`,
+        `- Purpose: ${journal.purpose}`,
+        journal.fields.length
+            ? `- Fields typically captured: ${journal.fields.join(', ')}`
+            : '',
+        `- Local time now: ${nowLocal}`,
+        `- Nudge type: ${kind}. ${kindDescription}`,
+        ``,
+        `RECENT JOURNAL ENTRIES (for continuity):`,
+        recentEntries.length
+            ? recentEntries
+                .map((e) => {
+                const d = new Date(e.ts * 1000).toISOString().slice(0, 16).replace('T', ' ');
+                return `- [${d}] ${e.note}`;
+            })
+                .join('\n')
+            : '(none yet)',
+        ``,
+        `RECENT CONVERSATION (so you sound like yourself, not a stranger):`,
+        recentMessages.length
+            ? recentMessages.slice(-10).map(formatMsg).join('\n')
+            : '(none)',
+        ``,
+        `RULES:`,
+        `- Stay fully in character (your personality file defines tone; you are NOT customer service and NOT a reminder app).`,
+        `- Short. One message, a few sentences max. No bullet lists, no headers.`,
+        `- Do not open with validation, greetings, or "hope you're doing well" fillers. Get to the point.`,
+        `- Be specific to the journal and what you know about the owner from recent entries and conversation.`,
+        `- If previous entries show a pattern or an unresolved thread, reference it.`,
+        `- Do NOT include any [TAG: ...] markers. This message is sent raw.`,
+        `- If you truly think sending nothing is better right now (e.g. you just talked about this an hour ago), output the single word: SKIP`,
+        ``,
+        `OUTPUT: either the message text, or the single word SKIP. No preamble, no explanation.`,
+    ];
+    return lines.filter(Boolean).join('\n');
+}
+function nowLocalString(timezone, now) {
+    const fmt = new Intl.DateTimeFormat('en-GB', {
+        timeZone: timezone,
+        weekday: 'long',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        timeZoneName: 'short',
+        hour12: false,
+    });
+    return fmt.format(new Date(now * 1000));
+}
+async function composeAndSend(params) {
+    const { journal, kind, jid } = params;
+    const now = Math.floor(Date.now() / 1000);
+    const nowLocal = nowLocalString(config.owner.timezone, now);
+    const recentMessages = await readLast(jid, 30);
+    const recentEntries = readEntries(journal.slug, 10).map((e) => ({
+        ts: e.ts,
+        note: e.note,
+    }));
+    const prompt = buildPrompt({
+        journal,
+        kind,
+        nowLocal,
+        recentEntries,
+        recentMessages,
+    });
+    let output;
+    try {
+        output = await spawnComposer(prompt);
+    }
+    catch (err) {
+        logger.error({ err, slug: journal.slug, kind }, 'nudge composer failed');
+        return false;
+    }
+    const text = output.trim();
+    if (!text || text.toUpperCase() === 'SKIP') {
+        logger.info({ slug: journal.slug, kind }, 'nudge composer chose to skip');
+        return false;
+    }
+    const sent = await initiate({ jid, text });
+    return sent;
+}
+function lastOwnerInboundTs(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m.direction === 'in' && m.senderNumber === config.owner.number) {
+            return m.timestamp;
+        }
+    }
+    return 0;
+}
+function needCheckin(journal, state, now) {
+    const cadence = parseCadence(journal.cadence.checkin);
+    if (!cadence)
+        return false;
+    const next = nextFireTs({
+        cadence,
+        lastFiredTs: state.lastCheckinTs || null,
+        now,
+        timezone: config.owner.timezone,
+    });
+    return now >= next;
+}
+function needSilentNudge(params) {
+    const { journal, state, now, lastOwnerActivityTs } = params;
+    const cadence = parseCadence(journal.cadence.nudge_if_silent);
+    if (!cadence || cadence.kind !== 'interval')
+        return false;
+    const silenceThresholdSec = cadence.seconds;
+    if (now - lastOwnerActivityTs < silenceThresholdSec)
+        return false;
+    // Debounce: don't resend the same silent nudge more often than the threshold.
+    if (now - state.lastSilentNudgeTs < silenceThresholdSec)
+        return false;
+    return true;
+}
+export async function runNudgeTick() {
+    const jid = defaultNudgeJid();
+    if (!jid) {
+        logger.warn('nudge tick: no owner.number, skipping');
+        return;
+    }
+    if (!canSendProactive(jid)) {
+        logger.debug({ jid }, 'nudge tick: proactive sending not allowed for target jid');
+        return;
+    }
+    const now = Math.floor(Date.now() / 1000);
+    if (isInQuietHours({
+        now,
+        window: '22:00-08:00',
+        timezone: config.owner.timezone,
+    })) {
+        return;
+    }
+    const journals = listJournals().filter((j) => j.status === 'active');
+    for (const journal of journals) {
+        const state = loadNudgeState(journal.slug);
+        if (state.snoozedUntilTs && now < state.snoozedUntilTs)
+            continue;
+        // Per-journal quiet hours override
+        if (isInQuietHours({
+            now,
+            window: journal.quiet_hours,
+            timezone: config.owner.timezone,
+        })) {
+            continue;
+        }
+        const recent = await readLast(jid, 50);
+        const lastOwnerTs = lastOwnerInboundTs(recent);
+        if (needCheckin(journal, state, now)) {
+            const sent = await composeAndSend({
+                journal,
+                kind: 'checkin',
+                jid,
+            });
+            if (sent) {
+                const fresh = loadNudgeState(journal.slug);
+                fresh.lastCheckinTs = now;
+                saveNudgeState(journal.slug, fresh);
+                logger.info({ slug: journal.slug, kind: 'checkin' }, 'nudge sent');
+            }
+            // Don't also send a silent nudge in the same tick for this journal.
+            continue;
+        }
+        if (needSilentNudge({
+            journal,
+            state,
+            now,
+            lastOwnerActivityTs: lastOwnerTs,
+        })) {
+            const sent = await composeAndSend({
+                journal,
+                kind: 'silent',
+                jid,
+            });
+            if (sent) {
+                const fresh = loadNudgeState(journal.slug);
+                fresh.lastSilentNudgeTs = now;
+                saveNudgeState(journal.slug, fresh);
+                logger.info({ slug: journal.slug, kind: 'silent' }, 'nudge sent');
+            }
+        }
+    }
+}

package/dist/memory/journal-observer.js

@@ -0,0 +1,225 @@
+import { spawn } from 'child_process';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+import { logPrompt } from '../promptlog.js';
+import { readLast } from '../store/messages.js';
+import { appendEntry, getLastScannedTs, getJournal, readEntries, setLastScannedTs, } from './journals.js';
+// How many recent messages to include in the scan window on each sweep.
+// Observer runs every memory.sweepIntervalMs (default 3h), so this window
+// must cover at least that much chat activity to avoid gaps.
+const SCAN_WINDOW = 200;
+// How many recent entries to show Claude for dedup context.
+const DEDUP_WINDOW = 20;
+async function spawnObserver(prompt) {
+    const args = [
+        '-p',
+        '--output-format',
+        'json',
+        '--model',
+        config.claude.model,
+        '--permission-mode',
+        'acceptEdits',
+    ];
+    const startedAt = Date.now();
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn('claude', args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            cwd: process.cwd(),
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString('utf-8');
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString('utf-8');
+        });
+        const logFail = (error) => void logPrompt({
+            ts: Math.floor(startedAt / 1000),
+            caller: 'journal-observer',
+            args,
+            input: prompt,
+            error,
+            durationMs: Date.now() - startedAt,
+        });
+        child.on('error', (err) => {
+            logFail(`spawn failed: ${err.message}`);
+            rejectPromise(new Error(`journal observer spawn failed: ${err.message}`));
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                logFail(`exit ${code}: ${stderr.slice(0, 300)}`);
+                return rejectPromise(new Error(`journal observer exit ${code}: ${stderr.slice(0, 300)}`));
+            }
+            try {
+                const parsed = JSON.parse(stdout);
+                if (parsed.is_error ||
+                    parsed.subtype !== 'success' ||
+                    !parsed.result) {
+                    logFail(`bad output: ${parsed.result ?? stderr.slice(0, 200)}`);
+                    return rejectPromise(new Error(`journal observer bad output: ${parsed.result ?? stderr.slice(0, 200)}`));
+                }
+                const output = parsed.result.trim();
+                void logPrompt({
+                    ts: Math.floor(startedAt / 1000),
+                    caller: 'journal-observer',
+                    args,
+                    input: prompt,
+                    output,
+                    durationMs: Date.now() - startedAt,
+                });
+                resolvePromise(output);
+            }
+            catch (err) {
+                logFail(`parse failed: ${err.message}`);
+                rejectPromise(new Error(`journal observer parse failed: ${err.message}`));
+            }
+        });
+        child.stdin.write(prompt);
+        child.stdin.end();
+    });
+}
+function formatMsg(m) {
+    const date = new Date(m.timestamp * 1000)
+        .toISOString()
+        .slice(0, 16)
+        .replace('T', ' ');
+    const who = m.direction === 'out' ? 'assistant' : m.pushName || m.senderNumber || 'user';
+    return `[${m.timestamp}] ${who} (${date}): ${m.text}`;
+}
+function buildPrompt(params) {
+    const { journal, recentEntries, messages } = params;
+    const lines = [
+        `You are a silent observer for a long-running journal called "${journal.name}" (slug: ${journal.slug}).`,
+        ``,
+        `PURPOSE: ${journal.purpose}`,
+        journal.fields.length
+            ? `FIELDS TO CAPTURE: ${journal.fields.join(', ')}`
+            : '',
+        ``,
+        `Your job: scan the new messages below and decide if any of them contain content that belongs in this journal. Extract zero or more new entries.`,
+        ``,
+        `RECENT ENTRIES (to avoid duplicates — do not re-log anything already captured here):`,
+        recentEntries.length
+            ? recentEntries
+                .map((e) => {
+                const d = new Date(e.ts * 1000).toISOString().slice(0, 16).replace('T', ' ');
+                return `- [${d}] ${e.note}`;
+            })
+                .join('\n')
+            : '(none yet)',
+        ``,
+        `NEW MESSAGES TO SCAN:`,
+        messages.map(formatMsg).join('\n'),
+        ``,
+        `RULES:`,
+        `- Only extract content that genuinely belongs in the "${journal.name}" journal based on its purpose.`,
+        `- Ignore small talk, logistics, unrelated topics.`,
+        `- Do not invent or infer things the messages don't say.`,
+        `- If the owner mentioned the same thing twice in this window, log it once.`,
+        `- Skip anything already in RECENT ENTRIES above.`,
+        ``,
+        `OUTPUT FORMAT:`,
+        `- If there are no new entries to log, output exactly the single word: NONE`,
+        `- Otherwise, output one JSON object per line (JSONL), each with this exact shape:`,
+        `  {"note": "<one-line summary of the entry>"}`,
+        `- No preamble, no trailing text, no markdown, no code fences.`,
+    ];
+    return lines.filter(Boolean).join('\n');
+}
+function parseOutput(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.toUpperCase() === 'NONE')
+        return [];
+    const out = [];
+    for (const line of trimmed.split(/\r?\n/)) {
+        const l = line.trim();
+        if (!l)
+            continue;
+        try {
+            const parsed = JSON.parse(l);
+            if (typeof parsed.note === 'string' && parsed.note.trim()) {
+                out.push({ note: parsed.note.trim() });
+            }
+        }
+        catch {
+            // skip malformed line
+        }
+    }
+    return out;
+}
+// Default scan scope: owner's self-DM. Journals can override later by adding a
+// scan_jids frontmatter field (not yet implemented — this keeps the default
+// behavior safe).
+function defaultScanJids() {
+    if (!config.owner.number)
+        return [];
+    return [`${config.owner.number}@s.whatsapp.net`];
+}
+export async function runJournalObserverForJid(params) {
+    const { slug, jid } = params;
+    const journal = getJournal(slug);
+    if (!journal) {
+        logger.warn({ slug }, 'journal observer: slug not found, skipping');
+        return { appended: 0, scanned: 0 };
+    }
+    if (journal.status !== 'active') {
+        return { appended: 0, scanned: 0 };
+    }
+    const since = getLastScannedTs(slug, jid);
+    const recent = await readLast(jid, SCAN_WINDOW);
+    const newMessages = recent.filter((m) => m.timestamp > since);
+    if (newMessages.length === 0) {
+        return { appended: 0, scanned: 0 };
+    }
+    const recentEntries = readEntries(slug, DEDUP_WINDOW).map((e) => ({
+        ts: e.ts,
+        note: e.note,
+    }));
+    const prompt = buildPrompt({
+        journal,
+        recentEntries,
+        messages: newMessages,
+    });
+    let output;
+    try {
+        output = await spawnObserver(prompt);
+    }
+    catch (err) {
+        logger.error({ err, slug, jid }, 'journal observer pass failed');
+        return { appended: 0, scanned: newMessages.length };
+    }
+    const entries = parseOutput(output);
+    for (const e of entries) {
+        appendEntry(slug, {
+            source: 'observer',
+            jid,
+            note: e.note,
+        });
+    }
+    const maxTs = newMessages[newMessages.length - 1].timestamp;
+    setLastScannedTs(slug, jid, maxTs);
+    logger.info({ slug, jid, scanned: newMessages.length, appended: entries.length }, 'journal observer pass complete');
+    return { appended: entries.length, scanned: newMessages.length };
+}
+export async function runJournalObserverSweep() {
+    const { listJournals } = await import('./journals.js');
+    const journals = listJournals().filter((j) => j.status === 'active');
+    if (journals.length === 0)
+        return;
+    const jids = defaultScanJids();
+    if (jids.length === 0) {
+        logger.warn('journal observer: no owner.number configured, skipping sweep');
+        return;
+    }
+    for (const journal of journals) {
+        for (const jid of jids) {
+            try {
+                await runJournalObserverForJid({ slug: journal.slug, jid });
+            }
+            catch (err) {
+                logger.error({ err, slug: journal.slug, jid }, 'journal observer sweep error');
+            }
+        }
+    }
+}