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

package/dist/cli.cjs

@@ -25,193 +25,159 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/cli.ts
 var import_extra_typings = require("@commander-js/extra-typings");
+var import_cli_utils7 = require("@felixarntz/cli-utils");
 var import_dotenv = __toESM(require("dotenv"), 1);
 
-// src/util/logger.ts
-var import_node_util = require("util");
-var createStyledText = (style) => (text) => (0, import_node_util.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
+var import_ai_code_agents2 = require("ai-code-agents");
+var import_cli_utils2 = require("@felixarntz/cli-utils");
+
+// src/util/create-and-run-code-agent.ts
+var import_ai_code_agents = require("ai-code-agents");
+var import_cli_utils = require("@felixarntz/cli-utils");
+var createAndRunCodeAgent = async (options6) => {
+  const {
+    environment,
+    environmentToolsDefinition,
+    model,
+    prompt,
+    system,
+    maxSteps = 10,
+    directory
+  } = options6;
+  const modelSuffix = model ? ` (using model ${model})` : "";
+  import_cli_utils.logger.debug(
+    `Running task prompt in ${environment.name} about code in ${directory}${modelSuffix}...`
+  );
+  const agent = (0, import_ai_code_agents.createCodeAgent)({
+    model,
+    environment,
+    environmentToolsDefinition,
+    maxSteps,
+    instructions: system,
+    logStep: (log) => {
+      import_cli_utils.logger.debug("\n" + log);
     }
-    process.stderr.write(`${formatLogMessage(text, level)}
-`);
-  }
+  });
+  const result = await agent.generate({ prompt });
+  const { text } = result;
+  (0, import_cli_utils.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) => (0, import_cli_utils2.normalizeAbsolutePath)(value),
+    required: true
+  },
+  {
+    argname: "-t, --tools <tools>",
+    description: "Tools to allow the agent to use in the environment",
+    choices: import_ai_code_agents2.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 = (0, import_cli_utils2.injectFileOptionsForCommander)(actualOptions, [
+  "prompt",
+  "system"
+]).map((option) => (0, import_cli_utils2.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 (0, import_cli_utils2.promptMissingOptions)(
+      actualOptions,
+      await (0, import_cli_utils2.parseFileOptions)((0, import_cli_utils2.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: (0, import_ai_code_agents2.createEnvironment)("docker", {
+      directoryPath: directory,
+      containerId
+    }),
+    environmentToolsDefinition: tools,
+    model,
+    prompt,
+    system,
+    directory
+  });
 };
 
-// src/commands/code-agent.ts
-var import_ai_code_agents = require("ai-code-agents");
+// src/commands/just-bash-code-agent.ts
+var import_ai_code_agents4 = require("ai-code-agents");
+var import_just_bash = require("@ai-code-agents/just-bash");
+var import_cli_utils3 = require("@felixarntz/cli-utils");
 
-// src/util/paths.ts
+// src/util/read-local-directory-files.ts
 var import_node_path = __toESM(require("path"), 1);
-function normalizeAbsolutePath(filePath, rootDir = void 0) {
-  if (!rootDir) {
-    rootDir = process.cwd();
+var import_ai_code_agents3 = require("ai-code-agents");
+var readLocalDirectoryFiles = async (directoryPath) => {
+  const env = new import_ai_code_agents3.UnsafeLocalEnvironment({ directoryPath });
+  const getProjectFileStructureTool = new import_ai_code_agents3.GetProjectFileStructureTool(env);
+  const readManyFilesTool = new import_ai_code_agents3.ReadManyFilesTool(env);
+  const { files } = await getProjectFileStructureTool.execute(
+    { excludeGitIgnored: true },
+    {}
+  );
+  if (files.length === 0) {
+    return {};
   }
-  if (import_node_path.default.isAbsolute(filePath)) {
-    return filePath;
+  const readResult = await readManyFilesTool.execute(
+    { paths: files },
+    {}
+  );
+  const result = {};
+  for (const [, fileResult] of Object.entries(readResult)) {
+    const relativePath = import_node_path.default.relative(
+      directoryPath,
+      import_node_path.default.resolve(directoryPath, fileResult.path)
+    );
+    result[relativePath] = fileResult.content;
   }
-  return import_node_path.default.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
   },
   {
@@ -219,91 +185,289 @@ var options = [
     description: "Model to use for the agent",
     required: true
   },
-  {
-    argname: "-e, --environment <environment>",
-    description: "Environment type to use",
-    choices: import_ai_code_agents.EnvironmentNames,
-    required: true
-  },
   {
     argname: "-d, --directory <directory>",
     description: "Directory with the project to work on",
-    parse: (value) => normalizeAbsolutePath(value),
+    parse: (value) => (0, import_cli_utils3.normalizeAbsolutePath)(value),
     required: true
   },
   {
     argname: "-t, --tools <tools>",
-    description: "ID of the environment, if relevant (e.g. Docker container ID)",
-    choices: import_ai_code_agents.EnvironmentToolSafetyLevels,
-    default: "readonly"
+    description: "Tools to allow the agent to use in the environment",
+    choices: import_ai_code_agents4.EnvironmentToolSafetyLevels,
+    defaults: "readonly"
   },
   {
-    argname: "-i, --environment-id <environment-id>",
-    description: "ID of the environment, if relevant (e.g. Docker container ID)"
+    argname: "-l, --local-directory <local-directory>",
+    description: "Local directory to mount into the simulated environment (reads all files excluding gitignored)",
+    parse: (value) => (0, import_cli_utils3.normalizeAbsolutePath)(value)
   },
   {
     argname: "-s, --system <system>",
     description: "System instruction to guide the agent"
   }
 ];
-var parseOptions = (opt) => {
+var options2 = (0, import_cli_utils3.injectFileOptionsForCommander)(actualOptions2, [
+  "prompt",
+  "system"
+]).map((option) => (0, import_cli_utils3.stripOptionFieldsForCommander)(option));
+var parseOptions2 = (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["local-directory"]) {
+    config.localDirectory = String(opt["local-directory"]);
   }
   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}...`
+var handler2 = async (...handlerArgs) => {
+  const { prompt, model, directory, tools, localDirectory, system } = parseOptions2(
+    await (0, import_cli_utils3.promptMissingOptions)(
+      actualOptions2,
+      await (0, import_cli_utils3.parseFileOptions)((0, import_cli_utils3.getOpt)(handlerArgs), ["prompt", "system"])
+    )
   );
-  const environmentConfig = createEnvironmentConfig(
-    environment,
-    directory,
-    environmentId
+  const files = localDirectory ? await readLocalDirectoryFiles(localDirectory) : void 0;
+  await createAndRunCodeAgent({
+    environment: import_just_bash.JustBashEnvironment.create({
+      directoryPath: directory,
+      bashOptions: files ? { files } : void 0
+    }),
+    environmentToolsDefinition: tools,
+    model,
+    prompt,
+    system,
+    directory
+  });
+};
+
+// src/commands/mock-filesystem-code-agent.ts
+var import_ai_code_agents5 = require("ai-code-agents");
+var import_cli_utils4 = require("@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) => (0, import_cli_utils4.normalizeAbsolutePath)(value),
+    required: true
+  },
+  {
+    argname: "-t, --tools <tools>",
+    description: "Tools to allow the agent to use in the environment",
+    choices: import_ai_code_agents5.EnvironmentToolSafetyLevels,
+    defaults: "readonly"
+  },
+  {
+    argname: "-s, --system <system>",
+    description: "System instruction to guide the agent"
+  }
+];
+var options3 = (0, import_cli_utils4.injectFileOptionsForCommander)(actualOptions3, [
+  "prompt",
+  "system"
+]).map((option) => (0, import_cli_utils4.stripOptionFieldsForCommander)(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 (0, import_cli_utils4.promptMissingOptions)(
+      actualOptions3,
+      await (0, import_cli_utils4.parseFileOptions)((0, import_cli_utils4.getOpt)(handlerArgs), ["prompt", "system"])
+    )
   );
-  const agent = (0, import_ai_code_agents.createCodeAgent)({
+  await createAndRunCodeAgent({
+    environment: (0, import_ai_code_agents5.createEnvironment)("mock-filesystem", {
+      directoryPath: directory
+    }),
+    environmentToolsDefinition: tools,
     model,
-    environment: (0, import_ai_code_agents.createEnvironment)(environment, environmentConfig),
+    prompt,
+    system,
+    directory
+  });
+};
+
+// src/commands/node-filesystem-code-agent.ts
+var import_ai_code_agents6 = require("ai-code-agents");
+var import_cli_utils5 = require("@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: "-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) => (0, import_cli_utils5.normalizeAbsolutePath)(value),
+    required: true
+  },
+  {
+    argname: "-t, --tools <tools>",
+    description: "Tools to allow the agent to use in the environment",
+    choices: import_ai_code_agents6.EnvironmentToolSafetyLevels,
+    defaults: "readonly"
+  },
+  {
+    argname: "-s, --system <system>",
+    description: "System instruction to guide the agent"
+  }
+];
+var options4 = (0, import_cli_utils5.injectFileOptionsForCommander)(actualOptions4, [
+  "prompt",
+  "system"
+]).map((option) => (0, import_cli_utils5.stripOptionFieldsForCommander)(option));
+var parseOptions4 = (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 handler4 = async (...handlerArgs) => {
+  const { prompt, model, directory, tools, system } = parseOptions4(
+    await (0, import_cli_utils5.promptMissingOptions)(
+      actualOptions4,
+      await (0, import_cli_utils5.parseFileOptions)((0, import_cli_utils5.getOpt)(handlerArgs), ["prompt", "system"])
+    )
+  );
+  await createAndRunCodeAgent({
+    environment: (0, import_ai_code_agents6.createEnvironment)("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
+var import_ai_code_agents7 = require("ai-code-agents");
+var import_cli_utils6 = require("@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) => (0, import_cli_utils6.normalizeAbsolutePath)(value),
+    required: true
+  },
+  {
+    argname: "-t, --tools <tools>",
+    description: "Tools to allow the agent to use in the environment",
+    choices: import_ai_code_agents7.EnvironmentToolSafetyLevels,
+    defaults: "readonly"
+  },
+  {
+    argname: "-s, --system <system>",
+    description: "System instruction to guide the agent"
+  }
+];
+var options5 = (0, import_cli_utils6.injectFileOptionsForCommander)(actualOptions5, [
+  "prompt",
+  "system"
+]).map((option) => (0, import_cli_utils6.stripOptionFieldsForCommander)(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 (0, import_cli_utils6.promptMissingOptions)(
+      actualOptions5,
+      await (0, import_cli_utils6.parseFileOptions)((0, import_cli_utils6.getOpt)(handlerArgs), ["prompt", "system"])
+    )
+  );
+  await createAndRunCodeAgent({
+    environment: (0, import_ai_code_agents7.createEnvironment)("unsafe-local", {
+      directoryPath: directory
+    }),
+    environmentToolsDefinition: tools,
+    model,
+    prompt,
+    system,
+    directory
+  });
+};
 
 // src/cli.ts
 function initialize() {
   import_dotenv.default.config();
-  withOptions(import_extra_typings.program.command(name), options).description(description).action(withErrorHandling(handler));
+  (0, import_cli_utils7.withOptions)(import_extra_typings.program.command(name), options).description(description).action((0, import_cli_utils7.withErrorHandling)(handler));
+  (0, import_cli_utils7.withOptions)(import_extra_typings.program.command(name2), options2).description(description2).action((0, import_cli_utils7.withErrorHandling)(handler2));
+  (0, import_cli_utils7.withOptions)(
+    import_extra_typings.program.command(name3),
+    options3
+  ).description(description3).action((0, import_cli_utils7.withErrorHandling)(handler3));
+  (0, import_cli_utils7.withOptions)(
+    import_extra_typings.program.command(name4),
+    options4
+  ).description(description4).action((0, import_cli_utils7.withErrorHandling)(handler4));
+  (0, import_cli_utils7.withOptions)(
+    import_extra_typings.program.command(name5),
+    options5
+  ).description(description5).action((0, import_cli_utils7.withErrorHandling)(handler5));
 }
 function run() {
   import_extra_typings.program.parse();