pure-chat 0.1.1__tar.gz

pure_chat-0.1.1/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2026 Mats Heemeyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

pure_chat-0.1.1/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: pure-chat
+Version: 0.1.1
+Summary: A high-performance Terminal User Interface (TUI) designed to replicate the experience of browser based llm chat applications directly in your terminal.
+Author-email: Mats Heemeyer <matsheemeyer@gmail.com>
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: google-genai>=1.72.0
+Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: rich>=15.0.0
+Dynamic: license-file
+
+# PureChat
+
+A high-performance Terminal User Interface (TUI) designed to replicate the experience of browser based llm chat applications directly in your terminal. This tool provides persistent conversation memory, real-time streaming, and interactive session management.
+
+## 💡 Motivation
+
+Most modern AI CLI tools have become heavily "agentic." While powerful for automation, they often force massive context windows, auto-execute commands, and prioritize task completion over simple conversation. This results in high token consumption, slower response times, and a lack of control over what data is being sent.
+
+Gemini CLI Vault was built to fill the gap for a "regular" chat app in the terminal. It provides a familiar web-like experience for discussing complicated topics in a controlled environment where you don't want the tool to send excessive context or execute commands autonomously.
+
+## ✨ Key Features
+
+- **Persistent Memory**: Conversations are stored in a local SQLite database (gemini_vault.db), allowing you to resume any chat session at any time.
+- **Live Streaming & Markdown**: Responses stream in real-time with full Markdown rendering, including syntax-highlighted code blocks, tables, and lists.
+- **Intelligent Context Window**: Automatically manages token usage using a sliding window of the last 12 messages to maintain context without exceeding limits.
+- **Interactive Session Switcher**: Use the /conversations command to browse, search, and switch between previous chat sessions using an arrow-key menu.
+- **Global Command History**: Navigate your previous prompts across all sessions using the UP and DOWN arrows (powered by prompt_toolkit).
+- **Google Search Integration**: The assistant is equipped with the Google Search tool to provide up-to-date information on current events.
+- **Dynamic Personalities**: Load custom system instructions from a GEMINI.md file to change the AI's behavior and tone.
+
+## 🛠️ Installation (using uv)
+
+1. Clone the repository:
+
+```
+git clone https://github.com/yourusername/gemini-cli-vault.git
+cd gemini-cli-vault
+```
+
+2. Configure Environment Variables:
+
+```
+# Create a .env file in the project root:
+GEMINI_API_KEY=your_google_api_key_here
+GEMINI_MODEL=gemini-3-flash-preview
+```
+
+3. (Optional) Define System Instructions:
+   Create a GEMINI.md file to set the AI's System Prompt:
+   You are an expert software architect. Provide concise, high-level advice and always include code snippets in Python or Rust.
+
+## 🚀 Usage
+
+Start a new or default session:
+
+```
+uv run main.py
+```
+
+Start or resume a specific session by name:
+
+```
+python main.py --name Project-Alpha
+```
+
+### ⌨️ In-Chat Commands
+
+- `/conversations` : Opens the interactive session manager to switch or create chats.
+- `/exit` : Safely saves and exits the application.
+- `UP / DOWN` : Cycle through your entire history of user prompts.
+- `Ctrl+C` : Interrupt the current input line.
+
+## 🏗️ Project Architecture
+
+- `main.py`: The entry point and TUI controller. Handles the input loop and rich live display.
+- `db_manager.py`: The data layer. Manages SQLite tables, message logging, and session retrieval.
+- `ai_manager.py`: The AI integration layer. Configures the google-genai client, tools, and system instructions.
+- `gemini_vault.db`: The local database generated on first run.
+
+## 🤖 AI Disclosure
+
+This project was primarily developed with the assistance of AI. While the core logic, architecture, and feature set were human-directed, the majority of the code implementation and boilerplate was generated and refined using Large Language Models.

pure_chat-0.1.1/README.md

@@ -0,0 +1,72 @@
+# PureChat
+
+A high-performance Terminal User Interface (TUI) designed to replicate the experience of browser based llm chat applications directly in your terminal. This tool provides persistent conversation memory, real-time streaming, and interactive session management.
+
+## 💡 Motivation
+
+Most modern AI CLI tools have become heavily "agentic." While powerful for automation, they often force massive context windows, auto-execute commands, and prioritize task completion over simple conversation. This results in high token consumption, slower response times, and a lack of control over what data is being sent.
+
+Gemini CLI Vault was built to fill the gap for a "regular" chat app in the terminal. It provides a familiar web-like experience for discussing complicated topics in a controlled environment where you don't want the tool to send excessive context or execute commands autonomously.
+
+## ✨ Key Features
+
+- **Persistent Memory**: Conversations are stored in a local SQLite database (gemini_vault.db), allowing you to resume any chat session at any time.
+- **Live Streaming & Markdown**: Responses stream in real-time with full Markdown rendering, including syntax-highlighted code blocks, tables, and lists.
+- **Intelligent Context Window**: Automatically manages token usage using a sliding window of the last 12 messages to maintain context without exceeding limits.
+- **Interactive Session Switcher**: Use the /conversations command to browse, search, and switch between previous chat sessions using an arrow-key menu.
+- **Global Command History**: Navigate your previous prompts across all sessions using the UP and DOWN arrows (powered by prompt_toolkit).
+- **Google Search Integration**: The assistant is equipped with the Google Search tool to provide up-to-date information on current events.
+- **Dynamic Personalities**: Load custom system instructions from a GEMINI.md file to change the AI's behavior and tone.
+
+## 🛠️ Installation (using uv)
+
+1. Clone the repository:
+
+```
+git clone https://github.com/yourusername/gemini-cli-vault.git
+cd gemini-cli-vault
+```
+
+2. Configure Environment Variables:
+
+```
+# Create a .env file in the project root:
+GEMINI_API_KEY=your_google_api_key_here
+GEMINI_MODEL=gemini-3-flash-preview
+```
+
+3. (Optional) Define System Instructions:
+   Create a GEMINI.md file to set the AI's System Prompt:
+   You are an expert software architect. Provide concise, high-level advice and always include code snippets in Python or Rust.
+
+## 🚀 Usage
+
+Start a new or default session:
+
+```
+uv run main.py
+```
+
+Start or resume a specific session by name:
+
+```
+python main.py --name Project-Alpha
+```
+
+### ⌨️ In-Chat Commands
+
+- `/conversations` : Opens the interactive session manager to switch or create chats.
+- `/exit` : Safely saves and exits the application.
+- `UP / DOWN` : Cycle through your entire history of user prompts.
+- `Ctrl+C` : Interrupt the current input line.
+
+## 🏗️ Project Architecture
+
+- `main.py`: The entry point and TUI controller. Handles the input loop and rich live display.
+- `db_manager.py`: The data layer. Manages SQLite tables, message logging, and session retrieval.
+- `ai_manager.py`: The AI integration layer. Configures the google-genai client, tools, and system instructions.
+- `gemini_vault.db`: The local database generated on first run.
+
+## 🤖 AI Disclosure
+
+This project was primarily developed with the assistance of AI. While the core logic, architecture, and feature set were human-directed, the majority of the code implementation and boilerplate was generated and refined using Large Language Models.

pure_chat-0.1.1/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "pure-chat"
+version = "0.1.1"
+description = "A high-performance Terminal User Interface (TUI) designed to replicate the experience of browser based llm chat applications directly in your terminal."
+readme = "README.md"
+requires-python = ">=3.14"
+authors = [
+  { name="Mats Heemeyer", email="matsheemeyer@gmail.com" },
+]
+dependencies = [
+    "google-genai>=1.72.0",
+    "prompt-toolkit>=3.0.52",
+    "python-dotenv>=1.2.2",
+    "questionary>=2.1.1",
+    "rich>=15.0.0",
+]
+[project.scripts]
+purechat = "pure_chat.main:main"

pure_chat-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pure_chat-0.1.1/src/pure_chat/ai_manager.py

@@ -0,0 +1,34 @@
+import os
+from google import genai
+from google.genai import types
+
+
+class GeminiAssistant:
+    def __init__(self, history=None, model_id=None):
+        api_key = os.getenv("GEMINI_API_KEY")
+        model_id = model_id or os.getenv("GEMINI_MODEL", "gemini-3-flash-preview")
+
+        self.client = genai.Client(api_key=api_key)
+        self.model_id = model_id
+
+        # 1. Load instructions from GEMINI.md
+        instr = "You are a helpful assistant."
+        if os.path.exists("GEMINI.md"):
+            with open("GEMINI.md", "r") as f:
+                instr = f.read()
+
+        # 2. Configure Tools and Token Caps
+        search_tool = types.Tool(google_search=types.GoogleSearch())
+        self.config = types.GenerateContentConfig(
+            tools=[search_tool],
+            system_instruction=instr,
+            max_output_tokens=1000,  # Measure to reduce output token cost
+            temperature=0.7,
+        )
+
+        self.chat = self.client.chats.create(
+            model=self.model_id, config=self.config, history=history or []
+        )
+
+    def send_stream(self, text):
+        return self.chat.send_message_stream(text)

pure_chat-0.1.1/src/pure_chat/db_manager.py

@@ -0,0 +1,251 @@
+import sqlite3
+import random
+from datetime import datetime
+
+DB_NAME = "gemini_vault.db"
+
+# Friendly word lists for random names
+ADJECTIVES = ["sparkling", "brave", "swift", "quiet", "neon", "mighty", "clever"]
+NOUNS = ["phoenix", "glitch", "nebula", "cipher", "wizard", "orbit", "atlas"]
+
+
+def init_db():
+    with sqlite3.connect(DB_NAME) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """CREATE TABLE IF NOT EXISTS sessions 
+                          (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, created_at DATETIME)"""
+        )
+        cursor.execute("""CREATE TABLE IF NOT EXISTS messages 
+                          (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id INTEGER, 
+                           role TEXT, content TEXT, timestamp DATETIME,
+                           FOREIGN KEY(session_id) REFERENCES sessions(id))""")
+
+        # Create FTS5 virtual table for full-text search
+        cursor.execute("""CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+                content, role, session_id, content_rowid=rowid
+            )""")
+
+        # Create triggers to keep FTS in sync
+        cursor.execute(
+            """CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN
+                INSERT INTO messages_fts(rowid, content, role, session_id)
+                VALUES (new.id, new.content, new.role, new.session_id);
+            END"""
+        )
+        cursor.execute(
+            """CREATE TRIGGER IF NOT EXISTS messages_ad AFTER DELETE ON messages BEGIN
+                DELETE FROM messages_fts WHERE rowid = old.id;
+            END"""
+        )
+        cursor.execute(
+            """CREATE TRIGGER IF NOT EXISTS messages_au AFTER UPDATE ON messages BEGIN
+                UPDATE messages_fts SET content = new.content, role = new.role, session_id = new.session_id
+                WHERE rowid = new.id;
+            END"""
+        )
+
+        # Backfill: Index existing messages that aren't in FTS yet
+        cursor.execute("""INSERT INTO messages_fts(rowid, content, role, session_id)
+               SELECT m.id, m.content, m.role, m.session_id
+               FROM messages m
+               LEFT JOIN messages_fts fts ON m.id = fts.rowid
+               WHERE fts.rowid IS NULL""")
+
+
+def generate_random_name():
+    return (
+        f"{random.choice(ADJECTIVES)}-{random.choice(NOUNS)}-{random.randint(100, 999)}"
+    )
+
+
+def get_or_create_session(name=None):
+    if not name:
+        name = generate_random_name()
+
+    with sqlite3.connect(DB_NAME) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT OR IGNORE INTO sessions (name, created_at) VALUES (?, ?)",
+            (name, datetime.now()),
+        )
+        cursor.execute("SELECT id, name FROM sessions WHERE name = ?", (name,))
+        return cursor.fetchone()
+
+
+def get_chat_history(session_id, window_size=12):
+    """Token Reduction: Only fetch the last N messages (Sliding Window)."""
+    with sqlite3.connect(DB_NAME) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT role, content FROM (
+                SELECT role, content, timestamp FROM messages 
+                WHERE session_id = ? 
+                ORDER BY timestamp DESC LIMIT ?
+            ) ORDER BY timestamp ASC
+        """,
+            (session_id, window_size),
+        )
+        rows = cursor.fetchall()
+        return [{"role": r, "parts": [{"text": c}]} for r, c in rows]
+
+
+def save_message(session_id, role, content):
+    with sqlite3.connect(DB_NAME) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT INTO messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)",
+            (session_id, role, content, datetime.now()),
+        )
+
+
+def list_all_sessions():
+    with sqlite3.connect(DB_NAME) as conn:
+        return conn.execute(
+            "SELECT name, created_at FROM sessions ORDER BY created_at DESC"
+        ).fetchall()
+
+
+# Add this to db_manager.py
+def get_session_user_messages(session_id):
+    """Fetches only user messages to populate terminal history."""
+    with sqlite3.connect(DB_NAME) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT content FROM messages WHERE session_id = ? AND role = 'user' ORDER BY timestamp ASC",
+            (session_id,),
+        )
+        return [row[0] for row in cursor.fetchall()]
+
+
+# Add/Update these functions in db_manager.py
+
+
+def get_last_n_messages(session_id):
+    """Fetches the last N messages of a specific session for display."""
+    with sqlite3.connect(DB_NAME) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+                SELECT role, content FROM messages 
+                WHERE session_id = ? 
+                ORDER BY timestamp ASC
+        """,
+            (session_id,),
+        )
+        return cursor.fetchall()
+
+
+def get_all_user_messages_global():
+    """Fetches EVERY user prompt ever recorded for the global UP-arrow history."""
+    with sqlite3.connect(DB_NAME) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT content FROM messages WHERE role = 'user' ORDER BY timestamp ASC"
+        )
+        return [row[0] for row in cursor.fetchall()]
+
+
+def _escape_fts_token(token: str) -> str:
+    """Escape FTS5 special characters in a single token."""
+    # Remove characters that have special meaning in FTS5 MATCH expressions
+    special = '" * ( ) : ^'
+    for ch in special:
+        token = token.replace(ch, "")
+    return token
+
+
+def parse_search_query(query: str) -> str:
+    """
+    Parse search query for FTS5 syntax.
+    - Quoted phrases: "exact match" → use phrase search
+    - Unquoted: use prefix search per word for fuzzy matching
+    """
+    if not query or not query.strip():
+        return ""
+
+    query = query.strip()
+
+    # Check if query is wrapped in quotes (exact phrase)
+    if query.startswith('"') and query.endswith('"') and len(query) > 2:
+        # Remove quotes for phrase search (FTS5 handles phrases natively)
+        inner = query[1:-1]
+        return f'"{inner}"'
+
+    # Fuzzy search: add * at end of each word for prefix matching
+    tokens = query.split()
+    escaped = [_escape_fts_token(t) for t in tokens]
+    # Filter out empty tokens after escaping
+    escaped = [t for t in escaped if t]
+    if not escaped:
+        return ""
+    return " ".join(f"{t}*" for t in escaped)
+
+
+# Invisible sentinel markers for FTS5 snippets (won't conflict with Rich markup)
+_MARK_START = "\x01"
+_MARK_END = "\x02"
+
+
+def search_messages(query: str, limit: int = 10):
+    """
+    Search messages using FTS5 with snippet extraction.
+    Deduplicates by session (best match per session).
+    Returns list of dicts: [{session_id, session_name, content_snippet, timestamp, role}]
+    """
+    if not query or not query.strip():
+        return []
+
+    fts_query = parse_search_query(query)
+
+    with sqlite3.connect(DB_NAME) as conn:
+        cursor = conn.cursor()
+
+        # Search FTS table and join with messages for metadata
+        # Use invisible sentinel markers to avoid Rich markup conflicts
+        cursor.execute(
+            """
+            SELECT 
+                m.session_id,
+                s.name as session_name,
+                snippet(messages_fts, -1, ?, ?, '...', 64) as snippet,
+                m.timestamp,
+                m.role
+            FROM messages_fts
+            JOIN messages m ON messages_fts.rowid = m.id
+            JOIN sessions s ON m.session_id = s.id
+            WHERE messages_fts MATCH ?
+            ORDER BY rank
+            LIMIT ?
+            """,
+            (_MARK_START, _MARK_END, fts_query, limit),
+        )
+
+        # Deduplicate by session_id: keep the best (first) match per session
+        seen_sessions = set()
+        results = []
+        for row in cursor.fetchall():
+            sid = row[0]
+            if sid in seen_sessions:
+                continue
+            seen_sessions.add(sid)
+
+            # Replace sentinel markers with Rich markup tags
+            snippet = (
+                row[2]
+                .replace(_MARK_START, "[bold green]")
+                .replace(_MARK_END, "[/bold green]")
+            )
+
+            results.append(
+                {
+                    "session_id": sid,
+                    "session_name": row[1],
+                    "snippet": snippet,
+                    "timestamp": row[3],
+                    "role": row[4],
+                }
+            )
+
+        return results

pure_chat-0.1.1/src/pure_chat/main.py

@@ -0,0 +1,167 @@
+import argparse
+from dotenv import load_dotenv
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.live import Live
+from rich.panel import Panel
+
+# Terminal-style input imports
+from prompt_toolkit.formatted_text import HTML
+
+from pure_chat import util
+from pure_chat import db_manager
+
+load_dotenv()
+console = Console()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Gemini CLI with SQLite & Search")
+    parser.add_argument("--name", type=str, help="Start/Continue a specific session")
+    args = parser.parse_args()
+
+    db_manager.init_db()
+
+    # Initial Session Setup
+    session_id, session_name = db_manager.get_or_create_session(args.name)
+    ai, input_session = util.setup_chat_session(session_id)
+
+    console.print(
+        Panel(
+            f"Active Session: [bold green]{session_name}[/bold green]\n"
+            "[dim]• Use UP/DOWN arrows for question history\n"
+            "• Type /search <query> to search conversations\n"
+            "• Type /conversations to switch sessions\n"
+            "• Type /model to switch active model\n"
+            "• Type /exit to quit[/dim]",
+            title="Gemini CLI",
+            expand=False,
+        )
+    )
+
+    while True:
+        try:
+            # Styled prompt using prompt_toolkit
+            user_input = input_session.prompt(
+                HTML("<ansicyan><b>You > </b></ansicyan>")
+            )
+
+            if not user_input.strip():
+                continue
+
+            # --- COMMANDS ---
+            if user_input.lower() in ["/exit"]:
+                console.print("[yellow]Goodbye![/yellow]")
+                break
+
+            if user_input.lower().startswith("/search "):
+                query = user_input[8:]  # Remove "/search "
+                if not query.strip():
+                    console.print(
+                        "[yellow]Usage: /search <query> (use quotes for exact phrases)[/yellow]"
+                    )
+                    continue
+
+                results = db_manager.search_messages(query, limit=10)
+
+                if not results:
+                    console.print("[yellow]No matches found.[/yellow]")
+                    continue
+
+                console.print(
+                    f"\n[bold cyan]Found {len(results)} results for:[/bold cyan] {query}\n"
+                )
+
+                for idx, result in enumerate(results, 1):
+                    role_label = "You" if result["role"] == "user" else "Gemini"
+                    console.print(
+                        f"[bold white][{idx}][/bold white] [bold green]{result['session_name']}[/bold green]"
+                    )
+                    console.print(f"[dim]{result['timestamp']} | {role_label}[/dim]")
+                    # Escape Rich markup in snippet, then restore our highlight tags
+                    safe_snippet = (
+                        result["snippet"]
+                        .replace("[bold green]", "\x01")
+                        .replace("[/bold green]", "\x02")
+                    )
+                    safe_snippet = safe_snippet.replace("[", "\\[")
+                    safe_snippet = safe_snippet.replace("\x01", "[bold green]").replace(
+                        "\x02", "[/bold green]"
+                    )
+                    console.print(safe_snippet)
+                    console.print()
+
+                # Arrow-key selection (consistent with /conversations)
+                search_choices = [
+                    f"{r['session_name']} ({r['timestamp']} | {'You' if r['role'] == 'user' else 'Gemini'})"
+                    for r in results
+                ]
+                search_choices.append("Cancel")
+
+                selected = util.pick_from_list("Jump to session:", search_choices)
+
+                if selected is None or selected == "Cancel":
+                    console.print("[dim]Search cancelled.[/dim]\n")
+                else:
+                    selected_name = selected.rsplit(" (", 1)[0]
+                    session_id, session_name = db_manager.get_or_create_session(
+                        selected_name
+                    )
+                    ai, input_session = util.setup_chat_session(session_id)
+                    console.print(
+                        Panel(
+                            f"Switched to: [bold green]{session_name}[/bold green]",
+                            expand=False,
+                        )
+                    )
+                    util.print_session_tail(session_id, console)
+
+                continue
+
+            if user_input.lower() == "/conversations":
+                # Call the function directly (no weird import needed)
+                new_id, new_name = util.select_session_interactive()
+                session_id, session_name = new_id, new_name
+                ai, input_session = util.setup_chat_session(session_id)
+                console.print(
+                    Panel(
+                        f"Switched to: [bold green]{session_name}[/bold green]",
+                        expand=False,
+                    )
+                )
+                util.print_session_tail(session_id, console)
+                continue
+
+            if user_input.lower() == "/model":
+                util.select_model(session_id)
+                continue
+
+            # --- PROCESS CHAT ---
+            db_manager.save_message(session_id, "user", user_input)
+
+            full_res = ""
+            console.print("\n[bold magenta]Gemini:[/bold magenta]")
+
+            # Streaming with Rich Live display
+            with Live(Markdown(""), console=console, refresh_per_second=10) as live:
+                try:
+                    for chunk in ai.send_stream(user_input):
+                        if chunk.text:
+                            full_res += chunk.text
+                            live.update(Markdown(full_res))
+                except Exception as e:
+                    console.print(f"[bold red]API Error:[/bold red] {e}")
+
+            db_manager.save_message(session_id, "model", full_res)
+            print()  # Spacer
+
+        except KeyboardInterrupt:
+            # Standard terminal behavior: Ctrl+C clears the current line
+            continue
+        except EOFError:
+            # Ctrl+D exits
+            break
+
+
+if __name__ == "__main__":
+    main()

pure_chat-0.1.1/src/pure_chat/util.py

@@ -0,0 +1,105 @@
+import questionary
+import os
+from pure_chat import db_manager
+from rich.markdown import Markdown
+from prompt_toolkit import PromptSession
+from prompt_toolkit.history import InMemoryHistory
+from pure_chat.ai_manager import GeminiAssistant
+from google import genai
+
+QUESTIONARY_STYLE = questionary.Style(
+    [
+        ("pointer", "fg:#00ff00 bold"),
+        ("highlighted", "fg:#00ff00 bold"),
+        ("selected", "fg:#00ff00"),
+    ]
+)
+
+
+def pick_from_list(prompt, choices):
+    """Shared arrow-key selection using questionary."""
+    return questionary.select(
+        prompt,
+        choices=choices,
+        style=QUESTIONARY_STYLE,
+    ).ask()
+
+
+def select_session_interactive():
+    """Fetches sessions and lets user pick one with arrow keys."""
+    sessions = db_manager.list_all_sessions()
+
+    # We add an option to create a new one
+    choices = [f"{s[0]} ({s[1]})" for s in sessions]
+    choices.append("Create New Session")
+
+    selected = pick_from_list("Choose a conversation:", choices)
+
+    if selected == "Create New Session" or selected is None:
+        return db_manager.get_or_create_session()
+
+    # Extract the name back out (before the date in parentheses)
+    session_name = selected.rsplit(" (", 1)[0]
+    return db_manager.get_or_create_session(session_name)
+
+
+def print_session_tail(session_id, console):
+    """Prints the last 50 messages to the console with Rich formatting."""
+    tail = db_manager.get_last_n_messages(session_id)
+    if not tail:
+        return
+
+    for role, content in tail:
+        color = "blue" if role == "user" else "magenta"
+        label = "You" if role == "user" else "Gemini"
+        console.print(f"[bold {color}]{label}:[/bold {color}]")
+        console.print(Markdown(content))
+        console.print("")  # Spacer
+    console.print("[dim]--- End of history ---\n[/dim]")
+
+
+def setup_chat_session(session_id, model_id=None):
+    """Initializes history and the AI assistant."""
+    # 1. Load context history for Gemini (Sliding Window)
+    history = db_manager.get_chat_history(session_id, window_size=12)
+    ai = GeminiAssistant(history=history, model_id=model_id)
+
+    # 2. Setup UP-ARROW history for the terminal input
+    past_user_prompts = db_manager.get_all_user_messages_global()
+    terminal_history = InMemoryHistory()
+    for prompt in past_user_prompts:
+        terminal_history.append_string(prompt)
+
+    input_session = PromptSession(history=terminal_history)
+
+    return ai, input_session
+
+
+def select_model(session_id):
+    """
+    Lists available Gemini models that support content generation
+    and allows the user to select one via a CLI menu.
+    """
+    try:
+        api_key = os.getenv("GEMINI_API_KEY")
+        client = genai.Client(api_key=api_key)
+        available_models = [
+            m
+            for m in client.models.list()
+            if m.supported_actions and "generateContent" in m.supported_actions
+        ]
+
+        choices = [
+            {"name": f"{m.display_name} ({m.name})", "value": m.name}
+            for m in available_models
+        ]
+
+        selected_model_id = pick_from_list(
+            "Select the Gemini model you wish to use:", choices
+        )
+
+        return setup_chat_session(session_id, selected_model_id)
+
+    except Exception as e:
+        print(f"Error fetching models: {e}")
+        return None

pure_chat-0.1.1/src/pure_chat.egg-info/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: pure-chat
+Version: 0.1.1
+Summary: A high-performance Terminal User Interface (TUI) designed to replicate the experience of browser based llm chat applications directly in your terminal.
+Author-email: Mats Heemeyer <matsheemeyer@gmail.com>
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: google-genai>=1.72.0
+Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: rich>=15.0.0
+Dynamic: license-file
+
+# PureChat
+
+A high-performance Terminal User Interface (TUI) designed to replicate the experience of browser based llm chat applications directly in your terminal. This tool provides persistent conversation memory, real-time streaming, and interactive session management.
+
+## 💡 Motivation
+
+Most modern AI CLI tools have become heavily "agentic." While powerful for automation, they often force massive context windows, auto-execute commands, and prioritize task completion over simple conversation. This results in high token consumption, slower response times, and a lack of control over what data is being sent.
+
+Gemini CLI Vault was built to fill the gap for a "regular" chat app in the terminal. It provides a familiar web-like experience for discussing complicated topics in a controlled environment where you don't want the tool to send excessive context or execute commands autonomously.
+
+## ✨ Key Features
+
+- **Persistent Memory**: Conversations are stored in a local SQLite database (gemini_vault.db), allowing you to resume any chat session at any time.
+- **Live Streaming & Markdown**: Responses stream in real-time with full Markdown rendering, including syntax-highlighted code blocks, tables, and lists.
+- **Intelligent Context Window**: Automatically manages token usage using a sliding window of the last 12 messages to maintain context without exceeding limits.
+- **Interactive Session Switcher**: Use the /conversations command to browse, search, and switch between previous chat sessions using an arrow-key menu.
+- **Global Command History**: Navigate your previous prompts across all sessions using the UP and DOWN arrows (powered by prompt_toolkit).
+- **Google Search Integration**: The assistant is equipped with the Google Search tool to provide up-to-date information on current events.
+- **Dynamic Personalities**: Load custom system instructions from a GEMINI.md file to change the AI's behavior and tone.
+
+## 🛠️ Installation (using uv)
+
+1. Clone the repository:
+
+```
+git clone https://github.com/yourusername/gemini-cli-vault.git
+cd gemini-cli-vault
+```
+
+2. Configure Environment Variables:
+
+```
+# Create a .env file in the project root:
+GEMINI_API_KEY=your_google_api_key_here
+GEMINI_MODEL=gemini-3-flash-preview
+```
+
+3. (Optional) Define System Instructions:
+   Create a GEMINI.md file to set the AI's System Prompt:
+   You are an expert software architect. Provide concise, high-level advice and always include code snippets in Python or Rust.
+
+## 🚀 Usage
+
+Start a new or default session:
+
+```
+uv run main.py
+```
+
+Start or resume a specific session by name:
+
+```
+python main.py --name Project-Alpha
+```
+
+### ⌨️ In-Chat Commands
+
+- `/conversations` : Opens the interactive session manager to switch or create chats.
+- `/exit` : Safely saves and exits the application.
+- `UP / DOWN` : Cycle through your entire history of user prompts.
+- `Ctrl+C` : Interrupt the current input line.
+
+## 🏗️ Project Architecture
+
+- `main.py`: The entry point and TUI controller. Handles the input loop and rich live display.
+- `db_manager.py`: The data layer. Manages SQLite tables, message logging, and session retrieval.
+- `ai_manager.py`: The AI integration layer. Configures the google-genai client, tools, and system instructions.
+- `gemini_vault.db`: The local database generated on first run.
+
+## 🤖 AI Disclosure
+
+This project was primarily developed with the assistance of AI. While the core logic, architecture, and feature set were human-directed, the majority of the code implementation and boilerplate was generated and refined using Large Language Models.

pure_chat-0.1.1/src/pure_chat.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/pure_chat/__init__.py
+src/pure_chat/ai_manager.py
+src/pure_chat/db_manager.py
+src/pure_chat/main.py
+src/pure_chat/util.py
+src/pure_chat.egg-info/PKG-INFO
+src/pure_chat.egg-info/SOURCES.txt
+src/pure_chat.egg-info/dependency_links.txt
+src/pure_chat.egg-info/entry_points.txt
+src/pure_chat.egg-info/requires.txt
+src/pure_chat.egg-info/top_level.txt

pure_chat-0.1.1/src/pure_chat.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pure_chat-0.1.1/src/pure_chat.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+purechat = pure_chat.main:main

pure_chat-0.1.1/src/pure_chat.egg-info/requires.txt

@@ -0,0 +1,5 @@
+google-genai>=1.72.0
+prompt-toolkit>=3.0.52
+python-dotenv>=1.2.2
+questionary>=2.1.1
+rich>=15.0.0

pure_chat-0.1.1/src/pure_chat.egg-info/top_level.txt

@@ -0,0 +1 @@
+pure_chat