Merge pull request #118 from supreme-gg-gg/feat/message-summary

[feature] chat history summarization and command result display

Author: endernoke

README.md

@@ -107,9 +107,6 @@ The chat interface is the main feature of this package. It allows you to interac
 
 In the chat list page, use arrow keys (or 'j', 'k') + Enter to select a chat. You can also search for user by username using @user_name + Enter.
 
-> [!NOTE]
-> Chat commands (prefixed with `:`) are NOT available in the chat menu page. You must enter a chat to use chat commands.
-
 After entering the chat page, you can type messages as usual and send them with Enter. You can also use chat commands to supercharge your chat experience.
 
 > [!TIP]
@@ -136,9 +133,11 @@ All chat commands have the following syntax:
 - `:delay <seconds> "<message>"`: delay sending the message, similar as schedule
 - `:cancel`: cancel the latest scheduled/delayed message
 - `:upload`: upload media using the file navigator
-- `:upload <path>`: upload media (photo or video) directly from path
+- `:upload <path?>`: upload media (photo or video) directly from path
+- `:config <key?>=<value?>`: an in-chat version of `instagram config`
 - `:view <index>`: view and download media at index or open URL directly in browser
 - `:latex $<expr>$`: render and send LaTeX code as image, see [latex](#latex)
+- `:summarize <depth?>`: generate a summary of chat history using an LLM, see [chat summarization](#chat-summarization)
 
 ### Emoji
 
@@ -150,7 +149,7 @@ will be rendered as
 
 `This is an emoji 👍`
 
-> ![TIP]
+> [!TIP]
 > This does not have to be an exact match with the emoji name. For example, `:thumbsup:` can also be written as `:thumbs_up:`.
 
 ### LaTeX
@@ -171,6 +170,37 @@ Please note that the LaTeX code **_MUST_** be enclosed in `$` symbols.
 
 You can choose to render with [online API](https://latex.codecogs.com) (default) or local LaTeX installation such as TeX Live, MiKTeX, etc. You can set the rendering method with `instagram config --set latex_rendering_method <online|local>`.
 
+### Chat Summarization
+
+You can generate a summary of the chat history using the `:summarize` command. This will create a concise summary of the conversation, highlighting key points and important information.
+
+Local LLMs are first-class citizens here, allowing for maximum privacy and flexibility. All you need is a local LLM inferencing server like [Ollama](https://ollama.com/), [LM Studio](https://lmstudio.ai/). You will need to specify `llm.endpoint` (OpenAI-compatible) and `llm.model` in the config. For example, for Ollama, this would likely be:
+
+```plaintext
+http://localhost:11434/v1/
+```
+
+You can do this with `instagram config --set llm.endpoint <URL>` and `instagram config --set llm.model <MODEL_NAME>`.
+
+Once inside a chat conversation, you can summarize the chat history using:
+
+```plaintext
+:summarize
+```
+
+This will process all messages fetched in the current chat.
+
+To limit (or expand) the summarization to the `n` most recent messages:
+
+```plaintext
+:summarize n
+```
+
+You can also turn on streaming mode with `instagram config --set llm.stream True` to see the summary being generated in real-time.
+
+> [!TIP]
+> If you don't mind giving your data to AI companies, you may set the `llama.endpoint` and `llm.model` configs to a remote endpoint, e.g. `https://api.openai.com/v1/`, `gpt-5`.
+
 ### Scheduling Messages
 
 You can schedule messages to be sent at a later time. The syntax is as follows:

instagram/chat_ui/components/chat_window.py

@@ -1,5 +1,5 @@
 import curses
-from typing import List
+from typing import List, Optional
 from ..utils.types import LineInfo, ChatMode
 from instagram.api import MessageInfo
 from instagram.configs import Config
@@ -20,6 +20,7 @@ def __init__(self, window, height: int, width: int):
         self.scroll_offset = 0
         self.visible_messages_range = None
         self.visible_lines_range = None
+        self.custom_content: Optional[str] = None
 
     def set_messages(
         self, messages: List[MessageInfo]
@@ -28,6 +29,16 @@ def set_messages(
         self.messages = messages
         self._build_message_lines()
 
+    def set_custom_content(self, content: str):
+        """Set custom content to be displayed in the chat window."""
+        self.custom_content = content
+        self.update()
+
+    def clear_custom_content(self):
+        """Clear custom content."""
+        self.custom_content = None
+        self.update()
+
     def _build_message_lines(self):
         """
         Build wrapped lines for chat messages with word wrapping and formatting.
@@ -142,7 +153,23 @@ def update(self):
         - Basic word wrapping
         - Colored sender names
         - Replies and reactions
+
+        If custom content is set, it overrides the default message rendering.
         """
+        if self.custom_content:
+            self.window.erase()
+            content_lines = []
+            for raw_line in self.custom_content.split("\n"):
+                while len(raw_line) > self.width:
+                    content_lines.append(raw_line[: self.width])
+                    raw_line = raw_line[self.width :]
+                content_lines.append(raw_line)
+            # Only display up to available height
+            for i, line in enumerate(content_lines[: self.height]):
+                self.window.addstr(i, 0, line[: self.width])
+            self.window.refresh()
+            return
+
         if not self.messages:
             return
 

instagram/chat_ui/components/status_bar.py

@@ -38,7 +38,10 @@ def update(self, msg: str = None, override_default: bool = False):
             status_text = "[UNSEND] Use ↑↓ to select, Enter to confirm, Esc to exit"
         elif self.mode == ChatMode.COMMAND:
             self.window.bkgd(" ", curses.color_pair(2))
-            status_text = f"[COMMAND] Command {msg} executed. Press any key to continue"
+            status_text = f"[COMMAND] Executing command {msg if msg else '...'}"
+        elif self.mode == ChatMode.COMMAND_RESULT:
+            self.window.bkgd(" ", curses.color_pair(2))
+            status_text = "[COMMAND RESULT] Press any key to return to chat"
         else:
             status_text = "Georgian mode"
 

instagram/chat_ui/interface/chat_interface.py

@@ -1,5 +1,6 @@
 import curses
 import threading
+import inspect
 from ..components.input_box import InputBox
 from ..components.chat_window import ChatWindow
 from ..components.status_bar import StatusBar
@@ -166,7 +167,6 @@ def handle_input(self) -> Signal:
                         if result[1] == ":":
                             result = result[1:]
                         else:
-                            self.set_mode(ChatMode.COMMAND)
                             return self._handle_command(result[1:])
 
                     return self._handle_chat_message(result)
@@ -257,21 +257,26 @@ def _handle_command(self, command: str) -> Signal:
         """
         Executes a command, listen for special return signals or display the result.
         """
+        # Show command execution status
         self.set_mode(ChatMode.COMMAND)
+        self.status_bar.update(msg=command)
+
+        # Execute the command
         result = cmd_registry.execute(
             command, chat=self.direct_chat, screen=self.screen
         )
 
-        # Handle config changes command
-        if isinstance(result, dict):
-            for key, value in result.items():
-                if Config().get(f"chat.{key}"):
-                    Config().set(f"chat.{key}", value)
-            self.chat_window.update()
+        # If result is a generator, stream the output
+        if inspect.isgenerator(result):
+            self.set_mode(ChatMode.COMMAND_RESULT)
+            self.status_bar.update(msg=command)
+            self._display_streaming_command_result(result)
             self.set_mode(ChatMode.CHAT)
+            self.chat_window.update()
+            self.status_bar.update()
             return Signal.CONTINUE
 
-        # Handle special return signals
+        # Otherwise, the result is a string and we handle special return signals first
         elif result == "__QUIT__":
             self.stop_refresh.set()
             return Signal.QUIT
@@ -406,24 +411,46 @@ def _handle_command(self, command: str) -> Signal:
 
         # Regular command result display
         else:
+            # Display result and wait for key press
+            self.set_mode(ChatMode.COMMAND_RESULT)
             self.status_bar.update(msg=command)
             self._display_command_result(result)
-            curses.napms(1000)
             self.set_mode(ChatMode.CHAT)
+            self.chat_window.update()
             self.status_bar.update()
             return Signal.CONTINUE
 
     def _display_command_result(self, result: str):
         """
         Display the text result of a command in the chat window.
+        This is a blocking operation that waits for user key press.
         """
-        # TODO: Move this to chat window class
-        self.chat_window.window.erase()
-        lines = result.split("\n")
-        for idx, line in enumerate(lines):
-            if idx < self.height - 5:
-                self.chat_window.window.addstr(idx, 0, line[: self.width - 1])
-        self.chat_window.window.refresh()
+        self.chat_window.set_custom_content(result)
+        # Clear any buffered input that occurred during command execution
+        curses.flushinp()
+        # Handle command result mode - wait for any key press
+        self.screen.get_wch()  # Wait for any key press
+        self.chat_window.clear_custom_content()  # Clear content after display
+
+    def _display_streaming_command_result(self, result_generator):
+        """
+        Display the streaming text result of a command in the chat window.
+        """
+        self.chat_window.set_custom_content("")
+        curses.flushinp()
+        full_response = ""
+        try:
+            for chunk in result_generator:
+                full_response += chunk
+                self.chat_window.set_custom_content(full_response)
+                self.chat_window.update()
+        except Exception as e:
+            self.status_bar.update(f"Streaming error: {e}", override_default=True)
+            curses.napms(2000)
+
+        # After streaming is complete, wait for a key press to exit
+        self.screen.get_wch()
+        self.chat_window.clear_custom_content()
 
     def _handle_chat_message(self, message: str) -> Signal:
         """