@ai-code-agents/cli 0.1.0-beta.1 → 0.1.0

package/dist/cli.js

@@ -2,198 +2,185 @@
 
 // src/cli.ts
 import { program } from "@commander-js/extra-typings";
+import { withOptions, withErrorHandling } from "@felixarntz/cli-utils";
 import dotenv from "dotenv";
 
-// src/util/logger.ts
-import { styleText } from "util";
-var createStyledText = (style) => (text) => styleText(style, text);
-var formatBold = createStyledText("bold");
-var colorError = createStyledText("red");
-var colorWarning = createStyledText("yellowBright");
-var colorSuccess = createStyledText("green");
-var colorDebug = createStyledText("cyan");
-var formatLogMessage = (text, level) => {
-  switch (level) {
-    case 0 /* DEBUG */:
-      return colorDebug(text);
-    case 2 /* SUCCESS */:
-      return formatBold(colorSuccess(`\u2705 ${text}`));
-    case 3 /* WARN */:
-      return formatBold(colorWarning(`\u26A0\uFE0F ${text}`));
-    case 4 /* ERROR */:
-      return formatBold(colorError(`\u274C ${text}`));
-    default:
-      return text;
-  }
-};
-var DEFAULT_LOG_LEVEL = 1 /* INFO */;
-var CURRENT_LOG_LEVEL = process.env["NODE_ENV"] === "development" || process.env["DEBUG"] === "true" ? 0 /* DEBUG */ : process.env["SILENT"] === "true" ? 5 /* SILENT */ : DEFAULT_LOG_LEVEL;
-var Logger = class {
-  /**
-   * Logs a debug message.
-   *
-   * @param text - The message to log.
-   */
-  debug(text) {
-    this.log(text, 0 /* DEBUG */);
-  }
-  /**
-   * Logs an info message.
-   *
-   * @param text - The message to log.
-   */
-  info(text) {
-    this.log(text, 1 /* INFO */);
-  }
-  /**
-   * Logs a success message.
-   *
-   * @param text - The message to log.
-   */
-  success(text) {
-    this.log(text, 2 /* SUCCESS */);
-  }
-  /**
-   * Logs a warning message.
-   *
-   * @param text - The message to log.
-   */
-  warn(text) {
-    this.log(text, 3 /* WARN */);
-  }
-  /**
-   * Logs an error message.
-   *
-   * @param text - The message to log.
-   */
-  error(text) {
-    this.log(text, 4 /* ERROR */);
-  }
-  /**
-   * Logs a message with a log level.
-   *
-   * @param text - The message to log.
-   * @param level - The log level. Defaults to LogLevel.INFO.
-   */
-  log(text, level = 1 /* INFO */) {
-    if (level < CURRENT_LOG_LEVEL) {
-      return;
+// src/commands/docker-code-agent.ts
+import {
+  createEnvironment,
+  EnvironmentToolSafetyLevels
+} from "ai-code-agents";
+import {
+  getOpt,
+  parseFileOptions,
+  injectFileOptionsForCommander,
+  promptMissingOptions,
+  stripOptionFieldsForCommander,
+  normalizeAbsolutePath
+} from "@felixarntz/cli-utils";
+
+// src/util/create-and-run-code-agent.ts
+import {
+  createCodeAgent
+} from "ai-code-agents";
+import { output, logger } from "@felixarntz/cli-utils";
+var createAndRunCodeAgent = async (options6) => {
+  const {
+    environment,
+    environmentToolsDefinition,
+    model,
+    prompt,
+    system,
+    maxSteps = 10,
+    directory
+  } = options6;
+  const modelSuffix = model ? ` (using model ${model})` : "";
+  logger.debug(
+    `Running task prompt in ${environment.name} about code in ${directory}${modelSuffix}...`
+  );
+  const agent = createCodeAgent({
+    model,
+    environment,
+    environmentToolsDefinition,
+    maxSteps,
+    instructions: system,
+    logStep: (log) => {
+      logger.debug("\n" + log);
     }
-    process.stderr.write(`${formatLogMessage(text, level)}
-`);
-  }
+  });
+  const result = await agent.generate({ prompt });
+  const { text } = result;
+  output(text);
 };
-var logger = new Logger();
 
-// src/util/commander.ts
-var getArgs = (handlerArgs) => {
-  if (handlerArgs.length <= 2) {
-    return [];
+// src/commands/docker-code-agent.ts
+var name = "docker-code-agent";
+var description = "Runs a code agent in a Docker container to perform a specified task.";
+var actualOptions = [
+  {
+    argname: "-p, --prompt <prompt>",
+    description: "Task prompt for the agent",
+    required: true
+  },
+  {
+    argname: "-m, --model <model>",
+    description: "Model to use for the agent",
+    required: true
+  },
+  {
+    argname: "-d, --directory <directory>",
+    description: "Directory with the project to work on",
+    parse: (value) => normalizeAbsolutePath(value),
+    required: true
+  },
+  {
+    argname: "-t, --tools <tools>",
+    description: "Tools to allow the agent to use in the environment",
+    choices: EnvironmentToolSafetyLevels,
+    defaults: "readonly"
+  },
+  {
+    argname: "-i, --container-id <container-id>",
+    description: "ID of the Docker container",
+    required: true
+  },
+  {
+    argname: "-s, --system <system>",
+    description: "System instruction to guide the agent"
   }
-  return handlerArgs.slice(0, -2).map(String);
-};
-var getOpt = (handlerArgs) => {
-  if (handlerArgs.length <= 1) {
-    return {};
+];
+var options = injectFileOptionsForCommander(actualOptions, [
+  "prompt",
+  "system"
+]).map((option) => stripOptionFieldsForCommander(option));
+var parseOptions = (opt) => {
+  const config = {
+    prompt: String(opt["prompt"]),
+    model: opt["model"] ? String(opt["model"]) : "",
+    containerId: String(opt["container-id"]),
+    directory: opt["directory"] ? String(opt["directory"]) : "",
+    tools: opt["tools"] ? opt["tools"] : "readonly"
+  };
+  if (opt["system"]) {
+    config.system = String(opt["system"]);
   }
-  return handlerArgs[handlerArgs.length - 2];
+  return config;
 };
-var withOptions = (command, options2) => {
-  options2.forEach(
-    ({
-      description: description2,
-      argname,
-      positional,
-      required,
-      defaults,
-      choices,
-      parse,
-      variadic
-    }) => {
-      if (positional) {
-        const variadicSuffix = variadic ? "..." : "";
-        const argument = command.createArgument(
-          required ? `<${argname}${variadicSuffix}>` : `[${argname}${variadicSuffix}]`,
-          description2
-        );
-        if (defaults) {
-          argument.default(defaults);
-        }
-        if (typeof parse === "function") {
-          argument.argParser(parse);
-        }
-        if (choices) {
-          argument.choices(choices);
-        }
-        command.addArgument(argument);
-        return;
-      }
-      const option = command.createOption(argname, description2);
-      if (required) {
-        option.makeOptionMandatory(true);
-      }
-      if (defaults) {
-        option.default(defaults);
-      }
-      if (typeof parse === "function") {
-        option.argParser(parse);
-      }
-      if (choices) {
-        option.choices(choices);
-      }
-      command.addOption(option);
-    }
+var handler = async (...handlerArgs) => {
+  const { prompt, model, directory, tools, containerId, system } = parseOptions(
+    await promptMissingOptions(
+      actualOptions,
+      await parseFileOptions(getOpt(handlerArgs), ["prompt", "system"])
+    )
   );
-  return command;
-};
-var withErrorHandling = (handler2) => async (...handlerArgs) => {
-  try {
-    const result = handler2(...handlerArgs);
-    if (result instanceof Promise) {
-      await result;
-    }
-  } catch (error) {
-    if (error instanceof Error) {
-      logger.error(error.message);
-    }
-    process.exitCode = 1;
-  }
+  await createAndRunCodeAgent({
+    environment: createEnvironment("docker", {
+      directoryPath: directory,
+      containerId
+    }),
+    environmentToolsDefinition: tools,
+    model,
+    prompt,
+    system,
+    directory
+  });
 };
 
-// src/commands/code-agent.ts
+// src/commands/just-bash-code-agent.ts
 import {
-  createCodeAgent,
-  createEnvironment,
-  EnvironmentNames,
-  EnvironmentToolSafetyLevels
+  EnvironmentToolSafetyLevels as EnvironmentToolSafetyLevels2
 } from "ai-code-agents";
+import { JustBashEnvironment } from "@ai-code-agents/just-bash";
+import {
+  getOpt as getOpt2,
+  parseFileOptions as parseFileOptions2,
+  injectFileOptionsForCommander as injectFileOptionsForCommander2,
+  promptMissingOptions as promptMissingOptions2,
+  stripOptionFieldsForCommander as stripOptionFieldsForCommander2,
+  logger as logger2,
+  normalizeAbsolutePath as normalizeAbsolutePath2
+} from "@felixarntz/cli-utils";
 
-// src/util/paths.ts
+// src/util/read-local-directory-files.ts
 import path from "path";
-function normalizeAbsolutePath(filePath, rootDir = void 0) {
-  if (!rootDir) {
-    rootDir = process.cwd();
+import {
+  UnsafeLocalEnvironment,
+  GetProjectFileStructureTool,
+  ReadManyFilesTool
+} from "ai-code-agents";
+var readLocalDirectoryFiles = async (directoryPath) => {
+  const env = new UnsafeLocalEnvironment({ directoryPath });
+  const getProjectFileStructureTool = new GetProjectFileStructureTool(env);
+  const readManyFilesTool = new ReadManyFilesTool(env);
+  const { files } = await getProjectFileStructureTool.execute(
+    { excludeGitIgnored: true },
+    {}
+  );
+  if (files.length === 0) {
+    return {};
   }
-  if (path.isAbsolute(filePath)) {
-    return filePath;
+  const readResult = await readManyFilesTool.execute(
+    { paths: files },
+    {}
+  );
+  const result = {};
+  for (const [, fileResult] of Object.entries(readResult)) {
+    const relativePath = path.relative(
+      directoryPath,
+      path.resolve(directoryPath, fileResult.path)
+    );
+    result[relativePath] = fileResult.content;
   }
-  return path.join(rootDir, filePath);
-}
-
-// src/util/output.ts
-function output(text) {
-  process.stdout.write(`${text}
-`);
-}
+  return result;
+};
 
-// src/commands/code-agent.ts
-var name = "code-agent";
-var description = "Runs a code agent to perform a specified task.";
-var options = [
+// src/commands/just-bash-code-agent.ts
+var name2 = "just-bash-code-agent";
+var description2 = "Runs a code agent using a simulated bash environment to perform a specified task.";
+var actualOptions2 = [
   {
-    argname: "task",
-    description: "Task for the agent",
-    positional: true,
+    argname: "-p, --prompt <prompt>",
+    description: "Task prompt for the agent",
     required: true
   },
   {
@@ -202,90 +189,327 @@ var options = [
     required: true
   },
   {
-    argname: "-e, --environment <environment>",
-    description: "Environment type to use",
-    choices: EnvironmentNames,
+    argname: "-d, --directory <directory>",
+    description: "Working directory in the simulated bash environment",
+    parse: (value) => normalizeAbsolutePath2(value)
+  },
+  {
+    argname: "-t, --tools <tools>",
+    description: "Tools to allow the agent to use in the environment",
+    choices: EnvironmentToolSafetyLevels2,
+    defaults: "readonly"
+  },
+  {
+    argname: "-l, --local-directory <local-directory>",
+    description: "Local directory to mount into the simulated environment (reads all files excluding gitignored)",
+    parse: (value) => normalizeAbsolutePath2(value)
+  },
+  {
+    argname: "-s, --system <system>",
+    description: "System instruction to guide the agent"
+  }
+];
+var options2 = injectFileOptionsForCommander2(actualOptions2, [
+  "prompt",
+  "system"
+]).map((option) => stripOptionFieldsForCommander2(option));
+var parseOptions2 = (opt) => {
+  const config = {
+    prompt: String(opt["prompt"]),
+    model: opt["model"] ? String(opt["model"]) : "",
+    tools: opt["tools"] ? opt["tools"] : "readonly"
+  };
+  if (opt["directory"]) {
+    config.directory = String(opt["directory"]);
+  }
+  if (opt["local-directory"]) {
+    config.localDirectory = String(opt["local-directory"]);
+  }
+  if (opt["system"]) {
+    config.system = String(opt["system"]);
+  }
+  return config;
+};
+var handler2 = async (...handlerArgs) => {
+  const { prompt, model, directory, tools, localDirectory, system } = parseOptions2(
+    await promptMissingOptions2(
+      actualOptions2,
+      await parseFileOptions2(getOpt2(handlerArgs), ["prompt", "system"])
+    )
+  );
+  let files = void 0;
+  if (localDirectory) {
+    logger2.debug(`Reading files from local directory at ${localDirectory}...`);
+    files = await readLocalDirectoryFiles(localDirectory);
+    logger2.debug(
+      `Mounting ${Object.keys(files).length} files into the simulated bash environment...`
+    );
+  }
+  await createAndRunCodeAgent({
+    environment: JustBashEnvironment.create({
+      directoryPath: directory,
+      bashOptions: files ? { files } : void 0
+    }),
+    environmentToolsDefinition: tools,
+    model,
+    prompt,
+    system,
+    directory: directory || "/home/user"
+    // Default 'just-bash' working directory.
+  });
+};
+
+// src/commands/mock-filesystem-code-agent.ts
+import {
+  createEnvironment as createEnvironment2,
+  EnvironmentToolSafetyLevels as EnvironmentToolSafetyLevels3
+} from "ai-code-agents";
+import {
+  getOpt as getOpt3,
+  parseFileOptions as parseFileOptions3,
+  injectFileOptionsForCommander as injectFileOptionsForCommander3,
+  promptMissingOptions as promptMissingOptions3,
+  stripOptionFieldsForCommander as stripOptionFieldsForCommander3,
+  normalizeAbsolutePath as normalizeAbsolutePath3
+} from "@felixarntz/cli-utils";
+var name3 = "mock-filesystem-code-agent";
+var description3 = "Runs a code agent on a mock filesystem to perform a specified task.";
+var actualOptions3 = [
+  {
+    argname: "-p, --prompt <prompt>",
+    description: "Task prompt for the agent",
+    required: true
+  },
+  {
+    argname: "-m, --model <model>",
+    description: "Model to use for the agent",
     required: true
   },
   {
     argname: "-d, --directory <directory>",
     description: "Directory with the project to work on",
-    parse: (value) => normalizeAbsolutePath(value),
+    parse: (value) => normalizeAbsolutePath3(value),
     required: true
   },
   {
     argname: "-t, --tools <tools>",
-    description: "ID of the environment, if relevant (e.g. Docker container ID)",
-    choices: EnvironmentToolSafetyLevels,
-    default: "readonly"
+    description: "Tools to allow the agent to use in the environment",
+    choices: EnvironmentToolSafetyLevels3,
+    defaults: "readonly"
+  },
+  {
+    argname: "-s, --system <system>",
+    description: "System instruction to guide the agent"
+  }
+];
+var options3 = injectFileOptionsForCommander3(actualOptions3, [
+  "prompt",
+  "system"
+]).map((option) => stripOptionFieldsForCommander3(option));
+var parseOptions3 = (opt) => {
+  const config = {
+    prompt: String(opt["prompt"]),
+    model: opt["model"] ? String(opt["model"]) : "",
+    directory: opt["directory"] ? String(opt["directory"]) : "",
+    tools: opt["tools"] ? opt["tools"] : "readonly"
+  };
+  if (opt["system"]) {
+    config.system = String(opt["system"]);
+  }
+  return config;
+};
+var handler3 = async (...handlerArgs) => {
+  const { prompt, model, directory, tools, system } = parseOptions3(
+    await promptMissingOptions3(
+      actualOptions3,
+      await parseFileOptions3(getOpt3(handlerArgs), ["prompt", "system"])
+    )
+  );
+  await createAndRunCodeAgent({
+    environment: createEnvironment2("mock-filesystem", {
+      directoryPath: directory
+    }),
+    environmentToolsDefinition: tools,
+    model,
+    prompt,
+    system,
+    directory
+  });
+};
+
+// src/commands/node-filesystem-code-agent.ts
+import {
+  createEnvironment as createEnvironment3,
+  EnvironmentToolSafetyLevels as EnvironmentToolSafetyLevels4
+} from "ai-code-agents";
+import {
+  getOpt as getOpt4,
+  parseFileOptions as parseFileOptions4,
+  injectFileOptionsForCommander as injectFileOptionsForCommander4,
+  promptMissingOptions as promptMissingOptions4,
+  stripOptionFieldsForCommander as stripOptionFieldsForCommander4,
+  normalizeAbsolutePath as normalizeAbsolutePath4
+} from "@felixarntz/cli-utils";
+var name4 = "node-filesystem-code-agent";
+var description4 = "Runs a code agent locally using Node to perform a specified task.";
+var actualOptions4 = [
+  {
+    argname: "-p, --prompt <prompt>",
+    description: "Task prompt for the agent",
+    required: true
   },
   {
-    argname: "-i, --environment-id <environment-id>",
-    description: "ID of the environment, if relevant (e.g. Docker container ID)"
+    argname: "-m, --model <model>",
+    description: "Model to use for the agent",
+    required: true
+  },
+  {
+    argname: "-d, --directory <directory>",
+    description: "Directory with the project to work on",
+    parse: (value) => normalizeAbsolutePath4(value),
+    required: true
+  },
+  {
+    argname: "-t, --tools <tools>",
+    description: "Tools to allow the agent to use in the environment",
+    choices: EnvironmentToolSafetyLevels4,
+    defaults: "readonly"
   },
   {
     argname: "-s, --system <system>",
     description: "System instruction to guide the agent"
   }
 ];
-var parseOptions = (opt) => {
+var options4 = injectFileOptionsForCommander4(actualOptions4, [
+  "prompt",
+  "system"
+]).map((option) => stripOptionFieldsForCommander4(option));
+var parseOptions4 = (opt) => {
   const config = {
+    prompt: String(opt["prompt"]),
     model: opt["model"] ? String(opt["model"]) : "",
-    environment: opt["environment"],
     directory: opt["directory"] ? String(opt["directory"]) : "",
     tools: opt["tools"] ? opt["tools"] : "readonly"
   };
-  if (opt["environment-id"]) {
-    config.environmentId = String(opt["environment-id"]);
-  }
   if (opt["system"]) {
     config.system = String(opt["system"]);
   }
   return config;
 };
-var handler = async (...handlerArgs) => {
-  const [task] = getArgs(handlerArgs);
-  const { model, environment, directory, tools, environmentId, system } = parseOptions(getOpt(handlerArgs));
-  const modelSuffix = model ? ` (using model ${model})` : "";
-  logger.debug(
-    `Running task "${task}" in ${environment} about code in ${directory}${modelSuffix}...`
-  );
-  const environmentConfig = createEnvironmentConfig(
-    environment,
-    directory,
-    environmentId
+var handler4 = async (...handlerArgs) => {
+  const { prompt, model, directory, tools, system } = parseOptions4(
+    await promptMissingOptions4(
+      actualOptions4,
+      await parseFileOptions4(getOpt4(handlerArgs), ["prompt", "system"])
+    )
   );
-  const agent = createCodeAgent({
-    model,
-    environment: createEnvironment(environment, environmentConfig),
+  await createAndRunCodeAgent({
+    environment: createEnvironment3("node-filesystem", {
+      directoryPath: directory
+    }),
     environmentToolsDefinition: tools,
-    maxSteps: 10,
-    logStep: (log) => {
-      logger.debug("\n" + log);
-    },
-    system
+    model,
+    prompt,
+    system,
+    directory
   });
-  const result = await agent.generate({ prompt: task });
-  const { text } = result;
-  output(text);
 };
-var createEnvironmentConfig = (environment, directory, environmentId) => {
+
+// src/commands/unsafe-local-code-agent.ts
+import {
+  createEnvironment as createEnvironment4,
+  EnvironmentToolSafetyLevels as EnvironmentToolSafetyLevels5
+} from "ai-code-agents";
+import {
+  getOpt as getOpt5,
+  parseFileOptions as parseFileOptions5,
+  injectFileOptionsForCommander as injectFileOptionsForCommander5,
+  promptMissingOptions as promptMissingOptions5,
+  stripOptionFieldsForCommander as stripOptionFieldsForCommander5,
+  normalizeAbsolutePath as normalizeAbsolutePath5
+} from "@felixarntz/cli-utils";
+var name5 = "unsafe-local-code-agent";
+var description5 = "Runs a code agent locally to perform a specified task.";
+var actualOptions5 = [
+  {
+    argname: "-p, --prompt <prompt>",
+    description: "Task prompt for the agent",
+    required: true
+  },
+  {
+    argname: "-m, --model <model>",
+    description: "Model to use for the agent",
+    required: true
+  },
+  {
+    argname: "-d, --directory <directory>",
+    description: "Directory with the project to work on",
+    parse: (value) => normalizeAbsolutePath5(value),
+    required: true
+  },
+  {
+    argname: "-t, --tools <tools>",
+    description: "Tools to allow the agent to use in the environment",
+    choices: EnvironmentToolSafetyLevels5,
+    defaults: "readonly"
+  },
+  {
+    argname: "-s, --system <system>",
+    description: "System instruction to guide the agent"
+  }
+];
+var options5 = injectFileOptionsForCommander5(actualOptions5, [
+  "prompt",
+  "system"
+]).map((option) => stripOptionFieldsForCommander5(option));
+var parseOptions5 = (opt) => {
   const config = {
-    directoryPath: directory
+    prompt: String(opt["prompt"]),
+    model: opt["model"] ? String(opt["model"]) : "",
+    directory: opt["directory"] ? String(opt["directory"]) : "",
+    tools: opt["tools"] ? opt["tools"] : "readonly"
   };
-  if (environment === "docker" && environmentId) {
-    return {
-      ...config,
-      containerId: environmentId
-    };
+  if (opt["system"]) {
+    config.system = String(opt["system"]);
   }
   return config;
 };
+var handler5 = async (...handlerArgs) => {
+  const { prompt, model, directory, tools, system } = parseOptions5(
+    await promptMissingOptions5(
+      actualOptions5,
+      await parseFileOptions5(getOpt5(handlerArgs), ["prompt", "system"])
+    )
+  );
+  await createAndRunCodeAgent({
+    environment: createEnvironment4("unsafe-local", {
+      directoryPath: directory
+    }),
+    environmentToolsDefinition: tools,
+    model,
+    prompt,
+    system,
+    directory
+  });
+};
 
 // src/cli.ts
 function initialize() {
   dotenv.config();
   withOptions(program.command(name), options).description(description).action(withErrorHandling(handler));
+  withOptions(program.command(name2), options2).description(description2).action(withErrorHandling(handler2));
+  withOptions(
+    program.command(name3),
+    options3
+  ).description(description3).action(withErrorHandling(handler3));
+  withOptions(
+    program.command(name4),
+    options4
+  ).description(description4).action(withErrorHandling(handler4));
+  withOptions(
+    program.command(name5),
+    options5
+  ).description(description5).action(withErrorHandling(handler5));
 }
 function run() {
   program.parse();