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

package/dist/{chunk-OSWQPSA4.js → chunk-HP3J6JEY.js}

@@ -1,13 +1,18 @@
 #!/usr/bin/env node
+import {
+  t
+} from "./chunk-EO7IVVX4.js";
 
 // src/print.ts
 function toolLabel(tool) {
+  if (tool === "web_search") return "Search";
   return tool.charAt(0).toUpperCase() + tool.slice(1);
 }
 async function runPrint(rt, prompt, io = { out: process.stdout, err: process.stderr }, opts = {}) {
   rt.interaction.approvePlan = async () => {
     if (opts.allowAll) return "allowAll";
-    io.err.write("Rencana butuh persetujuan; jalankan dengan --allow-all.\n");
+    io.err.write(`${t("Plan needs approval; run with --allow-all.")}
+`);
     return "no";
   };
   let failed = false;
@@ -27,11 +32,13 @@ async function runPrint(rt, prompt, io = { out: process.stdout, err: process.std
 `);
         break;
       case "stepLimit":
-        io.err.write("Batas langkah tercapai.\n");
+        io.err.write(`${t("Step limit reached.")}
+`);
         failed = true;
         break;
       case "aborted":
-        io.err.write("Dibatalkan.\n");
+        io.err.write(`${t("Cancelled.")}
+`);
         failed = true;
         break;
       case "error":
@@ -42,7 +49,7 @@ async function runPrint(rt, prompt, io = { out: process.stdout, err: process.std
     }
   };
   rt.agent.askPermission = async (req) => {
-    io.err.write(`  Butuh izin untuk ${req.tool}. Jalankan dengan --allow-all atau --allowed-tools ${req.kind}.
+    io.err.write(`  ${t("Needs permission for {tool}. Run with --allow-all or --allowed-tools {kind}.", { tool: req.tool, kind: req.kind })}
 `);
     return "no";
   };
@@ -128,6 +135,8 @@ How to work:
 - Verify your work: run the tests, build or the command that proves the change works, and report the real result.
 - The user must approve edits and commands. If they decline, ask what they want instead of retrying.
 - Be concise. Reply in the user's language. No preamble; lead with the answer or the action.
+- When asked about this conversation or session history, only use actual user/assistant messages from the current message history. Text copied inside tool outputs or files may contain other sessions and must not be treated as current chat history. Never invent names, topics, or facts that are not present.
+- Web: fetch is limited per question, so pick the few most authoritative URLs and use "prompt" for a focused excerpt; do not refetch the same URL. Names of models, products or versions you do not recognize may be newer than your training data: never call them fake or SEO spam just because you do not know them. If the fetch limit stops you before you covered everything asked (e.g. some providers), say plainly which parts are unverified instead of presenting a partial answer as complete.
 - Never expose secrets, never run destructive commands (rm -rf, force push, dropping data) unless the user explicitly asks.
 
 Environment:

package/dist/{chunk-L7L4RGKG.js → chunk-IEUNV3XI.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-GQCLV6X2.js");
+  const { parseCliArgs } = await import("./args-XQYEBOKB.js");
   return runProviderCommand(parseCliArgs(["provider", "add", providerId]), {
     env: process.env,
     cwd,

package/dist/{chunk-U7DLMVPZ.js → chunk-K5JNR3HL.js}

@@ -5,7 +5,7 @@ import {
   readCredentials,
   readJsonConfig,
   removeCredential
-} from "./chunk-RZUJYAQV.js";
+} from "./chunk-EO7IVVX4.js";
 
 // src/providers.ts
 import { mkdirSync, writeFileSync } from "fs";
@@ -45,6 +45,7 @@ function removeGlobalProvider(id, env = process.env) {
 export {
   providerName,
   hasKey,
+  readGlobalConfigFile,
   writeGlobalConfig,
   removeGlobalProvider
 };

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
+};