siada-cli 0.0.1__py3-none-any.whl

siada/tools/coder/repo_map/special.py

@@ -0,0 +1,203 @@
+import os
+
+ROOT_IMPORTANT_FILES = [
+    # Version Control
+    ".gitignore",
+    ".gitattributes",
+    # Documentation
+    "README",
+    "README.md",
+    "README.txt",
+    "README.rst",
+    "CONTRIBUTING",
+    "CONTRIBUTING.md",
+    "CONTRIBUTING.txt",
+    "CONTRIBUTING.rst",
+    "LICENSE",
+    "LICENSE.md",
+    "LICENSE.txt",
+    "CHANGELOG",
+    "CHANGELOG.md",
+    "CHANGELOG.txt",
+    "CHANGELOG.rst",
+    "SECURITY",
+    "SECURITY.md",
+    "SECURITY.txt",
+    "CODEOWNERS",
+    # Package Management and Dependencies
+    "requirements.txt",
+    "Pipfile",
+    "Pipfile.lock",
+    "pyproject.toml",
+    "setup.py",
+    "setup.cfg",
+    "package.json",
+    "package-lock.json",
+    "yarn.lock",
+    "npm-shrinkwrap.json",
+    "Gemfile",
+    "Gemfile.lock",
+    "composer.json",
+    "composer.lock",
+    "pom.xml",
+    "build.gradle",
+    "build.gradle.kts",
+    "build.sbt",
+    "go.mod",
+    "go.sum",
+    "Cargo.toml",
+    "Cargo.lock",
+    "mix.exs",
+    "rebar.config",
+    "project.clj",
+    "Podfile",
+    "Cartfile",
+    "dub.json",
+    "dub.sdl",
+    # Configuration and Settings
+    ".env",
+    ".env.example",
+    ".editorconfig",
+    "tsconfig.json",
+    "jsconfig.json",
+    ".babelrc",
+    "babel.config.js",
+    ".eslintrc",
+    ".eslintignore",
+    ".prettierrc",
+    ".stylelintrc",
+    "tslint.json",
+    ".pylintrc",
+    ".flake8",
+    ".rubocop.yml",
+    ".scalafmt.conf",
+    ".dockerignore",
+    ".gitpod.yml",
+    "sonar-project.properties",
+    "renovate.json",
+    "dependabot.yml",
+    ".pre-commit-config.yaml",
+    "mypy.ini",
+    "tox.ini",
+    ".yamllint",
+    "pyrightconfig.json",
+    # Build and Compilation
+    "webpack.config.js",
+    "rollup.config.js",
+    "parcel.config.js",
+    "gulpfile.js",
+    "Gruntfile.js",
+    "build.xml",
+    "build.boot",
+    "project.json",
+    "build.cake",
+    "MANIFEST.in",
+    # Testing
+    "pytest.ini",
+    "phpunit.xml",
+    "karma.conf.js",
+    "jest.config.js",
+    "cypress.json",
+    ".nycrc",
+    ".nycrc.json",
+    # CI/CD
+    ".travis.yml",
+    ".gitlab-ci.yml",
+    "Jenkinsfile",
+    "azure-pipelines.yml",
+    "bitbucket-pipelines.yml",
+    "appveyor.yml",
+    "circle.yml",
+    ".circleci/config.yml",
+    ".github/dependabot.yml",
+    "codecov.yml",
+    ".coveragerc",
+    # Docker and Containers
+    "Dockerfile",
+    "docker-compose.yml",
+    "docker-compose.override.yml",
+    # Cloud and Serverless
+    "serverless.yml",
+    "firebase.json",
+    "now.json",
+    "netlify.toml",
+    "vercel.json",
+    "app.yaml",
+    "terraform.tf",
+    "main.tf",
+    "cloudformation.yaml",
+    "cloudformation.json",
+    "ansible.cfg",
+    "kubernetes.yaml",
+    "k8s.yaml",
+    # Database
+    "schema.sql",
+    "liquibase.properties",
+    "flyway.conf",
+    # Framework-specific
+    "next.config.js",
+    "nuxt.config.js",
+    "vue.config.js",
+    "angular.json",
+    "gatsby-config.js",
+    "gridsome.config.js",
+    # API Documentation
+    "swagger.yaml",
+    "swagger.json",
+    "openapi.yaml",
+    "openapi.json",
+    # Development environment
+    ".nvmrc",
+    ".ruby-version",
+    ".python-version",
+    "Vagrantfile",
+    # Quality and metrics
+    ".codeclimate.yml",
+    "codecov.yml",
+    # Documentation
+    "mkdocs.yml",
+    "_config.yml",
+    "book.toml",
+    "readthedocs.yml",
+    ".readthedocs.yaml",
+    # Package registries
+    ".npmrc",
+    ".yarnrc",
+    # Linting and formatting
+    ".isort.cfg",
+    ".markdownlint.json",
+    ".markdownlint.yaml",
+    # Security
+    ".bandit",
+    ".secrets.baseline",
+    # Misc
+    ".pypirc",
+    ".gitkeep",
+    ".npmignore",
+]
+
+
+# Normalize the lists once
+NORMALIZED_ROOT_IMPORTANT_FILES = set(os.path.normpath(path) for path in ROOT_IMPORTANT_FILES)
+
+
+def is_important(file_path):
+    file_name = os.path.basename(file_path)
+    dir_name = os.path.normpath(os.path.dirname(file_path))
+    normalized_path = os.path.normpath(file_path)
+
+    # Check for GitHub Actions workflow files
+    if dir_name == os.path.normpath(".github/workflows") and file_name.endswith(".yml"):
+        return True
+
+    return normalized_path in NORMALIZED_ROOT_IMPORTANT_FILES
+
+
+def filter_important_files(file_paths):
+    """
+    Filter a list of file paths to return only those that are commonly important in codebases.
+
+    :param file_paths: List of file paths to check
+    :return: List of file paths that match important file patterns
+    """
+    return list(filter(is_important, file_paths))

siada/tools/coder/repo_map/token_counter.py

@@ -0,0 +1,154 @@
+"""
+Token counting functionality for language models.
+
+Provides token calculation with litellm integration and fallback estimation.
+Supports any model with zero configuration and basic caching for performance.
+"""
+
+import logging
+from typing import Optional
+
+
+class TokenCounterModel:
+    """
+    Token counting model with litellm integration and fallback estimation.
+    
+    Uses litellm for accurate counting when available, otherwise falls back
+    to simple estimation (4 characters ≈ 1 token). Supports any model name
+    with basic caching mechanism.
+    """
+    
+    def __init__(self, model_name: str):
+        """
+        Initialize TokenCounterModel instance.
+        
+        Args:
+            model_name (str): Language model name (any name supported)
+        """
+        self.model_name = model_name
+        self._litellm_available = self._check_litellm_availability()
+        self._cache = {}
+        
+        logger = logging.getLogger(__name__)
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"Initialized TokenCounterModel: {self.model_name}")
+    
+    def token_count(self, text: str) -> int:
+        """
+        Calculate token count for given text.
+        
+        Args:
+            text (str): Text to count tokens for
+            
+        Returns:
+            int: Number of tokens
+        """
+        if not text:
+            return 0
+        
+        text_hash = hash(text)
+        if text_hash in self._cache:
+            return self._cache[text_hash]
+        
+        try:
+            if self._litellm_available:
+                token_count = self._count_with_litellm(text)
+            else:
+                token_count = self._count_with_estimation(text)
+            
+            if len(self._cache) >= 1000:
+                self._cache.clear()
+            self._cache[text_hash] = token_count
+            
+            return token_count
+            
+        except Exception as e:
+            logging.getLogger(__name__).warning(f"Token calculation failed, using estimation: {e}")
+            return self._count_with_estimation(text)
+    
+    def _check_litellm_availability(self) -> bool:
+        """Check if litellm is available."""
+        try:
+            from siada.provider.lazy_lite_llm import litellm
+            return True
+        except ImportError:
+            return False
+    
+    def _count_with_litellm(self, text: str) -> int:
+        """Count tokens using litellm."""
+        from siada.provider.lazy_lite_llm import litellm
+        response = litellm.token_counter(model=self.model_name, text=text)
+        return int(response)
+    
+    def _count_with_estimation(self, text: str) -> int:
+        """Count tokens using simple estimation (4 chars ≈ 1 token)."""
+        return max(1, len(text) // 4)
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"TokenCounterModel(model={self.model_name}, litellm={self._litellm_available})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"TokenCounterModel(model_name='{self.model_name}', litellm_available={self._litellm_available})"
+
+
+class OptimizedTokenCounterModel(TokenCounterModel):
+    """
+    Optimized token counter for long texts and large codebases.
+    
+    Uses sampling for texts exceeding the threshold to improve performance.
+    """
+    
+    def __init__(self, model_name: str, sampling_threshold: int = 10000):
+        """
+        Initialize optimized TokenCounterModel.
+        
+        Args:
+            model_name (str): Model name
+            sampling_threshold (int): Threshold for sampling, texts longer than this will use sampling
+        """
+        super().__init__(model_name)
+        self.sampling_threshold = sampling_threshold
+    
+    def token_count(self, text: str) -> int:
+        """
+        Optimized token counting with sampling for long texts.
+        
+        Args:
+            text (str): Text to count tokens for
+            
+        Returns:
+            int: Number of tokens
+        """
+        if not text:
+            return 0
+        
+        if len(text) <= self.sampling_threshold:
+            return super().token_count(text)
+        
+        return self._count_with_sampling(text)
+    
+    def _count_with_sampling(self, text: str) -> int:
+        """Count tokens for long text using sampling method."""
+        lines = text.splitlines(keepends=True)
+        num_lines = len(lines)
+        
+        if num_lines <= 100:
+            return super().token_count(text)
+        
+        step = max(1, num_lines // 100)
+        sampled_lines = lines[::step]
+        sample_text = "".join(sampled_lines)
+        
+        sample_tokens = super().token_count(sample_text)
+        
+        sample_length = len(sample_text)
+        total_length = len(text)
+        
+        if sample_length > 0:
+            estimated_tokens = int(sample_tokens * total_length / sample_length)
+        else:
+            estimated_tokens = self._count_with_estimation(text)
+        
+        return estimated_tokens

siada/tools/coder/repo_map/waiting.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python
+
+"""
+Thread-based, killable spinner utility.
+
+Use it like:
+
+    from .waiting import WaitingSpinner
+
+    spinner = WaitingSpinner("Waiting for LLM")
+    spinner.start()
+    ...  # long task
+    spinner.stop()
+"""
+
+import sys
+import threading
+import time
+
+from rich.console import Console
+
+
+class Spinner:
+    """
+    Minimal spinner that scans a single marker back and forth across a line.
+
+    The animation is pre-rendered into a list of frames.  If the terminal
+    cannot display unicode the frames are converted to plain ASCII.
+    """
+
+    last_frame_idx = 0  # Class variable to store the last frame index
+
+    def __init__(self, text: str, width: int = 7):
+        self.text = text
+        self.start_time = time.time()
+        self.last_update = 0.0
+        self.visible = False
+        self.is_tty = sys.stdout.isatty()
+        self.console = Console()
+
+        # Pre-render the animation frames using pure ASCII so they will
+        # always display, even on very limited terminals.
+        ascii_frames = [
+            "#=        ",  # C1 C2 space(8)
+            "=#        ",  # C2 C1 space(8)
+            " =#       ",  # space(1) C2 C1 space(7)
+            "  =#      ",  # space(2) C2 C1 space(6)
+            "   =#     ",  # space(3) C2 C1 space(5)
+            "    =#    ",  # space(4) C2 C1 space(4)
+            "     =#   ",  # space(5) C2 C1 space(3)
+            "      =#  ",  # space(6) C2 C1 space(2)
+            "       =# ",  # space(7) C2 C1 space(1)
+            "        =#",  # space(8) C2 C1
+            "        #=",  # space(8) C1 C2
+            "       #= ",  # space(7) C1 C2 space(1)
+            "      #=  ",  # space(6) C1 C2 space(2)
+            "     #=   ",  # space(5) C1 C2 space(3)
+            "    #=    ",  # space(4) C1 C2 space(4)
+            "   #=     ",  # space(3) C1 C2 space(5)
+            "  #=      ",  # space(2) C1 C2 space(6)
+            " #=       ",  # space(1) C1 C2 space(7)
+        ]
+
+        self.unicode_palette = "░█"
+        xlate_from, xlate_to = ("=#", self.unicode_palette)
+
+        # If unicode is supported, swap the ASCII chars for nicer glyphs.
+        if self._supports_unicode():
+            translation_table = str.maketrans(xlate_from, xlate_to)
+            frames = [f.translate(translation_table) for f in ascii_frames]
+            self.scan_char = xlate_to[xlate_from.find("#")]
+        else:
+            frames = ascii_frames
+            self.scan_char = "#"
+
+        # Bounce the scanner back and forth.
+        self.frames = frames
+        self.frame_idx = Spinner.last_frame_idx  # Initialize from class variable
+        self.width = len(frames[0]) - 2  # number of chars between the brackets
+        self.animation_len = len(frames[0])
+        self.last_display_len = 0  # Length of the last spinner line (frame + text)
+
+    def _supports_unicode(self) -> bool:
+        if not self.is_tty:
+            return False
+        try:
+            out = self.unicode_palette
+            out += "\b" * len(self.unicode_palette)
+            out += " " * len(self.unicode_palette)
+            out += "\b" * len(self.unicode_palette)
+            sys.stdout.write(out)
+            sys.stdout.flush()
+            return True
+        except UnicodeEncodeError:
+            return False
+        except Exception:
+            return False
+
+    def _next_frame(self) -> str:
+        frame = self.frames[self.frame_idx]
+        self.frame_idx = (self.frame_idx + 1) % len(self.frames)
+        Spinner.last_frame_idx = self.frame_idx  # Update class variable
+        return frame
+
+    def step(self, text: str = None) -> None:
+        if text is not None:
+            self.text = text
+
+        if not self.is_tty:
+            return
+
+        now = time.time()
+        if not self.visible and now - self.start_time >= 0.5:
+            self.visible = True
+            self.last_update = 0.0
+            if self.is_tty:
+                self.console.show_cursor(False)
+
+        if not self.visible or now - self.last_update < 0.1:
+            return
+
+        self.last_update = now
+        frame_str = self._next_frame()
+
+        # Determine the maximum width for the spinner line
+        # Subtract 2 as requested, to leave a margin or prevent cursor wrapping issues
+        max_spinner_width = self.console.width - 2
+        if max_spinner_width < 0:  # Handle extremely narrow terminals
+            max_spinner_width = 0
+
+        current_text_payload = f" {self.text}"
+        line_to_display = f"{frame_str}{current_text_payload}"
+
+        # Truncate the line if it's too long for the console width
+        if len(line_to_display) > max_spinner_width:
+            line_to_display = line_to_display[:max_spinner_width]
+
+        len_line_to_display = len(line_to_display)
+
+        # Calculate padding to clear any remnants from a longer previous line
+        padding_to_clear = " " * max(0, self.last_display_len - len_line_to_display)
+
+        # Write the spinner frame, text, and any necessary clearing spaces
+        sys.stdout.write(f"\r{line_to_display}{padding_to_clear}")
+        self.last_display_len = len_line_to_display
+
+        # Calculate number of backspaces to position cursor at the scanner character
+        scan_char_abs_pos = frame_str.find(self.scan_char)
+
+        # Total characters written to the line (frame + text + padding)
+        total_chars_written_on_line = len_line_to_display + len(padding_to_clear)
+
+        # num_backspaces will be non-positive if scan_char_abs_pos is beyond
+        # total_chars_written_on_line (e.g., if the scan char itself was truncated).
+        # (e.g., if the scan char itself was truncated).
+        # In such cases, (effectively) 0 backspaces are written,
+        # and the cursor stays at the end of the line.
+        num_backspaces = total_chars_written_on_line - scan_char_abs_pos
+        sys.stdout.write("\b" * num_backspaces)
+        sys.stdout.flush()
+
+    def end(self) -> None:
+        if self.visible and self.is_tty:
+            clear_len = self.last_display_len  # Use the length of the last displayed content
+            sys.stdout.write("\r" + " " * clear_len + "\r")
+            sys.stdout.flush()
+            self.console.show_cursor(True)
+        self.visible = False
+
+
+class WaitingSpinner:
+    """Background spinner that can be started/stopped safely."""
+
+    def __init__(self, text: str = "Waiting for LLM", delay: float = 0.15):
+        self.spinner = Spinner(text)
+        self.delay = delay
+        self._stop_event = threading.Event()
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+
+    def _spin(self):
+        while not self._stop_event.is_set():
+            self.spinner.step()
+            time.sleep(self.delay)
+        self.spinner.end()
+
+    def start(self):
+        """Start the spinner in a background thread."""
+        if not self._thread.is_alive():
+            self._thread.start()
+
+    def stop(self):
+        """Request the spinner to stop and wait briefly for the thread to exit."""
+        self._stop_event.set()
+        if self._thread.is_alive():
+            self._thread.join(timeout=self.delay)
+        self.spinner.end()
+
+    # Allow use as a context-manager
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+
+def main():
+    spinner = Spinner("Running spinner...")
+    try:
+        for _ in range(100):
+            time.sleep(0.15)
+            spinner.step()
+        print("Success!")
+    except KeyboardInterrupt:
+        print("\nInterrupted by user.")
+    finally:
+        spinner.end()
+
+
+if __name__ == "__main__":
+    main()

siada/tools/coder/reproduce_completion.py

@@ -0,0 +1,39 @@
+from agents import RunContextWrapper, function_tool
+
+from siada.foundation.code_agent_context import CodeAgentContext
+from siada.tools.coder.observation.observation import FunctionCallResult
+
+REPRODUCE_COMPLETION_DOCS = f"""ISSUE Reproduction Completion Tool
+Use this tool to submit your work results to the user whenever the ISSUE has been successfully reproduced—that is, when executing the test cases you generated can reliably reproduce the ISSUE. Include a brief description of your reproduction process.
+IMPORTANT NOTE: Do not invoke this tool unless the issue has been confirmed as reproduced.
+Args:
+    test_case: The full path of the test case used to reproduce the issue in the task.
+    bug_analysis: Analysis of the cause of the bug, including the involved code files, methods, and other relevant components.
+"""
+
+class ReproduceCompletionResult(FunctionCallResult):
+    def __init__(self, content: str):
+        super().__init__(content=content)
+    
+    def __str__(self):
+        return self.content
+    
+    def format_for_display(self):   
+        return "Reproduction Completed"
+
+
+@function_tool(
+    name_override="reproduce_completion", description_override=REPRODUCE_COMPLETION_DOCS, failure_error_function=None
+)
+async def reproduce_completion(context: RunContextWrapper[CodeAgentContext], test_case: str, bug_analysis: str) -> ReproduceCompletionResult:
+    # 获取 session_id
+    content = (f"====\n"
+            f"This issue can be reproduced using test case : {test_case}.\n Analysis of the issue: {bug_analysis} \n"
+            f"When you start fixing the issue, you must thoroughly refer to this information."
+            f"\n====")
+
+    return ReproduceCompletionResult(
+        content=content
+    )
+
+    

siada/tools/coder/run_cmd.py

@@ -0,0 +1,60 @@
+from agents import function_tool, RunContextWrapper
+
+from siada.foundation.code_agent_context import CodeAgentContext
+from siada.tools.coder.cmd_runner import run_cmd_impl
+from siada.tools.coder.observation.observation import FunctionCallResult
+
+
+RUN_CMD_DOCS = """Execute a shell command using the most appropriate method for the current environment.
+
+    This function automatically selects between pexpect (for interactive terminals on Unix-like
+    systems) and subprocess (for Windows or non-interactive environments) to execute shell
+    commands. It provides real-time output streaming and proper error handling.
+
+    Args:
+        command (str): The shell command to execute as a string.
+"""
+
+
+class RunCmdResult(FunctionCallResult):
+    """This data class represents the output of a command."""
+
+    def __init__(self, command: str, output: str, code: int):
+        self.command = command
+        self.output = output
+        self.code = code if code is not None else 1
+
+    @property
+    def content(self) -> str:
+        """Return the command output as content."""
+        return str((self.code, self.output))
+
+    def format_for_display(self) -> str:
+        if self.code == 0:
+            return f"`{self.command}` executed successfully!"
+        else:
+            return f"`{self.command}` executed with error!"
+
+    def __str__(self):
+        return self.content
+
+
+@function_tool
+def run_cmd(context: RunContextWrapper[CodeAgentContext], command) -> FunctionCallResult:
+    """Execute a shell command using the most appropriate method for the current environment.
+
+    This function automatically selects between pexpect (for interactive terminals on Unix-like
+    systems) and subprocess (for Windows or non-interactive environments) to execute shell
+    commands. It provides real-time output streaming and proper error handling.
+
+    Args:
+        command (str): The shell command to execute as a string.
+        verbose (bool, optional): If True, prints detailed execution information including
+            the execution method used, shell information, and command details. Defaults to False.
+        error_print (callable, optional): Custom error printing function. If provided, errors
+            will be output using this function instead of the default print(). Should accept
+            a single string argument. Defaults to None.
+    """
+    cwd = context.context.root_dir
+    code, output = run_cmd_impl(command=command, cwd=cwd)
+    return RunCmdResult(command=command, output=output, code=code)

siada/tools/coder/test_completion.py

@@ -0,0 +1,25 @@
+from agents import RunContextWrapper, function_tool
+
+from siada.foundation.code_agent_context import CodeAgentContext
+
+TEST_COMPLETION_DOCS = f"""Test Completion Tool
+Use this tool to submit your test work results to the user whenever the test task has been completed. This tool reports whether tests passed or failed and provides detailed information about the test execution.
+IMPORTANT NOTE: Do not invoke this tool unless the test task has been confirmed as completed.
+Args:
+    is_passed: Integer type, 0 indicates test failed, 1 indicates test passed.
+    test_detail: String type. If tests passed, describe which test cases were executed. If tests failed, describe each failed test case and the failure reason.
+"""
+
+
+@function_tool(
+    name_override="test_completion", description_override=TEST_COMPLETION_DOCS, failure_error_function=None
+)
+async def test_completion(context: RunContextWrapper[CodeAgentContext], is_passed: int, test_detail: str) -> str:
+    # 获取 session_id
+    test_result = "Tests passed" if is_passed == 1 else "Tests failed"
+
+    return {
+        "is_passed": is_passed,
+        "test_detail": test_result + ":" + test_detail
+    }
+