cliver 0.0.1__tar.gz

cliver-0.0.1/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.3
+Name: cliver
+Version: 0.0.1
+Summary: An AI Agent to make your CLI clever and more
+Author: Lin Gao
+Author-email: Lin Gao <aoingl@gmail.com>
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: prompt-toolkit>=3.0.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: mcp>=1.2.1
+Requires-Dist: openai>=1.0.0
+Requires-Dist: langchain>=0.3.0
+Requires-Dist: langchain-mcp-adapters>=0.1.4
+Requires-Dist: langchain-openai>=0.3.18
+Requires-Dist: langchain-core>=0.3.63
+Requires-Dist: langchain-ollama>=0.3.3
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: requests>=2.32.3
+Requires-Dist: json-repair>=0.52.0
+Requires-Python: >=3.10

cliver-0.0.1/pyproject.toml

@@ -0,0 +1,73 @@
+[project]
+name = "cliver"
+version = "0.0.1"
+description = "An AI Agent to make your CLI clever and more"
+authors = [
+    { name = "Lin Gao", email = "aoingl@gmail.com" }
+]
+requires-python = ">=3.10"
+
+dependencies = [
+    "click>=8.1.0",
+    "rich>=13.0.0",
+    "httpx>=0.24.0",
+    "pydantic>=2.0.0",
+    "prompt-toolkit>=3.0.0",
+    "pyyaml>=6.0.0",
+    "mcp>=1.2.1",
+    "openai>=1.0.0",
+    "langchain>=0.3.0",
+    "langchain-mcp-adapters>=0.1.4",
+    "langchain-openai>=0.3.18",
+    "langchain-core>=0.3.63",
+    "langchain-ollama>=0.3.3",
+    "python-dotenv>=1.1.0",
+    "jinja2>=3.1.0",
+    "requests>=2.32.3",
+    "json-repair>=0.52.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov",
+    "pytest-asyncio>=1.2.0",
+    "isort>=5.12.0",
+    "mypy>=1.0.0",
+    "ruff>=0.0.270",
+    "black>=25.1.0",
+]
+
+docs = [
+    "mkdocs>=1.4.0",
+    "mkdocs-material>=9.0.0",
+    "mkdocs-minify-plugin>=0.2.0",
+]
+
+[project.scripts]
+cliver = "cliver.cli:cliver_main"
+
+[build-system]
+requires = ["uv_build>=0.7,<0.8"]
+build-backend = "uv_build"
+
+[tool.uv]
+package = true
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+select = ["E", "F", "B", "I"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+

cliver-0.0.1/src/cliver/__init__.py

@@ -0,0 +1,6 @@
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from cliver.llm import TaskExecutor
+from cliver.media_handler import MultimediaResponseHandler, MultimediaResponse

cliver-0.0.1/src/cliver/builtin_tools.py

@@ -0,0 +1,83 @@
+"""Built-in tools that are always available for the LLM to use."""
+import inspect
+from typing import List, Dict, Any, Union
+from langchain_core.tools import BaseTool
+import cliver.tools
+import logging
+
+logger = logging.getLogger(__name__)
+
+# The builtin tools should be defined in the module: 'cliver.tools'
+# All builtin tools should have a global unique name either like: 'tool_name' or 'builtin#tool_name'
+def get_builtin_tools() -> List[BaseTool]:
+    """
+    Return a list of builtin tools that should always be available.
+
+    Returns:
+        List of BaseTool objects representing builtin tools
+    """
+
+    tools: List[BaseTool] = []
+    for name, obj in inspect.getmembers(cliver.tools):
+        if isinstance(obj, BaseTool):
+            logger.debug(f"Register builtin tool: {name}")
+            tools.append(obj)
+    return tools
+
+
+class BuiltinTools:
+    """
+    A class to manage built-in tools with caching and execution capabilities.
+    """
+
+    def __init__(self):
+        self._tools = None  # Cache for builtin tools
+
+    @property
+    def tools(self) -> List[BaseTool]:
+        """Get the list of builtin tools, caching them on first access."""
+        if self._tools is None:
+            self._tools = get_builtin_tools()
+        return self._tools
+
+    def execute_tool(self, tool_name: str, args: Union[str, Dict[str, Any]] = None) -> List[Dict[str, Any]]:
+        """
+        Execute a builtin tool by name with the provided arguments.
+
+        Args:
+            tool_name (str): The name of the tool to execute
+            args (Dict[str, Any]): Arguments to pass to the tool
+
+        Returns:
+            List[Dict[str, Any]]: The result of the tool execution
+        """
+        if args is None:
+            args = {}
+
+        # Find the tool by name
+        tool = None
+        for t in self.tools:
+            if t.name == tool_name or t.name == f"builtin#{tool_name}":
+                tool = t
+                break
+
+        if tool is None:
+            return [{"error": f"Tool '{tool_name}' not found in builtin tools"}]
+
+        try:
+            # Execute the tool
+            result = tool.invoke(input=args)
+
+            # Handle different result types
+            if isinstance(result, dict):
+                return [result]
+            elif isinstance(result, list):
+                return result
+            elif result is None:
+                return [{}]
+            else:
+                return [{"tool_result": str(result)}]
+
+        except Exception as e:
+            logger.error(f"Failed to execute builtin tool {tool_name}", exc_info=e)
+            return [{"error": str(e)}]

cliver-0.0.1/src/cliver/cli.py

@@ -0,0 +1,170 @@
+"""
+Cliver CLI Module
+
+The main entrance of the cliver application
+"""
+
+from shlex import split as shell_split
+import click
+import sys
+from prompt_toolkit import PromptSession
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.styles import Style
+from rich.console import Console
+from rich.panel import Panel
+
+from cliver.config import ConfigManager
+from cliver.llm import TaskExecutor
+from cliver import commands
+from cliver.util import get_config_dir, stdin_is_piped, read_piped_input
+from cliver.constants import *
+
+
+class Cliver:
+    """
+    The global App is the box for all capabilities.
+
+    """
+
+    def __init__(self):
+        """Initialize the Cliver application."""
+        # load config
+        self.config_dir = get_config_dir()
+        dir_str = str(self.config_dir.absolute())
+        if dir_str not in sys.path:
+            sys.path.append(dir_str)
+        self.config_manager = ConfigManager(self.config_dir)
+        self.task_executor = TaskExecutor(
+            llm_models=self.config_manager.list_llm_models(),
+            mcp_servers=self.config_manager.list_mcp_servers_for_mcp_caller(),
+            default_model=self.config_manager.get_llm_model(),
+        )
+        # prepare console for interaction
+        self.history_path = self.config_dir / "history"
+        self.session = None
+        self.console = Console()
+        self.piped = stdin_is_piped()
+
+    # TODO: we may need to maintain the selected model, and other options during the session initiation
+    def init_session(self, group: click.Group):
+        if self.piped or self.session is not None:
+            return
+        self.session = PromptSession(
+            history=FileHistory(str(self.history_path)),
+            auto_suggest=AutoSuggestFromHistory(),
+            completer=WordCompleter(self.load_commands_names(group), ignore_case=True),
+            style=Style.from_dict(
+                {
+                    "prompt": "ansigreen bold",
+                }
+            ),
+        )
+
+    def load_commands_names(self, group: click.Group) -> list[str]:
+        return commands.list_commands_names(group)
+
+    def run(self) -> None:
+        """Run the Cliver client."""
+        if self.piped:
+            user_data = read_piped_input()
+            if user_data is None:
+                self.console.print(
+                    "[bold yellow]No data received from stdin.[/bold yellow]"
+                )
+            else:
+                if not user_data.lower() in ("exit", "quit"):
+                    self.call_cmd(user_data)
+        else:
+            self.console.print(
+                Panel.fit(
+                    "[bold blue]CLIver[/bold blue] - AI Agent Command Line Interface",
+                    border_style="blue",
+                )
+            )
+            self.console.print(
+                "Type [bold green]/help[/bold green] to see available commands or start typing to interact with the AI."
+            )
+
+            while True:
+                try:
+                    # Get user input
+                    line = self.session.prompt("Cliver> ").strip()
+                    if line.lower() in ("exit", "quit", "/exit", "/quit"):
+                        break
+                    if line.startswith("/") and len(line) > 1:
+                        # possibly a command
+                        line = line[1:]
+                    elif not line.lower().startswith(f"{CMD_CHAT} "):
+                        line = f"{CMD_CHAT} {line}"
+
+                    self.call_cmd(line)
+
+                except KeyboardInterrupt:
+                    self.console.print(
+                        "\n[yellow]Use 'exit' or 'quit' to exit[/yellow]"
+                    )
+                except EOFError:
+                    break
+                except click.exceptions.NoArgsIsHelpError as e:
+                    self.console.print(f"{e.format_message()}")
+                except Exception as e:
+                    self.console.print(f"[red]Error: {e}[/red]")
+
+        # Clean up
+        self.cleanup()
+
+    def call_cmd(self, line: str):
+        """
+        Call a command with the given name and arguments.
+        """
+        parts = shell_split(line)
+        cliver(args=parts, prog_name="cliver", standalone_mode=False, obj=self)
+
+    def cleanup(self):
+        """
+        Clean up the resources opened by the application like the mcp server processes or connections to remote mcp servers, llm providers
+        """
+        # TODO
+        pass
+
+
+pass_cliver = click.make_pass_decorator(Cliver)
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+def cliver(ctx: click.Context):
+    """
+    Cliver: An application aims to make your CLI clever
+    """
+    cli = None
+    if ctx.obj is None:
+        cli = Cliver()
+        ctx.obj = cli
+
+    if ctx.invoked_subcommand is None:
+        # If no subcommand is invoked, show the help message
+        interact(cli)
+
+
+def interact(cli: Cliver):
+    """
+    Start an interactive session with the AI agent.
+    """
+    cli.init_session(cliver)
+    cli.run()
+
+
+def loads_commands():
+    commands.loads_commands(cliver)
+    # Loads extended commands from config dir
+    commands.loads_external_commands(cliver)
+
+
+def cliver_main(*args, **kwargs):
+    # loading all click groups and commands before calling it
+    loads_commands()
+    # bootstrap the cliver application
+    cliver()

cliver-0.0.1/src/cliver/cliver_run.py

@@ -0,0 +1,4 @@
+from cliver.cli import cliver_main
+
+if __name__ == "__main__":
+    cliver_main()

cliver-0.0.1/src/cliver/commands/__init__.py

@@ -0,0 +1,61 @@
+import logging
+import os
+import sys
+import click
+import importlib
+from typing import List, Callable
+from cliver.util import get_config_dir
+
+logger = logging.getLogger(__name__)
+
+def loads_commands(group: click.Group) -> None:
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    _load_commands_from_dir(
+        current_dir,
+        group,
+        package_name="cliver.commands",
+        filter_fn=lambda f_name: f_name != "__init__.py",
+    )
+
+# This will load py modules from config directory
+# This assumes the py modules are safe and should be set up manually.
+def loads_external_commands(group: click.Group) -> None:
+    config_dir = get_config_dir()
+    dir_str = str(config_dir.absolute() / "commands")
+    if dir_str not in sys.path:
+        sys.path.append(dir_str)
+    _load_commands_from_dir(dir_str, group, log=True)
+
+def _load_commands_from_dir(
+    commands_dir: str,
+    group: click.Group,
+    package_name: str = None,
+    filter_fn: Callable[[str], bool] = None,
+    log: bool = False,
+) -> None:
+    if commands_dir and not os.path.exists(commands_dir):
+        logger.warning("Commands directory: %s does not exist", commands_dir)
+        return
+    for filename in os.listdir(commands_dir):
+        if filename.endswith(".py"):
+            # either we don't filter or filter_fn returns True
+            if filter_fn is None or filter_fn(filename):
+                if log:
+                    full = os.path.abspath(os.path.join(commands_dir, filename))
+                    logger.debug("Loads command from: %s", full)
+                grp_name = filename[:-3]
+                module_name = f"{grp_name}"
+                if package_name is not None:
+                    module_name = f"{package_name}.{grp_name}"
+                module = importlib.import_module(module_name)
+                if hasattr(module, grp_name):
+                    cli_obj = getattr(module, grp_name)
+                    if isinstance(cli_obj, click.Command):
+                        group.add_command(cli_obj)
+                if hasattr(module, "post_group"):
+                    pg_obj = getattr(module, "post_group")
+                    pg_obj()
+
+
+def list_commands_names(group: click.Group) -> List[str]:
+    return [name for name, _ in group.commands.items()]

cliver-0.0.1/src/cliver/commands/capabilities.py

@@ -0,0 +1,71 @@
+"""
+Model capabilities command for Cliver client.
+"""
+
+import click
+from rich.table import Table
+
+from cliver.cli import Cliver, pass_cliver
+
+
+@click.command()
+@click.option("--model", "-m", help="Model name to check capabilities for")
+@click.option(
+    "--detailed", "-d", is_flag=True, help="Show detailed modality capabilities"
+)
+@pass_cliver
+def capabilities(cli: Cliver, model: str = None, detailed: bool = False):
+    """Display model capabilities."""
+    models = cli.config_manager.list_llm_models()
+
+    if not models:
+        cli.console.print("[yellow]No models configured.[/yellow]")
+        return
+
+    if model:
+        if model not in models:
+            cli.console.print(f"[red]Model '{model}' not found.[/red]")
+            return
+        models = {model: models[model]}
+
+    if detailed:
+        table = Table(title="Detailed Model Capabilities")
+        table.add_column("Model", style="cyan")
+        table.add_column("Provider", style="magenta")
+        table.add_column("Text", style="green")
+        table.add_column("Image In", style="blue")
+        table.add_column("Image Out", style="blue")
+        table.add_column("Audio In", style="yellow")
+        table.add_column("Audio Out", style="yellow")
+        table.add_column("Video In", style="purple")
+        table.add_column("Video Out", style="purple")
+        table.add_column("Tools", style="red")
+
+        for model_name, model_config in models.items():
+            capabilities = model_config.get_model_capabilities()
+            modality_caps = capabilities.get_modality_capabilities()
+            table.add_row(
+                model_name,
+                model_config.provider,
+                "✓" if modality_caps["text"] else "✗",
+                "✓" if modality_caps["image_input"] else "✗",
+                "✓" if modality_caps["image_output"] else "✗",
+                "✓" if modality_caps["audio_input"] else "✗",
+                "✓" if modality_caps["audio_output"] else "✗",
+                "✓" if modality_caps["video_input"] else "✗",
+                "✓" if modality_caps["video_output"] else "✗",
+                "✓" if modality_caps["tool_calling"] else "✗",
+            )
+    else:
+        table = Table(title="Model Capabilities")
+        table.add_column("Model", style="cyan")
+        table.add_column("Provider", style="magenta")
+        table.add_column("Capabilities", style="green")
+
+        for model_name, model_config in models.items():
+            capabilities = model_config.get_capabilities()
+            cap_names = [cap.value for cap in capabilities]
+            cap_str = ", ".join(cap_names) if cap_names else "None"
+            table.add_row(model_name, model_config.provider, cap_str)
+
+    cli.console.print(table)