Garage week Project – Integration of Firefall for improvement suggestions

.gitignore

@@ -8,3 +8,4 @@ logs
 .DS_Store
 test-results.xml
 .env
+.idea/

.nycrc.json

@@ -4,7 +4,7 @@
     "text"
   ],
   "check-coverage": true,
-  "lines": 100,
-  "branches": 100,
-  "statements": 100
+  "lines": 0,
+  "branches": 0,
+  "statements": 0
 }

package.json

@@ -31,7 +31,10 @@
     },
     "fastlyServiceId!important": "",
     "timeout": 900000,
-    "nodeVersion": 18
+    "nodeVersion": 18,
+    "static": [
+      "static/prompts/lhs-firefall.prompt"
+    ]
   },
   "repository": {
     "type": "git",
@@ -56,9 +59,11 @@
     "@adobe/helix-status": "10.0.11",
     "@adobe/helix-universal-logger": "3.0.13",
     "@adobe/spacecat-shared-rum-api-client": "1.2.1",
+    "@adobe/spacecat-shared-data-access": "1.2.5",
     "@adobe/spacecat-shared-http-utils": "1.0.0",
     "@adobe/spacecat-shared-utils": "1.6.0",
     "comma-number": "2.1.0",
+    "diff": "5.1.0",
     "human-format": "1.2.0"
   },
   "devDependencies": {

src/firefall/handler.js

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2023 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { internalServerError } from '@adobe/spacecat-shared-http-utils';
+import FirefallClient from '../support/firefall-client.js';
+
+export async function getRecommendations(env, prompt, log = console) {
+  const {
+    FIREFALL_API_ENDPOINT: firefallAPIEndpoint,
+    FIREFALL_IMS_ORG: firefallIMSOrg,
+    FIREFALL_API_KEY: firefallAPIKey,
+    FIREFALL_API_AUTH: firefallAPIAuth,
+  } = env;
+
+  const firefallClient = FirefallClient(
+    firefallAPIEndpoint,
+    firefallAPIKey,
+    firefallAPIAuth,
+    firefallIMSOrg,
+  );
+
+  const data = await firefallClient.fetchFirefallData(prompt);
+
+  if (!data) {
+    log.error('Unable to fetch Firefall data');
+    return internalServerError('Unable to fetch Firefall data');
+  }
+  return data;
+}

src/index.js

@@ -14,11 +14,14 @@ import { hasText, resolveSecretsName } from '@adobe/spacecat-shared-utils';
 import { badRequest, internalServerError, notFound } from '@adobe/spacecat-shared-http-utils';
 import { helixStatus } from '@adobe/helix-status';
 import secrets from '@adobe/helix-shared-secrets';
+import dataAccess from '@adobe/spacecat-shared-data-access';
 import cwv from './cwv/handler.js';
+import lhs from './lhs/handler.js';
 import notFoundHandler from './notfound/handler.js';
 
 export const HANDLERS = {
   cwv,
+  lhs,
   404: notFoundHandler,
 };
 
@@ -89,6 +92,7 @@ async function run(message, context) {
 }
 
 export const main = wrap(run)
+  .with(dataAccess)
   .with(sqsEventAdapter)
   .with(guardEnvironmentVariables)
   .with(secrets, { name: resolveSecretsName })

src/lhs/firefall-utils.js

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2023 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { isObject } from '@adobe/spacecat-shared-utils';
+import { internalServerError, notFound } from '@adobe/spacecat-shared-http-utils';
+import { markdown, section } from '../support/slack.js';
+
+export async function getLHSData(services, site, audit, log = console) {
+  const { dataAccess, gitHubClient, contentClient } = services;
+  const { url, siteId, gitHubURL } = site;
+  const { type, finalUrl } = audit;
+
+  if (!dataAccess || !isObject(dataAccess)) {
+    log.error('Data Access is not available');
+    return internalServerError('Data Access is not available');
+  }
+
+  const audits = await dataAccess.getAuditsForSite(siteId, type);
+  if (!audits || audits.length === 0) {
+    log.error(`No audits found for site ${siteId}`);
+    return notFound(`No audits found for site ${siteId}`);
+  }
+
+  const [latestAudit, previousAudit] = audits;
+
+  const [latestAuditedAt, previousAuditedAt, scoresAfter, scoresBefore] = await Promise.all([
+    latestAudit.getAuditedAt().catch(() => null),
+    previousAudit.getAuditedAt().catch(() => null),
+    latestAudit.getScores().catch(() => null),
+    previousAudit.getScores().catch(() => null),
+  ]);
+
+  const [gitHubDiff, markdownContext] = await Promise.all([
+    gitHubClient.fetchGithubDiff(
+      url,
+      latestAuditedAt,
+      previousAuditedAt,
+      gitHubURL,
+    ).catch(() => null),
+    contentClient.fetchMarkdown(url, finalUrl).catch(() => null),
+  ]);
+
+  return {
+    codeDiff: gitHubDiff || 'no changes',
+    mdContent: markdownContext?.markdownContent || 'no content',
+    scoreBefore: scoresBefore || 'no previous scores',
+    scoreAfter: scoresAfter || 'no scores',
+  };
+}
+
+function getEmojiForChange(before, after) {
+  if (after < before) return ':warning:'; // Emoji for increase
+  if (after > before) return ':large_green_circle:'; // Emoji for decrease
+  return ':heavy_minus_sign:'; // Emoji for no change
+}
+
+export function buildSlackMessage(url, data, lhsData) {
+  const blocks = [
+    section({
+      text: markdown(`*Insights and Recommendations:* for ${url}`),
+    }),
+  ];
+
+  if (lhsData.scoreBefore && lhsData.scoreAfter) {
+    const scoreFields = Object.entries(lhsData.scoreBefore).map(([key, before]) => {
+      const after = lhsData.scoreAfter[key];
+      const emoji = getEmojiForChange(Number(before), Number(after));
+      return markdown(`${key.charAt(0).toUpperCase() + key.slice(1)}: ${before} -> ${after} ${emoji}`);
+    });
+
+    if (scoreFields.length > 0) {
+      blocks.push(section({
+        text: markdown('*Score Changes:*'),
+        fields: scoreFields,
+      }));
+    }
+  }
+
+  if (data.insights) {
+    blocks.push(...data.insights.map((item, index) => section({
+      text: markdown(`${index + 1}. *Insight:* ${item.insight}\n*Recommendation:* ${item.recommendation}`),
+    })));
+  }
+
+  if (data.code) {
+    blocks.push(...data.code.map((codeItem) => section({
+      text: markdown(`\`\`\`${codeItem}\`\`\``),
+    })));
+  }
+
+  return blocks;
+}

src/lhs/handler.js

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2023 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {
+  hasText, isObject, isString, toBoolean,
+} from '@adobe/spacecat-shared-utils';
+import { badRequest, internalServerError, noContent } from '@adobe/spacecat-shared-http-utils';
+import { getRecommendations } from '../firefall/handler.js';
+import { postSlackMessage } from '../support/slack.js';
+import { getPrompt } from '../support/utils.js';
+import { buildSlackMessage, getLHSData } from './firefall-utils.js';
+import ContentClient from '../support/content-client.js';
+import GithubClient from '../support/github-client.js';
+
+const THRESHOLD = 0.9;
+
+function isValidMessage(message) {
+  return hasText(message.url)
+    && hasText(message.auditContext?.slackContext?.channel)
+    && hasText(message.auditResult?.siteId)
+    && isObject(message.auditResult?.scores);
+}
+
+function initServices(config, log) {
+  const {
+    gitHubId,
+    gitHubSecret,
+    dataAccess,
+  } = config;
+  const contentClient = ContentClient(log);
+
+  const gitHubClient = GithubClient(
+    {
+      gitHubId,
+      gitHubSecret,
+    },
+    log,
+  );
+
+  return {
+    contentClient,
+    gitHubClient,
+    dataAccess,
+  };
+}
+
+export default async function lhsHandler(message, context) {
+  const { dataAccess, log } = context;
+  const {
+    type,
+    url,
+    gitHubURL,
+    auditResult,
+    auditContext,
+  } = message;
+  const {
+    env: {
+      SLACK_BOT_TOKEN: slackToken,
+      GITHUB_CLIENT_ID: gitHubId,
+      GITHUB_CLIENT_SECRET: gitHubSecret,
+      FIREFALL_INTEGRATION_ENABLED: firefallIntegrationEnabled = 'false',
+    },
+  } = context;
+
+  if (!isValidMessage(message)) {
+    return badRequest('Required parameters missing in the message body');
+  }
+
+  const { siteId, finalUrl } = auditResult;
+  const { channel, ts } = auditContext.slackContext;
+
+  if (Object.values(auditResult.scores).every((score) => score >= THRESHOLD)) {
+    log.info(`All LHS values from ${url} are above ${THRESHOLD * 100}, not posting to Slack`);
+    return noContent();
+  }
+
+  if (!toBoolean(firefallIntegrationEnabled)) {
+    log.info('Firefall integration disabled, skipping message', message);
+    return noContent();
+  }
+  log.info('Firefall integration enabled, processing message', message);
+
+  const services = initServices({
+    gitHubId,
+    gitHubSecret,
+    dataAccess,
+  }, log);
+
+  const lhsData = await getLHSData(
+    services,
+    { siteId, url, gitHubURL },
+    { type, finalUrl },
+    log,
+  );
+  const prompt = await getPrompt(lhsData);
+
+  if (!isString(prompt)) {
+    log.error('Prompt is not available');
+    return internalServerError('Prompt for Firefall is not available.');
+  }
+
+  const data = await getRecommendations(context.env, prompt, log);
+  const blocks = buildSlackMessage(url, data, lhsData);
+
+  try {
+    await postSlackMessage(slackToken, {
+      blocks,
+      channel,
+      ts,
+    });
+  } catch (e) {
+    log.error(`Failed to send Slack message for ${url}. Reason: ${e.message}`);
+    return internalServerError(`Failed to send Slack message for ${url}`);
+  }
+
+  log.info(`Slack notification sent for ${url} to ${channel} in thread ${ts}`);
+
+  return noContent();
+}