@c4t4/heyamigo 0.1.0

package/config/personalities/professional.md

@@ -0,0 +1,25 @@
+# Personality: Professional
+
+You answer WhatsApp messages for the account owner in business and professional contexts.
+
+## Voice
+
+Clear, warm, efficient. Competent without being stiff.
+
+- Complete sentences but not wordy.
+- Polite and direct. Get to the answer quickly.
+- No slang. Use contractions sparingly.
+- Match the formality of the person writing to you.
+
+## Rules
+
+- Lead with the answer, then reasoning if needed.
+- Be specific with numbers, dates, and facts.
+- If something is unclear, ask instead of guessing.
+- Never break the frame with "As an AI assistant..." or similar.
+- Keep messages compact. If a response gets long, break it into short paragraphs.
+- Plain text only. No markdown headers, no bullet lists, no bold.
+
+## Self-check
+
+Would a colleague read this and feel respected? If it feels cold or bureaucratic, warm it up. If it feels sloppy, tighten it.

package/config/personalities/sharp.md

@@ -0,0 +1,45 @@
+# Personality: Sharp (default)
+
+You answer WhatsApp messages for the account owner. You are not customer service and not marketing copy. You are a conversational peer who is sharp, direct, and actually useful.
+
+## Voice
+
+Talk like a friend at dinner, not a brochure. If you wouldn't say it out loud to someone you respect, don't type it.
+
+- Be specific. Vague is what people say when they have nothing real to say. Numbers beat adjectives, concrete beats abstract.
+- Use the person's own words. Mirror how they talk. Casual if they're casual. Terse if they're terse.
+- Cut marketing speak. No "experience the difference", no "discover the power of". Kill it on sight.
+
+## Energy
+
+Confident, charming, magnetic. Never arrogant, weak, or desperate.
+
+- Confident: state things without hedging. No "maybe", no "possibly", no "könnte eventuell".
+- Charming: light enough that people nod or smile, not feel lectured.
+- Magnetic: don't chase, don't beg, don't push.
+
+Avoid: lecturing (arrogant), hedging (weak), over-eager pushing (desperate).
+
+## Rules
+
+- Name the elephant. If something obvious is awkward, say it first.
+- Reality over aspiration. Meet people where they are, not where you'd like them to be.
+- Specificity beats generality. If it could apply to 10 situations, it applies to none.
+- One person, one moment. Answer this question for this person right now.
+- Never use the em-dash character. Use a period, comma, or colon.
+- Don't jump to conclusions. Watch for red herrings. If you're not sure, say so. Being wrong confidently is worse than being uncertain honestly.
+- Prefer being less wrong over sounding more right. Check your reasoning before you commit to an answer.
+
+## WhatsApp constraints
+
+- Keep replies short, usually a few sentences. Go longer only if asked.
+- Plain text. No markdown headers, no bold, no bullet lists. WhatsApp renders them poorly.
+- In groups, don't dominate. Respect the conversation flow.
+- Never break the frame with "As an AI assistant..." or similar.
+
+## Self-check before every reply
+
+1. Could this reply work for any random person in any random context? If yes, rewrite specifically.
+2. Would I be embarrassed to say this to a friend? If yes, rewrite.
+3. Am I hedging, being arrogant, or desperate? If yes, rewrite.
+4. Any em-dash? If yes, replace with period or comma.

package/dist/ai/claude.js

@@ -0,0 +1,153 @@
+import { spawn } from 'child_process';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+import { logPrompt } from '../promptlog.js';
+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 {
+        // memory instructions optional
+    }
+    cachedSystemPrompt = memoryInstructions
+        ? `${personality}\n\n---\n\n${memoryInstructions}`
+        : personality;
+    return cachedSystemPrompt;
+}
+export function reloadSystemPrompt() {
+    cachedSystemPrompt = null;
+}
+function buildArgs(params) {
+    const args = [
+        '-p',
+        '--output-format',
+        config.claude.outputFormat,
+        '--model',
+        config.claude.model,
+        '--permission-mode',
+        'acceptEdits',
+    ];
+    if (params.sessionId) {
+        args.push('--resume', params.sessionId);
+    }
+    else {
+        args.push('--append-system-prompt', systemPrompt());
+        for (const dir of config.claude.addDirs) {
+            args.push('--add-dir', resolve(process.cwd(), dir));
+        }
+    }
+    // Memory + media dirs for file access (only effective if tools allow Read)
+    args.push('--add-dir', resolve(process.cwd(), config.memory.dir));
+    args.push('--add-dir', resolve(process.cwd(), config.storage.mediaDir));
+    // Tool restriction per role
+    if (params.allowedTools &&
+        params.allowedTools !== 'all' &&
+        params.allowedTools.length > 0) {
+        args.push('--allowedTools', params.allowedTools.join(','));
+    }
+    return args;
+}
+export async function askClaude(params) {
+    const args = buildArgs(params);
+    const startedAt = Date.now();
+    logger.debug({ resume: !!params.sessionId, inputChars: params.input.length }, 'spawning claude');
+    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');
+        });
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            void logPrompt({
+                ts: Math.floor(startedAt / 1000),
+                caller: 'worker',
+                args,
+                input: params.input,
+                error: `spawn failed: ${err.message}`,
+                durationMs: Date.now() - startedAt,
+            });
+            rejectPromise(new Error(`claude spawn failed: ${err.message}`));
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (timedOut) {
+                void logPrompt({
+                    ts: Math.floor(startedAt / 1000),
+                    caller: 'worker',
+                    args,
+                    input: params.input,
+                    error: 'timed out',
+                    durationMs: Date.now() - startedAt,
+                });
+                return rejectPromise(new Error(`claude timed out after ${config.claude.timeoutMs}ms`));
+            }
+            if (code !== 0) {
+                void logPrompt({
+                    ts: Math.floor(startedAt / 1000),
+                    caller: 'worker',
+                    args,
+                    input: params.input,
+                    error: `exit ${code}: ${stderr.slice(0, 500)}`,
+                    durationMs: Date.now() - startedAt,
+                });
+                return rejectPromise(new Error(`claude exited with code ${code}: ${stderr.slice(0, 500)}`));
+            }
+            try {
+                const parsed = JSON.parse(stdout);
+                if (parsed.is_error || parsed.subtype !== 'success') {
+                    return rejectPromise(new Error(`claude returned error (subtype=${parsed.subtype}): ${parsed.result ?? stderr.slice(0, 200)}`));
+                }
+                if (!parsed.result || !parsed.session_id) {
+                    return rejectPromise(new Error(`claude output missing result or session_id: ${stdout.slice(0, 200)}`));
+                }
+                const result = {
+                    reply: parsed.result,
+                    sessionId: parsed.session_id,
+                    usage: {
+                        inputTokens: parsed.usage?.input_tokens ?? 0,
+                        cacheReadTokens: parsed.usage?.cache_read_input_tokens ?? 0,
+                        cacheCreationTokens: parsed.usage?.cache_creation_input_tokens ?? 0,
+                        outputTokens: parsed.usage?.output_tokens ?? 0,
+                        numTurns: parsed.num_turns ?? 0,
+                    },
+                };
+                void logPrompt({
+                    ts: Math.floor(startedAt / 1000),
+                    caller: 'worker',
+                    args,
+                    input: params.input,
+                    output: result.reply,
+                    sessionId: result.sessionId,
+                    usage: result.usage,
+                    durationMs: Date.now() - startedAt,
+                });
+                resolvePromise(result);
+            }
+            catch (err) {
+                rejectPromise(new Error(`failed to parse claude output: ${err.message}\nstdout: ${stdout.slice(0, 500)}`));
+            }
+        });
+        child.stdin.write(params.input);
+        child.stdin.end();
+    });
+}

package/dist/ai/sessions.js

@@ -0,0 +1,63 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+function sessionsPath() {
+    return resolve(process.cwd(), config.storage.sessionsFile);
+}
+let sessions = load();
+function load() {
+    const path = sessionsPath();
+    if (!existsSync(path))
+        return {};
+    try {
+        const raw = JSON.parse(readFileSync(path, 'utf-8'));
+        const out = {};
+        for (const [jid, v] of Object.entries(raw)) {
+            if (typeof v === 'string') {
+                out[jid] = { sessionId: v }; // migrate old flat string format
+            }
+            else if (v && typeof v === 'object' && 'sessionId' in v) {
+                out[jid] = v;
+            }
+        }
+        return out;
+    }
+    catch (err) {
+        logger.warn({ err, path }, 'failed to load sessions.json, starting empty');
+        return {};
+    }
+}
+function save() {
+    const path = sessionsPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(sessions, null, 2) + '\n', 'utf-8');
+}
+export function getSession(jid) {
+    return sessions[jid]?.sessionId;
+}
+export function getSessionInfo(jid) {
+    return sessions[jid];
+}
+export function setSession(jid, sessionId) {
+    const existing = sessions[jid];
+    sessions[jid] = { sessionId, usage: existing?.usage };
+    save();
+}
+export function setUsage(jid, usage) {
+    const existing = sessions[jid];
+    if (!existing)
+        return;
+    sessions[jid] = { ...existing, usage };
+    save();
+}
+export function clearSession(jid) {
+    if (!(jid in sessions))
+        return false;
+    delete sessions[jid];
+    save();
+    return true;
+}
+export function listSessions() {
+    return sessions;
+}

package/dist/cli/import.js

@@ -0,0 +1,17 @@
+import { runImport } from '../memory/importer.js';
+async function main() {
+    const source = process.argv[2];
+    if (!source) {
+        console.error('Usage: npm run import -- <path-to-source-folder>');
+        process.exit(1);
+    }
+    try {
+        await runImport(source);
+        process.exit(0);
+    }
+    catch (err) {
+        console.error('Import failed:', err.message);
+        process.exit(1);
+    }
+}
+void main();

package/dist/cli/index.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+const program = new Command();
+program
+    .name('heyamigo')
+    .description('WhatsApp AI Bot powered by Claude')
+    .version('0.1.0');
+program
+    .command('setup')
+    .description('Run the setup wizard')
+    .action(async () => {
+    const { runSetup } = await import('./setup.js');
+    await runSetup();
+});
+program
+    .command('start')
+    .description('Start the bot as a background service')
+    .action(async () => {
+    const { serviceCmd } = await import('./service.js');
+    await serviceCmd('start');
+});
+program
+    .command('stop')
+    .description('Stop the bot')
+    .action(async () => {
+    const { serviceCmd } = await import('./service.js');
+    await serviceCmd('stop');
+});
+program
+    .command('restart')
+    .description('Restart the bot')
+    .action(async () => {
+    const { serviceCmd } = await import('./service.js');
+    await serviceCmd('restart');
+});
+program
+    .command('logs')
+    .description('Tail live logs')
+    .action(async () => {
+    const { serviceCmd } = await import('./service.js');
+    await serviceCmd('logs');
+});
+program
+    .command('status')
+    .description('Check if the bot is running')
+    .action(async () => {
+    const { serviceCmd } = await import('./service.js');
+    await serviceCmd('status');
+});
+program
+    .command('import <path>')
+    .description('Import external knowledge folder into memory')
+    .action(async (path) => {
+    const { runImport } = await import('../memory/importer.js');
+    try {
+        await runImport(path);
+    }
+    catch (err) {
+        console.error('Import failed:', err.message);
+        process.exit(1);
+    }
+});
+program
+    .command('dev')
+    .description('Start in foreground with file watching (development)')
+    .action(async () => {
+    const { main } = await import('./start.js');
+    await main();
+});
+program.parse(process.argv);

package/dist/cli/service.js

@@ -0,0 +1,105 @@
+import { spawn, spawnSync } from 'child_process';
+import { existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
+import { dirname, resolve } from 'path';
+const cwd = process.cwd();
+const PID_FILE = resolve(cwd, 'storage/heyamigo.pid');
+const LOG_FILE = resolve(cwd, 'storage/logs/heyamigo.log');
+function readPid() {
+    if (!existsSync(PID_FILE))
+        return null;
+    const raw = readFileSync(PID_FILE, 'utf-8').trim();
+    const pid = parseInt(raw, 10);
+    return isNaN(pid) ? null : pid;
+}
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function cleanPid() {
+    if (existsSync(PID_FILE))
+        unlinkSync(PID_FILE);
+}
+export async function serviceCmd(action) {
+    switch (action) {
+        case 'start': {
+            const existing = readPid();
+            if (existing && isAlive(existing)) {
+                console.log(`Already running (PID: ${existing})`);
+                return;
+            }
+            cleanPid();
+            mkdirSync(dirname(LOG_FILE), { recursive: true });
+            const logFd = openSync(LOG_FILE, 'a');
+            const child = spawn(process.execPath, [
+                '--import',
+                'file://' +
+                    resolve(cwd, 'node_modules/tsx/dist/loader.mjs'),
+                resolve(cwd, 'src/cli/supervisor.ts'),
+            ], {
+                detached: true,
+                stdio: ['ignore', logFd, logFd],
+                cwd,
+                env: { ...process.env, NODE_ENV: 'production' },
+            });
+            child.unref();
+            if (child.pid) {
+                writeFileSync(PID_FILE, String(child.pid));
+                console.log(`Started (PID: ${child.pid})`);
+                console.log(`Logs: heyamigo logs`);
+            }
+            else {
+                console.error('Failed to start');
+            }
+            break;
+        }
+        case 'stop': {
+            const pid = readPid();
+            if (!pid || !isAlive(pid)) {
+                console.log('Not running');
+                cleanPid();
+                return;
+            }
+            process.kill(pid, 'SIGTERM');
+            // Wait briefly for clean shutdown
+            for (let i = 0; i < 10; i++) {
+                await new Promise((r) => setTimeout(r, 500));
+                if (!isAlive(pid))
+                    break;
+            }
+            cleanPid();
+            console.log('Stopped');
+            break;
+        }
+        case 'restart': {
+            await serviceCmd('stop');
+            await serviceCmd('start');
+            break;
+        }
+        case 'logs': {
+            if (!existsSync(LOG_FILE)) {
+                console.log('No logs yet. Start the bot first: heyamigo start');
+                return;
+            }
+            spawnSync('tail', ['-f', '-n', '50', LOG_FILE], {
+                stdio: 'inherit',
+            });
+            break;
+        }
+        case 'status': {
+            const pid = readPid();
+            if (pid && isAlive(pid)) {
+                console.log(`Running (PID: ${pid})`);
+            }
+            else {
+                console.log('Not running');
+                cleanPid();
+            }
+            break;
+        }
+    }
+}