Add Windows CLI and session info API

README.md

@@ -156,3 +156,14 @@ python -m src.cli --user yourname
 The tool lists your existing chat sessions and lets you select one or create a
 new session. Type messages and the assistant's streamed replies will appear
 immediately. Enter ``exit`` or press ``Ctrl+D`` to quit.
+
+### Windows executable
+
+For a standalone application that does not require Python, use the code in
+`cli_app`. After installing ``pyinstaller`` run:
+
+```bash
+pyinstaller --onefile -n llm-chat cli_app/main.py
+```
+
+The resulting ``llm-chat.exe`` can be used on Windows 10/11.

cli_app/README.md

@@ -0,0 +1,31 @@
+# Windows CLI Application
+
+This folder contains a standalone command line interface for interacting with
+`llm-backend`. The application uses [Typer](https://typer.tiangolo.com/) for a
+simple user experience and can be packaged into a single Windows executable
+using [PyInstaller](https://www.pyinstaller.org/).
+
+## Running from source
+
+```bash
+python -m cli_app --user yourname
+```
+
+## Building the executable
+
+1. Install PyInstaller:
+
+   ```bash
+   pip install pyinstaller
+   ```
+
+2. Build the app:
+
+   ```bash
+   pyinstaller --onefile -n llm-chat cli_app/main.py
+   ```
+
+   The resulting `llm-chat.exe` will appear in the `dist` directory.
+
+The executable can be distributed on Windows 10/11 systems without requiring a
+Python installation.

cli_app/__main__.py

@@ -0,0 +1,4 @@
+from .main import app
+
+if __name__ == "__main__":
+    app()

cli_app/main.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import asyncio
+from typing import AsyncIterator, List, Dict
+
+import httpx
+import typer
+from colorama import Fore, Style, init
+
+API_URL = "http://localhost:8000"
+
+app = typer.Typer(add_completion=False, help="Chat with the LLM backend API")
+
+
+async def _get_sessions_info(user: str, server: str) -> List[Dict[str, str]]:
+    async with httpx.AsyncClient(base_url=server) as client:
+        resp = await client.get(f"/sessions/{user}/info")
+        if resp.status_code == 404:
+            # Fallback to basic list for older API versions
+            resp = await client.get(f"/sessions/{user}")
+            resp.raise_for_status()
+            names = resp.json().get("sessions", [])
+            return [{"name": n, "last_message": ""} for n in names]
+        resp.raise_for_status()
+        return resp.json().get("sessions", [])
+
+
+async def _stream_chat(
+    user: str, session: str, prompt: str, server: str
+) -> AsyncIterator[str]:
+    async with httpx.AsyncClient(base_url=server, timeout=None) as client:
+        async with client.stream(
+            "POST",
+            "/chat/stream",
+            json={"user": user, "session": session, "prompt": prompt},
+        ) as resp:
+            resp.raise_for_status()
+            async for line in resp.aiter_lines():
+                if line:
+                    yield line
+
+
+async def _chat_loop(user: str, server: str) -> None:
+    init(autoreset=True)
+    sessions = await _get_sessions_info(user, server)
+    session = "default"
+    if sessions:
+        typer.echo("Existing sessions:")
+        for idx, info in enumerate(sessions, 1):
+            snippet = f" - {info['last_message'][:40]}" if info.get("last_message") else ""
+            typer.echo(f"  {idx}. {info['name']}{snippet}")
+        choice = typer.prompt(
+            "Select session number or enter new name", default=str(len(sessions))
+        )
+        if choice.isdigit() and 1 <= int(choice) <= len(sessions):
+            session = sessions[int(choice) - 1]["name"]
+        else:
+            session = choice.strip() or session
+    else:
+        session = typer.prompt("Session name", default=session)
+
+    typer.echo(
+        f"Chatting as {Fore.GREEN}{user}{Style.RESET_ALL} in session '{session}'"
+    )
+
+    while True:
+        try:
+            msg = typer.prompt(f"{Fore.CYAN}You{Style.RESET_ALL}")
+        except EOFError:
+            break
+        if msg.strip().lower() in {"exit", "quit"}:
+            break
+        async for part in _stream_chat(user, session, msg, server):
+            typer.echo(f"{Fore.YELLOW}{part}{Style.RESET_ALL}")
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    user: str = typer.Option("default", "--user", "-u"),
+    server: str = typer.Option(API_URL, "--server", "-s"),
+) -> None:
+    """Start an interactive chat session."""
+
+    asyncio.run(_chat_loop(user, server))
+
+
+if __name__ == "__main__":  # pragma: no cover - manual execution
+    app()

src/api.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 from fastapi import FastAPI, UploadFile, File, Form
-from fastapi.responses import StreamingResponse
+from fastapi.responses import StreamingResponse, Response
+from fastapi import HTTPException
 from pydantic import BaseModel
 import asyncio
 import os
@@ -10,7 +11,7 @@ from pathlib import Path
 
 from .chat import ChatSession
 from .log import get_logger
-from .db import list_sessions
+from .db import list_sessions, list_sessions_info
 
 
 _LOG = get_logger(__name__)
@@ -63,6 +64,13 @@ def create_app() -> FastAPI:
     async def list_user_sessions(user: str):
         return {"sessions": list_sessions(user)}
 
+    @app.get("/sessions/{user}/info")
+    async def list_user_sessions_info(user: str):
+        data = list_sessions_info(user)
+        if not data:
+            raise HTTPException(status_code=404, detail="User not found")
+        return {"sessions": data}
+
     @app.get("/health")
     async def health():
         return {"status": "ok"}

src/db.py

@@ -62,6 +62,7 @@ __all__ = [
     "Document",
     "reset_history",
     "list_sessions",
+    "list_sessions_info",
     "add_document",
 ]
 
@@ -110,3 +111,25 @@ def list_sessions(username: str) -> list[str]:
     except User.DoesNotExist:
         return []
     return [c.session_name for c in Conversation.select().where(Conversation.user == user)]
+
+
+def list_sessions_info(username: str) -> list[dict[str, str]]:
+    """Return session names and a snippet of the last message for ``username``."""
+
+    init_db()
+    try:
+        user = User.get(User.username == username)
+    except User.DoesNotExist:
+        return []
+
+    sessions = []
+    for conv in Conversation.select().where(Conversation.user == user):
+        last_msg = (
+            Message.select()
+            .where(Message.conversation == conv)
+            .order_by(Message.created_at.desc())
+            .first()
+        )
+        snippet = (last_msg.content[:50] + "…") if last_msg else ""
+        sessions.append({"name": conv.session_name, "last_message": snippet})
+    return sessions