app.py

import gradio as gr
from github import Github, GithubException
import os
import requests

# Załaduj token z pliku .env lub ustaw bezpośrednio
GITHUB_TOKEN = os.getenv('GITHUB_TOKEN')
g = Github(GITHUB_TOKEN)


def github_tool(
    action: str,
    repo_name: str = None,
    branch: str = "main",  # domyślna gałąź
    path: str = None,
    content: str = None,
    message: str = None,
    owner: str = None,
    vcs_url: str = None,
    title: str = None,
    body: str = None,
    base: str = None,
    head: str = None,
    issue_number: int = None,
    labels: str = None,  # etykiety oddzielone przecinkami
    tag: str = None,
    name: str = None,  # nazwa release
):
    """Narzędzie do zarządzania repozytoriami GitHub."""
    user = g.get_user()

    try:
        if action == "import_repository":
            if not all([owner, repo_name, vcs_url]):
                raise ValueError(
                    "Brakujące parametry: owner, repo_name, vcs_url")

            # Sprawdź, czy repozytorium już istnieje
            try:
                repo = user.get_repo(repo_name)
                return "Repozytorium o tej nazwie już istnieje."
            except GithubException:
                pass

            headers = {
                'Authorization': f'token {GITHUB_TOKEN}',
                'Accept': 'application/vnd.github.v3+json',
            }
            import_url = f'https://api.github.com/repos/{owner}/{repo_name}/import'
            payload = {'vcs_url': vcs_url, 'vcs': 'git'}
            response = requests.put(import_url, json=payload, headers=headers)
            if response.status_code == 201:
                return "Import repozytorium został rozpoczęty."
            else:
                return f"Błąd importu: {response.status_code}, {response.json()}"

        elif action == "create_repository":
            if not repo_name:
                raise ValueError("Brakujący parametr: repo_name")
            repo = user.create_repo(name=repo_name)
            return f"Repozytorium {repo_name} utworzone: {repo.html_url}"

        elif action == "create_file":
            if not all([repo_name, path, content, message]):
                raise ValueError(
                    "Brakujące parametry: repo_name, path, content, message")
            repo = user.get_repo(repo_name)
            repo.create_file(path, message, content, branch=branch)
            return f"Plik {path} utworzony w {repo_name} na gałęzi {branch}"

        elif action == "get_file":
            if not all([repo_name, path]):
                raise ValueError("Brakujące parametry: repo_name, path")
            repo = user.get_repo(repo_name)
            file_content = repo.get_contents(path)
            return file_content.decoded_content.decode()

        elif action == "delete_file":
            if not all([repo_name, path]):
                raise ValueError("Brakujące parametry: repo_name, path")
            repo = user.get_repo(repo_name)
            file_contents = repo.get_contents(path, ref=branch)
            repo.delete_file(path, "Usunięcie pliku",
                             file_contents.sha, branch=branch)
            return f"Plik {path} usunięty z {repo_name} na gałęzi {branch}"

        elif action == "update_file":
            if not all([repo_name, path, content, message]):
                raise ValueError(
                    "Brakujące parametry: repo_name, path, content, message")
            repo = user.get_repo(repo_name)
            file_contents = repo.get_contents(path, ref=branch)
            repo.update_file(path, message, content,
                             file_contents.sha, branch=branch)
            return f"Plik {path} zaktualizowany w {repo_name} na gałęzi {branch}"

        elif action == "list_branches":
            if not repo_name:
                raise ValueError("Brakujący parametr: repo_name")
            repo = user.get_repo(repo_name)
            branches = repo.get_branches()
            return [branch.name for branch in branches]

        elif action == "create_branch":
            if not all([repo_name, base, head]):  # base jako źródło, head jako nowa nazwa
                raise ValueError("Brakujące parametry: repo_name, base, head")
            repo = user.get_repo(repo_name)
            source_branch = repo.get_branch(base)
            repo.create_git_ref(ref=f"refs/heads/{head}",
                                 sha=source_branch.commit.sha)
            return f"Gałąź {head} utworzona z {base} w {repo_name}"

        elif action == "delete_branch":
            if not all([repo_name, branch]):
                raise ValueError("Brakujące parametry: repo_name, branch")
            repo = user.get_repo(repo_name)
            repo.get_git_ref(f"heads/{branch}").delete()
            return f"Gałąź {branch} usunięta z {repo_name}"

        elif action == "create_pull_request":
            if not all([repo_name, title, body, base, head]):
                raise ValueError(
                    "Brakujące parametry: repo_name, title, body, base, head")
            repo = user.get_repo(repo_name)
            pr = repo.create_pull(title=title, body=body, base=base, head=head)
            return f"Pull request utworzony: {pr.html_url}"

        elif action == "list_open_pull_requests":
            if not repo_name:
                raise ValueError("Brakujący parametr: repo_name")
            repo = user.get_repo(repo_name)
            open_prs = repo.get_pulls(state='open')
            return [{'title': pr.title, 'url': pr.html_url} for pr in open_prs]

        elif action == "create_issue":
            if not all([repo_name, title, body]):
                raise ValueError("Brakujące parametry: repo_name, title, body")
            repo = user.get_repo(repo_name)
            issue = repo.create_issue(title=title, body=body)
            return f"Issue utworzone: {issue.html_url}"

        elif action == "list_issues":
            if not repo_name:
                raise ValueError("Brakujący parametr: repo_name")
            repo = user.get_repo(repo_name)
            issues = repo.get_issues(state='open')
            return [{'title': issue.title, 'url': issue.html_url} for issue in issues]

        elif action == "add_label_to_issue":
            if not all([repo_name, issue_number, labels]):
                raise ValueError(
                    "Brakujące parametry: repo_name, issue_number, labels")
            repo = user.get_repo(repo_name)
            issue = repo.get_issue(number=int(issue_number))
            for label in labels.split(","):
                issue.add_to_labels(label.strip())
            return f"Etykiety dodane do issue #{issue_number} w {repo_name}"

        elif action == "close_issue":
            if not all([repo_name, issue_number]):
                raise ValueError("Brakujące parametry: repo_name, issue_number")
            repo = user.get_repo(repo_name)
            issue = repo.get_issue(number=int(issue_number))
            issue.edit(state='closed')
            return f"Issue #{issue_number} zamknięte w {repo_name}"

        elif action == "add_comment_to_issue":
            if not all([repo_name, issue_number, message]):  # message jako treść komentarza
                raise ValueError(
                    "Brakujące parametry: repo_name, issue_number, message")
            repo = user.get_repo(repo_name)
            issue = repo.get_issue(number=int(issue_number))
            issue.create_comment(body=message)
            return f"Komentarz dodany do issue #{issue_number} w {repo_name}"

        elif action == "create_release":
            if not all([repo_name, tag, name, message]):
                raise ValueError(
                    "Brakujące parametry: repo_name, tag, name, message")
            repo = user.get_repo(repo_name)
            release = repo.create_git_release(
                tag=tag, name=name, message=message)
            return f"Release {name} utworzone w {repo_name}: {release.html_url}"

        elif action == "list_releases":
            if not repo_name:
                raise ValueError("Brakujący parametr: repo_name")
            repo = user.get_repo(repo_name)
            releases = repo.get_releases()
            return [{'tag_name': release.tag_name, 'url': release.html_url} for release in releases]

        elif action == "fork_repository":
            if not repo_name:
                raise ValueError("Brakujący parametr: repo_name")
            repo = g.get_repo(repo_name)  # Pobierz repozytorium do forkowania
            fork = user.create_fork(repo)
            return f"Fork repozytorium utworzony: {fork.html_url}"

        elif action == "list_forks":
            if not repo_name:
                raise ValueError("Brakujący parametr: repo_name")
            repo = g.get_repo(repo_name)  # Pobierz repo, którego forki chcesz wyświetlić
            forks = repo.get_forks()
            return [{'full_name': fork.full_name, 'url': fork.html_url} for fork in forks]

        elif action == "list_files":
            if not all([owner, repo_name]):
                raise ValueError("Brakujące parametry: owner, repo_name")
            repo = g.get_repo(f"{owner}/{repo_name}")
            contents = repo.get_contents(path)
            files = [{'name': content.name, 'path': content.path,
                      'download_url': content.download_url} for content in contents]
            return files

        else:
            raise ValueError(f"Nieznana akcja: {action}")

    except GithubException as e:
        return f"Błąd GitHub: {str(e)}"
    except ValueError as e:
        return f"Błąd: {str(e)}"


def my_function(input_text):
    return f"Hello {input_text}"

demo = gr.Interface(fn=my_function, inputs=gr.Textbox(label="Nazwa repozytorium"), outputs="text")

demo.launch()