acra-cli 0.1.1__py3-none-any.whl

acra/tools/code_tools/file_writer.py

@@ -0,0 +1,108 @@
+import logging
+from pathlib import Path
+from typing import Dict
+
+from acra.config import GENERATED_PROJECT_DIR, PROJECT_ROOT
+
+
+# file writer tool
+
+logger = logging.getLogger(__name__)
+
+
+def _resolve_allowed_path(filepath: str) -> Path:
+    target = Path(filepath).expanduser().resolve()
+    allowed_roots = [
+        Path(PROJECT_ROOT).resolve(),
+        Path(GENERATED_PROJECT_DIR).resolve(),
+    ]
+
+    if not any(target == root or target.is_relative_to(root) for root in allowed_roots):
+        raise ValueError(f"Refusing to write outside allowed roots: {filepath}")
+
+    return target
+
+
+class FileWriterTool:
+    """
+    File writing utility.
+
+    Responsibilities:
+    - create files
+    - update files
+    - create directories
+    - support generated projects
+    """
+
+
+    # write file
+
+    @staticmethod
+    def write_file(
+        filepath: str,
+        content: str
+    ) -> Dict:
+        """
+        Write content to file.
+        """
+
+        try:
+            safe_path = _resolve_allowed_path(filepath)
+
+            safe_path.parent.mkdir(
+                parents=True,
+                exist_ok=True
+            )
+
+            with open(
+                safe_path,
+                "w",
+                encoding="utf-8"
+            ) as f:
+
+                f.write(content)
+
+            logger.info(f"File written: {filepath} ({len(content)} bytes)")
+
+            return {
+
+                "success": True,
+
+                "filepath": str(safe_path)
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to write file {filepath}: {e}", exc_info=True)
+
+            return {
+
+                "success": False,
+
+                "filepath": filepath,
+
+                "error": str(e)
+            }
+
+
+    # write multiple files
+
+    @staticmethod
+    def write_files(
+        files: Dict[str, str]
+    ) -> Dict:
+        """
+        Write multiple files.
+        """
+
+        results = {}
+
+        for filepath, content in files.items():
+
+            results[filepath] = (
+                FileWriterTool.write_file(
+                    filepath=filepath,
+                    content=content
+                )
+            )
+
+        return results

acra/tools/code_tools/python_repl.py

@@ -0,0 +1,72 @@
+import contextlib
+import io
+import traceback
+from typing import Dict
+
+
+# python repl tool
+
+class PythonREPLTool:
+    """
+    Dynamic Python execution tool.
+
+    Responsibilities:
+    - execute Python snippets
+    - capture stdout/stderr
+    - support debugging workflows
+    - provide runtime experimentation
+    """
+
+    def __init__(self):
+        pass
+
+
+    # execute tool
+
+    def execute(
+        self,
+        code: str
+    ) -> Dict:
+        """
+        Execute Python code safely with fresh globals for each execution.
+        """
+
+        fresh_globals = {}
+        stdout_buffer = io.StringIO()
+
+        try:
+
+            with contextlib.redirect_stdout(
+                stdout_buffer
+            ):
+
+                exec(code, fresh_globals)
+
+            return {
+
+                "success": True,
+
+                "stdout": (
+                    stdout_buffer.getvalue()
+                ),
+
+                "error": None
+            }
+
+        except Exception:
+
+            return {
+
+                "success": False,
+
+                "stdout": (
+                    stdout_buffer.getvalue()
+                ),
+
+                "error": traceback.format_exc()
+            }
+
+
+# global helper 
+
+python_repl = PythonREPLTool()

acra/tools/code_tools/terminal_runner.py

@@ -0,0 +1,98 @@
+import subprocess
+from typing import Dict, Optional
+
+
+# terminal runner tool
+
+class TerminalRunnerTool:
+    """
+    Terminal command execution tool.
+
+    Responsibilities:
+    - execute shell commands
+    - capture stdout/stderr
+    - support workflow automation
+    - assist execution/debugging
+    """
+
+
+    # run command
+
+    @staticmethod
+    def run_command(
+        command: str,
+        cwd: Optional[str] = None,
+        timeout: int = 60
+    ) -> Dict:
+        """
+        Execute terminal command.
+        """
+
+        try:
+
+            result = subprocess.run(
+
+                command,
+
+                shell=True,
+
+                capture_output=True,
+
+                text=True,
+
+                cwd=cwd,
+
+                timeout=timeout
+            )
+
+            success = (
+                result.returncode == 0
+            )
+
+            return {
+
+                "success": success,
+
+                "command": command,
+
+                "stdout": result.stdout,
+
+                "stderr": result.stderr,
+
+                "return_code": (
+                    result.returncode
+                )
+            }
+
+        except subprocess.TimeoutExpired:
+
+            return {
+
+                "success": False,
+
+                "command": command,
+
+                "stdout": "",
+
+                "stderr": (
+                    "Command timed out."
+                )
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "command": command,
+
+                "stdout": "",
+
+                "stderr": str(e)
+            }
+
+
+# global helper 
+
+terminal_runner = TerminalRunnerTool()

acra/tools/github_tools/__init__.py

@@ -0,0 +1 @@
+# Package acra/tools/github_tools

acra/tools/github_tools/commit_generator.py

@@ -0,0 +1,91 @@
+from typing import Dict, List
+
+
+# commit generator tool
+
+class CommitMessageGenerator:
+    """
+    Git commit message generator.
+
+    Responsibilities:
+    - generate meaningful commit messages
+    - summarize code changes
+    - support workflow automation
+    """
+
+
+    # generate commit msg
+
+    @staticmethod
+    def generate_commit_message(
+        changed_files: List[str],
+        change_summary: str,
+        commit_type: str = "feat"
+    ) -> Dict:
+        """
+        Generate standardized commit message.
+        """
+
+        try:
+
+            short_summary = (
+                change_summary.strip()
+                .replace("\n", " ")
+            )
+
+            if len(short_summary) > 72:
+
+                short_summary = (
+                    short_summary[:72] + "..."
+                )
+
+            commit_message = (
+                f"{commit_type}: "
+                f"{short_summary}"
+            )
+
+            detailed_description = {
+
+                "commit_message": commit_message,
+
+                "changed_files": changed_files,
+
+                "summary": change_summary
+            }
+
+            return {
+
+                "success": True,
+
+                "commit": detailed_description
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "error": str(e)
+            }
+
+
+# global helper 
+
+def generate_commit_message(
+    changed_files: List[str],
+    change_summary: str,
+    commit_type: str = "feat"
+) -> Dict:
+    """
+    Simple commit generator helper.
+    """
+
+    return (
+        CommitMessageGenerator
+        .generate_commit_message(
+            changed_files=changed_files,
+            change_summary=change_summary,
+            commit_type=commit_type
+        )
+    )

acra/tools/github_tools/github_search.py

@@ -0,0 +1,113 @@
+import os
+from typing import Dict, List
+
+from github import Github
+
+
+# github client
+
+GITHUB_TOKEN = os.getenv(
+    "GITHUB_TOKEN"
+)
+
+github_client = Github(GITHUB_TOKEN)
+
+
+# github search tool
+
+class GitHubSearchTool:
+    """
+    GitHub repository search tool.
+
+    Responsibilities:
+    - search repositories
+    - retrieve implementation references
+    - support technical research
+    - discover open-source patterns
+    """
+
+    def __init__(
+        self,
+        max_results: int = 5
+    ):
+
+        self.max_results = max_results
+
+
+    # search repo
+
+    def search_repositories(
+        self,
+        query: str
+    ) -> Dict:
+        """
+        Search GitHub repositories.
+        """
+
+        try:
+
+            repositories = (
+                github_client.search_repositories(
+                    query=query
+                )
+            )
+
+            results = []
+
+            for repo in repositories[
+                :self.max_results
+            ]:
+
+                results.append({
+
+                    "name": repo.full_name,
+
+                    "description": repo.description,
+
+                    "stars": repo.stargazers_count,
+
+                    "language": repo.language,
+
+                    "url": repo.html_url,
+
+                    "topics": repo.get_topics()
+                })
+
+            return {
+
+                "success": True,
+
+                "query": query,
+
+                "repositories": results
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "query": query,
+
+                "error": str(e),
+
+                "repositories": []
+            }
+
+
+# global helper 
+
+def github_search(
+    query: str,
+    max_results: int = 5
+) -> Dict:
+    """
+    Simple GitHub repository search helper.
+    """
+
+    tool = GitHubSearchTool(
+        max_results=max_results
+    )
+
+    return tool.search_repositories(query)

acra/tools/github_tools/repo_analyzer.py

@@ -0,0 +1,138 @@
+import os
+from typing import Dict, List
+
+from github import Github
+
+
+# github client
+
+GITHUB_TOKEN = os.getenv(
+    "GITHUB_TOKEN"
+)
+
+github_client = Github(GITHUB_TOKEN)
+
+
+# repo analyzer
+
+class RepoAnalyzerTool:
+    """
+    GitHub repository analysis tool.
+
+    Responsibilities:
+    - inspect repository structure
+    - analyze technologies
+    - retrieve important files
+    - support implementation research
+    """
+
+
+    # analyze repo
+
+    def analyze_repository(
+        self,
+        repo_name: str
+    ) -> Dict:
+        """
+        Analyze GitHub repository.
+        """
+
+        try:
+
+            repo = github_client.get_repo(
+                repo_name
+            )
+
+            contents = repo.get_contents("")
+
+            file_structure = []
+
+            important_files = []
+
+            while contents:
+
+                file_content = contents.pop(0)
+
+                if file_content.type == "dir":
+
+                    contents.extend(
+                        repo.get_contents(
+                            file_content.path
+                        )
+                    )
+
+                else:
+
+                    file_structure.append(
+                        file_content.path
+                    )
+
+                    if any(
+
+                        keyword in file_content.path.lower()
+
+                        for keyword in [
+
+                            "readme",
+                            "requirements",
+                            "dockerfile",
+                            "package.json",
+                            "main.py",
+                            "app.py"
+                        ]
+                    ):
+
+                        important_files.append({
+
+                            "path": file_content.path,
+
+                            "download_url": (
+                                file_content.download_url
+                            )
+                        })
+
+            return {
+
+                "success": True,
+
+                "repository": repo.full_name,
+
+                "description": repo.description,
+
+                "stars": repo.stargazers_count,
+
+                "language": repo.language,
+
+                "topics": repo.get_topics(),
+
+                "file_count": len(file_structure),
+
+                "important_files": important_files,
+
+                "file_structure": file_structure[:100]
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "repository": repo_name,
+
+                "error": str(e)
+            }
+
+
+# global helper
+
+def analyze_repository(
+    repo_name: str
+) -> Dict:
+    """
+    Simple repository analyzer helper.
+    """
+
+    tool = RepoAnalyzerTool()
+
+    return tool.analyze_repository(repo_name)