rippletide 1.0.10 → 1.0.12

package/dist/App.d.ts

@@ -8,6 +8,7 @@ interface AppProps {
     pineconeUrl?: string;
     pineconeApiKey?: string;
     postgresqlConnection?: string;
+    pdfPath?: string;
     customHeaders?: Record<string, string>;
     customBodyTemplate?: string;
     customResponseField?: string;

package/dist/App.js

@@ -13,6 +13,7 @@ import { BaseError, ValidationError } from './errors/types.js';
 import { logger } from './utils/logger.js';
 const knowledgeSources = [
     { label: 'Local Files (qanda.json)', value: 'files', description: 'Use qanda.json from current directory' },
+    { label: 'PDF Document', value: 'pdf', description: 'Upload and extract knowledge from a PDF file' },
     { label: 'Pinecone', value: 'pinecone', description: 'Fetch Q&A from Pinecone database' },
     { label: 'PostgreSQL Database', value: 'postgresql', description: 'Connect to PostgreSQL database' },
     { label: 'Current Repository', value: 'repo', description: 'Scan current git repository', disabled: true },
@@ -20,7 +21,7 @@ const knowledgeSources = [
     { label: 'GitHub Repository', value: 'github', description: 'Import from GitHub repo', disabled: true },
     { label: 'Skip (No Knowledge)', value: 'skip', description: 'Run tests without knowledge base', disabled: true },
 ];
-export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: initialAgentEndpoint, knowledgeSource: initialKnowledgeSource, pineconeUrl: initialPineconeUrl, pineconeApiKey: initialPineconeApiKey, postgresqlConnection: initialPostgresqlConnection, customHeaders, customBodyTemplate, customResponseField, templatePath }) => {
+export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: initialAgentEndpoint, knowledgeSource: initialKnowledgeSource, pineconeUrl: initialPineconeUrl, pineconeApiKey: initialPineconeApiKey, postgresqlConnection: initialPostgresqlConnection, pdfPath: initialPdfPath, customHeaders, customBodyTemplate, customResponseField, templatePath }) => {
     const { exit } = useApp();
     const initialStep = nonInteractive && initialAgentEndpoint ? 'testing-connection' : 'agent-endpoint';
     const [step, setStep] = useState(initialStep);
@@ -40,6 +41,10 @@ export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: i
     const [postgresqlConnectionString, setPostgresqlConnectionString] = useState(initialPostgresqlConnection || '');
     const [postgresqlQAndA, setPostgresqlQAndA] = useState([]);
     const [postgresqlProgress, setPostgresqlProgress] = useState('');
+    const [pdfPath, setPdfPath] = useState(initialPdfPath || '');
+    const [pdfQAndA, setPdfQAndA] = useState([]);
+    const [pdfProgress, setPdfProgress] = useState('');
+    const [currentAgentId, setCurrentAgentId] = useState('');
     const [evaluationProgress, setEvaluationProgress] = useState(0);
     const [evaluationResult, setEvaluationResult] = useState(null);
     const [currentQuestion, setCurrentQuestion] = useState('');
@@ -141,6 +146,15 @@ export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: i
                             process.exit(1);
                         }
                     }
+                    else if (knowledgeSource === 'pdf') {
+                        if (pdfPath) {
+                            setStep('uploading-pdf');
+                        }
+                        else {
+                            console.error('PDF path required for PDF source');
+                            process.exit(1);
+                        }
+                    }
                     else {
                         setStep('running-evaluation');
                     }
@@ -220,6 +234,39 @@ export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: i
             })();
         }
     }, [step, postgresqlConnectionString, backendUrl]);
+    useEffect(() => {
+        if (step === 'uploading-pdf') {
+            (async () => {
+                try {
+                    const startTime = Date.now();
+                    setPdfProgress('Generating API key...');
+                    await api.generateApiKey('CLI Evaluation');
+                    setPdfProgress('Creating agent...');
+                    const agent = await api.createAgent(agentEndpoint);
+                    const agentId = agent.id;
+                    setCurrentAgentId(agentId);
+                    setPdfProgress('Uploading PDF file...');
+                    const { uploadPdfToAgent } = await import('./api/knowledge.js');
+                    const { qaPairs } = await uploadPdfToAgent(agentId, pdfPath, (message) => setPdfProgress(message));
+                    setPdfQAndA(qaPairs);
+                    setStep('running-evaluation');
+                }
+                catch (error) {
+                    logger.error('Error uploading PDF:', error);
+                    const errorMessage = error instanceof BaseError ? error.userMessage : error.message;
+                    setEvaluationResult({
+                        totalTests: 0,
+                        passed: 0,
+                        failed: 0,
+                        duration: 'Failed',
+                        evaluationUrl: dashboardUrl || 'https://eval.rippletide.com',
+                        error: errorMessage,
+                    });
+                    setStep('complete');
+                }
+            })();
+        }
+    }, [step, pdfPath, agentEndpoint, dashboardUrl]);
     useEffect(() => {
         if (step === 'running-evaluation') {
             (async () => {
@@ -229,8 +276,14 @@ export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: i
                     setEvaluationProgress(5);
                     await api.generateApiKey('CLI Evaluation');
                     setEvaluationProgress(10);
-                    const agent = await api.createAgent(agentEndpoint);
-                    const agentId = agent.id;
+                    let agentId = currentAgentId;
+                    if (!agentId) {
+                        // Ensure we have a body template for the evaluation
+                        const effectiveBodyTemplate = customConfig.bodyTemplate || '{"message": "[eval-question]"}';
+                        const agent = await api.createAgent(agentEndpoint, effectiveBodyTemplate);
+                        agentId = agent.id;
+                        setCurrentAgentId(agentId);
+                    }
                     setEvaluationProgress(30);
                     setEvaluationProgress(40);
                     let testPrompts = [];
@@ -290,8 +343,19 @@ export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: i
                             answer: item.answer
                         }));
                     }
+                    else if (knowledgeSource === 'pdf' && pdfQAndA.length > 0) {
+                        testPrompts = pdfQAndA.slice(0, 5).map((item) => ({
+                            question: item.question,
+                            answer: item.answer
+                        }));
+                    }
                     const createdPrompts = await api.addTestPrompts(agentId, testPrompts);
                     setEvaluationProgress(50);
+                    // Ensure customConfig has the body template for evaluation
+                    const evalConfig = {
+                        ...customConfig,
+                        bodyTemplate: customConfig.bodyTemplate || '{"message": "[eval-question]"}'
+                    };
                     const evaluationResults = await api.runAllPromptEvaluations(agentId, createdPrompts, agentEndpoint, (current, total, question, llmResponse) => {
                         const progress = 50 + Math.round((current / total) * 40);
                         setEvaluationProgress(progress);
@@ -303,7 +367,7 @@ export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: i
                             logs.push({ question: question || '', response: llmResponse });
                             setEvaluationLogs([...logs]);
                         }
-                    }, customConfig);
+                    }, evalConfig);
                     setEvaluationProgress(100);
                     let passed = 0;
                     let failed = 0;
@@ -345,7 +409,7 @@ export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: i
                 }
             })();
         }
-    }, [step, agentEndpoint, knowledgeSource, pineconeQAndA, postgresqlQAndA]);
+    }, [step, agentEndpoint, knowledgeSource, pineconeQAndA, postgresqlQAndA, pdfQAndA, currentAgentId]);
     const handleAgentEndpointSubmit = (value) => {
         const trimmedValue = value.trim();
         if (!trimmedValue) {
@@ -362,6 +426,9 @@ export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: i
         else if (value === 'postgresql') {
             setStep('postgresql-config');
         }
+        else if (value === 'pdf') {
+            setStep('pdf-path-input');
+        }
         else {
             setStep('running-evaluation');
         }
@@ -378,6 +445,10 @@ export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: i
         setPostgresqlConnectionString(value);
         setStep('fetching-postgresql');
     };
+    const handlePdfPathSubmit = (value) => {
+        setPdfPath(value);
+        setStep('uploading-pdf');
+    };
     return (React.createElement(Box, { flexDirection: "column", padding: 1 },
         React.createElement(Header, null),
         step === 'agent-endpoint' && (React.createElement(Box, { flexDirection: "column" },
@@ -542,6 +613,18 @@ export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: i
             React.createElement(TextInput, { label: "PostgreSQL connection", placeholder: "postgresql://postgres:password@localhost:5432/mydb", onSubmit: handlePostgresqlConnectionSubmit }))),
         step === 'fetching-postgresql' && (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Spinner, { label: postgresqlProgress || "Analyzing PostgreSQL database..." }))),
+        step === 'pdf-path-input' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "#eba1b5" }, "Enter the path to your PDF file")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true }, "Examples:"),
+                React.createElement(Box, { paddingLeft: 2, flexDirection: "column" },
+                    React.createElement(Text, { dimColor: true }, "- ./docs/manual.pdf"),
+                    React.createElement(Text, { dimColor: true }, "- /home/user/documents/guide.pdf"),
+                    React.createElement(Text, { dimColor: true }, "- ../knowledge/faq.pdf"))),
+            React.createElement(TextInput, { label: "PDF path", placeholder: "./document.pdf", onSubmit: handlePdfPathSubmit }))),
+        step === 'uploading-pdf' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Spinner, { label: pdfProgress || "Uploading PDF file..." }))),
         step === 'running-evaluation' && (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 2 },
                 React.createElement(Spinner, { label: "Running evaluation" })),

package/dist/api/endpoint.js

@@ -25,6 +25,9 @@ export function normalizeEndpoint(endpoint) {
 }
 export function generatePayloadVariants(question) {
     const variants = [];
+    variants.push({
+        messages: [{ role: 'user', content: question }]
+    });
     variants.push({ message: question });
     variants.push({ inputs: question });
     variants.push({
@@ -39,9 +42,6 @@ export function generatePayloadVariants(question) {
     variants.push({ input: question });
     variants.push({ text: question });
     variants.push({ user_message: question });
-    variants.push({
-        messages: [{ role: 'user', content: question }]
-    });
     variants.push({ data: question });
     variants.push({ content: question });
     variants.push(question);
@@ -49,11 +49,17 @@ export function generatePayloadVariants(question) {
 }
 export function buildCustomPayload(template, question) {
     try {
-        const replaced = template.replace(/{question}/g, question);
+        let replaced = template
+            .replace(/\[eval-question\]/g, question)
+            .replace(/\{\{question\}\}/g, question)
+            .replace(/\{question\}/g, question);
         return JSON.parse(replaced);
     }
     catch (e) {
-        return template.replace(/{question}/g, question);
+        return template
+            .replace(/\[eval-question\]/g, question)
+            .replace(/\{\{question\}\}/g, question)
+            .replace(/\{question\}/g, question);
     }
 }
 export function createAxiosClient(customConfig) {

package/dist/api/evaluation.d.ts

@@ -17,7 +17,7 @@ export interface PromptEvaluationResult {
 }
 export declare function setBackendUrl(url: string): void;
 export declare function generateApiKey(name?: string): Promise<any>;
-export declare function createAgent(publicUrl: string): Promise<any>;
+export declare function createAgent(publicUrl: string, customPayloadTemplate?: string): Promise<any>;
 export declare function addTestPrompts(agentId: string, prompts?: string[] | Array<{
     question: string;
     answer?: string;

package/dist/api/evaluation.js

@@ -35,6 +35,8 @@ export async function generateApiKey(name) {
         API_KEY = response.data.apiKey;
         logger.info('API key generated successfully');
         logger.debug('API Key:', API_KEY?.substring(0, 12) + '...');
+        const { setApiClient } = await import('./knowledge.js');
+        setApiClient(client, API_KEY);
         return response.data;
     }
     catch (error) {
@@ -42,7 +44,7 @@ export async function generateApiKey(name) {
         throw error;
     }
 }
-export async function createAgent(publicUrl) {
+export async function createAgent(publicUrl, customPayloadTemplate) {
     try {
         const response = await client.post('/api/agents', {
             name: `Agent Eval ${Date.now()}`,
@@ -51,6 +53,22 @@ export async function createAgent(publicUrl) {
             publicUrl: publicUrl,
             label: 'eval',
         });
+        const agentId = response.data.id;
+        const payloadTemplate = customPayloadTemplate || '{"message": "[eval-question]"}';
+        logger.debug(`Configuring advanced payload for agent ${agentId}`);
+        logger.debug(`Payload template: ${payloadTemplate}`);
+        try {
+            await client.patch(`/api/agents/${agentId}`, {
+                advancedPayload: {
+                    payload: payloadTemplate
+                }
+            });
+            logger.debug('Advanced payload configured successfully');
+        }
+        catch (patchError) {
+            logger.warn('Could not set advanced payload:', patchError?.message);
+            logger.debug('Will use default payload format');
+        }
         return response.data;
     }
     catch (error) {

package/dist/api/knowledge.d.ts

@@ -12,6 +12,12 @@ export declare function getTestResults(agentId: string): Promise<any>;
 export interface EvaluationConfig {
     agentEndpoint: string;
     knowledgeSource?: string;
+    customConfig?: {
+        headers?: Record<string, string>;
+        bodyTemplate?: string;
+        responseField?: string;
+        method?: string;
+    };
 }
 export interface EvaluationResult {
     totalTests: number;
@@ -21,6 +27,12 @@ export interface EvaluationResult {
     evaluationUrl: string;
     agentId?: string;
 }
+export declare function uploadPdfToAgent(agentId: string, pdfPath: string, onProgress?: (message: string) => void): Promise<{
+    qaPairs: Array<{
+        question: string;
+        answer: string;
+    }>;
+}>;
 export declare function runEvaluation(config: EvaluationConfig, onProgress?: (progress: number) => void): Promise<{
     totalTests: any;
     passed: number;

package/dist/api/knowledge.js

@@ -1,7 +1,9 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import axios from 'axios';
+import FormData from 'form-data';
 import { logger } from '../utils/logger.js';
+import { PdfUploadError, PdfValidationError } from '../errors/types.js';
 let client = axios.create({
     baseURL: 'https://rippletide-backend.azurewebsites.net',
     headers: {
@@ -59,13 +61,75 @@ export async function getTestResults(agentId) {
         return [];
     }
 }
+export async function uploadPdfToAgent(agentId, pdfPath, onProgress) {
+    try {
+        if (!fs.existsSync(pdfPath)) {
+            throw new PdfValidationError(pdfPath, 'not_found');
+        }
+        const stats = fs.statSync(pdfPath);
+        const MAX_SIZE = 10 * 1024 * 1024;
+        if (stats.size > MAX_SIZE) {
+            throw new PdfValidationError(pdfPath, 'too_large', {
+                fileSize: stats.size,
+                maxSize: MAX_SIZE
+            });
+        }
+        const fileName = path.basename(pdfPath);
+        const fileBuffer = fs.readFileSync(pdfPath);
+        const fileSizeKB = Math.round(fileBuffer.length / 1024);
+        if (onProgress) {
+            onProgress(`Uploading ${fileName} (${fileSizeKB}KB) - this may take a few minutes...`);
+        }
+        const formData = new FormData();
+        formData.append('file', fileBuffer, {
+            filename: fileName,
+            contentType: 'application/pdf'
+        });
+        const response = await client.post(`/api/agents/${agentId}/upload-pdf`, formData, {
+            headers: {
+                ...formData.getHeaders(),
+                ...(API_KEY ? { 'x-api-key': API_KEY } : {})
+            },
+            maxBodyLength: Infinity,
+            maxContentLength: Infinity,
+            timeout: 300000 // 5 minutes timeout for PDF processing
+        });
+        if (!response.data.success) {
+            throw new PdfUploadError('upload', response.data.message || 'Upload failed', pdfPath);
+        }
+        if (onProgress) {
+            onProgress('Processing PDF and generating Q&A pairs...');
+        }
+        const qaPairs = response.data.processed?.qaPairs || [];
+        if (qaPairs.length === 0) {
+            throw new PdfUploadError('extract', 'No Q&A pairs generated from PDF', pdfPath);
+        }
+        if (onProgress) {
+            onProgress(`Generated ${qaPairs.length} Q&A pairs`);
+        }
+        return {
+            qaPairs: qaPairs.map((pair) => ({
+                question: pair.question,
+                answer: pair.answer
+            }))
+        };
+    }
+    catch (error) {
+        if (error instanceof PdfValidationError || error instanceof PdfUploadError) {
+            throw error;
+        }
+        logger.error('Error uploading PDF:', error);
+        throw new PdfUploadError('upload', error.message || 'Unknown error', pdfPath, error);
+    }
+}
 export async function runEvaluation(config, onProgress) {
     const { generateApiKey, createAgent, addTestPrompts, runAllPromptEvaluations } = await import('./evaluation.js');
     try {
         const startTime = Date.now();
         if (onProgress)
             onProgress(10);
-        const agent = await createAgent(config.agentEndpoint);
+        const payloadTemplate = config.customConfig?.bodyTemplate || '{"message": "[eval-question]"}';
+        const agent = await createAgent(config.agentEndpoint, payloadTemplate);
         const agentId = agent.id;
         if (onProgress)
             onProgress(30);

package/dist/errors/types.d.ts

@@ -13,6 +13,8 @@ export declare enum ErrorCode {
     DATABASE_ERROR = "DATABASE_ERROR",
     PINECONE_ERROR = "PINECONE_ERROR",
     POSTGRESQL_ERROR = "POSTGRESQL_ERROR",
+    PDF_UPLOAD_ERROR = "PDF_UPLOAD_ERROR",
+    PDF_VALIDATION_ERROR = "PDF_VALIDATION_ERROR",
     EVALUATION_ERROR = "EVALUATION_ERROR",
     UNKNOWN_ERROR = "UNKNOWN_ERROR"
 }
@@ -39,6 +41,12 @@ export declare class FileError extends BaseError {
 export declare class DatabaseError extends BaseError {
     constructor(dbType: 'pinecone' | 'postgresql', operation: string, originalError?: any);
 }
+export declare class PdfUploadError extends BaseError {
+    constructor(operation: 'upload' | 'process' | 'extract', reason: string, filePath?: string, originalError?: any);
+}
+export declare class PdfValidationError extends BaseError {
+    constructor(filePath: string, reason: 'not_found' | 'too_large' | 'invalid_format' | 'no_permission', details?: any);
+}
 export declare class EvaluationError extends BaseError {
     constructor(stage: string, reason: string, details?: any);
 }

package/dist/errors/types.js

@@ -14,6 +14,8 @@ export var ErrorCode;
     ErrorCode["DATABASE_ERROR"] = "DATABASE_ERROR";
     ErrorCode["PINECONE_ERROR"] = "PINECONE_ERROR";
     ErrorCode["POSTGRESQL_ERROR"] = "POSTGRESQL_ERROR";
+    ErrorCode["PDF_UPLOAD_ERROR"] = "PDF_UPLOAD_ERROR";
+    ErrorCode["PDF_VALIDATION_ERROR"] = "PDF_VALIDATION_ERROR";
     ErrorCode["EVALUATION_ERROR"] = "EVALUATION_ERROR";
     ErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
 })(ErrorCode || (ErrorCode = {}));
@@ -96,6 +98,27 @@ export class DatabaseError extends BaseError {
         super(code, `${dbName} ${operation} failed: ${originalError?.message || 'Unknown error'}`, `Failed to ${operation} with ${dbName}. Please check your connection details and try again.`, true, { dbType, operation, originalError });
     }
 }
+export class PdfUploadError extends BaseError {
+    constructor(operation, reason, filePath, originalError) {
+        const userMessages = {
+            upload: `Failed to upload PDF: ${reason}`,
+            process: `Failed to process PDF: ${reason}`,
+            extract: `Failed to extract Q&A from PDF: ${reason}`
+        };
+        super(ErrorCode.PDF_UPLOAD_ERROR, `PDF ${operation} error: ${reason}`, userMessages[operation], operation === 'upload', { filePath, operation, originalError });
+    }
+}
+export class PdfValidationError extends BaseError {
+    constructor(filePath, reason, details) {
+        const userMessages = {
+            not_found: `PDF file not found: ${filePath}`,
+            too_large: `PDF file is too large (max 10MB): ${filePath}`,
+            invalid_format: `File is not a valid PDF: ${filePath}`,
+            no_permission: `No permission to read PDF file: ${filePath}`
+        };
+        super(ErrorCode.PDF_VALIDATION_ERROR, `PDF validation error: ${reason} - ${filePath}`, userMessages[reason], false, { filePath, reason, ...details });
+    }
+}
 export class EvaluationError extends BaseError {
     constructor(stage, reason, details) {
         super(ErrorCode.EVALUATION_ERROR, `Evaluation failed at ${stage}: ${reason}`, `Evaluation could not complete: ${reason}`, false, { stage, ...details });

package/dist/index.js

@@ -65,6 +65,10 @@ const parseArgs = () => {
             options.knowledgeSource = args[i + 1];
             i++;
         }
+        else if ((args[i] === '--pdf-path' || args[i] === '-pp') && args[i + 1]) {
+            options.pdfPath = args[i + 1];
+            i++;
+        }
         else if ((args[i] === '--pinecone-url' || args[i] === '-pu') && args[i + 1]) {
             options.pineconeUrl = args[i + 1];
             i++;
@@ -116,7 +120,7 @@ Commands:
 Options:
   -t, --template <name>       Use a pre-configured template
   -a, --agent <url>           Agent endpoint URL (e.g., localhost:8000)
-  -k, --knowledge <source>    Knowledge source: files, pinecone, or postgresql (default: files)
+  -k, --knowledge <source>    Knowledge source: files, pinecone, postgresql, or pdf (default: files)
   -b, --backend-url <url>     Backend API URL (default: https://rippletide-backend.azurewebsites.net)
   -d, --dashboard-url <url>   Dashboard URL (default: https://eval.rippletide.com)
   
@@ -127,6 +131,9 @@ Options:
   PostgreSQL options:
   -pg, --postgresql <conn>    PostgreSQL connection string or comma-separated values
   
+  PDF options:
+  -pp, --pdf-path <path>      Path to PDF file for knowledge extraction
+  
   Custom endpoint options:
   -H, --headers <headers>     Custom headers (e.g., "Authorization: Bearer token, X-API-Key: key")
   -B, --body <template>       Custom body template (use {question} as placeholder)
@@ -155,6 +162,9 @@ Examples:
   # Direct evaluation with PostgreSQL
   rippletide eval -a localhost:8000 -k postgresql -pg "postgresql://user:pass@localhost:5432/db"
   
+  # Direct evaluation with PDF
+  rippletide eval -a localhost:8000 -k pdf -pp ./docs/manual.pdf
+  
   # With custom headers and body
   rippletide eval -a localhost:8000 -H "Authorization: Bearer token" -B '{"prompt": "{question}"}'
 `);
@@ -170,7 +180,7 @@ async function run() {
     try {
         const options = parseArgs();
         process.stdout.write('\x1Bc');
-        const { waitUntilExit } = render(React.createElement(App, { backendUrl: options.backendUrl, dashboardUrl: options.dashboardUrl, nonInteractive: options.nonInteractive, agentEndpoint: options.agentEndpoint, knowledgeSource: options.knowledgeSource, pineconeUrl: options.pineconeUrl, pineconeApiKey: options.pineconeApiKey, postgresqlConnection: options.postgresqlConnection, customHeaders: options.headers, customBodyTemplate: options.bodyTemplate, customResponseField: options.responseField, templatePath: options.templatePath }));
+        const { waitUntilExit } = render(React.createElement(App, { backendUrl: options.backendUrl, dashboardUrl: options.dashboardUrl, nonInteractive: options.nonInteractive, agentEndpoint: options.agentEndpoint, knowledgeSource: options.knowledgeSource, pineconeUrl: options.pineconeUrl, pineconeApiKey: options.pineconeApiKey, postgresqlConnection: options.postgresqlConnection, customHeaders: options.headers, customBodyTemplate: options.bodyTemplate, customResponseField: options.responseField, templatePath: options.templatePath, pdfPath: options.pdfPath }));
         await waitUntilExit();
     }
     catch (error) {

package/dist/utils/pdf.d.ts

@@ -0,0 +1,28 @@
+export interface QAPair {
+    question: string;
+    answer: string;
+}
+export interface PdfUploadResponse {
+    success: boolean;
+    message: string;
+    file?: {
+        originalName: string;
+        size: number;
+        mimetype: string;
+    };
+    processed?: {
+        totalChunks: number;
+        chunks: Array<{
+            text: string;
+            type: string;
+        }>;
+        qaPairs: Array<{
+            question: string;
+            answer: string;
+            sourceChunk?: string;
+            chunkType?: string;
+        }>;
+        totalQAPairs: number;
+    };
+}
+export declare function getPdfQAndA(pdfPath: string, agentId: string, backendUrl: string, onProgress?: (message: string) => void): Promise<QAPair[]>;

package/dist/utils/pdf.js

@@ -0,0 +1,100 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import FormData from 'form-data';
+import axios from 'axios';
+import { PdfUploadError, PdfValidationError } from '../errors/types.js';
+import { logger } from './logger.js';
+const MAX_FILE_SIZE = 10 * 1024 * 1024;
+function validatePdfFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        throw new PdfValidationError(filePath, 'not_found');
+    }
+    const stats = fs.statSync(filePath);
+    if (!stats.isFile()) {
+        throw new PdfValidationError(filePath, 'invalid_format', { reason: 'Path is not a file' });
+    }
+    if (stats.size > MAX_FILE_SIZE) {
+        throw new PdfValidationError(filePath, 'too_large', {
+            fileSize: stats.size,
+            maxSize: MAX_FILE_SIZE
+        });
+    }
+    try {
+        fs.accessSync(filePath, fs.constants.R_OK);
+    }
+    catch (error) {
+        throw new PdfValidationError(filePath, 'no_permission');
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext !== '.pdf') {
+        throw new PdfValidationError(filePath, 'invalid_format', {
+            extension: ext,
+            expected: '.pdf'
+        });
+    }
+}
+export async function getPdfQAndA(pdfPath, agentId, backendUrl, onProgress) {
+    try {
+        if (onProgress)
+            onProgress('Validating PDF file...');
+        validatePdfFile(pdfPath);
+        const fileName = path.basename(pdfPath);
+        const fileBuffer = fs.readFileSync(pdfPath);
+        if (onProgress)
+            onProgress(`Uploading ${fileName} (${Math.round(fileBuffer.length / 1024)}KB)...`);
+        const formData = new FormData();
+        formData.append('file', fileBuffer, {
+            filename: fileName,
+            contentType: 'application/pdf'
+        });
+        const uploadUrl = `${backendUrl}/api/agents/${agentId}/upload-pdf`;
+        logger.debug(`Uploading PDF to: ${uploadUrl}`);
+        logger.debug(`File: ${fileName}, Size: ${fileBuffer.length} bytes`);
+        const response = await axios.post(uploadUrl, formData, {
+            headers: {
+                ...formData.getHeaders()
+            },
+            maxBodyLength: Infinity,
+            maxContentLength: Infinity,
+            timeout: 300000 // 5 minutes timeout for PDF processing
+        });
+        if (!response.data.success) {
+            throw new PdfUploadError('upload', response.data.message || 'Upload failed', pdfPath);
+        }
+        if (onProgress)
+            onProgress('Processing PDF content...');
+        if (!response.data.processed || !response.data.processed.qaPairs) {
+            throw new PdfUploadError('extract', 'No Q&A pairs generated from PDF', pdfPath);
+        }
+        const qaPairs = response.data.processed.qaPairs;
+        if (onProgress) {
+            onProgress(`Generated ${qaPairs.length} Q&A pairs from ${response.data.processed.totalChunks} chunks`);
+        }
+        return qaPairs.map(pair => ({
+            question: pair.question,
+            answer: pair.answer
+        }));
+    }
+    catch (error) {
+        if (error instanceof PdfValidationError || error instanceof PdfUploadError) {
+            throw error;
+        }
+        if (error.response) {
+            const status = error.response.status;
+            const message = error.response.data?.message || error.response.statusText;
+            if (status === 413) {
+                throw new PdfValidationError(pdfPath, 'too_large', {
+                    serverMessage: message
+                });
+            }
+            throw new PdfUploadError('upload', `Server error (${status}): ${message}`, pdfPath, error);
+        }
+        if (error.code === 'ECONNREFUSED') {
+            throw new PdfUploadError('upload', 'Cannot connect to backend server', pdfPath, error);
+        }
+        if (error.code === 'ETIMEDOUT') {
+            throw new PdfUploadError('upload', 'Upload timed out - file may be too large', pdfPath, error);
+        }
+        throw new PdfUploadError('upload', error.message || 'Unknown error', pdfPath, error);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rippletide",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "Rippletide Evaluation CLI",
   "main": "dist/index.js",
   "bin": {
@@ -33,8 +33,10 @@
     "axios": "^1.13.2",
     "chalk": "^5.3.0",
     "drizzle-orm": "^0.38.3",
+    "form-data": "^4.0.0",
     "ink": "^5.0.1",
     "ink-text-input": "^6.0.0",
+    "mime-types": "^2.1.35",
     "node-fetch": "^3.3.2",
     "pg": "^8.13.1",
     "react": "^18.3.1",
@@ -48,6 +50,7 @@
     "@types/node-fetch": "^2.6.13",
     "@types/pg": "^8.16.0",
     "@types/react": "^18.3.18",
+    "@types/mime-types": "^2.1.4",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2"
   }