wpallstars/wp-plugin-starter-template-for-ai-coding
Template
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update documentation with AI IDE context recommendations and improve starter prompt
Some checks failed
Tests / PHP 7.0 (push) Has been cancelled
Details
Tests / PHP 7.4 (push) Has been cancelled
Details
Tests / PHP 8.0 (push) Has been cancelled
Details
Tests / Code Style (push) Has been cancelled
Details
Release / Build and Release (push) Has been cancelled
Details

Browse Source
This commit is contained in:
Marcus Quinn
2025-04-18 03:57:43 +01:00
parent 66758ac0f8
commit 342eefd471
9 changed files with 1199 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
.ai-workflows/bug-fixing.md Normal file
View File

@ -0,0 +1,202 @@
# Bug Fixing Guide for AI Assistants
This document provides guidance for AI assistants to help with bug fixing for the Fix Plugin Does Not Exist Notices plugin.
## Bug Fixing Workflow
### 1. Create a Bug Fix Branch
Always start by creating a bug fix branch from the latest main branch pulled from origin (this step is mandatory):
```bash
git checkout main
git pull origin main # Critical step - never skip this
git checkout -b fix/bug-description
```
Use a descriptive name that clearly indicates what bug is being fixed. If there's an issue number, include it in the branch name (e.g., `fix/123-plugin-activation-error`).
For more detailed git workflow guidelines, see **@.ai-workflows/git-workflow.md**.
### 2. Understand the Bug
Before fixing a bug, make sure you understand:
- What is the expected behavior?
- What is the actual behavior?
- What are the steps to reproduce the bug?
- What is the impact of the bug?
- What is the root cause of the bug?
### 3. Fix the Bug
When fixing a bug:
- Make minimal changes necessary to fix the bug
- Avoid introducing new features while fixing bugs
- Maintain backward compatibility
- Add appropriate comments explaining the fix
- Consider adding tests to prevent regression
### 4. Update Documentation
Update relevant documentation to reflect the bug fix:
- Add a description to CHANGELOG.md under an "Unreleased" section
- Update readme.txt if the bug fix affects user-facing functionality
### 5. Testing
Test the bug fix thoroughly:
- Verify that the bug is fixed
- Ensure no regression in related functionality
- Test with the latest WordPress version
- Test with the minimum supported WordPress version (5.0)
- Test with PHP 7.0+ (minimum supported version)
### 6. Commit Changes
Make atomic commits with clear messages:
```bash
git add .
git commit -m "Fix #123: Brief description of the bug fix"
```
If there's an issue number, reference it in the commit message.
### 7. Prepare for Release
When the bug fix is ready to be released:
1. Create a version branch for the release:
```bash
git checkout -b v{MAJOR}.{MINOR}.{PATCH}
```
2. Merge your bug fix branch into the version branch:
```bash
git merge fix/bug-description --no-ff
```
3. Update version numbers and changelog entries
4. Follow the standard release process from this point
### 8. Push to Remote (Optional for Collaboration)
If you need to collaborate with others on the bug fix before it's ready for release:
```bash
git push github HEAD:fix/bug-description
git push gitea HEAD:fix/bug-description
```
### 9. Create Pull Request (Optional)
If the repository uses pull requests for code review, create a pull request from the bug fix branch to the version branch.
## Determining Version Increment
After fixing a bug and confirming it works, determine the appropriate version increment:
- **PATCH** (e.g., 1.6.0 → 1.6.1): For most bug fixes that don't change functionality
- **MINOR** (e.g., 1.6.0 → 1.7.0): For bug fixes that introduce new features or significant changes
- **MAJOR** (e.g., 1.6.0 → 2.0.0): For bug fixes that introduce breaking changes
**IMPORTANT**: Don't update version numbers during initial development and testing. Only create a version branch (e.g., `v2.2.3`) and update version numbers when the fix is confirmed working.
This approach is more time-efficient as it allows you to focus on fixing the bug without worrying about version updates until the fix is confirmed working.
For detailed guidelines on time-efficient development and testing, see **@.ai-workflows/incremental-development.md**.
## Testing Previous Versions
To test a previous version of the plugin:
```bash
# Checkout a specific tag for testing
git checkout v{MAJOR}.{MINOR}.{PATCH}
# Or create a test branch from a specific tag
git checkout v{MAJOR}.{MINOR}.{PATCH} -b test/some-feature
```
## Hotfix Process
For critical bugs that need immediate fixing in a released version:
### 1. Create a Hotfix Branch
```bash
git checkout v{MAJOR}.{MINOR}.{PATCH}
git checkout -b hotfix/v{MAJOR}.{MINOR}.{PATCH+1}
```
### 2. Fix the Issues
Apply the minimal fix necessary to address the critical issue.
### 3. Update Version Numbers
Increment the PATCH version and update all version numbers:
- Main plugin file (fix-plugin-does-not-exist-notices.php)
- FPDEN_VERSION constant
- CHANGELOG.md
- readme.txt
- README.md
- languages/fix-plugin-does-not-exist-notices.pot (Project-Id-Version)
### 4. Commit and Push
```bash
git add .
git commit -m "Hotfix: Brief description of the critical bug fix"
git push github HEAD:hotfix/v{MAJOR}.{MINOR}.{PATCH+1}
git push gitea HEAD:hotfix/v{MAJOR}.{MINOR}.{PATCH+1}
```
### 5. Create and Push Tag
```bash
git tag -a v{MAJOR}.{MINOR}.{PATCH+1} -m "Hotfix release version {MAJOR}.{MINOR}.{PATCH+1}"
git push github refs/tags/v{MAJOR}.{MINOR}.{PATCH+1}
git push gitea refs/tags/v{MAJOR}.{MINOR}.{PATCH+1}
```
## Common Bug Types and Fixing Strategies
### WordPress Compatibility Issues
- Test with the specific WordPress version where the issue occurs
- Check for deprecated functions or hooks
- Review WordPress changelog for relevant changes
### PHP Compatibility Issues
- Test with the specific PHP version where the issue occurs
- Check for deprecated PHP functions or features
- Use appropriate polyfills if necessary
### JavaScript Issues
- Test in different browsers
- Check for browser console errors
- Consider browser-specific workarounds if necessary
### CSS Issues
- Test in different browsers and screen sizes
- Use browser developer tools to inspect elements
- Consider browser-specific workarounds if necessary
### Database Issues
- Use proper database prefixing
- Sanitize database inputs
- Use prepared statements for queries
- Consider database version differences

163
.ai-workflows/code-review.md Normal file
View File

@ -0,0 +1,163 @@
# Code Review Guide for AI Assistants
This document provides guidance for AI assistants to help with code review for the Fix Plugin Does Not Exist Notices plugin.
## Code Review Checklist
When reviewing code, check for the following:
### Functionality
- [ ] Does the code work as expected?
- [ ] Does it handle edge cases appropriately?
- [ ] Are there any logical errors?
- [ ] Is error handling implemented properly?
### Code Quality
- [ ] Does the code follow WordPress coding standards?
- [ ] Is the code well-organized and easy to understand?
- [ ] Are there any code smells (duplicate code, overly complex functions, etc.)?
- [ ] Are functions and variables named appropriately?
- [ ] Are there appropriate comments and documentation?
### Security
- [ ] Is user input properly validated and sanitized?
- [ ] Is output properly escaped?
- [ ] Are capability checks used for user actions?
- [ ] Are nonces used for form submissions?
- [ ] Are there any potential SQL injection vulnerabilities?
- [ ] Are there any potential XSS vulnerabilities?
### Performance
- [ ] Are there any performance bottlenecks?
- [ ] Are database queries optimized?
- [ ] Is caching used appropriately?
- [ ] Are assets (CSS, JS) properly enqueued?
### Compatibility
- [ ] Is the code compatible with the minimum supported WordPress version (5.0)?
- [ ] Is the code compatible with the minimum supported PHP version (7.0)?
- [ ] Are there any browser compatibility issues?
- [ ] Are there any conflicts with other plugins?
### Internationalization
- [ ] Are all user-facing strings translatable?
- [ ] Is the correct text domain used?
- [ ] Are translation functions used correctly?
### Accessibility
- [ ] Does the code follow accessibility best practices?
- [ ] Are ARIA attributes used appropriately?
- [ ] Is keyboard navigation supported?
- [ ] Is screen reader support implemented?
## Code Review Process
### 1. Understand the Context
Before reviewing code, understand:
- What problem is the code trying to solve?
- What are the requirements?
- What are the constraints?
### 2. Review the Code
Review the code with the checklist above in mind.
### 3. Provide Feedback
When providing feedback:
- Be specific and clear
- Explain why a change is needed
- Provide examples or suggestions when possible
- Prioritize feedback (critical issues vs. minor improvements)
- Be constructive and respectful
### 4. Follow Up
After the code has been updated:
- Review the changes
- Verify that issues have been addressed
- Provide additional feedback if necessary
## Common Issues to Look For
### PHP Issues
- Undefined variables or functions
- Incorrect function parameters
- Missing return statements
- Improper error handling
- Inefficient loops or conditionals
- Hardcoded values that should be configurable
### WordPress-Specific Issues
- Incorrect hook usage
- Missing or incorrect nonces
- Missing capability checks
- Direct database queries instead of using WordPress functions
- Improper enqueuing of scripts and styles
- Not using WordPress functions for common tasks
### JavaScript Issues
- Undefined variables or functions
- Event listener memory leaks
- jQuery conflicts
- Browser compatibility issues
- Missing error handling
### CSS Issues
- Browser compatibility issues
- Specificity issues
- Unused styles
- Overriding WordPress admin styles inappropriately
## Example Feedback
### Good Feedback Example
```
In function `handle_remove_reference()`:
1. The nonce check is missing, which could lead to CSRF vulnerabilities.
Consider adding:
```php
if (!isset($_GET['_wpnonce']) || !wp_verify_nonce($_GET['_wpnonce'], 'fpden_remove_reference')) {
wp_die(__('Security check failed.', 'fix-plugin-does-not-exist-notices'));
}
```
2. The user capability check should be more specific. Instead of:
```php
if (!current_user_can('manage_options')) {
```
Consider using:
```php
if (!current_user_can('activate_plugins')) {
```
This is more appropriate for the action being performed.
3. The success message should be translatable:
```php
// Change this:
add_settings_error('fpden', 'fpden_removed', 'Plugin reference removed successfully.', 'updated');
// To this:
add_settings_error('fpden', 'fpden_removed', __('Plugin reference removed successfully.', 'fix-plugin-does-not-exist-notices'), 'updated');
```
```
### Poor Feedback Example
```
This code has security issues and doesn't follow best practices. Fix it.
```

62
.ai-workflows/dev-prefs-memory.md Normal file
View File

@ -0,0 +1,62 @@
# Developer Preferences Memory
This document serves as a persistent memory for developer preferences established during coding sessions. AI assistants should refer to this document to understand the developer's preferences and update it as new preferences are established.
## Purpose
- Maintain a consistent record of developer preferences across coding sessions
- Ensure AI assistants can provide assistance that aligns with the developer's preferred coding style and practices
- Reduce the need for developers to repeatedly explain their preferences
## How to Use This Document
- **AI Assistants**: Review this document before providing assistance. Update it when new preferences are established through user feedback.
- **Developers**: Reference this document to see what preferences have been recorded. Feel free to edit it directly to add or modify preferences.
## Recorded Preferences
### File and Directory Structure
- Prefer lowercase filenames for consistency across the codebase
- Use unique folder names following best practices
- Folder references should be easily identifiable when using @mentions in AI-assisted coding
- Admin-specific functionality should be in the `admin/lib/` directory
- Core plugin functionality should be in the `includes/` directory
### Code Style
- Follow WordPress coding standards
- Use OOP best practices for WordPress plugins
- Create modular, maintainable, and efficient code structure
### Documentation
- Prefer token-efficient documentation in `.ai-assistant.md` that references `.ai-workflows/` files
- Document the release workflow in `.ai-assistant.md` and `.ai-workflows/release-process.md`
- Store environment variable documentation in `.ai-workflows/local-env-vars.md`
- Maintain consistent documentation across readme.txt, README.md, and CHANGELOG.md
### Asset Organization
- Store banner, icon, and screenshot images in `.wordpress-org/assets/`
- Store WORDPRESS_ORG files within `/wordpress-org`
- Organize files in `/assets` into relevant `/admin` folders
### Version Control
- Use standard Git practices for version control and code management
- When updating plugin versions, create a GitHub tag and trigger GitHub actions
- Follow a specific release process with proper tagging and GitHub releases
- Ensure commits are merged to the main branch as Git Updater pulls data from the readme.txt file in the primary branch
### Plugin Development
- Prefer simpler solutions over complex ones for plugins
- Use a specific formatting style for the CHANGELOG.md file, using #### for section headings
- When updating plugin versions, remember to update language files (POT/PO)
- Comment out redundant code during testing
### Potential AI Assised IDE Issues
- Check for non-standard local terminal commandline customisations that might not be understood by the AI IDE in its terminal useage and cause errors in execution or confusion in not seeing expected results, and advise on how to resolve
- Check for non-standard or multiple python and node.js versions, including homebrew versions, that might not be understood by the AI IDE in its terminal useage and cause errors in execution or confusion in not seeing expected results, and advise on how to resolve

205
.ai-workflows/feature-development.md Normal file
View File

@ -0,0 +1,205 @@
# Feature Development Guide for AI Assistants
This document provides guidance for AI assistants to help with feature development for the Fix Plugin Does Not Exist Notices plugin.
## Feature Development Workflow
### 1. Create a Feature Branch
Always start by creating a feature branch from the latest main branch pulled from origin (this step is mandatory):
```bash
git checkout main
git pull origin main # Critical step - never skip this
git checkout -b feature/descriptive-name
```
Use a descriptive name that clearly indicates what the feature is about. If there's an issue number, include it in the branch name (e.g., `feature/123-update-source-selector`).
For more detailed git workflow guidelines, see **@.ai-workflows/git-workflow.md**.
### 2. Implement the Feature
When implementing a new feature:
- Follow WordPress coding standards
- Ensure all strings are translatable
- Add appropriate comments
- Consider performance implications
- Maintain backward compatibility
- Review reference plugins in the `reference-plugins/` directory for inspiration and best practices
### 3. Update Documentation
Update relevant documentation to reflect the new feature:
- Add a description to CHANGELOG.md under an "Unreleased" section
- Update readme.txt if the feature affects user-facing functionality
- Update README.md with the new feature description
- Update inline documentation/comments
- Update wiki documentation in the `.wiki` directory:
- Create or update feature-specific pages
- Update the Home.md page if necessary
- Add the feature to any relevant existing pages
- Add screenshots or examples if applicable
- Remember that any feature addition will require a version increment in all relevant files
For detailed guidelines on maintaining wiki documentation, see **@.ai-workflows/wiki-documentation.md**.
### 4. Testing
Test the feature thoroughly:
- Test with the latest WordPress version
- Test with the minimum supported WordPress version (5.0)
- Test with PHP 7.0+ (minimum supported version)
- Test in different environments (if possible)
### 5. Commit Changes
Make atomic commits with clear messages:
```bash
git add .
git commit -m "Add feature: descriptive name"
```
### 6. Prepare for Release
When the feature is ready to be released:
1. Create a version branch with the appropriate version number (typically increment the minor version for features):
```bash
# Example: from 2.2.0 to 2.3.0
git checkout -b v{MAJOR}.{MINOR+1}.0
```
2. Now update version numbers in all required files:
- Main plugin file (wp-fix-plugin-does-not-exist-notices.php)
- CHANGELOG.md (add a new version section)
- readme.txt
- README.md
- languages/wp-fix-plugin-does-not-exist-notices.pot (Project-Id-Version)
3. Commit the version updates:
```bash
git add .
git commit -m "Version {MAJOR}.{MINOR+1}.0 - [brief description]"
```
4. Tag the version as stable:
```bash
git tag -a v{MAJOR}.{MINOR+1}.0-stable -m "Stable version {MAJOR}.{MINOR+1}.0"
```
5. Follow the standard release process from this point
**IMPORTANT**: Don't update version numbers during initial development and testing. Only create a version branch and update version numbers when the feature is confirmed working.
For detailed guidelines on time-efficient development and testing, see **@.ai-workflows/incremental-development.md**.
### 7. Push to Remote (Optional for Collaboration)
If you need to collaborate with others on the feature before it's ready for release:
```bash
git push github HEAD:feature/descriptive-name
git push gitea HEAD:feature/descriptive-name
```
### 8. Create Pull Request (Optional)
If the repository uses pull requests for code review, create a pull request from the feature branch to the version branch.
## Code Standards and Best Practices
### PHP Coding Standards
- Follow [WordPress PHP Coding Standards](https://developer.wordpress.org/coding-standards/wordpress-coding-standards/php/)
- Use tabs for indentation, not spaces
- Use proper naming conventions:
- Class names: `Class_Name`
- Function names: `function_name`
- Variable names: `$variable_name`
### JavaScript Coding Standards
- Follow [WordPress JavaScript Coding Standards](https://developer.wordpress.org/coding-standards/wordpress-coding-standards/javascript/)
- Use tabs for indentation, not spaces
- Use proper naming conventions:
- Function names: `functionName`
- Variable names: `variableName`
### Internationalization (i18n)
- Wrap all user-facing strings in appropriate translation functions:
- `__()` for simple strings
- `_e()` for echoed strings
- `esc_html__()` for escaped strings
- `esc_html_e()` for escaped and echoed strings
- Always use the plugin's text domain: `fix-plugin-does-not-exist-notices`
### Security Best Practices
- Validate and sanitize all input
- Escape all output
- Use nonces for form submissions
- Use capability checks for user actions
## Working in Multi-Repository Workspaces
When developing features in a workspace with multiple repositories:
1. **Verify Repository Context**:
- Confirm you're working in the correct repository before suggesting or implementing features
- Use `pwd` and `git remote -v` to verify the current repository
2. **Feature Verification**:
- Before implementing a feature, verify it doesn't already exist in the current repository
- Don't assume features from other repositories should be implemented in this one
- Use `codebase-retrieval` to search for existing functionality
3. **Repository-Specific Implementation**:
- Implement features appropriate for this specific plugin's purpose
- Maintain consistency with the current repository's architecture and coding style
- Don't copy code directly from other repositories without adaptation
4. **Cross-Repository Inspiration**:
- If implementing a feature inspired by another repository, explicitly note that it's a new feature
- Adapt the feature to fit the current repository's needs and architecture
- Document the inspiration source in code comments
For detailed guidelines on working in multi-repository workspaces, see **@.ai-workflows/multi-repo-workspace.md**.
## Feature Types and Implementation Guidelines
### Admin Interface Features
When adding features to the admin interface:
- Use WordPress admin UI components for consistency
- Follow WordPress admin UI patterns
- Ensure accessibility compliance
- Add appropriate help text
### Plugin Functionality Features
When adding core functionality:
- Ensure compatibility with WordPress hooks system
- Consider performance impact
- Maintain backward compatibility
- Add appropriate error handling
### Integration Features
When adding integration with other plugins or services:
- Make integrations optional when possible
- Check if the integrated plugin/service is available before using it
- Provide fallback functionality when the integration is not available
- Document the integration requirements

255
.ai-workflows/git-workflow.md Normal file
View File

@ -0,0 +1,255 @@
# Git Workflow Guide for AI Assistants
This document provides guidance for AI assistants to help with git workflow management for the Fix Plugin Does Not Exist Notices plugin.
## Core Git Workflow Principles
### 1. Always Start from Latest Main Branch
Before creating any new branch, always ensure you're working with the latest code from the main branch by pulling from the origin:
```bash
git checkout main
git pull origin main
```
This critical step ensures that your new branch includes all the latest changes from the remote repository and reduces the chance of merge conflicts later. Never skip this step, as working from an outdated main branch can lead to integration problems.
### 2. One Issue Per Branch
Create a separate branch for each issue or feature you're working on:
- For bug fixes: `fix/issue-description` or `fix/issue-number-description`
- For features: `feature/descriptive-name`
- For small improvements: `patch/descriptive-name`
- For code restructuring: `refactor/descriptive-name`
**Important**: Use descriptive names without version numbers for development branches. This allows focusing on the changes without worrying about version updates until the changes are confirmed working.
Only create version branches (e.g., `v2.2.3`) when changes are ready for release, and only then update version numbers in files.
This approach keeps changes focused, makes code review easier, and provides clear rollback points if needed.
### 3. Pull Request for Each Issue
Create a separate pull request for each issue or feature. This ensures:
- Each change can be reviewed independently
- Issues can be merged as soon as they're ready
- Changes can be reverted individually if needed
- CI/CD checks can run on focused changes
## Detailed Workflow
### Starting a New Task
1. **Update Main Branch from Origin**
```bash
git checkout main
git pull origin main
```
This step is mandatory before creating any new branch to ensure you're working with the latest code.
2. **Create a New Branch**
```bash
git checkout -b [branch-type]/[description]
```
Examples:
```bash
git checkout -b fix/123-plugin-activation-error
git checkout -b feature/update-source-selector
git checkout -b patch/2.2.1
```
3. **Make Your Changes**
- Make focused changes related only to the specific issue
- Commit regularly with clear, descriptive messages
- Reference issue numbers in commit messages when applicable
4. **Testing Approach**
For efficient development:
- **Local Testing (Default)**: Test without updating version numbers
```bash
# Get current version from plugin file
CURRENT_VERSION=$(grep -o "Version: [0-9.]*" wp-fix-plugin-does-not-exist-notices.php | cut -d' ' -f2)
# Build and deploy with current version
./build.sh $CURRENT_VERSION
```
- **Remote Testing (When Requested)**: Push development branch to remote
```bash
git add .
git commit -m "[Brief description] for remote testing"
git push origin [branch-name]
```
- **Version Creation**: Only when changes are confirmed working
```bash
# Create version branch
git checkout -b v{MAJOR}.{MINOR}.{PATCH}
# Update version numbers in all required files
# Commit version updates
git add .
git commit -m "Version {MAJOR}.{MINOR}.{PATCH} - Brief description"
# Tag as stable
git tag -a v{MAJOR}.{MINOR}.{PATCH}-stable -m "Stable version {MAJOR}.{MINOR}.{PATCH}"
```
5. **Push Branch to Remote (When Needed)**
```bash
git push origin [branch-name]
```
### Creating a Pull Request
1. **Ensure Tests Pass Locally**
- Run any available tests to ensure your changes work as expected
- Fix any issues before creating a pull request
2. **Create Pull Request**
- Create a pull request from your branch to the main branch
- Include a clear description of the changes
- Reference any related issues
- Assign reviewers if appropriate
3. **Address Review Feedback**
- Make requested changes
- Push additional commits to the same branch
- Respond to comments
### CI/CD Integration
Each pull request should pass through CI/CD checks before being merged. This ensures that all changes are compatible with the existing codebase and meet quality standards.
1. **Automated Tests**
- Unit tests
- Integration tests
- Code style checks
- Compatibility checks
2. **Manual Review**
- Code review by team members
- Functional testing in test environment
- Verification of feature requirements
3. **Approval Process**
- Required approvals before merging
- Final checks for conflicts with other pending PRs
- Verification that all CI/CD checks have passed
4. **Compatibility with Unmerged PRs**
- When multiple PRs are in progress simultaneously, ensure each PR is compatible with the main branch
- For related changes, consider using feature flags to allow independent merging
- Document dependencies between PRs in the PR description
### Handling Concurrent Development
When working on multiple issues simultaneously:
1. **Keep Branches Independent**
- Always create new branches from the latest main branch pulled from origin, not from other feature branches
- This ensures each PR can be merged independently and contains all the latest changes
2. **Handle Conflicts Proactively**
- If main has been updated with other changes while you're working:
```bash
git checkout main
git pull origin main
git checkout your-branch
git merge main
```
- Resolve any conflicts locally before pushing
3. **Coordinate on Dependent Changes**
- If changes depend on each other, note this in the PR description
- Consider using the "Depends on #PR-number" notation in PR descriptions
## Release Process
When preparing for a release:
1. **Ensure All Required PRs are Merged**
- All features and fixes planned for the release should be merged to main
2. **Create a Release Branch**
```bash
git checkout main
git pull origin main
git checkout -b v{MAJOR}.{MINOR}.{PATCH}
```
3. **Follow Standard Release Process**
- Update version numbers
- Update changelogs
- Create tag
- See **@.ai-workflows/release-process.md** for complete details
## Contributing to External Repositories
When working on issues for external repositories (pull/merge requests):
### 1. Clearly Indicate Testing Status
In the PR description and comments, clearly indicate the testing status:
- **Not tested**: "This PR addresses [issue] but has not been tested locally or remotely. It's ready for community/maintainer testing."
- **Locally tested**: "This PR has been tested in a local WordPress environment and [describe results]."
- **Remotely tested**: "This PR has been tested with a remote build and [describe results]."
### 2. Provide Testing Instructions
Include clear instructions for maintainers on how to test the changes:
- Steps to reproduce the original issue (if applicable)
- Steps to verify the fix or feature
- Any specific environments or configurations needed for testing
### 3. Be Responsive to Feedback
Monitor the PR for feedback from maintainers and be prepared to make additional changes if requested.
## Best Practices
### Commit Messages
- Use present tense ("Add feature" not "Added feature")
- Start with a verb
- Keep the first line under 50 characters
- Reference issues when relevant: "Fix #123: Resolve plugin detection issue"
- For more complex changes, add a detailed description after the first line
### Branch Management
- Delete branches after they've been merged
- Keep branch names descriptive but concise
- Use consistent naming conventions
### Code Review
- Review code thoroughly before approving
- Test changes locally when possible
- Provide constructive feedback
- See **@.ai-workflows/code-review.md** for detailed code review guidelines
### Suggested Improvements
If you identify potential improvements outside the scope of the current issue:
1. **Document the Suggestion**
- Note the suggestion in the PR comments
- Create a new issue for the suggestion
- Be specific about the benefits and implementation details
2. **Create a Separate Branch**
- Don't include unrelated improvements in the current PR
- Create a new branch from the latest main branch for the suggested improvement
- Submit a separate PR for the suggestion
3. **Ensure Compatibility**
- Make sure the suggested improvement is compatible with any unmerged PRs
- If the improvement depends on changes in another PR, note this dependency
- Consider how the improvement will interact with other pending changes

19
.ai-workflows/local-env-vars.md Normal file
View File

@ -0,0 +1,19 @@
# Local Development Environment Variables
This file contains important paths and URLs for local development.
## Repository Paths
- Local development repository: ~/Git/wp-fix-plugin-does-not-exist-notices
- LocalWP plugin testing site storage: ~/Local/plugin-testing/app/wp-fix-plugin-does-not-exist-notices
- LocalWP plugin testing site configuration: ~/Local/plugin-testing/conf/
## URLs
- LocalWP plugin testing URL: http://plugin-testing.local/
- PHP details: http://plugin-testing.local/local-phpinfo.php
- XDebug info: http://plugin-testing.local/local-xdebuginfo.php
- Adminer Evo: http://localhost:10010/?username=root&db=local
- Mailpit: http://localhost:10000/
## Build and Deploy Scripts
- Build script: ~/Git/wp-fix-plugin-does-not-exist-notices/build.sh
- Local deploy script: ~/Git/wp-fix-plugin-does-not-exist-notices/deploy-local.sh

8
CHANGELOG.md
View File

@ -1,5 +1,13 @@
All notable changes to this project should be documented both here and in the main Readme files.
#### [0.1.2] - 2025-04-18
#### Added
- STARTER-PROMPT.md with comprehensive guide for customizing the template
- Additional AI workflow files for better development guidance
#### Changed
- Updated documentation files with improved instructions
#### [0.1.1] - 2025-04-18
#### Changed
- Updated LICENSE file with correct GPL-2.0 text

270
README.md
View File

@ -1,145 +1,217 @@
# WordPress Plugin Starter Template for AI Coding
# WordPress Plugin Starter Template
[![License](https://img.shields.io/badge/license-GPL--2.0%2B-blue.svg)](https://www.gnu.org/licenses/gpl-2.0.html)
A comprehensive starter template for WordPress plugins with best practices for AI-assisted development.
[![WordPress Plugin Version](https://img.shields.io/wordpress/plugin/v/wp-plugin-starter-template-for-ai-coding)](https://wordpress.org/plugins/wp-plugin-starter-template-for-ai-coding/)
[![WordPress Plugin Rating](https://img.shields.io/wordpress/plugin/rating/wp-plugin-starter-template-for-ai-coding)](https://wordpress.org/plugins/wp-plugin-starter-template-for-ai-coding/)
[![WordPress Plugin Downloads](https://img.shields.io/wordpress/plugin/dt/wp-plugin-starter-template-for-ai-coding)](https://wordpress.org/plugins/wp-plugin-starter-template-for-ai-coding/)
[![License](https://img.shields.io/github/license/wpallstars/wp-plugin-starter-template-for-ai-coding)](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/blob/main/LICENSE)
## Description
The WordPress Plugin Starter Template provides a solid foundation for developing WordPress plugins with AI assistance. It includes a well-structured codebase, documentation templates, and best practices to help you create high-quality WordPress plugins efficiently.
The WordPress Plugin Starter Template provides a solid foundation for developing WordPress plugins. It incorporates best practices, modern coding standards, and a comprehensive structure that makes it easy to get started with plugin development.
This template is based on the experience gained from developing the "Fix 'Plugin file does not exist' Notices" plugin and other successful WordPress plugins.
### Key Features
- **Well-structured codebase** following WordPress coding standards
- **Modular architecture** for easy maintenance and extension
- **Comprehensive documentation** templates for both users and developers
- **AI-friendly workflows** with detailed guidance for AI assistants
- **Git integration** with GitHub and Gitea support
- **Update mechanism** with multiple source options (WordPress.org, GitHub, Gitea)
- **Internationalization** ready with proper text domain setup
- **Admin interface** components for building settings pages
* **Object-Oriented Architecture**: Well-structured, maintainable code using OOP principles
* **Namespace Support**: Modern PHP namespacing for better organization and avoiding conflicts
* **Comprehensive Documentation**: Detailed documentation for both users and developers
* **Testing Framework**: PHPUnit setup for unit testing
* **Internationalization Ready**: Full support for translation and localization
* **Update Source Selection**: Choose between WordPress.org, GitHub, or Gitea for plugin updates
* **AI Workflow Documentation**: Detailed guides for AI-assisted development
* **Wiki Documentation**: Ready-to-use wiki structure for comprehensive documentation
### For Developers
### How to Use This Template
This template is designed to be a starting point for your WordPress plugin development. It provides:
1. Clone or download this repository
2. **Important**: Begin by reading the [STARTER-PROMPT.md](STARTER-PROMPT.md) file for detailed instructions
3. Add the .ai-assistant.md file and .ai-workflows/ directory to your AI IDE chat context (pin them if possible)
4. Use the prompt in STARTER-PROMPT.md to guide the AI in customizing the template for your plugin
5. Rename files and update namespaces to match your plugin
6. Customize the functionality for your specific needs
7. Update documentation to reflect your plugin's features
8. Build and test your plugin
- A clean, well-organized file structure
- OOP approach with namespaced classes
- Separation of concerns (admin, core functionality)
- Documentation templates for wiki and readme files
- GitHub Actions workflows for automated tasks
- AI workflow documentation for AI-assisted development
### AI-Assisted Development
This template includes comprehensive documentation for AI-assisted development:
* **.ai-assistant.md**: Guide for AI assistants to understand the project structure
* **.ai-workflows/**: Detailed workflow documentation for common development tasks
* **STARTER-PROMPT.md**: Comprehensive prompt for AI tools to help customize the template
**Important**: For the best AI assistance, add the .ai-assistant.md file and .ai-workflows/ directory to your AI IDE chat context. In most AI IDEs, you can pin these files to ensure they're considered in each message.
## Installation
### From GitHub
1. Download the latest release from the [GitHub repository](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/releases)
2. Upload the plugin files to the `/wp-content/plugins/wp-plugin-starter-template` directory, or install the plugin through the WordPress plugins screen directly
3. Activate the plugin through the 'Plugins' screen in WordPress
### Using as a Template for Your Plugin
1. Clone or download this repository
2. Rename the plugin directory and files to match your plugin name
3. Update namespaces, function prefixes, and text domains
4. Update plugin headers in the main PHP file
5. Customize the functionality to meet your specific needs
6. Update documentation to reflect your plugin's features
2. Read the [STARTER-PROMPT.md](STARTER-PROMPT.md) file for detailed instructions
3. Add the .ai-assistant.md file and .ai-workflows/ directory to your AI IDE chat context
4. Use the prompt in STARTER-PROMPT.md to guide the AI in customizing the template
5. Rename files and update namespaces to match your plugin
6. Customize the functionality for your specific needs
7. Update documentation to reflect your plugin's features
8. Build and test your plugin
## Usage
### Basic Structure
### Getting Started
The template follows a modular structure:
To get started with this template, follow these steps:
- `wp-plugin-starter-template.php`: Main plugin file with plugin headers
- `includes/`: Core plugin functionality
- `plugin.php`: Main plugin class that initializes everything
- `core.php`: Core functionality class
- `updater.php`: Update mechanism for multiple sources
- `admin/`: Admin-specific functionality
- `lib/`: Admin classes
- `css/`: Admin stylesheets
- `js/`: Admin JavaScript files
- `languages/`: Translation files
- `.github/workflows/`: GitHub Actions workflows
- `.ai-workflows/`: Documentation for AI assistants
- `.wiki/`: Wiki documentation templates
1. Clone this repository to your local machine:
```bash
git clone https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding.git
```
### Customizing for Your Plugin
2. Open the STARTER-PROMPT.md file and follow the instructions to customize the template for your plugin.
1. **Rename Files and Update Namespaces**:
- Rename `wp-plugin-starter-template.php` to your plugin name
- Update the namespace from `WPALLSTARS\PluginStarterTemplate` to your own
- Update text domain from `wp-plugin-starter-template` to your own
3. Add the .ai-assistant.md file and .ai-workflows/ directory to your AI IDE chat context.
2. **Update Plugin Headers**:
- Edit the plugin headers in the main PHP file
- Update GitHub/Gitea repository URLs
4. Use an AI assistant like GitHub Copilot, Claude, or ChatGPT to help you customize the template by providing the prompt from STARTER-PROMPT.md.
3. **Customize Functionality**:
- Modify the core functionality in `includes/core.php`
- Add your own classes as needed
- Customize admin interfaces in the `admin/` directory
### Using with Git Updater
4. **Update Documentation**:
- Update README.md and readme.txt with your plugin information
- Customize wiki documentation in the `.wiki/` directory
If you've installed this plugin from GitHub or Gitea, you'll need Git Updater to receive updates:
## Documentation
1. Install the Git Updater plugin from [git-updater.com/git-updater/](https://git-updater.com/git-updater/)
2. Go to Settings > Git Updater > Remote Management
3. Click the "Refresh Cache" button to ensure Git Updater recognizes the latest version
4. Updates will now appear in your WordPress dashboard when available
Comprehensive documentation is available in the [Wiki](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/wiki).
### Choosing Your Update Source
### For Users
This template includes functionality that allows users to choose where they want to receive updates from:
- [Installation Guide](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/wiki/Installation-Guide)
- [Usage Instructions](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/wiki/Usage-Instructions)
- [Frequently Asked Questions](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/wiki/Frequently-Asked-Questions)
- [Troubleshooting](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/wiki/Troubleshooting)
1. In the Plugins list, find your plugin
2. Click the "Update Source" link next to the plugin
3. Select your preferred update source:
- **WordPress.org**: Updates from the official WordPress.org repository
- **GitHub**: Updates directly from the GitHub repo
- **Gitea**: Updates directly from the Gitea repo
4. Click "Save" to apply your preference
### For Developers
## Frequently Asked Questions
- [Architecture Overview](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/wiki/Architecture-Overview)
- [Extending the Plugin](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/wiki/Extending-the-Plugin)
- [Coding Standards](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/wiki/Coding-Standards)
- [Release Process](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/wiki/Release-Process)
### How do I customize this template for my plugin?
### For AI Assistants
See the [STARTER-PROMPT.md](STARTER-PROMPT.md) file for detailed instructions on customizing this template for your specific plugin needs. Make sure to add the .ai-assistant.md file and .ai-workflows/ directory to your AI IDE chat context for the best results.
The `.ai-assistant.md` file and `.ai-workflows/` directory contain detailed guidance for AI assistants working with this template. These resources help ensure consistent, high-quality code and documentation when using AI tools for development.
### What files do I need to update with my plugin information?
The main files you need to update include:
1. Main plugin file (rename and update header)
2. README.md
3. readme.txt
4. CHANGELOG.md
5. composer.json
6. languages/pot file
7. .github/workflows/
8. .wiki/
9. .ai-assistant.md
10. includes/plugin.php
11. includes/core.php
12. admin/lib/admin.php
### How do I build and test my plugin?
Use the included build.sh script to create a deployable version of your plugin:
```bash
./build.sh {VERSION}
```
This will create a ZIP file that you can install in WordPress.
### How do I add custom functionality to my plugin?
Customize the includes/core.php file to implement your core functionality and the admin/lib/admin.php file for admin-specific functionality.
## Support & Feedback
If you need help with this template, there are several ways to get support:
* [GitHub Issues](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/issues)
* [Gitea Issues](https://gitea.wpallstars.com/wpallstars/wp-plugin-starter-template-for-ai-coding/issues)
## Contributing
Contributions are welcome! Please feel free to submit a pull request or open an issue on the [GitHub repository](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding).
Contributions are welcome! Please feel free to submit a Pull Request.
### Development Process
1. Fork the repository
2. Create a feature branch: `git checkout -b feature/your-feature-name`
3. Make your changes and commit them: `git commit -m 'Add some feature'`
4. Push to the branch: `git push origin feature/your-feature-name`
1. Fork the repository on [GitHub](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/) or [Gitea](https://gitea.wpallstars.com/wpallstars/wp-plugin-starter-template-for-ai-coding/)
2. Create your feature branch: `git checkout -b feature/amazing-feature`
3. Commit your changes: `git commit -m 'Add some amazing feature'`
4. Push to the branch: `git push origin feature/amazing-feature`
5. Submit a pull request
## Credits
## Developers
This template is maintained by [WPALLSTARS](https://www.wpallstars.com) and is based on the experience and best practices developed while creating the [Fix 'Plugin file does not exist' Notices](https://github.com/wpallstars/wp-fix-plugin-does-not-exist-notices) plugin.
### AI-Powered Development
This repository is configured to work with various AI-powered development tools. You can use any of the following AI IDEs to contribute to this project:
- [Augment Code](https://www.augmentcode.com/) - AI-powered coding assistant
- [Cursor](https://cursor.com/) - AI-first code editor
- [v0](https://v0.dev/) - AI-powered design and development tool
- [Windsurf](https://www.windsurf.com/) - AI coding assistant
- [Cline](https://cline.bot/) - AI terminal assistant
- [Roo Code](https://roocode.com/) - AI pair programmer
- [Loveable](https://lovable.dev/) - AI development environment
- [Bolt](https://www.bolt.new/) - AI-powered code editor
- [Cody](https://sourcegraph.com/cody) - Sourcegraph's AI coding assistant
- [Continue](https://continue.dev/) - Open-source AI coding assistant
The repository includes configuration files for all these tools to ensure a consistent development experience.
### Git Updater Integration
This template is designed to work seamlessly with the Git Updater plugin for updates from GitHub and Gitea. To ensure proper integration:
1. **Required Headers**: The plugin includes specific headers in the main plugin file that Git Updater uses to determine update sources and branches:
```php
* GitHub Plugin URI: wpallstars/wp-plugin-starter-template-for-ai-coding
* GitHub Branch: main
* Primary Branch: main
* Release Branch: main
* Release Asset: true
* Gitea Plugin URI: https://gitea.wpallstars.com/wpallstars/wp-plugin-starter-template-for-ai-coding
* Gitea Branch: main
```
2. **Tagging Releases**: When creating a new release, always tag it with the 'v' prefix (e.g., `v0.1.2`) to ensure GitHub Actions can create the proper release assets.
3. **GitHub Actions**: The repository includes a GitHub Actions workflow that automatically builds the plugin and creates a release with the .zip file when a new tag is pushed.
4. **Update Source Selection**: The template includes a feature that allows users to choose their preferred update source (WordPress.org, GitHub, or Gitea).
For more information on Git Updater integration, see the [Git Updater Required Headers documentation](https://git-updater.com/knowledge-base/required-headers/).
## Changelog
### 0.1.2
* Added: STARTER-PROMPT.md with comprehensive guide for customizing the template
* Updated: Documentation files with improved instructions
* Added: Additional AI workflow files for better development guidance
### 0.1.1
* Updated: LICENSE file with correct GPL-2.0 text
### 0.1.0
* Initial release with basic template structure
* Added: Core plugin architecture with OOP approach
* Added: Admin interface components and styling
* Added: Update mechanism with multiple source options
* Added: Documentation templates for users and developers
* Added: AI workflow documentation for AI-assisted development
* Added: GitHub Actions workflows for automated tasks
* Added: Wiki documentation templates
[View full changelog](CHANGELOG.md)
## License
This project is licensed under the GPL-2.0+ License - see the [LICENSE](LICENSE) file for details.
## Changelog
## Credits
### 0.1.1
- Updated LICENSE file with correct GPL-2.0 text
### 0.1.0
- Initial release with basic template structure
- Added core plugin architecture
- Added admin interface components
- Added documentation templates
- Added AI workflow documentation
This template is based on the experience gained from developing the ["Fix 'Plugin file does not exist' Notices"](https://github.com/wpallstars/wp-fix-plugin-does-not-exist-notices) plugin by WPALLSTARS.

188
readme.txt
View File

@ -1,11 +1,11 @@
=== WordPress Plugin Starter Template ===
Contributors: wpallstars, your_wp_username
Donate link: https://www.wpallstars.com
Contributors: wpallstars
Donate link: https://www.wpallstars.com/
Tags: starter, template, boilerplate, plugin development, ai coding
Requires at least: 5.0
Tested up to: 6.4
Requires PHP: 7.0
Stable tag: 0.1.1
Stable tag: 0.1.2
License: GPL-2.0+
License URI: https://www.gnu.org/licenses/gpl-2.0.html
@ -13,62 +13,117 @@ A comprehensive starter template for WordPress plugins with best practices for A
== Description ==
The WordPress Plugin Starter Template provides a solid foundation for developing WordPress plugins with AI assistance. It includes a well-structured codebase, documentation templates, and best practices to help you create high-quality WordPress plugins efficiently.
The WordPress Plugin Starter Template provides a solid foundation for developing WordPress plugins. It incorporates best practices, modern coding standards, and a comprehensive structure that makes it easy to get started with plugin development.
This template is based on the experience gained from developing the "Fix 'Plugin file does not exist' Notices" plugin and other successful WordPress plugins.
= Key Features =
* **Well-structured codebase** following WordPress coding standards
* **Modular architecture** for easy maintenance and extension
* **Comprehensive documentation** templates for both users and developers
* **AI-friendly workflows** with detailed guidance for AI assistants
* **Git integration** with GitHub and Gitea support
* **Update mechanism** with multiple source options (WordPress.org, GitHub, Gitea)
* **Internationalization** ready with proper text domain setup
* **Admin interface** components for building settings pages
* **Object-Oriented Architecture**: Well-structured, maintainable code using OOP principles
* **Namespace Support**: Modern PHP namespacing for better organization and avoiding conflicts
* **Comprehensive Documentation**: Detailed documentation for both users and developers
* **Testing Framework**: PHPUnit setup for unit testing
* **Internationalization Ready**: Full support for translation and localization
* **Update Source Selection**: Choose between WordPress.org, GitHub, or Gitea for plugin updates
* **AI Workflow Documentation**: Detailed guides for AI-assisted development
* **Wiki Documentation**: Ready-to-use wiki structure for comprehensive documentation
= For Developers =
= How to Use This Template =
This template is designed to be a starting point for your WordPress plugin development. It provides:
1. Clone or download this repository
2. **Important**: Begin by reading the STARTER-PROMPT.md file for detailed instructions
3. Add the .ai-assistant.md file and .ai-workflows/ directory to your AI IDE chat context (pin them if possible)
4. Use the prompt in STARTER-PROMPT.md to guide the AI in customizing the template for your plugin
5. Rename files and update namespaces to match your plugin
6. Customize the functionality for your specific needs
7. Update documentation to reflect your plugin's features
8. Build and test your plugin
* A clean, well-organized file structure
* OOP approach with namespaced classes
* Separation of concerns (admin, core functionality)
* Documentation templates for wiki and readme files
* GitHub Actions workflows for automated tasks
* AI workflow documentation for AI-assisted development
For detailed instructions, see the [STARTER-PROMPT.md](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/blob/main/STARTER-PROMPT.md) file.
= Credits =
= AI-Assisted Development =
This template is based on the experience and best practices developed while creating the [Fix 'Plugin file does not exist' Notices](https://github.com/wpallstars/wp-fix-plugin-does-not-exist-notices) plugin.
This template includes comprehensive documentation for AI-assisted development:
* **.ai-assistant.md**: Guide for AI assistants to understand the project structure
* **.ai-workflows/**: Detailed workflow documentation for common development tasks
* **STARTER-PROMPT.md**: Comprehensive prompt for AI tools to help customize the template
**Important**: For the best AI assistance, add the .ai-assistant.md file and .ai-workflows/ directory to your AI IDE chat context. In most AI IDEs, you can pin these files to ensure they're considered in each message.
= Support & Feedback =
If you need help with this template, there are several ways to get support:
* [GitHub Issues](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/issues)
* [Gitea Issues](https://gitea.wpallstars.com/wpallstars/wp-plugin-starter-template-for-ai-coding/issues)
= Contributing =
Contributions are welcome! Please feel free to submit a Pull Request.
1. Fork the repository on [GitHub](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/) or [Gitea](https://gitea.wpallstars.com/wpallstars/wp-plugin-starter-template-for-ai-coding/)
2. Create your feature branch: `git checkout -b feature/amazing-feature`
3. Commit your changes: `git commit -m 'Add some amazing feature'`
4. Push to the branch: `git push origin feature/amazing-feature`
5. Submit a pull request
== Installation ==
1. Download the plugin zip file
2. Log in to your WordPress admin dashboard
3. Go to Plugins > Add New
4. Click the "Upload Plugin" button at the top of the page
5. Select the zip file and click "Install Now"
6. Activate the plugin through the 'Plugins' menu in WordPress
1. Clone or download this repository
2. Read the STARTER-PROMPT.md file for detailed instructions
3. Add the .ai-assistant.md file and .ai-workflows/ directory to your AI IDE chat context
4. Use the prompt in STARTER-PROMPT.md to guide the AI in customizing the template
5. Rename files and update namespaces to match your plugin
6. Customize the functionality for your specific needs
7. Update documentation to reflect your plugin's features
8. Build and test your plugin
For detailed instructions, see the [STARTER-PROMPT.md](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/blob/main/STARTER-PROMPT.md) file.
== Frequently Asked Questions ==
= How do I use this template? =
= How do I customize this template for my plugin? =
This template is meant to be a starting point for your own plugin development. You should:
See the [STARTER-PROMPT.md](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding/blob/main/STARTER-PROMPT.md) file for detailed instructions on customizing this template for your specific plugin needs. Make sure to add the .ai-assistant.md file and .ai-workflows/ directory to your AI IDE chat context for the best results.
1. Copy the template files to your new plugin directory
2. Rename files and update namespaces to match your plugin name
3. Update plugin headers in the main PHP file
4. Customize the functionality to meet your specific needs
5. Update documentation to reflect your plugin's features
= What files do I need to update with my plugin information? =
= Is this template suitable for all types of plugins? =
The main files you need to update include:
1. Main plugin file (rename and update header)
2. README.md
3. readme.txt
4. CHANGELOG.md
5. composer.json
6. languages/pot file
7. .github/workflows/
8. .wiki/
9. .ai-assistant.md
10. includes/plugin.php
11. includes/core.php
12. admin/lib/admin.php
Yes, this template provides a solid foundation for most WordPress plugins. It's designed to be flexible and can be adapted for various types of plugins, from simple utilities to complex applications.
= How do I build and test my plugin? =
= How do I contribute to this template? =
Use the included build.sh script to create a deployable version of your plugin:
Contributions are welcome! Please feel free to submit a pull request or open an issue on the [GitHub repository](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding).
```bash
./build.sh {VERSION}
```
This will create a ZIP file that you can install in WordPress.
= How do I add custom functionality to my plugin? =
Customize the includes/core.php file to implement your core functionality and the admin/lib/admin.php file for admin-specific functionality.
= How do I update the namespace for my plugin? =
You'll need to update all namespace references from WPALLSTARS\PluginStarterTemplate to your own namespace throughout the codebase.
= How do I update the text domain for my plugin? =
You'll need to update all text domain references from 'wp-plugin-starter-template' to your own text domain throughout the codebase.
== Screenshots ==
@ -76,46 +131,31 @@ Contributions are welcome! Please feel free to submit a pull request or open an
== Changelog ==
= 0.1.2 =
* Added: STARTER-PROMPT.md with comprehensive guide for customizing the template
* Updated: Documentation files with improved instructions
* Added: Additional AI workflow files for better development guidance
= 0.1.1 =
* Updated LICENSE file with correct GPL-2.0 text
* Updated: LICENSE file with correct GPL-2.0 text
= 0.1.0 =
* Initial release with basic template structure
* Added core plugin architecture
* Added admin interface components
* Added documentation templates
* Added AI workflow documentation
* Added: Core plugin architecture with OOP approach
* Added: Admin interface components and styling
* Added: Update mechanism with multiple source options
* Added: Documentation templates for users and developers
* Added: AI workflow documentation for AI-assisted development
* Added: GitHub Actions workflows for automated tasks
* Added: Wiki documentation templates
== Upgrade Notice ==
= 0.1.2 =
Added STARTER-PROMPT.md with comprehensive guide for customizing the template and improved documentation.
= 0.1.1 =
Updated LICENSE file with correct GPL-2.0 text.
= 0.1.0 =
Initial release of the WordPress Plugin Starter Template.
== Development ==
The development of this plugin follows these principles:
1. **Clean Code**: Following WordPress coding standards and best practices
2. **Modularity**: Keeping components separate and focused
3. **Documentation**: Comprehensive documentation for both users and developers
4. **Testing**: Thorough testing across different WordPress versions
5. **Accessibility**: Ensuring the plugin is accessible to all users
6. **Internationalization**: Making the plugin translatable
= Development Resources =
* [GitHub Repository](https://github.com/wpallstars/wp-plugin-starter-template-for-ai-coding)
* [WordPress Plugin Development Handbook](https://developer.wordpress.org/plugins/)
* [WordPress Coding Standards](https://developer.wordpress.org/coding-standards/)
= Contributing =
We welcome contributions to improve this template. Please feel free to:
* Report bugs or issues
* Suggest new features or improvements
* Submit pull requests with bug fixes or enhancements
== Credits ==
This template is maintained by [WPALLSTARS](https://www.wpallstars.com) and is based on the experience and best practices developed while creating the [Fix 'Plugin file does not exist' Notices](https://github.com/wpallstars/wp-fix-plugin-does-not-exist-notices) plugin.
Initial release with basic template structure and core functionality.