@botconnector/bccli 0.1.0-beta.3 → 0.2.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BotConnector
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,58 @@
+# BCCLI
+
+Agent AI coding dari BotConnector yang bekerja di terminal: membaca kode, mengedit file,
+dan menjalankan perintah — dengan izin kamu.
+
+```bash
+npm i -g @botconnector/bccli@next    # v0.2 beta, butuh Node.js 22+
+bccli login                     # simpan API key BotConnector Cloud
+cd project-kamu && bccli
+```
+
+## Pemakaian
+
+| Perintah | Fungsi |
+|---|---|
+| `bccli` | mode interaktif |
+| `bccli -p "tugas"` | satu tugas tanpa interaksi (skrip/CI) |
+| `bccli -c` / `bccli -r` | lanjutkan sesi terakhir / pilih sesi |
+| `bccli -m provider/model` | pilih model |
+| `bccli models` | daftar model |
+
+Di dalam sesi: `/help`, `/model`, `/clear`, `/compact`, `/cost`, `/exit`.
+Shift+Tab ganti mode izin: `default` → `acceptEdits` → `plan` → `allowAll`.
+
+Mode `-p` tidak pernah bertanya: alat yang butuh izin ditolak, kecuali memakai
+`--allow-all` atau `--allowed-tools bash,edit,fetch`.
+
+## Provider lain (OpenAI-compatible)
+
+`~/.bccli/config.json`:
+
+```json
+{
+  "model": "openrouter/qwen/qwen3-coder",
+  "providers": {
+    "openrouter": { "baseURL": "https://openrouter.ai/api/v1", "apiKeyEnv": "OPENROUTER_API_KEY" },
+    "local": { "baseURL": "http://127.0.0.1:11434/v1" }
+  },
+  "allow": ["bash(npm test)"]
+}
+```
+
+`.bccli/config.json` di dalam project hanya boleh memilih `model` dan menambah provider baru tanpa API key —
+izin (`permissionMode`, `allow`) dan provider yang sudah ada hanya diatur dari `~/.bccli/config.json`,
+supaya repo yang kamu clone tidak bisa memberi dirinya izin penuh atau mencuri API key.
+
+Instruksi project dibaca dari `AGENTS.md` dan `BCCLI.md`.
+
+## Pengembangan
+
+```bash
+npm install
+npm test && npm run typecheck && npm run lint && npm run build
+```
+
+CI (`ci.yml`) menjalankan hal yang sama di Linux, macOS, dan Windows.
+Rilis: naikkan `version` di `package.json`, lalu push tag `v<version>` — `release.yml`
+menjalankan test, smoke test ke BotConnector Cloud, dan `npm publish --provenance`.

package/dist/chunk-SJH3YLW4.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+// src/session.ts
+import { randomBytes } from "crypto";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "fs";
+import { join } from "path";
+function projectDir(home, cwd) {
+  const slug = cwd.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(-100) || "root";
+  return join(home, "sessions", slug);
+}
+function repairTail(messages) {
+  const out = [...messages];
+  for (let i = out.length - 1; i >= 0; i--) {
+    const m = out[i];
+    if (m.role !== "assistant" || !m.tool_calls?.length) continue;
+    const answered = new Set(out.slice(i + 1).flatMap((x) => x.role === "tool" ? [x.tool_call_id] : []));
+    if (!m.tool_calls.every((c) => answered.has(c.id))) out.length = i;
+    break;
+  }
+  return out;
+}
+var Session = class _Session {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  static create(home, cwd, now = /* @__PURE__ */ new Date()) {
+    const dir = projectDir(home, cwd);
+    mkdirSync(dir, { recursive: true });
+    const stamp = now.toISOString().replace(/[:.]/g, "-");
+    return new _Session(join(dir, `${stamp}-${randomBytes(3).toString("hex")}.jsonl`));
+  }
+  static list(home, cwd) {
+    const dir = projectDir(home, cwd);
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+      const session = new _Session(join(dir, f));
+      const first = session.load().find((m) => m.role === "user");
+      return { session, mtime: statSync(session.file).mtime, preview: first ? String(first.content).slice(0, 80) : "" };
+    }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime() || b.session.file.localeCompare(a.session.file));
+  }
+  static latest(home, cwd) {
+    return _Session.list(home, cwd)[0]?.session;
+  }
+  write(record) {
+    appendFileSync(this.file, `${JSON.stringify(record)}
+`);
+  }
+  append(message) {
+    this.write({ t: "msg", m: message });
+  }
+  reset() {
+    this.write({ t: "reset" });
+  }
+  load() {
+    if (!existsSync(this.file)) return [];
+    let messages = [];
+    for (const line of readFileSync(this.file, "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      let record;
+      try {
+        record = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (record.t === "reset") messages = [];
+      else if (record.t === "msg") messages.push(record.m);
+    }
+    return repairTail(messages);
+  }
+};
+function pruneSessions(home, now = Date.now(), maxAgeDays = 30) {
+  const root = join(home, "sessions");
+  if (!existsSync(root)) return 0;
+  let removed = 0;
+  for (const project of readdirSync(root)) {
+    const dir = join(root, project);
+    for (const file of readdirSync(dir)) {
+      const path = join(dir, file);
+      if (now - statSync(path).mtimeMs > maxAgeDays * 864e5) {
+        rmSync(path);
+        removed++;
+      }
+    }
+  }
+  return removed;
+}
+
+export {
+  Session,
+  pruneSessions
+};

package/dist/chunk-WZYWKWPD.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+// src/print.ts
+function toolLabel(tool) {
+  return tool.charAt(0).toUpperCase() + tool.slice(1);
+}
+async function runPrint(rt, prompt, io = { out: process.stdout, err: process.stderr }) {
+  let failed = false;
+  let wroteText = false;
+  rt.agent.onEvent = (event) => {
+    switch (event.type) {
+      case "text":
+        io.out.write(event.delta);
+        wroteText = true;
+        break;
+      case "toolStart":
+        io.err.write(`\u23BF ${toolLabel(event.tool)}  ${event.target}
+`);
+        break;
+      case "toolEnd":
+        if (event.isError) io.err.write(`  \u2717 ${event.output.split("\n")[0]}
+`);
+        break;
+      case "stepLimit":
+        io.err.write("Batas langkah tercapai.\n");
+        failed = true;
+        break;
+      case "aborted":
+        io.err.write("Dibatalkan.\n");
+        failed = true;
+        break;
+      case "error":
+        io.err.write(`Error: ${event.message}
+`);
+        failed = true;
+        break;
+    }
+  };
+  rt.agent.askPermission = async (req) => {
+    io.err.write(`  Butuh izin untuk ${req.tool}. Jalankan dengan --allow-all atau --allowed-tools ${req.kind}.
+`);
+    return "no";
+  };
+  const controller = new AbortController();
+  const onSigint = () => controller.abort();
+  process.once("SIGINT", onSigint);
+  try {
+    await rt.agent.run(prompt, controller.signal);
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+  if (wroteText) io.out.write("\n");
+  return failed ? 1 : 0;
+}
+
+// src/permissions.ts
+import { isAbsolute, relative, resolve, sep } from "path";
+var MODE_ORDER = ["default", "acceptEdits", "plan", "allowAll"];
+function nextMode(mode) {
+  return MODE_ORDER[(MODE_ORDER.indexOf(mode) + 1) % MODE_ORDER.length];
+}
+var TWO_WORD = /* @__PURE__ */ new Set(["npm", "npx", "pnpm", "yarn", "bun", "git", "cargo", "go", "docker", "python", "python3", "uv", "make"]);
+function commandKey(segment) {
+  const words = segment.trim().split(/\s+/);
+  return TWO_WORD.has(words[0]) && words[1] ? `${words[0]} ${words[1]}` : words[0];
+}
+var Permissions = class {
+  constructor(mode, rules = [], cwd = process.cwd()) {
+    this.mode = mode;
+    this.cwd = cwd;
+    this.rules = new Set(rules);
+  }
+  mode;
+  cwd;
+  rules;
+  /** Edits may only be auto-allowed inside the project and outside .git. */
+  editInProject(target) {
+    const rel = relative(this.cwd, resolve(this.cwd, target));
+    if (!rel || rel.startsWith("..") || isAbsolute(rel)) return false;
+    return !rel.split(sep).includes(".git") && !rel.split("/").includes(".git");
+  }
+  /** Rules that "[a] allow for this session" would add; undefined when it must always be asked. */
+  rulesFor(req) {
+    if (req.kind === "edit") return this.editInProject(req.target) ? ["edit(project)"] : void 0;
+    if (req.kind === "fetch") {
+      try {
+        return [`fetch(${new URL(req.target).hostname})`];
+      } catch {
+        return void 0;
+      }
+    }
+    if (req.kind === "bash") {
+      if (/`|\$\(|[<>]|^\s*[({]/.test(req.target)) return void 0;
+      const segments = req.target.split(/&&|\|\||[;&|\n]/).map((s) => s.trim()).filter(Boolean);
+      if (!segments.length) return void 0;
+      return [...new Set(segments.map((s) => `bash(${commandKey(s)})`))];
+    }
+    return [];
+  }
+  check(req) {
+    if (req.kind === "read") return "allow";
+    if (this.mode === "allowAll") return "allow";
+    if (this.mode === "plan") return "deny";
+    if (this.rules.has(req.kind)) return "allow";
+    const needed = this.rulesFor(req);
+    if (!needed) return "ask";
+    if (req.kind === "edit" && this.mode === "acceptEdits") return "allow";
+    return needed.every((rule) => this.rules.has(rule)) ? "allow" : "ask";
+  }
+  allowForSession(req) {
+    for (const rule of this.rulesFor(req) ?? []) this.rules.add(rule);
+  }
+};
+
+// src/tools/ignore.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+function ignorePatterns(root) {
+  const patterns = ["**/node_modules/**", "**/.git/**"];
+  let lines = [];
+  try {
+    lines = readFileSync(join(root, ".gitignore"), "utf8").split(/\r?\n/);
+  } catch {
+    return patterns;
+  }
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || line.startsWith("!")) continue;
+    const p = line.replace(/^\//, "").replace(/\/$/, "");
+    patterns.push(`**/${p}`, `**/${p}/**`);
+  }
+  return patterns;
+}
+
+export {
+  MODE_ORDER,
+  nextMode,
+  Permissions,
+  toolLabel,
+  runPrint,
+  ignorePatterns
+};