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

package/dist/bundled-agents/marketplace-agents/index.js

@@ -1,208 +0,0 @@
-/**
- * marketplace-agents — Google Cloud Function Entry Point
- *
- * Cloud Function name : marketplace-agents
- * Runtime             : nodejs20
- * Entry point         : handler
- * Region              : us-central1
- *
- * Routes:
- *   GET  /health                          → Health check
- *   POST /v1/marketplace/package          → Marketplace Packaging Agent
- *   POST /v1/marketplace/deprecation      → Deprecation Agent
- *
- * Every response includes execution_metadata and layers_executed.
- *
- * Deploy:
- *   gcloud functions deploy marketplace-agents \
- *     --runtime nodejs20 --trigger-http --region us-central1 \
- *     --project agentics-dev --entry-point handler \
- *     --memory 512MB --timeout 60s --no-allow-unauthenticated
- */
-
-'use strict';
-
-const crypto = require('crypto');
-
-// Import agent handlers — business logic is NOT duplicated.
-const {
-  handleDeprecation,
-  handlePackaging,
-} = require('./src/unified-service/server');
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const SERVICE = 'marketplace-agents';
-const VERSION = '1.0.0';
-
-const CORS_HEADERS = {
-  'Access-Control-Allow-Origin': process.env.CORS_ORIGIN || '*',
-  'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
-  'Access-Control-Allow-Headers':
-    'Content-Type, Authorization, X-Request-Id, X-Correlation-Id, X-Execution-Id, X-Parent-Span-Id',
-  'Access-Control-Max-Age': '86400',
-};
-
-// ---------------------------------------------------------------------------
-// Agent routing table — only the 2 owned agents
-// ---------------------------------------------------------------------------
-
-const AGENTS = {
-  '/v1/marketplace/package': {
-    handler: handlePackaging,
-    layerName: 'MARKETPLACE_PACKAGE',
-  },
-  '/v1/marketplace/deprecation': {
-    handler: handleDeprecation,
-    layerName: 'MARKETPLACE_DEPRECATION',
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Apply CORS and standard headers to the response.
- */
-function setCors(res) {
-  Object.entries(CORS_HEADERS).forEach(([k, v]) => res.set(k, v));
-  res.set('Content-Type', 'application/json');
-  res.set('X-Service-Name', SERVICE);
-}
-
-/**
- * Build the execution_metadata block required on every response.
- */
-function buildExecutionMetadata(req) {
-  return {
-    trace_id: req.headers['x-correlation-id'] || crypto.randomUUID(),
-    timestamp: new Date().toISOString(),
-    service: SERVICE,
-    execution_id: crypto.randomUUID(),
-  };
-}
-
-/**
- * Send a JSON response enriched with execution_metadata + layers_executed.
- */
-function sendResponse(res, statusCode, body, layers, req) {
-  res.status(statusCode).json({
-    ...body,
-    execution_metadata: buildExecutionMetadata(req),
-    layers_executed: layers,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Cloud Function handler
-// ---------------------------------------------------------------------------
-
-/**
- * HTTP entry point for Google Cloud Functions.
- *
- * @param {import('@google-cloud/functions-framework').Request}  req
- * @param {import('@google-cloud/functions-framework').Response} res
- */
-exports.handler = async (req, res) => {
-  setCors(res);
-
-  // ---- CORS preflight ----
-  if (req.method === 'OPTIONS') {
-    return res.status(204).send('');
-  }
-
-  const path = req.path || '/';
-
-  // ---- Health check ----
-  if ((path === '/' || path === '/health') && req.method === 'GET') {
-    return sendResponse(
-      res,
-      200,
-      {
-        service: SERVICE,
-        version: VERSION,
-        status: 'healthy',
-        agents: ['package', 'deprecation'],
-        timestamp: new Date().toISOString(),
-      },
-      [{ layer: 'HEALTH_CHECK', status: 'completed' }],
-      req,
-    );
-  }
-
-  // ---- Agent routing ----
-  const agent = AGENTS[path];
-
-  if (!agent) {
-    return sendResponse(
-      res,
-      404,
-      {
-        success: false,
-        error: {
-          code: 'NOT_FOUND',
-          message: `Route ${path} not found`,
-        },
-        available_routes: [
-          'GET  /health',
-          'POST /v1/marketplace/package',
-          'POST /v1/marketplace/deprecation',
-        ],
-      },
-      [{ layer: 'AGENT_ROUTING', status: 'error' }],
-      req,
-    );
-  }
-
-  if (req.method !== 'POST') {
-    return sendResponse(
-      res,
-      405,
-      {
-        success: false,
-        error: { code: 'METHOD_NOT_ALLOWED', message: 'POST only' },
-      },
-      [{ layer: 'AGENT_ROUTING', status: 'error' }],
-      req,
-    );
-  }
-
-  // ---- Execute agent ----
-  const body = req.body || {};
-  const agentStart = Date.now();
-
-  try {
-    const result = await agent.handler(req, body);
-    const duration_ms = Date.now() - agentStart;
-
-    return sendResponse(
-      res,
-      result.status,
-      result.body,
-      [
-        { layer: 'AGENT_ROUTING', status: 'completed' },
-        { layer: agent.layerName, status: 'completed', duration_ms },
-      ],
-      req,
-    );
-  } catch (error) {
-    const duration_ms = Date.now() - agentStart;
-
-    return sendResponse(
-      res,
-      500,
-      {
-        success: false,
-        error: { code: 'INTERNAL_ERROR', message: error.message },
-      },
-      [
-        { layer: 'AGENT_ROUTING', status: 'completed' },
-        { layer: agent.layerName, status: 'error', duration_ms },
-      ],
-      req,
-    );
-  }
-};

package/dist/bundled-agents/marketplace-agents/package-lock.json

@@ -1,15 +0,0 @@
-{
-  "name": "marketplace-agents",
-  "version": "1.0.0",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "marketplace-agents",
-      "version": "1.0.0",
-      "engines": {
-        "node": ">=20.0.0"
-      }
-    }
-  }
-}

package/dist/bundled-agents/marketplace-agents/package.json

@@ -1,9 +0,0 @@
-{
-  "name": "marketplace-agents",
-  "version": "1.0.0",
-  "description": "Marketplace Agents Cloud Function — Package + Deprecation",
-  "main": "index.js",
-  "engines": {
-    "node": ">=20.0.0"
-  }
-}

package/dist/bundled-agents/marketplace-agents/src/unified-service/execution-context.js

@@ -1,258 +0,0 @@
-/**
- * Execution Context Module
- *
- * Runtime implementation for the Foundational Execution Unit span lifecycle.
- * Provides functions to extract execution context, create/close spans,
- * attach artifacts, and build the structured execution result.
- *
- * This module enforces the invariants required by the Agentics execution system:
- *   - parent_span_id must be present (reject otherwise)
- *   - Every agent execution produces a span
- *   - No successful result without at least one agent span
- *   - Artifacts attach to agent spans only
- *   - Causal ordering via parent_span_id chain: Core -> Repo -> Agent
- */
-
-const crypto = require('crypto');
-
-const REPO_NAME = 'llm-marketplace';
-
-/**
- * Generate a UUID v4.
- * @returns {string}
- */
-function generateSpanId() {
-  return crypto.randomUUID();
-}
-
-/**
- * Extract and validate execution context from the request.
- * Checks body fields first (primary), then headers (fallback).
- *
- * @param {import('http').IncomingMessage} req
- * @param {object} body - parsed request body
- * @returns {{ valid: true, context: { execution_id: string, parent_span_id: string } } | { valid: false, error: string }}
- */
-function extractExecutionContext(req, body) {
-  const parent_span_id = body?.parent_span_id
-    || req.headers['x-parent-span-id']
-    || null;
-
-  if (!parent_span_id) {
-    return {
-      valid: false,
-      error: 'MISSING_PARENT_SPAN_ID: parent_span_id is required. '
-           + 'Provide in request body or X-Parent-Span-Id header.',
-    };
-  }
-
-  const execution_id = body?.execution_id
-    || req.headers['x-execution-id']
-    || generateSpanId();
-
-  return {
-    valid: true,
-    context: { execution_id, parent_span_id },
-  };
-}
-
-/**
- * Create an open repo-level span linked to the Core's parent span.
- *
- * @param {{ execution_id: string, parent_span_id: string }} executionContext
- * @returns {object} repo span (end_time is null until closed)
- */
-function createRepoSpan(executionContext) {
-  return {
-    span_id: generateSpanId(),
-    parent_span_id: executionContext.parent_span_id,
-    type: 'repo',
-    repo_name: REPO_NAME,
-    execution_id: executionContext.execution_id,
-    start_time: new Date().toISOString(),
-    end_time: null,
-    status: 'ok',
-    agent_count: 0,
-    metadata: {},
-  };
-}
-
-/**
- * Create an open agent-level span linked to the repo span.
- *
- * @param {string} agentName - registered agent name
- * @param {string} repoSpanId - the repo span's span_id
- * @returns {object} agent span (end_time is null until closed)
- */
-function createAgentSpan(agentName, repoSpanId) {
-  return {
-    span_id: generateSpanId(),
-    parent_span_id: repoSpanId,
-    type: 'agent',
-    agent_name: agentName,
-    repo_name: REPO_NAME,
-    start_time: new Date().toISOString(),
-    end_time: null,
-    status: 'ok',
-    artifacts: [],
-    evidence: [],
-    metadata: {},
-  };
-}
-
-/**
- * Close a span by setting its end_time and final status.
- *
- * @param {object} span
- * @param {string} [status='ok'] - 'ok', 'error', or 'invalid'
- * @returns {object} the closed span
- */
-function closeSpan(span, status) {
-  span.end_time = new Date().toISOString();
-  span.status = status || 'ok';
-  return span;
-}
-
-/**
- * Create an artifact envelope.
- *
- * @param {string} artifactType - e.g. 'DecisionEvent', 'AgentOutput'
- * @param {object} data - artifact payload
- * @returns {object}
- */
-function createArtifact(artifactType, data) {
-  return {
-    artifact_id: generateSpanId(),
-    artifact_type: artifactType,
-    produced_at: new Date().toISOString(),
-    data,
-  };
-}
-
-/**
- * Attach an artifact to an agent span.
- *
- * @param {object} agentSpan
- * @param {object} artifact
- * @returns {object} the agent span
- */
-function attachArtifact(agentSpan, artifact) {
-  agentSpan.artifacts.push(artifact);
-  return agentSpan;
-}
-
-/**
- * Wrap an agent handler invocation with full span lifecycle.
- *
- * Creates an agent span, invokes the handler, attaches any DecisionEvent
- * and AgentOutput artifacts, and closes the span.
- *
- * @param {string} agentName - registered agent name
- * @param {object} repoSpan - the repo-level span
- * @param {Function} handlerFn - async (req, body) => { status, body }
- * @param {import('http').IncomingMessage} req
- * @param {object} body - parsed request body
- * @returns {Promise<{ agentSpan: object, handlerResult: object }>}
- */
-async function executeAgentWithSpan(agentName, repoSpan, handlerFn, req, body) {
-  const agentSpan = createAgentSpan(agentName, repoSpan.span_id);
-
-  try {
-    const handlerResult = await handlerFn(req, body);
-
-    // Attach DecisionEvent if present in the response
-    const decisionEvent = handlerResult?.body?.data?.decisionEvent;
-    if (decisionEvent) {
-      attachArtifact(agentSpan, createArtifact('DecisionEvent', decisionEvent));
-    }
-
-    // Attach a summary of the agent output as evidence
-    attachArtifact(agentSpan, createArtifact('AgentOutput', {
-      status: handlerResult.status,
-      result_code: handlerResult.body?.result_code,
-      success: handlerResult.body?.success,
-    }));
-
-    closeSpan(agentSpan, handlerResult.status >= 400 ? 'error' : 'ok');
-
-    return { agentSpan, handlerResult };
-  } catch (error) {
-    attachArtifact(agentSpan, createArtifact('Error', {
-      message: error.message,
-      stack: error.stack,
-    }));
-    closeSpan(agentSpan, 'error');
-
-    return {
-      agentSpan,
-      handlerResult: {
-        status: 500,
-        body: {
-          success: false,
-          error: { code: 'AGENT_EXECUTION_ERROR', message: error.message },
-        },
-      },
-    };
-  }
-}
-
-/**
- * Assemble the final RepoExecutionResult.
- *
- * Enforces the invariant that at least one agent span must exist.
- * If no agent spans were produced, returns valid: false and marks the
- * repo span as 'invalid'.
- *
- * @param {object} repoSpan
- * @param {object[]} agentSpans
- * @param {{ execution_id: string, parent_span_id: string }} executionContext
- * @returns {{ valid: boolean, result: object, error?: string }}
- */
-function buildExecutionResult(repoSpan, agentSpans, executionContext) {
-  if (!agentSpans || agentSpans.length === 0) {
-    closeSpan(repoSpan, 'invalid');
-    return {
-      valid: false,
-      error: 'NO_AGENT_SPANS: Execution produced no agent spans. '
-           + 'At least one agent must execute.',
-      result: {
-        repo_span: repoSpan,
-        agent_spans: [],
-        artifacts: [],
-        execution_context: executionContext,
-      },
-    };
-  }
-
-  // Check for any failed agent spans
-  const hasFailedAgent = agentSpans.some(s => s.status === 'error');
-
-  repoSpan.agent_count = agentSpans.length;
-  closeSpan(repoSpan, hasFailedAgent ? 'error' : 'ok');
-
-  // Flatten all artifacts from agent spans
-  const allArtifacts = agentSpans.flatMap(s => s.artifacts || []);
-
-  return {
-    valid: true,
-    result: {
-      repo_span: repoSpan,
-      agent_spans: agentSpans,
-      artifacts: allArtifacts,
-      execution_context: executionContext,
-    },
-  };
-}
-
-module.exports = {
-  extractExecutionContext,
-  createRepoSpan,
-  createAgentSpan,
-  closeSpan,
-  createArtifact,
-  attachArtifact,
-  executeAgentWithSpan,
-  buildExecutionResult,
-  generateSpanId,
-  REPO_NAME,
-};