Add AI recommendation feature using GitHub username input

client/src/infra/rest/apis/github/index.ts

@@ -0,0 +1,68 @@
+// api/github/index.ts
+import { patch, post } from '../..';
+import {
+  AnalyzeUserPayload,
+  AnalyzeUserResponse,
+  GetIssueMetricsPayload,
+  IssueMetricsResponse,
+  GetPRMetricsPayload,
+  PRMetricsResponse,
+  GetLanguagesPayload,
+  LanguagesResponse,
+  GetFilesPayload,
+  GetUserReposPayload,
+  UserReposResponse,
+} from './typing';
+import { ApiResponse, BaseApiResponse } from '../../typings';
+
+export const analyzeUser = async (payload: AnalyzeUserPayload) => {
+  return post<
+    AnalyzeUserPayload,
+    ApiResponse<AnalyzeUserResponse>
+  >('/api/github/analyze-user', true, payload);
+};
+
+export const getIssueMetrics = async (payload: GetIssueMetricsPayload) => {
+  return post<
+    GetIssueMetricsPayload,
+    ApiResponse<IssueMetricsResponse>
+  >('/api/github/issue-metrics', true, payload);
+};
+
+export const getPRMetrics = async (payload: GetPRMetricsPayload) => {
+  return post<
+    GetPRMetricsPayload,
+    ApiResponse<PRMetricsResponse>
+  >('/api/github/pr-metrics', true, payload);
+};
+
+export const getLanguages = async (payload: GetLanguagesPayload) => {
+  return post<
+    GetLanguagesPayload,
+    ApiResponse<LanguagesResponse>
+  >('/api/github/languages', true, payload);
+};
+
+export const getFiles = async (payload: GetFilesPayload) => {
+  return post<
+    GetFilesPayload,
+    ApiResponse<any[]>
+  >('/api/github/files', true, payload);
+};
+
+export const getUserRepos = async (payload: GetUserReposPayload) => {
+  return post<
+    GetUserReposPayload,
+    ApiResponse<UserReposResponse>
+  >('/api/github/user-repos', true, payload);
+};
+
+export const detectCapabilities = async (payload: {
+  files: any[];
+  deps?: string[];
+}) => {
+  return post<
+    { files: any[]; deps?: string[] },
+    ApiResponse<string[]>
+  >('/api/github/detect-capabilities', true, payload);
+};

client/src/infra/rest/apis/github/typing.ts

@@ -0,0 +1,60 @@
+export interface AnalyzeUserPayload{
+    username: string;
+}
+export interface AnalyzeUserResponse{
+    repos: Array<{
+        repo:string;
+        languages: string[];
+        capabilities: string[];
+        avgPRMergeTime: number | null;
+        avgIssueResolutionTime: number | null;
+    } >;
+}
+export interface GetIssueMetricsPayload{
+    owner: string;
+    repo: string;
+}
+
+export interface IssueMetricsResponse{
+    issue: Array<{
+        issue: number;
+        resolutionHours: number;
+    }>;
+}
+
+export interface GetPRMetricsPayload{
+    owner : string;
+    repo: string ;
+}
+
+export interface PRMetricsResponse{
+    prs:Array<{
+        prnumber:number;
+        mergetimehours:number;
+    }>;
+}
+
+export interface GetLanguagesPayload{
+    owner:string;
+    repo:string;
+}
+
+export interface LanguagesResponse {
+  [language: string]: number;
+}
+
+export interface GetFilesPayload {
+  owner: string;
+  repo: string;
+}
+
+export interface GetUserReposPayload {
+  username: string;
+}
+
+export interface UserReposResponse {
+  repos: Array<{
+    owner: { login: string };
+    name: string;
+  }>;
+}

client/src/shared/components/organisms/navbar/components/recommendation.tsx

@@ -0,0 +1,34 @@
+import { useEffect, useState } from "react";
+
+export default function Recommendation() {
+  const [result, setResult] = useState("");
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    const fetchRecommendation = async () => {
+      try {
+        const res = await fetch("http://localhost:5000/api/recommend", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ platform: "facebook" })
+        });
+
+        const data = await res.json();
+        setResult(data.recommendation);
+      } catch (err) {
+        setResult("Error getting recommendation");
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchRecommendation();
+  }, []);
+
+  return (
+    <div>
+      {loading && <p>Generating AI recommendation...</p>}
+      {!loading && <pre>{result}</pre>}
+    </div>
+  );
+}

server/gemini.js

@@ -0,0 +1,38 @@
+import { GEMINI_API_KEY } from "./src/config/env.js"; 
+
+export async function getAIRecommendation(analysisData) {
+  const prompt = `
+You are an AI recommendation system.
+Based on the following analysis of repos of github, generate clear recommendations of what tech stack should be learned to improve skills according to tech stack and also tell some future project ideas that can be built using the current skills and the recommended skills.
+
+Analysis:
+${JSON.stringify(analysisData, null, 2)}
+`;
+
+  const response = await fetch(
+  `https://generativelanguage.googleapis.com/v1/models/gemini-2.0-flash:generateContent?key=${GEMINI_API_KEY}`,
+
+
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        contents: [
+          {
+            parts: [{ text: prompt }]
+          }
+        ]
+      })
+    }
+  );
+
+  const data = await response.json();
+
+  console.log("Raw Gemini response:", JSON.stringify(data, null, 2));
+  if (!data.candidates || data.candidates.length === 0) {
+  throw new Error("Gemini returned no response");
+}
+
+return data.candidates[0].content.parts[0].text;
+
+}

server/index2.js

@@ -0,0 +1,17 @@
+import "dotenv/config";
+
+import { analyzeUser } from "./src/services/index.js";
+import { getAIRecommendation } from "./gemini.js";
+
+async function run() {
+  try {
+    const analysis = await analyzeUser("facebook");
+    await getAIRecommendation({ test: "hello" });
+    const aiResult = await getAIRecommendation(analysis);
+    console.log(aiResult);
+  } catch (err) {
+    console.error(err);
+  }
+}
+
+run();

server/package.json

@@ -36,7 +36,7 @@
     "cookie-parser": "^1.4.7",
     "cors": "^2.8.5",
     "crypto": "^1.0.1",
-    "dotenv": "^16.4.7",
+    "dotenv": "^16.6.1",
     "express": "^4.21.2",
     "helmet": "^8.1.0",
     "hpp": "^0.2.3",

server/src/config/env.js

@@ -40,3 +40,6 @@ export const CLOUDINARY_API_SECRET =
 export const ADMIN_EMAIL = process.env.ADMIN_EMAIL || 'dev.admin@example.com';
 export const RESEND_API_KEY =
   process.env.RESEND_API_KEY || 'dev_resend_key_abc123';
+
+// AI Configuration
+export const GEMINI_API_KEY = process.env.GEMINI_API_KEY;

server/src/services/analyze-user.js

@@ -0,0 +1,94 @@
+/**
+ * Analyze User - Comprehensive GitHub user analysis
+ * Gathers repositories, analyzes code patterns, and computes metrics
+ */
+
+import { fetchGitHubRepos } from './fetch-github-repos.js';
+import { fetchRepositoryFiles } from './fetch-repository-files.js';
+import { fetchRepositoryLanguages } from './fetch-repository-languages.js';
+import { fetchPullRequestMetrics } from './fetch-pull-request-metrics.js';
+import { fetchIssueMetrics } from './fetch-issue-metrics.js';
+import { detectCapabilities } from './detect-capabilities.js';
+
+/**
+ * Analyzes a GitHub user's repositories and generates capability metrics
+ * Fetches repo information, analyzes files, and computes PR/issue metrics
+ * @param {string} username - GitHub username to analyze
+ * @returns {Promise<Array<Object>>} Analysis results per repository
+ * @throws {Error} If user not found or API fails
+ */
+export async function analyzeUser(username) {
+  if (!username || typeof username !== 'string') {
+    throw new Error('Invalid username: must be a non-empty string');
+  }
+
+  try {
+    const repos = await fetchGitHubRepos(username);
+    const analysisResults = [];
+
+    for (const repo of repos) {
+      console.log('Analyzing repo:', repo.owner.login, repo.name);
+
+      try {
+        // Fetch repository files
+        console.log('Fetching files...');
+        const files = await fetchRepositoryFiles(
+          repo.owner.login,
+          repo.name
+        );
+
+        // Detect capabilities based on files
+        const capabilities = detectCapabilities(files, []);
+
+        // Fetch PR metrics
+        console.log('Fetching PR metrics...');
+        const prMetrics = await fetchPullRequestMetrics(
+          repo.owner.login,
+          repo.name
+        );
+
+        // Fetch issue metrics
+        console.log('Fetching issue metrics...');
+        const issueMetrics = await fetchIssueMetrics(
+          repo.owner.login,
+          repo.name
+        );
+
+        // Fetch languages
+        console.log('Fetching languages...');
+        const languages = await fetchRepositoryLanguages(repo);
+
+        // Calculate averages
+        const avgPRMergeTime =
+          prMetrics.length
+            ? prMetrics.reduce((a, b) => a + b.mergeTimeHours, 0) /
+              prMetrics.length
+            : null;
+
+        const avgIssueResolutionTime =
+          issueMetrics.length
+            ? issueMetrics.reduce((a, b) => a + b.resolutionTimeHours, 0) /
+              issueMetrics.length
+            : null;
+
+        analysisResults.push({
+          repo: repo.name,
+          languages: Object.keys(languages),
+          capabilities,
+          avgPRMergeTime,
+          avgIssueResolutionTime
+        });
+      } catch (repoError) {
+        console.error(`Error analyzing repo ${repo.name}:`, repoError.message);
+        // Continue with next repo even if one fails
+        continue;
+      }
+    }
+
+    return analysisResults;
+  } catch (error) {
+    throw new Error(
+      `Failed to analyze user ${username}: ${error.message}`
+    );
+  }
+}