pmp-gywd 3.3.0

package/lib/questioning/question-engine.js

@@ -0,0 +1,311 @@
+/**
+ * Adaptive Questioning Engine
+ *
+ * Generates context-aware questions that learn from responses.
+ * Core component of the "sophisticated brain" for v3.0.
+ */
+
+/**
+ * Question types for different purposes
+ */
+const QUESTION_TYPES = {
+  CLARIFYING: 'clarifying', // Clarify ambiguous requirements
+  EXPLORATORY: 'exploratory', // Discover unknown aspects
+  VALIDATING: 'validating', // Confirm assumptions
+  TECHNICAL: 'technical', // Technical decisions
+  PREFERENCE: 'preference', // User preferences
+  CONSTRAINT: 'constraint', // Identify constraints
+};
+
+/**
+ * Question priority levels
+ */
+const PRIORITY = {
+  CRITICAL: 'critical', // Must ask before proceeding
+  HIGH: 'high', // Important but can infer
+  MEDIUM: 'medium', // Good to know
+  LOW: 'low', // Nice to have
+};
+
+/**
+ * Question template structure
+ */
+const createQuestion = (opts) => ({
+  // Spread opts first to include any extra fields (expertText, beginnerText, etc.)
+  ...opts,
+  // Then set defaults for standard fields
+  id: opts.id || `q-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  type: opts.type || QUESTION_TYPES.CLARIFYING,
+  priority: opts.priority || PRIORITY.MEDIUM,
+  text: opts.text,
+  context: opts.context || null,
+  options: opts.options || null,
+  defaultAnswer: opts.defaultAnswer || null,
+  followUps: opts.followUps || [],
+  tags: opts.tags || [],
+  askCondition: opts.askCondition || null,
+  skipIfKnown: opts.skipIfKnown || [],
+});
+
+/**
+ * Adaptive Questioning Engine class
+ */
+class QuestionEngine {
+  constructor() {
+    this.questionHistory = [];
+    this.knowledgeBase = new Map();
+    this.askedQuestions = new Set();
+    this.userProfile = null;
+  }
+
+  /**
+   * Set user profile for personalized questions
+   * @param {object} profile - User profile from ProfileManager
+   */
+  setProfile(profile) {
+    this.userProfile = profile;
+  }
+
+  /**
+   * Record an answer to a question
+   * @param {string} questionId - Question ID
+   * @param {any} answer - The answer provided
+   * @param {object} metadata - Additional metadata
+   */
+  recordAnswer(questionId, answer, metadata = {}) {
+    this.questionHistory.push({
+      questionId,
+      answer,
+      timestamp: Date.now(),
+      ...metadata,
+    });
+
+    // Update knowledge base
+    if (metadata.knowledgeKey) {
+      this.knowledgeBase.set(metadata.knowledgeKey, {
+        value: answer,
+        source: 'direct-answer',
+        confidence: 1.0,
+        timestamp: Date.now(),
+      });
+    }
+
+    this.askedQuestions.add(questionId);
+  }
+
+  /**
+   * Record inferred knowledge
+   * @param {string} key - Knowledge key
+   * @param {any} value - Inferred value
+   * @param {number} confidence - Confidence level (0-1)
+   */
+  recordInference(key, value, confidence = 0.7) {
+    this.knowledgeBase.set(key, {
+      value,
+      source: 'inference',
+      confidence,
+      timestamp: Date.now(),
+    });
+  }
+
+  /**
+   * Check if we already know something
+   * @param {string} key - Knowledge key
+   * @param {number} minConfidence - Minimum confidence required
+   * @returns {boolean}
+   */
+  isKnown(key, minConfidence = 0.7) {
+    const knowledge = this.knowledgeBase.get(key);
+    if (!knowledge) return false;
+    return knowledge.confidence >= minConfidence;
+  }
+
+  /**
+   * Get known value
+   * @param {string} key - Knowledge key
+   * @returns {any} The known value or undefined
+   */
+  getKnowledge(key) {
+    const knowledge = this.knowledgeBase.get(key);
+    return knowledge ? knowledge.value : undefined;
+  }
+
+  /**
+   * Check if a question should be asked
+   * @param {object} question - Question object
+   * @returns {boolean}
+   */
+  shouldAsk(question) {
+    // Already asked this specific question
+    if (this.askedQuestions.has(question.id)) {
+      return false;
+    }
+
+    // Check skipIfKnown conditions
+    if (question.skipIfKnown && question.skipIfKnown.length > 0) {
+      const allKnown = question.skipIfKnown.every(key => this.isKnown(key));
+      if (allKnown) {
+        return false;
+      }
+    }
+
+    // Check custom ask condition
+    if (question.askCondition && typeof question.askCondition === 'function') {
+      return question.askCondition(this.knowledgeBase, this.userProfile);
+    }
+
+    return true;
+  }
+
+  /**
+   * Filter questions to only those that should be asked
+   * @param {Array} questions - Array of questions
+   * @returns {Array} Filtered questions
+   */
+  filterQuestions(questions) {
+    return questions.filter(q => this.shouldAsk(q));
+  }
+
+  /**
+   * Sort questions by priority
+   * @param {Array} questions - Array of questions
+   * @returns {Array} Sorted questions
+   */
+  sortByPriority(questions) {
+    const priorityOrder = {
+      [PRIORITY.CRITICAL]: 0,
+      [PRIORITY.HIGH]: 1,
+      [PRIORITY.MEDIUM]: 2,
+      [PRIORITY.LOW]: 3,
+    };
+
+    return [...questions].sort((a, b) => {
+      // Use ?? instead of || because 0 is a valid priority value
+      const aOrder = priorityOrder[a.priority] ?? 2;
+      const bOrder = priorityOrder[b.priority] ?? 2;
+      return aOrder - bOrder;
+    });
+  }
+
+  /**
+   * Get next questions to ask
+   * @param {Array} questions - Available questions
+   * @param {number} maxCount - Maximum number to return
+   * @returns {Array} Questions to ask
+   */
+  getNextQuestions(questions, maxCount = 3) {
+    const filtered = this.filterQuestions(questions);
+    const sorted = this.sortByPriority(filtered);
+    return sorted.slice(0, maxCount);
+  }
+
+  /**
+   * Adapt question depth based on user expertise
+   * @param {object} question - Question object
+   * @param {string} domain - Domain area
+   * @returns {object} Adapted question
+   */
+  adaptToExpertise(question, domain) {
+    if (!this.userProfile) return question;
+
+    const expertise = this.userProfile.domain?.expertiseAreas || [];
+    const isExpert = expertise.includes(domain);
+
+    if (isExpert) {
+      // Experts get more technical, less explanation
+      return {
+        ...question,
+        text: question.expertText || question.text,
+        options: question.expertOptions || question.options,
+      };
+    }
+
+    // Non-experts get more context
+    return {
+      ...question,
+      text: question.beginnerText || question.text,
+      context: question.beginnerContext || question.context,
+    };
+  }
+
+  /**
+   * Generate follow-up questions based on answer
+   * @param {object} question - Original question
+   * @param {any} answer - The answer provided
+   * @returns {Array} Follow-up questions
+   */
+  generateFollowUps(question, answer) {
+    if (!question.followUps || question.followUps.length === 0) {
+      return [];
+    }
+
+    return question.followUps
+      .filter(fu => {
+        if (fu.condition && typeof fu.condition === 'function') {
+          return fu.condition(answer);
+        }
+        if (fu.triggerAnswer !== undefined) {
+          return fu.triggerAnswer === answer;
+        }
+        return true;
+      })
+      .map(fu => createQuestion(fu));
+  }
+
+  /**
+   * Get question history summary
+   * @returns {object} Summary of asked questions
+   */
+  getHistorySummary() {
+    const byType = {};
+    const byPriority = {};
+
+    for (const entry of this.questionHistory) {
+      const q = entry;
+      byType[q.type] = (byType[q.type] || 0) + 1;
+      byPriority[q.priority] = (byPriority[q.priority] || 0) + 1;
+    }
+
+    return {
+      totalAsked: this.questionHistory.length,
+      byType,
+      byPriority,
+      knowledgeCount: this.knowledgeBase.size,
+    };
+  }
+
+  /**
+   * Clear all state (for testing)
+   */
+  clear() {
+    this.questionHistory = [];
+    this.knowledgeBase.clear();
+    this.askedQuestions.clear();
+    this.userProfile = null;
+  }
+
+  /**
+   * Export current knowledge base
+   * @returns {object} Knowledge base as plain object
+   */
+  exportKnowledge() {
+    return Object.fromEntries(this.knowledgeBase);
+  }
+
+  /**
+   * Import knowledge base
+   * @param {object} knowledge - Knowledge to import
+   */
+  importKnowledge(knowledge) {
+    for (const [key, value] of Object.entries(knowledge)) {
+      this.knowledgeBase.set(key, value);
+    }
+  }
+}
+
+module.exports = {
+  QuestionEngine,
+  QUESTION_TYPES,
+  PRIORITY,
+  createQuestion,
+};

package/lib/questioning/question-templates.js

@@ -0,0 +1,315 @@
+/**
+ * Question Templates
+ *
+ * Predefined question templates for common development scenarios.
+ * Used by the Adaptive Questioning Engine.
+ */
+
+const { QUESTION_TYPES, PRIORITY, createQuestion } = require('./question-engine');
+
+/**
+ * Project initialization questions
+ */
+const PROJECT_QUESTIONS = [
+  createQuestion({
+    id: 'project-type',
+    type: QUESTION_TYPES.CLARIFYING,
+    priority: PRIORITY.CRITICAL,
+    text: 'What type of project is this?',
+    options: [
+      { value: 'web-app', label: 'Web Application' },
+      { value: 'api', label: 'API/Backend Service' },
+      { value: 'cli', label: 'Command Line Tool' },
+      { value: 'library', label: 'Library/Package' },
+      { value: 'mobile', label: 'Mobile Application' },
+      { value: 'other', label: 'Other' },
+    ],
+    tags: ['project', 'initialization'],
+    skipIfKnown: ['project.type'],
+  }),
+
+  createQuestion({
+    id: 'project-scale',
+    type: QUESTION_TYPES.EXPLORATORY,
+    priority: PRIORITY.HIGH,
+    text: 'What is the expected scale of this project?',
+    options: [
+      { value: 'prototype', label: 'Prototype/POC' },
+      { value: 'small', label: 'Small (1-5 files)' },
+      { value: 'medium', label: 'Medium (5-20 files)' },
+      { value: 'large', label: 'Large (20+ files)' },
+      { value: 'enterprise', label: 'Enterprise scale' },
+    ],
+    tags: ['project', 'scope'],
+    skipIfKnown: ['project.scale'],
+  }),
+
+  createQuestion({
+    id: 'project-team',
+    type: QUESTION_TYPES.EXPLORATORY,
+    priority: PRIORITY.MEDIUM,
+    text: 'Who will be working on this project?',
+    options: [
+      { value: 'solo', label: 'Just me' },
+      { value: 'small-team', label: 'Small team (2-5)' },
+      { value: 'large-team', label: 'Large team (5+)' },
+      { value: 'open-source', label: 'Open source community' },
+    ],
+    tags: ['project', 'team'],
+    skipIfKnown: ['project.team'],
+  }),
+];
+
+/**
+ * Technical decision questions
+ */
+const TECHNICAL_QUESTIONS = [
+  createQuestion({
+    id: 'testing-approach',
+    type: QUESTION_TYPES.TECHNICAL,
+    priority: PRIORITY.HIGH,
+    text: 'What testing approach do you prefer?',
+    options: [
+      { value: 'tdd', label: 'Test-Driven Development' },
+      { value: 'bdd', label: 'Behavior-Driven Development' },
+      { value: 'post-hoc', label: 'Write tests after implementation' },
+      { value: 'minimal', label: 'Minimal testing' },
+    ],
+    tags: ['testing', 'methodology'],
+    skipIfKnown: ['testing.approach'],
+    followUps: [
+      {
+        id: 'testing-coverage',
+        type: QUESTION_TYPES.PREFERENCE,
+        priority: PRIORITY.MEDIUM,
+        text: 'What level of test coverage do you target?',
+        options: [
+          { value: 'critical', label: 'Critical paths only (50-60%)' },
+          { value: 'standard', label: 'Standard coverage (70-80%)' },
+          { value: 'comprehensive', label: 'Comprehensive (80%+)' },
+        ],
+        triggerAnswer: value => value !== 'minimal',
+      },
+    ],
+  }),
+
+  createQuestion({
+    id: 'error-handling',
+    type: QUESTION_TYPES.TECHNICAL,
+    priority: PRIORITY.MEDIUM,
+    text: 'How should errors be handled?',
+    options: [
+      { value: 'exceptions', label: 'Throw exceptions' },
+      { value: 'result-types', label: 'Return Result/Either types' },
+      { value: 'error-codes', label: 'Return error codes' },
+      { value: 'mixed', label: 'Mixed approach' },
+    ],
+    tags: ['error-handling', 'patterns'],
+    skipIfKnown: ['error.handling'],
+  }),
+
+  createQuestion({
+    id: 'async-pattern',
+    type: QUESTION_TYPES.TECHNICAL,
+    priority: PRIORITY.MEDIUM,
+    text: 'Preferred async pattern?',
+    options: [
+      { value: 'async-await', label: 'async/await' },
+      { value: 'promises', label: 'Promises (.then/.catch)' },
+      { value: 'callbacks', label: 'Callbacks' },
+      { value: 'observables', label: 'Observables/RxJS' },
+    ],
+    tags: ['async', 'patterns'],
+    skipIfKnown: ['async.pattern'],
+  }),
+];
+
+/**
+ * Preference questions
+ */
+const PREFERENCE_QUESTIONS = [
+  createQuestion({
+    id: 'code-style',
+    type: QUESTION_TYPES.PREFERENCE,
+    priority: PRIORITY.MEDIUM,
+    text: 'What code style do you prefer?',
+    options: [
+      { value: 'compact', label: 'Compact (fewer lines)' },
+      { value: 'verbose', label: 'Verbose (explicit and clear)' },
+      { value: 'balanced', label: 'Balanced' },
+    ],
+    tags: ['style', 'preferences'],
+    skipIfKnown: ['style.code'],
+  }),
+
+  createQuestion({
+    id: 'documentation-level',
+    type: QUESTION_TYPES.PREFERENCE,
+    priority: PRIORITY.LOW,
+    text: 'How much documentation do you want?',
+    options: [
+      { value: 'minimal', label: 'Minimal (only complex parts)' },
+      { value: 'standard', label: 'Standard (public APIs)' },
+      { value: 'comprehensive', label: 'Comprehensive (everything)' },
+    ],
+    tags: ['documentation', 'preferences'],
+    skipIfKnown: ['documentation.level'],
+  }),
+
+  createQuestion({
+    id: 'naming-convention',
+    type: QUESTION_TYPES.PREFERENCE,
+    priority: PRIORITY.LOW,
+    text: 'Preferred naming convention for functions?',
+    options: [
+      { value: 'camelCase', label: 'camelCase' },
+      { value: 'snake_case', label: 'snake_case' },
+      { value: 'PascalCase', label: 'PascalCase' },
+    ],
+    tags: ['naming', 'preferences'],
+    skipIfKnown: ['naming.functions'],
+  }),
+];
+
+/**
+ * Constraint questions
+ */
+const CONSTRAINT_QUESTIONS = [
+  createQuestion({
+    id: 'browser-support',
+    type: QUESTION_TYPES.CONSTRAINT,
+    priority: PRIORITY.HIGH,
+    text: 'What browsers need to be supported?',
+    options: [
+      { value: 'modern', label: 'Modern browsers only' },
+      { value: 'ie11', label: 'Including IE11' },
+      { value: 'mobile', label: 'Mobile browsers focus' },
+      { value: 'all', label: 'All browsers' },
+    ],
+    tags: ['constraints', 'browser'],
+    skipIfKnown: ['constraints.browsers'],
+    askCondition: (kb) => kb.get('project.type')?.value === 'web-app',
+  }),
+
+  createQuestion({
+    id: 'node-version',
+    type: QUESTION_TYPES.CONSTRAINT,
+    priority: PRIORITY.MEDIUM,
+    text: 'Minimum Node.js version to support?',
+    options: [
+      { value: '16', label: 'Node 16 LTS' },
+      { value: '18', label: 'Node 18 LTS' },
+      { value: '20', label: 'Node 20 LTS' },
+      { value: '22', label: 'Node 22 (Current)' },
+    ],
+    tags: ['constraints', 'node'],
+    skipIfKnown: ['constraints.node'],
+  }),
+
+  createQuestion({
+    id: 'dependencies',
+    type: QUESTION_TYPES.CONSTRAINT,
+    priority: PRIORITY.MEDIUM,
+    text: 'What is your dependency philosophy?',
+    options: [
+      { value: 'minimal', label: 'Minimize dependencies' },
+      { value: 'pragmatic', label: 'Use well-maintained packages' },
+      { value: 'full', label: 'Use packages freely' },
+    ],
+    tags: ['constraints', 'dependencies'],
+    skipIfKnown: ['constraints.dependencies'],
+  }),
+];
+
+/**
+ * Phase-specific questions
+ */
+const PHASE_QUESTIONS = [
+  createQuestion({
+    id: 'phase-priority',
+    type: QUESTION_TYPES.CLARIFYING,
+    priority: PRIORITY.HIGH,
+    text: 'What is the priority for this phase?',
+    options: [
+      { value: 'speed', label: 'Speed (ship fast)' },
+      { value: 'quality', label: 'Quality (thorough testing)' },
+      { value: 'balanced', label: 'Balanced' },
+    ],
+    tags: ['phase', 'priority'],
+  }),
+
+  createQuestion({
+    id: 'phase-blockers',
+    type: QUESTION_TYPES.EXPLORATORY,
+    priority: PRIORITY.HIGH,
+    text: 'Are there any known blockers or concerns for this phase?',
+    options: [
+      { value: 'none', label: 'No known blockers' },
+      { value: 'technical', label: 'Technical uncertainty' },
+      { value: 'dependencies', label: 'Waiting on dependencies' },
+      { value: 'requirements', label: 'Requirements unclear' },
+    ],
+    tags: ['phase', 'blockers'],
+  }),
+];
+
+/**
+ * Get all question templates
+ * @returns {object} Categorized question templates
+ */
+function getAllTemplates() {
+  return {
+    project: PROJECT_QUESTIONS,
+    technical: TECHNICAL_QUESTIONS,
+    preference: PREFERENCE_QUESTIONS,
+    constraint: CONSTRAINT_QUESTIONS,
+    phase: PHASE_QUESTIONS,
+  };
+}
+
+/**
+ * Get questions by tags
+ * @param {string[]} tags - Tags to filter by
+ * @returns {Array} Matching questions
+ */
+function getByTags(tags) {
+  const allQuestions = [
+    ...PROJECT_QUESTIONS,
+    ...TECHNICAL_QUESTIONS,
+    ...PREFERENCE_QUESTIONS,
+    ...CONSTRAINT_QUESTIONS,
+    ...PHASE_QUESTIONS,
+  ];
+
+  return allQuestions.filter(q =>
+    q.tags.some(t => tags.includes(t)),
+  );
+}
+
+/**
+ * Get questions by type
+ * @param {string} type - Question type
+ * @returns {Array} Matching questions
+ */
+function getByType(type) {
+  const allQuestions = [
+    ...PROJECT_QUESTIONS,
+    ...TECHNICAL_QUESTIONS,
+    ...PREFERENCE_QUESTIONS,
+    ...CONSTRAINT_QUESTIONS,
+    ...PHASE_QUESTIONS,
+  ];
+
+  return allQuestions.filter(q => q.type === type);
+}
+
+module.exports = {
+  PROJECT_QUESTIONS,
+  TECHNICAL_QUESTIONS,
+  PREFERENCE_QUESTIONS,
+  CONSTRAINT_QUESTIONS,
+  PHASE_QUESTIONS,
+  getAllTemplates,
+  getByTags,
+  getByType,
+};