@bbearai/core 0.2.0 → 0.2.1

package/dist/index.mjs

@@ -117,6 +117,7 @@ var BugBearClient = class {
       const { data, error } = await this.supabase.from("test_assignments").select(`
           id,
           status,
+          started_at,
           test_case:test_cases(
             id,
             title,
@@ -144,6 +145,7 @@ var BugBearClient = class {
       return (data || []).map((item) => ({
         id: item.id,
         status: item.status,
+        startedAt: item.started_at,
         testCase: {
           id: item.test_case.id,
           title: item.test_case.title,
@@ -169,6 +171,254 @@ var BugBearClient = class {
       return [];
     }
   }
+  /**
+   * Get assignment by ID with time tracking fields
+   */
+  async getAssignment(assignmentId) {
+    try {
+      const { data, error } = await this.supabase.from("test_assignments").select(`
+          id,
+          status,
+          started_at,
+          completed_at,
+          duration_seconds,
+          test_case:test_cases(
+            id,
+            title,
+            test_key,
+            description,
+            steps,
+            expected_result,
+            priority,
+            target_route,
+            track:qa_tracks(
+              id,
+              name,
+              icon,
+              color,
+              test_template,
+              rubric_mode,
+              description
+            )
+          )
+        `).eq("id", assignmentId).single();
+      if (error || !data) return null;
+      const testCase = data.test_case;
+      if (!testCase) {
+        console.error("BugBear: Assignment returned without test_case");
+        return null;
+      }
+      const track = testCase.track;
+      return {
+        id: data.id,
+        status: data.status,
+        startedAt: data.started_at,
+        durationSeconds: data.duration_seconds,
+        testCase: {
+          id: testCase.id,
+          title: testCase.title,
+          testKey: testCase.test_key,
+          description: testCase.description,
+          steps: testCase.steps,
+          expectedResult: testCase.expected_result,
+          priority: testCase.priority,
+          targetRoute: testCase.target_route,
+          track: track ? {
+            id: track.id,
+            name: track.name,
+            icon: track.icon,
+            color: track.color,
+            testTemplate: track.test_template,
+            rubricMode: track.rubric_mode || "pass_fail",
+            description: track.description
+          } : void 0
+        }
+      };
+    } catch (err) {
+      console.error("BugBear: Error fetching assignment", err);
+      return null;
+    }
+  }
+  /**
+   * Update assignment status with automatic time tracking
+   * - Sets started_at when status changes to 'in_progress'
+   * - Calculates duration_seconds when status changes to 'passed'/'failed'/'blocked'
+   * - Optionally include feedback when completing a test
+   */
+  async updateAssignmentStatus(assignmentId, status, options) {
+    try {
+      const { data: currentAssignment, error: fetchError } = await this.supabase.from("test_assignments").select("status, started_at").eq("id", assignmentId).single();
+      if (fetchError || !currentAssignment) {
+        return { success: false, error: "Assignment not found" };
+      }
+      const updateData = { status };
+      let durationSeconds;
+      if (status === "in_progress" && currentAssignment.status !== "in_progress") {
+        updateData.started_at = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      if (["passed", "failed", "blocked"].includes(status)) {
+        updateData.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+        if (currentAssignment.started_at) {
+          const startedAt = new Date(currentAssignment.started_at);
+          const completedAt = /* @__PURE__ */ new Date();
+          durationSeconds = Math.round((completedAt.getTime() - startedAt.getTime()) / 1e3);
+          updateData.duration_seconds = durationSeconds;
+        }
+      }
+      if (options?.notes) {
+        updateData.notes = options.notes;
+      }
+      if (options?.testResult) {
+        updateData.test_result = options.testResult;
+      }
+      const { error } = await this.supabase.from("test_assignments").update(updateData).eq("id", assignmentId);
+      if (error) {
+        console.error("BugBear: Failed to update assignment status", error);
+        return { success: false, error: error.message };
+      }
+      if (options?.feedback && ["passed", "failed", "blocked"].includes(status)) {
+        const { data: assignmentData, error: fetchError2 } = await this.supabase.from("test_assignments").select("test_case_id").eq("id", assignmentId).single();
+        if (fetchError2) {
+          console.error("BugBear: Failed to fetch assignment for feedback", fetchError2);
+        } else if (assignmentData?.test_case_id) {
+          const feedbackResult = await this.submitTestFeedback({
+            testCaseId: assignmentData.test_case_id,
+            assignmentId,
+            feedback: options.feedback,
+            timeToCompleteSeconds: durationSeconds
+          });
+          if (!feedbackResult.success) {
+            console.error("BugBear: Failed to submit feedback", feedbackResult.error);
+          }
+        }
+      }
+      return { success: true, durationSeconds };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error updating assignment status", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Submit feedback on a test case to help improve test quality
+   * This empowers testers to shape better tests over time
+   */
+  async submitTestFeedback(options) {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) {
+        return { success: false, error: "Not authenticated as tester" };
+      }
+      const { testCaseId, assignmentId, feedback, timeToCompleteSeconds } = options;
+      if (feedback.rating < 1 || feedback.rating > 5) {
+        return { success: false, error: "Rating must be between 1 and 5" };
+      }
+      const { error: feedbackError } = await this.supabase.from("test_feedback").insert({
+        project_id: this.config.projectId,
+        test_case_id: testCaseId,
+        assignment_id: assignmentId || null,
+        tester_id: testerInfo.id,
+        rating: feedback.rating,
+        clarity_rating: feedback.clarityRating || null,
+        steps_rating: feedback.stepsRating || null,
+        relevance_rating: feedback.relevanceRating || null,
+        feedback_note: feedback.feedbackNote?.trim() || null,
+        suggested_improvement: feedback.suggestedImprovement?.trim() || null,
+        is_outdated: feedback.isOutdated || false,
+        needs_more_detail: feedback.needsMoreDetail || false,
+        steps_unclear: feedback.stepsUnclear || false,
+        expected_result_unclear: feedback.expectedResultUnclear || false,
+        platform: this.getDeviceInfo().platform,
+        time_to_complete_seconds: timeToCompleteSeconds || null
+      });
+      if (feedbackError) {
+        console.error("BugBear: Failed to submit feedback", feedbackError);
+        return { success: false, error: feedbackError.message };
+      }
+      if (assignmentId) {
+        const { error: assignmentError } = await this.supabase.from("test_assignments").update({
+          feedback_rating: feedback.rating,
+          feedback_note: feedback.feedbackNote?.trim() || null,
+          feedback_submitted_at: (/* @__PURE__ */ new Date()).toISOString()
+        }).eq("id", assignmentId);
+        if (assignmentError) {
+          console.error("BugBear: Failed to update assignment feedback fields", assignmentError);
+        }
+      }
+      return { success: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error submitting feedback", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Get the currently active (in_progress) assignment for the tester
+   */
+  async getActiveAssignment() {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) return null;
+      const { data, error } = await this.supabase.from("test_assignments").select(`
+          id,
+          status,
+          started_at,
+          test_case:test_cases(
+            id,
+            title,
+            test_key,
+            description,
+            steps,
+            expected_result,
+            priority,
+            target_route,
+            track:qa_tracks(
+              id,
+              name,
+              icon,
+              color,
+              test_template,
+              rubric_mode,
+              description
+            )
+          )
+        `).eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).eq("status", "in_progress").order("started_at", { ascending: false }).limit(1).maybeSingle();
+      if (error || !data) return null;
+      const testCase = data.test_case;
+      if (!testCase) {
+        console.error("BugBear: Active assignment returned without test_case");
+        return null;
+      }
+      const track = testCase.track;
+      return {
+        id: data.id,
+        status: data.status,
+        startedAt: data.started_at,
+        testCase: {
+          id: testCase.id,
+          title: testCase.title,
+          testKey: testCase.test_key,
+          description: testCase.description,
+          steps: testCase.steps,
+          expectedResult: testCase.expected_result,
+          priority: testCase.priority,
+          targetRoute: testCase.target_route,
+          track: track ? {
+            id: track.id,
+            name: track.name,
+            icon: track.icon,
+            color: track.color,
+            testTemplate: track.test_template,
+            rubricMode: track.rubric_mode || "pass_fail",
+            description: track.description
+          } : void 0
+        }
+      };
+    } catch (err) {
+      console.error("BugBear: Error fetching active assignment", err);
+      return null;
+    }
+  }
   /**
    * Get current tester info
    * Looks up tester by email from the host app's authenticated user
@@ -719,6 +969,248 @@ var BugBearClient = class {
       return { success: false, error: message };
     }
   }
+  // ============================================
+  // QA Sessions (Sprint 1)
+  // ============================================
+  /**
+   * Start a new QA session for exploratory testing
+   */
+  async startSession(options = {}) {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) {
+        return { success: false, error: "Not authenticated as a tester" };
+      }
+      const activeSession = await this.getActiveSession();
+      if (activeSession) {
+        return { success: false, error: "You already have an active session. End it before starting a new one." };
+      }
+      const { data, error } = await this.supabase.rpc("start_qa_session", {
+        p_project_id: this.config.projectId,
+        p_tester_id: testerInfo.id,
+        p_focus_area: options.focusArea || null,
+        p_track: options.track || null,
+        p_platform: options.platform || null
+      });
+      if (error) {
+        console.error("BugBear: Failed to start session", error);
+        return { success: false, error: error.message };
+      }
+      const session = await this.getSession(data);
+      if (!session) {
+        return { success: false, error: "Session created but could not be fetched" };
+      }
+      return { success: true, session };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error starting session", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * End the current QA session
+   */
+  async endSession(sessionId, options = {}) {
+    try {
+      const { data, error } = await this.supabase.rpc("end_qa_session", {
+        p_session_id: sessionId,
+        p_notes: options.notes || null,
+        p_routes_covered: options.routesCovered || null
+      });
+      if (error) {
+        console.error("BugBear: Failed to end session", error);
+        return { success: false, error: error.message };
+      }
+      const session = this.transformSession(data);
+      return { success: true, session };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error ending session", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Get the current active session for the tester
+   */
+  async getActiveSession() {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) return null;
+      const { data, error } = await this.supabase.from("qa_sessions").select("*").eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).eq("status", "active").order("started_at", { ascending: false }).limit(1).maybeSingle();
+      if (error || !data) return null;
+      return this.transformSession(data);
+    } catch (err) {
+      console.error("BugBear: Error fetching active session", err);
+      return null;
+    }
+  }
+  /**
+   * Get a session by ID
+   */
+  async getSession(sessionId) {
+    try {
+      const { data, error } = await this.supabase.from("qa_sessions").select("*").eq("id", sessionId).single();
+      if (error || !data) return null;
+      return this.transformSession(data);
+    } catch (err) {
+      console.error("BugBear: Error fetching session", err);
+      return null;
+    }
+  }
+  /**
+   * Get session history for the tester
+   */
+  async getSessionHistory(limit = 10) {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) return [];
+      const { data, error } = await this.supabase.from("qa_sessions").select("*").eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).order("started_at", { ascending: false }).limit(limit);
+      if (error) {
+        console.error("BugBear: Failed to fetch session history", error);
+        return [];
+      }
+      return (data || []).map((s) => this.transformSession(s));
+    } catch (err) {
+      console.error("BugBear: Error fetching session history", err);
+      return [];
+    }
+  }
+  /**
+   * Add a finding during a session
+   */
+  async addFinding(sessionId, options) {
+    try {
+      const { data, error } = await this.supabase.rpc("add_session_finding", {
+        p_session_id: sessionId,
+        p_type: options.type,
+        p_title: options.title,
+        p_description: options.description || null,
+        p_severity: options.severity || "observation",
+        p_route: options.route || null,
+        p_screenshot_url: options.screenshotUrl || null,
+        p_console_logs: options.consoleLogs || null,
+        p_network_snapshot: options.networkSnapshot || null,
+        p_device_info: options.deviceInfo || null,
+        p_app_context: options.appContext || null
+      });
+      if (error) {
+        console.error("BugBear: Failed to add finding", error);
+        return { success: false, error: error.message };
+      }
+      const finding = this.transformFinding(data);
+      return { success: true, finding };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error adding finding", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Get findings for a session
+   */
+  async getSessionFindings(sessionId) {
+    try {
+      const { data, error } = await this.supabase.from("qa_findings").select("*").eq("session_id", sessionId).order("created_at", { ascending: true });
+      if (error) {
+        console.error("BugBear: Failed to fetch findings", error);
+        return [];
+      }
+      return (data || []).map((f) => this.transformFinding(f));
+    } catch (err) {
+      console.error("BugBear: Error fetching findings", err);
+      return [];
+    }
+  }
+  /**
+   * Convert a finding to a bug report
+   */
+  async convertFindingToBug(findingId) {
+    try {
+      const { data, error } = await this.supabase.rpc("convert_finding_to_bug", {
+        p_finding_id: findingId
+      });
+      if (error) {
+        console.error("BugBear: Failed to convert finding", error);
+        return { success: false, error: error.message };
+      }
+      return { success: true, bugId: data };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error converting finding", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Dismiss a finding
+   */
+  async dismissFinding(findingId, reason) {
+    try {
+      const { error } = await this.supabase.from("qa_findings").update({
+        dismissed: true,
+        dismissed_reason: reason || null,
+        dismissed_at: (/* @__PURE__ */ new Date()).toISOString()
+      }).eq("id", findingId);
+      if (error) {
+        console.error("BugBear: Failed to dismiss finding", error);
+        return { success: false, error: error.message };
+      }
+      return { success: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error dismissing finding", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Transform database session to QASession type
+   */
+  transformSession(data) {
+    return {
+      id: data.id,
+      projectId: data.project_id,
+      testerId: data.tester_id,
+      focusArea: data.focus_area,
+      track: data.track,
+      platform: data.platform,
+      startedAt: data.started_at,
+      endedAt: data.ended_at,
+      notes: data.notes,
+      routesCovered: data.routes_covered || [],
+      status: data.status,
+      durationMinutes: data.duration_minutes,
+      findingsCount: data.findings_count || 0,
+      bugsFiled: data.bugs_filed || 0,
+      createdAt: data.created_at,
+      updatedAt: data.updated_at
+    };
+  }
+  /**
+   * Transform database finding to QAFinding type
+   */
+  transformFinding(data) {
+    return {
+      id: data.id,
+      sessionId: data.session_id,
+      projectId: data.project_id,
+      type: data.type,
+      severity: data.severity,
+      title: data.title,
+      description: data.description,
+      route: data.route,
+      screenshotUrl: data.screenshot_url,
+      consoleLogs: data.console_logs,
+      networkSnapshot: data.network_snapshot,
+      deviceInfo: data.device_info,
+      appContext: data.app_context,
+      convertedToBugId: data.converted_to_bug_id,
+      convertedToTestId: data.converted_to_test_id,
+      dismissed: data.dismissed || false,
+      dismissedReason: data.dismissed_reason,
+      dismissedAt: data.dismissed_at,
+      createdAt: data.created_at,
+      updatedAt: data.updated_at
+    };
+  }
 };
 function createBugBear(config) {
   return new BugBearClient(config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bbearai/core",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Core utilities and types for BugBear QA platform",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",