@iservu-inc/adf-cli 0.1.6 → 0.2.0

package/lib/frameworks/output-generators.js

@@ -0,0 +1,345 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Output Generators
+ * Transform Q&A responses into framework-specific documents
+ */
+
+async function generatePRP(answers, outputPath) {
+  const prp = `# Product Requirement Prompt (PRP)
+
+**Generated:** ${new Date().toISOString()}
+
+---
+
+## 1. Goal Definition
+
+### What We're Building
+${answers['prp-1'] || 'Not provided'}
+
+### Primary User Action
+${answers['prp-2'] || 'Not provided'}
+
+### Problem Being Solved
+${answers['prp-3'] || 'Not provided'}
+
+### Success Criteria
+${answers['prp-4'] || 'Not provided'}
+
+---
+
+## 2. Business Justification
+
+### Value to Users
+${answers['prp-5'] || 'Not provided'}
+
+### Cost of NOT Building
+${answers['prp-6'] || 'Not provided'}
+
+### Usage Pattern
+${answers['prp-7'] || 'Not provided'}
+
+---
+
+## 3. Contextual Intelligence
+
+### Technology Stack
+${answers['prp-8'] || 'Not provided'}
+
+### Files & Directories
+${answers['prp-9'] || 'Not provided'}
+
+### Libraries & Packages
+${answers['prp-10'] || 'Not provided'}
+
+### Code Patterns to Follow
+${answers['prp-11'] || 'Not provided'}
+
+### Documentation References
+${answers['prp-12'] || 'Not provided'}
+
+---
+
+## 4. Implementation Blueprint
+
+### Implementation Steps
+${answers['prp-13'] || 'Not provided'}
+
+### Data Model
+${answers['prp-14'] || 'Not provided'}
+
+### API Design
+${answers['prp-15'] || 'Not provided'}
+
+### Edge Cases & Error Handling
+${answers['prp-16'] || 'Not provided'}
+
+### Technical Approach
+${answers['prp-17'] || 'Not provided'}
+
+---
+
+## 5. Validation
+
+### Manual Testing Steps
+${answers['prp-18'] || 'Not provided'}
+
+### Automated Tests Required
+${answers['prp-19'] || 'Not provided'}
+
+### Definition of Done
+${answers['prp-20'] || 'Not provided'}
+
+---
+
+## AI Agent Instructions
+
+**Implement the above feature following this blueprint:**
+
+1. Start with the implementation steps in Section 4
+2. Reference the code patterns and documentation in Section 3
+3. Implement the data model and API design as specified
+4. Handle all edge cases listed
+5. Write tests as specified in Section 5
+6. Validate against the Definition of Done
+
+**Success Criteria:** ${answers['prp-4'] || 'See Section 1'}
+`;
+
+  await fs.writeFile(path.join(outputPath, 'prp.md'), prp, 'utf-8');
+}
+
+async function generateBalanced(answers, outputPath) {
+  // Constitution
+  const constitution = `# Project Constitution
+
+**Generated:** ${new Date().toISOString()}
+
+## Code Quality Standards
+${answers['bal-21'] || 'Not provided'}
+
+## Testing Requirements
+${answers['bal-22'] || 'Not provided'}
+
+## Documentation Standards
+${answers['bal-23'] || 'Not provided'}
+
+## UX/Accessibility Principles
+${answers['bal-24'] || 'Not provided'}
+
+## Security Standards
+${answers['bal-25'] || 'Not provided'}
+
+## Decision-Making Guidelines
+${answers['bal-26'] || 'Not provided'}
+`;
+
+  // Specification
+  const specification = `# Specification
+
+**Generated:** ${new Date().toISOString()}
+
+---
+
+## Overview
+
+### Goal
+${answers['prp-1'] || 'Not provided'}
+
+### Problem
+${answers['prp-3'] || 'Not provided'}
+
+### Success Criteria
+${answers['prp-4'] || 'Not provided'}
+
+---
+
+## Features & Requirements
+
+### All Features with Priorities
+${answers['bal-27'] || 'Not provided'}
+
+### Feature Behaviors
+${answers['bal-28'] || 'Not provided'}
+
+### Out of Scope
+${answers['bal-29'] || 'Not provided'}
+
+### Integration Requirements
+${answers['bal-30'] || 'Not provided'}
+
+### User Workflow
+${answers['bal-31'] || 'Not provided'}
+
+### Edge Cases
+${answers['bal-32'] || 'Not provided'}
+
+### UI/UX Specifications
+${answers['bal-33'] || 'Not provided'}
+
+### Assumptions
+${answers['bal-34'] || 'Not provided'}
+
+### Open Questions
+${answers['bal-35'] || 'Not provided'}
+
+---
+
+## Technical Context
+
+### Technology Stack
+${answers['prp-8'] || 'Not provided'}
+
+### Files & Directories
+${answers['prp-9'] || 'Not provided'}
+
+### Dependencies
+${answers['prp-10'] || 'Not provided'}
+
+### Code Patterns
+${answers['prp-11'] || 'Not provided'}
+
+### Documentation
+${answers['prp-12'] || 'Not provided'}
+`;
+
+  // Technical Plan
+  const plan = `# Technical Plan
+
+**Generated:** ${new Date().toISOString()}
+
+---
+
+## Architecture
+
+### Technology Choice Justification
+${answers['bal-36'] || 'Not provided'}
+
+### Architectural Pattern
+${answers['bal-37'] || 'Not provided'}
+
+### Database Design
+${answers['bal-38'] || 'Not provided'}
+
+### API Design
+${answers['bal-39'] || 'Not provided'}
+
+### Authentication/Authorization
+${answers['bal-40'] || 'Not provided'}
+
+### Third-Party Services
+${answers['bal-41'] || 'Not provided'}
+
+### Deployment Architecture
+${answers['bal-42'] || 'Not provided'}
+
+### Performance Strategy
+${answers['bal-43'] || 'Not provided'}
+
+---
+
+## Implementation Details
+
+### Steps
+${answers['prp-13'] || 'Not provided'}
+
+### Data Model
+${answers['prp-14'] || 'Not provided'}
+
+### API Endpoints
+${answers['prp-15'] || 'Not provided'}
+
+### Error Handling
+${answers['prp-16'] || 'Not provided'}
+
+### Technical Approach
+${answers['prp-17'] || 'Not provided'}
+`;
+
+  // Tasks
+  const tasks = `# Implementation Tasks
+
+**Generated:** ${new Date().toISOString()}
+
+---
+
+## Task Breakdown
+
+### All Tasks (Dependency Order)
+${answers['bal-44'] || 'Not provided'}
+
+### Critical Path
+${answers['bal-45'] || 'Not provided'}
+
+### Parallel Tasks
+${answers['bal-46'] || 'Not provided'}
+
+### Milestones
+${answers['bal-47'] || 'Not provided'}
+
+### Testing Strategy
+${answers['bal-48'] || 'Not provided'}
+
+### Effort Estimates
+${answers['bal-49'] || 'Not provided'}
+
+---
+
+## Validation
+
+### Manual Testing
+${answers['prp-18'] || 'Not provided'}
+
+### Automated Tests
+${answers['prp-19'] || 'Not provided'}
+
+### Project Definition of Done
+${answers['bal-50'] || 'Not provided'}
+`;
+
+  await fs.writeFile(path.join(outputPath, 'constitution.md'), constitution, 'utf-8');
+  await fs.writeFile(path.join(outputPath, 'specification.md'), specification, 'utf-8');
+  await fs.writeFile(path.join(outputPath, 'plan.md'), plan, 'utf-8');
+  await fs.writeFile(path.join(outputPath, 'tasks.md'), tasks, 'utf-8');
+}
+
+async function generateBMAD(answers, outputPath) {
+  // For now, BMAD uses the balanced outputs + additional strategic docs
+  // Full BMAD implementation would include PRD, Architecture, and Stories
+  await generateBalanced(answers, outputPath);
+
+  const prd = `# Product Requirements Document
+
+**Generated:** ${new Date().toISOString()}
+
+## Business Overview
+[BMAD questions would populate this section]
+
+## Market Analysis
+[BMAD questions would populate this section]
+
+## Complete Requirements
+See specification.md for detailed requirements.
+`;
+
+  const architecture = `# Architecture Document
+
+**Generated:** ${new Date().toISOString()}
+
+## System Architecture
+See plan.md for technical architecture details.
+
+## Advanced Architecture Considerations
+[BMAD-specific architecture questions would populate this]
+`;
+
+  await fs.writeFile(path.join(outputPath, 'prd.md'), prd, 'utf-8');
+  await fs.writeFile(path.join(outputPath, 'architecture.md'), architecture, 'utf-8');
+}
+
+module.exports = {
+  generatePRP,
+  generateBalanced,
+  generateBMAD
+};

package/lib/frameworks/progress-tracker.js

@@ -0,0 +1,239 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Real-time Progress Tracker
+ * Tracks interview progress and enables resume capability
+ */
+
+class ProgressTracker {
+  constructor(sessionPath, totalBlocks, framework = null) {
+    this.sessionPath = sessionPath;
+    this.progressFile = path.join(sessionPath, '_progress.json');
+    this.progressBackupFile = path.join(sessionPath, '_progress.backup.json');
+    this.progressLogFile = path.join(sessionPath, '_progress-log.md');
+    this.totalBlocks = totalBlocks;
+    this.progress = {
+      sessionId: path.basename(sessionPath),
+      framework: framework, // Store framework for resume
+      status: 'in-progress',
+      startedAt: new Date().toISOString(),
+      lastUpdated: new Date().toISOString(),
+      completedAt: null,
+      totalBlocks: totalBlocks,
+      currentBlock: 0,
+      completedBlocks: [],
+      skippedBlocks: [],
+      totalQuestionsAnswered: 0,
+      informationRichness: 0, // Quality metric 0-100
+      averageAnswerQuality: 0, // Average quality score of all answers
+      totalWordCount: 0,
+      comprehensiveAnswers: 0, // Answers with quality >= 70
+      canResume: true,
+      lastQuestion: null,
+      answers: {}, // Store all answers here for resume
+      transcript: [] // Store transcript for resume
+    };
+  }
+
+  async initialize() {
+    // Check if progress file exists (resuming session)
+    if (await fs.pathExists(this.progressFile)) {
+      this.progress = await fs.readJson(this.progressFile);
+      this.progress.canResume = true;
+      return true; // Session can be resumed
+    }
+
+    // New session - create progress file
+    await this.save();
+    await this.initializeLog();
+    return false; // New session
+  }
+
+  async initializeLog() {
+    const log = `# Interview Progress Log
+
+**Session:** ${this.progress.sessionId}
+**Started:** ${this.progress.startedAt}
+**Status:** ${this.progress.status}
+
+---
+
+## Progress Timeline
+
+`;
+    await fs.writeFile(this.progressLogFile, log, 'utf-8');
+  }
+
+  async startBlock(blockNumber, blockTitle) {
+    this.progress.currentBlock = blockNumber;
+    this.progress.lastUpdated = new Date().toISOString();
+
+    await this.save();
+    await this.appendToLog(`\n### Block ${blockNumber}: ${blockTitle}\n**Started:** ${this.progress.lastUpdated}\n`);
+  }
+
+  async completeBlock(blockNumber, blockTitle, questionsAnswered) {
+    this.progress.completedBlocks.push({
+      number: blockNumber,
+      title: blockTitle,
+      questionsAnswered: questionsAnswered,
+      completedAt: new Date().toISOString()
+    });
+    this.progress.totalQuestionsAnswered += questionsAnswered;
+    this.progress.lastUpdated = new Date().toISOString();
+
+    await this.save();
+    await this.appendToLog(`**Completed:** ${this.progress.lastUpdated} | Questions answered: ${questionsAnswered}\n`);
+
+    this.displayProgress();
+  }
+
+  async skipBlock(blockNumber, blockTitle) {
+    this.progress.skippedBlocks.push({
+      number: blockNumber,
+      title: blockTitle,
+      skippedAt: new Date().toISOString()
+    });
+    this.progress.lastUpdated = new Date().toISOString();
+
+    await this.save();
+    await this.appendToLog(`**Skipped:** ${this.progress.lastUpdated}\n`);
+
+    this.displayProgress();
+  }
+
+  async answerQuestion(questionId, questionText, answer, qualityMetrics) {
+    this.progress.lastQuestion = {
+      id: questionId,
+      text: questionText,
+      answeredAt: new Date().toISOString()
+    };
+    this.progress.lastUpdated = new Date().toISOString();
+
+    // Store answer for resume capability
+    this.progress.answers[questionId] = {
+      text: answer,
+      quality: qualityMetrics,
+      timestamp: new Date().toISOString()
+    };
+
+    // Update quality metrics
+    this.progress.totalWordCount += qualityMetrics.wordCount;
+    if (qualityMetrics.isComprehensive) {
+      this.progress.comprehensiveAnswers++;
+    }
+
+    // Recalculate average quality
+    const allScores = Object.values(this.progress.answers).map(a => a.quality.qualityScore);
+    this.progress.averageAnswerQuality = Math.round(
+      allScores.reduce((sum, score) => sum + score, 0) / allScores.length
+    );
+
+    // Calculate information richness (weighted average)
+    const completionFactor = this.progress.completedBlocks.length / this.totalBlocks;
+    const qualityFactor = this.progress.averageAnswerQuality / 100;
+    this.progress.informationRichness = Math.round((completionFactor * 0.4 + qualityFactor * 0.6) * 100);
+
+    // Triple-redundant save
+    await this.saveWithBackup();
+  }
+
+  async saveWithBackup() {
+    try {
+      // Save 1: Main progress file
+      await fs.writeJson(this.progressFile, this.progress, { spaces: 2 });
+
+      // Save 2: Backup file (in case main gets corrupted)
+      await fs.writeJson(this.progressBackupFile, this.progress, { spaces: 2 });
+
+      // Save 3: Append to log (human-readable backup)
+      const timestamp = new Date().toISOString();
+      await fs.appendFile(
+        this.progressLogFile,
+        `\n💾 Auto-save: ${timestamp} | Questions: ${this.progress.totalQuestionsAnswered} | Quality: ${this.progress.averageAnswerQuality}% | Richness: ${this.progress.informationRichness}%\n`,
+        'utf-8'
+      );
+    } catch (error) {
+      console.error(chalk.red('\n⚠️  Save error (attempting recovery):'), error.message);
+
+      // Emergency save to timestamped file
+      const emergencyFile = path.join(this.sessionPath, `_emergency-${Date.now()}.json`);
+      await fs.writeJson(emergencyFile, this.progress, { spaces: 2 });
+      console.log(chalk.yellow(`   Emergency backup saved to: ${path.basename(emergencyFile)}\n`));
+    }
+  }
+
+  async addTranscriptEntry(entry) {
+    this.progress.transcript.push({
+      ...entry,
+      timestamp: new Date().toISOString()
+    });
+    await this.saveWithBackup();
+  }
+
+  async complete() {
+    this.progress.status = 'completed';
+    this.progress.completedAt = new Date().toISOString();
+    this.progress.canResume = false;
+
+    await this.save();
+    await this.appendToLog(`\n---\n\n## Session Completed\n**Finished:** ${this.progress.completedAt}\n**Total Questions Answered:** ${this.progress.totalQuestionsAnswered}\n`);
+  }
+
+  async save() {
+    await fs.writeJson(this.progressFile, this.progress, { spaces: 2 });
+  }
+
+  async appendToLog(text) {
+    await fs.appendFile(this.progressLogFile, text, 'utf-8');
+  }
+
+  displayProgress() {
+    const completed = this.progress.completedBlocks.length;
+    const skipped = this.progress.skippedBlocks.length;
+    const remaining = this.totalBlocks - completed - skipped;
+    const blockPercentage = Math.round((completed / this.totalBlocks) * 100);
+
+    // Show information richness (quality-based metric)
+    const richnessEmoji = this.progress.informationRichness >= 80 ? '🌟' :
+                         this.progress.informationRichness >= 60 ? '✨' :
+                         this.progress.informationRichness >= 40 ? '💫' : '⭐';
+
+    console.log(chalk.gray(`\n📊 Information Richness: ${richnessEmoji} ${this.progress.informationRichness}% | Avg Quality: ${this.progress.averageAnswerQuality}%`));
+    console.log(chalk.gray(`   Blocks: ${completed}/${this.totalBlocks} (${blockPercentage}%) | Questions: ${this.progress.totalQuestionsAnswered} | Words: ${this.progress.totalWordCount}`));
+
+    if (remaining > 0) {
+      console.log(chalk.gray(`   Remaining: ${remaining} blocks\n`));
+    } else {
+      console.log(chalk.green(`   🎉 All blocks completed!\n`));
+    }
+  }
+
+  async saveCheckpoint(message) {
+    await this.appendToLog(`\n💾 **Checkpoint:** ${message} - ${new Date().toISOString()}\n`);
+    await this.save();
+  }
+
+  getProgress() {
+    return this.progress;
+  }
+
+  canResume() {
+    return this.progress.canResume && this.progress.status === 'in-progress';
+  }
+
+  getResumeInfo() {
+    return {
+      sessionId: this.progress.sessionId,
+      lastUpdated: this.progress.lastUpdated,
+      completedBlocks: this.progress.completedBlocks.length,
+      totalBlocks: this.totalBlocks,
+      totalQuestionsAnswered: this.progress.totalQuestionsAnswered,
+      currentBlock: this.progress.currentBlock
+    };
+  }
+}
+
+module.exports = ProgressTracker;