@marco-kueks/agent-factory-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,784 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+
+// src/commands/dev.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import chokidar from "chokidar";
+import { join as join3 } from "path";
+
+// src/utils/config.ts
+import { join } from "path";
+var defaultConfig = {
+  port: 3000,
+  host: "localhost",
+  cors: {
+    origins: ["http://localhost:3000"],
+    credentials: true
+  },
+  logging: {
+    level: "info",
+    format: "pretty"
+  },
+  auth: {
+    type: "none"
+  }
+};
+async function loadConfig(cwd) {
+  const configPath = join(cwd, "af.config.ts");
+  try {
+    const module = await import(configPath);
+    const config = module.default || module;
+    return {
+      ...defaultConfig,
+      ...config,
+      cors: {
+        ...defaultConfig.cors,
+        ...config.cors
+      },
+      logging: {
+        ...defaultConfig.logging,
+        ...config.logging
+      },
+      auth: {
+        ...defaultConfig.auth,
+        ...config.auth
+      }
+    };
+  } catch {
+    return defaultConfig;
+  }
+}
+
+// src/utils/agent.ts
+import { join as join2 } from "path";
+async function loadAgent(cwd) {
+  const agentPath = join2(cwd, "src/agent.ts");
+  try {
+    const module = await import(agentPath);
+    const agent = module.default || module;
+    if (!agent.name) {
+      throw new Error("Agent must have a name");
+    }
+    if (!agent.version) {
+      throw new Error("Agent must have a version");
+    }
+    if (!agent.systemPrompt) {
+      throw new Error("Agent must have a systemPrompt");
+    }
+    return agent;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Cannot find module")) {
+      throw new Error(`Agent not found at ${agentPath}`);
+    }
+    throw error;
+  }
+}
+
+// src/commands/dev.ts
+var devCommand = new Command("dev").description("Start development server with hot reload").option("-p, --port <port>", "Port to run on", "3000").option("-c, --channel <channel>", "Channel to open (web, api)", "web").option("--no-open", "Do not open browser").action(async (options) => {
+  const spinner = ora();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk.bold("Agent Factory Dev Server"));
+  console.log();
+  spinner.start("Loading configuration");
+  const config = await loadConfig(cwd);
+  const port = parseInt(options.port) || config.port || 3000;
+  spinner.succeed("Configuration loaded");
+  spinner.start("Loading agent");
+  let agent = await loadAgent(cwd);
+  spinner.succeed(`Agent "${agent.name}" loaded`);
+  const server = Bun.serve({
+    port,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/health") {
+        return Response.json({ status: "ok", agent: agent.name });
+      }
+      if (url.pathname === "/api/chat" && req.method === "POST") {
+        const body = await req.json();
+        return Response.json({
+          response: `[Dev Mode] Received: ${body.message}`,
+          conversationId: body.conversationId || crypto.randomUUID()
+        });
+      }
+      if (url.pathname === "/" && options.channel === "web") {
+        return new Response(getDevHtml(agent.name), {
+          headers: { "Content-Type": "text/html" }
+        });
+      }
+      return new Response("Not Found", { status: 404 });
+    }
+  });
+  console.log();
+  console.log(chalk.green("Server running at"), chalk.cyan(`http://localhost:${port}`));
+  console.log();
+  if (options.channel === "web" && options.open) {
+    const openUrl = `http://localhost:${port}`;
+    if (process.platform === "darwin") {
+      Bun.spawn(["open", openUrl]);
+    } else if (process.platform === "linux") {
+      Bun.spawn(["xdg-open", openUrl]);
+    }
+  }
+  spinner.start("Watching for changes");
+  const watcher = chokidar.watch([join3(cwd, "src"), join3(cwd, "af.config.ts")], {
+    ignoreInitial: true,
+    ignored: /node_modules/
+  });
+  watcher.on("change", async (path) => {
+    spinner.text = `Reloading (${path.replace(cwd, ".")})`;
+    try {
+      agent = await loadAgent(cwd);
+      spinner.succeed(`Reloaded "${agent.name}"`);
+      spinner.start("Watching for changes");
+    } catch (error) {
+      spinner.fail(`Reload failed: ${error}`);
+      spinner.start("Watching for changes");
+    }
+  });
+  process.on("SIGINT", () => {
+    console.log();
+    spinner.stop();
+    watcher.close();
+    server.stop();
+    console.log(chalk.gray("Server stopped"));
+    process.exit(0);
+  });
+});
+function getDevHtml(agentName) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${agentName} - Dev</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: system-ui, -apple-system, sans-serif; background: #0a0a0a; color: #fafafa; height: 100vh; display: flex; flex-direction: column; }
+    header { padding: 1rem; border-bottom: 1px solid #333; }
+    header h1 { font-size: 1rem; font-weight: 500; }
+    header span { color: #888; font-size: 0.875rem; }
+    #messages { flex: 1; overflow-y: auto; padding: 1rem; display: flex; flex-direction: column; gap: 0.75rem; }
+    .message { max-width: 80%; padding: 0.75rem 1rem; border-radius: 0.75rem; line-height: 1.5; }
+    .message.user { align-self: flex-end; background: #2563eb; }
+    .message.assistant { align-self: flex-start; background: #27272a; }
+    form { padding: 1rem; border-top: 1px solid #333; display: flex; gap: 0.5rem; }
+    input { flex: 1; padding: 0.75rem 1rem; background: #18181b; border: 1px solid #333; border-radius: 0.5rem; color: #fafafa; font-size: 1rem; outline: none; }
+    input:focus { border-color: #2563eb; }
+    button { padding: 0.75rem 1.5rem; background: #2563eb; border: none; border-radius: 0.5rem; color: white; font-size: 1rem; cursor: pointer; }
+    button:hover { background: #1d4ed8; }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>${agentName}</h1>
+    <span>Development Mode</span>
+  </header>
+  <div id="messages"></div>
+  <form id="chat-form">
+    <input type="text" id="input" placeholder="Type a message..." autocomplete="off" />
+    <button type="submit">Send</button>
+  </form>
+  <script>
+    const messages = document.getElementById('messages');
+    const form = document.getElementById('chat-form');
+    const input = document.getElementById('input');
+    let conversationId = null;
+
+    function addMessage(role, content) {
+      const div = document.createElement('div');
+      div.className = 'message ' + role;
+      div.textContent = content;
+      messages.appendChild(div);
+      messages.scrollTop = messages.scrollHeight;
+    }
+
+    form.addEventListener('submit', async (e) => {
+      e.preventDefault();
+      const message = input.value.trim();
+      if (!message) return;
+
+      addMessage('user', message);
+      input.value = '';
+
+      try {
+        const res = await fetch('/api/chat', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ message, conversationId }),
+        });
+        const data = await res.json();
+        conversationId = data.conversationId;
+        addMessage('assistant', data.response);
+      } catch (err) {
+        addMessage('assistant', 'Error: ' + err.message);
+      }
+    });
+
+    input.focus();
+  </script>
+</body>
+</html>`;
+}
+
+// src/commands/build.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import { join as join4 } from "path";
+
+// src/utils/validate.ts
+function validateAgent(agent) {
+  const errors = [];
+  if (!agent.name) {
+    errors.push("Agent name is required");
+  } else if (!/^[a-z0-9-]+$/.test(agent.name)) {
+    errors.push("Agent name must be lowercase alphanumeric with hyphens only");
+  }
+  if (!agent.version) {
+    errors.push("Agent version is required");
+  } else if (!/^\d+\.\d+\.\d+/.test(agent.version)) {
+    errors.push("Agent version must follow semver format (e.g., 1.0.0)");
+  }
+  if (!agent.systemPrompt) {
+    errors.push("System prompt is required");
+  } else if (typeof agent.systemPrompt === "string" && agent.systemPrompt.trim().length === 0) {
+    errors.push("System prompt cannot be empty");
+  }
+  if (agent.model) {
+    const validProviders = ["anthropic", "openai", "google", "custom"];
+    if (!validProviders.includes(agent.model.provider)) {
+      errors.push(`Invalid model provider: ${agent.model.provider}`);
+    }
+    if (!agent.model.name) {
+      errors.push("Model name is required when model is specified");
+    }
+    if (agent.model.temperature !== undefined) {
+      if (agent.model.temperature < 0 || agent.model.temperature > 2) {
+        errors.push("Model temperature must be between 0 and 2");
+      }
+    }
+    if (agent.model.maxTokens !== undefined) {
+      if (agent.model.maxTokens < 1) {
+        errors.push("Model maxTokens must be at least 1");
+      }
+    }
+  }
+  if (agent.tools) {
+    for (const tool of agent.tools) {
+      const toolErrors = validateTool(tool);
+      errors.push(...toolErrors);
+    }
+  }
+  if (agent.state) {
+    const validStorage = ["memory", "redis", "postgres", "custom"];
+    if (!validStorage.includes(agent.state.storage)) {
+      errors.push(`Invalid state storage: ${agent.state.storage}`);
+    }
+    if (agent.state.ttl !== undefined && agent.state.ttl < 0) {
+      errors.push("State TTL must be non-negative");
+    }
+  }
+  return errors;
+}
+function validateTool(tool) {
+  const errors = [];
+  if (!tool.name) {
+    errors.push("Tool name is required");
+  } else if (!/^[a-z_][a-z0-9_]*$/.test(tool.name)) {
+    errors.push(`Tool name "${tool.name}" must be snake_case`);
+  }
+  if (!tool.description) {
+    errors.push(`Tool "${tool.name || "unknown"}" requires a description`);
+  }
+  if (!tool.parameters) {
+    errors.push(`Tool "${tool.name || "unknown"}" requires parameters definition`);
+  } else if (tool.parameters.type !== "object") {
+    errors.push(`Tool "${tool.name || "unknown"}" parameters type must be "object"`);
+  }
+  if (typeof tool.handler !== "function") {
+    errors.push(`Tool "${tool.name || "unknown"}" requires a handler function`);
+  }
+  return errors;
+}
+
+// src/commands/build.ts
+var buildCommand = new Command2("build").description("Build and validate agent for production").option("-o, --outdir <dir>", "Output directory", "dist").action(async (options) => {
+  const spinner = ora2();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk2.bold("Building Agent"));
+  console.log();
+  spinner.start("Loading configuration");
+  const config = await loadConfig(cwd);
+  spinner.succeed("Configuration loaded");
+  spinner.start("Loading agent");
+  const agent = await loadAgent(cwd);
+  spinner.succeed(`Agent "${agent.name}" loaded`);
+  spinner.start("Validating agent");
+  const errors = validateAgent(agent);
+  if (errors.length > 0) {
+    spinner.fail("Validation failed");
+    console.log();
+    for (const error of errors) {
+      console.log(chalk2.red("  ✗"), error);
+    }
+    console.log();
+    process.exit(1);
+  }
+  spinner.succeed("Agent validated");
+  spinner.start("Building");
+  const outdir = join4(cwd, options.outdir);
+  const result = await Bun.build({
+    entrypoints: [join4(cwd, "src/agent.ts")],
+    outdir,
+    target: "node",
+    minify: true
+  });
+  if (!result.success) {
+    spinner.fail("Build failed");
+    console.log();
+    for (const log of result.logs) {
+      console.log(chalk2.red("  ✗"), log.message);
+    }
+    process.exit(1);
+  }
+  spinner.succeed("Build completed");
+  console.log();
+  console.log(chalk2.green("Success!"), `Built to ${chalk2.cyan(options.outdir)}`);
+  console.log();
+  console.log("Output files:");
+  for (const output of result.outputs) {
+    console.log(chalk2.gray("  •"), output.path.replace(cwd, "."));
+  }
+  console.log();
+});
+
+// src/commands/test.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import ora3 from "ora";
+import { join as join5 } from "path";
+import { readdir, readFile } from "fs/promises";
+import YAML from "yaml";
+var testCommand = new Command3("test").description("Run test conversations").argument("[pattern]", "Test file pattern", "*.test.yaml").option("-v, --verbose", "Show detailed output").action(async (pattern, options) => {
+  const spinner = ora3();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk3.bold("Running Tests"));
+  console.log();
+  spinner.start("Loading agent");
+  const agent = await loadAgent(cwd);
+  spinner.succeed(`Agent "${agent.name}" loaded`);
+  spinner.start("Finding test files");
+  const testsDir = join5(cwd, "tests");
+  let testFiles = [];
+  try {
+    const files = await readdir(testsDir);
+    testFiles = files.filter((f) => f.endsWith(".test.yaml") || f.endsWith(".test.yml"));
+  } catch {
+    spinner.warn("No tests directory found");
+    console.log();
+    console.log(chalk3.gray("Create tests in"), chalk3.cyan("tests/*.test.yaml"));
+    console.log();
+    return;
+  }
+  if (testFiles.length === 0) {
+    spinner.warn("No test files found");
+    console.log();
+    return;
+  }
+  spinner.succeed(`Found ${testFiles.length} test file(s)`);
+  const results = [];
+  for (const file of testFiles) {
+    const filePath = join5(testsDir, file);
+    const content = await readFile(filePath, "utf-8");
+    const testCase = YAML.parse(content);
+    if (options.verbose) {
+      console.log();
+      console.log(chalk3.gray("Running:"), testCase.name);
+    }
+    const result = await runTest(testCase, agent, options.verbose);
+    results.push(result);
+    if (result.passed) {
+      console.log(chalk3.green("  ✓"), result.name);
+    } else {
+      console.log(chalk3.red("  ✗"), result.name);
+      for (const error of result.errors) {
+        console.log(chalk3.red("    →"), error);
+      }
+    }
+  }
+  const passed = results.filter((r) => r.passed).length;
+  const failed = results.filter((r) => !r.passed).length;
+  console.log();
+  if (failed === 0) {
+    console.log(chalk3.green("All tests passed!"), chalk3.gray(`(${passed}/${results.length})`));
+  } else {
+    console.log(chalk3.red("Tests failed:"), chalk3.gray(`${passed}/${results.length} passed`));
+  }
+  console.log();
+  if (failed > 0) {
+    process.exit(1);
+  }
+});
+async function runTest(testCase, agent, verbose) {
+  const errors = [];
+  for (const message of testCase.conversation || []) {
+    if (message.role === "assistant" && message.assertions) {
+      for (const assertion of message.assertions) {
+        const passed = checkAssertion(assertion, "[mock response]");
+        if (!passed) {
+          errors.push(`Assertion failed: ${assertion.type} - ${JSON.stringify(assertion.value)}`);
+        }
+      }
+    }
+  }
+  if (errors.length === 0 && testCase.assertions) {
+    for (const assertion of testCase.assertions) {
+      const passed = checkAssertion(assertion, "[mock response]");
+      if (!passed) {
+        errors.push(`Assertion failed: ${assertion.type} - ${JSON.stringify(assertion.value)}`);
+      }
+    }
+  }
+  return {
+    name: testCase.name,
+    passed: errors.length === 0,
+    errors
+  };
+}
+function checkAssertion(assertion, response) {
+  switch (assertion.type) {
+    case "contains":
+      return typeof assertion.value === "string" && response.includes(assertion.value);
+    case "matches":
+      return typeof assertion.value === "string" && new RegExp(assertion.value).test(response);
+    case "toolCalled":
+      return true;
+    case "stateEquals":
+      return true;
+    default:
+      return false;
+  }
+}
+
+// src/commands/deploy.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import ora4 from "ora";
+var deployCommand = new Command4("deploy").description("Deploy agent to Agent Factory cloud").option("-e, --env <environment>", "Target environment", "staging").option("--dry-run", "Show what would be deployed without deploying").action(async (options) => {
+  const spinner = ora4();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk4.bold("Deploying Agent"));
+  console.log();
+  spinner.start("Loading configuration");
+  const config = await loadConfig(cwd);
+  spinner.succeed("Configuration loaded");
+  spinner.start("Loading agent");
+  const agent = await loadAgent(cwd);
+  spinner.succeed(`Agent "${agent.name}" loaded`);
+  spinner.start("Validating agent");
+  const errors = validateAgent(agent);
+  if (errors.length > 0) {
+    spinner.fail("Validation failed");
+    console.log();
+    for (const error of errors) {
+      console.log(chalk4.red("  ✗"), error);
+    }
+    console.log();
+    process.exit(1);
+  }
+  spinner.succeed("Agent validated");
+  if (options.dryRun) {
+    console.log();
+    console.log(chalk4.yellow("Dry run mode - no changes will be made"));
+    console.log();
+    console.log("Would deploy:");
+    console.log(chalk4.gray("  •"), `Agent: ${chalk4.cyan(agent.name)}`);
+    console.log(chalk4.gray("  •"), `Version: ${chalk4.cyan(agent.version)}`);
+    console.log(chalk4.gray("  •"), `Environment: ${chalk4.cyan(options.env)}`);
+    console.log();
+    return;
+  }
+  spinner.start(`Deploying to ${options.env}`);
+  const apiKey = process.env.AGENT_FACTORY_API_KEY;
+  if (!apiKey) {
+    spinner.fail("Missing AGENT_FACTORY_API_KEY environment variable");
+    console.log();
+    console.log("Set your API key:");
+    console.log(chalk4.gray("  $"), chalk4.cyan("export AGENT_FACTORY_API_KEY=your_api_key"));
+    console.log();
+    process.exit(1);
+  }
+  const apiUrl = process.env.AGENT_FACTORY_API_URL || "https://api.agent-factory.dev";
+  try {
+    const response = await fetch(`${apiUrl}/v1/agents/deploy`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        name: agent.name,
+        version: agent.version,
+        environment: options.env,
+        config: agent
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.message || `HTTP ${response.status}`);
+    }
+    const result = await response.json();
+    spinner.succeed(`Deployed to ${options.env}`);
+    console.log();
+    console.log(chalk4.green("Success!"), "Agent deployed");
+    console.log();
+    console.log("Deployment details:");
+    console.log(chalk4.gray("  •"), `ID: ${chalk4.cyan(result.deploymentId)}`);
+    console.log(chalk4.gray("  •"), `URL: ${chalk4.cyan(result.url)}`);
+    console.log();
+  } catch (error) {
+    spinner.fail("Deployment failed");
+    console.log();
+    console.log(chalk4.red("Error:"), error instanceof Error ? error.message : String(error));
+    console.log();
+    process.exit(1);
+  }
+});
+
+// src/commands/validate.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+import ora5 from "ora";
+var validateCommand = new Command5("validate").description("Validate agent configuration").option("--strict", "Enable strict validation").action(async (options) => {
+  const spinner = ora5();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk5.bold("Validating Agent"));
+  console.log();
+  spinner.start("Loading agent");
+  let agent;
+  try {
+    agent = await loadAgent(cwd);
+    spinner.succeed(`Agent "${agent.name}" loaded`);
+  } catch (error) {
+    spinner.fail("Failed to load agent");
+    console.log();
+    console.log(chalk5.red("Error:"), error instanceof Error ? error.message : String(error));
+    console.log();
+    process.exit(1);
+  }
+  spinner.start("Validating configuration");
+  const errors = validateAgent(agent);
+  const warnings = options.strict ? getStrictWarnings(agent) : [];
+  if (errors.length === 0 && warnings.length === 0) {
+    spinner.succeed("Agent is valid");
+    console.log();
+    console.log(chalk5.green("✓"), "No issues found");
+    console.log();
+    return;
+  }
+  if (errors.length > 0) {
+    spinner.fail("Validation failed");
+    console.log();
+    console.log(chalk5.red("Errors:"));
+    for (const error of errors) {
+      console.log(chalk5.red("  ✗"), error);
+    }
+  } else {
+    spinner.succeed("Validation passed with warnings");
+  }
+  if (warnings.length > 0) {
+    console.log();
+    console.log(chalk5.yellow("Warnings:"));
+    for (const warning of warnings) {
+      console.log(chalk5.yellow("  ⚠"), warning);
+    }
+  }
+  console.log();
+  if (errors.length > 0) {
+    process.exit(1);
+  }
+});
+function getStrictWarnings(agent) {
+  const warnings = [];
+  if (!agent.description) {
+    warnings.push("Agent is missing a description");
+  }
+  if (!agent.tools || agent.tools.length === 0) {
+    warnings.push("Agent has no tools defined");
+  }
+  return warnings;
+}
+
+// src/commands/logs.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+import ora6 from "ora";
+var logsCommand = new Command6("logs").description("Stream production logs").option("-e, --env <environment>", "Environment to stream from", "production").option("-f, --follow", "Follow log output").option("-n, --lines <number>", "Number of lines to show", "100").action(async (options) => {
+  const spinner = ora6();
+  console.log();
+  console.log(chalk6.bold("Streaming Logs"));
+  console.log();
+  const apiKey = process.env.AGENT_FACTORY_API_KEY;
+  if (!apiKey) {
+    console.log(chalk6.red("Error:"), "Missing AGENT_FACTORY_API_KEY environment variable");
+    console.log();
+    console.log("Set your API key:");
+    console.log(chalk6.gray("  $"), chalk6.cyan("export AGENT_FACTORY_API_KEY=your_api_key"));
+    console.log();
+    process.exit(1);
+  }
+  const apiUrl = process.env.AGENT_FACTORY_API_URL || "https://api.agent-factory.dev";
+  if (options.follow) {
+    spinner.start(`Connecting to ${options.env} logs`);
+    try {
+      const wsUrl = apiUrl.replace("https://", "wss://").replace("http://", "ws://");
+      const ws = new WebSocket(`${wsUrl}/v1/logs/stream?env=${options.env}`, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`
+        }
+      });
+      ws.onopen = () => {
+        spinner.succeed(`Connected to ${options.env}`);
+        console.log();
+        console.log(chalk6.gray("Streaming logs... (Ctrl+C to stop)"));
+        console.log();
+      };
+      ws.onmessage = (event) => {
+        const log = JSON.parse(event.data);
+        const levelColor = log.level === "error" ? chalk6.red : log.level === "warn" ? chalk6.yellow : chalk6.gray;
+        console.log(chalk6.gray(new Date(log.timestamp).toISOString()), levelColor(`[${log.level}]`), log.message);
+      };
+      ws.onerror = () => {
+        spinner.fail("Connection error");
+        process.exit(1);
+      };
+      ws.onclose = () => {
+        console.log();
+        console.log(chalk6.gray("Connection closed"));
+        process.exit(0);
+      };
+      process.on("SIGINT", () => {
+        console.log();
+        ws.close();
+      });
+    } catch (error) {
+      spinner.fail("Failed to connect");
+      console.log();
+      console.log(chalk6.red("Error:"), error instanceof Error ? error.message : String(error));
+      console.log();
+      process.exit(1);
+    }
+  } else {
+    spinner.start("Fetching logs");
+    try {
+      const response = await fetch(`${apiUrl}/v1/logs?env=${options.env}&lines=${options.lines}`, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const logs = await response.json();
+      spinner.succeed(`Fetched ${logs.length} log entries`);
+      console.log();
+      for (const log of logs) {
+        const levelColor = log.level === "error" ? chalk6.red : log.level === "warn" ? chalk6.yellow : chalk6.gray;
+        console.log(chalk6.gray(new Date(log.timestamp).toISOString()), levelColor(`[${log.level}]`), log.message);
+      }
+      console.log();
+    } catch (error) {
+      spinner.fail("Failed to fetch logs");
+      console.log();
+      console.log(chalk6.red("Error:"), error instanceof Error ? error.message : String(error));
+      console.log();
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/state.ts
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+import ora7 from "ora";
+var stateCommand = new Command7("state").description("Inspect conversation state").argument("<id>", "Conversation ID").option("-e, --env <environment>", "Environment", "production").option("--json", "Output as JSON").action(async (id, options) => {
+  const spinner = ora7();
+  console.log();
+  console.log(chalk7.bold("Conversation State"));
+  console.log();
+  const apiKey = process.env.AGENT_FACTORY_API_KEY;
+  if (!apiKey) {
+    console.log(chalk7.red("Error:"), "Missing AGENT_FACTORY_API_KEY environment variable");
+    console.log();
+    console.log("Set your API key:");
+    console.log(chalk7.gray("  $"), chalk7.cyan("export AGENT_FACTORY_API_KEY=your_api_key"));
+    console.log();
+    process.exit(1);
+  }
+  const apiUrl = process.env.AGENT_FACTORY_API_URL || "https://api.agent-factory.dev";
+  spinner.start("Fetching conversation state");
+  try {
+    const response = await fetch(`${apiUrl}/v1/conversations/${id}/state?env=${options.env}`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error("Conversation not found");
+      }
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const state = await response.json();
+    spinner.succeed("State retrieved");
+    if (options.json) {
+      console.log();
+      console.log(JSON.stringify(state, null, 2));
+      console.log();
+      return;
+    }
+    console.log();
+    console.log(chalk7.gray("Conversation:"), chalk7.cyan(state.conversationId));
+    console.log(chalk7.gray("Created:"), new Date(state.createdAt).toLocaleString());
+    console.log(chalk7.gray("Updated:"), new Date(state.updatedAt).toLocaleString());
+    console.log(chalk7.gray("Messages:"), state.messageCount);
+    console.log();
+    console.log(chalk7.bold("State:"));
+    if (Object.keys(state.state).length === 0) {
+      console.log(chalk7.gray("  (empty)"));
+    } else {
+      for (const [key, value] of Object.entries(state.state)) {
+        const displayValue = typeof value === "object" ? JSON.stringify(value) : String(value);
+        console.log(chalk7.gray("  •"), `${key}:`, chalk7.cyan(displayValue));
+      }
+    }
+    console.log();
+  } catch (error) {
+    spinner.fail("Failed to fetch state");
+    console.log();
+    console.log(chalk7.red("Error:"), error instanceof Error ? error.message : String(error));
+    console.log();
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+program.name("af").description("Agent Factory CLI").version("0.1.0");
+program.addCommand(devCommand);
+program.addCommand(buildCommand);
+program.addCommand(testCommand);
+program.addCommand(deployCommand);
+program.addCommand(validateCommand);
+program.addCommand(logsCommand);
+program.addCommand(stateCommand);
+program.parse();

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@marco-kueks/agent-factory-cli",
+  "version": "0.1.0",
+  "description": "CLI tool for developing, testing, and deploying AI agents",
+  "keywords": ["ai", "agents", "cli", "developer-tools", "llm"],
+  "author": "marco-kueks",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MarcoNaik/agent-factory.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/MarcoNaik/agent-factory#readme",
+  "bugs": {
+    "url": "https://github.com/MarcoNaik/agent-factory/issues"
+  },
+  "type": "module",
+  "bin": {
+    "af": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": ["dist"],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --external commander --external chalk --external ora --external chokidar --external yaml && chmod +x ./dist/index.js",
+    "dev": "bun run ./src/index.ts",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@marco-kueks/agent-factory-core": "^0.1.0",
+    "chalk": "^5.3.0",
+    "chokidar": "^3.5.3",
+    "commander": "^12.0.0",
+    "ora": "^8.0.0",
+    "yaml": "^2.3.4"
+  },
+  "devDependencies": {
+    "bun-types": "^1.0.0",
+    "typescript": "^5.3.0"
+  }
+}