chatrepl 0.1.0a0__tar.gz

chatrepl-0.1.0a0/LICENSE

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

chatrepl-0.1.0a0/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: chatrepl
+Version: 0.1.0a0
+Summary: A Python 2.7+ REPL for interacting with LLMs with an OpenAI Chat Completions-compatible API.
+Author-email: Jifeng Wu <jifengwu2k@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jifengwu2k/chatrepl
+Project-URL: Bug Tracker, https://github.com/jifengwu2k/chatrepl/issues
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=2
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+A Python 2.7+ REPL for interacting with LLMs with an OpenAI Chat Completions-compatible API.
+
+## Features
+
+- **Zero Dependencies:** Works with stock Python 2.7+ and 3.x
+- **Interactive Chat:** Natural REPL interface with conversation tracking
+- **Streaming Responses:** See responses as they're generated
+- **Multiline Input:** Support for complex prompts with `:multiline`
+- **File Integration:** Load prompts from text files with `:send <textfile>`
+- **Conversation Persistence:** Save/load complete conversations in JSON format
+- **Enhanced Input:** Optional readline support for history and line editing
+- **Dual Modes:** Both interactive REPL and pipe-friendly CLI
+
+## Interactive Mode
+
+```bash
+$ python -m terminal_chat \
+  --api-key "your-api-key" \
+  --base-url "https://api.openai.com/v1" \
+  --model "gpt-4o"
+```
+
+### Basic Conversation
+
+```text
+User [1]: Explain recursion to a 5-year-old
+
+Assistant [1]: Imagine you're holding a doll that has...
+```
+
+### Using Files
+```text
+User [2]: :send code.py
+Assistant [2]: I notice this Python code could be improved...
+
+User [3]: :save review_chat.json
+```
+
+### Multiline Input
+
+```text
+User [4]: :multiline
+Enter EOF on a blank line to finish input:
+> Compare these programming languages:
+> 1. Python
+> 2. Rust
+> 3. Go
+> [Ctrl-D]
+
+Assistant [4]: Here's a comparison:
+1. Python - High-level, interpreted...
+2. Rust - Systems programming...
+3. Go - Compiled, concurrent...
+```
+
+## Non-interactive Mode (Piped Input)
+
+```bash
+$ uname -a | python -m terminal_chat --api-key <your_api_key> --base-url <your_base_url> --model <model_name>
+The output you've provided appears to be system information from ... [output streamed to STDOUT]
+```
+
+## Print Saved Conversations
+
+```bash
+$ python -m terminal_chat --print conversation.json
+User [1]: ...
+
+Assistant [1]: ...
+```
+
+## Interactive Commands
+
+- `:multiline` - Enter multiline input mode (end with blank line + Ctrl-D)
+- `:send TEXTFILE` - Send contents of TEXTFILE
+- `:load JSONFILE` - Load conversation from JSONFILE
+- `:save JSONFILE` - Save conversation to JSONFILE
+- `:help` - Show help
+- `:quit` or `Ctrl-D` - Exit the program
+
+## Best Practices
+
+1. For long sessions, periodically save with `:save`
+2. Use `:multiline` for structured prompts (lists, code, etc.)
+3. JSON files can be edited manually for prompt engineering
+
+## Contributing
+
+Contributions are welcome! Please submit pull requests or open issues on the GitHub repository.
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

chatrepl-0.1.0a0/README.md

@@ -0,0 +1,93 @@
+A Python 2.7+ REPL for interacting with LLMs with an OpenAI Chat Completions-compatible API.
+
+## Features
+
+- **Zero Dependencies:** Works with stock Python 2.7+ and 3.x
+- **Interactive Chat:** Natural REPL interface with conversation tracking
+- **Streaming Responses:** See responses as they're generated
+- **Multiline Input:** Support for complex prompts with `:multiline`
+- **File Integration:** Load prompts from text files with `:send <textfile>`
+- **Conversation Persistence:** Save/load complete conversations in JSON format
+- **Enhanced Input:** Optional readline support for history and line editing
+- **Dual Modes:** Both interactive REPL and pipe-friendly CLI
+
+## Interactive Mode
+
+```bash
+$ python -m terminal_chat \
+  --api-key "your-api-key" \
+  --base-url "https://api.openai.com/v1" \
+  --model "gpt-4o"
+```
+
+### Basic Conversation
+
+```text
+User [1]: Explain recursion to a 5-year-old
+
+Assistant [1]: Imagine you're holding a doll that has...
+```
+
+### Using Files
+```text
+User [2]: :send code.py
+Assistant [2]: I notice this Python code could be improved...
+
+User [3]: :save review_chat.json
+```
+
+### Multiline Input
+
+```text
+User [4]: :multiline
+Enter EOF on a blank line to finish input:
+> Compare these programming languages:
+> 1. Python
+> 2. Rust
+> 3. Go
+> [Ctrl-D]
+
+Assistant [4]: Here's a comparison:
+1. Python - High-level, interpreted...
+2. Rust - Systems programming...
+3. Go - Compiled, concurrent...
+```
+
+## Non-interactive Mode (Piped Input)
+
+```bash
+$ uname -a | python -m terminal_chat --api-key <your_api_key> --base-url <your_base_url> --model <model_name>
+The output you've provided appears to be system information from ... [output streamed to STDOUT]
+```
+
+## Print Saved Conversations
+
+```bash
+$ python -m terminal_chat --print conversation.json
+User [1]: ...
+
+Assistant [1]: ...
+```
+
+## Interactive Commands
+
+- `:multiline` - Enter multiline input mode (end with blank line + Ctrl-D)
+- `:send TEXTFILE` - Send contents of TEXTFILE
+- `:load JSONFILE` - Load conversation from JSONFILE
+- `:save JSONFILE` - Save conversation to JSONFILE
+- `:help` - Show help
+- `:quit` or `Ctrl-D` - Exit the program
+
+## Best Practices
+
+1. For long sessions, periodically save with `:save`
+2. Use `:multiline` for structured prompts (lists, code, etc.)
+3. JSON files can be edited manually for prompt engineering
+
+## Contributing
+
+Contributions are welcome! Please submit pull requests or open issues on the GitHub repository.
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

chatrepl-0.1.0a0/chatrepl.egg-info/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: chatrepl
+Version: 0.1.0a0
+Summary: A Python 2.7+ REPL for interacting with LLMs with an OpenAI Chat Completions-compatible API.
+Author-email: Jifeng Wu <jifengwu2k@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jifengwu2k/chatrepl
+Project-URL: Bug Tracker, https://github.com/jifengwu2k/chatrepl/issues
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=2
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+A Python 2.7+ REPL for interacting with LLMs with an OpenAI Chat Completions-compatible API.
+
+## Features
+
+- **Zero Dependencies:** Works with stock Python 2.7+ and 3.x
+- **Interactive Chat:** Natural REPL interface with conversation tracking
+- **Streaming Responses:** See responses as they're generated
+- **Multiline Input:** Support for complex prompts with `:multiline`
+- **File Integration:** Load prompts from text files with `:send <textfile>`
+- **Conversation Persistence:** Save/load complete conversations in JSON format
+- **Enhanced Input:** Optional readline support for history and line editing
+- **Dual Modes:** Both interactive REPL and pipe-friendly CLI
+
+## Interactive Mode
+
+```bash
+$ python -m terminal_chat \
+  --api-key "your-api-key" \
+  --base-url "https://api.openai.com/v1" \
+  --model "gpt-4o"
+```
+
+### Basic Conversation
+
+```text
+User [1]: Explain recursion to a 5-year-old
+
+Assistant [1]: Imagine you're holding a doll that has...
+```
+
+### Using Files
+```text
+User [2]: :send code.py
+Assistant [2]: I notice this Python code could be improved...
+
+User [3]: :save review_chat.json
+```
+
+### Multiline Input
+
+```text
+User [4]: :multiline
+Enter EOF on a blank line to finish input:
+> Compare these programming languages:
+> 1. Python
+> 2. Rust
+> 3. Go
+> [Ctrl-D]
+
+Assistant [4]: Here's a comparison:
+1. Python - High-level, interpreted...
+2. Rust - Systems programming...
+3. Go - Compiled, concurrent...
+```
+
+## Non-interactive Mode (Piped Input)
+
+```bash
+$ uname -a | python -m terminal_chat --api-key <your_api_key> --base-url <your_base_url> --model <model_name>
+The output you've provided appears to be system information from ... [output streamed to STDOUT]
+```
+
+## Print Saved Conversations
+
+```bash
+$ python -m terminal_chat --print conversation.json
+User [1]: ...
+
+Assistant [1]: ...
+```
+
+## Interactive Commands
+
+- `:multiline` - Enter multiline input mode (end with blank line + Ctrl-D)
+- `:send TEXTFILE` - Send contents of TEXTFILE
+- `:load JSONFILE` - Load conversation from JSONFILE
+- `:save JSONFILE` - Save conversation to JSONFILE
+- `:help` - Show help
+- `:quit` or `Ctrl-D` - Exit the program
+
+## Best Practices
+
+1. For long sessions, periodically save with `:save`
+2. Use `:multiline` for structured prompts (lists, code, etc.)
+3. JSON files can be edited manually for prompt engineering
+
+## Contributing
+
+Contributions are welcome! Please submit pull requests or open issues on the GitHub repository.
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

chatrepl-0.1.0a0/chatrepl.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+chatrepl.py
+pyproject.toml
+setup.cfg
+chatrepl.egg-info/PKG-INFO
+chatrepl.egg-info/SOURCES.txt
+chatrepl.egg-info/dependency_links.txt
+chatrepl.egg-info/top_level.txt

chatrepl-0.1.0a0/chatrepl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chatrepl-0.1.0a0/chatrepl.egg-info/top_level.txt

@@ -0,0 +1 @@
+chatrepl

chatrepl-0.1.0a0/chatrepl.py

@@ -0,0 +1,423 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from __future__ import print_function
+import argparse
+import codecs
+import getopt
+import io
+import json
+import os
+import os.path
+import sys
+
+# Python version compatibility setup
+if sys.version_info < (3,):
+    from urllib2 import Request, urlopen, URLError
+    text_type = unicode
+    binary_type = str
+
+    def unicode_input(prompt):
+        return raw_input(prompt).decode(sys.stdin.encoding)
+
+    open_with_encoding = codecs.open
+
+    def post_request_instance(url, data, headers):
+        return Request(url, data=data, headers=headers)
+else:
+    from urllib.request import Request, urlopen
+    from urllib.error import URLError
+    text_type = str
+    binary_type = bytes
+    unicode_input = input
+    open_with_encoding = open
+
+    def post_request_instance(url, data, headers):
+        return Request(url, data=data, headers=headers, method='POST')
+
+
+# Are we under interactive mode?
+IS_INTERACTIVE = sys.stdin.isatty()
+
+
+def sanitize(text):
+    return text.encode(sys.stdout.encoding, errors='ignore').decode(sys.stdout.encoding)
+
+
+def fputs(text, stream):
+    """Write text to a stream."""
+    try:
+        stream.write(text)
+        stream.flush()
+    except UnicodeEncodeError:
+        fputs(sanitize(text), stream)
+
+
+def perror(e):
+    fputs(u'%s: %s\n' % (type(e).__name__, e), sys.stderr)
+
+
+# Try to import readline under interactive mode
+if IS_INTERACTIVE:
+    try:
+        import readline
+    except ImportError as e:
+        readline = None
+        perror(e)
+        fputs(u"\nFailed to import readline. This will affect the command-line interface functionality:\n", sys.stderr)
+        fputs(u" - Line editing features (arrow keys, cursor movement) will be disabled\n", sys.stderr)
+        fputs(u" - Command history (up/down keys) will not be available\n", sys.stderr)
+        fputs(u"\nWhile the program will still run, the text input will be basic and limited.\n", sys.stderr)
+else:
+    readline = None
+
+
+def save_messages_to_file(messages, filename):
+    """Save chat messages to a JSON file."""
+    with open_with_encoding(filename, 'w', encoding='utf-8') as f:
+        json.dump(messages, f, indent=2, ensure_ascii=False)
+
+
+def load_messages_from_file(filename):
+    """Load chat messages from a JSON file."""
+    with open_with_encoding(filename, 'r', encoding='utf-8') as f:
+        loaded = json.load(f)
+        if isinstance(loaded, list) and all(
+            (
+                isinstance(message, dict)
+                and message.get(u'role', None) in (u'user', u'assistant')
+                and isinstance(message.get(u'content', None), text_type)
+            )
+            for message in loaded
+        ):
+            return loaded
+        else:
+            raise ValueError(u"Invalid JSON schema: Expected a list of dictionaries with keys 'role' ('user' or 'assistant') and 'content' (string). Got: %s" % loaded)
+
+
+def print_loaded_messages(loaded_message_list):
+    """Print all loaded messages.
+    Return number of user messages."""
+    num_user_messages_encountered = 0
+    
+    for message in loaded_message_list:
+        role = message[u'role']
+        content = message[u'content']
+        
+        if role == 'user':
+            num_user_messages_encountered += 1
+            
+        fputs(
+            u'\n%s [%i]: %s\n' % (
+                role.capitalize(),
+                num_user_messages_encountered,
+                content
+            ),
+            sys.stdout
+        )
+
+    return num_user_messages_encountered
+
+
+def read_file_content(filename):
+    """Read text_type content from a file."""
+    with open_with_encoding(filename, 'r', encoding='utf-8') as f:
+        return f.read()
+
+
+# Global message counter
+# Like IPython's message counter, incremented for non-empty user messages
+# Read in `get_single_message_content_from_model`
+# Written in `get_single_message_content_from_user`, `main`
+global_message_counter = 1
+
+
+# Model-facing functions
+def send_messages_to_model_and_stream_response(
+    api_key,
+    base_url,
+    model,
+    message_list
+):
+    """Send messages to the model using standard library HTTP requests."""
+    url = u"%s/chat/completions" % base_url
+    headers = {
+        u"Content-Type": u"application/json",
+        u"Authorization": u"Bearer %s" % api_key
+    }
+    data = json.dumps({
+        u"model": model,
+        u"messages": message_list,
+        u"stream": True
+    }).encode('utf-8')
+
+    req = post_request_instance(url, data=data, headers=headers)
+    response = urlopen(req)
+    for line in response:
+        if line.startswith(b"data: "):
+            chunk_data = line[6:].decode('utf-8').strip()  # Remove "data: " prefix
+            if chunk_data == u"[DONE]":
+                break
+            
+            chunk = json.loads(chunk_data)
+            content = chunk.get(u"choices", [{}])[0].get(u"delta", {}).get(u"content", "") or u""
+            yield content
+
+
+def get_single_message_content_from_model(
+    api_key,
+    base_url,
+    model,
+    message_list
+):
+    global global_message_counter
+    
+    fputs(
+        u'\nAssistant [%d]: ' % global_message_counter,
+        sys.stdout
+    )
+    
+    full_response = []
+    for response in send_messages_to_model_and_stream_response(
+        api_key,
+        base_url,
+        model,
+        message_list
+    ):
+        fputs(response, sys.stdout)
+        full_response.append(response)
+    
+    fputs(u'\n', sys.stdout)
+    
+    return u''.join(full_response)
+
+
+# User-facing functions
+def display_help():
+    fputs(u'\nEnter a message to send to the model or use one of the following commands:\n', sys.stdout)
+    fputs(u':multiline        Enter multiline input\n', sys.stdout)
+    fputs(u':send TEXTFILE    Send the contents of TEXTFILE\n', sys.stdout)
+    fputs(u':load JSONFILE    Load a conversation from JSONFILE\n', sys.stdout)
+    fputs(u':save JSONFILE    Save the conversation to JSONFILE\n', sys.stdout)
+    fputs(u':help             Display help\n', sys.stdout)
+    fputs(u':quit (or Ctrl-D) Exit the program\n', sys.stdout)
+
+
+def get_single_line_input(prompt=u'> '):
+    """Get a single-line input from the user."""
+    # Do NOT use unicode_input().
+    # When the user enters something and presses down BACKSPACE, the prompt is removed as well.
+    return unicode_input(prompt)
+
+
+def get_multi_line_input():
+    """Get multi-line input from the user until EOF."""
+    fputs(u'Enter EOF on a blank line to finish input:\n', sys.stdout)
+    lines = []
+    try:
+        while True:
+            line = get_single_line_input(u'> ')
+            lines.append(line)
+    except EOFError as e:
+        pass
+
+    return u'\n'.join(lines)
+
+
+def get_single_message_content_from_user(mutable_message_list):
+    global global_message_counter
+    
+    while True:
+        user_input = get_single_line_input(
+            u'\nUser [%d]: ' % global_message_counter
+        ).strip()
+
+        if user_input.startswith(u':'):
+            tokens = user_input.split()
+            cmd = tokens[0] if tokens else u""
+            args = tokens[1:]
+
+            # :multiline
+            if cmd == u":multiline" and not args:
+                content = get_multi_line_input()
+            # :send <textfile>
+            elif cmd == u":send" and len(args) == 1: 
+                try:
+                    content = read_file_content(args[0])
+                except Exception as e:
+                    perror(e)
+                    
+                    global_message_counter += 1
+                    continue
+            # :load <jsonfile>
+            elif cmd == u":load" and len(args) == 1:
+                try:
+                    loaded_messages = load_messages_from_file(args[0])
+                    fputs(u"Loaded conversation from %s:\n" % args[0], sys.stdout)
+                    
+                    last_message_counter = print_loaded_messages(loaded_messages)
+                    
+                    mutable_message_list[:] = loaded_messages
+                    global_message_counter = last_message_counter + 1
+                    continue
+                except Exception as e:
+                    perror(e)
+                    
+                    global_message_counter += 1
+                    continue
+            # :save <jsonfile>
+            elif cmd == u":save" and len(args) == 1:
+                try:
+                    save_messages_to_file(mutable_message_list, args[0])
+                    fputs(u"Conversation saved to %s\n" % args[0], sys.stdout)
+                except Exception as e:
+                    perror(e)
+                
+                global_message_counter += 1
+                continue
+            # :help
+            elif cmd == u":help" and not args:
+                display_help()
+
+                global_message_counter += 1
+                continue
+            # :quit
+            elif cmd == u":quit" and not args:
+                # Same as pressing Ctrl-D (sending EOF)
+                raise EOFError
+            else:
+                fputs(u"Unknown command.\n", sys.stdout)
+                display_help()
+                
+                global_message_counter += 1
+                continue
+        else:
+            content = user_input
+
+        # We do not allow content to be empty
+        if not content:
+            continue
+        
+        return content
+
+
+def main():
+    """Entry point for the chat interface."""
+    global global_message_counter
+    
+    # Create the parser
+    parser = argparse.ArgumentParser()
+
+    # Add arguments
+    parser.add_argument('--api-key', type=str, required=False, help='API key')
+    parser.add_argument('--base-url', type=str, required=False, help='Base URL')
+    parser.add_argument('--model', type=str, required=False, help='Model name')
+    parser.add_argument('--load', metavar='JSONFILE', type=str, required=False, help='Load a conversation from JSONFILE')
+    parser.add_argument('--print', metavar='JSONFILE', type=str, required=False, help='Print a saved conversation from JSONFILE and exit')
+
+    # Parse arguments
+    args = parser.parse_args()
+    
+    # Print a saved conversation from JSONFILE and exit
+    if args.print:
+        print_loaded_messages(load_messages_from_file(args.print))
+    else:
+        if (
+            not args.api_key
+            or not args.base_url
+            or not args.model
+        ):
+            parser.error('Must provide --api-key, --base-url, and --model when not printing a conversation using --print')
+        
+        # Initialize messages
+        if args.load:
+            messages = load_messages_from_file(args.load)
+        else:
+            messages = []
+    
+        # Non-interactive mode
+        if not IS_INTERACTIVE:
+            user_message_content = sys.stdin.read()
+            
+            if user_message_content:
+                messages.append(
+                    {
+                        u'role': 'user',
+                        u'content': user_message_content
+                    }
+                )
+                
+                for response in send_messages_to_model_and_stream_response(
+                    args.api_key,
+                    args.base_url,
+                    args.model,
+                    messages
+                ):
+                    fputs(response, sys.stdout)
+        
+            fputs(u'\n', sys.stdout)
+            
+        # Interactive mode
+        else:
+            # Read readline history file
+            if readline is not None:
+                histfile = os.path.join(os.path.expanduser("~"), ".chat_history")
+                try:
+                    readline.read_history_file(histfile)
+                except Exception:
+                    pass
+        
+            # Display greeting
+            fputs(
+                u'\nWelcome to Terminal Chat (Model: %s)\n' % args.model,
+                sys.stdout
+            )
+            display_help()
+            
+            # Main loop
+            while True:
+                try:
+                    user_message_content = get_single_message_content_from_user(
+                        messages
+                    )
+                    
+                    messages.append(
+                        {
+                            u'role': 'user',
+                            u'content': user_message_content
+                        }
+                    )
+                except EOFError:
+                    break
+                
+                try:
+                    assistant_message_content = get_single_message_content_from_model(
+                        args.api_key,
+                        args.base_url,
+                        args.model,
+                        messages
+                    )
+                    
+                    messages.append(
+                        {
+                            u'role': u'assistant',
+                            u'content': assistant_message_content
+                        }
+                    )
+                except URLError as e:
+                    perror(e)
+                    
+                    # Also remove the last user message
+                    messages.pop()
+                    
+                    # And skip incrementing global_message_counter
+                    continue
+                
+                global_message_counter += 1
+                
+            # Write readline history file before exiting
+            if readline is not None:
+                readline.write_history_file(histfile)
+
+
+if __name__ == "__main__":
+    main()

chatrepl-0.1.0a0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chatrepl"
+version = "0.1.0-alpha"
+description = "A Python 2.7+ REPL for interacting with LLMs with an OpenAI Chat Completions-compatible API."
+readme = "README.md"
+requires-python = ">=2"
+license = "MIT"
+authors = [
+  { name="Jifeng Wu", email="jifengwu2k@gmail.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 2",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+]
+
+[project.urls]
+"Homepage" = "https://github.com/jifengwu2k/chatrepl"
+"Bug Tracker" = "https://github.com/jifengwu2k/chatrepl/issues"

chatrepl-0.1.0a0/setup.cfg

@@ -0,0 +1,7 @@
+[bdist_wheel]
+universal = 1
+
+[egg_info]
+tag_build = 
+tag_date = 0
+