@simpleapps-com/augur-api 0.3.0 → 0.3.2

package/dist/cjs/services/gregorovich/client.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GregorovichClient = void 0;
+const base_client_1 = require("../../core/base-client");
+const schemas_1 = require("./schemas");
+/**
+ * Gregorovich AI Service Client
+ *
+ * Provides access to AI-powered document management and conversational AI endpoints
+ * including ChatGPT integration, Ollama local models, and document processing capabilities.
+ *
+ * @service gregorovich
+ * @domain ai-and-document-management
+ */
+class GregorovichClient extends base_client_1.BaseServiceClient {
+    constructor(http, baseUrl) {
+        super('gregorovich', http, baseUrl || 'https://gregorovich.augur-api.com');
+        /**
+         * Check service health and availability
+         *
+         * @fullPath api.gregorovich.healthCheck.get
+         * @service gregorovich
+         * @domain system-health
+         * @dataMethod healthCheckData
+         * @discoverable true
+         * @searchTerms ["health", "status", "availability", "ping", "check", "ai service"]
+         * @relatedEndpoints ["api.gregorovich.chatGpt.ask", "api.gregorovich.documents.list", "api.gregorovich.ollama.generate", "api.agrWork.healthCheck.get"]
+         * @commonPatterns ["Health check", "Service status", "AI service availability", "System monitoring"]
+         * @workflow ["system-monitoring", "health-checks", "service-discovery", "ai-service-verification"]
+         * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header"]
+         * @nextSteps ["Use AI endpoints if healthy", "Verify AI service connectivity", "Monitor service metrics"]
+         * @businessRules ["Returns service status and basic info", "Requires standard authentication", "Standard health check format"]
+         * @functionalArea "system-monitoring"
+         * @caching "No caching - real-time status required"
+         * @performance "Fast response, minimal processing, use for AI service monitoring"
+         *
+         * @returns Promise<HealthCheckResponse> Service health status
+         *
+         * @example
+         * ```typescript
+         * // Check if AI service is healthy
+         * const response = await client.healthCheck();
+         * console.log(response.data); // Health status string
+         * console.log(response.status); // HTTP status code
+         *
+         * // Get just the health status
+         * const status = await client.healthCheckData();
+         * console.log(status); // Direct string access
+         * ```
+         */
+        this.healthCheck = this.createHealthCheckMethod(schemas_1.HealthCheckResponseSchema);
+        /**
+         * Ask ChatGPT a question with advanced AI capabilities
+         *
+         * @fullPath api.gregorovich.chatGpt.ask
+         * @service gregorovich
+         * @domain ai-conversation
+         * @dataMethod chatGptAskData
+         * @discoverable true
+         * @searchTerms ["chatgpt", "ai", "question", "ask", "conversation", "gpt", "openai", "assistant", "chat"]
+         * @relatedEndpoints ["api.gregorovich.ollama.generate", "api.gregorovich.documents.list", "api.agrSite.ai.transcripts.create", "api.p21Pim.ai.suggestions.get"]
+         * @commonPatterns ["Ask AI question", "Get AI assistance", "Conversational AI", "AI-powered help", "Question answering", "AI consultation"]
+         * @workflow ["ai-conversation", "customer-support", "content-generation", "decision-support", "knowledge-retrieval"]
+         * @prerequisites ["Valid authentication token", "x-site-id header", "Question parameter", "ChatGPT service availability"]
+         * @nextSteps ["Process AI response", "Continue conversation", "Store conversation history", "Analyze AI recommendations"]
+         * @businessRules ["Requires question parameter", "Supports conversation context", "Token usage tracking", "Response quality metrics", "Configurable AI parameters"]
+         * @functionalArea "ai-and-automation"
+         * @crossSite "Multi-site AI conversation support"
+         * @caching "Cache responses for 1 hour for identical questions, AI responses are generally stable"
+         * @performance "Response time varies by question complexity, use streaming for long responses"
+         *
+         * @param params ChatGPT question parameters including question text and AI configuration options
+         * @returns Promise<ChatGptAskResponse> Complete AI response with answer, metadata, and usage information
+         *
+         * @example
+         * ```typescript
+         * // Ask a simple question
+         * const aiResponse = await client.chatGptAsk({ question: 'What is the weather like today?' });
+         * console.log(aiResponse.data.answer); // AI generated answer
+         * console.log(aiResponse.data.tokens); // Token usage information
+         *
+         * // Get just the AI answer
+         * const answer = await client.chatGptAskData({ question: 'Explain quantum computing' });
+         * console.log(answer.answer); // Direct access to AI response
+         *
+         * // Advanced AI configuration
+         * const complexRequest = {
+         *   question: 'Write a business plan for a tech startup',
+         *   temperature: 0.7,
+         *   maxTokens: 2000,
+         *   format: 'markdown' as const,
+         *   systemPrompt: 'You are a business consultant with 20 years of experience',
+         *   conversationId: 'conv-123',
+         *   language: 'english'
+         * };
+         *
+         * const businessPlan = await client.chatGptAskData(complexRequest);
+         * console.log(businessPlan.answer); // Detailed business plan
+         * console.log(businessPlan.usage); // Token usage breakdown
+         *
+         * // Continue a conversation
+         * const followUp = await client.chatGptAskData({
+         *   question: 'Can you expand on the marketing strategy section?',
+         *   conversationId: 'conv-123',
+         *   temperature: 0.5
+         * });
+         * ```
+         */
+        this.chatGptAsk = async (params) => {
+            return this.executeRequest({
+                method: 'GET',
+                path: '/chat-gpt/ask',
+                paramsSchema: schemas_1.ChatGptAskRequestParamsSchema,
+                responseSchema: schemas_1.ChatGptAskResponseSchema,
+            }, params);
+        };
+        /**
+         * List available documents in the AI knowledge base
+         *
+         * @fullPath api.gregorovich.documents.list
+         * @service gregorovich
+         * @domain document-management
+         * @dataMethod documentsListData
+         * @discoverable true
+         * @searchTerms ["documents", "files", "knowledge", "library", "content", "resources", "papers", "manuals"]
+         * @relatedEndpoints ["api.gregorovich.chatGpt.ask", "api.joomla.content.list", "api.agrSite.content.search", "api.items.faq.list"]
+         * @commonPatterns ["List documents", "Browse knowledge base", "Find resources", "Document library", "Content discovery", "Knowledge management"]
+         * @workflow ["document-discovery", "knowledge-management", "research", "content-organization", "ai-training-data"]
+         * @prerequisites ["Public bearer token", "x-site-id header", "Document access permissions"]
+         * @nextSteps ["Select document for AI processing", "Use document content for AI questions", "Organize document library", "Analyze document metadata"]
+         * @businessRules ["Returns accessible documents only", "Supports document filtering", "Includes metadata and status", "Permissions-based access", "Searchable content"]
+         * @functionalArea "content-and-knowledge-management"
+         * @crossSite "Multi-site document library support"
+         * @caching "Cache for 15 minutes, document lists change infrequently"
+         * @performance "Optimize with pagination for large document sets, supports filtering and search"
+         *
+         * @returns Promise<DocumentsListResponse> Complete list of available documents with metadata and organization information
+         *
+         * @example
+         * ```typescript
+         * // List all available documents
+         * const docsResponse = await client.documentsList();
+         * console.log(docsResponse.data); // Array of document objects
+         * console.log(docsResponse.total); // Total document count
+         *
+         * // Get just the documents array
+         * const documents = await client.documentsListData();
+         * console.log(documents); // Direct access to document array
+         *
+         * // Process document library
+         * const docs = await client.documentsListData();
+         * const publishedDocs = docs.filter(doc => doc.status === 'published');
+         * const categories = [...new Set(docs.map(doc => doc.category))];
+         *
+         * console.log(`Found ${publishedDocs.length} published documents`);
+         * console.log(`Available categories: ${categories.join(', ')}`);
+         *
+         * // Find specific document types
+         * const manuals = docs.filter(doc =>
+         *   doc.type === 'manual' || doc.tags?.includes('manual')
+         * );
+         * const recentDocs = docs.filter(doc =>
+         *   new Date(doc.updatedAt || 0) > new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
+         * );
+         * ```
+         */
+        this.documentsList = async () => {
+            return this.executeRequest({
+                method: 'GET',
+                path: '/documents',
+                responseSchema: schemas_1.DocumentsListResponseSchema,
+            });
+        };
+        /**
+         * Generate content using local Ollama AI models
+         *
+         * @fullPath api.gregorovich.ollama.generate
+         * @service gregorovich
+         * @domain ai-generation
+         * @dataMethod ollamaGenerateData
+         * @discoverable true
+         * @searchTerms ["ollama", "generate", "ai", "local", "llm", "model", "text", "completion", "generation"]
+         * @relatedEndpoints ["api.gregorovich.chatGpt.ask", "api.p21Pim.ai.suggestions.get", "api.agrSite.ai.transcripts.create", "api.gregorovich.documents.list"]
+         * @commonPatterns ["Generate AI content", "Local AI processing", "Text completion", "AI writing assistant", "Custom model inference", "Private AI generation"]
+         * @workflow ["content-generation", "ai-assistance", "text-processing", "creative-writing", "code-generation", "document-analysis"]
+         * @prerequisites ["Public bearer token", "x-site-id header", "Model name", "Generation prompt", "Ollama service availability"]
+         * @nextSteps ["Process generated content", "Refine generation parameters", "Chain multiple generations", "Store generation results"]
+         * @businessRules ["Requires model and prompt parameters", "Supports local model execution", "Configurable generation parameters", "Token and context management", "Performance monitoring"]
+         * @functionalArea "ai-and-automation"
+         * @crossSite "Multi-site AI generation support"
+         * @caching "Cache responses for 30 minutes for identical prompts and parameters"
+         * @performance "Local processing, faster than external APIs but depends on model size and complexity"
+         *
+         * @param params Ollama generation parameters including model, prompt, and generation configuration
+         * @returns Promise<OllamaGenerateResponse> Complete AI generation result with content, metadata, and performance metrics
+         *
+         * @example
+         * ```typescript
+         * // Simple text generation
+         * const generation = await client.ollamaGenerate({
+         *   model: 'llama2',
+         *   prompt: 'Write a short story about a robot learning to paint'
+         * });
+         * console.log(generation.data.response); // Generated story
+         * console.log(generation.data.total_duration); // Generation time
+         *
+         * // Get just the generated content
+         * const story = await client.ollamaGenerateData({
+         *   model: 'codellama',
+         *   prompt: 'Create a Python function to calculate fibonacci numbers'
+         * });
+         * console.log(story.response); // Direct access to generated code
+         *
+         * // Advanced generation with parameters
+         * const technicalDoc = await client.ollamaGenerateData({
+         *   model: 'mistral',
+         *   prompt: 'Explain machine learning algorithms for beginners',
+         *   temperature: 0.3,
+         *   max_tokens: 1500,
+         *   system: 'You are a patient teacher who explains complex topics simply',
+         *   format: 'json',
+         *   top_p: 0.9,
+         *   seed: 42
+         * });
+         *
+         * // Creative writing with higher randomness
+         * const creativeContent = await client.ollamaGenerateData({
+         *   model: 'neural-chat',
+         *   prompt: 'Write a product description for a smart home device',
+         *   temperature: 0.8,
+         *   top_k: 40,
+         *   repeat_penalty: 1.1,
+         *   stop: ['\\n\\n', 'END'],
+         *   sessionId: 'creative-session-1'
+         * });
+         *
+         * // Conversation with context
+         * const conversational = await client.ollamaGenerateData({
+         *   model: 'llama2-chat',
+         *   prompt: 'What are the benefits of renewable energy?',
+         *   context: previousContext, // Array of context tokens
+         *   conversationId: 'energy-discussion',
+         *   num_predict: 200
+         * });
+         * ```
+         */
+        this.ollamaGenerate = this.createCreateMethod('/ollama/generate', schemas_1.OllamaGenerateRequestParamsSchema, schemas_1.OllamaGenerateResponseSchema);
+        // Data-only methods for direct access to response data
+        /**
+         * Get health check status data only
+         * @returns Promise<string> Health status string
+         */
+        this.healthCheckData = async () => {
+            const response = await this.healthCheck();
+            return response.data;
+        };
+        /**
+         * Ask ChatGPT a question and return AI response data only
+         * @param params ChatGPT question parameters
+         * @returns Promise<ChatGptAskResult> AI response with answer and metadata
+         */
+        this.chatGptAskData = async (params) => {
+            const response = await this.chatGptAsk(params);
+            return response.data;
+        };
+        /**
+         * List documents and return documents array data only
+         * @returns Promise<DocumentsListResult[]> Array of document objects
+         */
+        this.documentsListData = async () => {
+            const response = await this.documentsList();
+            return response.data;
+        };
+        /**
+         * Generate content with Ollama and return generation result data only
+         * @param params Ollama generation parameters
+         * @returns Promise<OllamaGenerateResult> Generated content with metadata and performance metrics
+         */
+        this.ollamaGenerateData = async (params) => {
+            const response = await this.ollamaGenerate(params);
+            return response.data;
+        };
+    }
+    getServiceDescription() {
+        return 'AI-powered document management and conversational AI service with ChatGPT and Ollama integration';
+    }
+}
+exports.GregorovichClient = GregorovichClient;
+//# sourceMappingURL=client.js.map

package/dist/cjs/services/gregorovich/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../src/services/gregorovich/client.ts"],"names":[],"mappings":";;;AAAA,wDAA2D;AAE3D,uCAcmB;AAEnB;;;;;;;;GAQG;AACH,MAAa,iBAAkB,SAAQ,+BAAiB;IACtD,YAAY,IAAgB,EAAE,OAAgB;QAC5C,KAAK,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,IAAI,mCAAmC,CAAC,CAAC;QAO7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCG;QACM,gBAAW,GAAG,IAAI,CAAC,uBAAuB,CAAC,mCAAyB,CAAC,CAAC;QAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAwDG;QACM,eAAU,GAAG,KAAK,EAAE,MAA+B,EAA+B,EAAE;YAC3F,OAAO,IAAI,CAAC,cAAc,CACxB;gBACE,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,eAAe;gBACrB,YAAY,EAAE,uCAA6B;gBAC3C,cAAc,EAAE,kCAAwB;aACzC,EACD,MAAM,CACP,CAAC;QACJ,CAAC,CAAC;QAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDG;QACM,kBAAa,GAAG,KAAK,IAAoC,EAAE;YAClE,OAAO,IAAI,CAAC,cAAc,CAAC;gBACzB,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,YAAY;gBAClB,cAAc,EAAE,qCAA2B;aAC5C,CAAC,CAAC;QACL,CAAC,CAAC;QAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAwEG;QACM,mBAAc,GAAG,IAAI,CAAC,kBAAkB,CAC/C,kBAAkB,EAClB,2CAAiC,EACjC,sCAA4B,CAC7B,CAAC;QAEF,uDAAuD;QAEvD;;;WAGG;QACM,oBAAe,GAAG,KAAK,IAAqB,EAAE;YACrD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;YAC1C,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC,CAAC;QAEF;;;;WAIG;QACM,mBAAc,GAAG,KAAK,EAAE,MAA+B,EAA6B,EAAE;YAC7F,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAC/C,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC,CAAC;QAEF;;;WAGG;QACM,sBAAiB,GAAG,KAAK,IAAoC,EAAE;YACtE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;YAC5C,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC,CAAC;QAEF;;;;WAIG;QACM,uBAAkB,GAAG,KAAK,EACjC,MAAmC,EACJ,EAAE;YACjC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;YACnD,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC,CAAC;IA/RF,CAAC;IAES,qBAAqB;QAC7B,OAAO,kGAAkG,CAAC;IAC5G,CAAC;CA4RF;AAnSD,8CAmSC"}

package/dist/cjs/services/gregorovich/index.d.ts

@@ -0,0 +1,3 @@
+export { GregorovichClient } from './client';
+export type { HealthCheckResponse, ChatGptAskRequestParams, ChatGptAskResponse, ChatGptAskResult, DocumentsListResponse, DocumentsListResult, OllamaGenerateRequestParams, OllamaGenerateResponse, OllamaGenerateResult, } from './schemas';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/services/gregorovich/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/gregorovich/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,YAAY,EAEV,mBAAmB,EAEnB,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAEhB,qBAAqB,EACrB,mBAAmB,EAEnB,2BAA2B,EAC3B,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,WAAW,CAAC"}

package/dist/cjs/services/gregorovich/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GregorovichClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "GregorovichClient", { enumerable: true, get: function () { return client_1.GregorovichClient; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/services/gregorovich/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/services/gregorovich/index.ts"],"names":[],"mappings":";;;AAAA,mCAA6C;AAApC,2GAAA,iBAAiB,OAAA"}