code-lm 0.3.1__tar.gz → 0.3.2__tar.gz

{code_lm-0.3.1/src/code_lm.egg-info → code_lm-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-lm
-Version: 0.3.1
+Version: 0.3.2
 Summary: An AI coding assistant using various LLM models.
 Home-page: https://github.com/Panagiotis897/lm-code
 Author: Panagiotis897
@@ -39,6 +39,10 @@ LM Code is a powerful AI coding assistant for your terminal supporting 17 free m
   - Markdown rendering for improved readability.
 - **17 Free Models via OpenRouter**:
   - NVIDIA Nemotron, Qwen, OpenAI, Meta Llama, Mistral, and more.
+- **Session Persistence**:
+  - Conversations are saved per project directory.
+  - Resume previous sessions automatically or manually with `/load`.
+  - Auto-saves after each exchange.
 - **Automated Tool Usage**:
   - File operations: `view`, `edit`, `grep`, `glob`.
   - Directory operations: `ls`, `tree`, `create_directory`.
@@ -47,12 +51,6 @@ LM Code is a powerful AI coding assistant for your terminal supporting 17 free m
   - Test running: `pytest` and similar tools.
 - **Customizable Configurations**:
   - Easily set default models and API keys.
-- **Session Persistence**:
-  - Conversation history is saved per project directory.
-  - Resume previous sessions when you restart in the same directory.
-- **Mid-Session Commands**:
-  - `/compact` — Summarize conversation history to stay within context limits.
-  - `/model` — Switch models mid-session without restarting.
 
 ---
 
@@ -138,11 +136,12 @@ lmcode list-models
 
 During an interactive session:
 
-- **`/exit`**: Exit the session.
+- **`/exit`**: Save session and exit.
 - **`/help`**: Display help information.
-- **`/compact`**: Summarize the conversation history to reduce token usage. Useful when the session gets long and you want to free up context space.
-- **`/model`**: List all available models.
-- **`/model <model_id>`**: Switch to a different model mid-session without losing conversation history.
+- **`/sessions`**: List all sessions for the current project.
+- **`/load <id>`**: Load a session by ID.
+- **`/new`**: Start a new session (saves current first).
+- **`/save`**: Manually save the current session.
 
 ---
 
@@ -162,11 +161,11 @@ LM Code is under active development. Contributions, feature requests, and feedba
 
 ### Changelog
 
-#### v0.3.1
-- Added `/compact` command — summarizes conversation history via LLM to stay within context limits.
-- Added `/model` command — list available models or switch models mid-session without restarting.
-- Added session persistence — conversation history is auto-saved per project directory and can be resumed on restart.
-- Updated help text to include new interactive commands.
+#### v0.3.2
+- Added session persistence: conversations are saved per project directory.
+- Sessions auto-save after each exchange and on exit.
+- New commands: `/sessions`, `/load <id>`, `/new`, `/save`.
+- On startup, offers to resume previous sessions for the current project.
 
 #### v0.3.0
 - Updated default model to NVIDIA Nemotron 3 Super 120B.

{code_lm-0.3.1 → code_lm-0.3.2}/README.md

@@ -11,6 +11,10 @@ LM Code is a powerful AI coding assistant for your terminal supporting 17 free m
   - Markdown rendering for improved readability.
 - **17 Free Models via OpenRouter**:
   - NVIDIA Nemotron, Qwen, OpenAI, Meta Llama, Mistral, and more.
+- **Session Persistence**:
+  - Conversations are saved per project directory.
+  - Resume previous sessions automatically or manually with `/load`.
+  - Auto-saves after each exchange.
 - **Automated Tool Usage**:
   - File operations: `view`, `edit`, `grep`, `glob`.
   - Directory operations: `ls`, `tree`, `create_directory`.
@@ -19,12 +23,6 @@ LM Code is a powerful AI coding assistant for your terminal supporting 17 free m
   - Test running: `pytest` and similar tools.
 - **Customizable Configurations**:
   - Easily set default models and API keys.
-- **Session Persistence**:
-  - Conversation history is saved per project directory.
-  - Resume previous sessions when you restart in the same directory.
-- **Mid-Session Commands**:
-  - `/compact` — Summarize conversation history to stay within context limits.
-  - `/model` — Switch models mid-session without restarting.
 
 ---
 
@@ -110,11 +108,12 @@ lmcode list-models
 
 During an interactive session:
 
-- **`/exit`**: Exit the session.
+- **`/exit`**: Save session and exit.
 - **`/help`**: Display help information.
-- **`/compact`**: Summarize the conversation history to reduce token usage. Useful when the session gets long and you want to free up context space.
-- **`/model`**: List all available models.
-- **`/model <model_id>`**: Switch to a different model mid-session without losing conversation history.
+- **`/sessions`**: List all sessions for the current project.
+- **`/load <id>`**: Load a session by ID.
+- **`/new`**: Start a new session (saves current first).
+- **`/save`**: Manually save the current session.
 
 ---
 
@@ -134,11 +133,11 @@ LM Code is under active development. Contributions, feature requests, and feedba
 
 ### Changelog
 
-#### v0.3.1
-- Added `/compact` command — summarizes conversation history via LLM to stay within context limits.
-- Added `/model` command — list available models or switch models mid-session without restarting.
-- Added session persistence — conversation history is auto-saved per project directory and can be resumed on restart.
-- Updated help text to include new interactive commands.
+#### v0.3.2
+- Added session persistence: conversations are saved per project directory.
+- Sessions auto-save after each exchange and on exit.
+- New commands: `/sessions`, `/load <id>`, `/new`, `/save`.
+- On startup, offers to resume previous sessions for the current project.
 
 #### v0.3.0
 - Updated default model to NVIDIA Nemotron 3 Super 120B.

{code_lm-0.3.1 → code_lm-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-lm"
-version = "0.3.1"
+version = "0.3.2"
 authors = [
   { name="Panagiotis897", email="orion256business@gmail.com" }
 ]

{code_lm-0.3.1 → code_lm-0.3.2/src/code_lm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-lm
-Version: 0.3.1
+Version: 0.3.2
 Summary: An AI coding assistant using various LLM models.
 Home-page: https://github.com/Panagiotis897/lm-code
 Author: Panagiotis897
@@ -39,6 +39,10 @@ LM Code is a powerful AI coding assistant for your terminal supporting 17 free m
   - Markdown rendering for improved readability.
 - **17 Free Models via OpenRouter**:
   - NVIDIA Nemotron, Qwen, OpenAI, Meta Llama, Mistral, and more.
+- **Session Persistence**:
+  - Conversations are saved per project directory.
+  - Resume previous sessions automatically or manually with `/load`.
+  - Auto-saves after each exchange.
 - **Automated Tool Usage**:
   - File operations: `view`, `edit`, `grep`, `glob`.
   - Directory operations: `ls`, `tree`, `create_directory`.
@@ -47,12 +51,6 @@ LM Code is a powerful AI coding assistant for your terminal supporting 17 free m
   - Test running: `pytest` and similar tools.
 - **Customizable Configurations**:
   - Easily set default models and API keys.
-- **Session Persistence**:
-  - Conversation history is saved per project directory.
-  - Resume previous sessions when you restart in the same directory.
-- **Mid-Session Commands**:
-  - `/compact` — Summarize conversation history to stay within context limits.
-  - `/model` — Switch models mid-session without restarting.
 
 ---
 
@@ -138,11 +136,12 @@ lmcode list-models
 
 During an interactive session:
 
-- **`/exit`**: Exit the session.
+- **`/exit`**: Save session and exit.
 - **`/help`**: Display help information.
-- **`/compact`**: Summarize the conversation history to reduce token usage. Useful when the session gets long and you want to free up context space.
-- **`/model`**: List all available models.
-- **`/model <model_id>`**: Switch to a different model mid-session without losing conversation history.
+- **`/sessions`**: List all sessions for the current project.
+- **`/load <id>`**: Load a session by ID.
+- **`/new`**: Start a new session (saves current first).
+- **`/save`**: Manually save the current session.
 
 ---
 
@@ -162,11 +161,11 @@ LM Code is under active development. Contributions, feature requests, and feedba
 
 ### Changelog
 
-#### v0.3.1
-- Added `/compact` command — summarizes conversation history via LLM to stay within context limits.
-- Added `/model` command — list available models or switch models mid-session without restarting.
-- Added session persistence — conversation history is auto-saved per project directory and can be resumed on restart.
-- Updated help text to include new interactive commands.
+#### v0.3.2
+- Added session persistence: conversations are saved per project directory.
+- Sessions auto-save after each exchange and on exit.
+- New commands: `/sessions`, `/load <id>`, `/new`, `/save`.
+- On startup, offers to resume previous sessions for the current project.
 
 #### v0.3.0
 - Updated default model to NVIDIA Nemotron 3 Super 120B.

{code_lm-0.3.1 → code_lm-0.3.2}/src/lm_code/__init__.py

@@ -2,4 +2,4 @@
 LM CLI - A command-line interface for interacting with various LLM models.
 """
 
-__version__ = "0.3.1"
+__version__ = "0.1.70"

{code_lm-0.3.1 → code_lm-0.3.2}/src/lm_code/main.py

@@ -10,6 +10,7 @@ from rich.console import Console
 from rich.markdown import Markdown
 from rich.panel import Panel
 from pathlib import Path
+from typing import Optional, Dict, Any
 import yaml
 import logging
 import time
@@ -261,51 +262,18 @@ def start_interactive_session(model_name: str, console: Console):
         )
         return
 
-    # --- Session persistence setup ---
-    session_mgr = SessionManager()
-    project_dir = str(Path.cwd())
-    saved_session = session_mgr.load_session(project_dir)
-
-    if saved_session:
-        saved_model = saved_session.get("model_name", "?")
-        saved_time = time.strftime(
-            "%Y-%m-%d %H:%M",
-            time.localtime(saved_session.get("timestamp", 0)),
-        )
-        msg_count = len(saved_session.get("chat_history", []))
-        console.print(
-            f"\n[yellow]Found saved session[/yellow] (model: {saved_model}, "
-            f"saved: {saved_time}, {msg_count} messages)"
-        )
-        try:
-            resume = questionary.confirm(
-                "Resume previous session?",
-                default=True,
-                auto_enter=False,
-            ).ask()
-        except (KeyboardInterrupt, EOFError):
-            resume = None
-
-        if resume is None:
-            console.print("\n[yellow]Exiting.[/yellow]")
-            return
-    else:
-        resume = False
+    # --- Session Persistence Setup ---
+    session_manager = SessionManager()
+    project_dir = os.getcwd()
+    current_session_id = None
+    current_model_name = model_name
     # ---
 
     try:
         console.print(f"\nInitializing model [bold]{model_name}[/bold]...")
         # Pass the console object to OpenRouterModel constructor
         model = OpenRouterModel(api_key=api_key, console=console, model_name=model_name)
-
-        # Restore session history if resuming
-        if resume and saved_session:
-            model.chat_history = saved_session.get("chat_history", model.chat_history)
-            console.print(
-                f"[green]Session restored ({len(model.chat_history)} messages).[/green]\n"
-            )
-        else:
-            console.print("[green]Model initialized successfully.[/green]\n")
+        console.print("[green]Model initialized successfully.[/green]\n")
 
     except Exception as e:
         console.print(
@@ -317,21 +285,128 @@ def start_interactive_session(model_name: str, console: Console):
         )
         return
 
+    # --- Check for existing sessions and offer to resume ---
+    existing_sessions = session_manager.list_sessions(project_dir)
+    if existing_sessions:
+        console.print(
+            f"\n[yellow]Found {len(existing_sessions)} previous session(s) for this project:[/yellow]"
+        )
+        for i, session in enumerate(existing_sessions[:5], 1):
+            updated = session.get("updated_at", "")[:19].replace("T", " ")
+            messages = session.get("message_count", 0)
+            model = session.get("model_name", "unknown")
+            console.print(f"  {i}. [{updated}] {messages} messages (model: {model})")
+
+        resume_choice = questionary.select(
+            "Resume a previous session?",
+            choices=["Start new session", "Resume latest", "Choose session"],
+            default="Start new session",
+        ).ask()
+
+        if resume_choice == "Resume latest":
+            latest_session = session_manager.get_latest_session(project_dir)
+            if latest_session:
+                model.chat_history = latest_session["chat_history"]
+                current_session_id = latest_session["id"]
+                current_model_name = latest_session.get("model_name", model_name)
+                console.print(
+                    f"[green]Resumed session {current_session_id} ({len(model.chat_history)} messages)[/green]\n"
+                )
+            else:
+                console.print("[yellow]No session to resume. Starting new.[/yellow]\n")
+        elif resume_choice == "Choose session":
+            session_choices = [
+                f"{s['id']} ({s['message_count']} msgs, {s['updated_at'][:16]})"
+                for s in existing_sessions[:10]
+            ]
+            session_choices.append("Cancel - start new session")
+            chosen = questionary.select(
+                "Select a session to resume:",
+                choices=session_choices,
+            ).ask()
+            if chosen and chosen != "Cancel - start new session":
+                chosen_id = chosen.split(" (")[0]
+                loaded_session = session_manager.load_session(project_dir, chosen_id)
+                if loaded_session:
+                    model.chat_history = loaded_session["chat_history"]
+                    current_session_id = loaded_session["id"]
+                    current_model_name = loaded_session.get("model_name", model_name)
+                    console.print(
+                        f"[green]Resumed session {current_session_id} ({len(model.chat_history)} messages)[/green]\n"
+                    )
+                else:
+                    console.print("[red]Failed to load session. Starting new.[/red]\n")
+            else:
+                console.print("[yellow]Starting new session.[/yellow]\n")
+        else:
+            console.print("[yellow]Starting new session.[/yellow]\n")
+    # --- End Session Resume Check ---
+
     # --- Session Start Message ---
     console.print("Type '/help' for commands, '/exit' or Ctrl+C to quit.")
-    console.print(f"[dim]Current model: {model.current_model_name}[/dim]")
 
     while True:
         try:
             user_input = console.input("[bold green]You:[/bold green] ")
 
             if user_input.lower() == "/exit":
+                # Save session before exiting
+                _save_current_session(
+                    session_manager,
+                    project_dir,
+                    model,
+                    current_model_name,
+                    current_session_id,
+                    console,
+                )
                 break
             elif user_input.lower() == "/help":
                 show_help()
                 continue
-            elif user_input.lower().startswith("/model"):
-                _handle_model_command(user_input, model, console, SUPPORTED_MODELS)
+            elif user_input.lower() == "/sessions":
+                _show_sessions(session_manager, project_dir, console)
+                continue
+            elif user_input.lower().startswith("/load "):
+                session_id = user_input[6:].strip()
+                loaded = _load_session_by_id(
+                    session_manager, project_dir, session_id, model, console
+                )
+                if loaded:
+                    current_session_id = loaded["id"]
+                    current_model_name = loaded.get("model_name", model_name)
+                continue
+            elif user_input.lower() == "/new":
+                # Save current session first
+                _save_current_session(
+                    session_manager,
+                    project_dir,
+                    model,
+                    current_model_name,
+                    current_session_id,
+                    console,
+                )
+                # Reset chat history
+                model.chat_history = [
+                    {"role": "system", "content": model.system_instruction},
+                    {
+                        "role": "assistant",
+                        "content": "Okay, I'm ready. Provide the directory context and your request.",
+                    },
+                ]
+                current_session_id = None
+                console.print("[green]Started new session.[/green]\n")
+                continue
+            elif user_input.lower() == "/save":
+                session_id = _save_current_session(
+                    session_manager,
+                    project_dir,
+                    model,
+                    current_model_name,
+                    current_session_id,
+                    console,
+                )
+                if session_id:
+                    current_session_id = session_id
                 continue
 
             # Display initial "thinking" status - generate handles intermediate ones
@@ -345,19 +420,29 @@ def start_interactive_session(model_name: str, console: Console):
                 log.warning("generate() returned None unexpectedly.")
                 continue
 
-            # Show compact result without markdown rendering
-            if user_input.lower().strip() == "/compact":
-                console.print(f"[cyan]{response_text}[/cyan]")
-            else:
-                console.print("[bold green]Assistant:[/bold green]")
-                console.print(Markdown(response_text), highlight=True)
-
-            # Auto-save session after each turn
-            session_mgr.save_session(
-                project_dir, model.chat_history, model.current_model_name
+            console.print("[bold green]Assistant:[/bold green]")
+            console.print(Markdown(response_text), highlight=True)
+
+            # Auto-save after each exchange
+            current_session_id = _auto_save_session(
+                session_manager,
+                project_dir,
+                model,
+                current_model_name,
+                current_session_id,
+                console,
             )
 
         except KeyboardInterrupt:
+            # Save session before exiting
+            _save_current_session(
+                session_manager,
+                project_dir,
+                model,
+                current_model_name,
+                current_session_id,
+                console,
+            )
             console.print("\n[yellow]Session interrupted. Exiting.[/yellow]")
             break
         except Exception as e:
@@ -366,42 +451,95 @@ def start_interactive_session(model_name: str, console: Console):
             )
             log.error("Error during interactive loop", exc_info=True)
 
-    # Save session on exit
-    session_mgr.save_session(project_dir, model.chat_history, model.current_model_name)
-    console.print("[dim]Session saved.[/dim]")
-
-
-def _handle_model_command(
-    user_input: str, model, console: Console, supported_models: list
-):
-    """Handle /model command to switch models mid-session."""
-    parts = user_input.strip().split(None, 1)
-    if len(parts) < 2:
-        # No model specified — show available models
-        console.print("[cyan]Available models:[/cyan]")
-        for m in supported_models:
-            current = (
-                " [bold green](current)[/bold green]"
-                if m["id"] == model.current_model_name
-                else ""
-            )
-            console.print(f"  [bold]{m['id']}[/bold]{current} — {m['description']}")
-        console.print("\nUsage: /model <model_id>")
-        return
 
-    target = parts[1].strip()
+def _save_current_session(
+    session_manager: SessionManager,
+    project_dir: str,
+    model: OpenRouterModel,
+    model_name: str,
+    session_id: Optional[str],
+    console: Console,
+) -> Optional[str]:
+    """Save the current session. Returns the session ID if saved."""
+    # Don't save if there are no user messages
+    user_messages = [msg for msg in model.chat_history if msg.get("role") == "user"]
+    if not user_messages:
+        return None
 
-    # Validate the model is in supported list
-    valid_ids = {m["id"] for m in supported_models}
-    if target not in valid_ids:
-        console.print(f"[red]Unknown model:[/red] {target}")
-        console.print("Use [bold]/model[/bold] (no argument) to list available models.")
+    try:
+        saved_id = session_manager.save_session(
+            project_dir=project_dir,
+            chat_history=model.chat_history,
+            model_name=model_name,
+            session_id=session_id,
+        )
+        console.print(f"[dim]Session saved: {saved_id}[/dim]")
+        return saved_id
+    except Exception as e:
+        log.error(f"Failed to save session: {e}")
+        console.print(f"[red]Warning: Failed to save session: {e}[/red]")
+        return None
+
+
+def _auto_save_session(
+    session_manager: SessionManager,
+    project_dir: str,
+    model: OpenRouterModel,
+    model_name: str,
+    session_id: Optional[str],
+    console: Console,
+) -> Optional[str]:
+    """Auto-save session silently. Returns the session ID."""
+    try:
+        saved_id = session_manager.save_session(
+            project_dir=project_dir,
+            chat_history=model.chat_history,
+            model_name=model_name,
+            session_id=session_id,
+        )
+        return saved_id
+    except Exception as e:
+        log.error(f"Auto-save failed: {e}")
+        return session_id
+
+
+def _show_sessions(session_manager: SessionManager, project_dir: str, console: Console):
+    """Display sessions for the current project."""
+    sessions = session_manager.list_sessions(project_dir)
+    if not sessions:
+        console.print("[yellow]No sessions found for this project.[/yellow]")
         return
 
-    old_model = model.current_model_name
-    model.switch_model(target)
-    console.print(f"[green]Switched model:[/green] {old_model} → [bold]{target}[/bold]")
-    console.print(f"[dim]Current model: {model.current_model_name}[/dim]")
+    console.print(f"\n[bold cyan]Sessions for current project:[/bold cyan]")
+    for i, session in enumerate(sessions, 1):
+        updated = session.get("updated_at", "")[:19].replace("T", " ")
+        messages = session.get("message_count", 0)
+        model = session.get("model_name", "unknown")
+        console.print(
+            f"  {i}. ID: [green]{session['id']}[/green] | {updated} | {messages} msgs | {model}"
+        )
+    console.print("\nUse '/load <session_id>' to resume a session.\n")
+
+
+def _load_session_by_id(
+    session_manager: SessionManager,
+    project_dir: str,
+    session_id: str,
+    model: OpenRouterModel,
+    console: Console,
+) -> Optional[Dict[str, Any]]:
+    """Load a session by ID. Returns session data or None."""
+    loaded_session = session_manager.load_session(project_dir, session_id)
+    if loaded_session:
+        model.chat_history = loaded_session["chat_history"]
+        console.print(
+            f"[green]Loaded session {session_id} ({len(model.chat_history)} messages)[/green]\n"
+        )
+        return loaded_session
+    else:
+        console.print(f"[red]Session '{session_id}' not found.[/red]")
+        console.print("[yellow]Use '/sessions' to list available sessions.[/yellow]\n")
+        return None
 
 
 def show_help():
@@ -419,11 +557,12 @@ def show_help():
     help_text = f""" [bold]Help[/bold]
 
  [cyan]Interactive Commands:[/cyan]
-  /exit
-  /help
-  /compact          Summarize conversation history to save tokens
-  /model            List available models
-  /model <name>     Switch to a different model mid-session
+  /exit          - Save session and exit
+  /help          - Show this help message
+  /sessions      - List sessions for current project
+  /load <id>     - Load a session by ID
+  /new           - Start a new session (saves current first)
+  /save          - Manually save current session
 
  [cyan]CLI Commands:[/cyan]
   lmcode setup KEY
@@ -433,6 +572,10 @@ def show_help():
 
  [cyan]Workflow Hint:[/cyan] Analyze -> Plan -> Execute -> Verify -> Summarize
 
+ [cyan]Session Persistence:[/cyan]
+  Sessions are automatically saved per project directory.
+  Resume previous sessions with /load or on startup.
+
  [cyan]Available Tools:[/cyan]
 {tool_list_formatted}
 """

{code_lm-0.3.1 → code_lm-0.3.2}/src/lm_code/models/openrouter.py

@@ -188,99 +188,6 @@ class OpenRouterModel:
             )
         return tools
 
-    # --- Model switching ---
-    def switch_model(self, model_name: str) -> None:
-        """Switch to a different model without resetting conversation history."""
-        self.current_model_name = model_name
-        log.info(f"Switched model to: {model_name}")
-
-    # --- Compact history via summarization ---
-    def compact_history(self) -> str:
-        """Summarize the conversation history to reduce token usage."""
-        if len(self.chat_history) <= 2:
-            return "Nothing to compact."
-
-        self.console.print("[yellow]Compacting conversation history...[/yellow]")
-
-        # Extract user-facing conversation (skip system message at index 0)
-        conversation_text = ""
-        for msg in self.chat_history[1:]:
-            role = msg.get("role", "?")
-            content = msg.get("content", "")
-            if role == "user":
-                # Strip the orientation context prefix for cleaner summary
-                lines = content.split("\n")
-                user_lines = []
-                capturing = False
-                for line in lines:
-                    if line.startswith("User request:"):
-                        capturing = True
-                    if capturing:
-                        user_lines.append(line)
-                if user_lines:
-                    conversation_text += f"User: {' '.join(user_lines)}\n"
-                else:
-                    conversation_text += f"User: {content[:500]}\n"
-            elif role == "assistant":
-                conversation_text += f"Assistant: {content[:1000]}\n"
-            elif role == "tool":
-                name = msg.get("name", "tool")
-                conversation_text += f"Tool({name}): {content[:500]}\n"
-
-        if not conversation_text.strip():
-            return "Nothing to compact."
-
-        summarization_prompt = (
-            "You are a summarizer. Summarize the following conversation between a user and an AI coding assistant. "
-            "Preserve all key details: what was discussed, what files were viewed/edited, "
-            "what decisions were made, and what the current state of work is. "
-            "Be concise but complete. This summary will replace the conversation history.\n\n"
-            f"Conversation:\n{conversation_text}\n\n"
-            "Provide a concise summary:"
-        )
-
-        try:
-            payload = {
-                "model": self.current_model_name,
-                "messages": [
-                    {
-                        "role": "system",
-                        "content": "You are a helpful summarizer. Return only the summary, no preamble.",
-                    },
-                    {"role": "user", "content": summarization_prompt},
-                ],
-                "temperature": 0.3,
-                "max_tokens": 1000,
-            }
-
-            with self.console.status("[yellow]Generating summary...", spinner="dots"):
-                response = requests.post(
-                    self.base_url, headers=self.headers, json=payload
-                )
-                response.raise_for_status()
-                data = response.json()
-
-            summary = data["choices"][0]["message"]["content"]
-            original_count = len(self.chat_history)
-
-            # Keep system message, replace everything else with summary
-            self.chat_history = [
-                self.chat_history[0],  # system message
-                {
-                    "role": "assistant",
-                    "content": f"[Conversation summary]\n{summary}",
-                },
-            ]
-
-            log.info(
-                f"Compacted history from {original_count} to {len(self.chat_history)} messages"
-            )
-            return f"Compacted {original_count} messages down to a summary."
-
-        except Exception as e:
-            log.error(f"Compaction failed: {e}", exc_info=True)
-            return f"Compaction failed: {e}"
-
     # --- Native Function Calling Agent Loop ---
     def generate(self, prompt: str) -> str | None:
         logging.info(
@@ -289,11 +196,10 @@ class OpenRouterModel:
         original_user_prompt = prompt
         if prompt.startswith("/"):
             command = prompt.split()[0].lower()
+            # Handle commands like /compact here eventually
             if command in ["/exit", "/help"]:
                 logging.info(f"Handled command: {command}")
-                return None
-            if command == "/compact":
-                return self.compact_history()
+                return None  # Or return specific help text
 
         # === Step 1: Mandatory Orientation ===
         orientation_context = ""

code_lm-0.3.2/src/lm_code/session.py

@@ -0,0 +1,283 @@
+"""
+Session persistence for LM Code CLI.
+Saves and loads conversation history per project directory.
+"""
+
+import json
+import hashlib
+import os
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Optional, Any
+
+log = logging.getLogger(__name__)
+
+
+class SessionManager:
+    """Manages session persistence for conversation history."""
+
+    def __init__(self, sessions_dir: Optional[str] = None):
+        self.sessions_dir = (
+            Path(sessions_dir)
+            if sessions_dir
+            else Path.home() / ".config" / "lm-code" / "sessions"
+        )
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+        self.current_session_id = None
+        self.current_project_dir = None
+
+    def _get_project_hash(self, project_dir: str) -> str:
+        """Generate a unique hash for a project directory path."""
+        normalized = os.path.normpath(os.path.abspath(project_dir))
+        return hashlib.sha256(normalized.encode()).hexdigest()[:16]
+
+    def _get_project_sessions_dir(self, project_dir: str) -> Path:
+        """Get the sessions directory for a specific project."""
+        project_hash = self._get_project_hash(project_dir)
+        project_sessions_dir = self.sessions_dir / project_hash
+        project_sessions_dir.mkdir(parents=True, exist_ok=True)
+        return project_sessions_dir
+
+    def save_session(
+        self,
+        project_dir: str,
+        chat_history: List[Dict[str, Any]],
+        model_name: str,
+        session_id: Optional[str] = None,
+    ) -> str:
+        """
+        Save a session to disk.
+
+        Args:
+            project_dir: The project directory path
+            chat_history: The chat history list from OpenRouterModel
+            model_name: The model being used
+            session_id: Optional existing session ID to overwrite
+
+        Returns:
+            The session ID of the saved session
+        """
+        if session_id is None:
+            session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+        project_sessions_dir = self._get_project_sessions_dir(project_dir)
+
+        session_data = {
+            "id": session_id,
+            "project_dir": os.path.abspath(project_dir),
+            "model_name": model_name,
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+            "chat_history": chat_history,
+            "message_count": len(
+                [
+                    msg
+                    for msg in chat_history
+                    if msg.get("role") in ("user", "assistant")
+                ]
+            ),
+        }
+
+        session_file = project_sessions_dir / f"{session_id}.json"
+
+        try:
+            with open(session_file, "w", encoding="utf-8") as f:
+                json.dump(session_data, f, indent=2, ensure_ascii=False)
+            log.info(f"Session saved: {session_id} for project {project_dir}")
+            self.current_session_id = session_id
+            self.current_project_dir = project_dir
+            return session_id
+        except Exception as e:
+            log.error(f"Failed to save session: {e}", exc_info=True)
+            raise
+
+    def load_session(
+        self, project_dir: str, session_id: str
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Load a session from disk.
+
+        Args:
+            project_dir: The project directory path
+            session_id: The session ID to load
+
+        Returns:
+            Session data dict or None if not found
+        """
+        project_sessions_dir = self._get_project_sessions_dir(project_dir)
+        session_file = project_sessions_dir / f"{session_id}.json"
+
+        if not session_file.exists():
+            log.warning(f"Session file not found: {session_file}")
+            return None
+
+        try:
+            with open(session_file, "r", encoding="utf-8") as f:
+                session_data = json.load(f)
+            log.info(f"Session loaded: {session_id}")
+            self.current_session_id = session_id
+            self.current_project_dir = project_dir
+            return session_data
+        except Exception as e:
+            log.error(f"Failed to load session: {e}", exc_info=True)
+            return None
+
+    def list_sessions(self, project_dir: str) -> List[Dict[str, Any]]:
+        """
+        List all sessions for a project directory.
+
+        Args:
+            project_dir: The project directory path
+
+        Returns:
+            List of session metadata dicts, sorted by most recent first
+        """
+        project_sessions_dir = self._get_project_sessions_dir(project_dir)
+        sessions = []
+
+        for session_file in project_sessions_dir.glob("*.json"):
+            try:
+                with open(session_file, "r", encoding="utf-8") as f:
+                    session_data = json.load(f)
+                sessions.append(
+                    {
+                        "id": session_data.get("id", session_file.stem),
+                        "project_dir": session_data.get("project_dir", project_dir),
+                        "model_name": session_data.get("model_name", "unknown"),
+                        "created_at": session_data.get("created_at", ""),
+                        "updated_at": session_data.get("updated_at", ""),
+                        "message_count": session_data.get("message_count", 0),
+                    }
+                )
+            except Exception as e:
+                log.warning(f"Failed to read session file {session_file}: {e}")
+                continue
+
+        # Sort by most recent first
+        sessions.sort(key=lambda s: s.get("updated_at", ""), reverse=True)
+        return sessions
+
+    def list_all_sessions(self) -> List[Dict[str, Any]]:
+        """
+        List all sessions across all projects.
+
+        Returns:
+            List of session metadata dicts, sorted by most recent first
+        """
+        all_sessions = []
+
+        for project_hash_dir in self.sessions_dir.iterdir():
+            if not project_hash_dir.is_dir():
+                continue
+
+            for session_file in project_hash_dir.glob("*.json"):
+                try:
+                    with open(session_file, "r", encoding="utf-8") as f:
+                        session_data = json.load(f)
+                    all_sessions.append(
+                        {
+                            "id": session_data.get("id", session_file.stem),
+                            "project_dir": session_data.get("project_dir", "unknown"),
+                            "model_name": session_data.get("model_name", "unknown"),
+                            "created_at": session_data.get("created_at", ""),
+                            "updated_at": session_data.get("updated_at", ""),
+                            "message_count": session_data.get("message_count", 0),
+                        }
+                    )
+                except Exception as e:
+                    log.warning(f"Failed to read session file {session_file}: {e}")
+                    continue
+
+        # Sort by most recent first
+        all_sessions.sort(key=lambda s: s.get("updated_at", ""), reverse=True)
+        return all_sessions
+
+    def get_latest_session(self, project_dir: str) -> Optional[Dict[str, Any]]:
+        """
+        Get the most recent session for a project directory.
+
+        Args:
+            project_dir: The project directory path
+
+        Returns:
+            Session data dict or None if no sessions exist
+        """
+        sessions = self.list_sessions(project_dir)
+        if not sessions:
+            return None
+
+        latest_id = sessions[0]["id"]
+        return self.load_session(project_dir, latest_id)
+
+    def delete_session(self, project_dir: str, session_id: str) -> bool:
+        """
+        Delete a session.
+
+        Args:
+            project_dir: The project directory path
+            session_id: The session ID to delete
+
+        Returns:
+            True if deleted successfully, False otherwise
+        """
+        project_sessions_dir = self._get_project_sessions_dir(project_dir)
+        session_file = project_sessions_dir / f"{session_id}.json"
+
+        if not session_file.exists():
+            log.warning(f"Session file not found for deletion: {session_file}")
+            return False
+
+        try:
+            session_file.unlink()
+            log.info(f"Session deleted: {session_id}")
+            if self.current_session_id == session_id:
+                self.current_session_id = None
+            return True
+        except Exception as e:
+            log.error(f"Failed to delete session: {e}", exc_info=True)
+            return False
+
+    def update_session(
+        self, project_dir: str, session_id: str, chat_history: List[Dict[str, Any]]
+    ) -> bool:
+        """
+        Update an existing session with new chat history.
+
+        Args:
+            project_dir: The project directory path
+            session_id: The session ID to update
+            chat_history: The updated chat history
+
+        Returns:
+            True if updated successfully, False otherwise
+        """
+        project_sessions_dir = self._get_project_sessions_dir(project_dir)
+        session_file = project_sessions_dir / f"{session_id}.json"
+
+        if not session_file.exists():
+            log.warning(f"Session file not found for update: {session_file}")
+            return False
+
+        try:
+            with open(session_file, "r", encoding="utf-8") as f:
+                session_data = json.load(f)
+
+            session_data["chat_history"] = chat_history
+            session_data["updated_at"] = datetime.now().isoformat()
+            session_data["message_count"] = len(
+                [
+                    msg
+                    for msg in chat_history
+                    if msg.get("role") in ("user", "assistant")
+                ]
+            )
+
+            with open(session_file, "w", encoding="utf-8") as f:
+                json.dump(session_data, f, indent=2, ensure_ascii=False)
+
+            log.info(f"Session updated: {session_id}")
+            return True
+        except Exception as e:
+            log.error(f"Failed to update session: {e}", exc_info=True)
+            return False

code_lm-0.3.1/src/lm_code/session.py

@@ -1,97 +0,0 @@
-"""
-Session persistence for LM Code.
-Saves and loads conversation history per project directory.
-"""
-
-import hashlib
-import json
-import logging
-import os
-import time
-from pathlib import Path
-from typing import Optional, Dict, List, Any
-
-log = logging.getLogger(__name__)
-
-SESSIONS_DIR = Path.home() / ".config" / "lm-code" / "sessions"
-
-
-def _project_hash(project_dir: str) -> str:
-    """Create a stable hash from the absolute project directory path."""
-    abs_path = str(Path(project_dir).resolve())
-    return hashlib.sha256(abs_path.encode()).hexdigest()[:16]
-
-
-class SessionManager:
-    """Manages per-project session persistence."""
-
-    def __init__(self):
-        SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
-
-    def _session_path(self, project_dir: str) -> Path:
-        h = _project_hash(project_dir)
-        return SESSIONS_DIR / f"{h}.json"
-
-    def save_session(
-        self,
-        project_dir: str,
-        chat_history: List[Dict[str, Any]],
-        model_name: str,
-    ) -> None:
-        """Save chat history and metadata for a project directory."""
-        data = {
-            "project_dir": str(Path(project_dir).resolve()),
-            "model_name": model_name,
-            "timestamp": time.time(),
-            "chat_history": chat_history,
-        }
-        path = self._session_path(project_dir)
-        try:
-            with open(path, "w", encoding="utf-8") as f:
-                json.dump(data, f, ensure_ascii=False, indent=2)
-            log.debug(f"Session saved to {path}")
-        except Exception as e:
-            log.error(f"Failed to save session: {e}")
-
-    def load_session(self, project_dir: str) -> Optional[Dict[str, Any]]:
-        """Load a saved session for a project directory, or None."""
-        path = self._session_path(project_dir)
-        if not path.exists():
-            return None
-        try:
-            with open(path, "r", encoding="utf-8") as f:
-                data = json.load(f)
-            log.info(f"Session loaded from {path}")
-            return data
-        except Exception as e:
-            log.error(f"Failed to load session: {e}")
-            return None
-
-    def delete_session(self, project_dir: str) -> bool:
-        """Delete a saved session. Returns True if one was deleted."""
-        path = self._session_path(project_dir)
-        if path.exists():
-            path.unlink()
-            log.info(f"Session deleted: {path}")
-            return True
-        return False
-
-    def list_sessions(self) -> List[Dict[str, Any]]:
-        """List all saved sessions with metadata."""
-        sessions = []
-        for p in SESSIONS_DIR.glob("*.json"):
-            try:
-                with open(p, "r", encoding="utf-8") as f:
-                    data = json.load(f)
-                sessions.append(
-                    {
-                        "project_dir": data.get("project_dir", "?"),
-                        "model_name": data.get("model_name", "?"),
-                        "timestamp": data.get("timestamp", 0),
-                        "message_count": len(data.get("chat_history", [])),
-                    }
-                )
-            except Exception:
-                continue
-        sessions.sort(key=lambda s: s["timestamp"], reverse=True)
-        return sessions