@equilateral_ai/mindmeld 3.5.3 → 4.0.2

package/src/core/parsers/eslintParser.js

@@ -1,439 +0,0 @@
-/**
- * ESLint Config Parser - Parse ESLint configurations into YAML standards format
- *
- * Accepts ESLint config content (JSON or JS module format) and maps rules to
- * YAML-compatible standards objects matching the equilateral-standards schema.
- *
- * Rule severity mapping:
- *   "error" / 2   -> ALWAYS (for positive rules) or NEVER (for "no-" rules)
- *   "warn"  / 1   -> PREFER (for positive rules) or AVOID (for "no-" rules)
- *   "off"   / 0   -> skipped
- *
- * @module parsers/eslintParser
- */
-
-/**
- * Well-known ESLint rule descriptions for common rules
- * Maps rule name to a human-readable description
- */
-const RULE_DESCRIPTIONS = {
-  // Possible errors
-  'no-console': 'Console statements in production',
-  'no-debugger': 'Debugger statements in production code',
-  'no-dupe-args': 'Duplicate arguments in function definitions',
-  'no-dupe-keys': 'Duplicate keys in object literals',
-  'no-duplicate-case': 'Duplicate case labels in switch statements',
-  'no-empty': 'Empty block statements',
-  'no-extra-semi': 'Unnecessary semicolons',
-  'no-unreachable': 'Unreachable code after return, throw, continue, or break',
-  'no-unsafe-negation': 'Negating the left operand of relational operators',
-
-  // Best practices
-  'no-eval': 'Use of eval()',
-  'no-implied-eval': 'Use of implied eval() through setTimeout/setInterval strings',
-  'no-unused-vars': 'Leave unused variables',
-  'no-unused-expressions': 'Unused expressions that have no effect',
-  'no-var': 'Use of var declarations',
-  'no-shadow': 'Variable declarations that shadow outer scope variables',
-  'no-param-reassign': 'Reassignment of function parameters',
-  'no-return-await': 'Unnecessary return await',
-  'no-throw-literal': 'Throwing literals as exceptions',
-  'no-useless-catch': 'Catch clauses that only rethrow',
-  'no-useless-return': 'Redundant return statements',
-
-  // Style & conventions
-  'eqeqeq': 'Use strict equality operators (=== and !==)',
-  'curly': 'Use curly braces for all control statements',
-  'prefer-const': 'Use const for variables that are never reassigned',
-  'prefer-template': 'Use template literals instead of string concatenation',
-  'prefer-arrow-callback': 'Use arrow functions for callbacks',
-  'prefer-destructuring': 'Use destructuring from arrays and objects',
-  'prefer-rest-params': 'Use rest parameters instead of arguments object',
-  'prefer-spread': 'Use spread syntax instead of .apply()',
-  'arrow-body-style': 'Require braces around arrow function bodies',
-  'consistent-return': 'Require consistent return statements',
-  'default-case': 'Require default case in switch statements',
-  'dot-notation': 'Use dot notation whenever possible',
-  'no-else-return': 'Disallow else blocks after return in if statements',
-
-  // ES6+
-  'no-duplicate-imports': 'Duplicate imports from the same module',
-  'no-useless-constructor': 'Unnecessary constructors',
-  'no-useless-rename': 'Renaming imports/exports/destructured to the same name',
-
-  // Node.js
-  'no-process-exit': 'Use of process.exit()',
-  'no-path-concat': 'String concatenation with __dirname and __filename',
-  'callback-return': 'Require return after callback',
-  'handle-callback-err': 'Handle callback error parameters',
-
-  // TypeScript (common plugin rules)
-  '@typescript-eslint/no-explicit-any': 'Use of explicit any type',
-  '@typescript-eslint/no-unused-vars': 'Leave unused variables',
-  '@typescript-eslint/explicit-function-return-type': 'Require explicit return types on functions',
-  '@typescript-eslint/no-non-null-assertion': 'Use of non-null assertion operator (!)',
-
-  // React (common plugin rules)
-  'react/no-direct-mutation-state': 'Direct mutation of state',
-  'react/no-unused-state': 'Unused state fields',
-  'react/jsx-no-bind': 'Use of .bind() or arrow functions in JSX props',
-  'react/jsx-key': 'Missing key prop in iterators/collection literals',
-  'react-hooks/rules-of-hooks': 'Follow the Rules of Hooks',
-  'react-hooks/exhaustive-deps': 'Verify the list of dependencies for Hooks'
-};
-
-/**
- * Parse ESLint config content into YAML-compatible standards object
- *
- * @param {string} content - ESLint config content (JSON string or JS module string)
- * @param {Object} options - Parser options
- * @param {string} options.filename - Source filename
- * @param {string} options.category - Standards category override
- * @returns {Object} YAML-compatible standards object
- */
-function parseEslint(content, options = {}) {
-  if (!content || typeof content !== 'string') {
-    throw new Error('ESLint config content is required and must be a string');
-  }
-
-  const filename = options.filename || '.eslintrc';
-  const config = parseConfigContent(content);
-
-  if (!config || typeof config !== 'object') {
-    throw new Error('Failed to parse ESLint configuration');
-  }
-
-  const rules = extractRules(config);
-  const plugins = extractPlugins(config);
-  const extendsConfigs = extractExtends(config);
-  const category = options.category || inferCategory(plugins, extendsConfigs);
-
-  const id = generateId(filename);
-
-  return {
-    id,
-    category,
-    priority: determinePriority(rules),
-    rules,
-    anti_patterns: extractAntiPatterns(rules),
-    context: {
-      source_format: 'eslint',
-      source_file: filename,
-      extends: extendsConfigs,
-      plugins
-    },
-    tags: buildTags(plugins, extendsConfigs),
-    updated: new Date().toISOString().split('T')[0]
-  };
-}
-
-/**
- * Parse config content from JSON or JS module format
- *
- * @param {string} content - Raw config content
- * @returns {Object} Parsed config object
- */
-function parseConfigContent(content) {
-  const trimmed = content.trim();
-
-  // Try JSON first
-  try {
-    return JSON.parse(trimmed);
-  } catch (_jsonError) {
-    // Not valid JSON, try extracting object from JS module
-  }
-
-  // Try extracting from module.exports = { ... }
-  const moduleExportsMatch = trimmed.match(/module\.exports\s*=\s*(\{[\s\S]*\})\s*;?\s*$/);
-  if (moduleExportsMatch) {
-    try {
-      // Use Function constructor to safely evaluate the object literal
-      // This handles JS features like trailing commas and comments
-      const fn = new Function(`return (${moduleExportsMatch[1]})`);
-      return fn();
-    } catch (_evalError) {
-      // Fall through to next attempt
-    }
-  }
-
-  // Try extracting from export default { ... } (flat config)
-  const exportDefaultMatch = trimmed.match(/export\s+default\s+(\{[\s\S]*\})\s*;?\s*$/);
-  if (exportDefaultMatch) {
-    try {
-      const fn = new Function(`return (${exportDefaultMatch[1]})`);
-      return fn();
-    } catch (_evalError) {
-      // Fall through
-    }
-  }
-
-  // Try extracting from flat config array format: export default [...]
-  const flatArrayMatch = trimmed.match(/(?:module\.exports|export\s+default)\s*=?\s*(\[[\s\S]*\])\s*;?\s*$/);
-  if (flatArrayMatch) {
-    try {
-      const fn = new Function(`return (${flatArrayMatch[1]})`);
-      const arr = fn();
-      // Merge all config objects in the array
-      if (Array.isArray(arr)) {
-        return arr.reduce((merged, item) => {
-          if (item && typeof item === 'object') {
-            if (item.rules) merged.rules = { ...merged.rules, ...item.rules };
-            if (item.plugins) merged.plugins = [...(merged.plugins || []), ...(Array.isArray(item.plugins) ? item.plugins : [])];
-          }
-          return merged;
-        }, { rules: {}, plugins: [] });
-      }
-    } catch (_evalError) {
-      // Fall through
-    }
-  }
-
-  throw new Error('Unable to parse ESLint config: unsupported format');
-}
-
-/**
- * Extract and map ESLint rules to YAML standards rules
- *
- * @param {Object} config - Parsed ESLint config
- * @returns {Array<Object>} Array of rule objects with action and rule text
- */
-function extractRules(config) {
-  const configRules = config.rules || {};
-  const yamlRules = [];
-
-  for (const [ruleName, ruleValue] of Object.entries(configRules)) {
-    const severity = normalizeSeverity(ruleValue);
-
-    // Skip disabled rules
-    if (severity === 0) continue;
-
-    const isNegativeRule = ruleName.startsWith('no-') ||
-      ruleName.includes('/no-') ||
-      ruleName.includes('no-direct') ||
-      ruleName.includes('no-unused');
-
-    const action = mapSeverityToAction(severity, isNegativeRule);
-    const description = getDescription(ruleName);
-    const ruleOptions = extractRuleOptions(ruleValue);
-
-    const rule = {
-      action,
-      rule: description
-    };
-
-    // Include rule options as applies_to context if meaningful
-    if (ruleOptions) {
-      rule.options = ruleOptions;
-    }
-
-    yamlRules.push(rule);
-  }
-
-  return yamlRules;
-}
-
-/**
- * Normalize ESLint rule severity to numeric value
- *
- * @param {*} ruleValue - ESLint rule value (string, number, or array)
- * @returns {number} 0 (off), 1 (warn), or 2 (error)
- */
-function normalizeSeverity(ruleValue) {
-  const value = Array.isArray(ruleValue) ? ruleValue[0] : ruleValue;
-
-  if (typeof value === 'number') return value;
-  if (value === 'error') return 2;
-  if (value === 'warn') return 1;
-  if (value === 'off') return 0;
-
-  return 0;
-}
-
-/**
- * Map ESLint severity to YAML action type
- *
- * @param {number} severity - Numeric severity (1 or 2)
- * @param {boolean} isNegative - Whether the rule is a "no-" rule
- * @returns {string} Action type
- */
-function mapSeverityToAction(severity, isNegative) {
-  if (severity === 2) {
-    return isNegative ? 'NEVER' : 'ALWAYS';
-  }
-  // severity === 1
-  return isNegative ? 'AVOID' : 'PREFER';
-}
-
-/**
- * Get a human-readable description for an ESLint rule
- *
- * @param {string} ruleName - ESLint rule name
- * @returns {string} Human-readable description
- */
-function getDescription(ruleName) {
-  // Check known descriptions
-  if (RULE_DESCRIPTIONS[ruleName]) {
-    return RULE_DESCRIPTIONS[ruleName];
-  }
-
-  // Generate description from rule name
-  const parts = ruleName.split('/');
-  const name = parts[parts.length - 1];
-
-  return name
-    .replace(/^no-/, 'Disallow ')
-    .replace(/^prefer-/, 'Prefer ')
-    .replace(/^require-/, 'Require ')
-    .replace(/-/g, ' ')
-    .replace(/^\w/, c => c.toUpperCase());
-}
-
-/**
- * Extract rule options from array-format rule values
- *
- * @param {*} ruleValue - ESLint rule value
- * @returns {*} Rule options or null
- */
-function extractRuleOptions(ruleValue) {
-  if (!Array.isArray(ruleValue) || ruleValue.length <= 1) return null;
-  const options = ruleValue.slice(1);
-  return options.length === 1 ? options[0] : options;
-}
-
-/**
- * Extract anti-patterns from NEVER/AVOID rules
- *
- * @param {Array<Object>} rules - Parsed rules
- * @returns {Array<string>} Anti-pattern descriptions
- */
-function extractAntiPatterns(rules) {
-  return rules
-    .filter(r => r.action === 'NEVER' || r.action === 'AVOID')
-    .map(r => r.rule);
-}
-
-/**
- * Extract plugin names from config
- *
- * @param {Object} config - Parsed ESLint config
- * @returns {Array<string>} Plugin names
- */
-function extractPlugins(config) {
-  if (!config.plugins) return [];
-
-  if (Array.isArray(config.plugins)) {
-    return config.plugins.map(p => typeof p === 'string' ? p : '').filter(Boolean);
-  }
-
-  // Object format (flat config)
-  if (typeof config.plugins === 'object') {
-    return Object.keys(config.plugins);
-  }
-
-  return [];
-}
-
-/**
- * Extract extends configurations
- *
- * @param {Object} config - Parsed ESLint config
- * @returns {Array<string>} Extends config names
- */
-function extractExtends(config) {
-  if (!config.extends) return [];
-  if (typeof config.extends === 'string') return [config.extends];
-  if (Array.isArray(config.extends)) return config.extends;
-  return [];
-}
-
-/**
- * Infer standards category from plugins and extends
- *
- * @param {Array<string>} plugins - Plugin names
- * @param {Array<string>} extendsConfigs - Extended config names
- * @returns {string} Inferred category
- */
-function inferCategory(plugins, extendsConfigs) {
-  const all = [...plugins, ...extendsConfigs].map(s => s.toLowerCase());
-
-  if (all.some(s => s.includes('react') || s.includes('jsx'))) return 'frontend-development';
-  if (all.some(s => s.includes('typescript'))) return 'frontend-development';
-  if (all.some(s => s.includes('vue'))) return 'frontend-development';
-  if (all.some(s => s.includes('node'))) return 'backend';
-  if (all.some(s => s.includes('security'))) return 'compliance-security';
-
-  return 'general';
-}
-
-/**
- * Generate standards ID from filename
- *
- * @param {string} filename - Source filename
- * @returns {string} Generated ID
- */
-function generateId(filename) {
-  const slug = filename
-    .replace(/\.(json|js|cjs|mjs|yaml|yml)$/i, '')
-    .replace(/[^a-z0-9]+/gi, '-')
-    .toLowerCase();
-
-  return `eslint-${slug}`;
-}
-
-/**
- * Determine priority based on rule severity distribution
- *
- * @param {Array<Object>} rules - Extracted rules
- * @returns {number} Priority (10, 20, or 30)
- */
-function determinePriority(rules) {
-  const enforcedCount = rules.filter(r =>
-    r.action === 'ALWAYS' || r.action === 'NEVER'
-  ).length;
-
-  const total = rules.length;
-  if (total === 0) return 30;
-
-  // Majority enforced -> high priority
-  if (enforcedCount / total > 0.5) return 10;
-  if (enforcedCount > 0) return 20;
-
-  return 30;
-}
-
-/**
- * Build tags from plugins and extends
- *
- * @param {Array<string>} plugins - Plugin names
- * @param {Array<string>} extendsConfigs - Extended config names
- * @returns {Array<string>} Tags
- */
-function buildTags(plugins, extendsConfigs) {
-  const tags = ['eslint', 'linting'];
-
-  for (const plugin of plugins) {
-    const cleaned = plugin
-      .replace(/^eslint-plugin-/, '')
-      .replace(/^@[^/]+\//, '')
-      .toLowerCase();
-    tags.push(cleaned);
-  }
-
-  for (const ext of extendsConfigs) {
-    if (ext.includes('recommended')) tags.push('recommended');
-    if (ext.includes('strict')) tags.push('strict');
-    if (ext.includes('airbnb')) tags.push('airbnb');
-    if (ext.includes('prettier')) tags.push('prettier');
-    if (ext.includes('standard')) tags.push('standard');
-  }
-
-  return [...new Set(tags)];
-}
-
-module.exports = {
-  parseEslint,
-  extractRules,
-  normalizeSeverity,
-  mapSeverityToAction,
-  getDescription
-};

package/src/database/dbOperations.js

@@ -1,105 +0,0 @@
-/**
- * Rapport v3 - Database Operations
- *
- * Provides database query execution following Tim-Combo backend_handler_standards.md
- * Uses cached single client (NOT connection pools) per Lambda database standards
- */
-
-const { Client } = require('pg');
-
-// Cached client for connection reuse across warm Lambda invocations
-let cachedClient = null;
-
-/**
- * Get or create database client
- *
- * Follows Lambda database standards:
- * - NEVER use connection pools (Lambda handles one request at a time)
- * - Cache single client for reuse across warm invocations
- * - Use environment variables (NOT runtime SSM fetches)
- *
- * @returns {Promise<Client>} PostgreSQL client
- */
-async function getClient() {
-    if (cachedClient && cachedClient._connected) {
-        return cachedClient;
-    }
-
-    const client = new Client({
-        host: process.env.DB_HOST,
-        port: process.env.DB_PORT || 5432,
-        database: process.env.DB_NAME,
-        user: process.env.DB_USER,
-        password: process.env.DB_PASSWORD,
-        ssl: process.env.DB_SSL === 'true' ? { rejectUnauthorized: false } : false
-    });
-
-    await client.connect();
-    client._connected = true;
-
-    cachedClient = client;
-    return client;
-}
-
-/**
- * Execute a database query
- *
- * Standard pattern from backend_handler_standards.md
- *
- * @param {string} query - SQL query
- * @param {Array} params - Query parameters
- * @returns {Promise<Object>} Query result
- */
-async function executeQuery(query, params = []) {
-    const client = await getClient();
-
-    try {
-        const result = await client.query(query, params);
-        return result;
-    } catch (error) {
-        console.error('[dbOperations] Query error:', {
-            error: error.message,
-            query: query.substring(0, 200),
-            params: params
-        });
-        throw error;
-    }
-}
-
-/**
- * Execute multiple queries in a transaction
- *
- * @param {Function} callback - Async function that receives client
- * @returns {Promise<any>} Callback result
- */
-async function executeTransaction(callback) {
-    const client = await getClient();
-
-    try {
-        await client.query('BEGIN');
-        const result = await callback(client);
-        await client.query('COMMIT');
-        return result;
-    } catch (error) {
-        await client.query('ROLLBACK');
-        console.error('[dbOperations] Transaction error:', error);
-        throw error;
-    }
-}
-
-/**
- * Close database connection (for graceful shutdown)
- */
-async function closeConnection() {
-    if (cachedClient) {
-        await cachedClient.end();
-        cachedClient = null;
-    }
-}
-
-module.exports = {
-    executeQuery,
-    executeTransaction,
-    closeConnection,
-    getClient
-};

package/src/handlers/activity/activityGetMe.js

@@ -1,98 +0,0 @@
-/**
- * Activity Get Me Handler
- * Retrieves current user's activity summary
- *
- * GET /api/activity/me
- * Auth: Cognito JWT required
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
-
-exports.handler = wrapHandler(async ({ requestContext }) => {
-    const Request_ID = requestContext.requestId;
-    const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-
-    if (!email) {
-        return createErrorResponse(401, 'Authentication required');
-    }
-
-    // Get activity from materialized view
-    const result = await executeQuery(`
-        SELECT
-            email_address,
-            display_name,
-            sessions_30d,
-            sessions_7d,
-            last_session,
-            avg_session_duration_seconds,
-            commits_30d,
-            commits_7d,
-            last_commit,
-            days_since_commit,
-            prs_opened_30d,
-            prs_merged_30d,
-            avg_pr_review_hours,
-            commits_within_24h_of_session,
-            session_to_commit_conversion_pct
-        FROM rapport.mv_developer_activity
-        WHERE email_address = $1
-    `, [email]);
-
-    if (result.rowCount === 0) {
-        // Return empty activity for new users
-        return createSuccessResponse(
-            {
-                Records: [{
-                    email_address: email,
-                    sessions_30d: 0,
-                    sessions_7d: 0,
-                    commits_30d: 0,
-                    commits_7d: 0,
-                    prs_opened_30d: 0,
-                    prs_merged_30d: 0,
-                    session_to_commit_conversion_pct: 0
-                }]
-            },
-            'Activity retrieved (new user)',
-            { Total_Records: 1, Request_ID, Timestamp: new Date().toISOString() }
-        );
-    }
-
-    const activity = result.rows[0];
-
-    return createSuccessResponse(
-        {
-            Records: [{
-                email_address: activity.email_address,
-                display_name: activity.display_name,
-                sessions: {
-                    last_30_days: parseInt(activity.sessions_30d) || 0,
-                    last_7_days: parseInt(activity.sessions_7d) || 0,
-                    last_session: activity.last_session,
-                    avg_duration_minutes: activity.avg_session_duration_seconds
-                        ? Math.round(activity.avg_session_duration_seconds / 60)
-                        : null
-                },
-                commits: {
-                    last_30_days: parseInt(activity.commits_30d) || 0,
-                    last_7_days: parseInt(activity.commits_7d) || 0,
-                    last_commit: activity.last_commit,
-                    days_since_commit: activity.days_since_commit !== null ? parseInt(activity.days_since_commit) : null
-                },
-                pull_requests: {
-                    opened_30d: parseInt(activity.prs_opened_30d) || 0,
-                    merged_30d: parseInt(activity.prs_merged_30d) || 0,
-                    avg_review_hours: activity.avg_pr_review_hours
-                        ? parseFloat(activity.avg_pr_review_hours).toFixed(1)
-                        : null
-                },
-                value_correlation: {
-                    commits_within_24h_of_session: parseInt(activity.commits_within_24h_of_session) || 0,
-                    session_to_commit_conversion_pct: parseFloat(activity.session_to_commit_conversion_pct) || 0
-                }
-            }]
-        },
-        'Activity retrieved',
-        { Total_Records: 1, Request_ID, Timestamp: new Date().toISOString() }
-    );
-});