@equilateral_ai/mindmeld 3.3.1 → 3.4.0

package/src/core/RelevanceDetector.js

@@ -215,20 +215,27 @@ class RelevanceDetector {
      * Detect React usage
      */
     async detectReact(keyFiles) {
-        if (!keyFiles.includes('package.json')) {
-            return false;
-        }
-
+        // Check root package.json first
         try {
             const pkgPath = path.join(this.workingDirectory, 'package.json');
             const content = await fs.readFile(pkgPath, 'utf-8');
             const pkg = JSON.parse(content);
+            if (pkg.dependencies?.react || pkg.devDependencies?.react) return true;
+        } catch (error) { /* continue */ }
 
-            return !!(pkg.dependencies?.react || pkg.devDependencies?.react);
-        } catch (error) {
-            // Check for .jsx or .tsx files
-            return keyFiles.some(f => f.endsWith('.jsx') || f.endsWith('.tsx'));
+        // Check subdirectory package.json files (monorepo support)
+        const subDirs = ['frontend', 'frontend/admin', 'client', 'web', 'app'];
+        for (const dir of subDirs) {
+            try {
+                const pkgPath = path.join(this.workingDirectory, dir, 'package.json');
+                const content = await fs.readFile(pkgPath, 'utf-8');
+                const pkg = JSON.parse(content);
+                if (pkg.dependencies?.react || pkg.devDependencies?.react) return true;
+            } catch (error) { /* continue */ }
         }
+
+        // Fallback: check for .jsx or .tsx files in keyFiles
+        return keyFiles.some(f => f.endsWith('.jsx') || f.endsWith('.tsx'));
     }
 
     /**
@@ -462,15 +469,18 @@ class RelevanceDetector {
         } catch (error) {
             // Database unavailable — fall back to reading YAML files directly
             console.warn('Standards patterns table not found. Falling back to file-based standards.');
-            return this.loadStandardsFromFiles(categories);
+            return this.loadStandardsFromFiles(categories, characteristics);
         }
     }
 
     /**
      * File-system fallback: load and filter standards from YAML files
      * Used when database is unavailable (local dev, first run, DB down)
+     * @param {Array<string>} categories - Categories to filter by
+     * @param {Object} characteristics - Project characteristics for relevance scoring
+     * @returns {Promise<Array>} Ranked standards
      */
-    async loadStandardsFromFiles(categories) {
+    async loadStandardsFromFiles(categories, characteristics = null) {
         try {
             const standardsPath = path.isAbsolute(this.standardsPath)
                 ? this.standardsPath
@@ -483,12 +493,20 @@ class RelevanceDetector {
             const validMaturity = ['enforced', 'validated', 'recommended'];
             const categorySet = new Set(categories);
 
-            return allPatterns
-                .filter(p => categorySet.has(p.category) && validMaturity.includes(p.maturity))
-                .sort((a, b) => {
-                    const maturityOrder = { enforced: 1, validated: 2, recommended: 3 };
-                    return (maturityOrder[a.maturity] || 3) - (maturityOrder[b.maturity] || 3);
-                });
+            const filtered = allPatterns.filter(p =>
+                categorySet.has(p.category) && validMaturity.includes(p.maturity)
+            );
+
+            // Apply full relevance scoring if characteristics provided
+            if (characteristics) {
+                return this.rankStandards(filtered, characteristics, categories);
+            }
+
+            // Fallback: sort by maturity only (legacy behavior)
+            return filtered.sort((a, b) => {
+                const maturityOrder = { enforced: 1, validated: 2, recommended: 3 };
+                return (maturityOrder[a.maturity] || 3) - (maturityOrder[b.maturity] || 3);
+            });
         } catch (fallbackError) {
             console.error('File-based standards fallback failed:', fallbackError.message);
             return [];
@@ -533,6 +551,11 @@ class RelevanceDetector {
                 score += 5;
             }
 
+            // Workflow bonus (actionable procedures are high-value)
+            if (standard.type === 'workflow' || (standard.tags && standard.tags.includes('workflow'))) {
+                score += 10;
+            }
+
             return {
                 ...standard,
                 relevance_score: Math.round(score * 10) / 10 // Round to 1 decimal
@@ -542,39 +565,103 @@ class RelevanceDetector {
 
     /**
      * Format standards for injection into Claude Code context
+     * Handles both standard rules and workflow procedures
      */
     formatForInjection(relevantStandards) {
         if (!relevantStandards || relevantStandards.length === 0) {
             return '';
         }
 
-        let output = '## Relevant Standards (Auto-Detected)\n\n';
+        const standards = [];
+        const workflows = [];
+
+        for (const item of relevantStandards) {
+            if (item.type === 'workflow' || (item.tags && item.tags.includes('workflow') && item.examples && item.examples[0]?.type === 'workflow')) {
+                workflows.push(item);
+            } else {
+                standards.push(item);
+            }
+        }
+
+        let output = '';
 
-        for (const standard of relevantStandards) {
-            output += `### ${standard.element}\n`;
-            output += `**Category**: ${standard.category}\n`;
-            output += `**Maturity**: ${standard.maturity}\n`;
-            output += `**Relevance**: ${standard.relevance_score}/100\n\n`;
-            output += `${standard.rule}\n\n`;
+        if (standards.length > 0) {
+            output += '## Relevant Standards (Auto-Detected)\n\n';
 
-            // Include examples if available
-            if (standard.examples && standard.examples.length > 0) {
-                output += '**Examples**:\n';
-                for (const example of standard.examples.slice(0, 2)) { // Max 2 examples
-                    output += `\`\`\`javascript\n${example.code || example}\n\`\`\`\n\n`;
+            for (const standard of standards) {
+                output += `### ${standard.element}\n`;
+                output += `**Category**: ${standard.category}\n`;
+                output += `**Maturity**: ${standard.maturity}\n`;
+                output += `**Relevance**: ${standard.relevance_score}/100\n\n`;
+                output += `${standard.rule}\n\n`;
+
+                if (standard.examples && standard.examples.length > 0) {
+                    output += '**Examples**:\n';
+                    for (const example of standard.examples.slice(0, 2)) {
+                        output += `\`\`\`javascript\n${example.code || example}\n\`\`\`\n\n`;
+                    }
                 }
-            }
 
-            // Include anti-patterns if available
-            if (standard.anti_patterns && Object.keys(standard.anti_patterns).length > 0) {
-                output += '**Anti-Patterns** (Avoid):\n';
-                for (const [key, value] of Object.entries(standard.anti_patterns)) {
-                    output += `- ❌ ${key}: ${value}\n`;
+                if (standard.anti_patterns && Object.keys(standard.anti_patterns).length > 0) {
+                    output += '**Anti-Patterns** (Avoid):\n';
+                    for (const [key, value] of Object.entries(standard.anti_patterns)) {
+                        output += `- ❌ ${key}: ${value}\n`;
+                    }
+                    output += '\n';
                 }
-                output += '\n';
+
+                output += '---\n\n';
             }
+        }
+
+        if (workflows.length > 0) {
+            output += '## Workflows (Auto-Detected)\n\n';
+
+            for (const workflow of workflows) {
+                const workflowData = workflow.examples && workflow.examples[0]?.type === 'workflow'
+                    ? workflow.examples[0]
+                    : null;
+
+                output += `### ${workflow.element}\n`;
+                output += `**Category**: ${workflow.category}\n`;
 
-            output += '---\n\n';
+                if (workflowData) {
+                    output += `**When**: ${workflowData.trigger}\n\n`;
+
+                    if (workflowData.preconditions && workflowData.preconditions.length > 0) {
+                        output += '**Preconditions**:\n';
+                        for (const pre of workflowData.preconditions) {
+                            output += `- ${pre}\n`;
+                        }
+                        output += '\n';
+                    }
+
+                    if (workflowData.steps && workflowData.steps.length > 0) {
+                        output += '**Steps**:\n';
+                        for (const step of workflowData.steps) {
+                            const gateMarker = step.gate ? ' (GATE)' : '';
+                            output += `${step.index}. **${step.name}**${gateMarker} — ${step.description}\n`;
+                            if (step.command) {
+                                output += `   \`${step.command.trim().split('\n')[0]}\`\n`;
+                            }
+                            if (step.validation) {
+                                output += `   Verify: ${step.validation}\n`;
+                            }
+                        }
+                        output += '\n';
+                    }
+                }
+
+                if (workflow.anti_patterns && Object.keys(workflow.anti_patterns).length > 0) {
+                    output += '**Anti-Patterns** (Avoid):\n';
+                    for (const [key, value] of Object.entries(workflow.anti_patterns)) {
+                        output += `- ❌ ${key}: ${value}\n`;
+                    }
+                    output += '\n';
+                }
+
+                output += '---\n\n';
+            }
         }
 
         return output;

package/src/core/StandardsIngestion.js

@@ -227,16 +227,13 @@ class StandardsIngestion {
 
   /**
    * Parse a YAML standards file into Rapport pattern format
-   * YAML format:
-   *   id: string
-   *   category: string
-   *   priority: 10 | 20 | 30
-   *   rules:
-   *     - action: ALWAYS | NEVER | USE | PREFER | AVOID
-   *       rule: string
-   *       applies_to: [glob patterns]
-   *   anti_patterns:
-   *     - string
+   * Supports both type: standard (v2.0) and type: workflow (v3.0)
+   *
+   * YAML format (standard):
+   *   id, category, priority, rules[], anti_patterns[]
+   *
+   * YAML format (workflow):
+   *   id, category, priority, type: workflow, trigger, steps[], preconditions[], anti_patterns[]
    */
   async parseYamlStandard(filepath, category) {
     const content = await fs.readFile(filepath, 'utf-8');
@@ -254,6 +251,11 @@ class StandardsIngestion {
       throw new Error('Invalid YAML structure: expected an object');
     }
 
+    // Route to workflow parser if type: workflow
+    if (doc.type === 'workflow') {
+      return this.parseYamlWorkflow(doc, filepath, filename, category);
+    }
+
     const patterns = [];
     const standardId = doc.id || filename;
     const standardCategory = doc.category || category;
@@ -268,15 +270,36 @@ class StandardsIngestion {
         }))
       : [];
 
-    // Extract examples - now a named object in YAML format
+    // Extract examples - handles both array of strings and named object formats
     const examples = [];
-    if (doc.examples && typeof doc.examples === 'object') {
-      for (const [name, code] of Object.entries(doc.examples)) {
-        examples.push({
-          description: name.replace(/_/g, ' '),
-          code: typeof code === 'string' ? code.trim() : String(code),
-          language: this.inferLanguageFromCode(code)
-        });
+    if (doc.examples) {
+      if (Array.isArray(doc.examples)) {
+        // Array format: ["code example 1", "code example 2"]
+        for (const example of doc.examples) {
+          if (typeof example === 'string') {
+            examples.push({
+              description: 'Example',
+              code: example.trim(),
+              language: this.inferLanguageFromCode(example)
+            });
+          } else if (typeof example === 'object' && example !== null) {
+            // Object in array: { description: "...", code: "..." }
+            examples.push({
+              description: example.description || 'Example',
+              code: (example.code || '').trim(),
+              language: example.language || this.inferLanguageFromCode(example.code || '')
+            });
+          }
+        }
+      } else if (typeof doc.examples === 'object') {
+        // Named object format: { example_name: "code here" }
+        for (const [name, code] of Object.entries(doc.examples)) {
+          examples.push({
+            description: name.replace(/_/g, ' '),
+            code: typeof code === 'string' ? code.trim() : String(code),
+            language: this.inferLanguageFromCode(code)
+          });
+        }
       }
     }
 
@@ -366,6 +389,84 @@ class StandardsIngestion {
     return { patterns };
   }
 
+  /**
+   * Parse a workflow YAML file into a single Rapport pattern with workflow metadata
+   * Workflows are stored as one pattern (not exploded into per-rule patterns)
+   * so the injection system can render them as ordered procedures.
+   */
+  parseYamlWorkflow(doc, filepath, filename, category) {
+    const standardId = doc.id || filename;
+    const standardCategory = doc.category || category;
+    const standardPriority = doc.priority || 10; // Workflows default to high priority
+
+    const antiPatterns = Array.isArray(doc.anti_patterns)
+      ? doc.anti_patterns.map(ap => ({
+          description: typeof ap === 'string' ? ap : ap.description || 'Anti-pattern to avoid',
+          code: typeof ap === 'object' ? ap.code : null,
+          language: typeof ap === 'object' ? ap.language : null
+        }))
+      : [];
+
+    const tags = Array.isArray(doc.tags) ? doc.tags : [];
+    const costImpact = doc.cost_impact && typeof doc.cost_impact === 'object'
+      ? doc.cost_impact
+      : (typeof doc.cost_impact === 'string' ? { description: doc.cost_impact } : null);
+
+    const steps = Array.isArray(doc.steps) ? doc.steps : [];
+    const preconditions = Array.isArray(doc.preconditions) ? doc.preconditions : [];
+    const trigger = doc.trigger || '';
+    const related = Array.isArray(doc.related) ? doc.related : [];
+
+    const patternId = this.generatePatternId(standardCategory, standardId, 'workflow');
+
+    // Build a readable element name from the id
+    const element = standardId.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+
+    // The rule field contains the trigger for search/matching
+    const rule = `WORKFLOW: ${trigger}`;
+
+    // Store workflow structure in examples field (JSON-serializable)
+    // This preserves the full workflow for the injection formatter
+    const workflowData = {
+      type: 'workflow',
+      trigger: trigger,
+      preconditions: preconditions,
+      steps: steps.map((step, i) => ({
+        index: i + 1,
+        name: step.name || `Step ${i + 1}`,
+        description: step.description || '',
+        command: step.command || null,
+        validation: step.validation || null,
+        standards: Array.isArray(step.standards) ? step.standards : [],
+        gate: step.gate === true
+      })),
+      related: related
+    };
+
+    return {
+      patterns: [{
+        pattern_id: patternId,
+        file_name: filename,
+        element: element,
+        rule: rule,
+        priority: standardPriority,
+        correlation: 1.0,
+        source: 'equilateral-standards',
+        maturity: 'enforced',
+        scope: 'organization',
+        category: standardCategory,
+        applicable_files: this.extractApplicableFiles('', standardCategory),
+        anti_patterns: antiPatterns,
+        examples: [workflowData], // Workflow data stored as first example
+        cost_impact: costImpact,
+        tags: [...tags, 'workflow'],
+        source_file: filepath,
+        title: standardId,
+        type: 'workflow' // Flag for injection formatter
+      }]
+    };
+  }
+
   /**
    * Parse a markdown standards file into Rapport pattern format
    */

package/src/handlers/activity/activityGetMe.js

@@ -77,7 +77,7 @@ exports.handler = wrapHandler(async ({ requestContext }) => {
                     last_30_days: parseInt(activity.commits_30d) || 0,
                     last_7_days: parseInt(activity.commits_7d) || 0,
                     last_commit: activity.last_commit,
-                    days_since_commit: parseInt(activity.days_since_commit) || null
+                    days_since_commit: activity.days_since_commit !== null ? parseInt(activity.days_since_commit) : null
                 },
                 pull_requests: {
                     opened_30d: parseInt(activity.prs_opened_30d) || 0,

package/src/handlers/activity/activityGetTeam.js

@@ -18,10 +18,10 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
 
     // Check if user is a manager or admin
     const managerCheck = await executeQuery(`
-        SELECT ue."Company_ID", ue."Manager", ue."Admin", u."Super_Admin"
-        FROM "UserEntitlements" ue
-        JOIN "Users" u ON ue."Email_Address" = u."Email_Address"
-        WHERE ue."Email_Address" = $1
+        SELECT ue.company_id, ue.manager, ue.admin, u.super_admin
+        FROM rapport.user_entitlements ue
+        JOIN rapport.users u ON ue.email_address = u.email_address
+        WHERE ue.email_address = $1
     `, [email]);
 
     if (managerCheck.rowCount === 0) {
@@ -29,72 +29,117 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
     }
 
     const userRole = managerCheck.rows[0];
-    const isAuthorized = userRole.Manager || userRole.Admin || userRole.Super_Admin;
+    const isAuthorized = userRole.manager || userRole.admin || userRole.super_admin;
 
     if (!isAuthorized) {
         return createErrorResponse(403, 'Manager or Admin access required');
     }
 
-    const companyId = queryStringParameters?.company_id || userRole.Company_ID;
+    const companyId = queryStringParameters?.company_id || userRole.company_id;
 
-    // Get team summary
+    // Get team summary directly from base tables
     const summaryResult = await executeQuery(`
-        SELECT * FROM rapport.v_team_activity_summary
-        WHERE company_id = $1
+        SELECT
+            COUNT(DISTINCT ue.email_address) as total_developers,
+            COUNT(DISTINCT ue.email_address) FILTER (
+                WHERE EXISTS (
+                    SELECT 1 FROM rapport.sessions s
+                    WHERE s.email_address = ue.email_address
+                    AND s.started_at > NOW() - INTERVAL '30 days'
+                )
+            ) as active_developers
+        FROM rapport.user_entitlements ue
+        JOIN rapport.users u ON ue.email_address = u.email_address
+        WHERE ue.company_id = $1
+        AND u.active = true
     `, [companyId]);
 
     // Get individual developer activity
     const developersResult = await executeQuery(`
         SELECT
-            email_address,
-            display_name,
-            sessions_30d,
-            sessions_7d,
-            last_session,
-            commits_30d,
-            commits_7d,
-            last_commit,
-            days_since_commit,
-            prs_merged_30d,
-            session_to_commit_conversion_pct
-        FROM rapport.mv_developer_activity
-        WHERE company_id = $1
+            ue.email_address,
+            u.first_name || ' ' || u.last_name as display_name,
+            COALESCE(sess.sessions_30d, 0) as sessions_30d,
+            COALESCE(sess.sessions_7d, 0) as sessions_7d,
+            sess.last_session,
+            COALESCE(comm.commits_30d, 0) as commits_30d,
+            COALESCE(comm.commits_7d, 0) as commits_7d,
+            comm.last_commit,
+            CASE WHEN comm.last_commit IS NOT NULL
+                THEN EXTRACT(DAY FROM NOW() - comm.last_commit)::INTEGER
+                ELSE NULL
+            END as days_since_commit,
+            COALESCE(pr_data.prs_merged_30d, 0) as prs_merged_30d
+        FROM rapport.user_entitlements ue
+        JOIN rapport.users u ON ue.email_address = u.email_address
+        LEFT JOIN (
+            SELECT email_address,
+                COUNT(*) FILTER (WHERE started_at > NOW() - INTERVAL '30 days') as sessions_30d,
+                COUNT(*) FILTER (WHERE started_at > NOW() - INTERVAL '7 days') as sessions_7d,
+                MAX(started_at) as last_session
+            FROM rapport.sessions
+            GROUP BY email_address
+        ) sess ON sess.email_address = ue.email_address
+        LEFT JOIN (
+            SELECT author_email,
+                COUNT(*) FILTER (WHERE commit_timestamp > NOW() - INTERVAL '30 days') as commits_30d,
+                COUNT(*) FILTER (WHERE commit_timestamp > NOW() - INTERVAL '7 days') as commits_7d,
+                MAX(commit_timestamp) as last_commit
+            FROM rapport.commits
+            GROUP BY author_email
+        ) comm ON comm.author_email = ue.email_address
+        LEFT JOIN (
+            SELECT pr.author_email,
+                COUNT(*) as prs_merged_30d
+            FROM rapport.pull_requests pr
+            WHERE pr.merged_at > NOW() - INTERVAL '30 days'
+            GROUP BY pr.author_email
+        ) pr_data ON pr_data.author_email = ue.email_address
+        WHERE ue.company_id = $1
+        AND u.active = true
         ORDER BY
-            CASE
-                WHEN days_since_commit IS NULL THEN 999
-                ELSE days_since_commit
+            CASE WHEN comm.last_commit IS NULL THEN 999
+                 ELSE EXTRACT(DAY FROM NOW() - comm.last_commit)
             END DESC,
-            sessions_30d DESC
+            COALESCE(sess.sessions_30d, 0) DESC
     `, [companyId]);
 
     const summary = summaryResult.rows[0] || {
         total_developers: 0,
-        active_developers: 0,
-        stale_developers: 0,
-        very_stale_developers: 0,
-        avg_sessions_30d: 0,
-        avg_commits_30d: 0,
-        avg_conversion_pct: 0
+        active_developers: 0
     };
 
-    const developers = developersResult.rows.map(dev => ({
-        email_address: dev.email_address,
-        display_name: dev.display_name,
-        sessions: {
-            last_30_days: parseInt(dev.sessions_30d) || 0,
-            last_7_days: parseInt(dev.sessions_7d) || 0,
-            last_session: dev.last_session
-        },
-        commits: {
-            last_30_days: parseInt(dev.commits_30d) || 0,
-            last_7_days: parseInt(dev.commits_7d) || 0,
-            last_commit: dev.last_commit,
-            days_since_commit: parseInt(dev.days_since_commit) || null
-        },
-        prs_merged_30d: parseInt(dev.prs_merged_30d) || 0,
-        session_to_commit_conversion_pct: parseFloat(dev.session_to_commit_conversion_pct) || 0,
-        status: getDevStatus(dev)
-    }));
+    const developers = developersResult.rows.map(dev => {
+        const sessions30d = parseInt(dev.sessions_30d) || 0;
+        const commits30d = parseInt(dev.commits_30d) || 0;
+        const conversionPct = sessions30d > 0 ? Math.round((commits30d / sessions30d) * 100) : 0;
+
+        return {
+            email_address: dev.email_address,
+            display_name: dev.display_name,
+            sessions: {
+                last_30_days: sessions30d,
+                last_7_days: parseInt(dev.sessions_7d) || 0,
+                last_session: dev.last_session
+            },
+            commits: {
+                last_30_days: commits30d,
+                last_7_days: parseInt(dev.commits_7d) || 0,
+                last_commit: dev.last_commit,
+                days_since_commit: parseInt(dev.days_since_commit) || null
+            },
+            prs_merged_30d: parseInt(dev.prs_merged_30d) || 0,
+            session_to_commit_conversion_pct: conversionPct,
+            status: getDevStatus(dev)
+        };
+    });
+
+    const totalSessions = developers.reduce((sum, d) => sum + d.sessions.last_30_days, 0);
+    const totalCommits = developers.reduce((sum, d) => sum + d.commits.last_30_days, 0);
+    const devCount = developers.length || 1;
+    const avgConversion = developers.length > 0
+        ? developers.reduce((sum, d) => sum + d.session_to_commit_conversion_pct, 0) / developers.length
+        : 0;
 
     return createSuccessResponse(
         {
@@ -103,11 +148,11 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
                 summary: {
                     total_developers: parseInt(summary.total_developers) || 0,
                     active_developers: parseInt(summary.active_developers) || 0,
-                    stale_developers: parseInt(summary.stale_developers) || 0,
-                    very_stale_developers: parseInt(summary.very_stale_developers) || 0,
-                    avg_sessions_30d: parseFloat(summary.avg_sessions_30d)?.toFixed(1) || 0,
-                    avg_commits_30d: parseFloat(summary.avg_commits_30d)?.toFixed(1) || 0,
-                    avg_conversion_pct: parseFloat(summary.avg_conversion_pct)?.toFixed(1) || 0
+                    stale_developers: developers.filter(d => d.status === 'stale').length,
+                    very_stale_developers: developers.filter(d => d.status === 'very_stale').length,
+                    avg_sessions_30d: parseFloat((totalSessions / devCount).toFixed(1)),
+                    avg_commits_30d: parseFloat((totalCommits / devCount).toFixed(1)),
+                    avg_conversion_pct: parseFloat(avgConversion.toFixed(1))
                 },
                 developers
             }]