leedab 0.1.0

package/dist/audit.d.ts

@@ -0,0 +1,15 @@
+export interface AuditEntry {
+    timestamp: string;
+    user: string;
+    channel: string;
+    action: string;
+    query?: string;
+    responseSummary?: string;
+    durationMs?: number;
+}
+export declare function logAudit(entry: AuditEntry): Promise<void>;
+export declare function readAuditLog(options?: {
+    since?: Date;
+    channel?: string;
+    limit?: number;
+}): Promise<AuditEntry[]>;

package/dist/audit.js

@@ -0,0 +1,46 @@
+import { appendFile, readFile, mkdir } from "node:fs/promises";
+import { resolve, dirname } from "node:path";
+const AUDIT_PATH = resolve(".leedab", "logs", "audit.jsonl");
+export async function logAudit(entry) {
+    await mkdir(dirname(AUDIT_PATH), { recursive: true });
+    const line = JSON.stringify({
+        ...entry,
+        timestamp: entry.timestamp || new Date().toISOString(),
+    });
+    await appendFile(AUDIT_PATH, line + "\n", "utf-8");
+}
+export async function readAuditLog(options) {
+    let raw;
+    try {
+        raw = await readFile(AUDIT_PATH, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    let entries = raw
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter(Boolean);
+    if (options?.since) {
+        const since = options.since.toISOString();
+        entries = entries.filter((e) => e.timestamp >= since);
+    }
+    if (options?.channel) {
+        entries = entries.filter((e) => e.channel === options.channel);
+    }
+    // Most recent first
+    entries.reverse();
+    if (options?.limit) {
+        entries = entries.slice(0, options.limit);
+    }
+    return entries;
+}

package/dist/brand.d.ts

@@ -0,0 +1,9 @@
+import { type ChildProcess, type SpawnOptions } from "node:child_process";
+/**
+ * Spawn a gateway command with LeedAB branding applied to all output.
+ */
+export declare function spawnBranded(bin: string, args: string[], options?: SpawnOptions): ChildProcess;
+/**
+ * Run a gateway command with branded output and wait for exit.
+ */
+export declare function execBranded(bin: string, args: string[], options?: SpawnOptions): Promise<number>;

package/dist/brand.js

@@ -0,0 +1,57 @@
+import { spawn } from "node:child_process";
+import { Transform } from "node:stream";
+const REPLACEMENTS = [
+    [/🦞 OpenClaw \d{4}\.\d+\.\d+ \([a-f0-9]+\)/g, "LeedAB"],
+    [/🦞 OpenClaw/g, "LeedAB"],
+    [/OpenClaw/g, "LeedAB"],
+    [/openclaw/g, "leedab"],
+    [/leedab tui/g, "leedab terminal"],
+    [/🦞/g, ""],
+];
+// Motd quips — strip the " — <quip>" after the version line
+const MOTD_PATTERN = /LeedAB\s*\n\s{3}.+\n/g;
+function createBrandTransform() {
+    return new Transform({
+        transform(chunk, _encoding, callback) {
+            let text = chunk.toString();
+            // Strip the full banner block: "🦞 OpenClaw 2026.x.x (hash) — quip\n\n"
+            text = text.replace(/🦞 OpenClaw \d{4}\.\d+\.\d+ \([a-f0-9]+\)[^\n]*\n\s*[^\n]*\n\n?/g, "");
+            // Catch any remaining OpenClaw references
+            for (const [pattern, replacement] of REPLACEMENTS) {
+                text = text.replace(pattern, replacement);
+            }
+            // Collapse 3+ consecutive newlines into 2
+            text = text.replace(/\n{3,}/g, "\n\n");
+            // Strip leading blank lines
+            if (text.match(/^\n+$/))
+                text = "";
+            callback(null, text);
+        },
+    });
+}
+/**
+ * Spawn a gateway command with LeedAB branding applied to all output.
+ */
+export function spawnBranded(bin, args, options = {}) {
+    const child = spawn(bin, args, {
+        ...options,
+        stdio: ["inherit", "pipe", "pipe"],
+    });
+    if (child.stdout) {
+        child.stdout.pipe(createBrandTransform()).pipe(process.stdout);
+    }
+    if (child.stderr) {
+        child.stderr.pipe(createBrandTransform()).pipe(process.stderr);
+    }
+    return child;
+}
+/**
+ * Run a gateway command with branded output and wait for exit.
+ */
+export function execBranded(bin, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawnBranded(bin, args, options);
+        child.on("close", (code) => resolve(code ?? 1));
+        child.on("error", reject);
+    });
+}

package/dist/channels/index.d.ts

@@ -0,0 +1,5 @@
+import type { LeedABConfig } from "../config/schema.js";
+/**
+ * List channel status and print a summary table.
+ */
+export declare function setupChannels(config: LeedABConfig): Promise<void>;

package/dist/channels/index.js

@@ -0,0 +1,47 @@
+import chalk from "chalk";
+/**
+ * List channel status and print a summary table.
+ */
+export async function setupChannels(config) {
+    const channels = [
+        {
+            name: "Telegram",
+            enabled: config.channels.telegram?.enabled ?? false,
+            status: config.channels.telegram?.enabled ? "connected" : "unconfigured",
+        },
+        {
+            name: "WhatsApp",
+            enabled: config.channels.whatsapp?.enabled ?? false,
+            status: config.channels.whatsapp?.enabled
+                ? config.channels.whatsapp?.phone
+                    ? "connected"
+                    : "disconnected"
+                : "unconfigured",
+        },
+        {
+            name: "Teams",
+            enabled: config.channels.teams?.enabled ?? false,
+            status: config.channels.teams?.enabled
+                ? config.channels.teams?.appId
+                    ? "connected"
+                    : "disconnected"
+                : "unconfigured",
+        },
+    ];
+    console.log(chalk.bold("\nChannels:"));
+    for (const ch of channels) {
+        const icon = statusIcon(ch.status);
+        console.log(`  ${icon} ${ch.name}: ${ch.status}`);
+    }
+    console.log();
+}
+function statusIcon(status) {
+    switch (status) {
+        case "connected":
+            return chalk.green("●");
+        case "disconnected":
+            return chalk.yellow("○");
+        default:
+            return chalk.dim("○");
+    }
+}

package/dist/config/index.d.ts

@@ -0,0 +1,10 @@
+import { type LeedABConfig } from "./schema.js";
+export { type LeedABConfig } from "./schema.js";
+/**
+ * Load and validate a LeedAB config file, merging with defaults.
+ */
+export declare function loadConfig(configPath?: string): Promise<LeedABConfig>;
+/**
+ * Write default config to leedab.config.json.
+ */
+export declare function initConfig(): Promise<void>;

package/dist/config/index.js

@@ -0,0 +1,49 @@
+import { readFile, writeFile, access } from "node:fs/promises";
+import { resolve } from "node:path";
+import { DEFAULT_CONFIG } from "./schema.js";
+/**
+ * Load and validate a LeedAB config file, merging with defaults.
+ */
+export async function loadConfig(configPath = "leedab.config.json") {
+    const fullPath = resolve(configPath);
+    let userConfig = {};
+    try {
+        const raw = await readFile(fullPath, "utf-8");
+        userConfig = JSON.parse(raw);
+    }
+    catch {
+        console.warn(`No config at ${fullPath}, using defaults.`);
+    }
+    return deepMerge(DEFAULT_CONFIG, userConfig);
+}
+/**
+ * Write default config to leedab.config.json.
+ */
+export async function initConfig() {
+    const configPath = resolve("leedab.config.json");
+    try {
+        await access(configPath);
+        throw new Error("leedab.config.json already exists");
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    await writeFile(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n");
+}
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        if (source[key] &&
+            typeof source[key] === "object" &&
+            !Array.isArray(source[key]) &&
+            target[key] &&
+            typeof target[key] === "object") {
+            result[key] = deepMerge(target[key], source[key]);
+        }
+        else {
+            result[key] = source[key];
+        }
+    }
+    return result;
+}

package/dist/config/schema.d.ts

@@ -0,0 +1,58 @@
+export interface WhatsAppChannelConfig {
+    enabled: boolean;
+    /** Phone number to register with Baileys */
+    phone?: string;
+    /** Groups to listen in (empty = DMs only) */
+    groups?: string[];
+    /** DM policy: "open" | "pairing" | "closed" */
+    dmPolicy?: "open" | "pairing" | "closed";
+}
+export interface TelegramChannelConfig {
+    enabled: boolean;
+    /** Bot token from @BotFather */
+    token?: string;
+}
+export interface TeamsChannelConfig {
+    enabled: boolean;
+    /** Azure AD app ID */
+    appId?: string;
+    /** Tenant ID */
+    tenantId?: string;
+}
+export interface GatewayConfig {
+    port: number;
+    host: string;
+    auth?: {
+        mode: "none" | "token" | "tailscale";
+        token?: string;
+    };
+}
+export interface MemoryConfig {
+    /** Path to memory directory (default: .leedab/memory) */
+    dir: string;
+    /** Enable vector search if embedding provider is set */
+    vectorSearch: boolean;
+}
+export interface AgentConfig {
+    /** Agent display name */
+    name: string;
+    /** Default model to use */
+    model: string;
+    /** Path to SOUL.md personality file */
+    soulPath: string;
+    /** Thinking level: "none" | "low" | "medium" | "high" */
+    thinkingLevel: "none" | "low" | "medium" | "high";
+    /** Industry vertical for pre-configured templates */
+    vertical?: "general" | "supply-chain";
+}
+export interface LeedABConfig {
+    agent: AgentConfig;
+    gateway: GatewayConfig;
+    memory: MemoryConfig;
+    channels: {
+        whatsapp?: WhatsAppChannelConfig;
+        telegram?: TelegramChannelConfig;
+        teams?: TeamsChannelConfig;
+    };
+}
+export declare const DEFAULT_CONFIG: LeedABConfig;

package/dist/config/schema.js

@@ -0,0 +1,21 @@
+export const DEFAULT_CONFIG = {
+    agent: {
+        name: "LeedAB",
+        model: "claude-sonnet-4-6",
+        soulPath: "./SOUL.md",
+        thinkingLevel: "medium",
+    },
+    gateway: {
+        port: 18789,
+        host: "127.0.0.1",
+    },
+    memory: {
+        dir: ".leedab/memory",
+        vectorSearch: false,
+    },
+    channels: {
+        whatsapp: { enabled: false },
+        telegram: { enabled: false },
+        teams: { enabled: false },
+    },
+};

package/dist/dashboard/routes.d.ts

@@ -0,0 +1,5 @@
+import { type IncomingMessage, type ServerResponse } from "node:http";
+import type { LeedABConfig } from "../config/schema.js";
+type RouteHandler = (req: IncomingMessage, res: ServerResponse, url: URL) => Promise<void>;
+export declare function createRoutes(config: LeedABConfig): Record<string, RouteHandler>;
+export {};