@wrenai/genbi 0.0.1

package/dist-server/server/wire-types.js

@@ -0,0 +1 @@
+export {};

package/dist-server/server/wren-home.d.ts

@@ -0,0 +1,19 @@
+import type { SetupMode } from "./wire-types.js";
+/**
+ * Builds the `setWrenHomeForSetupMode` function wired onto `TurnDeps` by `server/bin.ts` (see
+ * `TurnDeps.setWrenHomeForSetupMode`'s doc comment in `server/turn.ts` for the full call-site
+ * rationale). Pulled out of `bin.ts`'s closure into its own module so the exact logic that runs
+ * in production is directly unit-testable, instead of only reachable through a mocked
+ * `TurnDeps` in a route-level test.
+ *
+ * `workspaceRoot` and `originalWrenHome` are captured once at BFF boot (bootstrap-mode boots
+ * only — a bound-mode boot has no `workspaceRoot` and never runs the setup wizard, so the
+ * returned function is a no-op for it). `"create"` anchors `process.env.WREN_HOME` to
+ * `<workspaceRoot>/.wren` so a scaffolded project's `wren profile add` writes into a fresh,
+ * workspace-scoped `profiles.yml` instead of the operator's real `~/.wren/profiles.yml`.
+ * `"adopt"` or `undefined` (e.g. after "Reset setup") restores `originalWrenHome`
+ * exactly — deleting the env var entirely if the process never had it set, rather than forcing
+ * some other default — since adopt is strictly read-only against global state and must keep
+ * resolving the operator's own profiles.
+ */
+export declare function createSetWrenHomeForSetupMode(workspaceRoot: string | undefined, originalWrenHome: string | undefined): (mode: SetupMode | undefined) => void;

package/dist-server/server/wren-home.js

@@ -0,0 +1,33 @@
+import path from "node:path";
+/**
+ * Builds the `setWrenHomeForSetupMode` function wired onto `TurnDeps` by `server/bin.ts` (see
+ * `TurnDeps.setWrenHomeForSetupMode`'s doc comment in `server/turn.ts` for the full call-site
+ * rationale). Pulled out of `bin.ts`'s closure into its own module so the exact logic that runs
+ * in production is directly unit-testable, instead of only reachable through a mocked
+ * `TurnDeps` in a route-level test.
+ *
+ * `workspaceRoot` and `originalWrenHome` are captured once at BFF boot (bootstrap-mode boots
+ * only — a bound-mode boot has no `workspaceRoot` and never runs the setup wizard, so the
+ * returned function is a no-op for it). `"create"` anchors `process.env.WREN_HOME` to
+ * `<workspaceRoot>/.wren` so a scaffolded project's `wren profile add` writes into a fresh,
+ * workspace-scoped `profiles.yml` instead of the operator's real `~/.wren/profiles.yml`.
+ * `"adopt"` or `undefined` (e.g. after "Reset setup") restores `originalWrenHome`
+ * exactly — deleting the env var entirely if the process never had it set, rather than forcing
+ * some other default — since adopt is strictly read-only against global state and must keep
+ * resolving the operator's own profiles.
+ */
+export function createSetWrenHomeForSetupMode(workspaceRoot, originalWrenHome) {
+    return function setWrenHomeForSetupMode(mode) {
+        if (workspaceRoot === undefined)
+            return; // only bootstrap-mode boots ever run the setup wizard
+        if (mode === "create") {
+            process.env["WREN_HOME"] = path.join(workspaceRoot, ".wren");
+        }
+        else if (originalWrenHome === undefined) {
+            delete process.env["WREN_HOME"];
+        }
+        else {
+            process.env["WREN_HOME"] = originalWrenHome;
+        }
+    };
+}

package/dist-server/server/wren-profiles.d.ts

@@ -0,0 +1,43 @@
+/** One profile's raw field map, as declared in profiles.yml (values still `${VAR}`-templated — this module never expands or otherwise touches secret material, it only reads structure). */
+export type ProfileFields = ReadonlyMap<string, string>;
+export interface ProfileStore {
+    /** The store's global `active:` profile name, or `undefined` if unset/null. */
+    readonly active: string | undefined;
+    readonly profiles: ReadonlyMap<string, ProfileFields>;
+}
+/** The only shape ever allowed to cross the wire to the frontend — see `listCandidateProfiles`. */
+export interface ProfileCandidate {
+    readonly name: string;
+    readonly datasource: string;
+}
+/** Absolute path to the profiles store this process would read — exported so callers (and tests) can point elsewhere via `WREN_HOME` without guessing the join. */
+export declare function profilesFilePath(): string;
+/**
+ * Parses profiles.yml's known two-level shape:
+ * ```yaml
+ * active: <name>
+ * profiles:
+ *   <name>:
+ *     <field>: <value>
+ *     ...
+ * ```
+ * Never throws on malformed content — returns as much as it could confidently
+ * parse (an empty profiles map in the worst case), mirroring this module's
+ * "profile discovery degrades to nothing found" philosophy: a broken
+ * profiles.yml should surface as "no candidates" to callers, not crash them.
+ */
+export declare function parseProfileStore(content: string): ProfileStore;
+/** Reads and parses profiles.yml off disk. Returns an empty store (never throws) when the file is missing or unreadable — same "degrade to nothing found" contract as `parseProfileStore`. */
+export declare function loadProfileStore(): ProfileStore;
+/**
+ * Candidate profiles for the adopt flow's profile-select checkpoint: every
+ * profile whose `datasource:` field equals the project's `data_source`,
+ * ranked with the profile named after the project directory first, then the
+ * store's global `active` profile, then the rest in `profiles.yml`'s own
+ * declaration order (stable sort). Returns ONLY `{name, datasource}` — never
+ * crosses the wire with anything else in a profile's field map (hosts, ports,
+ * credential material) per the adopt route's hard "no credentials to the
+ * frontend" rule; callers that need more of a profile's fields should read
+ * `store.profiles` directly, in-process, rather than widening this type.
+ */
+export declare function listCandidateProfiles(store: ProfileStore, sourceType: string, projectDirName: string): readonly ProfileCandidate[];

package/dist-server/server/wren-profiles.js

@@ -0,0 +1,123 @@
+/**
+ * Reads the wren CLI's global connection-profile store (`profiles.yml`, at
+ * `$WREN_HOME/profiles.yml`, defaulting to `~/.wren/profiles.yml` — mirrors
+ * `core/wren/src/wren/profile.py`'s own `WREN_HOME` resolution so this reads
+ * the exact same file the CLI would) into an in-process shape other BFF
+ * modules can query.
+ *
+ * Deliberately NOT narrowed to any one caller's needs: `server/adopt.ts`'s
+ * adopt flow only ever needs `{name, datasource}` candidates — and must never
+ * let credentials cross the wire, see `listCandidateProfiles`'s doc comment —
+ * but another module resolves a project's pinned profile into a non-secret
+ * connection summary for display and needs the rest of a profile's fields
+ * (host/port/database/url/...). Both read through this one parser so there is
+ * exactly one YAML-shape understanding of profiles.yml in this repo, not two
+ * that can silently drift apart.
+ *
+ * Hand-rolled indentation-aware scan, not a general YAML parser dependency —
+ * matches this repo's existing convention (see `server/adopt.ts`'s
+ * `readYamlScalarField`) of small single-purpose parsers over pulling in a
+ * YAML dependency just to read a handful of known fields: profiles.yml is
+ * exactly two levels deep (`profiles.<name>.<field>`) plus one top-level
+ * `active:` scalar, so a generic multi-document YAML parser would be most of
+ * a new dependency spent reading a shape this constrained.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function wrenHomeDir() {
+    const override = process.env.WREN_HOME?.trim();
+    return override ? override : path.join(os.homedir(), ".wren");
+}
+/** Absolute path to the profiles store this process would read — exported so callers (and tests) can point elsewhere via `WREN_HOME` without guessing the join. */
+export function profilesFilePath() {
+    return path.join(wrenHomeDir(), "profiles.yml");
+}
+/** Strips one layer of matching quotes — same convention as `server/adopt.ts`'s `readYamlScalarField`. */
+function unquote(raw) {
+    const match = /^(['"])(.*)\1$/.exec(raw);
+    return match ? match[2] : raw;
+}
+/**
+ * Parses profiles.yml's known two-level shape:
+ * ```yaml
+ * active: <name>
+ * profiles:
+ *   <name>:
+ *     <field>: <value>
+ *     ...
+ * ```
+ * Never throws on malformed content — returns as much as it could confidently
+ * parse (an empty profiles map in the worst case), mirroring this module's
+ * "profile discovery degrades to nothing found" philosophy: a broken
+ * profiles.yml should surface as "no candidates" to callers, not crash them.
+ */
+export function parseProfileStore(content) {
+    const lines = content.split(/\r?\n/);
+    const activeMatch = /^active:\s*(.*)$/m.exec(content);
+    const activeRaw = activeMatch ? activeMatch[1].trim() : "";
+    const active = activeRaw && activeRaw !== "null" && activeRaw !== "~" ? unquote(activeRaw) : undefined;
+    const profiles = new Map();
+    const profilesLineIdx = lines.findIndex((line) => /^profiles:\s*$/.test(line));
+    if (profilesLineIdx === -1)
+        return { active, profiles };
+    // `nameIndent` is established from the first profile-name line seen (a bare `<name>:` key with
+    // no value) and used to tell a new profile name apart from that profile's own nested fields —
+    // real profiles.yml files use 2-space name indent / 4-space field indent, but this doesn't
+    // hardcode that, it just requires field lines to be indented deeper than their profile's name.
+    let nameIndent;
+    let current;
+    for (let i = profilesLineIdx + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.trim() || line.trim().startsWith("#"))
+            continue;
+        const indent = line.length - line.trimStart().length;
+        if (indent === 0)
+            break; // back to a top-level key — the profiles block ended
+        const nameMatch = /^(\s+)([\w.-]+):\s*$/.exec(line);
+        if (nameMatch && (nameIndent === undefined || indent === nameIndent)) {
+            nameIndent = indent;
+            current = new Map();
+            profiles.set(nameMatch[2], current);
+            continue;
+        }
+        if (current === undefined || nameIndent === undefined || indent <= nameIndent)
+            continue;
+        const fieldMatch = /^\s+([\w.-]+):\s*(.*)$/.exec(line);
+        if (fieldMatch) {
+            current.set(fieldMatch[1], unquote(fieldMatch[2].trim()));
+        }
+    }
+    return { active, profiles };
+}
+/** Reads and parses profiles.yml off disk. Returns an empty store (never throws) when the file is missing or unreadable — same "degrade to nothing found" contract as `parseProfileStore`. */
+export function loadProfileStore() {
+    const file = profilesFilePath();
+    if (!existsSync(file))
+        return { active: undefined, profiles: new Map() };
+    try {
+        return parseProfileStore(readFileSync(file, "utf-8"));
+    }
+    catch {
+        return { active: undefined, profiles: new Map() };
+    }
+}
+/**
+ * Candidate profiles for the adopt flow's profile-select checkpoint: every
+ * profile whose `datasource:` field equals the project's `data_source`,
+ * ranked with the profile named after the project directory first, then the
+ * store's global `active` profile, then the rest in `profiles.yml`'s own
+ * declaration order (stable sort). Returns ONLY `{name, datasource}` — never
+ * crosses the wire with anything else in a profile's field map (hosts, ports,
+ * credential material) per the adopt route's hard "no credentials to the
+ * frontend" rule; callers that need more of a profile's fields should read
+ * `store.profiles` directly, in-process, rather than widening this type.
+ */
+export function listCandidateProfiles(store, sourceType, projectDirName) {
+    const rank = (name) => (name === projectDirName ? 0 : name === store.active ? 1 : 2);
+    return [...store.profiles.entries()]
+        .map(([name, fields], index) => ({ name, datasource: fields.get("datasource"), index }))
+        .filter((c) => c.datasource === sourceType)
+        .sort((a, b) => rank(a.name) - rank(b.name) || a.index - b.index)
+        .map(({ name, datasource }) => ({ name, datasource }));
+}

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@wrenai/genbi",
+  "version": "0.0.1",
+  "description": "Wren GenBI — the web UI for WrenAI: ask questions of your data and get dashboards back",
+  "license": "Apache-2.0",
+  "keywords": [
+    "wrenai",
+    "genbi",
+    "bi",
+    "analytics",
+    "dashboard",
+    "semantic-layer",
+    "text-to-sql",
+    "ai-agent"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Canner/WrenAI.git",
+    "directory": "apps/genbi"
+  },
+  "homepage": "https://github.com/Canner/WrenAI/tree/main/apps/genbi#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "genbi": "bin/genbi.mjs"
+  },
+  "type": "module",
+  "dependencies": {
+    "@ai-sdk/anthropic": "~4.0.15",
+    "@ai-sdk/mcp": "~2.0.13",
+    "@ai-sdk/openai-compatible": "~3.0.10",
+    "@ai-sdk/provider": "~4.0.3",
+    "@ant-design/icons": "^6.3.2",
+    "@hono/node-server": "^2.0.10",
+    "@warble/claude-agent-sdk": "0.9.0",
+    "@warble/cli": "0.9.0",
+    "@warble/codex-local": "0.9.0",
+    "@warble/ir-spec": "0.6.0",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
+    "ai": "~7.0.28",
+    "antd": "^6.5.1",
+    "echarts": "^6.1.0",
+    "hono": "^4.12.30",
+    "node-pty": "^1.1.0",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "react-router-dom": "^7.18.1",
+    "ws": "^8.21.3",
+    "zod": "^4.4.3",
+    "zustand": "^5.0.14"
+  },
+  "devDependencies": {
+    "@playwright/test": "1.59.1",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/node": "^26.1.1",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@types/ws": "^8.18.1",
+    "@vitejs/plugin-react": "^6.0.3",
+    "jsdom": "^29.1.1",
+    "typescript": "^7.0.2",
+    "vite": "^8.1.5",
+    "vitest": "^4.1.10"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "!dist/**/*.map",
+    "dist-server/server",
+    "dist-server/harness",
+    "dist-server/providers",
+    "profiles"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build && tsc -p tsconfig.server.json && node scripts/copy-providers.js",
+    "start:bff": "node dist-server/server/bin.js",
+    "check:contracts": "node scripts/verify-local-launch.mjs",
+    "check:warble-peers": "pnpm peers check",
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:browser": "playwright test",
+    "test:watch": "vitest",
+    "typecheck": "tsc -b --noEmit && tsc -p tsconfig.server.json --noEmit"
+  }
+}

package/profiles/genbi-default/context/binding.yml

@@ -0,0 +1,9 @@
+# Coarse context binding: the whole v5-jaffle semantic layer. Since IR v0.3 the Warble front-end
+# builds a real MdlContext over the bound project and evaluates context_precondition predicates
+# against it — it does introspect MDL. The binding stays "coarse" in a different sense: it names the
+# whole project, not a specific metric/grain.
+#
+# The host rewrites this `project:` line to the user's own wren project at bind time; the committed
+# value pins this repo's own v5 example so the profile compiles standalone for CI/dev.
+# Path is relative to this profile directory.
+project: ../../../../examples/v5-jaffle