@equilateral_ai/mindmeld 3.5.3 → 4.0.1

package/src/handlers/enterprise/enterpriseKnowledgeGet.js

@@ -1,87 +0,0 @@
-/**
- * Enterprise Knowledge Get Handler
- *
- * GET /api/enterprise/knowledge?page=&pageSize=&status=&category=
- * Returns: { Records: CuratedKnowledge[] } + meta { Total_Records, Page, Page_Size, Request_ID, Timestamp }
- * Auth: Cognito JWT required, enterprise tier only
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
-
-async function getEnterpriseKnowledge({ queryStringParameters, requestContext }) {
-    try {
-        const Request_ID = requestContext.requestId;
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-        if (!email) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        const userResult = await executeQuery(
-            `SELECT u.client_id, c.subscription_tier
-             FROM rapport.users u
-             JOIN rapport.clients c ON c.client_id = u.client_id
-             WHERE u.email_address = $1 LIMIT 1`,
-            [email]
-        );
-        if (!userResult.rows.length) {
-            return createErrorResponse(403, 'User not found');
-        }
-        if (userResult.rows[0].subscription_tier !== 'enterprise') {
-            return createErrorResponse(403, 'Enterprise subscription required');
-        }
-        const clientId = userResult.rows[0].client_id;
-
-        const params = queryStringParameters || {};
-        const page = Math.max(1, parseInt(params.page) || 1);
-        const pageSize = Math.min(100, Math.max(1, parseInt(params.pageSize) || 20));
-        const offset = (page - 1) * pageSize;
-
-        const conditions = ['client_id = $1'];
-        const values = [clientId];
-        let paramIndex = 2;
-
-        if (params.status) {
-            conditions.push(`status = $${paramIndex}`);
-            values.push(params.status);
-            paramIndex++;
-        }
-
-        if (params.category) {
-            conditions.push(`category = $${paramIndex}`);
-            values.push(params.category);
-            paramIndex++;
-        }
-
-        const whereClause = conditions.join(' AND ');
-
-        const countResult = await executeQuery(
-            `SELECT COUNT(*) as total FROM rapport.curated_knowledge WHERE ${whereClause}`,
-            values
-        );
-        const total = parseInt(countResult.rows[0].total);
-
-        const dataResult = await executeQuery(
-            `SELECT
-                knowledge_id, client_id, invariant_id,
-                title, content, category, tags,
-                curator_email, status,
-                created_at, published_at
-            FROM rapport.curated_knowledge
-            WHERE ${whereClause}
-            ORDER BY created_at DESC
-            LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
-            [...values, pageSize, offset]
-        );
-
-        return createSuccessResponse(
-            { Records: dataResult.rows },
-            'Knowledge items retrieved',
-            { Total_Records: total, Page: page, Page_Size: pageSize, Request_ID, Timestamp: new Date().toISOString() }
-        );
-
-    } catch (error) {
-        return handleError(error);
-    }
-}
-
-exports.handler = wrapHandler(getEnterpriseKnowledge);

package/src/handlers/enterprise/enterpriseKnowledgeUpdate.js

@@ -1,122 +0,0 @@
-/**
- * Enterprise Knowledge Update Handler
- *
- * PUT /api/enterprise/knowledge
- * Body: { knowledge_id, title?, content?, category?, tags?, status? }
- * Returns: { Records: [CuratedKnowledge] } + meta
- * Auth: Cognito JWT required, enterprise tier only
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError, logModificationEvent, AuditEventType, EntityType } = require('./helpers');
-
-async function updateEnterpriseKnowledge({ body, requestContext }) {
-    try {
-        const Request_ID = requestContext.requestId;
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-        if (!email) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        const userResult = await executeQuery(
-            `SELECT u.client_id, c.subscription_tier
-             FROM rapport.users u
-             JOIN rapport.clients c ON c.client_id = u.client_id
-             WHERE u.email_address = $1 LIMIT 1`,
-            [email]
-        );
-        if (!userResult.rows.length) {
-            return createErrorResponse(403, 'User not found');
-        }
-        if (userResult.rows[0].subscription_tier !== 'enterprise') {
-            return createErrorResponse(403, 'Enterprise subscription required');
-        }
-        const clientId = userResult.rows[0].client_id;
-
-        const requestBody = body || {};
-        const { knowledge_id, title, content, category, tags, status } = requestBody;
-
-        if (!knowledge_id) {
-            return createErrorResponse(400, 'knowledge_id is required');
-        }
-
-        // Fetch current state for audit trail
-        const current = await executeQuery(
-            'SELECT * FROM rapport.curated_knowledge WHERE knowledge_id = $1 AND client_id = $2',
-            [knowledge_id, clientId]
-        );
-        if (!current.rows.length) {
-            return createErrorResponse(404, 'Knowledge item not found');
-        }
-        const beforeState = current.rows[0];
-
-        // Build dynamic update
-        const updates = [];
-        const values = [];
-        let paramIndex = 1;
-
-        if (title !== undefined) {
-            updates.push(`title = $${paramIndex}`);
-            values.push(title);
-            paramIndex++;
-        }
-        if (content !== undefined) {
-            updates.push(`content = $${paramIndex}`);
-            values.push(content);
-            paramIndex++;
-        }
-        if (category !== undefined) {
-            updates.push(`category = $${paramIndex}`);
-            values.push(category || null);
-            paramIndex++;
-        }
-        if (tags !== undefined) {
-            updates.push(`tags = $${paramIndex}`);
-            values.push(tags);
-            paramIndex++;
-        }
-        if (status !== undefined) {
-            updates.push(`status = $${paramIndex}`);
-            values.push(status);
-            paramIndex++;
-
-            // Set published_at when transitioning to published
-            if (status === 'published' && beforeState.status !== 'published') {
-                updates.push('published_at = NOW()');
-            }
-        }
-
-        if (updates.length === 0) {
-            return createErrorResponse(400, 'No fields to update');
-        }
-
-        updates.push('updated_at = NOW()');
-
-        const result = await executeQuery(
-            `UPDATE rapport.curated_knowledge
-            SET ${updates.join(', ')}
-            WHERE knowledge_id = $${paramIndex} AND client_id = $${paramIndex + 1}
-            RETURNING *`,
-            [...values, knowledge_id, clientId]
-        );
-
-        const updated = result.rows[0];
-
-        await logModificationEvent(AuditEventType.DATA_UPDATE, EntityType.KNOWLEDGE, String(knowledge_id), {
-            requestContext,
-            client_id: clientId,
-            before_state: { title: beforeState.title, status: beforeState.status, category: beforeState.category },
-            after_state: { title: updated.title, status: updated.status, category: updated.category },
-        });
-
-        return createSuccessResponse(
-            { Records: [updated] },
-            'Knowledge item updated',
-            { Total_Records: 1, Request_ID, Timestamp: new Date().toISOString() }
-        );
-
-    } catch (error) {
-        return handleError(error);
-    }
-}
-
-exports.handler = wrapHandler(updateEnterpriseKnowledge);

package/src/handlers/enterprise/enterpriseOnboardingComplete.js

@@ -1,77 +0,0 @@
-/**
- * Enterprise Onboarding Complete Handler
- *
- * POST /api/enterprise/onboarding/complete
- * Auth: Cognito JWT required, enterprise tier only
- *
- * Body: { enabled_categories?: Record<string, boolean> }
- * Marks onboarding as completed and optionally saves standards preferences.
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
-
-async function enterpriseOnboardingComplete({ requestContext, body }) {
-    try {
-        const Request_ID = requestContext.requestId;
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-        if (!email) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        // Look up client_id and company_id
-        const userResult = await executeQuery(
-            `SELECT u.client_id, ue.company_id
-             FROM rapport.users u
-             JOIN rapport.user_entitlements ue ON ue.email_address = u.email_address
-             WHERE u.email_address = $1
-             LIMIT 1`,
-            [email]
-        );
-        if (!userResult.rows.length) {
-            return createErrorResponse(403, 'User not found or no company assigned');
-        }
-
-        const { client_id, company_id } = userResult.rows[0];
-        if (!company_id) {
-            return createErrorResponse(400, 'No company associated with this account');
-        }
-
-        // Verify enterprise tier
-        const clientResult = await executeQuery(
-            'SELECT subscription_tier FROM rapport.clients WHERE client_id = $1',
-            [client_id]
-        );
-        if (!clientResult.rows.length || clientResult.rows[0].subscription_tier !== 'enterprise') {
-            return createErrorResponse(403, 'Enterprise subscription required');
-        }
-
-        // Save standards preferences if provided
-        const enabledCategories = body?.enabled_categories;
-        const standardsConfigured = enabledCategories && Object.keys(enabledCategories).length > 0;
-
-        // Mark onboarding as completed
-        await executeQuery(
-            `INSERT INTO rapport.enterprise_onboarding_status
-                (company_id, step_completed, standards_configured, completed, completed_at, completed_by)
-             VALUES ($1, 5, $2, true, NOW(), $3)
-             ON CONFLICT (company_id) DO UPDATE SET
-                step_completed = 5,
-                standards_configured = COALESCE($2, rapport.enterprise_onboarding_status.standards_configured),
-                completed = true,
-                completed_at = NOW(),
-                completed_by = $3`,
-            [company_id, standardsConfigured || false, email]
-        );
-
-        return createSuccessResponse(
-            { Records: [{ company_id, completed: true }] },
-            'Enterprise onboarding completed',
-            { Request_ID, Timestamp: new Date().toISOString() }
-        );
-
-    } catch (error) {
-        return handleError(error);
-    }
-}
-
-exports.handler = wrapHandler(enterpriseOnboardingComplete);

package/src/handlers/enterprise/enterpriseOnboardingInvite.js

@@ -1,138 +0,0 @@
-/**
- * Enterprise Onboarding Invite Handler
- *
- * POST /api/enterprise/onboarding/invite
- * Auth: Cognito JWT required, enterprise tier only
- *
- * Body: { invitations: [{ email, role }] }
- * Creates invitation records for team members. Max 10 per request.
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
-
-async function enterpriseOnboardingInvite({ requestContext, body }) {
-    try {
-        const Request_ID = requestContext.requestId;
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-        if (!email) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        // Look up client_id and company_id
-        const userResult = await executeQuery(
-            `SELECT u.client_id, ue.company_id
-             FROM rapport.users u
-             JOIN rapport.user_entitlements ue ON ue.email_address = u.email_address
-             WHERE u.email_address = $1
-             LIMIT 1`,
-            [email]
-        );
-        if (!userResult.rows.length) {
-            return createErrorResponse(403, 'User not found or no company assigned');
-        }
-
-        const { client_id, company_id } = userResult.rows[0];
-        if (!company_id) {
-            return createErrorResponse(400, 'No company associated with this account');
-        }
-
-        // Verify enterprise tier
-        const clientResult = await executeQuery(
-            'SELECT subscription_tier, seat_count FROM rapport.clients WHERE client_id = $1',
-            [client_id]
-        );
-        if (!clientResult.rows.length || clientResult.rows[0].subscription_tier !== 'enterprise') {
-            return createErrorResponse(403, 'Enterprise subscription required');
-        }
-
-        const seatCount = clientResult.rows[0].seat_count || 25;
-
-        // Validate invitations
-        const invitations = body?.invitations;
-        if (!Array.isArray(invitations) || invitations.length === 0) {
-            return createErrorResponse(400, 'invitations array is required');
-        }
-        if (invitations.length > 10) {
-            return createErrorResponse(400, 'Maximum 10 invitations per request');
-        }
-
-        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-        const validRoles = ['admin', 'member'];
-
-        for (const inv of invitations) {
-            if (!inv.email || !emailRegex.test(inv.email)) {
-                return createErrorResponse(400, `Invalid email: ${inv.email || '(empty)'}`);
-            }
-            if (!inv.role || !validRoles.includes(inv.role)) {
-                return createErrorResponse(400, `Invalid role for ${inv.email}: must be admin or member`);
-            }
-        }
-
-        // Check seat capacity
-        const existingResult = await executeQuery(
-            `SELECT COUNT(*) as count FROM rapport.user_entitlements WHERE company_id = $1`,
-            [company_id]
-        );
-        const existingUsers = parseInt(existingResult.rows[0].count, 10);
-
-        const pendingResult = await executeQuery(
-            `SELECT COUNT(*) as count FROM rapport.enterprise_invitations
-             WHERE company_id = $1 AND status = 'pending'`,
-            [company_id]
-        );
-        const pendingInvites = parseInt(pendingResult.rows[0].count, 10);
-
-        const totalAfterInvite = existingUsers + pendingInvites + invitations.length;
-        if (totalAfterInvite > seatCount) {
-            return createErrorResponse(400,
-                `Seat limit exceeded. You have ${seatCount} seats, ${existingUsers} users, ${pendingInvites} pending invites. Cannot add ${invitations.length} more.`
-            );
-        }
-
-        // Insert invitations (skip duplicates)
-        const inserted = [];
-        for (const inv of invitations) {
-            try {
-                const result = await executeQuery(
-                    `INSERT INTO rapport.enterprise_invitations
-                        (client_id, company_id, email, role, invited_by, status, created_at)
-                     VALUES ($1, $2, $3, $4, $5, 'pending', NOW())
-                     ON CONFLICT (company_id, email) DO UPDATE SET
-                        role = EXCLUDED.role,
-                        invited_by = EXCLUDED.invited_by,
-                        status = 'pending',
-                        created_at = NOW()
-                     RETURNING invitation_id, email, role, status`,
-                    [client_id, company_id, inv.email.toLowerCase(), inv.role, email]
-                );
-                if (result.rows.length) {
-                    inserted.push(result.rows[0]);
-                }
-            } catch (insertErr) {
-                console.log(`[EnterpriseInvite] Failed to insert invite for ${inv.email}:`, insertErr.message);
-            }
-        }
-
-        // Update onboarding status
-        await executeQuery(
-            `INSERT INTO rapport.enterprise_onboarding_status
-                (company_id, step_completed, invites_sent, completed_by)
-             VALUES ($1, 2, $2, $3)
-             ON CONFLICT (company_id) DO UPDATE SET
-                step_completed = GREATEST(rapport.enterprise_onboarding_status.step_completed, 2),
-                invites_sent = $2`,
-            [company_id, inserted.length, email]
-        );
-
-        return createSuccessResponse(
-            { Records: inserted, sent: inserted.length },
-            `${inserted.length} invitation(s) created`,
-            { Request_ID, Timestamp: new Date().toISOString() }
-        );
-
-    } catch (error) {
-        return handleError(error);
-    }
-}
-
-exports.handler = wrapHandler(enterpriseOnboardingInvite);

package/src/handlers/enterprise/enterpriseOnboardingSetup.js

@@ -1,128 +0,0 @@
-/**
- * Enterprise Onboarding Setup Handler
- *
- * POST /api/enterprise/onboarding/setup
- * Auth: Cognito JWT required, enterprise tier only
- *
- * Body: { company_name, domain, industry?, company_size? }
- * Updates the company profile and marks onboarding step 1 complete.
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
-
-async function enterpriseOnboardingSetup({ requestContext, body }) {
-    try {
-        const Request_ID = requestContext.requestId;
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-        if (!email) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        // Look up client_id and company_id for the authenticated user
-        const userResult = await executeQuery(
-            `SELECT u.client_id, ue.company_id
-             FROM rapport.users u
-             JOIN rapport.user_entitlements ue ON ue.email_address = u.email_address
-             WHERE u.email_address = $1
-             LIMIT 1`,
-            [email]
-        );
-        if (!userResult.rows.length) {
-            return createErrorResponse(403, 'User not found or no company assigned');
-        }
-
-        const { client_id, company_id: currentCompanyId } = userResult.rows[0];
-        if (!currentCompanyId) {
-            return createErrorResponse(400, 'No company associated with this account');
-        }
-
-        // Verify enterprise tier
-        const clientResult = await executeQuery(
-            'SELECT subscription_tier FROM rapport.clients WHERE client_id = $1',
-            [client_id]
-        );
-        if (!clientResult.rows.length || clientResult.rows[0].subscription_tier !== 'enterprise') {
-            return createErrorResponse(403, 'Enterprise subscription required');
-        }
-
-        // Validate required fields
-        const companyName = body?.company_name;
-        const domain = body?.domain;
-        if (!companyName || !domain) {
-            return createErrorResponse(400, 'company_name and domain are required');
-        }
-
-        const industry = body?.industry || null;
-        const companySize = body?.company_size || null;
-
-        // Generate a proper enterprise company_id from company name
-        const enterpriseCompanyId = `${companyName.replace(/[^a-zA-Z0-9]/g, '_').toUpperCase()}_MAIN`;
-        let company_id = currentCompanyId;
-
-        if (enterpriseCompanyId !== currentCompanyId) {
-            // Create the enterprise company (or update if it already exists)
-            await executeQuery(
-                `INSERT INTO rapport.companies (company_id, client_id, company_name, company_status, domain, industry, company_size)
-                 VALUES ($1, $2, $3, 'Active', $4, $5, $6)
-                 ON CONFLICT (company_id) DO UPDATE SET
-                    company_name = $3, domain = $4, industry = $5, company_size = $6, last_updated = NOW()`,
-                [enterpriseCompanyId, client_id, companyName, domain, industry, companySize]
-            );
-
-            // Migrate user entitlement from personal to enterprise company
-            await executeQuery(
-                `UPDATE rapport.user_entitlements
-                 SET company_id = $1
-                 WHERE email_address = $2 AND company_id = $3`,
-                [enterpriseCompanyId, email, currentCompanyId]
-            );
-
-            // Clean up orphaned personal company if nothing else references it
-            await executeQuery(
-                `DELETE FROM rapport.companies
-                 WHERE company_id = $1
-                 AND NOT EXISTS (
-                     SELECT 1 FROM rapport.user_entitlements WHERE company_id = $1
-                 )
-                 AND NOT EXISTS (
-                     SELECT 1 FROM rapport.projects WHERE company_id = $1
-                 )`,
-                [currentCompanyId]
-            );
-
-            company_id = enterpriseCompanyId;
-            console.log(`Migrated company: ${currentCompanyId} -> ${enterpriseCompanyId}`);
-        } else {
-            // Same company_id, just update profile
-            await executeQuery(
-                `UPDATE rapport.companies
-                 SET company_name = $1, domain = $2, industry = $3, company_size = $4, last_updated = NOW()
-                 WHERE company_id = $5`,
-                [companyName, domain, industry, companySize, company_id]
-            );
-        }
-
-        // Upsert onboarding status
-        await executeQuery(
-            `INSERT INTO rapport.enterprise_onboarding_status
-                (company_id, step_completed, org_configured, started_at, completed_by)
-             VALUES ($1, 1, true, NOW(), $2)
-             ON CONFLICT (company_id) DO UPDATE SET
-                step_completed = GREATEST(rapport.enterprise_onboarding_status.step_completed, 1),
-                org_configured = true,
-                completed_by = $2`,
-            [company_id, email]
-        );
-
-        return createSuccessResponse(
-            { Records: [{ company_id, company_name: companyName, domain, step_completed: 1 }] },
-            'Organization profile saved',
-            { Request_ID, Timestamp: new Date().toISOString() }
-        );
-
-    } catch (error) {
-        return handleError(error);
-    }
-}
-
-exports.handler = wrapHandler(enterpriseOnboardingSetup);

package/src/handlers/enterprise/enterpriseOnboardingStatus.js

@@ -1,88 +0,0 @@
-/**
- * Enterprise Onboarding Status Handler
- *
- * GET /api/enterprise/onboarding/status
- * Auth: Cognito JWT required
- *
- * Returns the enterprise onboarding completion state for the user's company.
- * Used by Dashboard to decide whether to redirect to enterprise onboarding.
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
-
-async function getEnterpriseOnboardingStatus({ requestContext }) {
-    try {
-        const Request_ID = requestContext.requestId;
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-        if (!email) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        // Look up client_id and company_id
-        const userResult = await executeQuery(
-            `SELECT u.client_id, ue.company_id
-             FROM rapport.users u
-             JOIN rapport.user_entitlements ue ON ue.email_address = u.email_address
-             WHERE u.email_address = $1
-             LIMIT 1`,
-            [email]
-        );
-        if (!userResult.rows.length) {
-            return createSuccessResponse(
-                { Records: [{ completed: false, step_completed: 0 }] },
-                'No company found',
-                { Request_ID, Timestamp: new Date().toISOString() }
-            );
-        }
-
-        const { client_id, company_id } = userResult.rows[0];
-        if (!company_id) {
-            return createSuccessResponse(
-                { Records: [{ completed: false, step_completed: 0 }] },
-                'No company assigned',
-                { Request_ID, Timestamp: new Date().toISOString() }
-            );
-        }
-
-        // Check if enterprise tier
-        const clientResult = await executeQuery(
-            'SELECT subscription_tier FROM rapport.clients WHERE client_id = $1',
-            [client_id]
-        );
-        if (!clientResult.rows.length || clientResult.rows[0].subscription_tier !== 'enterprise') {
-            return createSuccessResponse(
-                { Records: [{ completed: true, step_completed: 5, not_enterprise: true }] },
-                'Not an enterprise account',
-                { Request_ID, Timestamp: new Date().toISOString() }
-            );
-        }
-
-        // Get onboarding status
-        const statusResult = await executeQuery(
-            `SELECT *
-             FROM rapport.enterprise_onboarding_status
-             WHERE company_id = $1`,
-            [company_id]
-        );
-
-        if (!statusResult.rows.length) {
-            return createSuccessResponse(
-                { Records: [{ completed: false, step_completed: 0, company_id }] },
-                'Onboarding not started',
-                { Request_ID, Timestamp: new Date().toISOString() }
-            );
-        }
-
-        const status = statusResult.rows[0];
-        return createSuccessResponse(
-            { Records: [{ ...status, company_id }] },
-            'Onboarding status retrieved',
-            { Request_ID, Timestamp: new Date().toISOString() }
-        );
-
-    } catch (error) {
-        return handleError(error);
-    }
-}
-
-exports.handler = wrapHandler(getEnterpriseOnboardingStatus);

package/src/handlers/github/githubConnectionStatus.js

@@ -1,49 +0,0 @@
-/**
- * GitHub Connection Status Handler
- * Returns current GitHub connection status
- *
- * GET /api/github/status (CognitoAuthorizer)
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
-
-async function githubConnectionStatus({ requestContext }) {
-    try {
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-
-        if (!email) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        // Check for active connection
-        const connResult = await executeQuery(`
-            SELECT github_username, connected_at, last_used_at
-            FROM rapport.github_connections
-            WHERE email_address = $1 AND revoked = FALSE
-        `, [email]);
-
-        const connected = connResult.rowCount > 0;
-        const github_username = connected ? connResult.rows[0].github_username : null;
-
-        // Count projects with GitHub connected
-        const projectsResult = await executeQuery(`
-            SELECT COUNT(*) as count FROM rapport.projects p
-            JOIN rapport.project_collaborators pc ON p.project_id = pc.project_id
-            WHERE pc.email_address = $1
-            AND p.repo_url IS NOT NULL
-            AND p.archived = FALSE
-        `, [email]);
-
-        const projects_connected = parseInt(projectsResult.rows[0].count);
-
-        return createSuccessResponse(
-            { connected, github_username, projects_connected },
-            'Status retrieved'
-        );
-    } catch (error) {
-        console.error('GitHub Status Error:', error);
-        return createErrorResponse(500, 'Failed to get connection status');
-    }
-}
-
-exports.handler = wrapHandler(githubConnectionStatus);