leedab 0.1.0

package/bin/leedab.js

@@ -0,0 +1,626 @@
+#!/usr/bin/env node
+
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { program } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { startGateway, stopGateway } from "../dist/gateway.js";
+import { loadConfig, initConfig } from "../dist/config/index.js";
+import { setupChannels } from "../dist/channels/index.js";
+import { runOnboard } from "../dist/onboard/index.js";
+import { startDashboard } from "../dist/dashboard/server.js";
+import { execBranded } from "../dist/brand.js";
+import { resolveOpenClawBin, openclawEnv } from "../dist/openclaw.js";
+import { addEntry, removeEntry, listEntries, encryptVault, decryptVault } from "../dist/vault.js";
+import { loadTeam, addMember, removeMember } from "../dist/team.js";
+import { ensureLicense } from "../dist/license.js";
+
+const pkg = createRequire(import.meta.url)("../package.json");
+const OPENCLAW_BIN = resolveOpenClawBin();
+const STATE_DIR = resolve(".leedab");
+const ocEnv = openclawEnv(STATE_DIR);
+
+/** Commands that don't require an existing project directory or license. */
+const NO_PROJECT_REQUIRED = new Set(["onboard", "init", "help"]);
+/** Commands that need a project but not a license (onboard handles its own license check). */
+const NO_LICENSE_REQUIRED = new Set(["onboard", "init", "help", "stop"]);
+
+/**
+ * Check that we're inside a LeedAB project directory.
+ * Runs before every command except onboard/init.
+ */
+function requireProject(command) {
+  const name = command.name();
+  // Also allow subcommands whose parent doesn't need a project
+  const parentName = command.parent?.name();
+  if (NO_PROJECT_REQUIRED.has(name) || NO_PROJECT_REQUIRED.has(parentName)) return;
+
+  const hasConfig = existsSync(resolve("leedab.config.json"));
+  const hasState = existsSync(STATE_DIR);
+  if (!hasConfig && !hasState) {
+    console.error(chalk.red("\n  Not a LeedAB project directory.\n"));
+    console.error(chalk.dim("  Run ") + chalk.cyan("leedab onboard") + chalk.dim(" to set up a new project here,"));
+    console.error(chalk.dim("  or cd into an existing project directory.\n"));
+    process.exit(1);
+  }
+}
+
+/**
+ * Check for a valid license. Runs before commands that need one.
+ */
+async function requireLicense(command) {
+  const name = command.name();
+  const parentName = command.parent?.name();
+  if (NO_LICENSE_REQUIRED.has(name) || NO_LICENSE_REQUIRED.has(parentName)) return;
+
+  // Only check if we're in a project (requireProject runs first)
+  const hasState = existsSync(STATE_DIR);
+  if (!hasState) return;
+
+  const license = await ensureLicense();
+  if (!license) {
+    console.error(chalk.red("\n  Invalid or expired license.\n"));
+    console.error(chalk.dim("  Re-enter your key: ") + chalk.cyan("leedab onboard"));
+    console.error(chalk.dim("  Get a key at:      ") + chalk.cyan("https://leedab.com\n"));
+    process.exit(1);
+  }
+}
+
+// Hook into every command automatically
+program.hook("preAction", async (thisCommand, actionCommand) => {
+  requireProject(actionCommand);
+  await requireLicense(actionCommand);
+});
+
+program
+  .name("leedab")
+  .description("LeedAB — Your enterprise AI agent")
+  .version(pkg.version);
+
+program
+  .command("onboard")
+  .description("Interactive setup wizard — connect channels and set up credential vault")
+  .action(async () => {
+    try {
+      await runOnboard();
+    } catch (err) {
+      console.error(chalk.red(`\nOnboard failed: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
+const configure = program
+  .command("configure")
+  .description("Reconfigure LeedAB settings");
+
+configure
+  .command("model")
+  .description("Change the LLM provider and API key")
+  .action(async () => {
+    const { onboardProvider } = await import("../dist/onboard/steps/provider.js");
+    const result = await onboardProvider();
+    if (result) {
+      const { readFile, writeFile } = await import("node:fs/promises");
+      const configPath = resolve("leedab.config.json");
+      try {
+        const raw = JSON.parse(await readFile(configPath, "utf-8"));
+        raw.agent.model = result.model;
+        await writeFile(configPath, JSON.stringify(raw, null, 2) + "\n");
+        console.log(chalk.green(`\n  Config updated. Restart with ${chalk.cyan("leedab start")} to apply.\n`));
+      } catch (err) {
+        console.error(chalk.red(`Failed to update config: ${err.message}`));
+        process.exit(1);
+      }
+    }
+  });
+
+program
+  .command("init")
+  .description("Initialize LeedAB with default config (use 'onboard' for guided setup)")
+  .action(async () => {
+    const spinner = ora("Initializing LeedAB...").start();
+    try {
+      await initConfig();
+      spinner.succeed(chalk.green("LeedAB initialized. Edit leedab.config.json to configure."));
+    } catch (err) {
+      spinner.fail(chalk.red(`Init failed: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("start")
+  .description("Start the LeedAB agent and dashboard")
+  .option("-c, --config <path>", "Path to config file", "leedab.config.json")
+  .option("-p, --dashboard-port <port>", "Dashboard port", "3000")
+  .action(async (opts) => {
+    const spinner = ora("Starting LeedAB agent...").start();
+    try {
+      const config = await loadConfig(opts.config);
+      const { logPath } = await startGateway(config);
+      spinner.succeed(chalk.green("LeedAB is live"));
+      await startDashboard(config, parseInt(opts.dashboardPort));
+
+      const enabledChannels = Object.entries(config.channels)
+        .filter(([_, v]) => v?.enabled)
+        .map(([k]) => k);
+
+      console.log();
+      console.log(chalk.bold("  Ready to go."));
+      console.log();
+      const dashUrl = `http://localhost:${opts.dashboardPort}`;
+      const link = `\x1b]8;;${dashUrl}\x1b\\${dashUrl}\x1b]8;;\x1b\\`;
+      console.log(`  ${chalk.cyan(link)}    Dashboard`);
+      if (enabledChannels.length > 0) {
+        console.log(`  ${chalk.green("Channels")}                 ${enabledChannels.join(", ")}`);
+      }
+      console.log();
+      console.log(chalk.dim(`  Logs: ${logPath}`));
+      console.log();
+    } catch (err) {
+      spinner.fail(chalk.red(`Failed to start: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("dashboard")
+  .description("Open the setup dashboard (without starting the agent)")
+  .option("-c, --config <path>", "Path to config file", "leedab.config.json")
+  .option("-p, --port <port>", "Dashboard port", "3000")
+  .action(async (opts) => {
+    try {
+      const config = await loadConfig(opts.config);
+      console.log(chalk.bold("\n  LeedAB Dashboard\n"));
+      await startDashboard(config, parseInt(opts.port));
+      console.log(chalk.dim("  Open the URL above in your browser.\n"));
+    } catch (err) {
+      console.error(chalk.red(`Failed: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("terminal")
+  .alias("os")
+  .description("Chat with the agent in the terminal")
+  .option("--session <key>", "Session key", "main")
+  .option("--thinking <level>", "Thinking level: off | low | medium | high")
+  .action(async (opts) => {
+    const { readFile } = await import("node:fs/promises");
+
+    // Read gateway token from openclaw.json so the TUI can authenticate
+    let termEnv = { ...ocEnv };
+    try {
+      const raw = JSON.parse(await readFile(resolve(STATE_DIR, "openclaw.json"), "utf-8"));
+      if (raw.gateway?.auth?.token) {
+        termEnv.OPENCLAW_GATEWAY_TOKEN = raw.gateway.auth.token;
+      }
+    } catch {}
+
+    const args = ["tui"];
+    if (opts.session) args.push("--session", opts.session);
+    if (opts.thinking) args.push("--thinking", opts.thinking);
+    const code = await execBranded(OPENCLAW_BIN, args, { env: termEnv });
+    process.exit(code);
+  });
+
+program
+  .command("gateway")
+  .description("Run the LeedAB gateway (foreground)")
+  .action(async () => {
+    console.log(chalk.bold("\n  LeedAB Gateway\n"));
+    const code = await execBranded(OPENCLAW_BIN, ["gateway", "run"], { env: ocEnv });
+    process.exit(code);
+  });
+
+program
+  .command("stop")
+  .description("Stop the LeedAB agent")
+  .action(async () => {
+    await stopGateway();
+    console.log(chalk.green("LeedAB agent stopped."));
+  });
+
+const pairing = program
+  .command("pairing")
+  .description("Manage channel pairing (approve users to message the agent)");
+
+pairing
+  .command("approve <channel> <code>")
+  .description("Approve a pairing request (e.g. leedab pairing approve telegram 67D9348E)")
+  .action(async (channel, code) => {
+    const codeResult = await execBranded(OPENCLAW_BIN, ["pairing", "approve", channel, code], { env: ocEnv });
+    process.exit(codeResult);
+  });
+
+pairing
+  .command("list")
+  .description("List pending pairing requests")
+  .action(async () => {
+    const code = await execBranded(OPENCLAW_BIN, ["pairing", "list"], { env: ocEnv });
+    process.exit(code);
+  });
+
+pairing
+  .command("add <channel> <userId>")
+  .description("Add a user to a channel's allowlist (e.g. leedab pairing add telegram 6549960466)")
+  .action(async (channel, userId) => {
+    const { readFile, writeFile } = await import("node:fs/promises");
+    const { resolve } = await import("node:path");
+    const configPath = resolve(STATE_DIR, "openclaw.json");
+
+    try {
+      const config = JSON.parse(await readFile(configPath, "utf-8"));
+      if (!config.channels?.[channel]) {
+        console.error(chalk.red(`Channel "${channel}" not found in config.`));
+        process.exit(1);
+      }
+
+      if (!config.channels[channel].allowFrom) {
+        config.channels[channel].allowFrom = [];
+      }
+
+      if (config.channels[channel].allowFrom.includes(userId)) {
+        console.log(chalk.yellow(`User ${userId} is already allowed on ${channel}.`));
+        return;
+      }
+
+      config.channels[channel].allowFrom.push(userId);
+      config.channels[channel].dmPolicy = "allowlist";
+      await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+      console.log(chalk.green(`Added ${chalk.bold(userId)} to ${channel} allowlist.`));
+
+      // Auto-restart gateway if running
+      try {
+        const { execFile: ef } = await import("node:child_process");
+        const { promisify: p } = await import("node:util");
+        await p(ef)(OPENCLAW_BIN, ["gateway", "health"], { env: ocEnv, timeout: 3000 });
+        // Gateway is running, restart it
+        const spin = ora("Restarting gateway...").start();
+        await p(ef)(OPENCLAW_BIN, ["gateway", "restart"], { env: ocEnv, timeout: 10000 });
+        spin.succeed(chalk.green("Gateway restarted. Change is live."));
+      } catch {
+        // Gateway not running, no restart needed
+      }
+    } catch (err) {
+      console.error(chalk.red(`Failed: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
+pairing
+  .command("remove <channel> <userId>")
+  .description("Remove a user from a channel's allowlist")
+  .action(async (channel, userId) => {
+    const { readFile, writeFile } = await import("node:fs/promises");
+    const { resolve } = await import("node:path");
+    const configPath = resolve(STATE_DIR, "openclaw.json");
+
+    try {
+      const config = JSON.parse(await readFile(configPath, "utf-8"));
+      const list = config.channels?.[channel]?.allowFrom;
+      if (!list || !list.includes(userId)) {
+        console.error(chalk.red(`User ${userId} not found in ${channel} allowlist.`));
+        process.exit(1);
+      }
+
+      config.channels[channel].allowFrom = list.filter((id) => id !== userId);
+      await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+      console.log(chalk.green(`Removed ${chalk.bold(userId)} from ${channel} allowlist.`));
+
+      // Auto-restart gateway if running
+      try {
+        const { execFile: ef } = await import("node:child_process");
+        const { promisify: p } = await import("node:util");
+        await p(ef)(OPENCLAW_BIN, ["gateway", "health"], { env: ocEnv, timeout: 3000 });
+        const spin = ora("Restarting gateway...").start();
+        await p(ef)(OPENCLAW_BIN, ["gateway", "restart"], { env: ocEnv, timeout: 10000 });
+        spin.succeed(chalk.green("Gateway restarted. Change is live."));
+      } catch {
+        // Gateway not running, no restart needed
+      }
+    } catch (err) {
+      console.error(chalk.red(`Failed: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("channels")
+  .description("List configured channels and their status")
+  .option("-c, --config <path>", "Path to config file", "leedab.config.json")
+  .action(async (opts) => {
+    const config = await loadConfig(opts.config);
+    await setupChannels(config);
+  });
+
+const sessions = program
+  .command("sessions")
+  .description("Manage conversation sessions");
+
+sessions
+  .command("list")
+  .description("List all sessions")
+  .action(async () => {
+    const code = await execBranded(OPENCLAW_BIN, ["sessions", "--json"], { env: ocEnv });
+    // If branded exec didn't output, fallback
+    if (code !== 0) {
+      console.log(chalk.dim("No sessions found."));
+    }
+  });
+
+sessions
+  .command("delete <key>")
+  .description("Delete a session by key (e.g. test21)")
+  .action(async (key) => {
+    const { readFile, writeFile, unlink } = await import("node:fs/promises");
+    const { resolve } = await import("node:path");
+    const storePath = resolve(STATE_DIR, "agents", "main", "sessions", "sessions.json");
+
+    let store;
+    try {
+      store = JSON.parse(await readFile(storePath, "utf-8"));
+    } catch {
+      console.error(chalk.red("No sessions store found."));
+      process.exit(1);
+    }
+
+    // Match by key suffix (user types "test21", actual key is "agent:main:test21")
+    const entries = Object.entries(store.sessions || {});
+    const match = entries.find(([k]) => k === key || k === `agent:main:${key}` || k.endsWith(`:${key}`));
+
+    if (!match) {
+      console.error(chalk.red(`No session found matching "${key}"`));
+      console.log(chalk.dim("Available: " + entries.map(([k]) => k.replace("agent:main:", "")).join(", ")));
+      process.exit(1);
+    }
+
+    const [fullKey, session] = match;
+
+    // Delete transcript file
+    if (session.sessionId) {
+      const transcript = resolve(STATE_DIR, "agents", "main", "sessions", `${session.sessionId}.jsonl`);
+      try { await unlink(transcript); } catch {}
+    }
+
+    // Remove from store
+    delete store.sessions[fullKey];
+    await writeFile(storePath, JSON.stringify(store, null, 2) + "\n");
+
+    console.log(chalk.green(`Deleted session ${chalk.bold(fullKey)}`));
+  });
+
+sessions
+  .command("clear")
+  .description("Delete all sessions")
+  .action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const { confirm } = await inquirer.prompt([
+      { type: "confirm", name: "confirm", message: "Delete all sessions?", default: false },
+    ]);
+    if (!confirm) return;
+
+    const { readFile, writeFile, readdir, unlink } = await import("node:fs/promises");
+    const { resolve } = await import("node:path");
+    const sessionsDir = resolve(STATE_DIR, "agents", "main", "sessions");
+
+    // Delete all transcript files
+    try {
+      const files = await readdir(sessionsDir);
+      for (const f of files) {
+        if (f.endsWith(".jsonl")) {
+          await unlink(resolve(sessionsDir, f));
+        }
+      }
+    } catch {}
+
+    // Reset sessions store
+    const storePath = resolve(sessionsDir, "sessions.json");
+    try {
+      const store = JSON.parse(await readFile(storePath, "utf-8"));
+      store.sessions = {};
+      await writeFile(storePath, JSON.stringify(store, null, 2) + "\n");
+    } catch {}
+
+    console.log(chalk.green("All sessions deleted."));
+  });
+
+const vault = program
+  .command("vault")
+  .description("Manage credentials the agent can use for browser login");
+
+vault
+  .command("add <service>")
+  .description("Add or update credentials for a service")
+  .option("-u, --url <url>", "Login URL")
+  .option("-e, --email <email>", "Username or email")
+  .option("-p, --password <password>", "Password")
+  .option("-n, --notes <notes>", "Extra notes for the agent")
+  .action(async (service, opts) => {
+    if (!opts.email && !opts.password && !opts.url) {
+      console.error(chalk.red("Provide at least one of --email, --password, or --url"));
+      process.exit(1);
+    }
+    await addEntry(service, {
+      url: opts.url,
+      username: opts.email,
+      password: opts.password,
+      notes: opts.notes,
+    });
+    console.log(chalk.green(`Saved credentials for ${chalk.bold(service)}`));
+  });
+
+vault
+  .command("list")
+  .description("List stored services (passwords hidden)")
+  .action(async () => {
+    const entries = await listEntries();
+    if (entries.length === 0) {
+      console.log(chalk.dim("No credentials stored. Use `leedab vault add <service>` to add some."));
+      return;
+    }
+    console.log(chalk.bold("\n  Stored Credentials\n"));
+    for (const e of entries) {
+      console.log(`  ${chalk.cyan(e.service)}${e.url ? chalk.dim(` — ${e.url}`) : ""}${e.username ? chalk.dim(` (${e.username})`) : ""}`);
+    }
+    console.log();
+  });
+
+vault
+  .command("remove <service>")
+  .description("Remove credentials for a service")
+  .action(async (service) => {
+    const removed = await removeEntry(service);
+    if (removed) {
+      console.log(chalk.green(`Removed credentials for ${chalk.bold(service)}`));
+    } else {
+      console.error(chalk.red(`No credentials found for "${service}"`));
+      process.exit(1);
+    }
+  });
+
+vault
+  .command("encrypt")
+  .description("Encrypt the vault with a master password")
+  .action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const { password } = await inquirer.prompt([
+      {
+        type: "password",
+        name: "password",
+        message: "Master password:",
+        mask: "*",
+        validate: (v) => v.length >= 8 || "Must be at least 8 characters",
+      },
+    ]);
+    const { confirm } = await inquirer.prompt([
+      { type: "password", name: "confirm", message: "Confirm password:", mask: "*" },
+    ]);
+    if (password !== confirm) {
+      console.error(chalk.red("Passwords do not match"));
+      process.exit(1);
+    }
+    await encryptVault(password);
+    console.log(chalk.green("Vault encrypted. Set LEEDAB_VAULT_KEY env var for auto-decrypt."));
+  });
+
+vault
+  .command("decrypt")
+  .description("Decrypt the vault back to plaintext")
+  .action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const { password } = await inquirer.prompt([
+      { type: "password", name: "password", message: "Master password:", mask: "*" },
+    ]);
+    try {
+      await decryptVault(password);
+      console.log(chalk.green("Vault decrypted to plaintext."));
+    } catch (err) {
+      console.error(chalk.red(`Decryption failed: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
+const team = program
+  .command("team")
+  .description("Manage team members");
+
+team
+  .command("list")
+  .description("List team members")
+  .action(async () => {
+    const members = await loadTeam();
+    if (members.length === 0) {
+      console.log(chalk.dim("No team members. Use `leedab team add <name>` to add someone."));
+      return;
+    }
+    console.log(chalk.bold("\n  Team Members\n"));
+    for (const m of members) {
+      const role = m.role === "admin" ? chalk.hex("#AE5630")(m.role) : m.role === "operator" ? chalk.green(m.role) : chalk.dim(m.role);
+      console.log(`  ${chalk.cyan(m.name)} — ${role}${m.email ? chalk.dim(` (${m.email})`) : ""}`);
+    }
+    console.log();
+  });
+
+team
+  .command("add <name>")
+  .description("Add a team member")
+  .option("-e, --email <email>", "Email address")
+  .option("-r, --role <role>", "Role: admin, operator, viewer", "operator")
+  .action(async (name, opts) => {
+    const member = await addMember({
+      name,
+      email: opts.email,
+      role: opts.role,
+      channels: [],
+    });
+    console.log(chalk.green(`Added ${chalk.bold(name)} as ${opts.role} (${member.id})`));
+  });
+
+team
+  .command("remove <id>")
+  .description("Remove a team member by ID")
+  .action(async (id) => {
+    const removed = await removeMember(id);
+    if (removed) {
+      console.log(chalk.green("Member removed."));
+    } else {
+      console.error(chalk.red(`No member found with ID "${id}"`));
+      process.exit(1);
+    }
+  });
+
+// Default action: show status if in a project, nudge to onboard if not
+if (process.argv.length <= 2) {
+  const hasProject = existsSync(resolve("leedab.config.json")) || existsSync(STATE_DIR);
+  if (!hasProject) {
+    console.log(chalk.bold("\n  LeedAB") + chalk.dim(" — Your enterprise AI agent\n"));
+    console.log(chalk.dim("  Get started:\n"));
+    console.log(`  ${chalk.cyan("leedab onboard")}    Interactive setup wizard`);
+    console.log(`  ${chalk.cyan("leedab init")}       Quick init with defaults`);
+    console.log(`  ${chalk.cyan("leedab --help")}     All commands\n`);
+    process.exit(0);
+  } else {
+    // Show project status
+    (async () => {
+      try {
+        const config = await loadConfig("leedab.config.json");
+        const channels = Object.entries(config.channels)
+          .filter(([_, v]) => v?.enabled)
+          .map(([k]) => k);
+
+        // Check if gateway is running
+        let gatewayUp = false;
+        try {
+          const { execFile: ef } = await import("node:child_process");
+          const { promisify: p } = await import("node:util");
+          await p(ef)(OPENCLAW_BIN, ["gateway", "health"], { env: ocEnv, timeout: 3000 });
+          gatewayUp = true;
+        } catch {}
+
+        console.log(chalk.bold("\n  LeedAB") + chalk.dim(` — ${config.agent.name}\n`));
+        console.log(`  Status     ${gatewayUp ? chalk.green("running") : chalk.yellow("stopped")}`);
+        console.log(`  Model      ${chalk.cyan(config.agent.model)}`);
+        if (channels.length > 0) {
+          console.log(`  Channels   ${channels.join(", ")}`);
+        }
+        console.log();
+        if (!gatewayUp) {
+          console.log(`  ${chalk.cyan("leedab start")}      Start the agent`);
+        } else {
+          console.log(`  ${chalk.cyan("leedab terminal")}   Chat with your agent`);
+          console.log(`  ${chalk.cyan("leedab stop")}       Stop the agent`);
+        }
+        console.log(`  ${chalk.cyan("leedab --help")}     All commands`);
+        console.log();
+      } catch {
+        program.parse();
+      }
+    })();
+  }
+} else {
+  program.parse();
+}

package/dist/analytics.d.ts

@@ -0,0 +1,20 @@
+export interface AnalyticsSummary {
+    messagesPerDay: {
+        date: string;
+        count: number;
+    }[];
+    avgResponseTimeMs: number;
+    topQueries: {
+        query: string;
+        count: number;
+    }[];
+    channelBreakdown: {
+        channel: string;
+        count: number;
+        percentage: number;
+    }[];
+    activeUsers: number;
+    totalMessages: number;
+    periodDays: number;
+}
+export declare function getAnalytics(days?: number): Promise<AnalyticsSummary>;

package/dist/analytics.js

@@ -0,0 +1,57 @@
+import { readAuditLog } from "./audit.js";
+export async function getAnalytics(days = 30) {
+    const since = new Date();
+    since.setDate(since.getDate() - days);
+    const entries = await readAuditLog({ since });
+    // Messages per day
+    const byDay = new Map();
+    for (const e of entries) {
+        const date = e.timestamp.slice(0, 10); // YYYY-MM-DD
+        byDay.set(date, (byDay.get(date) ?? 0) + 1);
+    }
+    const messagesPerDay = Array.from(byDay.entries())
+        .map(([date, count]) => ({ date, count }))
+        .sort((a, b) => a.date.localeCompare(b.date));
+    // Average response time
+    const withDuration = entries.filter((e) => e.durationMs != null);
+    const avgResponseTimeMs = withDuration.length > 0
+        ? Math.round(withDuration.reduce((sum, e) => sum + (e.durationMs ?? 0), 0) /
+            withDuration.length)
+        : 0;
+    // Top queries (by first 50 chars, deduplicated)
+    const queryMap = new Map();
+    for (const e of entries) {
+        if (e.query) {
+            const key = e.query.slice(0, 50).toLowerCase().trim();
+            queryMap.set(key, (queryMap.get(key) ?? 0) + 1);
+        }
+    }
+    const topQueries = Array.from(queryMap.entries())
+        .map(([query, count]) => ({ query, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 10);
+    // Channel breakdown
+    const channelMap = new Map();
+    for (const e of entries) {
+        channelMap.set(e.channel, (channelMap.get(e.channel) ?? 0) + 1);
+    }
+    const total = entries.length || 1;
+    const channelBreakdown = Array.from(channelMap.entries())
+        .map(([channel, count]) => ({
+        channel,
+        count,
+        percentage: Math.round((count / total) * 100),
+    }))
+        .sort((a, b) => b.count - a.count);
+    // Active users
+    const users = new Set(entries.map((e) => e.user));
+    return {
+        messagesPerDay,
+        avgResponseTimeMs,
+        topQueries,
+        channelBreakdown,
+        activeUsers: users.size,
+        totalMessages: entries.length,
+        periodDays: days,
+    };
+}