gitpadi 2.0.7 → 2.1.1

package/src/gitlab-agents/contributor-scoring-agent.ts

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+// gitlab-agents/contributor-scoring-agent.ts
+//
+// GitLab Duo External Agent — Contributor Scoring
+//
+// Triggered when someone comments "@gitpadi score" on a GitLab issue.
+// Reads the issue thread, identifies applicants, scores them using Claude,
+// and posts a ranked breakdown as a GitLab issue note.
+//
+// Environment variables injected by GitLab Duo Agent Platform:
+//   AI_FLOW_INPUT          — the triggering comment text
+//   AI_FLOW_CONTEXT        — JSON with issue details, comments, project info
+//   AI_FLOW_AI_GATEWAY_TOKEN — GitLab-managed Anthropic auth token
+//   AI_FLOW_AI_GATEWAY_HEADERS — formatted auth headers
+//
+// Additional env vars (set in CI/CD variables):
+//   GITLAB_TOKEN           — for posting back to GitLab
+//   GITLAB_HOST            — default: https://gitlab.com
+
+import Anthropic from '@anthropic-ai/sdk';
+
+const GITLAB_TOKEN = process.env.GITLAB_TOKEN || '';
+const GITLAB_HOST = (process.env.GITLAB_HOST || 'https://gitlab.com').replace(/\/$/, '');
+const GATEWAY_TOKEN = process.env.AI_FLOW_AI_GATEWAY_TOKEN || '';
+
+// Support both GitLab AI gateway (preferred for Anthropic prize) and direct API key
+const anthropic = GATEWAY_TOKEN
+    ? new Anthropic({
+        apiKey: GATEWAY_TOKEN,
+        baseURL: `${GITLAB_HOST}/api/v4/ai/llm/v1`,
+    })
+    : new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+
+interface AgentContext {
+    project_id: number;
+    project_path: string;
+    issue_iid?: number;
+    mr_iid?: number;
+    current_user: string;
+    notes?: Array<{ author: string; body: string; created_at: string }>;
+    title?: string;
+    description?: string;
+    labels?: string[];
+}
+
+async function glFetch<T>(method: string, path: string, body?: unknown): Promise<T> {
+    const res = await fetch(`${GITLAB_HOST}/api/v4${path}`, {
+        method,
+        headers: { 'PRIVATE-TOKEN': GITLAB_TOKEN, 'Content-Type': 'application/json' },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) throw new Error(`GitLab ${method} ${path} → ${res.status}`);
+    return res.json() as Promise<T>;
+}
+
+async function postNote(projectId: number, issueIid: number, body: string): Promise<void> {
+    await glFetch('POST', `/projects/${projectId}/issues/${issueIid}/notes`, { body });
+}
+
+async function main(): Promise<void> {
+    console.log('\n🤖 GitPadi Contributor Scoring Agent\n');
+
+    const input = process.env.AI_FLOW_INPUT || '';
+    const contextRaw = process.env.AI_FLOW_CONTEXT || '{}';
+
+    let context: AgentContext;
+    try {
+        context = JSON.parse(contextRaw) as AgentContext;
+    } catch {
+        console.error('❌ Could not parse AI_FLOW_CONTEXT');
+        process.exit(1);
+    }
+
+    const { project_id, project_path, issue_iid, notes = [], title = '', description = '', labels = [] } = context;
+
+    if (!issue_iid) {
+        console.log('⏭️ No issue context — skipping.');
+        return;
+    }
+
+    console.log(`  Project: ${project_path}`);
+    console.log(`  Issue:   #${issue_iid} — ${title}`);
+    console.log(`  Notes:   ${notes.length} comments\n`);
+
+    // Filter to applicant comments (exclude bots and the trigger command)
+    const applicantNotes = notes.filter(n =>
+        n.author !== 'gitpadi-bot' &&
+        !n.body.includes('@gitpadi') &&
+        n.body.trim().length > 5
+    );
+
+    if (applicantNotes.length === 0) {
+        await postNote(project_id, issue_iid, [
+            '## 🤖 GitPadi — No Applicants Found',
+            '',
+            'No applicant comments detected on this issue yet.',
+            'Applicants should comment expressing interest to be scored.',
+            '',
+            '---',
+            '_GitPadi Contributor Scoring Agent 🤖_',
+        ].join('\n'));
+        return;
+    }
+
+    console.log(`  Found ${applicantNotes.length} potential applicant(s). Calling Claude...\n`);
+
+    // Build prompt for Claude
+    const prompt = `You are GitPadi, an AI agent that scores and ranks contributor applicants for open source issues.
+
+Issue: "${title}"
+${description ? `Description: ${description.substring(0, 500)}` : ''}
+Labels: ${labels.join(', ') || 'none'}
+
+Applicant comments:
+${applicantNotes.map((n, i) => `[${i + 1}] @${n.author}: "${n.body.substring(0, 300)}"`).join('\n')}
+
+Score each applicant on a scale of 0-100 across these criteria:
+- Application Quality (0-30): How well they explain their approach, experience, and plan
+- Enthusiasm & Clarity (0-20): Clear intent and genuine interest
+- Technical Relevance (0-30): Evidence of relevant skills based on their comment
+- Community Fit (0-20): Professionalism and collaborative tone
+
+Return a JSON object with this exact structure:
+{
+  "applicants": [
+    {
+      "username": "@username",
+      "scores": { "applicationQuality": N, "enthusiasm": N, "technicalRelevance": N, "communityFit": N },
+      "total": N,
+      "tier": "S|A|B|C|D",
+      "reasoning": "1-2 sentence explanation",
+      "recommendation": "string"
+    }
+  ],
+  "topPick": "@username",
+  "summary": "1-2 sentence overall summary"
+}
+
+Be fair, constructive, and encouraging. Even lower-scoring applicants should receive positive, actionable feedback.`;
+
+    let scoringResult: any;
+
+    try {
+        const response = await anthropic.messages.create({
+            model: 'claude-haiku-4-5-20251001',
+            max_tokens: 1024,
+            messages: [{ role: 'user', content: prompt }],
+        });
+
+        const text = response.content[0].type === 'text' ? response.content[0].text : '';
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) throw new Error('No JSON in response');
+        scoringResult = JSON.parse(jsonMatch[0]);
+    } catch (e: any) {
+        console.error(`❌ Claude scoring failed: ${e.message}`);
+        // Fallback: post a simple note that scoring failed
+        await postNote(project_id, issue_iid,
+            `## 🤖 GitPadi Scoring — Temporary Error\n\nCould not complete AI scoring at this time. Please try again by commenting \`@gitpadi score\`.\n\n---\n_GitPadi 🤖_`
+        );
+        process.exit(1);
+    }
+
+    // Build the comment
+    const tierEmoji: Record<string, string> = { S: '🏆', A: '🟢', B: '🟡', C: '🟠', D: '🔴' };
+    const sorted = [...(scoringResult.applicants || [])].sort((a: any, b: any) => b.total - a.total);
+
+    let comment = `## 🤖 GitPadi — AI Contributor Scoring\n\n`;
+    comment += `**Issue:** ${title} (#${issue_iid})\n`;
+    comment += `**Scored:** ${sorted.length} applicant(s) | **Top Pick:** ${scoringResult.topPick || sorted[0]?.username}\n\n`;
+
+    comment += `### Rankings\n\n`;
+    comment += `| Rank | Applicant | Tier | Score | Application | Technical | Enthusiasm |\n`;
+    comment += `|------|-----------|------|-------|-------------|-----------|------------|\n`;
+    sorted.forEach((a: any, i: number) => {
+        const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : `${i + 1}.`;
+        comment += `| ${medal} | ${a.username} | ${tierEmoji[a.tier] || ''} ${a.tier} | **${a.total}**/100 | ${a.scores?.applicationQuality}/30 | ${a.scores?.technicalRelevance}/30 | ${a.scores?.enthusiasm}/20 |\n`;
+    });
+
+    comment += `\n### Feedback\n\n`;
+    sorted.forEach((a: any) => {
+        comment += `**${a.username}** (${a.total}/100): ${a.reasoning}\n\n`;
+        if (a.recommendation) comment += `> 💡 ${a.recommendation}\n\n`;
+    });
+
+    if (scoringResult.summary) {
+        comment += `### Summary\n\n${scoringResult.summary}\n\n`;
+    }
+
+    comment += `---\n_🤖 Scored by [GitPadi](https://github.com/Netwalls/contributor-agent) using Claude via GitLab Duo Agent Platform_\n\n<!-- gitpadi-scoring -->`;
+
+    await postNote(project_id, issue_iid, comment);
+    console.log(`✅ Scoring posted for ${sorted.length} applicant(s)`);
+    console.log(`   Top pick: ${scoringResult.topPick}`);
+}
+
+main().catch(e => { console.error('Fatal:', e.message); process.exit(1); });

package/src/gitlab-agents/grade-assignment-agent.ts

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+// gitlab-agents/grade-assignment-agent.ts
+//
+// GitLab Duo External Agent — AI-powered Assignment Grading
+//
+// Triggered when an MR is opened or updated in a GitLab project that uses
+// GitPadi for educational workflows.
+//
+// Grades the submission on 5 criteria using Claude, posts a grade card,
+// and auto-merges if the score meets the pass threshold.
+
+import Anthropic from '@anthropic-ai/sdk';
+
+const GITLAB_TOKEN = process.env.GITLAB_TOKEN || '';
+const GITLAB_HOST = (process.env.GITLAB_HOST || 'https://gitlab.com').replace(/\/$/, '');
+const GATEWAY_TOKEN = process.env.AI_FLOW_AI_GATEWAY_TOKEN || '';
+const PASS_THRESHOLD = parseInt(process.env.PASS_THRESHOLD || '40');
+
+const anthropic = GATEWAY_TOKEN
+    ? new Anthropic({ apiKey: GATEWAY_TOKEN, baseURL: `${GITLAB_HOST}/api/v4/ai/llm/v1` })
+    : new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+
+const GRADE_MARKER = '<!-- gitpadi-grade -->';
+
+async function glFetch<T>(method: string, path: string, body?: unknown): Promise<T> {
+    const res = await fetch(`${GITLAB_HOST}/api/v4${path}`, {
+        method,
+        headers: { 'PRIVATE-TOKEN': GITLAB_TOKEN, 'Content-Type': 'application/json' },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) throw new Error(`GitLab ${method} ${path} → ${res.status}`);
+    return res.json() as Promise<T>;
+}
+
+function getLetterGrade(score: number): { letter: string; emoji: string } {
+    if (score >= 80) return { letter: 'A', emoji: '🟢' };
+    if (score >= 60) return { letter: 'B', emoji: '🔵' };
+    if (score >= 40) return { letter: 'C', emoji: '🟡' };
+    if (score >= 20) return { letter: 'D', emoji: '🟠' };
+    return { letter: 'F', emoji: '🔴' };
+}
+
+async function getAIFeedback(context: {
+    student: string;
+    assignmentTitle: string;
+    assignmentDesc: string;
+    scores: Record<string, { score: number; max: number; detail: string }>;
+    totalScore: number;
+    letter: string;
+    changes: any[];
+}): Promise<string> {
+    const prompt = `You are GitPadi, an encouraging and constructive AI teaching assistant.
+
+A student submitted an assignment:
+- Student: @${context.student}
+- Assignment: "${context.assignmentTitle}"
+- Score: ${context.totalScore}/100 (Grade ${context.letter})
+
+Score breakdown:
+${Object.entries(context.scores).map(([k, v]) => `- ${k}: ${v.score}/${v.max} — ${v.detail}`).join('\n')}
+
+Files changed: ${context.changes.slice(0, 10).map((c: any) => c.new_path).join(', ')}
+
+Write 3-4 sentences of personalized, constructive feedback:
+1. Acknowledge what they did well
+2. Point to the most impactful improvement they can make
+3. End with an encouraging note
+
+Keep it warm, specific, and under 120 words. Address the student directly.`;
+
+    try {
+        const response = await anthropic.messages.create({
+            model: 'claude-haiku-4-5-20251001',
+            max_tokens: 256,
+            messages: [{ role: 'user', content: prompt }],
+        });
+        return response.content[0].type === 'text' ? response.content[0].text.trim() : '';
+    } catch {
+        return '';
+    }
+}
+
+async function main(): Promise<void> {
+    console.log('\n📝 GitPadi Assignment Grader Agent\n');
+
+    const contextRaw = process.env.AI_FLOW_CONTEXT || '{}';
+    let context: any;
+    try { context = JSON.parse(contextRaw); } catch { context = {}; }
+
+    const {
+        project_id,
+        project_path = '',
+        mr_iid,
+        title = '',
+        description = '',
+        source_branch = '',
+        author = '',
+        changes = [],
+        pipeline_status = null,
+    } = context;
+
+    if (!mr_iid) { console.log('⏭️ No MR context — skipping.'); return; }
+
+    const student = author;
+    const branchName = source_branch;
+    const prBody = description || '';
+
+    console.log(`  Project: ${project_path}`);
+    console.log(`  MR:      !${mr_iid} — ${title}`);
+    console.log(`  Student: @${student}\n`);
+
+    // Detect linked assignment issue
+    const bodyMatch = prBody.match(/(?:fixes|closes|resolves|assignment)\s*#(\d+)/i);
+    const branchMatch = branchName.match(/(?:assignment|hw|task|fix\/issue)-(\d+)/i);
+    const assignmentNum = bodyMatch ? parseInt(bodyMatch[1]) : branchMatch ? parseInt(branchMatch[1]) : null;
+
+    if (!assignmentNum) {
+        await glFetch('POST', `/projects/${project_id}/merge_requests/${mr_iid}/notes`, {
+            body: `⚠️ **GitPadi Grader:** Could not detect the assignment.\n\nPlease include \`Fixes #N\` in your MR description or name your branch \`assignment-N\`.\n\n${GRADE_MARKER}`,
+        });
+        return;
+    }
+
+    console.log(`  Assignment: #${assignmentNum}\n`);
+
+    // Fetch assignment issue
+    let issueTitle = '';
+    let issueBody = '';
+    let issueLabels: string[] = [];
+    try {
+        const issue = await glFetch<{ title: string; description: string | null; labels: string[] }>(
+            'GET', `/projects/${project_id}/issues/${assignmentNum}`
+        );
+        issueTitle = issue.title;
+        issueBody = issue.description || '';
+        issueLabels = issue.labels || [];
+    } catch {
+        console.log(`❌ Assignment issue #${assignmentNum} not found.`);
+        return;
+    }
+
+    const filenames = changes.map((c: any) => (c.new_path || '').toLowerCase());
+    const totalChanges = changes.reduce((sum: number, c: any) => {
+        const adds = (c.diff?.match(/^\+/gm) || []).length;
+        const dels = (c.diff?.match(/^-/gm) || []).length;
+        return sum + adds + dels;
+    }, 0);
+
+    // ── 1. CI Passing (25 pts) ─────────────────────────────────────────
+    const ciScore = pipeline_status === 'success' ? 25 : pipeline_status === 'failed' ? 0 : 10;
+    const ciDetail = pipeline_status === 'success' ? 'Pipeline passed' : pipeline_status === 'failed' ? 'Pipeline failed' : 'Pipeline pending';
+
+    // ── 2. Assignment Relevance (25 pts) ──────────────────────────────
+    const keywords = issueBody.toLowerCase()
+        .replace(/[#*`\[\]()]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 3 && !['this', 'that', 'with', 'from', 'have', 'will', 'should', 'must', 'need'].includes(w));
+    const uniqueKeywords = [...new Set(keywords)];
+    const keywordHits = uniqueKeywords.filter(kw => filenames.some((f: string) => f.includes(kw)) || prBody.toLowerCase().includes(kw));
+    const relevanceRatio = uniqueKeywords.length > 0 ? keywordHits.length / Math.min(uniqueKeywords.length, 15) : 0;
+    const relevanceScore = Math.min(25, Math.round(relevanceRatio * 25));
+    const relevanceDetail = relevanceScore >= 20 ? 'Strong match to assignment scope' : relevanceScore >= 10 ? 'Partial match' : 'Low relevance';
+
+    // ── 3. Test Coverage (20 pts) ──────────────────────────────────────
+    const srcFiles = changes.filter((c: any) =>
+        !c.new_path?.includes('test') && !c.new_path?.includes('spec') &&
+        /\.(ts|js|py|rs|go|java)$/.test(c.new_path || '')
+    );
+    const testFiles = changes.filter((c: any) =>
+        c.new_path?.includes('test') || c.new_path?.includes('spec')
+    );
+    let testScore = 0;
+    if (testFiles.length > 0 && srcFiles.length > 0) {
+        const ratio = testFiles.length / srcFiles.length;
+        testScore = ratio >= 0.5 ? 20 : ratio >= 0.25 ? 15 : 10;
+    } else if (testFiles.length > 0) { testScore = 15; }
+    else if (srcFiles.length === 0) { testScore = 10; }
+    const testDetail = testFiles.length > 0 ? `${testFiles.length} test file(s) included` : 'No test files';
+
+    // ── 4. Code Quality (15 pts) ──────────────────────────────────────
+    let qualityScore = 15;
+    const qualityNotes: string[] = [];
+    if (totalChanges > 1000) { qualityScore -= 5; qualityNotes.push('Very large MR'); }
+    else if (totalChanges > 500) { qualityScore -= 2; qualityNotes.push('Large MR'); }
+    const sensitivePatterns = ['.env', 'secret', 'password', 'key', 'credential'];
+    const hasSensitive = filenames.some((f: string) => sensitivePatterns.some((p: string) => f.includes(p)));
+    if (hasSensitive) { qualityScore -= 5; qualityNotes.push('Sensitive files detected'); }
+    qualityScore = Math.max(0, qualityScore);
+    const qualityDetail = qualityNotes.length > 0 ? qualityNotes.join(', ') : 'Clean submission';
+
+    // ── 5. Submission Format (15 pts) ─────────────────────────────────
+    let formatScore = 0;
+    const goodBranch = /^(assignment|hw|task|fix\/issue)-\d+/i.test(branchName);
+    if (goodBranch) formatScore += 5; else if (branchName !== 'main' && branchName !== 'master') formatScore += 2;
+    if (/(?:fixes|closes|resolves)\s+#\d+/i.test(prBody)) formatScore += 5;
+    if (prBody.trim().length > 20) formatScore += 5; else if (prBody.trim().length > 0) formatScore += 2;
+    const formatDetail = formatScore >= 12 ? 'Well-formatted' : formatScore >= 7 ? 'Acceptable' : 'Missing branch naming/issue ref/description';
+
+    const scores = {
+        'CI Passing': { score: ciScore, max: 25, detail: ciDetail },
+        'Assignment Relevance': { score: relevanceScore, max: 25, detail: relevanceDetail },
+        'Test Coverage': { score: testScore, max: 20, detail: testDetail },
+        'Code Quality': { score: qualityScore, max: 15, detail: qualityDetail },
+        'Submission Format': { score: formatScore, max: 15, detail: formatDetail },
+    };
+
+    const totalScore = Object.values(scores).reduce((sum, s) => sum + s.score, 0);
+    const { letter, emoji } = getLetterGrade(totalScore);
+    const passed = totalScore >= PASS_THRESHOLD;
+
+    console.log(`  Total: ${totalScore}/100 — Grade ${letter} ${emoji}`);
+    console.log(`  Passed: ${passed ? 'Yes' : 'No'}\n`);
+
+    // Get AI personalized feedback
+    const aiFeedback = await getAIFeedback({ student, assignmentTitle: issueTitle, assignmentDesc: issueBody.substring(0, 500), scores, totalScore, letter, changes });
+
+    // Build grade card
+    let body = `## ${emoji} GitPadi Assignment Grade — MR !${mr_iid}\n\n`;
+    body += `**Student:** @${student}\n`;
+    body += `**Assignment:** ${issueTitle} (#${assignmentNum})\n\n`;
+    body += `| Criteria | Score | Max |\n|----------|-------|-----|\n`;
+    Object.entries(scores).forEach(([k, v]) => { body += `| ${k} | ${v.score} | ${v.max} |\n`; });
+    body += `| **Total** | **${totalScore}** | **100** |\n\n`;
+    body += `**Grade: ${letter}** ${emoji}\n\n`;
+
+    if (passed) {
+        body += `> ✅ **Passed** (threshold: ${PASS_THRESHOLD}/100)\n\n`;
+    } else {
+        body += `> ❌ **Did not pass** (need ${PASS_THRESHOLD}/100). Review feedback and re-submit.\n\n`;
+    }
+
+    body += `### Criteria Breakdown\n\n`;
+    Object.entries(scores).forEach(([k, v]) => {
+        const icon = v.score >= v.max * 0.7 ? '✅' : v.score >= v.max * 0.4 ? '⚠️' : '❌';
+        body += `- ${icon} **${k}** (${v.score}/${v.max}): ${v.detail}\n`;
+    });
+
+    if (aiFeedback) {
+        body += `\n### Personalized Feedback\n\n${aiFeedback}\n`;
+    }
+
+    body += `\n---\n_📝 Graded by [GitPadi](https://github.com/Netwalls/contributor-agent) using Claude_\n\n${GRADE_MARKER}`;
+
+    // Post or update grade comment
+    const notes = await glFetch<Array<{ id: number; body: string }>>(
+        'GET', `/projects/${project_id}/merge_requests/${mr_iid}/notes?per_page=100`
+    );
+    const existing = notes.find(n => n.body?.includes(GRADE_MARKER));
+
+    if (existing) {
+        await glFetch('PUT', `/projects/${project_id}/merge_requests/${mr_iid}/notes/${existing.id}`, { body });
+        console.log('✅ Updated existing grade card');
+    } else {
+        await glFetch('POST', `/projects/${project_id}/merge_requests/${mr_iid}/notes`, { body });
+        console.log('✅ Posted grade card');
+    }
+
+    // Auto-merge if passed and CI green
+    if (passed && ciScore === 25) {
+        try {
+            await glFetch('PUT', `/projects/${project_id}/merge_requests/${mr_iid}/merge`, {
+                squash: true,
+                squash_commit_message: `[Grade ${letter}] ${title} (!${mr_iid})`,
+            });
+            console.log(`✅ MR !${mr_iid} auto-merged (Grade ${letter})`);
+        } catch (e: any) {
+            console.log(`⚠️ Auto-merge failed: ${e.message}`);
+        }
+    } else if (!passed) {
+        console.log(`❌ Grade ${letter} — below threshold. Not merging.`);
+        process.exit(1);
+    }
+}
+
+main().catch(e => { console.error('Fatal:', e.message); process.exit(1); });