@llm-dev-ops/agentics-cli 1.4.26 → 1.4.29

package/dist/bundled-agents/policy-engine-agents/src/core/evaluator/condition-evaluator.ts

@@ -0,0 +1,233 @@
+/**
+ * Condition Evaluator - Evaluates policy conditions against context
+ */
+import { Condition, ConditionOperator, EvaluationContext } from '../../types/policy';
+import { PolicyEvaluationError } from '@utils/errors';
+import logger from '@utils/logger';
+import { get } from 'lodash';
+
+export interface ConditionEvaluationResult {
+  result: boolean;
+  evaluationTimeMs: number;
+  details?: string;
+}
+
+export class ConditionEvaluator {
+  /**
+   * Evaluate a condition against an evaluation context
+   */
+  evaluate(condition: Condition, context: EvaluationContext): ConditionEvaluationResult {
+    const startTime = Date.now();
+
+    try {
+      const result = this.evaluateCondition(condition, context);
+      const evaluationTimeMs = Date.now() - startTime;
+
+      logger.debug(
+        {
+          condition,
+          result,
+          evaluationTimeMs,
+        },
+        'Condition evaluated',
+      );
+
+      return {
+        result,
+        evaluationTimeMs,
+        details: `Evaluated ${condition.operator} condition`,
+      };
+    } catch (error) {
+      const evaluationTimeMs = Date.now() - startTime;
+      logger.error({ condition, error }, 'Condition evaluation failed');
+
+      throw new PolicyEvaluationError(
+        `Condition evaluation failed: ${error instanceof Error ? error.message : String(error)}`,
+        { condition, evaluationTimeMs },
+      );
+    }
+  }
+
+  /**
+   * Internal recursive condition evaluation
+   */
+  private evaluateCondition(condition: Condition, context: EvaluationContext): boolean {
+    const { operator } = condition;
+
+    // Logical operators
+    if (operator === ConditionOperator.AND) {
+      return this.evaluateAnd(condition.conditions || [], context);
+    }
+
+    if (operator === ConditionOperator.OR) {
+      return this.evaluateOr(condition.conditions || [], context);
+    }
+
+    if (operator === ConditionOperator.NOT) {
+      return !this.evaluateCondition(condition.conditions![0], context);
+    }
+
+    // Comparison operators
+    const fieldValue = this.getFieldValue(condition.field!, context);
+    const compareValue = condition.value;
+
+    switch (operator) {
+      case ConditionOperator.EQUALS:
+        return this.equals(fieldValue, compareValue);
+
+      case ConditionOperator.NOT_EQUALS:
+        return !this.equals(fieldValue, compareValue);
+
+      case ConditionOperator.GREATER_THAN:
+        return this.greaterThan(fieldValue, compareValue);
+
+      case ConditionOperator.GREATER_THAN_OR_EQUAL:
+        return this.greaterThanOrEqual(fieldValue, compareValue);
+
+      case ConditionOperator.LESS_THAN:
+        return this.lessThan(fieldValue, compareValue);
+
+      case ConditionOperator.LESS_THAN_OR_EQUAL:
+        return this.lessThanOrEqual(fieldValue, compareValue);
+
+      case ConditionOperator.IN:
+        return this.in(fieldValue, compareValue);
+
+      case ConditionOperator.NOT_IN:
+        return !this.in(fieldValue, compareValue);
+
+      case ConditionOperator.CONTAINS:
+        return this.contains(fieldValue, compareValue);
+
+      case ConditionOperator.NOT_CONTAINS:
+        return !this.contains(fieldValue, compareValue);
+
+      case ConditionOperator.MATCHES:
+        return this.matches(fieldValue, compareValue);
+
+      default:
+        throw new PolicyEvaluationError(`Unknown operator: ${operator}`);
+    }
+  }
+
+  /**
+   * AND operator - all conditions must be true
+   */
+  private evaluateAnd(conditions: Condition[], context: EvaluationContext): boolean {
+    return conditions.every((cond) => this.evaluateCondition(cond, context));
+  }
+
+  /**
+   * OR operator - at least one condition must be true
+   */
+  private evaluateOr(conditions: Condition[], context: EvaluationContext): boolean {
+    return conditions.some((cond) => this.evaluateCondition(cond, context));
+  }
+
+  /**
+   * Get field value from context using dot notation
+   */
+  private getFieldValue(field: string, context: EvaluationContext): any {
+    return get(context, field);
+  }
+
+  /**
+   * Equality comparison
+   */
+  private equals(a: any, b: any): boolean {
+    if (a === b) return true;
+    if (a == null || b == null) return a === b;
+
+    // Deep equality for objects and arrays
+    if (typeof a === 'object' && typeof b === 'object') {
+      return JSON.stringify(a) === JSON.stringify(b);
+    }
+
+    return String(a) === String(b);
+  }
+
+  /**
+   * Greater than comparison
+   */
+  private greaterThan(a: any, b: any): boolean {
+    const numA = Number(a);
+    const numB = Number(b);
+
+    if (isNaN(numA) || isNaN(numB)) {
+      return String(a) > String(b);
+    }
+
+    return numA > numB;
+  }
+
+  /**
+   * Greater than or equal comparison
+   */
+  private greaterThanOrEqual(a: any, b: any): boolean {
+    return this.greaterThan(a, b) || this.equals(a, b);
+  }
+
+  /**
+   * Less than comparison
+   */
+  private lessThan(a: any, b: any): boolean {
+    const numA = Number(a);
+    const numB = Number(b);
+
+    if (isNaN(numA) || isNaN(numB)) {
+      return String(a) < String(b);
+    }
+
+    return numA < numB;
+  }
+
+  /**
+   * Less than or equal comparison
+   */
+  private lessThanOrEqual(a: any, b: any): boolean {
+    return this.lessThan(a, b) || this.equals(a, b);
+  }
+
+  /**
+   * IN operator - value is in array
+   */
+  private in(value: any, array: any[]): boolean {
+    if (!Array.isArray(array)) {
+      return false;
+    }
+
+    return array.some((item) => this.equals(value, item));
+  }
+
+  /**
+   * CONTAINS operator - array/string contains value
+   */
+  private contains(haystack: any, needle: any): boolean {
+    if (typeof haystack === 'string') {
+      return haystack.includes(String(needle));
+    }
+
+    if (Array.isArray(haystack)) {
+      return haystack.some((item) => this.equals(item, needle));
+    }
+
+    if (typeof haystack === 'object' && haystack !== null) {
+      return Object.values(haystack).some((value) => this.equals(value, needle));
+    }
+
+    return false;
+  }
+
+  /**
+   * MATCHES operator - regex match
+   */
+  private matches(value: any, pattern: string): boolean {
+    try {
+      const regex = new RegExp(pattern);
+      return regex.test(String(value));
+    } catch (error) {
+      logger.warn({ pattern, error }, 'Invalid regex pattern');
+      return false;
+    }
+  }
+}

package/dist/bundled-agents/policy-engine-agents/src/core/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Core Module Exports
+ * Central export point for all core policy engine functionality
+ */
+
+// Parser exports
+export { YAMLParser } from './parser/yaml-parser';
+export { JSONParser } from './parser/json-parser';
+
+// Validator exports
+export { SchemaValidator } from './validator/schema-validator';
+
+// Evaluator exports
+export { ConditionEvaluator } from './evaluator/condition-evaluator';
+
+// Primitives exports
+export { TokenCounter } from './primitives/token-counter';
+export { PIIDetector } from './primitives/pii-detector';
+export { CostCalculator } from './primitives/cost-calculator';
+
+// Engine exports
+export { PolicyEngine } from './engine/policy-engine';

package/dist/bundled-agents/policy-engine-agents/src/core/parser/index.ts

@@ -0,0 +1,56 @@
+/**
+ * Policy Parser - Main Interface
+ */
+import { Policy } from '../../types/policy';
+import { YAMLParser } from './yaml-parser';
+import { JSONParser } from './json-parser';
+import { PolicyParseError } from '@utils/errors';
+
+export class PolicyParser {
+  private yamlParser: YAMLParser;
+  private jsonParser: JSONParser;
+
+  constructor() {
+    this.yamlParser = new YAMLParser();
+    this.jsonParser = new JSONParser();
+  }
+
+  parse(content: string, format?: 'yaml' | 'json'): Policy {
+    if (!format) {
+      // Auto-detect format
+      const trimmed = content.trim();
+      if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        format = 'json';
+      } else {
+        format = 'yaml';
+      }
+    }
+
+    if (format === 'yaml') {
+      return this.yamlParser.parse(content);
+    } else if (format === 'json') {
+      return this.jsonParser.parse(content);
+    } else {
+      throw new PolicyParseError(`Unsupported format: ${format}`);
+    }
+  }
+
+  parseYaml(content: string): Policy {
+    return this.yamlParser.parse(content);
+  }
+
+  parseJson(content: string): Policy {
+    return this.jsonParser.parse(content);
+  }
+
+  stringifyYaml(policy: Policy): string {
+    return this.yamlParser.stringify(policy);
+  }
+
+  stringifyJson(policy: Policy, pretty: boolean = false): string {
+    return this.jsonParser.stringify(policy, pretty);
+  }
+}
+
+export * from './yaml-parser';
+export * from './json-parser';

package/dist/bundled-agents/policy-engine-agents/src/core/parser/json-parser.ts

@@ -0,0 +1,66 @@
+/**
+ * JSON Policy Parser
+ */
+import { Policy } from '../../types/policy';
+import { PolicyParseError } from '@utils/errors';
+import logger from '@utils/logger';
+
+export class JSONParser {
+  parse(content: string): Policy {
+    try {
+      const parsed = JSON.parse(content);
+
+      if (!parsed) {
+        throw new PolicyParseError('Empty policy document');
+      }
+
+      // Validate basic structure
+      if (!parsed.metadata) {
+        throw new PolicyParseError('Missing policy metadata');
+      }
+
+      if (!parsed.rules || !Array.isArray(parsed.rules)) {
+        throw new PolicyParseError('Missing or invalid rules array');
+      }
+
+      const policy: Policy = {
+        metadata: {
+          id: parsed.metadata.id,
+          name: parsed.metadata.name,
+          description: parsed.metadata.description,
+          version: parsed.metadata.version || '1.0.0',
+          namespace: parsed.metadata.namespace || 'default',
+          tags: parsed.metadata.tags || [],
+          priority: parsed.metadata.priority || 0,
+        },
+        rules: parsed.rules.map((rule: any, index: number) => ({
+          id: rule.id || `rule-${index}`,
+          name: rule.name || `Rule ${index}`,
+          description: rule.description,
+          condition: rule.condition,
+          action: rule.action,
+          enabled: rule.enabled !== false,
+        })),
+        status: parsed.status || 'active',
+      };
+
+      logger.debug({ policyId: policy.metadata.id }, 'Parsed JSON policy');
+      return policy;
+    } catch (error) {
+      if (error instanceof PolicyParseError) {
+        throw error;
+      }
+      throw new PolicyParseError(`JSON parse error: ${error instanceof Error ? error.message : String(error)}`, {
+        originalError: error,
+      });
+    }
+  }
+
+  stringify(policy: Policy, pretty: boolean = false): string {
+    try {
+      return JSON.stringify(policy, null, pretty ? 2 : 0);
+    } catch (error) {
+      throw new PolicyParseError(`JSON stringify error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}

package/dist/bundled-agents/policy-engine-agents/src/core/parser/yaml-parser.ts

@@ -0,0 +1,67 @@
+/**
+ * YAML Policy Parser
+ */
+import YAML from 'yaml';
+import { Policy } from '../../types/policy';
+import { PolicyParseError } from '@utils/errors';
+import logger from '@utils/logger';
+
+export class YAMLParser {
+  parse(content: string): Policy {
+    try {
+      const parsed = YAML.parse(content);
+
+      if (!parsed) {
+        throw new PolicyParseError('Empty policy document');
+      }
+
+      // Validate basic structure
+      if (!parsed.metadata) {
+        throw new PolicyParseError('Missing policy metadata');
+      }
+
+      if (!parsed.rules || !Array.isArray(parsed.rules)) {
+        throw new PolicyParseError('Missing or invalid rules array');
+      }
+
+      const policy: Policy = {
+        metadata: {
+          id: parsed.metadata.id,
+          name: parsed.metadata.name,
+          description: parsed.metadata.description,
+          version: parsed.metadata.version || '1.0.0',
+          namespace: parsed.metadata.namespace || 'default',
+          tags: parsed.metadata.tags || [],
+          priority: parsed.metadata.priority || 0,
+        },
+        rules: parsed.rules.map((rule: any, index: number) => ({
+          id: rule.id || `rule-${index}`,
+          name: rule.name || `Rule ${index}`,
+          description: rule.description,
+          condition: rule.condition,
+          action: rule.action,
+          enabled: rule.enabled !== false,
+        })),
+        status: parsed.status || 'active',
+      };
+
+      logger.debug({ policyId: policy.metadata.id }, 'Parsed YAML policy');
+      return policy;
+    } catch (error) {
+      if (error instanceof PolicyParseError) {
+        throw error;
+      }
+      throw new PolicyParseError(`YAML parse error: ${error instanceof Error ? error.message : String(error)}`, {
+        originalError: error,
+      });
+    }
+  }
+
+  stringify(policy: Policy): string {
+    try {
+      return YAML.stringify(policy);
+    } catch (error) {
+      throw new PolicyParseError(`YAML stringify error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}

package/dist/bundled-agents/policy-engine-agents/src/core/primitives/cost-calculator.ts

@@ -0,0 +1,232 @@
+/**
+ * Cost Calculator for LLM requests
+ */
+import { TokenCounter } from './token-counter';
+
+export interface CostEstimate {
+  provider: string;
+  model: string;
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+  promptCost: number;
+  completionCost: number;
+  totalCost: number;
+  currency: string;
+}
+
+export interface ProviderPricing {
+  promptCostPer1kTokens: number;
+  completionCostPer1kTokens: number;
+  currency: string;
+}
+
+export class CostCalculator {
+  private tokenCounter: TokenCounter;
+
+  // Pricing data (as of 2025 - update regularly)
+  private pricing: Record<string, Record<string, ProviderPricing>> = {
+    openai: {
+      'gpt-4-turbo': {
+        promptCostPer1kTokens: 0.01,
+        completionCostPer1kTokens: 0.03,
+        currency: 'USD',
+      },
+      'gpt-4': {
+        promptCostPer1kTokens: 0.03,
+        completionCostPer1kTokens: 0.06,
+        currency: 'USD',
+      },
+      'gpt-4-32k': {
+        promptCostPer1kTokens: 0.06,
+        completionCostPer1kTokens: 0.12,
+        currency: 'USD',
+      },
+      'gpt-3.5-turbo': {
+        promptCostPer1kTokens: 0.0005,
+        completionCostPer1kTokens: 0.0015,
+        currency: 'USD',
+      },
+      'gpt-3.5-turbo-16k': {
+        promptCostPer1kTokens: 0.003,
+        completionCostPer1kTokens: 0.004,
+        currency: 'USD',
+      },
+    },
+    anthropic: {
+      'claude-3-opus': {
+        promptCostPer1kTokens: 0.015,
+        completionCostPer1kTokens: 0.075,
+        currency: 'USD',
+      },
+      'claude-3-sonnet': {
+        promptCostPer1kTokens: 0.003,
+        completionCostPer1kTokens: 0.015,
+        currency: 'USD',
+      },
+      'claude-3-haiku': {
+        promptCostPer1kTokens: 0.00025,
+        completionCostPer1kTokens: 0.00125,
+        currency: 'USD',
+      },
+      'claude-2.1': {
+        promptCostPer1kTokens: 0.008,
+        completionCostPer1kTokens: 0.024,
+        currency: 'USD',
+      },
+      'claude-2': {
+        promptCostPer1kTokens: 0.008,
+        completionCostPer1kTokens: 0.024,
+        currency: 'USD',
+      },
+      'claude-instant': {
+        promptCostPer1kTokens: 0.0008,
+        completionCostPer1kTokens: 0.0024,
+        currency: 'USD',
+      },
+    },
+    google: {
+      'gemini-pro': {
+        promptCostPer1kTokens: 0.00025,
+        completionCostPer1kTokens: 0.0005,
+        currency: 'USD',
+      },
+      'gemini-ultra': {
+        promptCostPer1kTokens: 0.001,
+        completionCostPer1kTokens: 0.002,
+        currency: 'USD',
+      },
+      'palm-2': {
+        promptCostPer1kTokens: 0.0005,
+        completionCostPer1kTokens: 0.0005,
+        currency: 'USD',
+      },
+    },
+  };
+
+  constructor() {
+    this.tokenCounter = new TokenCounter();
+  }
+
+  /**
+   * Calculate cost for a request
+   */
+  calculateCost(
+    provider: string,
+    model: string,
+    promptTokens: number,
+    completionTokens: number,
+  ): CostEstimate {
+    const pricing = this.getPricing(provider, model);
+
+    const promptCost = (promptTokens / 1000) * pricing.promptCostPer1kTokens;
+    const completionCost = (completionTokens / 1000) * pricing.completionCostPer1kTokens;
+    const totalCost = promptCost + completionCost;
+
+    return {
+      provider,
+      model,
+      promptTokens,
+      completionTokens,
+      totalTokens: promptTokens + completionTokens,
+      promptCost,
+      completionCost,
+      totalCost,
+      currency: pricing.currency,
+    };
+  }
+
+  /**
+   * Estimate cost from text
+   */
+  estimateCostFromText(
+    provider: string,
+    model: string,
+    promptText: string,
+    estimatedCompletionTokens: number = 500,
+  ): CostEstimate {
+    const { tokens: promptTokens } = this.tokenCounter.estimateTokens(promptText, model);
+
+    return this.calculateCost(provider, model, promptTokens, estimatedCompletionTokens);
+  }
+
+  /**
+   * Get pricing for a provider/model
+   */
+  getPricing(provider: string, model: string): ProviderPricing {
+    const providerLower = provider.toLowerCase();
+    const modelLower = model.toLowerCase();
+
+    // Try exact match first
+    if (this.pricing[providerLower]?.[modelLower]) {
+      return this.pricing[providerLower][modelLower];
+    }
+
+    // Try partial match (e.g., "gpt-4-turbo-preview" matches "gpt-4-turbo")
+    // Sort keys by length descending to match most specific model first
+    const providerPricing = this.pricing[providerLower];
+    if (providerPricing) {
+      const matchingModel = Object.keys(providerPricing)
+        .sort((a, b) => b.length - a.length)
+        .find((key) => modelLower.includes(key.toLowerCase()));
+
+      if (matchingModel) {
+        return providerPricing[matchingModel];
+      }
+    }
+
+    // Default pricing if not found
+    return {
+      promptCostPer1kTokens: 0.01,
+      completionCostPer1kTokens: 0.03,
+      currency: 'USD',
+    };
+  }
+
+  /**
+   * Compare costs across providers/models
+   */
+  compareCosts(
+    promptTokens: number,
+    completionTokens: number,
+    models: Array<{ provider: string; model: string }>,
+  ): CostEstimate[] {
+    return models.map(({ provider, model }) =>
+      this.calculateCost(provider, model, promptTokens, completionTokens),
+    );
+  }
+
+  /**
+   * Find cheapest option
+   */
+  findCheapest(
+    promptTokens: number,
+    completionTokens: number,
+    models: Array<{ provider: string; model: string }>,
+  ): CostEstimate {
+    const costs = this.compareCosts(promptTokens, completionTokens, models);
+    return costs.reduce((cheapest, current) =>
+      current.totalCost < cheapest.totalCost ? current : cheapest,
+    );
+  }
+
+  /**
+   * Calculate monthly cost based on usage
+   */
+  calculateMonthlyCost(
+    provider: string,
+    model: string,
+    dailyRequests: number,
+    avgPromptTokens: number,
+    avgCompletionTokens: number,
+  ): number {
+    const singleRequestCost = this.calculateCost(
+      provider,
+      model,
+      avgPromptTokens,
+      avgCompletionTokens,
+    ).totalCost;
+
+    return singleRequestCost * dailyRequests * 30;
+  }
+}

package/dist/bundled-agents/policy-engine-agents/src/core/primitives/index.ts

@@ -0,0 +1,7 @@
+/**
+ * LLM Primitives - Export all primitive functions
+ */
+
+export * from './token-counter';
+export * from './pii-detector';
+export * from './cost-calculator';