Vite + React

)) Card.displayName = "Card" const CardHeader = React.forwardRef(({ className, ...props }, ref) => (

)) CardHeader.displayName = "CardHeader" const CardTitle = React.forwardRef(({ className, ...props }, ref) => (

)) CardTitle.displayName = "CardTitle" const CardDescription = React.forwardRef(({ className, ...props }, ref) => (
)) CardDescription.displayName = "CardDescription" const CardContent = React.forwardRef(({ className, ...props }, ref) => (
)) CardContent.displayName = "CardContent" const CardFooter = React.forwardRef(({ className, ...props }, ref) => (
)) CardFooter.displayName = "CardFooter" export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent }""", "src/lib/utils.js": """import { clsx } from "clsx" import { twMerge } from "tailwind-merge" export function cn(...inputs) { return twMerge(clsx(inputs)) }""" }, "post_process": "shadcn_setup" # Now using a specific post_process action }, } 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() # Raise HTTPError for bad responses (4xx or 5xx) 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 # New parameter for template parameters ): """Manages GitHub repositories.""" user = g.get_user() try: # Single try block for ALL actions 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) # Check if repo exists (simplified) return "Repository already exists." except GithubException: pass # Repo doesn't exist, proceed with import 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() # Handle potential HTTP errors. 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] # Prepare template parameters, use defaults if not provided 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") # Handle file renaming and content templating repo_name_snake_case = repo_name.replace("-", "_") # For django app names readme_filename = "README.md" # Default readme name env = jinja2.Environment() # Initialize Jinja2 environment for file_path, file_content in template["files"].items(): final_file_path = file_path final_file_content = file_content # Apply file renaming if defined in template 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) # Render file content using Jinja2 template 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 # Pass template parameters to Jinja2 ) repo.create_file( final_file_path, f"Create {final_file_path} from template {template_name}", final_file_content, branch="main", ) # Post-processing actions (example: install dependencies) 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).") # existing message elif post_process_action == "shadcn_setup": # New post-process action 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}") # Handle unknown actions return f"Repository {repo_name} created from template {template_name}! [Open repository]({repo.html_url})" elif action == "create_file": # ... rest of actions - no changes needed in most of them ... 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) # Dummy call to avoid UnboundLocalError. get_file_content changed! 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 == "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) # Simplified path handling 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) # Use helper 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 else: # Correct else for handling unknown actions raise ValueError(f"Unknown action: {action}") except GithubException as e: return f"GitHub Error: {e}" except ValueError as e: return f"Error: {e}" # This is line 434 (now corrected) except requests.exceptions.RequestException as e: return f"Connection Error: {e}" except Exception as e: return f"Unexpected Error:** {e}" # Catch all. 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", # Modular actions - to be added later in UI if needed # "create_repository_structure", # "add_dependencies", # "configure_database", # "add_authentication", "create_file", "get_file", "get_file_content_by_url", "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", "get_repository_info", "get_file_content", "analyze_repository_by_url", "analyze_repository_content", ], label="Select Action", ) repo_name = gr.Textbox(label="Repository Name") template_name = gr.Dropdown( choices=[""] + list(PROJECT_TEMPLATES.keys()), # Add "" as a choice label="Project Template", value="", # Set default value to "" (no selection) allow_custom_value=True, # Use allow_custom_value instead of allow_none ) # Template parameters UI - dynamically generated based on template template_params_ui = {} with gr.Row(): # Display parameters in a row for better layout 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: # Hide initially 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: # Add other input types if needed (e.g., Textbox for string parameters) 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 # Store the section itself for visibility control branch = gr.Textbox(label="Branch", value="main") path = gr.Textbox(label="File Path") content = gr.Code(label="File Content", lines=5, language='python') # Larger code box message = gr.Textbox(label="Message/Comment") 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") # Function to show/hide template parameters based on template selection 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]} # Initially hide all 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) # Show for selected template return [visibility_map.get(key, gr.Column.update(visible=False)) for key in PROJECT_TEMPLATES if "params" in PROJECT_TEMPLATES[key]] # Return list in consistent order template_param_visibility_outputs = [template_params_ui[key] for key in PROJECT_TEMPLATES if "params" in PROJECT_TEMPLATES[key]] # Get list of output components for visibility template_name.change( show_template_params, inputs=[template_name], outputs=template_param_visibility_outputs ) run_button = gr.Button("Execute") output = gr.Markdown(label="Result") # Use Markdown for richer output 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, ] # Add template parameters dynamically to input components for template_key in PROJECT_TEMPLATES: if "params" in PROJECT_TEMPLATES[template_key]: for param_name in template_params_ui: # Use keys from template_params_ui which are param names if param_name in PROJECT_TEMPLATES[template_key]["params"]: # Check if parameter belongs to template input_components.append(template_params_ui[param_name]) # Append parameter component run_button.click( github_tool, inputs=input_components, # Use dynamically built input list outputs=output, api_name="github_tool" ) demo.launch()

Hello from React!

Hello from Static Website!

Witaj w aplikacji Shadcn UI!