agileflow 2.90.7 → 2.92.0

package/lib/colors.js

@@ -11,21 +11,123 @@
  * - Cyan (#00CED1):      4.6:1 ✓ (meets AA for normal text)
  * - Brand (#e8683a):     3.8:1 ✓ (meets AA for large text/UI elements)
  *
+ * WCAG AAA Contrast Ratios (high-contrast mode, 7:1+ ratio):
+ * - HC Green (#7CFC00):  11.3:1 ✓ (lawn green - meets AAA)
+ * - HC Red (#FF6B6B):    5.0:1 → #FF9999 8.1:1 ✓ (light coral - meets AAA)
+ * - HC Yellow (#FFFF00): 19.6:1 ✓ (pure yellow - meets AAA)
+ * - HC Cyan (#00FFFF):   14.0:1 ✓ (aqua - meets AAA)
+ * - HC White (#FFFFFF):  21.0:1 ✓ (pure white - meets AAA)
+ *
  * Note: Standard ANSI colors vary by terminal theme. The above ratios
  * are for typical dark terminal configurations.
  */
 
+// High-contrast mode detection
+let _highContrastMode = null;
+
+/**
+ * Check if high-contrast mode is enabled.
+ * Checks: AGILEFLOW_HIGH_CONTRAST env var, or cached value.
+ * @returns {boolean} True if high-contrast mode is enabled
+ */
+function isHighContrast() {
+  if (_highContrastMode !== null) {
+    return _highContrastMode;
+  }
+  const envValue = process.env.AGILEFLOW_HIGH_CONTRAST;
+  return envValue === '1' || envValue === 'true' || envValue === 'yes';
+}
+
+/**
+ * Enable or disable high-contrast mode programmatically.
+ * @param {boolean} enabled - Whether to enable high-contrast mode
+ */
+function setHighContrast(enabled) {
+  _highContrastMode = enabled;
+}
+
+/**
+ * Reset high-contrast mode to use environment variable.
+ */
+function resetHighContrast() {
+  _highContrastMode = null;
+}
+
 /**
  * Brand color hex value for chalk compatibility.
  * Use with chalk.hex(BRAND_HEX) in files that use chalk.
  */
 const BRAND_HEX = '#e8683a';
 
+/**
+ * WCAG AAA high-contrast color palette (7:1+ contrast ratio).
+ * Used when AGILEFLOW_HIGH_CONTRAST=1 or --high-contrast flag.
+ */
+const hc = {
+  // Reset and modifiers
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[0m', // No dimming in high-contrast (use regular text)
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+
+  // High-contrast standard colors (bright variants for max visibility)
+  red: '\x1b[91m', // Bright red
+  green: '\x1b[92m', // Bright green
+  yellow: '\x1b[93m', // Bright yellow
+  blue: '\x1b[94m', // Bright blue
+  magenta: '\x1b[95m', // Bright magenta
+  cyan: '\x1b[96m', // Bright cyan
+  white: '\x1b[97m', // Bright white
+
+  // Bright variants (same in high-contrast mode)
+  brightBlack: '\x1b[37m', // Use white instead of gray
+  brightRed: '\x1b[91m',
+  brightGreen: '\x1b[92m',
+  brightYellow: '\x1b[93m',
+  brightBlue: '\x1b[94m',
+  brightMagenta: '\x1b[95m',
+  brightCyan: '\x1b[96m',
+  brightWhite: '\x1b[97m',
+
+  // 256-color high-contrast alternatives (all 7:1+ ratio)
+  mintGreen: '\x1b[92m', // Bright green
+  peach: '\x1b[93m', // Bright yellow
+  coral: '\x1b[91m', // Bright red
+  lightGreen: '\x1b[92m', // Bright green
+  lightYellow: '\x1b[93m', // Bright yellow
+  lightPink: '\x1b[91m', // Bright red
+  skyBlue: '\x1b[96m', // Bright cyan
+  lavender: '\x1b[95m', // Bright magenta
+  softGold: '\x1b[93m', // Bright yellow
+  teal: '\x1b[96m', // Bright cyan
+  slate: '\x1b[97m', // White (instead of gray)
+  rose: '\x1b[91m', // Bright red
+  amber: '\x1b[93m', // Bright yellow
+  powder: '\x1b[96m', // Bright cyan
+
+  // Brand color - use bright orange/yellow for visibility
+  brand: '\x1b[38;2;255;165;0m', // Bright orange (#FFA500 - 8.0:1 ratio)
+  orange: '\x1b[38;2;255;165;0m',
+
+  // Background colors (same as standard)
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+
+  // Semantic aliases
+  success: '\x1b[92m',
+  error: '\x1b[91m',
+  warning: '\x1b[93m',
+  info: '\x1b[96m',
+};
+
 /**
  * ANSI color codes for terminal output.
  * Includes standard colors, 256-color palette, and brand colors.
  */
-const c = {
+const cStandard = {
   // Reset and modifiers
   reset: '\x1b[0m',
   bold: '\x1b[1m',
@@ -85,6 +187,36 @@ const c = {
   info: '\x1b[36m', // Same as cyan
 };
 
+/**
+ * Get the active color palette based on high-contrast mode.
+ * @returns {Object} Color palette object (either cStandard or hc)
+ */
+function getColors() {
+  return isHighContrast() ? hc : cStandard;
+}
+
+// For backwards compatibility, export a Proxy that delegates to the active palette
+const c = new Proxy(
+  {},
+  {
+    get(_, prop) {
+      return getColors()[prop];
+    },
+    has(_, prop) {
+      return prop in cStandard;
+    },
+    ownKeys() {
+      return Object.keys(cStandard);
+    },
+    getOwnPropertyDescriptor(_, prop) {
+      if (prop in cStandard) {
+        return { enumerable: true, configurable: true, value: getColors()[prop] };
+      }
+      return undefined;
+    },
+  }
+);
+
 /**
  * Box drawing characters for tables and borders.
  */
@@ -114,18 +246,49 @@ const box = {
 };
 
 /**
- * Status indicators with colors.
+ * Get status indicators with current color palette.
+ * Uses a Proxy to dynamically generate colored indicators.
  */
-const status = {
-  success: `${c.green}✓${c.reset}`,
-  warning: `${c.yellow}⚠️${c.reset}`,
-  error: `${c.red}✗${c.reset}`,
-  info: `${c.cyan}ℹ${c.reset}`,
-  pending: `${c.dim}○${c.reset}`,
-  inProgress: `${c.yellow}◐${c.reset}`,
-  done: `${c.green}●${c.reset}`,
-  blocked: `${c.red}◆${c.reset}`,
-};
+const status = new Proxy(
+  {},
+  {
+    get(_, prop) {
+      const colors = getColors();
+      const indicators = {
+        success: `${colors.green}✓${colors.reset}`,
+        warning: `${colors.yellow}⚠️${colors.reset}`,
+        error: `${colors.red}✗${colors.reset}`,
+        info: `${colors.cyan}ℹ${colors.reset}`,
+        pending: `${isHighContrast() ? colors.white : colors.dim}○${colors.reset}`,
+        inProgress: `${colors.yellow}◐${colors.reset}`,
+        done: `${colors.green}●${colors.reset}`,
+        blocked: `${colors.red}◆${colors.reset}`,
+      };
+      return indicators[prop];
+    },
+    has(_, prop) {
+      return [
+        'success',
+        'warning',
+        'error',
+        'info',
+        'pending',
+        'inProgress',
+        'done',
+        'blocked',
+      ].includes(prop);
+    },
+    ownKeys() {
+      return ['success', 'warning', 'error', 'info', 'pending', 'inProgress', 'done', 'blocked'];
+    },
+    getOwnPropertyDescriptor(_, prop) {
+      if (status.has(_, prop)) {
+        return { enumerable: true, configurable: true };
+      }
+      return undefined;
+    },
+  }
+);
 
 /**
  * Wrap text with color codes.
@@ -199,9 +362,22 @@ function brand(text) {
 }
 
 module.exports = {
+  // Color palettes
   c,
+  cStandard,
+  hc,
+  getColors,
+
+  // High-contrast mode control
+  isHighContrast,
+  setHighContrast,
+  resetHighContrast,
+
+  // UI elements
   box,
   status,
+
+  // Helper functions
   colorize,
   dim,
   bold,
@@ -209,5 +385,7 @@ module.exports = {
   warning,
   error,
   brand,
+
+  // Constants
   BRAND_HEX,
 };

package/lib/consent.js

@@ -0,0 +1,232 @@
+/**
+ * consent.js
+ *
+ * GDPR consent handling for AgileFlow (US-0149)
+ *
+ * Manages privacy consent during setup:
+ * - Prompts user to acknowledge privacy policy
+ * - Stores consent timestamp in .agileflow/config/consent.json
+ * - Supports --accept-privacy flag for CI environments
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+/**
+ * Consent configuration
+ */
+const CONSENT_FILE = '.agileflow/config/consent.json';
+const PRIVACY_POLICY_URL =
+  'https://github.com/projectquestorg/AgileFlow/blob/main/packages/cli/PRIVACY.md';
+
+/**
+ * Consent status types
+ */
+const ConsentStatus = {
+  ACCEPTED: 'accepted',
+  DECLINED: 'declined',
+  PENDING: 'pending',
+};
+
+/**
+ * Check if consent has been given
+ * @returns {{ hasConsent: boolean, consent: Object | null }}
+ */
+function checkConsent() {
+  const consentPath = path.resolve(process.cwd(), CONSENT_FILE);
+
+  try {
+    if (fs.existsSync(consentPath)) {
+      const consent = JSON.parse(fs.readFileSync(consentPath, 'utf8'));
+      return {
+        hasConsent: consent.status === ConsentStatus.ACCEPTED,
+        consent,
+      };
+    }
+  } catch {
+    // Ignore errors, treat as no consent
+  }
+
+  return { hasConsent: false, consent: null };
+}
+
+/**
+ * Record consent
+ * @param {string} status - 'accepted' or 'declined'
+ * @param {Object} options - Additional options
+ * @param {string} options.method - How consent was given ('interactive', 'flag', 'api')
+ * @param {string} options.version - Privacy policy version
+ * @returns {{ ok: boolean, path: string }}
+ */
+function recordConsent(status, options = {}) {
+  const { method = 'interactive', version = '1.0.0' } = options;
+
+  const consentPath = path.resolve(process.cwd(), CONSENT_FILE);
+  const consentDir = path.dirname(consentPath);
+
+  // Ensure directory exists
+  if (!fs.existsSync(consentDir)) {
+    fs.mkdirSync(consentDir, { recursive: true });
+  }
+
+  const consent = {
+    status,
+    timestamp: new Date().toISOString(),
+    method,
+    policy_version: version,
+    policy_url: PRIVACY_POLICY_URL,
+  };
+
+  try {
+    fs.writeFileSync(consentPath, JSON.stringify(consent, null, 2));
+    return { ok: true, path: consentPath };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Prompt user for consent interactively
+ * @param {Object} options - Prompt options
+ * @param {WritableStream} options.output - Output stream (default: process.stdout)
+ * @param {ReadableStream} options.input - Input stream (default: process.stdin)
+ * @returns {Promise<{ accepted: boolean }>}
+ */
+async function promptConsent(options = {}) {
+  const { output = process.stdout, input = process.stdin } = options;
+
+  const rl = readline.createInterface({
+    input,
+    output,
+    terminal: false,
+  });
+
+  // Display privacy notice
+  const notice = `
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃                    Privacy Notice                             ┃
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+AgileFlow respects your privacy:
+
+• All data is stored locally on your machine
+• No telemetry, analytics, or tracking
+• No data is transmitted to external servers
+• You can delete all data at any time
+
+For details, see: ${PRIVACY_POLICY_URL}
+
+`;
+
+  output.write(notice);
+
+  return new Promise(resolve => {
+    const question = 'Do you accept the privacy policy? (yes/no): ';
+    output.write(question);
+
+    rl.once('line', answer => {
+      rl.close();
+      const normalized = answer.toLowerCase().trim();
+      const accepted = normalized === 'yes' || normalized === 'y';
+      resolve({ accepted });
+    });
+  });
+}
+
+/**
+ * Handle consent during setup
+ * @param {Object} options - Setup options
+ * @param {boolean} options.acceptPrivacy - --accept-privacy flag was passed
+ * @param {boolean} options.silent - Silent mode (no prompts)
+ * @param {WritableStream} options.output - Output stream
+ * @param {ReadableStream} options.input - Input stream
+ * @returns {Promise<{ ok: boolean, status: string, skipped: boolean }>}
+ */
+async function handleSetupConsent(options = {}) {
+  const {
+    acceptPrivacy = false,
+    silent = false,
+    output = process.stdout,
+    input = process.stdin,
+  } = options;
+
+  // Check if consent already given
+  const { hasConsent, consent } = checkConsent();
+  if (hasConsent) {
+    return { ok: true, status: 'already_consented', skipped: false, consent };
+  }
+
+  // If --accept-privacy flag provided
+  if (acceptPrivacy) {
+    const result = recordConsent(ConsentStatus.ACCEPTED, { method: 'flag' });
+    return { ok: result.ok, status: 'accepted_via_flag', skipped: false };
+  }
+
+  // If silent mode (CI without flag)
+  if (silent) {
+    return { ok: false, status: 'consent_required', skipped: true };
+  }
+
+  // Interactive prompt
+  const { accepted } = await promptConsent({ output, input });
+
+  if (accepted) {
+    const result = recordConsent(ConsentStatus.ACCEPTED, { method: 'interactive' });
+    return { ok: result.ok, status: 'accepted_interactive', skipped: false };
+  } else {
+    const result = recordConsent(ConsentStatus.DECLINED, { method: 'interactive' });
+    return { ok: false, status: 'declined', skipped: false };
+  }
+}
+
+/**
+ * Get consent status for display
+ * @returns {{ status: string, timestamp: string | null, method: string | null }}
+ */
+function getConsentStatus() {
+  const { hasConsent, consent } = checkConsent();
+
+  if (!consent) {
+    return { status: ConsentStatus.PENDING, timestamp: null, method: null };
+  }
+
+  return {
+    status: consent.status,
+    timestamp: consent.timestamp,
+    method: consent.method,
+    policyVersion: consent.policy_version,
+  };
+}
+
+/**
+ * Revoke consent (delete consent file)
+ * @returns {{ ok: boolean }}
+ */
+function revokeConsent() {
+  const consentPath = path.resolve(process.cwd(), CONSENT_FILE);
+
+  try {
+    if (fs.existsSync(consentPath)) {
+      fs.unlinkSync(consentPath);
+    }
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+module.exports = {
+  // Constants
+  CONSENT_FILE,
+  PRIVACY_POLICY_URL,
+  ConsentStatus,
+
+  // Functions
+  checkConsent,
+  recordConsent,
+  promptConsent,
+  handleSetupConsent,
+  getConsentStatus,
+  revokeConsent,
+};