clayton-forge 0.1.0

package/dist/index.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const new_1 = require("./commands/new");
+const run_1 = require("./commands/run");
+const test_1 = require("./commands/test");
+const pkg = require("../package.json");
+// ─────────────────────────────────────────────
+// Banner
+// ─────────────────────────────────────────────
+function printBanner() {
+    console.log("");
+    console.log(chalk_1.default.bold.cyan("  CLAYTON FORGE") + chalk_1.default.gray(` v${pkg.version}`));
+    console.log(chalk_1.default.gray("  Build AI agents with confidence."));
+    console.log(chalk_1.default.gray("  https://github.com/devclaytonn10/clayton-forge"));
+    console.log("");
+}
+// ─────────────────────────────────────────────
+// CLI
+// ─────────────────────────────────────────────
+const program = new commander_1.Command();
+program
+    .name("cforge")
+    .description("Clayton Forge — AI agent platform CLI")
+    .version(pkg.version, "-v, --version", "Output the current version")
+    .addHelpText("before", "\n  CLAYTON FORGE — Build AI agents with confidence.\n");
+// ─────────────────────────────────────────────
+// cforge new [name]
+// ─────────────────────────────────────────────
+program
+    .command("new [name]")
+    .description("Create a new agent with an interactive wizard")
+    .action(async (name) => {
+    await (0, new_1.commandNew)(name ? undefined : undefined);
+});
+// ─────────────────────────────────────────────
+// cforge run [agent-dir] [input]
+// ─────────────────────────────────────────────
+program
+    .command("run [agent-dir]")
+    .description("Execute an agent")
+    .option("-i, --input <text>", "Input text (skips interactive prompt for single-variable agents)")
+    .action(async (agentDir, options) => {
+    await (0, run_1.commandRun)(agentDir, options?.input);
+});
+// ─────────────────────────────────────────────
+// cforge test [agent-dir]
+// ─────────────────────────────────────────────
+program
+    .command("test [agent-dir]")
+    .description("Run the agent's test suite")
+    .action(async (agentDir) => {
+    await (0, test_1.commandTest)(agentDir);
+});
+// ─────────────────────────────────────────────
+// cforge validate
+// ─────────────────────────────────────────────
+program
+    .command("validate [agent-dir]")
+    .description("Validate agent.yaml without running the agent")
+    .action(async (agentDir) => {
+    const { parseAgentFile, findAgentFile } = await Promise.resolve().then(() => __importStar(require("@clayton-forge/core")));
+    const path = require("path");
+    const fs = require("fs");
+    const searchDir = agentDir ? path.resolve(agentDir) : process.cwd();
+    const agentPath = fs.existsSync(path.join(searchDir, "agent.yaml"))
+        ? path.join(searchDir, "agent.yaml")
+        : findAgentFile(searchDir);
+    if (!agentPath) {
+        console.error(chalk_1.default.red("✗ No agent.yaml found."));
+        process.exit(1);
+    }
+    try {
+        const agent = parseAgentFile(agentPath);
+        console.log(chalk_1.default.green(`\n  ✓ Valid agent.yaml`));
+        console.log(chalk_1.default.gray(`  Name: ${agent.name} v${agent.version}`));
+        console.log(chalk_1.default.gray(`  Type: ${agent.type}`));
+        console.log(chalk_1.default.gray(`  LLM:  ${agent.llm.provider}${agent.llm.model ? ` / ${agent.llm.model}` : ""}`));
+        console.log("");
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`\n  ✗ ${err instanceof Error ? err.message : err}`));
+        console.log("");
+        process.exit(1);
+    }
+});
+// ─────────────────────────────────────────────
+// Default: banner + help
+// ─────────────────────────────────────────────
+program.addHelpCommand(true);
+if (process.argv.length <= 2) {
+    printBanner();
+    program.help();
+}
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "clayton-forge",
+  "version": "0.1.0",
+  "description": "Clayton Forge CLI — build AI agents with confidence",
+  "main": "dist/index.js",
+  "bin": {
+    "cforge": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@clayton-forge/core": "*",
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0",
+    "inquirer": "^8.2.7",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^8.2.13",
+    "@types/node": "^20.14.0",
+    "typescript": "^5.4.5"
+  }
+}

package/src/commands/new.ts

@@ -0,0 +1,281 @@
+import inquirer from "inquirer";
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+
+// ─────────────────────────────────────────────
+// Tipos locais (para evitar import circular durante build inicial)
+// ─────────────────────────────────────────────
+
+interface WizardAnswers {
+  name: string;
+  description: string;
+  type: string;
+  llm_provider: string;
+  llm_model: string;
+  output_format: string;
+  trust_level: number;
+}
+
+// ─────────────────────────────────────────────
+// Helpers de display
+// ─────────────────────────────────────────────
+
+function header() {
+  console.log("");
+  console.log(chalk.bold.white("  ╔═══════════════════════════════════╗"));
+  console.log(chalk.bold.white("  ║") + chalk.bold.cyan("       CLAYTON FORGE — new        ") + chalk.bold.white("║"));
+  console.log(chalk.bold.white("  ╚═══════════════════════════════════╝"));
+  console.log("");
+  console.log(chalk.gray("  Let's create your agent. Answer a few questions."));
+  console.log(chalk.gray("  Press Ctrl+C at any time to cancel.\n"));
+}
+
+// ─────────────────────────────────────────────
+// Wizard
+// ─────────────────────────────────────────────
+
+export async function commandNew(targetDir?: string): Promise<void> {
+  header();
+
+  const answers = await inquirer.prompt<WizardAnswers>([
+    {
+      type: "input",
+      name: "name",
+      message: chalk.white("Agent name") + chalk.gray(" (kebab-case, e.g. invoice-classifier):"),
+      validate: (v: string) =>
+        /^[a-z][a-z0-9-]*$/.test(v) || "Use lowercase letters, numbers, and hyphens only",
+    },
+    {
+      type: "input",
+      name: "description",
+      message: chalk.white("What does this agent do?"),
+      validate: (v: string) => v.trim().length > 5 || "Please write a short description",
+    },
+    {
+      type: "list",
+      name: "type",
+      message: chalk.white("Agent type:"),
+      choices: [
+        { name: "reactive    — receives input → processes → responds", value: "reactive" },
+        { name: "proactive   — acts on triggers without waiting for input", value: "proactive" },
+        { name: "pipeline    — sequential steps, each feeding the next", value: "pipeline" },
+        { name: "orchestrator— coordinates other agents", value: "orchestrator" },
+        { name: "worker      — executed by an orchestrator", value: "worker" },
+      ],
+    },
+    {
+      type: "list",
+      name: "llm_provider",
+      message: chalk.white("LLM provider:"),
+      choices: [
+        { name: "anthropic       (Claude — requires ANTHROPIC_API_KEY)", value: "anthropic" },
+        { name: "openai          (GPT — requires OPENAI_API_KEY)", value: "openai" },
+        { name: "ollama          (local — requires Ollama running)", value: "ollama" },
+        { name: "lmstudio        (local — requires LM Studio running)", value: "lmstudio" },
+        { name: "openai-compatible (any OpenAI-compatible API)", value: "openai-compatible" },
+        { name: "none            (rule-based, no LLM)", value: "none" },
+      ],
+    },
+    {
+      type: "input",
+      name: "llm_model",
+      message: chalk.white("Model name:"),
+      when: (a: WizardAnswers) => a.llm_provider !== "none",
+      default: (a: WizardAnswers) => {
+        const defaults: Record<string, string> = {
+          anthropic: "claude-sonnet-4-6",
+          openai: "gpt-4o-mini",
+          ollama: "llama3",
+          lmstudio: "local-model",
+          "openai-compatible": "default",
+        };
+        return defaults[a.llm_provider] ?? "";
+      },
+    },
+    {
+      type: "list",
+      name: "output_format",
+      message: chalk.white("Output format:"),
+      choices: [
+        { name: "text     — plain text response", value: "text" },
+        { name: "json     — structured JSON (add output schema)", value: "json" },
+        { name: "markdown — formatted markdown", value: "markdown" },
+      ],
+    },
+    {
+      type: "list",
+      name: "trust_level",
+      message: chalk.white("Trust level:"),
+      choices: [
+        { name: "0 — sandboxed  (no external access)", value: 0 },
+        { name: "1 — read-only  (reads data, no writes)", value: 1 },
+        { name: "2 — write      (reads and writes)", value: 2 },
+        { name: "3 — admin      (full control)", value: 3 },
+      ],
+    },
+  ]);
+
+  // Destino
+  const projectName = answers.name;
+  const dest = targetDir ? path.resolve(targetDir, projectName) : path.resolve(process.cwd(), projectName);
+
+  // Verificar se pasta já existe
+  if (fs.existsSync(dest)) {
+    console.log(chalk.red(`\n✗ Directory already exists: ${dest}`));
+    process.exit(1);
+  }
+
+  const spinner = ora("Creating your agent...").start();
+
+  try {
+    // Criar pasta
+    fs.mkdirSync(dest, { recursive: true });
+
+    // Gerar agent.yaml
+    const apiKeyVar = getApiKeyVar(answers.llm_provider);
+    const agentYaml = buildAgentYaml(answers, apiKeyVar);
+    fs.writeFileSync(path.join(dest, "agent.yaml"), agentYaml);
+
+    // Gerar agent.test.yaml
+    const testYaml = buildTestYaml(answers.name);
+    fs.writeFileSync(path.join(dest, "agent.test.yaml"), testYaml);
+
+    // Gerar README.md
+    const readme = buildReadme(answers);
+    fs.writeFileSync(path.join(dest, "README.md"), readme);
+
+    // Gerar .env.example
+    if (apiKeyVar) {
+      fs.writeFileSync(path.join(dest, ".env.example"), `${apiKeyVar}=your-api-key-here\n`);
+    }
+
+    spinner.succeed(chalk.green("Agent created!"));
+
+    // Summary
+    console.log("");
+    console.log(chalk.bold("  📁 " + dest));
+    console.log(chalk.gray("  ├── agent.yaml"));
+    console.log(chalk.gray("  ├── agent.test.yaml"));
+    console.log(chalk.gray("  ├── README.md"));
+    if (apiKeyVar) console.log(chalk.gray("  └── .env.example"));
+    console.log("");
+    console.log(chalk.bold.cyan("  Next steps:"));
+    console.log(chalk.white(`  $ cd ${projectName}`));
+    if (apiKeyVar) console.log(chalk.white(`  $ cp .env.example .env   # add your API key`));
+    console.log(chalk.white(`  $ cforge run              # execute the agent`));
+    console.log(chalk.white(`  $ cforge test             # run tests`));
+    console.log("");
+  } catch (err) {
+    spinner.fail("Failed to create agent");
+    console.error(err);
+    process.exit(1);
+  }
+}
+
+// ─────────────────────────────────────────────
+// Builders
+// ─────────────────────────────────────────────
+
+function getApiKeyVar(provider: string): string | null {
+  const map: Record<string, string> = {
+    anthropic: "ANTHROPIC_API_KEY",
+    openai: "OPENAI_API_KEY",
+  };
+  return map[provider] ?? null;
+}
+
+function buildAgentYaml(answers: WizardAnswers, apiKeyVar: string | null): string {
+  const lines = [
+    `name: "${answers.name}"`,
+    `version: "1.0.0"`,
+    `description: "${answers.description}"`,
+    `type: ${answers.type}`,
+    `trust_level: ${answers.trust_level}`,
+    ``,
+    `llm:`,
+    `  provider: ${answers.llm_provider}`,
+  ];
+
+  if (answers.llm_provider !== "none") {
+    lines.push(`  model: ${answers.llm_model}`);
+    if (apiKeyVar) {
+      lines.push(`  api_key: "\${${apiKeyVar}}"`);
+    }
+    lines.push(`  temperature: 0.1`);
+    lines.push(`  max_tokens: 1000`);
+  }
+
+  lines.push(``);
+  lines.push(`prompt:`);
+  lines.push(`  system: |`);
+  lines.push(`    You are ${answers.description}.`);
+  lines.push(`    Be concise, accurate, and helpful.`);
+  lines.push(`  user_template: "{{input}}"`);
+  lines.push(`  variables:`);
+  lines.push(`    - name: input`);
+  lines.push(`      required: true`);
+  lines.push(`      description: "The user's input"`);
+  lines.push(``);
+  lines.push(`output:`);
+  lines.push(`  format: ${answers.output_format}`);
+  lines.push(``);
+  lines.push(`tests:`);
+  lines.push(`  - file: agent.test.yaml`);
+  lines.push(``);
+
+  return lines.join("\n");
+}
+
+function buildTestYaml(agentName: string): string {
+  return [
+    `agent: "${agentName}"`,
+    ``,
+    `cases:`,
+    `  - name: "basic test"`,
+    `    input:`,
+    `      input: "Hello, world!"`,
+    `    expected_contains:`,
+    `      - "Hello"    # adjust to match your agent's expected output`,
+    `    timeout_ms: 30000`,
+    ``,
+  ].join("\n");
+}
+
+function buildReadme(answers: WizardAnswers): string {
+  return [
+    `# ${answers.name}`,
+    ``,
+    `> ${answers.description}`,
+    ``,
+    `## Overview`,
+    ``,
+    `| Field | Value |`,
+    `|-------|-------|`,
+    `| **Type** | ${answers.type} |`,
+    `| **LLM** | ${answers.llm_provider}${answers.llm_model ? ` / ${answers.llm_model}` : ""} |`,
+    `| **Output** | ${answers.output_format} |`,
+    `| **Trust Level** | ${answers.trust_level} |`,
+    ``,
+    `## Usage`,
+    ``,
+    `\`\`\`bash`,
+    `cforge run    # execute the agent`,
+    `cforge test   # run test suite`,
+    `\`\`\``,
+    ``,
+    `## Configuration`,
+    ``,
+    `Edit \`agent.yaml\` to customize the agent's behavior.`,
+    ``,
+    `## Tests`,
+    ``,
+    `Edit \`agent.test.yaml\` to add test cases.`,
+    ``,
+    `---`,
+    ``,
+    `Built with [Clayton Forge](https://github.com/devclaytonn10/clayton-forge)`,
+    ``,
+  ].join("\n");
+}

package/src/commands/run.ts

@@ -0,0 +1,97 @@
+import * as readline from "readline";
+import chalk from "chalk";
+import ora from "ora";
+
+// ─────────────────────────────────────────────
+// cforge run [agent-dir]
+// ─────────────────────────────────────────────
+
+export async function commandRun(agentDir?: string, inputArg?: string): Promise<void> {
+  const { parseAgentFile, findAgentFile, executeAgent } = await import("@clayton-forge/core");
+
+  // 1. Find agent.yaml
+  const searchDir = agentDir ? require("path").resolve(agentDir) : process.cwd();
+  const agentPath =
+    require("fs").existsSync(require("path").join(searchDir, "agent.yaml"))
+      ? require("path").join(searchDir, "agent.yaml")
+      : findAgentFile(searchDir);
+
+  if (!agentPath) {
+    console.error(chalk.red("✗ No agent.yaml found. Run this command inside an agent directory."));
+    process.exit(1);
+  }
+
+  // 2. Parse
+  let agent: Awaited<ReturnType<typeof parseAgentFile>>;
+  try {
+    agent = parseAgentFile(agentPath);
+  } catch (err) {
+    console.error(chalk.red("✗ Invalid agent.yaml:"), err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+
+  console.log("");
+  console.log(chalk.bold.cyan(`  ▶ ${agent.name}`) + chalk.gray(` v${agent.version}`));
+  console.log(chalk.gray(`  ${agent.description ?? ""}`));
+  console.log(chalk.gray(`  Provider: ${agent.llm.provider}${agent.llm.model ? ` / ${agent.llm.model}` : ""}`));
+  console.log("");
+
+  // 3. Collect input
+  const requiredVars = agent.prompt.variables.filter((v) => v.required);
+  const variables: Record<string, string> = {};
+
+  if (inputArg && requiredVars.length <= 1) {
+    // Se só tem uma variável obrigatória, usa o argumento direto
+    const varName = requiredVars[0]?.name ?? "input";
+    variables[varName] = inputArg;
+  } else {
+    // Interactive input
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const question = (prompt: string): Promise<string> =>
+      new Promise((resolve) => rl.question(prompt, resolve));
+
+    for (const variable of agent.prompt.variables) {
+      if (variable.required || !variable.default) {
+        const defaultHint = variable.default ? chalk.gray(` (default: ${variable.default})`) : "";
+        const descHint = variable.description ? chalk.gray(` — ${variable.description}`) : "";
+        const value = await question(`  ${chalk.white(variable.name)}${descHint}${defaultHint}: `);
+        variables[variable.name] = value || variable.default || "";
+      }
+    }
+    rl.close();
+  }
+
+  console.log("");
+
+  // 4. Execute
+  const spinner = ora("Running agent...").start();
+  const result = await executeAgent(agent, { variables });
+
+  if (result.success) {
+    spinner.succeed(chalk.green(`Done`) + chalk.gray(` (${result.duration_ms}ms)`));
+    console.log("");
+    console.log(chalk.bold("  Output:"));
+    console.log("");
+
+    // Format output based on type
+    const lines = result.output.split("\n");
+    for (const line of lines) {
+      console.log("  " + line);
+    }
+
+    if (result.llm_response?.usage) {
+      const { input_tokens, output_tokens } = result.llm_response.usage;
+      console.log("");
+      console.log(
+        chalk.gray(`  Tokens: ${input_tokens ?? "?"} in / ${output_tokens ?? "?"} out`)
+      );
+    }
+  } else {
+    spinner.fail(chalk.red("Execution failed"));
+    console.log("");
+    console.error(chalk.red("  Error:"), result.error);
+    process.exit(1);
+  }
+
+  console.log("");
+}

package/src/commands/test.ts

@@ -0,0 +1,122 @@
+import * as path from "path";
+import * as fs from "fs";
+import chalk from "chalk";
+import ora from "ora";
+
+// ─────────────────────────────────────────────
+// cforge test [agent-dir]
+// ─────────────────────────────────────────────
+
+export async function commandTest(agentDir?: string): Promise<void> {
+  const { parseAgentFile, parseTestFile, runTestSuite, findAgentFile } =
+    await import("@clayton-forge/core");
+
+  // 1. Find agent.yaml
+  const searchDir = agentDir ? path.resolve(agentDir) : process.cwd();
+  const agentYamlPath = fs.existsSync(path.join(searchDir, "agent.yaml"))
+    ? path.join(searchDir, "agent.yaml")
+    : findAgentFile(searchDir);
+
+  if (!agentYamlPath) {
+    console.error(chalk.red("✗ No agent.yaml found."));
+    process.exit(1);
+  }
+
+  // 2. Parse agent
+  let agent: Awaited<ReturnType<typeof parseAgentFile>>;
+  try {
+    agent = parseAgentFile(agentYamlPath);
+  } catch (err) {
+    console.error(chalk.red("✗ Invalid agent.yaml:"), err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+
+  // 3. Find test files
+  const agentDir2 = path.dirname(agentYamlPath);
+  const testFiles = (agent.tests ?? []).map((t) => path.resolve(agentDir2, t.file));
+
+  // Fallback: tenta agent.test.yaml se não há tests declarados
+  if (testFiles.length === 0) {
+    const fallback = path.join(agentDir2, "agent.test.yaml");
+    if (fs.existsSync(fallback)) testFiles.push(fallback);
+  }
+
+  if (testFiles.length === 0) {
+    console.error(chalk.red("✗ No test files found. Create agent.test.yaml first."));
+    process.exit(1);
+  }
+
+  console.log("");
+  console.log(chalk.bold.cyan(`  ⚗  Testing: ${agent.name}`) + chalk.gray(` v${agent.version}`));
+  console.log(chalk.gray(`  Provider: ${agent.llm.provider}${agent.llm.model ? ` / ${agent.llm.model}` : ""}`));
+  console.log("");
+
+  let totalPassed = 0;
+  let totalFailed = 0;
+
+  for (const testFile of testFiles) {
+    // 4. Parse test suite
+    let suite: Awaited<ReturnType<typeof parseTestFile>>;
+    try {
+      suite = parseTestFile(testFile);
+    } catch (err) {
+      console.error(chalk.red(`✗ Invalid test file ${testFile}:`), err instanceof Error ? err.message : err);
+      continue;
+    }
+
+    console.log(chalk.gray(`  File: ${path.basename(testFile)}`));
+    console.log(chalk.gray(`  Cases: ${suite.cases.length}`));
+    console.log("");
+
+    // 5. Run
+    const spinner = ora("Running tests...").start();
+    const summary = await runTestSuite(agent, suite);
+    spinner.stop();
+
+    // 6. Display results
+    for (const result of summary.results) {
+      if (result.passed) {
+        console.log(
+          chalk.green("  ✓ PASS") +
+            chalk.white(` ${result.name}`) +
+            chalk.gray(` (${result.duration_ms}ms)`)
+        );
+      } else {
+        console.log(
+          chalk.red("  ✗ FAIL") +
+            chalk.white(` ${result.name}`) +
+            chalk.gray(` (${result.duration_ms}ms)`)
+        );
+        for (const failure of result.failures) {
+          console.log(chalk.red("       ↳ " + failure));
+        }
+        if (result.error) {
+          console.log(chalk.red("       Error: " + result.error));
+        }
+      }
+    }
+
+    totalPassed += summary.passed;
+    totalFailed += summary.failed;
+
+    console.log("");
+    console.log(
+      chalk.gray("  ─────────────────────────────────────")
+    );
+
+    const statusColor = summary.failed === 0 ? chalk.green : chalk.red;
+    console.log(
+      statusColor(
+        `  ${summary.passed}/${summary.total} passed`
+      ) +
+        chalk.gray(` · ${summary.duration_ms}ms`)
+    );
+  }
+
+  console.log("");
+
+  // Final exit code
+  if (totalFailed > 0) {
+    process.exit(1);
+  }
+}