@qearlyao/familiar 0.2.5 → 0.4.0

package/dist/discord/daemon.js

@@ -0,0 +1,379 @@
+import { Events, } from "discord.js";
+import { formatSetting } from "../config/settings.js";
+import { chatChannelKey } from "../conversation/chat-log.js";
+import { saveOwnerIdentity } from "../conversation/owner-identity.js";
+import { thinkingDurationMs } from "../runtime/agent-events.js";
+import { buildChannelRef, fetchMessageAnchor, getChannelRef, isDmChannel, runtimeKeyFromMessage, } from "./channel.js";
+import { isAllowedMessage, withReadyClient } from "./client.js";
+import { EPHEMERAL_REPLY, FAMILIAR_COMMAND_NAME, formatCommandResponse, getAutocompleteChoices, inboundInputFromInteraction, isAllowedInteractionChannel, registerFamiliarApplicationCommand, replyEphemeral, replyInteractionError, } from "./commands.js";
+import { canSteerFromRecord, getChannelTriggerSetting, getDispatchMode, toInboundInput } from "./inbound.js";
+import { sendChannelMessage, sendDiscordAttachments, sendReply } from "./send.js";
+import { isCanceledJob, runAgentTurn } from "./turn.js";
+const RETRY_MS = 15_000;
+async function applyControlCommand(options) {
+    const { control, runtime, familiarAgent, settings, channelTrigger, isDm, activeAgentOwner, restart } = options;
+    if (control.command === "stop") {
+        if (runtime.hasActiveJob() && activeAgentOwner === runtime.channelKey)
+            familiarAgent.abort(runtime.channelKey);
+        await runtime.resetConversation("stop requested");
+        return "Stopped current work and cleared the chat queue.";
+    }
+    if (control.command === "new") {
+        await familiarAgent.reset(runtime.channelKey);
+        await runtime.resetConversation("new conversation requested");
+        return "Started a fresh agent transcript for this channel.";
+    }
+    if (control.command === "reload") {
+        return familiarAgent.reload();
+    }
+    if (control.command === "restart") {
+        return restart
+            ? await restart()
+            : "Restart requested, but no restart handler is configured. Please restart the Familiar process manually.";
+    }
+    if (control.command === "model") {
+        return control.args
+            ? await familiarAgent.setModel(runtime.channelKey, control.args)
+            : `Current model: ${formatSetting(familiarAgent.getModel(runtime.channelKey))}`;
+    }
+    if (control.command === "thinking") {
+        return control.args
+            ? await familiarAgent.setThinkingLevel(runtime.channelKey, control.args)
+            : `Current thinking: ${formatSetting(familiarAgent.getThinkingLevel(runtime.channelKey))}`;
+    }
+    if (control.command === "channel-trigger") {
+        if (isDm) {
+            return "DM channel trigger is always.";
+        }
+        const triggerInput = control.args.trim().toLowerCase();
+        if (triggerInput && triggerInput !== "mention" && triggerInput !== "always") {
+            throw new Error("Usage: /channel-trigger mention|always");
+        }
+        const trigger = triggerInput === "mention" || triggerInput === "always" ? triggerInput : undefined;
+        if (trigger) {
+            await settings.setChannelTrigger(runtime.channelKey, trigger);
+            return `Channel trigger set to ${trigger} for this channel`;
+        }
+        return `Current channel trigger: ${formatSetting(channelTrigger)}`;
+    }
+    return formatCommandResponse(control.command, runtime, familiarAgent, channelTrigger);
+}
+function startTypingIndicator(message) {
+    const sendTyping = () => {
+        if (!message.channel.isSendable())
+            return;
+        void message.channel.sendTyping().catch(() => undefined);
+    };
+    sendTyping();
+    const timer = setInterval(sendTyping, 8000);
+    return () => {
+        clearInterval(timer);
+    };
+}
+export function startDiscordDaemon(config, token, familiarAgent, settings, _memoryService, core, options = {}) {
+    let client;
+    let session;
+    let stopped = false;
+    let retryTimer;
+    const collectTimers = new Map();
+    const getRuntime = async (message) => {
+        return core.getRuntimeForChannel(getChannelRef(message));
+    };
+    const getInteractionRuntime = async (interaction) => {
+        const channel = interaction.channel;
+        if (!channel || !interaction.channelId)
+            throw new Error("Discord interaction has no channel");
+        return core.getRuntimeForChannel(buildChannelRef(channel, interaction.channelId));
+    };
+    const createConnectedSession = (client) => {
+        let ownerDmChannelPromise;
+        const getOwnerDmChannel = () => {
+            if (!ownerDmChannelPromise) {
+                ownerDmChannelPromise = client.users
+                    .createDM(config.discord.ownerId)
+                    .then(async (dm) => {
+                    try {
+                        await saveOwnerIdentity(config.workspace.dataDir, {
+                            botUserId: client.user.id,
+                            dmChannelId: dm.id,
+                        });
+                    }
+                    catch (error) {
+                        console.error("failed to persist owner identity", error);
+                    }
+                    return dm;
+                })
+                    .catch((error) => {
+                    ownerDmChannelPromise = undefined;
+                    throw error;
+                });
+            }
+            return ownerDmChannelPromise;
+        };
+        const getWebSessions = async () => {
+            const dmChannel = await getOwnerDmChannel();
+            const dmRef = buildChannelRef(dmChannel, dmChannel.id);
+            const sessions = [
+                { key: chatChannelKey(dmRef), label: "Main Chat", channel: dmRef, isDefault: true },
+            ];
+            const fetched = await Promise.all(config.discord.allowedChannels.map((channelId) => client.channels.fetch(channelId).catch(() => undefined)));
+            for (const [index, channel] of fetched.entries()) {
+                if (!channel)
+                    continue;
+                const ref = buildChannelRef(channel, config.discord.allowedChannels[index]);
+                sessions.push({
+                    key: chatChannelKey(ref),
+                    label: ref.channelName || `Discord ${ref.scope}`,
+                    channel: ref,
+                });
+            }
+            return sessions;
+        };
+        const getOwnerDmSession = async () => {
+            const dmChannel = await getOwnerDmChannel();
+            const runtime = await core.getRuntimeForChannel(buildChannelRef(dmChannel, dmChannel.id));
+            return { runtime };
+        };
+        const liveSink = {
+            async deliver({ reply, parsedReply }) {
+                const channel = await getOwnerDmChannel();
+                return parsedReply.silent
+                    ? await sendDiscordAttachments(token, channel.id, reply.attachments)
+                    : await sendChannelMessage(config, token, channel, parsedReply.text, reply.attachments);
+            },
+        };
+        const drainJobs = async (message, runtime) => {
+            for (;;) {
+                const dispatch = runtime.beginNextJob();
+                if (!dispatch)
+                    return;
+                const stopTyping = startTypingIndicator(message);
+                try {
+                    const turn = await runAgentTurn(dispatch.job.jobId, runtime, (onEvent) => core.promptForRuntime(runtime, dispatch.job.jobId, dispatch.prompt, dispatch.attachments, onEvent));
+                    if (!turn)
+                        return;
+                    const { reply, parsedReply, summary, assistantMessageId } = turn;
+                    const replyAnchor = await fetchMessageAnchor(message, dispatch.triggerMessageId);
+                    const messageIds = parsedReply.silent
+                        ? await sendDiscordAttachments(token, replyAnchor.channelId, reply.attachments)
+                        : await sendReply(config, token, replyAnchor, parsedReply.text, dispatch.triggerMessageId, reply.attachments);
+                    await runtime.completeActiveJob({
+                        text: parsedReply.text,
+                        messageIds,
+                        webMessageId: assistantMessageId,
+                        attachments: reply.attachments,
+                        thinking: summary.thinking,
+                        thinkingMs: thinkingDurationMs(summary),
+                        silent: parsedReply.silent,
+                        replyToMessageId: dispatch.triggerMessageId,
+                    });
+                }
+                catch (error) {
+                    if (isCanceledJob(error) || !runtime.hasActiveJob(dispatch.job.jobId))
+                        return;
+                    const errorText = error instanceof Error ? error.message : String(error);
+                    await runtime.failActiveJob(errorText);
+                    await runtime.appendError(errorText);
+                    const fallback = "I hit an error while handling that message.";
+                    const replyAnchor = await fetchMessageAnchor(message, dispatch.triggerMessageId);
+                    const messageIds = await sendReply(config, token, replyAnchor, fallback, dispatch.triggerMessageId);
+                    await runtime.noteOutbound({
+                        text: fallback,
+                        messageIds,
+                        replyToMessageId: dispatch.triggerMessageId,
+                        jobId: dispatch.job.jobId,
+                    });
+                }
+                finally {
+                    stopTyping();
+                }
+            }
+        };
+        const flushCollected = async (message, runtime) => {
+            collectTimers.delete(runtime.channelKey);
+            try {
+                const isDm = isDmChannel(message.channel);
+                const queued = await runtime.queueLatestTrigger({
+                    channelTrigger: getChannelTriggerSetting(config, settings, runtime.channelKey, isDm).value,
+                });
+                if (!queued)
+                    return;
+                // The captured message is only a channel handle; drainJobs fetches the trigger record's message id for replies.
+                await drainJobs(message, runtime);
+            }
+            catch (error) {
+                console.error("Discord collect flush failed", error);
+                await runtime.appendError(error instanceof Error ? error.message : String(error));
+            }
+        };
+        const scheduleCollect = (message, runtime) => {
+            const existing = collectTimers.get(runtime.channelKey);
+            if (existing)
+                clearTimeout(existing);
+            const timer = setTimeout(() => {
+                void flushCollected(message, runtime);
+            }, config.discord.collectDebounceMs);
+            collectTimers.set(runtime.channelKey, timer);
+        };
+        const onMessageCreate = async (message) => {
+            if (!isAllowedMessage(config, message, client.user.id))
+                return;
+            let runtime;
+            try {
+                runtime = await getRuntime(message);
+                const isDm = isDmChannel(message.channel);
+                const channelTrigger = getChannelTriggerSetting(config, settings, runtime.channelKey, isDm);
+                const input = await toInboundInput(config, message, client.user.id);
+                const control = runtime.parseControlCommand(input);
+                if (control) {
+                    await runtime.noteControlCommand(input, control);
+                    const text = await applyControlCommand({
+                        control,
+                        runtime,
+                        familiarAgent,
+                        settings,
+                        channelTrigger,
+                        isDm,
+                        activeAgentOwner: core.activeOwner,
+                        restart: options.restart,
+                    });
+                    const messageIds = await sendReply(config, token, message, text);
+                    await runtime.noteOutbound({ text, messageIds, control: control.command });
+                    return;
+                }
+                const dispatchMode = getDispatchMode(config, message);
+                const shouldTrySteer = dispatchMode === "steer" && runtime.hasActiveJob() && core.activeOwner === runtime.channelKey;
+                const { record } = await runtime.ingestInbound(input, {
+                    mode: dispatchMode === "collect" || shouldTrySteer ? "collect" : "queue",
+                    channelTrigger: channelTrigger.value,
+                });
+                const canSteer = shouldTrySteer &&
+                    canSteerFromRecord(config, message, runtime, record, core.activeOwner, channelTrigger.value);
+                if (canSteer) {
+                    familiarAgent.steer(runtime.channelKey, runtime.buildSteerPromptForRecord(record));
+                    return;
+                }
+                if (shouldTrySteer) {
+                    await runtime.queueLatestTrigger({ channelTrigger: channelTrigger.value });
+                }
+                if (dispatchMode === "collect") {
+                    scheduleCollect(message, runtime);
+                    return;
+                }
+                await drainJobs(message, runtime);
+            }
+            catch (error) {
+                console.error("Discord message handling failed", error);
+                const channelKey = runtimeKeyFromMessage(message);
+                const existingRuntime = await core.peekRuntime(channelKey);
+                await existingRuntime?.appendError(error instanceof Error ? error.message : String(error));
+                await sendReply(config, token, message, "I hit an error while handling that message.");
+            }
+        };
+        const onInteractionCreate = async (interaction) => {
+            if (interaction.isAutocomplete()) {
+                if (interaction.commandName !== FAMILIAR_COMMAND_NAME)
+                    return;
+                if (!isAllowedInteractionChannel(config, interaction)) {
+                    await interaction.respond([]);
+                    return;
+                }
+                await interaction.respond(getAutocompleteChoices(config, interaction)).catch((error) => {
+                    console.error("Discord autocomplete response failed", error);
+                });
+                return;
+            }
+            if (!interaction.isChatInputCommand())
+                return;
+            if (interaction.commandName !== FAMILIAR_COMMAND_NAME)
+                return;
+            if (!isAllowedInteractionChannel(config, interaction)) {
+                await interaction.reply({
+                    content: "This Familiar command is owner-only for configured channels.",
+                    flags: EPHEMERAL_REPLY,
+                });
+                return;
+            }
+            let runtime;
+            try {
+                await interaction.deferReply({ flags: EPHEMERAL_REPLY });
+                runtime = await getInteractionRuntime(interaction);
+                const isDm = isDmChannel(interaction.channel);
+                const channelTrigger = getChannelTriggerSetting(config, settings, runtime.channelKey, isDm);
+                const input = inboundInputFromInteraction(interaction);
+                const control = runtime.parseControlCommand(input);
+                if (!control)
+                    throw new Error("Unsupported Familiar command.");
+                await runtime.noteControlCommand(input, control);
+                const text = await applyControlCommand({
+                    control,
+                    runtime,
+                    familiarAgent,
+                    settings,
+                    channelTrigger,
+                    isDm,
+                    activeAgentOwner: core.activeOwner,
+                    restart: options.restart,
+                });
+                const messageIds = await replyEphemeral(interaction, text);
+                await runtime.noteOutbound({ text, messageIds, control: control.command });
+            }
+            catch (error) {
+                await runtime?.appendError(error instanceof Error ? error.message : String(error));
+                await replyInteractionError(interaction, error);
+            }
+        };
+        return { onMessageCreate, onInteractionCreate, getOwnerDmSession, getWebSessions, liveSink };
+    };
+    const onClientError = (error) => console.error("Discord client error", error);
+    const onClientWarn = (warning) => console.warn("Discord warning", warning);
+    const onWsClose = (event) => {
+        console.warn("Discord websocket closed; discord.js will reconnect when possible", event);
+    };
+    const connect = async () => {
+        if (stopped)
+            return;
+        try {
+            client = await withReadyClient(token);
+            console.log(`Discord connected as ${client.user.tag}`);
+            await registerFamiliarApplicationCommand(client);
+            session = createConnectedSession(client);
+            client.on(Events.MessageCreate, session.onMessageCreate);
+            client.on(Events.InteractionCreate, session.onInteractionCreate);
+            client.on(Events.Error, onClientError);
+            client.on(Events.Warn, onClientWarn);
+            client.ws.on("close", onWsClose);
+            core.attachDiscord({
+                botUserId: client.user.id,
+                resolveDefaultSession: session.getOwnerDmSession,
+                getWebSessions: session.getWebSessions,
+                delivery: session.liveSink,
+            });
+        }
+        catch (error) {
+            console.error("Discord connect failed; retrying in background", error);
+            if (!stopped)
+                retryTimer = setTimeout(() => void connect(), RETRY_MS);
+        }
+    };
+    void connect();
+    return {
+        async stop() {
+            stopped = true;
+            if (retryTimer)
+                clearTimeout(retryTimer);
+            const liveClient = client;
+            if (liveClient && session) {
+                liveClient.off(Events.MessageCreate, session.onMessageCreate);
+                liveClient.off(Events.InteractionCreate, session.onInteractionCreate);
+                liveClient.off(Events.Error, onClientError);
+                liveClient.off(Events.Warn, onClientWarn);
+                liveClient.ws.off("close", onWsClose);
+            }
+            for (const timer of collectTimers.values())
+                clearTimeout(timer);
+            collectTimers.clear();
+            liveClient?.destroy();
+        },
+    };
+}

package/dist/discord/inbound.js

@@ -0,0 +1,44 @@
+import { materializeInboundAttachments } from "../media/inbound-attachments.js";
+import { isDmChannel, messageMentionsBot } from "./channel.js";
+export function getDispatchMode(config, message) {
+    return isDmChannel(message.channel) ? config.discord.dmMode : config.discord.channelMode;
+}
+export function getChannelTriggerSetting(config, settings, channelKey, isDm) {
+    if (isDm)
+        return { value: "always", source: "config" };
+    return settings.getChannelTrigger(channelKey, config.discord.channelTrigger);
+}
+export function canSteerFromRecord(config, message, runtime, record, activeAgentOwner, channelTrigger) {
+    if (getDispatchMode(config, message) !== "steer")
+        return false;
+    if (!runtime.hasActiveJob() || activeAgentOwner !== runtime.channelKey)
+        return false;
+    if (isDmChannel(message.channel))
+        return record.authorId === config.discord.ownerId && !record.isBot;
+    if (channelTrigger === "always")
+        return true;
+    return record.mentionedBot;
+}
+export async function toInboundInput(config, message, botUserId) {
+    const attachments = await materializeInboundAttachments(config, [...message.attachments.values()].map((attachment) => ({
+        id: attachment.id,
+        name: attachment.name,
+        mimeType: attachment.contentType ?? undefined,
+        size: attachment.size,
+        url: attachment.url,
+        source: "discord",
+    })));
+    return {
+        messageId: message.id,
+        authorId: message.author.id,
+        authorName: message.author.username,
+        text: message.content || "",
+        isBot: message.author.bot,
+        mentionedBot: messageMentionsBot(message, botUserId),
+        remoteTimestamp: new Date(message.createdTimestamp || Date.now()).toISOString(),
+        checkpoint: {
+            messageId: message.id,
+        },
+        attachments,
+    };
+}

package/dist/discord/send.js

@@ -0,0 +1,115 @@
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { parseAgentReply as parseSilentMarker } from "../runtime/silent-marker.js";
+import { chunkDiscord } from "./chunking.js";
+const NEWLINE_BURST_DELAY_MS = 500;
+const DISCORD_ATTACHMENT_SEND_TIMEOUT_MS = 120_000;
+const DISCORD_API_BASE_URL = "https://discord.com/api/v10";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function delayBetweenBurstChunks(config, channel) {
+    if (config.discord.chunkMode !== "newline")
+        return;
+    if (channel.isSendable()) {
+        void channel.sendTyping().catch(() => undefined);
+    }
+    await sleep(NEWLINE_BURST_DELAY_MS);
+}
+export function normalizeOutboundText(text) {
+    return text.trim() || "(empty response)";
+}
+function fallbackMimeType(name) {
+    return extname(name).toLowerCase() === ".mp3" ? "audio/mpeg" : "application/octet-stream";
+}
+export async function buildDiscordAttachmentFiles(attachments) {
+    const files = [];
+    for (const attachment of attachments) {
+        if (!attachment.localPath)
+            continue;
+        const data = await readFile(attachment.localPath);
+        files.push({
+            name: attachment.name,
+            data,
+            contentType: attachment.mimeType || fallbackMimeType(attachment.name),
+        });
+    }
+    return files;
+}
+export async function postDiscordAttachments(botToken, channelId, attachments) {
+    const files = await buildDiscordAttachmentFiles(attachments);
+    if (files.length === 0)
+        return [];
+    const form = new FormData();
+    form.set("payload_json", JSON.stringify({}));
+    for (const [index, file] of files.entries()) {
+        const bytes = new Uint8Array(file.data.byteLength);
+        bytes.set(file.data);
+        form.set(`files[${index}]`, new Blob([bytes], { type: file.contentType }), file.name);
+    }
+    const response = await fetch(`${DISCORD_API_BASE_URL}/channels/${channelId}/messages`, {
+        method: "POST",
+        headers: { Authorization: `Bot ${botToken}` },
+        body: form,
+        signal: AbortSignal.timeout(DISCORD_ATTACHMENT_SEND_TIMEOUT_MS),
+    });
+    const data = (await response.json().catch(() => ({})));
+    if (!response.ok || !data.id)
+        throw new Error(data.message || `Discord attachment send failed (${response.status})`);
+    return [data.id];
+}
+export function parseOutboundReply(text) {
+    const parsed = parseSilentMarker(text);
+    if (parsed.silent)
+        return parsed;
+    return { text: normalizeOutboundText(parsed.text), silent: false };
+}
+async function sendChunkedMessage(config, botToken, channel, channelId, normalizedText, attachments, sendChunk) {
+    const chunks = chunkDiscord(config, normalizedText);
+    const sentIds = [];
+    for (const [index, chunk] of chunks.entries()) {
+        if (index > 0)
+            await delayBetweenBurstChunks(config, channel);
+        const sent = await sendChunk(chunk, index);
+        sentIds.push(sent.id);
+    }
+    const attachmentIds = await sendDiscordAttachments(botToken, channelId, attachments);
+    return [...sentIds, ...attachmentIds];
+}
+export async function sendReply(config, botToken, message, text, replyToMessageId, attachments = []) {
+    const normalizedText = normalizeOutboundText(text);
+    return sendChunkedMessage(config, botToken, message.channel, message.channelId, normalizedText, attachments, async (chunk, index) => {
+        if (!message.channel.isSendable()) {
+            throw new Error(`Discord channel is not sendable: ${message.channelId}`);
+        }
+        if (index === 0 && config.discord.replyMode === "reply") {
+            try {
+                const replyTarget = replyToMessageId || message.id;
+                const options = { content: chunk, reply: { messageReference: replyTarget } };
+                return await message.channel.send(options);
+            }
+            catch (error) {
+                console.error("Discord reply failed; falling back to channel send", error);
+            }
+        }
+        return message.channel.send(chunk);
+    });
+}
+export async function sendChannelMessage(config, botToken, channel, text, attachments = []) {
+    if (!channel.isSendable()) {
+        throw new Error("Discord channel is not sendable");
+    }
+    const normalizedText = normalizeOutboundText(text);
+    return sendChunkedMessage(config, botToken, channel, channel.id, normalizedText, attachments, (chunk) => channel.send(chunk));
+}
+export async function sendDiscordAttachments(botToken, channelId, attachments) {
+    if (attachments.length === 0)
+        return [];
+    try {
+        return await postDiscordAttachments(botToken, channelId, attachments);
+    }
+    catch (error) {
+        console.error("Discord attachment send failed", error);
+        return [];
+    }
+}

package/dist/discord/turn.js

@@ -0,0 +1,55 @@
+import { messageId } from "../conversation/ids.js";
+import { createAgentEventRecorder, storedAgentEventFromAgentEvent, updateAgentEventSummary, } from "../runtime/agent-events.js";
+import { isHeartbeatDue } from "../runtime/scheduler.js";
+import { parseOutboundReply } from "./send.js";
+export const HEARTBEAT_SKIPPED = Symbol("heartbeat-skipped");
+export const CRON_SKIPPED = Symbol("cron-skipped");
+export function isCanceledJob(error) {
+    if (!(error instanceof Error))
+        return false;
+    return error.name === "CanceledJobError" || error.name === "AbortError" || /aborted|abort/i.test(error.message);
+}
+export function canceledJobError() {
+    const error = new Error("Job was canceled before completion.");
+    error.name = "CanceledJobError";
+    return error;
+}
+export function scheduledUserMessage(text, timestamp) {
+    return { role: "user", content: [{ type: "text", text }], timestamp };
+}
+export function heartbeatStillDue(config, now, lastUserInteractionAt, lastHeartbeatAt) {
+    return isHeartbeatDue({
+        now,
+        lastUserInteractionAt,
+        lastHeartbeatAt,
+        idleThresholdMs: config.heartbeat.idleThresholdMs,
+        intervalMs: config.heartbeat.intervalMs,
+    });
+}
+export async function runAgentTurn(jobKey, runtime, prompt) {
+    const assistantMessageId = messageId();
+    const summary = { thinking: "" };
+    const recorder = createAgentEventRecorder((storedEvent) => runtime.noteAgentEvent(jobKey, assistantMessageId, storedEvent, { notify: false }));
+    let reply;
+    try {
+        reply = await prompt(async (event) => {
+            updateAgentEventSummary(summary, event);
+            const storedEvent = storedAgentEventFromAgentEvent(event);
+            if (storedEvent) {
+                runtime.publishAgentEvent(jobKey, assistantMessageId, storedEvent);
+                await recorder.record(storedEvent);
+            }
+        });
+    }
+    finally {
+        await recorder.flush();
+    }
+    if (reply === HEARTBEAT_SKIPPED || reply === CRON_SKIPPED)
+        return null;
+    return {
+        reply,
+        parsedReply: parseOutboundReply(reply.text),
+        summary,
+        assistantMessageId,
+    };
+}

package/dist/index.js

@@ -1,11 +1,12 @@
-export { createFamiliarAgent } from "./agent.js";
-export { buildRecordBase, chatChannelKey, chatLogPath, createChatLog, } from "./chat-log.js";
-export { loadConfig } from "./config.js";
-export { startDiscordDaemon } from "./discord.js";
-export { startWorkspaceHotReload } from "./hot-reload.js";
-export { clampConfiguredThinkingLevel, createConfiguredModel, describeModelAuth, formatAllowedModels, isAllowedModel, isThinkingLevel, parseModelRef, resolveModel, resolveModelApiKey, supportedThinkingLevels, } from "./models.js";
-export { buildSystemPrompt, loadPersona } from "./persona.js";
-export { ConversationRuntime, } from "./runtime.js";
-export { loadSettingsStore, } from "./settings.js";
-export { formatFamiliarSkillsForPrompt, loadFamiliarSkills } from "./skills.js";
-export { startWebDaemon } from "./web.js";
+export { createFamiliarAgent } from "./agent/factory.js";
+export { loadConfig } from "./config/index.js";
+export { loadSettingsStore, } from "./config/settings.js";
+export { buildRecordBase, chatChannelKey, chatLogPath, createChatLog, } from "./conversation/chat-log.js";
+export { startDiscordDaemon } from "./discord/daemon.js";
+export { startWorkspaceHotReload } from "./lifecycle/hot-reload.js";
+export { clampConfiguredThinkingLevel, createConfiguredModel, describeModelAuth, formatAllowedModels, isAllowedModel, isThinkingLevel, parseModelRef, resolveModel, resolveModelApiKey, supportedThinkingLevels, } from "./models/index.js";
+export { buildSystemPrompt, loadPersona } from "./prompting/persona.js";
+export { formatFamiliarSkillsForPrompt, loadFamiliarSkills } from "./prompting/skills.js";
+export { createAgentCore } from "./runtime/agent-core.js";
+export { ConversationRuntime, } from "./runtime/conversation-runtime.js";
+export { startWebDaemon } from "./web/daemon.js";

package/dist/lifecycle/control.js

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

package/dist/{data-retention.js → lifecycle/data-retention.js}

@@ -1,6 +1,6 @@
 import { lstat, readdir, rm } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { isEnoent } from "./util/fs.js";
+import { isEnoent } from "../util/fs.js";
 export async function runDataRetention(config, now = Date.now()) {
     if (config.data.transcripts.retentionDays > 0) {
         console.warn("data.transcripts.retention_days is configured; transcript replay may lose restart context after retention.");

package/dist/{hot-reload.js → lifecycle/hot-reload.js}

@@ -1,8 +1,8 @@
 import { watch } from "node:fs";
 import { readdir } from "node:fs/promises";
 import { basename, relative, resolve, sep } from "node:path";
-import { refreshContactNote } from "./contact-note.js";
-import { isEnoent } from "./util/fs.js";
+import { refreshContactNote } from "../conversation/contact-note.js";
+import { isEnoent } from "../util/fs.js";
 const ROOT_FILES = new Set([
     "config.toml",
     ".env",

package/dist/{service.js → lifecycle/service.js}

@@ -279,6 +279,7 @@ export async function upgradeFamiliar(workspacePath, options = {}) {
     const npmCommand = currentPlatform === "win32" ? "npm.cmd" : "npm";
     const familiarCommand = currentPlatform === "win32" ? "familiar.cmd" : "familiar";
     await runInteractive(npmCommand, ["install", "-g", "@qearlyao/familiar@latest"], options, "npm upgrade");
+    await runInteractive(npmCommand, ["install", "-g", "@jackwener/opencli"], options, "OpenCLI upgrade");
     await runInteractive(familiarCommand, ["init", workspacePath], options, "workspace default refresh");
 }
 export function formatServiceResult(result) {

package/dist/media/attachment-limits.js

@@ -0,0 +1,3 @@
+export const MAX_INBOUND_ATTACHMENTS = 4;
+export const MAX_INBOUND_ATTACHMENT_BYTES = 32 * 1024 * 1024;
+export const MAX_INBOUND_TOTAL_BYTES = 96 * 1024 * 1024;

package/dist/{generated-media.js → media/generated-media.js}

@@ -1,6 +1,6 @@
 import { lstat, mkdir, readdir, rm } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve } from "node:path";
-import { isEnoent } from "./util/fs.js";
+import { isEnoent } from "../util/fs.js";
 export function createGeneratedMediaSink() {
     const attachments = [];
     return {