@botconnector/bccli 0.4.0-beta.2 → 0.4.0-beta.21

package/dist/chunk-ON6JYPE7.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import {
+  MODE_ORDER
+} from "./chunk-ELML4KVQ.js";
+import {
+  REASONING_LEVELS,
+  isReasoningLevel
+} from "./chunk-SN3ODJZN.js";
+import {
+  ConfigError,
+  parseLang,
+  t
+} from "./chunk-EO7IVVX4.js";
+
+// src/args.ts
+import { parseArgs } from "util";
+var HELP = `BCCLI \u2014 BotConnector's AI coding agent for the terminal
+
+Usage:
+  bccli [task]                  interactive mode (optionally start with a task)
+  bccli -p "task"               run one task without interaction (scripts/CI)
+  bccli login [provider]        save an API key (default: bc-cloud)
+  bccli models                  list models from the active provider
+  bccli provider list|add <id>|remove <id>   manage providers (custom: --url <url> [--name N] [--key-env ENV])
+  bccli mcp list|add <name>|remove <name>    manage MCP servers (catalog, or --url <url>)
+  bccli integrations             show the status of external agent integrations
+  bccli connect <agent>          opencode, aider, cline, dsh, codex, claude-code, cursor, openai-cli, openai-sdk, openai-compatible
+  bccli disconnect <agent>       remove an integration and restore the previous config
+
+Options:
+  -m, --model <provider/model>  choose a model, e.g. bc-cloud/glm-5.3-flash
+      --reasoning <level>        auto | off | low | medium | high | max
+  -c, --continue                continue the last session in this folder
+  -r, --resume                  pick a session to continue
+      --allow-all               run all tools without asking for permission
+      --allowed-tools <a,b>     tools allowed without asking: bash, edit, fetch
+      --permission-mode <mode>  default | acceptEdits | plan | allowAll
+      --lang <en|id>            interface language (default: en; or BCCLI_LANG, or "language" in config)
+  -v, --version                 version
+  -h, --help                    this help`;
+var helpText = () => t(HELP);
+function parseCliArgs(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      print: { type: "boolean", short: "p" },
+      model: { type: "string", short: "m" },
+      reasoning: { type: "string" },
+      lang: { type: "string" },
+      continue: { type: "boolean", short: "c" },
+      resume: { type: "boolean", short: "r" },
+      "allow-all": { type: "boolean" },
+      "allowed-tools": { type: "string" },
+      "permission-mode": { type: "string" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" },
+      url: { type: "string" },
+      name: { type: "string" },
+      "key-env": { type: "string" },
+      value: { type: "string", multiple: true }
+    }
+  });
+  const reasoning = values.reasoning;
+  if (reasoning && !isReasoningLevel(reasoning)) {
+    throw new ConfigError(t("--reasoning must be one of: {levels}", { levels: REASONING_LEVELS.join(", ") }));
+  }
+  const mode = values["permission-mode"];
+  if (mode && !MODE_ORDER.includes(mode)) {
+    throw new ConfigError(t("--permission-mode must be one of: {modes}", { modes: MODE_ORDER.join(", ") }));
+  }
+  if (values.lang !== void 0 && !parseLang(values.lang)) throw new ConfigError(t("--lang must be one of: en, id"));
+  const [first, ...rest] = positionals;
+  const SUBCOMMANDS = ["login", "models", "provider", "mcp", "connect", "disconnect", "integrations"];
+  const command = SUBCOMMANDS.includes(first) ? first : "run";
+  const words = command === "run" ? positionals : rest;
+  return {
+    command,
+    prompt: command === "run" && words.length ? words.join(" ") : void 0,
+    print: !!values.print,
+    model: values.model,
+    reasoning,
+    lang: parseLang(values.lang),
+    continue: !!values.continue,
+    resume: !!values.resume,
+    allowAll: !!values["allow-all"],
+    allowedTools: (values["allowed-tools"] ?? "").split(",").map((s) => s.trim()).filter(Boolean),
+    permissionMode: mode,
+    help: !!values.help,
+    version: !!values.version,
+    loginProvider: command === "login" ? rest[0] ?? "bc-cloud" : void 0,
+    subArgs: ["provider", "mcp", "connect", "disconnect", "integrations"].includes(command) ? rest : [],
+    url: values.url,
+    name: values.name,
+    keyEnv: values["key-env"],
+    values: values.value ?? []
+  };
+}
+
+export {
+  helpText,
+  parseCliArgs
+};

package/dist/chunk-SN3ODJZN.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import {
+  t
+} from "./chunk-EO7IVVX4.js";
+
+// src/reasoning.ts
+var REASONING_LEVELS = ["auto", "off", "low", "medium", "high", "max"];
+var OPENAI_LEVELS = ["auto", "low", "medium", "high"];
+var BOTCONNECTOR_LEVELS = REASONING_LEVELS;
+function isReasoningLevel(value) {
+  return REASONING_LEVELS.includes(value);
+}
+function parseReasoningLevel(value, label = "reasoning") {
+  if (!isReasoningLevel(value)) {
+    throw new Error(t("{label} must be one of: {levels}", { label, levels: REASONING_LEVELS.join(", ") }));
+  }
+  return value;
+}
+function reasoningCapability(providerId) {
+  switch (providerId) {
+    case "bc-cloud":
+      return { levels: BOTCONNECTOR_LEVELS, parameter: "reasoning_effort" };
+    case "openai":
+      return { levels: OPENAI_LEVELS, parameter: "reasoning_effort" };
+    case "openrouter":
+      return { levels: ["auto", "low", "medium", "high"], parameter: "reasoning" };
+    default:
+      return void 0;
+  }
+}
+function supportedReasoningLevels(providerId) {
+  return reasoningCapability(providerId)?.levels ?? ["auto"];
+}
+function assertReasoningSupported(providerId, level) {
+  if (level === "auto") return;
+  const capability = reasoningCapability(providerId);
+  if (!capability) {
+    throw new Error(t("This provider has no manual reasoning setting yet. Use Auto."));
+  }
+  if (!capability.levels.includes(level)) {
+    const supported = capability.levels.filter((x) => x !== "auto").map(capitalize).join("/");
+    throw new Error(t("This model/provider does not support reasoning level '{level}'. Use Auto{supported}.", { level, supported: supported ? `/${supported}` : "" }));
+  }
+}
+function reasoningPayload(providerId, level) {
+  if (level === "auto") return {};
+  assertReasoningSupported(providerId, level);
+  const capability = reasoningCapability(providerId);
+  if (capability.parameter === "reasoning") return { reasoning: { effort: level } };
+  return { reasoning_effort: level };
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+export {
+  REASONING_LEVELS,
+  isReasoningLevel,
+  parseReasoningLevel,
+  supportedReasoningLevels,
+  assertReasoningSupported,
+  reasoningPayload
+};

package/dist/{chunk-L7L4RGKG.js → chunk-VNIUYPVN.js}

@@ -35,8 +35,8 @@ function readSecret(prompt) {
   });
 }
 async function runLogin(providerId, cwd) {
-  const { runProviderCommand } = await import("./providerCli-G3X7KENO.js");
-  const { parseCliArgs } = await import("./args-FCLPQ7TO.js");
+  const { runProviderCommand } = await import("./providerCli-6FXMBKQL.js");
+  const { parseCliArgs } = await import("./args-XQYEBOKB.js");
   return runProviderCommand(parseCliArgs(["provider", "add", providerId]), {
     env: process.env,
     cwd,