opencode-claw 0.1.0

package/dist/memory/txt.js

@@ -0,0 +1,137 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { fileExists, readTextFile, writeTextFile } from "../compat.js";
+const SEPARATOR = "\n---\n\n";
+const HEADER_RE = /^## \[(\w+)\] (\S+) \| source:(.+)$/;
+const ID_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
+function generateId() {
+    const ts = Date.now().toString(36);
+    let suffix = "";
+    for (let i = 0; i < 4; i++) {
+        suffix += ID_CHARS[Math.floor(Math.random() * ID_CHARS.length)];
+    }
+    return `${ts}-${suffix}`;
+}
+function parseMemoryFile(raw) {
+    const blocks = raw.split(SEPARATOR).filter((b) => b.trim());
+    const entries = [];
+    for (const block of blocks) {
+        const lines = block.trim().split("\n");
+        const header = lines[0];
+        if (!header)
+            continue;
+        const match = header.match(HEADER_RE);
+        if (!match)
+            continue;
+        const category = match[1];
+        const timestamp = match[2] ?? "";
+        const source = match[3] ?? "";
+        const content = lines.slice(2).join("\n").trim();
+        if (!content)
+            continue;
+        entries.push({
+            id: `${timestamp}-${source}`,
+            content,
+            category,
+            source,
+            createdAt: new Date(timestamp),
+        });
+    }
+    return entries;
+}
+function formatEntry(entry, _id, timestamp) {
+    return `## [${entry.category}] ${timestamp} | source:${entry.source}\n\n${entry.content}`;
+}
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .split(/\W+/)
+        .filter((t) => t.length > 1);
+}
+function relevance(query, content, category) {
+    const tokens = tokenize(query);
+    if (tokens.length === 0)
+        return 0;
+    const target = `${category} ${content}`.toLowerCase();
+    let hits = 0;
+    for (const token of tokens) {
+        if (target.includes(token))
+            hits++;
+    }
+    return hits / tokens.length;
+}
+export function createTxtMemoryBackend(directory) {
+    const filepath = join(directory, "MEMORY.md");
+    let initialized = false;
+    async function readFile() {
+        if (!(await fileExists(filepath)))
+            return "";
+        return readTextFile(filepath);
+    }
+    async function writeFile(content) {
+        await writeTextFile(filepath, content);
+    }
+    return {
+        async initialize() {
+            await mkdir(directory, { recursive: true });
+            initialized = true;
+        },
+        async search(query, options) {
+            const raw = await readFile();
+            if (!raw)
+                return [];
+            const entries = parseMemoryFile(raw);
+            const limit = options?.limit ?? 10;
+            const minScore = options?.minRelevance ?? 0.1;
+            const scored = entries
+                .map((entry) => ({
+                ...entry,
+                relevance: relevance(query, entry.content, entry.category),
+            }))
+                .filter((e) => e.relevance >= minScore);
+            if (options?.category) {
+                const cat = options.category;
+                const filtered = scored.filter((e) => e.category === cat);
+                filtered.sort((a, b) => (b.relevance ?? 0) - (a.relevance ?? 0));
+                return filtered.slice(0, limit);
+            }
+            scored.sort((a, b) => (b.relevance ?? 0) - (a.relevance ?? 0));
+            return scored.slice(0, limit);
+        },
+        async store(entry) {
+            const id = generateId();
+            const timestamp = new Date().toISOString();
+            const formatted = formatEntry(entry, id, timestamp);
+            const existing = await readFile();
+            const content = existing
+                ? `${existing.trimEnd()}\n\n${SEPARATOR}${formatted}\n`
+                : `${formatted}\n`;
+            await writeFile(content);
+        },
+        async delete(id) {
+            const raw = await readFile();
+            if (!raw)
+                return;
+            const entries = parseMemoryFile(raw);
+            const filtered = entries.filter((e) => e.id !== id);
+            if (filtered.length === entries.length)
+                return;
+            const content = filtered
+                .map((e) => formatEntry(e, e.id, e.createdAt.toISOString()))
+                .join(SEPARATOR);
+            await writeFile(content ? `${content}\n` : "");
+        },
+        async status() {
+            const raw = await readFile();
+            const entries = raw ? parseMemoryFile(raw) : [];
+            return {
+                backend: "txt",
+                initialized,
+                entryCount: entries.length,
+            };
+        },
+        async close() {
+            // No resources to release
+        },
+    };
+}

package/dist/memory/types.d.ts

@@ -0,0 +1,36 @@
+export type MemoryCategory = "project" | "experience" | "preference" | "entity" | "event" | "knowledge";
+export type MemorySearchOptions = {
+    limit?: number;
+    sessionId?: string;
+    category?: MemoryCategory;
+    minRelevance?: number;
+};
+export type MemoryEntry = {
+    id: string;
+    content: string;
+    category: MemoryCategory;
+    source: string;
+    createdAt: Date;
+    relevance?: number;
+    metadata?: Record<string, unknown>;
+};
+export type MemoryInput = {
+    content: string;
+    category: MemoryCategory;
+    source: string;
+    metadata?: Record<string, unknown>;
+};
+export type MemoryStatus = {
+    backend: string;
+    initialized: boolean;
+    entryCount: number;
+    lastSync?: Date;
+};
+export type MemoryBackend = {
+    initialize(): Promise<void>;
+    search(query: string, options?: MemorySearchOptions): Promise<MemoryEntry[]>;
+    store(entry: MemoryInput): Promise<void>;
+    delete(id: string): Promise<void>;
+    status(): Promise<MemoryStatus>;
+    close(): Promise<void>;
+};

package/dist/memory/types.js

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

package/dist/outbox/drainer.d.ts

@@ -0,0 +1,8 @@
+import type { ChannelAdapter, ChannelId } from "../channels/types.js";
+import type { OutboxConfig } from "../config/types.js";
+import type { Logger } from "../utils/logger.js";
+export type OutboxDrainer = {
+    start(): void;
+    stop(): void;
+};
+export declare function createOutboxDrainer(config: OutboxConfig, adapters: Map<ChannelId, ChannelAdapter>, logger: Logger): OutboxDrainer;

package/dist/outbox/drainer.js

@@ -0,0 +1,140 @@
+import { readdir } from "node:fs/promises";
+import { mkdir, rename, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { fileExists, readTextFile, writeTextFile } from "../compat.js";
+const DEAD_LETTER_CHECK_INTERVAL = 60_000;
+export function createOutboxDrainer(config, adapters, logger) {
+    let timer = null;
+    async function readEntries() {
+        const results = [];
+        const baseDir = config.directory;
+        if (!(await dirExists(baseDir)))
+            return results;
+        const channels = await readdir(baseDir, { withFileTypes: true });
+        for (const ch of channels) {
+            if (!ch.isDirectory() || ch.name === "dead")
+                continue;
+            const channelDir = join(baseDir, ch.name);
+            const peers = await readdir(channelDir, { withFileTypes: true });
+            for (const peer of peers) {
+                if (!peer.isDirectory())
+                    continue;
+                const peerDir = join(channelDir, peer.name);
+                const files = await readdir(peerDir);
+                for (const file of files) {
+                    if (!file.endsWith(".json"))
+                        continue;
+                    const filepath = join(peerDir, file);
+                    const raw = await readTextFile(filepath);
+                    const entry = JSON.parse(raw);
+                    results.push({ entry, filepath });
+                }
+            }
+        }
+        return results;
+    }
+    async function moveToDead(filepath, entry) {
+        const deadDir = join(config.directory, "dead", entry.channel, entry.peerId);
+        await mkdir(deadDir, { recursive: true });
+        const filename = filepath.split("/").pop() ?? `${entry.id}.json`;
+        const dest = join(deadDir, filename);
+        await rename(filepath, dest);
+        logger.warn("outbox: moved to dead letter", {
+            id: entry.id,
+            channel: entry.channel,
+            peerId: entry.peerId,
+            attempts: entry.attempts,
+        });
+    }
+    async function drain() {
+        const pending = await readEntries();
+        if (pending.length === 0)
+            return;
+        for (const { entry, filepath } of pending) {
+            const adapter = adapters.get(entry.channel);
+            if (!adapter || adapter.status() !== "connected")
+                continue;
+            try {
+                await adapter.send(entry.peerId, {
+                    text: entry.text,
+                    threadId: entry.threadId,
+                });
+                if (await fileExists(filepath)) {
+                    await unlink(filepath);
+                }
+                logger.debug("outbox: delivered", {
+                    id: entry.id,
+                    channel: entry.channel,
+                });
+            }
+            catch (err) {
+                entry.attempts++;
+                if (entry.attempts >= config.maxAttempts) {
+                    await moveToDead(filepath, entry);
+                }
+                else {
+                    await writeTextFile(filepath, JSON.stringify(entry, null, 2));
+                    logger.warn("outbox: delivery failed, will retry", {
+                        id: entry.id,
+                        attempts: entry.attempts,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+        }
+    }
+    async function dirExists(path) {
+        try {
+            await readdir(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async function checkDeadLetters() {
+        const deadDir = join(config.directory, "dead");
+        try {
+            const entries = await readdir(deadDir, { recursive: true });
+            const count = entries.filter((e) => e.endsWith(".json")).length;
+            if (count > 0) {
+                logger.warn("outbox: dead letters detected", {
+                    count,
+                    path: deadDir,
+                });
+            }
+        }
+        catch {
+            // dead directory doesn't exist yet — no dead letters
+        }
+    }
+    let deadLetterTimer = null;
+    return {
+        start() {
+            timer = setInterval(() => {
+                drain().catch((err) => {
+                    logger.error("outbox: drain error", {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                });
+            }, config.pollIntervalMs);
+            deadLetterTimer = setInterval(() => {
+                checkDeadLetters().catch(() => { });
+            }, DEAD_LETTER_CHECK_INTERVAL);
+            logger.info("outbox: drainer started", {
+                pollIntervalMs: config.pollIntervalMs,
+            });
+        },
+        stop() {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+            if (deadLetterTimer) {
+                clearInterval(deadLetterTimer);
+                deadLetterTimer = null;
+            }
+            logger.info("outbox: drainer stopped");
+        },
+    };
+}

package/dist/outbox/writer.d.ts

@@ -0,0 +1,15 @@
+import type { ChannelId } from "../channels/types.js";
+import type { OutboxConfig } from "../config/types.js";
+export type OutboxEntry = {
+    id: string;
+    channel: ChannelId;
+    peerId: string;
+    text: string;
+    threadId?: string;
+    enqueuedAt: string;
+    attempts: number;
+};
+export type OutboxWriter = {
+    enqueue(entry: Omit<OutboxEntry, "id" | "enqueuedAt" | "attempts">): Promise<void>;
+};
+export declare function createOutboxWriter(config: OutboxConfig): OutboxWriter;

package/dist/outbox/writer.js

@@ -0,0 +1,29 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { writeTextFile } from "../compat.js";
+const CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
+function generateId() {
+    const ts = Date.now().toString(36);
+    let suffix = "";
+    for (let i = 0; i < 6; i++) {
+        suffix += CHARS[Math.floor(Math.random() * CHARS.length)];
+    }
+    return `${ts}-${suffix}`;
+}
+export function createOutboxWriter(config) {
+    return {
+        async enqueue(entry) {
+            const id = generateId();
+            const full = {
+                ...entry,
+                id,
+                enqueuedAt: new Date().toISOString(),
+                attempts: 0,
+            };
+            const dir = join(config.directory, entry.channel, entry.peerId);
+            await mkdir(dir, { recursive: true });
+            const path = join(dir, `${id}.json`);
+            await writeTextFile(path, JSON.stringify(full, null, 2));
+        },
+    };
+}

package/dist/sessions/manager.d.ts

@@ -0,0 +1,20 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { SessionsConfig } from "../config/types.js";
+import type { Logger } from "../utils/logger.js";
+export type SessionInfo = {
+    id: string;
+    key: string;
+    title: string;
+    active: boolean;
+    createdAt?: number;
+};
+export declare function buildSessionKey(channel: string, peerId: string, threadId?: string): string;
+export declare function createSessionManager(client: OpencodeClient, config: SessionsConfig, map: Map<string, string>, logger: Logger): {
+    resolveSession: (key: string, title?: string) => Promise<string>;
+    switchSession: (key: string, targetId: string) => Promise<void>;
+    newSession: (key: string, title?: string) => Promise<string>;
+    listSessions: (channelPeerPrefix: string) => Promise<SessionInfo[]>;
+    currentSession: (key: string) => string | undefined;
+    persist: () => Promise<void>;
+};
+export type SessionManager = ReturnType<typeof createSessionManager>;

package/dist/sessions/manager.js

@@ -0,0 +1,68 @@
+import { saveSessionMap } from "./persistence.js";
+export function buildSessionKey(channel, peerId, threadId) {
+    const base = `opencode-claw:${channel}:${peerId}`;
+    if (threadId)
+        return `${base}:thread:${threadId}`;
+    return base;
+}
+export function createSessionManager(client, config, map, logger) {
+    async function persist() {
+        await saveSessionMap(config, map, logger);
+    }
+    async function resolveSession(key, title) {
+        const existing = map.get(key);
+        if (existing)
+            return existing;
+        const session = await client.session.create({
+            body: { title: title ?? key },
+        });
+        if (!session.data)
+            throw new Error("session.create returned no data");
+        map.set(key, session.data.id);
+        await persist();
+        logger.info("sessions: created new session", { key, id: session.data.id });
+        return session.data.id;
+    }
+    async function switchSession(key, targetId) {
+        map.set(key, targetId);
+        await persist();
+        logger.info("sessions: switched session", { key, targetId });
+    }
+    async function newSession(key, title) {
+        const session = await client.session.create({
+            body: { title: title ?? `New session ${new Date().toISOString()}` },
+        });
+        if (!session.data)
+            throw new Error("session.create returned no data");
+        map.set(key, session.data.id);
+        await persist();
+        logger.info("sessions: created and switched to new session", { key, id: session.data.id });
+        return session.data.id;
+    }
+    async function listSessions(channelPeerPrefix) {
+        const all = await client.session.list();
+        const sessions = all.data ?? [];
+        const entries = [...map.entries()].filter(([key]) => key.includes(channelPeerPrefix));
+        return entries.map(([key, id]) => {
+            const session = sessions.find((s) => s.id === id);
+            return {
+                id,
+                key,
+                title: session?.title ?? "(deleted)",
+                active: map.get(key) === id,
+                createdAt: session?.time.created,
+            };
+        });
+    }
+    function currentSession(key) {
+        return map.get(key);
+    }
+    return {
+        resolveSession,
+        switchSession,
+        newSession,
+        listSessions,
+        currentSession,
+        persist,
+    };
+}

package/dist/sessions/persistence.d.ts

@@ -0,0 +1,4 @@
+import type { SessionsConfig } from "../config/types.js";
+import type { Logger } from "../utils/logger.js";
+export declare function loadSessionMap(config: SessionsConfig, logger: Logger): Promise<Map<string, string>>;
+export declare function saveSessionMap(config: SessionsConfig, map: Map<string, string>, logger: Logger): Promise<void>;

package/dist/sessions/persistence.js

@@ -0,0 +1,24 @@
+import { fileExists, readJsonFile, writeTextFile } from "../compat.js";
+export async function loadSessionMap(config, logger) {
+    if (!(await fileExists(config.persistPath))) {
+        logger.debug("sessions: no persisted map found, starting fresh");
+        return new Map();
+    }
+    try {
+        const data = await readJsonFile(config.persistPath);
+        const map = new Map(Object.entries(data));
+        logger.info("sessions: loaded persisted map", { count: map.size });
+        return map;
+    }
+    catch (err) {
+        logger.warn("sessions: failed to load persisted map, starting fresh", {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return new Map();
+    }
+}
+export async function saveSessionMap(config, map, logger) {
+    const data = Object.fromEntries(map);
+    await writeTextFile(config.persistPath, JSON.stringify(data, null, 2));
+    logger.debug("sessions: persisted map", { count: map.size });
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,8 @@
+import type { LogConfig } from "../config/types.js";
+export declare function createLogger(config: LogConfig): {
+    debug: (msg: string, data?: Record<string, unknown>) => void;
+    info: (msg: string, data?: Record<string, unknown>) => void;
+    warn: (msg: string, data?: Record<string, unknown>) => void;
+    error: (msg: string, data?: Record<string, unknown>) => void;
+};
+export type Logger = ReturnType<typeof createLogger>;

package/dist/utils/logger.js

@@ -0,0 +1,33 @@
+import { createFileWriter } from "../compat.js";
+const levels = { debug: 0, info: 1, warn: 2, error: 3 };
+export function createLogger(config) {
+    const threshold = levels[config.level];
+    const writer = config.file ? createFileWriter(config.file) : null;
+    function write(level, msg, data) {
+        if (levels[level] < threshold)
+            return;
+        const entry = {
+            ts: new Date().toISOString(),
+            level,
+            msg,
+            ...data,
+        };
+        const line = JSON.stringify(entry);
+        if (writer) {
+            writer.write(`${line}\n`);
+            writer.flush();
+        }
+        else {
+            if (level === "error")
+                console.error(line);
+            else
+                console.log(line);
+        }
+    }
+    return {
+        debug: (msg, data) => write("debug", msg, data),
+        info: (msg, data) => write("info", msg, data),
+        warn: (msg, data) => write("warn", msg, data),
+        error: (msg, data) => write("error", msg, data),
+    };
+}

package/dist/utils/reconnect.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from "./logger.js";
+type ReconnectOpts = {
+    name: string;
+    connect: () => Promise<void>;
+    logger: Logger;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    maxAttempts?: number;
+};
+export declare function createReconnector(opts: ReconnectOpts): {
+    attempt: () => Promise<void>;
+    reset: () => void;
+    stop: () => void;
+};
+export type Reconnector = ReturnType<typeof createReconnector>;
+export {};

package/dist/utils/reconnect.js

@@ -0,0 +1,54 @@
+const DEFAULT_BASE_DELAY = 1000;
+const DEFAULT_MAX_DELAY = 30_000;
+const DEFAULT_MAX_ATTEMPTS = Number.POSITIVE_INFINITY;
+export function createReconnector(opts) {
+    const base = opts.baseDelayMs ?? DEFAULT_BASE_DELAY;
+    const cap = opts.maxDelayMs ?? DEFAULT_MAX_DELAY;
+    const limit = opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    let attempts = 0;
+    let timer = null;
+    let stopped = false;
+    function delay() {
+        const exponential = base * 2 ** attempts;
+        const jitter = Math.random() * base;
+        return Math.min(exponential + jitter, cap);
+    }
+    async function attempt() {
+        if (stopped)
+            return;
+        attempts++;
+        if (attempts > limit) {
+            opts.logger.error(`${opts.name}: max reconnect attempts (${limit}) reached, giving up`);
+            return;
+        }
+        const ms = delay();
+        opts.logger.info(`${opts.name}: reconnecting in ${Math.round(ms)}ms (attempt ${attempts})`);
+        timer = setTimeout(async () => {
+            if (stopped)
+                return;
+            try {
+                await opts.connect();
+                attempts = 0;
+                opts.logger.info(`${opts.name}: reconnected successfully`);
+            }
+            catch (err) {
+                opts.logger.warn(`${opts.name}: reconnect failed`, {
+                    attempt: attempts,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                await attempt();
+            }
+        }, ms);
+    }
+    function reset() {
+        attempts = 0;
+    }
+    function stop() {
+        stopped = true;
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+    }
+    return { attempt, reset, stop };
+}

package/dist/utils/shutdown.d.ts

@@ -0,0 +1,5 @@
+import type { Logger } from "./logger.js";
+type ShutdownFn = () => Promise<void> | void;
+export declare function onShutdown(fn: ShutdownFn): void;
+export declare function setupShutdown(logger: Logger): void;
+export {};

package/dist/utils/shutdown.js

@@ -0,0 +1,27 @@
+const handlers = [];
+let shuttingDown = false;
+export function onShutdown(fn) {
+    handlers.push(fn);
+}
+export function setupShutdown(logger) {
+    const handler = async () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        logger.info("shutdown: signal received, draining...");
+        for (const fn of handlers.reverse()) {
+            try {
+                await fn();
+            }
+            catch (err) {
+                logger.error("shutdown: handler failed", {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        logger.info("shutdown: complete");
+        process.exit(0);
+    };
+    process.on("SIGTERM", handler);
+    process.on("SIGINT", handler);
+}