@poncho-ai/cli 0.2.0

package/dist/chunk-RFS3GC46.js

@@ -0,0 +1,239 @@
+// src/index.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import {
+  createServer
+} from "http";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { AgentHarness } from "@agentl/harness";
+import { Command } from "commander";
+import dotenv from "dotenv";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var writeJson = (response, statusCode, payload) => {
+  response.writeHead(statusCode, { "Content-Type": "application/json" });
+  response.end(JSON.stringify(payload));
+};
+var readRequestBody = async (request) => {
+  const chunks = [];
+  for await (const chunk of request) {
+    chunks.push(Buffer.from(chunk));
+  }
+  const body = Buffer.concat(chunks).toString("utf8");
+  return body.length > 0 ? JSON.parse(body) : {};
+};
+var parseParams = (values) => {
+  const params = {};
+  for (const value of values) {
+    const [key, ...rest] = value.split("=");
+    if (!key) {
+      continue;
+    }
+    params[key] = rest.join("=");
+  }
+  return params;
+};
+var AGENT_TEMPLATE = `---
+name: my-agent
+description: A helpful AgentL assistant
+model:
+  provider: anthropic
+  name: claude-sonnet-4-20250514
+  temperature: 0.2
+limits:
+  maxSteps: 50
+  timeout: 300
+---
+
+# My Agent
+
+You are a helpful assistant built with AgentL.
+
+Working directory: {{runtime.workingDir}}
+Environment: {{runtime.environment}}
+
+## Task Guidance
+
+- Use tools when needed
+- Explain your reasoning clearly
+- Ask clarifying questions when requirements are ambiguous
+`;
+var CONFIG_TEMPLATE = `export default {
+  mcp: []
+}
+`;
+var PACKAGE_TEMPLATE = (name) => JSON.stringify(
+  {
+    name,
+    private: true,
+    type: "module",
+    dependencies: {
+      "@agentl/harness": "^0.1.0"
+    }
+  },
+  null,
+  2
+);
+var ENV_TEMPLATE = "ANTHROPIC_API_KEY=sk-ant-...\n";
+var GITIGNORE_TEMPLATE = ".env\nnode_modules\ndist\n";
+var ensureFile = async (path, content) => {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, content, { encoding: "utf8", flag: "wx" });
+};
+var initProject = async (projectName) => {
+  const projectDir = resolve(process.cwd(), projectName);
+  await mkdir(projectDir, { recursive: true });
+  await ensureFile(resolve(projectDir, "AGENT.md"), AGENT_TEMPLATE);
+  await ensureFile(resolve(projectDir, "agentl.config.js"), CONFIG_TEMPLATE);
+  await ensureFile(resolve(projectDir, "package.json"), PACKAGE_TEMPLATE(projectName));
+  await ensureFile(resolve(projectDir, ".env.example"), ENV_TEMPLATE);
+  await ensureFile(resolve(projectDir, ".gitignore"), GITIGNORE_TEMPLATE);
+  process.stdout.write(`Initialized AgentL project at ${projectDir}
+`);
+};
+var formatSseEvent = (event) => `event: ${event.type}
+data: ${JSON.stringify(event)}
+
+`;
+var startDevServer = async (port) => {
+  dotenv.config({ path: resolve(process.cwd(), ".env") });
+  const harness = new AgentHarness({ workingDir: process.cwd() });
+  await harness.initialize();
+  const server = createServer(async (request, response) => {
+    if (!request.url || !request.method) {
+      writeJson(response, 404, { error: "Not found" });
+      return;
+    }
+    if (request.url === "/health" && request.method === "GET") {
+      writeJson(response, 200, { status: "ok" });
+      return;
+    }
+    if (request.url === "/run/sync" && request.method === "POST") {
+      try {
+        const input = await readRequestBody(request);
+        const output = await harness.runToCompletion(input);
+        writeJson(response, 200, {
+          runId: output.runId,
+          status: output.result.status,
+          result: output.result
+        });
+      } catch (error) {
+        writeJson(response, 500, {
+          code: "RUN_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+      return;
+    }
+    if (request.url === "/run" && request.method === "POST") {
+      response.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      try {
+        const input = await readRequestBody(request);
+        for await (const event of harness.run(input)) {
+          response.write(formatSseEvent(event));
+        }
+      } catch (error) {
+        response.write(
+          formatSseEvent({
+            type: "run:error",
+            runId: "run_unknown",
+            error: {
+              code: "RUN_ERROR",
+              message: error instanceof Error ? error.message : "Unknown error"
+            }
+          })
+        );
+      } finally {
+        response.end();
+      }
+      return;
+    }
+    writeJson(response, 404, { error: "Not found" });
+  });
+  await new Promise((resolveStart) => {
+    server.listen(port, () => resolveStart());
+  });
+  process.stdout.write(`AgentL dev server running at http://localhost:${port}
+`);
+  return server;
+};
+var runOnce = async (task, options) => {
+  dotenv.config({ path: resolve(process.cwd(), ".env") });
+  const harness = new AgentHarness({ workingDir: process.cwd() });
+  await harness.initialize();
+  const fileBlobs = await Promise.all(
+    options.filePaths.map(async (path) => {
+      const content = await readFile(resolve(process.cwd(), path), "utf8");
+      return `# File: ${path}
+${content}`;
+    })
+  );
+  const input = {
+    task: fileBlobs.length > 0 ? `${task}
+
+${fileBlobs.join("\n\n")}` : task,
+    parameters: options.params
+  };
+  if (options.json) {
+    const output = await harness.runToCompletion(input);
+    process.stdout.write(`${JSON.stringify(output, null, 2)}
+`);
+    return;
+  }
+  for await (const event of harness.run(input)) {
+    if (event.type === "model:chunk") {
+      process.stdout.write(event.content);
+    }
+    if (event.type === "run:error") {
+      process.stderr.write(`
+Error: ${event.error.message}
+`);
+    }
+    if (event.type === "run:completed") {
+      process.stdout.write("\n");
+    }
+  }
+};
+var buildCli = () => {
+  const program = new Command();
+  program.name("agentl").description("CLI for building and running AgentL agents").version("0.1.0");
+  program.command("init").argument("<name>", "project name").description("Scaffold a new AgentL project").action(async (name) => {
+    await initProject(name);
+  });
+  program.command("dev").description("Run local development server").option("--port <port>", "server port", "3000").action(async (options) => {
+    const port = Number.parseInt(options.port, 10);
+    await startDevServer(Number.isNaN(port) ? 3e3 : port);
+  });
+  program.command("run").argument("<task>", "task to run").description("Execute the agent once").option("--param <keyValue>", "parameter key=value", (value, all) => {
+    all.push(value);
+    return all;
+  }, []).option("--file <path>", "include file contents", (value, all) => {
+    all.push(value);
+    return all;
+  }, []).option("--json", "output json", false).action(
+    async (task, options) => {
+      await runOnce(task, {
+        params: parseParams(options.param),
+        json: options.json,
+        filePaths: options.file
+      });
+    }
+  );
+  return program;
+};
+var main = async (argv = process.argv) => {
+  await buildCli().parseAsync(argv);
+};
+var packageRoot = resolve(__dirname, "..");
+
+export {
+  initProject,
+  startDevServer,
+  runOnce,
+  buildCli,
+  main,
+  packageRoot
+};