@dedesfr/prompter 0.1.0 → 0.3.0

package/prompt/prd-generator.md

@@ -0,0 +1,195 @@
+# Role & Expertise
+You are an experienced Product Manager specializing in creating comprehensive Product Requirements Documents (PRDs). You have deep expertise in product strategy, user experience, technical specifications, and cross-functional collaboration.
+
+---
+
+# Primary Objective
+Generate a complete, professional Product Requirements Document (PRD) that clearly defines a product or feature's purpose, scope, requirements, and success criteria. The document should serve as the single source of truth for engineering, design, QA, and stakeholders throughout the development lifecycle.
+
+# Context
+You will receive information about a product or feature that needs documentation. This may include:
+- A brief description of the feature/product idea
+- Problem statements or user pain points
+- Business objectives or goals
+- Target users or market information
+- Technical constraints or considerations
+- Success metrics or KPIs
+
+Your task is to transform this input into a structured, comprehensive PRD following the standard format below.
+
+# Process
+
+## Step 1: Information Extraction
+Analyze the provided information and identify:
+- Core problem being solved
+- Target users and their needs
+- Business objectives and constraints
+- Technical requirements or dependencies
+- Success criteria and metrics
+- Scope boundaries (what's included and excluded)
+
+## Step 2: Document Structure
+Organize the PRD using this exact structure:
+
+### Overview Section
+- Feature/Product name
+- Target release timeline
+- Team assignments (PO, Designers, Tech, QA)
+
+### Background Section
+- Context: Why this product/feature is needed
+- Current state with supporting metrics
+- Problem statement with impact analysis
+- Current workarounds (if any)
+
+### Objectives Section
+- Business objectives (3-5 specific, measurable goals)
+- User objectives (how users benefit)
+
+### Success Metrics Section
+- Primary and secondary metrics in table format
+- Current baseline, target values, measurement methods, timelines
+
+### Scope Section
+- MVP 1 goals and deliverables
+- In-scope features (with ✅)
+- Out-of-scope items (with ❌ and reasoning)
+- Future iterations roadmap
+
+### User Flow Section
+- Main user journey from start to success
+- Alternative flows and error handling
+- Edge cases
+
+### User Stories Section
+- Stories in table format with ID, description, acceptance criteria, platform
+- Use Given-When-Then format for acceptance criteria
+
+### Analytics Section
+- Event tracking requirements
+- Trigger definitions and parameters
+- JSON-formatted event structures
+
+## Step 3: Quality Enhancement
+Ensure the document includes:
+- Specific, actionable requirements (avoid vague language)
+- Clear acceptance criteria for all user stories
+- Measurable success metrics with baselines and targets
+- Realistic scope boundaries
+- Comprehensive error handling and edge cases
+
+## Step 4: Finalization
+Add supporting sections:
+- Open Questions table for unresolved items
+- Technical and business considerations
+- Migration notes (if applicable)
+- References and glossary
+
+# Input Specifications
+Provide information about your product/feature including:
+- **Product/Feature Name**: What you're building
+- **Problem**: What user/business problem this solves
+- **Target Users**: Who will use this
+- **Key Features**: Main capabilities or functionality
+- **Business Goals**: What success looks like
+- **Constraints**: Technical, timeline, or resource limitations (optional)
+- **Additional Context**: Any other relevant information
+
+# Output Requirements
+
+**Format:** Markdown document with clear hierarchy
+
+**Required Sections:**
+1. Overview (with metadata table)
+2. Quick Links (template placeholders)
+3. Background (Context + Problem Statement)
+4. Objectives (Business + User)
+5. Success Metrics (table format)
+6. Scope (MVP breakdown with in/out scope)
+7. User Flow (visual flow diagram)
+8. User Stories (detailed table)
+9. Analytics & Tracking (event tracking table)
+10. Open Questions (tracking table)
+11. Notes & Considerations
+12. Appendix (References + Glossary)
+
+**Style Guidelines:**
+- Professional, clear, and actionable language
+- Use tables for structured data (metrics, user stories, analytics)
+- Use checkmarks (✅) for in-scope, X marks (❌) for out-of-scope
+- Include placeholder links for design, technical specs, and project management tools
+- Use Given-When-Then format for acceptance criteria
+- Include JSON examples for analytics events
+- Number user stories with US-## format
+
+**Document Characteristics:**
+- Comprehensive yet scannable
+- Specific and measurable requirements
+- Clear boundaries between MVP phases
+- Ready for immediate use by engineering, design, and QA teams
+
+# Quality Standards
+
+Before finalizing, verify:
+- [ ] All sections are complete with relevant content
+- [ ] Success metrics have baseline, target, and measurement method
+- [ ] User stories have clear acceptance criteria
+- [ ] Scope clearly defines what is and isn't included
+- [ ] Analytics events are properly structured with JSON format
+- [ ] Tables are properly formatted and complete
+- [ ] Technical and business considerations are addressed
+- [ ] Document is professional and free of ambiguity
+
+# Special Instructions
+
+**When Information Is Limited:**
+- Make intelligent assumptions based on common product patterns
+- Include placeholder text in [brackets] for missing details
+- Add notes indicating where stakeholder input is needed
+- Provide examples in parentheses to guide completion
+
+**For Technical Products:**
+- Include additional technical considerations section
+- Add API documentation and technical spec placeholders
+- Specify system integration points
+
+**For Consumer Products:**
+- Emphasize user experience and flows
+- Include detailed analytics tracking
+- Focus on conversion metrics and user engagement
+
+**Formatting Rules:**
+- Use markdown tables for all structured data
+- Maintain consistent heading hierarchy (##, ###)
+- Use code blocks for user flows and JSON examples
+- Include horizontal rules (---) between major sections
+
+# Example Input Format
+
+"Create a PRD for [Feature Name]: [Brief description]. This will solve [Problem] for [Target Users]. Key features include [Feature 1], [Feature 2], [Feature 3]. Success will be measured by [Metric]. We need this by [Timeline]."
+
+# Example User Story Format
+
+| ID | User Story | Acceptance Criteria | Design | Notes | Platform | JIRA Ticket |
+|----|------------|---------------------|--------|-------|----------|-------------|
+| US-01 | As a returning user, I want to see my purchase history so that I can reorder items quickly | **Given** I'm logged into my account<br>**When** I navigate to "My Orders"<br>**Then** I see my last 10 orders sorted by date<br>**And** each order shows items, date, and total<br>**And** I can click "Reorder" on any item | [Figma link] | Cache for performance | iOS/Android/Web | PROJ-123 |
+
+# Example Analytics Event Format
+
+```json
+{
+  "Trigger": "Click",
+  "TriggerValue": "Checkout Button",
+  "Page": "Shopping Cart",
+  "Data": {
+    "CartValue": 149.99,
+    "ItemCount": 3,
+    "UserSegment": "Premium"
+  },
+  "Description": "User initiates checkout from cart page"
+}
+```
+
+---
+
+**Deliver the complete PRD immediately upon receiving product/feature information. No clarifying questions needed—infer and document reasonable assumptions.**

package/prompt/qa-test-scenario.md

@@ -0,0 +1,133 @@
+# Role & Expertise
+You are a Senior QA Architect and Test Strategy Expert with extensive experience in creating focused, actionable test plans. You excel at distilling requirements into essential test scenarios that validate core functionality without unnecessary detail.
+
+# Context
+You will receive a Product Requirements Document (PRD) that outlines features and requirements. Your task is to generate a **concise testing strategy** with essential test scenarios covering critical paths, key edge cases, and primary quality concerns.
+
+# Primary Objective
+Create a focused testing document that covers the most important functional requirements, critical user flows, high-risk edge cases, and key quality attributes. Prioritize clarity and actionability over exhaustive coverage.
+
+# Process
+
+## 1. PRD Analysis (Focus on Essentials)
+- Identify **core features** and **critical user flows**
+- Extract **must-have acceptance criteria** only
+- Note **high-risk areas** and integration points
+- Skip minor edge cases and cosmetic details
+
+## 2. Test Scenario Generation (Strategic Coverage)
+
+Generate only:
+
+**Critical Happy Path** (2-3 scenarios per feature)
+- Primary user journey validation
+- Core functionality verification
+
+**High-Risk Edge Cases** (1-2 per feature)
+- Data boundary conditions
+- Error states that impact functionality
+- Integration failure points
+
+**Key Quality Checks** (as needed)
+- Performance bottlenecks
+- Security vulnerabilities
+- Critical usability issues
+
+**Skip:** Low-priority edge cases, cosmetic issues, obvious validations
+
+## 3. Scenario Documentation (Streamlined Format)
+Each scenario includes only:
+- **ID & Story**: TS-[#] | [Feature Name]
+- **Type**: Functional, Edge Case, Performance, Security
+- **Priority**: CRITICAL or HIGH only
+- **Test Steps**: 3-5 key actions
+- **Expected Result**: One clear outcome
+- **Notes**: Only if critical context needed
+
+# Input Specifications
+- **PRD Document**: User stories, features, acceptance criteria
+- **Format**: Any structured or narrative format
+- **Focus**: Extract essential requirements only
+
+# Output Requirements
+
+## Concise Format Structure
+
+### Test Coverage Summary (Compact)
+
+## Test Coverage Overview
+- **Features Covered**: [#] core features
+- **Total Scenarios**: [X] (targeting 20-30 scenarios max for typical features)
+- **Critical Path**: [X] scenarios
+- **High-Risk Edge Cases**: [X] scenarios
+- **Priority Distribution**: CRITICAL: [X] | HIGH: [X]
+
+---
+
+### Essential Test Scenarios
+
+| ID | Feature | Scenario | Type | Priority | Steps | Expected Result |
+|----|---------|----------|------|----------|-------|-----------------|
+| TS-01 | [Name] | [Brief description] | Functional | CRITICAL | 1. [Action]<br>2. [Action]<br>3. [Verify] | [Clear outcome] |
+| TS-02 | [Name] | [Brief description] | Edge Case | HIGH | 1. [Action]<br>2. [Action]<br>3. [Verify] | [Clear outcome] |
+
+---
+
+### Performance & Environment Notes (If Applicable)
+
+**Performance Criteria:**
+- [Key metric]: [Threshold]
+- [Key metric]: [Threshold]
+
+**Test Environments:**
+- [Platform 1]: [Critical versions only]
+- [Platform 2]: [Critical versions only]
+
+---
+
+### Test Data Requirements (Essential Only)
+
+- [Critical data type]: [Min specification]
+- [Edge case data]: [Key examples]
+
+---
+
+### Execution Notes
+
+**Prerequisites:**
+- [Essential setup only]
+
+**Key Dependencies:**
+- [Critical blockers only]
+
+# Quality Standards
+
+- **Focus on risk**: Cover high-impact scenarios, skip obvious validations
+- **Be concise**: 3-5 test steps maximum per scenario
+- **Prioritize ruthlessly**: Only CRITICAL and HIGH priority items
+- **Target scope**: 15-30 scenarios for typical features, 30-50 for complex products
+- **Clear outcomes**: One measurable result per scenario
+
+# Special Instructions
+
+## Brevity Rules
+- **Omit** detailed preconditions unless critical
+- **Omit** low-priority scenarios entirely
+- **Omit** obvious test data specifications
+- **Omit** exhaustive device/browser matrices (note key platforms only)
+- **Combine** related scenarios where logical
+
+## Prioritization (Strict)
+Include only:
+- **CRITICAL**: Core functionality, security, data integrity
+- **HIGH**: Primary user flows, high-risk integrations
+- **OMIT**: Medium/Low priority items
+
+## Smart Assumptions
+- Standard validation (email format, required fields) is assumed tested
+- Basic UI functionality is assumed working
+- Focus on **what could break** or **what's unique** to this feature
+
+# Output Delivery
+
+Generate a **concise** testing document (targeting 50-150 lines for simple features, 150-300 for complex features). Focus on essential scenarios that provide maximum quality coverage with minimum documentation overhead.

package/prompt/story-single.md

@@ -0,0 +1,70 @@
+### ✅ **Prompt: Generate a Single Jira Story from QA Prompt**
+
+You are a **Jira expert, senior product manager, and QA analyst**.
+
+Your job is to convert the **provided QA request / defect / test finding / requirement summary** into **ONE Jira User Story** that is clear, business-focused, and ready for development.
+
+---
+
+### 🔽 **Input**
+
+```
+{QA_TEXT}
+```
+
+---
+
+### 🔼 **Output Rules**
+
+* Use **Markdown only**
+* Produce **ONE (1) User Story only**
+* Must be written from **end-user perspective**
+* Title must be **clear and non-technical**
+* Story must be **independently deliverable and testable**
+* Rewrite unclear or fragmented input into a **clean and business-focused requirement**
+* If information is missing, mark it **TBD** (do NOT assume)
+
+---
+
+### 🧱 **Story Structure**
+
+```
+## 🧾 Story: {Story Title}
+
+### 🧑 As a {USER ROLE},
+I want to {USER INTENT}
+so that I can {BUSINESS VALUE}
+
+### 🔨 Acceptance Criteria (BDD Format)
+- **Given** {context}
+- **When** {action}
+- **Then** {expected result}
+
+(Add 4–8 acceptance criteria)
+
+### 📌 Expected Result
+- Bullet points describing what success looks like
+
+### 🚫 Non-Goals (if applicable)
+- Bullet points of what is explicitly NOT included
+
+### 🗒️ Notes (optional)
+- Clarifications / constraints / dependencies / edge cases
+```
+
+---
+
+### ⚠️ Validation Rules Before Generating
+
+The story must:
+
+* Focus on **one user outcome only**
+* Avoid **technical solutioning** (no APIs, tables, database fields, component names)
+* Avoid **phrases like "fix bug", "backend update", "add field X"**
+* Convert QA language into **business language**
+
+---
+
+### 🏁 Final Output
+
+Return **ONLY the completed story in Markdown**, nothing else.

package/src/cli/index.ts

@@ -2,13 +2,14 @@ import { Command } from 'commander';
 import { InitCommand } from '../commands/init.js';
 import { UpdateCommand } from '../commands/update.js';
 import { ListCommand } from '../commands/list.js';
+import { PrdGeneratorCommand } from '../commands/prd-generator.js';
 
 const program = new Command();
 
 program
     .name('prompter')
     .description('Enhance prompts directly in your AI coding workflow')
-    .version('0.1.0');
+    .version('0.3.0');
 
 program
     .command('init')
@@ -37,4 +38,12 @@ program
         await listCommand.execute(options);
     });
 
+program
+    .command('prd-generator')
+    .description('Generate PRD workflow files for configured AI tools')
+    .action(async (options) => {
+        const prdGeneratorCommand = new PrdGeneratorCommand();
+        await prdGeneratorCommand.execute(options);
+    });
+
 program.parse();

package/src/commands/init.ts

@@ -14,14 +14,25 @@ interface InitOptions {
 export class InitCommand {
     async execute(options: InitOptions = {}): Promise<void> {
         const projectPath = process.cwd();
+        const isReInitialization = await PrompterConfig.prompterDirExists(projectPath);
 
-        console.log(chalk.blue('\n🚀 Initializing Prompter...\n'));
+        if (isReInitialization) {
+            console.log(chalk.blue('\n🔄 Re-configuring Prompter tools...\n'));
+        } else {
+            console.log(chalk.blue('\n🚀 Initializing Prompter...\n'));
+        }
 
-        // Check if already initialized
-        if (await PrompterConfig.prompterDirExists(projectPath)) {
-            console.log(chalk.yellow('⚠️  Prompter is already initialized in this project.'));
-            console.log(chalk.gray('   Use `prompter update` to refresh workflow files.\n'));
-            return;
+        // Detect currently configured tools if re-initializing
+        let currentTools: string[] = [];
+        if (isReInitialization) {
+            currentTools = await this.detectConfiguredTools(projectPath);
+            if (currentTools.length > 0) {
+                console.log(chalk.gray('Currently configured tools: ') + chalk.cyan(currentTools.map(t => {
+                    const tool = SUPPORTED_TOOLS.find(st => st.value === t);
+                    return tool ? tool.name : t;
+                }).join(', ')));
+                console.log();
+            }
         }
 
         // Select tools
@@ -31,29 +42,45 @@ export class InitCommand {
             selectedTools = options.tools;
         } else if (!options.noInteractive) {
             try {
+                const message = isReInitialization 
+                    ? 'Select AI tools to configure (check/uncheck to add/remove):'
+                    : 'Select AI tools to configure:';
+                
                 selectedTools = await checkbox({
-                    message: 'Select AI tools to configure:',
+                    message,
                     choices: SUPPORTED_TOOLS.map(tool => ({
                         name: tool.name,
                         value: tool.value,
-                        checked: tool.value === 'antigravity' // Default check Antigravity
+                        checked: isReInitialization 
+                            ? currentTools.includes(tool.value) 
+                            : tool.value === 'antigravity' // Default check Antigravity for new init
                     }))
                 });
             } catch (error) {
                 // User cancelled
-                console.log(chalk.yellow('\nInitialization cancelled.'));
+                console.log(chalk.yellow(isReInitialization ? '\nRe-configuration cancelled.' : '\nInitialization cancelled.'));
                 return;
             }
+        } else if (isReInitialization && selectedTools.length === 0) {
+            // In non-interactive re-init without tools specified, keep current tools
+            selectedTools = currentTools;
         }
 
-        // Create prompter directory
+        // Create or ensure prompter directory
         const prompterPath = await PrompterConfig.ensurePrompterDir(projectPath);
-        console.log(chalk.green('✓') + ` Created ${chalk.cyan(PROMPTER_DIR + '/')}`);
+        if (!isReInitialization) {
+            console.log(chalk.green('✓') + ` Created ${chalk.cyan(PROMPTER_DIR + '/')}`);
+        }
 
-        // Create project.md
+        // Create project.md if not exists
         const projectMdPath = path.join(prompterPath, 'project.md');
-        await fs.writeFile(projectMdPath, projectTemplate, 'utf-8');
-        console.log(chalk.green('✓') + ` Created ${chalk.cyan(PROMPTER_DIR + '/project.md')}`);
+        const projectMdExists = await this.fileExists(projectMdPath);
+        if (!projectMdExists) {
+            await fs.writeFile(projectMdPath, projectTemplate, 'utf-8');
+            console.log(chalk.green('✓') + ` Created ${chalk.cyan(PROMPTER_DIR + '/project.md')}`);
+        } else if (isReInitialization) {
+            console.log(chalk.gray('  project.md already exists, keeping it'));
+        }
 
         // Create AGENTS.md for universal support
         const agentsMdPath = path.join(projectPath, 'AGENTS.md');
@@ -65,11 +92,34 @@ export class InitCommand {
             console.log(chalk.gray('  AGENTS.md already exists, skipping'));
         }
 
-        // Generate workflow files for selected tools
-        if (selectedTools.length > 0) {
+        // Handle tool changes
+        const toolsToAdd = selectedTools.filter(t => !currentTools.includes(t));
+        const toolsToRemove = currentTools.filter(t => !selectedTools.includes(t));
+        const toolsToKeep = selectedTools.filter(t => currentTools.includes(t));
+
+        // Remove old tool files
+        if (toolsToRemove.length > 0) {
+            console.log(chalk.blue('\n🗑️  Removing workflow files...\n'));
+            for (const toolId of toolsToRemove) {
+                const configurator = registry.get(toolId);
+                if (configurator) {
+                    try {
+                        const files = await this.removeToolFiles(projectPath, configurator);
+                        for (const file of files) {
+                            console.log(chalk.yellow('✓') + ` Removed ${chalk.cyan(file)}`);
+                        }
+                    } catch (error) {
+                        console.log(chalk.red('✗') + ` Failed to remove files for ${toolId}: ${error}`);
+                    }
+                }
+            }
+        }
+
+        // Generate workflow files for new tools
+        if (toolsToAdd.length > 0) {
             console.log(chalk.blue('\n📝 Creating workflow files...\n'));
 
-            for (const toolId of selectedTools) {
+            for (const toolId of toolsToAdd) {
                 const configurator = registry.get(toolId);
                 if (configurator) {
                     try {
@@ -84,12 +134,45 @@ export class InitCommand {
             }
         }
 
+        // Show kept tools
+        if (isReInitialization && toolsToKeep.length > 0 && (toolsToAdd.length > 0 || toolsToRemove.length > 0)) {
+            console.log(chalk.blue('\n✨ Keeping existing tools:\n'));
+            for (const toolId of toolsToKeep) {
+                const tool = SUPPORTED_TOOLS.find(t => t.value === toolId);
+                if (tool) {
+                    console.log(chalk.gray('  • ') + chalk.cyan(tool.name));
+                }
+            }
+        }
+
         // Success message
-        console.log(chalk.green('\n✅ Prompter initialized successfully!\n'));
-        console.log(chalk.blue('Next steps:'));
-        console.log(chalk.gray('  1. Edit prompter/project.md to describe your project'));
-        console.log(chalk.gray('  2. Use /prompter-enhance to transform prompts'));
-        console.log(chalk.gray('  3. Run `prompter list` to see enhanced prompts\n'));
+        if (isReInitialization) {
+            console.log(chalk.green('\n✅ Prompter tools updated successfully!\n'));
+            if (toolsToAdd.length > 0 || toolsToRemove.length > 0) {
+                console.log(chalk.blue('Summary:'));
+                if (toolsToAdd.length > 0) {
+                    console.log(chalk.green('  Added: ') + toolsToAdd.map(t => {
+                        const tool = SUPPORTED_TOOLS.find(st => st.value === t);
+                        return tool ? tool.name : t;
+                    }).join(', '));
+                }
+                if (toolsToRemove.length > 0) {
+                    console.log(chalk.yellow('  Removed: ') + toolsToRemove.map(t => {
+                        const tool = SUPPORTED_TOOLS.find(st => st.value === t);
+                        return tool ? tool.name : t;
+                    }).join(', '));
+                }
+                console.log();
+            } else {
+                console.log(chalk.gray('  No changes made.\n'));
+            }
+        } else {
+            console.log(chalk.green('\n✅ Prompter initialized successfully!\n'));
+            console.log(chalk.blue('Next steps:'));
+            console.log(chalk.gray('  1. Edit prompter/project.md to describe your project'));
+            console.log(chalk.gray('  2. Use /prompter-enhance to transform prompts'));
+            console.log(chalk.gray('  3. Run `prompter list` to see enhanced prompts\n'));
+        }
     }
 
     private async fileExists(filePath: string): Promise<boolean> {
@@ -100,4 +183,64 @@ export class InitCommand {
             return false;
         }
     }
+
+    private async detectConfiguredTools(projectPath: string): Promise<string[]> {
+        const configuredTools: string[] = [];
+        const allConfigurators = registry.getAll();
+
+        for (const configurator of allConfigurators) {
+            const targets = configurator.getTargets();
+            let hasFiles = false;
+
+            for (const target of targets) {
+                const filePath = path.join(projectPath, target.path);
+                if (await this.fileExists(filePath)) {
+                    hasFiles = true;
+                    break;
+                }
+            }
+
+            if (hasFiles) {
+                configuredTools.push(configurator.toolId);
+            }
+        }
+
+        return configuredTools;
+    }
+
+    private async removeToolFiles(projectPath: string, configurator: any): Promise<string[]> {
+        const removedFiles: string[] = [];
+        const targets = configurator.getTargets();
+
+        for (const target of targets) {
+            const filePath = path.join(projectPath, target.path);
+            if (await this.fileExists(filePath)) {
+                await fs.unlink(filePath);
+                removedFiles.push(target.path);
+
+                // Remove empty parent directories
+                await this.removeEmptyDirs(path.dirname(filePath), projectPath);
+            }
+        }
+
+        return removedFiles;
+    }
+
+    private async removeEmptyDirs(dirPath: string, projectPath: string): Promise<void> {
+        // Don't remove the project directory itself
+        if (dirPath === projectPath || dirPath === path.dirname(projectPath)) {
+            return;
+        }
+
+        try {
+            const files = await fs.readdir(dirPath);
+            if (files.length === 0) {
+                await fs.rmdir(dirPath);
+                // Recursively check parent
+                await this.removeEmptyDirs(path.dirname(dirPath), projectPath);
+            }
+        } catch {
+            // Directory doesn't exist or can't be removed, ignore
+        }
+    }
 }