rippletide 1.0.13 → 1.0.15

package/bin/rippletide

@@ -13,12 +13,6 @@ async function loadErrorHandler() {
 }
 
 async function main() {
-  if (!cmd || cmd === 'eval') {
-    process.argv = ['node', 'dist/index.js', ...args.slice(cmd === 'eval' ? 1 : 0)];
-    await import('../dist/index.js');
-    return;
-  }
-
   if (cmd === 'list-templates' || cmd === 'templates') {
     process.argv = ['node', 'dist/index.js', ...args];
     await import('../dist/index.js');
@@ -26,29 +20,13 @@ async function main() {
   }
 
   if (cmd === '--help' || cmd === '-h') {
-    console.log(`
-Rippletide CLI
-
-Usage:
-  rippletide eval [options]        Run the Rippletide evaluation UI
-
-Options:
-  -b, --backend-url <url>     Backend API URL (default: https://rippletide-backend.azurewebsites.net)
-  -d, --dashboard-url <url>   Dashboard URL (default: https://eval.rippletide.com)
-  --debug                      Show detailed error information and stack traces
-  -h, --help                  Show this help message
-
-Examples:
-  rippletide eval
-  rippletide eval -b http://localhost:3001 -d http://localhost:5173
-  rippletide eval --debug
-`);
+    process.argv = ['node', 'dist/index.js', '--help'];
+    await import('../dist/index.js');
     return;
   }
 
-  console.error(`Unknown command: ${cmd}`);
-  console.log(`Run "rippletide --help" for usage.`);
-  process.exit(1);
+  process.argv = ['node', 'dist/index.js', ...args.slice(cmd === 'eval' ? 1 : 0)];
+  await import('../dist/index.js');
 }
 
 main().catch(async (err) => {

package/dist/App.d.ts

@@ -13,6 +13,7 @@ interface AppProps {
     customBodyTemplate?: string;
     customResponseField?: string;
     templatePath?: string;
+    isRemoteTemplate?: boolean;
 }
 export declare const App: React.FC<AppProps>;
 export {};

package/dist/App.js

@@ -22,7 +22,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, pdfPath: initialPdfPath, 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, isRemoteTemplate }) => {
     const { exit } = useApp();
     const initialStep = nonInteractive && initialAgentEndpoint ? 'testing-connection' : 'agent-endpoint';
     const [step, setStep] = useState(initialStep);
@@ -299,25 +299,82 @@ export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: i
                         setCurrentAgentId(agentId);
                     }
                     setEvaluationProgress(30);
+                    if (knowledgeSource === 'files') {
+                        let knowledgeData = null;
+                        if (templatePath) {
+                            try {
+                                if (isRemoteTemplate) {
+                                    const axios = await import('axios');
+                                    const qandaUrl = `${templatePath}/qanda.json`;
+                                    const response = await axios.default.get(qandaUrl, { timeout: 5000 });
+                                    knowledgeData = response.data;
+                                }
+                                else {
+                                    const fs = await import('fs');
+                                    const path = await import('path');
+                                    const qandaPath = path.join(templatePath, 'qanda.json');
+                                    if (fs.existsSync(qandaPath)) {
+                                        knowledgeData = JSON.parse(fs.readFileSync(qandaPath, 'utf-8'));
+                                    }
+                                }
+                            }
+                            catch (error) {
+                                logger.debug('Error loading knowledge from template:', error);
+                            }
+                        }
+                        else {
+                            const knowledgeResult = await api.checkKnowledge();
+                            if (knowledgeResult.found && knowledgeResult.path) {
+                                try {
+                                    const fs = await import('fs');
+                                    knowledgeData = JSON.parse(fs.readFileSync(knowledgeResult.path, 'utf-8'));
+                                }
+                                catch (error) {
+                                    logger.debug('Error loading knowledge:', error);
+                                }
+                            }
+                        }
+                        if (knowledgeData) {
+                            setEvaluationProgress(35);
+                            try {
+                                const importResult = await api.importKnowledge(agentId, knowledgeData);
+                                logger.debug('Knowledge import result:', importResult);
+                                await new Promise(resolve => setTimeout(resolve, 1000));
+                            }
+                            catch (error) {
+                                logger.error('Failed to import knowledge:', error?.message || error);
+                                logger.debug('Import error details:', error?.response?.data);
+                            }
+                        }
+                    }
                     setEvaluationProgress(40);
                     let testPrompts = [];
                     if (knowledgeSource === 'files') {
                         if (templatePath) {
                             try {
-                                const fs = await import('fs');
-                                const path = await import('path');
-                                const qandaPath = path.join(templatePath, 'qanda.json');
-                                if (fs.existsSync(qandaPath)) {
-                                    const knowledgeData = JSON.parse(fs.readFileSync(qandaPath, 'utf-8'));
-                                    if (Array.isArray(knowledgeData)) {
-                                        testPrompts = knowledgeData.map((item) => ({
-                                            question: item.question || item.prompt || item.input || 'Test question',
-                                            answer: item.answer || item.response || item.expectedAnswer
-                                        }));
-                                    }
+                                let knowledgeData = null;
+                                if (isRemoteTemplate) {
+                                    const axios = await import('axios');
+                                    const qandaUrl = `${templatePath}/qanda.json`;
+                                    const response = await axios.default.get(qandaUrl, { timeout: 5000 });
+                                    knowledgeData = response.data;
                                 }
                                 else {
-                                    logger.debug('No qanda.json found in template directory:', templatePath);
+                                    const fs = await import('fs');
+                                    const path = await import('path');
+                                    const qandaPath = path.join(templatePath, 'qanda.json');
+                                    if (fs.existsSync(qandaPath)) {
+                                        knowledgeData = JSON.parse(fs.readFileSync(qandaPath, 'utf-8'));
+                                    }
+                                    else {
+                                        logger.debug('No qanda.json found in template directory:', templatePath);
+                                    }
+                                }
+                                if (knowledgeData && Array.isArray(knowledgeData)) {
+                                    testPrompts = knowledgeData.map((item) => ({
+                                        question: item.question || item.prompt || item.input || 'Test question',
+                                        answer: item.answer || item.response || item.expectedAnswer
+                                    }));
                                 }
                             }
                             catch (error) {
@@ -365,7 +422,6 @@ export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: i
                     }
                     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]"}'

package/dist/api/knowledge.d.ts

@@ -7,7 +7,10 @@ export declare function checkKnowledge(folderPath?: string): Promise<{
     found: boolean;
     path?: undefined;
 }>;
-export declare function importKnowledge(agentId: string, knowledgeData: any): Promise<any>;
+export declare function importKnowledge(agentId: string, knowledgeData: any): Promise<{
+    imported: number;
+    total: number;
+} | null>;
 export declare function getTestResults(agentId: string): Promise<any>;
 export interface EvaluationConfig {
     agentEndpoint: string;

package/dist/api/knowledge.js

@@ -41,14 +41,44 @@ export async function checkKnowledge(folderPath = '.') {
 }
 export async function importKnowledge(agentId, knowledgeData) {
     try {
-        const response = await client.post(`/api/agents/${agentId}/knowledge/import`, {
-            data: knowledgeData,
-        });
-        return response.data;
+        logger.debug('Importing knowledge for agent:', agentId);
+        logger.debug('Knowledge data type:', Array.isArray(knowledgeData) ? 'array' : typeof knowledgeData);
+        logger.debug('Knowledge data length:', Array.isArray(knowledgeData) ? knowledgeData.length : 'N/A');
+        if (!Array.isArray(knowledgeData)) {
+            logger.warn('Knowledge data is not an array, skipping import');
+            return null;
+        }
+        let importedCount = 0;
+        for (const item of knowledgeData) {
+            try {
+                const question = item.question || item.prompt || item.input;
+                const answer = item.answer || item.response || item.expectedAnswer;
+                if (!question || !answer) {
+                    logger.debug('Skipping item without question or answer:', item);
+                    continue;
+                }
+                const response = await client.post(`/api/agents/${agentId}/config`, {
+                    label: question,
+                    description: answer,
+                    type: 'knowledge'
+                });
+                importedCount++;
+                logger.debug(`Imported Q&A ${importedCount}/${knowledgeData.length}: ${question.substring(0, 50)}...`);
+            }
+            catch (error) {
+                logger.warn(`Failed to import Q&A pair: ${error?.message || error}`);
+                logger.debug('Q&A import error details:', error?.response?.data);
+                logger.debug('Q&A import error status:', error?.response?.status);
+            }
+        }
+        logger.info(`Knowledge imported successfully: ${importedCount}/${knowledgeData.length} Q&A pairs`);
+        return { imported: importedCount, total: knowledgeData.length };
     }
     catch (error) {
-        logger.error('Error importing knowledge:', error);
-        return null;
+        logger.error('Error importing knowledge:', error?.message || error);
+        logger.debug('Error details:', error?.response?.data);
+        logger.debug('Error status:', error?.response?.status);
+        throw error;
     }
 }
 export async function getTestResults(agentId) {

package/dist/index.js

@@ -6,13 +6,13 @@ import { ErrorHandler } from './errors/handler.js';
 import { ValidationError } from './errors/types.js';
 import { listTemplates, loadTemplate, getTemplateOptions } from './utils/templates.js';
 import { analytics } from './utils/analytics.js';
-const parseArgs = () => {
+const parseArgs = async () => {
     const args = process.argv.slice(2);
     if (args[0] === 'list-templates' || args[0] === 'templates') {
-        const templates = listTemplates();
+        const templates = await listTemplates();
         console.log('\nAvailable Templates:\n');
         if (templates.length === 0) {
-            console.log('No templates found in ./templates directory');
+            console.log('No templates found');
         }
         else {
             templates.forEach(template => {
@@ -37,15 +37,15 @@ const parseArgs = () => {
     };
     for (let i = 0; i < args.length; i++) {
         if ((args[i] === '--template' || args[i] === '-t') && args[i + 1]) {
-            const template = loadTemplate(args[i + 1]);
+            const template = await loadTemplate(args[i + 1]);
             if (!template) {
                 console.error(`Template '${args[i + 1]}' not found.`);
                 console.log('\nAvailable templates:');
-                const templates = listTemplates();
+                const templates = await listTemplates();
                 templates.forEach(t => console.log(`  - ${t.name}`));
                 process.exit(1);
             }
-            const templateOptions = getTemplateOptions(template);
+            const templateOptions = await getTemplateOptions(template);
             Object.assign(options, templateOptions);
             i++;
         }
@@ -184,14 +184,12 @@ Examples:
 };
 async function run() {
     try {
-        const options = parseArgs();
-        // Check if this is a new user
+        const options = await parseArgs();
         const fs = await import('fs');
         const path = await import('path');
         const os = await import('os');
         const configPath = path.join(os.homedir(), '.rippletide', 'config.json');
         const isNewUser = !fs.existsSync(configPath);
-        // Track start event and wait for it to be sent
         analytics.track('cli_started', {
             command: process.argv[2] || 'eval',
             has_template: !!options.templatePath,
@@ -199,19 +197,16 @@ async function run() {
             is_non_interactive: options.nonInteractive,
             is_new_user: isNewUser,
         });
-        // Track new user activation separately
         if (isNewUser) {
             analytics.track('new_user_activated', {
                 source: process.argv[2] || 'eval',
                 activation_date: new Date().toISOString(),
             });
         }
-        // Give PostHog a moment to send the event
         await new Promise(resolve => setTimeout(resolve, 100));
         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, pdfPath: options.pdfPath }));
+        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, isRemoteTemplate: options.isRemoteTemplate, pdfPath: options.pdfPath }));
         await waitUntilExit();
-        // Ensure all events are sent before exiting
         await analytics.shutdown();
         await new Promise(resolve => setTimeout(resolve, 500));
     }

package/dist/utils/analytics.js

@@ -33,7 +33,6 @@ class Analytics {
             if (process.env.DEBUG_ANALYTICS) {
                 console.log('[Analytics] Client initialized with ID:', this.distinctId);
             }
-            // Force flush on various exit events
             const cleanup = () => {
                 if (this.client) {
                     this.client.shutdown();
@@ -149,13 +148,11 @@ class Analytics {
             const config = this.getConfig();
             const firstSeen = config.first_seen || new Date().toISOString();
             const totalLaunches = (config.total_launches || 0) + 1;
-            // Save first seen and increment launch count
             this.saveConfig({
                 ...config,
                 first_seen: firstSeen,
                 total_launches: totalLaunches
             });
-            // Identify the user with persistent properties
             this.client.identify({
                 distinctId: this.distinctId,
                 properties: {
@@ -168,7 +165,6 @@ class Analytics {
                     hostname_hash: createHash('sha256').update(os.hostname()).digest('hex').substring(0, 8),
                 },
             });
-            // Also set these as super properties for all events
             this.client.capture({
                 distinctId: this.distinctId,
                 event: '$set',
@@ -200,7 +196,6 @@ class Analytics {
             });
         }
         catch (error) {
-            // Silently fail
         }
     }
     async shutdown() {

package/dist/utils/templates.d.ts

@@ -15,7 +15,9 @@ export interface Template {
     name: string;
     path: string;
     config: TemplateConfig;
+    isRemote?: boolean;
 }
-export declare const listTemplates: () => Template[];
-export declare const loadTemplate: (templateName: string) => Template | null;
-export declare const getTemplateOptions: (template: Template) => any;
+export declare const listTemplates: () => Promise<Template[]>;
+export declare const loadTemplate: (templateName: string) => Promise<Template | null>;
+export declare const getTemplateOptions: (template: Template) => Promise<any>;
+export declare const loadRemoteQAndA: (templateName: string) => Promise<any>;

package/dist/utils/templates.js

@@ -1,25 +1,43 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import axios from 'axios';
+const GITHUB_BASE_URL = 'https://raw.githubusercontent.com/rippletideco/starter/refs/heads/main/cli/templates';
+const REMOTE_TEMPLATES = [
+    'banking_analyst',
+    'blog_to_linkedin',
+    'customer_service',
+    'local_dev',
+    'luxe_concierge',
+    'openai_compatible',
+    'project_manager'
+];
 const getTemplatesDir = () => {
     const currentDir = process.cwd();
     const cliDir = path.resolve(currentDir);
     const templatesDir = path.join(cliDir, 'templates');
-    if (!fs.existsSync(templatesDir)) {
-        const altTemplatesDir = path.join(path.dirname(cliDir), 'cli', 'templates');
-        if (fs.existsSync(altTemplatesDir)) {
-            return altTemplatesDir;
+    if (fs.existsSync(templatesDir)) {
+        const configFiles = fs.readdirSync(templatesDir, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory())
+            .some(dirent => fs.existsSync(path.join(templatesDir, dirent.name, 'config.json')));
+        if (configFiles) {
+            return templatesDir;
         }
-        const globalTemplatesDir = path.join(__dirname, '..', '..', 'templates');
-        if (fs.existsSync(globalTemplatesDir)) {
-            return globalTemplatesDir;
+    }
+    const altTemplatesDir = path.join(path.dirname(cliDir), 'cli', 'templates');
+    if (fs.existsSync(altTemplatesDir)) {
+        const configFiles = fs.readdirSync(altTemplatesDir, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory())
+            .some(dirent => fs.existsSync(path.join(altTemplatesDir, dirent.name, 'config.json')));
+        if (configFiles) {
+            return altTemplatesDir;
         }
     }
-    return templatesDir;
+    return null;
 };
-export const listTemplates = () => {
+const loadLocalTemplates = () => {
     const templates = [];
     const templatesDir = getTemplatesDir();
-    if (!fs.existsSync(templatesDir)) {
+    if (!templatesDir || !fs.existsSync(templatesDir)) {
         return templates;
     }
     const dirs = fs.readdirSync(templatesDir, { withFileTypes: true })
@@ -38,24 +56,65 @@ export const listTemplates = () => {
                         ...config,
                         name: config.name || dir,
                         description: config.description || `Template: ${dir}`
-                    }
+                    },
+                    isRemote: false
                 });
             }
             catch (error) {
-                console.error(`Error loading template ${dir}:`, error);
             }
         }
     }
     return templates;
 };
-export const loadTemplate = (templateName) => {
-    const templates = listTemplates();
-    const template = templates.find(t => t.name.toLowerCase() === templateName.toLowerCase() ||
+const loadRemoteTemplate = async (templateName) => {
+    try {
+        const configUrl = `${GITHUB_BASE_URL}/${templateName}/config.json`;
+        const response = await axios.get(configUrl, { timeout: 5000 });
+        const config = response.data;
+        return {
+            name: templateName,
+            path: `${GITHUB_BASE_URL}/${templateName}`,
+            config: {
+                ...config,
+                name: config.name || templateName,
+                description: config.description || `Template: ${templateName}`
+            },
+            isRemote: true
+        };
+    }
+    catch (error) {
+        return null;
+    }
+};
+export const listTemplates = async () => {
+    const localTemplates = loadLocalTemplates();
+    if (localTemplates.length > 0) {
+        return localTemplates;
+    }
+    const remoteTemplates = [];
+    for (const templateName of REMOTE_TEMPLATES) {
+        const template = await loadRemoteTemplate(templateName);
+        if (template) {
+            remoteTemplates.push(template);
+        }
+    }
+    return remoteTemplates;
+};
+export const loadTemplate = async (templateName) => {
+    const localTemplates = loadLocalTemplates();
+    const localTemplate = localTemplates.find(t => t.name.toLowerCase() === templateName.toLowerCase() ||
         t.config.name?.toLowerCase() === templateName.toLowerCase());
-    return template || null;
+    if (localTemplate) {
+        return localTemplate;
+    }
+    return await loadRemoteTemplate(templateName);
 };
-export const getTemplateOptions = (template) => {
+export const getTemplateOptions = async (template) => {
     const config = template.config;
+    let templatePath = template.path;
+    if (template.isRemote) {
+        templatePath = `${template.path}`;
+    }
     return {
         agentEndpoint: config.endpoint_url,
         knowledgeSource: config.knowledge_source || 'files',
@@ -66,6 +125,17 @@ export const getTemplateOptions = (template) => {
         bodyTemplate: config.body_template,
         responseField: config.response_field,
         nonInteractive: true,
-        templatePath: template.path
+        templatePath,
+        isRemoteTemplate: template.isRemote
     };
 };
+export const loadRemoteQAndA = async (templateName) => {
+    try {
+        const qandaUrl = `${GITHUB_BASE_URL}/${templateName}/qanda.json`;
+        const response = await axios.get(qandaUrl, { timeout: 5000 });
+        return response.data;
+    }
+    catch (error) {
+        return null;
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rippletide",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "Rippletide Evaluation CLI",
   "main": "dist/index.js",
   "bin": {

package/src/App.tsx

@@ -58,6 +58,7 @@ interface AppProps {
   customBodyTemplate?: string;
   customResponseField?: string;
   templatePath?: string;
+  isRemoteTemplate?: boolean;
 }
 
 export const App: React.FC<AppProps> = ({ 
@@ -73,7 +74,8 @@ export const App: React.FC<AppProps> = ({
   customHeaders,
   customBodyTemplate,
   customResponseField,
-  templatePath
+  templatePath,
+  isRemoteTemplate
 }) => {
   const { exit } = useApp();
   const initialStep = nonInteractive && initialAgentEndpoint ? 'testing-connection' : 'agent-endpoint';
@@ -368,24 +370,78 @@ export const App: React.FC<AppProps> = ({
           
           setEvaluationProgress(30);
           
+          if (knowledgeSource === 'files') {
+            let knowledgeData: any = null;
+            if (templatePath) {
+              try {
+                if (isRemoteTemplate) {
+                  const axios = await import('axios');
+                  const qandaUrl = `${templatePath}/qanda.json`;
+                  const response = await axios.default.get(qandaUrl, { timeout: 5000 });
+                  knowledgeData = response.data;
+                } else {
+                  const fs = await import('fs');
+                  const path = await import('path');
+                  const qandaPath = path.join(templatePath, 'qanda.json');
+                  if (fs.existsSync(qandaPath)) {
+                    knowledgeData = JSON.parse(fs.readFileSync(qandaPath, 'utf-8'));
+                  }
+                }
+              } catch (error) {
+                logger.debug('Error loading knowledge from template:', error);
+              }
+            } else {
+              const knowledgeResult = await api.checkKnowledge();
+              if (knowledgeResult.found && knowledgeResult.path) {
+                try {
+                  const fs = await import('fs');
+                  knowledgeData = JSON.parse(fs.readFileSync(knowledgeResult.path, 'utf-8'));
+                } catch (error) {
+                  logger.debug('Error loading knowledge:', error);
+                }
+              }
+            }
+            
+            if (knowledgeData) {
+              setEvaluationProgress(35);
+              try {
+                const importResult = await api.importKnowledge(agentId, knowledgeData);
+                logger.debug('Knowledge import result:', importResult);
+                await new Promise(resolve => setTimeout(resolve, 1000));
+              } catch (error: any) {
+                logger.error('Failed to import knowledge:', error?.message || error);
+                logger.debug('Import error details:', error?.response?.data);
+              }
+            }
+          }
+          
           setEvaluationProgress(40);
           let testPrompts: Array<{question: string, answer?: string}> | string[] = [];
           if (knowledgeSource === 'files') {
             if (templatePath) {
               try {
-                const fs = await import('fs');
-                const path = await import('path');
-                const qandaPath = path.join(templatePath, 'qanda.json');
-                if (fs.existsSync(qandaPath)) {
-                  const knowledgeData = JSON.parse(fs.readFileSync(qandaPath, 'utf-8'));
-                  if (Array.isArray(knowledgeData)) {
-                    testPrompts = knowledgeData.map((item: any) => ({
-                      question: item.question || item.prompt || item.input || 'Test question',
-                      answer: item.answer || item.response || item.expectedAnswer
-                    }));
-                  }
+                let knowledgeData: any = null;
+                if (isRemoteTemplate) {
+                  const axios = await import('axios');
+                  const qandaUrl = `${templatePath}/qanda.json`;
+                  const response = await axios.default.get(qandaUrl, { timeout: 5000 });
+                  knowledgeData = response.data;
                 } else {
-                  logger.debug('No qanda.json found in template directory:', templatePath);
+                  const fs = await import('fs');
+                  const path = await import('path');
+                  const qandaPath = path.join(templatePath, 'qanda.json');
+                  if (fs.existsSync(qandaPath)) {
+                    knowledgeData = JSON.parse(fs.readFileSync(qandaPath, 'utf-8'));
+                  } else {
+                    logger.debug('No qanda.json found in template directory:', templatePath);
+                  }
+                }
+                
+                if (knowledgeData && Array.isArray(knowledgeData)) {
+                  testPrompts = knowledgeData.map((item: any) => ({
+                    question: item.question || item.prompt || item.input || 'Test question',
+                    answer: item.answer || item.response || item.expectedAnswer
+                  }));
                 }
               } catch (error) {
                 logger.debug('Error loading prompts from template:', error);

package/src/api/knowledge.ts

@@ -48,14 +48,49 @@ export async function checkKnowledge(folderPath: string = '.') {
 
 export async function importKnowledge(agentId: string, knowledgeData: any) {
   try {
-    const response = await client.post(`/api/agents/${agentId}/knowledge/import`, {
-      data: knowledgeData,
-    });
+    logger.debug('Importing knowledge for agent:', agentId);
+    logger.debug('Knowledge data type:', Array.isArray(knowledgeData) ? 'array' : typeof knowledgeData);
+    logger.debug('Knowledge data length:', Array.isArray(knowledgeData) ? knowledgeData.length : 'N/A');
     
-    return response.data;
-  } catch (error) {
-    logger.error('Error importing knowledge:', error);
-    return null;
+    if (!Array.isArray(knowledgeData)) {
+      logger.warn('Knowledge data is not an array, skipping import');
+      return null;
+    }
+    
+    let importedCount = 0;
+    for (const item of knowledgeData) {
+      try {
+        const question = item.question || item.prompt || item.input;
+        const answer = item.answer || item.response || item.expectedAnswer;
+        
+        if (!question || !answer) {
+          logger.debug('Skipping item without question or answer:', item);
+          continue;
+        }
+        
+        const response = await client.post(`/api/agents/${agentId}/config`, {
+          label: question,
+          description: answer,
+          type: 'knowledge'
+        });
+        
+        importedCount++;
+        logger.debug(`Imported Q&A ${importedCount}/${knowledgeData.length}: ${question.substring(0, 50)}...`);
+      } catch (error: any) {
+        logger.warn(`Failed to import Q&A pair: ${error?.message || error}`);
+        logger.debug('Q&A import error details:', error?.response?.data);
+        logger.debug('Q&A import error status:', error?.response?.status);
+      }
+    }
+    
+    logger.info(`Knowledge imported successfully: ${importedCount}/${knowledgeData.length} Q&A pairs`);
+    
+    return { imported: importedCount, total: knowledgeData.length };
+  } catch (error: any) {
+    logger.error('Error importing knowledge:', error?.message || error);
+    logger.debug('Error details:', error?.response?.data);
+    logger.debug('Error status:', error?.response?.status);
+    throw error;
   }
 }
 

package/src/index.tsx

@@ -7,14 +7,14 @@ import { ValidationError } from './errors/types.js';
 import { listTemplates, loadTemplate, getTemplateOptions } from './utils/templates.js';
 import { analytics } from './utils/analytics.js';
 
-const parseArgs = () => {
+const parseArgs = async () => {
   const args = process.argv.slice(2);
   
   if (args[0] === 'list-templates' || args[0] === 'templates') {
-    const templates = listTemplates();
+    const templates = await listTemplates();
     console.log('\nAvailable Templates:\n');
     if (templates.length === 0) {
-      console.log('No templates found in ./templates directory');
+      console.log('No templates found');
     } else {
       templates.forEach(template => {
         console.log(`  ${template.name}`);
@@ -40,15 +40,15 @@ const parseArgs = () => {
 
   for (let i = 0; i < args.length; i++) {
     if ((args[i] === '--template' || args[i] === '-t') && args[i + 1]) {
-      const template = loadTemplate(args[i + 1]);
+      const template = await loadTemplate(args[i + 1]);
       if (!template) {
         console.error(`Template '${args[i + 1]}' not found.`);
         console.log('\nAvailable templates:');
-        const templates = listTemplates();
+        const templates = await listTemplates();
         templates.forEach(t => console.log(`  - ${t.name}`));
         process.exit(1);
       }
-      const templateOptions = getTemplateOptions(template);
+      const templateOptions = await getTemplateOptions(template);
       Object.assign(options, templateOptions);
       i++;
     } else if ((args[i] === '--backend-url' || args[i] === '-b') && args[i + 1]) {
@@ -177,7 +177,7 @@ Examples:
 
 async function run() {
   try {
-    const options = parseArgs();
+    const options = await parseArgs();
     
     const fs = await import('fs');
     const path = await import('path');
@@ -218,6 +218,7 @@ async function run() {
         customBodyTemplate={options.bodyTemplate}
         customResponseField={options.responseField}
         templatePath={options.templatePath}
+        isRemoteTemplate={options.isRemoteTemplate}
         pdfPath={options.pdfPath}
       />
     );

package/src/utils/templates.ts

@@ -1,5 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import { fileURLToPath } from 'url';
+import axios from 'axios';
 
 export interface TemplateConfig {
   endpoint_url: string;
@@ -19,33 +21,53 @@ export interface Template {
   name: string;
   path: string;
   config: TemplateConfig;
+  isRemote?: boolean;
 }
 
-const getTemplatesDir = (): string => {
+const GITHUB_BASE_URL = 'https://raw.githubusercontent.com/rippletideco/starter/refs/heads/main/cli/templates';
+
+const REMOTE_TEMPLATES = [
+  'banking_analyst',
+  'blog_to_linkedin',
+  'customer_service',
+  'local_dev',
+  'luxe_concierge',
+  'openai_compatible',
+  'project_manager'
+];
+
+const getTemplatesDir = (): string | null => {
   const currentDir = process.cwd();
   const cliDir = path.resolve(currentDir);
   const templatesDir = path.join(cliDir, 'templates');
   
-  if (!fs.existsSync(templatesDir)) {
-    const altTemplatesDir = path.join(path.dirname(cliDir), 'cli', 'templates');
-    if (fs.existsSync(altTemplatesDir)) {
-      return altTemplatesDir;
+  if (fs.existsSync(templatesDir)) {
+    const configFiles = fs.readdirSync(templatesDir, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .some(dirent => fs.existsSync(path.join(templatesDir, dirent.name, 'config.json')));
+    if (configFiles) {
+      return templatesDir;
     }
-    
-    const globalTemplatesDir = path.join(__dirname, '..', '..', 'templates');
-    if (fs.existsSync(globalTemplatesDir)) {
-      return globalTemplatesDir;
+  }
+  
+  const altTemplatesDir = path.join(path.dirname(cliDir), 'cli', 'templates');
+  if (fs.existsSync(altTemplatesDir)) {
+    const configFiles = fs.readdirSync(altTemplatesDir, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .some(dirent => fs.existsSync(path.join(altTemplatesDir, dirent.name, 'config.json')));
+    if (configFiles) {
+      return altTemplatesDir;
     }
   }
   
-  return templatesDir;
+  return null;
 };
 
-export const listTemplates = (): Template[] => {
+const loadLocalTemplates = (): Template[] => {
   const templates: Template[] = [];
   const templatesDir = getTemplatesDir();
   
-  if (!fs.existsSync(templatesDir)) {
+  if (!templatesDir || !fs.existsSync(templatesDir)) {
     return templates;
   }
   
@@ -66,10 +88,10 @@ export const listTemplates = (): Template[] => {
             ...config,
             name: config.name || dir,
             description: config.description || `Template: ${dir}`
-          }
+          },
+          isRemote: false
         });
       } catch (error) {
-        console.error(`Error loading template ${dir}:`, error);
       }
     }
   }
@@ -77,18 +99,67 @@ export const listTemplates = (): Template[] => {
   return templates;
 };
 
-export const loadTemplate = (templateName: string): Template | null => {
-  const templates = listTemplates();
-  const template = templates.find(t => 
+const loadRemoteTemplate = async (templateName: string): Promise<Template | null> => {
+  try {
+    const configUrl = `${GITHUB_BASE_URL}/${templateName}/config.json`;
+    const response = await axios.get(configUrl, { timeout: 5000 });
+    const config = response.data as TemplateConfig;
+    
+    return {
+      name: templateName,
+      path: `${GITHUB_BASE_URL}/${templateName}`,
+      config: {
+        ...config,
+        name: config.name || templateName,
+        description: config.description || `Template: ${templateName}`
+      },
+      isRemote: true
+    };
+  } catch (error) {
+    return null;
+  }
+};
+
+export const listTemplates = async (): Promise<Template[]> => {
+  const localTemplates = loadLocalTemplates();
+  
+  if (localTemplates.length > 0) {
+    return localTemplates;
+  }
+  
+  const remoteTemplates: Template[] = [];
+  for (const templateName of REMOTE_TEMPLATES) {
+    const template = await loadRemoteTemplate(templateName);
+    if (template) {
+      remoteTemplates.push(template);
+    }
+  }
+  
+  return remoteTemplates;
+};
+
+export const loadTemplate = async (templateName: string): Promise<Template | null> => {
+  const localTemplates = loadLocalTemplates();
+  const localTemplate = localTemplates.find(t => 
     t.name.toLowerCase() === templateName.toLowerCase() ||
     t.config.name?.toLowerCase() === templateName.toLowerCase()
   );
   
-  return template || null;
+  if (localTemplate) {
+    return localTemplate;
+  }
+  
+  return await loadRemoteTemplate(templateName);
 };
 
-export const getTemplateOptions = (template: Template): any => {
+export const getTemplateOptions = async (template: Template): Promise<any> => {
   const config = template.config;
+  
+  let templatePath = template.path;
+  if (template.isRemote) {
+    templatePath = `${template.path}`;
+  }
+  
   return {
     agentEndpoint: config.endpoint_url,
     knowledgeSource: config.knowledge_source || 'files',
@@ -99,6 +170,17 @@ export const getTemplateOptions = (template: Template): any => {
     bodyTemplate: config.body_template,
     responseField: config.response_field,
     nonInteractive: true,
-    templatePath: template.path
+    templatePath,
+    isRemoteTemplate: template.isRemote
   };
 };
+
+export const loadRemoteQAndA = async (templateName: string): Promise<any> => {
+  try {
+    const qandaUrl = `${GITHUB_BASE_URL}/${templateName}/qanda.json`;
+    const response = await axios.get(qandaUrl, { timeout: 5000 });
+    return response.data;
+  } catch (error) {
+    return null;
+  }
+};

package/templates/luxe_concierge/qanda.json

@@ -41,7 +41,7 @@
   },
   {
     "question": "What shopping outputs can you produce?",
-    "answer": "Shortlist, "best overall / best value / best statement," sizing guide, care guide, authenticity checklist, buying plan by budget."
+    "answer": "Shortlist, \"best overall / best value / best statement,\" sizing guide, care guide, authenticity checklist, buying plan by budget."
   },
   {
     "question": "How do you handle gifts?",