Update app.py

app.py

@@ -8,549 +8,289 @@ GITHUB_TOKEN = os.getenv('GITHUB_TOKEN')
 g = Github(GITHUB_TOKEN)
 
 
-def import_repository(owner: str, repo_name: str, vcs_url: str):
-    """Importuje repozytorium z podanego URL."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)  # Sprawdź, czy repozytorium już istnieje
-        return "Repozytorium o tej nazwie już istnieje."
-    except GithubException:
-        pass  # Repozytorium nie istnieje, można importować
-
-    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',
-    }
-
-    try:
-        response = requests.put(import_url, json=payload, headers=headers)
-        if response.status_code == 201:
-            return "Import repozytorium został rozpoczęty."
-        else:
-            return f"Nie udało się rozpocząć importu repozytorium. Status: {response.status_code}, Szczegóły: {response.json()}"
-    except Exception as e:
-        return f"Wystąpił błąd podczas próby importu repozytorium: {str(e)}"
-
-
-def create_repository(name: str):
-    """Tworzy nowe repozytorium."""
-    try:
-        user = g.get_user()
-        repo = user.create_repo(name=name)
-        return f"Repozytorium {name} zostało utworzone: {repo.html_url}"
-    except GithubException as e:
-        return f"Nie udało się utworzyć repozytorium: {str(e)}"
-
-
-def create_file(repo_name: str, branch: str, message: str, content: str, path: str):
-    """Tworzy plik w repozytorium."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)
-        repo.create_file(path, message, content, branch=branch)
-        return f"Plik {path} został utworzony w {repo_name} na gałęzi {branch}"
-    except GithubException as e:
-        return f"Nie udało się utworzyć pliku: {str(e)}"
-
-
-def get_file(repo_name: str, path: str):
-    """Pobiera zawartość pliku z repozytorium."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)
-        file_content = repo.get_contents(path)
-        return file_content.decoded_content.decode()
-    except GithubException as e:
-        return f"Nie znaleziono pliku: {str(e)}"
-
-
-def delete_file(repo_name: str, branch: str, path: str):
-    """Usuwa plik z repozytorium."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)
-        file_contents = repo.get_contents(path, ref=branch)
-        repo.delete_file(path, "Usuń plik", file_contents.sha, branch=branch)
-        return f"Plik {path} został usunięty z {repo_name} na gałęzi {branch}"
-    except GithubException as e:
-        return f"Nie udało się usunąć pliku: {str(e)}"
-
-
-def update_file(repo_name: str, branch: str, path: str, message: str, content: str):
-    """Aktualizuje plik w repozytorium."""
-    try:
-        user = g.get_user()
-        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} został zaktualizowany w {repo_name} na gałęzi {branch}"
-    except GithubException as e:
-        return f"Nie udało się zaktualizować pliku: {str(e)}"
-
-
-def list_branches(repo_name: str):
-    """Listuje gałęzie w repozytorium."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)
-        branches = repo.get_branches()
-        return [branch.name for branch in branches]
-    except GithubException as e:
-        return f"Nie udało się pobrać listy gałęzi: {str(e)}"
-
-
-def create_branch(repo_name: str, source_branch: str, new_branch: str):
-    """Tworzy nową gałąź w repozytorium."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)
-        source_branch = repo.get_branch(source_branch)
-        repo.create_git_ref(ref=f"refs/heads/{new_branch}", sha=source_branch.commit.sha)
-        return f"Gałąź {new_branch} została utworzona od {source_branch}"
-    except GithubException as e:
-        return f"Nie udało się utworzyć gałęzi: {str(e)}"
-
-
-def delete_branch(repo_name: str, branch_name: str):
-    """Usuwa gałąź z repozytorium."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)
-        repo.get_git_ref(f"heads/{branch_name}").delete()
-        return f"Gałąź {branch_name} została usunięta"
-    except GithubException as e:
-        return f"Nie znaleziono gałęzi lub błąd podczas usuwania: {str(e)}"
-
-
-def create_pull_request(repo_name: str, title: str, body: str, base: str, head: str):
-    """Tworzy pull request."""
-    try:
-        user = g.get_user()
-        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}"
-    except GithubException as e:
-        return f"Nie udało się utworzyć pull requesta: {str(e)}"
-
-
-def list_open_pull_requests(repo_name: str):
-    """Listuje otwarte pull requesty."""
-    try:
-        user = g.get_user()
-        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]
-    except GithubException as e:
-        return f"Nie udało się pobrać listy otwartych pull requestów: {str(e)}"
-
-
-def create_issue(repo_name: str, title: str, body: str):
-    """Tworzy issue."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)
-        issue = repo.create_issue(title=title, body=body)
-        return f"Issue utworzone: {issue.html_url}"
-    except GithubException as e:
-        return f"Nie udało się utworzyć issue: {str(e)}"
-
-
-def list_issues(repo_name: str):
-    """Listuje issue."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)
-        issues = repo.get_issues(state='open')
-        return [{'title': issue.title, 'url': issue.html_url} for issue in issues]
-    except GithubException as e:
-        return f"Nie udało się pobrać listy issue: {str(e)}"
-
-
-def add_label_to_issue(repo_name: str, issue_number: int, labels: list[str]):
-    """Dodaje etykiety do issue."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)
-        issue = repo.get_issue(number=int(issue_number))
-        for label in labels:
-            issue.add_to_labels(label)
-        return f"Dodano etykiety do issue #{issue_number}"
-    except GithubException as e:
-        return f"Nie udało się dodać etykiet do issue: {str(e)}"
-
-
-def close_issue(repo_name: str, issue_number: int):
-    """Zamyka issue."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)
-        issue = repo.get_issue(number=int(issue_number))
-        issue.edit(state='closed')
-        return f"Issue #{issue_number} zostało zamknięte"
-    except GithubException as e:
-        return f"Nie udało się zamknąć issue: {str(e)}"
+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()
 
-
-def add_comment_to_issue(repo_name: str, issue_number: int, comment: str):
-    """Dodaje komentarz do issue."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)
-        issue = repo.get_issue(number=int(issue_number))
-        issue.create_comment(body=comment)
-        return f"Dodano komentarz do issue #{issue_number}"
-    except GithubException as e:
-        return f"Nie udało się dodać komentarza do issue: {str(e)}"
-
-
-def create_release(repo_name: str, tag: str, name: str, message: str):
-    """Tworzy release."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)
-        release = repo.create_git_release(tag=tag, name=name, message=message)
-        return f"Release utworzone: {release.html_url}"
-    except GithubException as e:
-        return f"Nie udało się utworzyć release: {str(e)}"
-
-
-def list_releases(repo_name: str):
-    """Listuje release."""
-    try:
-        user = g.get_user()
-        repo = user.get_repo(repo_name)
-        releases = repo.get_releases()
-        return [{'tag_name': release.tag_name, 'url': release.html_url} for release in releases]
-    except GithubException as e:
-        return f"Nie udało się pobrać listy release: {str(e)}"
-
-
-def fork_repository(repo_name: str):
-    """Forkuje repozytorium."""
-    try:
-        user = g.get_user()
-        repo = g.get_repo(repo_name)  # Pobierz repozytorium do forkowania
-        fork = user.create_fork(repo)
-        return f"Fork repozytorium utworzony: {fork.html_url}"
-    except GithubException as e:
-        return f"Nie udało się utworzyć forka repozytorium: {str(e)}"
-
-
-def list_forks(repo_name: str):
-    """Listuje forki repozytorium."""
     try:
-        repo = g.get_repo(repo_name)  # Pobierz repozytorium, którego forki chcesz wyświetlić
-        forks = repo.get_forks()
-        return [{'full_name': fork.full_name, 'url': fork.html_url} for fork in forks]
-    except GithubException as e:
-        return f"Nie udało się pobrać listy forków: {str(e)}"
+        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}")
 
-def list_files(owner: str, repo_name: str, path: str = ""):
-    """Listuje pliki w repozytorium."""
-    try:
-        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
     except GithubException as e:
-        return f"Nie udało się pobrać listy plików: {str(e)}"
+        return f"Błąd GitHub: {str(e)}"
+    except ValueError as e:
+        return f"Błąd: {str(e)}"
 
 
 with gr.Blocks() as demo:
-    with gr.Tab("Repozytoria"):
-        with gr.Row():
-            import_repo_owner = gr.Textbox(label="Właściciel")
-            import_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            import_repo_vcs_url = gr.Textbox(label="URL VCS")
-            import_repo_button = gr.Button("Importuj repozytorium")
-        import_repo_output = gr.Textbox(label="Wynik")
-        import_repo_button.click(
-            import_repository,
-            inputs=[import_repo_owner, import_repo_name,
-                    import_repo_vcs_url],
-            outputs=import_repo_output,
-            api_name="import_repository"
-        )
-
-        with gr.Row():
-            create_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            create_repo_button = gr.Button("Utwórz repozytorium")
-        create_repo_output = gr.Textbox(label="Wynik")
-        create_repo_button.click(
-            create_repository,
-            inputs=create_repo_name,
-            outputs=create_repo_output,
-            api_name="create_repository"
-        )
-
-    with gr.Tab("Pliki"):
-        with gr.Row():
-            create_file_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            create_file_branch = gr.Textbox(label="Gałąź")
-            create_file_message = gr.Textbox(label="Wiadomość commita")
-            create_file_content = gr.Textbox(label="Zawartość pliku")
-            create_file_path = gr.Textbox(label="Ścieżka do pliku")
-            create_file_button = gr.Button("Utwórz plik")
-        create_file_output = gr.Textbox(label="Wynik")
-        create_file_button.click(
-            create_file,
-            inputs=[create_file_repo_name, create_file_branch,
-                    create_file_message, create_file_content, create_file_path],
-            outputs=create_file_output,
-            api_name="create_file"
-        )
-
-        with gr.Row():
-            get_file_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            get_file_path = gr.Textbox(label="Ścieżka do pliku")
-            get_file_button = gr.Button("Pobierz plik")
-        get_file_output = gr.Textbox(label="Zawartość pliku")
-        get_file_button.click(
-            get_file,
-            inputs=[get_file_repo_name, get_file_path],
-            outputs=get_file_output,
-            api_name="get_file"
-        )
-
-        with gr.Row():
-            delete_file_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            delete_file_branch = gr.Textbox(label="Gałąź")
-            delete_file_path = gr.Textbox(label="Ścieżka do pliku")
-            delete_file_button = gr.Button("Usuń plik")
-        delete_file_output = gr.Textbox(label="Wynik")
-        delete_file_button.click(
-            delete_file,
-            inputs=[delete_file_repo_name, delete_file_branch,
-                    delete_file_path],
-            outputs=delete_file_output,
-            api_name="delete_file"
-        )
-
-        with gr.Row():
-            update_file_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            update_file_branch = gr.Textbox(label="Gałąź")
-            update_file_path = gr.Textbox(label="Ścieżka do pliku")
-            update_file_message = gr.Textbox(label="Wiadomość commita")
-            update_file_content = gr.Textbox(label="Nowa zawartość pliku")
-            update_file_button = gr.Button("Zaktualizuj plik")
-        update_file_output = gr.Textbox(label="Wynik")
-        update_file_button.click(
-            update_file,
-            inputs=[update_file_repo_name, update_file_branch,
-                    update_file_path, update_file_message, update_file_content],
-            outputs=update_file_output,
-            api_name="update_file"
-        )
-
-    with gr.Tab("Gałęzie"):
-        with gr.Row():
-            list_branches_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            list_branches_button = gr.Button("Listuj gałęzie")
-        list_branches_output = gr.Textbox(label="Lista gałęzi")
-        list_branches_button.click(
-            list_branches,
-            inputs=list_branches_repo_name,
-            outputs=list_branches_output,
-            api_name="list_branches"
-        )
-
-        with gr.Row():
-            create_branch_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            create_branch_source_branch = gr.Textbox(
-                label="Nazwa gałęzi źródłowej")
-            create_branch_new_branch = gr.Textbox(label="Nazwa nowej gałęzi")
-            create_branch_button = gr.Button("Utwórz gałąź")
-        create_branch_output = gr.Textbox(label="Wynik")
-        create_branch_button.click(
-            create_branch,
-            inputs=[create_branch_repo_name, create_branch_source_branch,
-                    create_branch_new_branch],
-            outputs=create_branch_output,
-            api_name="create_branch"
-        )
-
-        with gr.Row():
-            delete_branch_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            delete_branch_branch_name = gr.Textbox(label="Nazwa gałęzi")
-            delete_branch_button = gr.Button("Usuń gałąź")
-        delete_branch_output = gr.Textbox(label="Wynik")
-        delete_branch_button.click(
-            delete_branch,
-            inputs=[delete_branch_repo_name, delete_branch_branch_name],
-            outputs=delete_branch_output,
-            api_name="delete_branch"
-        )
-
-    with gr.Tab("Pull Requesty"):
-        with gr.Row():
-            create_pr_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            create_pr_title = gr.Textbox(label="Tytuł")
-            create_pr_body = gr.Textbox(label="Treść")
-            create_pr_base = gr.Textbox(label="Gałąź bazowa")
-            create_pr_head = gr.Textbox(label="Gałąź docelowa")
-            create_pr_button = gr.Button("Utwórz Pull Request")
-        create_pr_output = gr.Textbox(label="Wynik")
-        create_pr_button.click(
-            create_pull_request,
-            inputs=[create_pr_repo_name, create_pr_title,
-                    create_pr_body, create_pr_base, create_pr_head],
-            outputs=create_pr_output,
-            api_name="create_pull_request"
-        )
-
-        with gr.Row():
-            list_open_prs_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            list_open_prs_button = gr.Button("Listuj otwarte Pull Requesty")
-        list_open_prs_output = gr.JSON(label="Lista otwartych Pull Requestów")
-        list_open_prs_button.click(
-            list_open_pull_requests,
-            inputs=list_open_prs_repo_name,
-            outputs=list_open_prs_output,
-            api_name="list_open_pull_requests"
-        )
-
-    with gr.Tab("Issue"):
-        with gr.Row():
-            create_issue_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            create_issue_title = gr.Textbox(label="Tytuł")
-            create_issue_body = gr.Textbox(label="Treść")
-            create_issue_button = gr.Button("Utwórz Issue")
-        create_issue_output = gr.Textbox(label="Wynik")
-        create_issue_button.click(
-            create_issue,
-            inputs=[create_issue_repo_name, create_issue_title,
-                    create_issue_body],
-            outputs=create_issue_output,
-            api_name="create_issue"
-        )
-
-        with gr.Row():
-            list_issues_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            list_issues_button = gr.Button("Listuj Issue")
-        list_issues_output = gr.JSON(label="Lista Issue")
-        list_issues_button.click(
-            list_issues,
-            inputs=list_issues_repo_name,
-            outputs=list_issues_output,
-            api_name="list_issues"
-        )
-
-        with gr.Row():
-            add_label_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            add_label_issue_number = gr.Number(
-                label="Numer Issue", precision=0)
-            add_label_labels = gr.Textbox(
-                label="Etykiety (oddzielone przecinkami)")
-            add_label_button = gr.Button("Dodaj etykiety")
-        add_label_output = gr.Textbox(label="Wynik")
-        add_label_button.click(
-            lambda repo_name, issue_number, labels: add_label_to_issue(
-                repo_name, issue_number, labels.split(",")),
-            inputs=[add_label_repo_name, add_label_issue_number,
-                    add_label_labels],
-            outputs=add_label_output,
-            api_name="add_label_to_issue"
-        )
-
-        with gr.Row():
-            close_issue_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            close_issue_issue_number = gr.Number(
-                label="Numer Issue", precision=0)
-            close_issue_button = gr.Button("Zamknij Issue")
-        close_issue_output = gr.Textbox(label="Wynik")
-        close_issue_button.click(
-            close_issue,
-            inputs=[close_issue_repo_name, close_issue_issue_number],
-            outputs=close_issue_output,
-            api_name="close_issue"
-        )
-
-        with gr.Row():
-            add_comment_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            add_comment_issue_number = gr.Number(
-                label="Numer Issue", precision=0)
-            add_comment_comment = gr.Textbox(label="Komentarz")
-            add_comment_button = gr.Button("Dodaj komentarz")
-        add_comment_output = gr.Textbox(label="Wynik")
-        add_comment_button.click(
-            add_comment_to_issue,
-            inputs=[add_comment_repo_name, add_comment_issue_number,
-                    add_comment_comment],
-            outputs=add_comment_output,
-            api_name="add_comment_to_issue"
-        )
-
-    with gr.Tab("Release"):
-        with gr.Row():
-            create_release_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            create_release_tag = gr.Textbox(label="Tag")
-            create_release_name = gr.Textbox(label="Nazwa")
-            create_release_message = gr.Textbox(label="Wiadomość")
-            create_release_button = gr.Button("Utwórz Release")
-        create_release_output = gr.Textbox(label="Wynik")
-        create_release_button.click(
-            create_release,
-            inputs=[create_release_repo_name, create_release_tag,
-                    create_release_name, create_release_message],
-            outputs=create_release_output,
-            api_name="create_release"
-        )
-
-        with gr.Row():
-            list_releases_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            list_releases_button = gr.Button("Listuj Release")
-        list_releases_output = gr.JSON(label="Lista Release")
-        list_releases_button.click(
-            list_releases,
-            inputs=list_releases_repo_name,
-            outputs=list_releases_output,
-            api_name="list_releases"
-        )
-
-    with gr.Tab("Forki"):
-        with gr.Row():
-            fork_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            fork_repo_button = gr.Button("Forkuj repozytorium")
-        fork_repo_output = gr.Textbox(label="Wynik")
-        fork_repo_button.click(
-            fork_repository,
-            inputs=fork_repo_name,
-            outputs=fork_repo_output,
-            api_name="fork_repository"
-        )
-
-        with gr.Row():
-            list_forks_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            list_forks_button = gr.Button("Listuj forki")
-        list_forks_output = gr.JSON(label="Lista forków")
-        list_forks_button.click(
-            list_forks,
-            inputs=list_forks_repo_name,
-            outputs=list_forks_output,
-            api_name="list_forks"
-        )
-
-    with gr.Tab("Listowanie plików"):
-        with gr.Row():
-            list_files_owner = gr.Textbox(label="Właściciel")
-            list_files_repo_name = gr.Textbox(label="Nazwa repozytorium")
-            list_files_path = gr.Textbox(
-                label="Ścieżka (opcjonalnie)", value="")
-            list_files_button = gr.Button("Listuj pliki")
-        list_files_output = gr.JSON(label="Lista plików")
-        list_files_button.click(
-            list_files,
-            inputs=[list_files_owner, list_files_repo_name, list_files_path],
-            outputs=list_files_output,
-            api_name="list_files"
+    with gr.Row():
+        action = gr.Dropdown(
+            choices=[
+                "import_repository",
+                "create_repository",
+                "create_file",
+                "get_file",
+                "delete_file",
+                "update_file",
+                "list_branches",
+                "create_branch",
+                "delete_branch",
+                "create_pull_request",
+                "list_open_pull_requests",
+                "create_issue",
+                "list_issues",
+                "add_label_to_issue",
+                "close_issue",
+                "add_comment_to_issue",
+                "create_release",
+                "list_releases",
+                "fork_repository",
+                "list_forks",
+                "list_files",
+            ],
+            label="Akcja",
         )
+        repo_name = gr.Textbox(label="Nazwa repozytorium")
+        branch = gr.Textbox(label="Gałąź", value="main")
+        path = gr.Textbox(label="Ścieżka do pliku")
+        content = gr.Textbox(label="Zawartość pliku")
+        message = gr.Textbox(label="Wiadomość/Komentarz")
+        owner = gr.Textbox(label="Właściciel")
+        vcs_url = gr.Textbox(label="URL VCS")
+        title = gr.Textbox(label="Tytuł")
+        body = gr.Textbox(label="Treść")
+        base = gr.Textbox(label="Gałąź bazowa")
+        head = gr.Textbox(label="Gałąź docelowa/Nowa gałąź")
+        issue_number = gr.Number(label="Numer issue", precision=0)
+        labels = gr.Textbox(label="Etykiety (oddzielone przecinkami)")
+        tag = gr.Textbox(label="Tag")
+        release_name = gr.Textbox(label="Nazwa release")  # Zmieniona nazwa
+    
+    with gr.Row():
+        run_button = gr.Button("Wykonaj")
+        output = gr.Textbox(label="Wynik")
+
+    run_button.click(
+        github_tool,
+        inputs=[
+            action,
+            repo_name,
+            branch,
+            path,
+            content,
+            message,
+            owner,
+            vcs_url,
+            title,
+            body,
+            base,
+            head,
+            issue_number,
+            labels,
+            tag,
+            release_name,  # Użycie zmienionej nazwy
+        ],
+        outputs=output,
+        api_name="github_tool"
+    )
 
 demo.launch()