yaicli 0.3.3__py3-none-any.whl → 0.5.0__py3-none-any.whl

yaicli/const.py

@@ -1,10 +1,12 @@
 from enum import StrEnum
 from pathlib import Path
 from tempfile import gettempdir
-from typing import Any
+from typing import Any, Literal, Optional
 
 from rich.console import JustifyMethod
 
+BOOL_STR = Literal["true", "false", "yes", "no", "y", "n", "1", "0", "on", "off"]
+
 
 class JustifyEnum(StrEnum):
     DEFAULT = "default"
@@ -22,36 +24,41 @@ CMD_SAVE_CHAT = "/save"
 CMD_LOAD_CHAT = "/load"
 CMD_LIST_CHATS = "/list"
 CMD_DELETE_CHAT = "/del"
+CMD_HELP = ("/help", "?")
 
 EXEC_MODE = "exec"
 CHAT_MODE = "chat"
 TEMP_MODE = "temp"
 CODE_MODE = "code"
 
+HISTORY_FILE = Path("~/.yaicli_history").expanduser()
 CONFIG_PATH = Path("~/.config/yaicli/config.ini").expanduser()
 ROLES_DIR = CONFIG_PATH.parent / "roles"
+FUNCTIONS_DIR = CONFIG_PATH.parent / "functions"
 
 # Default configuration values
 DEFAULT_CODE_THEME = "monokai"
-DEFAULT_COMPLETION_PATH = "chat/completions"
-DEFAULT_ANSWER_PATH = "choices[0].message.content"
 DEFAULT_PROVIDER = "openai"
 DEFAULT_BASE_URL = "https://api.openai.com/v1"
 DEFAULT_MODEL = "gpt-4o"
 DEFAULT_SHELL_NAME = "auto"
 DEFAULT_OS_NAME = "auto"
-DEFAULT_STREAM = "true"
-DEFAULT_TEMPERATURE: float = 0.7
+DEFAULT_STREAM: BOOL_STR = "true"
+DEFAULT_TEMPERATURE: float = 0.5
 DEFAULT_TOP_P: float = 1.0
 DEFAULT_MAX_TOKENS: int = 1024
 DEFAULT_MAX_HISTORY: int = 500
-DEFAULT_AUTO_SUGGEST = "true"
-DEFAULT_SHOW_REASONING = "true"
+DEFAULT_AUTO_SUGGEST: BOOL_STR = "true"
+DEFAULT_SHOW_REASONING: BOOL_STR = "true"
 DEFAULT_TIMEOUT: int = 60
 DEFAULT_INTERACTIVE_ROUND: int = 25
-DEFAULT_CHAT_HISTORY_DIR = Path(gettempdir()) / "yaicli/chats"
+DEFAULT_CHAT_HISTORY_DIR: Path = Path(gettempdir()) / "yaicli/chats"
 DEFAULT_MAX_SAVED_CHATS = 20
 DEFAULT_JUSTIFY: JustifyMethod = "default"
+DEFAULT_ROLE_MODIFY_WARNING: BOOL_STR = "true"
+DEFAULT_ENABLE_FUNCTIONS: BOOL_STR = "true"
+DEFAULT_SHOW_FUNCTION_OUTPUT: BOOL_STR = "true"
+DEFAULT_REASONING_EFFORT: Optional[Literal["low", "high", "medium"]] = None
 
 
 class EventTypeEnum(StrEnum):
@@ -62,14 +69,18 @@ class EventTypeEnum(StrEnum):
     REASONING_END = "reasoning_end"
     CONTENT = "content"
     FINISH = "finish"
+    TOOL_CALL_START = "tool_call_start"
+    TOOL_CALL_DELTA = "tool_call_delta"
+    TOOL_CALL_END = "tool_call_end"
+    TOOL_RESULT = "tool_result"
+    TOOL_CALLS_FINISH = "tool_calls_finish"
 
 
-SHELL_PROMPT = """Your are a Shell Command Generator named YAICLI.
-Generate a command EXCLUSIVELY for {_os} OS with {_shell} shell.
-If details are missing, offer the most logical solution.
-Ensure the output is a valid shell command.
-Combine multiple steps with `&&` when possible.
-Supply plain text only, avoiding Markdown formatting."""
+SHELL_PROMPT = """You are YAICLI, a shell command generator.
+The context conversation may contain other types of messages, 
+but you should only respond with a single valid {_shell} shell command for {_os}.
+Do not include any explanations, comments, or formatting — only the command as plain text, avoiding Markdown formatting.
+"""
 
 DEFAULT_PROMPT = """
 You are YAICLI, a system management and programing assistant, 
@@ -113,15 +124,13 @@ DEFAULT_CONFIG_MAP = {
     # System detection hints
     "SHELL_NAME": {"value": DEFAULT_SHELL_NAME, "env_key": "YAI_SHELL_NAME", "type": str},
     "OS_NAME": {"value": DEFAULT_OS_NAME, "env_key": "YAI_OS_NAME", "type": str},
-    # API paths (usually no need to change for OpenAI compatible APIs)
-    "COMPLETION_PATH": {"value": DEFAULT_COMPLETION_PATH, "env_key": "YAI_COMPLETION_PATH", "type": str},
-    "ANSWER_PATH": {"value": DEFAULT_ANSWER_PATH, "env_key": "YAI_ANSWER_PATH", "type": str},
     # API call parameters
     "STREAM": {"value": DEFAULT_STREAM, "env_key": "YAI_STREAM", "type": bool},
     "TEMPERATURE": {"value": DEFAULT_TEMPERATURE, "env_key": "YAI_TEMPERATURE", "type": float},
     "TOP_P": {"value": DEFAULT_TOP_P, "env_key": "YAI_TOP_P", "type": float},
     "MAX_TOKENS": {"value": DEFAULT_MAX_TOKENS, "env_key": "YAI_MAX_TOKENS", "type": int},
     "TIMEOUT": {"value": DEFAULT_TIMEOUT, "env_key": "YAI_TIMEOUT", "type": int},
+    "REASONING_EFFORT": {"value": DEFAULT_REASONING_EFFORT, "env_key": "YAI_REASONING_EFFORT", "type": str},
     "INTERACTIVE_ROUND": {
         "value": DEFAULT_INTERACTIVE_ROUND,
         "env_key": "YAI_INTERACTIVE_ROUND",
@@ -136,6 +145,15 @@ DEFAULT_CONFIG_MAP = {
     # Chat history settings
     "CHAT_HISTORY_DIR": {"value": DEFAULT_CHAT_HISTORY_DIR, "env_key": "YAI_CHAT_HISTORY_DIR", "type": str},
     "MAX_SAVED_CHATS": {"value": DEFAULT_MAX_SAVED_CHATS, "env_key": "YAI_MAX_SAVED_CHATS", "type": int},
+    # Role settings
+    "ROLE_MODIFY_WARNING": {"value": DEFAULT_ROLE_MODIFY_WARNING, "env_key": "YAI_ROLE_MODIFY_WARNING", "type": bool},
+    # Function settings
+    "ENABLE_FUNCTIONS": {"value": DEFAULT_ENABLE_FUNCTIONS, "env_key": "YAI_ENABLE_FUNCTIONS", "type": bool},
+    "SHOW_FUNCTION_OUTPUT": {
+        "value": DEFAULT_SHOW_FUNCTION_OUTPUT,
+        "env_key": "YAI_SHOW_FUNCTION_OUTPUT",
+        "type": bool,
+    },
 }
 
 DEFAULT_CONFIG_INI = f"""[core]
@@ -148,10 +166,6 @@ MODEL={DEFAULT_CONFIG_MAP["MODEL"]["value"]}
 SHELL_NAME={DEFAULT_CONFIG_MAP["SHELL_NAME"]["value"]}
 OS_NAME={DEFAULT_CONFIG_MAP["OS_NAME"]["value"]}
 
-# API paths (usually no need to change for OpenAI compatible APIs)
-COMPLETION_PATH={DEFAULT_CONFIG_MAP["COMPLETION_PATH"]["value"]}
-ANSWER_PATH={DEFAULT_CONFIG_MAP["ANSWER_PATH"]["value"]}
-
 # true: streaming response, false: non-streaming
 STREAM={DEFAULT_CONFIG_MAP["STREAM"]["value"]}
 
@@ -160,6 +174,7 @@ TEMPERATURE={DEFAULT_CONFIG_MAP["TEMPERATURE"]["value"]}
 TOP_P={DEFAULT_CONFIG_MAP["TOP_P"]["value"]}
 MAX_TOKENS={DEFAULT_CONFIG_MAP["MAX_TOKENS"]["value"]}
 TIMEOUT={DEFAULT_CONFIG_MAP["TIMEOUT"]["value"]}
+REASONING_EFFORT=
 
 # Interactive mode parameters
 INTERACTIVE_ROUND={DEFAULT_CONFIG_MAP["INTERACTIVE_ROUND"]["value"]}
@@ -177,4 +192,14 @@ JUSTIFY={DEFAULT_CONFIG_MAP["JUSTIFY"]["value"]}
 # Chat history settings
 CHAT_HISTORY_DIR={DEFAULT_CONFIG_MAP["CHAT_HISTORY_DIR"]["value"]}
 MAX_SAVED_CHATS={DEFAULT_CONFIG_MAP["MAX_SAVED_CHATS"]["value"]}
+
+# Role settings
+# Set to false to disable warnings about modified built-in roles
+ROLE_MODIFY_WARNING={DEFAULT_CONFIG_MAP["ROLE_MODIFY_WARNING"]["value"]}
+
+# Function settings
+# Set to false to disable sending functions in API requests
+ENABLE_FUNCTIONS={DEFAULT_CONFIG_MAP["ENABLE_FUNCTIONS"]["value"]}
+# Set to false to disable showing function output in the response
+SHOW_FUNCTION_OUTPUT={DEFAULT_CONFIG_MAP["SHOW_FUNCTION_OUTPUT"]["value"]}
 """

yaicli/entry.py

@@ -3,15 +3,15 @@ from typing import Annotated, Any, Optional
 
 import typer
 
-from yaicli.chat_manager import FileChatManager
-from yaicli.cli import CLI
-from yaicli.config import cfg
-from yaicli.const import DEFAULT_CONFIG_INI, DefaultRoleNames, JustifyEnum
-from yaicli.roles import RoleManager
+from .chat import FileChatManager
+from .config import cfg
+from .const import DEFAULT_CONFIG_INI, DefaultRoleNames, JustifyEnum
+from .functions import install_functions, print_functions
+from .role import RoleManager
 
 app = typer.Typer(
     name="yaicli",
-    help="YAICLI - Yet Another AI CLI Interface.",
+    help="YAICLI - Your AI assistant in the command line.",
     context_settings={"help_option_names": ["-h", "--help"]},
     pretty_exceptions_enable=False,  # Let the CLI handle errors gracefully
     rich_markup_mode="rich",  # Render rich text in help messages
@@ -73,6 +73,14 @@ def main(
         min=1,
         callback=override_config,
     ),
+    stream: bool = typer.Option(  # noqa: F841
+        cfg["STREAM"],
+        "--stream/--no-stream",
+        help=f"Specify whether to stream the response. [dim](default: {'stream' if cfg['STREAM'] else 'no-stream'})[/dim]",
+        rich_help_panel="LLM Options",
+        show_default=False,
+        callback=override_config,
+    ),
     # ------------------- Role Options -------------------
     role: str = typer.Option(
         DefaultRoleNames.DEFAULT,
@@ -118,7 +126,7 @@ def main(
         help="Start in interactive chat mode.",
         rich_help_panel="Chat Options",
     ),
-    # ------------------- Shell Options -------------------
+    # # ------------------- Shell Options -------------------
     shell: bool = typer.Option(
         False,
         "--shell",
@@ -126,7 +134,7 @@ def main(
         help="Generate and optionally execute a shell command (non-interactive).",
         rich_help_panel="Shell Options",
     ),
-    # ------------------- Code Options -------------------
+    # # ------------------- Code Options -------------------
     code: bool = typer.Option(
         False,
         "--code",
@@ -157,7 +165,8 @@ def main(
     ),
     show_reasoning: bool = typer.Option(  # noqa: F841
         cfg["SHOW_REASONING"],
-        help=f"Show reasoning content from the LLM. [dim](default: {cfg['SHOW_REASONING']})[/dim]",
+        "--show-reasoning/--hide-reasoning",
+        help=f"Show reasoning content from the LLM. [dim](default: {'show' if cfg['SHOW_REASONING'] else 'hide'})[/dim]",
         rich_help_panel="Other Options",
         show_default=False,
         callback=override_config,
@@ -170,6 +179,37 @@ def main(
         rich_help_panel="Other Options",
         callback=override_config,
     ),
+    # ------------------- Function Options -------------------
+    install_functions: bool = typer.Option(  # noqa: F841
+        False,
+        "--install-functions",
+        help="Install default functions.",
+        rich_help_panel="Function Options",
+        callback=install_functions,
+    ),
+    list_functions: bool = typer.Option(  # noqa: F841
+        False,
+        "--list-functions",
+        help="List all available functions.",
+        rich_help_panel="Function Options",
+        callback=print_functions,
+    ),
+    enable_functions: bool = typer.Option(  # noqa: F841
+        cfg["ENABLE_FUNCTIONS"],
+        "--enable-functions/--disable-functions",
+        help=f"Enable/disable function calling in API requests [dim](default: {'enabled' if cfg['ENABLE_FUNCTIONS'] else 'disabled'})[/dim]",
+        rich_help_panel="Function Options",
+        show_default=False,
+        callback=override_config,
+    ),
+    show_function_output: bool = typer.Option(  # noqa: F841
+        cfg["SHOW_FUNCTION_OUTPUT"],
+        "--show-function-output/--hide-function-output",
+        help=f"Show the output of functions [dim](default: {'show' if cfg['SHOW_FUNCTION_OUTPUT'] else 'hide'})[/dim]",
+        rich_help_panel="Function Options",
+        show_default=False,
+        callback=override_config,
+    ),
 ):
     """YAICLI: Your AI assistant in the command line.
 
@@ -179,7 +219,7 @@ def main(
         print(DEFAULT_CONFIG_INI)
         raise typer.Exit()
 
-    # Combine prompt argument with stdin content if available
+    # # Combine prompt argument with stdin content if available
     final_prompt = prompt
     if not sys.stdin.isatty():
         stdin_content = sys.stdin.read().strip()
@@ -194,40 +234,29 @@ def main(
         if chat:
             print("Warning: --chat is ignored when stdin was redirected.")
             chat = False
+    if not any([final_prompt, chat]):
+        print(ctx.get_help())
+        return
 
-    # Basic validation for conflicting options or missing prompt
-    if not any([final_prompt, chat, list_chats, list_roles, create_role]):
-        # If no prompt, not starting chat, and not listing chats or roles, show help
-        typer.echo(ctx.get_help())
-        raise typer.Exit()
-
-    # Use build-in role for --shell or --code mode
+    # # Use build-in role for --shell or --code mode
     if role and role != DefaultRoleNames.DEFAULT and (shell or code):
         print("Warning: --role is ignored when --shell or --code is used.")
         role = DefaultRoleNames.DEFAULT
 
-    if code:
-        role = DefaultRoleNames.CODER
-
-    try:
-        # Instantiate the main CLI class with the specified role
-        cli_instance = CLI(verbose=verbose, role=role)
-
-        # Run the appropriate mode
-        cli_instance.run(
-            chat=chat,
-            shell=shell,
-            input=final_prompt,
-            role=role,
-        )
-    except Exception as e:
-        # Catch potential errors during CLI initialization or run
-        print(f"An error occurred: {e}")
-        if verbose:
-            import traceback
-
-            traceback.print_exc()
-        raise typer.Exit(code=1)
+    from yaicli.cli import CLI
+
+    role = CLI.evaluate_role_name(code, shell, role)
+
+    # Instantiate the main CLI class with the specified role
+    cli = CLI(verbose=verbose, role=role)
+
+    # Run the appropriate mode
+    cli.run(
+        chat=chat,
+        shell=shell,
+        code=code,
+        user_input=final_prompt,
+    )
 
 
 if __name__ == "__main__":

yaicli/exceptions.py

@@ -1,46 +1,18 @@
-class YAICLIException(Exception):
-    """Base exception for YAICLI"""
+class YaicliError(Exception):
+    """Base exception for yaicli"""
 
     def __init__(self, message: str):
         self.message = message
         super().__init__(self.message)
 
 
-###################################
-# Role exceptions
-class RoleNotFoundError(YAICLIException):
-    """Exception raised when a role is not found"""
+class ChatSaveError(YaicliError):
+    """Error saving chat"""
 
-    pass
 
+class ChatLoadError(YaicliError):
+    """Error loading chat"""
 
-class RoleAlreadyExistsError(YAICLIException):
-    """Exception raised when a role already exists"""
 
-    pass
-
-
-class RoleCreationError(YAICLIException):
-    """Exception raised when a role creation fails"""
-
-    pass
-
-
-###################################
-# Chat exceptions
-class ChatNotFoundError(YAICLIException):
-    """Exception raised when a chat is not found"""
-
-    pass
-
-
-class ChatSaveError(YAICLIException):
-    """Exception raised when a chat save fails"""
-
-    pass
-
-
-class ChatDeleteError(YAICLIException):
-    """Exception raised when a chat delete fails"""
-
-    pass
+class ChatDeleteError(YaicliError):
+    """Error deleting chat"""

yaicli/functions/__init__.py

@@ -0,0 +1,39 @@
+import shutil
+from pathlib import Path
+from typing import Any
+
+from ..console import get_console
+from ..const import FUNCTIONS_DIR
+from ..utils import option_callback
+
+console = get_console()
+
+
+@option_callback
+def install_functions(cls, _: Any) -> None:
+    """Install buildin functions"""
+    cur_dir = Path(__file__).absolute().parent
+    buildin_dir = cur_dir / "buildin"
+    buildin_funcs = [Path(path) for path in buildin_dir.glob("*.py")]
+    console.print("Installing buildin functions...")
+    if not FUNCTIONS_DIR.exists():
+        FUNCTIONS_DIR.mkdir(parents=True)
+    for file in buildin_funcs:
+        if (FUNCTIONS_DIR / file.name).exists():
+            # Skip if function already exists
+            console.print(f"Function {file.name} already exists, skipping.")
+            continue
+        shutil.copy(file, FUNCTIONS_DIR, follow_symlinks=True)
+        console.print(f"Installed {FUNCTIONS_DIR}/{file.name}")
+
+
+@option_callback
+def print_functions(cls, _: Any) -> None:
+    """List all available buildin functions"""
+    if not FUNCTIONS_DIR.exists():
+        console.print("No installed functions found.")
+        return
+    for file in FUNCTIONS_DIR.glob("*.py"):
+        if file.name.startswith("_"):
+            continue
+        console.print(file)

yaicli/functions/buildin/execute_shell_command.py

@@ -0,0 +1,47 @@
+import subprocess
+
+from instructor import OpenAISchema
+from pydantic import Field
+
+
+class Function(OpenAISchema):
+    """
+    Execute a shell command and return the output (result).
+    """
+
+    shell_command: str = Field(
+        ...,
+        json_schema_extra={
+            "example": "ls -la",
+        },
+        description="Shell command to execute.",
+    )
+
+    class Config:
+        title = "execute_shell_command"
+
+    @classmethod
+    def execute(cls, shell_command: str) -> str:
+        """
+        Execute a shell command and return the output (result).
+
+        Args:
+            shell_command (str): shell command to execute.
+
+        Returns:
+            str: exit code and output string.
+        """
+        # Optional security check
+        dangerous_commands = ["rm -rf", "mkfs", "dd"]
+        if any(cmd in shell_command for cmd in dangerous_commands):
+            return "Error: Dangerous command detected."
+
+        try:
+            process = subprocess.Popen(
+                shell_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
+            )
+            output, _ = process.communicate()
+            exit_code = process.returncode
+            return f"Exit code: {exit_code}, Output:\n{output}"
+        except Exception as e:
+            return f"Error: {str(e)}"