digital-brain 0.1.0

package/scripts/digital_brain_whatsapp_mac_sync.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import sqlite3
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+CORE_DATA_EPOCH_OFFSET = 978_307_200
+DEFAULT_DB = Path.home() / "Library/Group Containers/group.net.whatsapp.WhatsApp.shared/ChatStorage.sqlite"
+
+
+def main():
+    args = parse_args()
+    vault = args.vault.resolve()
+    whats_app = vault / "08 Sources" / "WhatsApp"
+    raw_dir = whats_app / "Raw"
+    chats_dir = whats_app / "Chats"
+    state_dir = whats_app / ".sync-state"
+    seen_path = state_dir / "mac-seen-message-ids.json"
+    for directory in (raw_dir, chats_dir, state_dir):
+        directory.mkdir(parents=True, exist_ok=True)
+
+    seen = load_seen(seen_path)
+    total = 0
+    while True:
+        added = sync_once(args, seen, raw_dir, chats_dir, whats_app)
+        total += added
+        save_seen(seen_path, seen)
+        print(f"Added {added} new messages. Total this run: {total}.")
+        if not args.live:
+            break
+        time.sleep(args.interval)
+
+
+def sync_once(args, seen, raw_dir, chats_dir, whats_app):
+    if not args.db.exists():
+        raise SystemExit(f"WhatsApp database not found: {args.db}")
+
+    cutoff = time.time() - args.days * 24 * 60 * 60 - CORE_DATA_EPOCH_OFFSET
+    conn = sqlite3.connect(f"file:{args.db}?mode=ro", uri=True)
+    conn.row_factory = sqlite3.Row
+    rows = conn.execute(
+        """
+        SELECT m.Z_PK message_pk, m.ZSTANZAID stanza_id, m.ZMESSAGEDATE message_date,
+               m.ZISFROMME is_from_me, m.ZFROMJID from_jid, m.ZTOJID to_jid,
+               m.ZPUSHNAME push_name, m.ZTEXT text, m.ZMESSAGETYPE message_type,
+               c.Z_PK chat_pk, c.ZPARTNERNAME chat_name, c.ZCONTACTJID chat_jid,
+               c.ZSESSIONTYPE session_type
+        FROM ZWAMESSAGE m
+        LEFT JOIN ZWACHATSESSION c ON c.Z_PK = m.ZCHATSESSION
+        WHERE m.ZMESSAGEDATE >= ?
+          AND m.ZTEXT IS NOT NULL
+          AND length(m.ZTEXT) > 0
+        ORDER BY m.ZMESSAGEDATE ASC, m.Z_PK ASC
+        """,
+        (cutoff,),
+    ).fetchall()
+    conn.close()
+
+    added = 0
+    for row in rows:
+        record = row_to_record(row, args.self_name)
+        if args.no_groups and record["isGroup"]:
+            continue
+        if args.chat and args.chat.lower() not in record["chatName"].lower():
+            continue
+        if record["id"] in seen:
+            continue
+        append_jsonl(raw_dir, record)
+        append_markdown(chats_dir, whats_app, record, args.markdown_mode)
+        seen.add(record["id"])
+        added += 1
+    return added
+
+
+def row_to_record(row, self_name):
+    timestamp = datetime.fromtimestamp(float(row["message_date"]) + CORE_DATA_EPOCH_OFFSET, tz=timezone.utc).isoformat()
+    chat_name = row["chat_name"] or row["chat_jid"] or "Unknown Chat"
+    from_me = bool(row["is_from_me"])
+    return {
+        "id": str(row["stanza_id"] or f"mac-db-{row['message_pk']}"),
+        "source": "WhatsApp Mac app ChatStorage.sqlite",
+        "timestamp": timestamp,
+        "chatPk": row["chat_pk"],
+        "chatName": chat_name,
+        "chatJid": row["chat_jid"],
+        "isGroup": bool(row["chat_jid"] and "@g.us" in row["chat_jid"]) or row["session_type"] not in (None, 0),
+        "fromMe": from_me,
+        "author": self_name if from_me else (row["push_name"] or row["from_jid"] or "Unknown"),
+        "fromJid": row["from_jid"],
+        "toJid": row["to_jid"],
+        "messageType": row["message_type"],
+        "body": row["text"] or "",
+    }
+
+
+def append_jsonl(raw_dir, record):
+    with (raw_dir / f"{record['timestamp'][:10]}.jsonl").open("a", encoding="utf-8") as f:
+        f.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+
+def append_markdown(chats_dir, whats_app, record, mode):
+    if mode == "none":
+        return
+    if mode == "month":
+        directory = whats_app / "ChatsByMonth" / record["timestamp"][:7]
+        directory.mkdir(parents=True, exist_ok=True)
+        file_path = directory / f"{safe_filename(record['chatName'])}.md"
+    else:
+        file_path = chats_dir / f"{safe_filename(record['chatName'])}.md"
+    if not file_path.exists():
+        file_path.write_text(f"# {record['chatName']}\n\nSynced from WhatsApp Mac app.\n\n", encoding="utf-8")
+    speaker = record["author"]
+    body = " ".join(record["body"].split())
+    with file_path.open("a", encoding="utf-8") as f:
+        f.write(f"- {record['timestamp']} | {speaker}: {body}\n")
+
+
+def load_seen(path):
+    if not path.exists():
+        return set()
+    try:
+        return set(json.loads(path.read_text(encoding="utf-8")))
+    except Exception:
+        return set()
+
+
+def save_seen(path, seen):
+    path.write_text(json.dumps(sorted(seen), indent=2), encoding="utf-8")
+
+
+def safe_filename(value):
+    cleaned = "".join("-" if char in '/:\\?%*"<>|' else char for char in value)
+    return (" ".join(cleaned.split()).strip() or "Unknown Chat")[:120]
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--vault", type=Path, required=True)
+    parser.add_argument("--days", type=int, default=30)
+    parser.add_argument("--live", action="store_true")
+    parser.add_argument("--interval", type=int, default=60)
+    parser.add_argument("--chat", default="")
+    parser.add_argument("--no-groups", action="store_true")
+    parser.add_argument("--db", type=Path, default=DEFAULT_DB)
+    parser.add_argument("--self-name", default="Me")
+    parser.add_argument("--markdown-mode", choices=["chat", "month", "none"], default="chat")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()

package/templates/vault/00 Home/How AI Should Use This Vault.md

@@ -0,0 +1,11 @@
+# How AI Should Use This Vault
+
+Use this vault to understand the user's preferences, relationships, communication patterns, and working context.
+
+Rules:
+
+- Prefer local evidence over assumptions.
+- Be clear when a claim is inferred.
+- Treat generated relationship notes as provisional.
+- Do not send messages without explicit permission.
+

package/templates/vault/00 Home/Start Here.md

@@ -0,0 +1,11 @@
+# Start Here
+
+Digital Brain is your local context layer for AI assistants.
+
+Core notes:
+
+- [[How AI Should Use This Vault]]
+- [[Working Profile]]
+- [[What AI Should Remember]]
+- [[Interpreted Relationship Memory]]
+

package/templates/vault/01 Identity/Working Profile.md

@@ -0,0 +1,11 @@
+# Working Profile
+
+Fill this in manually or let Digital Brain update it over time.
+
+- Name:
+- Location:
+- Work:
+- Current focus:
+- Communication style:
+- Important context:
+

package/templates/vault/04 People/Relationship Overrides.md

@@ -0,0 +1,16 @@
+# Relationship Overrides
+
+Use `08 Sources/WhatsApp/relationship_overrides.json` to manually label important people.
+
+Example:
+
+```json
+{
+  "Mom": {
+    "role": "mother",
+    "confidence": "high",
+    "notes": "Manual label."
+  }
+}
+```
+

package/templates/vault/06 AI Memory/Interpreted Relationship Memory.md

@@ -0,0 +1,4 @@
+# Interpreted Relationship Memory
+
+Run `digital-brain interpret` to populate this file.
+

package/templates/vault/06 AI Memory/What AI Should Remember.md

@@ -0,0 +1,4 @@
+# What AI Should Remember
+
+Add durable user preferences here.
+

package/templates/vault/08 Sources/WhatsApp/Outbound/README.md

@@ -0,0 +1,20 @@
+# WhatsApp Outbound
+
+Outbound sending is disabled unless you explicitly run the sender with `--yes`.
+
+Draft:
+
+```bash
+digital-brain send-whatsapp --vault . --to "Name" --message "Text"
+```
+
+Send:
+
+```bash
+digital-brain send-whatsapp --vault . --to "Name" --message "Text" --yes
+```
+
+Disclosure rule:
+
+- If Digital Brain sends multiple AI-assisted messages in the same chat, it must disclose that AI is helping after roughly 2 messages.
+- The sender enforces this on the third AI-assisted send within 24 hours unless the message already includes a disclosure.

package/templates/vault/08 Sources/WhatsApp/relationship_overrides.example.json

@@ -0,0 +1,8 @@
+{
+  "Mom": {
+    "role": "mother",
+    "confidence": "high",
+    "notes": "Example only. Copy to relationship_overrides.json and edit."
+  }
+}
+

package/templates/vault/AGENTS.md

@@ -0,0 +1,19 @@
+# Digital Brain Context
+
+This is a Digital Brain vault.
+
+Before answering personal-context questions, read:
+
+- `00 Home/Start Here.md`
+- `00 Home/How AI Should Use This Vault.md`
+- `01 Identity/Working Profile.md`
+- `06 AI Memory/What AI Should Remember.md`
+- `06 AI Memory/Interpreted Relationship Memory.md`
+
+Rules:
+
+- Keep answers direct.
+- Separate facts from interpretation.
+- Treat relationship labels as editable working notes.
+- Do not expose private summaries unless asked.
+

package/templates/vault/CLAUDE.md

@@ -0,0 +1,6 @@
+# Digital Brain Context
+
+This is a Digital Brain vault. Use it as local personal context when relevant.
+
+Start with `00 Home/Start Here.md`.
+

package/templates/vault/GEMINI.md

@@ -0,0 +1,5 @@
+# Digital Brain Context
+
+This is a Digital Brain vault. Use it as local personal context when relevant.
+
+Start with `00 Home/Start Here.md`.

package/whatsapp-web/send.mjs

@@ -0,0 +1,139 @@
+import fs from "node:fs";
+import path from "node:path";
+import qrcode from "qrcode-terminal";
+import pkg from "whatsapp-web.js";
+
+const { Client, LocalAuth } = pkg;
+const args = parseArgs(process.argv.slice(2));
+
+if (!args.vault || !args.to || !args.message) usage();
+
+const vault = path.resolve(args.vault);
+const whatsAppDir = path.join(vault, "08 Sources", "WhatsApp");
+const outboundDir = path.join(whatsAppDir, "Outbound");
+const sessionDir = path.join(whatsAppDir, ".session");
+fs.mkdirSync(outboundDir, { recursive: true });
+
+if (!args.yes) {
+  console.log("Draft only. Nothing sent.");
+  console.log(`To: ${args.to}`);
+  console.log(`Message: ${args.message}`);
+  console.log("Re-run with --yes to send.");
+  process.exit(2);
+}
+
+const client = new Client({
+  authStrategy: new LocalAuth({ clientId: "digital-brain", dataPath: sessionDir }),
+  puppeteer: { headless: false, args: ["--no-sandbox", "--disable-setuid-sandbox"] },
+});
+
+client.on("qr", (qr) => {
+  console.log("Scan this QR in WhatsApp > Linked devices:");
+  qrcode.generate(qr, { small: true });
+});
+
+client.on("ready", async () => {
+  try {
+    const chat = await resolveChat(args.to);
+    const disclosure = disclosureStatus(chat);
+    if (disclosure.required && !containsDisclosure(args.message) && !args["skip-disclosure-check"]) {
+      throw new Error(
+        'AI disclosure required before sending. Add a clear disclosure like: "Just flagging this is my AI assistant helping draft/send this."',
+      );
+    }
+    const sent = await chat.sendMessage(args.message);
+    const record = {
+      timestamp: new Date().toISOString(),
+      to: args.to,
+      resolvedChatName: chatName(chat),
+      message: args.message,
+      messageId: sent.id?._serialized || null,
+      aiAssisted: !args.human,
+      disclosureIncluded: containsDisclosure(args.message),
+    };
+    fs.appendFileSync(path.join(outboundDir, "sent.jsonl"), `${JSON.stringify(record)}\n`);
+    fs.appendFileSync(path.join(outboundDir, "Sent.md"), `- ${record.timestamp} | ${record.resolvedChatName}: ${record.message}\n`);
+    console.log(`Sent to ${record.resolvedChatName}`);
+    await client.destroy();
+    process.exit(0);
+  } catch (error) {
+    console.error(`Send failed: ${error.message}`);
+    await client.destroy();
+    process.exit(1);
+  }
+});
+
+client.initialize();
+
+async function resolveChat(target) {
+  const number = normalizePhone(target);
+  if (number) {
+    const id = await client.getNumberId(number);
+    if (!id) throw new Error(`No WhatsApp account found for phone ${target}`);
+    return await client.getChatById(id._serialized);
+  }
+  const chats = await client.getChats();
+  const matches = chats.filter((chat) => chatName(chat).toLowerCase().includes(target.toLowerCase()));
+  if (matches.length === 0) throw new Error(`No chat matched "${target}"`);
+  if (matches.length > 1) throw new Error(`Multiple chats matched "${target}": ${matches.slice(0, 10).map(chatName).join(", ")}`);
+  return matches[0];
+}
+
+function normalizePhone(input) {
+  if (!input.startsWith("+") && !/^\d{8,}$/.test(input)) return "";
+  return input.replace(/[^\d]/g, "");
+}
+
+function chatName(chat) {
+  return chat.name || chat.formattedTitle || chat.id?._serialized || "Unknown Chat";
+}
+
+function parseArgs(argv) {
+  const out = { yes: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--yes") out.yes = true;
+    else if (arg === "--human") out.human = true;
+    else if (arg === "--skip-disclosure-check") out["skip-disclosure-check"] = true;
+    else if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      out[key] = argv[++i] || "";
+    }
+  }
+  return out;
+}
+
+function usage() {
+  console.error('Usage: digital-brain send-whatsapp --vault <path> --to "Name" --message "Text" [--yes]');
+  process.exit(1);
+}
+
+function disclosureStatus(chat) {
+  const logPath = path.join(outboundDir, "sent.jsonl");
+  if (!fs.existsSync(logPath)) return { required: false, count: 0 };
+
+  const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+  const name = chatName(chat);
+  const count = fs
+    .readFileSync(logPath, "utf8")
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter((record) => record)
+    .filter((record) => record.resolvedChatName === name)
+    .filter((record) => record.aiAssisted !== false)
+    .filter((record) => new Date(record.timestamp).getTime() >= cutoff)
+    .filter((record) => !record.disclosureIncluded).length;
+
+  return { required: count >= 2, count };
+}
+
+function containsDisclosure(message) {
+  return /\b(ai|assistant|automated|bot)\b/i.test(message);
+}