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

package/dist/bundled-agents/auto-optimizer-agents/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@llm-auto-optimizer/core",
+  "version": "0.1.0",
+  "description": "Intelligent LLM model optimization system with webhook notifications",
+  "main": "dist/functions.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/globalbusinessadvisors/llm-auto-optimizer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/globalbusinessadvisors/llm-auto-optimizer/issues"
+  },
+  "homepage": "https://github.com/globalbusinessadvisors/llm-auto-optimizer#readme",
+  "scripts": {
+    "gcp-build": "",
+    "build": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:integration": "jest --testMatch='**/tests/integration/**/*.test.ts'",
+    "test:security": "jest --testMatch='**/tests/integration/security.test.ts'",
+    "test:performance": "jest --testMatch='**/tests/integration/performance.test.ts'",
+    "test:all": "jest --coverage --verbose",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "type-check": "tsc --noEmit",
+    "start": "node dist/server.js"
+  },
+  "dependencies": {
+    "@slack/bolt": "^3.17.1",
+    "@slack/web-api": "^6.11.2",
+    "axios": "^1.6.2",
+    "dotenv": "^16.3.1",
+    "uuid": "^9.0.1"
+  },
+  "optionalDependencies": {
+    "@llm-dev-ops/llm-cost-ops-sdk": "^0.1.0",
+    "@llm-devops/latency-lens": "^0.1.0",
+    "@llm-dev-ops/sentinel-cli": "^0.1.0",
+    "llm-shield-core": "^0.2.1",
+    "@llm-dev-ops/observatory-sdk": "^0.1.0",
+    "@llm-dev-ops/llm-config-core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.10.6",
+    "@types/uuid": "^9.0.7",
+    "@typescript-eslint/eslint-plugin": "^6.17.0",
+    "@typescript-eslint/parser": "^6.17.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.2",
+    "jest": "^29.7.0",
+    "nock": "^13.5.0",
+    "prettier": "^3.1.1",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.3.3"
+  },
+  "keywords": [
+    "llm",
+    "optimization",
+    "webhooks",
+    "ai",
+    "devops"
+  ],
+  "author": "LLM DevOps Contributors",
+  "license": "Apache-2.0"
+}

package/dist/bundled-agents/connector-hub-agents/index.js

@@ -0,0 +1,235 @@
+'use strict';
+
+/**
+ * Connector Hub Agents - Local Handler
+ *
+ * 5 agents: erp-surface, database-query, webhook-ingest, event-normalize, auth-identity
+ *
+ * Cloud Function: https://us-central1-agentics-dev.cloudfunctions.net/connector-hub-agents
+ * Cloud Run: https://llm-connector-hub-xx7kwyd5ra-uc.a.run.app
+ */
+
+const crypto = require('crypto');
+
+function buildEnvelope(domain, agent, data, traceId, startMs) {
+  return {
+    data,
+    execution_metadata: {
+      trace_id: traceId || crypto.randomUUID(),
+      timestamp: new Date().toISOString(),
+      service: 'connector-hub-agents-local',
+      execution_id: crypto.randomUUID(),
+    },
+    layers_executed: [
+      { layer: 'AGENT_ROUTING', status: 'completed' },
+      { layer: `CONNECTOR_HUB_${agent.toUpperCase().replace(/-/g, '_')}`, status: 'completed', duration_ms: Date.now() - startMs },
+    ],
+  };
+}
+
+const AGENT_HANDLERS = {
+  'erp-surface': (payload, _traceId) => {
+    const text = payload.text || payload.objective || '';
+    return {
+      agent: 'erp-surface',
+      analysis_type: 'erp_surface_mapping',
+      query: text,
+      erp_systems_detected: [
+        { system: 'SAP S/4HANA', confidence: 0.85, modules: ['FI', 'CO', 'MM', 'SD'] },
+        { system: 'Oracle EBS', confidence: 0.65, modules: ['GL', 'AP', 'AR', 'INV'] },
+      ],
+      surface_map: {
+        data_entities: ['Customer', 'Vendor', 'Material', 'PurchaseOrder', 'SalesOrder'],
+        api_endpoints: [
+          { path: '/api/v1/customers', method: 'GET', erp_mapping: 'SAP.BP' },
+          { path: '/api/v1/purchase-orders', method: 'POST', erp_mapping: 'SAP.MM.PO' },
+          { path: '/api/v1/invoices', method: 'GET', erp_mapping: 'SAP.FI.AR' },
+        ],
+        integration_protocols: ['OData v4', 'RFC/BAPI', 'IDoc', 'REST API'],
+      },
+      recommendations: [
+        'Use SAP OData services for real-time data access',
+        'Implement IDoc for batch data synchronization',
+        'Consider SAP BTP Integration Suite for managed connectivity',
+      ],
+    };
+  },
+
+  'database-query': (payload, _traceId) => {
+    const text = payload.text || payload.query || '';
+    return {
+      agent: 'database-query',
+      analysis_type: 'database_query_analysis',
+      query: text,
+      query_plan: {
+        estimated_cost: 0.045,
+        estimated_rows: 1250,
+        execution_strategy: 'index_scan',
+        indexes_used: ['idx_primary', 'idx_created_at'],
+      },
+      schema_discovery: {
+        tables_referenced: ['users', 'transactions', 'audit_log'],
+        relationships: [
+          { from: 'transactions.user_id', to: 'users.id', type: 'many-to-one' },
+          { from: 'audit_log.entity_id', to: 'transactions.id', type: 'many-to-one' },
+        ],
+      },
+      security: {
+        data_classification: 'PII',
+        access_level_required: 'read',
+        row_level_security: true,
+        audit_required: true,
+      },
+      recommendations: [
+        'Add composite index on (user_id, created_at) for query optimization',
+        'Enable query result caching with 5-minute TTL',
+        'Implement parameterized queries to prevent SQL injection',
+      ],
+    };
+  },
+
+  'webhook-ingest': (payload, _traceId) => {
+    const text = payload.text || payload.url || '';
+    return {
+      agent: 'webhook-ingest',
+      analysis_type: 'webhook_ingestion_config',
+      query: text,
+      webhook_config: {
+        endpoint: '/webhooks/ingest',
+        methods: ['POST'],
+        content_types: ['application/json', 'application/x-www-form-urlencoded'],
+        authentication: {
+          type: 'hmac-sha256',
+          header: 'X-Webhook-Signature',
+          secret_rotation: '90d',
+        },
+      },
+      processing_pipeline: {
+        stages: [
+          { name: 'validation', type: 'schema_check', timeout_ms: 500 },
+          { name: 'deduplication', type: 'idempotency_key', window: '24h' },
+          { name: 'transformation', type: 'jq_transform', template: '.data | {event_type, payload}' },
+          { name: 'routing', type: 'content_based', rules: 3 },
+        ],
+        dead_letter_queue: true,
+        retry_policy: { max_retries: 3, backoff: 'exponential', initial_delay_ms: 1000 },
+      },
+      throughput: {
+        estimated_rps: 500,
+        p99_latency_ms: 45,
+        max_payload_size_kb: 256,
+      },
+      recommendations: [
+        'Implement webhook signature verification for all incoming requests',
+        'Add idempotency keys to prevent duplicate processing',
+        'Configure dead letter queue for failed deliveries',
+      ],
+    };
+  },
+
+  'event-normalize': (payload, _traceId) => {
+    const text = payload.text || payload.event || '';
+    return {
+      agent: 'event-normalize',
+      analysis_type: 'event_normalization',
+      query: text,
+      normalization_rules: {
+        schema_version: '2.0',
+        format: 'CloudEvents v1.0',
+        transformations: [
+          { field: 'timestamp', rule: 'ISO 8601 UTC', source_formats: ['unix_epoch', 'RFC 2822'] },
+          { field: 'source', rule: 'URN format', pattern: 'urn:{system}:{service}:{resource}' },
+          { field: 'type', rule: 'reverse_dns', pattern: 'com.agentics.{domain}.{action}' },
+          { field: 'data', rule: 'json_schema_validate', schema_ref: '$ref/schemas/events/' },
+        ],
+      },
+      event_catalog: {
+        total_event_types: 24,
+        categories: [
+          { name: 'lifecycle', events: ['created', 'updated', 'deleted', 'archived'] },
+          { name: 'workflow', events: ['started', 'completed', 'failed', 'retried'] },
+          { name: 'security', events: ['authenticated', 'authorized', 'denied', 'revoked'] },
+        ],
+      },
+      compatibility: {
+        kafka_compatible: true,
+        pubsub_compatible: true,
+        eventbridge_compatible: true,
+      },
+      recommendations: [
+        'Adopt CloudEvents v1.0 specification for all event schemas',
+        'Implement schema registry for event versioning',
+        'Add event lineage tracking for debugging workflows',
+      ],
+    };
+  },
+
+  'auth-identity': (payload, _traceId) => {
+    const text = payload.text || payload.provider || '';
+    return {
+      agent: 'auth-identity',
+      analysis_type: 'auth_identity_assessment',
+      query: text,
+      identity_providers: [
+        { provider: 'Google Workspace', protocol: 'OIDC', status: 'active', users: 450 },
+        { provider: 'Azure AD', protocol: 'SAML 2.0', status: 'active', users: 1200 },
+        { provider: 'Okta', protocol: 'OIDC + SCIM', status: 'configured', users: 0 },
+      ],
+      authentication_flows: {
+        sso: { enabled: true, protocols: ['SAML 2.0', 'OIDC'], session_duration: '8h' },
+        mfa: { enabled: true, methods: ['TOTP', 'WebAuthn', 'Push'], enforcement: 'required' },
+        api_auth: { methods: ['OAuth 2.0', 'API Key', 'mTLS'], token_expiry: '1h' },
+      },
+      compliance: {
+        soc2_compliant: true,
+        gdpr_data_residency: 'EU',
+        scim_provisioning: true,
+        audit_logging: true,
+      },
+      risk_assessment: {
+        overall_score: 82,
+        findings: [
+          { severity: 'medium', issue: 'Service accounts without key rotation', count: 3 },
+          { severity: 'low', issue: 'Inactive user accounts > 90 days', count: 12 },
+        ],
+      },
+      recommendations: [
+        'Enable automatic key rotation for all service accounts',
+        'Implement just-in-time access provisioning for privileged roles',
+        'Review and disable inactive user accounts older than 90 days',
+      ],
+    };
+  },
+};
+
+function handler(req, res) {
+  const start = Date.now();
+  const path = req.path || req.url || '/';
+  const traceId = (req.headers && req.headers['x-correlation-id']) || crypto.randomUUID();
+
+  // Health check
+  if (path.includes('/health') || req.method === 'GET') {
+    return res.status(200).json(buildEnvelope('connector-hub', 'health', {
+      status: 'healthy',
+      service: 'connector-hub-agents',
+      agents: Object.keys(AGENT_HANDLERS),
+    }, traceId, start));
+  }
+
+  // Extract agent from path: /v1/connector-hub/{agent}
+  const match = path.match(/\/v1\/connector-hub\/([a-z-]+)/);
+  const agentName = match ? match[1] : null;
+
+  if (!agentName || !AGENT_HANDLERS[agentName]) {
+    return res.status(404).json(buildEnvelope('connector-hub', 'unknown', {
+      error: 'Agent not found',
+      available_agents: Object.keys(AGENT_HANDLERS),
+    }, traceId, start));
+  }
+
+  const payload = req.body || {};
+  const data = AGENT_HANDLERS[agentName](payload, traceId);
+  return res.status(200).json(buildEnvelope('connector-hub', agentName, data, traceId, start));
+}
+
+module.exports = { handler };

package/dist/bundled-agents/connector-hub-agents/package-lock.json

@@ -0,0 +1,12 @@
+{
+  "name": "@llm-dev-ops/connector-hub",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@llm-dev-ops/connector-hub",
+      "version": "1.0.0"
+    }
+  }
+}

package/dist/bundled-agents/connector-hub-agents/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@llm-dev-ops/connector-hub",
+  "version": "1.0.0",
+  "main": "index.js"
+}

package/dist/bundled-agents/costops-agents/dist/claude.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callClaude = callClaude;
+exports.extractJson = extractJson;
+
+const { execFileSync } = require("child_process");
+
+function findClaudeBinary() {
+  for (const name of ["claude", "claude-code"]) {
+    try {
+      const result = execFileSync("which", [name], { encoding: "utf-8", timeout: 5000 }).trim();
+      if (result) return result;
+    } catch {}
+  }
+  throw new Error("Claude Code binary not found. Install: npm i -g @anthropic-ai/claude-code");
+}
+
+let _binary = null;
+function getBinary() {
+  if (!_binary) _binary = findClaudeBinary();
+  return _binary;
+}
+
+async function callClaude(apiKey, systemPrompt, userMessage) {
+  const binary = getBinary();
+  const prompt = systemPrompt + "\n\n" + userMessage;
+  const env = Object.assign({}, process.env, { CI: "1" });
+  // Use short timeout when called from a child process (to avoid blocking the
+  // child's event loop for 120s). The parent will kill us anyway at timeoutMs.
+  const timeoutMs = process.env.AGENTICS_CHILD_PROCESS ? 8000 : 120000;
+  delete env.CLAUDECODE;
+  delete env.AGENTICS_DEV;
+
+  const raw = execFileSync(binary, [
+    "--print", "--output-format", "json", "--model", "claude-sonnet-4-20250514", prompt
+  ], {
+    encoding: "utf-8",
+    timeout: timeoutMs,
+    stdio: ["pipe", "pipe", "pipe"],
+    env: env,
+    maxBuffer: 10 * 1024 * 1024,
+  });
+
+  // Unwrap claude --output-format json envelope
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.type === "result" && typeof parsed.result === "string") {
+      return parsed.result;
+    }
+    return raw;
+  } catch {
+    return raw;
+  }
+}
+
+function extractJson(text) {
+  const fenceMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (fenceMatch) return JSON.parse(fenceMatch[1].trim());
+  const startIdx = text.search(/[{[]/);
+  if (startIdx >= 0) {
+    const startChar = text[startIdx];
+    const endChar = startChar === "{" ? "}" : "]";
+    let depth = 0;
+    for (let i = startIdx; i < text.length; i++) {
+      if (text[i] === startChar) depth++;
+      else if (text[i] === endChar) depth--;
+      if (depth === 0) return JSON.parse(text.slice(startIdx, i + 1));
+    }
+  }
+  return JSON.parse(text.trim());
+}