digital-brain 1.1.15 → 1.1.20

package/README.md

@@ -83,8 +83,8 @@ node ./bin/digital-brain.js init ./Digital Brain\ Vault
 - Generate reply-ready person context that keeps WhatsApp, iMessage, Slack, and LinkedIn evidence separate under the same person.
 - Create AI-readable memory files for future prompts.
 - Draft WhatsApp sends by default, send with explicit `--yes`, or configure auto-send mode during init.
-- Run an explicit WhatsApp auto-responder that uses Ollama or a Codex command plus vault memory while the command is running.
-- Choose the WhatsApp auto-reply provider during init: Ollama, Codex app bridge, or Codex CLI.
+- Run an explicit WhatsApp auto-responder that uses Ollama, OpenAI, or Codex plus vault memory while the command is running.
+- Choose the WhatsApp auto-reply provider during init: Ollama, OpenAI API, Codex app bridge, or Codex CLI.
 - Enforce an AI-disclosure guard after repeated AI-assisted sends.
 
 ## Core Commands
@@ -99,6 +99,7 @@ digital-brain import-linkedin --input ./linkedin-archive.zip
 digital-brain send-whatsapp --to "Name" --message "text"
 digital-brain auto-whatsapp --allow "Name" --model llama3.1
 digital-brain auto-whatsapp --contact "+15551234567" --model llama3.1
+OPENAI_API_KEY="sk-..." digital-brain auto-whatsapp --allow-all --provider openai --model gpt-4.1-mini --yes
 digital-brain auto-whatsapp --allow-all --provider codex --yes
 digital-brain auto-whatsapp --allow-all --provider codex-app --yes
 ```
@@ -127,6 +128,7 @@ digital-brain auto-whatsapp --allow "Mom" --model llama3.1
 digital-brain auto-whatsapp --allow "Mom" --model llama3.1 --yes
 digital-brain auto-whatsapp --allow "Mom" --model llama3.1 --yes --no-process-unread
 digital-brain auto-whatsapp --contact "+15551234567" --model llama3.1 --yes
+OPENAI_API_KEY="sk-..." digital-brain auto-whatsapp --allow-all --provider openai --model gpt-4.1-mini --yes
 digital-brain auto-whatsapp --allow-all --provider codex --yes
 digital-brain auto-whatsapp --allow-all --provider codex-app --yes
 ```
@@ -135,7 +137,13 @@ If you start without `--allow`, `--contact`, or `--allow-all` in an interactive
 
 Even with `--allow-all`, likely business, notification, OTP, delivery, bank, and support chats are skipped by default. Use explicit `--allow "Name"` or `--contact "+15551234567"` for trusted personal chats. Pass `--include-businesses` only if you intentionally want those chats included.
 
-The default provider is local Ollama. `--provider codex` uses the Codex CLI. `--provider codex-app` uses a file bridge for the Codex desktop app.
+The default provider is local Ollama. `--provider openai` uses the OpenAI API with the same vault context prompt. `--provider codex` uses the Codex CLI. `--provider codex-app` uses a file bridge for the Codex desktop app.
+
+```bash
+OPENAI_API_KEY="sk-..." digital-brain auto-whatsapp --allow-all --provider openai --model gpt-4.1-mini --yes
+```
+
+If you select `OpenAI API` during `digital-brain init`, you can either paste an API key to store it in the local vault config or leave it blank and set `OPENAI_API_KEY` before running `auto-whatsapp`.
 
 ```bash
 digital-brain auto-whatsapp --allow-all --provider codex --yes

package/bin/digital-brain.js

@@ -50,6 +50,8 @@ async function init(argv, args) {
   let timezone = args.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone || "local";
   let outboundMode = args["outbound-mode"] || "draft";
   let autoReplyProvider = args["auto-reply-provider"] || args.provider || "ollama";
+  let openaiApiKey = args["openai-api-key"] || "";
+  let openaiModel = args["openai-model"] || "gpt-4.1-mini";
   let privacyMode = args["privacy-mode"] || "standard";
   let sourceMarkdownMode = args["source-markdown-mode"] || "none";
   let selectedSources = parseList(args.sources || "whatsapp");
@@ -109,9 +111,17 @@ async function init(argv, args) {
     if (outboundMode !== "disabled") {
       autoReplyProvider = await select(rl, "WhatsApp auto-reply brain", [
         ["ollama", "Ollama local model", "Runs fully local if Ollama and the model are installed.", "🦙"],
+        ["openai", "OpenAI API", "Fast hosted replies using the same Digital Brain context prompt.", "⚡"],
         ["codex-app", "Codex app bridge", "Uses request/response files for a Codex desktop automation or thread.", "🧠"],
         ["codex", "Codex CLI", "Uses a local codex command; only choose this if the CLI works.", "⌨️"],
       ], autoReplyProvider);
+      if (autoReplyProvider === "openai") {
+        openaiModel = await ask(rl, "🤖 OpenAI model", openaiModel);
+        openaiApiKey = await askSecret(rl, "🔑 OpenAI API key", {
+          fallbackLabel: process.env.OPENAI_API_KEY ? "OPENAI_API_KEY env found" : "use OPENAI_API_KEY at runtime",
+          helpText: "Paste a key to store it locally in this vault config. Leave blank to use OPENAI_API_KEY at runtime.",
+        });
+      }
     }
     connectAi = await confirm(rl, "🔗 Add global AI pointers for Codex/Claude/Gemini?", true);
     responsibilityAccepted = await responsibilityGate(rl, { schedule, outboundMode });
@@ -141,6 +151,8 @@ async function init(argv, args) {
     timezone,
     outboundMode,
     autoReplyProvider,
+    autoReplyModel: autoReplyProvider === "openai" ? openaiModel : args.model || undefined,
+    openaiApiKey: autoReplyProvider === "openai" && openaiApiKey ? openaiApiKey : undefined,
     privacyMode,
     sourceMarkdownMode,
     selectedSources,
@@ -184,6 +196,9 @@ async function init(argv, args) {
       console.log("Codex app config was not detected. The bridge guide was still generated for later use.");
     }
   }
+  if (autoReplyProvider === "openai" && !openaiApiKey && !process.env.OPENAI_API_KEY) {
+    console.log("OpenAI provider selected. Set OPENAI_API_KEY before running auto-whatsapp, or add openaiApiKey to the vault config.");
+  }
   console.log("Next:");
   console.log("  digital-brain run");
   if (schedule === "always-on") console.log(`  "${path.join(vault, "Tools", "digital-brain-watch.sh")}"`);
@@ -310,6 +325,14 @@ function printSetupCheck(vault, options = {}) {
       optional: true,
     },
   ];
+  if (config.autoReplyProvider === "openai") {
+    checks.push({
+      label: "OpenAI API key",
+      ok: Boolean(process.env.OPENAI_API_KEY || config.openaiApiKey),
+      value: process.env.OPENAI_API_KEY ? "found in OPENAI_API_KEY" : config.openaiApiKey ? "stored in vault config" : "not found",
+      hint: "Set OPENAI_API_KEY or re-run init and choose OpenAI API.",
+    });
+  }
   if (selectedSources.includes("whatsapp")) {
     checks.push({
       label: "WhatsApp Mac database",
@@ -507,6 +530,13 @@ async function ask(rl, label, fallback, helpText = "") {
   return answer.trim() || fallback;
 }
 
+async function askSecret(rl, label, options = {}) {
+  if (options.helpText) console.log(`  ${options.helpText}`);
+  const suffix = options.fallbackLabel ? ` [${options.fallbackLabel}]` : "";
+  const answer = await rl.question(`${label}${suffix}: `);
+  return answer.trim();
+}
+
 async function askNumber(rl, label, fallback, options = {}) {
   const suffix = options.suffix ? ` ${options.suffix}` : "";
   const answer = await ask(rl, `${label}${suffix}`, String(fallback));
@@ -657,6 +687,6 @@ Usage:
   digital-brain extract --days 30
   digital-brain interpret --days 30
   digital-brain send-whatsapp --to "Name" --message "Text" [--yes]
-  digital-brain auto-whatsapp --allow "Name" --contact "+15551234567" --provider ollama|codex --model llama3.1 [--yes] [--no-process-unread]
+  digital-brain auto-whatsapp --allow "Name" --contact "+15551234567" --provider ollama|openai|codex|codex-app --model llama3.1 [--yes] [--no-process-unread]
 `);
 }

package/docs/AUTOMATIONS.md

@@ -98,13 +98,14 @@ The generated script loops forever and sleeps for `refreshIntervalMinutes`. The
 
 ## WhatsApp Auto-Reply
 
-`digital-brain auto-whatsapp` is separate from refresh automation. It uses WhatsApp Web for live incoming messages and either Ollama or a Codex command for reply generation. On startup it scans unread WhatsApp Web chats, then continues listening for new messages.
+`digital-brain auto-whatsapp` is separate from refresh automation. It uses WhatsApp Web for live incoming messages and Ollama, OpenAI, or Codex for reply generation. On startup it scans unread WhatsApp Web chats, then continues listening for new messages.
 
 Draft-only:
 
 ```bash
 digital-brain auto-whatsapp --allow "Mom" --model llama3.1
 digital-brain auto-whatsapp --contact "+15551234567" --model llama3.1
+OPENAI_API_KEY="sk-..." digital-brain auto-whatsapp --allow-all --provider openai --model gpt-4.1-mini
 digital-brain auto-whatsapp --allow-all --provider codex
 digital-brain auto-whatsapp --allow-all --provider codex-app
 ```
@@ -114,6 +115,7 @@ Auto-send while the command is running:
 ```bash
 digital-brain auto-whatsapp --allow "Mom" --model llama3.1 --yes
 digital-brain auto-whatsapp --contact "+15551234567" --model llama3.1 --yes
+OPENAI_API_KEY="sk-..." digital-brain auto-whatsapp --allow-all --provider openai --model gpt-4.1-mini --yes
 digital-brain auto-whatsapp --allow-all --provider codex --yes
 digital-brain auto-whatsapp --allow-all --provider codex-app --yes
 ```
@@ -132,11 +134,14 @@ Provider options:
 
 ```bash
 digital-brain auto-whatsapp --allow "Mom" --provider ollama --model llama3.1 --yes
+OPENAI_API_KEY="sk-..." digital-brain auto-whatsapp --allow "Mom" --provider openai --model gpt-4.1-mini --yes
 digital-brain auto-whatsapp --allow "Mom" --provider codex --yes
 digital-brain auto-whatsapp --allow "Mom" --provider codex-app --yes
 digital-brain auto-whatsapp --allow "Mom" --provider codex --codex-command "codex exec --skip-git-repo-check" --yes
 ```
 
+`--provider openai` sends the same Digital Brain prompt and relevant vault context to the OpenAI API. Set `OPENAI_API_KEY`, pass `--openai-api-key`, or choose OpenAI during `digital-brain init` and paste the key into the local vault config.
+
 `--provider codex` runs a local Codex command. If `--codex-command` contains `{promptFile}`, Digital Brain writes the prompt to a temp file and substitutes the path; otherwise it pipes the prompt to stdin.
 
 `--provider codex-app` does not use the Codex CLI. It writes request JSON files to `08 Sources/WhatsApp/Outbound/Codex App Bridge/requests` and waits for response JSON files in `responses`. A Codex desktop automation or live Codex thread must process those request files and write `{"reply":"..."}` to the provided `responsePath`.
@@ -153,6 +158,7 @@ Guardrails:
 
 - with `--provider ollama`, requires Ollama running locally
 - with `--provider ollama`, requires the selected model, for example `ollama pull llama3.1`
+- with `--provider openai`, requires `OPENAI_API_KEY`, `--openai-api-key`, or `openaiApiKey` in the vault config
 - with `--provider codex`, requires a working local Codex command
 - with `--provider codex-app`, requires a Codex desktop bridge automation/thread that writes response files
 - requires `--allow "Name"` or `--contact "+15551234567"` unless `--allow-all` is explicitly passed
@@ -161,7 +167,7 @@ Guardrails:
 - processes unread chats on startup unless `--no-process-unread` is passed
 - skips groups unless `--include-groups` is passed
 - uses a per-chat cooldown, default 20 minutes
-- caps replies per chat per run, default 5
+- no reply cap by default, so conversations can continue naturally; pass `--max-replies-per-chat <n>` to add one
 - logs metadata by default, not full sent text
 - enforces the AI disclosure rule after repeated AI-assisted sends, but does not repeat it after that chat has already received a disclosure
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "digital-brain",
-  "version": "1.1.15",
+  "version": "1.1.20",
   "description": "Your private digital imprint for AI assistants.",
   "type": "module",
   "bin": {

package/whatsapp-web/auto-reply.mjs

@@ -23,8 +23,9 @@ const whitelistPath = path.join(outboundDir, "auto-reply-whitelist.json");
 const codexAppBridgeDir = path.join(outboundDir, "Codex App Bridge");
 const config = readConfig(vault);
 const provider = args.provider || config.autoReplyProvider || "ollama";
-const model = args.model || config.autoReplyModel || "llama3.1";
+const model = args.model || config.autoReplyModel || (provider === "openai" ? "gpt-4.1-mini" : "llama3.1");
 const codexCommand = args["codex-command"] || process.env.DIGITAL_BRAIN_CODEX_COMMAND || config.codexCommand || "codex exec --skip-git-repo-check";
+const openaiApiKey = args["openai-api-key"] || process.env.OPENAI_API_KEY || config.openaiApiKey || "";
 const allow = parseList(args.allow || "");
 const deny = parseList(args.deny || "");
 const contactNumbers = parseList([args.contact, args.phone, args["contact-number"]].filter(Boolean).join(","))
@@ -38,7 +39,7 @@ const includeBusinesses = Boolean(args["include-businesses"]);
 const sendEnabled = Boolean(args.yes) || config.outboundMode === "auto-send";
 const processUnreadOnStart = !Boolean(args["no-process-unread"]);
 const cooldownMinutes = numberArg("cooldown-minutes", 20);
-const maxRepliesPerChat = numberArg("max-replies-per-chat", 5);
+const maxRepliesPerChat = numberArg("max-replies-per-chat", 0);
 const maxContextChars = numberArg("max-context-chars", 12000);
 const outboundLogMode = args["log-mode"] || config.outboundLogMode || "metadata";
 const state = loadState();
@@ -63,8 +64,10 @@ if (!hasInitialScope && !interactiveTerminal) {
 
 if (provider === "ollama") {
   await assertOllamaModel(model);
+} else if (provider === "openai") {
+  assertOpenAiConfig();
 } else if (!["codex", "codex-app"].includes(provider)) {
-  throw new Error(`Unsupported auto-reply provider "${provider}". Use "ollama", "codex", or "codex-app".`);
+  throw new Error(`Unsupported auto-reply provider "${provider}". Use "ollama", "openai", "codex", or "codex-app".`);
 }
 
 const client = new Client({
@@ -78,13 +81,14 @@ client.on("qr", (qr) => {
 });
 
 client.on("ready", async () => {
-  console.log(`Digital Brain WhatsApp auto-reply running with provider: ${provider}${provider === "ollama" ? ` (${model})` : ""}`);
+  console.log(`Digital Brain WhatsApp auto-reply running with provider: ${provider}${["ollama", "openai"].includes(provider) ? ` (${model})` : ""}`);
   console.log(sendEnabled ? "Auto-send is enabled." : "Draft mode. Replies will be logged but not sent. Add --yes or set outboundMode=auto-send to send.");
   if (!hasInitialScope) await configureInteractiveScope();
   console.log(runtimeAllowAll ? "Allowlist: all chats, with first-send approval per new chat." : allowlistSummary());
   if (provider === "codex") console.log(`Codex command: ${codexCommand}`);
   if (provider === "codex-app") console.log(`Codex App bridge: ${codexAppBridgeDir}`);
   if (!includeBusinesses) console.log("Likely business, notification, OTP, and service chats are skipped by default.");
+  console.log(maxRepliesPerChat > 0 ? `Reply cap: ${maxRepliesPerChat} per chat per run.` : "Reply cap: unlimited.");
   try {
     if (processUnreadOnStart) {
       await processUnreadChats();
@@ -126,7 +130,7 @@ async function processUnreadChats() {
       console.log(`Skipping unread chat during cooldown: ${name}`);
       continue;
     }
-    if (replyCount(name) >= maxRepliesPerChat) {
+    if (isAtReplyCap(name)) {
       console.log(`Skipping unread chat at reply cap: ${name}`);
       continue;
     }
@@ -242,7 +246,7 @@ async function handleMessage(message, knownChat = null) {
     console.log(`Skipping chat during cooldown: ${name}`);
     return;
   }
-  if (replyCount(name) >= maxRepliesPerChat) {
+  if (isAtReplyCap(name)) {
     console.log(`Skipping chat at reply cap: ${name}`);
     return;
   }
@@ -347,9 +351,44 @@ function readMemoryContext(chatName) {
 async function generateReply(prompt) {
   if (provider === "codex") return generateCodexReply(prompt);
   if (provider === "codex-app") return generateCodexAppReply(prompt);
+  if (provider === "openai") return generateOpenAiReply(prompt);
   return generateOllamaReply(prompt);
 }
 
+async function generateOpenAiReply(prompt) {
+  const timeoutMs = numberArg("provider-timeout-ms", 45000);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch("https://api.openai.com/v1/responses", {
+      method: "POST",
+      signal: controller.signal,
+      headers: {
+        "authorization": `Bearer ${openaiApiKey}`,
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        model,
+        input: prompt,
+        max_output_tokens: 160,
+        temperature: 0.35,
+      }),
+    });
+  } catch (error) {
+    if (error.name === "AbortError") throw new Error(`OpenAI reply timed out after ${timeoutMs}ms`);
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+  const text = await response.text();
+  if (!response.ok) throw new Error(`OpenAI reply failed: ${response.status} ${summarize(text)}`);
+  const body = parseJsonLine(text);
+  const reply = extractOpenAiText(body);
+  if (!reply) throw new Error("OpenAI returned an empty reply.");
+  return cleanReply(reply);
+}
+
 async function generateOllamaReply(prompt) {
   const response = await fetch("http://127.0.0.1:11434/api/generate", {
     method: "POST",
@@ -465,6 +504,24 @@ async function assertOllamaModel(modelName) {
   }
 }
 
+function assertOpenAiConfig() {
+  if (!openaiApiKey) {
+    throw new Error("OpenAI provider requires an API key. Set OPENAI_API_KEY, pass --openai-api-key, or re-run init and enter the key.");
+  }
+}
+
+function extractOpenAiText(body) {
+  if (!body) return "";
+  if (typeof body.output_text === "string") return body.output_text;
+  const chunks = [];
+  for (const item of body.output || []) {
+    for (const content of item.content || []) {
+      if (typeof content.text === "string") chunks.push(content.text);
+    }
+  }
+  return chunks.join(" ");
+}
+
 function cleanReply(value) {
   return String(value)
     .replace(/^["'\s]+|["'\s]+$/g, "")
@@ -630,6 +687,10 @@ function replyCount(name) {
   return state.sentCountByChat[name] || 0;
 }
 
+function isAtReplyCap(name) {
+  return maxRepliesPerChat > 0 && replyCount(name) >= maxRepliesPerChat;
+}
+
 function markProcessed(message, name, options = { sent: true }) {
   state.processedMessageIds.push(message.id?._serialized);
   state.processedMessageIds = state.processedMessageIds.filter(Boolean).slice(-1000);
@@ -805,6 +866,6 @@ function parseArgs(argv) {
 }
 
 function usage() {
-  console.error('Usage: digital-brain auto-whatsapp --allow "Name" --contact "+15551234567" --provider ollama|codex|codex-app --model llama3.1 [--yes] [--allow-all] [--include-groups] [--include-businesses]');
+  console.error('Usage: digital-brain auto-whatsapp --allow "Name" --contact "+15551234567" --provider ollama|openai|codex|codex-app --model llama3.1 [--yes] [--allow-all] [--include-groups] [--include-businesses]');
   process.exit(1);
 }