profclaw 0.0.1-beta.1

package/dist/integrations/github-ticket-sync.js

@@ -0,0 +1,352 @@
+/**
+ * GitHub Ticket Sync Handler
+ *
+ * Handles GitHub webhooks to update synced tickets.
+ * This is separate from the task creation handler (github.ts).
+ */
+import { eq, and } from 'drizzle-orm';
+import { randomUUID } from 'crypto';
+import { getDb } from '../storage/index.js';
+import { tickets, ticketExternalLinks, ticketComments, ticketHistory, githubCommentSyncs, } from '../storage/schema.js';
+import { findOrCreateLabel, setTicketLabels } from '../labels/index.js';
+function isGitHubSyncWebhookPayload(payload) {
+    return typeof payload === 'object' && payload !== null;
+}
+function mapGitHubStateToStatus(state, stateReason) {
+    if (state === 'open')
+        return 'todo';
+    if (state === 'closed') {
+        if (stateReason === 'completed')
+            return 'done';
+        if (stateReason === 'not_planned')
+            return 'cancelled';
+        return 'done';
+    }
+    return 'backlog';
+}
+function mapPriorityFromLabels(labels) {
+    const labelNames = labels.map((l) => l.name.toLowerCase());
+    if (labelNames.includes('critical') || labelNames.includes('p0') || labelNames.includes('priority: critical')) {
+        return 'urgent';
+    }
+    if (labelNames.includes('high') || labelNames.includes('p1') || labelNames.includes('priority: high')) {
+        return 'high';
+    }
+    if (labelNames.includes('low') || labelNames.includes('p3') || labelNames.includes('priority: low')) {
+        return 'low';
+    }
+    return 'medium';
+}
+function mapTypeFromLabels(labels) {
+    const labelNames = labels.map((l) => l.name.toLowerCase());
+    if (labelNames.includes('bug') || labelNames.includes('type: bug'))
+        return 'bug';
+    if (labelNames.includes('feature') || labelNames.includes('type: feature') || labelNames.includes('enhancement')) {
+        return 'feature';
+    }
+    if (labelNames.includes('epic') || labelNames.includes('type: epic'))
+        return 'epic';
+    if (labelNames.includes('story') || labelNames.includes('user story'))
+        return 'story';
+    return 'task';
+}
+// FIND SYNCED TICKET
+async function findSyncedTicket(repository, issue) {
+    const db = getDb();
+    if (!db)
+        return null;
+    // Look for external link by various ID patterns
+    const possibleExternalIds = [
+        `${repository.owner.login}/${repository.name}#${issue.number}`,
+        `${repository.full_name}#${issue.number}`,
+        issue.id.toString(),
+        `#${issue.number}`,
+    ];
+    for (const externalId of possibleExternalIds) {
+        const link = await db
+            .select({
+            ticketId: ticketExternalLinks.ticketId,
+            linkId: ticketExternalLinks.id,
+        })
+            .from(ticketExternalLinks)
+            .where(and(eq(ticketExternalLinks.platform, 'github'), eq(ticketExternalLinks.externalId, externalId), eq(ticketExternalLinks.syncEnabled, true)))
+            .limit(1);
+        if (link[0]) {
+            // Get project ID from ticket
+            const ticket = await db
+                .select({ projectId: tickets.projectId })
+                .from(tickets)
+                .where(eq(tickets.id, link[0].ticketId))
+                .limit(1);
+            return {
+                ticketId: link[0].ticketId,
+                linkId: link[0].linkId,
+                projectId: ticket[0]?.projectId || '',
+            };
+        }
+    }
+    return null;
+}
+// ISSUE EVENT HANDLERS
+/**
+ * Handle issue opened/edited/closed/reopened events
+ */
+export async function handleIssueEvent(action, issue, repository) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    // Find synced ticket
+    const synced = await findSyncedTicket(repository, issue);
+    if (!synced) {
+        // No synced ticket found - could create one here if auto-import enabled
+        return { action: 'ignored', reason: 'ticket_not_synced' };
+    }
+    const { ticketId, projectId } = synced;
+    const now = new Date();
+    // Map GitHub state to profClaw status
+    const newStatus = mapGitHubStateToStatus(issue.state, issue.state_reason);
+    const newPriority = mapPriorityFromLabels(issue.labels);
+    const newType = mapTypeFromLabels(issue.labels);
+    const newAssignee = issue.assignees?.[0]?.login || null;
+    // Get current ticket for comparison
+    const currentTicket = await db
+        .select()
+        .from(tickets)
+        .where(eq(tickets.id, ticketId))
+        .limit(1);
+    if (!currentTicket[0]) {
+        return { action: 'ignored', reason: 'ticket_not_found' };
+    }
+    const current = currentTicket[0];
+    const changes = [];
+    // Track changes for history
+    if (current.title !== issue.title) {
+        changes.push({ field: 'title', oldValue: current.title, newValue: issue.title });
+    }
+    if (current.description !== (issue.body || '')) {
+        changes.push({ field: 'description', oldValue: current.description || '', newValue: issue.body || '' });
+    }
+    if (current.status !== newStatus) {
+        changes.push({ field: 'status', oldValue: current.status, newValue: newStatus });
+    }
+    if (current.priority !== newPriority) {
+        changes.push({ field: 'priority', oldValue: current.priority, newValue: newPriority });
+    }
+    if (current.type !== newType) {
+        changes.push({ field: 'type', oldValue: current.type, newValue: newType });
+    }
+    if (current.assignee !== newAssignee) {
+        changes.push({ field: 'assignee', oldValue: current.assignee, newValue: newAssignee });
+    }
+    // If no changes, skip
+    if (changes.length === 0) {
+        return { action: 'ignored', reason: 'no_changes' };
+    }
+    // Update ticket
+    await db.update(tickets).set({
+        title: issue.title,
+        description: issue.body || '',
+        status: newStatus,
+        priority: newPriority,
+        type: newType,
+        assignee: newAssignee,
+        updatedAt: now,
+    }).where(eq(tickets.id, ticketId));
+    // Record history for each change
+    for (const change of changes) {
+        await db.insert(ticketHistory).values({
+            id: randomUUID(),
+            ticketId,
+            field: change.field,
+            oldValue: change.oldValue,
+            newValue: change.newValue,
+            changedByType: 'human',
+            changedByName: issue.user.login,
+            changedByPlatform: 'github',
+            timestamp: now,
+        });
+    }
+    // Sync labels if project ID is available
+    if (projectId && issue.labels.length > 0) {
+        try {
+            const labelIds = [];
+            for (const ghLabel of issue.labels) {
+                const label = await findOrCreateLabel(projectId, ghLabel.name, {
+                    color: ghLabel.color ? `#${ghLabel.color}` : undefined,
+                    externalSource: 'github',
+                    externalId: ghLabel.name,
+                });
+                labelIds.push(label.id);
+            }
+            await setTicketLabels(ticketId, labelIds);
+        }
+        catch (e) {
+            console.warn('[GitHub Sync] Failed to sync labels:', e);
+        }
+    }
+    // Update last synced timestamp
+    await db.update(ticketExternalLinks).set({
+        lastSyncedAt: now,
+        syncError: null,
+    }).where(eq(ticketExternalLinks.ticketId, ticketId));
+    console.log(`[GitHub Sync] Updated ticket ${ticketId} from issue #${issue.number}: ${changes.map(c => c.field).join(', ')}`);
+    return { action: 'updated', ticketId };
+}
+/**
+ * Handle issue labeled/unlabeled events
+ */
+export async function handleIssueLabelEvent(action, issue, repository, _label) {
+    const synced = await findSyncedTicket(repository, issue);
+    if (!synced) {
+        return { action: 'ignored', reason: 'ticket_not_synced' };
+    }
+    // Re-sync all labels from current issue state
+    return handleIssueEvent('labeled', issue, repository);
+}
+// COMMENT EVENT HANDLERS
+/**
+ * Handle issue comment created event
+ */
+export async function handleCommentCreated(issue, comment, repository) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const synced = await findSyncedTicket(repository, issue);
+    if (!synced) {
+        return { action: 'ignored', reason: 'ticket_not_synced' };
+    }
+    const { ticketId, linkId } = synced;
+    // Check if comment already synced
+    const existingSync = await db
+        .select()
+        .from(githubCommentSyncs)
+        .where(eq(githubCommentSyncs.githubCommentId, comment.id))
+        .limit(1);
+    if (existingSync[0]) {
+        return { action: 'ignored', reason: 'comment_already_synced' };
+    }
+    // Create comment
+    const commentId = randomUUID();
+    const now = new Date();
+    await db.insert(ticketComments).values({
+        id: commentId,
+        ticketId,
+        content: comment.body,
+        authorType: 'human',
+        authorName: comment.user.login,
+        authorPlatform: 'github',
+        authorAvatarUrl: comment.user.avatar_url,
+        source: 'github',
+        externalId: comment.id.toString(),
+        isAiResponse: false,
+        createdAt: now,
+        updatedAt: now,
+    });
+    // Track sync
+    await db.insert(githubCommentSyncs).values({
+        id: randomUUID(),
+        ticketExternalLinkId: linkId,
+        commentId,
+        githubCommentId: comment.id,
+        createdAt: now,
+    });
+    console.log(`[GitHub Sync] Created comment ${commentId} from GitHub comment #${comment.id}`);
+    return { action: 'comment_created', ticketId, commentId };
+}
+/**
+ * Handle issue comment edited event
+ */
+export async function handleCommentEdited(issue, comment, repository) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const synced = await findSyncedTicket(repository, issue);
+    if (!synced) {
+        return { action: 'ignored', reason: 'ticket_not_synced' };
+    }
+    // Find synced comment
+    const syncRecord = await db
+        .select()
+        .from(githubCommentSyncs)
+        .where(eq(githubCommentSyncs.githubCommentId, comment.id))
+        .limit(1);
+    if (!syncRecord[0]) {
+        // Comment wasn't synced before - create it now
+        return handleCommentCreated(issue, comment, repository);
+    }
+    // Update comment
+    await db.update(ticketComments).set({
+        content: comment.body,
+        updatedAt: new Date(),
+    }).where(eq(ticketComments.id, syncRecord[0].commentId));
+    console.log(`[GitHub Sync] Updated comment ${syncRecord[0].commentId} from GitHub comment #${comment.id}`);
+    return { action: 'comment_updated', ticketId: synced.ticketId, commentId: syncRecord[0].commentId };
+}
+/**
+ * Handle issue comment deleted event
+ */
+export async function handleCommentDeleted(issue, comment, repository) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const synced = await findSyncedTicket(repository, issue);
+    if (!synced) {
+        return { action: 'ignored', reason: 'ticket_not_synced' };
+    }
+    // Find synced comment
+    const syncRecord = await db
+        .select()
+        .from(githubCommentSyncs)
+        .where(eq(githubCommentSyncs.githubCommentId, comment.id))
+        .limit(1);
+    if (!syncRecord[0]) {
+        return { action: 'ignored', reason: 'comment_not_synced' };
+    }
+    // Delete sync record and comment
+    await db.delete(githubCommentSyncs).where(eq(githubCommentSyncs.id, syncRecord[0].id));
+    await db.delete(ticketComments).where(eq(ticketComments.id, syncRecord[0].commentId));
+    console.log(`[GitHub Sync] Deleted comment ${syncRecord[0].commentId}`);
+    return { action: 'comment_deleted', ticketId: synced.ticketId };
+}
+// MAIN WEBHOOK HANDLER
+/**
+ * Process GitHub webhook for ticket sync
+ * Call this from the sync routes after signature verification
+ */
+export async function processGitHubWebhookForTicketSync(event, payload) {
+    try {
+        if (!isGitHubSyncWebhookPayload(payload)) {
+            return { action: 'ignored', reason: 'invalid_payload' };
+        }
+        if (event === 'issues') {
+            const { action, issue, repository, label } = payload;
+            if ((action === 'labeled' || action === 'unlabeled') && issue && repository && label) {
+                return handleIssueLabelEvent(action, issue, repository, label);
+            }
+            if (action
+                && issue
+                && repository
+                && ['opened', 'edited', 'closed', 'reopened', 'assigned', 'unassigned'].includes(action)) {
+                return handleIssueEvent(action, issue, repository);
+            }
+        }
+        if (event === 'issue_comment') {
+            const { action, issue, comment, repository } = payload;
+            if (action === 'created' && issue && comment && repository) {
+                return handleCommentCreated(issue, comment, repository);
+            }
+            if (action === 'edited' && issue && comment && repository) {
+                return handleCommentEdited(issue, comment, repository);
+            }
+            if (action === 'deleted' && issue && comment && repository) {
+                return handleCommentDeleted(issue, comment, repository);
+            }
+        }
+        return { action: 'ignored', reason: `unhandled_event: ${event}` };
+    }
+    catch (error) {
+        console.error('[GitHub Sync] Error processing webhook:', error);
+        throw error;
+    }
+}
+//# sourceMappingURL=github-ticket-sync.js.map

package/dist/integrations/github.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from 'hono';
+import type { CreateTaskInput } from '../types/task.js';
+/**
+ * Verify GitHub webhook signature
+ */
+export declare function verifyGitHubSignature(payload: string, signature: string | undefined): boolean;
+/**
+ * Handle GitHub webhook
+ */
+export declare function handleGitHubWebhook(c: Context): Promise<CreateTaskInput | null>;
+//# sourceMappingURL=github.d.ts.map

package/dist/integrations/github.js

@@ -0,0 +1,241 @@
+import { createHmac, timingSafeEqual } from 'crypto';
+/**
+ * GitHub Webhook Integration
+ *
+ * Receives webhooks from GitHub and creates tasks from issues/PRs.
+ *
+ * Supported events:
+ * - issues.opened - New issue created
+ * - issues.labeled - Issue labeled (e.g., "ai-task")
+ * - issue_comment.created - Comment on issue (can trigger task)
+ * - pull_request.opened - New PR opened
+ * - pull_request.review_requested - Review requested
+ */
+// Label that triggers AI task creation
+const AI_TASK_LABEL = process.env.GITHUB_AI_TASK_LABEL || 'ai-task';
+const AI_REVIEW_LABEL = process.env.GITHUB_AI_REVIEW_LABEL || 'ai-review';
+const WEBHOOK_SECRET = process.env.GITHUB_WEBHOOK_SECRET || '';
+/**
+ * Verify GitHub webhook signature
+ */
+export function verifyGitHubSignature(payload, signature) {
+    if (!WEBHOOK_SECRET) {
+        console.warn('GITHUB_WEBHOOK_SECRET not set - skipping signature verification');
+        return true;
+    }
+    if (!signature) {
+        return false;
+    }
+    const expectedSignature = `sha256=${createHmac('sha256', WEBHOOK_SECRET)
+        .update(payload)
+        .digest('hex')}`;
+    try {
+        return timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Handle GitHub webhook
+ */
+export async function handleGitHubWebhook(c) {
+    const event = c.req.header('X-GitHub-Event');
+    const signature = c.req.header('X-Hub-Signature-256');
+    const deliveryId = c.req.header('X-GitHub-Delivery');
+    const rawBody = await c.req.text();
+    // Verify signature
+    if (!verifyGitHubSignature(rawBody, signature)) {
+        throw new Error('Invalid webhook signature');
+    }
+    const payload = JSON.parse(rawBody);
+    console.log(`[GitHub Webhook] Event: ${event}, Delivery: ${deliveryId}`);
+    switch (event) {
+        case 'ping':
+            console.log('[GitHub Webhook] Ping received');
+            return null;
+        case 'issues':
+            return handleIssueEvent(payload);
+        case 'issue_comment':
+            return handleIssueCommentEvent(payload);
+        case 'pull_request':
+            return handlePullRequestEvent(payload);
+        default:
+            console.log(`[GitHub Webhook] Unhandled event: ${event}`);
+            return null;
+    }
+}
+/**
+ * Handle issue events
+ */
+function handleIssueEvent(payload) {
+    const { action, issue, repository } = payload;
+    // Only handle opened issues or when ai-task label is added
+    if (action === 'opened') {
+        // Check if issue has the AI task label
+        const hasAiLabel = issue.labels?.some((l) => l.name === AI_TASK_LABEL || l.name === AI_REVIEW_LABEL);
+        if (!hasAiLabel) {
+            console.log('[GitHub] Issue opened without AI label, skipping');
+            return null;
+        }
+    }
+    else if (action === 'labeled') {
+        // Check if the added label is an AI label
+        const labelAdded = payload.label?.name;
+        if (labelAdded !== AI_TASK_LABEL && labelAdded !== AI_REVIEW_LABEL) {
+            return null;
+        }
+    }
+    else {
+        return null;
+    }
+    // Create task from issue
+    return {
+        title: issue.title,
+        description: issue.body || undefined,
+        prompt: buildPromptFromIssue(issue),
+        priority: getPriorityFromLabels(issue.labels || []),
+        source: 'github_issue',
+        sourceId: issue.number.toString(),
+        sourceUrl: issue.html_url,
+        repository: repository.full_name,
+        labels: (issue.labels || []).map((l) => l.name),
+        metadata: {
+            issueNumber: issue.number,
+            author: issue.user.login,
+            createdAt: issue.created_at,
+        },
+    };
+}
+/**
+ * Handle issue comment events (for trigger commands like /ai-do)
+ */
+function handleIssueCommentEvent(payload) {
+    const { action, issue, comment, repository } = payload;
+    if (action !== 'created')
+        return null;
+    // Check for trigger commands in comment
+    const body = comment.body.trim();
+    const triggerMatch = body.match(/^\/ai(?:-do)?\s+(.+)/is);
+    if (!triggerMatch) {
+        return null;
+    }
+    const prompt = triggerMatch[1].trim();
+    console.log(`[GitHub] AI trigger command in issue #${issue.number}: ${prompt.substring(0, 50)}...`);
+    return {
+        title: `AI Task: ${issue.title}`,
+        description: `Triggered by @${comment.user.login} in issue #${issue.number}`,
+        prompt: prompt,
+        priority: 2, // High priority for manual triggers
+        source: 'github_issue',
+        sourceId: issue.number.toString(),
+        sourceUrl: issue.html_url,
+        repository: repository.full_name,
+        labels: (issue.labels || []).map((l) => l.name),
+        metadata: {
+            issueNumber: issue.number,
+            triggeredBy: comment.user.login,
+            triggerCommentId: comment.id,
+            triggerCommentUrl: comment.html_url,
+        },
+    };
+}
+/**
+ * Handle pull request events
+ */
+function handlePullRequestEvent(payload) {
+    const { action, pull_request, repository } = payload;
+    // Handle review requests
+    if (action === 'review_requested') {
+        return {
+            title: `Review PR: ${pull_request.title}`,
+            description: pull_request.body || undefined,
+            prompt: buildReviewPrompt(pull_request),
+            priority: 2,
+            source: 'github_pr',
+            sourceId: pull_request.number.toString(),
+            sourceUrl: pull_request.html_url,
+            repository: repository.full_name,
+            branch: pull_request.head.ref,
+            labels: (pull_request.labels || []).map((l) => l.name),
+            metadata: {
+                prNumber: pull_request.number,
+                author: pull_request.user.login,
+                baseBranch: pull_request.base.ref,
+                headBranch: pull_request.head.ref,
+            },
+        };
+    }
+    // Handle opened PRs with ai-review label
+    if (action === 'opened' || action === 'labeled') {
+        const hasReviewLabel = pull_request.labels?.some((l) => l.name === AI_REVIEW_LABEL);
+        if (!hasReviewLabel)
+            return null;
+        return {
+            title: `Review PR: ${pull_request.title}`,
+            description: pull_request.body || undefined,
+            prompt: buildReviewPrompt(pull_request),
+            priority: 2,
+            source: 'github_pr',
+            sourceId: pull_request.number.toString(),
+            sourceUrl: pull_request.html_url,
+            repository: repository.full_name,
+            branch: pull_request.head.ref,
+            labels: (pull_request.labels || []).map((l) => l.name),
+            metadata: {
+                prNumber: pull_request.number,
+                author: pull_request.user.login,
+            },
+        };
+    }
+    return null;
+}
+/**
+ * Build AI prompt from GitHub issue
+ */
+function buildPromptFromIssue(issue) {
+    const parts = [];
+    parts.push(`GitHub Issue #${issue.number}: ${issue.title}`);
+    if (issue.body) {
+        parts.push('\n## Issue Description:');
+        parts.push(issue.body);
+    }
+    parts.push('\n## Task:');
+    parts.push('Please analyze this issue and implement a solution.');
+    parts.push('If this is a bug, fix it. If this is a feature request, implement it.');
+    parts.push('Create atomic commits with clear messages.');
+    parts.push('If you need clarification, note what questions you have.');
+    return parts.join('\n');
+}
+/**
+ * Build AI prompt for PR review
+ */
+function buildReviewPrompt(pr) {
+    return `Please review Pull Request #${pr.number}: ${pr.title}
+
+## PR Description:
+${pr.body || 'No description provided.'}
+
+## Review Tasks:
+1. Check the code changes for correctness and best practices
+2. Look for potential bugs, security issues, or performance problems
+3. Verify the changes match the PR description
+4. Suggest improvements if applicable
+5. Add a review comment summarizing your findings
+
+Be constructive and specific in your feedback.`;
+}
+/**
+ * Get priority from issue labels
+ */
+function getPriorityFromLabels(labels) {
+    const labelNames = labels.map((l) => l.name.toLowerCase());
+    if (labelNames.includes('critical') || labelNames.includes('p0'))
+        return 1;
+    if (labelNames.includes('high') || labelNames.includes('p1'))
+        return 2;
+    if (labelNames.includes('low') || labelNames.includes('p3'))
+        return 4;
+    return 3; // Default medium
+}
+//# sourceMappingURL=github.js.map

package/dist/integrations/jira-client.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Jira API Client
+ *
+ * Supports adding comments and updating issue status.
+ */
+export declare class JiraClient {
+    private baseUrl;
+    private email?;
+    private apiToken?;
+    private authHeader?;
+    constructor(config: {
+        baseUrl: string;
+        email?: string;
+        apiToken?: string;
+        authHeader?: string;
+    });
+    /**
+     * Add a comment to a Jira issue
+     */
+    addComment(issueKey: string, body: string): Promise<void>;
+    /**
+     * Update issue status (transition)
+     */
+    transitionIssue(issueKey: string, transitionId: string): Promise<void>;
+    /**
+     * Internal request helper
+     */
+    private request;
+}
+//# sourceMappingURL=jira-client.d.ts.map