@ziamana/bruine 0.1.0

package/dist/compat.js

@@ -0,0 +1,40 @@
+// 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"));
+}
+var SKILLS_MANIFEST_NAME = ".bruine-installed.json";
+function manifestReadPath(skillsDir, pathMod = path) {
+  return compatReadPath(pathMod.join(skillsDir, SKILLS_MANIFEST_NAME), pathMod.join(skillsDir, ".kumo-installed.json"));
+}
+export {
+  SKILLS_MANIFEST_NAME,
+  appEnv,
+  appHome,
+  compatReadPath,
+  configReadPath,
+  configWritePath,
+  manifestReadPath,
+  runtimeHome
+};

package/dist/plugins/approval.js

@@ -0,0 +1,147 @@
+// src/plugins/approval.ts
+var name = "bruine-approval";
+function approvalTitle(request, describe) {
+  let detail = "";
+  if (request.callId !== void 0) {
+    const info = describe?.(request.callId);
+    if (info !== void 0 && info.summary !== "") detail = info.summary;
+  }
+  if (detail === "" && request.reason !== void 0 && request.reason !== "") {
+    detail = request.reason;
+  }
+  const target = detail === "" ? request.toolName : `${request.toolName}: ${detail}`;
+  return `? Allow ${target}`;
+}
+function buildQuestion(request, describe) {
+  return `${approvalTitle(request, describe)} ? [y/N] `;
+}
+function alwaysLabel(scope, toolName) {
+  if (scope === void 0) return "Always for this session";
+  const at = scope.indexOf(":");
+  if (at > 0) {
+    const command = scope.slice(at + 1).replace(/\s+/g, " ").trim();
+    const shown = command.length > 48 ? `${command.slice(0, 47)}\u2026` : command;
+    return `Always allow "${shown}" this session`;
+  }
+  return `Always allow every ${toolName === "edit" || toolName === "write" ? toolName : `${toolName} call`} this session`;
+}
+function parseAnswer(line) {
+  return /^y(es)?$/i.test(line.trim());
+}
+function apply(ctx) {
+  let repl;
+  let render;
+  let modes;
+  ctx.inject(["bruineRepl"], (c) => {
+    repl = c.bruineRepl;
+  });
+  ctx.inject(["bruineRender"], (c) => {
+    render = c.bruineRender;
+  });
+  ctx.inject(["bruineModes"], (c) => {
+    modes = c.bruineModes;
+  });
+  ctx.on(
+    "user-questions/request",
+    (request, next) => {
+      if (repl === void 0 || !(modes?.governs(request.agent) ?? request.agent === repl.agent)) return next();
+      if (request.signal?.aborted) {
+        return { answers: request.questions.map((q) => ({ id: q.id, selected: [], custom: "skipped by the user" })) };
+      }
+      const ui = repl.ui;
+      if (ui !== void 0 && typeof ui.askQuestions === "function") {
+        return ui.askQuestions(request.questions).then((answers) => {
+          const resolved = answers ?? request.questions.map((q) => ({ id: q.id, selected: [], custom: "skipped by the user" }));
+          return { answers: resolved };
+        });
+      }
+      const ask = repl.ask;
+      if (ask === void 0) return next();
+      return (async () => {
+        const answers = [];
+        for (const q of request.questions) {
+          const opts = [...q.options ?? [], { label: "Other\u2026" }];
+          const lines = [
+            q.header !== void 0 ? `${q.header}: ${q.question}` : q.question,
+            ...opts.map((o, i) => `${String(i + 1)}) ${o.label}${o.description !== void 0 ? ` (${o.description})` : ""}`)
+          ].join("\n");
+          const raw = (await ask(`${lines}
+  [1]`)).trim();
+          const n = Number.parseInt(raw, 10);
+          if (Number.isInteger(n) && n >= 1 && n <= opts.length) {
+            const chosen = opts[n - 1];
+            if (chosen.label === "Other\u2026") {
+              const custom = (await ask("Other answer: ")).trim();
+              answers.push({ id: q.id, selected: [], ...custom !== "" ? { custom } : {} });
+            } else {
+              answers.push({ id: q.id, selected: [chosen.label] });
+            }
+          } else if (raw !== "") {
+            answers.push({ id: q.id, selected: [], custom: raw });
+          } else {
+            answers.push({ id: q.id, selected: opts[0] !== void 0 && opts[0].label !== "Other\u2026" ? [opts[0].label] : [], custom: void 0 });
+          }
+        }
+        return { answers };
+      })();
+    }
+  );
+  ctx.on(
+    "approval/request",
+    (request, next) => {
+      if (!(modes?.governs(request.agent) ?? request.agent === repl?.agent)) return next();
+      if (request.signal?.aborted) return "cancelled";
+      if (modes !== void 0) {
+        const decision = modes.decisionFor(request.callId);
+        if (decision === "allow") return "allowed-once";
+        if (decision === "deny") return "rejected";
+        if (decision !== "ask") return repl === void 0 ? "rejected" : next();
+      }
+      if (repl === void 0) return "rejected";
+      const ui = repl.ui;
+      if (ui !== void 0) {
+        const title = approvalTitle(request, (id) => render?.describe?.(id));
+        return ui.askChoice(
+          title,
+          [
+            { value: "allow", label: "Allow once" },
+            { value: "always", label: alwaysLabel(modes?.alwaysScope?.(request.callId), request.toolName) },
+            { value: "reject", label: "Reject" }
+          ],
+          { keys: ["y", "a", "n"] }
+        ).then((choice) => {
+          if (choice === 0) return "allowed-once";
+          if (choice === 1) {
+            modes?.rememberFor(request.callId);
+            return "allowed-once";
+          }
+          return "rejected";
+        });
+      }
+      const screen = render?.screen;
+      const question = buildQuestion(request, (id) => screen?.tools.describe(id));
+      screen?.reasoning.end();
+      const ask = repl.ask;
+      if (ask === void 0) return next();
+      return ask(question).then((answer) => {
+        const always = /^a(lways?)?$/i.test(answer.trim());
+        const ok = always || parseAnswer(answer);
+        if (always) modes?.rememberFor(request.callId);
+        if (screen !== void 0) {
+          const mark = ok ? screen.icons.ok : screen.icons.fail;
+          screen.screen.write(`${mark} ${ok ? always ? "allowed for session" : "allowed" : "rejected"}
+`);
+        }
+        return ok ? "allowed-once" : "rejected";
+      });
+    }
+  );
+}
+export {
+  alwaysLabel,
+  apply,
+  approvalTitle,
+  buildQuestion,
+  name,
+  parseAnswer
+};

package/dist/plugins/headless.js

@@ -0,0 +1,236 @@
+// src/plugins/headless.ts
+import { randomUUID } from "crypto";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { installModelSelection } from "@deepseek-ai/dsh-agent";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { join as join2 } from "path";
+
+// 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/setup/skills.ts
+import { cp, lstat, mkdir, readFile, readdir, rename, rm, symlink, writeFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import path2, { dirname, join } from "path";
+var SAFE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function parseSkillFrontmatter(md) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(md);
+  if (m === null || m[1] === void 0) return {};
+  const lines = m[1].split(/\r?\n/);
+  const out = {};
+  const unquote = (v) => v.replaceAll(/^["']|["']$/g, "");
+  for (let i = 0; i < lines.length; i += 1) {
+    const kv = /^([A-Za-z_][\w-]*)\s*:\s*(.*)$/.exec(lines[i].trimEnd());
+    if (kv === null || kv[1] === void 0 || kv[2] === void 0) continue;
+    const key = kv[1];
+    let value = kv[2].trim();
+    const rest = [];
+    let j = i + 1;
+    while (j < lines.length && (lines[j].trim() === "" || /^\s+\S/.test(lines[j]))) {
+      rest.push(lines[j]);
+      j += 1;
+    }
+    while (rest.length > 0 && rest[rest.length - 1].trim() === "") rest.pop();
+    const block = /^([>|])[+-]?\d*$/.exec(value);
+    if (block !== null) {
+      const body = rest.map((l) => l.trim());
+      value = block[1] === "|" ? body.join("\n") : body.join(" ").replaceAll(/\s+/g, " ").trim();
+      i = j - 1;
+    } else if (rest.length > 0 && key !== "name") {
+      value = [value, ...rest.map((l) => l.trim())].filter((l) => l !== "").join(" ");
+      i = j - 1;
+    }
+    if (key === "name") out.name = unquote(value);
+    if (key === "description") out.description = unquote(value);
+  }
+  return out;
+}
+async function readSkillsUnder(root) {
+  const out = [];
+  if (!existsSync2(root)) return out;
+  for (const entry of await readdir(root, { withFileTypes: true })) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    const skillPath = join(root, entry.name, "SKILL.md");
+    if (!existsSync2(skillPath)) continue;
+    const fm = parseSkillFrontmatter(await readFile(skillPath, "utf8"));
+    if (fm.name === void 0 || !SAFE_NAME.test(fm.name)) continue;
+    out.push({ name: fm.name, description: fm.description ?? "", dir: join(root, entry.name) });
+  }
+  return out;
+}
+async function scanProjectSkills(cwd, pathMod = path2) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rel of [
+    [".agents", "skills"],
+    [".dsh", "skills"]
+  ]) {
+    for (const skill of await readSkillsUnder(pathMod.join(cwd, ...rel))) {
+      if (seen.has(skill.name)) continue;
+      seen.add(skill.name);
+      out.push(skill);
+    }
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function readAvailableSkills(homeSkillsDir, cwd) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const skill of await readSkillsUnder(homeSkillsDir)) {
+    byName.set(skill.name, { ...skill, scope: "user" });
+  }
+  for (const skill of await scanProjectSkills(cwd)) {
+    byName.set(skill.name, { ...skill, scope: "project" });
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/plugins/ui-skills.ts
+var UI_SKILLS = ["impeccable", "make-interfaces-feel-better"];
+var WEB_TASK = /\b(?:sites?(?:\s+(?:web|internet))?|web\s?sites?|web\s?apps?|landing(?:\s+page)?|home\s?page|page\s+(?:web|d['’]accueil)|front[- ]?end|dashboard|tableau\s+de\s+bord|html|css|tailwind|maquette|mock-?ups?|portfolio|boutique(?:\s+en\s+ligne)?|e-?commerce|interface\s+(?:utilisateur|graphique|web)|user\s+interface|ui|ux|gui|web\s+design|design\s+system|re-?design)\b/i;
+function isUiTask(text) {
+  return WEB_TASK.test(text);
+}
+function uiSkillsHint(text, available) {
+  if (!isUiTask(text)) return void 0;
+  const names = UI_SKILLS.filter((name2) => available.includes(name2));
+  if (names.length === 0) return void 0;
+  const list = names.map((name2) => `\`${name2}\``).join(" and ");
+  return [
+    "<system-reminder>",
+    `If this task builds or changes a web page, a site or an interface: call the \`skill\` tool for ${list} first, read what they say, and apply it to the design and the details. Do this before writing any code.`,
+    "Where the page needs pictures, draw them yourself as detailed inline SVG with depth, light, shadow and texture; never grey boxes, emoji or placeholders.",
+    "When the user asks for a complete or professional site, plan all of it first with todo_write: every page a real site of that kind has, and for each page the features people expect (a shop: a home with many sections, a catalogue with filters, sort and search, a product page, a cart, a checkout, an account, a journal, legal pages, a 404 and a contact page). Build all of it. A first version that works is not the end: go through the pages again to add detail, content and polish.",
+    "Invent the brand name and the content for the business the user describes. The name of the working folder or of this tool is not the brand.",
+    "Before you say it is done, open every page in the browser at desktop and at phone width, look at the screenshots, and fix whatever is cut off, overlapping, low in contrast or empty.",
+    "</system-reminder>"
+  ].join("\n");
+}
+function withUiSkillsHint(text, parts, available) {
+  const hint = uiSkillsHint(text, available);
+  return hint === void 0 ? parts : [...parts, { type: "text", text: hint }];
+}
+async function availableSkillNames(homeSkillsDir, cwd) {
+  try {
+    return (await readAvailableSkills(homeSkillsDir, cwd)).map((skill) => skill.name);
+  } catch {
+    return [];
+  }
+}
+
+// src/plugins/headless.ts
+var name = "bruine-headless";
+var inject = ["agentDefaultModel", "agents", "sessions", "bruineStartup", "bruineModes"];
+async function stdinTask() {
+  let task = "";
+  for await (const chunk of process.stdin) task += String(chunk);
+  return task;
+}
+function messageText(event) {
+  const blocks = event?.data?.message?.content;
+  return Array.isArray(blocks) ? blocks.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n") : "";
+}
+async function run(ctx) {
+  await ctx.get("loader")?.await();
+  const startup = ctx.get("bruineStartup");
+  const task = startup?.headless;
+  if (task === void 0 || task.prompts.length === 0) throw new Error("headless task is missing");
+  const modes = ctx.get("bruineModes");
+  if (modes === void 0) throw new Error("permission gate is unavailable");
+  const agents = ctx.get("agents");
+  const sessions = ctx.get("sessions");
+  const selection = ctx.get("agentDefaultModel")?.currentSelection();
+  if (agents === void 0 || sessions === void 0 || selection === void 0) throw new Error("agent services are unavailable");
+  const selectionRef = { current: selection, assembled: void 0 };
+  const handle = await agents.create({
+    sessionId: SessionId(`session-${randomUUID()}`),
+    meta: { cwd: process.cwd() },
+    agentOptions: { provider: selection.provider, model: selection.model },
+    setup: (agentCtx) => {
+      installModelSelection(agentCtx, selectionRef);
+    }
+  });
+  const { agent } = handle;
+  modes.govern(agent);
+  await agent.whenIdle();
+  const started = Date.now();
+  let text = "";
+  let reason = "error";
+  let streamed = "";
+  const writeEvent = (event) => {
+    if (task.format === "stream-json") process.stdout.write(`${JSON.stringify(event)}
+`);
+  };
+  const offStream = ctx.on("agent/assistant-stream", ({ agent: subject, frame }) => {
+    if (subject !== agent || task.format !== "stream-json") return;
+    if (frame?.type === "chunk" && frame.chunk?.type === "text-delta") {
+      streamed += String(frame.chunk.text ?? "");
+      writeEvent({ type: "text", text: frame.chunk.text });
+    }
+  });
+  const offSession = ctx.on("session/event", (session, event) => {
+    if (session !== agent.session) return;
+    if (event?.type === "assistant/message") text = messageText(event);
+    if (event?.type === "turn/end") reason = String(event.data?.reason?.kind ?? "error");
+    if (event?.type === "tool/call") writeEvent({ type: "tool", name: event.data?.name, callId: event.data?.callId });
+  });
+  try {
+    for (const raw of task.prompts) {
+      const prompt = raw === "-" ? await stdinTask() : raw;
+      if (prompt.trim() === "") throw new Error("-p needs a non-empty task");
+      text = "";
+      streamed = "";
+      reason = "error";
+      const skills = await availableSkillNames(join2(runtimeHome(), "skills"), process.cwd());
+      agent.followup(createUserMessage({ content: withUiSkillsHint(prompt, [{ type: "text", text: prompt }], skills), source: { kind: "user" } }));
+      await agent.whenIdle();
+      if (text === "") text = streamed;
+      if (reason !== "completed") break;
+    }
+    await sessions.flush(agent.session);
+    const result = {
+      ok: reason === "completed",
+      text,
+      reason,
+      sessionId: String(agent.session.id),
+      durationMs: Date.now() - started,
+      tools: modes.log.map(({ tool, decision }) => ({ name: tool, decision }))
+    };
+    if (task.format === "text") process.stdout.write(result.text);
+    else process.stdout.write(`${JSON.stringify(result)}
+`);
+    return result.ok ? 0 : 1;
+  } finally {
+    offStream();
+    offSession();
+    await handle.dispose();
+  }
+}
+function apply(ctx) {
+  const exit = ctx.get("appExit");
+  if (exit === void 0) throw new Error("bruine-headless: appExit is unavailable");
+  void run(ctx).then(exit, (error) => {
+    console.error(`bruine: ${error instanceof Error ? error.message : String(error)}`);
+    exit(1);
+  });
+}
+export {
+  apply,
+  inject,
+  name
+};