Spaces:

adowu
/

gh

Sleeping

App Files Files Community

adowu commited on Feb 25

Commit

dc11f97

verified ·

1 Parent(s): 6f91c0b

Update app.py

Browse files

Files changed (1) hide show

app.py +211 -64

app.py CHANGED Viewed

@@ -8,6 +8,110 @@ import re
 GITHUB_TOKEN = os.getenv('GITHUB_TOKEN')
 g = Github(GITHUB_TOKEN)
 def get_file_content(owner, repo_name, path, branch="main"):
     url = f"https://raw.githubusercontent.com/{owner}/{repo_name}/{branch}/{path}"
     response = requests.get(url)
@@ -44,6 +148,7 @@ def github_tool(
     name: str = None,  # nazwa release
     file_url: str = None, # URL pliku do pobrania,
     repo_url: str = None,  # Link do repozytorium
 ):
     """Narzędzie do zarządzania repozytoriami GitHub."""
     user = g.get_user()
@@ -76,7 +181,20 @@ def github_tool(
             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]):
@@ -84,21 +202,21 @@ def github_tool(
                     "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, ref=branch)
-            return file_content.decoded_content.decode()  # Zdekoduj zawartość pliku i zwróć jako string
         elif action == "get_file_content_by_url":
             if not file_url:
                 raise ValueError("Brakujący parametr: file_url")
             response = requests.get(file_url)
             response.raise_for_status() # Sprawdź czy nie ma błędu HTTP
-            return response.text
         elif action == "delete_file":
             if not all([repo_name, path]):
@@ -107,7 +225,7 @@ def github_tool(
             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]):
@@ -117,14 +235,15 @@ def github_tool(
             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
@@ -133,14 +252,14 @@ def github_tool(
             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]):
@@ -148,28 +267,34 @@ def github_tool(
                     "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]):
@@ -179,7 +304,7 @@ def github_tool(
             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]):
@@ -187,7 +312,7 @@ def github_tool(
             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
@@ -196,7 +321,7 @@ def github_tool(
             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]):
@@ -205,67 +330,78 @@ def github_tool(
             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}")
             # Dodaj obsługę pustej ścieżki:
             if not path:
                 contents = repo.get_contents("")  # Pobierz zawartość głównego katalogu
             else:
                 contents = repo.get_contents(path)
-            files = [{'name': content.name, 'path': content.path,
-                      'download_url': content.download_url} for content in contents]
-            return files
         elif action == "get_repository_info":
             if not all([owner, repo_name]):
                 raise ValueError("Brakujące parametry: owner, repo_name")
             repo = g.get_repo(f"{owner}/{repo_name}")
             info = {
-                "nazwa": repo.name,
-                "opis": repo.description,
-                "url": repo.html_url,
-                "właściciel": repo.owner.login,
-                "gałąź domyślna": repo.default_branch,
-                "język": repo.language,
-                "liczba gwiazdek": repo.stargazers_count,
-                "liczba forków": repo.forks_count,
-                "utworzone": repo.created_at,
-                "ostatnia aktualizacja": repo.updated_at
             }
-            return info  # Zwraca słownik z informacjami
         elif action == "get_file_content":
             if not all([owner, repo_name, path]):
                 raise ValueError("Brakujące parametry: owner, repo_name, path")
-            return get_file_content(owner, repo_name, path, branch)
         elif action == "analyze_repository_by_url":
             if not repo_url:
                 raise ValueError("Brakujący parametr: repo_url")
@@ -291,11 +427,13 @@ def github_tool(
                             "content": file_content,
                             # Możesz dodać tutaj analizę zawartości pliku
                         })
-                return file_analyses
             except GithubException as e:
                 return f"Błąd GitHub: {str(e)}"
         elif action == "analyze_repository_content":
             if not all([owner, repo_name]):
                 raise ValueError("Brakujące parametry: owner, repo_name")
@@ -316,30 +454,34 @@ def github_tool(
                             "path": content.path,
                             "content": file_content,
                         })
-                return file_analyses
-            except GithubException as e:
-                return f"Błąd GitHub: {str(e)}"
         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)}"
 with gr.Blocks() as demo:
-    with gr.Row():
         action = gr.Dropdown(
             choices=[
                 "import_repository",
                 "create_repository",
                 "create_file",
                 "get_file",
-                "get_file_content_by_url",
                 "delete_file",
                 "update_file",
                 "list_branches",
@@ -357,17 +499,22 @@ with gr.Blocks() as demo:
                 "fork_repository",
                 "list_forks",
                 "list_files",
-                "get_repository_info",
                 "get_file_content",
                 "analyze_repository_by_url",
-                "analyze_repository_content",  # Nowa akcja
             ],
-            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")
@@ -378,13 +525,12 @@ with gr.Blocks() as demo:
         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
-        file_url = gr.Textbox(label="URL pliku") # Dodane pole
-        repo_url = gr.Textbox(label="Link do repozytorium") # Dodane pole
-    with gr.Row():
-        run_button = gr.Button("Wykonaj")
-        output = gr.Textbox(label="Wynik")
     run_button.click(
         github_tool,
@@ -404,12 +550,13 @@ with gr.Blocks() as demo:
             issue_number,
             labels,
             tag,
-            release_name,  # Użycie zmienionej nazwy
-            file_url, # Dodany argument
-            repo_url, # Dodany argument
         ],
         outputs=output,
-        api_name="github_tool"
     )
 demo.launch()

 GITHUB_TOKEN = os.getenv('GITHUB_TOKEN')
 g = Github(GITHUB_TOKEN)
+# Szablony projektów - definicje jako słowniki:
+PROJECT_TEMPLATES = {
+    "flask": {
+        "files": {
+            "app.py": """from flask import Flask
+app = Flask(__name__)
+@app.route('/')
+def hello():
+    return "Hello, Flask!"
+if __name__ == '__main__':
+    app.run(debug=True)
+""",
+            "requirements.txt": "Flask",
+            ".gitignore": "__pycache__/\n*.pyc\nvenv/\ninstance/"
+        }
+    },
+    "react": {
+        "files": {
+            "package.json": """{
+  "name": "react-app",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.2.1",
+    "vite": "^5.0.8"
+  }
+}
+""",
+            "vite.config.js": """import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})
+""",
+            "index.html": """<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>
+""",
+            "src/main.jsx": """import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App.jsx'
+import './index.css'
+ReactDOM.createRoot(document.getElementById('root')).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)
+""",
+            "src/App.jsx": """import React from 'react'
+import './App.css'
+function App() {
+  return (
+    <>
+      <h1>Hello from React!</h1>
+    </>
+  )
+}
+export default App
+""",
+            "src/index.css": """body {
+  margin: 0;
+  font-family: sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+code {
+  font-family: monospace;
+}
+""",
+            ".gitignore": "node_modules/\ndist/"
+        }
+    }
+}
 def get_file_content(owner, repo_name, path, branch="main"):
     url = f"https://raw.githubusercontent.com/{owner}/{repo_name}/{branch}/{path}"
     response = requests.get(url)
     name: str = None,  # nazwa release
     file_url: str = None, # URL pliku do pobrania,
     repo_url: str = None,  # Link do repozytorium
+    template_name: str = None, # Nazwa szablonu projektu
 ):
     """Narzędzie do zarządzania repozytoriami GitHub."""
     user = g.get_user()
             if not repo_name:
                 raise ValueError("Brakujący parametr: repo_name")
             repo = user.create_repo(name=repo_name)
+            return f"Repozytorium **{repo_name}** utworzone! [Otwórz repozytorium]({repo.html_url})"
+        elif action == "create_project_from_template":
+            if not all([repo_name, template_name]):
+                raise ValueError("Brakujące parametry: repo_name, template_name")
+            if template_name not in PROJECT_TEMPLATES:
+                raise ValueError(f"Nieznany szablon projektu: {template_name}. Dostępne szablony: {', '.join(PROJECT_TEMPLATES.keys())}")
+            repo = user.create_repo(name=repo_name)
+            template = PROJECT_TEMPLATES[template_name]
+            for file_path, file_content in template["files"].items():
+                repo.create_file(file_path, f"Utworzenie {file_path} z szablonu {template_name}", file_content, branch="main")
+            return f"Repozytorium **{repo_name}** utworzone z szablonu **{template_name}**! [Otwórz repozytorium]({repo.html_url})"
         elif action == "create_file":
             if not all([repo_name, path, content, message]):
                     "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 repozytorium **`{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, ref=branch)
+            return f"Zawartość pliku **`{path}`** z repozytorium **`{repo_name}`**:\n\n```\n{file_content.decoded_content.decode()}\n```" # Dodano formatowanie Markdown
         elif action == "get_file_content_by_url":
             if not file_url:
                 raise ValueError("Brakujący parametr: file_url")
             response = requests.get(file_url)
             response.raise_for_status() # Sprawdź czy nie ma błędu HTTP
+            return f"Zawartość pliku z URL **`{file_url}`**:\n\n```\n{response.text}\n```" # Dodano formatowanie Markdown
         elif action == "delete_file":
             if not all([repo_name, path]):
             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 repozytorium **`{repo_name}`** na gałęzi **`{branch}`**."
         elif action == "update_file":
             if not all([repo_name, path, content, message]):
             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 repozytorium **`{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()
+            branch_list = "\n".join([f"- `{branch.name}`" for branch in branches]) # Formatowanie Markdown
+            return f"Gałęzie w repozytorium **`{repo_name}`**:\n{branch_list}"
         elif action == "create_branch":
             if not all([repo_name, base, head]):  # base jako źródło, head jako nowa nazwa
             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 repozytorium **`{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 repozytorium **`{repo_name}`**."
         elif action == "create_pull_request":
             if not all([repo_name, title, body, base, head]):
                     "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! [Otwórz Pull Request]({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')
+            if not open_prs:
+                return f"Brak otwartych pull requestów w repozytorium **`{repo_name}`**."
+            prs_list = "\n".join([f"- [{pr.title}]({pr.html_url})" for pr in open_prs]) # Formatowanie Markdown
+            return f"Otwarte pull requesty w repozytorium **`{repo_name}`**:\n{prs_list}"
         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! [Otwórz Issue]({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')
+            if not issues:
+                return f"Brak otwartych issues w repozytorium **`{repo_name}`**."
+            issues_list = "\n".join([f"- [{issue.title}]({issue.html_url})" for issue in issues]) # Formatowanie Markdown
+            return f"Otwarte issues w repozytorium **`{repo_name}`**:\n{issues_list}"
         elif action == "add_label_to_issue":
             if not all([repo_name, issue_number, labels]):
             issue = repo.get_issue(number=int(issue_number))
             for label in labels.split(","):
                 issue.add_to_labels(label.strip())
+            return f"Etykiety **`{labels}`** dodane do issue **#{issue_number}** w repozytorium **`{repo_name}`**."
         elif action == "close_issue":
             if not all([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 repozytorium **`{repo_name}`**."
         elif action == "add_comment_to_issue":
             if not all([repo_name, issue_number, message]):  # message jako treść komentarza
             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 repozytorium **`{repo_name}`**."
         elif action == "create_release":
             if not all([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 repozytorium **`{repo_name}`**! [Otwórz Release]({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()
+            if not releases:
+                return f"Brak release'ów w repozytorium **`{repo_name}`**."
+            releases_list = "\n".join([f"- [{release.tag_name}]({release.html_url})" for release in releases]) # Formatowanie Markdown
+            return f"Releases w repozytorium **`{repo_name}`**:\n{releases_list}"
         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"Repozytorium **`{repo_name}`** zostało zforkowane! [Otwórz fork]({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()
+            if not forks:
+                return f"Brak forków repozytorium **`{repo_name}`**."
+            forks_list = "\n".join([f"- [{fork.full_name}]({fork.html_url})" for fork in forks]) # Formatowanie Markdown
+            return f"Linki do forków repozytorium **`{repo_name}`**:\n{forks_list}"
         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}")
             # Dodaj obsługę pustej ścieżki:
             if not path:
                 contents = repo.get_contents("")  # Pobierz zawartość głównego katalogu
             else:
                 contents = repo.get_contents(path)
+            if not contents:
+                return f"Brak plików w ścieżce **`{path}`** repozytorium **`{repo_name}`**." # Komunikat, gdy brak plików
+            files_list = "\n".join([f"- [{content.name}]({content.download_url})" for content in contents]) # Formatowanie Markdown
+            return f"Pliki w ścieżce **`{path}`** repozytorium **`{repo_name}`**:\n{files_list}"
         elif action == "get_repository_info":
             if not all([owner, repo_name]):
                 raise ValueError("Brakujące parametry: owner, repo_name")
             repo = g.get_repo(f"{owner}/{repo_name}")
             info = {
+                "Nazwa": repo.name,
+                "Opis": repo.description,
+                "URL": repo.html_url,
+                "Właściciel": repo.owner.login,
+                "Gałąź domyślna": repo.default_branch,
+                "Język": repo.language,
+                "Liczba gwiazdek": repo.stargazers_count,
+                "Liczba forków": repo.forks_count,
+                "Utworzone": str(repo.created_at), # Konwersja datetime na string
+                "Ostatnia aktualizacja": str(repo.updated_at) # Konwersja datetime na string
             }
+            info_md = "\n".join([f"- **{key}**: {value}" for key, value in info.items()]) # Formatowanie Markdown
+            return f"Informacje o repozytorium **`{repo_name}`**:\n{info_md}"
         elif action == "get_file_content":
             if not all([owner, repo_name, path]):
                 raise ValueError("Brakujące parametry: owner, repo_name, path")
+            content_text = get_file_content(owner, repo_name, path, branch)
+            return f"Zawartość pliku **`{path}`** z repozytorium **`{repo_name}`**:\n\n```\n{content_text}\n```" # Dodano formatowanie Markdown
         elif action == "analyze_repository_by_url":
             if not repo_url:
                 raise ValueError("Brakujący parametr: repo_url")
                             "content": file_content,
                             # Możesz dodać tutaj analizę zawartości pliku
                         })
+                # Formatowanie wyjścia analizy (można dostosować)
+                analysis_md = "Analiza plików repozytorium:\n" + "\n".join([f"- **{f['path']}**: (pierwsze 100 znaków): `{f['content'][:100]}...`" for f in file_analyses])
+                return analysis_md
             except GithubException as e:
                 return f"Błąd GitHub: {str(e)}"
         elif action == "analyze_repository_content":
             if not all([owner, repo_name]):
                 raise ValueError("Brakujące parametry: owner, repo_name")
                             "path": content.path,
                             "content": file_content,
                         })
+                # Formatowanie wyjścia analizy (można dostosować)
+                analysis_md = "Analiza zawartości plików repozytorium:\n" + "\n".join([f"- **{f['path']}**: (pierwsze 100 znaków): `{f['content'][:100]}...`" for f in file_analyses])
+                return analysis_md
         else:
             raise ValueError(f"Nieznana akcja: {action}")
     except GithubException as e:
+        return f"**Błąd GitHub:** {str(e)}" # Wyraźniejszy komunikat błędu
     except ValueError as e:
+        return f"**Błąd:** {str(e)}" # Wyraźniejszy komunikat błędu
+    except requests.exceptions.RequestException as e: # Dodana obsługa błędów requestów
+        return f"**Błąd połączenia:** {str(e)}"
 with gr.Blocks() as demo:
+    gr.Markdown("# Narzędzie GitHub Plugingit (Uproszczony Interfejs)")
+    with gr.Column(): # Używamy Column zamiast Tabów
         action = gr.Dropdown(
             choices=[
                 "import_repository",
                 "create_repository",
+                "create_project_from_template",
                 "create_file",
                 "get_file",
+                "get_file_content_by_url",
                 "delete_file",
                 "update_file",
                 "list_branches",
                 "fork_repository",
                 "list_forks",
                 "list_files",
+                "get_repository_info",
                 "get_file_content",
                 "analyze_repository_by_url",
+                "analyze_repository_content",
             ],
+            label="Wybierz akcję",
         )
         repo_name = gr.Textbox(label="Nazwa repozytorium")
+        template_name = gr.Dropdown(
+            choices=list(PROJECT_TEMPLATES.keys()),
+            label="Szablon projektu",
+            allow_none=True,
+        )
         branch = gr.Textbox(label="Gałąź", value="main")
         path = gr.Textbox(label="Ścieżka do pliku")
+        content = gr.Code(label="Zawartość pliku", lines=5, language='python') # Nadal Code, ale bez zbędnych opcji
         message = gr.Textbox(label="Wiadomość/Komentarz")
         owner = gr.Textbox(label="Właściciel")
         vcs_url = gr.Textbox(label="URL VCS")
         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")
+        file_url = gr.Textbox(label="URL pliku")
+        repo_url = gr.Textbox(label="Link do repozytorium")
+    run_button = gr.Button("Wykonaj")
+    output = gr.Markdown(label="Wynik")
     run_button.click(
         github_tool,
             issue_number,
             labels,
             tag,
+            release_name,
+            file_url,
+            repo_url,
+            template_name,
         ],
         outputs=output,
+        api_name="github_tool" # API NAME JEST KLUCZOWE!
     )
 demo.launch()