bjir-cli 0.1.0

package/README.md

@@ -0,0 +1,129 @@
+<h1 align="center">BJiR</h1>
+
+<p align="center">A token-lean AI coding agent for the terminal.</p>
+
+<p align="center"><b>One obsession: do the same work for far fewer tokens.</b></p>
+
+<p align="center">
+  <a href="README.md">English</a> |
+  <a href="README.id.md">Bahasa Indonesia</a>
+</p>
+
+---
+
+## What is BJiR?
+
+BJiR is an AI coding agent you run in your terminal. It reads and edits code, runs commands, and talks to a model (Claude, GPT, Gemini, MiMo, local models).
+
+The difference is token usage. Every request is trimmed, every reply is steered to be terse, and noisy tool output (test logs, big JSON, `git status`) is compressed before it reaches the model. These optimizations are compiled in and always on, so you save without configuring anything. Less context in and less text out means lower cost, faster replies, and longer sessions.
+
+## Install
+
+### npm (recommended)
+
+```bash
+npm i -g bjir          # or: bun add -g bjir / pnpm add -g bjir / yarn global add bjir
+bjir                   # launch
+```
+
+### From source
+
+```bash
+git clone https://github.com/gogetrekt/bjir
+cd bjir
+bun install
+./bin/bjir.sh
+```
+
+To run `bjir` from anywhere on a source checkout, symlink it onto your PATH:
+
+```bash
+ln -s "$PWD/bin/bjir.sh" ~/.local/bin/bjir
+```
+
+### API key
+
+BJiR needs a model provider. Launch `bjir`, open the provider dialog, and add one (OpenAI-compatible, Anthropic-compatible, or a preset). Name, base URL, key, and models are saved and persist across restarts.
+
+## Quick start
+
+Run `bjir` (just `bjir`) to open the interactive TUI:
+
+```bash
+bjir                       # open the TUI in the current directory
+bjir /path/to/project      # open the TUI in a specific project
+bjir run "summarize today's changes"   # one-shot, non-interactive
+bjir gain                  # show tokens saved
+```
+
+In the TUI: type to chat, press `Tab` to switch between the build agent (full access) and the plan agent (read-only), run `/reducer` to change optimization intensity, and watch the sidebar for a live tokens-saved counter.
+
+## Optimizations
+
+Built into the binary, always on. Nothing to configure.
+
+| Optimization | What it does |
+| --- | --- |
+| Ponytail | Code-minimalism rules. The agent writes the smallest correct change, so replies and diffs stay small. |
+| Caveman | Response-style rules that make the model answer tersely. The biggest cut to output tokens. Three intensity levels (see `/reducer`). |
+| I/O Refiner | Trims the assembled prompt right before it is sent, cutting input tokens. |
+| Context Prune | Drops stale history each turn so old context stops costing tokens. |
+| Read Dedup | Skips re-sending a file that was already read. |
+| Semantic Read | Returns only the relevant parts of a file when that is enough. |
+| Tool-output compression | Big tool results are compressed by type: SmartCrusher for large JSON, Log Compressor for build and shell logs, and CCR, which stashes the full output and lets the agent pull back any part on demand. Lossless or skipped. |
+| RTK | Wraps shell commands (`git`, `cargo`, `npm`, `bun`, `docker`) so their output is compressed before the agent sees it. |
+| BJiR Gateway | A local OpenAI-compatible gateway that routes across providers with automatic fallback and meters token usage. |
+
+### Intensity
+
+Caveman has three levels: `lite`, `standard`, `ultra`. Switch live in the TUI with `/reducer` (also `/caveman`, `/ponytail`); it applies on your next message. From the CLI, `bjir profile [explain|balanced|ultra]` sets a persistent profile. Set `BJIR_OPTIMIZE=0` to turn the layer off.
+
+## Savings
+
+```bash
+bjir gain              # ranked table of tokens saved
+bjir gain --json       # machine-readable
+bjir gain --reset      # clear history
+```
+
+Numbers come from real session data. The TUI sidebar shows a running total.
+
+## Commands
+
+Run `bjir <command> --help` for options.
+
+| Command | Description |
+| --- | --- |
+| `bjir` | Launch the interactive TUI (default). |
+| `bjir run "<prompt>"` | One-shot, non-interactive run. |
+| `bjir serve` | Run the headless HTTP API server. |
+| `bjir attach` | Connect to a running server. |
+| `bjir gain` | Show the token-savings summary. |
+| `bjir compress` | Caveman-compress memory files (`CLAUDE.md`, `AGENTS.md`, `.opencode/memory.md`). |
+| `bjir profile [name]` | Show or switch the optimization profile. |
+| `bjir gateway` | Start the BJiR Gateway (usually automatic). |
+| `bjir models` | List available models. |
+| `bjir providers` | Manage providers and credentials. |
+| `bjir revoke [id]` | Remove a connected provider. |
+| `bjir agent` | Create and manage agents. |
+| `bjir mcp` | Manage MCP servers. |
+| `bjir github` | Set up and run the GitHub agent. |
+| `bjir upgrade` | Update to the latest version. |
+| `bjir uninstall` | Uninstall BJiR. |
+
+## Configuration
+
+BJiR reads config from `~/.config/opencode/opencode.json` (seeded on first run) and a project-local `opencode.json` or `.opencode/opencode.json`. Providers added through the connect dialog are written here. Built-in optimizations are not config; tune them with `/reducer`, `bjir profile`, and `BJIR_*` environment variables.
+
+## Agents
+
+Switch with `Tab`:
+
+- build: full-access agent for writing and changing code.
+- plan: read-only, denies edits and asks before running commands.
+
+Invoke the general subagent for complex searches with `@general`.
+
+## License
+
+MIT. BJiR is a fork of [opencode](https://github.com/anomalyco/opencode) and is not affiliated with or endorsed by the opencode team.

package/bin/bjir.cjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+// bjir launcher — find binary, start gateway if needed, run agent.
+const childProcess = require("child_process")
+const fs = require("fs")
+const path = require("path")
+const os = require("os")
+const http = require("http")
+
+const platformMap = { darwin: "darwin", linux: "linux", win32: "windows" }
+const archMap = { x64: "x64", arm64: "arm64", arm: "arm" }
+const platform = platformMap[os.platform()] || os.platform()
+const arch = archMap[os.arch()] || os.arch()
+const base = "bjir-" + platform + "-" + arch
+const binName = platform === "windows" ? "bjir.exe" : "bjir"
+const names = [base, base + "-baseline", base + "-musl", base + "-baseline-musl"]
+
+function findBinary(startDir) {
+  let current = startDir
+  for (;;) {
+    const modules = path.join(current, "node_modules")
+    if (fs.existsSync(modules)) {
+      for (const name of names) {
+        const candidate = path.join(modules, name, "bin", binName)
+        if (fs.existsSync(candidate)) return candidate
+      }
+    }
+    const parent = path.dirname(current)
+    if (parent === current) return
+    current = parent
+  }
+}
+
+const binary = process.env.BJIR_BIN_PATH || findBinary(path.dirname(fs.realpathSync(__filename)))
+if (!binary) {
+  console.error("bjir: could not find the platform binary (" + names.join(" / ") + "). Reinstall `bjir`.")
+  process.exit(1)
+}
+
+const PORT = Number(process.env.BJIR_GATEWAY_PORT || 9090)
+const args = process.argv.slice(2)
+
+// `bjir gateway ...` -> run the gateway directly (no wrapper orchestration).
+if (args[0] === "gateway") {
+  childProcess.spawn(binary, args, { stdio: "inherit" }).on("exit", (c) => process.exit(c || 0))
+  return
+}
+
+// Ensure a default config exists (never clobber an existing one).
+try {
+  const cfgDir = path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "opencode")
+  const cfg = path.join(cfgDir, "opencode.json")
+  const def = path.join(__dirname, "..", "share", "opencode.json")
+  if (!fs.existsSync(cfg) && fs.existsSync(def)) {
+    fs.mkdirSync(cfgDir, { recursive: true })
+    fs.copyFileSync(def, cfg)
+  }
+} catch {}
+
+function health(cb) {
+  const req = http.get({ host: "localhost", port: PORT, path: "/health", timeout: 500 }, (res) => {
+    res.resume()
+    cb(res.statusCode === 200)
+  })
+  req.on("error", () => cb(false))
+  req.on("timeout", () => {
+    req.destroy()
+    cb(false)
+  })
+}
+
+function startAgent(routerProc) {
+  // Bare launch (no subcommand) -> open the TUI in the user's cwd.
+  const passed = args.length === 0 ? [process.cwd()] : args
+  const child = childProcess.spawn(binary, passed, { stdio: "inherit" })
+  const cleanup = () => {
+    if (routerProc) try { routerProc.kill() } catch {}
+  }
+  for (const s of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(s, () => { try { child.kill(s) } catch {} })
+  child.on("exit", (code, signal) => {
+    cleanup()
+    if (signal) return process.kill(process.pid, signal)
+    process.exit(typeof code === "number" ? code : 0)
+  })
+}
+
+health((up) => {
+  if (up) return startAgent(null)
+  const router = childProcess.spawn(binary, ["gateway"], { stdio: "ignore", detached: false })
+  let waited = 0
+  const tick = () =>
+    health((ok) => {
+      if (ok || waited >= 6000) return startAgent(router)
+      waited += 250
+      setTimeout(tick, 250)
+    })
+  setTimeout(tick, 250)
+})

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "bjir-cli",
+  "version": "0.1.0",
+  "description": "BJiR: Bloat Judgement & I/O Refiner, a token-lean AI coding agent for the terminal.",
+  "license": "MIT",
+  "homepage": "https://github.com/gogetrekt/bjir",
+  "repository": { "type": "git", "url": "git+https://github.com/gogetrekt/bjir.git" },
+  "keywords": ["ai", "agent", "cli", "tui", "coding", "tokens", "llm", "terminal"],
+  "bin": { "bjir": "./bin/bjir.cjs" },
+  "files": ["bin", "scripts", "share", "vendor"],
+  "scripts": { "postinstall": "node scripts/postinstall.cjs" },
+  "optionalDependencies": {
+    "bjir-linux-x64": "0.1.0",
+    "bjir-linux-x64-baseline": "0.1.0",
+    "bjir-linux-x64-musl": "0.1.0",
+    "bjir-linux-x64-baseline-musl": "0.1.0",
+    "bjir-linux-arm64": "0.1.0",
+    "bjir-linux-arm64-musl": "0.1.0",
+    "bjir-darwin-arm64": "0.1.0",
+    "bjir-darwin-x64": "0.1.0",
+    "bjir-darwin-x64-baseline": "0.1.0",
+    "bjir-windows-x64": "0.1.0",
+    "bjir-windows-x64-baseline": "0.1.0",
+    "bjir-windows-arm64": "0.1.0"
+  },
+  "preferUnplugged": true
+}

package/scripts/postinstall.cjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/**
+ * bjir postinstall — copy the matching rtk binary to ~/.bjir/bin/rtk so the bash
+ * tool finds it (shell-output compression). Best-effort: never fails install.
+ * The default opencode config is written on first run by the launcher.
+ */
+const fs = require("fs")
+const path = require("path")
+const os = require("os")
+
+try {
+  const platformMap = { darwin: "darwin", linux: "linux", win32: "windows" }
+  const platform = platformMap[os.platform()] || os.platform()
+  const arch = os.arch() === "arm64" ? "arm64" : "x64"
+  const ext = platform === "windows" ? ".exe" : ""
+  const src = path.join(__dirname, "..", "vendor", "rtk", `rtk-${platform}-${arch}${ext}`)
+  if (!fs.existsSync(src)) {
+    console.warn(`[bjir] no bundled rtk for ${platform}-${arch}; shell compression disabled until rtk is on PATH`)
+    return
+  }
+  const destDir = path.join(os.homedir(), ".bjir", "bin")
+  const dest = path.join(destDir, `rtk${ext}`)
+  fs.mkdirSync(destDir, { recursive: true })
+  fs.copyFileSync(src, dest)
+  if (platform !== "windows") fs.chmodSync(dest, 0o755)
+  console.log(`[bjir] rtk installed -> ${dest}`)
+} catch (e) {
+  console.warn(`[bjir] postinstall skipped: ${e && e.message ? e.message : e}`)
+}

package/share/opencode.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "bjir-gw": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "BJiR Gateway",
+      "options": { "baseURL": "http://localhost:9090/v1", "apiKey": "local" },
+      "models": {
+        "auto": { "name": "auto" },
+        "claude-sonnet-4-6": { "name": "Claude Sonnet 4.6" },
+        "gpt-4o": { "name": "GPT-4o" },
+        "gemini/gemini-2.0-flash": { "name": "Gemini 2.0 Flash" },
+        "ollama:qwen2.5-coder": { "name": "Qwen2.5 Coder (Ollama)" }
+      }
+    }
+  },
+  "model": "bjir-gw/auto",
+  "lsp": true,
+  "reducer": "standard"
+}