alive-ai 0.1.2 → 0.1.3

package/cli/tui.js

@@ -0,0 +1,248 @@
+"use strict";
+
+const readline = require("readline");
+
+const EVENT_PREFIX = "__ALIVE_AI_TUI__";
+
+function stripAnsi(value) {
+  return String(value || "").replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
+}
+
+function truncate(value, width) {
+  const text = stripAnsi(value);
+  if (width <= 1) return "";
+  return text.length > width ? `${text.slice(0, Math.max(0, width - 1))}…` : text;
+}
+
+function wrap(value, width) {
+  const words = stripAnsi(value).replace(/\r/g, "").split(/\s+/);
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    if (!word) continue;
+    if (!current) {
+      current = word;
+    } else if (`${current} ${word}`.length <= width) {
+      current += ` ${word}`;
+    } else {
+      lines.push(current);
+      current = word;
+    }
+    while (current.length > width) {
+      lines.push(current.slice(0, width));
+      current = current.slice(width);
+    }
+  }
+  if (current) lines.push(current);
+  return lines.length ? lines : [""];
+}
+
+function boxLine(left, right, leftWidth, rightWidth) {
+  return `│ ${truncate(left, leftWidth).padEnd(leftWidth)} │ ${truncate(right, rightWidth).padEnd(rightWidth)} │`;
+}
+
+function formatChat(entry, width) {
+  const label = entry.role === "user" ? "You" : entry.role === "proactive" ? "Alice proactive" : entry.role === "assistant" ? "Alice" : "System";
+  const prefix = `${label}: `;
+  const lines = wrap(entry.text, Math.max(10, width - prefix.length));
+  return lines.map((line, index) => `${index === 0 ? prefix : " ".repeat(prefix.length)}${line}`);
+}
+
+function runRuntimeTui(child, options = {}) {
+  const state = {
+    chat: [],
+    logs: [],
+    input: "",
+    status: "starting",
+    dashboard: options.dashboard || "http://127.0.0.1:8080",
+    stopping: false,
+  };
+
+  let stdoutBuffer = "";
+  let stderrBuffer = "";
+  let renderTimer = null;
+  const isTty = process.stdin.isTTY && process.stdout.isTTY;
+
+  function addChat(role, text) {
+    state.chat.push({ role, text: String(text || "") });
+    if (state.chat.length > 200) state.chat = state.chat.slice(-200);
+    scheduleRender();
+  }
+
+  function addLog(text) {
+    for (const rawLine of String(text || "").split(/\n/)) {
+      const line = stripAnsi(rawLine).trimEnd();
+      if (!line || line === ">") continue;
+      state.logs.push(line);
+    }
+    if (state.logs.length > 400) state.logs = state.logs.slice(-400);
+    scheduleRender();
+  }
+
+  function handleLine(line, stream) {
+    const clean = line.trimEnd();
+    if (!clean) return;
+    if (clean.startsWith(EVENT_PREFIX)) {
+      try {
+        const event = JSON.parse(clean.slice(EVENT_PREFIX.length));
+        addChat(event.role || "system", event.text || "");
+        return;
+      } catch {
+        addLog(clean);
+        return;
+      }
+    }
+    addLog(stream === "stderr" ? `[stderr] ${clean}` : clean);
+  }
+
+  function consume(chunk, stream) {
+    let buffer = stream === "stderr" ? stderrBuffer : stdoutBuffer;
+    buffer += chunk.toString();
+    const lines = buffer.split(/\n/);
+    buffer = lines.pop() || "";
+    for (const line of lines) handleLine(line, stream);
+    if (stream === "stderr") stderrBuffer = buffer;
+    else stdoutBuffer = buffer;
+  }
+
+  function scheduleRender() {
+    if (!isTty) return;
+    if (renderTimer) return;
+    renderTimer = setTimeout(() => {
+      renderTimer = null;
+      render();
+    }, 30);
+  }
+
+  function render() {
+    if (!isTty) return;
+    const width = Math.max(80, process.stdout.columns || 100);
+    const height = Math.max(24, process.stdout.rows || 30);
+    const leftWidth = Math.max(34, Math.floor((width - 7) * 0.58));
+    const rightWidth = Math.max(28, width - leftWidth - 7);
+    const bodyHeight = height - 7;
+
+    const chatLines = [];
+    for (const entry of state.chat) {
+      chatLines.push(...formatChat(entry, leftWidth), "");
+    }
+    const visibleChat = chatLines.slice(-bodyHeight);
+    const visibleLogs = state.logs.slice(-bodyHeight);
+
+    const top = `┌${"─".repeat(leftWidth + 2)}┬${"─".repeat(rightWidth + 2)}┐`;
+    const sep = `├${"─".repeat(leftWidth + 2)}┼${"─".repeat(rightWidth + 2)}┤`;
+    const bottom = `└${"─".repeat(leftWidth + 2)}┴${"─".repeat(rightWidth + 2)}┘`;
+    const inputLine = `> ${state.input}`;
+
+    const lines = [
+      top,
+      boxLine("Chat", `Logs • ${state.status} • ${state.dashboard}`, leftWidth, rightWidth),
+      sep,
+    ];
+
+    for (let index = 0; index < bodyHeight; index += 1) {
+      lines.push(boxLine(visibleChat[index] || "", visibleLogs[index] || "", leftWidth, rightWidth));
+    }
+
+    lines.push(bottom);
+    lines.push(truncate(inputLine, width - 1));
+    lines.push(truncate("Enter sends • /help commands • /exit stops • Ctrl+C stops", width - 1));
+
+    process.stdout.write("\x1b[H\x1b[2J");
+    process.stdout.write(lines.join("\n"));
+  }
+
+  function restoreTerminal() {
+    if (!isTty) return;
+    process.stdin.setRawMode(false);
+    process.stdout.write("\x1b[?25h\x1b[?1049l");
+  }
+
+  function stopChild() {
+    if (state.stopping) return;
+    state.stopping = true;
+    state.status = "stopping";
+    scheduleRender();
+    try {
+      if (child.stdin.writable) child.stdin.write("/exit\n");
+    } catch {}
+    setTimeout(() => {
+      if (!child.killed) child.kill("SIGINT");
+    }, 1200).unref();
+  }
+
+  function sendLine() {
+    const line = state.input.trim();
+    state.input = "";
+    if (!line) {
+      scheduleRender();
+      return;
+    }
+    addChat("user", line);
+    if (line === "/exit" || line === "/quit" || line === "/stop") {
+      state.status = "stopping";
+      state.stopping = true;
+    }
+    child.stdin.write(`${line}\n`);
+    scheduleRender();
+  }
+
+  return new Promise((resolve) => {
+    if (!isTty) {
+      child.stdout.on("data", (chunk) => process.stdout.write(chunk));
+      child.stderr.on("data", (chunk) => process.stderr.write(chunk));
+      child.on("exit", (code) => resolve(code || 0));
+      return;
+    }
+
+    process.stdout.write("\x1b[?1049h\x1b[?25l");
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+
+    addChat("system", "Type a message and press Enter. The runtime logs stay on the right.");
+    child.stdout.on("data", (chunk) => consume(chunk, "stdout"));
+    child.stderr.on("data", (chunk) => consume(chunk, "stderr"));
+
+    const onKeypress = (str, key = {}) => {
+      if (key.ctrl && key.name === "c") {
+        stopChild();
+        return;
+      }
+      if (key.name === "return") {
+        sendLine();
+        return;
+      }
+      if (key.name === "backspace") {
+        state.input = state.input.slice(0, -1);
+        scheduleRender();
+        return;
+      }
+      if (key.name === "escape") {
+        state.input = "";
+        scheduleRender();
+        return;
+      }
+      if (str && !key.ctrl && !key.meta) {
+        state.input += str;
+        scheduleRender();
+      }
+    };
+
+    process.stdin.on("keypress", onKeypress);
+    process.stdout.on("resize", scheduleRender);
+    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);
+    });
+  });
+}
+
+module.exports = { runRuntimeTui };

package/config/settings.example.json

@@ -5,6 +5,7 @@
   "ALIVE_AI_TERMINAL_USER_ID": "terminal_owner",
   "telegram_token": "",
   "TELEGRAM_OWNER_ID": "",
+  "TELEGRAM_TIMEOUT_SECONDS": 30,
   "WEBUI_ENABLED": true,
   "WEBUI_PORT": 8080,
   "language": "en",

package/core/hot_reload.py

@@ -10,6 +10,7 @@ import threading
 from pathlib import Path
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler, FileModifiedEvent
+from .paths import project_root
 
 
 class HotReloader:
@@ -24,7 +25,7 @@ class HotReloader:
         self.pending_reload = False
         self.observer = None
         self.watched_dirs = ["core", "brain", "heart", "config", "input", "output"]
-        self.base_path = Path("/app")
+        self.base_path = project_root()
 
     def start(self):
         """Start watching for file changes"""

package/core/manifest.md

@@ -7,10 +7,12 @@ The foundation of the AI. Always required.
 - `config.py` - Configuration loader
 - `state.py` - Global state management
 - `self.py` - The Self (main coordinator)
+- `paths.py` - Runtime path resolution for npm/local/Docker installs
 
 ## Key Integration Points
 - **NervousSystem** - Central event bus; all modules communicate via events
 - **Self** - Coordinates: memory, heart, LLM, subconscious, input/output
+- **Paths** - Keeps project runtime state under local `data/` instead of hard-coded `/app`
 - Connects to subconscious for proactive messaging
 - Emits: `message_received`, `send_text`, `send_voice_file`, `send_image`, `send_video`
 

package/core/paths.py

@@ -0,0 +1,48 @@
+"""
+Core path helpers.
+
+Alive-AI can run from Docker at /app or from an npm-created project folder.
+All runtime state must resolve through this module so local installs never try
+to write into a read-only container path.
+"""
+
+import os
+from pathlib import Path
+
+
+def project_root() -> Path:
+    configured = os.environ.get("ALIVE_AI_ROOT")
+    if configured:
+        return Path(configured).expanduser().resolve()
+    return Path(__file__).parent.parent.resolve()
+
+
+def _resolve_under_root(value: str) -> Path:
+    path = Path(value).expanduser()
+    if not path.is_absolute():
+        path = project_root() / path
+    return path.resolve()
+
+
+def data_dir() -> Path:
+    configured = os.environ.get("ALIVE_AI_DATA_PATH") or os.environ.get("DATA_PATH")
+    path = _resolve_under_root(configured) if configured else project_root() / "data"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def state_file(name: str) -> Path:
+    return data_dir() / name
+
+
+def media_dir(name: str) -> Path:
+    path = project_root() / name
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def cache_dir(name: str = "") -> Path:
+    base = project_root() / ".cache"
+    path = base / name if name else base
+    path.mkdir(parents=True, exist_ok=True)
+    return path

package/core/self.py

@@ -4,6 +4,7 @@ The AI's Self - coordinates everything via nervous system
 """
 
 import asyncio
+import contextlib
 from pathlib import Path
 from .events import NervousSystem
 from .config import Config
@@ -130,7 +131,47 @@ class Self:
         print(f"[{name}] Ready!")
 
         # Start listening
-        await self._input.start()
+        try:
+            await self._input.start()
+        finally:
+            await self.stop()
+
+    async def stop(self):
+        """Stop background loops and close network clients."""
+        if self._hot_reload:
+            with contextlib.suppress(Exception):
+                self._hot_reload.stop()
+            self._hot_reload = None
+
+        if self._input and hasattr(self._input, "stop"):
+            with contextlib.suppress(Exception):
+                result = self._input.stop()
+                if asyncio.iscoroutine(result):
+                    await result
+
+        if self._default_mode:
+            with contextlib.suppress(Exception):
+                await self._default_mode.stop_background_processing()
+            self._default_mode = None
+
+        if self._subconscious:
+            with contextlib.suppress(Exception):
+                await self._subconscious.stop()
+            self._subconscious = None
+
+        if self._timer_task:
+            self._timer_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._timer_task
+            self._timer_task = None
+
+        seen = set()
+        for client in (self._llm, self._fast_llm):
+            if not client or id(client) in seen or not hasattr(client, "close"):
+                continue
+            seen.add(id(client))
+            with contextlib.suppress(Exception):
+                await client.close()
 
     async def _decay_timer(self):
         """Natural emotion decay every minute + memory check"""

package/core/user_manager.py

@@ -8,6 +8,7 @@ import json
 from pathlib import Path
 from typing import Dict, Optional, Any
 from datetime import datetime
+from .paths import data_dir
 
 
 class UserManager:
@@ -26,10 +27,7 @@ class UserManager:
         if base_path:
             self.base_path = base_path
         else:
-            # Try Docker path first, then local development path
-            docker_path = Path("/app/data")
-            local_path = Path(__file__).parent.parent / "data"
-            self.base_path = docker_path if docker_path.exists() else local_path
+            self.base_path = data_dir()
 
         self.users_path = self.base_path / "users"
         self.users_path.mkdir(parents=True, exist_ok=True)

package/docs/index.html

@@ -283,15 +283,16 @@ npx . chat</code></pre>
   <section class="facts">
     <div class="fact"><h2>Persistent affect</h2><p>Emotions decay, compound, and influence future messages instead of resetting after each prompt.</p></div>
     <div class="fact"><h2>Memory with weight</h2><p>Built-in local memory stays active, and OpenMind can add cloud or local semantic recall.</p></div>
-    <div class="fact"><h2>Terminal or Telegram</h2><p>Chat from the command line with `npx . chat`, or connect a Telegram bot when you want mobile access.</p></div>
+    <div class="fact"><h2>Terminal or Telegram</h2><p>Chat from the split-pane terminal with `npx . chat`, use `npx . chat --plain` for raw mode, or connect Telegram for mobile access.</p></div>
   </section>
 
   <section class="section" id="setup">
     <h2>Setup Flow</h2>
     <p>`npx . setup` asks for the minimum required configuration and lets optional systems be skipped. Use `local` for Ollama, `skip` for optional keys, and OpenMind cloud or local when you want a shared long-term semantic memory.</p>
     <div class="steps">
-      <div class="step"><strong>Start local terminal chat</strong><span>`npx . chat` starts the same runtime with terminal input and the WebUI at `http://127.0.0.1:8080`.</span></div>
-      <div class="step"><strong>Start Telegram/runtime mode</strong><span>`npx . start` starts the runtime with the configured input channel. Stop foreground runs with `Ctrl+C`.</span></div>
+      <div class="step"><strong>Start local terminal chat</strong><span>`npx . chat` starts the same runtime with chat on the left, logs on the right, and the WebUI at `http://127.0.0.1:8080`.</span></div>
+      <div class="step"><strong>Start Telegram/runtime mode</strong><span>`npx . start` starts the configured input channel and validates Telegram before polling. Stop foreground runs with `Ctrl+C`.</span></div>
+      <div class="step"><strong>Keep it updated</strong><span>`start` and `chat` check npm for newer versions. Use `npx . update` manually or `npx . uninstall` to remove local runtime files.</span></div>
       <div class="step"><strong>Use OpenMind</strong><span>Choose `openmind-cloud` for `https://theopenmind.pro` or `openmind-local` for `http://127.0.0.1:3333`.</span></div>
       <div class="step"><strong>Preview the dashboard</strong><span>`npx . demo` is keyless. The real runtime dashboard streams local state over SSE.</span></div>
     </div>

package/heart/emotional_state.py

@@ -4,9 +4,9 @@ Extended for Soul Architecture dimensions
 """
 import json
 from datetime import datetime
-from pathlib import Path
+from core.paths import state_file
 
-EMOTION_STATE_PATH = Path("/app/data/emotion_state.json")  # Use mounted /app directory
+EMOTION_STATE_PATH = state_file("emotion_state.json")
 DEFAULTS = {
     "valence": 0.5, "arousal": 0.3, "dominance": 0.5, "desire": 0.0,
     "high_desire_threshold": 0.7, "joy": 0.5, "love": 0.2, "trust": 0.5,

package/heart/hormonal.py

@@ -11,8 +11,8 @@ interprets and responds to the world.
 from datetime import datetime, timedelta
 from dataclasses import dataclass, field
 from typing import Dict, List, Optional, Tuple
-from pathlib import Path
 import json
+from core.paths import state_file
 
 
 @dataclass
@@ -61,7 +61,7 @@ class HormonalModulationMatrix:
     MAX_METABOLITES = 10
 
     # Persistence
-    HORMONAL_DATA_PATH = Path("/app/data/hormonal_state.json")
+    HORMONAL_DATA_PATH = state_file("hormonal_state.json")
 
     def __init__(self):
         # Primary hormones (0.0 - 1.0)

package/heart/integrity.py

@@ -12,6 +12,7 @@ from typing import Optional, List, Dict, Any
 from pathlib import Path
 import json
 import os
+from core.paths import data_dir
 
 
 @dataclass
@@ -118,7 +119,7 @@ class SelfIntegrityCore:
     DAMAGE_RATE = 0.12    # Base damage from negative experiences
 
     # Data persistence - configurable via environment variable
-    INTEGRITY_DATA_PATH = Path(os.environ.get("ALIVE_AI_DATA_PATH", "/app/data")) / "integrity_state.json"
+    INTEGRITY_DATA_PATH = data_dir() / "integrity_state.json"
 
     def __init__(self):
         # Core integrity components (0.0 - 1.0)

package/heart/interoception.py

@@ -31,16 +31,13 @@ import logging
 import sys
 sys.path.insert(0, str(Path(__file__).parent.parent))
 from core.settings import get_float, get_int, get
+from core.paths import state_file
 
 # Configure logging
 logger = logging.getLogger("Interoception")
 logger.setLevel(logging.DEBUG)
 
-# Persistence path - use /app/data if available (Docker), otherwise local data directory
-if Path("/app/data").exists():
-    INTEROCEPTION_DATA_PATH = Path("/app/data/interoceptive_state.json")
-else:
-    INTEROCEPTION_DATA_PATH = Path(__file__).parent.parent / "data" / "interoceptive_state.json"
+INTEROCEPTION_DATA_PATH = state_file("interoceptive_state.json")
 
 
 class InteroceptiveStateType(Enum):

package/heart/love.py

@@ -4,11 +4,11 @@ Attachment system - can fall in love
 """
 
 import json
-from pathlib import Path
 from datetime import datetime
+from core.paths import state_file
 
 # Persistence path for attachment state
-ATTACHMENT_STATE_PATH = Path("/app/data/attachment_state.json")
+ATTACHMENT_STATE_PATH = state_file("attachment_state.json")
 
 
 class AttachmentSystem:

package/heart/scars.py

@@ -10,9 +10,9 @@ behaviors that persist over time.
 from datetime import datetime
 from dataclasses import dataclass, field
 from typing import Dict, List, Optional
-from pathlib import Path
 import json
 import random
+from core.paths import state_file
 
 
 @dataclass
@@ -99,7 +99,7 @@ class EmotionalScarSystem:
     POSITIVE_HEALING_RATE = 0.05  # With positive experience
 
     # Persistence
-    SCAR_DATA_PATH = Path("/app/data/emotional_scars.json")
+    SCAR_DATA_PATH = state_file("emotional_scars.json")
 
     # Wound types and their patterns
     WOUND_PATTERNS = {
@@ -471,4 +471,3 @@ class EmotionalScarSystem:
             "vulnerability_summary": self.get_vulnerability_summary(),
             "scar_descriptions": self.get_scar_descriptions()[:3]  # Top 3
         }
-

package/heart/telemetry.py

@@ -17,6 +17,7 @@ from pathlib import Path
 import json
 import threading
 import time
+from core.paths import state_file
 
 
 @dataclass
@@ -129,10 +130,7 @@ class SoulTelemetry:
     """
 
     # Default data path
-    DEFAULT_DATA_PATH = Path("/app/data/soul_telemetry.json")
-
-    # Alternative path for local development
-    FALLBACK_DATA_PATH = Path(__file__).parent.parent / "data" / "soul_telemetry.json"
+    DEFAULT_DATA_PATH = state_file("soul_telemetry.json")
 
     # Default retention period (hours)
     DEFAULT_RETENTION_HOURS = 24
@@ -160,11 +158,7 @@ class SoulTelemetry:
         if data_path:
             self.data_path = Path(data_path)
         else:
-            # Try /app/data first, fallback to local data directory
-            if self.DEFAULT_DATA_PATH.parent.exists():
-                self.data_path = self.DEFAULT_DATA_PATH
-            else:
-                self.data_path = self.FALLBACK_DATA_PATH
+            self.data_path = self.DEFAULT_DATA_PATH
 
         # Ensure data directory exists
         self.data_path.parent.mkdir(parents=True, exist_ok=True)

package/input/manifest.md

@@ -8,7 +8,7 @@ How the AI perceives and processes incoming messages.
   - `voice.py` - Voice message processing via STT
   - `commands.py` - Admin command handler
 - `terminal/` - Local terminal chat integration
-  - `listener.py` - CLI chat loop, slash commands, and output handlers
+  - `listener.py` - CLI chat loop, slash commands, TUI events, and output handlers
 
 ## Commands
 - `/start` - Welcome message
@@ -24,7 +24,7 @@ How the AI perceives and processes incoming messages.
 
 ## Integration Points
 - Receives Telegram updates
-- Receives terminal input through `npx . chat`
+- Receives split-pane terminal input through `npx . chat`, or raw shell input through `npx . chat --plain`
 - Uses STT for voice transcription
 - Emits `message_received` event to nervous system
 - Commands access: heart, subconscious, LLM, voice, photos, videos