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

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

@@ -0,0 +1,49 @@
+{
+  "name": "@llm-shield/agents",
+  "version": "1.0.0",
+  "private": true,
+  "description": "LLM-Shield Agent Implementations",
+  "type": "module",
+  "main": "functions/dist/index.js",
+  "workspaces": [
+    "contracts",
+    "lib",
+    "prompt-injection-detection",
+    "pii-detection",
+    "data-redaction",
+    "secrets-leakage-detection",
+    "toxicity-detection",
+    "safety-boundary",
+    "content-moderation",
+    "model-abuse-detection",
+    "credential-exposure-detection",
+    "service",
+    "functions"
+  ],
+  "scripts": {
+    "gcp-build": "npm run build -w @llm-shield/agentics-contracts && npm run build -w @llm-shield/lib && npm run build -w @llm-shield/prompt-injection-detection && npm run build -w @llm-shield/pii-detection-agent && npm run build -w @llm-shield/data-redaction-agent && npm run build -w @llm-shield/secrets-leakage-detection-agent && npm run build -w @llm-shield/toxicity-detection && npm run build -w @llm-shield/safety-boundary && npm run build -w @llm-shield/content-moderation-agent && npm run build -w @llm-shield/model-abuse-detection-agent && npm run build -w @llm-shield/credential-exposure-detection-agent && npm run build -w @llm-shield/functions",
+    "build": "npm run build --workspaces",
+    "build:contracts": "npm run build -w @llm-shield/agentics-contracts",
+    "build:agents": "npm run build -w @llm-shield/prompt-injection-detection",
+    "build:content-moderation": "npm run build -w @llm-shield/content-moderation-agent",
+    "build:functions": "npm run build -w @llm-shield/functions",
+    "deploy": "gcloud functions deploy shield-agents --runtime nodejs20 --trigger-http --allow-unauthenticated --region us-central1 --project agentics-dev --entry-point api --memory 512MB --timeout 60s --source .",
+    "test": "npm run test --workspaces --if-present",
+    "typecheck": "npm run typecheck --workspaces --if-present",
+    "clean": "npm run clean --workspaces --if-present",
+    "lint": "eslint . --ext .ts",
+    "format": "prettier --write ."
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "prettier": "^3.2.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "express": "^5.2.1"
+  }
+}

package/dist/cli/index.js

@@ -75,6 +75,11 @@ import { executeErpListCommand, executeErpInspectCommand, executeErpSurfaceComma
 import { executeReadinessShowCommand, executeReadinessExplainCommand, formatReadinessForDisplay, formatReadinessExplainForDisplay, } from '../commands/readiness.js';
 import { executeDemoStartCommand, } from '../commands/demo.js';
 import { executeAgentsListCommand, executeAgentsHealthCommand, executeAgentsInvokeCommand, executeNaturalLanguageRoute, formatAgentsListForDisplay, formatAgentResultForDisplay, formatRouteResultForDisplay, routeResultToJson, AGENT_DOMAINS, } from '../commands/agents.js';
+import { executePhase2Command, formatPhase2ForDisplay } from '../commands/phase2.js';
+import { executePhase3Command, formatPhase3ForDisplay } from '../commands/phase3.js';
+import { executePhase4Command, formatPhase4ForDisplay } from '../commands/phase4.js';
+import { executePhase5Command, formatPhase5ForDisplay } from '../commands/phase5.js';
+import { executePhase6Command, formatPhase6ForDisplay } from '../commands/phase6.js';
 // ============================================================================
 // Utility Helpers
 // ============================================================================
@@ -660,6 +665,20 @@ async function main() {
                 }, options);
                 // Track objective for executive synthesis
                 executiveArtifact = { objective: simInput, command: 'simulate' };
+                // Non-fatal: generate simulation artifacts
+                try {
+                    const { generateSimulationArtifacts } = await import('../synthesis/simulation-artifact-generator.js');
+                    const simArtifacts = await generateSimulationArtifacts({
+                        executionId: options.trace_id ?? crypto.randomUUID(),
+                        query: simInput,
+                        simulationResult: result,
+                        platformAnalysis: [],
+                        correlationId: options.trace_id ?? '',
+                        timing: 0,
+                    });
+                    console.error(`Simulation artifacts: ${simArtifacts.runDir}`);
+                }
+                catch { /* non-fatal */ }
                 break;
             }
             case 'inspect': {
@@ -1651,6 +1670,137 @@ async function main() {
                 console.error('Supported subcommands: list, health, invoke');
                 process.exit(EXIT_CODES.USAGE_ERROR);
             }
+            case 'phase2': {
+                // Phase 2: Transform simulation artifacts into engineering package
+                const phase2Options = {
+                    trace: parsed.options['trace'] ?? parsed.options['trace-id'],
+                    latest: parsed.flags['latest'] === true,
+                    verbose: options.verbose,
+                    format: options.format,
+                };
+                try {
+                    const phase2Result = await executePhase2Command(phase2Options);
+                    if (options.format === 'json') {
+                        console.log(JSON.stringify(phase2Result.manifest, null, parsed.flags['pretty'] ? 2 : 0));
+                    }
+                    else {
+                        console.log(formatPhase2ForDisplay(phase2Result));
+                    }
+                    process.exit(EXIT_CODES.SUCCESS);
+                }
+                catch (error) {
+                    if (error instanceof CLIError) {
+                        console.error(`Error [${error.code}]: ${error.message}`);
+                        process.exit(error.exitCode);
+                    }
+                    throw error;
+                }
+            }
+            case 'phase3': {
+                // Phase 3: Transform engineering package into domain-core implementation
+                const phase3Options = {
+                    trace: parsed.options['trace'] ?? parsed.options['trace-id'],
+                    latest: parsed.flags['latest'] === true,
+                    verbose: options.verbose,
+                    format: options.format,
+                };
+                try {
+                    const phase3Result = await executePhase3Command(phase3Options);
+                    if (options.format === 'json') {
+                        console.log(JSON.stringify(phase3Result.manifest, null, parsed.flags['pretty'] ? 2 : 0));
+                    }
+                    else {
+                        console.log(formatPhase3ForDisplay(phase3Result));
+                    }
+                    process.exit(EXIT_CODES.SUCCESS);
+                }
+                catch (error) {
+                    if (error instanceof CLIError) {
+                        console.error(`Error [${error.code}]: ${error.message}`);
+                        process.exit(error.exitCode);
+                    }
+                    throw error;
+                }
+            }
+            case 'phase4': {
+                // Phase 4: Transform domain-core into deployable Cloud Run service
+                const phase4Options = {
+                    trace: parsed.options['trace'] ?? parsed.options['trace-id'],
+                    latest: parsed.flags['latest'] === true,
+                    verbose: options.verbose,
+                    format: options.format,
+                };
+                try {
+                    const phase4Result = await executePhase4Command(phase4Options);
+                    if (options.format === 'json') {
+                        console.log(JSON.stringify(phase4Result.manifest, null, parsed.flags['pretty'] ? 2 : 0));
+                    }
+                    else {
+                        console.log(formatPhase4ForDisplay(phase4Result));
+                    }
+                    process.exit(EXIT_CODES.SUCCESS);
+                }
+                catch (error) {
+                    if (error instanceof CLIError) {
+                        console.error(`Error [${error.code}]: ${error.message}`);
+                        process.exit(error.exitCode);
+                    }
+                    throw error;
+                }
+            }
+            case 'phase5': {
+                // Phase 5: Build (Code Gen + Deployable Service)
+                const phase5Options = {
+                    trace: parsed.options['trace'] ?? parsed.options['trace-id'],
+                    latest: parsed.flags['latest'] === true,
+                    verbose: options.verbose,
+                    format: options.format,
+                };
+                try {
+                    const phase5Result = await executePhase5Command(phase5Options);
+                    if (options.format === 'json') {
+                        console.log(JSON.stringify(phase5Result.manifest, null, parsed.flags['pretty'] ? 2 : 0));
+                    }
+                    else {
+                        console.log(formatPhase5ForDisplay(phase5Result));
+                    }
+                    process.exit(EXIT_CODES.SUCCESS);
+                }
+                catch (error) {
+                    if (error instanceof CLIError) {
+                        console.error(`Error [${error.code}]: ${error.message}`);
+                        process.exit(error.exitCode);
+                    }
+                    throw error;
+                }
+            }
+            case 'phase6': {
+                // Phase 6: ERP Surface Push
+                const phase6Options = {
+                    trace: parsed.options['trace'] ?? parsed.options['trace-id'],
+                    latest: parsed.flags['latest'] === true,
+                    verbose: options.verbose,
+                    format: options.format,
+                    outputDir: parsed.options['output-dir'] ?? parsed.options['output'],
+                };
+                try {
+                    const phase6Result = await executePhase6Command(phase6Options);
+                    if (options.format === 'json') {
+                        console.log(JSON.stringify(phase6Result.manifest, null, parsed.flags['pretty'] ? 2 : 0));
+                    }
+                    else {
+                        console.log(formatPhase6ForDisplay(phase6Result, phase6Options.outputDir));
+                    }
+                    process.exit(EXIT_CODES.SUCCESS);
+                }
+                catch (error) {
+                    if (error instanceof CLIError) {
+                        console.error(`Error [${error.code}]: ${error.message}`);
+                        process.exit(error.exitCode);
+                    }
+                    throw error;
+                }
+            }
             case 'ask': {
                 // Natural language routing: agentics ask "check this for injection attacks"
                 const queryParts = [];
@@ -1681,6 +1831,35 @@ async function main() {
                             : routeResult.result.timing;
                         console.error(`NL routing completed in ${timing}ms`);
                     }
+                    // If this was an enterprise simulation, offer the prototype pipeline
+                    if (routeResult.kind === 'multi') {
+                        const hasSimIntent = routeResult.result.intents.some((i) => i.domain === 'simulator' && i.agent === 'enterprise');
+                        if (hasSimIntent && process.stdin.isTTY) {
+                            try {
+                                const { executePipeline } = await import('../pipeline/index.js');
+                                const simInvocation = routeResult.result.invocations.find((inv) => inv.intent.domain === 'simulator' && inv.intent.agent === 'enterprise');
+                                const platformInvocations = routeResult.result.invocations.filter((inv) => inv.intent.domain === 'platform');
+                                const pipelineRunDir = `${process.env['HOME'] ?? '/tmp'}/.agentics/runs/${options.trace_id ?? crypto.randomUUID()}`;
+                                await executePipeline({
+                                    executionId: options.trace_id ?? crypto.randomUUID(),
+                                    query: nlQuery,
+                                    simulationResult: simInvocation ? ('result' in simInvocation ? simInvocation.result : null) : null,
+                                    platformAnalysis: platformInvocations.map((inv) => inv.result),
+                                    artifactsDir: pipelineRunDir,
+                                    mode: 'human-in-the-loop', // Decision gate will let user pick
+                                    stageOutputs: new Map(),
+                                    userFeedback: new Map(),
+                                    userContext: {},
+                                });
+                            }
+                            catch (pipeErr) {
+                                // Pipeline errors are non-fatal — simulation results were already displayed
+                                if (options.verbose) {
+                                    console.error(`Pipeline error: ${pipeErr instanceof Error ? pipeErr.message : String(pipeErr)}`);
+                                }
+                            }
+                        }
+                    }
                     process.exit(EXIT_CODES.SUCCESS);
                 }
                 catch (error) {