claudity 1.0.0

package/src/services/imessage.js

@@ -0,0 +1,200 @@
+const Database = require('better-sqlite3');
+const { execFile } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const chatDbPath = path.join(process.env.HOME, 'Library', 'Messages', 'chat.db');
+const POLL_INTERVAL = 3000;
+const MAX_RESPONSE_LENGTH = 1500;
+
+let db = null;
+let lastRowId = 0;
+let timer = null;
+let chatModule = null;
+let selfChatId = null;
+const recentSent = new Set();
+
+function log(msg) {
+  console.log(`[imessage] ${msg}`);
+}
+
+function open() {
+  if (!fs.existsSync(chatDbPath)) {
+    log('chat.db not found');
+    return false;
+  }
+
+  try {
+    db = new Database(chatDbPath, { fileMustExist: true });
+    db.pragma('journal_mode = WAL');
+    db.pragma('busy_timeout = 2000');
+    db.function('after_delete_message_plugin', { varargs: true }, () => {});
+    db.function('before_delete_attachment_path', { varargs: true }, () => {});
+    db.function('delete_attachment_path', { varargs: true }, () => {});
+    db.function('delete_chat_background_before_deleting_chat', { varargs: true }, () => {});
+    db.function('guid_for_chat', { varargs: true }, () => '');
+    db.function('is_mic_enabled', { varargs: true }, () => 0);
+    db.function('verify_chat', { varargs: true }, () => {});
+    return true;
+  } catch (err) {
+    log('cannot open chat.db: ' + err.message);
+    return false;
+  }
+}
+
+function initSelfChat(phone) {
+  if (!phone) {
+    log('no phone number configured');
+    return false;
+  }
+
+  const row = db.prepare("select ROWID, guid from chat where chat_identifier = ?").get(phone);
+  if (!row) {
+    log(`no self-chat found for ${phone}`);
+    return false;
+  }
+
+  selfChatId = row.ROWID;
+  log(`self-chat: ${row.guid} (id ${selfChatId})`);
+  return true;
+}
+
+function initLastRowId() {
+  const row = db.prepare("select max(ROWID) as maxId from message").get();
+  lastRowId = row && row.maxId ? row.maxId : 0;
+  log(`starting from rowid ${lastRowId}`);
+}
+
+function parseMessage(text) {
+  if (!text) return null;
+  const match = text.match(/^(\w+):\s*(.+)$/s);
+  if (!match) return null;
+  return { agent: match[1].toLowerCase(), command: match[2].trim() };
+}
+
+function readNewMessages() {
+  try {
+    return db.prepare(
+      "select m.ROWID, m.text, m.is_from_me, m.date, c.guid as chat_guid from message m join chat_message_join cmj on cmj.message_id = m.ROWID join chat c on c.ROWID = cmj.chat_id where m.ROWID > ? and m.is_from_me = 0 and m.text is not null and cmj.chat_id = ? order by m.ROWID asc limit 20"
+    ).all(lastRowId, selfChatId);
+  } catch (err) {
+    log('read error: ' + err.message);
+    return [];
+  }
+}
+
+function sendMessage(chatGuid, text) {
+  let truncated = text;
+  if (text.length > MAX_RESPONSE_LENGTH) {
+    truncated = text.slice(0, MAX_RESPONSE_LENGTH) + '...';
+  }
+
+  const escaped = truncated.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+
+  const script = `tell application "Messages"
+  send "${escaped}" to chat id "${chatGuid}"
+end tell`;
+
+  recentSent.add(truncated);
+  setTimeout(() => recentSent.delete(truncated), 15000);
+
+  const beforeMax = db.prepare("select max(ROWID) as maxId from message").get();
+  const beforeId = beforeMax ? beforeMax.maxId : 0;
+
+  execFile('osascript', ['-e', script], (err) => {
+    if (err) {
+      log('send error: ' + err.message);
+      return;
+    }
+    setTimeout(() => deleteResponseEcho(beforeId, truncated), 2000);
+  });
+}
+
+function deleteResponseEcho(afterRowId, text) {
+  try {
+    const echo = db.prepare(
+      "select m.ROWID from message m where m.is_from_me = 0 and m.ROWID > ? and m.text = ?"
+    ).get(afterRowId, text);
+
+    if (echo) {
+      db.prepare("delete from chat_message_join where message_id = ?").run(echo.ROWID);
+      log('deleted response echo');
+    }
+  } catch (err) {
+    log('response echo delete error: ' + err.message);
+  }
+}
+
+function poll() {
+  const messages = readNewMessages();
+
+  for (const msg of messages) {
+    if (msg.ROWID > lastRowId) {
+      lastRowId = msg.ROWID;
+    }
+
+    if (!msg.text) continue;
+    if (recentSent.has(msg.text)) continue;
+
+    const { stmts } = require('../db');
+    let parsed = parseMessage(msg.text);
+    let agent;
+    if (parsed) {
+      agent = stmts.getAgentByName.get(parsed.agent);
+      if (!agent) continue;
+    } else {
+      agent = stmts.getDefaultAgent.get();
+      if (!agent) continue;
+      parsed = { agent: agent.name, command: msg.text.trim() };
+    }
+
+    log(`${parsed.agent}: ${parsed.command}`);
+    handleCommand(agent, parsed.command, msg.chat_guid);
+  }
+}
+
+async function handleCommand(agent, command, chatGuid) {
+  try {
+    const result = await chatModule.enqueueMessage(agent.id, command, {
+      onAck: (text) => sendMessage(chatGuid, text)
+    });
+    if (result && result.content) {
+      sendMessage(chatGuid, result.content);
+    }
+  } catch (err) {
+    sendMessage(chatGuid, `error: ${err.message}`);
+  }
+}
+
+function start(config, callbacks) {
+  chatModule = require('./chat');
+  const { onStatus } = callbacks || {};
+
+  if (!open()) {
+    if (onStatus) onStatus('error', 'chat.db not found');
+    return;
+  }
+  if (!initSelfChat(config && config.phone)) {
+    if (onStatus) onStatus('error', 'self-chat not found for ' + (config && config.phone));
+    return;
+  }
+
+  initLastRowId();
+  timer = setInterval(poll, POLL_INTERVAL);
+  log('relay started');
+  if (onStatus) onStatus('connected', 'polling self-chat');
+}
+
+function stop() {
+  if (timer) {
+    clearInterval(timer);
+    timer = null;
+  }
+  if (db) {
+    db.close();
+    db = null;
+  }
+  log('relay stopped');
+}
+
+module.exports = { start, stop };

package/src/services/memory.js

@@ -0,0 +1,183 @@
+const { spawn } = require('child_process');
+const { v4: uuid } = require('uuid');
+const { db, stmts } = require('../db');
+const auth = require('./auth');
+const workspace = require('./workspace');
+
+const API_URL = 'https://api.anthropic.com/v1/messages';
+const HAIKU_MODEL = 'claude-haiku-4-5-20251001';
+const EXTRACTION_COOLDOWN = 30000;
+
+const lastExtractionTime = new Map();
+
+async function callLightweight(prompt, systemPrompt) {
+  const status = auth.getAuthStatus();
+  if (!status.authenticated) return null;
+
+  if (status.mode === 'api_key') {
+    const headers = auth.getHeaders();
+    const body = {
+      model: HAIKU_MODEL,
+      max_tokens: 1024,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: prompt }]
+    };
+
+    const res = await fetch(API_URL, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body)
+    });
+
+    if (!res.ok) return null;
+    const data = await res.json();
+    const textBlock = data.content?.find(b => b.type === 'text');
+    return textBlock?.text || null;
+  }
+
+  return cliCall(['--model', 'haiku'], prompt, systemPrompt);
+}
+
+function cliCall(extraArgs, prompt, systemPrompt) {
+  return new Promise((resolve) => {
+    const args = ['-p', '--output-format', 'json', '--no-session-persistence', '--dangerously-skip-permissions', '--setting-sources', '', ...extraArgs];
+    if (systemPrompt) args.push('--system-prompt', systemPrompt);
+    let done = false;
+    const proc = spawn('claude', args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 60000,
+      cwd: '/tmp'
+    });
+
+    const fallback = setTimeout(() => {
+      if (!done) {
+        done = true;
+        proc.kill();
+        resolve(null);
+      }
+    }, 65000);
+
+    let stdout = '';
+    proc.stdout.on('data', d => stdout += d);
+    proc.on('close', () => {
+      if (done) return;
+      done = true;
+      clearTimeout(fallback);
+      try {
+        const parsed = JSON.parse(stdout.trim());
+        resolve(typeof parsed.result === 'string' ? parsed.result : null);
+      } catch {
+        resolve(stdout.trim() || null);
+      }
+    });
+    proc.on('error', () => {
+      if (done) return;
+      done = true;
+      clearTimeout(fallback);
+      resolve(null);
+    });
+
+    proc.stdin.write(prompt);
+    proc.stdin.end();
+  });
+}
+
+async function extractMemories(agentId, userContent, assistantContent) {
+  if (typeof userContent === 'string' && userContent.startsWith('[scheduled reminder]')) return;
+
+  const now = Date.now();
+  const last = lastExtractionTime.get(agentId) || 0;
+  if (now - last < EXTRACTION_COOLDOWN) return;
+  lastExtractionTime.set(agentId, now);
+
+  const existing = stmts.listMemories.all(agentId);
+  const existingBlock = existing.length
+    ? 'existing memories:\n' + existing.map(m => `- ${m.summary}`).join('\n')
+    : 'no existing memories.';
+
+  const systemPrompt = `extract only concrete facts THE USER explicitly stated. ignore everything the assistant said. max 3 memories per exchange. only extract: user's name, stated preferences, explicit instructions, key decisions. do NOT extract: greetings, small talk, questions, the assistant's personality, setup details, or anything implied. output a bullet list starting with "- ". if nothing worth remembering, respond with exactly "none".`;
+
+  const prompt = `${existingBlock}\n\nlatest exchange:\nuser: ${userContent}\nassistant: ${assistantContent}`;
+
+  try {
+    const result = await callLightweight(prompt, systemPrompt);
+    if (!result || result.trim().toLowerCase() === 'none') return;
+
+    const lines = result.split('\n')
+      .map(l => l.replace(/^-\s*/, '').trim())
+      .filter(l => l.length > 0 && l.length < 500)
+      .filter(l => !/^(done|here|your|i've|i have|consolidated|saved|memory is|sure|no new)/i.test(l));
+
+    const agent = stmts.getAgent.get(agentId);
+
+    for (const line of lines) {
+      stmts.createMemory.run(uuid(), agentId, line);
+      if (agent) {
+        try { workspace.appendToDaily(agent.name, line); } catch (err) {
+          console.error(`[memory] daily log error: ${err.message}`);
+        }
+      }
+    }
+
+    if (lines.length > 0) {
+      console.log(`[memory] extracted ${lines.length} memories for agent ${agentId}`);
+    }
+  } catch (err) {
+    console.error(`[memory] extraction error: ${err.message}`);
+  }
+}
+
+function startConsolidation() {
+  console.log('[memory] consolidation service started (every 15 min)');
+
+  setInterval(async () => {
+    try {
+      const agents = stmts.listAgents.all();
+
+      for (const agent of agents) {
+        const memories = stmts.listMemories.all(agent.id);
+        if (memories.length < 5) continue;
+
+        const memoryList = memories.map(m => `- ${m.summary}`).join('\n');
+        const systemPrompt = `you are a memory consolidation tool. your ONLY job is to deduplicate and clean up a list of factual memories. output ONLY a bullet list — one fact per line, each starting with "- ". do NOT add commentary, explanations, confirmations, or any text that is not a memory. do NOT say "done" or "here is your list" or anything like that. just output the cleaned list.`;
+
+        const result = await callLightweight(memoryList, systemPrompt);
+        if (!result || result.trim().toLowerCase() === 'none') continue;
+
+        const lines = result.split('\n')
+          .map(l => l.replace(/^-\s*/, '').trim())
+          .filter(l => l.length > 0 && l.length < 500)
+          .filter(l => /^[A-Z]/.test(l) || /^[a-z]/.test(l))
+          .filter(l => !/^(done|here|your|i've|i have|consolidated|saved|memory is|sure|i appreciate|i'm claude|i'm an|i need to|based on|please provide|what memories|i'm ready)/i.test(l))
+          .filter(l => !/(clarify my|actual role|anthropic|memory consolidation tool|deduplicate)/i.test(l));
+
+        if (lines.length === 0) continue;
+        if (lines.length < memories.length * 0.3) {
+          console.log(`[memory] skipping consolidation for ${agent.name} — output too small (${lines.length} vs ${memories.length})`);
+          continue;
+        }
+
+        const consolidate = db.transaction(() => {
+          stmts.deleteMemories.run(agent.id);
+          for (const line of lines) {
+            stmts.createMemory.run(uuid(), agent.id, line);
+          }
+        });
+        consolidate();
+
+        try {
+          const memoryMd = lines.map(l => `- ${l}`).join('\n');
+          workspace.writeFile(agent.name, 'MEMORY.md', memoryMd + '\n');
+        } catch (err) {
+          console.error(`[memory] failed to write MEMORY.md for ${agent.name}: ${err.message}`);
+        }
+
+        console.log(`[memory] consolidated ${memories.length} → ${lines.length} memories for ${agent.name}`);
+      }
+    } catch (err) {
+      console.error(`[memory] consolidation error: ${err.message}`);
+    }
+  }, 15 * 60 * 1000);
+}
+
+module.exports = { extractMemories, startConsolidation, callLightweight };

package/src/services/scheduler.js

@@ -0,0 +1,32 @@
+const { stmts } = require('../db');
+
+let chatModule = null;
+let timer = null;
+
+function start() {
+  chatModule = require('./chat');
+  timer = setInterval(tick, 30000);
+  tick();
+}
+
+function stop() {
+  if (timer) clearInterval(timer);
+}
+
+function tick() {
+  const now = Date.now();
+  const due = stmts.dueSchedules.all(now);
+
+  for (const schedule of due) {
+    stmts.updateScheduleRun.run(now, now + schedule.interval_ms, schedule.id);
+
+    chatModule.enqueueMessage(
+      schedule.agent_id,
+      `[scheduled reminder] ${schedule.description}`
+    ).catch(err => {
+      console.log(`[scheduler] schedule ${schedule.id} failed: ${err.message}`);
+    });
+  }
+}
+
+module.exports = { start, stop };

package/src/services/signal.js

@@ -0,0 +1,237 @@
+const { spawn, execSync } = require('child_process');
+const QRCode = require('qrcode');
+
+const MAX_RESPONSE_LENGTH = 4000;
+
+let daemon = null;
+let rpcId = 1;
+
+function log(msg) {
+  console.log(`[signal] ${msg}`);
+}
+
+function parseMessage(text) {
+  if (!text) return null;
+  const match = text.match(/^(\w+):\s*(.+)$/s);
+  if (!match) return null;
+  return { agent: match[1].toLowerCase(), command: match[2].trim() };
+}
+
+function signalCliAvailable() {
+  try {
+    execSync('which signal-cli', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function send(recipient, message) {
+  if (!daemon || !daemon.stdin.writable) return;
+  const req = JSON.stringify({ jsonrpc: '2.0', id: rpcId++, method: 'send', params: { recipient: [recipient], message } });
+  daemon.stdin.write(req + '\n');
+}
+
+function startDaemon(phone, onStatus, chatModule, stmts) {
+  daemon = spawn('signal-cli', ['-a', phone, 'jsonRpc', '--receive-mode=on-start', '--send-read-receipts'], { stdio: ['pipe', 'pipe', 'pipe'] });
+
+  log(`daemon started for ${phone} (pid ${daemon.pid})`);
+  if (onStatus) onStatus('connected', phone);
+
+  let buffer = '';
+
+  daemon.stdout.on('data', (chunk) => {
+    buffer += chunk.toString();
+    let newline;
+    while ((newline = buffer.indexOf('\n')) !== -1) {
+      const line = buffer.slice(0, newline).trim();
+      buffer = buffer.slice(newline + 1);
+      if (!line) continue;
+
+      let msg;
+      try { msg = JSON.parse(line); } catch { continue; }
+
+      if (msg.method === 'receive') {
+        const envelope = msg.params && msg.params.envelope;
+        if (!envelope) continue;
+
+        let text, sender;
+
+        if (envelope.dataMessage && envelope.dataMessage.message) {
+          text = envelope.dataMessage.message;
+          sender = envelope.sourceNumber || envelope.source;
+        } else if (envelope.syncMessage && envelope.syncMessage.sentMessage && envelope.syncMessage.sentMessage.message) {
+          text = envelope.syncMessage.sentMessage.message;
+          sender = envelope.syncMessage.sentMessage.destinationNumber || envelope.syncMessage.sentMessage.destination || envelope.sourceNumber || envelope.source;
+        }
+
+        if (!text || !sender) continue;
+        if (!sender) continue;
+
+        let parsed = parseMessage(text);
+        let agent;
+        if (parsed) {
+          agent = stmts.getAgentByName.get(parsed.agent);
+          if (!agent) {
+            send(sender, `no agent named "${parsed.agent}"`);
+            continue;
+          }
+        } else {
+          agent = stmts.getDefaultAgent.get();
+          if (!agent) continue;
+          parsed = { agent: agent.name, command: text.trim() };
+        }
+
+        log(`${parsed.agent}: ${parsed.command}`);
+
+        chatModule.enqueueMessage(agent.id, parsed.command, {
+          onAck: (ackText) => send(sender, ackText)
+        }).then((result) => {
+          if (result && result.content) {
+            let reply = result.content;
+            if (reply.length > MAX_RESPONSE_LENGTH) {
+              reply = reply.slice(0, MAX_RESPONSE_LENGTH) + '...';
+            }
+            send(sender, reply);
+          }
+        }).catch((err) => {
+          send(sender, `error: ${err.message}`);
+        });
+      }
+    }
+  });
+
+  daemon.stderr.on('data', (chunk) => {
+    const text = chunk.toString().trim();
+    if (text) log(`stderr: ${text}`);
+  });
+
+  daemon.on('close', (code) => {
+    log(`daemon exited with code ${code}`);
+    daemon = null;
+    if (onStatus) onStatus('error', `signal-cli exited (code ${code})`);
+  });
+}
+
+function extractPhone(text) {
+  const match = text.match(/(\+\d{7,15})/);
+  return match ? match[1] : null;
+}
+
+function detectAccount() {
+  try {
+    const output = execSync('signal-cli --list-accounts 2>&1', { encoding: 'utf8', timeout: 5000 });
+    return extractPhone(output);
+  } catch { return null; }
+}
+
+function finishLink(phone, onStatus, chatModule, stmts, updateConfig) {
+  log(`linked as ${phone}`);
+  updateConfig({ phone });
+  startDaemon(phone, onStatus, chatModule, stmts);
+}
+
+function startLinking(onStatus, chatModule, stmts, updateConfig) {
+  const link = spawn('signal-cli', ['link', '-n', 'claudity'], { stdio: ['pipe', 'pipe', 'pipe'] });
+  let linked = false;
+  let linkBuffer = '';
+  let errBuffer = '';
+
+  function tryLink(text) {
+    if (linked) return;
+    const phone = extractPhone(text);
+    if (phone) {
+      linked = true;
+      finishLink(phone, onStatus, chatModule, stmts, updateConfig);
+    }
+  }
+
+  link.stdout.on('data', (chunk) => {
+    linkBuffer += chunk.toString();
+    let newline;
+    while ((newline = linkBuffer.indexOf('\n')) !== -1) {
+      const line = linkBuffer.slice(0, newline).trim();
+      linkBuffer = linkBuffer.slice(newline + 1);
+      if (!line) continue;
+
+      if (line.startsWith('tsdevice:') || line.startsWith('sgnl:')) {
+        log('link uri received');
+        QRCode.toDataURL(line, { width: 256, margin: 2 }).then((dataUrl) => {
+          if (onStatus) onStatus('qr', dataUrl);
+        }).catch((err) => {
+          log('qr generation failed: ' + err.message);
+        });
+      } else {
+        tryLink(line);
+      }
+    }
+  });
+
+  link.stderr.on('data', (chunk) => {
+    const text = chunk.toString();
+    errBuffer += text;
+    const trimmed = text.trim();
+    if (trimmed) log(`link stderr: ${trimmed}`);
+    tryLink(trimmed);
+  });
+
+  link.on('close', (code) => {
+    if (linked) return;
+
+    tryLink(errBuffer);
+
+    if (!linked) {
+      const phone = detectAccount();
+      if (phone) {
+        linked = true;
+        finishLink(phone, onStatus, chatModule, stmts, updateConfig);
+        return;
+      }
+    }
+
+    if (!linked) {
+      log(`link process exited with code ${code}`);
+      if (onStatus) onStatus('error', 'linking failed — scan the qr code within 60 seconds');
+    }
+  });
+
+  return link;
+}
+
+let linkProcess = null;
+
+function start(config, callbacks) {
+  const { onStatus } = callbacks || {};
+
+  if (!signalCliAvailable()) {
+    if (onStatus) onStatus('error', 'signal-cli not found — install with: brew install signal-cli');
+    return;
+  }
+
+  const chatModule = require('./chat');
+  const { stmts } = require('../db');
+
+  if (config.phone) {
+    startDaemon(config.phone, onStatus, chatModule, stmts);
+  } else {
+    const updateConfig = (newFields) => {
+      const merged = { ...config, ...newFields };
+      stmts.updateConnectionConfig.run(JSON.stringify(merged), 'signal');
+    };
+    linkProcess = startLinking(onStatus, chatModule, stmts, updateConfig);
+  }
+}
+
+function stop() {
+  if (linkProcess) {
+    linkProcess.kill();
+    linkProcess = null;
+  }
+  if (daemon) {
+    daemon.kill();
+    daemon = null;
+  }
+  log('disconnected');
+}
+
+module.exports = { start, stop };