@ziamana/bruine 0.1.0

package/dist/plugins/silence.js

@@ -0,0 +1,234 @@
+// src/plugins/silence.ts
+import { existsSync as existsSync2, readFileSync, statSync } from "fs";
+import { join } from "path";
+import { parse as parseYaml } from "yaml";
+
+// src/compat.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+function appEnv(suffix, env = process.env) {
+  return env[`BRUINE_${suffix}`] ?? env[`KUMO_${suffix}`];
+}
+function appHome(env = process.env, userHome = homedir(), pathMod = path, exists = existsSync) {
+  const explicit = appEnv("HOME", env);
+  if (explicit !== void 0) return explicit;
+  const current = pathMod.join(userHome, ".bruine");
+  const legacy = pathMod.join(userHome, ".kumo");
+  return exists(current) ? current : exists(legacy) ? legacy : current;
+}
+function runtimeHome(env = process.env, pathMod = path) {
+  return appEnv("HOME", env) ?? env.DSH_HOME ?? appHome(env, homedir(), pathMod);
+}
+
+// src/llm/silence.ts
+var STREAM_CEILING_MS = 15 * 60 * 1e3;
+var SECOND = 1e3;
+var MINUTE = 60 * SECOND;
+var PHASE_BUDGET_MS = {
+  waiting: 2 * MINUTE,
+  thinking: 90 * SECOND,
+  preparing: 3 * MINUTE,
+  answering: 60 * SECOND,
+  calling: 2 * MINUTE
+};
+var PER_THOUSAND_CHARS_MS = 6 * SECOND;
+var MAX_SIZE_BONUS_MS = 10 * MINUTE;
+var MIN_BUDGET_MS = 20 * SECOND;
+function effortFactor(effort) {
+  switch (effort) {
+    case "high":
+      return 1.5;
+    case "xhigh":
+      return 2;
+    case "max":
+      return 2.5;
+    default:
+      return 1;
+  }
+}
+function silenceBudget(state, ceiling, scale = 1) {
+  let base = PHASE_BUDGET_MS[state.phase];
+  if (state.phase === "calling") base += Math.min(MAX_SIZE_BONUS_MS, state.toolChars / 1e3 * PER_THOUSAND_CHARS_MS);
+  const grown = base * effortFactor(state.effort) * 2 ** Math.max(0, state.retry);
+  const learned = state.survived * 1.5;
+  const budget = Math.max(grown * scale, learned, MIN_BUDGET_MS * scale);
+  return Math.max(1, Math.min(budget, ceiling));
+}
+function advance(state, chunk) {
+  switch (chunk.type) {
+    case "reasoning-delta":
+      return { ...state, phase: "thinking" };
+    case "text-delta":
+      return { ...state, phase: "answering" };
+    case "tool-call-delta": {
+      const fresh = chunk.name !== void 0 && chunk.name !== state.tool;
+      return {
+        ...state,
+        phase: "calling",
+        tool: chunk.name ?? state.tool,
+        toolChars: (fresh ? 0 : state.toolChars) + (chunk.argumentsDelta?.length ?? 0)
+      };
+    }
+    case "block-end":
+      return chunk.block?.type === "reasoning" ? { ...state, phase: "preparing" } : state;
+    default:
+      return state;
+  }
+}
+function formatSilence(ms) {
+  const s = Math.round(ms / 1e3);
+  if (s < 60) return `${String(s)}s`;
+  const m = Math.floor(s / 60);
+  const rest = s % 60;
+  return rest === 0 ? `${String(m)}m` : `${String(m)}m ${String(rest)}s`;
+}
+var SILENCE_FAILURE_CODE = "TIMEOUT";
+function silenceFinish(quietMs) {
+  return {
+    type: "finish",
+    reason: {
+      kind: "error",
+      failure: { code: SILENCE_FAILURE_CODE, message: `no answer from the model for ${formatSilence(quietMs)}`, silenceMs: quietMs }
+    }
+  };
+}
+async function* watchSilence(source, opts) {
+  const now = opts.now ?? Date.now;
+  const iterator = source[Symbol.asyncIterator]();
+  let state = opts.start;
+  let quietSince = now();
+  let done = false;
+  try {
+    while (true) {
+      const budget = opts.budget(state);
+      opts.onState?.(state, quietSince, budget);
+      const left = Math.max(0, quietSince + budget - now());
+      let timer;
+      const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve("timeout"), left);
+      });
+      const next = iterator.next();
+      let result;
+      try {
+        result = await Promise.race([next, timeout]);
+      } finally {
+        if (timer !== void 0) clearTimeout(timer);
+      }
+      if (result === "timeout") {
+        const quiet2 = now() - quietSince;
+        opts.onGiveUp?.(quiet2, state);
+        next.catch(() => void 0);
+        void Promise.resolve(iterator.return?.(void 0)).catch(() => void 0);
+        done = true;
+        yield silenceFinish(quiet2);
+        return;
+      }
+      if (result.done === true) {
+        done = true;
+        return;
+      }
+      const at = now();
+      const quiet = at - quietSince;
+      if (quiet >= 1e3) opts.onResumed?.(quiet);
+      quietSince = at;
+      state = advance(state, result.value);
+      yield result.value;
+    }
+  } finally {
+    if (!done) await Promise.resolve(iterator.return?.(void 0)).catch(() => void 0);
+  }
+}
+
+// src/shared-state.ts
+function sharedState(key, init) {
+  const store = globalThis;
+  const id = /* @__PURE__ */ Symbol.for(`bruine.${key}`);
+  return store[id] ??= init();
+}
+
+// src/ui/rain.ts
+var effortState = sharedState("effort", () => ({ level: 0.45, effort: void 0 }));
+function currentEffortName() {
+  return effortState.effort;
+}
+
+// src/plugins/silence.ts
+var name = "bruine-silence";
+var BRUINE_SILENCE_SERVICE = "bruineSilence";
+var ADAPTER_DEFAULT_CEILING_MS = 3e5;
+function ceilingReader(home) {
+  let cache;
+  return (provider) => {
+    try {
+      const file = join(home(), "settings.yaml");
+      if (!existsSync2(file)) return ADAPTER_DEFAULT_CEILING_MS;
+      const mtime = statSync(file).mtimeMs;
+      if (cache?.mtime !== mtime) cache = { mtime, doc: parseYaml(readFileSync(file, "utf8")) };
+      const doc = cache.doc;
+      const value = provider === void 0 ? void 0 : doc?.["llm-pi-ai"]?.providers?.[provider]?.streamIdleTimeoutMs ?? doc?.["llm-deepseek"]?.streamIdleTimeoutMs;
+      return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : ADAPTER_DEFAULT_CEILING_MS;
+    } catch {
+      return ADAPTER_DEFAULT_CEILING_MS;
+    }
+  };
+}
+function apply(ctx) {
+  const enabled = appEnv("SILENCE") !== "off";
+  const scale = Number(appEnv("SILENCE_SCALE") ?? "1");
+  const factor = Number.isFinite(scale) && scale > 0 ? scale : 1;
+  const ceilingOf = ceilingReader(() => runtimeHome());
+  const retries = /* @__PURE__ */ new Map();
+  const readings = /* @__PURE__ */ new Map();
+  let survived = 0;
+  const service = {
+    reading: (sessionId) => sessionId === void 0 ? void 0 : readings.get(sessionId)
+  };
+  ctx.provide(BRUINE_SILENCE_SERVICE, service);
+  ctx.on("session/event", (session, event) => {
+    const id = session?.id === void 0 ? void 0 : String(session.id);
+    if (id === void 0) return;
+    if (event.type === "llm/retry" && typeof event.data?.retry === "number") retries.set(id, event.data.retry);
+    else if (event.type === "step/start" || event.type === "turn/end") retries.delete(id);
+  });
+  if (!enabled) return;
+  ctx.on(
+    "llm/stream",
+    (options, next) => {
+      const source = next();
+      const id = options.sessionId === void 0 ? void 0 : String(options.sessionId);
+      const ceiling = ceilingOf(options.provider);
+      const start = {
+        phase: "waiting",
+        toolChars: 0,
+        effort: options.reasoningEffort ?? currentEffortName(),
+        retry: id === void 0 ? 0 : retries.get(id) ?? 0,
+        survived
+      };
+      const watched = watchSilence(source, {
+        start,
+        budget: (state) => silenceBudget({ ...state, survived }, ceiling, factor),
+        onState: (state, quietSince, budget) => {
+          if (id !== void 0) readings.set(id, { quietSince, budget, state });
+        },
+        onResumed: (quiet) => {
+          survived = Math.max(survived, quiet);
+        }
+      });
+      return (async function* () {
+        try {
+          yield* watched;
+        } finally {
+          if (id !== void 0) readings.delete(id);
+        }
+      })();
+    },
+    { global: true }
+  );
+}
+export {
+  ADAPTER_DEFAULT_CEILING_MS,
+  BRUINE_SILENCE_SERVICE,
+  apply,
+  name
+};

package/dist/plugins/startup.js

@@ -0,0 +1,42 @@
+// src/plugins/startup.ts
+import { Command } from "commander";
+import { parseCmdline } from "@deepseek-ai/dsh-cmdline";
+var name = "bruine-startup";
+var inject = ["cmdlineArgs"];
+var BRUINE_STARTUP_SERVICE = "bruineStartup";
+function bruineCommand() {
+  const program = new Command().name("bruine").description(
+    "Interactive terminal agent. Type a message and press Enter; /exit or Ctrl+D quits."
+  ).helpOption("-h, --help", "show this help").option("-p, --print <task>", "run a task and exit", (value, previous) => [...previous, value], []).option("-f, --output-format <format>", "headless output: text, json, or stream-json", "text").argument("[prompt...]", "optional first prompt, sent before the loop starts").addHelpText(
+    "after",
+    `
+Examples:
+  bruine                     start an interactive session
+  bruine "fix the tests"     start and send a first prompt
+`
+  );
+  return program;
+}
+function apply(ctx) {
+  const program = bruineCommand();
+  program.action(() => {
+    const options = program.opts();
+    if (options.print.length > 0) {
+      if (!["text", "json", "stream-json"].includes(options.outputFormat)) {
+        throw new Error("--output-format must be one of: text, json, stream-json");
+      }
+      ctx.provide(BRUINE_STARTUP_SERVICE, { headless: { prompts: options.print, format: options.outputFormat } });
+      return;
+    }
+    const prompt = program.args.join(" ").trim();
+    const startup = prompt === "" ? {} : { initialPrompt: prompt };
+    ctx.provide(BRUINE_STARTUP_SERVICE, startup);
+  });
+  parseCmdline(ctx, program);
+}
+export {
+  BRUINE_STARTUP_SERVICE,
+  apply,
+  inject,
+  name
+};

package/dist/plugins/web-search.js

@@ -0,0 +1,138 @@
+// src/compat.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+function appEnv(suffix, env = process.env) {
+  return env[`BRUINE_${suffix}`] ?? env[`KUMO_${suffix}`];
+}
+function appHome(env = process.env, userHome = homedir(), pathMod = path, exists = existsSync) {
+  const explicit = appEnv("HOME", env);
+  if (explicit !== void 0) return explicit;
+  const current = pathMod.join(userHome, ".bruine");
+  const legacy = pathMod.join(userHome, ".kumo");
+  return exists(current) ? current : exists(legacy) ? legacy : current;
+}
+function runtimeHome(env = process.env, pathMod = path) {
+  return appEnv("HOME", env) ?? env.DSH_HOME ?? appHome(env, homedir(), pathMod);
+}
+function compatReadPath(currentPath, legacyPath) {
+  return existsSync(currentPath) || !existsSync(legacyPath) ? currentPath : legacyPath;
+}
+function configWritePath(home) {
+  return path.join(home, "bruine.json");
+}
+function configReadPath(home) {
+  return compatReadPath(configWritePath(home), path.join(home, "kumo.json"));
+}
+
+// src/plugins/web-search.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+var name = "bruine-web-search";
+var BRUINE_SEARCH_SERVICE = "bruineSearch";
+function readSearchConfig(env = process.env, read = (p) => readFileSync(p, "utf8"), has = existsSync2) {
+  const home = runtimeHome(env);
+  const path2 = configReadPath(home);
+  try {
+    if (!has(path2)) return { provider: "none" };
+    const raw = JSON.parse(read(path2));
+    const s = raw?.search;
+    if (s !== void 0 && typeof s.provider === "string" && s.provider !== "none") {
+      return s;
+    }
+  } catch {
+  }
+  return { provider: "none" };
+}
+function clip(sources, max) {
+  if (max === void 0 || sources.length <= max) {
+    return { sources, truncated: false };
+  }
+  return { sources: sources.slice(0, max), truncated: true };
+}
+function makeSearchProvider(cfg, env, doFetch) {
+  return {
+    id: "bruine",
+    available() {
+      if (cfg.provider === "none") return false;
+      if (cfg.provider === "searxng") return cfg.url !== void 0 && cfg.url !== "";
+      const key = cfg.apiKeyEnv ?? "";
+      return env[key] !== void 0 && env[key] !== "";
+    },
+    async search(request, signal) {
+      const q = encodeURIComponent(request.query);
+      if (cfg.provider === "searxng") {
+        const res = await doFetch(`${(cfg.url ?? "").replace(/\/+$/, "")}/search?q=${q}&format=json`, { signal });
+        if (!res.ok) throw new Error(`searxng: HTTP ${res.status}`);
+        const body = await res.json();
+        const sources = (body?.results ?? []).map((r) => ({
+          url: String(r.url),
+          title: r.title === void 0 ? void 0 : String(r.title),
+          snippet: r.content === void 0 ? void 0 : String(r.content)
+        }));
+        return clip(sources, request.maxResults);
+      }
+      if (cfg.provider === "brave") {
+        const key = env[cfg.apiKeyEnv ?? "BRAVE_API_KEY"] ?? "";
+        const res = await doFetch(
+          `https://api.search.brave.com/res/v1/web/search?q=${q}${request.maxResults !== void 0 ? `&count=${request.maxResults}` : ""}`,
+          { signal, headers: { "X-Subscription-Token": key, Accept: "application/json" } }
+        );
+        if (!res.ok) throw new Error(`brave: HTTP ${res.status}`);
+        const body = await res.json();
+        const sources = (body?.web?.results ?? []).map((r) => ({
+          url: String(r.url),
+          title: r.title === void 0 ? void 0 : String(r.title),
+          snippet: r.description === void 0 ? void 0 : String(r.description)
+        }));
+        return clip(sources, request.maxResults);
+      }
+      if (cfg.provider === "tavily") {
+        const key = env[cfg.apiKeyEnv ?? "TAVILY_API_KEY"] ?? "";
+        const res = await doFetch("https://api.tavily.com/search", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            api_key: key,
+            query: request.query,
+            max_results: request.maxResults ?? 8
+          }),
+          signal
+        });
+        if (!res.ok) throw new Error(`tavily: HTTP ${res.status}`);
+        const body = await res.json();
+        const sources = (body?.results ?? []).map((r) => ({
+          url: String(r.url),
+          title: r.title === void 0 ? void 0 : String(r.title),
+          snippet: r.content === void 0 ? void 0 : String(r.content)
+        }));
+        return clip(sources, request.maxResults);
+      }
+      return {
+        content: "Web search is not configured. Choose a provider in bruine setup (SearXNG, Brave, or Tavily).",
+        sources: [],
+        truncated: false
+      };
+    }
+  };
+}
+function apply(ctx) {
+  ctx.provide(BRUINE_SEARCH_SERVICE, { id: "bruine" });
+  const provider = makeSearchProvider(readSearchConfig(), process.env, fetch);
+  let dispose;
+  ctx.inject(["web"], (c) => {
+    const web = c.web ?? ctx.get("web");
+    if (typeof web?.registerSearchProvider === "function") {
+      dispose = web.registerSearchProvider(provider);
+    }
+  });
+  return () => {
+    dispose?.();
+  };
+}
+export {
+  BRUINE_SEARCH_SERVICE,
+  apply,
+  makeSearchProvider,
+  name,
+  readSearchConfig
+};

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@ziamana/bruine",
+  "version": "0.1.0",
+  "description": "Interactive terminal coding agent that runs your own models, local or OpenAI-compatible",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ziamana/bruine.git"
+  },
+  "homepage": "https://github.com/ziamana/bruine#readme",
+  "bugs": {
+    "url": "https://github.com/ziamana/bruine/issues"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "cli",
+    "coding-assistant",
+    "llm",
+    "local-llm",
+    "llama.cpp",
+    "openai-compatible",
+    "terminal",
+    "tui"
+  ],
+  "bin": {
+    "bruine": "dist/bin.js",
+    "kumo": "dist/bin.js"
+  },
+  "exports": {
+    "./startup": "./dist/plugins/startup.js",
+    "./repl": "./dist/plugins/repl.js",
+    "./headless": "./dist/plugins/headless.js",
+    "./render": "./dist/plugins/render.js",
+    "./approval": "./dist/plugins/approval.js",
+    "./herdr": "./dist/plugins/herdr.js",
+    "./modes": "./dist/plugins/modes.js",
+    "./web-search": "./dist/plugins/web-search.js",
+    "./mcp": "./dist/plugins/mcp.js",
+    "./silence": "./dist/plugins/silence.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json",
+    "./compat": "./dist/compat.js"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "packageManager": "pnpm@12.4.2",
+  "files": [
+    "dist",
+    "skills",
+    "THIRD_PARTY_NOTICES.md",
+    "cordis.patch.yml"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "bench": "node --experimental-strip-types --import ./bench/ts-hooks.mjs bench/run.ts",
+    "typecheck": "tsc --noEmit",
+    "test:e2e": "vitest run test/e2e"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@xterm/headless": "^6.0.0",
+    "node-pty": "^1.1.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^3.0.0"
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh": "0.1.5-rc.3",
+    "@deepseek-ai/dsh-agent": "0.1.5-rc.3",
+    "@deepseek-ai/dsh-attachment": "0.1.5-rc.3",
+    "@deepseek-ai/dsh-cmdline": "0.1.5-rc.3",
+    "@deepseek-ai/dsh-llm": "0.1.5-rc.3",
+    "@deepseek-ai/dsh-mcp-client": "0.1.5-rc.3",
+    "@deepseek-ai/dsh-session": "0.1.5-rc.3",
+    "@earendil-works/pi-ai": "0.85.1",
+    "@earendil-works/pi-tui": "0.85.1",
+    "commander": "^15.0.0",
+    "diff": "^9.0.0",
+    "highlight.js": "^11.12.0",
+    "jpeg-js": "0.4.4",
+    "string-width": "^8.3.0",
+    "yaml": "^2.9.1"
+  }
+}

package/skills/code-review/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: code-review
+description: Review diffs like the next reader matters: intent, correctness, edge cases, tests, and long-term cost.
+---
+
+# Code review
+
+Use this skill when asked to review a diff, a pull request, or your own change before shipping.
+
+## Read in this order
+1. **Intent**: what is this change for? Is it the smallest honest way to do that?
+2. **Correctness**: trace the happy path once, then the boundaries: empty, single, max, wrong-type, concurrent, canceled, partially-failed.
+3. **Contracts**: callers and callees: did any signature, ordering, error type, or default change silently?
+4. **Tests**: does a test fail if the bug returns? Tests that only assert the code compiles are cost, not safety.
+5. **Longevity**: will the next person understand this in six months? Is there now a second way to do the same thing?
+
+## Severity when reporting
+- **[block]** wrong, unsafe, or silently breaking a contract. Must fix.
+- **[should]** real weakness with a concrete better shape. Fix unless out of scope.
+- **[nit]** taste-level. Say it, then move on; never gate on a nit.
+
+## Rules
+- Comment on the code, not the person; every "why not X?" beats every "this is bad".
+- One concrete suggestion per finding: show the shape of the fix, not just the flaw.
+- Check the diff for things that must never appear: secrets, tokens, personal paths, debug prints, dead flags, commented-out code.
+- Verify, don't trust: run the tests the diff claims are green; run the repro for a claimed fix.
+- If the change is yours: re-read it as a stranger once, top to bottom, before presenting it.
+
+## Sign off
+Say what you actually checked and what you did not. "Tests pass on Linux, Windows CI pending" is a review; "looks good" is not.

package/skills/git-workflow/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: git-workflow
+description: Keep git history clean and reviewable: focused branches, atomic commits, honest messages, safe pushes.
+---
+
+# Git workflow
+
+Use this skill whenever you are asked to commit, branch, rebase, or push work.
+
+## Branches
+- Work on a focused branch named `type/scope-short-title` (e.g. `feat/login`, `fix/cache-prefix`).
+- Never commit directly to the default branch unless the user explicitly asked for it.
+- Start from an up-to-date base: check the current branch and how far ahead/behind it is before making changes.
+
+## Commits
+- One logical change per commit. Stage deliberately (`git add <paths>`), never `git add -A` when unrelated files are dirty.
+- Message format: a command-style subject under ~70 characters ("Fix cache prefix on mode flip"), then a blank line and a body explaining *why*, not *what*.
+- No "WIP", no emoji, no "as requested". The diff says what; the message says why.
+- If a commit would need "and also" in its subject, split it.
+
+## Working with the user's state
+- Check `git status --short` before touching files; never revert, stash, or overwrite changes you did not make.
+- When rebasing or amending, prefer `--force-with-lease` over `--force` for pushes, and say plainly what rewrote history in your final message.
+- Never push, tag, or open a PR unless the user asked.
+
+## Recovery
+- Losing work: check `git reflog` before declaring anything destroyed.
+- Merge conflicts: resolve hunk by hunk, keep both intents when they are compatible, and run the tests before declaring the conflict solved.
+
+## Verification
+- Before the final commit of a task, run the project's checks (typecheck, build, tests) and report anything you could not run instead of silently skipping it.