app.py

def get_file_content(owner, repo_name, path, branch="main"):
    """Fetches file content from a GitHub repository."""
    url = f"https://raw.githubusercontent.com/{owner}/{repo_name}/{branch}/{path}"
    try:
        response = requests.get(url)
        response.raise_for_status()
        return response.text
    except requests.exceptions.RequestException as e:
        return f"Error fetching file: {e}"


def extract_repo_info(url):
    """Extracts owner and repo name from a GitHub URL."""
    match = re.search(r"github\.com/([^/]+)/([^/]+)", url)
    return match.group(1), match.group(2) if match else (None, None)


def analyze_file_content(content, file_path):
    """Analyzes file content and returns statistics."""
    lines = content.splitlines()
    word_count = sum(len(line.split()) for line in lines)
    line_count = len(lines)
    file_extension = file_path.split('.')[-1].lower() if '.' in file_path else "unknown"
    return {
        "line_count": line_count,
        "word_count": word_count,
        "file_extension": file_extension,
    }


def github_tool(
    action: str,
    repo_name: str = None,
    branch: str = "main",
    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,
    tag: str = None,
    name: str = None,
    file_url: str = None,
    repo_url: str = None,
    template_name: str = None,
    template_params: dict = None,
    diff: str = None,
    diff_message: str = None,
    new_description: str = None,
    issue_title: str = None,
    issue_body: str = None,
    issue_state: str = None,
    **kwargs
):
    """Manages GitHub repositories."""
    user = g.get_user()

    try:
        if action == "import_repository":
            if not all([owner, repo_name, vcs_url]):
                raise ValueError("Missing parameters: owner, repo_name, vcs_url")
            try:
                user.get_repo(repo_name)
                return "Repository already exists."
            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'
            response = requests.put(import_url, json={'vcs_url': vcs_url, 'vcs': 'git'}, headers=headers)
            response.raise_for_status()
            return "Repository import started."

        elif action == "create_repository":
            if not repo_name:
                raise ValueError("Missing parameter: repo_name")
            repo = user.create_repo(name=repo_name)
            return f"Repository **{repo_name}** created! [Open repository]({repo.html_url})"

        elif action == "create_project_from_template":
            if not all([repo_name, template_name]):
                raise ValueError("Missing parameters: repo_name, template_name")
            if template_name not in PROJECT_TEMPLATES:
                raise ValueError(
                    f"Unknown template: {template_name}.  Available: {', '.join(PROJECT_TEMPLATES.keys())}"
                )
            repo = user.create_repo(name=repo_name)
            template = PROJECT_TEMPLATES[template_name]

            template_params_final = {}
            if "params" in template:
                for param_name, param_config in template["params"].items():
                    template_params_final[param_name] = template_params.get(param_name, param_config.get("default")) if template_params else param_config.get("default")

            repo_name_snake_case = repo_name.replace("-", "_")
            readme_filename = "README.md"

            env = jinja2.Environment()

            for file_path, file_content in template["files"].items():
                final_file_path = file_path
                final_file_content = file_content

                if "rename_files" in template:
                    for old_name, new_name_template in template["rename_files"].items():
                        if file_path == old_name:
                            final_file_path = new_name_template.replace("{{repo_name_snake_case}}", repo_name_snake_case).replace("{{repo_name}}", repo_name).replace("{{readme_filename}}", readme_filename)

                template_render = env.from_string(final_file_content)
                final_file_content = template_render.render(
                    repo_name=repo_name,
                    repo_name_snake_case=repo_name_snake_case,
                    readme_filename=readme_filename,
                    **template_params_final
                )

                repo.create_file(
                    final_file_path,
                    f"Create {final_file_path} from template {template_name}",
                    final_file_content,
                    branch="main",
                )

            if "post_process" in template:
                post_process_action = template["post_process"]
                if post_process_action == "install_dependencies":
                    print(
                        f"Post-processing: install_dependencies for {repo_name} (Not fully implemented in this example).")
                elif post_process_action == "shadcn_setup":
                    instructions = f"""
**Konfiguracja Shadcn UI wymaga dodatkowych kroków po stronie klienta!**

1.  **Sklonuj repozytorium:** `git clone https://github.com/{user.login}/{repo_name}.git`
2.  **Przejdź do katalogu projektu:** `cd {repo_name}`
3.  **Zainstaluj zależności:** `npm install` (lub `yarn install`, `pnpm install`)
4.  **Zainicjuj Shadcn UI:** `npx shadcn-ui@latest init`
5.  **Uruchom aplikację:** `npm run dev` (lub odpowiednia komenda dla Twojego menedżera pakietów)

Po wykonaniu tych kroków, Twoja aplikacja Shadcn UI będzie w pełni skonfigurowana i gotowa do rozwoju.
                    """
                    return f"Repository **{repo_name}** created from template **{template_name}**! [Open repository]({repo.html_url})\n\n{instructions}"
                else:
                    print(f"Unknown post-process action: {post_process_action}")

            return f"Repository **{repo_name}** created from template **{template_name}**! [Open repository]({repo.html_url})"

        elif action == "create_file":
            if not all([repo_name, path, content, message]):
                raise ValueError("Missing parameters: repo_name, path, content, message")
            repo = user.get_repo(repo_name)
            repo.create_file(path, message, content, branch=branch)
            return f"File **`{path}`** created in repository **`{repo_name}`** on branch **`{branch}`**."

        elif action == "get_file":
            if not all([repo_name, path]):
                raise ValueError("Missing parameters: repo_name, path")
            repo = user.get_repo(repo_name)
            file_content = repo.get_contents(path, ref=branch)
            return (
                f"File content of **`{path}`** from **`{repo_name}`**:\n\n`\n{file_content.decoded_content.decode()}\n`"
            )

        elif action == "get_file_content_by_url":
            if not file_url:
                raise ValueError("Missing parameter: file_url")
            file_content = get_file_content(None, None, None, None)
            return f"File content from URL **`{file_url}`**:\n\n`\n{file_content}\n`"

        elif action == "delete_file":
            if not all([repo_name, path]):
                raise ValueError("Missing parameters: repo_name, path")
            repo = user.get_repo(repo_name)
            file_contents = repo.get_contents(path, ref=branch)
            repo.delete_file(path, "Delete file", file_contents.sha, branch=branch)
            return f"File **`{path}`** deleted from repository **`{repo_name}`** on branch **`{branch}`**."

        elif action == "update_file":
            if not all([repo_name, path, content, message]):
                raise ValueError("Missing parameters: 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"File **`{path}`** updated in repository **`{repo_name}`** on branch **`{branch}`**."

        elif action == "update_file_diff":
            if not all([repo_name, path, diff, diff_message]):
                raise ValueError("Missing parameters: repo_name, path, diff, diff_message")
            repo = user.get_repo(repo_name)
            file_contents = repo.get_contents(path, ref=branch)
            current_content_text = file_contents.decoded_content.decode()

            dmp = diff_match_patch()

            try:
                patches = dmp.patch_fromText(diff)
            except ValueError:
                raise ValueError("Invalid patch format. Please provide a valid patch in 'diff' format.")

            patched_content_tuple = dmp.patch_apply(patches, current_content_text)
            patched_content_text = patched_content_tuple[0]
            patch_results = patched_content_tuple[1]

            if not any(patch_results):
                raise ValueError("Failed to apply patch. Diff might be outdated or invalid.")

            repo.update_file(path, diff_message, patched_content_text, file_contents.sha, branch=branch)
            return f"File **`{path}`** updated using diff in repository **`{repo_name}`** on branch **`{branch}`**."


        elif action == "list_branches":
            if not repo_name:
                raise ValueError("Missing parameter: repo_name")
            repo = user.get_repo(repo_name)
            branches = repo.get_branches()
            branch_list = "\n".join([f"- `{branch.name}`" for branch in branches])
            return f"Branches in repository **`{repo_name}`**:\n{branch_list}"

        elif action == "create_branch":
            if not all([repo_name, base, head]):
                raise ValueError("Missing parameters: 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"Branch **`{head}`** created from **`{base}`** in repository **`{repo_name}`**."

        elif action == "delete_branch":
            if not all([repo_name, branch]):
                raise ValueError("Missing parameters: repo_name, branch")
            repo = user.get_repo(repo_name)
            repo.get_git_ref(f"heads/{branch}").delete()
            return f"Branch **`{branch}`** deleted from repository **`{repo_name}`**."

        elif action == "create_pull_request":
            if not all([repo_name, title, body, base, head]):
                raise ValueError("Missing parameters: 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 created! [Open Pull Request]({pr.html_url})"

        elif action == "list_open_pull_requests":
            if not repo_name:
                raise ValueError("Missing parameter: repo_name")
            repo = user.get_repo(repo_name)
            open_prs = repo.get_pulls(state='open')
            if not open_prs:
                return f"No open pull requests in repository **`{repo_name}`**."
            prs_list = "\n".join([f"- [{pr.title}]({pr.html_url})" for pr in open_prs])
            return f"Open pull requests in repository **`{repo_name}`**:\n{prs_list}"

        elif action == "create_issue":
            if not all([repo_name, title, body]):
                raise ValueError("Missing parameters: repo_name, title, body")
            repo = user.get_repo(repo_name)
            issue = repo.create_issue(title=title, body=body)
            return f"Issue created! [Open Issue]({issue.html_url})"

        elif action == "list_issues":
            if not repo_name:
                raise ValueError("Missing parameter: repo_name")
            repo = user.get_repo(repo_name)
            issues = repo.get_issues(state='open')
            if not issues:
                return f"No open issues in repository **`{repo_name}`**."
            issues_list = "\n".join([f"- [{issue.title}]({issue.html_url})" for issue in issues])
            return f"Open issues in repository **`{repo_name}`**:\n{issues_list}"

        elif action == "add_label_to_issue":
            if not all([repo_name, issue_number, labels]):
                raise ValueError("Missing parameters: 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"Labels **`{labels}`** added to issue **#{issue_number}** in repository **`{repo_name}`**."
            )

        elif action == "close_issue":
            if not all([repo_name, issue_number]):
                raise ValueError("Missing parameters: 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}** closed in repository **`{repo_name}`**."

        elif action == "add_comment_to_issue":
            if not all([repo_name, issue_number, message]):
                raise ValueError("Missing parameters: 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"Comment added to issue **#{issue_number}** in repository **`{repo_name}`**."

        elif action == "create_release":
            if not all([repo_name, tag, name, message]):
                raise ValueError("Missing parameters: 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}`** created in repository **`{repo_name}`**! [Open Release]({release.html_url})"
            )

        elif action == "list_releases":
            if not repo_name:
                raise ValueError("Missing parameter: repo_name")
            repo = user.get_repo(repo_name)
            releases = repo.get_releases()
            if not releases:
                return f"No releases in repository **`{repo_name}`**."
            releases_list = "\n".join([f"- [{release.tag_name}]({release.html_url})" for release in releases])
            return f"Releases in repository **`{repo_name}`**:\n{releases_list}"

        elif action == "fork_repository":
            if not repo_name:
                raise ValueError("Missing parameter: repo_name")
            repo = g.get_repo(repo_name)
            fork = user.create_fork(repo)
            return f"Repository **`{repo_name}`** forked! [Open fork]({fork.html_url})"

        elif action == "list_forks":
            if not repo_name:
                raise ValueError("Missing parameter: repo_name")
            repo = g.get_repo(repo_name)
            forks = repo.get_forks()
            if not forks:
                return f"No forks of repository **`{repo_name}`**."
            forks_list = "\n".join([f"- [{fork.full_name}]({fork.html_url})" for fork in forks])
            return f"Forks of repository **`{repo_name}`**:\n{forks_list}"

        elif action == "list_files":
            if not all([owner, repo_name]):
                raise ValueError("Missing parameters: owner, repo_name")
            repo = g.get_repo(f"{owner}/{repo_name}")
            contents = repo.get_contents("" if not path else path)
            if not contents:
                return f"No files in path **`{path}`** of repository **`{repo_name}`**."
            files_list = "\n".join([f"- [{content.name}]({content.download_url})" for content in contents])
            return f"Files in path **`{path}`** of repository **`{repo_name}`**:\n{files_list}"

        elif action == "get_repository_info":
            if not all([owner, repo_name]):
                raise ValueError("Missing parameters: owner, repo_name")
            repo = g.get_repo(f"{owner}/{repo_name}")
            info = {
                "Name": repo.name,
                "Description": repo.description,
                "URL": repo.html_url,
                "Owner": repo.owner.login,
                "Default branch": repo.default_branch,
                "Language": repo.language,
                "Stars": repo.stargazers_count,
                "Forks": repo.forks_count,
                "Created at": str(repo.created_at),
                "Last updated": str(repo.updated_at),
            }
            info_md = "\n".join([f"- **{key}**: {value}" for key, value in info.items()])
            return f"Repository info for **`{repo_name}`**:\n{info_md}"

        elif action == "get_file_content":
            if not all([owner, repo_name, path]):
                raise ValueError("Missing parameters: owner, repo_name, path")
            content_text = get_file_content(owner, repo_name, path, branch)
            return (
                f"File content of **`{path}`** from repository **`{repo_name}`**:\n\n`\n{content_text}\n`"
            )

        elif action == "analyze_repository_by_url":
            if not repo_url:
                raise ValueError("Missing parameter: repo_url")
            owner, repo_name = extract_repo_info(repo_url)
            if not owner or not repo_name:
                raise ValueError("Invalid repository URL")

            repo = g.get_repo(f"{owner}/{repo_name}")
            contents = repo.get_contents("")
            file_analyses = []
            for content in contents:
                if content.type == "file":
                    file_content = content.decoded_content.decode()
                    analysis = analyze_file_content(file_content, content.path)
                    file_analyses.append({
                        "name": content.name,
                        "path": content.path,
                        "analysis": analysis,
                    })
            analysis_md = "Repository file analysis:\n" + "\n".join([
                f"- **{f['path']}**:\n"
                f"  - Lines: {f['analysis']['line_count']}\n"
                f"  - Words: {f['analysis']['word_count']}\n"
                f"  - Extension: {f['analysis']['file_extension']}"
                for f in file_analyses
            ])
            return analysis_md

        elif action == "analyze_repository_content":
            if not all([owner, repo_name]):
                raise ValueError("Missing parameters: owner, repo_name")
            repo = g.get_repo(f"{owner}/{repo_name}")
            contents = repo.get_contents("")
            file_analyses = []
            for content in contents:
                if content.type == "file":
                    file_content = get_file_content(owner, repo_name, content.path, branch)
                    analysis = analyze_file_content(file_content, content.path)
                    file_analyses.append({
                        "name": content.name,
                        "path": content.path,
                        "analysis": analysis,
                    })
            analysis_md = "Repository content analysis:\n" + "\n".join([
                f"- **{f['path']}**:\n"
                f"  - Lines: {f['analysis']['line_count']}\n"
                f"  - Words: {f['analysis']['word_count']}\n"
                f"  - Extension: {f['analysis']['file_extension']}"
                for f in file_analyses
            ])
            return analysis_md

        elif action == "delete_repository":
            if not repo_name:
                raise ValueError("Missing parameter: repo_name")
            repo = user.get_repo(repo_name)
            repo.delete()
            return f"Repository **`{repo_name}`** deleted!"

        elif action == "update_repository_description":
            if not all([repo_name, new_description]):
                raise ValueError("Missing parameters: repo_name, new_description")
            repo = user.get_repo(repo_name)
            repo.edit(description=new_description)
            return f"Repository **`{repo_name}`** description updated to: \"{new_description}\""

        elif action == "edit_issue":
            if not all([repo_name, issue_number]):
                raise ValueError("Missing parameters: repo_name, issue_number")
            repo = user.get_repo(repo_name)
            issue = repo.get_issue(number=int(issue_number))
            issue_update_params = {}
            if issue_title is not None:
                issue_update_params['title'] = issue_title
            if issue_body is not None:
                issue_update_params['body'] = issue_body
            if issue_state is not None:
                issue_update_params['state'] = issue_state
            if not issue_update_params:
                raise ValueError("No issue details to update provided (title, body, or state)")
            issue.edit(**issue_update_params)
            updated_fields = ", ".join(issue_update_params.keys())
            return f"Issue **#{issue_number}** in repository **`{repo_name}`** updated fields: {updated_fields}"

        elif action == "list_closed_issues":
            if not repo_name:
                raise ValueError("Missing parameter: repo_name")
            repo = user.get_repo(repo_name)
            issues = repo.get_issues(state='closed')
            if not issues:
                return f"No closed issues in repository **`{repo_name}`**."
            issues_list = "\n".join([f"- [{issue.title}]({issue.html_url})" for issue in issues])
            return f"Closed issues in repository **`{repo_name}`**:\n{issues_list}"

        elif action == "get_issue_details":
            if not all([repo_name, issue_number]):
                raise ValueError("Missing parameters: repo_name, issue_number")
            repo = user.get_repo(repo_name)
            issue = repo.get_issue(number=int(issue_number))
            comments = issue.get_comments()
            details = f"""
**Issue #{issue.number}: {issue.title}**
State: {issue.state}
Created At: {issue.created_at}
Author: {issue.user.login}

**Body:**
{issue.body}

**Comments:**
"""
            if comments:
                for comment in comments:
                    details += f"""
---
**{comment.user.login}** at {comment.created_at}:
{comment.body}
"""
            else:
                details += "No comments."

            return details

        else:
            raise ValueError(f"Unknown action: {action}")

    except GithubException as e:
        return f"**GitHub Error:** {e}"
    except ValueError as e:
        return f"**Error:** {e}"
    except requests.exceptions.RequestException as e:
        return f"**Connection Error:** {e}"
    except Exception as e:
        return f"**Unexpected Error:** {e}"


with gr.Blocks() as demo:
    gr.Markdown("# GitHub Tool Plugingit (Simplified Interface)")

    with gr.Column():
        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", "update_file_diff",
                "list_branches", "create_branch", "delete_branch",
                "create_pull_request", "list_open_pull_requests",
                "create_issue", "list_issues", "list_closed_issues", "get_issue_details",
                "add_label_to_issue", "close_issue", "add_comment_to_issue",
                "create_release", "list_releases",
                "fork_repository", "list_forks",
                "list_files", "get_repository_info",
                "analyze_repository_by_url", "analyze_repository_content",
                "delete_repository", "update_repository_description", "edit_issue"
            ],
            label="Select Action",
        )
        repo_name = gr.Textbox(label="Repository Name")
        template_name = gr.Dropdown(
            choices=[""] + list(PROJECT_TEMPLATES.keys()),
            label="Project Template",
            value="",
            allow_custom_value=True,
        )
        template_params_ui = {}
        with gr.Row():
            for template_key, template_config in PROJECT_TEMPLATES.items():
                if "params" in template_config:
                    with gr.Column(visible=False, elem_classes=f"params_{template_key}") as params_section:
                        for param_name, param_details in template_config["params"].items():
                            if param_details["type"] == "choice":
                                template_params_ui[param_name] = gr.Dropdown(
                                    choices=param_details["choices"],
                                    label=param_details["description"] or param_name,
                                    value=param_details["default"]
                                )
                            else:
                                template_params_ui[param_name] = gr.Textbox(
                                    label=param_details["description"] or param_name,
                                    value=param_details["default"] if "default" in param_details else ""
                                )
                    template_params_ui[template_key] = params_section

        branch = gr.Textbox(label="Branch", value="main")
        path = gr.Textbox(label="File Path")
        content = gr.Code(label="File Content", lines=5, language='python', visible=True)
        diff = gr.Code(label="Diff Content", lines=5, language='diff', visible=False)
        message = gr.Textbox(label="Message/Comment", visible=True)
        diff_message = gr.Textbox(label="Diff Message", visible=False)
        owner = gr.Textbox(label="Owner")
        vcs_url = gr.Textbox(label="VCS URL")
        title = gr.Textbox(label="Title")
        body = gr.Textbox(label="Body")
        base = gr.Textbox(label="Base Branch")
        head = gr.Textbox(label="Head Branch/New Branch")
        issue_number = gr.Number(label="Issue Number", precision=0)
        labels = gr.Textbox(label="Labels (comma-separated)")
        tag = gr.Textbox(label="Tag")
        release_name = gr.Textbox(label="Release Name")
        file_url = gr.Textbox(label="File URL")
        repo_url = gr.Textbox(label="Repository URL")
        new_description = gr.Textbox(label="New Repository Description", visible=False)
        issue_title = gr.Textbox(label="New Issue Title", visible=False)
        issue_body = gr.Textbox(label="New Issue Body", visible=False, lines=3)
        issue_state = gr.Dropdown(label="New Issue State (open/closed)", choices=["open", "closed", None], value=None, allow_none=True, visible=False)

    def show_template_params(template_name):
        visibility_map = {key: gr.Column.update(visible=False) for key in PROJECT_TEMPLATES if
                          "params" in PROJECT_TEMPLATES[key]}
        if template_name and template_name in PROJECT_TEMPLATES and "params" in PROJECT_TEMPLATES[template_name]:
            visibility_map[template_name] = gr.Column.update(visible=True)
        return [visibility_map.get(key, gr.Column.update(visible=False)) for key in PROJECT_TEMPLATES if
                "params" in PROJECT_TEMPLATES[key]]

    template_param_visibility_outputs = [template_params_ui[key] for key in PROJECT_TEMPLATES if
                                         "params" in PROJECT_TEMPLATES[key]]
    template_name.change(
        show_template_params,
        inputs=[template_name],
        outputs=template_param_visibility_outputs
    )

    run_button = gr.Button("Execute")
    output = gr.Markdown(label="Result")

    input_components = [
        action, repo_name, branch, path, content, message, owner, vcs_url, title, body, base, head, issue_number,
        labels, tag, release_name, file_url, repo_url, template_name, new_description, issue_title, issue_body,
        issue_state, diff, diff_message
    ]

    for template_key in PROJECT_TEMPLATES:
        if "params" in PROJECT_TEMPLATES[template_key]:
            for param_name in template_params_ui:
                if param_name in PROJECT_TEMPLATES[template_key]["params"]:
                    input_components.append(template_params_ui[param_name])

    def show_hide_input_fields(action_name):
        visibility_map = {
            "repo_name": gr.Textbox.update(visible=False),
            "branch": gr.Textbox.update(visible=False),
            "path": gr.Textbox.update(visible=False),
            "content": gr.Code.update(visible=False),
            "diff": gr.Code.update(visible=False),
            "message": gr.Textbox.update(visible=False),
            "diff_message": gr.Textbox.update(visible=False),
            "owner": gr.Textbox.update(visible=False),
            "vcs_url": gr.Textbox.update(visible=False),
            "title": gr.Textbox.update(visible=False),
            "body": gr.Textbox.update(visible=False),
            "base": gr.Textbox.update(visible=False),
            "head": gr.Textbox.update(visible=False),
            "issue_number": gr.Number.update(visible=False),
            "labels": gr.Textbox.update(visible=False),
            "tag": gr.Textbox.update(visible=False),
            "release_name": gr.Textbox.update(visible=False),
            "file_url": gr.Textbox.update(visible=False),
            "repo_url": gr.Textbox.update(visible=False),
            "template_name": gr.Dropdown.update(visible=False),
            "new_description": gr.Textbox.update(visible=False),
            "issue_title": gr.Textbox.update(visible=False),
            "issue_body": gr.Textbox.update(visible=False),
            "issue_state": gr.Dropdown.update(visible=False),
        }

        if action_name in ["import_repository"]:
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "owner": gr.Textbox.update(visible=True), "vcs_url": gr.Textbox.update(visible=True)})
        elif action_name in ["create_repository", "delete_repository", "list_branches", "list_open_pull_requests", "list_issues", "list_closed_issues", "list_releases", "list_forks"]:
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True)})
        elif action_name == "create_project_from_template":
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "template_name": gr.Dropdown.update(visible=True)})
        elif action_name in ["create_file", "get_file", "delete_file", "get_file_content"]:
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "path": gr.Textbox.update(visible=True), "branch": gr.Textbox.update(visible=True)})
            if action_name == "create_file":
                visibility_map.update({"content": gr.Code.update(visible=True), "message": gr.Textbox.update(visible=True)})
        elif action_name == "update_file":
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "path": gr.Textbox.update(visible=True), "branch": gr.Textbox.update(visible=True), "content": gr.Code.update(visible=True), "message": gr.Textbox.update(visible=True)})
        elif action_name == "update_file_diff":
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "path": gr.Textbox.update(visible=True), "branch": gr.Textbox.update(visible=True), "diff": gr.Code.update(visible=True), "diff_message": gr.Textbox.update(visible=True)})
        elif action_name == "get_file_content_by_url":
            visibility_map.update({"file_url": gr.Textbox.update(visible=True)})
        elif action_name in ["create_branch", "delete_branch"]:
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "branch": gr.Textbox.update(visible=True)})
            if action_name == "create_branch":
                visibility_map.update({"base": gr.Textbox.update(visible=True), "head": gr.Textbox.update(visible=True)})
        elif action_name == "create_pull_request":
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "title": gr.Textbox.update(visible=True), "body": gr.Textbox.update(visible=True), "base": gr.Textbox.update(visible=True), "head": gr.Textbox.update(visible=True)})
        elif action_name == "create_issue":
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "title": gr.Textbox.update(visible=True), "body": gr.Textbox.update(visible=True)})
        elif action_name == "add_label_to_issue":
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "issue_number": gr.Number.update(visible=True), "labels": gr.Textbox.update(visible=True)})
        elif action_name in ["close_issue", "add_comment_to_issue", "get_issue_details", "edit_issue"]:
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "issue_number": gr.Number.update(visible=True)})
            if action_name == "add_comment_to_issue":
                visibility_map.update({"message": gr.Textbox.update(visible=True)})
            if action_name == "edit_issue":
                visibility_map.update({"issue_title": gr.Textbox.update(visible=True), "issue_body": gr.Textbox.update(visible=True), "issue_state": gr.Dropdown.update(visible=True)})
        elif action_name == "create_release":
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "tag": gr.Textbox.update(visible=True), "release_name": gr.Textbox.update(visible=True), "message": gr.Textbox.update(visible=True)})
        elif action_name == "fork_repository":
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True)})
        elif action_name in ["list_files", "get_repository_info", "analyze_repository_content"]:
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "owner": gr.Textbox.update(visible=True)})
        elif action_name == "analyze_repository_by_url":
            visibility_map.update({"repo_url": gr.Textbox.update(visible=True)})
        elif action_name == "update_repository_description":
            visibility_map.update({"repo_name": gr.Textbox.update(visible=True), "new_description": gr.Textbox.update(visible=True)})


        return [visibility_map.get(key, gr.Textbox.update(visible=False)) for key in visibility_map]

    output_components_visibility = [
        repo_name, branch, path, content, message, owner, vcs_url, title, body, base, head, issue_number, labels,
        tag, release_name, file_url, repo_url, template_name, new_description, issue_title, issue_body,
        issue_state, diff, diff_message
    ]

    action.change(
        show_hide_input_fields,
        inputs=[action],
        outputs=output_components_visibility
    )


    run_button.click(
        github_tool,
        inputs=input_components,
        outputs=output,
        api_name="github_tool"
    )

demo.launch()