add ai workspace

Author: christso

.cursorrules

@@ -0,0 +1,37 @@
+# RepoDiff Development Guidelines
+
+You are an expert in **Python** and **PyQt** focused on building high-performance, maintainable, and scalable desktop applications.
+
+## Code Structure and Best Practices
+- Use **object-oriented programming (OOP)** principles to structure PyQt applications effectively.
+- Leverage **QMainWindow, QWidget, QDialog** appropriately to organize UI components.
+- Use **PyQt Signals and Slots** for event-driven programming.
+- Prefer **composition over inheritance** for better modularity and reusability.
+- Store UI layouts in **.ui XML files** and load them dynamically with **PyQt’s uic module**.
+- Keep UI definitions (`.ui` files) separate from logic to improve team collaboration.
+
+## Performance and Optimization
+- Minimize **UI redraw events** to avoid unnecessary processing.
+- Use **QThread or QThreadPool** for background tasks to keep the UI responsive.
+- Optimize large table views with **QAbstractTableModel** instead of default models.
+
+## GUI Styling and Responsiveness
+- Use **Qt Style Sheets (QSS)** for flexible UI customization.
+- Implement **adaptive layouts (QVBoxLayout, QHBoxLayout, QGridLayout)** to support different screen sizes.
+- Avoid hardcoded dimensions; use **size policies** instead.
+
+## Code Quality and Maintainability
+- Follow **PEP 8** guidelines for code readability.
+- Use **descriptive method names** that reflect UI behavior (e.g., `on_button_click`, `load_settings`).
+- Implement **logging** using Python’s `logging` module instead of `print` statements.
+- Modularize code into **separate files (e.g., models, views, controllers)**.
+
+## Debugging and Testing
+- Use **QDebug** and **Qt’s logging mechanisms** to track issues.
+- Write **unit tests** with `pytest` and **mock PyQt objects** where necessary.
+- Use **pytest-qt** for UI testing.
+
+## Deployment and Packaging
+- Use **PyInstaller** to bundle the application into an executable.
+- Ensure all **Qt dependencies** are included in the packaging process.
+- Create an **installer** using tools like NSIS or Inno Setup for Windows distributions.

ai-workspace/core/prd.md

@@ -0,0 +1,92 @@
+# Product Requirements Document (PRD) for RepoDiff: Single-Pass Diff + Post-Processing
+
+## 1. Overview
+The goal is to **simplify** RepoDiff by performing a **single** `git diff` command that captures all changed files. Post-processing will then apply user-defined rules (like ignoring bodies of methods far from the changed lines). This approach eliminates the need for multiple Git calls or complex exclude patterns.
+
+## 2. Key Objectives
+1. Generate one **unified diff** that covers all changed files in a **single pass**.  
+2. **Post-process** that diff in Python to apply user-defined patterns, such as:
+   - Number of context lines around changes.
+   - Inclusion of entire files with method body removal outside a specified threshold.
+3. Provide **user-friendly** output. For instance, when removing method bodies, either keep the braces or replace them with a comment so that an LLM or human reviewer knows code is intentionally omitted.
+
+## 3. Example Configuration
+```json
+{
+  "tiktoken_model": "gpt-4o",
+  "filters": [
+    {
+      "file_pattern": "*.cs",
+      "include_entire_file_with_signatures": true,
+      "method_body_threshold": 10
+    },
+    {
+      "file_pattern": "*.py",
+      "context_lines": 5
+    }
+  ]
+}
+```
+
+## 4. Single-Pass Approach
+1. **Collect All Changes**: Perform one `git diff` for the relevant commits or branches, capturing all changed files (e.g., `git diff commit1 commit2 --unified=999999`).
+2. **Parse the Unified Diff**: Use Python to parse each file’s changed lines, hunks, and contextual lines.
+3. **Apply Filters**: For each file, determine which config pattern applies and apply the appropriate rule.
+4. **Finalize Output**: Reconstruct a single unified diff in memory or produce a custom output where method bodies are replaced with `{ ... }`.
+
+## 5. Handling Method Body Removal in C#
+When **`include_entire_file_with_signatures`** is true for a `.cs` file:
+1. **Preserve** the **method signature** (e.g., `public void Foo(int x) { ... }`).
+2. Keep an **opening** and **closing** brace for that method, replacing the body with `{ ... }`.
+
+```csharp
+public void Foo(int x)
+{
+    { ... }
+}
+```
+
+The `{ ... }` placeholder is defined in an **instructional header** at the beginning of the diff output to explain that method bodies were intentionally omitted.
+
+## 6. Additional Instructions in Output
+Include a **header** in the final diff explaining placeholders:
+
+```
+NOTE: Some method bodies have been replaced with "{ ... }" to improve clarity for code reviews and LLM analysis.
+```
+
+## 7. Pseudocode
+```python
+def generate_single_pass_diff(commit1, commit2):
+    cmd = ["git", "diff", commit1, commit2, "--unified=999999", "--ignore-all-space"]
+    return run_command(cmd)
+
+def parse_unified_diff(diff_output):
+    return parse_patch(diff_output)
+
+def post_process_files(patch_dict, config):
+    for filename, hunks in patch_dict.items():
+        rule = find_matching_rule(filename, config['filters'])
+        if rule.get('include_entire_file_with_signatures'):
+            threshold = rule.get('method_body_threshold', 10)
+            patch_dict[filename] = apply_signature_removal(hunks, threshold)
+        else:
+            c = rule.get('context_lines', 3)
+            patch_dict[filename] = apply_context_filter(hunks, c)
+
+def main():
+    config = load_config('config.json')
+    raw_diff = generate_single_pass_diff("commit1", "commit2")
+    patch_dict = parse_unified_diff(raw_diff)
+    post_process_files(patch_dict, config)
+    final_output = reconstruct_patch(patch_dict)
+    add_explanatory_comments(final_output)
+    print(final_output)
+```
+
+## 8. Performance
+- **Single Git Command**: Works efficiently for 20-100 changed files.
+- **In-Memory Post-Processing**: Minimal overhead, simple to maintain.
+
+## 9. Summary
+By **capturing all changes in one pass** and then **applying** user-defined rules in Python, RepoDiff remains simple, fast, and predictable. Including an **instructional header** helps both humans and LLMs understand the placeholders used for omitted code sections.

ai-workspace/ui/prd.md

@@ -0,0 +1,91 @@
+**Product Requirements Document (PRD) for RepoDiff UI (PyQt)**
+
+### 1. Overview
+This PRD outlines the requirements for a **modern, dark-mode enabled UI** for RepoDiff, built using **PyQt**. The UI should provide an intuitive interface for users to configure diff settings, select commits, and generate a structured diff file for LLM consumption.
+
+### 2. Key Objectives
+1. **Provide an intuitive UI** for configuring file filters, diff settings, and context rules.
+2. **Support dark mode** with modern aesthetics.
+3. **Enable commit selection** from a dropdown or interactive selection.
+4. **Allow easy export** of the processed diff to a file.
+5. **Ensure responsiveness** and usability across different screen sizes.
+6. **Keep UI simple** without embedding a diff viewer, as users will edit the output in their own text editor.
+
+### 3. UI Design
+#### **3.1. Main Window Components**
+1. **Commit Selection Panel**
+   - Dropdowns to select `commit1` and `commit2`.
+2. **Configuration Panel**
+   - File pattern selector (`*.cs`, `*.py`, etc.).
+   - Toggle for `include_entire_file_with_signatures`.
+   - Input field for `method_body_threshold`.
+   - Context lines selection (`-U` value).
+3. **Export Options**
+   - Output path.
+   - “Pack” button to trigger diff generation and export output as `.md` file.
+4. **Dark Mode Toggle**
+   - Integrated style switcher for light/dark themes.
+
+### 4. Dark Mode Implementation
+- Use **Qt’s Fusion theme** with a dark stylesheet.
+- Custom stylesheets for buttons, dropdowns, and text areas to ensure consistency.
+- Automatic detection of system theme (if possible).
+
+### 5. Interaction Flow
+1. **User selects two commits** from dropdowns.
+2. **User configures filters and options** (e.g., method body removal, context lines).
+3. **User clicks “Pack”** to generate the diff file.
+4. **File is automatically saved/exported**, ready for upload to an LLM.
+
+### 6. Sample Pseudocode
+```python
+from PyQt6.QtWidgets import QApplication, QMainWindow, QPushButton, QVBoxLayout, QFileDialog
+from PyQt6.QtGui import QPalette, QColor
+
+class RepoDiffUI(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.initUI()
+
+    def initUI(self):
+        self.setWindowTitle("RepoDiff")
+        self.setGeometry(100, 100, 600, 400)
+
+        # Dark mode setup
+        palette = QPalette()
+        palette.setColor(QPalette.ColorRole.Window, QColor(53, 53, 53))
+        palette.setColor(QPalette.ColorRole.WindowText, QColor(255, 255, 255))
+        self.setPalette(palette)
+
+        # Main Layout
+        layout = QVBoxLayout()
+
+        # Pack Button
+        self.pack_button = QPushButton("Pack")
+        self.pack_button.clicked.connect(self.generate_diff)
+        layout.addWidget(self.pack_button)
+
+        self.setLayout(layout)
+
+    def generate_diff(self):
+        file_path, _ = QFileDialog.getSaveFileName(self, "Save Diff File", "", "Markdown Files (*.md);;All Files (*)")
+        if file_path:
+            with open(file_path, 'w') as f:
+                f.write("Generated diff output...")
+
+app = QApplication([])
+window = RepoDiffUI()
+window.show()
+app.exec()
+```
+
+### 7. Expected Outcome
+- A modern UI with a **clean, structured layout**.
+- **Dark mode support** with clear text visibility.
+- **No embedded diff viewer**, only file export.
+- **Seamless interaction** for configuring and generating diffs.
+- **Optimized for LLMs and manual editing.**
+
+### 8. Summary
+RepoDiff’s UI will be developed in **PyQt**, providing a **modern, user-friendly interface** with dark mode support. The UI will enable easy configuration, commit selection, and diff generation, making RepoDiff an accessible and efficient tool for code review workflows.
+