- {qa.sources.map((source, sourceIndex) => {
+ {uniqueSources.map((source, sourceIndex) => {
const isPolicy = source.sourceType === 'policy' && source.sourceId;
+ const isKnowledgeBaseDocument =
+ source.sourceType === 'knowledge_base_document' && source.sourceId;
const sourceContent = source.sourceName || source.sourceType;
return (
@@ -187,6 +234,13 @@ export function QuestionnaireResultsTable({
{sourceContent}
+ ) : isKnowledgeBaseDocument && source.sourceId ? (
+
) : (
{sourceContent}
)}
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/components/SecurityQuestionnaireBreadcrumb.tsx b/apps/app/src/app/(app)/[orgId]/security-questionnaire/components/SecurityQuestionnaireBreadcrumb.tsx
new file mode 100644
index 000000000..3ae039ce4
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/components/SecurityQuestionnaireBreadcrumb.tsx
@@ -0,0 +1,19 @@
+'use client';
+
+import { FileQuestion } from 'lucide-react';
+
+export function SecurityQuestionnaireBreadcrumb() {
+ return (
+
+ );
+}
+
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/components/types.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/components/types.ts
index 34e37f3c5..e08acb40b 100644
--- a/apps/app/src/app/(app)/[orgId]/security-questionnaire/components/types.ts
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/components/types.ts
@@ -6,8 +6,10 @@ export interface QuestionAnswer {
sourceName?: string;
sourceId?: string;
policyName?: string;
+ documentName?: string;
score: number;
}>;
failedToGenerate?: boolean; // Track if auto-generation was attempted but failed
+ status?: 'untouched' | 'generated' | 'manual'; // Track answer source: untouched, AI-generated, or manually edited
}
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/usePersistGeneratedAnswers.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/usePersistGeneratedAnswers.ts
new file mode 100644
index 000000000..541796671
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/usePersistGeneratedAnswers.ts
@@ -0,0 +1,324 @@
+"use client";
+
+import { type Dispatch, type SetStateAction, useEffect, useRef } from 'react';
+import type { QuestionAnswer } from '../components/types';
+
+type PersistedQuestionAnswer = QuestionAnswer & {
+ originalIndex?: number;
+ questionAnswerId?: string;
+ status?: 'untouched' | 'generated' | 'manual';
+};
+
+type UpdateAnswerAction = {
+ execute: (...args: any[]) => unknown;
+ executeAsync: (...args: any[]) => Promise;
+};
+
+interface UsePersistGeneratedAnswersParams {
+ questionnaireId: string | null;
+ results: TResults;
+ setResults: Dispatch>;
+ autoAnswerRun: {
+ metadata?: Record;
+ status?: string;
+ output?: unknown;
+ } | null;
+ updateAnswerAction: UpdateAnswerAction;
+ setQuestionStatuses: React.Dispatch<
+ React.SetStateAction>
+ >;
+}
+
+export function usePersistGeneratedAnswers({
+ questionnaireId,
+ results,
+ setResults,
+ autoAnswerRun,
+ updateAnswerAction,
+ setQuestionStatuses,
+}: UsePersistGeneratedAnswersParams) {
+ const processedMetadataAnswersRef = useRef>(new Set());
+ const pendingMetadataUpdatesRef = useRef<
+ Map
+ >(new Map());
+ const metadataUpdateTimeoutRef = useRef(null);
+ const updateQueueRef = useRef>(Promise.resolve());
+ const resultsRef = useRef(results ?? []);
+ const previousResultsRef = useRef(results ?? []);
+ const processedResultsRef = useRef>(new Set());
+ const resultsUpdateTimeoutRef = useRef(null);
+ const pendingResultsUpdatesRef = useRef<
+ Map
+ >(new Map());
+ const pendingUpdatesWaitingForIdRef = useRef<
+ Map
+ >(new Map());
+
+ useEffect(() => {
+ resultsRef.current = results ?? [];
+ }, [results]);
+
+ useEffect(() => {
+ previousResultsRef.current = results ?? [];
+ }, [results]);
+
+ useEffect(() => {
+ return () => {
+ if (metadataUpdateTimeoutRef.current) {
+ clearTimeout(metadataUpdateTimeoutRef.current);
+ }
+ if (resultsUpdateTimeoutRef.current) {
+ clearTimeout(resultsUpdateTimeoutRef.current);
+ }
+ };
+ }, []);
+
+ const enqueueUpdate = (
+ key: string,
+ payload: { questionAnswerId: string; answer: string; sources?: any[] },
+ onError: () => void,
+ ) => {
+ if (!questionnaireId) {
+ return;
+ }
+
+ updateQueueRef.current = updateQueueRef.current
+ .catch(() => {
+ // Swallow previous error to keep queue progressing
+ })
+ .then(async () => {
+ try {
+ await updateAnswerAction.executeAsync({
+ questionnaireId,
+ questionAnswerId: payload.questionAnswerId,
+ answer: payload.answer,
+ sources: payload.sources,
+ status: 'generated',
+ });
+ console.log('Successfully updated answer in database:', {
+ questionAnswerId: payload.questionAnswerId,
+ });
+ } catch (error) {
+ console.error('Failed to update answer in database', error);
+ onError();
+ }
+
+ await new Promise((resolve) => setTimeout(resolve, 200));
+ });
+ };
+
+ useEffect(() => {
+ if (!questionnaireId || !resultsRef.current.length || !autoAnswerRun?.metadata) {
+ return;
+ }
+
+ const meta = autoAnswerRun.metadata as Record;
+ const answerKeys = Object.keys(meta).filter((key) => key.startsWith('answer_'));
+
+ answerKeys.forEach((key) => {
+ if (processedMetadataAnswersRef.current.has(key)) {
+ return;
+ }
+
+ const answerData = meta[key] as {
+ questionIndex?: number;
+ answer?: string | null;
+ sources?: any[];
+ };
+
+ if (!answerData || answerData.questionIndex === undefined || !answerData.answer) {
+ return;
+ }
+
+ const resultMatch = resultsRef.current.find((r) => r.originalIndex === answerData.questionIndex);
+
+ if (!resultMatch?.questionAnswerId) {
+ pendingUpdatesWaitingForIdRef.current.set(answerData.questionIndex, {
+ answer: answerData.answer || '',
+ sources: answerData.sources,
+ });
+ return;
+ }
+
+ processedMetadataAnswersRef.current.add(key);
+ pendingMetadataUpdatesRef.current.set(key, {
+ questionAnswerId: resultMatch.questionAnswerId,
+ answer: answerData.answer || '',
+ sources: answerData.sources,
+ });
+ });
+
+ if (metadataUpdateTimeoutRef.current) {
+ clearTimeout(metadataUpdateTimeoutRef.current);
+ }
+
+ metadataUpdateTimeoutRef.current = setTimeout(() => {
+ const updates = Array.from(pendingMetadataUpdatesRef.current.entries());
+ pendingMetadataUpdatesRef.current.clear();
+
+ updates.forEach(([key, update]) => {
+ enqueueUpdate(key, update, () => {
+ processedMetadataAnswersRef.current.delete(key);
+ });
+ });
+ }, 500);
+ }, [autoAnswerRun?.metadata, questionnaireId]);
+
+ useEffect(() => {
+ if (!questionnaireId || !results?.length) {
+ return;
+ }
+
+ results.forEach((result) => {
+ if (result.originalIndex == null) return;
+
+ const pendingForIndex = pendingUpdatesWaitingForIdRef.current.get(result.originalIndex);
+
+ if (pendingForIndex && result.questionAnswerId) {
+ const answerKey = `${result.questionAnswerId}-${result.originalIndex}`;
+ if (!processedResultsRef.current.has(answerKey)) {
+ processedResultsRef.current.add(answerKey);
+ pendingResultsUpdatesRef.current.set(answerKey, {
+ questionAnswerId: result.questionAnswerId,
+ answer: pendingForIndex.answer,
+ sources: pendingForIndex.sources,
+ });
+ }
+ pendingUpdatesWaitingForIdRef.current.delete(result.originalIndex);
+ }
+
+ if (!result.questionAnswerId) return;
+
+ const prevResult = previousResultsRef.current.find((r) => r.originalIndex === result.originalIndex);
+ const answerKey = `${result.questionAnswerId}-${result.originalIndex}`;
+
+ if (processedResultsRef.current.has(answerKey)) {
+ return;
+ }
+
+ if (
+ result.answer &&
+ result.answer.trim().length > 0 &&
+ result.status !== 'manual' &&
+ (!prevResult || prevResult.answer !== result.answer)
+ ) {
+ processedResultsRef.current.add(answerKey);
+ pendingResultsUpdatesRef.current.set(answerKey, {
+ questionAnswerId: result.questionAnswerId,
+ answer: result.answer,
+ sources: result.sources,
+ });
+ }
+ });
+
+ if (resultsUpdateTimeoutRef.current) {
+ clearTimeout(resultsUpdateTimeoutRef.current);
+ }
+
+ resultsUpdateTimeoutRef.current = setTimeout(() => {
+ const updates = Array.from(pendingResultsUpdatesRef.current.entries());
+ pendingResultsUpdatesRef.current.clear();
+
+ updates.forEach(([answerKey, update]) => {
+ enqueueUpdate(answerKey, update, () => {
+ processedResultsRef.current.delete(answerKey);
+ });
+ });
+ }, 500);
+ }, [questionnaireId, results]);
+
+ useEffect(() => {
+ if (!autoAnswerRun?.metadata || !resultsRef.current.length) {
+ return;
+ }
+
+ const meta = autoAnswerRun.metadata as Record;
+ const answerKeys = Object.keys(meta).filter((key) => key.startsWith('answer_'));
+
+ if (!answerKeys.length) {
+ return;
+ }
+
+ const answers = answerKeys
+ .map((key) => {
+ const answer = meta[key] as {
+ questionIndex: number;
+ question: string;
+ answer: string | null;
+ sources?: Array<{
+ sourceType: string;
+ sourceName?: string;
+ score: number;
+ }>;
+ };
+ return answer;
+ })
+ .filter((answer): answer is NonNullable => Boolean(answer))
+ .sort((a, b) => a.questionIndex - b.questionIndex);
+
+ if (!answers.length) {
+ return;
+ }
+
+ setResults((prevResults) => {
+ if (!prevResults) {
+ return prevResults;
+ }
+
+ const updatedResults = [...prevResults];
+ let hasChanges = false;
+
+ answers.forEach((answer) => {
+ const targetIndex = updatedResults.findIndex(
+ (r) => r.originalIndex === answer.questionIndex,
+ );
+
+ if (targetIndex < 0 || targetIndex >= updatedResults.length) {
+ return;
+ }
+
+ const currentAnswer = updatedResults[targetIndex]?.answer;
+ const originalQuestion = updatedResults[targetIndex]?.question;
+
+ if (answer.answer) {
+ if (currentAnswer !== answer.answer) {
+ updatedResults[targetIndex] = {
+ ...updatedResults[targetIndex],
+ question: originalQuestion || answer.question,
+ answer: answer.answer,
+ sources: answer.sources,
+ failedToGenerate: false,
+ status:
+ updatedResults[targetIndex]?.status === 'manual'
+ ? 'manual'
+ : 'generated',
+ };
+ hasChanges = true;
+
+ const statusKey = updatedResults[targetIndex]?.originalIndex ?? targetIndex;
+ setQuestionStatuses((prevStatuses) => {
+ const newStatuses = new Map(prevStatuses);
+ if (prevStatuses.get(statusKey) !== 'completed') {
+ newStatuses.set(statusKey, 'completed');
+ return newStatuses;
+ }
+ return prevStatuses;
+ });
+ }
+ } else if (!currentAnswer) {
+ updatedResults[targetIndex] = {
+ ...updatedResults[targetIndex],
+ question: originalQuestion || answer.question,
+ answer: null,
+ failedToGenerate: true,
+ };
+ hasChanges = true;
+ }
+ });
+
+ return (hasChanges ? updatedResults : prevResults) as TResults;
+ });
+ }, [autoAnswerRun?.metadata, setQuestionStatuses, setResults]);
+}
+
+
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireActions.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireActions.ts
index 3ac27bb25..d093b8078 100644
--- a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireActions.ts
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireActions.ts
@@ -1,10 +1,11 @@
'use client';
import { useAction } from 'next-safe-action/hooks';
-import { useCallback } from 'react';
+import { useCallback, useTransition } from 'react';
import type { FileRejection } from 'react-dropzone';
import { toast } from 'sonner';
import { exportQuestionnaire } from '../actions/export-questionnaire';
+import { saveAnswerAction } from '../actions/save-answer';
import type { QuestionAnswer } from '../components/types';
interface UseQuestionnaireActionsProps {
@@ -13,6 +14,7 @@ interface UseQuestionnaireActionsProps {
results: QuestionAnswer[] | null;
editingAnswer: string;
expandedSources: Set;
+ questionnaireId: string | null;
setSelectedFile: (file: File | null) => void;
setEditingIndex: (index: number | null) => void;
setEditingAnswer: (answer: string) => void;
@@ -56,6 +58,7 @@ export function useQuestionnaireActions({
results,
editingAnswer,
expandedSources,
+ questionnaireId,
setSelectedFile,
setEditingIndex,
setEditingAnswer,
@@ -75,6 +78,18 @@ export function useQuestionnaireActions({
triggerAutoAnswer,
triggerSingleAnswer,
}: UseQuestionnaireActionsProps) {
+ const saveAnswer = useAction(saveAnswerAction, {
+ onSuccess: () => {
+ // Answer saved successfully
+ },
+ onError: ({ error }) => {
+ console.error('Error saving answer:', error);
+ // Don't show toast for every save - too noisy
+ },
+ });
+
+ const [isPending, startTransition] = useTransition();
+
const exportAction = useAction(exportQuestionnaire, {
onSuccess: ({ data }: { data: any }) => {
const responseData = data?.data || data;
@@ -215,16 +230,28 @@ export function useQuestionnaireActions({
};
const handleSaveAnswer = (index: number) => {
- if (!results) return;
+ if (!results || !questionnaireId) return;
const updated = [...results];
+ const answerText = editingAnswer.trim() || null;
updated[index] = {
...updated[index],
- answer: editingAnswer.trim() || null,
+ answer: answerText,
failedToGenerate: false,
};
setResults(updated);
setEditingIndex(null);
setEditingAnswer('');
+
+ // Save to database (use startTransition to avoid rendering issues)
+ startTransition(() => {
+ saveAnswer.execute({
+ questionnaireId,
+ questionIndex: index,
+ answer: answerText,
+ status: 'manual',
+ });
+ });
+
toast.success('Answer updated');
};
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireAutoAnswer.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireAutoAnswer.ts
index 00e2e4e65..374f9c182 100644
--- a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireAutoAnswer.ts
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireAutoAnswer.ts
@@ -2,8 +2,11 @@
import { useRealtimeTaskTrigger } from '@trigger.dev/react-hooks';
import type { vendorQuestionnaireOrchestratorTask } from '@/jobs/tasks/vendors/vendor-questionnaire-orchestrator';
-import { useEffect, useMemo, useRef } from 'react';
+import { useEffect, useMemo, useRef, useTransition } from 'react';
import { toast } from 'sonner';
+import { useAction } from 'next-safe-action/hooks';
+import { saveAnswerAction } from '../actions/save-answer';
+import { saveAnswersBatchAction } from '../actions/save-answers-batch';
import type { QuestionAnswer } from '../components/types';
interface UseQuestionnaireAutoAnswerProps {
@@ -18,6 +21,7 @@ interface UseQuestionnaireAutoAnswerProps {
React.SetStateAction>
>;
setAnsweringQuestionIndex: (index: number | null) => void;
+ questionnaireId: string | null;
}
export function useQuestionnaireAutoAnswer({
@@ -30,6 +34,7 @@ export function useQuestionnaireAutoAnswer({
setResults,
setQuestionStatuses,
setAnsweringQuestionIndex,
+ questionnaireId,
}: UseQuestionnaireAutoAnswerProps) {
// Use realtime task trigger for auto-answer
const {
@@ -42,10 +47,46 @@ export function useQuestionnaireAutoAnswer({
enabled: !!autoAnswerToken,
});
+ // Action for saving answers batch
+ const saveAnswersBatch = useAction(saveAnswersBatchAction, {
+ onError: ({ error }) => {
+ console.error('Error saving answers batch:', error);
+ },
+ });
+
+ const [isPending, startTransition] = useTransition();
+
+ // Debug logging for run tracking
+ useEffect(() => {
+ console.log('[AutoAnswer] Hook state:', {
+ hasToken: !!autoAnswerToken,
+ hasRun: !!autoAnswerRun,
+ runId: autoAnswerRun?.id,
+ runStatus: autoAnswerRun?.status,
+ hasMetadata: !!autoAnswerRun?.metadata,
+ metadataKeys: autoAnswerRun?.metadata ? Object.keys(autoAnswerRun.metadata as Record).length : 0,
+ isTriggering: isAutoAnswerTriggering,
+ hasError: !!autoAnswerError,
+ });
+
+ if (autoAnswerRun?.metadata) {
+ const meta = autoAnswerRun.metadata as Record;
+ const answerKeys = Object.keys(meta).filter((key) => key.startsWith('answer_'));
+ const statusKeys = Object.keys(meta).filter((key) => key.startsWith('question_') && key.endsWith('_status'));
+ console.log('[AutoAnswer] Metadata keys:', {
+ answerKeys,
+ statusKeys,
+ allKeys: Object.keys(meta).slice(0, 20), // First 20 keys for debugging
+ });
+ }
+ }, [autoAnswerToken, autoAnswerRun?.id, autoAnswerRun?.status, autoAnswerRun?.metadata, isAutoAnswerTriggering, autoAnswerError]);
+
// Track processed metadata to avoid infinite loops
const processedMetadataRef = useRef('');
// Track which run ID we're currently processing for single questions
const currentRunIdRef = useRef(null);
+ // Track which run IDs we've already processed completion for (to prevent infinite loops)
+ const processedCompletionRef = useRef>(new Set());
// Use ref to access latest results without causing dependency issues
const resultsRef = useRef(results);
useEffect(() => {
@@ -67,7 +108,15 @@ export function useQuestionnaireAutoAnswer({
useEffect(() => {
// Read individual answers and statuses from metadata keys
// Each answer-question task updates parent metadata when it starts and completes
- if (!autoAnswerRun?.metadata || !resultsRef.current) return;
+ if (!autoAnswerRun?.metadata || !resultsRef.current) {
+ if (autoAnswerRun && !autoAnswerRun.metadata) {
+ console.log('[AutoAnswer] Run exists but no metadata yet', {
+ runId: autoAnswerRun.id,
+ status: autoAnswerRun.status,
+ });
+ }
+ return;
+ }
// For single question operations, only process metadata from the current run
// This prevents metadata from previous runs (like "Auto Answer All") from interfering
@@ -84,10 +133,25 @@ export function useQuestionnaireAutoAnswer({
const answerKeys = Object.keys(meta).filter((key) => key.startsWith('answer_')).sort();
const statusKeys = Object.keys(meta).filter((key) => key.startsWith('question_') && key.endsWith('_status')).sort();
+ // Debug logging
+ if (answerKeys.length > 0) {
+ console.log('[AutoAnswer] Found answer keys in metadata:', {
+ answerKeys,
+ answerCount: answerKeys.length,
+ runId: autoAnswerRun.id,
+ status: autoAnswerRun.status,
+ });
+ }
+
// Build hash from actual values, not just keys
const answerValues = answerKeys.map((key) => {
const answer = meta[key] as { questionIndex?: number; answer?: string | null } | undefined;
- return answer ? `${answer.questionIndex}:${answer.answer ? 'has-answer' : 'no-answer'}` : null;
+ if (answer) {
+ const value = `${answer.questionIndex}:${answer.answer ? 'has-answer' : 'no-answer'}`;
+ console.log('[AutoAnswer] Answer value for hash:', { key, value, answerData: answer });
+ return value;
+ }
+ return null;
}).filter(Boolean);
const statusValues = statusKeys.map((key) => {
@@ -103,7 +167,15 @@ export function useQuestionnaireAutoAnswer({
});
// Skip if we've already processed this exact metadata state
- if (processedMetadataRef.current === metadataHash) return;
+ if (processedMetadataRef.current === metadataHash) {
+ console.log('[AutoAnswer] Skipping duplicate metadata hash');
+ return;
+ }
+ console.log('[AutoAnswer] Processing new metadata:', {
+ hash: metadataHash.substring(0, 100),
+ answerKeysCount: answerKeys.length,
+ statusKeysCount: statusKeys.length,
+ });
processedMetadataRef.current = metadataHash;
const isSingleQuestion = answeringQuestionIndex !== null;
@@ -149,24 +221,62 @@ export function useQuestionnaireAutoAnswer({
if (answerKeys.length > 0) {
const answers = answerKeys
.map((key) => {
- const answerData = meta[key] as {
- questionIndex: number;
- question: string;
- answer: string | null;
+ const rawValue = meta[key];
+
+ // Handle case where metadata value might be a string (shouldn't happen, but be defensive)
+ if (typeof rawValue === 'string') {
+ console.warn('[AutoAnswer] Unexpected string value in metadata:', { key, value: rawValue });
+ return undefined;
+ }
+
+ // Handle case where metadata value is null or undefined
+ if (!rawValue || typeof rawValue !== 'object') {
+ console.warn('[AutoAnswer] Invalid metadata value:', { key, value: rawValue, type: typeof rawValue });
+ return undefined;
+ }
+
+ const answerData = rawValue as {
+ questionIndex?: number;
+ question?: string;
+ answer?: string | null;
sources?: Array<{
sourceType: string;
sourceName?: string;
score: number;
}>;
- } | undefined;
- return answerData;
+ };
+
+ // Validate that answerData has required fields
+ if (typeof answerData.questionIndex !== 'number') {
+ console.warn('[AutoAnswer] Missing questionIndex in answer data:', { key, answerData });
+ return undefined;
+ }
+
+ return {
+ questionIndex: answerData.questionIndex,
+ question: answerData.question || '',
+ answer: answerData.answer ?? null,
+ sources: answerData.sources || [],
+ };
})
.filter((answer): answer is NonNullable => answer !== undefined)
.sort((a, b) => a.questionIndex - b.questionIndex);
if (answers.length > 0) {
+ console.log('[AutoAnswer] Processing answers:', {
+ answersCount: answers.length,
+ answers: answers.map((a) => ({
+ questionIndex: a.questionIndex,
+ hasAnswer: !!a.answer,
+ answerLength: a.answer?.length || 0,
+ })),
+ });
+
setResults((prevResults) => {
- if (!prevResults) return prevResults;
+ if (!prevResults) {
+ console.warn('[AutoAnswer] No previous results to update');
+ return prevResults;
+ }
const updatedResults = [...prevResults];
let hasChanges = false;
@@ -186,7 +296,7 @@ export function useQuestionnaireAutoAnswer({
// For single question operations, double-check the index matches
if (isSingleQuestion && answeringQuestionIndex !== null) {
if (targetIndex !== answeringQuestionIndex) {
- console.warn('Index mismatch in single question update:', {
+ console.warn('[AutoAnswer] Index mismatch in single question update:', {
targetIndex,
answeringQuestionIndex,
answerQuestionIndex: answer.questionIndex,
@@ -197,7 +307,7 @@ export function useQuestionnaireAutoAnswer({
// Safety check: ensure targetIndex is valid
if (targetIndex < 0 || targetIndex >= updatedResults.length) {
- console.warn('Invalid questionIndex in answer update:', {
+ console.warn('[AutoAnswer] Invalid questionIndex in answer update:', {
targetIndex,
resultsLength: updatedResults.length,
answerQuestionIndex: answer.questionIndex,
@@ -208,6 +318,13 @@ export function useQuestionnaireAutoAnswer({
const currentAnswer = updatedResults[targetIndex]?.answer;
const originalQuestion = updatedResults[targetIndex]?.question;
+ console.log('[AutoAnswer] Updating answer:', {
+ targetIndex,
+ currentAnswer: currentAnswer ? `${currentAnswer.substring(0, 50)}...` : null,
+ newAnswer: answer.answer ? `${answer.answer.substring(0, 50)}...` : null,
+ hasAnswer: !!answer.answer,
+ });
+
// Verify we're updating the correct question by checking question text matches
// This is an extra safety check to prevent updating wrong questions
if (originalQuestion && answer.question) {
@@ -215,7 +332,7 @@ export function useQuestionnaireAutoAnswer({
if (isSingleQuestion && answeringQuestionIndex !== null) {
const expectedQuestion = resultsRef.current?.[answeringQuestionIndex]?.question;
if (expectedQuestion && answer.question.trim() !== expectedQuestion.trim()) {
- console.warn('Question text mismatch in single question update:', {
+ console.warn('[AutoAnswer] Question text mismatch in single question update:', {
targetIndex,
answeringQuestionIndex,
expectedQuestion: expectedQuestion.substring(0, 50),
@@ -233,17 +350,22 @@ export function useQuestionnaireAutoAnswer({
if (answer.answer) {
if (currentAnswer !== answer.answer) {
+ console.log('[AutoAnswer] Setting answer for question', targetIndex);
updatedResults[targetIndex] = {
+ ...updatedResults[targetIndex], // Preserve status and other fields
question: originalQuestion || answer.question, // Preserve original question text
answer: answer.answer,
sources: answer.sources,
failedToGenerate: false,
};
hasChanges = true;
+ } else {
+ console.log('[AutoAnswer] Answer unchanged for question', targetIndex);
}
} else {
// Only update if answer is still null (don't overwrite existing answers)
if (!currentAnswer) {
+ console.log('[AutoAnswer] Marking question as failed to generate', targetIndex);
updatedResults[targetIndex] = {
...updatedResults[targetIndex],
question: originalQuestion || answer.question, // Preserve original question text
@@ -255,21 +377,36 @@ export function useQuestionnaireAutoAnswer({
}
});
+ if (hasChanges) {
+ console.log('[AutoAnswer] Results updated successfully');
+ } else {
+ console.log('[AutoAnswer] No changes detected in results');
+ }
+
return hasChanges ? updatedResults : prevResults;
});
+ } else {
+ console.log('[AutoAnswer] No answers found to process');
}
}
}, [
autoAnswerRun?.metadata,
answeringQuestionIndex,
+ questionnaireId,
+ saveAnswersBatch,
// Don't include results, setResults, setQuestionStatuses, setAnsweringQuestionIndex in deps
// results is only used for existence check, setState functions are stable
]);
- // Handle final completion (for toast notifications and cleanup only)
- // UI updates are handled by the metadata watcher above
+ // Handle final completion - read ALL answers from final output
+ // This is the primary source of truth since metadata may not be reliable
useEffect(() => {
- if (autoAnswerRun?.status === 'COMPLETED' && autoAnswerRun.output) {
+ if (
+ autoAnswerRun?.status === 'COMPLETED' &&
+ autoAnswerRun.output &&
+ autoAnswerRun.id &&
+ !processedCompletionRef.current.has(autoAnswerRun.id)
+ ) {
const answers = autoAnswerRun.output.answers as
| Array<{
questionIndex: number;
@@ -284,44 +421,134 @@ export function useQuestionnaireAutoAnswer({
| undefined;
if (answers && Array.isArray(answers)) {
- const isSingleQuestion = answeringQuestionIndex !== null;
+ // Mark this run as processed to prevent infinite loops
+ processedCompletionRef.current.add(autoAnswerRun.id);
- // Mark all remaining "processing" questions as "completed" when orchestrator finishes
- // This fixes the issue where some questions stay stuck in "Generating answer..." state
- // For single question operations, only mark that specific question as completed
- if (results) {
- setQuestionStatuses((prev) => {
- const newStatuses = new Map(prev);
- if (isSingleQuestion && answeringQuestionIndex !== null) {
- // Single question: only mark that question as completed
- const currentStatus = prev.get(answeringQuestionIndex);
- if (currentStatus === 'processing') {
- newStatuses.set(answeringQuestionIndex, 'completed');
- }
- } else {
- // Batch operation: mark all processing questions as completed
- results.forEach((qa, index) => {
- const currentStatus = prev.get(index);
- if (currentStatus === 'processing') {
- newStatuses.set(index, 'completed');
- }
+ console.log('[AutoAnswer] Task completed, updating ALL answers from final output:', {
+ answersCount: answers.length,
+ answeredCount: answers.filter((a) => a.answer).length,
+ runId: autoAnswerRun.id,
+ });
+
+ // Update results from final output - merge new answers with existing ones
+ // The orchestrator only returns answers for questions it processed (unanswered ones)
+ // So we merge them with existing answers
+ setResults((prevResults) => {
+ if (!prevResults) return prevResults;
+
+ const updatedResults = [...prevResults];
+ let hasChanges = false;
+
+ // Create a map of new answers by questionIndex for quick lookup
+ const newAnswersMap = new Map(
+ answers.map((answer) => [answer.questionIndex, answer])
+ );
+
+ // Update only the questions that were processed (have new answers)
+ newAnswersMap.forEach((answer, targetIndex) => {
+ // Safety check: ensure targetIndex is valid
+ if (targetIndex < 0 || targetIndex >= updatedResults.length) {
+ console.warn('[AutoAnswer] Invalid questionIndex in final output:', {
+ targetIndex,
+ resultsLength: updatedResults.length,
});
+ return;
+ }
+
+ const originalQuestion = updatedResults[targetIndex]?.question;
+ const currentAnswer = updatedResults[targetIndex]?.answer;
+
+ // Update with new answer from orchestrator
+ if (answer.answer) {
+ // Only update if answer changed
+ if (currentAnswer !== answer.answer) {
+ updatedResults[targetIndex] = {
+ ...updatedResults[targetIndex], // Preserve status and other fields
+ question: originalQuestion || answer.question,
+ answer: answer.answer,
+ sources: answer.sources,
+ failedToGenerate: false,
+ };
+ hasChanges = true;
+ }
+ } else {
+ // Mark as failed if no answer was generated (only if it wasn't already answered)
+ if (!currentAnswer) {
+ updatedResults[targetIndex] = {
+ ...updatedResults[targetIndex],
+ question: originalQuestion || answer.question,
+ answer: null,
+ failedToGenerate: true,
+ };
+ hasChanges = true;
+ }
}
- return newStatuses;
});
+
+ return hasChanges ? updatedResults : prevResults;
+ });
+
+ // Save all answers in batch after final output (defer to avoid rendering issues)
+ if (questionnaireId) {
+ const answersToSave = answers
+ .map((answer) => {
+ if (answer.answer) {
+ return {
+ questionIndex: answer.questionIndex,
+ answer: answer.answer,
+ sources: answer.sources,
+ status: 'generated' as const,
+ };
+ }
+ return null;
+ })
+ .filter((a): a is NonNullable => a !== null);
+
+ if (answersToSave.length > 0) {
+ // Use startTransition to defer the save call to avoid rendering issues
+ startTransition(() => {
+ saveAnswersBatch.execute({
+ questionnaireId,
+ answers: answersToSave,
+ });
+ });
+ }
}
- // Cleanup: mark process as finished
+ const isSingleQuestion = answeringQuestionIndex !== null;
+
+ // Mark all remaining "processing" questions as "completed" when orchestrator finishes
+ setQuestionStatuses((prev) => {
+ const newStatuses = new Map(prev);
+ if (isSingleQuestion && answeringQuestionIndex !== null) {
+ // Single question: only mark that question as completed
+ const currentStatus = prev.get(answeringQuestionIndex);
+ if (currentStatus === 'processing') {
+ newStatuses.set(answeringQuestionIndex, 'completed');
+ }
+ } else {
+ // Batch operation: mark all processing questions as completed
+ answers.forEach((answer) => {
+ const currentStatus = prev.get(answer.questionIndex);
+ if (currentStatus === 'processing') {
+ newStatuses.set(answer.questionIndex, 'completed');
+ }
+ });
+ }
+ return newStatuses;
+ });
+
+ // Cleanup: mark process as finished
if (!isSingleQuestion) {
isAutoAnswerProcessStartedRef.current = false;
setIsAutoAnswerProcessStarted(false);
}
- // Reset answering index and run ID for single questions
- if (isSingleQuestion) {
- setAnsweringQuestionIndex(null);
- currentRunIdRef.current = null; // Clear run ID when operation completes
- }
+ // Reset answering index and run ID for single questions
+ if (isSingleQuestion) {
+ setAnsweringQuestionIndex(null);
+ currentRunIdRef.current = null;
+ }
// Show final toast notification
const totalQuestions = answers.length;
@@ -350,8 +577,10 @@ export function useQuestionnaireAutoAnswer({
}, [
autoAnswerRun?.status,
autoAnswerRun?.output,
+ autoAnswerRun?.id,
answeringQuestionIndex,
- results,
+ questionnaireId,
+ saveAnswersBatch,
setAnsweringQuestionIndex,
setQuestionStatuses,
setIsAutoAnswerProcessStarted,
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireDetail.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireDetail.ts
new file mode 100644
index 000000000..68927d0f6
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireDetail.ts
@@ -0,0 +1,529 @@
+'use client';
+
+import { useCallback, useEffect, useMemo, useRef, useState, type Dispatch, type SetStateAction } from 'react';
+import { useQuestionnaireActions } from './useQuestionnaireActions';
+import { useQuestionnaireAutoAnswer } from './useQuestionnaireAutoAnswer';
+import { useQuestionnaireSingleAnswer } from './useQuestionnaireSingleAnswer';
+import type { QuestionAnswer } from '../components/types';
+import { createTriggerToken } from '../actions/create-trigger-token';
+import { updateQuestionnaireAnswer } from '../actions/update-questionnaire-answer';
+import { deleteQuestionnaireAnswer } from '../actions/delete-questionnaire-answer';
+import { useAction } from 'next-safe-action/hooks';
+import { useRouter } from 'next/navigation';
+import { toast } from 'sonner';
+import { usePersistGeneratedAnswers } from './usePersistGeneratedAnswers';
+
+interface QuestionnaireQuestionAnswer {
+ id: string;
+ question: string;
+ answer: string | null;
+ status: 'untouched' | 'generated' | 'manual';
+ questionIndex: number;
+ sources: any;
+}
+
+type QuestionnaireResult = QuestionAnswer & {
+ originalIndex: number;
+ questionAnswerId: string;
+ status: 'untouched' | 'generated' | 'manual';
+};
+
+interface UseQuestionnaireDetailProps {
+ questionnaireId: string;
+ organizationId: string;
+ initialQuestions: QuestionnaireQuestionAnswer[];
+}
+
+export function useQuestionnaireDetail({
+ questionnaireId,
+ organizationId,
+ initialQuestions,
+}: UseQuestionnaireDetailProps) {
+ const router = useRouter();
+
+ // Initialize results from database
+ const [results, setResults] = useState(() =>
+ initialQuestions.map((q) => ({
+ question: q.question,
+ answer: q.answer ?? null, // Preserve null instead of converting to empty string
+ originalIndex: q.questionIndex,
+ sources: q.sources ? (Array.isArray(q.sources) ? q.sources : []) : [],
+ questionAnswerId: q.id,
+ status: q.status,
+ failedToGenerate: false, // Initialize failedToGenerate
+ }))
+ );
+
+ // State management (same as useQuestionnaireState)
+ const [editingIndex, setEditingIndex] = useState(null);
+ const [editingAnswer, setEditingAnswer] = useState('');
+ const [expandedSources, setExpandedSources] = useState>(new Set());
+ const [questionStatuses, setQuestionStatuses] = useState>(new Map());
+ const [answeringQuestionIndex, setAnsweringQuestionIndex] = useState(null);
+ const [isAutoAnswerProcessStarted, setIsAutoAnswerProcessStarted] = useState(false);
+ const [hasClickedAutoAnswer, setHasClickedAutoAnswer] = useState(false);
+ const [autoAnswerToken, setAutoAnswerToken] = useState(null);
+ const [singleAnswerToken, setSingleAnswerToken] = useState(null);
+ const [searchQuery, setSearchQuery] = useState('');
+ const isAutoAnswerProcessStartedRef = useRef(false);
+
+ // Refs to capture values for save callback
+ const saveIndexRef = useRef(null);
+ const saveAnswerRef = useRef('');
+
+ // Actions - use callbacks that reference the refs
+ const updateAnswerAction = useAction(updateQuestionnaireAnswer, {
+ onSuccess: () => {
+ // Only handle manual saves (when saveIndexRef is set)
+ if (saveIndexRef.current !== null) {
+ const index = saveIndexRef.current;
+ const answer = saveAnswerRef.current;
+
+ // Update local state optimistically
+ setResults((prev) =>
+ prev.map((r, i) => {
+ if (i === index) {
+ const trimmedAnswer = answer.trim();
+ // If answer is empty, reset failedToGenerate and allow auto-fill
+ // If answer has content, mark as manual
+ return {
+ ...r,
+ answer: trimmedAnswer || null,
+ status: trimmedAnswer ? ('manual' as const) : ('untouched' as const),
+ failedToGenerate: false, // Reset failedToGenerate when user saves (even if empty)
+ };
+ }
+ return r;
+ })
+ );
+
+ setEditingIndex(null);
+ setEditingAnswer('');
+ toast.success('Answer saved');
+ router.refresh();
+
+ // Reset refs
+ saveIndexRef.current = null;
+ saveAnswerRef.current = '';
+ }
+ },
+ onError: ({ error }) => {
+ console.error('Failed to update answer:', error);
+ if (saveIndexRef.current !== null) {
+ toast.error(`Failed to save answer: ${error instanceof Error ? error.message : 'Unknown error'}`);
+ saveIndexRef.current = null;
+ saveAnswerRef.current = '';
+ }
+ },
+ });
+ const deleteAnswerAction = useAction(deleteQuestionnaireAnswer);
+ // Note: We don't use orchestratorAction here - we use triggerAutoAnswer directly from useQuestionnaireAutoAnswer
+ // This ensures we get a trackable run via useRealtimeTaskTrigger
+
+ // Create trigger tokens
+ useEffect(() => {
+ const fetchTokens = async () => {
+ const [autoTokenResult, singleTokenResult] = await Promise.all([
+ createTriggerToken('vendor-questionnaire-orchestrator'),
+ createTriggerToken('answer-question'),
+ ]);
+
+ if (autoTokenResult.success && autoTokenResult.token) {
+ setAutoAnswerToken(autoTokenResult.token);
+ }
+ if (singleTokenResult.success && singleTokenResult.token) {
+ setSingleAnswerToken(singleTokenResult.token);
+ }
+ };
+
+ fetchTokens();
+ }, []);
+
+ // Auto-answer hook (same as useQuestionnaireParser)
+ const autoAnswer = useQuestionnaireAutoAnswer({
+ autoAnswerToken,
+ results: results as QuestionAnswer[] | null,
+ answeringQuestionIndex,
+ isAutoAnswerProcessStarted,
+ isAutoAnswerProcessStartedRef,
+ setIsAutoAnswerProcessStarted,
+ setResults: setResults as Dispatch>,
+ setQuestionStatuses,
+ setAnsweringQuestionIndex,
+ questionnaireId,
+ });
+
+ // Wrapper for setResults that handles QuestionnaireResult[] with originalIndex
+ const setResultsWrapper = useCallback((updater: React.SetStateAction) => {
+ setResults((prevResults) => {
+ if (!prevResults) {
+ const newResults = typeof updater === 'function' ? updater(null) : updater;
+ if (!newResults) return prevResults; // Return empty array instead of null
+ // Convert QuestionAnswer[] to QuestionnaireResult[]
+ return newResults.map((r, index) => ({
+ question: r.question,
+ answer: r.answer ?? null, // Preserve null instead of converting to empty string
+ originalIndex: index,
+ sources: r.sources || [],
+ questionAnswerId: '',
+ status: 'untouched' as const,
+ failedToGenerate: r.failedToGenerate ?? false, // Preserve failedToGenerate
+ }));
+ }
+
+ const questionAnswerResults = prevResults.map((r) => ({
+ question: r.question,
+ answer: r.answer,
+ sources: r.sources,
+ failedToGenerate: (r as any).failedToGenerate ?? false, // Preserve failedToGenerate from result
+ _originalIndex: r.originalIndex, // Preserve originalIndex
+ }));
+
+ const newResults = typeof updater === 'function'
+ ? updater(questionAnswerResults)
+ : updater;
+
+ if (!newResults) return prevResults; // Return previous results instead of null
+
+ // Map back to QuestionnaireResult[] preserving originalIndex
+ return newResults.map((newR, index) => {
+ const originalIndex = (newR as any)._originalIndex !== undefined
+ ? (newR as any)._originalIndex
+ : index;
+ const existingResult = prevResults.find((r) => r.originalIndex === originalIndex);
+ if (existingResult) {
+ return {
+ ...existingResult,
+ question: newR.question,
+ answer: newR.answer ?? null, // Preserve null instead of converting to empty string
+ sources: newR.sources,
+ failedToGenerate: newR.failedToGenerate ?? false, // Preserve failedToGenerate
+ };
+ }
+ // Fallback: create new result (shouldn't happen)
+ return {
+ question: newR.question,
+ answer: newR.answer ?? null, // Preserve null instead of converting to empty string
+ originalIndex,
+ sources: newR.sources || [],
+ questionAnswerId: '',
+ status: 'untouched' as const,
+ failedToGenerate: newR.failedToGenerate ?? false, // Preserve failedToGenerate
+ };
+ });
+ });
+ }, []);
+
+ // Single answer hook (same as useQuestionnaireParser)
+ const singleAnswer = useQuestionnaireSingleAnswer({
+ singleAnswerToken,
+ results: results.map((r) => ({
+ question: r.question,
+ answer: r.answer,
+ sources: r.sources,
+ failedToGenerate: (r as any).failedToGenerate ?? false, // Preserve failedToGenerate from result
+ _originalIndex: r.originalIndex, // Pass originalIndex for reference
+ })) as QuestionAnswer[],
+ answeringQuestionIndex,
+ setResults: setResultsWrapper,
+ setQuestionStatuses,
+ setAnsweringQuestionIndex,
+ questionnaireId,
+ });
+
+ // Expose isSingleAnswerTriggering for isLoading calculation
+ const isSingleAnswerTriggering = singleAnswer.isSingleAnswerTriggering;
+
+ // Reuse the same actions hook (but adapt it for detail page)
+ const actions = useQuestionnaireActions({
+ orgId: organizationId,
+ selectedFile: null,
+ results: results as QuestionAnswer[] | null,
+ editingAnswer,
+ expandedSources,
+ setSelectedFile: () => {},
+ setEditingIndex,
+ setEditingAnswer,
+ setResults: setResults as Dispatch>,
+ setExpandedSources,
+ setIsParseProcessStarted: () => {},
+ setIsAutoAnswerProcessStarted,
+ isAutoAnswerProcessStartedRef,
+ setHasClickedAutoAnswer,
+ answeringQuestionIndex,
+ setAnsweringQuestionIndex,
+ setQuestionStatuses,
+ questionnaireId,
+ setParseTaskId: () => {},
+ setParseToken: () => {},
+ uploadFileAction: { execute: async () => {}, status: 'idle' as const },
+ parseAction: { execute: async () => {}, status: 'idle' as const },
+ triggerAutoAnswer: autoAnswer.triggerAutoAnswer,
+ triggerSingleAnswer: singleAnswer.triggerSingleAnswer,
+ } as Parameters[0]);
+
+ const persistenceAction = {
+ execute: () => {},
+ executeAsync: (input: Parameters[0]) =>
+ updateAnswerAction.executeAsync(input),
+ };
+
+ usePersistGeneratedAnswers({
+ questionnaireId,
+ results: results as QuestionAnswer[] | null,
+ setResults: setResults as Dispatch>,
+ autoAnswerRun: autoAnswer.autoAnswerRun ?? null,
+ updateAnswerAction: persistenceAction as any,
+ setQuestionStatuses,
+ });
+
+ // Override handleAutoAnswer to include orchestrator call
+ const handleAutoAnswer = () => {
+ if (answeringQuestionIndex !== null) {
+ toast.warning('Please wait for the current question to finish before answering all questions');
+ return;
+ }
+
+ setHasClickedAutoAnswer(true);
+ setIsAutoAnswerProcessStarted(true);
+ isAutoAnswerProcessStartedRef.current = true;
+
+ // Filter out questions with manual answers
+ const questionsToAnswer = results
+ .filter((r) => r.status !== 'manual' && (!r.answer || r.answer.trim().length === 0))
+ .map((r) => ({
+ question: r.question,
+ answer: r.answer || null,
+ _originalIndex: r.originalIndex,
+ }));
+
+ if (questionsToAnswer.length === 0) {
+ toast.info('All questions already have answers');
+ setIsAutoAnswerProcessStarted(false);
+ isAutoAnswerProcessStartedRef.current = false;
+ return;
+ }
+
+ // Optimistic UI update: immediately show spinners for all unanswered questions
+ setQuestionStatuses((prev) => {
+ const newStatuses = new Map(prev);
+ questionsToAnswer.forEach((q) => {
+ if (q._originalIndex !== undefined) {
+ newStatuses.set(q._originalIndex, 'processing');
+ }
+ });
+ return newStatuses;
+ });
+
+ // Call triggerAutoAnswer directly - this will trigger the task AND give us a trackable run
+ // The useRealtimeTaskTrigger hook will handle the actual task triggering
+ try {
+ autoAnswer.triggerAutoAnswer({
+ vendorId: `org_${organizationId}`,
+ organizationId,
+ questionsAndAnswers: questionsToAnswer.map((q) => ({
+ question: q.question,
+ answer: q.answer,
+ _originalIndex: q._originalIndex, // Pass _originalIndex for orchestrator to use
+ })) as any,
+ });
+ console.log('Triggered auto-answer, run should be available soon');
+ } catch (error) {
+ console.error('Failed to trigger auto-answer:', error);
+ toast.error('Failed to start auto-answer process');
+ setIsAutoAnswerProcessStarted(false);
+ isAutoAnswerProcessStartedRef.current = false;
+ // Reset question statuses
+ setQuestionStatuses((prev) => {
+ const newStatuses = new Map(prev);
+ questionsToAnswer.forEach((q) => {
+ if (q._originalIndex !== undefined) {
+ newStatuses.delete(q._originalIndex);
+ }
+ });
+ return newStatuses;
+ });
+ }
+ };
+
+ // Override handleAnswerSingleQuestion to set processing status immediately
+ const handleAnswerSingleQuestion = (index: number) => {
+ if (isAutoAnswerProcessStarted || answeringQuestionIndex !== null) {
+ return;
+ }
+
+ const result = results.find((r) => r.originalIndex === index);
+ if (!result) {
+ return;
+ }
+
+ // Allow auto-fill even if status is 'manual' - user may have cleared the answer
+ // Only prevent if there's already an answer (non-empty)
+ if (result.status === 'manual' && result.answer && result.answer.trim().length > 0) {
+ return;
+ }
+
+ setAnsweringQuestionIndex(index);
+
+ // Set status to processing immediately to show spinner
+ setQuestionStatuses((prev) => {
+ const newStatuses = new Map(prev);
+ newStatuses.set(index, 'processing');
+ return newStatuses;
+ });
+
+ singleAnswer.triggerSingleAnswer({
+ question: result.question,
+ organizationId,
+ questionIndex: index,
+ totalQuestions: results.length,
+ });
+ };
+
+ // Handle delete manual answer
+ const handleDeleteAnswer = async (questionAnswerId: string, questionIndex: number) => {
+ try {
+ await deleteAnswerAction.execute({
+ questionnaireId,
+ questionAnswerId,
+ });
+
+ setResults((prev) =>
+ prev.map((r) =>
+ r.originalIndex === questionIndex
+ ? { ...r, answer: '', status: 'untouched' as const }
+ : r
+ )
+ );
+
+ toast.success('Answer deleted. You can now generate a new answer.');
+ router.refresh();
+ } catch (error) {
+ console.error('Failed to delete answer:', error);
+ toast.error('Failed to delete answer');
+ }
+ };
+
+ // Handle save answer (override to save to database)
+ const handleSaveAnswer = (index: number) => {
+ // The index passed is the array index from QuestionnaireResultsTable
+ // Find the result at that array position
+ const result = results[index];
+
+ if (!result) {
+ console.error('Cannot save answer: result not found at index', {
+ index,
+ resultsLength: results.length,
+ results: results.map((r, i) => ({ i, originalIndex: r.originalIndex, questionAnswerId: r.questionAnswerId }))
+ });
+ toast.error('Cannot find question to save');
+ return;
+ }
+
+ if (!result.questionAnswerId) {
+ console.error('Cannot save answer: questionAnswerId not found', { index, result });
+ toast.error('Cannot save answer: missing question ID');
+ return;
+ }
+
+ // Store values in refs for the callback
+ saveIndexRef.current = index;
+ saveAnswerRef.current = editingAnswer;
+
+ // Execute the save - callbacks will use the refs
+ updateAnswerAction.execute({
+ questionnaireId,
+ questionAnswerId: result.questionAnswerId,
+ answer: editingAnswer.trim(),
+ });
+ };
+
+ const filteredResults = useMemo(() => {
+ if (!searchQuery.trim()) return results;
+ const query = searchQuery.toLowerCase();
+ return results.filter(
+ (r) =>
+ r.question.toLowerCase().includes(query) ||
+ (r.answer && r.answer.toLowerCase().includes(query))
+ );
+ }, [results, searchQuery]);
+
+ const answeredCount = useMemo(() => {
+ return results.filter((r) => r.answer && r.answer.trim().length > 0).length;
+ }, [results]);
+
+ const progressPercentage = useMemo(() => {
+ if (results.length === 0) return 0;
+ return Math.round((answeredCount / results.length) * 100);
+ }, [answeredCount, results.length]);
+
+ const isAutoAnswering = useMemo(() => {
+ return (
+ isAutoAnswerProcessStarted &&
+ hasClickedAutoAnswer &&
+ (autoAnswer.autoAnswerRun?.status === 'EXECUTING' ||
+ autoAnswer.autoAnswerRun?.status === 'QUEUED' ||
+ autoAnswer.autoAnswerRun?.status === 'WAITING')
+ );
+ }, [isAutoAnswerProcessStarted, hasClickedAutoAnswer, autoAnswer.autoAnswerRun?.status]);
+
+ // Calculate isLoading based on answer generation status
+ const isLoading = useMemo(() => {
+ // Check if any question is being processed
+ const hasProcessingQuestions = Array.from(questionStatuses.values()).some(
+ (status) => status === 'processing'
+ );
+
+ // Check if single answer is being triggered
+ const isSingleAnswerTriggering = singleAnswer.isSingleAnswerTriggering;
+
+ // Check if auto answer is being triggered or running
+ const isAutoAnswerTriggering = autoAnswer.isAutoAnswerTriggering;
+ const isAutoAnswerRunActive =
+ autoAnswer.autoAnswerRun?.status === 'EXECUTING' ||
+ autoAnswer.autoAnswerRun?.status === 'QUEUED' ||
+ autoAnswer.autoAnswerRun?.status === 'WAITING';
+
+ return hasProcessingQuestions || isSingleAnswerTriggering || isAutoAnswerTriggering || isAutoAnswerRunActive;
+ }, [
+ questionStatuses,
+ isSingleAnswerTriggering,
+ autoAnswer.isAutoAnswerTriggering,
+ autoAnswer.autoAnswerRun?.status,
+ ]);
+
+ // Check if saving is in progress
+ const isSaving = updateAnswerAction.status === 'executing';
+ const savingIndex = isSaving && saveIndexRef.current !== null ? saveIndexRef.current : null;
+
+ return {
+ orgId: organizationId,
+ results,
+ searchQuery,
+ setSearchQuery,
+ editingIndex,
+ editingAnswer,
+ setEditingAnswer,
+ expandedSources,
+ questionStatuses,
+ answeringQuestionIndex,
+ hasClickedAutoAnswer,
+ isLoading,
+ isAutoAnswering,
+ isExporting: actions.exportAction.status === 'executing',
+ isSaving,
+ savingIndex,
+ filteredResults,
+ answeredCount,
+ totalCount: results.length,
+ progressPercentage,
+ handleAutoAnswer,
+ handleAnswerSingleQuestion,
+ handleEditAnswer: actions.handleEditAnswer,
+ handleSaveAnswer,
+ handleCancelEdit: actions.handleCancelEdit,
+ handleExport: actions.handleExport,
+ handleToggleSource: actions.handleToggleSource,
+ };
+}
+
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireParse.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireParse.ts
index 580cfde90..6941778d4 100644
--- a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireParse.ts
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireParse.ts
@@ -3,6 +3,7 @@
import type { parseQuestionnaireTask } from '@/jobs/tasks/vendors/parse-questionnaire';
import { useRealtimeRun } from '@trigger.dev/react-hooks';
import { useAction } from 'next-safe-action/hooks';
+import { useRouter } from 'next/navigation';
import { useEffect } from 'react';
import { toast } from 'sonner';
import { createRunReadToken, createTriggerToken } from '../actions/create-trigger-token';
@@ -26,6 +27,8 @@ interface UseQuestionnaireParseProps {
React.SetStateAction>
>;
setHasClickedAutoAnswer: (clicked: boolean) => void;
+ setQuestionnaireId: (id: string | null) => void;
+ orgId: string;
}
export function useQuestionnaireParse({
@@ -42,7 +45,10 @@ export function useQuestionnaireParse({
setExtractedContent,
setQuestionStatuses,
setHasClickedAutoAnswer,
+ setQuestionnaireId,
+ orgId,
}: UseQuestionnaireParseProps) {
+ const router = useRouter();
// Get trigger token for auto-answer (can trigger and read)
useEffect(() => {
async function getAutoAnswerToken() {
@@ -86,6 +92,7 @@ export function useQuestionnaireParse({
}>
| undefined;
const extractedContent = run.output.extractedContent as string | undefined;
+ const questionnaireId = run.output.questionnaireId as string | undefined;
if (questionsAndAnswers && Array.isArray(questionsAndAnswers)) {
const initializedResults = questionsAndAnswers.map((qa) => ({
@@ -96,6 +103,13 @@ export function useQuestionnaireParse({
setExtractedContent(extractedContent || null);
setQuestionStatuses(new Map());
setHasClickedAutoAnswer(false);
+ if (questionnaireId) {
+ setQuestionnaireId(questionnaireId);
+ // Redirect to questionnaire detail page after successful parse
+ setTimeout(() => {
+ router.push(`/${orgId}/security-questionnaire/${questionnaireId}`);
+ }, 500); // Small delay to show success toast
+ }
toast.success(
`Successfully parsed ${questionsAndAnswers.length} question-answer pairs`,
);
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireParser.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireParser.ts
index c63c36974..ebe54cb8a 100644
--- a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireParser.ts
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireParser.ts
@@ -24,6 +24,8 @@ export function useQuestionnaireParser() {
setExtractedContent: state.setExtractedContent,
setQuestionStatuses: state.setQuestionStatuses,
setHasClickedAutoAnswer: state.setHasClickedAutoAnswer,
+ setQuestionnaireId: state.setQuestionnaireId,
+ orgId: state.orgId,
});
const autoAnswer = useQuestionnaireAutoAnswer({
@@ -36,6 +38,7 @@ export function useQuestionnaireParser() {
setResults: state.setResults,
setQuestionStatuses: state.setQuestionStatuses,
setAnsweringQuestionIndex: state.setAnsweringQuestionIndex,
+ questionnaireId: state.questionnaireId,
});
const singleAnswer = useQuestionnaireSingleAnswer({
@@ -45,6 +48,7 @@ export function useQuestionnaireParser() {
setResults: state.setResults,
setQuestionStatuses: state.setQuestionStatuses,
setAnsweringQuestionIndex: state.setAnsweringQuestionIndex,
+ questionnaireId: state.questionnaireId,
});
const actions = useQuestionnaireActions({
@@ -53,6 +57,7 @@ export function useQuestionnaireParser() {
results: state.results,
editingAnswer: state.editingAnswer,
expandedSources: state.expandedSources,
+ questionnaireId: state.questionnaireId,
setSelectedFile: state.setSelectedFile,
setEditingIndex: state.setEditingIndex,
setEditingAnswer: state.setEditingAnswer,
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireSingleAnswer.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireSingleAnswer.ts
index 4df51913c..2189ba06e 100644
--- a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireSingleAnswer.ts
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireSingleAnswer.ts
@@ -2,8 +2,10 @@
import { useRealtimeTaskTrigger } from '@trigger.dev/react-hooks';
import type { answerQuestion } from '@/jobs/tasks/vendors/answer-question';
-import { useEffect } from 'react';
+import { useEffect, useTransition } from 'react';
import { toast } from 'sonner';
+import { useAction } from 'next-safe-action/hooks';
+import { saveAnswerAction } from '../actions/save-answer';
import type { QuestionAnswer } from '../components/types';
interface UseQuestionnaireSingleAnswerProps {
@@ -15,6 +17,7 @@ interface UseQuestionnaireSingleAnswerProps {
React.SetStateAction>
>;
setAnsweringQuestionIndex: (index: number | null) => void;
+ questionnaireId: string | null;
}
export function useQuestionnaireSingleAnswer({
@@ -24,6 +27,7 @@ export function useQuestionnaireSingleAnswer({
setResults,
setQuestionStatuses,
setAnsweringQuestionIndex,
+ questionnaireId,
}: UseQuestionnaireSingleAnswerProps) {
// Use realtime task trigger for single question answer
const {
@@ -36,6 +40,39 @@ export function useQuestionnaireSingleAnswer({
enabled: !!singleAnswerToken,
});
+ // Action for saving answer
+ const saveAnswer = useAction(saveAnswerAction, {
+ onError: ({ error }) => {
+ console.error('Error saving answer:', error);
+ },
+ });
+
+ const [isPending, startTransition] = useTransition();
+
+ // Set status to processing when task starts or is triggering
+ useEffect(() => {
+ if (answeringQuestionIndex !== null) {
+ const shouldBeProcessing =
+ isSingleAnswerTriggering ||
+ singleAnswerRun?.status === 'EXECUTING' ||
+ singleAnswerRun?.status === 'QUEUED' ||
+ singleAnswerRun?.status === 'WAITING';
+
+ if (shouldBeProcessing) {
+ setQuestionStatuses((prev) => {
+ const newStatuses = new Map(prev);
+ // Ensure status is set to processing when task is running or triggering
+ const currentStatus = prev.get(answeringQuestionIndex);
+ if (currentStatus !== 'processing') {
+ newStatuses.set(answeringQuestionIndex, 'processing');
+ return newStatuses;
+ }
+ return prev;
+ });
+ }
+ }
+ }, [singleAnswerRun?.status, answeringQuestionIndex, isSingleAnswerTriggering, setQuestionStatuses]);
+
// Handle single answer completion
useEffect(() => {
if (singleAnswerRun?.status === 'COMPLETED' && singleAnswerRun.output && answeringQuestionIndex !== null) {
@@ -57,26 +94,61 @@ export function useQuestionnaireSingleAnswer({
}
if (output.success && output.answer) {
- // Update the results with the answer
- setResults((prevResults) => {
- if (!prevResults) return prevResults;
-
- const updatedResults = [...prevResults];
- const targetIndex = output.questionIndex;
-
- // Verify we're updating the correct question
- if (targetIndex === answeringQuestionIndex && targetIndex >= 0 && targetIndex < updatedResults.length) {
- updatedResults[targetIndex] = {
- question: updatedResults[targetIndex].question, // Preserve original question text
- answer: output.answer,
- sources: output.sources,
- failedToGenerate: false,
- };
- return updatedResults;
+ const targetIndex = output.questionIndex;
+
+ // Verify we're updating the correct question
+ if (targetIndex === answeringQuestionIndex && targetIndex >= 0) {
+ // Update the results with the answer
+ setResults((prevResults) => {
+ if (!prevResults) return prevResults;
+
+ const updatedResults = [...prevResults];
+
+ // Try to find by questionIndex first (for QuestionnaireResult with originalIndex)
+ // Otherwise use array index
+ let resultIndex = -1;
+ for (let i = 0; i < updatedResults.length; i++) {
+ const result = updatedResults[i] as any;
+ if (result.originalIndex === targetIndex || result._originalIndex === targetIndex) {
+ resultIndex = i;
+ break;
+ }
+ }
+
+ // Fallback to array index if not found by originalIndex
+ if (resultIndex === -1 && targetIndex < updatedResults.length) {
+ resultIndex = targetIndex;
+ }
+
+ if (resultIndex >= 0 && resultIndex < updatedResults.length) {
+ const existingResult = updatedResults[resultIndex];
+ updatedResults[resultIndex] = {
+ ...existingResult,
+ question: existingResult.question, // Preserve original question text
+ answer: output.answer,
+ sources: output.sources,
+ failedToGenerate: false,
+ };
+ return updatedResults;
+ }
+
+ return prevResults;
+ });
+
+ // Save answer to database (outside of setState)
+ if (questionnaireId && output.answer) {
+ // Use startTransition to defer the save call to avoid rendering issues
+ startTransition(() => {
+ saveAnswer.execute({
+ questionnaireId,
+ questionIndex: targetIndex,
+ answer: output.answer!,
+ sources: output.sources,
+ status: 'generated',
+ });
+ });
}
-
- return prevResults;
- });
+ }
// Mark question as completed
setQuestionStatuses((prev) => {
@@ -121,7 +193,7 @@ export function useQuestionnaireSingleAnswer({
// Reset answering index
setAnsweringQuestionIndex(null);
}
- }, [singleAnswerRun?.status, singleAnswerRun?.output, answeringQuestionIndex, setResults, setQuestionStatuses, setAnsweringQuestionIndex]);
+ }, [singleAnswerRun?.status, singleAnswerRun?.output, answeringQuestionIndex, questionnaireId, saveAnswer, setResults, setQuestionStatuses, setAnsweringQuestionIndex]);
// Handle single answer errors
useEffect(() => {
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireState.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireState.ts
index fdd8c1aa3..327049809 100644
--- a/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireState.ts
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/hooks/useQuestionnaireState.ts
@@ -27,6 +27,7 @@ export function useQuestionnaireState() {
const [singleAnswerToken, setSingleAnswerToken] = useState(null);
const [isParseProcessStarted, setIsParseProcessStarted] = useState(false);
const [isAutoAnswerProcessStarted, setIsAutoAnswerProcessStarted] = useState(false);
+ const [questionnaireId, setQuestionnaireId] = useState(null);
const isAutoAnswerProcessStartedRef = useRef(false);
const resetState = () => {
@@ -42,6 +43,7 @@ export function useQuestionnaireState() {
setIsParseProcessStarted(false);
isAutoAnswerProcessStartedRef.current = false;
setIsAutoAnswerProcessStarted(false);
+ setQuestionnaireId(null);
};
return {
@@ -81,6 +83,8 @@ export function useQuestionnaireState() {
isAutoAnswerProcessStarted,
setIsAutoAnswerProcessStarted,
isAutoAnswerProcessStartedRef,
+ questionnaireId,
+ setQuestionnaireId,
resetState,
};
}
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/delete-document.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/delete-document.ts
new file mode 100644
index 000000000..2fbda7066
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/delete-document.ts
@@ -0,0 +1,116 @@
+'use server';
+
+import { authActionClient } from '@/actions/safe-action';
+import { APP_AWS_KNOWLEDGE_BASE_BUCKET, s3Client } from '@/app/s3';
+import { db } from '@db';
+import { DeleteObjectCommand } from '@aws-sdk/client-s3';
+import { revalidatePath } from 'next/cache';
+import { z } from 'zod';
+import { tasks } from '@trigger.dev/sdk';
+import { deleteKnowledgeBaseDocumentTask } from '@/jobs/tasks/vector/delete-knowledge-base-document';
+
+const deleteDocumentSchema = z.object({
+ documentId: z.string(),
+});
+
+export const deleteKnowledgeBaseDocumentAction = authActionClient
+ .inputSchema(deleteDocumentSchema)
+ .metadata({
+ name: 'delete-knowledge-base-document',
+ track: {
+ event: 'delete-knowledge-base-document',
+ description: 'Delete Knowledge Base Document',
+ channel: 'server',
+ },
+ })
+ .action(async ({ parsedInput, ctx }) => {
+ const { documentId } = parsedInput;
+ const { activeOrganizationId } = ctx.session;
+
+ if (!activeOrganizationId) {
+ return {
+ success: false,
+ error: 'Not authorized',
+ };
+ }
+
+ if (!s3Client) {
+ return {
+ success: false,
+ error: 'S3 client not configured',
+ };
+ }
+
+ if (!APP_AWS_KNOWLEDGE_BASE_BUCKET) {
+ return {
+ success: false,
+ error: 'Knowledge base bucket is not configured',
+ };
+ }
+
+ try {
+ // Find the document
+ const document = await db.knowledgeBaseDocument.findUnique({
+ where: {
+ id: documentId,
+ organizationId: activeOrganizationId,
+ },
+ });
+
+ if (!document) {
+ return {
+ success: false,
+ error: 'Document not found',
+ };
+ }
+
+ // Delete embeddings from vector database first (async, non-blocking)
+ let vectorDeletionRunId: string | undefined;
+ try {
+ const handle = await tasks.trigger(
+ 'delete-knowledge-base-document-from-vector',
+ {
+ documentId: document.id,
+ organizationId: activeOrganizationId,
+ },
+ );
+ vectorDeletionRunId = handle.id;
+ } catch (triggerError) {
+ // Log error but continue with deletion
+ console.error('Failed to trigger vector deletion task:', triggerError);
+ }
+
+ // Delete from S3
+ try {
+ const deleteCommand = new DeleteObjectCommand({
+ Bucket: APP_AWS_KNOWLEDGE_BASE_BUCKET,
+ Key: document.s3Key,
+ });
+ await s3Client.send(deleteCommand);
+ } catch (s3Error) {
+ // Log error but continue with database deletion
+ console.error('Error deleting file from S3:', s3Error);
+ }
+
+ // Delete from database
+ await db.knowledgeBaseDocument.delete({
+ where: {
+ id: documentId,
+ },
+ });
+
+ revalidatePath(`/${activeOrganizationId}/security-questionnaire/knowledge-base`);
+
+ return {
+ success: true,
+ vectorDeletionRunId, // Return run ID for tracking deletion progress
+ };
+ } catch (error) {
+ console.error('Error deleting knowledge base document:', error);
+ return {
+ success: false,
+ error: 'Failed to delete document',
+ };
+ }
+ });
+
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/download-document.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/download-document.ts
new file mode 100644
index 000000000..31e1dbd26
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/download-document.ts
@@ -0,0 +1,95 @@
+'use server';
+
+import { authActionClient } from '@/actions/safe-action';
+import { APP_AWS_KNOWLEDGE_BASE_BUCKET, s3Client } from '@/app/s3';
+import { db } from '@db';
+import { GetObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { z } from 'zod';
+
+const downloadDocumentSchema = z.object({
+ documentId: z.string(),
+});
+
+export const downloadKnowledgeBaseDocumentAction = authActionClient
+ .inputSchema(downloadDocumentSchema)
+ .metadata({
+ name: 'download-knowledge-base-document',
+ track: {
+ event: 'download-knowledge-base-document',
+ description: 'Download Knowledge Base Document',
+ channel: 'server',
+ },
+ })
+ .action(async ({ parsedInput, ctx }) => {
+ const { documentId } = parsedInput;
+ const { session } = ctx;
+
+ if (!session?.activeOrganizationId) {
+ return {
+ success: false,
+ error: 'Not authorized',
+ };
+ }
+
+ if (!s3Client) {
+ return {
+ success: false,
+ error: 'S3 client not configured',
+ };
+ }
+
+ if (!APP_AWS_KNOWLEDGE_BASE_BUCKET) {
+ return {
+ success: false,
+ error: 'Knowledge base bucket is not configured',
+ };
+ }
+
+ try {
+ const document = await db.knowledgeBaseDocument.findUnique({
+ where: {
+ id: documentId,
+ organizationId: session.activeOrganizationId,
+ },
+ select: {
+ s3Key: true,
+ name: true,
+ fileType: true,
+ },
+ });
+
+ if (!document) {
+ return {
+ success: false,
+ error: 'Document not found',
+ };
+ }
+
+ // Generate signed URL for download
+ const command = new GetObjectCommand({
+ Bucket: APP_AWS_KNOWLEDGE_BASE_BUCKET,
+ Key: document.s3Key,
+ ResponseContentDisposition: `attachment; filename="${encodeURIComponent(document.name)}"`,
+ });
+
+ const signedUrl = await getSignedUrl(s3Client, command, {
+ expiresIn: 3600, // URL expires in 1 hour
+ });
+
+ return {
+ success: true,
+ data: {
+ signedUrl,
+ fileName: document.name,
+ },
+ };
+ } catch (error) {
+ console.error('Error generating download URL:', error);
+ return {
+ success: false,
+ error: 'Failed to generate download URL',
+ };
+ }
+ });
+
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/get-document-view-url.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/get-document-view-url.ts
new file mode 100644
index 000000000..b991568d9
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/get-document-view-url.ts
@@ -0,0 +1,119 @@
+'use server';
+
+import { authActionClient } from '@/actions/safe-action';
+import { APP_AWS_KNOWLEDGE_BASE_BUCKET, s3Client } from '@/app/s3';
+import { db } from '@db';
+import { GetObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { z } from 'zod';
+
+const getDocumentViewUrlSchema = z.object({
+ documentId: z.string(),
+});
+
+/**
+ * Gets a signed URL for viewing a knowledge base document (opens in browser, doesn't force download)
+ */
+export const getKnowledgeBaseDocumentViewUrlAction = authActionClient
+ .inputSchema(getDocumentViewUrlSchema)
+ .metadata({
+ name: 'get-knowledge-base-document-view-url',
+ track: {
+ event: 'get-knowledge-base-document-view-url',
+ description: 'Get Knowledge Base Document View URL',
+ channel: 'server',
+ },
+ })
+ .action(async ({ parsedInput, ctx }) => {
+ const { documentId } = parsedInput;
+ const { session } = ctx;
+
+ if (!session?.activeOrganizationId) {
+ return {
+ success: false,
+ error: 'Not authorized',
+ };
+ }
+
+ if (!s3Client) {
+ return {
+ success: false,
+ error: 'S3 client not configured',
+ };
+ }
+
+ if (!APP_AWS_KNOWLEDGE_BASE_BUCKET) {
+ return {
+ success: false,
+ error: 'Knowledge base bucket is not configured',
+ };
+ }
+
+ try {
+ const document = await db.knowledgeBaseDocument.findUnique({
+ where: {
+ id: documentId,
+ organizationId: session.activeOrganizationId,
+ },
+ select: {
+ s3Key: true,
+ name: true,
+ fileType: true,
+ },
+ });
+
+ if (!document) {
+ return {
+ success: false,
+ error: 'Document not found',
+ };
+ }
+
+ // Generate signed URL for viewing in browser
+ // Set Content-Type header so browser knows how to handle the file
+ // For PDFs, images, and text files: browser will display inline
+ // For DOCX, XLSX, etc.: browser may download or try to open with external app
+ const command = new GetObjectCommand({
+ Bucket: APP_AWS_KNOWLEDGE_BASE_BUCKET,
+ Key: document.s3Key,
+ ResponseContentDisposition: `inline; filename="${encodeURIComponent(document.name)}"`,
+ ResponseContentType: document.fileType || 'application/octet-stream', // Set Content-Type header
+ });
+
+ const signedUrl = await getSignedUrl(s3Client, command, {
+ expiresIn: 3600, // URL expires in 1 hour
+ });
+
+ // Determine if file can be viewed inline in browser
+ const viewableInBrowser = [
+ 'application/pdf',
+ 'image/png',
+ 'image/jpeg',
+ 'image/jpg',
+ 'image/gif',
+ 'image/webp',
+ 'image/svg+xml',
+ 'text/plain',
+ 'text/html',
+ 'text/csv',
+ 'text/markdown',
+ ].includes(document.fileType);
+
+ return {
+ success: true,
+ data: {
+ signedUrl,
+ fileName: document.name,
+ fileType: document.fileType,
+ viewableInBrowser,
+ },
+ };
+ } catch (error) {
+ console.error('Error generating view URL:', error);
+ return {
+ success: false,
+ error: 'Failed to generate view URL',
+ };
+ }
+ });
+
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/process-documents.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/process-documents.ts
new file mode 100644
index 000000000..f66ceed12
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/process-documents.ts
@@ -0,0 +1,78 @@
+'use server';
+
+import { authActionClient } from '@/actions/safe-action';
+import { tasks } from '@trigger.dev/sdk';
+import { processKnowledgeBaseDocumentTask } from '@/jobs/tasks/vector/process-knowledge-base-document';
+import { processKnowledgeBaseDocumentsOrchestratorTask } from '@/jobs/tasks/vector/process-knowledge-base-documents-orchestrator';
+import { z } from 'zod';
+
+const processDocumentsSchema = z.object({
+ documentIds: z.array(z.string()).min(1),
+ organizationId: z.string(),
+});
+
+/**
+ * Server action to trigger document processing
+ * Uses orchestrator for multiple documents, individual task for single document
+ */
+export const processKnowledgeBaseDocumentsAction = authActionClient
+ .inputSchema(processDocumentsSchema)
+ .metadata({
+ name: 'process-knowledge-base-documents',
+ track: {
+ event: 'process-knowledge-base-documents',
+ description: 'Process Knowledge Base Documents',
+ channel: 'server',
+ },
+ })
+ .action(async ({ parsedInput, ctx }) => {
+ const { documentIds, organizationId } = parsedInput;
+ const { session } = ctx;
+
+ if (!session?.activeOrganizationId || session.activeOrganizationId !== organizationId) {
+ return {
+ success: false,
+ error: 'Not authorized',
+ };
+ }
+
+ try {
+ let runId: string | undefined;
+
+ // Use orchestrator for multiple documents, individual task for single document
+ if (documentIds.length > 1) {
+ const handle = await tasks.trigger(
+ 'process-knowledge-base-documents-orchestrator',
+ {
+ documentIds,
+ organizationId,
+ },
+ );
+ runId = handle.id;
+ } else {
+ const handle = await tasks.trigger(
+ 'process-knowledge-base-document',
+ {
+ documentId: documentIds[0]!,
+ organizationId,
+ },
+ );
+ runId = handle.id;
+ }
+
+ return {
+ success: true,
+ runId,
+ message: documentIds.length > 1
+ ? `Processing ${documentIds.length} documents in parallel...`
+ : 'Processing document...',
+ };
+ } catch (error) {
+ console.error('Failed to trigger document processing:', error);
+ return {
+ success: false,
+ error: 'Failed to trigger document processing',
+ };
+ }
+ });
+
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/upload-document.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/upload-document.ts
new file mode 100644
index 000000000..66108a77a
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/actions/upload-document.ts
@@ -0,0 +1,132 @@
+'use server';
+
+import { authActionClient } from '@/actions/safe-action';
+import { APP_AWS_KNOWLEDGE_BASE_BUCKET, s3Client } from '@/app/s3';
+import { db } from '@db';
+import { PutObjectCommand } from '@aws-sdk/client-s3';
+import { randomBytes } from 'crypto';
+import { revalidatePath } from 'next/cache';
+import { z } from 'zod';
+
+const uploadDocumentSchema = z.object({
+ fileName: z.string(),
+ fileType: z.string(),
+ fileData: z.string(), // base64 encoded file
+ description: z.string().optional(),
+ organizationId: z.string(),
+});
+
+export const uploadKnowledgeBaseDocumentAction = authActionClient
+ .inputSchema(uploadDocumentSchema)
+ .metadata({
+ name: 'upload-knowledge-base-document',
+ track: {
+ event: 'upload-knowledge-base-document',
+ description: 'Upload Knowledge Base Document',
+ channel: 'server',
+ },
+ })
+ .action(async ({ parsedInput, ctx }) => {
+ const { fileName, fileType, fileData, description, organizationId } = parsedInput;
+ const { session } = ctx;
+
+ if (!session?.activeOrganizationId || session.activeOrganizationId !== organizationId) {
+ return {
+ success: false,
+ error: 'Not authorized',
+ };
+ }
+
+ if (!s3Client) {
+ return {
+ success: false,
+ error: 'S3 client not configured',
+ };
+ }
+
+ if (!APP_AWS_KNOWLEDGE_BASE_BUCKET) {
+ return {
+ success: false,
+ error: 'Knowledge base bucket is not configured. Please set APP_AWS_KNOWLEDGE_BASE_BUCKET environment variable.',
+ };
+ }
+
+ try {
+ // Convert base64 to buffer
+ const fileBuffer = Buffer.from(fileData, 'base64');
+
+ // Validate file size (10MB limit)
+ const MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
+ if (fileBuffer.length > MAX_FILE_SIZE_BYTES) {
+ return {
+ success: false,
+ error: `File exceeds the ${MAX_FILE_SIZE_BYTES / (1024 * 1024)}MB limit`,
+ };
+ }
+
+ // Generate unique file key
+ const fileId = randomBytes(16).toString('hex');
+ const sanitizedFileName = fileName.replace(/[^a-zA-Z0-9.-]/g, '_');
+ const timestamp = Date.now();
+ const s3Key = `${organizationId}/knowledge-base-documents/${timestamp}-${fileId}-${sanitizedFileName}`;
+
+ // Sanitize filename for S3 metadata
+ // S3 metadata values must be valid HTTP header values
+ // To be absolutely safe, we'll encode the filename using a safe character set
+ // Remove control characters and non-ASCII characters, keep only safe printable ASCII
+ const sanitizedMetadataFileName = Buffer.from(fileName, 'utf8')
+ .toString('ascii') // Convert to ASCII, replacing non-ASCII with '?'
+ .replace(/[\x00-\x1F\x7F]/g, '') // Remove control characters
+ .replace(/\?/g, '_') // Replace '?' (from non-ASCII conversion) with '_'
+ .trim()
+ .substring(0, 1024); // S3 metadata values have a 2KB limit per value
+
+ // Upload to S3
+ const putCommand = new PutObjectCommand({
+ Bucket: APP_AWS_KNOWLEDGE_BASE_BUCKET,
+ Key: s3Key,
+ Body: fileBuffer,
+ ContentType: fileType,
+ Metadata: {
+ originalFileName: sanitizedMetadataFileName,
+ organizationId,
+ },
+ });
+
+ await s3Client.send(putCommand);
+
+ // Create database record
+ const document = await db.knowledgeBaseDocument.create({
+ data: {
+ name: fileName,
+ description: description || null,
+ s3Key,
+ fileType,
+ fileSize: fileBuffer.length,
+ organizationId,
+ processingStatus: 'pending',
+ },
+ });
+
+ // Note: Processing is triggered by orchestrator in the component
+ // when multiple files are uploaded, or individually for single files
+
+ revalidatePath(`/${organizationId}/security-questionnaire/knowledge-base`);
+
+ return {
+ success: true,
+ data: {
+ id: document.id,
+ name: document.name,
+ s3Key: document.s3Key,
+ },
+ };
+ } catch (error) {
+ console.error('Error uploading knowledge base document:', error);
+ return {
+ success: false,
+ error: 'Failed to upload document',
+ };
+ }
+ });
+
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/components/AdditionalDocumentsSection.tsx b/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/components/AdditionalDocumentsSection.tsx
new file mode 100644
index 000000000..05ec51f4c
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/knowledge-base/additional-documents/components/AdditionalDocumentsSection.tsx
@@ -0,0 +1,436 @@
+'use client';
+
+import { FileUploader } from '@/components/file-uploader';
+import { Accordion, AccordionContent, AccordionItem, AccordionTrigger } from '@comp/ui/accordion';
+import {
+ AlertDialog,
+ AlertDialogAction,
+ AlertDialogCancel,
+ AlertDialogContent,
+ AlertDialogDescription,
+ AlertDialogFooter,
+ AlertDialogHeader,
+ AlertDialogTitle,
+} from '@comp/ui/alert-dialog';
+import { Button } from '@comp/ui/button';
+import { Card } from '@comp/ui';
+import { ChevronLeft, ChevronRight, Download, FileText, Trash2, Upload } from 'lucide-react';
+import { useState, useRef } from 'react';
+import { toast } from 'sonner';
+import { uploadKnowledgeBaseDocumentAction } from '../actions/upload-document';
+import { downloadKnowledgeBaseDocumentAction } from '../actions/download-document';
+import { deleteKnowledgeBaseDocumentAction } from '../actions/delete-document';
+import { processKnowledgeBaseDocumentsAction } from '../actions/process-documents';
+import { useRouter } from 'next/navigation';
+import { usePagination } from '../../hooks/usePagination';
+import { format } from 'date-fns';
+import { useDocumentProcessing } from '../hooks/useDocumentProcessing';
+import { Loader2 } from 'lucide-react';
+
+type KnowledgeBaseDocument = Awaited<
+ ReturnType
+>[number];
+
+interface AdditionalDocumentsSectionProps {
+ organizationId: string;
+ documents: Awaited>;
+}
+
+export function AdditionalDocumentsSection({
+ organizationId,
+ documents,
+}: AdditionalDocumentsSectionProps) {
+ const router = useRouter();
+ const sectionRef = useRef(null);
+ const [isUploading, setIsUploading] = useState(false);
+ const [uploadProgress, setUploadProgress] = useState>({});
+ const [downloadingIds, setDownloadingIds] = useState>(new Set());
+ const [deletingId, setDeletingId] = useState(null);
+ const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false);
+ const [documentToDelete, setDocumentToDelete] = useState<{ id: string; name: string } | null>(
+ null,
+ );
+
+ // Track processing and deletion run IDs
+ const [processingRunIds, setProcessingRunIds] = useState>(new Map()); // documentId -> runId
+ const [deletionRunIds, setDeletionRunIds] = useState>(new Map()); // documentId -> runId
+
+ // Track processing/deletion progress for current document
+ const currentProcessingRunId = Array.from(processingRunIds.values())[0] || null;
+ const currentDeletionRunId = deletionRunIds.get(deletingId || '') || null;
+
+ const { isProcessing, isDeleting, processingStatus, deletionStatus } = useDocumentProcessing({
+ processingRunId: currentProcessingRunId,
+ deletionRunId: currentDeletionRunId,
+ onProcessingComplete: () => {
+ // Clear processing run ID and refresh
+ setProcessingRunIds(new Map());
+ router.refresh();
+ toast.success('Document processed successfully');
+ },
+ onDeletionComplete: () => {
+ // Clear deletion run ID
+ const newDeletionRunIds = new Map(deletionRunIds);
+ if (deletingId) {
+ newDeletionRunIds.delete(deletingId);
+ }
+ setDeletionRunIds(newDeletionRunIds);
+ },
+ });
+
+ const { currentPage, totalPages, paginatedItems, handlePageChange } = usePagination({
+ items: documents,
+ itemsPerPage: 10,
+ });
+
+ const handleAccordionChange = (value: string) => {
+ // If opening (value is set), scroll to section
+ if (value === 'additional-documents' && sectionRef.current) {
+ setTimeout(() => {
+ sectionRef.current?.scrollIntoView({
+ behavior: 'smooth',
+ block: 'start',
+ });
+ }, 100); // Small delay to allow accordion animation to start
+ }
+ };
+
+ const handleFileUpload = async (files: File[]) => {
+ setIsUploading(true);
+ const newProgress: Record = {};
+
+ try {
+ // Initialize progress for all files
+ files.forEach((file) => {
+ newProgress[file.name] = 0;
+ });
+ setUploadProgress(newProgress);
+
+ const uploadedDocumentIds: string[] = [];
+
+ // Upload files sequentially
+ for (const file of files) {
+ try {
+ // Convert file to base64
+ const fileData = await fileToBase64(file);
+
+ // Update progress
+ newProgress[file.name] = 50;
+ setUploadProgress({ ...newProgress });
+
+ // Upload file
+ const result = await uploadKnowledgeBaseDocumentAction({
+ fileName: file.name,
+ fileType: file.type,
+ fileData,
+ organizationId,
+ });
+
+ if (result?.data?.success && result.data.data?.id) {
+ uploadedDocumentIds.push(result.data.data.id);
+ newProgress[file.name] = 100;
+ setUploadProgress({ ...newProgress });
+ toast.success(`Successfully uploaded ${file.name}`);
+ } else {
+ throw new Error(result?.data?.error || 'Failed to upload file');
+ }
+ } catch (error) {
+ console.error(`Error uploading ${file.name}:`, error);
+ toast.error(
+ `Failed to upload ${file.name}: ${error instanceof Error ? error.message : 'Unknown error'}`,
+ );
+ delete newProgress[file.name];
+ setUploadProgress({ ...newProgress });
+ }
+ }
+
+ // Trigger processing for uploaded documents (orchestrator for multiple, individual for single)
+ if (uploadedDocumentIds.length > 0) {
+ try {
+ const result = await processKnowledgeBaseDocumentsAction({
+ documentIds: uploadedDocumentIds,
+ organizationId,
+ });
+
+ if (result?.data?.success) {
+ // Store run ID for tracking progress
+ const runId = result.data.runId;
+ if (runId) {
+ const newProcessingRunIds = new Map(processingRunIds);
+ // For orchestrator, track all documents with the same run ID
+ uploadedDocumentIds.forEach((docId) => {
+ newProcessingRunIds.set(docId, runId);
+ });
+ setProcessingRunIds(newProcessingRunIds);
+ }
+ toast.success(result.data.message || 'Processing documents...');
+ } else {
+ console.error('Failed to trigger document processing:', result?.data?.error);
+ }
+ } catch (error) {
+ console.error('Failed to trigger document processing:', error);
+ }
+ }
+
+ // Refresh the page to show new documents
+ router.refresh();
+ } catch (error) {
+ console.error('Error during file upload:', error);
+ toast.error('An error occurred during file upload');
+ } finally {
+ setIsUploading(false);
+ setUploadProgress({});
+ }
+ };
+
+ const handleDownload = async (documentId: string, fileName: string, e?: React.MouseEvent) => {
+ if (e) {
+ e.stopPropagation();
+ }
+
+ if (downloadingIds.has(documentId)) {
+ return;
+ }
+
+ setDownloadingIds((prev) => new Set(prev).add(documentId));
+
+ try {
+ const result = await downloadKnowledgeBaseDocumentAction({ documentId });
+
+ if (result?.data?.success && result.data.data?.signedUrl) {
+ // Create a temporary link and trigger download
+ const link = document.createElement('a');
+ link.href = result.data.data.signedUrl;
+ link.download = fileName;
+ document.body.appendChild(link);
+ link.click();
+ document.body.removeChild(link);
+ toast.success(`Downloading ${fileName}...`);
+ } else {
+ toast.error(result?.data?.error || 'Failed to download file');
+ }
+ } catch (error) {
+ console.error('Error downloading file:', error);
+ toast.error('An error occurred while downloading the file');
+ } finally {
+ setDownloadingIds((prev) => {
+ const newSet = new Set(prev);
+ newSet.delete(documentId);
+ return newSet;
+ });
+ }
+ };
+
+ const handleDeleteClick = (documentId: string, fileName: string, e: React.MouseEvent) => {
+ e.stopPropagation();
+ setDocumentToDelete({ id: documentId, name: fileName });
+ setIsDeleteDialogOpen(true);
+ };
+
+ const handleDeleteConfirm = async () => {
+ if (!documentToDelete) return;
+
+ setDeletingId(documentToDelete.id);
+ setIsDeleteDialogOpen(false);
+
+ try {
+ const result = await deleteKnowledgeBaseDocumentAction({
+ documentId: documentToDelete.id,
+ });
+
+ if (result?.data?.success) {
+ // Store deletion run ID for tracking progress
+ const vectorDeletionRunId = result.data.vectorDeletionRunId;
+ if (vectorDeletionRunId) {
+ const newDeletionRunIds = new Map(deletionRunIds);
+ newDeletionRunIds.set(documentToDelete.id, vectorDeletionRunId);
+ setDeletionRunIds(newDeletionRunIds);
+ }
+
+ toast.success(`Successfully deleted ${documentToDelete.name}`);
+ router.refresh();
+ } else {
+ toast.error(result?.data?.error || 'Failed to delete document');
+ }
+ } catch (error) {
+ console.error('Error deleting document:', error);
+ toast.error('An error occurred while deleting the document');
+ } finally {
+ setDeletingId(null);
+ setDocumentToDelete(null);
+ }
+ };
+
+ const fileToBase64 = (file: File): Promise => {
+ return new Promise((resolve, reject) => {
+ const reader = new FileReader();
+ reader.readAsDataURL(file);
+ reader.onload = () => {
+ const result = reader.result as string;
+ // Remove data URL prefix (e.g., "data:image/png;base64,")
+ const base64 = result.split(',')[1];
+ resolve(base64);
+ };
+ reader.onerror = (error) => reject(error);
+ });
+ };
+
+ return (
+ <>
+
+
+
+
+
+
+ Additional Documents
+ ({documents.length})
+
+
+
+
+
+ Upload documents or images to enhance your knowledge base. Supported formats: PDF, Word (.docx), Excel, CSV, text files, and images (PNG, JPG, GIF, WebP, SVG). Click on a document to download it.
+
+
+
+ {/* Delete Confirmation Dialog */}
+
+ e.stopPropagation()}>
+
+ Delete Questionnaire
+
+ Are you sure you want to delete {questionnaire.filename}? This action
+ cannot be undone and will permanently delete all questions and answers.
+
+
+
+ Cancel
+
+ {isDeleting ? (
+ <>
+
+ Deleting...
+
+ ) : (
+ 'Delete'
+ )}
+
+
+
+
+
+ );
+}
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/start_page/components/QuestionnaireOverview.tsx b/apps/app/src/app/(app)/[orgId]/security-questionnaire/start_page/components/QuestionnaireOverview.tsx
new file mode 100644
index 000000000..e41c4d684
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/start_page/components/QuestionnaireOverview.tsx
@@ -0,0 +1,70 @@
+'use client';
+
+import { Button } from '@comp/ui/button';
+import { Card, CardContent } from '@comp/ui';
+import { FileText, Plus } from 'lucide-react';
+import Link from 'next/link';
+import { useParams } from 'next/navigation';
+import { QuestionnaireHistory } from './QuestionnaireHistory';
+
+interface QuestionnaireOverviewProps {
+ questionnaires: Awaited>;
+}
+
+export function QuestionnaireOverview({ questionnaires }: QuestionnaireOverviewProps) {
+ const params = useParams();
+ const orgId = params.orgId as string;
+
+ return (
+
+ {/* Header */}
+
+
+ Security Questionnaire
+
+
+ Automatically analyze and answer questionnaires using AI. Upload questionnaires from
+ vendors, and our system will extract questions and generate answers based on your
+ organization's policies and documentation.
+
+
+
+ {/* New Questionnaire Card */}
+
+
+
+
+
+
+
+
+
Create New Questionnaire
+
+ Upload a questionnaire file to extract questions and generate answers
+
+
+
+
+
+
+
+
+ {/* History Section */}
+
+
+
History
+
+ View and manage your previously parsed questionnaires
+
+
+
+
+
+ );
+}
+
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/start_page/components/index.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/start_page/components/index.ts
new file mode 100644
index 000000000..b0f7bdfd0
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/start_page/components/index.ts
@@ -0,0 +1,7 @@
+// Start Page (First Step) Components
+// This folder contains components for the questionnaire start page
+// which displays the list of questionnaires and allows creating new ones.
+
+export { QuestionnaireOverview } from './QuestionnaireOverview';
+export { QuestionnaireHistory } from './QuestionnaireHistory';
+
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/start_page/data/queries.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/start_page/data/queries.ts
new file mode 100644
index 000000000..e0ed85fbd
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/start_page/data/queries.ts
@@ -0,0 +1,45 @@
+'use server';
+
+import { auth } from '@/utils/auth';
+import { db } from '@db';
+import { headers } from 'next/headers';
+import 'server-only';
+
+export const getQuestionnaires = async (organizationId: string) => {
+ const session = await auth.api.getSession({
+ headers: await headers(),
+ });
+
+ if (!session?.session?.activeOrganizationId || session.session.activeOrganizationId !== organizationId) {
+ return [];
+ }
+
+ const questionnaires = await db.questionnaire.findMany({
+ where: {
+ organizationId,
+ status: {
+ in: ['completed', 'parsing'],
+ },
+ },
+ include: {
+ questions: {
+ orderBy: {
+ questionIndex: 'asc',
+ },
+ select: {
+ id: true,
+ question: true,
+ answer: true,
+ status: true,
+ questionIndex: true,
+ },
+ },
+ },
+ orderBy: {
+ createdAt: 'desc',
+ },
+ });
+
+ return questionnaires;
+};
+
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/start_page/hooks/useQuestionnaireHistory.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/start_page/hooks/useQuestionnaireHistory.ts
new file mode 100644
index 000000000..55871e1e5
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/start_page/hooks/useQuestionnaireHistory.ts
@@ -0,0 +1,59 @@
+'use client';
+
+import { useMemo, useState } from 'react';
+
+interface UseQuestionnaireHistoryProps {
+ questionnaires: Awaited>;
+}
+
+export function useQuestionnaireHistory({ questionnaires }: UseQuestionnaireHistoryProps) {
+ const [searchQuery, setSearchQuery] = useState('');
+ const [currentPage, setCurrentPage] = useState(1);
+ const [itemsPerPage, setItemsPerPage] = useState(5);
+
+ // Filter questionnaires by filename
+ const filteredQuestionnaires = useMemo(() => {
+ if (!searchQuery.trim()) {
+ return questionnaires;
+ }
+
+ const query = searchQuery.toLowerCase();
+ return questionnaires.filter((questionnaire: Awaited>[number]) =>
+ questionnaire.filename.toLowerCase().includes(query),
+ );
+ }, [questionnaires, searchQuery]);
+
+ // Calculate pagination
+ const totalPages = Math.max(1, Math.ceil(filteredQuestionnaires.length / itemsPerPage));
+ const startIndex = (currentPage - 1) * itemsPerPage;
+ const endIndex = startIndex + itemsPerPage;
+ const paginatedQuestionnaires = filteredQuestionnaires.slice(startIndex, endIndex);
+
+ // Reset to page 1 when search changes or items per page changes
+ const handleSearchChange = (value: string) => {
+ setSearchQuery(value);
+ setCurrentPage(1);
+ };
+
+ const handleItemsPerPageChange = (value: number) => {
+ setItemsPerPage(value);
+ setCurrentPage(1);
+ };
+
+ const handlePageChange = (page: number) => {
+ setCurrentPage(page);
+ };
+
+ return {
+ searchQuery,
+ setSearchQuery: handleSearchChange,
+ currentPage,
+ itemsPerPage,
+ totalPages,
+ paginatedQuestionnaires,
+ totalFiltered: filteredQuestionnaires.length,
+ handlePageChange,
+ handleItemsPerPageChange,
+ };
+}
+
diff --git a/apps/app/src/app/(app)/[orgId]/security-questionnaire/utils/deduplicate-sources.ts b/apps/app/src/app/(app)/[orgId]/security-questionnaire/utils/deduplicate-sources.ts
new file mode 100644
index 000000000..014975db7
--- /dev/null
+++ b/apps/app/src/app/(app)/[orgId]/security-questionnaire/utils/deduplicate-sources.ts
@@ -0,0 +1,111 @@
+/**
+ * Universal utility function to deduplicate sources for questionnaire answers.
+ *
+ * Deduplication rules:
+ * - Policies: Same policy name = same source (deduplicated by policyName)
+ * - Context: All context entries = single "Context Q&A" source
+ * - Manual Answers: All manual answers = single "Manual Answer" source
+ * - Knowledge Base Documents: Deduplicated by sourceId (each document is a separate source)
+ * - Other sources: Deduplicated by sourceId
+ */
+
+export interface Source {
+ sourceType: string;
+ sourceName?: string;
+ sourceId?: string;
+ policyName?: string;
+ documentName?: string;
+ score: number;
+}
+
+/**
+ * Deduplicates an array of sources based on source type and content.
+ * For each source type, uses appropriate deduplication key:
+ * - Policies: policyName
+ * - Context: "Context Q&A" (all grouped together)
+ * - Manual Answers: "Manual Answer" (all grouped together)
+ * - Knowledge Base Documents: sourceId (each document is separate)
+ * - Others: sourceId
+ *
+ * When duplicates are found, keeps the one with the highest score.
+ */
+export function deduplicateSources(sources: Source[]): Source[] {
+ const sourceMap = new Map();
+
+ for (const source of sources) {
+ let deduplicationKey: string;
+
+ // Determine deduplication key based on source type
+ if (source.sourceType === 'policy' && source.policyName) {
+ // Policies: deduplicate by policy name
+ deduplicationKey = `policy:${source.policyName}`;
+ } else if (source.sourceType === 'context') {
+ // Context: all context entries are grouped as one source
+ deduplicationKey = 'context:all';
+ } else if (source.sourceType === 'manual_answer') {
+ // Manual Answers: all manual answers are grouped as one source
+ deduplicationKey = 'manual_answer:all';
+ } else if (source.sourceType === 'knowledge_base_document') {
+ // Knowledge Base Documents: deduplicate by sourceId (each document is separate)
+ deduplicationKey = `knowledge_base_document:${source.sourceId || 'unknown'}`;
+ } else {
+ // Other sources: deduplicate by sourceId
+ deduplicationKey = source.sourceId || `unknown:${source.sourceType}`;
+ }
+
+ // If we haven't seen this source, or this chunk has a higher score, use it
+ const existing = sourceMap.get(deduplicationKey);
+ if (!existing || source.score > existing.score) {
+ // Create a normalized source with appropriate sourceName
+ // Preserve documentName if available (it might be missing in some chunks)
+ const normalizedSource: Source = {
+ ...source,
+ documentName: source.documentName || existing?.documentName,
+ sourceName: getSourceDisplayName({
+ ...source,
+ documentName: source.documentName || existing?.documentName,
+ }),
+ };
+ sourceMap.set(deduplicationKey, normalizedSource);
+ } else if (existing && source.documentName && !existing.documentName) {
+ // If existing source doesn't have documentName but new one does, update it
+ existing.documentName = source.documentName;
+ existing.sourceName = getSourceDisplayName(existing);
+ }
+ }
+
+ // Convert map to array and sort by score (highest first)
+ return Array.from(sourceMap.values()).sort((a, b) => b.score - a.score);
+}
+
+/**
+ * Generates a display name for a source based on its type and properties.
+ */
+function getSourceDisplayName(source: Source): string {
+ if (source.sourceType === 'policy' && source.policyName) {
+ return `Policy: ${source.policyName}`;
+ }
+
+ if (source.sourceType === 'context') {
+ return 'Context Q&A';
+ }
+
+ if (source.sourceType === 'manual_answer') {
+ return 'Manual Answer';
+ }
+
+ if (source.sourceType === 'knowledge_base_document') {
+ // Show filename if available, otherwise just "Knowledge Base Document"
+ if (source.documentName) {
+ return `Knowledge Base Document (${source.documentName})`;
+ }
+ return 'Knowledge Base Document';
+ }
+
+ if (source.sourceName) {
+ return source.sourceName;
+ }
+
+ return source.sourceType || 'Unknown Source';
+}
+
diff --git a/apps/app/src/app/(app)/[orgId]/settings/trust-portal/actions/update-trust-portal-frameworks.ts b/apps/app/src/app/(app)/[orgId]/settings/trust-portal/actions/update-trust-portal-frameworks.ts
index 03b9193fb..dd705077d 100644
--- a/apps/app/src/app/(app)/[orgId]/settings/trust-portal/actions/update-trust-portal-frameworks.ts
+++ b/apps/app/src/app/(app)/[orgId]/settings/trust-portal/actions/update-trust-portal-frameworks.ts
@@ -15,6 +15,7 @@ interface UpdateTrustPortalFrameworksParams {
hipaa?: boolean;
pcidss?: boolean;
nen7510?: boolean;
+ iso9001?: boolean;
soc2type1Status?: 'started' | 'in_progress' | 'compliant';
soc2type2Status?: 'started' | 'in_progress' | 'compliant';
iso27001Status?: 'started' | 'in_progress' | 'compliant';
@@ -23,6 +24,7 @@ interface UpdateTrustPortalFrameworksParams {
hipaaStatus?: 'started' | 'in_progress' | 'compliant';
pcidssStatus?: 'started' | 'in_progress' | 'compliant';
nen7510Status?: 'started' | 'in_progress' | 'compliant';
+ iso9001Status?: 'started' | 'in_progress' | 'compliant';
}
export async function updateTrustPortalFrameworks({
@@ -35,6 +37,8 @@ export async function updateTrustPortalFrameworks({
hipaa,
pcidss,
nen7510,
+ iso9001,
+ iso9001Status,
soc2type1Status,
soc2type2Status,
iso27001Status,
@@ -85,6 +89,8 @@ export async function updateTrustPortalFrameworks({
hipaa_status: hipaaStatus ?? trustPortal.hipaa_status,
pci_dss_status: pcidssStatus ?? trustPortal.pci_dss_status,
nen7510_status: nen7510Status ?? trustPortal.nen7510_status,
+ iso9001: iso9001 ?? trustPortal.iso9001,
+ iso9001_status: iso9001Status ?? trustPortal.iso9001_status,
},
});
diff --git a/apps/app/src/app/(app)/[orgId]/settings/trust-portal/components/TrustPortalSwitch.tsx b/apps/app/src/app/(app)/[orgId]/settings/trust-portal/components/TrustPortalSwitch.tsx
index 1a6d4c8cb..e90cb32c6 100644
--- a/apps/app/src/app/(app)/[orgId]/settings/trust-portal/components/TrustPortalSwitch.tsx
+++ b/apps/app/src/app/(app)/[orgId]/settings/trust-portal/components/TrustPortalSwitch.tsx
@@ -17,7 +17,17 @@ import { z } from 'zod';
import { isFriendlyAvailable } from '../actions/is-friendly-available';
import { trustPortalSwitchAction } from '../actions/trust-portal-switch';
import { updateTrustPortalFrameworks } from '../actions/update-trust-portal-frameworks';
-import { GDPR, HIPAA, ISO27001, SOC2Type1, SOC2Type2, PCIDSS, ISO42001, NEN7510 } from './logos';
+import {
+ GDPR,
+ HIPAA,
+ ISO27001,
+ ISO42001,
+ ISO9001,
+ NEN7510,
+ PCIDSS,
+ SOC2Type1,
+ SOC2Type2,
+} from './logos';
const trustPortalSwitchSchema = z.object({
enabled: z.boolean(),
@@ -31,6 +41,7 @@ const trustPortalSwitchSchema = z.object({
hipaa: z.boolean(),
pcidss: z.boolean(),
nen7510: z.boolean(),
+ iso9001: z.boolean(),
soc2type1Status: z.enum(['started', 'in_progress', 'compliant']),
soc2type2Status: z.enum(['started', 'in_progress', 'compliant']),
iso27001Status: z.enum(['started', 'in_progress', 'compliant']),
@@ -39,6 +50,7 @@ const trustPortalSwitchSchema = z.object({
hipaaStatus: z.enum(['started', 'in_progress', 'compliant']),
pcidssStatus: z.enum(['started', 'in_progress', 'compliant']),
nen7510Status: z.enum(['started', 'in_progress', 'compliant']),
+ iso9001Status: z.enum(['started', 'in_progress', 'compliant']),
});
export function TrustPortalSwitch({
@@ -64,6 +76,8 @@ export function TrustPortalSwitch({
pcidssStatus,
nen7510,
nen7510Status,
+ iso9001,
+ iso9001Status,
friendlyUrl,
}: {
enabled: boolean;
@@ -88,6 +102,8 @@ export function TrustPortalSwitch({
hipaaStatus: 'started' | 'in_progress' | 'compliant';
pcidssStatus: 'started' | 'in_progress' | 'compliant';
nen7510Status: 'started' | 'in_progress' | 'compliant';
+ iso9001: boolean;
+ iso9001Status: 'started' | 'in_progress' | 'compliant';
friendlyUrl: string | null;
}) {
const trustPortalSwitch = useAction(trustPortalSwitchAction, {
@@ -114,6 +130,7 @@ export function TrustPortalSwitch({
hipaa: hipaa ?? false,
pcidss: pcidss ?? false,
nen7510: nen7510 ?? false,
+ iso9001: iso9001 ?? false,
soc2type1Status: soc2type1Status ?? 'started',
soc2type2Status: soc2type2Status ?? 'started',
iso27001Status: iso27001Status ?? 'started',
@@ -122,6 +139,7 @@ export function TrustPortalSwitch({
hipaaStatus: hipaaStatus ?? 'started',
pcidssStatus: pcidssStatus ?? 'started',
nen7510Status: nen7510Status ?? 'started',
+ iso9001Status: iso9001Status ?? 'started',
friendlyUrl: friendlyUrl ?? undefined,
},
});
@@ -578,6 +596,35 @@ export function TrustPortalSwitch({
}
}}
/>
+ {/* ISO 9001 */}
+ {
+ try {
+ await updateTrustPortalFrameworks({
+ orgId,
+ iso9001Status: value as 'started' | 'in_progress' | 'compliant',
+ });
+ toast.success('ISO 9001 status updated');
+ } catch (error) {
+ toast.error('Failed to update ISO 9001 status');
+ }
+ }}
+ onToggle={async (checked) => {
+ try {
+ await updateTrustPortalFrameworks({
+ orgId,
+ iso9001: checked,
+ });
+ toast.success('ISO 9001 status updated');
+ } catch (error) {
+ toast.error('Failed to update ISO 9001 status');
+ }
+ }}
+ />
@@ -638,6 +685,10 @@ function ComplianceFramework({