@praesidia/neurogent 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,519 @@
+#!/usr/bin/env node
+import {
+  compileToAgentCard,
+  createAgentServer,
+  parseAgentConfig
+} from "../chunk-JBDXA3BS.js";
+import {
+  ShellYamlSchema
+} from "../chunk-VPHKQCPP.js";
+import {
+  clearRuntime,
+  loadRuntime,
+  pingAgent,
+  saveRuntime
+} from "../chunk-ZC65T52L.js";
+
+// src/cli/index.ts
+import { Command as Command9 } from "commander";
+
+// src/cli/commands/init.ts
+import { Command } from "commander";
+import fs from "fs-extra";
+import * as path from "path";
+import chalk from "chalk";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var initCommand = new Command("init").description("Scaffold a new Neuro agent project").argument("<project-name>", "Name of the project directory").option("--template <template>", "Template to use", "ts-basic").action(async (projectName, options) => {
+  const targetDir = path.resolve(process.cwd(), projectName);
+  const templateDir = path.resolve(__dirname, "../../../templates", options.template);
+  console.log(chalk.blue(`[Neuro] Initializing agent ${projectName} using template ${options.template}...`));
+  try {
+    if (fs.existsSync(targetDir)) {
+      console.error(chalk.red(`Error: Directory ${projectName} already exists.`));
+      process.exit(1);
+    }
+    await fs.ensureDir(targetDir);
+    if (fs.existsSync(templateDir)) {
+      await fs.copy(templateDir, targetDir);
+    } else {
+      console.warn(chalk.yellow("Template dir not found, scaffolding bare minimum for demonstration."));
+      await fs.writeFile(path.join(targetDir, "neuro.agent.yaml"), `name: ${projectName}\\nversion: 1.0.0\\ndescription: An A2A agent\\nauthor: Acme\\nlicense: MIT\\ncapabilities: [\\"chat\\"]\\nmodel:\\n  provider: dummy\\n  name: default`);
+      await fs.mkdirp(path.join(targetDir, "src"));
+      await fs.writeFile(path.join(targetDir, "src/index.ts"), `import { createAgent } from '@praesidia/neuro';\\n\\nconst agent = createAgent({ config: './neuro.agent.yaml' });\\nagent.start();\\n`);
+      await fs.writeFile(path.join(targetDir, "package.json"), JSON.stringify({ name: projectName, type: "module", scripts: { dev: "tsx src/index.ts" } }, null, 2));
+    }
+    console.log(chalk.green(`\\nSuccess! Created ${projectName} at ${targetDir}`));
+    console.log(`\\nNext steps:\\n  cd ${projectName}\\n  pnpm install\\n  pnpm dev`);
+  } catch (err) {
+    console.error(chalk.red(`Initialization failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/dev.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import { spawn } from "child_process";
+import * as path2 from "path";
+import * as fs2 from "fs";
+var devCommand = new Command2("dev").description("Start local A2A server with hot reload").option("--port <port>", "Port to listen on", "8080").action(async (options) => {
+  console.log(chalk2.blue(`[Neuro] Starting dev server on port ${options.port}...`));
+  const entryPath = path2.resolve(process.cwd(), "src/index.ts");
+  if (!fs2.existsSync(entryPath)) {
+    console.error(chalk2.red(`Error: entry file not found at ${entryPath}`));
+    process.exit(1);
+  }
+  const runner = spawn("npx", ["tsx", "watch", "src/index.ts"], {
+    stdio: "inherit",
+    env: { ...process.env, PORT: options.port }
+  });
+  runner.on("close", (code) => {
+    console.log(chalk2.yellow(`[Neuro] Dev server exited with code ${code}`));
+  });
+});
+
+// src/cli/commands/build.ts
+import { Command as Command3 } from "commander";
+import * as fs3 from "fs-extra";
+import * as path3 from "path";
+import * as crypto from "crypto";
+import chalk3 from "chalk";
+var buildCommand = new Command3("build").description("Validate config and generate AgentCard").option("--out-dir <dir>", "Output directory", "dist").action(async (options) => {
+  console.log(chalk3.blue("[Neuro] Building AgentCard..."));
+  const configPath = path3.resolve(process.cwd(), "neuro.agent.yaml");
+  if (!fs3.existsSync(configPath)) {
+    console.error(chalk3.red(`Error: Could not find neuro.agent.yaml at ${configPath}`));
+    process.exit(1);
+  }
+  try {
+    const rawYaml = await fs3.readFile(configPath, "utf-8");
+    const config = parseAgentConfig(rawYaml);
+    let policyHash;
+    const policyPath = path3.resolve(process.cwd(), "praesidia.policy.yaml");
+    if (fs3.existsSync(policyPath)) {
+      const policyContent = await fs3.readFile(policyPath, "utf-8");
+      policyHash = crypto.createHash("sha256").update(policyContent).digest("hex");
+      console.log(chalk3.dim(`[Neuro] Policy hash (sha256): ${policyHash}`));
+    }
+    const agentCard = compileToAgentCard(config, policyHash);
+    const outDir = path3.resolve(process.cwd(), options.outDir);
+    await fs3.ensureDir(path3.join(outDir, ".well-known"));
+    const outPath = path3.join(outDir, ".well-known", "agent.json");
+    await fs3.writeFile(outPath, JSON.stringify(agentCard, null, 2));
+    console.log(chalk3.green(`
+\u2713 AgentCard \u2192 ${outPath}`));
+    console.log(chalk3.dim(`  name: ${config.name}  version: ${config.version}  capabilities: ${config.capabilities.join(", ")}`));
+  } catch (err) {
+    console.error(chalk3.red(`Build failed: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/deploy.ts
+import { Command as Command4 } from "commander";
+import fs4 from "fs-extra";
+import * as path4 from "path";
+import chalk4 from "chalk";
+var deployCommand = new Command4("deploy").description("Generate production Docker artifacts for your Neuro agent").option("-c, --config <path>", "Path to neuro.agent.yaml", "neuro.agent.yaml").option("-p, --port <port>", "Port the agent listens on", "8080").option("--compose", "Also generate a docker-compose.yml").action(async (options) => {
+  const configPath = path4.resolve(process.cwd(), options.config);
+  if (!fs4.existsSync(configPath)) {
+    console.error(chalk4.red(`Error: config not found at ${configPath}`));
+    process.exit(1);
+  }
+  let config;
+  try {
+    const rawYaml = await fs4.readFile(configPath, "utf-8");
+    config = parseAgentConfig(rawYaml);
+  } catch (err) {
+    console.error(chalk4.red(`Failed to parse config: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+  const imageName = config.name.toLowerCase().replace(/\s+/g, "-");
+  const port = options.port;
+  const dockerfile = `# syntax=docker/dockerfile:1
+# \u2500\u2500 Stage 1: build \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm ci --ignore-scripts
+
+COPY tsconfig*.json ./
+COPY src ./src
+COPY neuro.agent.yaml ./
+
+RUN npm run build
+
+# \u2500\u2500 Stage 2: runtime \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+FROM node:20-alpine AS runtime
+
+ENV NODE_ENV=production
+ENV PORT=${port}
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm ci --omit=dev --ignore-scripts
+
+COPY --from=builder /app/dist ./dist
+COPY neuro.agent.yaml ./
+
+EXPOSE ${port}
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s \\
+  CMD wget -qO- http://localhost:${port}/.well-known/agent.json || exit 1
+
+CMD ["node", "dist/index.js"]
+`;
+  const dockerignore = `node_modules
+dist
+.neuro
+*.log
+.env
+.env.*
+!.env.example
+.git
+.gitignore
+README.md
+`;
+  const compose = `services:
+  ${imageName}:
+    build: .
+    image: ${imageName}:latest
+    ports:
+      - "${port}:${port}"
+    environment:
+      - NODE_ENV=production
+      - PORT=${port}
+      # Add your provider key:
+      # - OPENAI_API_KEY=\${OPENAI_API_KEY}
+      # - ANTHROPIC_API_KEY=\${ANTHROPIC_API_KEY}
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "http://localhost:${port}/.well-known/agent.json"]
+      interval: 30s
+      timeout: 5s
+      retries: 3
+`;
+  const cwd = process.cwd();
+  await fs4.writeFile(path4.join(cwd, "Dockerfile"), dockerfile);
+  console.log(chalk4.green(`\u2713 Dockerfile`));
+  await fs4.writeFile(path4.join(cwd, ".dockerignore"), dockerignore);
+  console.log(chalk4.green(`\u2713 .dockerignore`));
+  if (options.compose) {
+    await fs4.writeFile(path4.join(cwd, "docker-compose.yml"), compose);
+    console.log(chalk4.green(`\u2713 docker-compose.yml`));
+  }
+  console.log(chalk4.blue(`
+[Neuro] Artifacts generated for ${chalk4.bold(config.name)} v${config.version}
+`));
+  console.log("Build and run:");
+  console.log(chalk4.dim(`  docker build -t ${imageName} .`));
+  console.log(chalk4.dim(`  docker run -p ${port}:${port} -e OPENAI_API_KEY=sk-... ${imageName}`));
+  if (options.compose) {
+    console.log("\nOr with Compose:");
+    console.log(chalk4.dim(`  docker compose up --build`));
+  }
+});
+
+// src/cli/commands/register.ts
+import { Command as Command5 } from "commander";
+import fs5 from "fs-extra";
+import * as path5 from "path";
+import chalk5 from "chalk";
+var registerCommand = new Command5("register").description("Publish your AgentCard to an A2A directory registry").option("-c, --config <path>", "Path to neuro.agent.yaml", "neuro.agent.yaml").option("-r, --registry <url>", "A2A registry base URL", "https://registry.a2a.dev").option("--dry-run", "Validate and print the AgentCard without publishing").action(async (options) => {
+  const configPath = path5.resolve(process.cwd(), options.config);
+  if (!fs5.existsSync(configPath)) {
+    console.error(chalk5.red(`Error: config not found at ${configPath}`));
+    process.exit(1);
+  }
+  let config;
+  try {
+    const rawYaml = await fs5.readFile(configPath, "utf-8");
+    config = parseAgentConfig(rawYaml);
+  } catch (err) {
+    console.error(chalk5.red(`Failed to parse config: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+  const distCardPath = path5.resolve(process.cwd(), "dist", ".well-known", "agent.json");
+  let agentCard;
+  if (fs5.existsSync(distCardPath)) {
+    agentCard = await fs5.readJson(distCardPath);
+    console.log(chalk5.dim(`[Neuro] Using built AgentCard from ${distCardPath}`));
+  } else {
+    agentCard = compileToAgentCard(config);
+    console.log(chalk5.yellow("[Neuro] No dist/ found \u2014 run `neuro build` first for production. Using compiled card."));
+  }
+  console.log(chalk5.blue(`
+[Neuro] AgentCard for ${chalk5.bold(config.name)}:`));
+  console.log(chalk5.dim(JSON.stringify(agentCard, null, 2)));
+  if (options.dryRun) {
+    console.log(chalk5.cyan("\n[Neuro] Dry run complete. No data was sent."));
+    return;
+  }
+  const registryUrl = options.registry.replace(/\/$/, "");
+  const publishUrl = `${registryUrl}/api/v1/agents/publish`;
+  console.log(chalk5.blue(`
+[Neuro] Publishing to ${publishUrl}...`));
+  let responseData;
+  try {
+    const res = await fetch(publishUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(agentCard),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Registry returned ${res.status}: ${body}`);
+    }
+    responseData = await res.json();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(chalk5.red(`
+[Neuro] Registration failed: ${msg}`));
+    console.error(chalk5.dim("Tip: Use --dry-run to validate your AgentCard without publishing."));
+    process.exit(1);
+  }
+  const neuroDir = path5.resolve(process.cwd(), ".neuro");
+  const registrationPath = path5.join(neuroDir, "registration.json");
+  await fs5.ensureDir(neuroDir);
+  const record = {
+    agentName: config.name,
+    registry: registryUrl,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    agentCardUrl: `${registryUrl}/agents/${config.name.toLowerCase().replace(/\s+/g, "-")}`,
+    raw: responseData
+  };
+  await fs5.writeJson(registrationPath, record, { spaces: 2 });
+  console.log(chalk5.green(`
+\u2713 ${config.name} registered successfully.`));
+  console.log(`  Registry: ${chalk5.cyan(registryUrl)}`);
+  console.log(`  AgentCard: ${chalk5.cyan(record.agentCardUrl)}`);
+  console.log(chalk5.dim(`  Registration saved to ${registrationPath}`));
+});
+
+// src/cli/commands/start.ts
+import { Command as Command6 } from "commander";
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as yaml from "js-yaml";
+import chalk6 from "chalk";
+var CONFIG_SEARCH = ["neurogent-shell.yaml", "neurogent-shell.yml", ".neurogent-shell.yaml"];
+function findConfig(explicit) {
+  if (explicit) {
+    const resolved = path6.resolve(explicit);
+    if (!fs6.existsSync(resolved)) throw new Error(`Config not found: ${resolved}`);
+    return resolved;
+  }
+  for (const name of CONFIG_SEARCH) {
+    const resolved = path6.resolve(name);
+    if (fs6.existsSync(resolved)) return resolved;
+  }
+  throw new Error("No config found. Use --config <file> or create neurogent-shell.yaml");
+}
+var startCommand = new Command6("start").description("Start persistent ZeroClaw agent servers from a config file").option("-c, --config <path>", "Path to YAML config file").option("-p, --base-port <number>", "Starting port (default: 4100)", "4100").action(async (opts) => {
+  const basePort = parseInt(opts.basePort, 10);
+  let configPath;
+  try {
+    configPath = findConfig(opts.config);
+  } catch (err) {
+    console.error(chalk6.red(err.message));
+    process.exit(1);
+  }
+  const raw = yaml.load(fs6.readFileSync(configPath, "utf-8"));
+  const validated = ShellYamlSchema.parse(raw);
+  const globalModel = validated.model ? {
+    provider: validated.model.provider,
+    name: validated.model.name,
+    maxTokens: validated.model.max_tokens,
+    temperature: validated.model.temperature,
+    baseUrl: validated.model.base_url
+  } : void 0;
+  const agents = validated.agents.map((a) => ({
+    id: a.id,
+    name: a.name,
+    role: a.role,
+    emoji: a.emoji,
+    inkColor: a.color,
+    expertise: a.expertise,
+    systemPrompt: a.system_prompt,
+    model: a.model ? {
+      provider: a.model.provider,
+      name: a.model.name,
+      maxTokens: a.model.max_tokens,
+      temperature: a.model.temperature,
+      baseUrl: a.model.base_url
+    } : void 0
+  }));
+  console.log(chalk6.magenta("\n  Neurogent ZeroClaw Runtime\n"));
+  console.log(chalk6.gray(`  Config : ${configPath}`));
+  console.log(chalk6.gray(`  Agents : ${agents.length}
+`));
+  clearRuntime();
+  const servers = [];
+  const registration = {
+    agents: [],
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  for (let i = 0; i < agents.length; i++) {
+    const agent = agents[i];
+    const port = basePort + i;
+    const server = createAgentServer(agent, port, globalModel);
+    servers.push(server);
+    try {
+      const instance = await server.start();
+      registration.agents.push({
+        id: agent.id,
+        name: agent.name,
+        url: instance.url,
+        port,
+        pid: process.pid,
+        startedAt: instance.startedAt
+      });
+      console.log(
+        chalk6.green("  \u2713") + chalk6.white(` ${agent.emoji} ${agent.name.padEnd(14)}`) + chalk6.gray(` \u2192 `) + chalk6.cyan(`http://localhost:${port}`)
+      );
+    } catch (err) {
+      console.error(chalk6.red(`  \u2717 ${agent.name}: ${err.message}`));
+    }
+  }
+  saveRuntime(registration);
+  console.log(chalk6.gray("\n  Runtime saved to .neurogent/runtime.json"));
+  console.log(chalk6.magenta("\n  Agents are live. Press Ctrl+C to stop.\n"));
+  const stop = () => {
+    console.log(chalk6.yellow("\n  Stopping agents..."));
+    servers.forEach((s) => s.stop());
+    clearRuntime();
+    console.log(chalk6.gray("  Runtime cleared. Goodbye.\n"));
+    process.exit(0);
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+  await new Promise(() => {
+  });
+});
+
+// src/cli/commands/connect.ts
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+var connectCommand = new Command7("connect").description("Connect the shell to a remote ZeroClaw agent server").option("-u, --url <url>", "Base URL of the ZeroClaw server (e.g. http://my-server:4100)").option("-a, --agent <id>", "Agent ID to connect (default: connect to all)").option("--clear", "Remove the remote connection and fall back to local LLM").action(async (opts) => {
+  if (opts.clear) {
+    clearRuntime();
+    console.log(chalk7.yellow("  Remote connection cleared. Shell will use local LLM.\n"));
+    return;
+  }
+  if (!opts.url) {
+    console.error(chalk7.red("  Error: --url is required\n"));
+    console.log(chalk7.gray("  Example: neurogent connect --url http://my-server:4100\n"));
+    process.exit(1);
+  }
+  const url = opts.url.replace(/\/$/, "");
+  console.log(chalk7.magenta("\n  Checking connection...\n"));
+  const health = await pingAgent(url);
+  if (!health.alive) {
+    console.error(chalk7.red(`  Cannot reach ${url}: ${health.error}`));
+    console.log(chalk7.gray("  Make sure the remote server is running: neurogent start\n"));
+    process.exit(1);
+  }
+  console.log(chalk7.green(`  Connected to: ${health.agent ?? "ZeroClaw"} (uptime ${health.uptime}s)`));
+  const runtime = loadRuntime() ?? { agents: [], startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  if (opts.agent) {
+    const existing = runtime.agents.find((a) => a.id === opts.agent);
+    if (existing) {
+      existing.url = url;
+    } else {
+      runtime.agents.push({
+        id: opts.agent,
+        name: opts.agent,
+        url,
+        port: parseInt(new URL(url).port || "80", 10),
+        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    console.log(chalk7.cyan(`
+  Agent "${opts.agent}" \u2192 ${url}`));
+  } else {
+    const wildcardIdx = runtime.agents.findIndex((a) => a.id === "*");
+    const entry = {
+      id: "*",
+      name: "remote",
+      url,
+      port: parseInt(new URL(url).port || "80", 10),
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (wildcardIdx >= 0) {
+      runtime.agents[wildcardIdx] = entry;
+    } else {
+      runtime.agents.unshift(entry);
+    }
+    console.log(chalk7.cyan(`
+  All agents \u2192 ${url}`));
+  }
+  saveRuntime(runtime);
+  console.log(chalk7.gray("  Saved to .neurogent/runtime.json"));
+  console.log(chalk7.magenta("\n  Launch the shell to use the remote backend:\n"));
+  console.log(chalk7.white("  neurogent shell\n"));
+});
+
+// src/cli/commands/status.ts
+import { Command as Command8 } from "commander";
+import chalk8 from "chalk";
+async function printStatus() {
+  const runtime = loadRuntime();
+  if (!runtime || runtime.agents.length === 0) {
+    console.log(chalk8.yellow("\n  No agents registered.\n"));
+    console.log(chalk8.gray("  Start agents:   neurogent start --config <file>"));
+    console.log(chalk8.gray("  Connect remote: neurogent connect --url <url>\n"));
+    return;
+  }
+  console.log(chalk8.magenta("\n  Neurogent Agent Status\n"));
+  console.log(
+    chalk8.gray("  " + "AGENT".padEnd(16) + "URL".padEnd(28) + "STATUS".padEnd(10) + "UPTIME")
+  );
+  console.log(chalk8.gray("  " + "\u2500".repeat(64)));
+  const checks = runtime.agents.map(async (agent) => {
+    const health = await pingAgent(agent.url);
+    const status = health.alive ? chalk8.green("\u25CF online") : chalk8.red("\u25CB offline");
+    const uptime = health.alive && health.uptime !== void 0 ? chalk8.gray(`${health.uptime}s`) : chalk8.gray("\u2014");
+    const name = agent.id === "*" ? chalk8.gray("(wildcard)") : chalk8.white(agent.name);
+    console.log(
+      `  ${"\u{1F916} " + (agent.id === "*" ? "*".padEnd(13) : agent.name.padEnd(13))}${chalk8.cyan(agent.url.padEnd(28))}${status.padEnd(10)}` + uptime
+    );
+  });
+  await Promise.all(checks);
+  const started = new Date(runtime.startedAt).toLocaleTimeString();
+  console.log(chalk8.gray(`
+  Runtime started at ${started}
+`));
+}
+var statusCommand = new Command8("status").description("Show health status of all registered ZeroClaw agents").option("-w, --watch", "Refresh every 3 seconds").action(async (opts) => {
+  await printStatus();
+  if (opts.watch) {
+    const interval = setInterval(async () => {
+      process.stdout.write("\x1B[2J\x1B[0f");
+      await printStatus();
+    }, 3e3);
+    process.on("SIGINT", () => {
+      clearInterval(interval);
+      process.exit(0);
+    });
+    await new Promise(() => {
+    });
+  }
+});
+
+// src/cli/index.ts
+var program = new Command9();
+program.name("neurogent").description("A CLI for creating and managing A2A compliant Neuro agents").version("0.3.0");
+program.addCommand(initCommand);
+program.addCommand(devCommand);
+program.addCommand(buildCommand);
+program.addCommand(deployCommand);
+program.addCommand(registerCommand);
+program.addCommand(startCommand);
+program.addCommand(connectCommand);
+program.addCommand(statusCommand);
+program.parse(process.argv);