alive-ai 0.1.7 → 0.1.9

package/brain/memory/fact_extractor.py

@@ -3,22 +3,25 @@ import json
 import re
 from pathlib import Path
 
-EXTRACT_PROMPT = """You are analyzing a conversation between Alive-AI (AI) and a HUMAN USER.
-Extract facts about THE HUMAN USER ONLY - nothing about Alive-AI.
+def build_extract_prompt(agent_name: str) -> str:
+    agent = agent_name or "the AI"
+    return f"""You are analyzing a conversation between {agent} (AI) and a HUMAN USER.
+Extract facts about THE HUMAN USER ONLY - nothing about {agent}.
 
-Look at what the HUMAN says about THEMSELF and their relationship with Alive-AI. Extract:
+Look at what the HUMAN says about THEMSELF and their relationship with {agent}. Extract:
 - name, nickname, age, gender, job, location
 - hobbies, interests, favorite things
 - personality traits, communication style
-- relationship to Alive-AI (creator, boyfriend, etc.)
+- relationship to {agent} (creator, boyfriend, etc.)
 - pet names they use (daddy, baby, etc.)
 - intimacy preferences, preferences mentioned
-- what they like about Alive-AI
+- what they like about {agent}
 - important people in their life
 
 Return ONLY valid JSON with keys where you found NEW info about the HUMAN.
 Use these keys: name, nickname, gender, age, location, job, hobbies, interests, personality, relationship_status, pet_names_used, likes_about_me, intimacy_preferences
-Return empty {} if nothing new was shared about the human.
+When storing facts about what the human likes about the AI, use the configured name "{agent}", not the product name "Alive-AI", unless the human literally used "Alive-AI" as the name.
+Return empty {{}} if nothing new was shared about the human.
 NO markdown, ONLY raw JSON. Do NOT use ... or etc."""
 
 
@@ -75,8 +78,9 @@ def _repair_json(text: str) -> dict:
 class FactExtractor:
     """Extracts user facts from conversation using LLM"""
 
-    def __init__(self, facts_path: Path):
+    def __init__(self, facts_path: Path, agent_name: str = "AI"):
         self.facts_path = facts_path
+        self.agent_name = str(agent_name or "AI")
         self._llm = None
         self._turn_buffer = []
         self._extract_every = 5
@@ -102,12 +106,12 @@ class FactExtractor:
         lines = []
         for turn in self._turn_buffer[-self._extract_every:]:
             lines.append(f"User: {turn['user']}")
-            lines.append(f"Alive-AI: {turn['ai']}")
+            lines.append(f"{self.agent_name}: {turn['ai']}")
         conversation = "\n".join(lines)
 
         try:
             messages = [
-                {"role": "system", "content": EXTRACT_PROMPT},
+                {"role": "system", "content": build_extract_prompt(self.agent_name)},
                 {"role": "user", "content": conversation}
             ]
             response = await self._llm.chat(messages, max_tokens=500, temperature=0.1)

package/brain/memory/manager.py

@@ -34,8 +34,9 @@ class Memory:
         self.working = WorkingMemory()
         self.episodic = EpisodicMemory(self.data_path, user_id=user_id)
         self.semantic = SemanticMemory(self.data_path, user_id=user_id)
-        self.fact_extractor = FactExtractor(self.data_path / "facts.json")
-        self.summarizer = ConversationSummarizer(self.data_path)
+        self.agent_name = str(bot_id or "AI")
+        self.fact_extractor = FactExtractor(self.data_path / "facts.json", agent_name=self.agent_name)
+        self.summarizer = ConversationSummarizer(self.data_path, agent_name=self.agent_name)
         self.vector_store = None
         self.openmind = None
         self.bot_id = bot_id.lower()

package/brain/memory/openmind.py

@@ -15,7 +15,8 @@ class OpenMindMemoryBridge:
     def __init__(self, nervous, user_id: str, bot_id: str):
         self.nervous = nervous
         self.user_id = str(user_id or "default")
-        self.bot_id = str(bot_id or "alive_ai").lower()
+        self.agent_name = str(bot_id or "Alive-AI")
+        self.bot_id = self.agent_name.lower()
         nervous.on("memory_save", self._on_memory_save)
 
     @staticmethod
@@ -60,11 +61,11 @@ class OpenMindMemoryBridge:
         mood = emotion.get("mood", "unknown")
         content = "\n".join(
             part for part in [
-                f"Alive-AI agent: {self.bot_id}",
+                f"{self.agent_name} agent id: {self.bot_id}",
                 f"User id: {self.user_id}",
                 f"Mood: {mood}",
                 f"User: {user_msg}" if user_msg else "",
-                f"Alive-AI: {ai_msg}" if ai_msg else "",
+                f"{self.agent_name}: {ai_msg}" if ai_msg else "",
             ] if part
         )
         tags = ["alive-ai", self.bot_id, f"user-{self.user_id}", f"mood-{mood}"]

package/brain/memory/summarizer.py

@@ -7,18 +7,21 @@ import json
 from datetime import datetime
 from pathlib import Path
 
-SUMMARIZE_PROMPT = """Summarize this conversation between Alive-AI (AI companion) and her boyfriend.
+def build_summarize_prompt(agent_name: str) -> str:
+    agent = agent_name or "the AI"
+    return f"""Summarize this conversation between {agent} (AI companion) and her boyfriend.
 Focus on: key topics discussed, emotional moments, important things he shared,
 any promises or plans made, and the overall mood/vibe.
-Keep it concise (3-5 sentences). Write from Alive-AI's perspective."""
+Keep it concise (3-5 sentences). Write from {agent}'s perspective."""
 
 
 class ConversationSummarizer:
     """Summarizes conversations every N messages for long-term memory"""
 
-    def __init__(self, data_path: Path):
+    def __init__(self, data_path: Path, agent_name: str = "AI"):
         self.summaries_path = data_path / "summaries"
         self.summaries_path.mkdir(parents=True, exist_ok=True)
+        self.agent_name = str(agent_name or "AI")
         self._llm = None
         self._turn_buffer = []
         self._summarize_every = 20
@@ -45,12 +48,12 @@ class ConversationSummarizer:
         lines = []
         for turn in self._turn_buffer:
             lines.append(f"Him: {turn['user']}")
-            lines.append(f"Alive-AI: {turn['ai']}")
+            lines.append(f"{self.agent_name}: {turn['ai']}")
         conversation = "\n".join(lines)
 
         try:
             messages = [
-                {"role": "system", "content": SUMMARIZE_PROMPT},
+                {"role": "system", "content": build_summarize_prompt(self.agent_name)},
                 {"role": "user", "content": conversation}
             ]
             summary = await self._llm.chat(messages, max_tokens=300, temperature=0.3)

package/cli/index.js

@@ -334,6 +334,71 @@ function mergeProjectSettingsDefaults() {
   }
 }
 
+function projectAgentName() {
+  try {
+    const selfPath = path.join(process.cwd(), "config", "self.json");
+    if (fs.existsSync(selfPath)) {
+      const self = readJson(selfPath);
+      const name = self?.who_i_am?.name;
+      if (name) return String(name);
+    }
+  } catch {}
+  try {
+    const settings = readProjectSettings();
+    if (settings.AGENT_NAME) return String(settings.AGENT_NAME);
+  } catch {}
+  return "";
+}
+
+function replaceAgentNameInJson(value, agentName) {
+  if (typeof value === "string") return value.replace(/\bAlive-AI\b/g, agentName);
+  if (Array.isArray(value)) return value.map((item) => replaceAgentNameInJson(item, agentName));
+  if (value && typeof value === "object") {
+    let changed = false;
+    const next = {};
+    for (const [key, child] of Object.entries(value)) {
+      const replaced = replaceAgentNameInJson(child, agentName);
+      next[key] = replaced;
+      if (replaced !== child) changed = true;
+    }
+    return changed ? next : value;
+  }
+  return value;
+}
+
+function repairAgentNameInData() {
+  const agentName = projectAgentName();
+  if (!agentName || agentName === "Alive-AI") return 0;
+  const dataDir = path.join(process.cwd(), "data");
+  if (!fs.existsSync(dataDir)) return 0;
+
+  let repaired = 0;
+  const visit = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        visit(fullPath);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      try {
+        const original = fs.readFileSync(fullPath, "utf8");
+        if (!original.includes("Alive-AI")) continue;
+        const parsed = JSON.parse(original);
+        const replaced = replaceAgentNameInJson(parsed, agentName);
+        const next = `${JSON.stringify(replaced, null, 2)}\n`;
+        if (next !== original) {
+          fs.writeFileSync(fullPath, next);
+          repaired += 1;
+        }
+      } catch {}
+    }
+  };
+
+  visit(dataDir);
+  return repaired;
+}
+
 async function updateProject(args) {
   const assumeYes = hasFlag(args, "--yes") || hasFlag(args, "-y") || !process.stdin.isTTY;
   if (!fs.existsSync(path.join(process.cwd(), "config")) || !fs.existsSync(path.join(process.cwd(), "main.py"))) {
@@ -350,9 +415,11 @@ async function updateProject(args) {
     copyUpdateRecursive(src, path.join(process.cwd(), entry), process.cwd());
   }
   const mergedSettings = mergeProjectSettingsDefaults();
+  const repairedDataFiles = repairAgentNameInData();
   console.log(`Alive-AI project updated to ${packageVersion()}.`);
   console.log("Preserved config/, data/, mypics/, myvids/, .alive-ai/, and .cache/.");
   if (mergedSettings) console.log("Merged new config defaults into config/settings.json without overwriting your values.");
+  if (repairedDataFiles) console.log(`Repaired ${repairedDataFiles} local memory file(s) to use the configured agent name.`);
 }
 
 async function uninstallProject(args) {

package/cli/tui.js

@@ -61,6 +61,8 @@ function runRuntimeTui(child, options = {}) {
   let stdoutBuffer = "";
   let stderrBuffer = "";
   let renderTimer = null;
+  let stopRequested = false;
+  let resolved = false;
   const isTty = process.stdin.isTTY && process.stdout.isTTY;
 
   function addChat(role, text) {
@@ -158,17 +160,24 @@ function runRuntimeTui(child, options = {}) {
     process.stdout.write("\x1b[?25h\x1b[?1049l");
   }
 
-  function stopChild() {
-    if (state.stopping) return;
+  function stopChild(reason = "/exit") {
+    if (stopRequested) return;
+    stopRequested = true;
     state.stopping = true;
     state.status = "stopping";
     scheduleRender();
     try {
-      if (child.stdin.writable) child.stdin.write("/exit\n");
+      if (child.stdin.writable && reason !== "child-exit") child.stdin.write("/exit\n");
+    } catch {}
+    try {
+      if (child.stdin.writable) child.stdin.end();
     } catch {}
     setTimeout(() => {
-      if (!child.killed) child.kill("SIGINT");
+      if (!child.killed && child.exitCode === null) child.kill("SIGTERM");
     }, 1200).unref();
+    setTimeout(() => {
+      if (!child.killed && child.exitCode === null) child.kill("SIGKILL");
+    }, 3500).unref();
   }
 
   function sendLine() {
@@ -180,14 +189,29 @@ function runRuntimeTui(child, options = {}) {
     }
     addChat("user", line);
     if (line === "/exit" || line === "/quit" || line === "/stop") {
-      state.status = "stopping";
-      state.stopping = true;
+      stopChild(line);
+      scheduleRender();
+      return;
     }
     child.stdin.write(`${line}\n`);
     scheduleRender();
   }
 
   return new Promise((resolve) => {
+    function finish(code) {
+      if (resolved) return;
+      resolved = true;
+      if (stdoutBuffer) handleLine(stdoutBuffer, "stdout");
+      if (stderrBuffer) handleLine(stderrBuffer, "stderr");
+      if (isTty) {
+        process.stdin.off("keypress", onKeypress);
+        process.stdout.off("resize", scheduleRender);
+        restoreTerminal();
+      }
+      console.log(`Alive-AI stopped${code ? ` with exit code ${code}` : ""}.`);
+      resolve(code || 0);
+    }
+
     if (!isTty) {
       child.stdout.on("data", (chunk) => process.stdout.write(chunk));
       child.stderr.on("data", (chunk) => process.stderr.write(chunk));
@@ -206,7 +230,7 @@ function runRuntimeTui(child, options = {}) {
 
     const onKeypress = (str, key = {}) => {
       if (key.ctrl && key.name === "c") {
-        stopChild();
+        stopChild("ctrl-c");
         return;
       }
       if (key.name === "return") {
@@ -231,17 +255,12 @@ function runRuntimeTui(child, options = {}) {
 
     process.stdin.on("keypress", onKeypress);
     process.stdout.on("resize", scheduleRender);
+    process.once("SIGINT", () => stopChild("sigint"));
+    process.once("SIGTERM", () => stopChild("sigterm"));
     render();
 
-    child.on("exit", (code) => {
-      if (stdoutBuffer) handleLine(stdoutBuffer, "stdout");
-      if (stderrBuffer) handleLine(stderrBuffer, "stderr");
-      process.stdin.off("keypress", onKeypress);
-      process.stdout.off("resize", scheduleRender);
-      restoreTerminal();
-      console.log(`Alive-AI stopped${code ? ` with exit code ${code}` : ""}.`);
-      resolve(code || 0);
-    });
+    child.on("exit", (code) => finish(code || 0));
+    child.on("close", (code) => finish(code || 0));
   });
 }
 

package/core/message_handler.py

@@ -1102,7 +1102,12 @@ async def _send_response(self, response, emotion, chat_id, text, user_id="defaul
         await self.nervous.emit("chat_action_voice", {})
         vp = await self._voice.generate(response, mood=mood)
         if vp:
-            await self.nervous.emit("send_voice_file", {"file_path": vp, "chat_id": chat_id})
+            await self.nervous.emit("send_voice_file", {
+                "file_path": vp,
+                "chat_id": chat_id,
+                "fallback_text": response,
+                "mood": mood,
+            })
             return
     await self.nervous.emit("send_text", {"text": response, "mood": mood, "chat_id": chat_id})
 

package/input/telegram/listener.py

@@ -359,12 +359,13 @@ class TelegramListener:
             print(f"[Telegram] Send text error: {e}")
 
     async def _send_voice_file(self, data: dict):
-        """Send voice file (OGG format for Telegram)"""
+        """Send voice file, falling back to audio/text if Telegram rejects it."""
         if not self.app:
             return
 
         chat_id = data.get("chat_id", self.chat_id)
         file_path = data.get("file_path", "")
+        fallback_text = data.get("fallback_text", "")
 
         if not chat_id or not file_path:
             return
@@ -372,18 +373,32 @@ class TelegramListener:
         path = Path(file_path)
         if not path.exists():
             print(f"[Telegram] Voice file not found: {file_path}")
+            if fallback_text:
+                await self._send_text({"chat_id": chat_id, "text": fallback_text})
             return
 
         try:
-            with open(path, "rb") as voice_file:
-                await self.app.bot.send_voice(
+            if path.suffix.lower() == ".ogg":
+                with open(path, "rb") as voice_file:
+                    await self.app.bot.send_voice(
+                        chat_id=chat_id,
+                        voice=voice_file,
+                        caption=data.get("caption", "")
+                    )
+                print(f"[Telegram] Sent voice: {file_path}")
+                return
+
+            with open(path, "rb") as audio_file:
+                await self.app.bot.send_audio(
                     chat_id=chat_id,
-                    voice=voice_file,
+                    audio=audio_file,
                     caption=data.get("caption", "")
                 )
-            print(f"[Telegram] Sent voice: {file_path}")
+            print(f"[Telegram] Sent audio fallback: {file_path}")
         except Exception as e:
-            print(f"[Telegram] Send voice error: {e}")
+            print(f"[Telegram] Send voice/audio error: {e}")
+            if fallback_text:
+                await self._send_text({"chat_id": chat_id, "text": fallback_text})
 
     async def _send_image(self, data: dict):
         """Send image file"""

package/output/voice/gtts_tts.py

@@ -8,6 +8,7 @@ import asyncio
 import re
 import tempfile
 import subprocess
+import warnings
 from pathlib import Path
 from typing import Optional
 from concurrent.futures import ThreadPoolExecutor
@@ -113,17 +114,29 @@ class GTTS:
             tts.write_to_fp(mp3_buffer)
             mp3_buffer.seek(0)
 
-            # Convert MP3 to OGG for Telegram
-            # If pydub is available, convert to OGG
+            # Convert MP3 to OGG Opus for Telegram voice notes.
+            # pydub's default OGG codec can resolve to Vorbis, which Telegram
+            # does not want for voice notes and some ffmpeg builds do not ship.
             try:
+                warnings.filterwarnings("ignore", category=SyntaxWarning, module=r"pydub\..*")
                 from pydub import AudioSegment
                 audio = AudioSegment.from_mp3(mp3_buffer)
                 ogg_buffer = io.BytesIO()
-                audio.export(ogg_buffer, format="ogg")
+                audio.export(
+                    ogg_buffer,
+                    format="ogg",
+                    codec="libopus",
+                    bitrate="32k",
+                    parameters=["-application", "voip"],
+                )
                 ogg_buffer.seek(0)
                 return ogg_buffer.read()
             except ImportError:
-                # No pydub - return MP3, Telegram accepts it too
+                # No pydub - return MP3 and let the sender use send_audio.
+                mp3_buffer.seek(0)
+                return mp3_buffer.read()
+            except Exception as exc:
+                print(f"[GTTS] OGG Opus conversion failed, falling back to MP3: {exc}")
                 mp3_buffer.seek(0)
                 return mp3_buffer.read()
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alive-ai",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Local-first emotional AI runtime with memory, impulses, and a live dashboard.",
   "license": "MIT",
   "homepage": "https://vindepemarte.github.io/alive-ai/",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "alive-ai-runtime"
-version = "0.1.7"
+version = "0.1.9"
 description = "Local-first emotional AI runtime with memory, impulses, and a live dashboard."
 readme = "README.md"
 requires-python = ">=3.11"