pretticlaw 0.1.0

package/dist/agent/tools/spawn.js

@@ -0,0 +1,35 @@
+import { Tool } from "./base.js";
+export class SpawnTool extends Tool {
+    manager;
+    name = "spawn";
+    description = "Spawn a subagent to handle a task in the background.";
+    parameters = {
+        type: "object",
+        properties: {
+            task: { type: "string", description: "The task for the subagent to complete" },
+            label: { type: "string", description: "Optional short label" },
+        },
+        required: ["task"],
+    };
+    originChannel = "cli";
+    originChatId = "direct";
+    sessionKey = "cli:direct";
+    constructor(manager) {
+        super();
+        this.manager = manager;
+    }
+    setContext(channel, chatId) {
+        this.originChannel = channel;
+        this.originChatId = chatId;
+        this.sessionKey = `${channel}:${chatId}`;
+    }
+    async execute(args) {
+        return this.manager.spawn({
+            task: String(args.task ?? ""),
+            label: args.label != null ? String(args.label) : null,
+            originChannel: this.originChannel,
+            originChatId: this.originChatId,
+            sessionKey: this.sessionKey,
+        });
+    }
+}

package/dist/agent/tools/web.d.ts

@@ -0,0 +1,50 @@
+import { Tool } from "./base.js";
+export declare class WebSearchTool extends Tool {
+    private readonly apiKey;
+    private readonly maxResults;
+    readonly name = "web_search";
+    readonly description = "Search the web. Returns titles, URLs, and snippets.";
+    readonly parameters: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            count: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    constructor(apiKey: string | null, maxResults?: number);
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+export declare class WebFetchTool extends Tool {
+    private readonly maxChars;
+    readonly name = "web_fetch";
+    readonly description = "Fetch URL and extract readable content (HTML to markdown/text).";
+    readonly parameters: {
+        type: string;
+        properties: {
+            url: {
+                type: string;
+                description: string;
+            };
+            extractMode: {
+                type: string;
+                enum: string[];
+            };
+            maxChars: {
+                type: string;
+                minimum: number;
+            };
+        };
+        required: string[];
+    };
+    constructor(maxChars?: number);
+    execute(args: Record<string, unknown>): Promise<string>;
+}

package/dist/agent/tools/web.js

@@ -0,0 +1,119 @@
+import { Tool } from "./base.js";
+function stripTags(text) {
+    return text.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, "").trim();
+}
+function normalize(text) {
+    return text.replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+function validateUrl(url) {
+    try {
+        const u = new URL(url);
+        if (!["http:", "https:"].includes(u.protocol))
+            return [false, `Only http/https allowed, got '${u.protocol.replace(":", "")}'`];
+        if (!u.hostname)
+            return [false, "Missing domain"];
+        return [true, ""];
+    }
+    catch (err) {
+        return [false, String(err)];
+    }
+}
+export class WebSearchTool extends Tool {
+    apiKey;
+    maxResults;
+    name = "web_search";
+    description = "Search the web. Returns titles, URLs, and snippets.";
+    parameters = {
+        type: "object",
+        properties: { query: { type: "string", description: "Search query" }, count: { type: "integer", minimum: 1, maximum: 10, description: "Results (1-10)" } },
+        required: ["query"],
+    };
+    constructor(apiKey, maxResults = 5) {
+        super();
+        this.apiKey = apiKey;
+        this.maxResults = maxResults;
+    }
+    async execute(args) {
+        const query = String(args.query ?? "");
+        const count = Math.min(Math.max(Number(args.count ?? this.maxResults), 1), 10);
+        const key = this.apiKey || process.env.BRAVE_API_KEY || "";
+        if (!key)
+            return "Error: Brave Search API key not configured. Set tools.web.search.apiKey or BRAVE_API_KEY.";
+        try {
+            const url = new URL("https://api.search.brave.com/res/v1/web/search");
+            url.searchParams.set("q", query);
+            url.searchParams.set("count", String(count));
+            const res = await fetch(url, { headers: { Accept: "application/json", "X-Subscription-Token": key } });
+            if (!res.ok)
+                return `Error: ${res.status} ${res.statusText}`;
+            const json = await res.json();
+            const results = json.web?.results ?? [];
+            if (!results.length)
+                return `No results for: ${query}`;
+            const lines = [`Results for: ${query}`, ""];
+            results.slice(0, count).forEach((item, i) => {
+                lines.push(`${i + 1}. ${item.title ?? ""}`);
+                lines.push(`   ${item.url ?? ""}`);
+                if (item.description)
+                    lines.push(`   ${item.description}`);
+            });
+            return lines.join("\n");
+        }
+        catch (err) {
+            return `Error: ${String(err)}`;
+        }
+    }
+}
+export class WebFetchTool extends Tool {
+    maxChars;
+    name = "web_fetch";
+    description = "Fetch URL and extract readable content (HTML to markdown/text).";
+    parameters = {
+        type: "object",
+        properties: {
+            url: { type: "string", description: "URL to fetch" },
+            extractMode: { type: "string", enum: ["markdown", "text"] },
+            maxChars: { type: "integer", minimum: 100 },
+        },
+        required: ["url"],
+    };
+    constructor(maxChars = 50000) {
+        super();
+        this.maxChars = maxChars;
+    }
+    async execute(args) {
+        const url = String(args.url ?? "");
+        const extractMode = String(args.extractMode ?? "markdown");
+        const maxChars = Number(args.maxChars ?? this.maxChars);
+        const [ok, err] = validateUrl(url);
+        if (!ok)
+            return JSON.stringify({ error: `URL validation failed: ${err}`, url });
+        try {
+            const res = await fetch(url, { redirect: "follow", headers: { "User-Agent": "Mozilla/5.0" } });
+            const ctype = res.headers.get("content-type") || "";
+            let text = "";
+            let extractor = "raw";
+            if (ctype.includes("application/json")) {
+                text = JSON.stringify(await res.json(), null, 2);
+                extractor = "json";
+            }
+            else {
+                const raw = await res.text();
+                if (ctype.includes("text/html") || /^\s*<!doctype|^\s*<html/i.test(raw.slice(0, 256))) {
+                    const content = extractMode === "text" ? stripTags(raw) : normalize(stripTags(raw));
+                    text = content;
+                    extractor = "html";
+                }
+                else {
+                    text = raw;
+                }
+            }
+            const truncated = text.length > maxChars;
+            const sliced = truncated ? text.slice(0, maxChars) : text;
+            return JSON.stringify({ url, finalUrl: res.url, status: res.status, extractor, truncated, length: sliced.length, text: sliced });
+        }
+        catch (e) {
+            return JSON.stringify({ error: String(e), url });
+        }
+    }
+}

package/dist/bus/async-queue.d.ts

@@ -0,0 +1,7 @@
+export declare class AsyncQueue<T> {
+    private items;
+    private waiters;
+    push(v: T): void;
+    pop(): Promise<T>;
+    size(): number;
+}

package/dist/bus/async-queue.js

@@ -0,0 +1,20 @@
+export class AsyncQueue {
+    items = [];
+    waiters = [];
+    push(v) {
+        const waiter = this.waiters.shift();
+        if (waiter)
+            waiter(v);
+        else
+            this.items.push(v);
+    }
+    async pop() {
+        const item = this.items.shift();
+        if (item !== undefined)
+            return item;
+        return new Promise((resolve) => this.waiters.push(resolve));
+    }
+    size() {
+        return this.items.length;
+    }
+}

package/dist/bus/events.d.ts

@@ -0,0 +1,19 @@
+export interface InboundMessage {
+    channel: string;
+    senderId: string;
+    chatId: string;
+    content: string;
+    timestamp?: Date;
+    media?: string[];
+    metadata?: Record<string, unknown>;
+    sessionKeyOverride?: string;
+}
+export interface OutboundMessage {
+    channel: string;
+    chatId: string;
+    content: string;
+    replyTo?: string;
+    media?: string[];
+    metadata?: Record<string, unknown>;
+}
+export declare function sessionKey(msg: InboundMessage): string;

package/dist/bus/events.js

@@ -0,0 +1,3 @@
+export function sessionKey(msg) {
+    return msg.sessionKeyOverride ?? `${msg.channel}:${msg.chatId}`;
+}

package/dist/bus/queue.d.ts

@@ -0,0 +1,12 @@
+import { AsyncQueue } from "./async-queue.js";
+import type { InboundMessage, OutboundMessage } from "./events.js";
+export declare class MessageBus {
+    readonly inbound: AsyncQueue<InboundMessage>;
+    readonly outbound: AsyncQueue<OutboundMessage>;
+    publishInbound(msg: InboundMessage): Promise<void>;
+    consumeInbound(): Promise<InboundMessage>;
+    publishOutbound(msg: OutboundMessage): Promise<void>;
+    consumeOutbound(): Promise<OutboundMessage>;
+    get inboundSize(): number;
+    get outboundSize(): number;
+}

package/dist/bus/queue.js

@@ -0,0 +1,23 @@
+import { AsyncQueue } from "./async-queue.js";
+export class MessageBus {
+    inbound = new AsyncQueue();
+    outbound = new AsyncQueue();
+    async publishInbound(msg) {
+        this.inbound.push(msg);
+    }
+    async consumeInbound() {
+        return this.inbound.pop();
+    }
+    async publishOutbound(msg) {
+        this.outbound.push(msg);
+    }
+    async consumeOutbound() {
+        return this.outbound.pop();
+    }
+    get inboundSize() {
+        return this.inbound.size();
+    }
+    get outboundSize() {
+        return this.outbound.size();
+    }
+}

package/dist/channels/base.d.ts

@@ -0,0 +1,22 @@
+import type { MessageBus } from "../bus/queue.js";
+import type { OutboundMessage } from "../bus/events.js";
+export declare abstract class BaseChannel<TConfig = unknown> {
+    protected readonly config: TConfig;
+    protected readonly bus: MessageBus;
+    protected running: boolean;
+    constructor(config: TConfig, bus: MessageBus);
+    abstract readonly name: string;
+    abstract start(): Promise<void>;
+    abstract stop(): Promise<void>;
+    abstract send(msg: OutboundMessage): Promise<void>;
+    protected isAllowed(senderId: string): boolean;
+    protected handleMessage(input: {
+        senderId: string;
+        chatId: string;
+        content: string;
+        media?: string[];
+        metadata?: Record<string, unknown>;
+        sessionKey?: string;
+    }): Promise<void>;
+    get isRunning(): boolean;
+}

package/dist/channels/base.js

@@ -0,0 +1,35 @@
+export class BaseChannel {
+    config;
+    bus;
+    running = false;
+    constructor(config, bus) {
+        this.config = config;
+        this.bus = bus;
+    }
+    isAllowed(senderId) {
+        const allowFrom = (this.config?.allowFrom ?? []);
+        if (!allowFrom.length)
+            return true;
+        if (allowFrom.includes(String(senderId)))
+            return true;
+        if (String(senderId).includes("|"))
+            return String(senderId).split("|").some((p) => allowFrom.includes(p));
+        return false;
+    }
+    async handleMessage(input) {
+        if (!this.isAllowed(input.senderId))
+            return;
+        await this.bus.publishInbound({
+            channel: this.name,
+            senderId: String(input.senderId),
+            chatId: String(input.chatId),
+            content: input.content,
+            media: input.media ?? [],
+            metadata: input.metadata ?? {},
+            sessionKeyOverride: input.sessionKey,
+        });
+    }
+    get isRunning() {
+        return this.running;
+    }
+}

package/dist/channels/discord.d.ts

@@ -0,0 +1,24 @@
+import type { OutboundMessage } from "../bus/events.js";
+import type { MessageBus } from "../bus/queue.js";
+import { BaseChannel } from "./base.js";
+type DiscordConfig = {
+    enabled: boolean;
+    token: string;
+    allowFrom: string[];
+    gatewayUrl: string;
+    intents: number;
+};
+export declare class DiscordChannel extends BaseChannel<DiscordConfig> {
+    readonly name = "discord";
+    private ws;
+    private hb;
+    private seq;
+    constructor(config: DiscordConfig, bus: MessageBus);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(msg: OutboundMessage): Promise<void>;
+    private connectOnce;
+    private startHeartbeat;
+    private sendPayload;
+}
+export {};

package/dist/channels/discord.js

@@ -0,0 +1,133 @@
+import WebSocket from "ws";
+import { BaseChannel } from "./base.js";
+export class DiscordChannel extends BaseChannel {
+    name = "discord";
+    ws = null;
+    hb = null;
+    seq = null;
+    constructor(config, bus) {
+        super(config, bus);
+    }
+    async start() {
+        if (!this.config.token) {
+            console.error("Discord token not configured");
+            return;
+        }
+        this.running = true;
+        while (this.running) {
+            try {
+                await this.connectOnce();
+            }
+            catch {
+                // reconnect loop
+            }
+            if (this.running)
+                await new Promise((r) => setTimeout(r, 2000));
+        }
+    }
+    async stop() {
+        this.running = false;
+        if (this.hb) {
+            clearInterval(this.hb);
+            this.hb = null;
+        }
+        if (this.ws) {
+            try {
+                this.ws.close();
+            }
+            catch {
+                // ignore
+            }
+            this.ws = null;
+        }
+    }
+    async send(msg) {
+        if (!this.config.token)
+            return;
+        await fetch(`https://discord.com/api/v10/channels/${msg.chatId}/messages`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bot ${this.config.token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ content: msg.content || "" }),
+        }).catch(() => undefined);
+    }
+    async connectOnce() {
+        await new Promise((resolve) => {
+            const ws = new WebSocket(this.config.gatewayUrl);
+            this.ws = ws;
+            ws.on("message", async (raw) => {
+                let payload;
+                try {
+                    payload = JSON.parse(raw.toString());
+                }
+                catch {
+                    return;
+                }
+                if (payload.s != null)
+                    this.seq = payload.s;
+                if (payload.op === 10) {
+                    const interval = Number(payload.d?.heartbeat_interval ?? 30000);
+                    this.startHeartbeat(interval);
+                    this.sendPayload({
+                        op: 2,
+                        d: {
+                            token: this.config.token,
+                            intents: this.config.intents,
+                            properties: { os: process.platform, browser: "pretticlaw", device: "pretticlaw" },
+                        },
+                    });
+                    return;
+                }
+                if (payload.op === 7) {
+                    ws.close();
+                    return;
+                }
+                if (payload.op === 11)
+                    return;
+                if (payload.t === "MESSAGE_CREATE") {
+                    const m = payload.d;
+                    if (!m || m.author?.bot)
+                        return;
+                    const content = String(m.content ?? "").trim();
+                    if (!content)
+                        return;
+                    const sender = `${m.author?.id}${m.author?.username ? `|${m.author.username}` : ""}`;
+                    await this.handleMessage({
+                        senderId: sender,
+                        chatId: String(m.channel_id),
+                        content,
+                        metadata: { message_id: m.id, guild_id: m.guild_id ?? null },
+                    });
+                }
+            });
+            ws.on("close", () => {
+                if (this.hb) {
+                    clearInterval(this.hb);
+                    this.hb = null;
+                }
+                resolve();
+            });
+            ws.on("error", () => {
+                if (this.hb) {
+                    clearInterval(this.hb);
+                    this.hb = null;
+                }
+                resolve();
+            });
+        });
+    }
+    startHeartbeat(intervalMs) {
+        if (this.hb)
+            clearInterval(this.hb);
+        this.hb = setInterval(() => {
+            this.sendPayload({ op: 1, d: this.seq });
+        }, intervalMs);
+    }
+    sendPayload(data) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        this.ws.send(JSON.stringify(data));
+    }
+}

package/dist/channels/manager.d.ts

@@ -0,0 +1,17 @@
+import type { Config } from "../config/schema.js";
+import type { MessageBus } from "../bus/queue.js";
+import type { BaseChannel } from "./base.js";
+export declare class ChannelManager {
+    private readonly config;
+    private readonly bus;
+    readonly channels: Map<string, BaseChannel<unknown>>;
+    private dispatchLoop;
+    private stopping;
+    constructor(config: Config, bus: MessageBus);
+    private initChannels;
+    startAll(): Promise<void>;
+    stopAll(): Promise<void>;
+    private dispatchOutbound;
+    get enabledChannels(): string[];
+    getStatus(): Record<string, unknown>;
+}

package/dist/channels/manager.js

@@ -0,0 +1,67 @@
+import { StubChannel } from "./stub.js";
+import { TelegramChannel } from "./telegram.js";
+import { DiscordChannel } from "./discord.js";
+export class ChannelManager {
+    config;
+    bus;
+    channels = new Map();
+    dispatchLoop = null;
+    stopping = false;
+    constructor(config, bus) {
+        this.config = config;
+        this.bus = bus;
+        this.initChannels();
+    }
+    initChannels() {
+        const add = (name, enabled, channelConfig) => {
+            if (enabled)
+                this.channels.set(name, new StubChannel(name, channelConfig, this.bus));
+        };
+        if (this.config.channels.telegram.enabled) {
+            this.channels.set("telegram", new TelegramChannel(this.config.channels.telegram, this.bus));
+        }
+        add("whatsapp", this.config.channels.whatsapp.enabled, this.config.channels.whatsapp);
+        if (this.config.channels.discord.enabled) {
+            this.channels.set("discord", new DiscordChannel(this.config.channels.discord, this.bus));
+        }
+        add("feishu", this.config.channels.feishu.enabled, this.config.channels.feishu);
+        add("mochat", this.config.channels.mochat.enabled, this.config.channels.mochat);
+        add("dingtalk", this.config.channels.dingtalk.enabled, this.config.channels.dingtalk);
+        add("email", this.config.channels.email.enabled, this.config.channels.email);
+        add("slack", this.config.channels.slack.enabled, this.config.channels.slack);
+        add("qq", this.config.channels.qq.enabled, this.config.channels.qq);
+        add("matrix", this.config.channels.matrix.enabled, this.config.channels.matrix);
+    }
+    async startAll() {
+        if (!this.channels.size)
+            return;
+        this.stopping = false;
+        this.dispatchLoop = this.dispatchOutbound();
+        await Promise.all([...this.channels.values()].map((c) => c.start().catch(() => undefined)));
+    }
+    async stopAll() {
+        this.stopping = true;
+        await Promise.all([...this.channels.values()].map((c) => c.stop().catch(() => undefined)));
+    }
+    async dispatchOutbound() {
+        while (!this.stopping) {
+            const msg = await this.bus.consumeOutbound();
+            if (msg.metadata?._progress) {
+                const isTool = !!msg.metadata._tool_hint;
+                if (isTool && !this.config.channels.sendToolHints)
+                    continue;
+                if (!isTool && !this.config.channels.sendProgress)
+                    continue;
+            }
+            const ch = this.channels.get(msg.channel);
+            if (ch)
+                await ch.send(msg).catch(() => undefined);
+        }
+    }
+    get enabledChannels() {
+        return [...this.channels.keys()];
+    }
+    getStatus() {
+        return Object.fromEntries([...this.channels].map(([name, c]) => [name, { enabled: true, running: c.isRunning }]));
+    }
+}

package/dist/channels/stub.d.ts

@@ -0,0 +1,10 @@
+import type { OutboundMessage } from "../bus/events.js";
+import type { MessageBus } from "../bus/queue.js";
+import { BaseChannel } from "./base.js";
+export declare class StubChannel extends BaseChannel<any> {
+    readonly name: string;
+    constructor(name: string, config: any, bus: MessageBus);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(_msg: OutboundMessage): Promise<void>;
+}

package/dist/channels/stub.js

@@ -0,0 +1,18 @@
+import { BaseChannel } from "./base.js";
+export class StubChannel extends BaseChannel {
+    name;
+    constructor(name, config, bus) {
+        super(config, bus);
+        this.name = name;
+    }
+    async start() {
+        this.running = true;
+        await new Promise(() => { });
+    }
+    async stop() {
+        this.running = false;
+    }
+    async send(_msg) {
+        // no-op
+    }
+}

package/dist/channels/telegram.d.ts

@@ -0,0 +1,20 @@
+import type { OutboundMessage } from "../bus/events.js";
+import type { MessageBus } from "../bus/queue.js";
+import { BaseChannel } from "./base.js";
+type TelegramConfig = {
+    enabled: boolean;
+    token: string;
+    allowFrom: string[];
+    proxy: string | null;
+    replyToMessage: boolean;
+};
+export declare class TelegramChannel extends BaseChannel<TelegramConfig> {
+    readonly name = "telegram";
+    private offset;
+    constructor(config: TelegramConfig, bus: MessageBus);
+    private api;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(msg: OutboundMessage): Promise<void>;
+}
+export {};