siada-cli 0.0.1__py3-none-any.whl

siada/session/session_models.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass, field
+from typing import Dict, Any, Optional
+from uuid import uuid4
+
+from agents import SQLiteSession
+
+from siada.entrypoint.interaction.config import RunningConfig
+from siada.io.io import InputOutput
+from siada.models.model_run_config import ModelRunConfig
+
+
+@dataclass
+class SessionState:
+    """
+    Interaction session state data model
+    
+    Stores state information during user interactions, complementing OpenAI Agents' SQLiteSession:
+    - SQLiteSession: Stores large language model conversation history
+    - SessionState: Stores interaction state and context information
+    """
+
+    # Core state fields
+    context_vars: Dict[str, Any] = field(default_factory=dict)
+    """Context variables, works with foundation.context module"""
+
+    # Agent-related state
+    current_agent: Optional[str] = None
+    """Currently active Agent name"""
+    
+    openai_session: Optional[SQLiteSession] = None
+
+
+@dataclass
+class RunningSession:
+
+    siada_config: RunningConfig
+
+    session_id: str = field(default_factory=lambda: str(uuid4()))
+
+    state: SessionState = field(default_factory=SessionState)
+
+    def get_input(self) -> str:
+        return self.siada_config.io.get_input()

siada/support/completer.py

@@ -0,0 +1,204 @@
+from prompt_toolkit.completion import Completer, Completion
+import os
+
+from siada.services.file_recommendation import FileRecommendationEngine, CompletionConfig
+
+
+class CommandCompletionException(Exception):
+    """Raised when a command should use the normal autocompleter instead of
+    command-specific completion."""
+    pass
+
+
+
+class AutoCompleter(Completer):
+    def __init__(
+        self, root, commands, encoding
+    ):
+        self.encoding = encoding
+        self.root = root
+
+        self.words = set()
+
+        self.commands = commands
+        self.command_completions = dict()
+        if commands:
+            self.command_names = self.commands.get_commands()
+        
+        # Initialize file recommendation engine
+        current_dir = root if root else os.getcwd()
+        config = CompletionConfig(
+            max_results=20,
+            enable_recursive_search=True,
+            max_search_depth=5,
+            respect_git_ignore=True
+        )
+        self.file_recommendation_engine = FileRecommendationEngine(
+            current_directory=current_dir,
+            config=config
+        )
+        
+        # Add completion state management
+        self.completion_state = {
+            'just_completed': False,
+            'last_completion_pos': 0,
+            'last_at_command': None,
+            'last_completion_text': None
+        }
+
+    def get_command_completions(self, document, complete_event, text, words):
+        if len(words) == 1 and not text[-1].isspace():
+            partial = words[0].lower()
+            candidates = [cmd for cmd in self.command_names if cmd.startswith(partial)]
+            for candidate in sorted(candidates):
+                yield Completion(candidate, start_position=-len(words[-1]))
+            return
+
+        if len(words) <= 1 or text[-1].isspace():
+            return
+
+        cmd = words[0]
+        partial = words[-1].lower()
+
+        matches, _, _ = self.commands.matching_commands(cmd)
+        if len(matches) == 1:
+            cmd = matches[0]
+        elif cmd not in matches:
+            return
+
+        raw_completer = self.commands.get_raw_completions(cmd)
+        if raw_completer:
+            yield from raw_completer(document, complete_event)
+            return
+
+        if cmd not in self.command_completions:
+            candidates = self.commands.get_completions(cmd)
+            self.command_completions[cmd] = candidates
+        else:
+            candidates = self.command_completions[cmd]
+
+        if candidates is None:
+            return
+
+        candidates = [word for word in candidates if partial in word.lower()]
+        for candidate in sorted(candidates):
+            yield Completion(candidate, start_position=-len(words[-1]))
+
+    def get_completions(self, document, complete_event):
+
+        text = document.text_before_cursor
+        words = text.split()
+        if not words:
+            return
+
+        if text and text[-1].isspace():
+            # don't keep completing after a space
+            return
+
+        if text[0] == "/":
+            try:
+                yield from self.get_command_completions(document, complete_event, text, words)
+                return
+            except CommandCompletionException:
+                # Fall through to normal completion
+                pass
+
+        # Check for @ symbol anywhere in the text before cursor
+        text_before_cursor = document.text_before_cursor
+        at_pos = text_before_cursor.rfind("@")
+        
+        if at_pos != -1:
+            try:
+                # Extract query text from @ symbol to cursor
+                query_text = text_before_cursor[at_pos:]
+                current_pos = len(text_before_cursor)
+                
+                # Check if user just completed a selection and cursor is at end
+                if (self.completion_state['just_completed'] and 
+                    current_pos == self.completion_state['last_completion_pos'] and
+                    query_text == self.completion_state['last_at_command']):
+                    # Reset state and don't show suggestions immediately after completion
+                    self.completion_state['just_completed'] = False
+                    return
+                
+                # Reset completion state if user moved cursor or changed text
+                if (current_pos != self.completion_state['last_completion_pos'] or
+                    query_text != self.completion_state['last_at_command']):
+                    self.completion_state['just_completed'] = False
+                
+                if self.file_recommendation_engine.should_show_suggestions(query_text):
+                    suggestions = self.file_recommendation_engine.get_suggestions_sync(query_text)
+                    
+                    # Calculate start_position to replace from @ symbol
+                    start_position = at_pos - len(text_before_cursor)
+                    
+                    for suggestion in suggestions:
+                        # Create completion that will trigger state update when selected
+                        # Auto-add space after completion to indicate completion end
+                        completion_text = "@" + suggestion['value'] + " "
+                        completion = Completion(
+                            completion_text, 
+                            start_position=start_position,
+                            display=suggestion['label']
+                        )
+                        
+                        # Store state for after completion (include space in position calculation)
+                        self._prepare_completion_state(
+                            completion_text,
+                            at_pos + len(completion_text)
+                        )
+                        
+                        yield completion
+                else:
+                    if query_text == "@":
+                        suggestions = self.file_recommendation_engine.get_suggestions_sync("@")
+                        for suggestion in suggestions:
+                            # Auto-add space after completion to indicate completion end
+                            completion_text = "@" + suggestion['value'] + " "
+                            completion = Completion(
+                                completion_text,
+                                start_position=at_pos - len(text_before_cursor),  # Replace from @ symbol
+                                display=suggestion['label']
+                            )
+                            
+                            # Store state for after completion (include space in position calculation)
+                            self._prepare_completion_state(
+                                completion_text,
+                                at_pos + len(completion_text)
+                            )
+                            
+                            yield completion
+            except Exception as e:
+                pass
+
+
+        candidates = self.words
+        candidates = [word if type(word) is tuple else (word, word) for word in candidates]
+
+        last_word = words[-1]
+    
+    def _prepare_completion_state(self, completion_text: str, completion_pos: int):
+        """
+        Prepare completion state for tracking when user selects a completion
+        
+        Args:
+            completion_text: The text that will be inserted
+            completion_pos: The cursor position after completion
+        """
+        self.completion_state.update({
+            'just_completed': True,
+            'last_completion_pos': completion_pos,
+            'last_at_command': completion_text,
+            'last_completion_text': completion_text
+        })
+    
+    def reset_completion_state(self):
+        """
+        Reset completion state
+        """
+        self.completion_state.update({
+            'just_completed': False,
+            'last_completion_pos': 0,
+            'last_at_command': None,
+            'last_completion_text': None
+        })

siada/support/editor.py

@@ -0,0 +1,146 @@
+"""
+Editor module for handling system text editor interactions.
+
+This module provides functionality to:
+- Discover and launch the system's configured text editor
+- Create and manage temporary files for editing
+- Handle editor preferences from environment variables
+- Support cross-platform editor operations
+"""
+
+import os
+import platform
+import subprocess
+import tempfile
+
+from rich.console import Console
+
+
+DEFAULT_EDITOR_NIX = "vi"
+DEFAULT_EDITOR_OS_X = "vim"
+DEFAULT_EDITOR_WINDOWS = "notepad"
+
+console = Console()
+
+
+def print_status_message(success, message, style=None):
+    """
+    Print a status message with appropriate styling.
+
+    :param success: Whether the operation was successful
+    :param message: The message to display
+    :param style: Optional style override. If None, uses green for success and red for failure
+    """
+    if style is None:
+        style = "bold green" if success else "bold red"
+    console.print(message, style=style)
+    print("")
+
+
+def write_temp_file(
+    input_data="",
+    suffix=None,
+    prefix=None,
+    dir=None,
+):
+    """
+    Create a temporary file with the given input data.
+
+    :param input_data: Content to write to the temporary file
+    :param suffix: Optional file extension (without the dot)
+    :param prefix: Optional prefix for the temporary filename
+    :param dir: Optional directory to create the file in
+    :return: Path to the created temporary file
+    :raises: OSError if file creation or writing fails
+    """
+    kwargs = {"prefix": prefix, "dir": dir}
+    if suffix:
+        kwargs["suffix"] = f".{suffix}"
+    fd, filepath = tempfile.mkstemp(**kwargs)
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(input_data)
+    except Exception:
+        os.close(fd)
+        raise
+    return filepath
+
+
+def get_environment_editor(default=None):
+    """
+    Fetches the preferred editor from the environment variables.
+
+    This function checks the following environment variables in order to
+    determine the user's preferred editor:
+
+     - VISUAL
+     - EDITOR
+
+    :param default: The default editor to return if no environment variable is set.
+    :type default: str or None
+    :return: The preferred editor as specified by environment variables or the default value.
+    :rtype: str or None
+    """
+    editor = os.environ.get("VISUAL", os.environ.get("EDITOR", default))
+    return editor
+
+
+def discover_editor(editor_override=None):
+    """
+    Discovers and returns the appropriate editor command.
+
+    Handles cases where the editor command includes arguments, including quoted arguments
+    with spaces (e.g. 'vim -c "set noswapfile"').
+
+    :return: The editor command as a string
+    :rtype: str
+    """
+    system = platform.system()
+    if system == "Windows":
+        default_editor = DEFAULT_EDITOR_WINDOWS
+    elif system == "Darwin":
+        default_editor = DEFAULT_EDITOR_OS_X
+    else:
+        default_editor = DEFAULT_EDITOR_NIX
+
+    if editor_override:
+        editor = editor_override
+    else:
+        editor = get_environment_editor(default_editor)
+
+    return editor
+
+
+def pipe_editor(input_data="", suffix=None, editor=None):
+    """
+    Opens the system editor with optional input data and returns the edited content.
+
+    This function creates a temporary file with the provided input data, opens it in
+    the system editor, waits for the user to make changes and close the editor, then
+    reads and returns the modified content. The temporary file is deleted afterwards.
+
+    :param input_data: Initial content to populate the editor with
+    :type input_data: str
+    :param suffix: Optional file extension for the temporary file (e.g. '.txt', '.md')
+    :type suffix: str or None
+    :return: The edited content after the editor is closed
+    :rtype: str
+    """
+    filepath = write_temp_file(input_data, suffix)
+    command_str = discover_editor(editor)
+    command_str += " " + filepath
+
+    subprocess.call(command_str, shell=True)
+    with open(filepath, "r") as f:
+        output_data = f.read()
+    try:
+        os.remove(filepath)
+    except PermissionError:
+        print_status_message(
+            False,
+            (
+                f"WARNING: Unable to delete temporary file {filepath!r}. You may need to delete it"
+                " manually."
+            ),
+        )
+    return output_data

siada/support/envprocessor.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+
+def generate_search_path_list(default_file, git_root, command_line_file):
+    files = []
+    files.append(Path.home() / default_file)  # homedir
+    if git_root:
+        files.append(Path(git_root) / default_file)  # git root
+    files.append(default_file)
+    if command_line_file:
+        files.append(command_line_file)
+
+    resolved_files = []
+    for fn in files:
+        try:
+            resolved_files.append(Path(fn).resolve())
+        except OSError:
+            pass
+
+    files = resolved_files
+    files.reverse()
+    uniq = []
+    for fn in files:
+        if fn not in uniq:
+            uniq.append(fn)
+    uniq.reverse()
+    files = uniq
+    files = list(map(str, files))
+    files = list(dict.fromkeys(files))
+
+    return files
+
+
+def load_dotenv_files(git_root, dotenv_fname, encoding="utf-8"):
+    # Standard .env file search path
+    dotenv_files = generate_search_path_list(
+        ".env",
+        git_root,
+        dotenv_fname,
+    )
+
+    loaded = []
+    for fname in dotenv_files:
+        try:
+            if Path(fname).exists():
+                load_dotenv(fname, override=True, encoding=encoding)
+                loaded.append(fname)
+        except OSError as e:
+            print(f"OSError loading {fname}: {e}")
+        except Exception as e:
+            print(f"Error loading {fname}: {e}")
+    return loaded

siada/support/repo.py

@@ -0,0 +1,51 @@
+import contextlib
+import os
+import time
+from pathlib import Path, PurePosixPath
+
+try:
+    import git
+
+    ANY_GIT_ERROR = [
+        git.exc.ODBError,
+        git.exc.GitError,
+        git.exc.InvalidGitRepositoryError,
+        git.exc.GitCommandNotFound,
+    ]
+except ImportError:
+    git = None
+    ANY_GIT_ERROR = []
+
+ANY_GIT_ERROR += [
+    OSError,
+    IndexError,
+    BufferError,
+    TypeError,
+    ValueError,
+    AttributeError,
+    AssertionError,
+    TimeoutError,
+]
+ANY_GIT_ERROR = tuple(ANY_GIT_ERROR)
+
+
+
+def get_git_root(path=None):
+    """Try and guess the git repo, since the conf.yml can be at the repo root
+    
+    Args:
+        path: Optional path to start searching from. If None, uses current directory.
+        
+    Returns:
+        str or None: Path to git repository root, or None if not found
+    """
+    try:
+        # If path is provided, start search from that directory
+        if path:
+            repo = git.Repo(path, search_parent_directories=True)
+        else:
+            # Default behavior: search from current directory
+            repo = git.Repo(search_parent_directories=True)
+        return repo.working_tree_dir
+    except (git.InvalidGitRepositoryError, FileNotFoundError):
+        return None