@memberjunction/server 5.27.1 → 5.29.0

package/dist/resolvers/FeedbackResolver.js

@@ -0,0 +1,876 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Resolver, Mutation, Query, Arg, Ctx, Field, InputType, ObjectType } from 'type-graphql';
+import { Octokit } from '@octokit/rest';
+import { createAppAuth } from '@octokit/auth-app';
+import { LogError, LogStatus } from '@memberjunction/core';
+import { configInfo } from '../config.js';
+import { z } from 'zod';
+import { ChatParams, ChatMessageRole, GetAIAPIKey, BaseLLM } from '@memberjunction/ai';
+import { AIEngine } from '@memberjunction/aiengine';
+import { MJGlobal } from '@memberjunction/global';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { homedir } from 'os';
+// Module-level cache — survives across resolver instances (type-graphql creates a new instance per request)
+let cachedPrivateKey; // undefined = not yet read
+let cachedOctokit = null;
+let cachedAuthType = null;
+// ============================================================================
+// GraphQL Input/Output Types
+// ============================================================================
+/**
+ * Input type for feedback submission
+ */
+let SubmitFeedbackInput = class SubmitFeedbackInput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "Title", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "Description", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "Category", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "StepsToReproduce", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "ExpectedBehavior", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "ActualBehavior", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "Severity", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "UseCase", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "ProposedSolution", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "Email", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "Name", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "Environment", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "AffectedArea", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "CurrentPage", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "UserAgent", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "ScreenSize", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "AppName", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "AppVersion", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "UserId", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "Timestamp", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], SubmitFeedbackInput.prototype, "Metadata", void 0);
+SubmitFeedbackInput = __decorate([
+    InputType()
+], SubmitFeedbackInput);
+export { SubmitFeedbackInput };
+/**
+ * Response type for feedback submission
+ */
+let FeedbackResponseType = class FeedbackResponseType {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], FeedbackResponseType.prototype, "Success", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], FeedbackResponseType.prototype, "IssueNumber", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], FeedbackResponseType.prototype, "IssueUrl", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], FeedbackResponseType.prototype, "Error", void 0);
+FeedbackResponseType = __decorate([
+    ObjectType()
+], FeedbackResponseType);
+export { FeedbackResponseType };
+/**
+ * Input type for feedback classification
+ */
+let ClassifyFeedbackInput = class ClassifyFeedbackInput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ClassifyFeedbackInput.prototype, "Title", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ClassifyFeedbackInput.prototype, "Description", void 0);
+ClassifyFeedbackInput = __decorate([
+    InputType()
+], ClassifyFeedbackInput);
+export { ClassifyFeedbackInput };
+/**
+ * Response type for feedback classification
+ */
+let FeedbackClassificationResult = class FeedbackClassificationResult {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], FeedbackClassificationResult.prototype, "Success", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], FeedbackClassificationResult.prototype, "Category", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], FeedbackClassificationResult.prototype, "Severity", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], FeedbackClassificationResult.prototype, "Error", void 0);
+FeedbackClassificationResult = __decorate([
+    ObjectType()
+], FeedbackClassificationResult);
+export { FeedbackClassificationResult };
+// ============================================================================
+// Validation Schema
+// ============================================================================
+const FeedbackSubmissionSchema = z.object({
+    title: z
+        .string()
+        .min(5, 'Title must be at least 5 characters')
+        .max(256, 'Title must not exceed 256 characters'),
+    description: z
+        .string()
+        .min(20, 'Description must be at least 20 characters')
+        .max(10000, 'Description must not exceed 10000 characters'),
+    category: z.union([
+        z.literal('bug'),
+        z.literal('feature'),
+        z.literal('question'),
+        z.literal('other'),
+        z.string().max(50),
+    ]),
+    stepsToReproduce: z.string().max(5000).optional(),
+    expectedBehavior: z.string().max(5000).optional(),
+    actualBehavior: z.string().max(5000).optional(),
+    severity: z.enum(['critical', 'major', 'minor', 'trivial']).optional(),
+    useCase: z.string().max(5000).optional(),
+    proposedSolution: z.string().max(5000).optional(),
+    email: z.string().email().optional().or(z.literal('')),
+    name: z.string().max(100).optional(),
+    environment: z.enum(['production', 'staging', 'development', 'local']).optional(),
+    affectedArea: z.string().max(100).optional(),
+    currentPage: z.string().max(200).optional(),
+    userAgent: z.string().max(500).optional(),
+    screenSize: z.string().max(20).optional(),
+    appName: z.string().max(100).optional(),
+    appVersion: z.string().max(50).optional(),
+    userId: z.string().max(100).optional(),
+    timestamp: z.string().optional(),
+    metadata: z.record(z.unknown()).optional(),
+});
+// ============================================================================
+// Display Labels
+// ============================================================================
+const categoryLabels = {
+    bug: 'Bug Report',
+    feature: 'Feature Request',
+    question: 'Question',
+    other: 'Other',
+};
+const severityLabels = {
+    critical: 'Critical',
+    major: 'Major',
+    minor: 'Minor',
+    trivial: 'Trivial',
+};
+const environmentLabels = {
+    production: 'Production',
+    staging: 'Staging',
+    development: 'Development',
+    local: 'Local',
+};
+// ============================================================================
+// Resolver
+// ============================================================================
+let FeedbackResolver = class FeedbackResolver {
+    /**
+     * Submit feedback and create a GitHub issue
+     */
+    /**
+     * Check if the feedback feature is enabled for this org.
+     */
+    FeedbackEnabled() {
+        return this.isFeedbackEnabled();
+    }
+    /**
+     * Feedback is considered enabled only when both (a) the org kill switch
+     * is not explicitly off and (b) GitHub credentials are configured. Without
+     * (b) the feature cannot create issues, so we hide it rather than letting
+     * users submit into a broken pipe.
+     */
+    isFeedbackEnabled() {
+        if (configInfo.feedbackSettings.enabled === false) {
+            return false;
+        }
+        return this.resolveAuth() !== null;
+    }
+    async SubmitFeedback(input, ctx) {
+        try {
+            if (!this.isFeedbackEnabled()) {
+                return { Success: false, Error: 'Feedback is disabled for this organization.' };
+            }
+            // Get configuration
+            const config = this.getConfig();
+            if (!config) {
+                return {
+                    Success: false,
+                    Error: 'Feedback system is not configured. GITHUB_PAT environment variable is required.',
+                };
+            }
+            // Convert input to internal format
+            const submission = this.convertInputToSubmission(input, ctx);
+            // Validate submission
+            const validationResult = FeedbackSubmissionSchema.safeParse(submission);
+            if (!validationResult.success) {
+                const errorMessages = validationResult.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`);
+                return {
+                    Success: false,
+                    Error: `Validation failed: ${errorMessages.join('; ')}`,
+                };
+            }
+            // Create GitHub issue
+            const issue = await this.createGitHubIssue(submission, config);
+            LogStatus(`Feedback submitted: Issue #${issue.number} created`);
+            return {
+                Success: true,
+                IssueNumber: issue.number,
+                IssueUrl: issue.html_url,
+            };
+        }
+        catch (error) {
+            LogError('Error submitting feedback', undefined, error);
+            const message = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                Success: false,
+                Error: message,
+            };
+        }
+    }
+    /**
+     * Classify feedback using an LLM to suggest category and severity.
+     */
+    async ClassifyFeedback(input, ctx) {
+        try {
+            if (!this.isFeedbackEnabled()) {
+                return { Success: false, Error: 'Feedback is disabled for this organization.' };
+            }
+            // Get the current context user for AIEngine config
+            const contextUser = ctx.userPayload?.userRecord;
+            await AIEngine.Instance.Config(false, contextUser);
+            // Get active LLM models with valid API keys (guard against null DriverClass)
+            const allModels = AIEngine.Instance.Models.filter(m => m.AIModelType?.trim().toLowerCase() === 'llm' && m.IsActive && m.DriverClass);
+            const models = allModels.filter(m => {
+                try {
+                    const key = GetAIAPIKey(m.DriverClass);
+                    return key && key.trim().length > 0;
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (models.length === 0) {
+                return { Success: false, Error: 'No AI models configured' };
+            }
+            // Pick a fast, cheap model — prefer Groq, then OpenAI, then any available
+            const model = models.find(m => m.DriverClass === 'GroqLLM')
+                || models.find(m => m.DriverClass === 'OpenAILLM')
+                || models[0];
+            const apiKey = GetAIAPIKey(model.DriverClass);
+            const llm = MJGlobal.Instance.ClassFactory.CreateInstance(BaseLLM, model.DriverClass, apiKey);
+            if (!llm) {
+                return { Success: false, Error: 'Failed to create LLM instance' };
+            }
+            const chatParams = new ChatParams();
+            chatParams.model = model.APIName;
+            chatParams.messages = [
+                {
+                    role: ChatMessageRole.system,
+                    content: `Classify this user feedback. Respond with ONLY a JSON object, no other text:
+{"category": "bug"|"feature"|"question"|"other", "severity": "critical"|"major"|"minor"|"trivial"}
+
+Step 1 — CATEGORY. Choose ONE. Read the intent, not just keywords:
+- "question" = user is SEEKING HELP or INFORMATION. Clues: "how do I", "where is", "can I", "is it possible", "I can't find", "where did ___ go", "used to see ___ but now", "help me". Even if they sound frustrated, if they're looking for guidance it's a question. A user who can't FIND something is asking a question, not reporting a bug.
+- "feature" = user WANTS something NEW: "it would be nice", "can you add", "I wish", "please add", "would love to see"
+- "bug" = something is OBJECTIVELY BROKEN: "error message", "crash", "500 error", "white screen", "data lost", "button does nothing when clicked", "stops responding". The system is malfunctioning, not just confusing.
+- "other" = doesn't fit the above
+
+Step 2 — SEVERITY. Strictly follow these rules:
+- If category is "question" → severity MUST be "trivial"
+- If category is "feature" → severity MUST be "minor"
+- If category is "other" → severity MUST be "minor"
+- If category is "bug":
+  - "critical" = data loss, security vulnerability, entire system unusable for ALL users
+  - "major" = user EXPLICITLY says words like "blocking me", "preventing me from", "can't complete my work", "unable to do my job". Without these exact phrases, do NOT use major.
+  - "trivial" = purely visual: typo, misspelling, alignment, spacing, colors, dark mode, theme, font, styling, cosmetic appearance
+  - "minor" = everything else. This is the DEFAULT for bugs. If unsure between trivial and minor, pick trivial. If unsure between minor and major, pick minor.`
+                },
+                {
+                    role: ChatMessageRole.user,
+                    content: `Title: ${input.Title}\nDescription: ${input.Description}`
+                }
+            ];
+            const result = await llm.ChatCompletion(chatParams);
+            const content = result?.data?.choices?.[0]?.message?.content?.trim();
+            if (!content) {
+                return { Success: false, Error: 'Empty response from AI' };
+            }
+            // Parse JSON from response (handle potential markdown code fences)
+            const jsonStr = content.replace(/```json?\s*/g, '').replace(/```/g, '').trim();
+            const parsed = JSON.parse(jsonStr);
+            return {
+                Success: true,
+                Category: parsed.category,
+                Severity: parsed.severity
+            };
+        }
+        catch (error) {
+            LogError('Error classifying feedback', undefined, error);
+            return { Success: false, Error: 'Classification failed' };
+        }
+    }
+    // ============================================================================
+    // Private Helper Methods
+    // ============================================================================
+    /**
+     * Get feedback configuration from environment/config.
+     * Supports GitHub App auth (preferred) or PAT fallback.
+     */
+    getConfig() {
+        const auth = this.resolveAuth();
+        if (!auth) {
+            return null;
+        }
+        const githubSettings = configInfo.feedbackSettings?.github;
+        return {
+            owner: githubSettings?.owner || process.env.GITHUB_FEEDBACK_OWNER || 'MemberJunction',
+            repo: githubSettings?.repo || process.env.GITHUB_FEEDBACK_REPO || 'MJ',
+            auth,
+            defaultLabels: githubSettings?.defaultLabels || ['user-submitted'],
+            categoryLabels: githubSettings?.categoryLabels || {
+                bug: 'bug',
+                feature: 'enhancement',
+                question: 'question',
+                other: 'triage',
+            },
+            severityLabels: githubSettings?.severityLabels || {
+                critical: 'priority: critical',
+                major: 'priority: high',
+                minor: 'priority: medium',
+                trivial: 'priority: low',
+            },
+            assignees: githubSettings?.assignees,
+        };
+    }
+    /**
+     * Resolve authentication — prefers GitHub App, falls back to PAT.
+     */
+    resolveAuth() {
+        // Try GitHub App first
+        const appId = process.env.GITHUB_APP_ID;
+        const installationId = process.env.GITHUB_APP_INSTALLATION_ID;
+        const privateKey = this.readPrivateKey();
+        if (appId && installationId && privateKey) {
+            return {
+                type: 'app',
+                appId: Number(appId),
+                installationId: Number(installationId),
+                privateKey
+            };
+        }
+        // Fall back to PAT
+        const token = process.env.GITHUB_PAT;
+        if (token) {
+            return { type: 'pat', token };
+        }
+        return null;
+    }
+    /**
+     * Read the GitHub App private key from file path or inline env var.
+     * Cached at module level — the key file doesn't change at runtime.
+     */
+    readPrivateKey() {
+        if (cachedPrivateKey !== undefined) {
+            return cachedPrivateKey;
+        }
+        // Option 1: File path
+        const keyPath = process.env.GITHUB_APP_PRIVATE_KEY_PATH;
+        if (keyPath) {
+            try {
+                const resolved = keyPath.startsWith('~/')
+                    ? resolve(homedir(), keyPath.slice(2))
+                    : resolve(keyPath);
+                cachedPrivateKey = readFileSync(resolved, 'utf-8');
+                return cachedPrivateKey;
+            }
+            catch (error) {
+                LogError('Failed to read GitHub App private key file', undefined, error);
+                cachedPrivateKey = null;
+                return null;
+            }
+        }
+        // Option 2: Inline key (with \n replaced)
+        const inlineKey = process.env.GITHUB_APP_PRIVATE_KEY;
+        if (inlineKey) {
+            cachedPrivateKey = inlineKey.replace(/\\n/g, '\n');
+            return cachedPrivateKey;
+        }
+        cachedPrivateKey = null;
+        return null;
+    }
+    /**
+     * Convert GraphQL input to internal submission format
+     */
+    convertInputToSubmission(input, ctx) {
+        const submission = {
+            title: input.Title,
+            description: input.Description,
+            category: input.Category,
+            stepsToReproduce: input.StepsToReproduce,
+            expectedBehavior: input.ExpectedBehavior,
+            actualBehavior: input.ActualBehavior,
+            severity: input.Severity,
+            useCase: input.UseCase,
+            proposedSolution: input.ProposedSolution,
+            email: input.Email,
+            name: input.Name,
+            environment: input.Environment,
+            affectedArea: input.AffectedArea,
+            currentPage: input.CurrentPage,
+            userAgent: input.UserAgent,
+            screenSize: input.ScreenSize,
+            appName: input.AppName,
+            appVersion: input.AppVersion,
+            userId: input.UserId || ctx.userPayload?.userRecord?.ID,
+            timestamp: input.Timestamp || new Date().toISOString(),
+        };
+        // Parse metadata if provided
+        if (input.Metadata) {
+            try {
+                submission.metadata = JSON.parse(input.Metadata);
+            }
+            catch {
+                // Ignore invalid JSON
+            }
+        }
+        return submission;
+    }
+    /**
+     * Get or create an authenticated Octokit instance.
+     * Cached at module level — createAppAuth handles token refresh internally.
+     */
+    getOctokit(config) {
+        if (cachedOctokit && cachedAuthType === config.auth.type) {
+            return cachedOctokit;
+        }
+        if (config.auth.type === 'app') {
+            cachedOctokit = new Octokit({
+                authStrategy: createAppAuth,
+                auth: {
+                    appId: config.auth.appId,
+                    privateKey: config.auth.privateKey,
+                    installationId: config.auth.installationId,
+                },
+            });
+        }
+        else {
+            cachedOctokit = new Octokit({ auth: config.auth.token });
+        }
+        cachedAuthType = config.auth.type;
+        return cachedOctokit;
+    }
+    /**
+     * Create a GitHub issue from the feedback submission.
+     * If a screenshot is present, uploads it to the repo and embeds it in the issue.
+     */
+    async createGitHubIssue(submission, config) {
+        const octokit = this.getOctokit(config);
+        // Extract screenshot before formatting (formatScreenshotSection removes it from metadata)
+        const screenshotDataUrl = submission.metadata?.screenshot;
+        const labels = this.buildLabels(submission, config);
+        const body = this.formatIssueBody(submission);
+        // Create the issue first
+        const response = await octokit.issues.create({
+            owner: config.owner,
+            repo: config.repo,
+            title: submission.title,
+            body,
+            labels,
+            assignees: config.assignees,
+        });
+        const issueNumber = response.data.number;
+        // Upload screenshot and update issue body if present
+        if (screenshotDataUrl && typeof screenshotDataUrl === 'string') {
+            try {
+                const imageUrl = await this.uploadScreenshot(octokit, config.owner, config.repo, screenshotDataUrl, issueNumber);
+                if (imageUrl) {
+                    const screenshotMarkdown = `\n## Screenshot\n\n![Screenshot](${imageUrl})\n`;
+                    await octokit.issues.update({
+                        owner: config.owner,
+                        repo: config.repo,
+                        issue_number: issueNumber,
+                        body: body + screenshotMarkdown,
+                    });
+                }
+            }
+            catch (error) {
+                // Screenshot upload is best-effort — don't fail the whole submission
+                LogError('Failed to upload feedback screenshot', undefined, error);
+            }
+        }
+        return {
+            number: issueNumber,
+            html_url: response.data.html_url,
+        };
+    }
+    /**
+     * Upload a base64 screenshot to the repo and return the raw content URL.
+     */
+    async uploadScreenshot(octokit, owner, repo, dataUrl, issueNumber) {
+        // Strip the data URL prefix (e.g., "data:image/jpeg;base64,")
+        const base64Match = dataUrl.match(/^data:image\/(\w+);base64,(.+)$/);
+        if (!base64Match)
+            return null;
+        const extension = base64Match[1] === 'jpeg' ? 'jpg' : base64Match[1];
+        const base64Content = base64Match[2];
+        const filename = `${issueNumber}-${Date.now()}.${extension}`;
+        const path = `.github/feedback-screenshots/${filename}`;
+        await octokit.repos.createOrUpdateFileContents({
+            owner,
+            repo,
+            path,
+            message: `feedback: add screenshot for issue #${issueNumber}`,
+            content: base64Content,
+        });
+        return `https://raw.githubusercontent.com/${owner}/${repo}/next/${path}`;
+    }
+    /**
+     * Build the labels array for the GitHub issue
+     */
+    buildLabels(submission, config) {
+        const labels = [];
+        if (config.defaultLabels) {
+            labels.push(...config.defaultLabels);
+        }
+        if (config.categoryLabels && submission.category in config.categoryLabels) {
+            labels.push(config.categoryLabels[submission.category]);
+        }
+        if (submission.severity && config.severityLabels && submission.severity in config.severityLabels) {
+            labels.push(config.severityLabels[submission.severity]);
+        }
+        return labels;
+    }
+    /**
+     * Format the feedback submission as a GitHub issue body in markdown.
+     * Orchestrates section-specific formatters and joins them.
+     */
+    formatIssueBody(submission) {
+        const sections = [
+            this.formatDescriptionSection(submission),
+            this.formatScreenshotSection(submission),
+            '---',
+            '',
+            this.formatDetailsTable(submission),
+            this.formatContactSection(submission),
+            this.formatTechnicalDetails(submission),
+            this.formatMetadataSection(submission),
+        ];
+        return sections.filter(s => s.length > 0).join('\n');
+    }
+    /**
+     * Format the description and category-specific sections (bug/feature)
+     */
+    formatDescriptionSection(submission) {
+        const lines = [];
+        lines.push('## Description', '', this.sanitizeMarkdown(submission.description), '');
+        if (submission.category === 'bug') {
+            if (submission.stepsToReproduce) {
+                lines.push('## Steps to Reproduce', '', this.sanitizeMarkdown(submission.stepsToReproduce), '');
+            }
+            if (submission.expectedBehavior) {
+                lines.push('## Expected Behavior', '', this.sanitizeMarkdown(submission.expectedBehavior), '');
+            }
+            if (submission.actualBehavior) {
+                lines.push('## Actual Behavior', '', this.sanitizeMarkdown(submission.actualBehavior), '');
+            }
+        }
+        if (submission.category === 'feature') {
+            if (submission.useCase) {
+                lines.push('## Use Case', '', this.sanitizeMarkdown(submission.useCase), '');
+            }
+            if (submission.proposedSolution) {
+                lines.push('## Proposed Solution', '', this.sanitizeMarkdown(submission.proposedSolution), '');
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format the submission details markdown table
+     */
+    formatDetailsTable(submission) {
+        const rows = [];
+        rows.push('### Submission Details', '', '| Field | Value |', '|-------|-------|');
+        if (submission.appName) {
+            const appInfo = submission.appVersion
+                ? `${this.sanitizeMarkdown(submission.appName)} v${this.sanitizeMarkdown(submission.appVersion)}`
+                : this.sanitizeMarkdown(submission.appName);
+            rows.push(`| **App** | ${appInfo} |`);
+        }
+        const categoryDisplay = categoryLabels[submission.category] || submission.category;
+        rows.push(`| **Category** | ${this.sanitizeMarkdown(categoryDisplay)} |`);
+        if (submission.severity) {
+            const severityDisplay = severityLabels[submission.severity] || submission.severity;
+            rows.push(`| **Severity** | ${this.sanitizeMarkdown(severityDisplay)} |`);
+        }
+        if (submission.environment) {
+            const envDisplay = environmentLabels[submission.environment] || submission.environment;
+            rows.push(`| **Environment** | ${this.sanitizeMarkdown(envDisplay)} |`);
+        }
+        if (submission.affectedArea) {
+            rows.push(`| **Affected Area** | ${this.sanitizeMarkdown(submission.affectedArea)} |`);
+        }
+        if (submission.timestamp) {
+            rows.push(`| **Submitted** | ${this.sanitizeMarkdown(submission.timestamp)} |`);
+        }
+        rows.push('');
+        return rows.join('\n');
+    }
+    /**
+     * Format the contact information section
+     */
+    formatContactSection(submission) {
+        if (!submission.name && !submission.email) {
+            return '';
+        }
+        const contactParts = [];
+        if (submission.name) {
+            contactParts.push(this.sanitizeMarkdown(submission.name));
+        }
+        if (submission.email) {
+            contactParts.push(this.sanitizeMarkdown(submission.email));
+        }
+        return ['### Contact', '', contactParts.join(' — '), ''].join('\n');
+    }
+    /**
+     * Format the technical details table (page, browser, screen, user)
+     */
+    formatTechnicalDetails(submission) {
+        if (!submission.currentPage && !submission.userAgent && !submission.screenSize && !submission.userId) {
+            return '';
+        }
+        const rows = [];
+        rows.push('### Technical Details', '', '| Field | Value |', '|-------|-------|');
+        if (submission.currentPage) {
+            rows.push(`| **Page/View** | ${this.sanitizeMarkdown(submission.currentPage)} |`);
+        }
+        if (submission.userAgent) {
+            const browserInfo = this.parseUserAgent(submission.userAgent);
+            rows.push(`| **Browser** | ${this.sanitizeMarkdown(browserInfo)} |`);
+        }
+        if (submission.screenSize) {
+            rows.push(`| **Screen Size** | ${this.sanitizeMarkdown(submission.screenSize)} |`);
+        }
+        if (submission.userId) {
+            rows.push(`| **User ID** | ${this.sanitizeMarkdown(submission.userId)} |`);
+        }
+        rows.push('');
+        return rows.join('\n');
+    }
+    /**
+     * Format the screenshot section. Embeds the base64 data in a collapsed block
+     * that AI agents can parse, even though GitHub won't render it visually.
+     * If the file upload succeeds (in createGitHubIssue), the issue body gets
+     * updated with a rendered image above this block.
+     */
+    formatScreenshotSection(submission) {
+        const screenshot = submission.metadata?.screenshot;
+        if (!screenshot || typeof screenshot !== 'string') {
+            return '';
+        }
+        // Remove from metadata so it doesn't also appear in the JSON section
+        delete submission.metadata.screenshot;
+        return [
+            '<details>',
+            '<summary>📷 Screenshot (for AI agents — not rendered by GitHub)</summary>',
+            '',
+            `![Screenshot](${screenshot})`,
+            '',
+            '</details>',
+            '',
+        ].join('\n');
+    }
+    /**
+     * Format the collapsible metadata JSON section
+     */
+    formatMetadataSection(submission) {
+        if (!submission.metadata || Object.keys(submission.metadata).length === 0) {
+            return '';
+        }
+        return [
+            '<details>',
+            '<summary>Additional Metadata</summary>',
+            '',
+            '```json',
+            JSON.stringify(submission.metadata, null, 2),
+            '```',
+            '</details>',
+        ].join('\n');
+    }
+    /**
+     * Sanitize a string for safe inclusion in markdown
+     */
+    sanitizeMarkdown(text) {
+        if (!text)
+            return '';
+        return text
+            .replace(/\\/g, '\\\\') // backslashes first (before other escapes add more)
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/`/g, '\\`') // inline code injection
+            .replace(/\[/g, '\\[')
+            .replace(/\]/g, '\\]')
+            .replace(/!\[/g, '!\\[')
+            .replace(/\(/g, '\\(') // link URL injection
+            .replace(/\)/g, '\\)')
+            .replace(/\|/g, '\\|');
+    }
+    /**
+     * Parse user agent string into a human-readable format
+     */
+    parseUserAgent(userAgent) {
+        let browser = 'Unknown Browser';
+        let os = 'Unknown OS';
+        if (userAgent.includes('Firefox/')) {
+            const match = userAgent.match(/Firefox\/(\d+)/);
+            browser = match ? `Firefox ${match[1]}` : 'Firefox';
+        }
+        else if (userAgent.includes('Edg/')) {
+            const match = userAgent.match(/Edg\/(\d+)/);
+            browser = match ? `Edge ${match[1]}` : 'Edge';
+        }
+        else if (userAgent.includes('Chrome/')) {
+            const match = userAgent.match(/Chrome\/(\d+)/);
+            browser = match ? `Chrome ${match[1]}` : 'Chrome';
+        }
+        else if (userAgent.includes('Safari/') && !userAgent.includes('Chrome')) {
+            const match = userAgent.match(/Version\/(\d+)/);
+            browser = match ? `Safari ${match[1]}` : 'Safari';
+        }
+        if (userAgent.includes('Windows NT 10')) {
+            os = 'Windows 10/11';
+        }
+        else if (userAgent.includes('Windows NT')) {
+            os = 'Windows';
+        }
+        else if (userAgent.includes('Mac OS X')) {
+            const match = userAgent.match(/Mac OS X (\d+[._]\d+)/);
+            os = match ? `macOS ${match[1].replace('_', '.')}` : 'macOS';
+        }
+        else if (userAgent.includes('Linux')) {
+            os = 'Linux';
+        }
+        else if (userAgent.includes('Android')) {
+            os = 'Android';
+        }
+        else if (userAgent.includes('iOS') || userAgent.includes('iPhone') || userAgent.includes('iPad')) {
+            os = 'iOS';
+        }
+        return `${browser} on ${os}`;
+    }
+};
+__decorate([
+    Query(() => Boolean),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Boolean)
+], FeedbackResolver.prototype, "FeedbackEnabled", null);
+__decorate([
+    Mutation(() => FeedbackResponseType),
+    __param(0, Arg('input')),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [SubmitFeedbackInput, Object]),
+    __metadata("design:returntype", Promise)
+], FeedbackResolver.prototype, "SubmitFeedback", null);
+__decorate([
+    Mutation(() => FeedbackClassificationResult),
+    __param(0, Arg('input')),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ClassifyFeedbackInput, Object]),
+    __metadata("design:returntype", Promise)
+], FeedbackResolver.prototype, "ClassifyFeedback", null);
+FeedbackResolver = __decorate([
+    Resolver()
+], FeedbackResolver);
+export { FeedbackResolver };
+//# sourceMappingURL=FeedbackResolver.js.map