TySS-Dev/github_pulse
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: TySS-Dev/github_pulse:main
Branches Tags
TySS-Dev/github_pulse:main TySS-Dev/github_pulse:Test
..
pull from: TySS-Dev/github_pulse:Test
Branches Tags
TySS-Dev/github_pulse:main TySS-Dev/github_pulse:Test

1 Commits
main .. Test

Author SHA1 Message Date
Tyler a97b4507a5 Add test.md with initial content 2025-11-11 22:15:56 -10:00
45 changed files with 5167 additions and 7387 deletions
Expand all files Collapse all files
.gitignore
+50 -41
View File
@@ -1,6 +1,6 @@
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*.py[codz]
*$py.class
# C extensions
@@ -46,7 +46,7 @@ htmlcov/
nosetests.xml
coverage.xml
*.cover
*.py,cover
*.py.cover
.hypothesis/
.pytest_cache/
cover/
@@ -94,20 +94,35 @@ ipython_config.py
# install all needed dependencies.
#Pipfile.lock
# UV
# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
# This is especially recommended for binary packages to ensure reproducibility, and is more
# commonly ignored for libraries.
#uv.lock
# poetry
# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
# This is especially recommended for binary packages to ensure reproducibility, and is more
# commonly ignored for libraries.
# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
*.lock
#poetry.lock
#poetry.toml
# pdm
# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
# pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
# https://pdm-project.org/en/latest/usage/project/#working-with-version-control
#pdm.lock
# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
# in version control.
# https://pdm.fming.dev/#use-with-ide
.pdm.toml
#pdm.toml
.pdm-python
.pdm-build/
# pixi
# Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
#pixi.lock
# Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
# in the .venv directory. It is recommended not to include this directory in version control.
.pixi
# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
__pypackages__/
@@ -121,6 +136,7 @@ celerybeat.pid
# Environments
.env
.envrc
.venv
env/
venv/
@@ -159,40 +175,33 @@ cython_debug/
# option (not recommended) you can uncomment the following to ignore the entire idea folder.
#.idea/
# Flet
storage/
.flet/
# Abstra
# Abstra is an AI-powered process automation framework.
# Ignore directories containing user credentials, local state, and settings.
# Learn more at https://abstra.io/docs
.abstra/
# Build artifacts
build/
dist/
src/build/
src/dist/
*.apk
*.ipa
*.app
*.exe
*.dmg
*.deb
*.rpm
*.tar.gz
# Visual Studio Code
# Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
# that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
# and can be added to the global gitignore or merged into this file. However, if you prefer,
# you could uncomment the following to ignore the entire vscode folder
# .vscode/
# Flutter/Flet build artifacts
.flutter-plugins
.flutter-plugins-dependencies
.dart_tool/
android/
ios/
linux/
macos/
windows/
web/
.flet
build/
*.toml
# Ruff stuff:
.ruff_cache/
# Configuration (generated during build, not in git)
# Note: pyproject.toml is now tracked for proper builds
# config.json should be user-specific
config.json
src/config.json
# PyPI configuration file
.pypirc
# Cursor
# Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
# exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
# refer to https://docs.cursor.com/context/ignore-files
.cursorignore
.cursorindexingignore
# Marimo
marimo/_static/
marimo/_lsp/
__marimo__/
BUILD.md
-152
View File
@@ -1,152 +0,0 @@
# Build Instructions
> [!NOTE]
> Building has only been tested for **linux**.
> Please report bugs with building on any other platform.
## Prerequisites
- [Node.js](https://nodejs.org/) (v18+)
- [Git](https://git-scm.com/)
- Flet v0.28.0
- Flutter SDK v3.29.0 (Flet will install this automatically, but you can also [install it manually](https://docs.flutter.dev/get-started/install))
- [Visual Studio 2016 (Windows Users)](https://aka.ms/vs/16/release/vs_community.exe)
- Android Studio (for Android builds)
- Xcode (for iOS builds)
- Any required package managers (e.g., npm, yarn)
> [!IMPORTANT]
> Flet v0.28.9 only supports Flutter SDK v3.29.0. Using other versions may lead to build failures.
> Flutter SDK v3.29.0 only supports Visual Studio 2016 on Windows. Ensure you have the correct version installed.
## Clone the Repository
```bash
git clone https://github.com/TySP-Dev/github_pulse.git
cd github_pulse/src
```
## Python Virtual Environment
```bash
# Create virtual environment
python -m venv venv
# Activate virtual environment
# On Windows:
venv\Scripts\activate
# On macOS/Linux:
source venv/bin/activate
```
## Install Dependencies
```bash
# For dev dependencies
pip install -r requirements/requirements-dev.txt
```
```bash
# Linux Dependencies (Ubuntu/Debian)
sudo apt update
sudo apt upgrade
sudo apt install clang cmake ninja-build pkg-config libgtk-3-dev liblzma-dev
```
## Setup Flutte
```bash
# Set ICU data file path (Windows example)
$env:FLUTTER_ICU_DATA_FILE="C:\path\to\flutter\bin\cache\artifacts\engine\windows-x64\icudtl.dat"
```
# Example path $env:FLUTTER_ICU_DATA_FILE="C:\Users\<username>\flutter\bin\cache\artifacts\engine\windows-x64\icudtl.dat"
```bash
# Verify Flutter installation
flutter --version
```
```bash
# Run Flutter doctor
flutter doctor
```
```bash
# Flet doctor
python -m flet.cli doctor
```
```bash
# Accept Android licenses (if building for Android)
flutter doctor --android-licenses
```
```bash
# Precache Flutter artifacts (All platforms)
flutter precache --all
```
```bash
# precache Flutter artifacts (Windows example)
flutter precache --windows
```
```bash
# precache Flutter artifacts (Linux example)
flutter precache --linux
```
```bash
# precache Flutter artifacts (MacOS example)
flutter precache --macos
```
```bash
# precache Flutter artifacts (iOS example)
flutter precache --ios
```
```bash
# precache Flutter artifacts (Android example)
flutter precache --android
```
>[!NOTE]
> Only precache the platforms you intend to build for.
## Build the Application
> [!NOTE]
> Ensure you are in the `src` directory of the project and the Python virtual environment is activated. `venv\Scripts\activate` (Windows) or `source venv/bin/activate` (macOS/Linux).
```bash
# Windows
flet build windows
```
```bash
# Linux
flet build linux
```
```bash
# Android
flet build apk
```
```bash
# macOS
flet build macos
```
```bash
# iOS
flet build ios
```
## Additional Notes
- See `README.md` for more details.
- For troubleshooting, check the logs or open an issue.
- Customize build scripts in `package.json` as needed.
README.md
+135 -90
View File
@@ -1,123 +1,168 @@
> [!WARNING]
> This project is no longer being maintained.
# Azure DevOps → GitHub Processor (GUI)
# ![GitHub Pulse Logo](src/app_components/assets/pulse_logo_white_no_bkg_github.png)
Azure DevOps -> GitHub Processor is a small, focused GUI tool that you can use to perform the following tasks:
A Python-based GUI application for GitHub automation workflows and AI assisted workflows.
1. Fetches Azure DevOps work items using a query you specify and extracts documentation change information from them.
1. Creates a GitHub issues using the information and assigns the issue to GitHub Copilot, which analyzes the request, creates a branch, updates the article to fix the issue, and submits a pull request (PR) on behalf of you.
![GitHub Pulse img](src/app_components/assets/github_pulse_img.png)
The following diagram shows you the high-level steps performed by this solution:
## Pulse Workflow
![High-level diagram of the Azure DevOps -> GitHub Processor solution](./media/flow-diagram.png)
![Pulse Workflow img](src/app_components/assets/flow-diagram.png)
The PR is assigned to the author of the article based on the author metadata in the article. The author reviews off the PR and signs on it if the changes done by Copilot look good.
## Project Structure
```text
github_pulse/
├── src/ # Main application directory
│ ├── main.py # Application entry point
│ ├── requirements.txt # Python dependencies
│ ├── assets/ # Images for build
│ │ ├── icon.png # Application icon
│ │ └── splash_android.png # Splash screen image
│ ├── requirements/
│ │ ├── requirements-dev.txt # Development dependencies
│ │ ├── requirements-ai.txt # AI dependencies
│ │ ├── requirements.txt # Production dependencies
│ │ └── requirements-base.txt # Base dependencies
│ └── app_components/ # Application modules
│ ├── assets/ # Images and assets
│ │ ├── flow-diagram.png # Workflow diagram
│ │ ├── github_pulse_img.png # GitHub Pulse image
│ │ ├── pulse_logo_gray_no_bkg.png # GitHub Pulse logo
│ │ ├── pulse_logo_white_no_bkg_github.png # Pulse logo
│ │ ├── pulse_logo_white_no_bkg.png # Pulse logo with background
│ │ └── pulse_logo_white_w_black_bkg.png # GitHub Pulse logo with background
│ ├── __init__.py # Package initializer
│ ├── ai_manager.py # AI provider integration
│ ├── cache_manager.py # Caching functionality
│ ├── config_manager.py # Configuration management
│ ├── github_api.py # GitHub API client
│ ├── main_gui.py # Main GUI interface
│ ├── processing_log_dialog.py # Processing log dialog
│ ├── settings_dialog.py # Settings dialog
│ ├── settings_manager.py # Settings management
│ ├── utils.py # Utility functions
│ └── workflow.py # Workflow processing
├── assets/ # Images and assets
├── README.md # Readme file
├── SETUP.md # This file
└── LICENSE # License information
```
The `devops_to_github.py` file in the `Devops_to_GitHub_Python/latest` folder has all the code behind this tool.
## Prerequisites
Here are the prerequisites to use the tool:
- Python 3.8 or higher
- Git installed and configured
- GitHub account with repository access
- Python 3.10 or newer (the code uses modern union types like `dict | None`)
- Install packages used in the code, such as `requests` and `tkinter`, which is used for the GUI.
- GitHub Copilot must be enabled at the organization level or for the specific repository.
- You must have admin access to the repository to assign issues to Copilot.
## Quick Start
### Azure DevOps prerequisites
1. **Clone the repository**
- **Azure DevOps Query URL**: A shared query URL containing documentation update work items. You can use this [sample query](https://dev.azure.com/msft-skilling/Content/_queries/query/ab92a364-1376-43d5-a6da-510aa40a65d1/) for testing purposes.
```bash
git clone https://github.com/TySP-Dev/github_pulse.git
cd github_pulse/src
Work items must contain the following fields in their description:
- **Nature of Request**: Must include **Modify existing docs**.
- **Link to doc**: Must be a URL to a Learn article.
- **Text to change**: Current text that needs to update. Can be blank.
- **Proposed new text**: Suggested replacement text. This text can be instructional such as "Remove last two links from the Related content section". In this example, the GitHub Copilot doesn't replace old text with new text. It just removes those two links.
- **Azure DevOps Personal Access Token (PAT)**: Token with work item read, write, and manage permissions. The write permission is used to write back the link to GitHub issue in the DevOps work item. For instructions on creating a token, see [Authenticate to DevOps with personal access tokens](https://learn.microsoft.com/azure/devops/organizations/accounts/use-personal-access-tokens-to-authenticate?view=azure-devops&tabs=Windows#create-a-pat).
### GitHub prerequisites
- **GitHub Personal Access Token**: A **classic** token with **repo**, **admin:org**, and **copilot** permissions. For instructions on creating a token, see [Create a personal access token (classic)](https://docs.github.com/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens#creating-a-personal-access-token-classic)
## Configuration and tokens management
The app first looks for tokens in the **launch.json** file and then in the **.env** file. We recommend that you use the **.env** approach.
Create a `.env` file in the repository root and add:
```
AZURE_DEVOPS_QUERY=your_azure-devops-query-url
AZURE_DEVOPS_PAT=your_azure_devops_pat_here
GITHUB_PAT=your_github_pat_here
```
2. **Create and activate virtual environment**
**Security reminder**: Never commit secrets. Add `.env` to `.gitignore` if you plan to store tokens locally.
```bash
# Create virtual environment
python -m venv venv
### launch.json
# Activate (Windows)
venv\Scripts\activate
Create or edit `.vscode/launch.json` and add the values into the `env` object for the configuration you run. Example snippet:
```json
{
"configurations": [
{
"name": "Run devops_to_github",
"type": "python",
"request": "launch",
"program": "${workspaceFolder}/POC/latest/devops_to_github.py",
"console": "integratedTerminal",
"env": {
"AZURE_DEVOPS_QUERY": "<your-azure-devops-query-url>",
"AZURE_DEVOPS_PAT": "<your-azure-pat>",
"GITHUB_PAT": "<your-github-pat>"
}
}
]
}
# Activate (macOS/Linux)
source venv/bin/activate
```
- If you use a VS Code launch configuration, do NOT put secrets in `.vscode/launch.json`.
- Instead use an env file and reference it via `"envFile": "${workspaceFolder}/.env"` or keep only placeholders in a committed `launch.json.example`.
- For CI and shared environments, use secret stores (GitHub Actions secrets, Azure Key Vault, etc.)—do not commit tokens into the repo.
3. **Install dependencies**
**Warning:** Never commit PATs, tokens, or other secrets. If a secret is accidentally committed, rotate it immediately.
```bash
# For all production dependencies
pip install -r requirements/requirements.txt
```
## How to run the app
Use one of the following methods:
```bash
# For dev dependencies
pip install -r requirements/requirements-dev.txt
```
- From a terminal (PowerShell on Windows), run the following command: `python .\POC\latest\devops_to_github.py`
- Or run the `Run`/`Debug` configuration in VS Code if you configured `launch.json` (or) `.env`.
```bash
# For ai dependencies
pip install -r requirements/requirements-ai.txt
```
## Using the app (overview)
1. Enter or verify the Azure DevOps Query URL and the PATs (or rely on loaded config from `launch.json` / `.env`).
1. Toggle **Dry Run**" to simulate operations (recommended for first runs).
1. Select **Fetch Work Items** to execute the Azure query and parse work items (this invokes `start_fetch_work_items` -> `fetch_work_items`).
```bash
# For base dependencies
pip install -r requirements/requirements-base.txt
```
![UI after fetching work items from Azure DevOps.](./media/fetch-work-items.png)
1. Navigate items with **← Previous** / **Next →**. Each item shows the parsed fields (`nature_of_request`, `mydoc_url`, `text_to_change`, `new_text`), detected GitHub repo (owner/repo), and `ms.author` when available.
1. Edit the **proposed new text** inline by selecting the ✏️ Edit control, make changes, then **Save**.
1. Select **🚀 CREATE ISSUE** to create an issue in the detected GitHub repo. On success you will get a hyperlink dialog with the created issue URL.
4. **Run the application**
![UI after creating a GitHub issue.](./media/issue-created.png)
```bash
python app.py
```
Here's what the tool does when you select **Create issue**
- Uses GitHub GraphQL API to fetch the repository ID and call `createIssue`.
- Attempts to locate a suggested actor named like Copilot and assign the new issue to that actor.
- Includes an `AB#<work item id>` line in the issue body to trace back to the Azure work item.
- If available, calls Azure DevOps API to add a hyperlink back to the Azure work item referencing the new GitHub issue URL.
1. Select the link to navigate to the GitHub issue to do the following tasks. In your Azure DevOps work item, you should see a link to the GitHub issue in the **GitHub issue** section as well.
- Review the details
- Notice that the GitHub issue is assigned to a Copilot
- The Copilot has created a pull request.
- A link back to Azure DevOps work item
## Configuration
![GitHub issue UI.](./media/github-issue-copilot-pr.png)
1. Select the pull request to review changes, and sign off on the PR after a successful build and the changes look good to you.
Configuration is managed through a `.env` file or settings dialog in the application.
![GitHub Pull Request UI.](./media/github-pull-request.png)
See [SETUP.md](SETUP.md) for detailed setup instructions.
## Dry-run and logging
Dry-run prints GraphQL payloads and simulates the behavior without performing remote mutations. Inspect the "Processing Log" tab to see payloads and debug messages.
## Notes, limitations & troubleshooting
- The UI currently focuses on creating issues. There is a GraphQL `createPullRequest` function implemented, but the PR option is not exposed in the GUI at the moment.
- The work item description parsing is opinionated and expects fields like "Nature of Request:", "Link to Doc:", "Text to Change:", and "Proposed new text:". If parsing fails, the work item will be skipped.
- Document URL extraction relies on the document's HTML metadata (`original_content_git_url` or similar). If the metadata isn't present or the URL is not a GitHub URL, the tool cannot determine owner/repo.
- Common errors:
- Invalid query URL: ensure the query URL uses `_queries/query/<id>/` or includes `queryId=`
- Token permission errors: check PAT scopes
- Network timeouts: check VPN/firewall rules and increase timeouts in code if needed
## Developer notes
- File of interest: `POC/latest/devops_to_github.py` (main GUI + logic)
- Logging is visible in the GUI under "Processing Log". The app is single-process with background threads for network calls.
- Python typing uses modern syntax (requires Python 3.10+).
## Process flow (diagram)
The following diagram illustrates the end-to-end processing flow implemented by `POC/latest/devops_to_github.py`. It shows how the application fetches Azure DevOps work items, validates and parses each item, discovers the target GitHub repository from the document metadata, and then creates and (optionally) assigns and links the resulting GitHub issue back to the Azure DevOps work item.
![Hack2025 processing flow](Devops_to_GitHub_Python/latest/Hack2025_flow.png)
High-level steps shown in the diagram:
1. User launches the GUI and provides the Azure DevOps query URL and tokens.
1. The app validates the query URL and executes the query to fetch work item IDs.
1. For each work item the app fetches details and parses the description for the required fields (Nature of Request, Link to Doc, Text to Change, Proposed new text).
1. If the item contains a valid document URL, the tool requests the document HTML and extracts `original_content_git_url` and metadata such as `ms.author`.
1. The tool maps the document metadata to a GitHub `owner/repo`, builds an issue title and body, and uses the GitHub GraphQL API to create the issue (dry-run mode simulates this).
1. If available, Copilot (or another suggested actor) is assigned to the created issue; the tool will also attempt to add a hyperlink back to the Azure work item.
1. The GUI updates the item's processing status and shows a link to the created issue on success.
## Contributing
This project welcomes contributions and suggestions. In order to contribute, please fork the repository and create a pull request.
This project welcomes contributions and suggestions. Most contributions require you to agree to a
Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
the rights to use your contribution. For details, visit [Contributor License Agreements](https://cla.opensource.microsoft.com).
## License
When you submit a pull request, a CLA bot will automatically determine whether you need to provide
a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
provided by the bot. You will only need to do this once across all repos using our CLA.
GNU General Public License v3.0.
See [LICENSE](LICENSE) file for details.
This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
## Trademarks
This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft
trademarks or logos is subject to and must follow
[Microsoft's Trademark & Brand Guidelines](https://www.microsoft.com/legal/intellectualproperty/trademarks/usage/general).
Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
Any use of third-party trademarks or logos are subject to those third-party's policies.
SETUP.md
+178 -72
View File
@@ -1,8 +1,8 @@
# GitHub Pulse - Setup Guide
# MicrosoftDocFlow Tool - Setup Guide
## Overview
A Python-based GUI application for GitHub automation workflows.
This tool automates the process of converting Azure DevOps work items into GitHub pull requests with AI assistance. It fetches work items, processes documentation changes, and creates pull requests with proper diffs.
## Quick Start
@@ -10,16 +10,17 @@ A Python-based GUI application for GitHub automation workflows.
- **Python 3.8+** installed on your system
- **Git** installed and configured
- **Azure DevOps** account with work items
- **GitHub** account with repository access
- **libmpv** installed on your system (Linux)
- **AI Provider** account (optional, for enhanced processing)
### Installation
1. **Clone/Download the Repository**
```bash
git clone https://github.com/TySP-Dev/github_pulse.git
cd github_pulse/src
git clone https://github.com/TySP-Dev/github_automation.git
cd github_automation\application
```
2. **Create Virtual Environment** (Recommended)
@@ -36,46 +37,30 @@ A Python-based GUI application for GitHub automation workflows.
source venv/bin/activate
```
To deactivate the environment when done:
```bash
deactivate
```
3. **Install Dependencies**
```bash
# For all production dependencies
pip install -r requirements/requirements.txt
```
```bash
# For dev dependencies
pip install -r requirements/requirements-dev.txt
```
```bash
# For ai dependencies
pip install -r requirements/requirements-ai.txt
```
```bash
# For base dependencies
pip install -r requirements/requirements-base.txt
pip install -r requirements.txt
```
4. **Run the Application**
```bash
python main.py
python app.py
```
> [!NOTE]
> It is highly recommended to use a virtual environment to manage dependencies and avoid conflicts with other Python projects on your system.
> Ensure you activate the virtual environment each time you work on or start this application.
### Virtual Environment Management
**Activating the environment** (when returning to the project):
```bash
- Windows: `venv\Scripts\activate`
- macOS/Linux: `source venv/bin/activate`
```
**Deactivating the environment** (when done working):
@@ -95,40 +80,24 @@ deactivate
The project is organized as follows:
```text
github_pulse/
├── src/ # Main application directory
│ ├── main.py # Application entry point
github_automation/
├── application/ # Main application
│ ├── app.py # Application entry point
│ ├── requirements.txt # Python dependencies
│ ├── assets/ # Images for build
│ │ ├── icon.png # Application icon
│ │ └── splash_android.png # Splash screen image
│ ├── requirements/
│ │ ├── requirements-dev.txt # Development dependencies
│ │ ├── requirements-ai.txt # AI dependencies
│ │ ├── requirements.txt # Production dependencies
│ │ └── requirements-base.txt # Base dependencies
│ └── app_components/ # Application modules
│ ├── assets/ # Images and assets
│ │ ├── flow-diagram.png # Workflow diagram
│ │ ├── github_pulse_img.png # GitHub Pulse image
│ │ ├── pulse_logo_gray_no_bkg.png # GitHub Pulse logo
│ │ ├── pulse_logo_white_no_bkg_github.png # Pulse logo
│ │ ├── pulse_logo_white_no_bkg.png # Pulse logo with background
│ │ └── pulse_logo_white_w_black_bkg.png # GitHub Pulse logo with background
│ ├── __init__.py # Package initializer
│ ├── ai_manager.py # AI provider integration
│ ├── cache_manager.py # Caching functionality
│ ├── config_manager.py # Configuration management
│ ├── ai_manager.py # AI provider
│ ├── azure_devops_api.py # Azure DevOps API
│ ├── cache_manager.py # Work item caching
│ ├── config_manager.py # Configuration
│ ├── dataverse_api.py # Dataverse API
│ ├── github_api.py # GitHub API client
│ ├── main_gui.py # Main GUI interface
│ ├── processing_log_dialog.py # Processing log dialog
│ ├── settings_dialog.py # Settings dialog
│ ├── settings_manager.py # Settings management
│ ├── utils.py # Utility functions
│ └── workflow.py # Workflow processing
├── assets/ # Images and assets
├── README.md # Readme file
├── SETUP.md # This file
│ └── work_item_processor.py # Work item
├── media/ # Images and assets
├── README.md # Project overview
├── SETUP.md # This setup guide
└── LICENSE # License information
```
@@ -137,7 +106,16 @@ github_pulse/
### First-Time Setup
1. **Launch the application** and click "Settings" button
2. **Configure required fields** in the Settings dialog
2. **Configure required fields** in the Settings dialog:
#### Azure DevOps Configuration (Required)
- **Query URL**: Your Azure DevOps query URL
- Example: `https://dev.azure.com/yourorg/project/_queries/query/12345678-1234-1234-1234-123456789abc/`
- Get this from Azure DevOps by creating/opening a query and copying the URL
- **Personal Access Token**: Azure DevOps PAT with work item read permissions
- Create at: `https://dev.azure.com/yourorg/_usersSettings/tokens`
- Required scopes: Work Items (Read/Write)
#### GitHub Configuration (Required)
@@ -145,46 +123,172 @@ github_pulse/
- Create at: `https://github.com/settings/tokens`
- Required scopes: repo, workflow
- **Target Repository**: Format as `owner/repository`
- Example: `microsoft/example-repo`
- **Forked Repository**: Your fork of the target repository (if applicable)
- Example: `yourusername/example-repo`
- Example: `microsoft/fabric-docs`
- **Forked Repository**: Your fork of the target repository
- Example: `yourusername/fabric-docs`
- **Local Repo Path**: Directory where repositories will be/are cloned
- Example: `C:\Users\yourname\repos\`
#### AI Provider Configuration (Optional)
- **Provider**: Choose from:
- `none` - No AI assistance
- `none` - GitHub Copilot via a automatic comment on the PR
- `claude` - Anthropic Claude API
- `chatgpt` - OpenAI ChatGPT API
- `github-copilot` - GitHub Models API
- `ollama` - Ollama Local Models
- **Ollama Model**: Select model based on local availability
- **Ollama API Endpoint**: URL for Ollama AI server
- **API Keys**: Provide keys based on your chosen provider
- GitHub Token: Auto-defaults to GitHub PAT if left empty
### Configuration Tips
**Start Simple**: Configure only GitHub initially
**Start Simple**: Configure only Azure DevOps and GitHub initially
**Test Connection**: Use "Test Connection" button to verify settings
**AI Enhancement**: Add AI provider later for automated processing
**Configuration File**: Settings are saved in `config.json` for persistence
**Cache Benefits**: Work items are cached for faster subsequent loads
**AI Enhancement**: Add AI provider later for automated text processing
## Usage Guide
### Basic Workflow
1. **Load Work Items**
- Click "Fetch Work Items" to load work items from your query
- Items are displayed in the "All Work Items" tab
- Cached items load automatically on subsequent launches
2. **Select Work Item**
- Navigate to "All Work Items" tab
- **Double-click** any work item to select it as current
- OR click "Set as Current Item" button
- Selected item appears in "Current Work Item" tab
3. **Review Work Item Details**
- **Work Item ID**: Click to open in Azure DevOps
- **Nature of Request**: Description of required changes
- **Document URL**: Target documentation URL
- **Text to Change**: Current text that needs modification
- **Proposed New Text**: Replacement text (editable)
4. **Process Changes**
- **With AI**: If AI provider is configured and the AI provider is not `none`, click "Create PR" and the selected AI will be used
- **Manual**: Click "Create PR" or "Create Issue" for manual processing / GitHub Copilot comment
- **Dry Run**: Enable for testing without actual changes (Located in settings)
### Advanced Features
#### Work Item Navigation
- **Next/Previous**: Navigate through multiple work items
- **Edit Mode**: Click "Edit" to modify proposed text
#### Git Diff Viewer
- View file changes in the "Git Diff" tab
- Shows before/after comparison
- Automatic diff generation from repository changes
#### Processing Log
- Real-time activity logging in "Processing Log" tab
- Track API calls, file operations, and errors
- Detailed workflow visibility
## Advanced Configuration
### AI Provider Setup
#### Claude (Anthropic)
1. Get API key from [console.anthropic.com](https://console.anthropic.com)
2. Set provider to `claude`
3. Enter API key in settings
4. Cost: ~$0.01-0.05 per work item
#### ChatGPT (OpenAI)
1. Get API key from [platform.openai.com/api-keys](https://platform.openai.com/api-keys)
1. Set provider to `chatgpt`
1. Enter API key in settings
1. Cost: ~$0.01-0.05 per work item
#### GitHub Copilot
1. Ensure GitHub account has Copilot access
2. Set provider to `github-copilot`
3. GitHub Token auto-defaults to GitHub PAT
4. Uses GitHub Models API
### Repository Management
#### Local Repository Setup
- **Automatic Cloning**: Repositories are cloned automatically to Local Repo Path if AI provider is used
- **Branch Management**: Creates feature branches for each work item
- **Sync Handling**: Keeps repositories updated with upstream changes
#### Forked Repository Workflow
1. **Fork** the target repository to your GitHub account
2. **Configure** both target and forked repositories in settings
3. **Automatic**: Tool manages branch creation and PR submission
### Custom Instructions
Add custom AI instructions in settings to guide processing:
```AI Prompt
Focus on technical accuracy and clear documentation.
Ensure all code examples are properly formatted.
Include relevant cross-references to related topics.
```
## 🛠️ Troubleshooting
### Common Issues
**"No work items found"**
- Verify Azure DevOps query URL is correct
- Check PAT has work item read permissions
- Ensure query returns results in Azure DevOps
**"Repository not found"**
- Verify GitHub repository name format (`owner/repo`)
- Check GitHub PAT has repository access
- Ensure repository exists and is accessible
**"AI processing failed"**
- Verify API key is correct and has credits
- Check internet connection
- Review processing log for specific errors
**"Git operations failed"**
- Ensure Git is installed and configured
- Check Local Repo Path exists and is writable
- Verify GitHub authentication is working
### Performance Tips
**Use Cache**: Let items load from cache for faster startup
**Dry Run**: Test changes before committing
**Batch Processing**: Process multiple items in sequence
**Monitor Logs**: Watch processing log for issues
## Security Best Practices
### Token Security
- **Use PATs** instead of passwords
- **Never commit** `.env` file to version control
- **Rotate tokens** regularly (90 days recommended)
- **Minimum permissions**: Use least privilege principle
- **Secure storage**: Store tokens in secure password manager
- **Avoid hardcoding**: Never hardcode tokens in source code
- **Secret management**: This project uses `keyring` for secure storage
### Repository Access
- **Fork workflow**: Use personal forks for changes
- **Branch isolation**: Each task gets separate branch
- **Branch isolation**: Each work item gets separate branch
- **Review process**: All changes go through pull requests
## Support
@@ -194,8 +298,10 @@ github_pulse/
1. **Check logs** in Processing Log tab for detailed errors
2. **Test connections** using Settings dialog test button
3. **Review configuration** for missing or incorrect values
4. **Consult documentation** for API-specific issues
### Common Resources
- [Azure DevOps PAT Documentation](https://docs.microsoft.com/en-us/azure/devops/organizations/accounts/use-personal-access-tokens-to-authenticate)
- [GitHub PAT Documentation](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token)
- [Git Configuration Guide](https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup)
application/app.py
+125
View File
@@ -0,0 +1,125 @@
"""
MicrosoftDocFlow v3
Main application entry point
This application processes Azure DevOps work items and UUF items,
creating GitHub issues or pull requests with AI assistance.
"""
import sys
import tkinter as tk
from tkinter import messagebox
# Import our modular components
try:
from app_components.config_manager import ConfigManager
from app_components.ai_manager import AIManager
from app_components.github_api import GitHubAPI
from app_components.utils import Logger, PRNumberManager, ContentBuilders
from app_components.main_gui import MainGUI
except ImportError as e:
print(f"Error importing application components: {e}")
print("Make sure all files are present in the app_components folder")
sys.exit(1)
class AzureDevOpsToGitHubApp:
"""Main application class that orchestrates all components"""
def __init__(self):
"""Initialize the application"""
self.root = tk.Tk()
self.root.title("MicrosoftDocFlow v3")
self.root.geometry("1400x1000")
# Initialize core managers
self.config_manager = ConfigManager()
self.ai_manager = AIManager()
# Load configuration
self.config = self.config_manager.load_configuration()
# Initialize dry run state
dry_run_config = self.config.get('DRY_RUN', 'false')
self.dry_run_enabled = str(dry_run_config).lower() in ('true', '1', 'yes', 'on')
# Initialize main GUI
self.main_gui = MainGUI(
root=self.root,
config_manager=self.config_manager,
ai_manager=self.ai_manager,
app=self
)
# Set up AI provider check after GUI is ready
self.root.after(100, self._check_ai_provider_setup)
def _check_ai_provider_setup(self):
"""Check and setup AI providers after GUI initialization"""
try:
ai_provider = self.config.get('AI_PROVIDER', '').strip().lower()
if not ai_provider or ai_provider in ['none', '']:
return # No AI provider selected
if ai_provider not in ['chatgpt', 'claude', 'anthropic', 'github-copilot', 'copilot', 'github_copilot']:
return # Unknown provider
# Check if modules are available and offer installation if needed
self.ai_manager.check_and_install_ai_modules(ai_provider, self.root)
except Exception as e:
print(f"Error checking AI provider setup: {e}")
def get_config(self):
"""Get current configuration"""
return self.config.copy()
def update_config(self, new_config):
"""Update configuration"""
self.config.update(new_config)
self.config_manager.config = self.config.copy()
def save_config(self, config_values):
"""Save configuration"""
success = self.config_manager.save_configuration(config_values)
if success:
self.config = self.config_manager.get_config()
# Update dry run state
dry_run_config = self.config.get('DRY_RUN', 'false')
self.dry_run_enabled = str(dry_run_config).lower() in ('true', '1', 'yes', 'on')
return success
def create_github_api(self, token=None, dry_run=None):
"""Create a GitHub API instance"""
if token is None:
token = self.config.get('GITHUB_PAT', '')
if dry_run is None:
dry_run = self.dry_run_enabled
logger = self.main_gui.logger if hasattr(self.main_gui, 'logger') else None
return GitHubAPI(token, logger, dry_run)
def run(self):
"""Start the application"""
try:
self.root.mainloop()
except KeyboardInterrupt:
print("Application interrupted by user")
except Exception as e:
messagebox.showerror("Application Error", f"An unexpected error occurred:\n{str(e)}")
print(f"Application error: {e}")
def main():
"""Main entry point"""
try:
app = AzureDevOpsToGitHubApp()
app.run()
except Exception as e:
print(f"Failed to start application: {e}")
sys.exit(1)
if __name__ == "__main__":
main()
application/app_components/__init__.py
+33
View File
@@ -0,0 +1,33 @@
"""
Azure DevOps & UUF → GitHub Processor - Application Components
Modular components for the application
"""
# Version info
__version__ = "3.0.0"
__author__ = "Azure DevOps to GitHub Processor"
# Export main classes for easier imports
from .config_manager import ConfigManager
from .ai_manager import AIManager
from .github_api import GitHubAPI
from .azure_devops_api import AzureDevOpsAPI
from .dataverse_api import DataverseAPI
from .work_item_processor import WorkItemProcessor
from .settings_dialog import SettingsDialog
from .main_gui import MainGUI
from .utils import Logger, PRNumberManager, ContentBuilders
__all__ = [
'ConfigManager',
'AIManager',
'GitHubAPI',
'AzureDevOpsAPI',
'DataverseAPI',
'WorkItemProcessor',
'SettingsDialog',
'MainGUI',
'Logger',
'PRNumberManager',
'ContentBuilders'
]
src/app_components/ai_manager.py → application/app_components/ai_manager.py
+107 -345
View File
@@ -10,8 +10,10 @@ import subprocess
import sys
import tempfile
import time
import tkinter as tk
from abc import ABC, abstractmethod
from pathlib import Path
from tkinter import messagebox
from typing import List, Tuple, Optional
@@ -742,12 +744,6 @@ Current file content:
class ChatGPTProvider(AIProvider):
"""ChatGPT/GPT-4 provider using OpenAI API"""
def __init__(self, api_key: str, logger: Logger):
"""Initialize ChatGPT provider with OpenAI client"""
super().__init__(api_key, logger)
import openai
self.client = openai.OpenAI(api_key=api_key)
def make_change(self, file_content: str, old_text: str, new_text: str, file_path: str, custom_instructions: str = None) -> Optional[str]:
"""Make smart, targeted changes based on reference text and suggestions
@@ -780,8 +776,8 @@ class ChatGPTProvider(AIProvider):
"""Generate updated document content using ChatGPT"""
try:
# Use the client initialized in __init__
client = self.client
import openai
client = openai.OpenAI(api_key=self.api_key)
# Build custom instructions text
if custom_instructions and custom_instructions.strip():
@@ -1483,9 +1479,6 @@ Current file content:
class GitHubCopilotProvider(AIProvider):
"""GitHub Copilot provider using GitHub Models API"""
# GitHub Models API endpoint
GITHUB_MODELS_API_URL = "https://models.inference.ai.azure.com/chat/completions"
def make_change(self, file_content: str, old_text: str, new_text: str, file_path: str, custom_instructions: str = None) -> Optional[str]:
"""Use diff-based approach for surgical edits"""
@@ -1512,7 +1505,7 @@ class GitHubCopilotProvider(AIProvider):
try:
import requests
url = self.GITHUB_MODELS_API_URL
url = "https://models.inference.ai.azure.com/chat/completions"
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json",
@@ -1876,7 +1869,7 @@ Return the complete updated file content now (NO explanatory text):"""
try:
import requests
url = self.GITHUB_MODELS_API_URL
url = "https://models.inference.ai.azure.com/chat/completions"
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json",
@@ -1948,7 +1941,7 @@ Generate the new content now:"""
try:
import requests
url = self.GITHUB_MODELS_API_URL
url = "https://models.inference.ai.azure.com/chat/completions"
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json",
@@ -2025,7 +2018,7 @@ Find the exact text to correct:"""
try:
import requests
url = self.GITHUB_MODELS_API_URL
url = "https://models.inference.ai.azure.com/chat/completions"
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json",
@@ -2716,7 +2709,7 @@ class LocalGitManager:
self.logger.log(f"❌ Error saving diff to file: {str(e)}")
def create_ai_provider(provider_name: str, api_key: str, logger: Logger, ollama_url: str = None, ollama_model: str = None) -> Optional[AIProvider]:
def create_ai_provider(provider_name: str, api_key: str, logger: Logger) -> Optional[AIProvider]:
"""Factory function to create AI provider instances"""
if provider_name.lower() == 'claude':
return ClaudeProvider(api_key, logger)
@@ -2724,9 +2717,6 @@ def create_ai_provider(provider_name: str, api_key: str, logger: Logger, ollama_
return ChatGPTProvider(api_key, logger)
elif provider_name.lower() in ['github-copilot', 'copilot', 'github_copilot']:
return GitHubCopilotProvider(api_key, logger)
elif provider_name.lower() == 'ollama':
# For Ollama, api_key is optional (can be empty string)
return OllamaProvider(api_key or "", logger, ollama_url, ollama_model)
else:
logger.log(f"⚠️ Unknown AI provider: {provider_name}")
return None
@@ -2766,6 +2756,10 @@ def get_detailed_python_environment_info() -> dict:
def install_ai_packages_enhanced(packages: List[str], parent_window=None) -> bool:
"""Enhanced AI provider package installation with better error handling
Args:
packages: List of package names to install
parent_window: Parent tkinter window for dialog (optional)
Returns:
bool: True if installation successful or user declined, False if failed
"""
@@ -2802,10 +2796,101 @@ def install_ai_packages_enhanced(packages: List[str], parent_window=None) -> boo
f"Would you like to install them now?\n\n"
f"This will run: pip install {' '.join(packages)}")
# Show confirmation dialog
try:
import tkinter as tk
from tkinter import messagebox
# If we have a parent window, use it; otherwise create a temporary root
if parent_window:
result = messagebox.askyesno("Install AI Packages", message, parent=parent_window)
else:
# Create temporary root window for the dialog
temp_root = tk.Tk()
temp_root.withdraw() # Hide the temporary window
result = messagebox.askyesno("Install AI Packages", message)
temp_root.destroy()
if not result:
print("User declined to install AI packages")
return True # User declined, but this isn't a failure
except Exception as e:
print(f"Could not show dialog, proceeding with installation: {e}")
# If dialog fails, ask in console
response = input(f"Install AI packages ({package_list})? [y/N]: ").lower()
if response not in ['y', 'yes']:
return True
# Install packages
try:
if in_venv:
print(f"Installing packages to virtual environment: {package_list}")
else:
print(f"Installing packages system-wide: {package_list}")
for package in packages:
print(f"Installing {package}...")
# Build pip command
pip_cmd = [sys.executable, '-m', 'pip', 'install', package]
# First attempt: Direct installation
result = subprocess.run(pip_cmd, capture_output=True, text=True, timeout=300)
# If direct install fails and we're not in venv, try with --user flag
if result.returncode != 0 and not in_venv:
print(f" Direct installation failed, trying with --user flag...")
pip_cmd_user = [sys.executable, '-m', 'pip', 'install', '--user', package]
result = subprocess.run(pip_cmd_user, capture_output=True, text=True, timeout=300)
if result.returncode == 0:
print(f"✅ Successfully installed {package} (user-local)")
continue
if result.returncode != 0:
print(f"❌ Failed to install {package}:")
print(f"Error: {result.stderr}")
# Show more helpful error message
if "permission" in result.stderr.lower() or "access" in result.stderr.lower():
print(" This appears to be a permissions issue.")
if not in_venv:
print(" Consider:")
print(" 1. Running as administrator")
print(" 2. Using a virtual environment")
print(" 3. Installing with --user flag")
return False
else:
install_type = "to virtual environment" if in_venv else "system-wide"
print(f"✅ Successfully installed {package} ({install_type})")
success_msg = "✅ AI packages installed successfully!"
if in_venv:
success_msg += f" (installed to virtual environment)"
else:
success_msg += f" (installed system-wide)"
print(success_msg)
print("Please restart the application to use the new AI features.")
return True
except subprocess.TimeoutExpired:
print("❌ Installation timed out")
return False
except Exception as e:
print(f"❌ Error installing packages: {e}")
return False
def validate_ai_provider_setup(config: dict, parent_window=None) -> bool:
"""Validate AI provider setup and offer to install missing modules
Args:
config: Configuration dictionary
parent_window: Parent tkinter window for dialogs
Returns:
bool: True if setup is valid or user handled the issue
"""
@@ -2842,198 +2927,6 @@ def validate_ai_provider_setup(config: dict, parent_window=None) -> bool:
return False
class OllamaProvider(AIProvider):
"""Ollama AI provider for self-hosted models"""
def __init__(self, api_key: str, logger: Logger, ollama_url: str = None, model: str = None):
super().__init__(api_key, logger)
self.ollama_url = ollama_url or "http://localhost:11434"
self.model = model or "llama2"
# Normalize URL
if not self.ollama_url.startswith('http'):
self.ollama_url = f"http://{self.ollama_url}"
def make_change(self, file_content: str, old_text: str, new_text: str, file_path: str, custom_instructions: str = None) -> Optional[str]:
"""Make targeted changes using Ollama"""
# Step 1: Try direct string replacement first
if old_text and old_text.strip() in file_content:
self.logger.log("✅ Making direct string replacement (reference text found exactly)")
updated_content = file_content.replace(old_text.strip(), new_text.strip())
if updated_content != file_content:
original_lines = file_content.split('\n')
updated_lines = updated_content.split('\n')
import difflib
diff = list(difflib.unified_diff(original_lines, updated_lines, lineterm=''))
changed_lines = len([line for line in diff if line.startswith('+') or line.startswith('-')])
self.logger.log(f"✅ Direct replacement successful ({changed_lines} lines changed)")
return updated_content
# Step 2: Use Ollama to generate full document with targeted changes
self.logger.log(f"📝 Using Ollama ({self.model}) to modify the document...")
return self._generate_updated_document(file_content, old_text, new_text, file_path, custom_instructions)
def _generate_updated_document(self, file_content: str, old_text: str, new_text: str, file_path: str, custom_instructions: str = None) -> Optional[str]:
"""Generate updated document content using Ollama"""
try:
import requests
# Build custom instructions text
if custom_instructions and custom_instructions.strip():
custom_instructions_text = f"""
**Additional Custom Instructions:**
{custom_instructions.strip()}
"""
else:
custom_instructions_text = ""
# Handle case where new_text is empty or just guidance
if new_text and new_text.strip() and not new_text.strip().lower().startswith('<blank'):
# We have specific replacement text
guidance_text = f"""
**Reference text to find:**
```
{old_text}
```
**Replace with this specific content:**
```
{new_text}
```
Please find the reference text and replace it with the suggested content."""
else:
# new_text is empty or just guidance - use old_text as instructions
guidance_text = f"""
**Task Instructions:**
{old_text}
**Note:** No specific replacement text provided. Use the task instructions above to determine what changes to make to improve the document. Add appropriate content based on the instructions."""
prompt = f"""**Instructions:**
Task: Update the documentation file with the changes requested.
Steps to complete:
1. Review the current file content below
2. Follow the guidance provided to determine what changes to make
3. Make appropriate improvements while maintaining existing formatting
4. Return the complete updated file content
> [!IMPORTANT]
> OUTPUT REQUIREMENTS:
> - Return ONLY the complete file content - no explanatory text, dialog, or commentary
> - Do NOT add any text before or after the file content
> - Do NOT wrap output in markdown code blocks (```), just return the raw content
> - Return the ENTIRE document - no truncation, no placeholders like [Rest of the document here...]
> - Every single line of the original document must be present in your response
> - Preserve all markdown formatting, links, and code blocks exactly
> - Only make changes that fulfill the specified request
{custom_instructions_text}
**Current File Content:**
```
{file_content}
```
{guidance_text}
Return the complete updated file content now (NO explanatory text):"""
# Prepare request headers
headers = {
"Content-Type": "application/json"
}
if self.api_key:
headers["Authorization"] = f"Bearer {self.api_key}"
# Prepare request payload
payload = {
"model": self.model,
"prompt": prompt,
"stream": False,
"options": {
"temperature": 0.3, # Lower temperature for more consistent output
"num_predict": -1, # Generate as many tokens as needed
}
}
# Make request to Ollama
self.logger.log(f"🔄 Sending request to Ollama at {self.ollama_url}...")
response = requests.post(
f"{self.ollama_url}/api/generate",
json=payload,
headers=headers,
timeout=300 # 5 minute timeout for large documents
)
response.raise_for_status()
result = response.json()
updated_content = result.get("response", "").strip()
if not updated_content:
self.logger.log("❌ Ollama returned empty response")
return None
# Clean up response
updated_content = self._clean_ai_response(updated_content)
# Validate that we got the full document back
original_line_count = len(file_content.split('\n'))
updated_line_count = len(updated_content.split('\n'))
if updated_line_count < original_line_count * 0.5: # Less than 50% of original lines
self.logger.log(f"⚠️ Warning: Updated document seems truncated ({updated_line_count} vs {original_line_count} lines)")
self.logger.log("❌ AI may have truncated the document - using fallback")
return None
self.logger.log(f"✅ Successfully generated updated document ({updated_line_count} lines)")
return updated_content
except requests.exceptions.ConnectionError:
self.logger.log(f"❌ Could not connect to Ollama server at {self.ollama_url}")
self.logger.log(" Make sure Ollama is running and the URL is correct")
return None
except requests.exceptions.Timeout:
self.logger.log("❌ Request to Ollama server timed out")
return None
except requests.exceptions.HTTPError as e:
if e.response.status_code == 401:
self.logger.log("❌ Authentication failed - check your Ollama API key")
elif e.response.status_code == 404:
self.logger.log(f"❌ Model '{self.model}' not found on Ollama server")
self.logger.log(f" Use 'ollama pull {self.model}' to download it")
else:
self.logger.log(f"❌ HTTP error from Ollama: {e}")
return None
except Exception as e:
self.logger.log(f"❌ Error calling Ollama: {str(e)}")
import traceback
traceback.print_exc()
return None
def _clean_ai_response(self, response: str) -> str:
"""Clean up AI response by removing markdown code blocks and explanatory text"""
# Remove markdown code blocks if present
if response.startswith('```'):
lines = response.split('\n')
# Remove first line if it's a code fence
if lines[0].startswith('```'):
lines = lines[1:]
# Remove last line if it's a code fence
if lines and lines[-1].strip() == '```':
lines = lines[:-1]
response = '\n'.join(lines)
return response.strip()
# AI Providers availability flag - now always True since they're included
AI_PROVIDERS_AVAILABLE = True
@@ -3061,7 +2954,7 @@ class AIManager:
"""Check if AI provider modules are available and return missing packages
Args:
provider_name: 'chatgpt', 'claude', 'anthropic', 'github-copilot', or 'ollama'
provider_name: 'chatgpt', 'claude', 'anthropic', or 'github-copilot'
Returns:
tuple: (all_available, missing_packages)
@@ -3078,8 +2971,6 @@ class AIManager:
required_packages = required_common + ['anthropic']
elif provider_name.lower() in ['github-copilot', 'copilot', 'github_copilot']:
required_packages = required_common + ['requests']
elif provider_name.lower() == 'ollama':
required_packages = required_common + ['requests']
else:
return True, [] # Unknown provider, assume no check needed
@@ -3091,8 +2982,6 @@ class AIManager:
import openai
elif package == 'anthropic':
import anthropic
elif package == 'requests':
import requests
except ImportError:
missing_packages.append(package)
@@ -3184,26 +3073,6 @@ class AIManager:
return self.install_ai_packages(missing, parent_window)
async def check_and_install_ai_modules_async(self, provider_name: str, page=None) -> bool:
"""Async wrapper for check_and_install_ai_modules for Flet integration
Args:
provider_name: AI provider name
page: Flet page instance for showing dialogs
Returns:
bool: True if modules are available or successfully installed
"""
import asyncio
# Run the sync method in a thread pool
result = await asyncio.to_thread(
self.check_and_install_ai_modules,
provider_name,
page
)
return result
def show_ai_modules_info(self, provider_name: str, parent_window=None) -> None:
"""Show detailed AI modules information"""
try:
@@ -3290,14 +3159,14 @@ class AIManager:
if self.logger:
self.logger.log(f"Error in AI modules check: {str(e)}")
def create_ai_provider(self, provider_name: str, api_key: str, ollama_url: str = None, ollama_model: str = None):
def create_ai_provider(self, provider_name: str, api_key: str):
"""Create an AI provider instance"""
if not AI_PROVIDERS_AVAILABLE:
return None
try:
ai_logger = Logger(self.log)
return create_ai_provider(provider_name, api_key, ai_logger, ollama_url, ollama_model)
return create_ai_provider(provider_name, api_key, ai_logger)
except Exception as e:
self.log(f"Error creating AI provider: {e}")
return None
@@ -3321,110 +3190,3 @@ class AIManager:
def clear_diff_content(self):
"""Clear the stored diff content"""
self.last_diff_content = ""
def generate_response(self, prompt: str, provider_name: str, config: dict) -> str:
"""Generate a text response from an AI provider
Args:
prompt: The prompt/question to send to the AI
provider_name: Name of the AI provider ('chatgpt', 'claude', 'ollama', etc.)
config: Configuration dictionary containing API keys and settings
Returns:
str: The AI-generated response
"""
try:
provider_name = provider_name.lower()
# OpenAI/ChatGPT
if provider_name in ['chatgpt', 'openai', 'gpt']:
api_key = config.get('OPENAI_API_KEY', '')
if not api_key:
return "Error: OpenAI API key not configured"
try:
import openai
client = openai.OpenAI(api_key=api_key)
response = client.chat.completions.create(
model=config.get('OPENAI_MODEL', 'gpt-4'),
messages=[
{"role": "system", "content": "You are a helpful assistant that analyzes GitHub pull requests and issues."},
{"role": "user", "content": prompt}
],
max_tokens=2000,
temperature=0.7
)
return response.choices[0].message.content.strip()
except Exception as e:
self.log(f"Error calling OpenAI API: {e}")
return f"Error calling OpenAI API: {str(e)}"
# Anthropic/Claude
elif provider_name in ['claude', 'anthropic']:
# Try both CLAUDE_API_KEY and ANTHROPIC_API_KEY for compatibility
api_key = config.get('CLAUDE_API_KEY', '')
if not api_key:
api_key = config.get('ANTHROPIC_API_KEY', '')
if not api_key:
return "Error: Claude API key not configured (tried both CLAUDE_API_KEY and ANTHROPIC_API_KEY)"
try:
import anthropic
client = anthropic.Anthropic(api_key=api_key)
response = client.messages.create(
model=config.get('ANTHROPIC_MODEL', 'claude-sonnet-4-5'),
max_tokens=2000,
messages=[
{"role": "user", "content": prompt}
]
)
return response.content[0].text.strip()
except Exception as e:
self.log(f"Error calling Anthropic API: {e}")
return f"Error calling Anthropic API: {str(e)}"
# Ollama
elif provider_name == 'ollama':
ollama_url = config.get('OLLAMA_URL', 'http://localhost:11434')
ollama_model = config.get('OLLAMA_MODEL', 'llama2')
try:
import requests
# Normalize URL
if not ollama_url.startswith('http'):
ollama_url = f"http://{ollama_url}"
# Remove trailing slash
ollama_url = ollama_url.rstrip('/')
api_url = f"{ollama_url}/api/generate"
payload = {
"model": ollama_model,
"prompt": prompt,
"stream": False
}
response = requests.post(api_url, json=payload, timeout=120)
response.raise_for_status()
result = response.json()
return result.get('response', '').strip()
except Exception as e:
self.log(f"Error calling Ollama API: {e}")
return f"Error calling Ollama API: {str(e)}"
else:
return f"Error: Unknown AI provider '{provider_name}'"
except Exception as e:
self.log(f"Error in generate_response: {e}")
return f"Error generating response: {str(e)}"
application/app_components/azure_devops_api.py
+213
View File
@@ -0,0 +1,213 @@
"""
Azure DevOps API Manager
Handles Azure DevOps REST API operations for work items
"""
import base64
import json
import re
import requests
from typing import List, Dict, Any, Tuple
from urllib.parse import urlparse, parse_qs
# User agent for Azure DevOps API requests
USER_AGENT = "azure-devops-github-processor/2.0"
class AzureDevOpsAPI:
"""Azure DevOps REST API client"""
def __init__(self, organization: str, pat_token: str, logger=None):
self.organization = organization
self.pat_token = pat_token
self.logger = logger
self.base_url = f"https://dev.azure.com/{organization}"
self.api_version = "7.0"
def log(self, message: str) -> None:
"""Log a message"""
if self.logger:
self.logger.log(message)
else:
print(message)
def _headers(self):
"""Get headers for Azure DevOps API requests"""
return {
"Authorization": f"Basic {base64.b64encode(f':{self.pat_token}'.encode()).decode()}",
"Content-Type": "application/json-patch+json",
"User-Agent": USER_AGENT
}
def parse_query_url(self, url: str) -> Tuple[str, str, str]:
"""Parse Azure DevOps query URL to extract org, project, and query ID
Supports both URL formats:
1. https://dev.azure.com/organization/project/_queries/query/12345/
2. https://organization.visualstudio.com/project/_queries/query/12345/
"""
parsed_url = urlparse(url)
# Check for dev.azure.com format
if 'dev.azure.com' in parsed_url.netloc:
path_parts = parsed_url.path.strip('/').split('/')
if len(path_parts) < 5:
raise ValueError("Invalid query URL format for dev.azure.com")
organization = path_parts[0]
project = path_parts[1]
# Check for visualstudio.com format
elif 'visualstudio.com' in parsed_url.netloc:
# Extract organization from subdomain (e.g., msft-skilling.visualstudio.com)
hostname_parts = parsed_url.netloc.split('.')
if len(hostname_parts) < 3 or hostname_parts[1] != 'visualstudio':
raise ValueError("Invalid visualstudio.com URL format")
organization = hostname_parts[0]
path_parts = parsed_url.path.strip('/').split('/')
if len(path_parts) < 4:
raise ValueError("Invalid query URL format for visualstudio.com")
project = path_parts[0]
else:
raise ValueError("URL must be from dev.azure.com or visualstudio.com")
# Find query ID in the URL (same logic for both formats)
query_id = None
if '_queries/query/' in url:
# Extract query ID from path
for i, part in enumerate(path_parts):
if part == 'query' and i > 0 and path_parts[i-1] == '_queries':
if i + 1 < len(path_parts):
query_id = path_parts[i + 1]
break
elif 'queryId=' in url:
match = re.search(r'queryId=([^&]+)', url)
if match:
query_id = match.group(1)
if not query_id:
raise ValueError("Could not extract query ID from URL")
return organization, project, query_id
def execute_query(self, org: str, project: str, query_id: str, token: str) -> List[Dict[str, Any]]:
"""Execute Azure DevOps query and return work items"""
# Build API URL for query execution
api_url = f"https://dev.azure.com/{org}/{project}/_apis/wit/wiql/{query_id}?api-version=6.0"
# Prepare headers
auth_string = base64.b64encode(f":{token}".encode()).decode()
headers = {
'Authorization': f'Basic {auth_string}',
'Content-Type': 'application/json',
'User-Agent': USER_AGENT
}
# Execute query
self.log(f"Executing query at: {api_url}")
response = requests.get(api_url, headers=headers, timeout=30)
if response.status_code != 200:
raise RuntimeError(f"Query execution failed: {response.status_code} - {response.text}")
query_result = response.json()
work_item_refs = query_result.get('workItems', [])
if not work_item_refs:
self.log("No work items found in query result")
return []
# Get detailed work item data
work_item_ids = [str(item['id']) for item in work_item_refs]
ids_param = ','.join(work_item_ids)
details_url = f"https://dev.azure.com/{org}/{project}/_apis/wit/workitems?ids={ids_param}&api-version=6.0"
self.log(f"Fetching details for {len(work_item_ids)} work items")
details_response = requests.get(details_url, headers=headers, timeout=30)
if details_response.status_code != 200:
raise RuntimeError(f"Work item details fetch failed: {details_response.status_code}")
return details_response.json().get('value', [])
def _get_work_items_details(self, organization: str, work_item_ids: List[str], pat_token: str) -> List[Dict[str, Any]]:
"""Get detailed information for work items"""
try:
# Build batch request URL
ids_param = ','.join(work_item_ids)
details_url = f"https://dev.azure.com/{organization}/_apis/wit/workitems"
headers = {
"Authorization": f"Basic {self._encode_pat(pat_token)}",
"Content-Type": "application/json",
"Accept": "application/json",
"User-Agent": USER_AGENT
}
params = {
"ids": ids_param,
"api-version": self.api_version,
"$expand": "fields"
}
self.log(f"Fetching details for work items: {ids_param}")
response = requests.get(details_url, headers=headers, params=params, timeout=30)
response.raise_for_status()
result = response.json()
work_items = result.get('value', [])
self.log(f"Retrieved details for {len(work_items)} work item(s)")
return work_items
except requests.RequestException as e:
raise Exception(f"Network error fetching work item details: {str(e)}")
except Exception as e:
raise Exception(f"Error fetching work item details: {str(e)}")
def add_github_link_to_work_item(self, work_item_id: str, github_url: str, link_title: str = "GitHub Issue"):
"""Add a GitHub issue/PR link to an Azure DevOps work item"""
self.log(f"Adding GitHub link to work item #{work_item_id}: {github_url}")
url = f"{self.base_url}/_apis/wit/workitems/{work_item_id}?api-version=7.0"
patch_document = [
{
"op": "add",
"path": "/relations/-",
"value": {
"rel": "Hyperlink",
"url": github_url,
"attributes": {
"comment": link_title
}
}
}
]
try:
response = requests.patch(url, headers=self._headers(), json=patch_document, timeout=30)
if response.status_code == 200:
self.log(f"✅ Successfully linked GitHub resource to work item #{work_item_id}")
return True
else:
self.log(f"❌ Failed to link GitHub resource: {response.status_code} - {response.text}")
return False
except Exception as e:
self.log(f"❌ Exception linking GitHub resource: {str(e)}")
return False
def _encode_pat(self, pat_token: str) -> str:
"""Encode PAT token for Basic authentication"""
import base64
# For Azure DevOps, username can be empty, just use :token
credentials = f":{pat_token}"
encoded = base64.b64encode(credentials.encode()).decode()
return encoded
src/app_components/cache_manager.py → application/app_components/cache_manager.py
+11 -11
View File
@@ -1,5 +1,5 @@
"""
Cache Manager for GitHub PRs and Issues
Cache Manager for Work Items and UUF Items
Stores fetched items in temporary cache to avoid reloading on every app start
"""
@@ -13,7 +13,7 @@ from hashlib import md5
class CacheManager:
"""Manages caching of GitHub PRs and Issues"""
"""Manages caching of work items and UUF items"""
def __init__(self, cache_duration_hours: int = 24):
"""
@@ -23,7 +23,7 @@ class CacheManager:
cache_duration_hours: How long cache is valid (default 24 hours)
"""
self.cache_duration_seconds = cache_duration_hours * 3600
self.cache_dir = Path(tempfile.gettempdir()) / "github_pulse_cache"
self.cache_dir = Path(tempfile.gettempdir()) / "devops_to_github_cache"
self.cache_dir.mkdir(exist_ok=True)
def _get_cache_key(self, source_type: str, identifier: str) -> str:
@@ -50,14 +50,14 @@ class CacheManager:
def load_from_cache(self, source_type: str, identifier: str) -> Optional[List[Dict[str, Any]]]:
"""
Load GitHub items from cache
Load work items from cache
Args:
source_type: 'github_prs', 'github_issues', 'target_prs', 'fork_prs', etc.
identifier: repository identifier or config hash
source_type: 'azure_devops' or 'uuf'
identifier: query URL hash or config hash
Returns:
List of items if cache is valid, None otherwise
List of work items if cache is valid, None otherwise
"""
if not self.is_cache_valid(source_type, identifier):
return None
@@ -81,12 +81,12 @@ class CacheManager:
def save_to_cache(self, source_type: str, identifier: str, items: List[Dict[str, Any]]) -> bool:
"""
Save GitHub items to cache
Save work items to cache
Args:
source_type: 'github_prs', 'github_issues', 'target_prs', 'fork_prs', etc.
identifier: repository identifier or config hash
items: List of items to cache (PRs or Issues)
source_type: 'azure_devops' or 'uuf'
identifier: query URL hash or config hash
items: List of work items to cache
Returns:
True if successful, False otherwise
application/app_components/config_manager.py
+304
View File
@@ -0,0 +1,304 @@
"""
Configuration Manager
Handles loading/saving configuration from .env files and launch.json
"""
import os
import json
from typing import Dict, Any, Optional
class ConfigManager:
"""Manages application configuration from multiple sources"""
def __init__(self):
self.config = self.load_configuration()
def _get_default_config(self) -> Dict[str, Any]:
"""Get default configuration values"""
return {
'AZURE_DEVOPS_QUERY': None,
'AZURE_DEVOPS_PAT': None,
'GITHUB_PAT': None,
'GITHUB_REPO': None,
'FORKED_REPO': None, # User's fork repository
'AI_PROVIDER': None,
'CLAUDE_API_KEY': None,
'OPENAI_API_KEY': None,
'GITHUB_TOKEN': None, # For GitHub Copilot AI Provider
'LOCAL_REPO_PATH': None,
'DRY_RUN': 'false',
'DATAVERSE_ENVIRONMENT_URL': None,
'DATAVERSE_TABLE_NAME': None,
'AZURE_AD_CLIENT_ID': None,
'AZURE_AD_CLIENT_SECRET': None,
'AZURE_AD_TENANT_ID': None,
'CUSTOM_INSTRUCTIONS': None # Custom AI instructions
}
def load_configuration(self) -> Dict[str, Any]:
"""Load configuration from launch.json first, then .env as fallback"""
config = self._get_default_config()
launch_json_keys = set()
# First, try to load from launch.json
launch_json_path = os.path.join('.vscode', 'launch.json')
if os.path.exists(launch_json_path):
try:
with open(launch_json_path, 'r', encoding='utf-8') as f:
launch_data = json.load(f)
# Look for configurations with env variables
for configuration in launch_data.get('configurations', []):
env_vars = configuration.get('env', {})
for key in config.keys():
if key in env_vars and env_vars[key] and not env_vars[key].startswith('<'):
config[key] = env_vars[key]
launch_json_keys.add(key)
if launch_json_keys:
print(f"Loaded configuration from launch.json: {launch_json_path}")
except (json.JSONDecodeError, FileNotFoundError, KeyError) as e:
print(f"Could not load launch.json: {e}")
# Check if .env file exists, create default if not
if not os.path.exists('.env'):
print("No .env file found. Creating default .env file...")
self._create_default_env_file(config)
# Load values from .env file (but don't override launch.json values)
if os.path.exists('.env'):
try:
env_loaded = False
with open('.env', 'r', encoding='utf-8') as f:
for line in f:
line = line.strip()
if line and not line.startswith('#') and '=' in line:
key, value = line.split('=', 1)
key = key.strip()
value = value.strip().strip('"').strip("'")
# Load from .env if key exists in config and wasn't loaded from launch.json
if key in config and key not in launch_json_keys:
config[key] = value if value else ''
env_loaded = True
if env_loaded:
print("Loaded configuration from .env file")
elif not launch_json_keys:
print("Configuration files found but no valid values loaded")
except FileNotFoundError:
print("No .env file found")
except Exception as e:
print(f"Could not load .env file: {e}")
# Ensure all config values are strings, not None
for key in config:
if config[key] is None:
config[key] = ''
# Special handling for AI_PROVIDER - default to 'none' if empty
if not config.get('AI_PROVIDER'):
config['AI_PROVIDER'] = 'none'
# Debug output
loaded_from = []
for key, value in config.items():
if value:
loaded_from.append(f"{key}: {'loaded' if value else 'not found'}")
if loaded_from:
print(f"Configuration status: {', '.join(loaded_from)}")
else:
print("No configuration values loaded - all fields will be blank")
self.config = config
return config
def _create_default_env_file(self, config: Dict[str, Any]) -> None:
"""Create a default .env file with empty values"""
try:
env_template = """# Azure DevOps to GitHub Tool Configuration
# Generated automatically - fill in your values
# IMPORTANT: Do NOT commit this file to source control. Add it to .gitignore.
# Azure DevOps Configuration
AZURE_DEVOPS_QUERY=
AZURE_DEVOPS_PAT=
# GitHub Configuration
GITHUB_PAT=
GITHUB_REPO=
FORKED_REPO=
# Application Settings
DRY_RUN=false
# AI Provider Configuration (for local PR creation with AI assistance)
AI_PROVIDER=
CLAUDE_API_KEY=
OPENAI_API_KEY=
GITHUB_TOKEN=
LOCAL_REPO_PATH=
# PowerApp/Dataverse Configuration (for UUF items - optional)
DATAVERSE_ENVIRONMENT_URL=
DATAVERSE_TABLE_NAME=
AZURE_AD_CLIENT_ID=
AZURE_AD_CLIENT_SECRET=
AZURE_AD_TENANT_ID=
# Custom AI Instructions (optional)
CUSTOM_INSTRUCTIONS=
"""
with open('.env', 'w', encoding='utf-8') as f:
f.write(env_template)
print("Created default .env file with blank values")
except Exception as e:
print(f"Error creating default .env file: {e}")
def save_configuration(self, config_values: Dict[str, Any]) -> bool:
"""Save configuration to .env file"""
try:
print(f"DEBUG: Saving config values: {config_values}")
print(f"DEBUG: AI_PROVIDER value being saved: '{config_values.get('AI_PROVIDER', 'NOT_FOUND')}'")
# Update internal config
for key, value in config_values.items():
if key in self.config:
old_value = self.config[key]
new_value = value or ''
self.config[key] = new_value
if key == 'AI_PROVIDER':
print(f"DEBUG: Updated AI_PROVIDER from '{old_value}' to '{new_value}'")
# Build .env file content
env_content = []
env_content.append("# Azure DevOps to GitHub Tool Configuration")
env_content.append("# Generated by Settings Dialog")
env_content.append("# IMPORTANT: Do NOT commit this file to source control. Add it to .gitignore.")
env_content.append("")
env_content.append("# Azure DevOps Configuration")
env_content.append(f"AZURE_DEVOPS_QUERY={self.config.get('AZURE_DEVOPS_QUERY', '')}")
env_content.append(f"AZURE_DEVOPS_PAT={self.config.get('AZURE_DEVOPS_PAT', '')}")
env_content.append("")
env_content.append("# GitHub Configuration")
env_content.append(f"GITHUB_PAT={self.config.get('GITHUB_PAT', '')}")
env_content.append(f"GITHUB_REPO={self.config.get('GITHUB_REPO', '')}")
env_content.append(f"FORKED_REPO={self.config.get('FORKED_REPO', '')}")
env_content.append("")
env_content.append("# Application Settings")
dry_run_value = str(self.config.get('DRY_RUN', 'false')).lower()
env_content.append(f"DRY_RUN={dry_run_value}")
env_content.append("")
env_content.append("# AI Provider Configuration (for local PR creation with AI assistance)")
ai_provider_value = self.config.get('AI_PROVIDER', '')
print(f"DEBUG: Writing AI_PROVIDER to file: '{ai_provider_value}'")
env_content.append(f"AI_PROVIDER={ai_provider_value}")
env_content.append(f"CLAUDE_API_KEY={self.config.get('CLAUDE_API_KEY', '')}")
env_content.append(f"OPENAI_API_KEY={self.config.get('OPENAI_API_KEY', '')}")
env_content.append(f"GITHUB_TOKEN={self.config.get('GITHUB_TOKEN', '')}")
env_content.append(f"LOCAL_REPO_PATH={self.config.get('LOCAL_REPO_PATH', '')}")
env_content.append("")
env_content.append("# PowerApp/Dataverse Configuration (for UUF items - optional)")
env_content.append(f"DATAVERSE_ENVIRONMENT_URL={self.config.get('DATAVERSE_ENVIRONMENT_URL', '')}")
env_content.append(f"DATAVERSE_TABLE_NAME={self.config.get('DATAVERSE_TABLE_NAME', '')}")
env_content.append(f"AZURE_AD_CLIENT_ID={self.config.get('AZURE_AD_CLIENT_ID', '')}")
env_content.append(f"AZURE_AD_CLIENT_SECRET={self.config.get('AZURE_AD_CLIENT_SECRET', '')}")
env_content.append(f"AZURE_AD_TENANT_ID={self.config.get('AZURE_AD_TENANT_ID', '')}")
env_content.append("")
env_content.append("# Custom AI Instructions (optional)")
env_content.append(f"CUSTOM_INSTRUCTIONS={self.config.get('CUSTOM_INSTRUCTIONS', '')}")
env_content.append("")
# Write to file
with open('.env', 'w', encoding='utf-8') as f:
f.write('\n'.join(env_content))
print("Configuration saved to .env file")
return True
except Exception as e:
print(f"Error saving configuration: {e}")
return False
def get_config(self) -> Dict[str, Any]:
"""Get current configuration with automatic GITHUB_TOKEN defaulting"""
config = self.config.copy()
# Auto-default GITHUB_TOKEN to GITHUB_PAT if GITHUB_TOKEN is empty or None
github_token = config.get('GITHUB_TOKEN', '').strip() if config.get('GITHUB_TOKEN') else ''
github_pat = config.get('GITHUB_PAT', '').strip() if config.get('GITHUB_PAT') else ''
if not github_token and github_pat:
config['GITHUB_TOKEN'] = github_pat
return config
def get_value(self, key: str, default: Any = None) -> Any:
"""Get a specific configuration value"""
return self.config.get(key, default)
def get(self, key: str, default: Any = None) -> Any:
"""Get a specific configuration value (dictionary-like interface)"""
return self.config.get(key, default)
def set_value(self, key: str, value: Any) -> None:
"""Set a specific configuration value"""
if key in self.config:
self.config[key] = value
def get_pr_counter_file(self) -> str:
"""Get the path to the PR counter file"""
script_dir = os.path.dirname(os.path.abspath(__file__))
return os.path.join(script_dir, '..', '.pr_counter.json')
def load_pr_counter(self) -> Dict[str, int]:
"""Load the PR counter from file"""
counter_file = self.get_pr_counter_file()
if os.path.exists(counter_file):
try:
with open(counter_file, 'r', encoding='utf-8') as f:
return json.load(f)
except (json.JSONDecodeError, FileNotFoundError):
pass
return {}
def save_pr_counter(self, counter: Dict[str, int]) -> None:
"""Save the PR counter to file"""
counter_file = self.get_pr_counter_file()
try:
# Ensure directory exists
os.makedirs(os.path.dirname(counter_file), exist_ok=True)
with open(counter_file, 'w', encoding='utf-8') as f:
json.dump(counter, f, indent=2)
except Exception as e:
print(f"Warning: Could not save PR counter: {e}")
def get_next_pr_number(self, provider_key: str) -> int:
"""
Get the next PR number for a given provider.
Args:
provider_key: Either the AI provider name ('chatgpt', 'claude') or 'gh_copilot'
Returns:
The next PR number for this provider
"""
counter = self.load_pr_counter()
current_number = counter.get(provider_key, 0)
next_number = current_number + 1
counter[provider_key] = next_number
self.save_pr_counter(counter)
return next_number
application/app_components/dataverse_api.py
+255
View File
@@ -0,0 +1,255 @@
"""
Dataverse API Manager
Handles PowerApp/Dataverse operations for UUF items
"""
import json
import re
import requests
import urllib.parse
from typing import List, Dict, Any, Optional
from urllib.parse import urlparse
# Constants
USER_AGENT = "azure-devops-github-processor/2.0"
class DataverseAPI:
"""Dataverse/PowerApp API client for UUF items"""
def __init__(self, environment_url: str, table_name: str, logger=None, config: dict = None):
self.environment_url = environment_url.rstrip('/')
self.table_name = table_name
self.logger = logger
self.config = config or {}
self.access_token = None
self.api_version = "v9.2"
def log(self, message: str) -> None:
"""Log a message"""
if self.logger:
self.logger.log(message)
else:
print(message)
def authenticate(self, client_id: str, client_secret: str, tenant_id: str) -> bool:
"""Authenticate with Azure AD and get access token"""
try:
# Azure AD token endpoint
token_url = f"https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token"
# Prepare request data
data = {
'grant_type': 'client_credentials',
'client_id': client_id,
'client_secret': client_secret,
'scope': f"{self.environment_url}/.default"
}
headers = {
'Content-Type': 'application/x-www-form-urlencoded'
}
self.log("Authenticating with Azure AD...")
response = requests.post(token_url, data=data, headers=headers, timeout=30)
response.raise_for_status()
token_data = response.json()
self.access_token = token_data['access_token']
self.log("✅ Successfully authenticated with Azure AD")
return True
except requests.RequestException as e:
self.log(f"❌ Network error during authentication: {str(e)}")
return False
except KeyError as e:
self.log(f"❌ Invalid token response: {str(e)}")
return False
except Exception as e:
self.log(f"❌ Authentication error: {str(e)}")
return False
def _headers(self):
"""Get headers for Dataverse API requests"""
return {
"Authorization": f"Bearer {self.access_token}",
"OData-MaxVersion": "4.0",
"OData-Version": "4.0",
"Accept": "application/json",
"Content-Type": "application/json",
"User-Agent": USER_AGENT
}
def fetch_uuf_items(self, filter_query: Optional[str] = None) -> List[Dict[str, Any]]:
"""Fetch UUF items from Dataverse"""
try:
if not self.access_token:
raise RuntimeError("Not authenticated. Call authenticate() first.")
self.log(f"Fetching UUF items from table: {self.table_name}")
# Build API URL
api_url = f"{self.environment_url}/api/data/{self.api_version}/{self.table_name}"
# Add filter if provided
if filter_query:
api_url += f"?$filter={urllib.parse.quote(filter_query)}"
response = requests.get(api_url, headers=self._headers(), timeout=60)
if response.status_code != 200:
raise RuntimeError(f"Failed to fetch UUF items: {response.status_code} - {response.text}")
data = response.json()
items = data.get('value', [])
self.log(f"✅ Fetched {len(items)} UUF items from Dataverse")
return items
except Exception as e:
self.log(f"❌ Error fetching UUF items: {str(e)}")
raise
def process_uuf_item(self, uuf_item: dict) -> dict | None:
"""Process a single UUF item from Dataverse/PowerApp
UUF items may have different field names than Azure DevOps work items.
Adjust the field mapping based on your actual Dataverse table schema.
"""
try:
# Extract UUF item ID (adjust field names as needed)
uuf_id = uuf_item.get('cr4af_uufid') or uuf_item.get('cr4af_name') or uuf_item.get('cr_uufitemid') or 'unknown'
# Extract title
title = uuf_item.get('cr4af_title') or uuf_item.get('cr4af_subject') or uuf_item.get('cr_title') or 'No Title'
# Extract description/details
description = uuf_item.get('cr4af_description') or uuf_item.get('cr4af_details') or uuf_item.get('cr_description') or ''
if not description:
self.log(f"UUF item {uuf_id} has no description, skipping")
return None
# Extract document URL
doc_url = uuf_item.get('cr4af_documenturl') or uuf_item.get('cr4af_docurl') or uuf_item.get('cr_documenturl') or ''
if not doc_url:
self.log(f"UUF item {uuf_id} has no document URL, skipping")
return None
# Extract text to change and new text
text_to_change = uuf_item.get('cr4af_texttochange') or uuf_item.get('cr4af_currenttext') or uuf_item.get('cr_currenttext') or ''
new_text = uuf_item.get('cr4af_proposednewtext') or uuf_item.get('cr4af_newtext') or uuf_item.get('cr_newtext') or ''
if not text_to_change or not new_text:
self.log(f"UUF item {uuf_id} missing text fields, skipping")
return None
# Extract GitHub info from document URL
github_info = self._extract_github_info(doc_url)
# If the document does not include an original_content_git_url, skip this item
if not github_info.get('original_content_git_url'):
self.log(f"UUF item {uuf_id} skipped: original_content_git_url not found in document {doc_url}")
return None
processed_item = {
'id': uuf_id,
'title': title,
'nature_of_request': 'UUF Item - Modify existing docs',
'mydoc_url': doc_url,
'text_to_change': text_to_change,
'new_text': new_text,
'github_info': github_info,
'status': 'Ready',
'original_new_text': new_text,
'source': 'UUF' # Mark as UUF item
}
self.log(f"Successfully processed UUF item {uuf_id}")
return processed_item
except Exception as e:
self.log(f"Error processing UUF item {uuf_item.get('cr4af_uufid', 'unknown')}: {str(e)}")
return None
def _extract_github_info(self, doc_url: str) -> dict:
"""Extract GitHub repository info and ms.author from document URL
If GITHUB_REPO is configured in .env, it will be used instead of the repo
extracted from the document metadata. This allows you to create PRs in your
fork while preserving the file path and ms.author from the original document.
"""
try:
# Fetch the document
headers = {'User-Agent': USER_AGENT}
response = requests.get(doc_url, headers=headers, timeout=30)
response.raise_for_status()
html = response.text
# Extract ms.author
ms_author = self._extract_meta_tag(html, 'ms.author')
# Extract original_content_git_url
original_content_git_url = self._extract_meta_tag(html, 'original_content_git_url')
if not original_content_git_url:
# Try alternative extraction method
match = re.search(r"original_content_git_url[\"\']?\s*[:=]\s*[\"\']([^\"']+)[\"']", html, re.IGNORECASE)
if match:
original_content_git_url = match.group(1).strip()
if not original_content_git_url:
raise ValueError("original_content_git_url not found in document")
# Check if GITHUB_REPO is configured in .env
# If it is, use that instead of the repo from the document
configured_repo = self.config.get('GITHUB_REPO')
if configured_repo and '/' in configured_repo:
# Use the configured repository (e.g., "b-tsammons/fabric-docs-pr")
parts = configured_repo.split('/', 1)
owner = parts[0].strip()
repo = parts[1].strip()
self.log(f"Using configured GITHUB_REPO: {owner}/{repo} (overriding document metadata)")
else:
# Parse GitHub owner/repo from original_content_git_url (fallback to document metadata)
owner, repo = self._parse_github_url(original_content_git_url)
self.log(f"Using repository from document metadata: {owner}/{repo}")
return {
'ms_author': ms_author,
'original_content_git_url': original_content_git_url,
'owner': owner,
'repo': repo
}
except Exception as e:
self.log(f"Error extracting GitHub info from {doc_url}: {str(e)}")
return {
'ms_author': None,
'original_content_git_url': None,
'owner': None,
'repo': None,
'error': str(e)
}
def _extract_meta_tag(self, html: str, name: str) -> str | None:
"""Extract content from meta tag"""
pattern = rf'<meta\s+(?:[^>]*?\s)?(?:name|property)\s*=\s*["\'](?P<n>{re.escape(name)})["\']\s+[^>]*?\bcontent\s*=\s*["\'](?P<content>[^"\']+)["\'][^>]*?>'
match = re.search(pattern, html, re.IGNORECASE)
if match:
return match.group('content').strip()
return None
def _parse_github_url(self, url: str) -> tuple[str, str]:
"""Parse GitHub URL to extract owner and repo"""
parsed = urlparse(url)
if "github.com" not in parsed.netloc.lower():
raise ValueError(f"Not a GitHub URL: {url}")
parts = [p for p in parsed.path.split("/") if p]
if len(parts) < 2:
raise ValueError(f"Unable to parse owner/repo from: {url}")
return parts[0], parts[1]
src/app_components/github_api.py → application/app_components/github_api.py
+26 -19
View File
@@ -12,7 +12,7 @@ from urllib.parse import urlparse
# Constants
GITHUB_GRAPHQL_ENDPOINT = "https://api.github.com/graphql"
USER_AGENT = "github-automation-tool/1.0"
USER_AGENT = "azure-devops-github-processor/2.0"
class GitHubGQL:
@@ -229,7 +229,9 @@ class GitHubGQL:
if self.dry_run:
# Return sample data for dry run
return [
"username/repo_name",
"username/fabric-docs",
"username/azure-docs",
"username/powerbi-docs"
]
try:
@@ -322,8 +324,8 @@ class GitHubGQL:
if self.dry_run:
return {
"target_alternatives": ["username/target_repo_name"],
"fork_alternatives": ["username/fork_repo_name"]
"target_alternatives": ["microsoftdocs/fabric-docs-pr"],
"fork_alternatives": ["b-tsammons/azure-docs-pr"]
}
try:
@@ -550,7 +552,7 @@ class GitHubGQL:
raise
def create_pull_request(self, repository_id: str, title: str, body: str, head_ref: str, base_ref: str = "main") -> tuple[str, str, int]:
"""Create a pull request"""
"""Create a pull request with AB# linking"""
self.log(f"Creating pull request with createPullRequest mutation from {head_ref} to {base_ref}...")
mutation = """
mutation($repositoryId:ID!, $title:String!, $body:String!, $headRefName:String!, $baseRefName:String!) {
@@ -662,8 +664,8 @@ class GitHubGQL:
old_text: Text to find and replace
new_text: New text to replace with
branch_name: Branch name for this PR
work_item_id: Reference ID for tracking (optional)
item_source: Source of the item (optional)
work_item_id: Work item or UUF issue ID
item_source: Source of the item ('UUF' or 'Azure DevOps')
Returns True if successful, False otherwise.
"""
@@ -678,22 +680,25 @@ class GitHubGQL:
"User-Agent": USER_AGENT
}
# Build reference ID if provided
# Build work item reference
if work_item_id:
reference_id = f"**Reference ID:** {work_item_id}\n"
if item_source == 'UUF':
work_item_ref = f"**UUF Issue:** {work_item_id}\n"
else:
reference_id = ""
work_item_ref = f"**Azure DevOps Work Item:** AB#{work_item_id}\n"
else:
work_item_ref = ""
# Build document reference
if file_path and not file_path.startswith("File path not specified"):
if file_path and not file_path.startswith("See work item") and not file_path.startswith("File path not specified"):
doc_ref = f"**Document to modify:** `{file_path}`\n"
file_instruction = f"2. Locate the file: `{file_path}`"
elif doc_url:
doc_ref = f"**Document URL:** {doc_url}\n"
file_instruction = f"2. Locate the file from this document URL: {doc_url}"
else:
doc_ref = "**Note:** File path not specified\n"
file_instruction = "2. Review the PR description to identify the file(s) that need to be modified"
doc_ref = "**Note:** File path not specified in work item\n"
file_instruction = "2. Review the PR description and work item details to identify the file(s) that need to be modified"
# Build custom instructions section
if custom_instructions and custom_instructions.strip():
@@ -708,24 +713,25 @@ class GitHubGQL:
# Create a comment mentioning @copilot with VERY explicit instructions
comment_body = f"""@copilot
{reference_id}{doc_ref}
{work_item_ref}{doc_ref}
**Instructions:**
Task: Update the file with the changes requested above.
Task: Update the documentation file with the changes requested above.
Steps to complete:
Locate the file containing the reference shown below.
Find the reference text within the file
Replace it with the 'Proposed New Text' shown above or use the reference as guidance
Maintain the existing formatting, indentation, and structure
Maintain the existing formatting, indentation, and markdown structure
Ensure no other content in the file is modified
> [!IMPORTANT]
> Only replace the specified text - do not make additional changes.
> Preserve all formatting, links, and code blocks.
> Preserve all markdown formatting, links, and code blocks.
> If the current text cannot be found exactly, search for similar text.
> Please ensure the changes align with Microsoft documentation standards.
> Do not remove any text unless the reference or suggested guidance indicates to do so, if the text is obsolete or incorrect.
1. Make changes to `{branch_name}` branch for this pull request.
@@ -742,13 +748,14 @@ Ensure no other content in the file is modified
{new_text}
```
5. Ensure the changes align with the context provided.
5. Ensure the changes align with the context of the work item.
6. Do a freshness check to ensure the file content is up-to-date before making changes.
7. Commit the changes to the `{branch_name}` branch
> [!NOTE]
> This documentation is maintained by spelluru.
> If guidance is empty, follow the reference to make changes.
{custom_instructions_section}
@@ -841,7 +848,7 @@ Thank you!
{new_text}
```
**Automated Suggestion:** This change was requested.
**Automated Suggestion:** This change was requested in Azure DevOps work item.
Click "Commit suggestion" above to apply this change directly to the PR."""
application/app_components/main_gui.py
+2441
View File
File diff suppressed because it is too large Load Diff
application/app_components/settings_dialog.py
+850
View File
@@ -0,0 +1,850 @@
"""
Settings Dialog
GUI for configuring application settings
"""
import tkinter as tk
import threading
from tkinter import ttk, messagebox, scrolledtext
from typing import Dict, Any, Optional
import sys
import os
class SettingsDialog:
"""Settings configuration dialog"""
def __init__(self, parent, config: Dict[str, Any], config_manager=None, cache_manager=None):
self.parent = parent
self.config = config.copy()
self.config_manager = config_manager
self.cache_manager = cache_manager
self.result = None
self.entries = {}
# Create dialog
self.dialog = tk.Toplevel(parent)
self.dialog.title("⚙️ Settings")
self.dialog.geometry("900x1000")
self.dialog.resizable(True, True)
self.dialog.transient(parent)
self.dialog.grab_set()
self._create_widgets()
self._bind_events()
def _create_widgets(self):
"""Create dialog widgets"""
# Main frame with scrollbar
main_frame = ttk.Frame(self.dialog, padding="20")
main_frame.pack(fill=tk.BOTH, expand=True)
# Create notebook for tabbed settings
notebook = ttk.Notebook(main_frame)
notebook.pack(fill=tk.BOTH, expand=True, pady=(0, 20))
# Create tabs
self._create_general_tab(notebook)
self._create_ai_tab(notebook)
self._create_dataverse_tab(notebook)
# Buttons frame
buttons_frame = ttk.Frame(main_frame)
buttons_frame.pack(fill=tk.X, pady=(10, 0))
# Buttons
ttk.Button(buttons_frame, text="💾 Save Settings", command=self._save_clicked).pack(side=tk.RIGHT, padx=(5, 0))
ttk.Button(buttons_frame, text="❌ Cancel", command=self._cancel_clicked).pack(side=tk.RIGHT)
ttk.Button(buttons_frame, text="🗑️ Clear Cache", command=self._clear_cache).pack(side=tk.LEFT, padx=(5, 0))
ttk.Button(buttons_frame, text="Test Connection", command=self._test_connection).pack(side=tk.LEFT)
# Center dialog after everything is created
self._center_dialog()
def _create_general_tab(self, notebook):
"""Create general settings tab"""
general_frame = ttk.Frame(notebook)
notebook.add(general_frame, text="General")
# Scrollable frame
canvas = tk.Canvas(general_frame)
scrollbar = ttk.Scrollbar(general_frame, orient="vertical", command=canvas.yview)
scrollable_frame = ttk.Frame(canvas)
scrollable_frame.bind(
"<Configure>",
lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
)
canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
canvas.configure(yscrollcommand=scrollbar.set)
# Configure column weights for proper expansion
scrollable_frame.columnconfigure(1, weight=1)
current_row = 0
# Azure DevOps section
self._create_section_header(scrollable_frame, current_row, "🔷 Azure DevOps Configuration")
current_row += 1
self._create_label_entry(scrollable_frame, current_row, "Query URL:", 'AZURE_DEVOPS_QUERY', width=60, multiline=True)
current_row += 1
self._create_label_entry(scrollable_frame, current_row, "Personal Access Token:", 'AZURE_DEVOPS_PAT', password=True, width=60)
current_row += 1
# GitHub section
self._create_section_header(scrollable_frame, current_row, "🐙 GitHub Configuration")
current_row += 1
self._create_label_entry(scrollable_frame, current_row, "Personal Access Token:", 'GITHUB_PAT', password=True, width=60)
current_row += 1
self._create_label_entry(scrollable_frame, current_row, "Target Repository (owner/repo):", 'GITHUB_REPO', width=60)
current_row += 1
self._create_forked_repo_dropdown(scrollable_frame, current_row)
current_row += 1
# General options section
self._create_section_header(scrollable_frame, current_row, "⚙️ General Options")
current_row += 1
self._create_dry_run_checkbox(scrollable_frame, current_row)
current_row += 1
self._create_label_entry(scrollable_frame, current_row, "Local Repo Path:", 'LOCAL_REPO_PATH', width=60)
current_row += 1
# Detected repos dropdown
ttk.Label(scrollable_frame, text="Detected Repos:", font=('Arial', 10, 'bold')).grid(
row=current_row, column=0, sticky=tk.W, pady=5, padx=10)
# Frame for dropdown and refresh button
detected_frame = ttk.Frame(scrollable_frame)
detected_frame.grid(row=current_row, column=1, sticky=(tk.W, tk.E), pady=5, padx=10)
self.detected_repos_var = tk.StringVar(value='Scanning...')
self.detected_repos_dropdown = ttk.Combobox(detected_frame, textvariable=self.detected_repos_var,
state='readonly', width=45)
self.detected_repos_dropdown.pack(side=tk.LEFT, fill=tk.X, expand=True)
self.detected_repos_dropdown.bind('<<ComboboxSelected>>', self._on_repo_selected)
refresh_button = ttk.Button(detected_frame, text="🔄 Scan", command=self._scan_repos, width=8)
refresh_button.pack(side=tk.LEFT, padx=(5, 0))
current_row += 1
# Help text for local repo path
repo_help = ttk.Label(scrollable_frame,
text="💡 Repository Setup Guide:\n"
" • Local Repo Path: Where your fork repos are cloned (e.g., C:\\git\\repos)\n"
" • Detected Repos: Shows your local fork (e.g., yourname/repo)\n"
" • Target Repository: Upstream repo for PRs (e.g., microsoft/repo)\n"
" • Fork Workflow: Work on your fork locally, create PRs to upstream",
font=('Arial', 9), foreground='gray', justify=tk.LEFT, wraplength=850)
repo_help.grid(row=current_row, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(10, 20), padx=10)
current_row += 1
# Help text
help_text = ttk.Label(scrollable_frame, text="💡 Getting Started:\n"
"1. Set your Azure DevOps Query URL (copy from browser)\n"
"2. Create Personal Access Tokens for both services\n"
"3. Configure GitHub repositories:\n"
" • Target Repository: Where PRs will be created\n"
" • Forked Repository: Your fork where changes are made\n"
"4. Set Local Repo Path for automatic repository detection\n"
"5. Configure AI provider in the AI tab (optional)\n"
"6. Test your connection before processing items",
font=('Arial', 9), foreground='blue', justify=tk.LEFT, wraplength=850)
help_text.grid(row=current_row, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(20, 30), padx=10)
# Scan for repos after creating the UI
self.dialog.after(100, self._scan_repos)
# Pack canvas and scrollbar
canvas.pack(side="left", fill="both", expand=True)
scrollbar.pack(side="right", fill="y")
def _create_ai_tab(self, notebook):
"""Create AI settings tab"""
ai_frame = ttk.Frame(notebook)
notebook.add(ai_frame, text="AI Providers")
# Scrollable frame
canvas = tk.Canvas(ai_frame)
scrollbar = ttk.Scrollbar(ai_frame, orient="vertical", command=canvas.yview)
scrollable_frame = ttk.Frame(canvas)
scrollable_frame.bind(
"<Configure>",
lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
)
canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
canvas.configure(yscrollcommand=scrollbar.set)
# AI Provider section
self._create_section_header(scrollable_frame, 0, "🤖 AI Provider Configuration")
# Provider dropdown
ttk.Label(scrollable_frame, text="AI Provider:", font=('Arial', 10, 'bold')).grid(
row=1, column=0, sticky=tk.W, pady=5, padx=10)
self.ai_provider_var = tk.StringVar(value=self.config.get('AI_PROVIDER', 'none'))
provider_dropdown = ttk.Combobox(scrollable_frame, textvariable=self.ai_provider_var,
values=['none', 'claude', 'chatgpt', 'github-copilot'], state='readonly', width=47)
provider_dropdown.grid(row=1, column=1, sticky=(tk.W, tk.E), pady=5, padx=10)
self.entries['AI_PROVIDER'] = self.ai_provider_var
# API Keys
self._create_label_entry(scrollable_frame, 2, "Claude API Key:", 'CLAUDE_API_KEY', password=True)
self._create_label_entry(scrollable_frame, 3, "ChatGPT API Key:", 'OPENAI_API_KEY', password=True)
self._create_label_entry(scrollable_frame, 4, "GitHub Token (for Copilot) [defaults to GitHub PAT]:", 'GITHUB_TOKEN', password=True)
# Help text
help_text = ttk.Label(scrollable_frame, text="\n💡 Tips:\n"
"• Provider: Choose 'none' to disable AI (uses Copilot workflow)\n"
"• Claude: Get key at console.anthropic.com\n"
"• ChatGPT: Get key at platform.openai.com/api-keys\n"
"• GitHub Copilot: Uses GitHub Models API (requires GitHub token)\n"
"• GitHub Token: Auto-defaults to GitHub PAT if left empty\n"
"• Cost: ~$0.01-0.05 per PR with AI, free with 'none'\n"
"• AI providers clone repos locally to make changes before pushing",
font=('Arial', 9), foreground='blue', justify=tk.LEFT, wraplength=800)
help_text.grid(row=5, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=20, padx=10)
# Pack canvas and scrollbar
canvas.pack(side="left", fill="both", expand=True)
scrollbar.pack(side="right", fill="y")
def _create_dataverse_tab(self, notebook):
"""Create Dataverse/PowerApp settings tab"""
dataverse_frame = ttk.Frame(notebook)
notebook.add(dataverse_frame, text="UUF/Dataverse")
# Scrollable frame
canvas = tk.Canvas(dataverse_frame)
scrollbar = ttk.Scrollbar(dataverse_frame, orient="vertical", command=canvas.yview)
scrollable_frame = ttk.Frame(canvas)
scrollable_frame.bind(
"<Configure>",
lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
)
canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
canvas.configure(yscrollcommand=scrollbar.set)
# Dataverse section
self._create_section_header(scrollable_frame, 0, "📊 PowerApp/Dataverse Configuration")
self._create_label_entry(scrollable_frame, 1, "Environment URL:", 'DATAVERSE_ENVIRONMENT_URL', width=60, multiline=True)
self._create_label_entry(scrollable_frame, 2, "Table Name:", 'DATAVERSE_TABLE_NAME')
# Azure AD section
self._create_section_header(scrollable_frame, 3, "🔐 Azure AD Configuration")
self._create_label_entry(scrollable_frame, 4, "Client ID:", 'AZURE_AD_CLIENT_ID', width=60)
self._create_label_entry(scrollable_frame, 5, "Client Secret:", 'AZURE_AD_CLIENT_SECRET', password=True, width=60)
self._create_label_entry(scrollable_frame, 6, "Tenant ID:", 'AZURE_AD_TENANT_ID', width=60)
# Help text
help_text = ttk.Label(scrollable_frame, text="\n💡 UUF Integration:\n"
"• This section is only needed if you want to fetch UUF items\n"
"• UUF items are processed differently than Azure DevOps work items\n"
"• Environment URL: Your Dataverse environment\n"
"• Azure AD app must have appropriate permissions\n"
"• Contact your PowerApp administrator for these values\n"
"• Leave blank if not using UUF integration",
font=('Arial', 9), foreground='blue', justify=tk.LEFT, wraplength=800)
help_text.grid(row=7, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=20, padx=10)
# Pack canvas and scrollbar
canvas.pack(side="left", fill="both", expand=True)
scrollbar.pack(side="right", fill="y")
def _create_section_header(self, parent, row: int, text: str):
"""Create a section header"""
header_frame = ttk.Frame(parent)
header_frame.grid(row=row, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(20, 10), padx=10)
header_frame.columnconfigure(1, weight=1)
ttk.Label(header_frame, text=text, font=('Arial', 12, 'bold')).grid(row=0, column=0, sticky=tk.W)
ttk.Separator(header_frame, orient='horizontal').grid(row=0, column=1, sticky=(tk.W, tk.E), padx=(10, 0))
def _create_label_entry(self, parent, row: int, label_text: str, config_key: str,
password: bool = False, width: int = 50, multiline: bool = False):
"""Create a label and entry pair"""
ttk.Label(parent, text=label_text, font=('Arial', 10, 'bold')).grid(
row=row, column=0, sticky=tk.W, pady=5, padx=10)
if multiline:
entry = scrolledtext.ScrolledText(parent, height=3, width=width)
entry.grid(row=row, column=1, sticky=(tk.W, tk.E), pady=5, padx=10)
entry.insert('1.0', self.config.get(config_key, '') or '')
elif password:
entry = ttk.Entry(parent, show="*", width=width)
entry.grid(row=row, column=1, sticky=(tk.W, tk.E), pady=5, padx=10)
# Special handling for GITHUB_TOKEN - show placeholder if using default
if config_key == 'GITHUB_TOKEN':
github_token = self.config.get('GITHUB_TOKEN', '').strip()
github_pat = self.config.get('GITHUB_PAT', '').strip()
if not github_token and github_pat:
# Show placeholder for defaulted value, but don't actually set it
entry.config(foreground='gray')
entry.insert(0, '(using GitHub PAT)')
# Add event handlers to clear placeholder on focus
def on_focus_in(event):
if entry.get() == '(using GitHub PAT)':
entry.delete(0, tk.END)
entry.config(foreground='black')
def on_focus_out(event):
if not entry.get():
entry.config(foreground='gray')
entry.insert(0, '(using GitHub PAT)')
entry.bind('<FocusIn>', on_focus_in)
entry.bind('<FocusOut>', on_focus_out)
else:
entry.insert(0, github_token)
else:
entry.insert(0, self.config.get(config_key, '') or '')
else:
entry = ttk.Entry(parent, width=width)
entry.grid(row=row, column=1, sticky=(tk.W, tk.E), pady=5, padx=10)
entry.insert(0, self.config.get(config_key, '') or '')
self.entries[config_key] = entry
parent.columnconfigure(1, weight=1)
def _create_forked_repo_dropdown(self, parent, row: int):
"""Create forked repository dropdown with local repo detection"""
ttk.Label(parent, text="Forked Repository:", font=('Arial', 10, 'bold')).grid(
row=row, column=0, sticky=tk.W, pady=5, padx=10)
# Frame for dropdown and refresh button
dropdown_frame = ttk.Frame(parent)
dropdown_frame.grid(row=row, column=1, sticky=(tk.W, tk.E), pady=5, padx=10)
dropdown_frame.columnconfigure(0, weight=1)
# Initial options
repo_options = [''] # Empty option
# Add local repositories
local_repo_path = self.config.get('LOCAL_REPO_PATH', '')
if local_repo_path:
try:
from .utils import LocalRepositoryScanner
local_repos = LocalRepositoryScanner.scan_local_repos(local_repo_path)
if local_repos:
repo_options.append('--- Local Repositories ---')
repo_options.extend(local_repos)
except Exception as e:
print(f"Error scanning local repos: {e}")
# Placeholder for user's forks (will be populated asynchronously)
self.forked_repos = []
self.forked_repo_var = tk.StringVar(value=self.config.get('FORKED_REPO', ''))
self.forked_repo_dropdown = ttk.Combobox(dropdown_frame, textvariable=self.forked_repo_var,
values=repo_options, width=50)
self.forked_repo_dropdown.grid(row=0, column=0, sticky=(tk.W, tk.E), padx=(0, 5))
self.entries['FORKED_REPO'] = self.forked_repo_var
# Refresh button
refresh_btn = ttk.Button(dropdown_frame, text="🔄", width=3,
command=self._refresh_forked_repos)
refresh_btn.grid(row=0, column=1)
# Help text for forked repo
help_label = ttk.Label(parent,
text=" ℹ️ Your fork where changes will be made. Leave empty to auto-detect from document URL.",
font=('Arial', 9), foreground='gray')
help_label.grid(row=row+1, column=0, columnspan=3, sticky=tk.W, padx=10)
# Start async loading of user's forks
self.dialog.after(100, self._load_user_forks_async)
def _refresh_forked_repos(self):
"""Refresh the forked repositories dropdown"""
self._load_user_forks_async()
# Also refresh local repos
local_repo_path = self.config.get('LOCAL_REPO_PATH', '')
if local_repo_path:
try:
from .utils import LocalRepositoryScanner
local_repos = LocalRepositoryScanner.scan_local_repos(local_repo_path)
# Update dropdown with current values plus refreshed local repos
current_values = list(self.forked_repo_dropdown['values'])
# Remove old local repos section
if '--- Local Repositories ---' in current_values:
start_idx = current_values.index('--- Local Repositories ---')
# Find where GitHub repos start or end of list
end_idx = len(current_values)
for i in range(start_idx + 1, len(current_values)):
if current_values[i].startswith('--- ') and 'GitHub' in current_values[i]:
end_idx = i
break
# Remove local repos section
current_values = current_values[:start_idx] + current_values[end_idx:]
# Add refreshed local repos
if local_repos:
current_values.insert(1, '--- Local Repositories ---')
for i, repo in enumerate(local_repos):
current_values.insert(2 + i, repo)
self.forked_repo_dropdown['values'] = current_values
except Exception as e:
print(f"Error refreshing local repos: {e}")
def _load_user_forks_async(self):
"""Load user's GitHub forks asynchronously"""
def load_forks():
try:
github_token = self.config.get('GITHUB_PAT', '')
if not github_token:
return
from .github_api import GitHubGQL
github_api = GitHubGQL(github_token, dry_run=False)
self.forked_repos = github_api.get_user_forks()
# Update dropdown on main thread
if hasattr(self, 'dialog') and self.dialog.winfo_exists():
self.dialog.after(0, self._update_forked_dropdown)
except Exception as e:
print(f"Error loading user forks: {e}")
threading.Thread(target=load_forks, daemon=True).start()
def _update_forked_dropdown(self):
"""Update the forked repository dropdown with GitHub forks"""
try:
# Check if dialog and dropdown still exist
if not hasattr(self, 'dialog') or not self.dialog.winfo_exists():
return
if not hasattr(self, 'forked_repo_dropdown') or not self.forked_repo_dropdown.winfo_exists():
return
current_values = list(self.forked_repo_dropdown['values'])
# Remove old GitHub forks section if exists
if '--- Your GitHub Forks ---' in current_values:
start_idx = current_values.index('--- Your GitHub Forks ---')
current_values = current_values[:start_idx]
# Add GitHub forks section
if self.forked_repos:
current_values.append('--- Your GitHub Forks ---')
current_values.extend(self.forked_repos)
self.forked_repo_dropdown['values'] = current_values
except Exception as e:
print(f"Error updating forked dropdown: {e}")
def _create_dry_run_checkbox(self, parent, row: int):
"""Create dry run checkbox"""
self.dry_run_var = tk.BooleanVar()
dry_run_value = self.config.get('DRY_RUN', 'false')
self.dry_run_var.set(str(dry_run_value).lower() in ('true', '1', 'yes', 'on'))
dry_run_frame = ttk.Frame(parent)
dry_run_frame.grid(row=row, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=10, padx=10)
dry_run_checkbox = ttk.Checkbutton(
dry_run_frame,
text="🧪 Dry Run Mode (Test without making changes)",
variable=self.dry_run_var
)
dry_run_checkbox.pack(side=tk.LEFT)
help_label = ttk.Label(dry_run_frame,
text=" ℹ️ Simulates operations without creating actual GitHub issues/PRs",
font=('Arial', 9), foreground='gray')
help_label.pack(side=tk.LEFT)
self.entries['DRY_RUN'] = self.dry_run_var
def _scan_repos(self):
"""Scan work items to detect commonly used repositories"""
try:
# This is a placeholder - could be enhanced to actually scan work items
# and suggest repositories based on document URLs found
pass
except Exception as e:
print(f"Could not scan repositories: {e}")
def _bind_events(self):
"""Bind keyboard events"""
self.dialog.bind('<Return>', lambda e: self._save_clicked())
self.dialog.bind('<Escape>', lambda e: self._cancel_clicked())
# Set focus to first entry if available
if self.entries:
first_entry = next(iter(self.entries.values()))
if hasattr(first_entry, 'focus_set'):
first_entry.focus_set()
def _test_connection(self):
"""Test connection to configured services"""
# Get current values
config_values = self._get_config_values()
results = []
# Test Azure DevOps
if config_values.get('AZURE_DEVOPS_QUERY') and config_values.get('AZURE_DEVOPS_PAT'):
try:
# Try to import and test Azure DevOps API
from .azure_devops_api import AzureDevOpsAPI
api = AzureDevOpsAPI(config_values.get('AZURE_DEVOPS_PAT'))
# Basic connection test (this would need actual implementation)
results.append("Azure DevOps: ✅ Configuration looks valid")
except ImportError:
results.append("Azure DevOps: ⚠️ Configuration set (API module not available)")
except Exception as e:
results.append(f"Azure DevOps: ❌ Error - {str(e)}")
elif config_values.get('AZURE_DEVOPS_QUERY') or config_values.get('AZURE_DEVOPS_PAT'):
results.append("Azure DevOps: ⚠️ Incomplete configuration")
# Test GitHub
if config_values.get('GITHUB_PAT'):
try:
# Try to import and test GitHub API
from .github_api import GitHubAPI
api = GitHubAPI(config_values.get('GITHUB_PAT'))
# Basic connection test
results.append("GitHub: ✅ Token configured")
if config_values.get('GITHUB_REPO'):
results.append(f"GitHub Repository: ✅ {config_values.get('GITHUB_REPO')}")
else:
results.append("GitHub Repository: ⚠️ Not configured")
except ImportError:
results.append("GitHub: ⚠️ Token set (API module not available)")
except Exception as e:
results.append(f"GitHub: ❌ Error - {str(e)}")
else:
results.append("GitHub: ❌ No token configured")
# Test AI Provider
ai_provider = config_values.get('AI_PROVIDER', 'none').lower()
if ai_provider and ai_provider != 'none':
try:
from .ai_manager import AIManager
ai_manager = AIManager()
available, missing = ai_manager.check_ai_module_availability(ai_provider)
if available:
results.append(f"AI Provider ({ai_provider}): ✅ Available")
else:
results.append(f"AI Provider ({ai_provider}): ⚠️ Missing packages: {', '.join(missing)}")
except ImportError:
results.append(f"AI Provider ({ai_provider}): ⚠️ Configuration set (AI manager not available)")
else:
results.append("AI Provider: ℹ️ Disabled (using standard method)")
# Show results
if results:
messagebox.showinfo("Connection Test Results",
"\n".join(results) + "\n\n💡 Full validation requires running the application.",
parent=self.dialog)
else:
messagebox.showwarning("Connection Test", "No configuration to test.", parent=self.dialog)
def _center_dialog(self):
"""Center the dialog over the parent window"""
self.dialog.update_idletasks()
# Get parent window position and size
self.parent.update_idletasks()
x = self.parent.winfo_x() + (self.parent.winfo_width() // 2) - (self.dialog.winfo_width() // 2)
y = self.parent.winfo_y() + (self.parent.winfo_height() // 2) - (self.dialog.winfo_height() // 2)
self.dialog.geometry(f"+{x}+{y}")
def _get_config_values(self) -> Dict[str, Any]:
"""Get configuration values from entries"""
config_values = {}
for key, widget in self.entries.items():
if isinstance(widget, tk.BooleanVar):
config_values[key] = 'true' if widget.get() else 'false'
elif isinstance(widget, tk.StringVar):
config_values[key] = widget.get().strip()
elif isinstance(widget, scrolledtext.ScrolledText):
config_values[key] = widget.get('1.0', tk.END).strip()
elif isinstance(widget, ttk.Combobox):
config_values[key] = widget.get().strip()
else: # Entry widget
value = widget.get().strip()
# Special handling for GITHUB_TOKEN placeholder
if key == 'GITHUB_TOKEN' and value == '(using GitHub PAT)':
value = '' # Save empty string when using placeholder
config_values[key] = value
return config_values
def _save_clicked(self):
"""Handle save button click"""
try:
# Get configuration values
config_values = self._get_config_values()
# Validate required fields
required_for_basic = ['AZURE_DEVOPS_QUERY', 'AZURE_DEVOPS_PAT', 'GITHUB_PAT']
missing_basic = [field for field in required_for_basic if not config_values.get(field)]
if missing_basic:
messagebox.showwarning(
"Missing Configuration",
f"The following required fields are missing:\n\n"
f"• {', '.join(missing_basic)}\n\n"
f"These are required for basic functionality."
)
return
# Check AI provider setup before saving
ai_provider = config_values.get('AI_PROVIDER', '').strip().lower()
if ai_provider and ai_provider not in ['none', '']:
if ai_provider in ['chatgpt', 'claude', 'anthropic', 'github-copilot', 'copilot', 'github_copilot']:
try:
# Import here to avoid circular imports
from .ai_manager import AIManager
ai_manager = AIManager()
available, missing = ai_manager.check_ai_module_availability(ai_provider)
if not available:
# Offer to install missing packages
install_success = ai_manager.install_ai_packages(missing, self.dialog)
if not install_success:
# Installation failed or was cancelled, but still save settings
messagebox.showwarning("AI Modules Not Installed",
f"Settings saved, but AI provider '{ai_provider}' "
f"requires additional packages: {', '.join(missing)}\n\n"
f"You can install them later with:\n"
f"pip install {' '.join(missing)}",
parent=self.dialog)
except ImportError:
# AIManager not available, skip AI validation
pass
# Save configuration using the provided config manager
if self.config_manager:
success = self.config_manager.save_configuration(config_values)
else:
# Fallback: create new config manager or save directly to file
try:
from .config_manager import ConfigManager
config_manager = ConfigManager()
success = config_manager.save_configuration(config_values)
except ImportError:
# Fallback to basic file saving if ConfigManager not available
success = self._save_to_env_file(config_values)
if success:
self.result = config_values
# Ask user if they want to restart the application
restart = messagebox.askyesno(
"Settings Saved",
"Settings have been saved to .env file!\n\n"
"Would you like to restart the application now to apply changes?",
parent=self.dialog
)
self.dialog.destroy()
if restart:
self._restart_application()
else:
messagebox.showerror("Save Error",
"Failed to save settings to .env file.",
parent=self.dialog)
except Exception as e:
messagebox.showerror("Save Error",
f"Error saving settings:\n{str(e)}",
parent=self.dialog)
def _save_to_env_file(self, config_values: Dict[str, Any]) -> bool:
"""Fallback method to save configuration to .env file"""
try:
import os
# Create .env content
env_content = "# Azure DevOps to GitHub Tool Configuration\n"
env_content += "# Generated by Settings Dialog\n\n"
# Add all configuration values
for key, value in config_values.items():
if value: # Only add non-empty values
env_content += f"{key}={value}\n"
else:
env_content += f"{key}=\n"
# Write to .env file
env_path = os.path.join(os.getcwd(), '.env')
with open(env_path, 'w', encoding='utf-8') as f:
f.write(env_content)
return True
except Exception as e:
print(f"Error saving to .env file: {e}")
return False
def _on_repo_selected(self, event=None):
"""Handle repo selection from dropdown - informational only for fork workflow"""
# The detected repo dropdown shows which FORK the AI will work on locally
# The GITHUB_REPO field is the UPSTREAM repo where PRs are created
# This supports the fork workflow: work on fork, PR to upstream
pass
def _scan_repos(self):
"""Scan for git repositories in the local repo path"""
try:
from pathlib import Path
# Get the local repo path from the entry field
local_path = self.entries.get('LOCAL_REPO_PATH')
if local_path and hasattr(local_path, 'get'):
path_str = local_path.get().strip()
else:
path_str = self.config.get('LOCAL_REPO_PATH', '').strip()
# If no path configured, use default
if not path_str:
path_str = str(Path.home() / "Downloads" / "github_repos")
base_path = Path(path_str)
# Check if path exists
if not base_path.exists():
self.detected_repos_var.set('No repos found (directory does not exist)')
self.detected_repos_dropdown['values'] = []
return
# Scan for git repositories
repos = []
try:
# Look for owner/repo structure: base_path/owner/repo/.git
for owner_dir in base_path.iterdir():
if not owner_dir.is_dir():
continue
for repo_dir in owner_dir.iterdir():
if not repo_dir.is_dir():
continue
# Check if it's a git repo
git_dir = repo_dir / ".git"
if git_dir.exists():
repo_name = f"{owner_dir.name}/{repo_dir.name}"
repos.append(repo_name)
except PermissionError:
self.detected_repos_var.set('Permission denied accessing directory')
self.detected_repos_dropdown['values'] = []
return
except Exception as e:
self.detected_repos_var.set(f'Error scanning: {str(e)[:50]}')
self.detected_repos_dropdown['values'] = []
return
# Update dropdown
if repos:
repos.sort()
self.detected_repos_dropdown['values'] = repos
# Auto-select if only one repo found
if len(repos) == 1:
self.detected_repos_var.set(repos[0])
# Trigger the selection handler to offer auto-populating GITHUB_REPO
self.dialog.after(200, self._on_repo_selected)
else:
self.detected_repos_var.set(f'{len(repos)} repo(s) found - select one')
else:
self.detected_repos_var.set('No git repositories found')
self.detected_repos_dropdown['values'] = []
except Exception as e:
self.detected_repos_var.set(f'Error: {str(e)[:50]}')
self.detected_repos_dropdown['values'] = []
def _restart_application(self):
"""Restart the application"""
try:
# Get the parent root window (main application)
root = self.parent
while root.master:
root = root.master
# Close the main window
root.quit()
# Restart the application using the same Python executable and script
python = sys.executable
script = sys.argv[0]
# If running as a module (python -m), preserve that
if script.endswith('__main__.py'):
# Running as module, restart with module syntax
os.execl(python, python, '-m', 'app')
else:
# Running as script, restart directly
os.execl(python, python, script, *sys.argv[1:])
except Exception as e:
messagebox.showerror(
"Restart Failed",
f"Could not restart application automatically:\n{str(e)}\n\n"
"Please restart the application manually.",
parent=self.parent
)
def _cancel_clicked(self):
"""Handle cancel button click"""
self.result = None
self.dialog.destroy()
def _clear_cache(self):
"""Clear all cached work items"""
result = messagebox.askyesno(
"Clear Cache",
"Are you sure you want to clear all cached items?\n\n"
"Cached work items and UUF items will be removed.\n"
"The next time you open the app, it will auto-load fresh data."
)
if result:
try:
# Use cache manager passed to dialog
if self.cache_manager:
self.cache_manager.invalidate_cache()
messagebox.showinfo(
"Cache Cleared",
"All cached items have been cleared.\n"
"Fresh data will be loaded on next app start."
)
else:
messagebox.showerror("Error", "Cache manager not available")
except Exception as e:
messagebox.showerror("Error", f"Failed to clear cache: {str(e)}")
def show(self) -> Optional[Dict[str, Any]]:
"""Show dialog and return result"""
self.dialog.wait_window()
return self.result
src/app_components/utils.py → application/app_components/utils.py
+100 -20
View File
@@ -192,11 +192,11 @@ class GitHubInfoExtractor:
class WorkItemFieldExtractor:
"""Extracts and processes item fields (placeholder for future implementation)"""
"""Extracts and processes work item fields"""
@staticmethod
def extract_work_item_fields(work_item: Dict[str, Any]) -> Dict[str, Any]:
"""Extract and process fields from work item (placeholder)"""
"""Extract and process fields from Azure DevOps work item"""
fields = work_item.get('fields', {})
# Extract basic fields
@@ -243,12 +243,12 @@ class WorkItemFieldExtractor:
'new_text': new_text,
'github_info': github_info,
'status': 'Ready',
'source': 'Generic'
'source': 'Azure DevOps'
}
@staticmethod
def extract_uuf_item_fields(uuf_item: Dict[str, Any]) -> Dict[str, Any]:
"""Extract and process fields from custom item (placeholder)"""
"""Extract and process fields from UUF item"""
# UUF items have different field structure
item_id = uuf_item.get('cr_uufitemid', 'Unknown')
title = uuf_item.get('cr_title', 'No Title')
@@ -296,10 +296,8 @@ class ContentBuilders:
@staticmethod
def build_issue_title(item: Dict[str, Any]) -> str:
"""Build GitHub issue title"""
item_id = item.get('id', '')
if item_id:
return f"[#{item_id}] {item['title']}"
return f"{item['title']}"
source_prefix = "UUF" if item.get('source') == 'UUF' else "AB"
return f"[{source_prefix}#{item['id']}] {item['title']}"
@staticmethod
def build_issue_body(item: Dict[str, Any], github_info: Dict[str, Any]) -> str:
@@ -307,7 +305,8 @@ class ContentBuilders:
body_parts = []
# Header
body_parts.append("## Item Details")
source_name = "UUF Item" if item.get('source') == 'UUF' else "Azure DevOps Work Item"
body_parts.append(f"## {source_name} Details")
body_parts.append("")
# Make ID a hyperlink if source URL is available
@@ -373,17 +372,15 @@ class ContentBuilders:
body_parts.append("5. Close this issue when complete")
body_parts.append("")
body_parts.append("---")
body_parts.append("*Created automatically by GitHub Pulse*")
body_parts.append("*Created automatically by Azure DevOps → GitHub Processor*")
return "\n".join(body_parts)
@staticmethod
def build_pr_title(item: Dict[str, Any]) -> str:
"""Build GitHub PR title"""
item_id = item.get('id', '')
if item_id:
return f"[#{item_id}] {item['title']}"
return f"{item['title']}"
source_prefix = "UUF" if item.get('source') == 'UUF' else "AB"
return f"[{source_prefix}#{item['id']}] {item['title']}"
@staticmethod
def build_pr_body(item: Dict[str, Any], github_info: Dict[str, Any]) -> str:
@@ -391,7 +388,8 @@ class ContentBuilders:
body_parts = []
# Header
body_parts.append("## Documentation Update")
source_name = "UUF Item" if item.get('source') == 'UUF' else "Azure DevOps Work Item"
body_parts.append(f"## {source_name} Documentation Update")
body_parts.append("")
# Make ID a hyperlink if source URL is available
@@ -450,7 +448,7 @@ class ContentBuilders:
body_parts.append("")
body_parts.append("---")
body_parts.append("*Created automatically by GitHub Pulse*")
body_parts.append("*Created automatically by Azure DevOps → GitHub Processor*")
return "\n".join(body_parts)
@@ -614,14 +612,17 @@ class ConfigurationHelpers:
def create_default_env_file() -> bool:
"""Create a default .env file with all settings blank"""
try:
default_config = """# GitHub Pulse Configuration
default_config = """# Azure DevOps to GitHub Tool Configuration
# Generated automatically - fill in your values
# IMPORTANT: Do NOT commit this file to source control. Add it to .gitignore.
# Azure DevOps Configuration
AZURE_DEVOPS_QUERY=
AZURE_DEVOPS_PAT=
# GitHub Configuration
GITHUB_PAT=
GITHUB_REPO=
FORKED_REPO=
# Application Settings
DRY_RUN=false
@@ -633,8 +634,12 @@ OPENAI_API_KEY=
GITHUB_TOKEN=
LOCAL_REPO_PATH=
# Custom AI Instructions (optional)
CUSTOM_INSTRUCTIONS=
# PowerApp/Dataverse Configuration (for UUF items - optional)
DATAVERSE_ENVIRONMENT_URL=
DATAVERSE_TABLE_NAME=
AZURE_AD_CLIENT_ID=
AZURE_AD_CLIENT_SECRET=
AZURE_AD_TENANT_ID=
"""
with open('.env', 'w', encoding='utf-8') as f:
f.write(default_config)
@@ -646,6 +651,81 @@ CUSTOM_INSTRUCTIONS=
print(f"Error creating default .env file: {e}")
return False
class EnhancedContentBuilders(ContentBuilders):
"""Enhanced content builders with Azure DevOps specific methods"""
@staticmethod
def build_pr_title_for_azure_devops(item: Dict[str, Any]) -> str:
"""Build GitHub PR title for Azure DevOps items"""
return f"Docs update: {item['title'][:80]} (AB#{item['id']})"
@staticmethod
def build_pr_body_for_azure_devops(item: Dict[str, Any], github_info: Dict[str, Any]) -> str:
"""Build GitHub PR body for Azure DevOps items with enhanced Copilot instructions"""
now = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M UTC")
lines = [
f"**Automated documentation update from Azure DevOps (created on {now})**",
"",
f"**Work Item ID:** AB#{item['id']}",
f"**Document URL:** {item['mydoc_url']}",
]
# Add file path information if available
if github_info.get('original_content_git_url'):
lines.append(f"**File Path:** {github_info['original_content_git_url']}")
# Add ms.author metadata if available
if github_info.get('ms_author'):
lines.append(f"**ms.author:** `{github_info['ms_author']}`")
# Add nature of request for context
lines.extend([
"",
"## Change Type",
f"{item['nature_of_request']}",
"",
])
lines.extend([
"## Changes Requested",
"",
"### Current Text to Replace",
"```",
item['text_to_change'],
"```",
"",
"### Proposed New Text",
"```",
item['new_text'],
"```",
"",
"---",
"",
"## Instructions for GitHub Copilot",
"",
"**Task:** Update the documentation file with the changes requested above.",
"",
"**Steps to complete:**",
"1. Locate the file containing the 'Current Text to Replace' shown above",
"2. Find the exact text that needs to be updated",
"3. Replace it with the 'Proposed New Text'",
"4. Ensure no other changes are made to the file",
"5. Commit the changes with a descriptive message",
"",
"**Important Notes:**",
"- Only change the specific text shown above",
"- Do not modify formatting, links, or other content",
"- Verify the replacement text fits naturally in context",
"",
"---",
"*This PR was created automatically from Azure DevOps work item AB#" + str(item['id']) + "*"
])
return "\n".join(lines)
# Compatibility functions for direct function access
def get_next_pr_number(provider_key: str) -> int:
"""Compatibility function for direct access to PR number generation"""
application/app_components/work_item_processor.py
+291
View File
@@ -0,0 +1,291 @@
"""
Work Item Processor
Handles processing of Azure DevOps work items and UUF items
"""
import re
import html
import requests
from typing import Dict, Any, Optional, Tuple
from urllib.parse import urlparse
from .utils import WorkItemFieldExtractor
# User agent for web requests
USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
class WorkItemProcessor:
"""Processor for extracting and validating work item data with advanced parsing"""
def __init__(self, logger, config: Dict[str, Any] = None):
self.logger = logger
self.log = logger.log if hasattr(logger, 'log') else logger
self.config = config or {}
def process_work_item(self, work_item: Dict[str, Any]) -> Optional[Dict[str, Any]]:
"""Process a single work item to extract required fields with advanced validation"""
try:
work_item_id = work_item['id']
title = work_item.get('fields', {}).get('System.Title', 'No Title')
description = work_item.get('fields', {}).get('System.Description', '')
if not description:
self.log(f"Work item {work_item_id} has no description, skipping")
return None
# Parse description for required fields
parsed_data = self._parse_description(description)
if not parsed_data:
self.log(f"Work item {work_item_id} doesn't contain required fields, skipping")
return None
# Validate nature of request (check for both variations)
nature_lower = parsed_data['nature_of_request'].lower()
if not ("modify existing docs" in nature_lower or "modifying existing docs" in nature_lower):
self.log(f"Work item {work_item_id} nature of request doesn't contain 'modify existing docs', skipping")
return None
# Extract GitHub info from document URL
github_info = self._extract_github_info(parsed_data['mydoc_url'])
# If the document does not include an original_content_git_url, skip this work item
if not github_info.get('original_content_git_url'):
self.log(f"Work item {work_item_id} skipped: original_content_git_url not found in document {parsed_data['mydoc_url']}")
return None
# Construct proper web URL for work item
# The API returns something like: https://dev.azure.com/org/project/_apis/wit/workItems/123
# We need to convert it to: https://dev.azure.com/org/project/_workitems/edit/123
work_item_url = ''
api_url = work_item.get('url', '')
if api_url:
# Convert API URL to web URL
# Replace /_apis/wit/workItems/ with /_workitems/edit/
work_item_url = api_url.replace('/_apis/wit/workItems/', '/_workitems/edit/')
processed_item = {
'id': work_item_id,
'title': title,
'nature_of_request': parsed_data['nature_of_request'],
'mydoc_url': parsed_data['mydoc_url'],
'text_to_change': parsed_data['text_to_change'],
'new_text': parsed_data['new_text'],
'github_info': github_info,
'status': 'Ready',
'source': 'Azure DevOps',
'source_url': work_item_url, # URL to Azure DevOps work item
'original_new_text': parsed_data['new_text'] # Keep original for reference
}
self.log(f"Successfully processed work item {work_item_id}")
return processed_item
except Exception as e:
self.log(f"Error processing work item {work_item.get('id', 'unknown')}: {str(e)}")
return None
def process_uuf_item(self, uuf_item: Dict[str, Any]) -> Optional[Dict[str, Any]]:
"""Process a single UUF item from Dataverse/PowerApp with enhanced field mapping"""
try:
# Extract UUF item ID (adjust field name as needed)
uuf_id = uuf_item.get('cr4af_uufid') or uuf_item.get('cr4af_name') or 'unknown'
# Extract title
title = uuf_item.get('cr4af_title') or uuf_item.get('cr4af_subject') or 'No Title'
# Extract description/details
description = uuf_item.get('cr4af_description') or uuf_item.get('cr4af_details') or ''
if not description:
self.log(f"UUF item {uuf_id} has no description, skipping")
return None
# Extract document URL
doc_url = uuf_item.get('cr4af_documenturl') or uuf_item.get('cr4af_docurl') or ''
if not doc_url:
self.log(f"UUF item {uuf_id} has no document URL, skipping")
return None
# Extract text to change and new text
text_to_change = uuf_item.get('cr4af_texttochange') or uuf_item.get('cr4af_currenttext') or ''
new_text = uuf_item.get('cr4af_proposednewtext') or uuf_item.get('cr4af_newtext') or ''
if not text_to_change or not new_text:
self.log(f"UUF item {uuf_id} missing text fields, skipping")
return None
# Extract GitHub info from document URL
github_info = self._extract_github_info(doc_url)
# If the document does not include an original_content_git_url, skip this item
if not github_info.get('original_content_git_url'):
self.log(f"UUF item {uuf_id} skipped: original_content_git_url not found in document {doc_url}")
return None
# Get UUF item URL if available (e.g., from Dataverse)
uuf_url = uuf_item.get('cr4af_itemurl', '') or uuf_item.get('cr4af_url', '')
processed_item = {
'id': uuf_id,
'title': title,
'nature_of_request': 'UUF Item - Modify existing docs',
'mydoc_url': doc_url,
'text_to_change': text_to_change,
'new_text': new_text,
'github_info': github_info,
'status': 'Ready',
'source': 'UUF', # Mark as UUF item
'source_url': uuf_url, # URL to UUF item (if available)
'original_new_text': new_text
}
self.log(f"Successfully processed UUF item {uuf_id}")
return processed_item
except Exception as e:
self.log(f"Error processing UUF item {uuf_item.get('cr4af_uufid', 'unknown')}: {str(e)}")
return None
def _parse_description(self, description: str) -> Optional[Dict[str, Any]]:
"""Parse work item description to extract required fields using enhanced regex patterns"""
# Enhanced regex patterns from regex_V5
patterns = {
'nature_of_request': r'nature\s+of\s+request[:\s]*([^\)]*\))',
'link_to_doc': r'link\s+to\s+doc[:\s]*([^\s&]+)',
'text_to_change': r'text\s+to\s+change[:\s]*([\s\S]*?)(?=\n*-+\s*Proposed new text|If adding brand new docs:|$)',
'proposed_new_text': r'proposed\s+new\s+text[:\s]*([\s\S]+?)(?=\s*If\s+adding\s+brand\s+new\s+docs:)'
}
# Clean HTML tags if present
clean_description = re.sub(r'<[^>]+>', '', description)
# Convert HTML entities to characters (e.g., &quot; to ", &amp; to &)
clean_description = html.unescape(clean_description)
extracted = {}
for field, pattern in patterns.items():
match = re.search(pattern, clean_description, re.IGNORECASE | re.DOTALL)
if match:
value = match.group(1).strip()
if field == 'nature_of_request':
extracted['nature_of_request'] = value
elif field == 'link_to_doc':
extracted['mydoc_url'] = value.rstrip('-')
elif field == 'text_to_change':
extracted['text_to_change'] = value
elif field == 'proposed_new_text':
extracted['new_text'] = value
# If enhanced patterns don't work, fall back to basic patterns
if not all(field in extracted for field in ['nature_of_request', 'mydoc_url', 'text_to_change', 'new_text']):
basic_patterns = {
'nature_of_request': r'nature\s+of\s+request[:\s]*([^\n]+)',
'link_to_doc': r'link\s+to\s+doc[:\s]*([^\s]+)',
'text_to_change': r'text\s+to\s+change[:\s]*(.+?)(?=proposed\s+new\s+text|$)',
'proposed_new_text': r'proposed\s+new\s+text[:\s]*(.+?)(?=\n\n|$)'
}
extracted = {}
for field, pattern in basic_patterns.items():
match = re.search(pattern, clean_description, re.IGNORECASE | re.DOTALL)
if match:
value = match.group(1).strip()
if field == 'nature_of_request':
extracted['nature_of_request'] = value
elif field == 'link_to_doc':
extracted['mydoc_url'] = value
elif field == 'text_to_change':
extracted['text_to_change'] = value
elif field == 'proposed_new_text':
extracted['new_text'] = value
# Validate all required fields are present
required_fields = ['nature_of_request', 'mydoc_url', 'text_to_change', 'new_text']
if not all(field in extracted for field in required_fields):
return None
return extracted
def _extract_github_info(self, doc_url: str) -> Dict[str, Any]:
"""Extract GitHub repository info and ms.author from document URL
If GITHUB_REPO is configured in .env, it will be used instead of the repo
extracted from the document metadata. This allows you to create PRs in your
fork while preserving the file path and ms.author from the original document.
"""
try:
# Fetch the document
headers = {'User-Agent': USER_AGENT}
response = requests.get(doc_url, headers=headers, timeout=30)
response.raise_for_status()
html_content = response.text
# Extract ms.author
ms_author = self._extract_meta_tag(html_content, 'ms.author')
# Extract original_content_git_url
original_content_git_url = self._extract_meta_tag(html_content, 'original_content_git_url')
if not original_content_git_url:
# Try alternative extraction method
match = re.search(r"original_content_git_url[\"\']?\s*[:=]\s*[\"\']([^\"']+)[\"']", html_content, re.IGNORECASE)
if match:
original_content_git_url = match.group(1).strip()
if not original_content_git_url:
raise ValueError("original_content_git_url not found in document")
# Check if GITHUB_REPO is configured in .env
# If it is, use that instead of the repo from the document
configured_repo = self.config.get('GITHUB_REPO')
if configured_repo and '/' in configured_repo:
# Use the configured repository (e.g., "b-tsammons/fabric-docs-pr")
parts = configured_repo.split('/', 1)
owner = parts[0].strip()
repo = parts[1].strip()
self.log(f"Using configured GITHUB_REPO: {owner}/{repo} (overriding document metadata)")
else:
# Parse GitHub owner/repo from original_content_git_url (fallback to document metadata)
owner, repo = self._parse_github_url(original_content_git_url)
self.log(f"Using repository from document metadata: {owner}/{repo}")
return {
'ms_author': ms_author,
'original_content_git_url': original_content_git_url,
'owner': owner,
'repo': repo
}
except Exception as e:
self.log(f"Error extracting GitHub info from {doc_url}: {str(e)}")
return {
'ms_author': None,
'original_content_git_url': None,
'owner': None,
'repo': None,
'error': str(e)
}
def _extract_meta_tag(self, html_content: str, name: str) -> Optional[str]:
"""Extract content from meta tag"""
pattern = rf'<meta\s+(?:[^>]*?\s)?(?:name|property)\s*=\s*["\'](?P<n>{re.escape(name)})["\']\s+[^>]*?\bcontent\s*=\s*["\'](?P<content>[^"\']+)["\'][^>]*?>'
match = re.search(pattern, html_content, re.IGNORECASE)
if match:
return match.group('content').strip()
return None
def _parse_github_url(self, url: str) -> Tuple[str, str]:
"""Parse GitHub URL to extract owner and repo"""
parsed = urlparse(url)
if "github.com" not in parsed.netloc.lower():
raise ValueError(f"Not a GitHub URL: {url}")
parts = [p for p in parsed.path.split("/") if p]
if len(parts) < 2:
raise ValueError(f"Unable to parse owner/repo from: {url}")
return parts[0], parts[1]
application/requirements.txt
+9
View File
@@ -0,0 +1,9 @@
# Core dependencies
requests>=2.31.0
# AI providers (optional - installed automatically when needed)
anthropic>=0.18.0 # Claude AI
openai>=1.12.0 # ChatGPT/GPT-4
# Git operations (required for AI functionality)
GitPython>=3.1.40
media/fetch-work-items.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 72 KiB

media/flow-diagram.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 77 KiB

media/github-issue-copilot-pr.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 127 KiB

media/github-pull-request.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 114 KiB

media/issue-created.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 7.8 KiB

pyproject.toml.example
-46
View File
@@ -1,46 +0,0 @@
[project]
name = "GitHub Pulse"
version = "0.0.1"
description = "A Python-based GUI application for GitHub automation workflows and AI assisted workflows."
readme = "README.md"
requires-python = ">=3.9"
authors = [
{ name = "Flet developer", email = "you@example.com" }
]
dependencies = [
"flet==0.28.3",
"requests>=2.32.5",
"keyring>=25.6.0",
"GitPython>=3.1.45",
"openai>=2.8.0",
"anthropic>=0.72.1"
]
[tool.flet]
# org name in reverse domain name notation, e.g. "com.mycompany".
# Combined with project.name to build bundle ID for iOS and Android apps
org = "com.mycompany"
# project display name that is used as an app title on Android and iOS home screens,
# shown in window titles and about app dialogs on desktop.
product = "GitHub Pulse"
# company name to display in about app dialogs
company = "Flet"
# copyright text to display in about app dialogs
copyright = "Copyright (C) 2025 by Flet"
[tool.flet.app]
path = "src"
[tool.uv]
dev-dependencies = [
"flet[all]==0.28.3",
]
[tool.poetry]
package-mode = false
[tool.poetry.group.dev.dependencies]
flet = {extras = ["all"], version = "0.28.3"}
src/app_components/__init__.py
-54
View File
@@ -1,54 +0,0 @@
"""
GitHub Pulse - Application Components
Modular components for the application
"""
import sys
import os
# Version info
__version__ = "0.0.1"
__author__ = "TySP-Dev"
__app_name__ = "GitHub Pulse"
# Determine if running in production build
IS_PRODUCTION = getattr(sys, 'frozen', False)
# Get the application directory
if IS_PRODUCTION:
# In production build, get the executable directory
APP_DIR = os.path.dirname(sys.executable)
else:
# In development, get the source directory
APP_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Export main classes for easier imports
from .config_manager import ConfigManager
from .ai_manager import AIManager
from .github_api import GitHubAPI
from .settings_dialog import SettingsDialog
from .main_gui import MainGUI
from .utils import Logger, PRNumberManager, ContentBuilders
from .workflow import WorkflowManager, WorkflowItem, GitHubRepoFetcher
from .ai_action_planner import AIActionPlanner, ActionPlan
__all__ = [
'ConfigManager',
'AIManager',
'GitHubAPI',
'SettingsDialog',
'MainGUI',
'Logger',
'PRNumberManager',
'ContentBuilders',
'WorkflowManager',
'WorkflowItem',
'GitHubRepoFetcher',
'AIActionPlanner',
'ActionPlan',
'__version__',
'__author__',
'__app_name__',
'IS_PRODUCTION',
'APP_DIR'
]
src/app_components/ai_action_planner.py
-617
View File
@@ -1,617 +0,0 @@
"""
AI Action Planner
Generates and executes action plans for GitHub issues and PRs using AI
"""
import json
import re
import requests
from typing import List, Dict, Any, Optional, Callable
from pathlib import Path
class ActionPlan:
"""Represents an AI-generated action plan"""
def __init__(self, title: str, steps: List[Dict[str, Any]], context: Dict[str, Any]):
self.title = title
self.steps = steps # List of {description, file_path, changes, completed}
self.context = context # PR/Issue context
self.completed_steps = []
self.failed_steps = []
def to_dict(self) -> Dict[str, Any]:
"""Convert plan to dictionary"""
return {
'title': self.title,
'steps': self.steps,
'context': self.context,
'completed_steps': self.completed_steps,
'failed_steps': self.failed_steps
}
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> 'ActionPlan':
"""Create plan from dictionary"""
plan = cls(data['title'], data['steps'], data['context'])
plan.completed_steps = data.get('completed_steps', [])
plan.failed_steps = data.get('failed_steps', [])
return plan
class OllamaProvider:
"""Simple Ollama API provider for AI action planning"""
def __init__(self, base_url: str, model: str, logger):
self.base_url = base_url.rstrip('/')
self.model = model
self.logger = logger
def generate(self, prompt: str) -> Optional[str]:
"""Generate a response from Ollama"""
try:
response = requests.post(
f"{self.base_url}/api/generate",
json={
"model": self.model,
"prompt": prompt,
"stream": False
},
timeout=120
)
response.raise_for_status()
result = response.json()
return result.get('response', '')
except Exception as e:
self.logger.log(f"❌ Ollama API error: {str(e)}")
return None
def make_change(self, file_content: str, old_text: str, new_text: str, file_path: str, custom_instructions: str = None) -> Optional[str]:
"""Make changes to file content using Ollama"""
# Try direct replacement first
if old_text and old_text.strip() in file_content:
return file_content.replace(old_text.strip(), new_text.strip())
# Use Ollama to make intelligent changes
prompt = f"""You are a code modification assistant. Modify the following file according to the instructions.
File: {file_path}
Current Content:
```
{file_content}
```
Instructions: {new_text}
{f'Additional context: {custom_instructions}' if custom_instructions else ''}
Return ONLY the complete modified file content. Do not include explanations or markdown code blocks."""
return self.generate(prompt)
class AIActionPlanner:
"""Generates and executes action plans using AI"""
def __init__(self, ai_manager, logger, config_manager):
self.ai_manager = ai_manager
self.logger = logger
self.config_manager = config_manager
def generate_plan(self, item, custom_instructions: str = "") -> Optional[ActionPlan]:
"""
Generate an action plan for a PR or Issue
Args:
item: The PR or Issue (WorkflowItem object or dict)
custom_instructions: Optional user-provided instructions
Returns:
ActionPlan object or None if generation failed
"""
# Handle both WorkflowItem objects and dictionaries
if hasattr(item, 'item_type'):
# It's a WorkflowItem object
item_type = item.item_type
item_number = item.number
title = item.title
body = item.body or ''
repo = getattr(item, 'repo', None)
else:
# It's a dictionary
item_type = item.get('type', 'unknown')
item_number = item.get('number')
title = item.get('title', 'Untitled')
body = item.get('body', '')
repo = item.get('repo')
self.logger.log(f"🤖 Generating action plan for {item_type} #{item_number}...")
# Get AI provider
config = self.config_manager.get_config()
ai_provider_name = config.get('AI_PROVIDER', 'none').lower()
if ai_provider_name == 'none' or not ai_provider_name:
self.logger.log("❌ No AI provider configured. Please configure in Settings.")
return None
# Get provider instance
provider = self._get_ai_provider(ai_provider_name, config)
if not provider:
return None
# Generate the plan using AI
try:
self.logger.log(f"📤 Calling AI provider: {type(provider).__name__}")
plan_text = self._call_ai_for_plan(provider, item_type, title, body, custom_instructions)
if not plan_text:
self.logger.log("❌ AI did not generate a plan (empty response)")
return None
self.logger.log(f"📥 Received response from AI ({len(plan_text)} characters)")
self.logger.log(f"📄 Response preview: {plan_text[:200]}...")
# Parse the plan
self.logger.log("🔍 Parsing AI response into steps...")
steps = self._parse_plan(plan_text)
if not steps:
self.logger.log("❌ Could not parse action steps from AI response")
return None
# Get repo from item or config
if repo is None:
repo = config.get('GITHUB_REPO', '')
plan = ActionPlan(
title=f"Action Plan for {item_type.upper()} #{item_number}: {title}",
steps=steps,
context={
'item_type': item_type,
'item_number': item_number,
'item_title': title,
'item_body': body,
'repo': repo
}
)
self.logger.log(f"✅ Generated plan with {len(steps)} steps")
return plan
except Exception as e:
self.logger.log(f"❌ Error generating plan: {str(e)}")
return None
def _get_ai_provider(self, provider_name: str, config: Dict[str, Any]):
"""Get the AI provider instance"""
try:
if provider_name in ['claude', 'anthropic']:
# Try both CLAUDE_API_KEY and ANTHROPIC_API_KEY for compatibility
api_key = config.get('CLAUDE_API_KEY')
if not api_key:
api_key = config.get('ANTHROPIC_API_KEY')
if not api_key:
self.logger.log("❌ Claude API key not found in secure storage (tried both CLAUDE_API_KEY and ANTHROPIC_API_KEY)")
return None
self.logger.log("ℹ️ Initializing Claude provider...")
from . import ai_manager
provider = ai_manager.ClaudeProvider(api_key, self.logger)
self.logger.log("✅ Claude provider initialized successfully")
return provider
elif provider_name in ['chatgpt', 'openai']:
api_key = config.get('OPENAI_API_KEY')
if not api_key:
self.logger.log("❌ OpenAI API key not found in secure storage")
return None
self.logger.log("ℹ️ Initializing ChatGPT provider...")
from . import ai_manager
provider = ai_manager.ChatGPTProvider(api_key, self.logger)
self.logger.log("✅ ChatGPT provider initialized successfully")
return provider
elif provider_name == 'ollama':
# Ollama doesn't need an API key, uses URL from config
ollama_url = config.get('OLLAMA_URL', 'http://localhost:11434')
ollama_model = config.get('OLLAMA_MODEL', 'llama2')
self.logger.log(f"ℹ️ Using Ollama at {ollama_url} with model {ollama_model}")
# Create a simple Ollama provider wrapper
return OllamaProvider(ollama_url, ollama_model, self.logger)
else:
self.logger.log(f"❌ Unsupported AI provider: {provider_name}")
return None
except Exception as e:
self.logger.log(f"❌ Error creating AI provider: {str(e)}")
return None
def _call_ai_for_plan(self, provider, item_type: str, title: str, body: str, custom_instructions: str) -> Optional[str]:
"""Call AI to generate an action plan"""
prompt = f"""You are an expert software engineer tasked with creating an actionable plan to address a GitHub {item_type}.
{item_type.upper()} Title: {title}
{item_type.upper()} Description:
{body}
{"Additional Instructions: " + custom_instructions if custom_instructions else ""}
Please create a detailed action plan with specific, executable steps. For each step, specify:
1. What needs to be done (clear description)
2. Which file(s) need to be modified (if applicable)
3. What changes should be made (if applicable)
Format your response as a JSON array of steps, where each step has:
- "description": A clear description of what to do
- "file_path": Path to the file to modify (or null if not file-specific)
- "changes": Description of changes to make (or null if not applicable)
- "action_type": One of ["modify_file", "create_file", "delete_file", "investigate", "test", "document"]
Example format:
```json
[
{{
"description": "Fix the authentication bug in login handler",
"file_path": "src/auth/login.py",
"changes": "Update the password validation logic to handle special characters correctly",
"action_type": "modify_file"
}},
{{
"description": "Add unit tests for authentication",
"file_path": "tests/test_auth.py",
"changes": "Add test cases for special characters in passwords",
"action_type": "create_file"
}}
]
```
IMPORTANT: Return ONLY the JSON array, no other text before or after."""
try:
if isinstance(provider, OllamaProvider):
# Use Ollama
self.logger.log(f"🤖 Calling Ollama AI to generate plan...")
return provider.generate(prompt)
elif hasattr(provider, '_generate_updated_document'):
# Use Claude's document generation
self.logger.log(f"🤖 Calling Claude AI to generate plan...")
import anthropic
client = anthropic.Anthropic(api_key=provider.api_key)
message = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=4096,
messages=[{"role": "user", "content": prompt}]
)
return message.content[0].text
elif hasattr(provider, 'client'):
# Use OpenAI/ChatGPT
self.logger.log(f"🤖 Calling ChatGPT AI to generate plan...")
response = provider.client.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}],
max_tokens=4096
)
self.logger.log(f"✅ ChatGPT response received")
return response.choices[0].message.content
else:
self.logger.log(f"❌ Unknown provider type: {type(provider).__name__}")
return None
except Exception as e:
self.logger.log(f"❌ AI API call failed: {str(e)}")
import traceback
self.logger.log(f"❌ Traceback: {traceback.format_exc()}")
return None
def _parse_plan(self, plan_text: str) -> List[Dict[str, Any]]:
"""Parse the AI-generated plan text into structured steps"""
try:
# Extract JSON from response (might be wrapped in markdown)
json_match = re.search(r'```json\s*(\[.*?\])\s*```', plan_text, re.DOTALL)
if json_match:
json_text = json_match.group(1)
else:
# Try to find JSON array directly
json_match = re.search(r'\[.*\]', plan_text, re.DOTALL)
if json_match:
json_text = json_match.group(0)
else:
self.logger.log("⚠️ Could not find JSON in AI response")
return []
# Parse JSON
steps = json.loads(json_text)
# Validate and clean up steps
validated_steps = []
for i, step in enumerate(steps):
if isinstance(step, dict):
validated_step = {
'step_number': i + 1,
'description': step.get('description', f'Step {i+1}'),
'file_path': step.get('file_path'),
'changes': step.get('changes'),
'action_type': step.get('action_type', 'investigate'),
'completed': False,
'status': 'pending'
}
validated_steps.append(validated_step)
self.logger.log(f"✅ Successfully parsed {len(validated_steps)} steps from AI response")
return validated_steps
except json.JSONDecodeError as e:
self.logger.log(f"❌ Failed to parse JSON: {str(e)}")
self.logger.log(f"Response was: {plan_text[:500]}...")
return []
except Exception as e:
self.logger.log(f"❌ Error parsing plan: {str(e)}")
return []
def execute_plan(
self,
plan: ActionPlan,
local_repo_path: str,
progress_callback: Optional[Callable[[int, int, str], None]] = None,
log_callback: Optional[Callable[[str], None]] = None
) -> Dict[str, Any]:
"""
Execute an action plan
Args:
plan: The ActionPlan to execute
local_repo_path: Path to local git repository
progress_callback: Callback function(current_step, total_steps, message)
log_callback: Callback function for logging thought process
Returns:
Dictionary with execution results
"""
def log(message):
"""Helper to log to both logger and callback"""
self.logger.log(message)
if log_callback:
log_callback(message)
log(f"▶️ Starting execution of plan: {plan.title}")
if not local_repo_path or not Path(local_repo_path).exists():
log(f"❌ Local repository path not found: {local_repo_path}")
return {'success': False, 'error': 'Invalid local repository path'}
total_steps = len(plan.steps)
completed = 0
failed = 0
for i, step in enumerate(plan.steps):
step_num = step['step_number']
# Mark step as in-progress
step['status'] = 'in_progress'
if progress_callback:
progress_callback(i + 1, total_steps, f"Executing step {step_num}...")
log(f"\n📍 Step {step_num}/{total_steps}: {step['description']}")
try:
result = self._execute_step(step, local_repo_path, plan.context, log)
if result['success']:
step['completed'] = True
step['status'] = 'completed'
plan.completed_steps.append(step_num)
completed += 1
log(f"✅ Step {step_num} completed")
else:
step['status'] = 'failed'
step['error'] = result.get('error', 'Unknown error')
plan.failed_steps.append(step_num)
failed += 1
log(f"❌ Step {step_num} failed: {result.get('error')}")
except Exception as e:
step['status'] = 'failed'
step['error'] = str(e)
plan.failed_steps.append(step_num)
failed += 1
log(f"❌ Step {step_num} failed with exception: {str(e)}")
log(f"\n📊 Execution complete: {completed}/{total_steps} steps successful, {failed} failed")
# If we made changes successfully, commit and push them
if completed > 0:
try:
log("\n🔧 Committing and pushing changes...")
# Get PR/Issue info from context
item_type = plan.context.get('item_type', 'item')
item_number = plan.context.get('item_number', 'unknown')
item_title = plan.context.get('item_title', 'changes')
# Commit message
commit_msg = f"AI: Execute action plan for {item_type} #{item_number}\n\n{item_title}\n\nAutomated changes by GitHub Pulse AI"
# Get current branch (should be the PR branch)
import subprocess
result = subprocess.run(
['git', 'rev-parse', '--abbrev-ref', 'HEAD'],
cwd=local_repo_path,
capture_output=True,
text=True,
timeout=10
)
current_branch = result.stdout.strip() if result.returncode == 0 else 'main'
log(f"📍 Current branch: {current_branch}")
# Stage all changes
log("📝 Staging changes...")
subprocess.run(['git', 'add', '-A'], cwd=local_repo_path, check=True, timeout=10)
# Check if there are changes to commit
result = subprocess.run(
['git', 'diff', '--cached', '--quiet'],
cwd=local_repo_path,
timeout=10
)
if result.returncode != 0: # There are changes
# Commit
log("💾 Committing changes...")
subprocess.run(
['git', 'commit', '-m', commit_msg],
cwd=local_repo_path,
check=True,
timeout=10
)
# Push
log(f"🚀 Pushing to {current_branch}...")
subprocess.run(
['git', 'push', 'origin', current_branch],
cwd=local_repo_path,
check=True,
timeout=30
)
log(f"✅ Changes pushed to {current_branch}")
else:
log("ℹ️ No changes to commit")
except subprocess.TimeoutExpired:
log("⚠️ Git operation timed out")
except subprocess.CalledProcessError as e:
log(f"⚠️ Git operation failed: {e}")
except Exception as e:
log(f"⚠️ Error during git commit/push: {str(e)}")
return {
'success': failed == 0,
'completed': completed,
'failed': failed,
'total': total_steps,
'plan': plan
}
def _execute_step(self, step: Dict[str, Any], local_repo_path: str, context: Dict[str, Any], log=None) -> Dict[str, Any]:
"""Execute a single step of the plan"""
action_type = step.get('action_type', 'investigate')
file_path = step.get('file_path')
changes = step.get('changes')
# Use log function if provided, otherwise fall back to logger
log_func = log if log else self.logger.log
if action_type == 'modify_file' and file_path:
return self._modify_file(file_path, changes, local_repo_path, log_func)
elif action_type == 'create_file' and file_path:
return self._create_file(file_path, changes, local_repo_path, log_func)
elif action_type == 'delete_file' and file_path:
return self._delete_file(file_path, local_repo_path, log_func)
else:
# For investigate, test, document actions, just mark as completed
# (requires manual intervention)
log_func(f"ℹ️ Manual action required: {step['description']}")
return {'success': True, 'message': 'Manual action logged'}
def _modify_file(self, file_path: str, changes: str, local_repo_path: str, log=None) -> Dict[str, Any]:
"""Modify a file using AI"""
log_func = log if log else self.logger.log
full_path = Path(local_repo_path) / file_path
if not full_path.exists():
return {'success': False, 'error': f'File not found: {file_path}'}
try:
log_func(f"📝 Reading file: {file_path}")
# Read current content
with open(full_path, 'r', encoding='utf-8') as f:
current_content = f.read()
# Get AI provider to make changes
config = self.config_manager.get_config()
provider_name = config.get('AI_PROVIDER', 'none').lower()
provider = self._get_ai_provider(provider_name, config)
if not provider:
return {'success': False, 'error': 'AI provider not available'}
# Use AI to make the changes
log_func(f"🤖 Using AI to modify {file_path}...")
log_func(f"🔍 Analyzing changes needed...")
updated_content = provider.make_change(
file_content=current_content,
old_text=current_content[:200] + "...", # Context
new_text=changes, # What to change
file_path=str(full_path),
custom_instructions=changes
)
if updated_content and updated_content != current_content:
log_func(f"💾 Writing changes to {file_path}...")
# Write updated content
with open(full_path, 'w', encoding='utf-8') as f:
f.write(updated_content)
log_func(f"✅ Successfully modified {file_path}")
return {'success': True, 'file': file_path}
else:
return {'success': False, 'error': 'AI could not generate changes'}
except Exception as e:
return {'success': False, 'error': f'Error modifying file: {str(e)}'}
def _create_file(self, file_path: str, content: str, local_repo_path: str, log=None) -> Dict[str, Any]:
"""Create a new file"""
log_func = log if log else self.logger.log
full_path = Path(local_repo_path) / file_path
if full_path.exists():
return {'success': False, 'error': f'File already exists: {file_path}'}
try:
log_func(f"📄 Creating new file: {file_path}")
# Create parent directories if needed
full_path.parent.mkdir(parents=True, exist_ok=True)
# Create file with content
with open(full_path, 'w', encoding='utf-8') as f:
f.write(content or f"# TODO: Implement {file_path}\n")
log_func(f"✅ Created {file_path}")
return {'success': True, 'file': file_path}
except Exception as e:
return {'success': False, 'error': f'Error creating file: {str(e)}'}
def _delete_file(self, file_path: str, local_repo_path: str, log=None) -> Dict[str, Any]:
"""Delete a file"""
log_func = log if log else self.logger.log
full_path = Path(local_repo_path) / file_path
if not full_path.exists():
return {'success': False, 'error': f'File not found: {file_path}'}
try:
log_func(f"🗑️ Deleting file: {file_path}")
full_path.unlink()
log_func(f"✅ Deleted {file_path}")
return {'success': True, 'file': file_path}
except Exception as e:
return {'success': False, 'error': f'Error deleting file: {str(e)}'}
src/app_components/assets/flow-diagram.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 128 KiB

src/app_components/assets/github_pulse_img.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 91 KiB

src/app_components/assets/pulse_logo_gray_no_bkg.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 25 KiB

src/app_components/assets/pulse_logo_white_no_bkg.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 25 KiB

src/app_components/assets/pulse_logo_white_no_bkg_github.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 72 KiB

src/app_components/assets/pulse_logo_white_w_black_bkg.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 23 KiB

src/app_components/config_manager.py
-246
View File
@@ -1,246 +0,0 @@
"""
Configuration Manager
Wrapper around SettingsManager for backward compatibility.
Now uses config.json + keyring instead of .env files.
"""
import os
import json
from typing import Dict, Any, Optional
from pathlib import Path
from .settings_manager import SettingsManager
class ConfigManager:
"""
Manages application configuration using the new SettingsManager.
Provides backward compatibility with old .env-based code while
using the modern config.json + keyring system underneath.
"""
def __init__(self):
"""Initialize with SettingsManager backend"""
# Initialize the modern settings system
self._settings = SettingsManager()
# Check if .env exists and offer migration
env_path = Path('.env')
if env_path.exists() and not Path('application/config.json').exists():
print("\n" + "="*60)
print("NOTICE: Legacy .env file detected!")
print("="*60)
print("Your app now uses a modern settings system with:")
print(" ✓ Secure API key storage (Windows Credential Manager)")
print(" ✓ Live settings updates (no restart needed)")
print(" ✓ Better configuration management")
print()
print("Migrating settings from .env to new system...")
print()
if self._settings.migrate_from_env(env_path):
print("✓ Migration successful!")
print(f" - Secrets → System keyring")
print(f" - Settings → {self._settings.config_file}")
print()
print("Your .env file is kept as backup.")
print("You can delete it once you verify everything works.")
else:
print("✗ Migration failed. Using .env as fallback.")
print("="*60 + "\n")
# Load configuration
self.config = self._settings.get_all()
# Auto-default GITHUB_TOKEN to GITHUB_PAT if needed
self._apply_token_defaults()
# Show configuration status
self._print_config_status()
def _apply_token_defaults(self):
"""Auto-default GITHUB_TOKEN to GITHUB_PAT if GITHUB_TOKEN is empty"""
github_token = self.config.get('GITHUB_TOKEN', '').strip() if self.config.get('GITHUB_TOKEN') else ''
github_pat = self.config.get('GITHUB_PAT', '').strip() if self.config.get('GITHUB_PAT') else ''
if not github_token and github_pat:
self.config['GITHUB_TOKEN'] = github_pat
self._settings.set('GITHUB_TOKEN', github_pat, save=False)
def _print_config_status(self):
"""Print configuration load status"""
loaded_keys = []
for key, value in self.config.items():
if value and str(value).strip():
# Don't show actual secret values
if key in SettingsManager.SECRET_KEYS:
loaded_keys.append(f"{key}: loaded")
else:
loaded_keys.append(f"{key}: loaded")
if loaded_keys:
print(f"Configuration status: {', '.join(loaded_keys)}")
else:
print("No configuration values loaded - using defaults")
def load_configuration(self) -> Dict[str, Any]:
"""
Load configuration from new system (config.json + keyring).
Returns:
Dictionary of all settings
"""
self.config = self._settings.load()
self._apply_token_defaults()
return self.config
def save_configuration(self, config_values: Dict[str, Any]) -> bool:
"""
Save configuration using new system.
No restart required - changes apply immediately!
Args:
config_values: Settings to save
Returns:
True if successful
"""
# Save using new system
success = self._settings.save(config_values)
if success:
# Reload to get updated values
self.config = self._settings.get_all()
self._apply_token_defaults()
print(f"Configuration saved to {self._settings.config_file}")
print("Settings updated (no restart needed!)")
else:
print("Failed to save configuration")
return success
def get_config(self) -> Dict[str, Any]:
"""
Get current configuration with automatic GITHUB_TOKEN defaulting.
Returns:
Dictionary of all settings
"""
config = self.config.copy()
# Auto-default GITHUB_TOKEN to GITHUB_PAT if needed
github_token = config.get('GITHUB_TOKEN', '').strip() if config.get('GITHUB_TOKEN') else ''
github_pat = config.get('GITHUB_PAT', '').strip() if config.get('GITHUB_PAT') else ''
if not github_token and github_pat:
config['GITHUB_TOKEN'] = github_pat
return config
def get_value(self, key: str, default: Any = None) -> Any:
"""
Get a specific configuration value.
Args:
key: Setting key
default: Default value if not found
Returns:
Setting value or default
"""
return self._settings.get(key, default)
def get(self, key: str, default: Any = None) -> Any:
"""
Get a specific configuration value (dictionary-like interface).
Args:
key: Setting key
default: Default value if not found
Returns:
Setting value or default
"""
return self._settings.get(key, default)
def set_value(self, key: str, value: Any) -> None:
"""
Set a specific configuration value.
Args:
key: Setting key
value: New value
"""
self._settings.set(key, value)
self.config[key] = value
def register_listener(self, callback):
"""
Register a callback for settings changes (live updates).
The callback will be called with (key, new_value) when a setting changes.
Args:
callback: Function to call on settings change
Example:
def on_settings_changed(key, value):
if key == 'THEME_MODE':
# Update theme immediately
page.theme_mode = ft.ThemeMode.DARK if value == 'dark' else ft.ThemeMode.LIGHT
page.update()
config_manager.register_listener(on_settings_changed)
"""
self._settings.register_listener(callback)
def unregister_listener(self, callback):
"""
Unregister a settings change callback.
Args:
callback: Function to remove from listeners
"""
self._settings.unregister_listener(callback)
# Legacy methods for PR counter (unchanged)
def get_pr_counter_file(self) -> str:
"""Get the path to the PR counter file"""
script_dir = os.path.dirname(os.path.abspath(__file__))
return os.path.join(script_dir, '..', '.pr_counter.json')
def load_pr_counter(self) -> Dict[str, int]:
"""Load the PR counter from file"""
counter_file = self.get_pr_counter_file()
if os.path.exists(counter_file):
try:
with open(counter_file, 'r', encoding='utf-8') as f:
return json.load(f)
except (json.JSONDecodeError, FileNotFoundError):
pass
return {'count': 0}
def save_pr_counter(self, counter: Dict[str, int]) -> bool:
"""Save the PR counter to file"""
counter_file = self.get_pr_counter_file()
try:
with open(counter_file, 'w', encoding='utf-8') as f:
json.dump(counter, f, indent=2)
return True
except Exception as e:
print(f"Error saving PR counter: {e}")
return False
def increment_pr_counter(self) -> int:
"""Increment and return the PR counter"""
counter = self.load_pr_counter()
counter['count'] = counter.get('count', 0) + 1
self.save_pr_counter(counter)
return counter['count']
def get_pr_counter(self) -> int:
"""Get the current PR counter value"""
counter = self.load_pr_counter()
return counter.get('count', 0)
src/app_components/main_gui.py
-3123
View File
File diff suppressed because it is too large Load Diff
src/app_components/processing_log_dialog.py
-125
View File
@@ -1,125 +0,0 @@
"""
Processing Log Dialog
Displays the processing log in a separate dialog window
"""
import flet as ft
# Compatibility fix for Flet 0.28+ (Icons vs icons, Colors vs colors)
ft.icons = ft.Icons
ft.colors = ft.Colors
class ProcessingLogDialog:
"""Processing log display dialog"""
def __init__(self, page: ft.Page, log_text_ref: ft.Ref):
self.page = page
self.log_text_ref = log_text_ref
self.dialog_ref = ft.Ref[ft.AlertDialog]()
self.log_display_ref = ft.Ref[ft.TextField]()
def show(self):
"""Show the processing log dialog"""
try:
print("ProcessingLogDialog.show() called")
# Create the dialog
dialog = self._create_dialog()
self.dialog_ref.current = dialog
# Sync the log content before showing
self._sync_log_content()
# Open the dialog
self.page.open(dialog)
self.page.update()
except Exception as ex:
print(f"Error in ProcessingLogDialog.show(): {ex}")
import traceback
traceback.print_exc()
def _sync_log_content(self):
"""Sync log content from main log to dialog display"""
if self.log_text_ref.current and self.log_display_ref.current:
self.log_display_ref.current.value = self.log_text_ref.current.value
if self.page:
self.page.update()
def _create_dialog(self) -> ft.AlertDialog:
"""Create the processing log dialog"""
# Create a display field that will show a copy of the log
# This is synced from the main log field
log_display = ft.TextField(
ref=self.log_display_ref,
value=self.log_text_ref.current.value if self.log_text_ref.current else "",
multiline=True,
read_only=True,
expand=True,
text_style=ft.TextStyle(font_family="Courier New"),
min_lines=20,
max_lines=30,
)
# Refresh button
refresh_button = ft.TextButton(
"Refresh",
icon=ft.icons.REFRESH,
on_click=self._refresh_log,
)
# Clear button
clear_button = ft.TextButton(
"Clear Log",
icon=ft.icons.DELETE_OUTLINE,
on_click=self._clear_log,
)
# Close button
close_button = ft.TextButton(
"Close",
on_click=self._close_clicked,
)
dialog = ft.AlertDialog(
ref=self.dialog_ref,
modal=True,
title=ft.Row(
[
ft.Icon(ft.icons.LIST_ALT, color="blue"),
ft.Text("Processing Log", size=20, weight=ft.FontWeight.BOLD),
],
alignment=ft.MainAxisAlignment.START,
),
content=ft.Container(
content=log_display,
width=800,
height=500,
),
actions=[
refresh_button,
clear_button,
close_button,
],
actions_alignment=ft.MainAxisAlignment.SPACE_BETWEEN,
)
return dialog
def _refresh_log(self, e):
"""Refresh the log content from the main log"""
self._sync_log_content()
def _clear_log(self, e):
"""Clear the log"""
# Clear both the main log and the display
if self.log_text_ref.current:
self.log_text_ref.current.value = ""
if self.log_display_ref.current:
self.log_display_ref.current.value = ""
self.page.update()
def _close_clicked(self, e):
"""Handle close button click"""
if self.dialog_ref.current:
self.page.close(self.dialog_ref.current)
src/app_components/settings_dialog.py
-1150
View File
File diff suppressed because it is too large Load Diff
src/app_components/settings_manager.py
-307
View File
@@ -1,307 +0,0 @@
"""
Settings Manager
Handles application settings with live updates and secure storage.
Non-secret settings are stored in config.json.
Secrets (API keys, tokens) are stored in the system keyring.
"""
import json
import os
from pathlib import Path
from typing import Dict, Any, Optional, Callable
import keyring
class SettingsManager:
"""
Manages application settings with live updates.
Features:
- Non-secret settings stored in JSON
- API keys stored securely in system keyring
- Live update notifications to registered listeners
- No app restart required for changes
"""
# Keyring service name for this app
SERVICE_NAME = "GitHubPulse"
# Keys that should be stored in keyring (secrets)
SECRET_KEYS = {
'GITHUB_PAT',
'ANTHROPIC_API_KEY',
'OPENAI_API_KEY',
'GITHUB_COPILOT_TOKEN',
'CLAUDE_API_KEY', # Alternative name for Anthropic
'GITHUB_TOKEN', # For GitHub Copilot
'OLLAMA_API_KEY', # Optional Ollama API key
}
# Default settings (non-secrets)
DEFAULT_SETTINGS = {
# GitHub Configuration
'GITHUB_REPO': '',
'FORKED_REPO': '',
'LOCAL_REPO_PATH': '',
# Application Settings
'AI_PROVIDER': 'none',
'DRY_RUN': 'false',
'DEFAULT_BRANCH': 'main',
'THEME_MODE': 'dark',
'AUTO_REFRESH': 'true',
'REFRESH_INTERVAL': '300',
# Ollama Configuration
'OLLAMA_URL': '',
'OLLAMA_MODEL': '',
# Custom AI Instructions
'CUSTOM_INSTRUCTIONS': '',
}
def __init__(self, config_dir: Optional[Path] = None):
"""
Initialize the settings manager.
Args:
config_dir: Directory to store config.json. Defaults to app directory.
"""
# Determine config directory
if config_dir is None:
# Use app directory
config_dir = Path(__file__).parent.parent
self.config_dir = Path(config_dir)
self.config_file = self.config_dir / "config.json"
# Settings storage
self._settings: Dict[str, Any] = {}
# Registered change listeners
self._listeners: list[Callable[[str, Any], None]] = []
# Load settings
self.load()
def load(self) -> Dict[str, Any]:
"""
Load settings from config.json and keyring.
Returns:
Dictionary of all settings (secrets and non-secrets combined)
"""
# Start with defaults
self._settings = self.DEFAULT_SETTINGS.copy()
# Load from JSON file
if self.config_file.exists():
try:
with open(self.config_file, 'r') as f:
saved_settings = json.load(f)
# Only load non-secret settings from JSON
for key, value in saved_settings.items():
if key not in self.SECRET_KEYS:
self._settings[key] = value
except Exception as e:
print(f"Error loading config.json: {e}")
# Load secrets from keyring
for secret_key in self.SECRET_KEYS:
try:
value = keyring.get_password(self.SERVICE_NAME, secret_key)
if value:
self._settings[secret_key] = value
except Exception as e:
print(f"Error loading {secret_key} from keyring: {e}")
return self._settings.copy()
def save(self, settings: Optional[Dict[str, Any]] = None) -> bool:
"""
Save settings to config.json and keyring.
Args:
settings: Settings to save. If None, saves current settings.
Returns:
True if successful, False otherwise
"""
if settings is not None:
# Update internal settings
for key, value in settings.items():
old_value = self._settings.get(key)
self._settings[key] = value
# Notify listeners of changes
if old_value != value:
self._notify_change(key, value)
try:
# Save non-secrets to JSON
json_settings = {
key: value for key, value in self._settings.items()
if key not in self.SECRET_KEYS
}
with open(self.config_file, 'w') as f:
json.dump(json_settings, f, indent=2)
# Save secrets to keyring
for secret_key in self.SECRET_KEYS:
if secret_key in self._settings:
value = self._settings[secret_key]
if value: # Only save non-empty values
try:
keyring.set_password(self.SERVICE_NAME, secret_key, str(value))
except Exception as e:
print(f"Error saving {secret_key} to keyring: {e}")
return True
except Exception as e:
print(f"Error saving settings: {e}")
return False
def get(self, key: str, default: Any = None) -> Any:
"""
Get a setting value.
Args:
key: Setting key
default: Default value if key doesn't exist
Returns:
Setting value or default
"""
return self._settings.get(key, default)
def set(self, key: str, value: Any, save: bool = True) -> bool:
"""
Set a setting value with live update.
Args:
key: Setting key
value: New value
save: Whether to persist immediately
Returns:
True if successful
"""
old_value = self._settings.get(key)
self._settings[key] = value
# Notify listeners
if old_value != value:
self._notify_change(key, value)
# Save if requested
if save:
return self.save()
return True
def get_all(self) -> Dict[str, Any]:
"""
Get all settings.
Returns:
Dictionary of all settings
"""
return self._settings.copy()
def register_listener(self, callback: Callable[[str, Any], None]):
"""
Register a callback to be notified of setting changes.
The callback will be called with (key, new_value) when a setting changes.
Args:
callback: Function to call on settings change
"""
if callback not in self._listeners:
self._listeners.append(callback)
def unregister_listener(self, callback: Callable[[str, Any], None]):
"""
Unregister a settings change callback.
Args:
callback: Function to remove from listeners
"""
if callback in self._listeners:
self._listeners.remove(callback)
def _notify_change(self, key: str, value: Any):
"""
Notify all registered listeners of a setting change.
Args:
key: Setting key that changed
value: New value
"""
for listener in self._listeners:
try:
listener(key, value)
except Exception as e:
print(f"Error notifying listener of {key} change: {e}")
def delete_secret(self, key: str) -> bool:
"""
Delete a secret from the keyring.
Args:
key: Secret key to delete
Returns:
True if successful
"""
if key not in self.SECRET_KEYS:
return False
try:
keyring.delete_password(self.SERVICE_NAME, key)
if key in self._settings:
del self._settings[key]
self._notify_change(key, None)
return True
except Exception as e:
print(f"Error deleting {key} from keyring: {e}")
return False
def migrate_from_env(self, env_file: Path) -> bool:
"""
Migrate settings from a .env file to the new system.
Args:
env_file: Path to .env file
Returns:
True if migration successful
"""
if not env_file.exists():
print(f"Env file not found: {env_file}")
return False
try:
# Read .env file
env_settings = {}
with open(env_file, 'r') as f:
for line in f:
line = line.strip()
if line and not line.startswith('#'):
if '=' in line:
key, value = line.split('=', 1)
key = key.strip()
value = value.strip().strip('"').strip("'")
env_settings[key] = value
# Save to new system
self.save(env_settings)
print(f"Successfully migrated {len(env_settings)} settings from .env")
return True
except Exception as e:
print(f"Error migrating from .env: {e}")
return False
src/app_components/workflow.py
-653
View File
@@ -1,653 +0,0 @@
"""
Workflow Manager
Manages GitHub workflow items (Issues and Pull Requests) from target and fork repositories
"""
import requests
from typing import List, Dict, Any, Optional, Tuple
class WorkflowItem:
"""Represents a GitHub workflow item (Issue or PR)"""
def __init__(self, item_type: str, data: Dict[str, Any], repo_source: str):
"""
Initialize a workflow item
Args:
item_type: 'issue' or 'pull_request'
data: Raw data from GitHub API
repo_source: 'target' or 'fork'
"""
self.item_type = item_type
self.repo_source = repo_source
self.data = data
# Extract common fields
self.number = data.get('number')
self.title = data.get('title', 'No Title')
self.state = data.get('state', 'unknown')
self.created_at = data.get('created_at', '')
self.updated_at = data.get('updated_at', '')
self.body = data.get('body', '')
self.url = data.get('html_url', '')
self.api_url = data.get('url', '')
# Author information
user = data.get('user', {})
self.author = user.get('login', 'unknown') if user else 'unknown'
self.author_url = user.get('html_url', '') if user else ''
# Labels
self.labels = [label.get('name', '') for label in data.get('labels', [])]
# Assignees
assignees = data.get('assignees', [])
self.assignees = [a.get('login', '') for a in assignees if a]
# PR-specific fields
if item_type == 'pull_request':
self.is_draft = data.get('draft', False)
self.mergeable_state = data.get('mergeable_state', 'unknown')
self.merged = data.get('merged', False)
self.base_ref = data.get('base', {}).get('ref', '')
self.head_ref = data.get('head', {}).get('ref', '')
else:
self.is_draft = False
self.mergeable_state = None
self.merged = False
self.base_ref = None
self.head_ref = None
# Comments count
self.comments_count = data.get('comments', 0)
def __repr__(self):
return f"<WorkflowItem {self.item_type} #{self.number}: {self.title[:50]}>"
def to_dict(self) -> Dict[str, Any]:
"""Convert to dictionary for easy serialization"""
return {
'item_type': self.item_type,
'repo_source': self.repo_source,
'data': self.data, # Include raw data for full reconstruction
'number': self.number,
'title': self.title,
'state': self.state,
'created_at': self.created_at,
'updated_at': self.updated_at,
'body': self.body,
'url': self.url,
'api_url': self.api_url,
'author': self.author,
'author_url': self.author_url,
'labels': self.labels,
'assignees': self.assignees,
'is_draft': self.is_draft,
'mergeable_state': self.mergeable_state,
'merged': self.merged,
'base_ref': self.base_ref,
'head_ref': self.head_ref,
'comments_count': self.comments_count
}
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> 'WorkflowItem':
"""Create WorkflowItem from dictionary (for cache deserialization)"""
# Extract the raw GitHub API data if available, otherwise use the dict itself
raw_data = data.get('data', data)
item_type = data.get('item_type', 'issue')
repo_source = data.get('repo_source', 'target')
return cls(item_type, raw_data, repo_source)
class GitHubRepoFetcher:
"""Fetches repository information from GitHub"""
def __init__(self, github_token: str, logger=None):
"""
Initialize the repo fetcher
Args:
github_token: GitHub Personal Access Token
logger: Optional logger instance
"""
self.token = github_token
self.logger = logger
self.headers = {
"Authorization": f"Bearer {github_token}",
"Accept": "application/vnd.github+json",
"User-Agent": "github-automation-tool/1.0"
}
def log(self, message: str):
"""Log a message"""
if self.logger:
self.logger.log(message)
else:
print(message)
def get_authenticated_user(self) -> Optional[Dict[str, Any]]:
"""
Get information about the authenticated user
Returns:
Dictionary with user information or None if error
"""
try:
url = "https://api.github.com/user"
response = requests.get(url, headers=self.headers, timeout=30)
response.raise_for_status()
return response.json()
except Exception as e:
self.log(f"❌ Error fetching authenticated user: {str(e)}")
return None
def fetch_user_repos(self, repo_type: str = 'owner', per_page: int = 100) -> List[Dict[str, Any]]:
"""
Fetch repositories for the authenticated user
Args:
repo_type: 'owner', 'member', or 'all'
per_page: Number of repos per page (max 100)
Returns:
List of repository dictionaries
"""
try:
url = "https://api.github.com/user/repos"
params = {
'type': repo_type,
'per_page': min(per_page, 100),
'sort': 'updated',
'direction': 'desc'
}
response = requests.get(url, headers=self.headers, params=params, timeout=30)
response.raise_for_status()
repos = response.json()
self.log(f"✅ Found {len(repos)} repositories ({repo_type})")
return repos
except Exception as e:
self.log(f"❌ Error fetching user repos: {str(e)}")
return []
def fetch_repos_with_permissions(self, min_permission: str = 'push') -> List[Dict[str, Any]]:
"""
Fetch repositories where user has specific permissions
Args:
min_permission: Minimum permission level ('pull', 'push', 'admin')
Returns:
List of repository dictionaries with sufficient permissions
"""
try:
# Fetch all repos user has access to
all_repos = self.fetch_user_repos(repo_type='all')
# Filter by permission level
filtered_repos = []
permission_levels = {'pull': 0, 'push': 1, 'admin': 2}
min_level = permission_levels.get(min_permission, 1)
for repo in all_repos:
permissions = repo.get('permissions', {})
# Check permission level
if permissions.get('admin'):
level = 2
elif permissions.get('push'):
level = 1
elif permissions.get('pull'):
level = 0
else:
level = -1
if level >= min_level:
filtered_repos.append(repo)
self.log(f"✅ Found {len(filtered_repos)} repos with '{min_permission}' permission or higher")
return filtered_repos
except Exception as e:
self.log(f"❌ Error fetching repos with permissions: {str(e)}")
return []
def search_repositories(self, query: str, per_page: int = 30) -> List[Dict[str, Any]]:
"""
Search for repositories on GitHub
Args:
query: Search query string
per_page: Number of results per page (max 100)
Returns:
List of repository dictionaries
"""
if not query or not query.strip():
return []
try:
url = "https://api.github.com/search/repositories"
params = {
'q': query.strip(),
'per_page': min(per_page, 100),
'sort': 'updated',
'order': 'desc'
}
response = requests.get(url, headers=self.headers, params=params, timeout=30)
response.raise_for_status()
data = response.json()
repos = data.get('items', [])
total_count = data.get('total_count', 0)
self.log(f"✅ Search found {total_count} repositories (showing {len(repos)})")
return repos
except Exception as e:
self.log(f"❌ Error searching repositories: {str(e)}")
return []
def get_repo_names(self, repos: List[Dict[str, Any]]) -> List[str]:
"""
Extract repository names in 'owner/repo' format
Args:
repos: List of repository dictionaries
Returns:
List of repository name strings
"""
return [repo.get('full_name', '') for repo in repos if repo.get('full_name')]
class WorkflowManager:
"""Manages workflow items from GitHub repositories"""
def __init__(self, github_token: str, logger=None):
"""
Initialize the workflow manager
Args:
github_token: GitHub Personal Access Token
logger: Optional logger instance
"""
self.token = github_token
self.logger = logger
self.headers = {
"Authorization": f"Bearer {github_token}",
"Accept": "application/vnd.github+json",
"User-Agent": "github-automation-tool/1.0"
}
# Initialize repo fetcher
self.repo_fetcher = GitHubRepoFetcher(github_token, logger)
def log(self, message: str):
"""Log a message"""
if self.logger:
self.logger.log(message)
else:
print(message)
def _parse_repo(self, repo_str: str) -> Optional[Tuple[str, str]]:
"""
Parse a repository string into owner and name
Args:
repo_str: Repository string in format "owner/repo"
Returns:
Tuple of (owner, repo) or None if invalid
"""
if not repo_str or '/' not in repo_str:
return None
parts = repo_str.strip().split('/')
if len(parts) != 2:
return None
return parts[0], parts[1]
def fetch_issues(self, repo_str: str, repo_source: str = 'target',
state: str = 'all', per_page: int = 100) -> List[WorkflowItem]:
"""
Fetch issues from a repository
Args:
repo_str: Repository string in format "owner/repo"
repo_source: 'target' or 'fork' to identify source
state: 'open', 'closed', or 'all'
per_page: Number of items per page (max 100)
Returns:
List of WorkflowItem objects
"""
parsed = self._parse_repo(repo_str)
if not parsed:
self.log(f"L Invalid repository format: {repo_str}")
return []
owner, repo = parsed
self.log(f"Fetching issues from {owner}/{repo} ({repo_source})...")
try:
url = f"https://api.github.com/repos/{owner}/{repo}/issues"
params = {
'state': state,
'per_page': min(per_page, 100),
'sort': 'updated',
'direction': 'desc'
}
response = requests.get(url, headers=self.headers, params=params, timeout=30)
response.raise_for_status()
items_data = response.json()
# Filter out pull requests (GitHub's issues endpoint includes PRs)
issues_data = [item for item in items_data if 'pull_request' not in item]
issues = [WorkflowItem('issue', data, repo_source) for data in issues_data]
self.log(f" Found {len(issues)} issues in {owner}/{repo}")
return issues
except requests.HTTPError as e:
self.log(f"L HTTP Error fetching issues from {owner}/{repo}: {e}")
if e.response.status_code == 401:
self.log(" Check your GitHub Personal Access Token")
elif e.response.status_code == 404:
self.log(" Repository not found or no access")
return []
except Exception as e:
self.log(f"L Error fetching issues from {owner}/{repo}: {str(e)}")
return []
def fetch_pull_requests(self, repo_str: str, repo_source: str = 'target',
state: str = 'all', per_page: int = 100) -> List[WorkflowItem]:
"""
Fetch pull requests from a repository
Args:
repo_str: Repository string in format "owner/repo"
repo_source: 'target' or 'fork' to identify source
state: 'open', 'closed', or 'all'
per_page: Number of items per page (max 100)
Returns:
List of WorkflowItem objects
"""
parsed = self._parse_repo(repo_str)
if not parsed:
self.log(f"L Invalid repository format: {repo_str}")
return []
owner, repo = parsed
self.log(f"Fetching pull requests from {owner}/{repo} ({repo_source})...")
try:
url = f"https://api.github.com/repos/{owner}/{repo}/pulls"
params = {
'state': state,
'per_page': min(per_page, 100),
'sort': 'updated',
'direction': 'desc'
}
response = requests.get(url, headers=self.headers, params=params, timeout=30)
response.raise_for_status()
prs_data = response.json()
prs = [WorkflowItem('pull_request', data, repo_source) for data in prs_data]
self.log(f" Found {len(prs)} pull requests in {owner}/{repo}")
return prs
except requests.HTTPError as e:
self.log(f"L HTTP Error fetching PRs from {owner}/{repo}: {e}")
if e.response.status_code == 401:
self.log(" Check your GitHub Personal Access Token")
elif e.response.status_code == 404:
self.log(" Repository not found or no access")
return []
except Exception as e:
self.log(f"L Error fetching PRs from {owner}/{repo}: {str(e)}")
return []
def fetch_all_workflow_items(self, target_repo: str, fork_repo: str = None,
include_issues: bool = True,
include_prs: bool = True,
state: str = 'all') -> Dict[str, List[WorkflowItem]]:
"""
Fetch all workflow items from both target and fork repositories
Args:
target_repo: Target repository string "owner/repo"
fork_repo: Fork repository string "owner/repo" (optional)
include_issues: Whether to fetch issues
include_prs: Whether to fetch pull requests
state: 'open', 'closed', or 'all'
Returns:
Dictionary with keys 'target_issues', 'target_prs', 'fork_issues', 'fork_prs'
"""
results = {
'target_issues': [],
'target_prs': [],
'fork_issues': [],
'fork_prs': []
}
# Fetch from target repository
if target_repo:
if include_issues:
results['target_issues'] = self.fetch_issues(target_repo, 'target', state)
if include_prs:
results['target_prs'] = self.fetch_pull_requests(target_repo, 'target', state)
# Fetch from fork repository
if fork_repo:
if include_issues:
results['fork_issues'] = self.fetch_issues(fork_repo, 'fork', state)
if include_prs:
results['fork_prs'] = self.fetch_pull_requests(fork_repo, 'fork', state)
# Log summary
total = sum(len(items) for items in results.values())
self.log(f"\n=� Summary: Fetched {total} total items")
self.log(f" Target Issues: {len(results['target_issues'])}")
self.log(f" Target PRs: {len(results['target_prs'])}")
if fork_repo:
self.log(f" Fork Issues: {len(results['fork_issues'])}")
self.log(f" Fork PRs: {len(results['fork_prs'])}")
return results
def get_combined_items(self, workflow_items: Dict[str, List[WorkflowItem]],
sort_by: str = 'updated') -> List[WorkflowItem]:
"""
Combine and sort all workflow items
Args:
workflow_items: Dictionary from fetch_all_workflow_items()
sort_by: 'updated', 'created', or 'number'
Returns:
Sorted list of all workflow items
"""
all_items = []
for items_list in workflow_items.values():
all_items.extend(items_list)
# Sort items
if sort_by == 'updated':
all_items.sort(key=lambda x: x.updated_at, reverse=True)
elif sort_by == 'created':
all_items.sort(key=lambda x: x.created_at, reverse=True)
elif sort_by == 'number':
all_items.sort(key=lambda x: x.number, reverse=True)
return all_items
def filter_items(self, items: List[WorkflowItem], **filters) -> List[WorkflowItem]:
"""
Filter workflow items based on criteria
Args:
items: List of WorkflowItem objects
**filters: Filter criteria (state, item_type, repo_source, author, labels)
Returns:
Filtered list of items
"""
filtered = items
if 'state' in filters and filters['state']:
filtered = [item for item in filtered if item.state == filters['state']]
if 'item_type' in filters and filters['item_type']:
filtered = [item for item in filtered if item.item_type == filters['item_type']]
if 'repo_source' in filters and filters['repo_source']:
filtered = [item for item in filtered if item.repo_source == filters['repo_source']]
if 'author' in filters and filters['author']:
filtered = [item for item in filtered if item.author == filters['author']]
if 'labels' in filters and filters['labels']:
label_filter = filters['labels']
if isinstance(label_filter, str):
label_filter = [label_filter]
filtered = [item for item in filtered
if any(label in item.labels for label in label_filter)]
return filtered
def fetch_comments(self, repo_str: str, issue_number: int, is_pull_request: bool = False) -> List[Dict[str, Any]]:
"""
Fetch comments for an issue or pull request
Args:
repo_str: Repository string in format "owner/repo"
issue_number: Issue or PR number
is_pull_request: Whether this is a pull request (for PR-specific comments)
Returns:
List of comment dictionaries with keys: 'user', 'body', 'created_at', 'updated_at'
"""
try:
# Parse repository string
if '/' not in repo_str:
self.log(f"Invalid repository format: {repo_str}")
return []
owner, repo = repo_str.split('/', 1)
# Fetch issue/PR comments (these are the same endpoint for both issues and PRs)
url = f"https://api.github.com/repos/{owner}/{repo}/issues/{issue_number}/comments"
print(f"DEBUG: Fetching comments from URL: {url}", flush=True)
response = requests.get(url, headers=self.headers)
print(f"DEBUG: Response status code: {response.status_code}", flush=True)
print(f"DEBUG: Response headers: {dict(response.headers)}", flush=True)
print(f"DEBUG: Response text length: {len(response.text)}", flush=True)
print(f"DEBUG: Response content (first 500): {response.text[:500]}", flush=True)
response.raise_for_status()
response_data = response.json()
print(f"DEBUG: Response data type: {type(response_data)}", flush=True)
print(f"DEBUG: Number of items: {len(response_data) if isinstance(response_data, list) else 'Not a list'}", flush=True)
if isinstance(response_data, list) and len(response_data) > 0:
print(f"DEBUG: First item keys: {list(response_data[0].keys())}", flush=True)
comments = []
for comment_data in response_data:
comments.append({
'user': comment_data.get('user', {}).get('login', 'unknown'),
'body': comment_data.get('body', ''),
'created_at': comment_data.get('created_at', ''),
'updated_at': comment_data.get('updated_at', ''),
'url': comment_data.get('html_url', '')
})
self.log(f"Fetched {len(comments)} comments for {repo_str} #{issue_number}")
print(f"DEBUG: Successfully parsed {len(comments)} comments", flush=True)
return comments
except requests.exceptions.RequestException as e:
self.log(f"Error fetching comments for {repo_str} #{issue_number}: {e}")
print(f"DEBUG: RequestException occurred: {e}", flush=True)
import traceback
traceback.print_exc()
return []
except Exception as e:
self.log(f"Unexpected error fetching comments: {e}")
print(f"DEBUG: Exception occurred: {e}", flush=True)
import traceback
traceback.print_exc()
return []
def fetch_pr_files(self, repo_str: str, pr_number: int) -> List[Dict[str, Any]]:
"""
Fetch the list of files changed in a pull request
Args:
repo_str: Repository string in format "owner/repo"
pr_number: Pull request number
Returns:
List of file dictionaries with keys: 'filename', 'status', 'additions', 'deletions', 'changes', 'patch'
"""
try:
# Parse repository string
if '/' not in repo_str:
self.log(f"Invalid repository format: {repo_str}")
return []
owner, repo = repo_str.split('/', 1)
# Fetch PR files
url = f"https://api.github.com/repos/{owner}/{repo}/pulls/{pr_number}/files"
print(f"DEBUG: Fetching PR files from URL: {url}", flush=True)
response = requests.get(url, headers=self.headers)
response.raise_for_status()
files_data = response.json()
print(f"DEBUG: Found {len(files_data)} files in PR #{pr_number}", flush=True)
files = []
for file_data in files_data:
files.append({
'filename': file_data.get('filename', ''),
'status': file_data.get('status', ''), # added, removed, modified, renamed
'additions': file_data.get('additions', 0),
'deletions': file_data.get('deletions', 0),
'changes': file_data.get('changes', 0),
'patch': file_data.get('patch', ''), # The actual diff patch
'blob_url': file_data.get('blob_url', ''),
})
self.log(f"Fetched {len(files)} files for PR {repo_str} #{pr_number}")
return files
except requests.exceptions.RequestException as e:
self.log(f"Error fetching PR files for {repo_str} #{pr_number}: {e}")
print(f"DEBUG: RequestException occurred: {e}", flush=True)
import traceback
traceback.print_exc()
return []
except Exception as e:
self.log(f"Unexpected error fetching PR files: {e}")
print(f"DEBUG: Exception occurred: {e}", flush=True)
import traceback
traceback.print_exc()
return []
src/assets/icon.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 25 KiB

src/assets/splash_android.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 25 KiB

src/main.py
-218
View File
@@ -1,218 +0,0 @@
"""
GitHub Pulse
Main application entry point
This application provides GitHub automation workflows with AI assistance.
Note: You may see a Flutter engine warning when closing the app:
"embedder.cc (2519): 'FlutterEngineRemoveView' returned 'kInvalidArguments'"
This is a harmless known issue with Flet/Flutter and can be safely ignored.
"""
import sys
import os
import flet as ft
# Compatibility fix for Flet 0.28+ (Icons vs icons, Colors vs colors)
ft.icons = ft.Icons
ft.colors = ft.Colors
# Import our modular components
try:
from app_components.config_manager import ConfigManager
from app_components.ai_manager import AIManager
from app_components.github_api import GitHubAPI
from app_components.main_gui import MainGUI
except ImportError as e:
print(f"Error importing application components: {e}")
print("Make sure all files are present in the app_components folder")
# In production builds, show a user-friendly error
if getattr(sys, 'frozen', False):
import traceback
error_details = traceback.format_exc()
print(error_details)
sys.exit(1)
class GitHubAutomationApp:
"""Main application class that orchestrates all components"""
def __init__(self, page: ft.Page):
"""Initialize the application"""
self.page = page
# Configure page
self.page.title = "GitHub Pulse"
self.page.theme_mode = ft.ThemeMode.DARK
self.page.padding = 0
# Set window size with platform detection
# Mobile devices will use full screen
is_mobile = page.web or (hasattr(page, 'platform') and
page.platform in ['android', 'ios'])
if not is_mobile:
self.page.window_width = 1400
self.page.window_height = 1000
self.page.window_min_width = 1200
self.page.window_min_height = 800
# Material Design 3 theme with optimized settings
self.page.theme = ft.Theme(
color_scheme_seed="blue",
use_material3=True,
)
# Initialize core managers
self.config_manager = ConfigManager()
self.ai_manager = AIManager()
# Load configuration
self.config = self.config_manager.load_configuration()
# Initialize dry run state
dry_run_config = self.config.get('DRY_RUN', 'false')
self.dry_run_enabled = str(dry_run_config).lower() in ('true', '1', 'yes', 'on')
# Register listener for live settings updates
self.config_manager.register_listener(self._on_setting_changed)
# Initialize main GUI
self.main_gui = MainGUI(
page=self.page,
config_manager=self.config_manager,
ai_manager=self.ai_manager,
app=self
)
# Build UI
self.page.add(self.main_gui.build())
# Check AI provider setup after a short delay
self.page.run_task(self._check_ai_provider_setup_async)
async def _check_ai_provider_setup_async(self):
"""Check and setup AI providers after GUI initialization"""
try:
# Wait a bit for GUI to fully load
import asyncio
await asyncio.sleep(0.5)
ai_provider = self.config.get('AI_PROVIDER', '').strip().lower()
if not ai_provider or ai_provider in ['none', '']:
return # No AI provider selected
if ai_provider not in ['chatgpt', 'claude', 'anthropic', 'github-copilot', 'copilot', 'github_copilot']:
return # Unknown provider
# Check if modules are available and offer installation if needed
await self.ai_manager.check_and_install_ai_modules_async(ai_provider, self.page)
except Exception as e:
print(f"Error checking AI provider setup: {e}")
def get_config(self):
"""Get current configuration"""
return self.config.copy()
def update_config(self, new_config):
"""Update configuration"""
self.config.update(new_config)
self.config_manager.config = self.config.copy()
def save_config(self, config_values):
"""Save configuration"""
success = self.config_manager.save_configuration(config_values)
if success:
self.config = self.config_manager.get_config()
# Update dry run state
dry_run_config = self.config.get('DRY_RUN', 'false')
self.dry_run_enabled = str(dry_run_config).lower() in ('true', '1', 'yes', 'on')
return success
def create_github_api(self, token=None, dry_run=None):
"""Create a GitHub API instance"""
if token is None:
token = self.config.get('GITHUB_PAT', '')
if dry_run is None:
dry_run = self.dry_run_enabled
logger = self.main_gui.logger if hasattr(self.main_gui, 'logger') else None
return GitHubAPI(token, logger, dry_run)
def _on_setting_changed(self, key: str, value: any):
"""
Handle settings changes with live updates (no restart needed!)
Args:
key: Setting key that changed
value: New value
"""
print(f"⚡ Setting changed: {key} = {value}")
# Theme changes - apply immediately
if key == 'THEME_MODE':
if value == 'dark':
self.page.theme_mode = ft.ThemeMode.DARK
elif value == 'light':
self.page.theme_mode = ft.ThemeMode.LIGHT
self.page.update()
print(f"✓ Theme updated to {value}")
# Dry run mode changes
elif key == 'DRY_RUN':
self.dry_run_enabled = str(value).lower() in ('true', '1', 'yes', 'on')
print(f"✓ Dry run mode: {self.dry_run_enabled}")
# GitHub token changes - reinitialize API
elif key == 'GITHUB_PAT':
if hasattr(self, 'main_gui') and self.main_gui:
print("✓ GitHub token updated - API will be reinitialized on next use")
# AI provider changes
elif key == 'AI_PROVIDER':
print(f"✓ AI provider changed to: {value}")
# AI manager will use new provider on next request
# Update internal config
self.config[key] = value
async def main(page: ft.Page):
"""Main entry point for Flet application"""
try:
app = GitHubAutomationApp(page)
except Exception as e:
# Show error as a simple text on the page since dialog can't open before page init
print(f"Failed to start application: {e}")
import traceback
traceback.print_exc()
# Add error message to page
error_text = ft.Text(
f"Application Error:\n\n{str(e)}\n\nPlease check the console for details.",
color="red",
size=16,
)
page.add(error_text)
if __name__ == "__main__":
# Run the Flet app with optimized settings
# For production builds, use appropriate view settings
is_production = getattr(sys, 'frozen', False)
if is_production:
# Production build settings
ft.app(
target=main,
view=ft.AppView.FLET_APP, # Native app view for builds
assets_dir="assets" # Ensure assets are loaded correctly
)
else:
# Development settings
ft.app(
target=main,
assets_dir="assets"
)
src/requirements/requirements-ai.txt
-11
View File
@@ -1,11 +0,0 @@
# AI Provider dependencies
# These are optional and only needed if using AI features
# Include base requirements
-r requirements-base.txt
# AI Providers (optional - install only what you need)
openai>=2.8.0 # For ChatGPT integration
anthropic>=0.72.1 # For Claude integration
# Note: Ollama and GitHub Copilot use REST APIs and don't require additional packages
src/requirements/requirements-base.txt
-14
View File
@@ -1,14 +0,0 @@
# Base requirements for all platforms
# Core dependencies required for the application to run
# UI Framework (Flet - Python wrapper for Flutter)
flet==0.28.3
# HTTP requests for API calls
requests>=2.32.5
# Secure credential storage (cross-platform)
keyring>=25.6.0
# Git operations for repository management
GitPython>=3.1.45
src/requirements/requirements-dev.txt
-12
View File
@@ -1,12 +0,0 @@
# Development requirements
# Includes all dependencies for development, testing, and building
# Include AI requirements (which includes base)
-r requirements-ai.txt
# Development tools
flet[all]==0.28.3 # Flet with all development extras
# Build tools (optional)
# pyinstaller>=6.0.0 # Alternative bundler if needed
# cx-Freeze>=6.15.0 # Alternative bundler if needed
src/requirements/requirements.txt
-23
View File
@@ -1,23 +0,0 @@
# GitHub Pulse - Main Requirements File
# This file includes all dependencies needed for production use
# Core dependencies
requests>=2.32.5 # HTTP client for GitHub API and AI providers
keyring>=25.6.0 # Secure credential storage (cross-platform)
GitPython>=3.1.45 # Git operations for repository management
# UI Framework - Flet (Python wrapper for Flutter)
flet==0.28.3 # Pin to specific version for build compatibility
# AI Providers (optional but included for full functionality)
openai>=2.8.0 # ChatGPT/OpenAI API integration
anthropic>=0.72.1 # Claude/Anthropic API integration
# Platform-specific notes:
# - Linux: Requires libgtk-3-dev, clang, cmake, ninja-build
# - Windows: Requires Visual Studio 2016+
# - Android: Requires Android Studio and SDK
# - iOS/macOS: Requires Xcode
# For minimal installation (no AI), use: pip install -r requirements-base.txt
# For development: pip install -r requirements-dev.txt
test.md
+1
View File
@@ -0,0 +1 @@
test