thinking-prompt 0.1.0__tar.gz

thinking_prompt-0.1.0/.gitignore

@@ -0,0 +1,75 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# macOS
+.DS_Store
+
+# Project specific
+notes/
+plans/
+.claude/
+claude.md
+GEMINI.md
+

thinking_prompt-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+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.

thinking_prompt-0.1.0/PKG-INFO

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: thinking-prompt
+Version: 0.1.0
+Summary: A prompt_toolkit extension that adds a thinking box above the prompt
+Project-URL: Homepage, https://github.com/shoom1/thinking-prompt
+Project-URL: Repository, https://github.com/shoom1/thinking-prompt
+Author: Andrey Shiryaev
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,cli,prompt_toolkit,terminal,thinking
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Terminals
+Requires-Python: >=3.9
+Requires-Dist: prompt-toolkit>=3.0.0
+Provides-Extra: all
+Requires-Dist: pygments>=2.0; extra == 'all'
+Requires-Dist: rich>=13.0; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: rich
+Requires-Dist: rich>=13.0; extra == 'rich'
+Description-Content-Type: text/markdown
+
+# thinking-prompt
+
+A prompt_toolkit extension that adds a "thinking box" above the prompt for displaying AI thinking/processing content with real-time streaming updates.
+
+![Demo](docs/demo.gif)
+
+## Features
+
+- **Thinking Box**: A collapsible area above the prompt that shows processing/thinking content
+- **Real-time Streaming**: Content updates in real-time as your callback returns new content
+- **Fullscreen Mode**: Optional fullscreen mode with chat history (disabled by default)
+- **Animated Separator**: Configurable animated indicator showing thinking is in progress
+- **Rich Output**: Support for markdown rendering and syntax-highlighted code blocks
+- **Customizable Styles**: Full control over colors and styling
+
+## Installation
+
+```bash
+pip install thinking-prompt
+```
+
+For markdown and code highlighting support:
+```bash
+pip install thinking-prompt[all]
+```
+
+## Quick Start
+
+```python
+import asyncio
+from thinking_prompt import ThinkingPromptSession, AppInfo
+
+async def main():
+    app_info = AppInfo(name="MyApp", version="1.0.0")
+    session = ThinkingPromptSession(app_info=app_info, message=">>> ")
+
+    @session.on_input
+    async def handle(text: str):
+        if not text.strip():
+            return
+
+        # Use context manager for clean thinking management
+        async with session.thinking() as content:
+            content.append("Processing...\n")
+            await asyncio.sleep(0.5)
+            content.append("Done!\n")
+
+        session.add_response(f"You said: {text}")
+
+    await session.run_async()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Key Bindings
+
+| Key | Action |
+|-----|--------|
+| Ctrl+T | Expand/collapse thinking box (in prompt mode) |
+| Ctrl+E | Toggle fullscreen mode (when enabled) |
+| Ctrl+C | Cancel current operation or exit |
+| Ctrl+D | Exit application |
+
+## API Reference
+
+### ThinkingPromptSession
+
+The main class for creating a thinking-enabled prompt session.
+
+```python
+session = ThinkingPromptSession(
+    message=">>> ",              # Prompt message
+    app_info=AppInfo(...),       # App metadata and configuration
+    max_thinking_height=15,      # Max lines when collapsed
+    enable_status_bar=True,      # Show status bar
+    echo_input=True,             # Echo user input to console
+)
+```
+
+### Thinking API
+
+**Context Manager (recommended):**
+```python
+async with session.thinking() as content:
+    content.append("Step 1...\n")
+    await asyncio.sleep(0.5)
+    content.append("Step 2...\n")
+# Automatically finishes when exiting context
+```
+
+**Manual control:**
+```python
+# Start with a content callback
+chunks = []
+session.start_thinking(lambda: ''.join(chunks))
+
+chunks.append("Processing...\n")
+await asyncio.sleep(0.5)
+
+# Finish and optionally echo to console
+session.finish_thinking(add_to_history=True, echo_to_console=True)
+```
+
+### Output Methods
+
+```python
+# Plain text response
+session.add_response("Hello, world!")
+
+# Markdown (requires rich)
+session.add_response("# Title\n- Item 1\n- Item 2", markdown=True)
+
+# Syntax-highlighted code (requires pygments)
+session.add_code("def hello(): return 'world'", language="python")
+
+# Status messages
+session.add_success("Operation completed")
+session.add_warning("Rate limit approaching")
+session.add_error("Connection failed")
+session.add_message("system", "Connecting to server...")
+```
+
+### AppInfo Configuration
+
+```python
+app_info = AppInfo(
+    name="MyApp",
+    version="1.0.0",
+    welcome_message="Welcome to MyApp!",  # Optional custom welcome
+
+    # Key bindings
+    fullscreen_key="c-e",        # Ctrl+E for fullscreen
+    expand_key="c-t",            # Ctrl+T for expand/collapse
+
+    # Feature flags
+    fullscreen_enabled=False,    # Enable fullscreen mode
+    echo_thinking=True,          # Echo thinking to console after completion
+
+    # Thinking animation
+    thinking_text="Thinking",    # Text in separator
+    thinking_animation=("⠋", "⠙", "⠹", ...),  # Animation frames
+    thinking_animation_position="before",      # "before" or "after" text
+)
+```
+
+## Examples
+
+See the `examples/` directory for complete demos:
+
+- `basic.py` - Simple thinking box usage
+- `demo.py` - Interactive demo with simulated AI thinking
+- `streaming.py` - Character-by-character streaming
+- `progress_demo.py` - Progress bar with callback
+- `demo_progress_line.py` - In-place progress updates
+- `demo_messages_during_thinking.py` - Output messages during thinking
+- `demo_animated_separator.py` - Different animation configurations
+
+## License
+
+MIT

thinking_prompt-0.1.0/README.md

@@ -0,0 +1,161 @@
+# thinking-prompt
+
+A prompt_toolkit extension that adds a "thinking box" above the prompt for displaying AI thinking/processing content with real-time streaming updates.
+
+![Demo](docs/demo.gif)
+
+## Features
+
+- **Thinking Box**: A collapsible area above the prompt that shows processing/thinking content
+- **Real-time Streaming**: Content updates in real-time as your callback returns new content
+- **Fullscreen Mode**: Optional fullscreen mode with chat history (disabled by default)
+- **Animated Separator**: Configurable animated indicator showing thinking is in progress
+- **Rich Output**: Support for markdown rendering and syntax-highlighted code blocks
+- **Customizable Styles**: Full control over colors and styling
+
+## Installation
+
+```bash
+pip install thinking-prompt
+```
+
+For markdown and code highlighting support:
+```bash
+pip install thinking-prompt[all]
+```
+
+## Quick Start
+
+```python
+import asyncio
+from thinking_prompt import ThinkingPromptSession, AppInfo
+
+async def main():
+    app_info = AppInfo(name="MyApp", version="1.0.0")
+    session = ThinkingPromptSession(app_info=app_info, message=">>> ")
+
+    @session.on_input
+    async def handle(text: str):
+        if not text.strip():
+            return
+
+        # Use context manager for clean thinking management
+        async with session.thinking() as content:
+            content.append("Processing...\n")
+            await asyncio.sleep(0.5)
+            content.append("Done!\n")
+
+        session.add_response(f"You said: {text}")
+
+    await session.run_async()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Key Bindings
+
+| Key | Action |
+|-----|--------|
+| Ctrl+T | Expand/collapse thinking box (in prompt mode) |
+| Ctrl+E | Toggle fullscreen mode (when enabled) |
+| Ctrl+C | Cancel current operation or exit |
+| Ctrl+D | Exit application |
+
+## API Reference
+
+### ThinkingPromptSession
+
+The main class for creating a thinking-enabled prompt session.
+
+```python
+session = ThinkingPromptSession(
+    message=">>> ",              # Prompt message
+    app_info=AppInfo(...),       # App metadata and configuration
+    max_thinking_height=15,      # Max lines when collapsed
+    enable_status_bar=True,      # Show status bar
+    echo_input=True,             # Echo user input to console
+)
+```
+
+### Thinking API
+
+**Context Manager (recommended):**
+```python
+async with session.thinking() as content:
+    content.append("Step 1...\n")
+    await asyncio.sleep(0.5)
+    content.append("Step 2...\n")
+# Automatically finishes when exiting context
+```
+
+**Manual control:**
+```python
+# Start with a content callback
+chunks = []
+session.start_thinking(lambda: ''.join(chunks))
+
+chunks.append("Processing...\n")
+await asyncio.sleep(0.5)
+
+# Finish and optionally echo to console
+session.finish_thinking(add_to_history=True, echo_to_console=True)
+```
+
+### Output Methods
+
+```python
+# Plain text response
+session.add_response("Hello, world!")
+
+# Markdown (requires rich)
+session.add_response("# Title\n- Item 1\n- Item 2", markdown=True)
+
+# Syntax-highlighted code (requires pygments)
+session.add_code("def hello(): return 'world'", language="python")
+
+# Status messages
+session.add_success("Operation completed")
+session.add_warning("Rate limit approaching")
+session.add_error("Connection failed")
+session.add_message("system", "Connecting to server...")
+```
+
+### AppInfo Configuration
+
+```python
+app_info = AppInfo(
+    name="MyApp",
+    version="1.0.0",
+    welcome_message="Welcome to MyApp!",  # Optional custom welcome
+
+    # Key bindings
+    fullscreen_key="c-e",        # Ctrl+E for fullscreen
+    expand_key="c-t",            # Ctrl+T for expand/collapse
+
+    # Feature flags
+    fullscreen_enabled=False,    # Enable fullscreen mode
+    echo_thinking=True,          # Echo thinking to console after completion
+
+    # Thinking animation
+    thinking_text="Thinking",    # Text in separator
+    thinking_animation=("⠋", "⠙", "⠹", ...),  # Animation frames
+    thinking_animation_position="before",      # "before" or "after" text
+)
+```
+
+## Examples
+
+See the `examples/` directory for complete demos:
+
+- `basic.py` - Simple thinking box usage
+- `demo.py` - Interactive demo with simulated AI thinking
+- `streaming.py` - Character-by-character streaming
+- `progress_demo.py` - Progress bar with callback
+- `demo_progress_line.py` - In-place progress updates
+- `demo_messages_during_thinking.py` - Output messages during thinking
+- `demo_animated_separator.py` - Different animation configurations
+
+## License
+
+MIT

thinking_prompt-0.1.0/examples/basic.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""
+Basic example demonstrating the ThinkingPromptSession.
+
+Run this script to see the thinking box in action:
+    python examples/basic.py
+"""
+import asyncio
+
+from thinking_prompt import ThinkingPromptSession, AppInfo
+
+
+async def main():
+    """Main async function demonstrating thinking box features."""
+    app_info = AppInfo(name="BasicDemo", version="1.0.0")
+    session = ThinkingPromptSession(
+        app_info=app_info,
+        message=">>> ",
+        max_thinking_height=10,
+    )
+
+    @session.on_input
+    async def handle(text: str):
+        """Handle user input with simulated thinking."""
+        if not text.strip():
+            return
+
+        # Use a list for O(1) append
+        chunks = []
+
+        def get_content():
+            return ''.join(chunks)
+
+        # Start thinking mode with content callback
+        session.start_thinking(get_content)
+
+        # Update thinking box with streaming content
+        chunks.append("Processing your input...\n")
+        await asyncio.sleep(0.3)
+
+        # Simulate token-by-token processing
+        words = text.split()
+        for i, word in enumerate(words):
+            chunks.append(f"  Token {i + 1}: {word}\n")
+            await asyncio.sleep(0.15)
+
+        chunks.append("\nAnalysis complete!\n")
+        await asyncio.sleep(0.5)
+
+        # Finish thinking - content moves to console
+        session.finish_thinking()
+
+        # Add response to chat history
+        session.add_response(f"You entered {len(words)} word(s): {text}")
+
+    # Run the session
+    await session.run_async()
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass

thinking_prompt-0.1.0/examples/chat_demo.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""
+Chat-like demo of ThinkingPromptSession.
+
+This example demonstrates:
+- Welcome message display at startup
+- Decorator-style handler registration
+- Thinking box appearing above the prompt during processing
+- Real-time streaming updates in the thinking box
+- Expand/collapse thinking box with Ctrl+T
+
+Run:
+    python examples/chat_demo.py
+"""
+import asyncio
+
+from thinking_prompt import ThinkingPromptSession, AppInfo
+
+
+async def main():
+    app_info = AppInfo(name="ChatDemo", version="1.0.0")
+    session = ThinkingPromptSession(
+        app_info=app_info,
+        message="You: ",
+        max_thinking_height=5,
+        status_text="Ctrl+C: cancel | Ctrl+D: exit",
+    )
+
+    @session.on_input
+    async def handle(user_input: str):
+        """Process user input with simulated thinking."""
+        if not user_input.strip():
+            return
+
+        # Use a list for O(1) append
+        chunks = []
+
+        def get_content():
+            return ''.join(chunks)
+
+        # Start thinking mode
+        session.start_thinking(get_content)
+
+        # Phase 1: Initial analysis
+        chunks.append("Analyzing your input...\n")
+        await asyncio.sleep(0.4)
+
+        # Phase 2: Show what we're processing
+        chunks.append(f"Received: \"{user_input}\"\n")
+        await asyncio.sleep(0.3)
+
+        # Phase 3: Simulated reasoning steps (more than max_thinking_height to show truncation)
+        steps = [
+            "Step 1: Parsing input...",
+            "Step 2: Tokenizing text...",
+            "Step 3: Analyzing semantics...",
+            "Step 4: Processing concepts...",
+            "Step 5: Building context...",
+            "Step 6: Generating candidates...",
+            "Step 7: Ranking responses...",
+            "Step 8: Selecting best response...",
+        ]
+
+        for step in steps:
+            chunks.append(f"  {step}\n")
+            await asyncio.sleep(0.3)
+
+        # Phase 4: Done
+        chunks.append("\nDone.\n")
+        await asyncio.sleep(0.3)
+
+        # Finish thinking - adds thinking content to history
+        session.finish_thinking()
+
+        # Add the actual response (separate from thinking)
+        response = f"I understood your message: '{user_input[:50]}{'...' if len(user_input) > 50 else ''}'"
+        session.add_response(response)
+
+    # Run the session - handler already registered with @on_input
+    await session.run_async()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

thinking_prompt-0.1.0/examples/demo.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""
+Interactive demo of ThinkingPromptSession.
+
+This example simulates an AI assistant that "thinks" before responding.
+The thinking box appears after you enter input, updates in real-time,
+and then transitions to permanent console output.
+
+Run:
+    python examples/demo.py
+"""
+import asyncio
+
+from thinking_prompt import ThinkingPromptSession, AppInfo
+
+
+async def main():
+    app_info = AppInfo(name="InteractiveDemo", version="1.0.0")
+    session = ThinkingPromptSession(
+        app_info=app_info,
+        message="You: ",
+        max_thinking_height=12,
+    )
+
+    @session.on_input
+    async def handle(user_input: str):
+        """Process user input with simulated thinking."""
+        if not user_input.strip():
+            return
+
+        # Use a list for O(1) append
+        chunks = []
+
+        def get_content():
+            return ''.join(chunks)
+
+        # Start thinking mode
+        session.start_thinking(get_content)
+
+        # Update thinking box in real-time
+        chunks.append("Analyzing your input...\n")
+        await asyncio.sleep(0.4)
+
+        chunks.append(f"Input received: \"{user_input}\"\n\n")
+        await asyncio.sleep(0.3)
+
+        # Simulated reasoning steps
+        steps = [
+            "Step 1: Parsing input structure...",
+            "Step 2: Identifying key concepts...",
+            "Step 3: Generating response...",
+        ]
+
+        for step in steps:
+            chunks.append(f"{step}\n")
+            await asyncio.sleep(0.5)
+
+        # Stream the "response" character by character
+        chunks.append("\nResponse: ")
+        await asyncio.sleep(0.2)
+
+        preview = user_input[:30] + ('...' if len(user_input) > 30 else '')
+        response = f"I understood your message about '{preview}'"
+        for char in response:
+            chunks.append(char)
+            await asyncio.sleep(0.03)
+
+        chunks.append("\n")
+        await asyncio.sleep(0.3)
+
+        # Finish - content is printed to console (if not in fullscreen)
+        session.finish_thinking()
+
+        # Add response to chat history
+        session.add_response(response)
+
+    # Run the session with the registered handler
+    await session.run_async()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())