@hazeljs/cli 2.0.5 → 2.0.6

package/README.md

@@ -1,8 +1,8 @@
 # @hazeljs/cli
 
-**From zero to AI-powered apps in one command.**
+**Scaffold Agent OS apps and HazelJS backends.**
 
-Generate controllers, services, modules, AI agents, RAG systems — or create a complete AI-Native application with PostgreSQL, Redis, and Docker. Interactive project setup, package management, and code that follows best practices.
+DNA / Store / Skillgate / HITL live in [Meridian](https://github.com/hazel-js/hazeljs-meridian-ops) and `hazel agent new`. HTTP + HCEL templates (`--template=ai-native`) are a secondary framework path — not the Agent OS flagship.
 
 [![npm version](https://img.shields.io/npm/v/@hazeljs/cli.svg)](https://www.npmjs.com/package/@hazeljs/cli)
 [![npm downloads](https://img.shields.io/npm/dm/@hazeljs/cli)](https://www.npmjs.com/package/@hazeljs/cli)
@@ -10,13 +10,13 @@ Generate controllers, services, modules, AI agents, RAG systems — or create a
 
 ## Features
 
-- 🤖 **AI-Native Templates** - Create complete AI applications with agents, RAG, PostgreSQL, and Docker
-- 🚀 **Project Scaffolding** - Create new HazelJS applications instantly with interactive setup
-- 🎨 **Code Generation** - Generate controllers, services, AI agents, RAG systems, and 20+ component types
-- 📦 **Package Management** - Add HazelJS packages interactively with optional setup file generation
-- 🏗️ **Best Practices** - Generated code follows HazelJS conventions and AI patterns
-- 🎯 **TypeScript First** - All generated code is fully typed
-- ⚡ **Fast Development** - Reduce boilerplate and speed up development
+- 🧬 **Agent OS** — `hazel agent new` (bare / agent-os / skillgate), Store, DNA install, runs, apply
+- 🚪 **Skillgate / Gatekeeper** — `hazel skillgate from-openapi`, `hazel gatekeeper validate|simulate|explain`
+- 🧪 **Eval / benchmark** — `hazel eval`, `hazel benchmark`
+- 🚀 **App scaffolding** — `hazel new`, `hazel g app` (HTTP skeleton or `--template=ai-native`)
+- 🎨 **Code generation** — controllers, services, agents, RAG, 20+ component types
+- 📦 **Package management** — `hazel add` with optional setup files
+- Generated apps do **not** list or import `reflect-metadata` — `@hazeljs/core` loads it
 
 ## Installation
 
@@ -34,25 +34,45 @@ npm install --save-dev @hazeljs/cli
 
 ## Commands
 
-### Create a New Application
+### Agent OS (start here)
 
-**AI-Native Application (Recommended for AI Projects):**
+**Flagship teaching path** — clone [Meridian](https://github.com/hazel-js/hazeljs-meridian-ops) (`store:sync` → `platform:sync` → `dev`). The CLI is not a substitute for that app.
+
+```bash
+# Smaller Agent OS / DNA scaffold (not Meridian)
+hazel agent new my-desk --template=agent-os
+# templates: bare | agent-os | skillgate
+# agent-os includes: DNA + real @Tool app + ops stack (self-healing + predictive-scaling) + K8s manifests
+cd my-desk && npm install && npm run dev
+
+hazel agent install ./packages/support.dna.json
+hazel agent runs list
+hazel store publish | install | list
+hazel skillgate from-openapi ./openapi.yaml
+hazel gatekeeper validate
+hazel benchmark
+hazel eval
+```
+
+`hazel agent run` is a DNA smoke with stubs. Real tools and HITL = your app’s `runtime.execute` / Meridian `/api/chat`. `hazel agent apply` declares desired state — it does not restart Node.
+
+### Create a framework application (secondary)
+
+HTTP + HCEL / RAG scaffold — **not** the Agent OS flagship:
 
 ```bash
 hazel g app my-ai-app --template=ai-native
 cd my-ai-app && npm install && cp .env.example .env && docker-compose up -d && npm run dev
 ```
 
-Creates a complete AI-powered application with agents, RAG (PostgreSQL + pgvector), Redis, and Docker.
-
-**Skeleton app (quick start):**
+Skeleton API:
 
 ```bash
 hazel g app my-app
 cd my-app && npm install && npm run dev
 ```
 
-**Full setup with interactive package selection:**
+Interactive package selection:
 
 ```bash
 hazel new my-app -i
@@ -218,6 +238,17 @@ hazel g serverless handler --platform lambda
 ## Quick Reference
 
 ```bash
+# Agent OS
+hazel agent new <name> [--template agent-os|bare|skillgate]
+hazel agent install <dna>
+hazel agent run | doctor | logs
+hazel agent runs list | inspect | cancel | resume | approve
+hazel store publish | install | list
+hazel skillgate from-openapi <spec>
+hazel gatekeeper validate | simulate | explain
+hazel benchmark
+hazel eval
+
 # Project Management
 hazel new <name> [-i]                # Create new project
 hazel info                           # Show project info

package/cli-manifest.json

@@ -4,7 +4,7 @@
   "description": "Machine-readable manifest of all CLI commands and options for LLM agent tool-use",
   "cli": {
     "name": "hazel",
-    "version": "2.0.5",
+    "version": "2.0.6",
     "description": "CLI for generating HazelJS components and applications"
   },
   "commands": [
@@ -746,6 +746,12 @@
           "label": "Configuration (@hazeljs/config)",
           "description": "Environment-based configuration management"
         },
+        {
+          "shortName": "config-server",
+          "npm": "@hazeljs/config-server",
+          "label": "Git config server (@hazeljs/config-server)",
+          "description": "Git-backed distributed configuration (Spring Cloud Config style)"
+        },
         {
           "shortName": "cron",
           "npm": "@hazeljs/cron",

package/dist/commands/agent-templates.js

@@ -54,7 +54,7 @@ exports.AGENT_TEMPLATES = [
     {
         id: 'agent-os',
         label: 'Agent OS mini-app',
-        description: 'DNA + real @Agent/@Tool TypeScript app (HITL refund demo) + store lock',
+        description: 'DNA + real @Agent/@Tool app + ops stack (self-healing + predictive scaling) + K8s manifests',
     },
     {
         id: 'skillgate',
@@ -156,6 +156,235 @@ Wire real \`@Tool\` / Skillgate handlers in your Hazel app for production behavi
 `,
     };
 }
+function agentOsOpsFiles(npm, projectName) {
+    const deployment = npm;
+    const hpaName = `${npm}-hpa`;
+    return {
+        '.env.example': `# Agent runtime
+HITL=0
+
+# Ops stack (proactive scaling + reactive self-healing)
+ENABLE_OPS_STACK=0
+K8S_DEPLOYMENT=${deployment}
+K8S_NAMESPACE=default
+K8S_HPA_NAME=${hpaName}
+PROMETHEUS_URL=http://prometheus.monitoring.svc:9090
+SLACK_BOT_TOKEN=
+PAGERDUTY_ROUTING_KEY=
+`,
+        'src/ops/stack.ts': `import { createOperationsStack } from '@hazeljs/predictive-scaling';
+import {
+  FetchKubernetesRestartClient,
+  FetchKubernetesScalingClient,
+  createSlackHealingNotifier,
+  createHealingNotifierChain,
+  InMemoryKubernetesRestartClient,
+  InMemoryKubernetesScalingClient,
+} from '@hazeljs/self-healing';
+
+export function createAgentOpsStack(appName: string) {
+  const deployment = process.env.K8S_DEPLOYMENT ?? appName;
+  const namespace = process.env.K8S_NAMESPACE ?? 'default';
+  const hpaName = process.env.K8S_HPA_NAME ?? \`\${deployment}-hpa\`;
+  const inCluster = Boolean(process.env.KUBERNETES_SERVICE_HOST);
+
+  const scalingClient = inCluster
+    ? new FetchKubernetesScalingClient()
+    : new InMemoryKubernetesScalingClient();
+  const restartClient = inCluster
+    ? new FetchKubernetesRestartClient()
+    : new InMemoryKubernetesRestartClient();
+
+  const notifications = [];
+  if (process.env.SLACK_BOT_TOKEN) {
+    notifications.push(
+      createSlackHealingNotifier({
+        token: process.env.SLACK_BOT_TOKEN,
+        channel: process.env.SLACK_ALERT_CHANNEL ?? '#ops-alerts',
+      })
+    );
+  }
+
+  return createOperationsStack({
+    healing: {
+      strategies: ['config-rollback', 'hpa-boost', 'pod-restart', 'safe-mode'],
+      aiDiagnostics: true,
+      drain: { timeoutMs: 30_000 },
+      notifyOn: ['critical-healing', 'healing-failed', 'hpa-boost', 'pod-restart'],
+      notifications: notifications.length ? createHealingNotifierChain(notifications) : undefined,
+      kubernetes: {
+        deployment,
+        namespace,
+        client: restartClient,
+        drainBeforeRestart: true,
+        hpa: {
+          name: hpaName,
+          namespace,
+          client: scalingClient,
+          boostMinReplicas: Number(process.env.HPA_BOOST_MIN ?? 4),
+          restoreAfterMs: Number(process.env.HPA_RESTORE_MS ?? 300_000),
+        },
+      },
+      performance: {
+        enabled: true,
+        autoScaleOnDegradation: true,
+        thresholds: { criticalLatencyMs: 2000, sampleSize: 20 },
+      },
+    },
+    scaling: {
+      model: 'time-series-forecast',
+      metrics: ['requests', 'latency', 'cpu'],
+      horizon: '30m',
+      confidence: 0.85,
+      capacityPerReplica: Number(process.env.CAPACITY_PER_REPLICA ?? 120),
+      hpa: {
+        name: hpaName,
+        namespace,
+        client: scalingClient,
+        maxReplicas: Number(process.env.HPA_MAX_REPLICAS ?? 50),
+      },
+    },
+    prometheus: process.env.PROMETHEUS_URL
+      ? {
+          baseUrl: process.env.PROMETHEUS_URL,
+          pollIntervalMs: 60_000,
+          queries: {
+            requests: \`sum(rate(http_requests_total{service="${deployment}"}[5m]))\`,
+            latency:
+              \`histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket{service="${deployment}"}[5m])) by (le))\`,
+            cpu: \`avg(rate(container_cpu_usage_seconds_total{pod=~"${deployment}-.*"}[5m]))\`,
+          },
+        }
+      : undefined,
+  });
+}
+
+let opsStack: ReturnType<typeof createAgentOpsStack> | null = null;
+
+export function startAgentOpsStack(appName: string) {
+  if (opsStack) return opsStack;
+  opsStack = createAgentOpsStack(appName);
+  opsStack.start();
+  return opsStack;
+}
+
+export function stopAgentOpsStack() {
+  opsStack?.stop();
+  opsStack = null;
+}
+`,
+        'deploy/kubernetes/deployment.yaml': `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: ${deployment}
+  labels:
+    app: ${deployment}
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: ${deployment}
+  template:
+    metadata:
+      labels:
+        app: ${deployment}
+    spec:
+      serviceAccountName: ${deployment}
+      containers:
+        - name: agent
+          image: ${deployment}:latest
+          env:
+            - name: ENABLE_OPS_STACK
+              value: "1"
+            - name: K8S_DEPLOYMENT
+              value: ${deployment}
+            - name: K8S_HPA_NAME
+              value: ${hpaName}
+            - name: PROMETHEUS_URL
+              value: http://prometheus.monitoring.svc:9090
+          resources:
+            requests:
+              cpu: 250m
+              memory: 512Mi
+            limits:
+              cpu: "1"
+              memory: 1Gi
+`,
+        'deploy/kubernetes/hpa.yaml': `apiVersion: autoscaling/v2
+kind: HorizontalPodAutoscaler
+metadata:
+  name: ${hpaName}
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: ${deployment}
+  minReplicas: 2
+  maxReplicas: 50
+  metrics:
+    - type: Resource
+      resource:
+        name: cpu
+        target:
+          type: Utilization
+          averageUtilization: 70
+    - type: Resource
+      resource:
+        name: memory
+        target:
+          type: Utilization
+          averageUtilization: 80
+`,
+        'deploy/kubernetes/service.yaml': `apiVersion: v1
+kind: Service
+metadata:
+  name: ${deployment}
+spec:
+  selector:
+    app: ${deployment}
+  ports:
+    - port: 80
+      targetPort: 3000
+`,
+        'deploy/kubernetes/serviceaccount.yaml': `apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: ${deployment}
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: ${deployment}-ops
+rules:
+  - apiGroups: ["autoscaling"]
+    resources: ["horizontalpodautoscalers"]
+    verbs: ["get", "patch", "update"]
+  - apiGroups: ["apps"]
+    resources: ["deployments"]
+    verbs: ["get", "patch", "update"]
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: ${deployment}-ops
+subjects:
+  - kind: ServiceAccount
+    name: ${deployment}
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: Role
+  name: ${deployment}-ops
+`,
+        'deploy/kubernetes/kustomization.yaml': `apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+resources:
+  - serviceaccount.yaml
+  - deployment.yaml
+  - service.yaml
+  - hpa.yaml
+`,
+    };
+}
 function agentOsFiles(projectName) {
     const dnaName = agentDnaName(projectName);
     const npm = sanitizeNpmName(projectName);
@@ -197,6 +426,8 @@ Use lookupOrder for facts. Call processRefund only after lookup. Be concise.`,
             },
             dependencies: {
                 '@hazeljs/agent': '^1.0.6',
+                '@hazeljs/self-healing': '^2.0.5',
+                '@hazeljs/predictive-scaling': '^2.0.5',
             },
             devDependencies: {
                 '@types/node': '^20.19.39',
@@ -279,9 +510,16 @@ import {
   type AgentEvent,
 } from '@hazeljs/agent';
 import { SupportAgent } from './support.agent';
+import { startAgentOpsStack, stopAgentOpsStack } from './ops/stack';
 
 async function main() {
   const input = process.argv.slice(2).join(' ') || 'Where is ORD-1001?';
+
+  if (process.env.ENABLE_OPS_STACK === '1') {
+    startAgentOpsStack('${npm}');
+    process.on('SIGINT', () => stopAgentOpsStack());
+    process.on('SIGTERM', () => stopAgentOpsStack());
+  }
   // Demo uses mock LLM. Wire OpenAI (or another provider) in production apps.
   const llm = createMockLlmProvider(
     'Used real @Tool handlers on AgentRuntime. (Replace createMockLlmProvider with your LLM.)'
@@ -326,6 +564,8 @@ main().catch((e) => {
 | \`dna/agent.marketplace.json\` | DNA / marketplace package (OpenAPI-for-agents) |
 | \`src/support.agent.ts\` | Real tool handlers |
 | \`src/main.ts\` | AgentRuntime bootstrap + optional DNA overlay |
+| \`src/ops/stack.ts\` | Predictive scaling + self-healing ops stack |
+| \`deploy/kubernetes/\` | K8s Deployment, HPA, RBAC for in-cluster ops |
 
 ## Quick start
 
@@ -343,7 +583,21 @@ npm run store:install
 \`\`\`
 
 Set \`HITL=1\` to pause on \`processRefund\` approvals.
+
+## Production ops (predictive + self-healing)
+
+\`\`\`bash
+cp .env.example .env
+ENABLE_OPS_STACK=1 npm run dev
+
+# Deploy to Kubernetes (requires kubectl + kustomize)
+kubectl apply -k deploy/kubernetes
+\`\`\`
+
+- **Proactive:** \`@hazeljs/predictive-scaling\` forecasts traffic and adjusts HPA min replicas
+- **Reactive:** \`@hazeljs/self-healing\` heals failures, drains pods, opens Slack/Jira alerts
 `,
+        ...agentOsOpsFiles(npm, projectName),
     };
 }
 function skillgateFiles(projectName) {

package/dist/commands/agent.test.js

@@ -88,8 +88,12 @@ describe('agent templates scaffold', () => {
         (0, agent_templates_1.scaffoldAgentProject)({ name: 'os-demo', destDir: dest, template: 'agent-os' });
         expect(fs.existsSync(path.join(dest, 'src/support.agent.ts'))).toBe(true);
         expect(fs.existsSync(path.join(dest, 'src/main.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(dest, 'src/ops/stack.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(dest, 'deploy/kubernetes/hpa.yaml'))).toBe(true);
         expect(fs.existsSync(path.join(dest, 'dna/agent.marketplace.json'))).toBe(true);
         const pkg = JSON.parse(fs.readFileSync(path.join(dest, 'package.json'), 'utf8'));
+        expect(pkg.dependencies['@hazeljs/self-healing']).toBe('^2.0.5');
+        expect(pkg.dependencies['@hazeljs/predictive-scaling']).toBe('^2.0.5');
         expect(pkg.dependencies['reflect-metadata']).toBeUndefined();
         const main = fs.readFileSync(path.join(dest, 'src/main.ts'), 'utf8');
         const agent = fs.readFileSync(path.join(dest, 'src/support.agent.ts'), 'utf8');

package/dist/utils/packages-registry.js

@@ -91,6 +91,22 @@ export const oauthImports = [
         moduleExpression: "ConfigModule.forRoot({ envFilePath: '.env' })",
         setupTemplate: null,
     },
+    {
+        shortName: 'config-server',
+        npm: '@hazeljs/config-server',
+        label: 'Git config server (@hazeljs/config-server)',
+        hint: 'import { ConfigServer } from "@hazeljs/config-server";\n  // await new ConfigServer({ git: { uri: process.env.CONFIG_GIT_URI! }, port: 8888 }).start()',
+        moduleImport: "import { ConfigServerModule } from '@hazeljs/config-server';",
+        moduleExpression: "ConfigServerModule.forRoot({ git: { uri: process.env.CONFIG_GIT_URI || '' }, port: 8888 })",
+        setupTemplate: `import { ConfigServerModule } from '@hazeljs/config-server';
+
+// Add ConfigServerModule.forRoot(...) to your HazelModule imports, then start:
+// await new ConfigServer({ git: { uri: process.env.CONFIG_GIT_URI! }, port: 8888 }).start();
+export const configServerImports = [
+  ConfigServerModule.forRoot({ git: { uri: process.env.CONFIG_GIT_URI || '' }, port: 8888 }),
+];
+`,
+    },
     {
         shortName: 'cron',
         npm: '@hazeljs/cron',
@@ -363,6 +379,37 @@ export class ExampleResilienceService {
     return 'ok';
   }
 }
+`,
+    },
+    {
+        shortName: 'self-healing',
+        npm: '@hazeljs/self-healing',
+        label: 'Self-Healing Microservices (@hazeljs/self-healing)',
+        hint: 'import { SelfHealing, SelfHeal, createHealingCoordinator } from "@hazeljs/self-healing";',
+        moduleImport: null,
+        moduleExpression: null,
+        setupTemplate: `import { createHealingCoordinator } from '@hazeljs/self-healing';
+
+export const healing = createHealingCoordinator({
+  strategies: ['config-rollback', 'hpa-boost', 'pod-restart'],
+});
+`,
+    },
+    {
+        shortName: 'predictive-scaling',
+        npm: '@hazeljs/predictive-scaling',
+        label: 'Predictive Auto-Scaling (@hazeljs/predictive-scaling)',
+        hint: 'import { PredictiveScaling, createPredictiveScaler } from "@hazeljs/predictive-scaling";',
+        moduleImport: null,
+        moduleExpression: null,
+        setupTemplate: `import { createPredictiveScaler } from '@hazeljs/predictive-scaling';
+
+// Wire hpa.client to your Kubernetes scaling client
+export const scaler = createPredictiveScaler({
+  horizon: '30m',
+  metrics: ['requests', 'latency'],
+  hpa: { name: 'api-hpa', client: scalingClient },
+});
 `,
     },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/cli",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "description": "Command-line interface for scaffolding and generating HazelJS applications and components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -31,11 +31,11 @@
     "mustache": "^4.2.0"
   },
   "peerDependencies": {
-    "@hazeljs/eval": "^2.0.5",
-    "@hazeljs/benchmark": "^2.0.5",
-    "@hazeljs/agent": "^2.0.5",
-    "@hazeljs/skillgate": "^2.0.5",
-    "@hazeljs/agent-gatekeeper": "^2.0.5"
+    "@hazeljs/eval": "^2.0.6",
+    "@hazeljs/benchmark": "^2.0.6",
+    "@hazeljs/agent": "^2.0.6",
+    "@hazeljs/skillgate": "^2.0.6",
+    "@hazeljs/agent-gatekeeper": "^2.0.6"
   },
   "peerDependenciesMeta": {
     "@hazeljs/eval": {
@@ -55,11 +55,11 @@
     }
   },
   "devDependencies": {
-    "@hazeljs/eval": "^2.0.5",
-    "@hazeljs/benchmark": "^2.0.5",
-    "@hazeljs/agent": "^2.0.5",
-    "@hazeljs/skillgate": "^2.0.5",
-    "@hazeljs/agent-gatekeeper": "^2.0.5",
+    "@hazeljs/eval": "^2.0.6",
+    "@hazeljs/benchmark": "^2.0.6",
+    "@hazeljs/agent": "^2.0.6",
+    "@hazeljs/skillgate": "^2.0.6",
+    "@hazeljs/agent-gatekeeper": "^2.0.6",
     "@types/inquirer": "^8.2.10",
     "@types/mustache": "^4.2.5",
     "typescript": "^6.0.3"