@c4t4/heyamigo 0.1.0

package/dist/gateway/outgoing.js

@@ -0,0 +1,168 @@
+import { existsSync, unlinkSync } from 'fs';
+import { isJidGroup } from 'baileys';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+import { append } from '../store/messages.js';
+import { detectMediaType, sendFile, sendText } from '../wa/sender.js';
+import { getSocket } from '../wa/socket.js';
+// Matches [FILE: path], [IMAGE: path], [VIDEO: path], [AUDIO: path], [DOCUMENT: path]
+const FILE_TAG_RE = /\[(?:FILE|IMAGE|VIDEO|AUDIO|DOCUMENT):\s*([^\]]+)\]/gi;
+function extractFiles(reply) {
+    const files = [];
+    const text = reply.replace(FILE_TAG_RE, (_, path) => {
+        const trimmed = path.trim();
+        if (existsSync(trimmed)) {
+            files.push(trimmed);
+        }
+        else {
+            logger.warn({ path: trimmed }, 'file path not found, skipping');
+        }
+        return '';
+    }).trim();
+    return { text, files };
+}
+export async function handleReply(job, result, originalMsg) {
+    const sock = getSocket();
+    if (!sock) {
+        logger.warn({ jid: job.jid }, 'no socket available to send reply');
+        return;
+    }
+    const raw = result.reply?.replaceAll('—', ', ').replaceAll('–', '-');
+    if (!raw)
+        return;
+    const { text, files } = extractFiles(raw);
+    const isGroup = isJidGroup(job.jid) === true;
+    const quoted = isGroup && config.reply.quoteInGroups ? originalMsg : undefined;
+    try {
+        // Send files first (images, videos, PDFs, audio, etc.)
+        for (const filePath of files) {
+            const isFirst = filePath === files[0];
+            const mediaType = detectMediaType(filePath);
+            // First file gets caption if text is short + single file + supports captions
+            const supportsCaption = mediaType !== 'audio';
+            const caption = isFirst && text && text.length <= 1000 && files.length === 1 && supportsCaption
+                ? text
+                : undefined;
+            await sendFile(sock, job.jid, filePath, caption, isFirst ? quoted : undefined);
+            await append({
+                id: `reply-file-${Date.now()}`,
+                jid: job.jid,
+                direction: 'out',
+                fromMe: true,
+                sender: sock.user?.id ?? '',
+                senderNumber: config.owner.number,
+                timestamp: Math.floor(Date.now() / 1000),
+                text: caption || `[${mediaType}: ${filePath}]`,
+                messageType: `${mediaType}Message`,
+                mediaPath: filePath,
+                mediaType,
+            });
+            logger.info({ jid: job.jid, path: filePath, mediaType }, 'file sent');
+            // Clean up temp file after sending
+            try {
+                unlinkSync(filePath);
+            }
+            catch { }
+            if (files.length > 1)
+                await sleep(config.reply.chunkDelayMs);
+        }
+        // Send text (skip if already used as caption on single file)
+        const textAlreadySent = files.length === 1 && text && text.length <= 1000 && detectMediaType(files[0]) !== 'audio';
+        if (text && !textAlreadySent) {
+            const chunks = chunkText(text, config.reply.chunkChars);
+            for (let i = 0; i < chunks.length; i++) {
+                const chunk = chunks[i];
+                const q = i === 0 && files.length === 0 ? quoted : undefined;
+                await sendText(sock, job.jid, chunk, q);
+                await append({
+                    id: `reply-${Date.now()}-${i}`,
+                    jid: job.jid,
+                    direction: 'out',
+                    fromMe: true,
+                    sender: sock.user?.id ?? '',
+                    senderNumber: config.owner.number,
+                    timestamp: Math.floor(Date.now() / 1000),
+                    text: chunk,
+                    messageType: 'conversation',
+                });
+                if (i < chunks.length - 1)
+                    await sleep(config.reply.chunkDelayMs);
+            }
+        }
+        if (config.reply.typingIndicator) {
+            await sock
+                .sendPresenceUpdate('paused', job.jid)
+                .catch(() => undefined);
+        }
+        logger.info({
+            jid: job.jid,
+            files: files.length,
+            chars: text.length,
+        }, 'reply sent');
+    }
+    catch (err) {
+        logger.error({ err, jid: job.jid }, 'failed to send reply');
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+export function chunkText(text, maxChars) {
+    if (text.length <= maxChars)
+        return [text];
+    const chunks = [];
+    const paragraphs = text.split(/\n\s*\n/);
+    let current = '';
+    const flush = () => {
+        if (current) {
+            chunks.push(current);
+            current = '';
+        }
+    };
+    for (const para of paragraphs) {
+        const joiner = current ? '\n\n' : '';
+        if (current.length + joiner.length + para.length <= maxChars) {
+            current += joiner + para;
+            continue;
+        }
+        flush();
+        if (para.length <= maxChars) {
+            current = para;
+        }
+        else {
+            const parts = splitLong(para, maxChars);
+            for (let i = 0; i < parts.length - 1; i++)
+                chunks.push(parts[i]);
+            current = parts[parts.length - 1] ?? '';
+        }
+    }
+    flush();
+    return chunks;
+}
+function splitLong(text, maxChars) {
+    const out = [];
+    const sentences = text.split(/(?<=[.!?])\s+/);
+    let current = '';
+    for (const s of sentences) {
+        const joiner = current ? ' ' : '';
+        if (current.length + joiner.length + s.length <= maxChars) {
+            current += joiner + s;
+            continue;
+        }
+        if (current) {
+            out.push(current);
+            current = '';
+        }
+        if (s.length <= maxChars) {
+            current = s;
+        }
+        else {
+            for (let i = 0; i < s.length; i += maxChars) {
+                out.push(s.slice(i, i + maxChars));
+            }
+        }
+    }
+    if (current)
+        out.push(current);
+    return out;
+}

package/dist/gateway/triggers.js

@@ -0,0 +1,75 @@
+import { jidDecode } from 'baileys';
+import { config } from '../config.js';
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function aliasMatches(text, aliases) {
+    for (const alias of aliases) {
+        const re = new RegExp(`(^|[^a-zA-Z0-9_])${escapeRegex(alias)}([^a-zA-Z0-9_]|$)`, 'i');
+        if (re.test(text))
+            return alias;
+    }
+    return null;
+}
+function ownerNumbers(sock) {
+    const out = new Set();
+    if (config.owner.number)
+        out.add(config.owner.number);
+    const pn = sock.user?.id ? jidDecode(sock.user.id)?.user : undefined;
+    if (pn)
+        out.add(pn);
+    const lid = sock.user?.lid ? jidDecode(sock.user.lid)?.user : undefined;
+    if (lid)
+        out.add(lid);
+    return out;
+}
+export function checkTrigger(params) {
+    const { isGroup, text, msg, sock } = params;
+    const mode = isGroup
+        ? config.triggers.groupMode
+        : config.triggers.dmMode;
+    if (mode === 'off')
+        return { triggered: false, reason: 'mode=off' };
+    if (mode === 'all')
+        return { triggered: true, reason: 'mode=all' };
+    const prefix = config.commands.prefix;
+    if (mode === 'command') {
+        return text.trim().startsWith(prefix)
+            ? { triggered: true, reason: 'command prefix' }
+            : { triggered: false, reason: 'no command prefix' };
+    }
+    // mode === 'mention'
+    // 1. Alias in text (word boundary, case insensitive)
+    const alias = aliasMatches(text, config.triggers.aliases);
+    if (alias)
+        return { triggered: true, reason: `alias:${alias}` };
+    // Extract contextInfo from any message type (text, image, video, etc.)
+    const content = msg.message ?? {};
+    const contextInfo = (content.extendedTextMessage?.contextInfo) ??
+        (content.imageMessage?.contextInfo) ??
+        (content.videoMessage?.contextInfo) ??
+        (content.audioMessage?.contextInfo) ??
+        (content.documentMessage?.contextInfo) ??
+        (content.documentWithCaptionMessage?.message?.documentMessage?.contextInfo) ??
+        (content.stickerMessage?.contextInfo);
+    // 2. WA @mention pointing at owner
+    const owners = ownerNumbers(sock);
+    const mentioned = contextInfo?.mentionedJid ?? [];
+    for (const m of mentioned) {
+        const user = jidDecode(m)?.user;
+        if (user && owners.has(user)) {
+            return { triggered: true, reason: 'wa mention' };
+        }
+    }
+    // 3. Reply to a bot/owner message
+    if (config.triggers.replyToBotCounts) {
+        const quotedParticipant = contextInfo?.participant;
+        if (quotedParticipant) {
+            const user = jidDecode(quotedParticipant)?.user;
+            if (user && owners.has(user)) {
+                return { triggered: true, reason: 'reply to bot' };
+            }
+        }
+    }
+    return { triggered: false, reason: 'no trigger match' };
+}

package/dist/index.js

@@ -0,0 +1,30 @@
+import { attachIncoming } from './gateway/incoming.js';
+import { handleReply } from './gateway/outgoing.js';
+import { logger } from './logger.js';
+import { startScheduler } from './memory/scheduler.js';
+import { replayPending } from './queue/queue.js';
+import { startSocket } from './wa/socket.js';
+async function main() {
+    logger.info('heyamigo starting');
+    startScheduler();
+    await startSocket((sock) => {
+        attachIncoming(sock);
+    });
+    // Replay any jobs left from a previous crash (no original WAMessage
+    // available, so replies are sent as plain messages, not quoted).
+    void replayPending(async (job, result) => {
+        await handleReply(job, result, {});
+    }).catch((err) => logger.error({ err }, 'replay failed'));
+}
+process.on('SIGINT', () => {
+    logger.info('SIGINT received, shutting down');
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    logger.info('SIGTERM received, shutting down');
+    process.exit(0);
+});
+main().catch((err) => {
+    logger.error({ err }, 'fatal error during boot');
+    process.exit(1);
+});

package/dist/logger.js

@@ -0,0 +1,7 @@
+import pino from 'pino';
+import { config } from './config.js';
+export const logger = pino({
+    level: config.logging.level,
+    base: undefined,
+    timestamp: pino.stdTimeFunctions.isoTime,
+});

package/dist/memory/digest-flag.js

@@ -0,0 +1,8 @@
+const DIGEST_RE = /\[DIGEST:\s*([^\]]+)\]\s*$/i;
+export function extractDigestFlag(reply) {
+    const match = reply.match(DIGEST_RE);
+    if (!match)
+        return { clean: reply, flag: null };
+    const clean = reply.slice(0, match.index).trimEnd();
+    return { clean, flag: match[1]?.trim() ?? '' };
+}

package/dist/memory/digest.js

@@ -0,0 +1,211 @@
+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 { readBrief, readProfile, setLastDigestedAt, writeBrief, writeProfile, } from './store.js';
+/**
+ * Run a stateless Claude call to consolidate memory.
+ * Returns the new content Claude proposed.
+ */
+async function spawnDigester(prompt) {
+    const args = [
+        '-p',
+        '--output-format',
+        'json',
+        '--model',
+        config.claude.model,
+    ];
+    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 = '';
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+        }, config.claude.timeoutMs);
+        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: 'digester',
+            args,
+            input: prompt,
+            error,
+            durationMs: Date.now() - startedAt,
+        });
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            logFail(`spawn failed: ${err.message}`);
+            rejectPromise(new Error(`digester spawn failed: ${err.message}`));
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (timedOut) {
+                logFail('timed out');
+                return rejectPromise(new Error('digester timed out'));
+            }
+            if (code !== 0) {
+                logFail(`exit ${code}: ${stderr.slice(0, 300)}`);
+                return rejectPromise(new Error(`digester 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(`digester bad output: ${parsed.result ?? stderr.slice(0, 200)}`));
+                }
+                const output = parsed.result.trim();
+                void logPrompt({
+                    ts: Math.floor(startedAt / 1000),
+                    caller: 'digester',
+                    args,
+                    input: prompt,
+                    output,
+                    durationMs: Date.now() - startedAt,
+                });
+                resolvePromise(output);
+            }
+            catch (err) {
+                logFail(`parse failed: ${err.message}`);
+                rejectPromise(new Error(`digester parse failed: ${err.message}`));
+            }
+        });
+        child.stdin.write(prompt);
+        child.stdin.end();
+    });
+}
+function formatMessagesForDigest(messages) {
+    return messages
+        .map((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 `${who} (${date}): ${m.text}`;
+    })
+        .join('\n');
+}
+function profilePrompt(params) {
+    const { number, current, messages, reason } = params;
+    const personMessages = messages.filter((m) => m.senderNumber === number && m.direction === 'in');
+    const replyMessages = messages.filter((m) => m.direction === 'out');
+    const lines = [
+        `You are consolidating the long-term profile for a WhatsApp contact.`,
+        `Contact number: ${number}`,
+        ``,
+        `Current profile (may be empty):`,
+        current || '(empty)',
+        ``,
+        reason ? `Reason this update was triggered: ${reason}` : '',
+        ``,
+        `Recent messages from this person:`,
+        personMessages.length
+            ? formatMessagesForDigest(personMessages)
+            : '(none in window)',
+        ``,
+        `Recent bot replies (for context):`,
+        replyMessages.length
+            ? formatMessagesForDigest(replyMessages.slice(-10))
+            : '(none)',
+        ``,
+        `Rewrite the profile in markdown. Structure:`,
+        `# <Name if known, else number>`,
+        `## Facts`,
+        `## Preferences`,
+        `## Patterns`,
+        `## Recent context`,
+        ``,
+        `Rules:`,
+        `- Keep under 500 tokens.`,
+        `- Only append durable observations. Merge redundant items.`,
+        `- Remove nothing unless clearly outdated.`,
+        `- Do not invent facts.`,
+        `- Output ONLY the new markdown profile content. No preamble, no explanation.`,
+    ];
+    return lines.filter(Boolean).join('\n');
+}
+function briefPrompt(params) {
+    const { jid, current, messages, reason } = params;
+    const lines = [
+        `You are consolidating the long-term brief for a WhatsApp chat.`,
+        `Chat JID: ${jid}`,
+        ``,
+        `Current brief (may be empty):`,
+        current || '(empty)',
+        ``,
+        reason ? `Reason this update was triggered: ${reason}` : '',
+        ``,
+        `Recent messages in this chat:`,
+        messages.length ? formatMessagesForDigest(messages) : '(none in window)',
+        ``,
+        `Rewrite the brief in markdown. Structure:`,
+        `# <Chat name>`,
+        `## Purpose`,
+        `## Tone and norms`,
+        `## Recent topics`,
+        `## Decisions and open questions`,
+        ``,
+        `Rules:`,
+        `- Keep under 500 tokens.`,
+        `- Focus on durable context useful for future replies.`,
+        `- Do not include raw messages or copy verbatim.`,
+        `- Output ONLY the new markdown brief. No preamble.`,
+    ];
+    return lines.filter(Boolean).join('\n');
+}
+export async function runDigest(params) {
+    const { jid, number, reason } = params;
+    const now = Math.floor(Date.now() / 1000);
+    const messages = await readLast(jid, config.memory.maxHistoryForDigest);
+    if (!messages.length) {
+        logger.info({ jid }, 'digest skipped: no messages in window');
+        return;
+    }
+    // Update brief for the jid
+    try {
+        const current = readBrief(jid);
+        const prompt = briefPrompt({
+            jid,
+            current,
+            messages,
+            reason: reason ?? null,
+        });
+        const next = await spawnDigester(prompt);
+        writeBrief(jid, next + '\n');
+        setLastDigestedAt('jid', jid, now);
+        logger.info({ jid, chars: next.length }, 'brief updated');
+    }
+    catch (err) {
+        logger.error({ err, jid }, 'brief digest failed');
+    }
+    // Update profile for the specific person if provided
+    if (number) {
+        try {
+            const current = readProfile(number);
+            const prompt = profilePrompt({
+                number,
+                current,
+                messages,
+                reason: reason ?? null,
+            });
+            const next = await spawnDigester(prompt);
+            writeProfile(number, next + '\n');
+            setLastDigestedAt('person', number, now);
+            logger.info({ number, chars: next.length }, 'profile updated');
+        }
+        catch (err) {
+            logger.error({ err, number }, 'profile digest failed');
+        }
+    }
+}

package/dist/memory/frontmatter.js

@@ -0,0 +1,100 @@
+const FM_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+export function parseFrontmatter(content) {
+    const m = content.match(FM_RE);
+    if (!m)
+        return { data: {}, body: content };
+    const yaml = m[1] ?? '';
+    const body = m[2] ?? '';
+    const data = {};
+    for (const rawLine of yaml.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const kv = line.match(/^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)$/);
+        if (!kv)
+            continue;
+        const key = kv[1];
+        data[key] = parseValue((kv[2] ?? '').trim());
+    }
+    return { data, body };
+}
+function parseValue(raw) {
+    if (raw === '' || raw === 'null' || raw === '~')
+        return null;
+    if (raw === 'true')
+        return true;
+    if (raw === 'false')
+        return false;
+    if (raw.startsWith('[') && raw.endsWith(']')) {
+        const inner = raw.slice(1, -1).trim();
+        if (!inner)
+            return [];
+        return splitArgs(inner).map(stripQuotes);
+    }
+    if ((raw.startsWith('"') && raw.endsWith('"')) ||
+        (raw.startsWith("'") && raw.endsWith("'"))) {
+        return stripQuotes(raw);
+    }
+    if (/^-?\d+(\.\d+)?$/.test(raw))
+        return Number(raw);
+    return raw;
+}
+function splitArgs(inner) {
+    const out = [];
+    let current = '';
+    let quote = null;
+    for (const ch of inner) {
+        if (quote) {
+            current += ch;
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            current += ch;
+            continue;
+        }
+        if (ch === ',') {
+            out.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    if (current.trim())
+        out.push(current.trim());
+    return out;
+}
+function stripQuotes(s) {
+    if ((s.startsWith('"') && s.endsWith('"')) ||
+        (s.startsWith("'") && s.endsWith("'"))) {
+        return s.slice(1, -1);
+    }
+    return s;
+}
+export function serializeFrontmatter(data, body) {
+    const lines = ['---'];
+    for (const [k, v] of Object.entries(data)) {
+        lines.push(`${k}: ${serializeValue(v)}`);
+    }
+    lines.push('---');
+    lines.push('');
+    lines.push(body.trimStart());
+    return lines.join('\n');
+}
+function serializeValue(v) {
+    if (v === null)
+        return 'null';
+    if (typeof v === 'boolean')
+        return v ? 'true' : 'false';
+    if (typeof v === 'number')
+        return String(v);
+    if (Array.isArray(v)) {
+        return '[' + v.map((x) => JSON.stringify(x)).join(', ') + ']';
+    }
+    // simple strings unquoted if safe
+    if (/^[A-Za-z0-9 _\-./:@]+$/.test(v))
+        return v;
+    return JSON.stringify(v);
+}