worldagents 0.1.0

package/README.md

@@ -0,0 +1,21 @@
+# worldagents
+
+WorldAgents cli.
+
+## Install
+
+```bash
+npm install -g worldagents
+```
+
+Or run it without installing:
+
+```bash
+npx worldagents@latest create my-agent
+```
+
+## CLI
+
+```bash
+worldagents create my-agent
+```

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "worldagents",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "WorldAgents cli",
+  "bin": {
+    "worldagents": "./src/cli.js"
+  },
+  "exports": {
+    ".": "./src/index.js",
+    "./cli": "./src/cli.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "README.md",
+    "src/"
+  ],
+  "keywords": [
+    "agent",
+    "cli",
+    "worldagents"
+  ]
+}

package/src/cli.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { CreateAgentError, createAgent } from "./create-agent.js";
+
+const USAGE = `Usage:
+  worldagents create [path] [--agent-name <name>] [--force]
+
+Commands:
+  create   Create a minimal agent stub.
+
+Options:
+  -n, --agent-name <name>   Agent name written into the scaffold.
+  -f, --force               Allow writing into a non-empty directory.
+  -h, --help                Show help.
+`;
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const [command, ...commandArgs] = argv;
+
+  if (!command || command === "-h" || command === "--help") {
+    printUsage();
+    return;
+  }
+
+  if (command === "create") {
+    await handleCreate(commandArgs);
+    return;
+  }
+
+  throw usageError(`Unknown command: ${command}`);
+}
+
+async function handleCreate(args) {
+  const { values, positionals } = parseCommandArgs(args, {
+    "agent-name": { type: "string", short: "n" },
+    force: { type: "boolean", short: "f" },
+    help: { type: "boolean", short: "h" },
+  });
+
+  if (values.help) {
+    printUsage();
+    return;
+  }
+
+  if (positionals.length > 1) {
+    throw usageError("Too many positional arguments for create.");
+  }
+
+  const targetPath = path.resolve(positionals[0] ?? process.cwd());
+
+  try {
+    const created = await createAgent({
+      path: targetPath,
+      agentName: values["agent-name"],
+      force: values.force,
+    });
+
+    logInfo(`Created agent stub at: ${created.agentPath}`);
+    logInfo(`Agent name: ${created.agentName}`);
+  } catch (error) {
+    if (error instanceof CreateAgentError) {
+      throw usageError(error.message);
+    }
+    throw error;
+  }
+}
+
+function parseCommandArgs(args, options) {
+  try {
+    return parseArgs({ args, allowPositionals: true, options });
+  } catch (error) {
+    throw usageError(error.message);
+  }
+}
+
+function usageError(message) {
+  const error = new Error(message);
+  error.exitCode = 2;
+  return error;
+}
+
+function printUsage() {
+  console.log(USAGE.trim());
+}
+
+function logInfo(message) {
+  console.log(message);
+}
+
+function logError(message) {
+  console.error(`error: ${message}`);
+}
+
+main().catch((error) => {
+  logError(error.message);
+  if (error.exitCode === 2) {
+    console.error("");
+    printUsage();
+  }
+  process.exitCode = error.exitCode ?? 1;
+});

package/src/create-agent.js

@@ -0,0 +1,68 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export const CONFIG_FILE_NAME = "worldagents.config.json";
+
+export class CreateAgentError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CreateAgentError";
+  }
+}
+
+export async function createAgent(options) {
+  if (!options || typeof options !== "object") {
+    throw new CreateAgentError("Options object is required.");
+  }
+
+  if (typeof options.path !== "string" || options.path.trim() === "") {
+    throw new CreateAgentError("path is required.");
+  }
+
+  if (options.force != null && typeof options.force !== "boolean") {
+    throw new CreateAgentError("force must be a boolean when provided.");
+  }
+
+  const agentPath = path.resolve(options.path);
+  const existing = await statIfExists(agentPath);
+
+  if (existing && !existing.isDirectory()) {
+    throw new CreateAgentError(`Path exists and is not a directory: ${agentPath}`);
+  }
+
+  if (existing && !options.force) {
+    const entries = await fs.readdir(agentPath);
+    if (entries.length > 0) {
+      throw new CreateAgentError(`Directory is not empty: ${agentPath}`);
+    }
+  }
+
+  await fs.mkdir(agentPath, { recursive: true });
+
+  const agentName =
+    typeof options.agentName === "string" && options.agentName.trim() !== ""
+      ? options.agentName.trim()
+      : path.basename(agentPath);
+
+  await fs.writeFile(
+    path.join(agentPath, CONFIG_FILE_NAME),
+    `${JSON.stringify({ name: agentName }, null, 2)}\n`,
+    "utf8",
+  );
+
+  return {
+    agentPath,
+    agentName,
+  };
+}
+
+async function statIfExists(filePath) {
+  try {
+    return await fs.stat(filePath);
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}

package/src/index.js

@@ -0,0 +1,5 @@
+export {
+  CONFIG_FILE_NAME,
+  CreateAgentError,
+  createAgent,
+} from "./create-agent.js";