siada-cli 0.0.1__py3-none-any.whl

siada/provider/client_factory.py

@@ -0,0 +1,112 @@
+import os
+import importlib
+from typing import Dict, Any, Tuple
+from siada.provider.llm_client import LLMClient
+import inspect
+
+CLIENT_DIR = os.path.dirname(__file__)
+client_map: Dict[str, LLMClient] = {}
+
+def _discover_clients():
+    """
+    Dynamically discovers and registers all LLMClient implementations.
+    """
+    for item in os.listdir(CLIENT_DIR):
+        item_path = os.path.join(CLIENT_DIR, item)
+        if os.path.isdir(item_path):
+            client_key = item
+            for file_name in os.listdir(item_path):
+                if file_name.endswith(".py") and file_name != "__init__.py":
+                    module_name = f"siada.provider.{client_key}.{file_name[:-3]}"
+                    try:
+                        module = importlib.import_module(module_name)
+                        for attr_name in dir(module):
+                            attr = getattr(module, attr_name)
+                            if inspect.isclass(attr) and issubclass(attr, LLMClient) and attr is not LLMClient:
+                                client_map[client_key] = attr()
+                    except ImportError as e:
+                        print(f"Error importing client module {module_name}: {e}")
+
+_discover_clients()
+
+# The client keys are determined dynamically, so we use `str` for type hinting.
+provider_type = str
+
+
+def get_client(p_type: provider_type | None = None) -> LLMClient:
+    """
+    Retrieves the LLM client instance based on the client name.
+
+    Args:
+        p_type (provider_type | None): The name of the provider, e.g., 'li', 'openrouter'. 
+                                     If None, defaults to the first available client.
+
+    Returns:
+        LLMClient: The corresponding LLM client instance.
+
+    Raises:
+        ValueError: If the client name is not supported.
+    """
+    if p_type and p_type in client_map:
+        return client_map[p_type]
+
+    raise ValueError("No LLM clients found or registered.")
+
+
+def build_chat_complete_kwargs(context: Any, default_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Build chat completion kwargs by merging context parameters with defaults.
+    
+    Args:
+        context: Context object that may contain override parameters
+        default_kwargs: Default parameters for chat completion
+        
+    Returns:
+        Dict[str, Any]: Merged kwargs with context overrides taking precedence
+    """
+    # Start with default kwargs
+    complete_kwargs = default_kwargs.copy()
+    
+    # Override with context parameters if available
+    if context and hasattr(context, 'model') and context.model:
+        complete_kwargs['model'] = context.model
+    
+    if context and hasattr(context, 'temperature') and context.temperature is not None:
+        complete_kwargs['temperature'] = context.temperature
+    
+    if context and hasattr(context, 'stream') and context.stream is not None:
+        complete_kwargs['stream'] = context.stream
+    
+    # Add any other context parameters that might be relevant
+    if context:
+        # Check for additional parameters that might be set on context
+        for param in ['max_tokens', 'top_p', 'frequency_penalty', 'presence_penalty']:
+            if hasattr(context, param) and getattr(context, param) is not None:
+                complete_kwargs[param] = getattr(context, param)
+    
+    return complete_kwargs
+
+
+def get_client_with_kwargs(context: Any, default_kwargs: Dict[str, Any]) -> Tuple[LLMClient, Dict[str, Any]]:
+    """
+    Get LLM client and build complete kwargs with context overrides.
+    
+    Args:
+        context: Context object containing provider info and optional parameter overrides
+        default_kwargs: Default parameters for chat completion
+        
+    Returns:
+        Tuple[LLMClient, Dict[str, Any]]: Client instance and merged kwargs
+    """
+    # Get provider from context
+    provider = None
+    if context and hasattr(context, 'provider'):
+        provider = context.provider
+    
+    # Get the client
+    client = get_client(provider)
+    
+    # Build complete kwargs with context overrides
+    complete_kwargs = build_chat_complete_kwargs(context, default_kwargs)
+    
+    return client, complete_kwargs

siada/provider/llm_client.py

@@ -0,0 +1,11 @@
+
+
+from litellm.types.utils import ModelResponse as LitellmModelResponse
+from abc import ABC, abstractmethod
+
+
+class LLMClient(ABC):
+
+    @abstractmethod
+    def completion(self, **kwargs) -> LitellmModelResponse:
+        pass

siada/provider/openrouter/coverter.py

@@ -0,0 +1,17 @@
+def covert_to_openrouter_model_name(model_name: str) -> str:
+    temp_model_name = model_name
+    if model_name.startswith("claude-"):
+        temp_model_name = model_name.replace("claude-", "anthropic/claude-")
+    elif model_name.startswith("deepseek-"):
+        if model_name == "deepseek-v3-0324":
+            temp_model_name = "deepseek-chat-v3-0324"
+        temp_model_name = temp_model_name.replace("deepseek-", "deepseek/deepseek-")
+    elif model_name.startswith("o3-"):
+        temp_model_name = model_name.replace("o3-", "openai/o3-")
+    elif model_name.startswith("gpt-"):
+        temp_model_name = model_name.replace("gpt-", "openai/gpt-")
+    elif model_name.startswith("gemini-"):
+        temp_model_name = model_name.replace("gemini-", "google/gemini-")
+    elif model_name.startswith("kimi-"):
+        temp_model_name = model_name.replace("kimi-", "moonshotai/kimi-")
+    return f"openrouter/{temp_model_name}"

siada/provider/openrouter/openroute_provider.py

@@ -0,0 +1,33 @@
+from agents import Model, ModelProvider
+from agents.extensions.models.litellm_model import LitellmModel
+import litellm
+
+from siada.provider.llm_client import LLMClient
+from litellm.types.utils import ModelResponse as LitellmModelResponse
+
+from siada.provider.openrouter.coverter import covert_to_openrouter_model_name
+
+
+class OpenRouterProvider(ModelProvider):
+    """implementation of ModelProvider for OpenRouter by litellm"""
+
+    def get_model(self, model_name: str | None) -> Model:
+        """Get a model by name.
+
+        Args:
+            model_name: The name of the model to get.
+
+        Returns:
+            The model.
+        """
+
+        covert_model_name = covert_to_openrouter_model_name(model_name)
+        return LitellmModel(model=covert_model_name)
+
+
+class OpenRouterClient(LLMClient):
+
+    def completion(self, **kwargs) -> LitellmModelResponse:
+        model = kwargs.get("model")
+        kwargs["model"] = covert_to_openrouter_model_name(model)
+        return litellm.completion(**kwargs)

siada/provider/provider_factory.py

@@ -0,0 +1,53 @@
+import os
+import importlib
+from typing import Dict, Type
+from agents import ModelProvider
+import inspect
+
+PROVIDER_DIR = os.path.dirname(__file__)
+provider_map: Dict[str, ModelProvider] = {}
+
+def _discover_providers():
+    """
+    Dynamically discovers and registers all ModelProvider implementations.
+    """
+    for item in os.listdir(PROVIDER_DIR):
+        item_path = os.path.join(PROVIDER_DIR, item)
+        if os.path.isdir(item_path):
+            provider_key = item
+            for file_name in os.listdir(item_path):
+                if file_name.endswith("_provider.py"):
+                    module_name = f"siada.provider.{provider_key}.{file_name[:-3]}"
+                    try:
+                        module = importlib.import_module(module_name)
+                        for attr_name in dir(module):
+                            attr = getattr(module, attr_name)
+                            if inspect.isclass(attr) and issubclass(attr, ModelProvider) and attr is not ModelProvider:
+                                provider_map[provider_key] = attr()
+                    except ImportError as e:
+                        print(f"Error importing provider module {module_name}: {e}")
+
+_discover_providers()
+
+# The provider keys are determined dynamically, so we use `str` for type hinting.
+provider_type = str
+
+
+def get_provider(p_type: provider_type | None = None) -> ModelProvider:
+    """
+    Retrieves the model provider instance based on the provider name.
+
+    Args:
+        p_type (provider_type | None): The name of the provider, e.g., 'li'. 
+                                           If None, defaults to the first available provider.
+
+    Returns:
+        ModelProvider: The corresponding model provider instance.
+
+    Raises:
+        ValueError: If the provider name is not supported.
+    """
+    if p_type and p_type in provider_map:
+        return provider_map[p_type]
+
+    raise ValueError("No model providers found or registered.")

siada/queries/tree-sitter-language-pack/README.md

@@ -0,0 +1,7 @@
+These scm files are all adapted from the github repositories listed here:
+
+https://github.com/Goldziher/tree-sitter-language-pack/blob/main/sources/language_definitions.json
+
+See this URL for information on the licenses of each repo:
+
+https://github.com/Goldziher/tree-sitter-language-pack/

siada/queries/tree-sitter-language-pack/arduino-tags.scm

@@ -0,0 +1,5 @@
+(function_declarator
+  declarator: (identifier) @name.definition.function) @definition.function
+
+(call_expression
+  function: (identifier) @name.reference.call) @reference.call

siada/queries/tree-sitter-language-pack/c-tags.scm

@@ -0,0 +1,9 @@
+(struct_specifier name: (type_identifier) @name.definition.class body:(_)) @definition.class
+
+(declaration type: (union_specifier name: (type_identifier) @name.definition.class)) @definition.class
+
+(function_declarator declarator: (identifier) @name.definition.function) @definition.function
+
+(type_definition declarator: (type_identifier) @name.definition.type) @definition.type
+
+(enum_specifier name: (type_identifier) @name.definition.type) @definition.type

siada/queries/tree-sitter-language-pack/chatito-tags.scm

@@ -0,0 +1,16 @@
+; Definitions
+(intent_def
+  (intent) @name.definition.intent) @definition.intent
+
+(slot_def
+  (slot) @name.definition.slot) @definition.slot
+
+(alias_def
+  (alias) @name.definition.alias) @definition.alias
+
+; References
+(slot_ref
+  (slot) @name.reference.slot) @reference.slot
+
+(alias_ref
+  (alias) @name.reference.alias) @reference.alias

siada/queries/tree-sitter-language-pack/commonlisp-tags.scm

@@ -0,0 +1,122 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; Function Definitions ;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun_header
+  function_name: (sym_lit) @name.definition.function) @definition.function
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; Function Calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; Basically, we consider every list literal with symbol as the
+;;; first element to be a call to a function named by that element.
+;;; But we must exclude some cases. Note, tree-sitter @ignore
+;;; cases only work if they are declared before the cases
+;;; we want to include.
+
+;; Exclude lambda lists for function definitions
+;; For example:
+;;
+;;    (defun my-func (arg1 arg2) ...)
+;;
+;; do not treat (arg1 arg2) as a call of function arg1
+;;
+(defun_header
+  lambda_list: (list_lit . [(sym_lit) (package_lit)] @ignore))
+
+;; Similar to the above, but for
+;;
+;;     (defmethod m ((type1 param1) (type2 param2)) ...)
+;;
+;; where list literals having symbol as their first element
+;; are nested inside the lambda list.
+(defun_header
+  lambda_list: (list_lit (list_lit . [(sym_lit) (package_lit)] @ignore)))
+
+;;
+;;      (let ((var ...) (var2 ...)) ...)
+;;
+;; - exclude var, var2
+;; - the same for let*, flet, labels, macrolet, symbol-macrolet
+(list_lit . [(sym_lit) (package_lit)] @name.reference.call
+          . (list_lit (list_lit . [(sym_lit) (package_lit)] @ignore))
+          (#match? @name.reference.call
+                   "(?i)^(cl:)?(let|let\\*|flet|labels|macrolet|symbol-macrolet)$")
+  )
+
+;; TODO:
+;;     - exclude also:
+;;       - (defclass name (parent parent2)
+;;           ((slot1 ...)
+;;            (slot2 ...))
+;;              exclude the parent, slot1, slot2
+;;       - (flet ((func-1 (param1 param2))) ...)
+;;           - we already exclude func-1, but param1 is still recognized
+;;             as a function call - exclude it too
+;;           - the same for labels
+;;           - the same macrolet
+;;       - what else?
+;;         (that's a non-goal to completely support all macros
+;;          and special operators, but every one we support
+;;          makes the solution a little bit better)
+;;     - (flet ((func-1 (param1 param2))) ...)
+;;       - instead of simply excluding it, as we do today,
+;;         tag func-1 as @local.definition.function (I suppose)
+;;       - the same for labels, macrolet
+;;     - @local.scope for let, let*, flet, labels, macrolet
+;;       - I guess the whole span of the scope text,
+;;         till the closing paren, should be tagged as @local.scope;
+;;         Hopefully, combined with @local.definition.function
+;;         within the scope, the usual  @reference.call within
+;;         that scope will refer to the local definition,
+;;         and there will be no need to use @local.reference.call
+;;         (which is more difficult to implement).
+;;       - When implementing, remember the scope rules differences
+;;         of let vs let*, flet vs labels.
+
+
+;; Include all other cases - list literal with symbol as the
+;; first element
+(list_lit . [(sym_lit) (package_lit)] @name.reference.call) @reference.call
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; classes
+
+(list_lit . [(sym_lit) (package_lit)] @ignore
+          . [(sym_lit) (package_lit)] @name.definition.class
+  (#match? @ignore "(?i)^(cl:)?defclass$")
+          ) @definition.class
+
+(list_lit . [(sym_lit) (package_lit)] @ignore
+          . (quoting_lit [(sym_lit) (package_lit)] @name.reference.class)
+  (#match? @ignore "(?i)^(cl:)?make-instance$")
+          ) @reference.class
+
+;;; TODO:
+;;  - @reference.class for base classes
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; TODO:
+;; - Symbols referenced in defpackage
+;;
+;;       (defpackage ...
+;;         (:export (symbol-a :symbol-b #:symbol-c "SYMBOL-D")))
+;;
+;;   The goal is to allow quick navigation from the API
+;;   overview in the form of defpackage, to the definition
+;;   where user can read parameters, docstring, etc.
+;;   - The @name must not include the colon, or sharpsign colon, quotes,
+;;     just symbol-a, symbol-b, symbol-c, sybmol-d
+;;   - Downcase the names specified as string literals?
+;;     ("SYMBOL-D" -> symbol-d)
+;;   - We don't know if the exported symbol is a function, variable,
+;;     class or something else. The official doc
+;;     (https://tree-sitter.github.io/tree-sitter/code-navigation-systems)
+;;     does not even suggest a tag for variable reference.
+;;     (Although in practice, the `tree-sitter tags` command
+;;     allows any @reference.* and @definition.* tags)
+;;     Probably it's better to just use @reference.call for all
+;;     the symbols in the :export clause.
+;;
+;; - The same for the export function call:
+;; 
+;;       (export '(symbol-a :symbol-b #:symbol-c "SYMBOL-D"))

siada/queries/tree-sitter-language-pack/cpp-tags.scm

@@ -0,0 +1,15 @@
+(struct_specifier name: (type_identifier) @name.definition.class body:(_)) @definition.class
+
+(declaration type: (union_specifier name: (type_identifier) @name.definition.class)) @definition.class
+
+(function_declarator declarator: (identifier) @name.definition.function) @definition.function
+
+(function_declarator declarator: (field_identifier) @name.definition.function) @definition.function
+
+(function_declarator declarator: (qualified_identifier scope: (namespace_identifier) @local.scope name: (identifier) @name.definition.method)) @definition.method
+
+(type_definition declarator: (type_identifier) @name.definition.type) @definition.type
+
+(enum_specifier name: (type_identifier) @name.definition.type) @definition.type
+
+(class_specifier name: (type_identifier) @name.definition.class) @definition.class

siada/queries/tree-sitter-language-pack/csharp-tags.scm

@@ -0,0 +1,26 @@
+; Based on https://github.com/tree-sitter/tree-sitter-c-sharp/blob/master/queries/tags.scm
+; MIT License.
+
+(class_declaration name: (identifier) @name.definition.class) @definition.class
+
+(class_declaration (base_list (_) @name.reference.class)) @reference.class
+
+(interface_declaration name: (identifier) @name.definition.interface) @definition.interface
+
+(interface_declaration (base_list (_) @name.reference.interface)) @reference.interface
+
+(method_declaration name: (identifier) @name.definition.method) @definition.method
+
+(object_creation_expression type: (identifier) @name.reference.class) @reference.class
+
+(type_parameter_constraints_clause (identifier) @name.reference.class) @reference.class
+
+(type_parameter_constraint (type type: (identifier) @name.reference.class)) @reference.class
+
+(variable_declaration type: (identifier) @name.reference.class) @reference.class
+
+(invocation_expression function: (member_access_expression name: (identifier) @name.reference.send)) @reference.send
+
+(namespace_declaration name: (identifier) @name.definition.module) @definition.module
+
+(namespace_declaration name: (identifier) @name.definition.module) @module

siada/queries/tree-sitter-language-pack/d-tags.scm

@@ -0,0 +1,26 @@
+(module_def (module_declaration (module_fqn) @name.definition.module)) @definition.module
+
+(struct_declaration (struct) . (identifier) @name.definition.class) @definition.class
+(interface_declaration (interface) . (identifier) @name.definition.interface) @definition.interface
+(enum_declaration (enum) . (identifier) @name.definition.type) @definition.type
+
+(class_declaration (class) . (identifier) @name.definition.class) @definition.class
+(constructor (this) @name.definition.method) @definition.method
+(destructor (this) @name.definition.method) @definition.method
+(postblit (this) @name.definition.method) @definition.method
+
+(manifest_declarator . (identifier) @name.definition.type) @definition.type
+
+(function_declaration (identifier) @name.definition.function) @definition.function
+
+(union_declaration (union) . (identifier) @name.definition.type) @definition.type
+
+(anonymous_enum_declaration (enum_member . (identifier) @name.definition.constant)) @definition.constant
+
+(enum_declaration (enum_member . (identifier) @name.definition.constant)) @definition.constant
+
+(call_expression (identifier) @name.reference.call) @reference.call
+(call_expression (type (template_instance (identifier) @name.reference.call))) @reference.call
+(parameter (type (identifier) @name.reference.class) @reference.class (identifier))
+
+(variable_declaration (type (identifier) @name.reference.class) @reference.class (declarator))

siada/queries/tree-sitter-language-pack/dart-tags.scm

@@ -0,0 +1,92 @@
+
+(class_definition
+  name: (identifier) @name.definition.class) @definition.class
+
+(method_signature
+  (function_signature)) @definition.method
+
+(type_alias
+  (type_identifier) @name.definition.type) @definition.type
+
+(method_signature
+(getter_signature
+  name: (identifier) @name.definition.method)) @definition.method
+
+(method_signature
+(setter_signature
+  name: (identifier) @name.definition.method)) @definition.method 
+
+(method_signature
+  (function_signature
+  name: (identifier) @name.definition.method)) @definition.method
+
+(method_signature
+  (factory_constructor_signature
+    (identifier) @name.definition.method)) @definition.method
+
+(method_signature
+  (constructor_signature
+  name: (identifier) @name.definition.method)) @definition.method
+
+(method_signature
+  (operator_signature)) @definition.method
+
+(method_signature) @definition.method
+
+(mixin_declaration
+  (mixin)
+  (identifier) @name.definition.mixin) @definition.mixin
+
+(extension_declaration
+  name: (identifier) @name.definition.extension) @definition.extension
+
+
+(new_expression
+  (type_identifier) @name.reference.class) @reference.class
+
+(enum_declaration
+  name: (identifier) @name.definition.enum) @definition.enum
+
+(function_signature
+  name: (identifier) @name.definition.function) @definition.function 
+
+(initialized_variable_definition
+  name: (identifier)
+  value: (identifier) @name.reference.class 
+  value: (selector
+	"!"?
+	(argument_part 
+	  (arguments
+	    (argument)*))?)?) @reference.class
+
+(assignment_expression
+  left: (assignable_expression 
+		  (identifier)
+		  (unconditional_assignable_selector
+			"."
+			(identifier) @name.reference.send))) @reference.call
+
+(assignment_expression
+  left: (assignable_expression 
+		  (identifier)
+		  (conditional_assignable_selector
+			"?."
+			(identifier) @name.reference.send))) @reference.call
+
+((identifier) @name.reference.send
+ (selector
+    "!"?
+    (conditional_assignable_selector
+      "?." (identifier) @name.reference.send)?
+    (unconditional_assignable_selector
+      "."? (identifier) @name.reference.send)?
+    (argument_part
+      (arguments
+        (argument)*))?)*
+	(cascade_section
+	  (cascade_selector
+		(identifier)) @name.reference.send 
+	  (argument_part 
+		(arguments
+		  (argument)*))?)?) @reference.call
+

siada/queries/tree-sitter-language-pack/elisp-tags.scm

@@ -0,0 +1,5 @@
+;; defun/defsubst
+(function_definition name: (symbol) @name.definition.function) @definition.function
+
+;; Treat macros as function definitions for the sake of TAGS.
+(macro_definition name: (symbol) @name.definition.function) @definition.function

siada/queries/tree-sitter-language-pack/elixir-tags.scm

@@ -0,0 +1,54 @@
+; Definitions
+
+; * modules and protocols
+(call
+  target: (identifier) @ignore
+  (arguments (alias) @name.definition.module)
+  (#any-of? @ignore "defmodule" "defprotocol")) @definition.module
+
+; * functions/macros
+(call
+  target: (identifier) @ignore
+  (arguments
+    [
+      ; zero-arity functions with no parentheses
+      (identifier) @name.definition.function
+      ; regular function clause
+      (call target: (identifier) @name.definition.function)
+      ; function clause with a guard clause
+      (binary_operator
+        left: (call target: (identifier) @name.definition.function)
+        operator: "when")
+    ])
+  (#any-of? @ignore "def" "defp" "defdelegate" "defguard" "defguardp" "defmacro" "defmacrop" "defn" "defnp")) @definition.function
+
+; References
+
+; ignore calls to kernel/special-forms keywords
+(call
+  target: (identifier) @ignore
+  (#any-of? @ignore "def" "defp" "defdelegate" "defguard" "defguardp" "defmacro" "defmacrop" "defn" "defnp" "defmodule" "defprotocol" "defimpl" "defstruct" "defexception" "defoverridable" "alias" "case" "cond" "else" "for" "if" "import" "quote" "raise" "receive" "require" "reraise" "super" "throw" "try" "unless" "unquote" "unquote_splicing" "use" "with"))
+
+; ignore module attributes
+(unary_operator
+  operator: "@"
+  operand: (call
+    target: (identifier) @ignore))
+
+; * function call
+(call
+  target: [
+   ; local
+   (identifier) @name.reference.call
+   ; remote
+   (dot
+     right: (identifier) @name.reference.call)
+  ]) @reference.call
+
+; * pipe into function call
+(binary_operator
+  operator: "|>"
+  right: (identifier) @name.reference.call) @reference.call
+
+; * modules
+(alias) @name.reference.module @reference.module

siada/queries/tree-sitter-language-pack/elm-tags.scm

@@ -0,0 +1,19 @@
+(value_declaration (function_declaration_left (lower_case_identifier) @name.definition.function)) @definition.function
+
+(function_call_expr (value_expr (value_qid) @name.reference.function)) @reference.function
+(exposed_value (lower_case_identifier) @name.reference.function) @reference.function
+(type_annotation ((lower_case_identifier) @name.reference.function) (colon)) @reference.function
+
+(type_declaration ((upper_case_identifier) @name.definition.type) ) @definition.type
+
+(type_ref (upper_case_qid (upper_case_identifier) @name.reference.type)) @reference.type
+(exposed_type (upper_case_identifier) @name.reference.type) @reference.type
+
+(type_declaration (union_variant (upper_case_identifier) @name.definition.union)) @definition.union
+
+(value_expr (upper_case_qid (upper_case_identifier) @name.reference.union)) @reference.union
+
+
+(module_declaration 
+    (upper_case_qid (upper_case_identifier)) @name.definition.module
+) @definition.module