@c4t4/heyamigo 0.3.0 → 0.6.1

package/dist/queue/async-tasks.js

@@ -0,0 +1,215 @@
+import { spawn } from 'child_process';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { config } from '../config.js';
+import fastq from 'fastq';
+import { initiate } from '../gateway/outgoing.js';
+import { logger } from '../logger.js';
+import { logPrompt } from '../promptlog.js';
+// Concurrency: how many async Claude workers can run simultaneously.
+// Start conservative — each process is expensive (Playwright, multi-minute runs).
+// Tune via config.asyncTasks.concurrency once we have real usage data.
+const CONCURRENCY = 3;
+// In-memory registry of tasks currently executing. Not persisted across
+// restarts — on reboot, any in-flight async work is silently dropped.
+// We expose listInProgress() so the chat preamble can show "in progress"
+// hints to the main Claude.
+const inProgress = new Map();
+const queue = fastq.promise(async (task) => {
+    inProgress.set(task.id, task);
+    try {
+        await runTask(task);
+    }
+    catch (err) {
+        logger.error({ err, id: task.id, jid: task.jid }, 'async task failed unexpectedly');
+    }
+    finally {
+        inProgress.delete(task.id);
+    }
+}, CONCURRENCY);
+export function enqueueAsyncTask(input) {
+    const task = {
+        ...input,
+        id: `async-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        startedAt: Math.floor(Date.now() / 1000),
+    };
+    logger.info({
+        id: task.id,
+        jid: task.jid,
+        description: task.description.slice(0, 200),
+    }, 'async task enqueued');
+    queue.push(task).catch((err) => logger.error({ err, id: task.id }, 'async queue push failed'));
+    return task;
+}
+export function listAsyncTasks(jid) {
+    const all = Array.from(inProgress.values());
+    if (!jid)
+        return all;
+    return all.filter((t) => t.jid === jid);
+}
+// ---------- task runner ----------
+let cachedSystemPrompt = null;
+function systemPrompt() {
+    if (cachedSystemPrompt !== null)
+        return cachedSystemPrompt;
+    const personality = readFileSync(resolve(process.cwd(), config.claude.personalityFile), 'utf-8');
+    let memoryInstructions = '';
+    try {
+        memoryInstructions = readFileSync(resolve(process.cwd(), config.memory.instructionsFile), 'utf-8');
+    }
+    catch {
+        // optional
+    }
+    cachedSystemPrompt = memoryInstructions
+        ? `${personality}\n\n---\n\n${memoryInstructions}`
+        : personality;
+    return cachedSystemPrompt;
+}
+export function reloadAsyncSystemPrompt() {
+    cachedSystemPrompt = null;
+}
+function buildPrompt(task) {
+    const lines = [
+        `You are running a BACKGROUND TASK for the owner. The chat already got your ack reply. Your only job now is to do the work and output the final message to send them.`,
+        ``,
+        `TASK:`,
+        task.description,
+        ``,
+        `ORIGINAL USER MESSAGE (for reference):`,
+        task.originatingMessage,
+        ``,
+        `Sender: ${task.senderName ?? task.senderNumber}`,
+        ``,
+        `RULES:`,
+        `- Stay fully in character (personality file). This is not customer service.`,
+        `- Do the real work. Use tools (browser, etc.) as needed.`,
+        `- When done, output ONLY the message to send the user. No preamble, no "here's what I found:" framing unless that's the message itself.`,
+        `- Do NOT emit any [DIGEST:...], [JOURNAL:...], [ASYNC:...], or other markers. This is the final output.`,
+        `- Start the message with a short reference to what you were working on so the user knows which task this is about (e.g. "About the TikTok scrape: ..."). They may have asked for multiple things.`,
+        `- If the task is impossible or the tools failed, say so honestly and briefly. Don't fabricate.`,
+        ``,
+        `Output the final user-facing message now.`,
+    ];
+    return lines.join('\n');
+}
+function buildArgs(task) {
+    const args = [
+        '-p',
+        '--output-format',
+        'json',
+        '--model',
+        config.claude.model,
+        '--permission-mode',
+        'acceptEdits',
+        '--append-system-prompt',
+        systemPrompt(),
+    ];
+    for (const dir of config.claude.addDirs) {
+        args.push('--add-dir', resolve(process.cwd(), dir));
+    }
+    args.push('--add-dir', resolve(process.cwd(), config.memory.dir));
+    args.push('--add-dir', resolve(process.cwd(), config.storage.mediaDir));
+    if (task.allowedTools &&
+        task.allowedTools !== 'all' &&
+        task.allowedTools.length > 0) {
+        args.push('--allowedTools', task.allowedTools.join(','));
+    }
+    return args;
+}
+async function spawnClaudeForTask(task, prompt) {
+    const args = buildArgs(task);
+    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: 'async-task',
+            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(`async task 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('async task bad output'));
+                }
+                const output = parsed.result.trim();
+                void logPrompt({
+                    ts: Math.floor(startedAt / 1000),
+                    caller: 'async-task',
+                    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();
+    });
+}
+async function runTask(task) {
+    const prompt = buildPrompt(task);
+    const elapsedLog = () => `${Math.round((Date.now() - task.startedAt * 1000) / 1000)}s`;
+    let output;
+    try {
+        output = await spawnClaudeForTask(task, prompt);
+    }
+    catch (err) {
+        logger.error({ err, id: task.id, jid: task.jid, elapsed: elapsedLog() }, 'async task claude call failed');
+        await initiate({
+            jid: task.jid,
+            text: `Heads up: the background task "${truncate(task.description, 80)}" failed. Ask me again and I'll retry.`,
+        });
+        return;
+    }
+    // Strip any accidental trailing markers Claude emitted despite instructions.
+    // Import lazily to avoid an import cycle (digest-flag already stands alone,
+    // but being explicit here keeps this module independent).
+    const { extractFlags } = await import('../memory/digest-flag.js');
+    const { clean } = extractFlags(output);
+    if (!clean.trim()) {
+        logger.warn({ id: task.id, jid: task.jid }, 'async task produced empty output after flag strip');
+        return;
+    }
+    const sent = await initiate({ jid: task.jid, text: clean });
+    logger.info({
+        id: task.id,
+        jid: task.jid,
+        sent,
+        elapsed: elapsedLog(),
+        chars: clean.length,
+    }, 'async task completed');
+}
+function truncate(s, n) {
+    return s.length > n ? s.slice(0, n - 1) + '…' : s;
+}

package/dist/queue/worker.js

@@ -1,19 +1,24 @@
 import { askClaude } from '../ai/claude.js';
 import { clearSession, setSession, setUsage } from '../ai/sessions.js';
+import { config } from '../config.js';
 import { logger } from '../logger.js';
 import { extractFlags } from '../memory/digest-flag.js';
-import { appendEntry, createJournal, getJournal, isValidSlug, updateJournalStatus, } from '../memory/journals.js';
+import { appendEntry, createJournal, getJournal, isValidSlug, } from '../memory/journals.js';
 import { scheduleDigest } from '../memory/scheduler.js';
+import { enqueueAsyncTask } from './async-tasks.js';
 function isStaleSessionError(err) {
     return (err instanceof Error &&
         err.message.includes('No conversation found'));
 }
 async function callClaude(job) {
+    const startedAt = Date.now();
+    const wasFresh = !job.sessionId;
     const { reply, sessionId, usage } = await askClaude({
         input: job.input,
         sessionId: job.sessionId,
         allowedTools: job.allowedTools,
     });
+    const durationMs = Date.now() - startedAt;
     if (!job.sessionId) {
         setSession(job.jid, sessionId);
     }
@@ -26,7 +31,7 @@ async function callClaude(job) {
         totalContextTokens,
         updatedAt: Math.floor(Date.now() / 1000),
     });
-    const { clean, digest, journals, lifecycleOps } = extractFlags(reply);
+    const { clean, digest, journals, journalCreates, asyncTasks } = extractFlags(reply);
     if (digest) {
         logger.info({ jid: job.jid, number: job.senderNumber, reason: digest }, 'DIGEST flag raised, scheduling');
         scheduleDigest({
@@ -35,43 +40,27 @@ async function callClaude(job) {
             reason: digest,
         });
     }
-    // Lifecycle ops run BEFORE entry appends so that a reply creating a new
-    // journal AND flagging its first entry in the same turn works correctly.
-    for (const op of lifecycleOps) {
+    // Creates run BEFORE entry appends so that a reply creating a new journal
+    // AND flagging its first entry in the same turn works correctly.
+    for (const op of journalCreates) {
         if (!isValidSlug(op.slug)) {
-            logger.warn({ op, jid: job.jid }, 'journal lifecycle op: invalid slug, dropped');
+            logger.warn({ op, jid: job.jid }, 'JOURNAL-NEW: invalid slug, dropped');
             continue;
         }
         try {
-            if (op.kind === 'new') {
-                if (getJournal(op.slug)) {
-                    logger.info({ slug: op.slug }, 'JOURNAL-NEW for existing slug, ignored');
-                    continue;
-                }
-                createJournal({
-                    slug: op.slug,
-                    name: titleCase(op.slug),
-                    purpose: op.purpose,
-                });
-                logger.info({ slug: op.slug, jid: job.jid }, 'journal created via bot marker');
-            }
-            else {
-                const status = op.kind === 'pause'
-                    ? 'paused'
-                    : op.kind === 'archive'
-                        ? 'archived'
-                        : 'active';
-                const updated = updateJournalStatus(op.slug, status);
-                if (updated) {
-                    logger.info({ slug: op.slug, status, jid: job.jid }, 'journal status updated via bot marker');
-                }
-                else {
-                    logger.warn({ op, jid: job.jid }, 'journal lifecycle op: unknown slug, dropped');
-                }
+            if (getJournal(op.slug)) {
+                logger.info({ slug: op.slug }, 'JOURNAL-NEW for existing slug, ignored');
+                continue;
             }
+            createJournal({
+                slug: op.slug,
+                name: titleCase(op.slug),
+                purpose: op.purpose,
+            });
+            logger.info({ slug: op.slug, jid: job.jid }, 'journal created via bot marker');
         }
         catch (err) {
-            logger.error({ err, op, jid: job.jid }, 'journal lifecycle op failed');
+            logger.error({ err, op, jid: job.jid }, 'JOURNAL-NEW failed');
         }
     }
     for (const j of journals) {
@@ -85,7 +74,34 @@ async function callClaude(job) {
             logger.warn({ slug: j.slug, jid: job.jid }, 'JOURNAL flag pointed at unknown slug, dropped');
         }
     }
-    return { reply: clean };
+    // Async tasks: Claude delegated long work (browser scrapes, multi-step
+    // research, etc.) to the background lane. The clean reply above is the
+    // user-facing ack and will be sent normally. The async tasks run stateless
+    // in their own queue and report back via initiate() when done.
+    for (const t of asyncTasks) {
+        enqueueAsyncTask({
+            jid: job.jid,
+            senderNumber: job.senderNumber,
+            description: t.description,
+            originatingMessage: job.text,
+            allowedTools: job.allowedTools ?? 'all',
+        });
+    }
+    return {
+        reply: clean,
+        stats: {
+            durationMs,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cacheReadTokens: usage.cacheReadTokens,
+            totalContextTokens,
+            contextWindow: config.claude.contextWindow,
+            fresh: wasFresh,
+            hasDigest: digest !== null,
+            journalSlugs: journals.map((j) => j.slug),
+            asyncCount: asyncTasks.length,
+        },
+    };
 }
 function titleCase(slug) {
     return slug

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4t4/heyamigo",
-  "version": "0.3.0",
+  "version": "0.6.1",
   "description": "WhatsApp AI bot powered by Claude with long-term memory, browser control, and role-based access",
   "type": "module",
   "main": "dist/index.js",