gitpadi 2.0.7 → 2.1.2

package/dist/gitlab-agents/reminder-agent.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+// gitlab-agents/reminder-agent.ts
+//
+// GitLab Duo External Agent — Escalating Contributor Reminders
+//
+// Runs on a schedule (e.g. daily cron). Finds stale open MRs, determines
+// escalation tier, and posts a progressively urgent reminder. Auto-unassigns
+// at 72h if no activity.
+//
+// Escalation:
+//   24h — gentle reminder
+//   48h — warning with context
+//   72h — final notice + auto-unassigns from issue
+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 PROJECT_PATH = process.env.GITLAB_PROJECT_PATH || '';
+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 REMINDER_MARKERS = {
+    h24: '<!-- gitpadi-reminder-24h -->',
+    h48: '<!-- gitpadi-reminder-48h -->',
+    h72: '<!-- gitpadi-reminder-72h -->',
+};
+async function glFetch(method, path, body) {
+    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();
+}
+function hoursAgo(dateStr) {
+    return (Date.now() - new Date(dateStr).getTime()) / (1000 * 60 * 60);
+}
+async function generateReminderMessage(tier, context) {
+    const tierDescriptions = {
+        '24h': 'gentle first reminder — friendly and encouraging',
+        '48h': 'second reminder — more urgent but still supportive, mention help is available',
+        '72h': 'final notice — professional but firm, this will be unassigned',
+    };
+    const prompt = `You are GitPadi, a friendly contributor management bot on GitLab.
+
+Write a ${tierDescriptions[tier]} for a stale Merge Request:
+- MR Title: "${context.mrTitle}"
+- Author: @${context.author}
+- Hours since last activity: ${Math.round(context.hoursStale)}
+- Branch: ${context.branchName}
+${context.linkedIssue ? `- Linked issue: ${context.linkedIssue}` : ''}
+
+Requirements:
+- Keep it under 100 words
+- Be human, warm, and specific to the situation
+- ${tier === '72h' ? 'Mention this is the final notice and the issue will be unassigned' : 'Do NOT mention unassignment'}
+- Start with a relevant emoji
+- Do NOT use generic corporate language
+
+Return just the message text, no JSON, no explanation.`;
+    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() : getFallbackMessage(tier, context.author);
+    }
+    catch {
+        return getFallbackMessage(tier, context.author);
+    }
+}
+function getFallbackMessage(tier, author) {
+    const messages = {
+        '24h': `👋 @${author} — just a friendly nudge! Your MR has been open for about 24 hours. Any updates or blockers we can help with?`,
+        '48h': `⚠️ @${author} — your MR has been idle for 48 hours. If you're blocked or need help, please comment so the team can assist. Otherwise, please push an update!`,
+        '72h': `🚨 @${author} — final notice. This MR has been inactive for 72 hours. We'll need to unassign the linked issue to allow other contributors to pick it up. Please comment if you're still working on this.`,
+    };
+    return messages[tier];
+}
+async function processMR(mr, projectId) {
+    const hoursStale = hoursAgo(mr.updated_at);
+    // Skip drafts — they're not ready
+    if (mr.draft) {
+        console.log(`  ⏭️ !${mr.iid} — Draft, skipping`);
+        return;
+    }
+    // Determine escalation tier
+    let tier = null;
+    if (hoursStale >= 72)
+        tier = '72h';
+    else if (hoursStale >= 48)
+        tier = '48h';
+    else if (hoursStale >= 24)
+        tier = '24h';
+    else
+        return; // Not stale enough
+    // Check for existing reminders
+    const notes = await glFetch('GET', `/projects/${projectId}/merge_requests/${mr.iid}/notes?per_page=100`);
+    const hasMarker = (marker) => notes.some(n => n.body?.includes(marker));
+    // Don't double-post the same tier
+    if (tier === '24h' && hasMarker(REMINDER_MARKERS.h24))
+        return;
+    if (tier === '48h' && hasMarker(REMINDER_MARKERS.h48))
+        return;
+    if (tier === '72h' && hasMarker(REMINDER_MARKERS.h72))
+        return;
+    // Detect linked issue from description
+    const issueMatch = mr.description?.match(/(?:fixes|closes|resolves)\s+#(\d+)/i);
+    const linkedIssue = issueMatch ? `#${issueMatch[1]}` : undefined;
+    console.log(`  📬 MR !${mr.iid} — Tier ${tier} (${Math.round(hoursStale)}h stale)`);
+    const message = await generateReminderMessage(tier, {
+        mrTitle: mr.title,
+        author: mr.author.username,
+        hoursStale,
+        branchName: mr.source_branch,
+        linkedIssue,
+    });
+    // Post reminder
+    const body = `${message}\n\n---\n_⏰ GitPadi Reminder — ${tier} | [Dismiss by pushing a commit](https://github.com/Netwalls/contributor-agent)_\n\n${REMINDER_MARKERS[`h${tier.replace('h', '')}`]}`;
+    await glFetch('POST', `/projects/${projectId}/merge_requests/${mr.iid}/notes`, { body });
+    // Auto-unassign at 72h
+    if (tier === '72h' && linkedIssue) {
+        const issueNum = parseInt(issueMatch[1]);
+        try {
+            await glFetch('PUT', `/projects/${projectId}/issues/${issueNum}`, { assignee_ids: [] });
+            console.log(`    ✓ Unassigned issue ${linkedIssue}`);
+            // Also post on the issue
+            await glFetch('POST', `/projects/${projectId}/issues/${issueNum}/notes`, {
+                body: `⏰ **GitPadi:** @${mr.author.username}'s MR !${mr.iid} has been inactive for 72 hours. The issue has been unassigned and is now open for other contributors.\n\n<!-- gitpadi-unassign -->`,
+            });
+        }
+        catch (e) {
+            console.log(`    ⚠️ Could not unassign issue: ${e.message}`);
+        }
+    }
+}
+async function main() {
+    console.log('\n🤖 GitPadi Reminder Agent\n');
+    if (!PROJECT_PATH) {
+        console.error('❌ GITLAB_PROJECT_PATH required (e.g. "mygroup/myproject")');
+        process.exit(1);
+    }
+    const encodedPath = encodeURIComponent(PROJECT_PATH);
+    const project = await glFetch(`GET`, `/projects/${encodedPath}`);
+    console.log(`  Project: ${project.path_with_namespace}\n`);
+    // Get all open MRs
+    const mrs = await glFetch('GET', `/projects/${project.id}/merge_requests?state=opened&per_page=100`);
+    console.log(`  Found ${mrs.length} open MR(s)\n`);
+    let reminded = 0;
+    for (const mr of mrs) {
+        try {
+            await processMR(mr, project.id);
+            reminded++;
+        }
+        catch (e) {
+            console.log(`  ⚠️ Error processing MR !${mr.iid}: ${e.message}`);
+        }
+    }
+    console.log(`\n✅ Reminder cycle complete — ${reminded} MR(s) processed`);
+}
+main().catch(e => { console.error('Fatal:', e.message); process.exit(1); });

package/dist/grade-assignment.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+// grade-assignment.ts — Automated assignment grading for GitPadi
+//
+// Triggered on pull_request events. Grades student submissions against
+// linked assignment issues, posts a grade card, and auto-merges passing work.
+//
+// Usage via Action:  action: grade-assignment
+import { Octokit } from '@octokit/rest';
+import chalk from 'chalk';
+const TOKEN = process.env.GITHUB_TOKEN || '';
+const OWNER = process.env.GITHUB_OWNER || '';
+const REPO = process.env.GITHUB_REPO || '';
+const PR_NUMBER = parseInt(process.env.PR_NUMBER || '0');
+const PASS_THRESHOLD = parseInt(process.env.PASS_THRESHOLD || '40');
+const octokit = new Octokit({ auth: TOKEN });
+const GRADE_SIGNATURE = '<!-- gitpadi-grade -->';
+function getLetterGrade(score) {
+    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: '🔴' };
+}
+// Extract assignment issue number from PR body or branch name
+function detectAssignment(prBody, branchName) {
+    // Check PR body: "Fixes #N", "Closes #N", "Assignment #N"
+    const bodyMatch = prBody.match(/(?:fixes|closes|resolves|assignment)\s*#(\d+)/i);
+    if (bodyMatch)
+        return parseInt(bodyMatch[1]);
+    // Check branch: "assignment-3", "hw-3", "task-3"
+    const branchMatch = branchName.match(/(?:assignment|hw|task|fix\/issue)-(\d+)/i);
+    if (branchMatch)
+        return parseInt(branchMatch[1]);
+    return null;
+}
+// Extract keywords from assignment issue body for relevance matching
+function extractKeywords(issueBody) {
+    const words = issueBody.toLowerCase()
+        .replace(/[#*`\[\]()]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 3);
+    // Remove common stop words
+    const stopWords = new Set(['this', 'that', 'with', 'from', 'have', 'will', 'should', 'your', 'must',
+        'need', 'make', 'using', 'create', 'please', 'assignment', 'task', 'following', 'requirements']);
+    return [...new Set(words.filter(w => !stopWords.has(w)))];
+}
+async function main() {
+    if (!PR_NUMBER) {
+        console.error('❌ PR_NUMBER is required');
+        process.exit(1);
+    }
+    console.log(`\n📝 GitPadi Assignment Grader — ${OWNER}/${REPO} #${PR_NUMBER}\n`);
+    // Get PR details
+    const { data: pr } = await octokit.pulls.get({ owner: OWNER, repo: REPO, pull_number: PR_NUMBER });
+    const student = pr.user?.login || 'unknown';
+    const branchName = pr.head.ref;
+    const prBody = pr.body || '';
+    console.log(`  Student: @${student}`);
+    console.log(`  Branch:  ${branchName}`);
+    // Detect linked assignment
+    const assignmentNumber = detectAssignment(prBody, branchName);
+    if (!assignmentNumber) {
+        console.log(chalk.yellow('⚠️ No assignment issue detected. Skipping grading.'));
+        await octokit.issues.createComment({
+            owner: OWNER, repo: REPO, issue_number: PR_NUMBER,
+            body: `⚠️ **GitPadi Grader:** Could not detect which assignment this PR is for.\n\nPlease include \`Fixes #N\` in your PR description or name your branch \`assignment-N\`.\n\n${GRADE_SIGNATURE}`
+        });
+        return;
+    }
+    console.log(`  Assignment: #${assignmentNumber}\n`);
+    // Fetch assignment issue
+    let issueTitle = '';
+    let issueBody = '';
+    let issueLabels = [];
+    try {
+        const { data: issue } = await octokit.issues.get({ owner: OWNER, repo: REPO, issue_number: assignmentNumber });
+        issueTitle = issue.title;
+        issueBody = issue.body || '';
+        issueLabels = issue.labels.map((l) => typeof l === 'string' ? l : l.name || '');
+    }
+    catch {
+        console.log(chalk.red(`❌ Assignment issue #${assignmentNumber} not found.`));
+        return;
+    }
+    // Fetch PR files
+    const { data: files } = await octokit.pulls.listFiles({ owner: OWNER, repo: REPO, pull_number: PR_NUMBER });
+    const totalChanges = files.reduce((sum, f) => sum + f.additions + f.deletions, 0);
+    const filenames = files.map(f => f.filename.toLowerCase());
+    // Fetch commits
+    const { data: commits } = await octokit.pulls.listCommits({ owner: OWNER, repo: REPO, pull_number: PR_NUMBER });
+    const checks = [];
+    // ── 1. CI Passing (25 points) ──────────────────────────────────────
+    const sha = pr.head.sha;
+    const { data: ciChecks } = await octokit.checks.listForRef({ owner: OWNER, repo: REPO, ref: sha });
+    const { data: statuses } = await octokit.repos.getCombinedStatusForRef({ owner: OWNER, repo: REPO, ref: sha });
+    const ciPassed = statuses.state === 'success' || (ciChecks.total_count > 0 && ciChecks.check_runs.every(c => c.conclusion === 'success'));
+    const ciPending = statuses.state === 'pending' || ciChecks.check_runs.some(c => c.status !== 'completed');
+    const ciFailed = statuses.state === 'failure' || ciChecks.check_runs.some(c => c.conclusion === 'failure');
+    if (ciPassed) {
+        checks.push({ criteria: 'CI Passing', score: 25, max: 25, detail: 'All checks green' });
+    }
+    else if (ciPending) {
+        checks.push({ criteria: 'CI Passing', score: 10, max: 25, detail: 'Still running — will re-grade when complete' });
+    }
+    else {
+        const failedNames = ciChecks.check_runs.filter(c => c.conclusion === 'failure').map(c => c.name).join(', ');
+        checks.push({ criteria: 'CI Passing', score: 0, max: 25, detail: `Failed: ${failedNames || 'status checks'}` });
+    }
+    // ── 2. Assignment Relevance (25 points) ────────────────────────────
+    const keywords = extractKeywords(issueBody);
+    const allFileContent = filenames.join(' ');
+    const keywordHits = keywords.filter(kw => allFileContent.includes(kw) || prBody.toLowerCase().includes(kw));
+    const relevanceRatio = keywords.length > 0 ? keywordHits.length / Math.min(keywords.length, 15) : 0;
+    const relevanceScore = Math.min(25, Math.round(relevanceRatio * 25));
+    checks.push({
+        criteria: 'Assignment Relevance',
+        score: relevanceScore,
+        max: 25,
+        detail: relevanceScore >= 20 ? 'Matches assignment scope' : relevanceScore >= 10 ? 'Partial match — some expected files/topics missing' : 'Low relevance to assignment requirements'
+    });
+    // ── 3. Test Coverage (20 points) ───────────────────────────────────
+    const srcFiles = files.filter(f => !f.filename.includes('test') && !f.filename.includes('spec') && (f.filename.endsWith('.ts') || f.filename.endsWith('.js') || f.filename.endsWith('.rs') || f.filename.endsWith('.py') || f.filename.endsWith('.jsx') || f.filename.endsWith('.tsx')));
+    const testFiles = files.filter(f => f.filename.includes('test') || f.filename.includes('spec'));
+    let testScore = 0;
+    if (testFiles.length > 0 && srcFiles.length > 0) {
+        const testRatio = testFiles.length / srcFiles.length;
+        testScore = testRatio >= 0.5 ? 20 : testRatio >= 0.25 ? 15 : 10;
+    }
+    else if (testFiles.length > 0) {
+        testScore = 15;
+    }
+    else if (srcFiles.length === 0) {
+        testScore = 10; // No source files changed, might be docs-only
+    }
+    checks.push({
+        criteria: 'Test Coverage',
+        score: testScore,
+        max: 20,
+        detail: testFiles.length > 0 ? `${testFiles.length} test file(s) included` : 'No test files in submission'
+    });
+    // ── 4. Code Quality (15 points) ────────────────────────────────────
+    let qualityScore = 15;
+    const qualityNotes = [];
+    // PR size
+    if (totalChanges > 1000) {
+        qualityScore -= 5;
+        qualityNotes.push('Very large PR');
+    }
+    else if (totalChanges > 500) {
+        qualityScore -= 2;
+        qualityNotes.push('Large PR');
+    }
+    // Commit messages — check for conventional format
+    const badCommits = commits.filter(c => {
+        const msg = c.commit.message.toLowerCase();
+        return msg.startsWith('update') || (msg.startsWith('fix') && msg.length < 10) || msg === 'wip';
+    });
+    if (badCommits.length > commits.length / 2) {
+        qualityScore -= 3;
+        qualityNotes.push('Vague commit messages');
+    }
+    // Sensitive files
+    const sensitivePatterns = ['.env', 'secret', 'password', 'key', 'credential'];
+    const hasSensitive = filenames.some(f => sensitivePatterns.some(p => f.includes(p)));
+    if (hasSensitive) {
+        qualityScore -= 5;
+        qualityNotes.push('Sensitive files detected');
+    }
+    qualityScore = Math.max(0, qualityScore);
+    checks.push({
+        criteria: 'Code Quality',
+        score: qualityScore,
+        max: 15,
+        detail: qualityNotes.length > 0 ? qualityNotes.join(', ') : 'Clean submission'
+    });
+    // ── 5. Submission Format (15 points) ────────────────────────────────
+    let formatScore = 0;
+    // Branch naming
+    const goodBranch = /^(assignment|hw|task|fix\/issue)-\d+/i.test(branchName);
+    if (goodBranch) {
+        formatScore += 5;
+    }
+    else if (branchName !== 'main' && branchName !== 'master') {
+        formatScore += 2;
+    }
+    // Issue linked
+    const hasIssueRef = /(?:fixes|closes|resolves)\s+#\d+/i.test(prBody);
+    if (hasIssueRef)
+        formatScore += 5;
+    // PR body not empty
+    if (prBody.trim().length > 20)
+        formatScore += 5;
+    else if (prBody.trim().length > 0)
+        formatScore += 2;
+    checks.push({
+        criteria: 'Submission Format',
+        score: formatScore,
+        max: 15,
+        detail: formatScore >= 12 ? 'Well-formatted submission' : formatScore >= 7 ? 'Acceptable format' : 'Missing branch naming, issue reference, or PR description'
+    });
+    // ── Calculate Final Grade ──────────────────────────────────────────
+    const totalScore = checks.reduce((sum, c) => sum + c.score, 0);
+    const { letter, emoji } = getLetterGrade(totalScore);
+    const passed = totalScore >= PASS_THRESHOLD;
+    console.log(`\n  Total: ${totalScore}/100 — Grade ${letter} ${emoji}\n`);
+    checks.forEach(c => console.log(`  ${c.score >= c.max * 0.7 ? '✅' : c.score >= c.max * 0.4 ? '⚠️' : '❌'} ${c.criteria}: ${c.score}/${c.max}`));
+    // ── Build Grade Card ───────────────────────────────────────────────
+    let body = `## ${emoji} GitPadi Assignment Grade — PR #${PR_NUMBER}\n\n`;
+    body += `**Student:** @${student}\n`;
+    body += `**Assignment:** ${issueTitle} (#${assignmentNumber})\n\n`;
+    body += `| Criteria | Score | Max |\n|----------|-------|-----|\n`;
+    checks.forEach(c => { body += `| ${c.criteria} | ${c.score} | ${c.max} |\n`; });
+    body += `| **Total** | **${totalScore}** | **100** |\n\n`;
+    body += `**Grade: ${letter}** ${emoji}\n\n`;
+    if (passed) {
+        body += `> ✅ **Passed** (threshold: ${PASS_THRESHOLD}/100). Auto-merging.\n`;
+    }
+    else {
+        body += `> ❌ **Did not pass** (need ${PASS_THRESHOLD}/100). Please review the feedback above and re-submit.\n`;
+    }
+    // Feedback per check
+    body += `\n### Feedback\n\n`;
+    checks.forEach(c => {
+        const icon = c.score >= c.max * 0.7 ? '✅' : c.score >= c.max * 0.4 ? '⚠️' : '❌';
+        body += `- ${icon} **${c.criteria}** (${c.score}/${c.max}): ${c.detail}\n`;
+    });
+    body += `\n---\n_Graded by [GitPadi](https://github.com/Netwalls/contributor-agent) 📝_\n\n${GRADE_SIGNATURE}`;
+    // ── Post or Update Grade Card ──────────────────────────────────────
+    const { data: existingComments } = await octokit.issues.listComments({ owner: OWNER, repo: REPO, issue_number: PR_NUMBER });
+    const existingGrade = existingComments.find(c => c.body?.includes(GRADE_SIGNATURE));
+    if (existingGrade) {
+        await octokit.issues.updateComment({ owner: OWNER, repo: REPO, comment_id: existingGrade.id, body });
+        console.log('✅ Updated existing grade card');
+    }
+    else {
+        await octokit.issues.createComment({ owner: OWNER, repo: REPO, issue_number: PR_NUMBER, body });
+        console.log('✅ Posted grade card');
+    }
+    // ── Auto-merge if passed ───────────────────────────────────────────
+    if (passed && ciPassed) {
+        try {
+            await octokit.pulls.merge({
+                owner: OWNER, repo: REPO, pull_number: PR_NUMBER,
+                merge_method: 'squash',
+                commit_title: `[Grade ${letter}] ${pr.title} (#${PR_NUMBER})`,
+            });
+            console.log(chalk.green(`✅ PR #${PR_NUMBER} merged (Grade ${letter}).`));
+        }
+        catch (e) {
+            console.log(chalk.yellow(`⚠️ Auto-merge failed: ${e.message}`));
+        }
+    }
+    else if (!passed) {
+        console.log(chalk.red(`❌ Grade ${letter} — below threshold. Not merging.`));
+        process.exit(1);
+    }
+}
+main().catch((e) => { console.error('Fatal:', e); process.exit(1); });

package/dist/remind-contributors.js

@@ -0,0 +1,127 @@
+import { initGitHub, getOctokit, getOwner, getRepo } from './core/github.js';
+import chalk from 'chalk';
+// Tiered Escalation Thresholds (in hours)
+const TIER_1_HOURS = 24; // Gentle reminder: "Please create a draft PR"
+const TIER_2_HOURS = 48; // Warning: "Will be unassigned in 24h"
+const TIER_3_HOURS = 72; // Auto-unassign
+// Signature markers for each tier (prevents duplicate comments)
+const SIG_TIER_1 = '<!-- gitpadi-reminder-24h -->';
+const SIG_TIER_2 = '<!-- gitpadi-reminder-48h -->';
+const SIG_TIER_3 = '<!-- gitpadi-unassigned -->';
+async function run() {
+    console.log(chalk.bold('\n🚀 GitPadi Escalating Reminder Engine\n'));
+    try {
+        initGitHub();
+        const octokit = getOctokit();
+        const owner = getOwner();
+        const repo = getRepo();
+        if (!owner || !repo) {
+            console.error(chalk.red('❌ Owner or Repo not found in environment/config.'));
+            process.exit(1);
+        }
+        console.log(chalk.dim(`🔎 Scanning ${owner}/${repo} for inactive contributors...\n`));
+        // 1. Fetch all open issues
+        const { data: issues } = await octokit.issues.listForRepo({
+            owner, repo, state: 'open', per_page: 100
+        });
+        const issuesWithAssignees = issues.filter(i => i.assignees && i.assignees.length > 0 && !i.pull_request);
+        if (issuesWithAssignees.length === 0) {
+            console.log(chalk.green('✅ No open issues with assignees found.'));
+            return;
+        }
+        const now = new Date();
+        let remindCount = 0, warnCount = 0, unassignCount = 0;
+        for (const issue of issuesWithAssignees) {
+            const issueNumber = issue.number;
+            console.log(chalk.cyan(`  ▸ Issue #${issueNumber}: "${issue.title.substring(0, 50)}..."`));
+            // 2. Check for existing reminder comments
+            const { data: comments } = await octokit.issues.listComments({
+                owner, repo, issue_number: issueNumber
+            });
+            const hasTier1 = comments.some(c => c.body?.includes(SIG_TIER_1));
+            const hasTier2 = comments.some(c => c.body?.includes(SIG_TIER_2));
+            const hasTier3 = comments.some(c => c.body?.includes(SIG_TIER_3));
+            if (hasTier3) {
+                console.log(chalk.dim(`    ⏩ Already processed (unassigned). Skipping.`));
+                continue;
+            }
+            // 3. Check for linked draft/open PRs
+            const { data: prs } = await octokit.pulls.list({
+                owner, repo, state: 'open', per_page: 100
+            });
+            const linkedPR = prs.find(pr => pr.body?.includes(`#${issueNumber}`) ||
+                pr.head.ref.includes(`issue-${issueNumber}`));
+            if (linkedPR) {
+                console.log(chalk.green(`    ✅ PR found: #${linkedPR.number} (${linkedPR.draft ? 'draft' : 'open'}). Skipping.`));
+                continue;
+            }
+            // 4. Find when the user was assigned
+            const { data: events } = await octokit.issues.listEvents({
+                owner, repo, issue_number: issueNumber
+            });
+            const assignmentEvent = [...events].reverse().find(e => e.event === 'assigned');
+            if (!assignmentEvent) {
+                console.log(chalk.dim(`    ❓ No assignment event found. Skipping.`));
+                continue;
+            }
+            const assignedAt = new Date(assignmentEvent.created_at);
+            const diffHours = Math.floor((now.getTime() - assignedAt.getTime()) / (1000 * 60 * 60));
+            const assignee = assignmentEvent.assignee?.login;
+            console.log(chalk.dim(`    🕒 Assigned ${diffHours}h ago (@${assignee})`));
+            // 5. Tiered escalation
+            if (diffHours >= TIER_3_HOURS && !hasTier3) {
+                // ── TIER 3: Auto-unassign ──
+                const message = `⏰ Hi @${assignee}, it's been **${diffHours} hours** since you were assigned to this issue, and no draft PR has been created.
+
+To keep the project moving, we're **unassigning you** from this issue. You're welcome to re-claim it anytime!
+
+${SIG_TIER_3}`;
+                await octokit.issues.createComment({
+                    owner, repo, issue_number: issueNumber, body: message
+                });
+                await octokit.issues.removeAssignees({
+                    owner, repo, issue_number: issueNumber,
+                    assignees: [assignee]
+                });
+                console.log(chalk.red(`    🔴 TIER 3: @${assignee} unassigned after ${diffHours}h.`));
+                unassignCount++;
+            }
+            else if (diffHours >= TIER_2_HOURS && !hasTier2) {
+                // ── TIER 2: Warning ──
+                const message = `⚠️ Hi @${assignee}, it's been **${diffHours} hours** since you were assigned to this issue.
+
+We haven't seen a draft PR yet. Please create one to confirm you're actively working on this — otherwise, you may be **unassigned in 24 hours** to keep things moving.
+
+${SIG_TIER_2}`;
+                await octokit.issues.createComment({
+                    owner, repo, issue_number: issueNumber, body: message
+                });
+                console.log(chalk.yellow(`    🟡 TIER 2: Warning sent to @${assignee} (${diffHours}h).`));
+                warnCount++;
+            }
+            else if (diffHours >= TIER_1_HOURS && !hasTier1) {
+                // ── TIER 1: Gentle reminder ──
+                const message = `👋 Hi @${assignee}, you've been assigned to this issue for **${diffHours} hours**.
+
+Just a friendly nudge — please create a **draft PR** when you start working, so we know you're on it! 🚀
+
+${SIG_TIER_1}`;
+                await octokit.issues.createComment({
+                    owner, repo, issue_number: issueNumber, body: message
+                });
+                console.log(chalk.green(`    🟢 TIER 1: Gentle reminder sent to @${assignee} (${diffHours}h).`));
+                remindCount++;
+            }
+            else {
+                console.log(chalk.dim(`    ⏳ Within threshold (${diffHours}h). No action needed.`));
+            }
+        }
+        console.log(chalk.bold(`\n✨ Reminder sweep complete.`));
+        console.log(chalk.dim(`   📊 Reminded: ${remindCount} | Warned: ${warnCount} | Unassigned: ${unassignCount}\n`));
+    }
+    catch (error) {
+        console.error(chalk.red(`\n❌ Error during reminder sweep: ${error.message}`));
+        process.exit(1);
+    }
+}
+run();