replio 0.5.0__py3-none-any.whl

replio/__main__.py

@@ -0,0 +1,3 @@
+from .main import main
+
+main()

replio/chat.py

@@ -0,0 +1,452 @@
+import sys
+import json
+import readline
+import os
+from datetime import datetime, timezone
+
+from .config import Config
+from .providers.ollama import OllamaProvider
+from .sessions.manager import SessionManager
+from .commands.registry import CommandRegistry
+from .commands.builtins import register_builtins
+
+HISTFILE = '.replio_history'
+
+
+class ChatLoop:
+    def __init__(self, config: Config):
+        self.config = config
+        self.provider = None
+        self._reinit_provider()
+
+        sessions_dir = config.local_path.parent / 'sessions'
+        self.sessions = SessionManager(sessions_dir)
+        self.current_session = self.sessions.create()
+        self._load_history(config)
+        self.registry = CommandRegistry(self)
+        register_builtins(self.registry)
+        self._setup_readline()
+
+    def _reinit_provider(self):
+        provider_name = self.config.get('provider', 'ollama')
+        if provider_name == 'ollama':
+            self.provider = OllamaProvider(
+                base_url=self.config.get('base_url'),
+                api_key=self.config.get('api_key'),
+                model=self.config.get('model'),
+                temperature=self.config.get('temperature'),
+                max_tokens=self.config.get('max_tokens'),
+            )
+        else:
+            print(f'Unknown provider "{provider_name}", falling back to ollama')
+            self.config.set('provider', 'ollama')
+            self._reinit_provider()
+
+    def _load_history(self, config):
+        hist = config.local_path.parent / HISTFILE
+        if hist.exists():
+            try:
+                readline.read_history_file(str(hist))
+            except OSError:
+                pass
+        readline.set_history_length(1000)
+
+    def _save_history(self):
+        hist = self.config.local_path.parent / HISTFILE
+        try:
+            hist.parent.mkdir(parents=True, exist_ok=True)
+            readline.write_history_file(str(hist))
+        except OSError:
+            pass
+
+    def _setup_readline(self):
+        commands = sorted(set(self.registry.commands.keys()))
+
+        def completer(text, state):
+            if text.startswith('/'):
+                options = [c for c in commands if c.startswith(text)]
+                if state < len(options):
+                    return options[state] + ' '
+            return None
+
+        readline.set_completer(completer)
+        readline.parse_and_bind('tab: complete')
+
+    def session_auto_save(self):
+        if self.current_session and self.current_session.messages:
+            self.sessions.save(self.current_session)
+
+    def run(self):
+        system_prompt = self.config.get('system_prompt', '')
+        if system_prompt:
+            self.current_session.add_message('system', system_prompt)
+
+        model_str = self.config.get('model', '?')
+        provider_str = self.config.get('provider', '?')
+        print(f'REPL.io ({provider_str}: {model_str})  /help for commands')
+
+        while True:
+            try:
+                line = input('\001\033[36m\002>>>\001\033[0m\002 ').strip()
+            except (EOFError, KeyboardInterrupt):
+                print()
+                self.session_auto_save()
+                self._save_history()
+                break
+
+            if not line:
+                continue
+
+            if line.startswith('/'):
+                self.current_session.add_message('command', line)
+                self.registry.dispatch(line)
+                self.session_auto_save()
+            else:
+                self._handle_message(line)
+
+        self._save_history()
+
+    def _stream_response(self) -> str | None:
+        messages = self.current_session.messages
+        full_response = ''
+        start = datetime.now(timezone.utc)
+        first_content = True
+        show_thinking = self.config.get('show_thinking', True)
+        thinking = False
+        md_state = {'code_block': False, 'inline_code': False, 'bold': False}
+
+        try:
+            for event in self.provider.chat(messages):
+                t = event.get('type', '')
+                if t == 'thinking':
+                    if show_thinking:
+                        if first_content:
+                            sys.stdout.write('\001\033[33m\002<<< \001\033[0m\002')
+                            sys.stdout.flush()
+                            first_content = False
+                        sys.stdout.write('\001\033[90m\002' + event['content'] + '\001\033[0m\002')
+                        sys.stdout.flush()
+                        full_response += event['content']
+                elif t == 'token':
+                    token = event['content']
+                    while token:
+                        if not thinking:
+                            idx = -1
+                            marker = ''
+                            for m in ('<thinking>',):
+                                pos = token.find(m)
+                                if pos != -1 and (idx == -1 or pos < idx):
+                                    idx = pos
+                                    marker = m
+                            if idx != -1:
+                                before = token[:idx]
+                                if before:
+                                    if first_content:
+                                        sys.stdout.write('\001\033[33m\002<<< \001\033[0m\002')
+                                        sys.stdout.flush()
+                                        first_content = False
+                                    sys.stdout.write(before)
+                                    sys.stdout.flush()
+                                    full_response += before
+                                if first_content:
+                                    sys.stdout.write('\001\033[33m\002<<< \001\033[0m\002')
+                                    sys.stdout.flush()
+                                    first_content = False
+                                if show_thinking:
+                                    sys.stdout.write('\001\033[90m\002' + marker + '\001\033[0m\002')
+                                    sys.stdout.flush()
+                                    full_response += marker
+                                token = token[idx + len(marker):]
+                                thinking = True
+                            else:
+                                if self.config.get('markdown_streaming'):
+                                    segments = self._render_token(token, md_state)
+                                    for text, ansi in segments:
+                                        if first_content:
+                                            sys.stdout.write('\001\033[33m\002<<< \001\033[0m\002')
+                                            sys.stdout.flush()
+                                            first_content = False
+                                        sys.stdout.write(f'\001{ansi}\002{text}\001\033[0m\002')
+                                        sys.stdout.flush()
+                                else:
+                                    if first_content:
+                                        sys.stdout.write('\001\033[33m\002<<< \001\033[0m\002')
+                                        sys.stdout.flush()
+                                        first_content = False
+                                    sys.stdout.write(token)
+                                    sys.stdout.flush()
+                                full_response += token
+                                token = ''
+                        else:
+                            closer = ''
+                            closer_pos = -1
+                            for c in ('</thinking>',):
+                                pos = token.find(c)
+                                if pos != -1 and (closer_pos == -1 or pos < closer_pos):
+                                    closer_pos = pos
+                                    closer = c
+                            if closer_pos != -1:
+                                before = token[:closer_pos]
+                                if before and show_thinking:
+                                    sys.stdout.write('\001\033[90m\002' + before + '\001\033[0m\002')
+                                    sys.stdout.flush()
+                                    full_response += before
+                                sys.stdout.write(closer)
+                                sys.stdout.flush()
+                                full_response += closer
+                                token = token[closer_pos + len(closer):]
+                                thinking = False
+                            else:
+                                if show_thinking:
+                                    sys.stdout.write('\001\033[90m\002' + token + '\001\033[0m\002')
+                                    sys.stdout.flush()
+                                    full_response += token
+                                token = ''
+                elif t == 'error':
+                    code = event.get('code', '')
+                    msg = event.get('message', 'Unknown error')
+                    print(f'\001\033[91m\002[Error {code}]\001\033[0m\002 {msg}')
+                    return None
+                elif t == 'done':
+                    elapsed = (datetime.now(timezone.utc) - start).total_seconds()
+                    print()
+                    print(f'\001\033[90m\002({elapsed:.1f}s)\001\033[0m\002')
+                    break
+
+        finally:
+            if full_response:
+                end = datetime.now(timezone.utc)
+                duration = (end - start).total_seconds()
+                self.current_session.add_message(
+                    'assistant', full_response,
+                    timestamp=end.isoformat(timespec='seconds'),
+                    duration=round(duration, 1),
+                    model=self.config.get('model'),
+                    provider=self.config.get('provider'),
+                )
+
+            self.session_auto_save()
+
+        return full_response
+
+    def _perform_search(self, query: str, silent: bool = False) -> str | None:
+        from .web.search import search as web_search
+        from .web.display import format_results, format_context
+
+        num = self.config.get('search_results', 5)
+        results = web_search(query, num)
+
+        if not results:
+            if not silent:
+                print('\001\033[90m\002(no search results)\001\033[0m\002')
+            return None
+
+        if not silent:
+            print()
+            print(format_results(query, results))
+
+        return format_context(query, results)
+
+    def _init_tooling(self):
+        if not self.config.get('tool_calling'):
+            self._tool_registry = None
+            return None
+        from .tools.registry import ToolRegistry
+        from .tools.builtins import register_tools
+        self._tool_registry = ToolRegistry()
+        register_tools(self._tool_registry)
+        return self._tool_registry.schema()
+
+    def _show_tool_status(self, name, arguments):
+        args_str = ', '.join(f'{k}={v!r}' for k, v in arguments.items())
+        print(f'\001\033[90m\002[{name}: {args_str}]\001\033[0m\002')
+
+    def _output_content(self, content):
+        end = datetime.now(timezone.utc)
+        elapsed = round((end - self._response_start).total_seconds(), 1)
+
+        print(f'\001\033[33m\002<<<\001\033[0m\002 {content}')
+        print(f'\001\033[90m\002({elapsed:.1f}s)\001\033[0m\002')
+
+        self.current_session.add_message(
+            'assistant', content,
+            timestamp=end.isoformat(timespec='seconds'),
+            duration=elapsed,
+            model=self.config.get('model'),
+            provider=self.config.get('provider'),
+        )
+        self.session_auto_save()
+
+    def _refine_query(self, query: str) -> str:
+        context_count = self.config.get('query_refine_context', 4)
+        context_msgs = self.current_session.messages[-context_count:] if context_count > 0 else []
+        refine_sys = "You are a search query optimizer. Rewrite the user's query to be more specific and standalone based on the conversation context. Return ONLY the rewritten query, nothing else."
+        refined = self.provider.chat_nonstreaming(
+            [{'role': 'system', 'content': refine_sys}] + context_msgs + [{'role': 'user', 'content': query}],
+            tools=None,
+        )
+        refined_query = (refined.get('content') or query).strip().strip('"\'')
+        return refined_query if refined_query else query
+
+    def _render_token(self, token: str, state: dict) -> list[tuple[str, str]]:
+        segments = []
+        while token:
+            if state['code_block']:
+                idx = token.find('```')
+                if idx != -1:
+                    before = token[:idx]
+                    if before:
+                        segments.append((before, '\033[36m'))
+                    state['code_block'] = False
+                    token = token[idx + 3:]
+                else:
+                    segments.append((token, '\033[36m'))
+                    token = ''
+            elif state['inline_code']:
+                idx = token.find('`')
+                if idx != -1:
+                    before = token[:idx]
+                    if before:
+                        segments.append((before, '\033[32m'))
+                    state['inline_code'] = False
+                    token = token[idx + 1:]
+                else:
+                    segments.append((token, '\033[32m'))
+                    token = ''
+            elif state['bold']:
+                idx = token.find('**')
+                if idx != -1:
+                    before = token[:idx]
+                    if before:
+                        segments.append((before, '\033[1m'))
+                    state['bold'] = False
+                    token = token[idx + 2:]
+                else:
+                    segments.append((token, '\033[1m'))
+                    token = ''
+            else:
+                idx = -1
+                marker = ''
+                for m in ('```', '**', '`'):
+                    pos = token.find(m)
+                    if pos != -1 and (idx == -1 or pos < idx):
+                        idx = pos
+                        marker = m
+                if idx != -1:
+                    before = token[:idx]
+                    if before:
+                        segments.append((before, ''))
+                    if marker == '```':
+                        state['code_block'] = True
+                    elif marker == '**':
+                        state['bold'] = True
+                    elif marker == '`':
+                        state['inline_code'] = True
+                    token = token[idx + len(marker):]
+                else:
+                    segments.append((token, ''))
+                    token = ''
+        return segments
+
+    def _chat_with_tools(self, force_search: str | None = None):
+        messages = self.current_session.messages
+        tools_schema = self._init_tooling()
+        self._response_start = datetime.now(timezone.utc)
+
+        if force_search:
+            context = self._perform_search(force_search, silent=False)
+            if context:
+                messages.append({
+                    'role': 'tool',
+                    'tool_call_id': 'forced',
+                    'content': context,
+                })
+
+        try:
+            while True:
+                result = self.provider.chat_nonstreaming(messages, tools=tools_schema)
+
+                if 'error' in result:
+                    err = result['error']
+                    print(f'\001\033[91m\002[Error {err["code"]}]\001\033[0m\002 {err["message"]}')
+                    break
+
+                tcs = result.get('tool_calls')
+                if tcs:
+                    messages.append({
+                        'role': 'assistant',
+                        'content': result.get('content'),
+                        'tool_calls': tcs,
+                        'timestamp': datetime.now(timezone.utc).isoformat(timespec='seconds'),
+                    })
+                    for tc in tcs:
+                        name = tc['function']['name']
+                        args = json.loads(tc['function']['arguments'])
+                        if (self.config.get('query_refine')
+                                and name == 'web_search'
+                                and len(args.get('query', '').split()) <= self.config.get('query_refine_min_words', 3)):
+                            original = args['query']
+                            args['query'] = self._refine_query(args['query'])
+                            if args['query'] != original:
+                                print(f'\001\033[90m\002[refine: "{original}" → "{args["query"]}"]\001\033[0m\002')
+                        if self.config.get('tool_status_visible', True):
+                            self._show_tool_status(name, args)
+                        output = self._tool_registry.execute(name, args)
+                        messages.append({
+                            'role': 'tool',
+                            'tool_call_id': tc['id'],
+                            'content': output,
+                            'timestamp': datetime.now(timezone.utc).isoformat(timespec='seconds'),
+                        })
+                    continue
+
+                response = self._stream_response()
+                if not response and result.get('content'):
+                    end = datetime.now(timezone.utc)
+                    duration = round((end - self._response_start).total_seconds(), 1)
+                    self.current_session.add_message(
+                        'assistant', result['content'],
+                        timestamp=end.isoformat(timespec='seconds'),
+                        duration=duration,
+                        model=self.config.get('model'),
+                        provider=self.config.get('provider'),
+                    )
+                break
+        finally:
+            self.session_auto_save()
+
+    def _handle_message(self, content):
+        now = datetime.now(timezone.utc)
+        self.current_session.add_message(
+            'user', content, timestamp=now.isoformat(timespec='seconds')
+        )
+        self.session_auto_save()
+
+        user_msgs = [m for m in self.current_session.messages if m['role'] == 'user']
+        if len(user_msgs) == 1:
+            ts = self.current_session.name
+            truncated = content[:40]
+            space = truncated.rfind(' ')
+            if space > 0:
+                truncated = truncated[:space]
+            msg_part = ''.join(c if c.isalnum() or c in '-_ ' else '' for c in truncated).strip().replace(' ', '_')
+            if msg_part:
+                old = self.sessions.sessions_dir / f'{self.current_session.name}.json'
+                self.current_session.name = f'{ts}_{msg_part.lower()}'
+                new = self.sessions.sessions_dir / f'{self.current_session.name}.json'
+                if old.exists() and old != new:
+                    old.rename(new)
+                    self.session_auto_save()
+
+        if self.config.get('tool_calling'):
+            self._chat_with_tools()
+        elif self.config.get('web_search'):
+            context = self._perform_search(content, silent=True)
+            if context:
+                self.current_session.add_message('system', context)
+            else:
+                print('\001\033[90m\002(Skipping AI — no search results)\001\033[0m\002')
+                return
+            self._stream_response()
+        else:
+            self._stream_response()

replio/commands/builtins.py

@@ -0,0 +1,149 @@
+import sys
+
+
+def register_builtins(registry):
+    chat = registry.chat_loop
+
+    @registry.register('help', aliases=['h'])
+    def help_cmd(_=None):
+        print('Available commands:')
+        seen = set()
+        for name, fn in sorted(registry.commands.items()):
+            if id(fn) not in seen:
+                seen.add(id(fn))
+                print(f'  /{name}')
+                aliases = [k for k, v in registry.commands.items()
+                           if v is fn and k != name]
+                if aliases:
+                    print(f'      aliases: {", ".join(aliases)}')
+
+    @registry.register('exit', aliases=['quit', 'q'])
+    def exit_cmd(_=None):
+        chat.session_auto_save()
+        sys.exit(0)
+
+    @registry.register('model')
+    def model_cmd(arg=''):
+        if arg:
+            chat.config.set('model', arg.strip())
+            chat.provider.model = chat.config.get('model')
+            print(f'Model set to: {chat.config.get("model")}')
+        else:
+            print(f'Current model: {chat.config.get("model")}')
+
+    @registry.register('provider')
+    def provider_cmd(arg=''):
+        if arg:
+            chat.config.set('provider', arg.strip())
+            chat._reinit_provider()
+            print(f'Provider set to: {chat.config.get("provider")}')
+        else:
+            print(f'Current provider: {chat.config.get("provider")}')
+
+    @registry.register('connect')
+    def connect_cmd(_=None):
+        print('Setting up provider connection:')
+        provider = input(
+            f'  Provider [{chat.config.get("provider")}]: '
+        ).strip() or chat.config.get('provider')
+        base_url = input(
+            f'  Base URL [{chat.config.get("base_url")}]: '
+        ).strip() or chat.config.get('base_url')
+        api_key = input('  API key (leave empty to skip): ').strip()
+        model = input(
+            f'  Model [{chat.config.get("model")}]: '
+        ).strip() or chat.config.get('model')
+
+        chat.config.set('provider', provider)
+        chat.config.set('base_url', base_url)
+        chat.config.set('model', model)
+        if api_key:
+            chat.config.set('api_key', api_key)
+
+        chat._reinit_provider()
+        print(f'Connected to {provider} ({base_url})')
+
+    @registry.register('config')
+    def config_cmd(arg=''):
+        parts = arg.strip().split(maxsplit=1)
+        if not arg:
+            for k, v in chat.config.data.items():
+                val = '***' if k == 'api_key' and v else v
+                print(f'  {k}: {val}')
+        elif len(parts) == 1:
+            key = parts[0]
+            val = chat.config.get(key)
+            if key == 'api_key':
+                val = '***' if val else val
+            print(f'  {key}: {val}')
+        else:
+            key, value = parts
+            chat.config.set(key, value)
+            print(f'Config {key} = {value}')
+
+    @registry.register('session')
+    def session_cmd(arg=''):
+        parts = arg.strip().split(maxsplit=1)
+        action = parts[0] if parts else ''
+
+        if not action:
+            print('Session commands:')
+            print('  /session new            start a new session')
+            print('  /session list           list saved sessions')
+            print('  /session load <name>    load a session')
+            print('  /session delete <name>  delete a session')
+            print('  /session save           save current session')
+            return
+
+        if action == 'new':
+            s = chat.sessions.create()
+            print(f'New session: {s.name}')
+        elif action == 'list':
+            sessions = chat.sessions.list()
+            if sessions:
+                current = chat.sessions.current.name if chat.sessions.current else ''
+                for s in sessions:
+                    marker = '  <-- current' if s == current else ''
+                    print(f'  {s}{marker}')
+            else:
+                print('  No sessions found')
+        elif action == 'load':
+            name = parts[1] if len(parts) > 1 else ''
+            if not name:
+                print('Usage: /session load <name>')
+                return
+            s = chat.sessions.load(name)
+            if s:
+                print(f'Loaded session: {name} ({len(s.messages)} messages)')
+            else:
+                print(f'Session not found: {name}')
+        elif action == 'delete':
+            name = parts[1] if len(parts) > 1 else ''
+            if not name:
+                print('Usage: /session delete <name>')
+                return
+            if chat.sessions.delete(name):
+                print(f'Deleted session: {name}')
+            else:
+                print(f'Session not found: {name}')
+        elif action == 'save':
+            chat.session_auto_save()
+            print('Session saved')
+
+    @registry.register('search', aliases=['web'])
+    def search_cmd(arg=''):
+        if not arg:
+            print('Usage: /search <query>')
+            return
+        from datetime import datetime, timezone
+        now = datetime.now(timezone.utc)
+        chat.current_session.add_message(
+            'user', arg, timestamp=now.isoformat(timespec='seconds')
+        )
+        if chat.config.get('tool_calling'):
+            chat._chat_with_tools(force_search=arg)
+        else:
+            if not chat._perform_search(arg):
+                print('No results found — try a different query.')
+                return
+            chat._stream_response()

replio/commands/registry.py

@@ -0,0 +1,33 @@
+from typing import Callable
+
+
+class CommandRegistry:
+    def __init__(self, chat_loop):
+        self.chat_loop = chat_loop
+        self.commands: dict[str, Callable] = {}
+
+    def register(self, name: str, aliases: list[str] | None = None,
+                 handler: Callable | None = None):
+        if handler is None:
+            def wrapper(fn):
+                self.commands[name] = fn
+                for alias in (aliases or []):
+                    self.commands[alias] = fn
+                return fn
+            return wrapper
+        self.commands[name] = handler
+        for alias in (aliases or []):
+            self.commands[alias] = handler
+
+    def dispatch(self, line: str):
+        parts = line.strip().split(maxsplit=1)
+        cmd = parts[0].lstrip('/')
+        arg = parts[1] if len(parts) > 1 else ''
+        handler = self.commands.get(cmd)
+        if handler:
+            try:
+                handler(arg)
+            except TypeError:
+                handler()
+        else:
+            print(f'Unknown command: /{cmd}. Type /help for available commands.')

replio/config.py

@@ -0,0 +1,51 @@
+import json
+from pathlib import Path
+
+
+DEFAULT_CONFIG = {
+    'provider': 'ollama',
+    'model': 'llama3.2',
+    'base_url': 'https://api.ollama.com',
+    'api_key': '',
+    'temperature': 0.7,
+    'max_tokens': 2048,
+    'system_prompt': '',
+    'tool_calling': True,
+    'tool_status_visible': True,
+    'query_refine': False,
+    'query_refine_min_words': 3,
+    'query_refine_context': 4,
+    'show_thinking': True,
+    'markdown_streaming': False,
+    'web_search': False,
+    'search_results': 5,
+}
+
+
+class Config:
+    def __init__(self, path: str | None = None):
+        self.global_path = Path.home() / '.config' / 'replio' / 'config.json'
+        if path:
+            self.local_path = Path(path).resolve() / '.replio' / 'config.json'
+        else:
+            self.local_path = Path.cwd() / '.replio' / 'config.json'
+        self.data = dict(DEFAULT_CONFIG)
+        self._load()
+
+    def _load(self):
+        for p in [self.global_path, self.local_path]:
+            if p.exists():
+                with open(p) as f:
+                    self.data.update(json.load(f))
+
+    def save(self):
+        self.local_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.local_path, 'w') as f:
+            json.dump(self.data, f, indent=2)
+
+    def get(self, key, default=None):
+        return self.data.get(key, default)
+
+    def set(self, key, value):
+        self.data[key] = value
+        self.save()

replio/main.py

@@ -0,0 +1,33 @@
+import sys
+import argparse
+
+from .config import Config
+from .chat import ChatLoop
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='REPL.io — A terminal-based REPL AI chat application'
+    )
+    parser.add_argument(
+        '--path', '-p',
+        help='Project path (default: current directory)'
+    )
+    args = parser.parse_args()
+
+    config = Config(path=args.path)
+    chat = ChatLoop(config)
+
+    try:
+        chat.run()
+    except SystemExit:
+        pass
+    except KeyboardInterrupt:
+        print()
+    except Exception as e:
+        print(f'\nUnexpected error: {e}', file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

replio/providers/base.py

@@ -0,0 +1,19 @@
+class BaseProvider:
+    def __init__(self, base_url: str = '', api_key: str = '',
+                 model: str = '', temperature: float = 0.7,
+                 max_tokens: int = 2048):
+        self.base_url = base_url.rstrip('/')
+        self.api_key = api_key
+        self.model = model
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+
+    def chat(self, messages: list[dict], stream: bool = True):
+        raise NotImplementedError
+
+    def chat_nonstreaming(self, messages: list[dict],
+                          tools: list[dict] | None = None) -> dict:
+        raise NotImplementedError
+
+    def list_models(self) -> list[str]:
+        raise NotImplementedError

replio/providers/ollama.py

@@ -0,0 +1,109 @@
+import json
+import urllib.request
+import urllib.error
+
+from .base import BaseProvider
+from ..utils.http import stream_sse
+
+
+class OllamaProvider(BaseProvider):
+    DEFAULT_BASE_URL = 'https://api.ollama.com'
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        if not self.base_url:
+            self.base_url = self.DEFAULT_BASE_URL
+
+    def _headers(self):
+        headers = {'Content-Type': 'application/json'}
+        if self.api_key:
+            headers['Authorization'] = f'Bearer {self.api_key}'
+        return headers
+
+    def _payload(self, messages, stream=False, tools=None):
+        payload = {
+            'model': self.model,
+            'messages': messages,
+            'temperature': self.temperature,
+            'max_tokens': self.max_tokens,
+            'stream': stream,
+        }
+        if tools:
+            payload['tools'] = tools
+        return payload
+
+    def _post(self, payload):
+        url = f'{self.base_url}/v1/chat/completions'
+        data = json.dumps(payload).encode('utf-8')
+        req = urllib.request.Request(url, data=data, headers=self._headers())
+        try:
+            with urllib.request.urlopen(req) as resp:
+                return json.loads(resp.read())
+        except urllib.error.HTTPError as e:
+            body = e.read().decode('utf-8', errors='replace')
+            return {'error': {'code': e.code, 'message': body}}
+        except urllib.error.URLError as e:
+            return {'error': {'code': 0, 'message': f'Network error: {e.reason}'}}
+        except Exception as e:
+            return {'error': {'code': 0, 'message': str(e)}}
+
+    def chat_nonstreaming(self, messages: list[dict],
+                          tools: list[dict] | None = None) -> dict:
+        payload = self._payload(messages, stream=False, tools=tools)
+        result = self._post(payload)
+        if 'error' in result:
+            return result
+        choice = result['choices'][0]
+        message = choice['message']
+        return {
+            'role': message.get('role', 'assistant'),
+            'content': message.get('content'),
+            'tool_calls': message.get('tool_calls'),
+            'finish_reason': choice.get('finish_reason'),
+        }
+
+    def chat(self, messages: list[dict], stream: bool = True):
+        payload = self._payload(messages, stream=stream)
+
+        if not stream:
+            result = self._post(payload)
+            if 'error' in result:
+                yield {'type': 'error', 'code': result['error']['code'], 'message': result['error']['message']}
+                return
+            content = result['choices'][0]['message']['content']
+            yield {'type': 'token', 'content': content}
+            yield {'type': 'done'}
+            return
+
+        for event in stream_sse(self._endpoint(), self._headers(), payload):
+            if 'type' in event:
+                yield event
+                return
+            choices = event.get('choices', [])
+            if not choices:
+                continue
+            delta = choices[0].get('delta', {})
+            reasoning = delta.get('reasoning_content', '')
+            if reasoning:
+                yield {'type': 'thinking', 'content': reasoning}
+                continue
+            content = delta.get('content', '')
+            if content:
+                yield {'type': 'token', 'content': content}
+            finish = choices[0].get('finish_reason')
+            if finish:
+                yield {'type': 'done', 'reason': finish}
+
+    def _endpoint(self):
+        return f'{self.base_url}/v1/chat/completions'
+
+    def list_models(self) -> list[str]:
+        url = f'{self.base_url}/v1/models'
+        req = urllib.request.Request(url, headers=self._headers())
+        try:
+            with urllib.request.urlopen(req) as resp:
+                data = json.loads(resp.read())
+            return [m['id'] for m in data.get('data', [])]
+        except Exception as e:
+            print(f'\001\033[91m\002[Error]\001\033[0m\002 Failed to list models: {e}')
+            return []

replio/sessions/manager.py

@@ -0,0 +1,64 @@
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+class Session:
+    def __init__(self, name: str, messages: list | None = None):
+        self.name = name
+        self.messages = messages or []
+
+    def add_message(self, role: str, content: str, **kwargs):
+        msg = {'role': role, 'content': content}
+        msg['timestamp'] = kwargs.pop(
+            'timestamp', datetime.now(timezone.utc).isoformat(timespec='seconds')
+        )
+        msg.update(kwargs)
+        self.messages.append(msg)
+
+    def to_dict(self):
+        visible = [m for m in self.messages if m.get('role') != 'tool']
+        return {'name': self.name, 'messages': visible}
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(data['name'], data.get('messages', []))
+
+
+class SessionManager:
+    def __init__(self, sessions_dir: Path):
+        self.sessions_dir = sessions_dir
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+        self.current: Session | None = None
+
+    def create(self, name: str | None = None) -> Session:
+        if not name:
+            name = datetime.now().strftime('%Y%m%d_%H%M%S')
+        self.current = Session(name)
+        return self.current
+
+    def load(self, name: str) -> Session | None:
+        path = self.sessions_dir / f'{name}.json'
+        if not path.exists():
+            return None
+        with open(path) as f:
+            data = json.load(f)
+        self.current = Session.from_dict(data)
+        return self.current
+
+    def save(self, session: Session | None = None):
+        s = session or self.current
+        if s is None:
+            return
+        with open(self.sessions_dir / f'{s.name}.json', 'w') as f:
+            json.dump(s.to_dict(), f, indent=2)
+
+    def list(self) -> list[str]:
+        return sorted(p.stem for p in self.sessions_dir.glob('*.json'))
+
+    def delete(self, name: str) -> bool:
+        path = self.sessions_dir / f'{name}.json'
+        if path.exists():
+            path.unlink()
+            return True
+        return False

replio/tools/builtins.py

@@ -0,0 +1,97 @@
+import json
+from html.parser import HTMLParser
+import re
+
+
+class _TextExtractor(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self._parts = []
+        self._skip_depth = 0
+        self._skip_tags = frozenset({'script', 'style', 'svg', 'noscript'})
+        self._block_tags = frozenset({
+            'p', 'br', 'li', 'div', 'tr', 'td', 'th',
+            'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+            'blockquote', 'pre', 'hr',
+        })
+
+    def handle_starttag(self, tag, attrs):
+        if tag in self._skip_tags:
+            self._skip_depth += 1
+        if self._skip_depth == 0 and tag in self._block_tags:
+            self._parts.append('\n')
+
+    def handle_endtag(self, tag):
+        if tag in self._skip_tags:
+            self._skip_depth = max(0, self._skip_depth - 1)
+        if self._skip_depth == 0 and tag in self._block_tags:
+            self._parts.append('\n')
+
+    def handle_data(self, data):
+        if self._skip_depth == 0:
+            self._parts.append(data)
+
+    def text(self):
+        text = ''.join(self._parts)
+        text = re.sub(r' +', ' ', text)
+        text = re.sub(r'\n ', '\n', text)
+        text = re.sub(r' \n', '\n', text)
+        text = re.sub(r'\n{3,}', '\n\n', text)
+        return text.strip()
+
+
+def register_tools(registry):
+    from ..web.search import search as web_search_fn
+    from ..web.display import format_context
+
+    @registry.register(
+        name='web_search',
+        description='Search the web for current information. Use this to find recent news, facts, documentation, and any information that may be time-sensitive or outside the model\'s training data.',
+        parameters={
+            'type': 'object',
+            'properties': {
+                'query': {
+                    'type': 'string',
+                    'description': 'The search query — be specific and concise',
+                },
+            },
+            'required': ['query'],
+        },
+    )
+    def web_search(query: str) -> str:
+        results = web_search_fn(query)
+        if not results:
+            return 'No search results found.'
+        return format_context(query, results)
+
+    @registry.register(
+        name='fetch_page',
+        description='Fetch and read the full content of a web page. Use this when search result snippets are insufficient and you need detailed information from a specific URL.',
+        parameters={
+            'type': 'object',
+            'properties': {
+                'url': {
+                    'type': 'string',
+                    'description': 'The full URL of the page to fetch',
+                },
+            },
+            'required': ['url'],
+        },
+    )
+    def fetch_page(url: str) -> str:
+        import urllib.request
+        try:
+            req = urllib.request.Request(
+                url,
+                headers={'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64)'},
+            )
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                content = resp.read().decode('utf-8', errors='replace')
+            extractor = _TextExtractor()
+            extractor.feed(content)
+            text = extractor.text()
+            if len(text) > 8000:
+                text = text[:8000] + '\n... (truncated)'
+            return text
+        except Exception as e:
+            return f'Error fetching page: {e}'

replio/tools/registry.py

@@ -0,0 +1,38 @@
+class ToolRegistry:
+    def __init__(self):
+        self._tools: dict[str, dict] = {}
+        self._schema: list[dict] = []
+
+    def register(self, name: str, description: str, parameters: dict):
+        def wrapper(fn):
+            entry = {
+                'name': name,
+                'fn': fn,
+                'schema': {
+                    'type': 'function',
+                    'function': {
+                        'name': name,
+                        'description': description,
+                        'parameters': parameters,
+                    },
+                },
+            }
+            self._tools[name] = entry
+            self._schema.append(entry['schema'])
+            return fn
+        return wrapper
+
+    def execute(self, name: str, arguments: dict) -> str:
+        tool = self._tools.get(name)
+        if not tool:
+            return f'Error: unknown tool "{name}"'
+        try:
+            return tool['fn'](**arguments)
+        except Exception as e:
+            return f'Error executing {name}: {e}'
+
+    def schema(self) -> list[dict]:
+        return list(self._schema)
+
+    def names(self) -> list[str]:
+        return list(self._tools.keys())

replio/utils/http.py

@@ -0,0 +1,36 @@
+import urllib.request
+import urllib.error
+import json
+
+
+def stream_sse(url, headers, payload, timeout=120):
+    data = json.dumps(payload).encode('utf-8')
+    req = urllib.request.Request(url, data=data, headers=headers, method='POST')
+
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            buffer = ''
+            while True:
+                chunk = resp.read(4096)
+                if not chunk:
+                    break
+                buffer += chunk.decode('utf-8')
+                while '\n' in buffer:
+                    line, buffer = buffer.split('\n', 1)
+                    line = line.strip()
+                    if not line:
+                        continue
+                    if line.startswith('data: '):
+                        data_str = line[6:]
+                        if data_str == '[DONE]':
+                            yield {'type': 'done'}
+                            return
+                        try:
+                            yield json.loads(data_str)
+                        except json.JSONDecodeError:
+                            pass
+    except urllib.error.HTTPError as e:
+        body = e.read().decode('utf-8', errors='replace')
+        yield {'type': 'error', 'code': e.code, 'message': body}
+    except Exception as e:
+        yield {'type': 'error', 'message': str(e)}

replio/web/display.py

@@ -0,0 +1,25 @@
+def format_results(query: str, results: list[dict]) -> str:
+    lines = [f'Search results for "{query}":\n']
+    for i, r in enumerate(results, 1):
+        title = r.get('title', '')
+        url = r.get('url', '')
+        snippet = r.get('snippet', '')
+        lines.append(f'  {i}. {title}')
+        lines.append(f'     {url}')
+        if snippet:
+            lines.append(f'     ({snippet})')
+        lines.append('')
+    return '\n'.join(lines)
+
+
+def format_context(query: str, results: list[dict]) -> str:
+    parts = [f'Web search results for "{query}":']
+    for i, r in enumerate(results, 1):
+        title = r.get('title', '')
+        url = r.get('url', '')
+        snippet = r.get('snippet', '')
+        parts.append(f'{i}. {title}')
+        parts.append(f'   URL: {url}')
+        if snippet:
+            parts.append(f'   Snippet: {snippet}')
+    return '\n'.join(parts)

replio/web/search.py

@@ -0,0 +1,68 @@
+import urllib.request
+import urllib.parse
+from html.parser import HTMLParser
+from typing import Generator
+
+
+SEARCH_URL = 'https://lite.duckduckgo.com/lite/'
+
+
+class DDGResultParser(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.results: list[dict] = []
+        self._cur: dict | None = None
+        self._state = 'idle'
+        self._text = ''
+
+    def handle_starttag(self, tag, attrs):
+        a = dict(attrs)
+        if tag == 'a' and a.get('rel') == 'nofollow':
+            self._cur = {'url': a.get('href', ''), 'title': '', 'snippet': ''}
+            self._state = 'link'
+            self._text = ''
+            return
+        if self._state == 'idle':
+            return
+        if tag == 'br':
+            if self._state in ('link', 'link_done'):
+                if self._state == 'link':
+                    self._cur['title'] = self._text.strip()
+                self._state = 'snippet'
+                self._text = ''
+            elif self._state == 'snippet':
+                self._cur['snippet'] = self._text.strip()
+                self._state = 'done'
+                self._text = ''
+
+    def handle_data(self, data):
+        if self._state in ('link', 'snippet'):
+            self._text += data
+
+    def handle_endtag(self, tag):
+        if tag == 'a' and self._state == 'link':
+            self._cur['title'] = self._text.strip()
+            self._state = 'link_done'
+            self._text = ''
+        if tag == 'td' and self._cur:
+            if self._cur.get('title'):
+                self.results.append(self._cur)
+            self._cur = None
+            self._state = 'idle'
+            self._text = ''
+
+
+def search(query: str, num_results: int = 5) -> list[dict]:
+    data = urllib.parse.urlencode({'q': query}).encode()
+    headers = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64)'}
+    req = urllib.request.Request(SEARCH_URL, data=data, headers=headers)
+
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            html = resp.read().decode('utf-8', errors='replace')
+    except Exception:
+        return []
+
+    parser = DDGResultParser()
+    parser.feed(html)
+    return parser.results[:num_results]

replio-0.5.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: replio
+Version: 0.5.0
+Summary: A terminal-based REPL AI chat application allowing web search alongside other tool calling
+Author: Contributors
+Requires-Python: >=3.10
+License-File: LICENSE
+Dynamic: license-file

replio-0.5.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+replio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+replio/__main__.py,sha256=vBQ82334kX06ImDbFlPFgiBRiLIinwNk3z8Khs6hd74,31
+replio/chat.py,sha256=O_m1HV6OoyumFuYEw6Okhx7V3P_l3mQRJ3dBtDS3hvc,19510
+replio/config.py,sha256=Nua0fok53JYCAQ6THt1-DdkZhdvKKJCMy5md9ZuMW6U,1422
+replio/main.py,sha256=MRCjLGDJH5qF1E7rnStYd96WXWMsGRrsYiJ3hQFuflc,681
+replio/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+replio/commands/builtins.py,sha256=pYohkvd6cpXsVaq262C0vAl6vlFFjrK9r2kpQYC2Ny4,5425
+replio/commands/registry.py,sha256=rBNjYXW4PYeZo4arNbC6H5fFzCBY7hzHpVu7VIl6z5Y,1079
+replio/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+replio/providers/base.py,sha256=36_nzwWtf44vg29JPLUtfVgo_Bkh6dkloWjteeKOPYc,693
+replio/providers/ollama.py,sha256=LzlGumhFuMj5jwi_Jy7HPFXaWrJf6a2_vPLVKc_kGaA,4040
+replio/sessions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+replio/sessions/manager.py,sha256=k3LeP2ofnFEWxargU2A1ITZEgyYgImT-TeUnsGSWa0A,2036
+replio/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+replio/tools/builtins.py,sha256=0deLB3E94dFDIW_NtLIfxp-jkphmq0FBXyIkHpWSM-U,3361
+replio/tools/registry.py,sha256=eGtpWJDDKnER4b-Na6eNm65w2HuOEIfkOhIdKXKa624,1180
+replio/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+replio/utils/http.py,sha256=TIQna8OYXIuo45wzvWMKYCoZyVCA0ekdIlIX3cHotPU,1346
+replio/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+replio/web/display.py,sha256=IPmi2XlCDga4Ovv3kPBLooc_IvIc4GLTFwenlEqr1oM,881
+replio/web/search.py,sha256=hWwIRjir1ZptlO-INRX7yYOm3v6znm3Qy53GWt15h3k,2184
+replio-0.5.0.dist-info/licenses/LICENSE,sha256=rLsIfIWeBi6EkxfJCvVKgb3ZfAYB1N-XW_NasdJy21k,1074
+replio-0.5.0.dist-info/METADATA,sha256=NmptH1GQnaJeL65Hhx0WdzX2q9OhvepVn08sfQNH29Y,239
+replio-0.5.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+replio-0.5.0.dist-info/entry_points.txt,sha256=kSlxLze8TgNcH7xsU6g_NUl6tdZOlu2ASUZQCbJxrls,44
+replio-0.5.0.dist-info/top_level.txt,sha256=_veHcbCUHNLeeFruPOxEE6-v9KGJz_g4x8IFa5Vwh2Q,7
+replio-0.5.0.dist-info/RECORD,,

replio-0.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

replio-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+replio = replio.main:main

replio-0.5.0.dist-info/licenses/LICENSE

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

replio-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+replio