@qearlyao/familiar 0.1.0

package/dist/chat-log.js

@@ -0,0 +1,130 @@
+import { appendFile, mkdir, open, readdir, readFile, rm } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+function sanitizeSegment(value) {
+    return value.replace(/[^A-Za-z0-9._=-]+/g, "_").slice(0, 120) || "unknown";
+}
+export function chatChannelKey(channel) {
+    const parts = [channel.service, channel.scope, channel.channelId];
+    if (channel.threadId)
+        parts.push(channel.threadId);
+    return parts.map(sanitizeSegment).join("-");
+}
+export function chatLogPath(config, channel, now = new Date()) {
+    const date = now.toISOString().slice(0, 10);
+    return resolve(config.workspace.dataDir, "chat", chatChannelKey(channel), `${date}.jsonl`);
+}
+function chatLockPath(config, channel) {
+    return resolve(config.workspace.dataDir, "chat", chatChannelKey(channel), ".lock");
+}
+function chatChannelDir(config, channel) {
+    return resolve(config.workspace.dataDir, "chat", chatChannelKey(channel));
+}
+function getErrorCode(error) {
+    return error && typeof error === "object" && "code" in error ? String(error.code) : undefined;
+}
+function extractOwnerPid(owner) {
+    const match = owner.match(/^familiar-(\d+)-/);
+    if (!match)
+        return undefined;
+    const pid = Number(match[1]);
+    return Number.isFinite(pid) ? pid : undefined;
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return getErrorCode(error) === "EPERM";
+    }
+}
+function isChatLogRecord(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return typeof record.recordId === "number" && typeof record.ts === "string" && typeof record.type === "string";
+}
+export function createChatLog(config, channel) {
+    const dir = chatChannelDir(config, channel);
+    const lockPath = chatLockPath(config, channel);
+    return {
+        channel,
+        dir,
+        lockPath,
+        async read() {
+            let files;
+            try {
+                files = await readdir(dir);
+            }
+            catch (error) {
+                if (getErrorCode(error) === "ENOENT")
+                    return [];
+                throw error;
+            }
+            const records = [];
+            for (const file of files.filter((entry) => entry.endsWith(".jsonl")).sort()) {
+                const filePath = resolve(dir, file);
+                const content = await readFile(filePath, "utf8");
+                for (const [index, line] of content.split(/\r?\n/).entries()) {
+                    if (!line.trim())
+                        continue;
+                    const parsed = JSON.parse(line);
+                    if (!isChatLogRecord(parsed))
+                        throw new Error(`Malformed chat log record: ${filePath}:${index + 1}`);
+                    records.push(parsed);
+                }
+            }
+            return records.sort((a, b) => a.recordId - b.recordId);
+        },
+        async append(record) {
+            const recordPath = chatLogPath(config, channel, new Date(record.ts));
+            await mkdir(dirname(recordPath), { recursive: true });
+            await appendFile(recordPath, `${JSON.stringify(record)}\n`, "utf8");
+        },
+        async acquire(owner) {
+            await mkdir(dirname(lockPath), { recursive: true });
+            try {
+                const handle = await open(lockPath, "wx");
+                try {
+                    await handle.writeFile(`${owner}\n`, "utf8");
+                }
+                finally {
+                    await handle.close();
+                }
+                return;
+            }
+            catch (error) {
+                if (getErrorCode(error) !== "EEXIST")
+                    throw error;
+            }
+            const existingOwner = (await readFile(lockPath, "utf8").catch(() => "")).trim();
+            const existingPid = extractOwnerPid(existingOwner);
+            if (existingPid !== undefined && !isPidAlive(existingPid)) {
+                await rm(lockPath, { force: true });
+                const handle = await open(lockPath, "wx");
+                try {
+                    await handle.writeFile(`${owner}\n`, "utf8");
+                }
+                finally {
+                    await handle.close();
+                }
+                return;
+            }
+            throw new Error(`Chat channel is already locked by ${existingOwner || "another familiar process"}`);
+        },
+        async release() {
+            await rm(lockPath, { force: true });
+        },
+    };
+}
+export function buildRecordBase(channel, recordId) {
+    return {
+        recordId,
+        ts: new Date().toISOString(),
+        service: channel.service,
+        scope: channel.scope,
+        channelId: channel.channelId,
+        channelName: channel.channelName,
+        threadId: channel.threadId,
+    };
+}

package/dist/cli.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { copyFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { config as loadDotenv } from "dotenv";
+import { createFamiliarAgent } from "./agent.js";
+import { loadConfig } from "./config.js";
+import { runDataRetention } from "./data-retention.js";
+import { startDiscordDaemon } from "./discord.js";
+import { cleanupGeneratedAttachments } from "./generated-media.js";
+import { memoryHelp, runMemoryOperator } from "./memory/operator.js";
+import { createMemoryService } from "./memory/service.js";
+import { loadSettingsStore } from "./settings.js";
+import { startWebDaemon } from "./web.js";
+const SOURCE_DIR = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = resolve(SOURCE_DIR, "..");
+const DEFAULT_WORKSPACE_PATH = resolve(homedir(), ".familiar");
+const MEMORY_SUBCOMMANDS = new Set(["status", "doctor", "reindex", "backfill", "prune", "backup", "help", "--help"]);
+function defaultWorkspaceDirs(workspacePath) {
+    const memoryRoot = resolve(workspacePath, "memories");
+    return {
+        dataDir: resolve(workspacePath, "data"),
+        memoryIndexDir: resolve(memoryRoot, "index"),
+        memoryLcmDir: resolve(memoryRoot, "lcm"),
+        memoryDiariesDir: resolve(memoryRoot, "diaries"),
+        memoryArchiveDir: resolve(memoryRoot, "archive"),
+    };
+}
+function configuredWorkspaceDirs(config) {
+    return {
+        dataDir: config.workspace.dataDir,
+        memoryIndexDir: config.memory.indexDir,
+        memoryLcmDir: config.memory.lcmDir,
+        memoryDiariesDir: config.memory.diariesDir,
+        memoryArchiveDir: config.memory.archiveDir,
+    };
+}
+async function ensureWorkspaceDirs(dirs) {
+    await Promise.all([
+        mkdir(dirs.dataDir, { recursive: true }),
+        mkdir(dirs.memoryIndexDir, { recursive: true }),
+        mkdir(dirs.memoryLcmDir, { recursive: true }),
+        mkdir(dirs.memoryDiariesDir, { recursive: true }),
+        mkdir(dirs.memoryArchiveDir, { recursive: true }),
+    ]);
+}
+function resolveWorkspaceInput(workspaceInput) {
+    return workspaceInput ? resolve(workspaceInput) : DEFAULT_WORKSPACE_PATH;
+}
+function parseMemoryArgs(workspaceOrCommand, rest) {
+    if (workspaceOrCommand && !MEMORY_SUBCOMMANDS.has(workspaceOrCommand)) {
+        return { workspacePath: resolveWorkspaceInput(workspaceOrCommand), args: rest };
+    }
+    return { workspacePath: DEFAULT_WORKSPACE_PATH, args: workspaceOrCommand ? [workspaceOrCommand, ...rest] : rest };
+}
+function isMemoryHelp(args) {
+    const command = args[0];
+    return !command || command === "help" || command === "--help";
+}
+async function initWorkspace(workspaceInput) {
+    const workspacePath = resolveWorkspaceInput(workspaceInput);
+    await mkdir(workspacePath, { recursive: true });
+    const envPath = resolve(workspacePath, ".env");
+    if (!existsSync(envPath)) {
+        await copyFile(resolve(PROJECT_ROOT, ".env.example"), envPath);
+    }
+    await copyFile(resolve(PROJECT_ROOT, "config.example.toml"), resolve(workspacePath, "config.toml"));
+    await copyFile(resolve(PROJECT_ROOT, "SOUL.md"), resolve(workspacePath, "SOUL.md"));
+    await copyFile(resolve(PROJECT_ROOT, "USER.md"), resolve(workspacePath, "USER.md"));
+    await copyFile(resolve(PROJECT_ROOT, "MEMORY.md"), resolve(workspacePath, "MEMORY.md"));
+    await copyFile(resolve(PROJECT_ROOT, "HEARTBEAT.md"), resolve(workspacePath, "HEARTBEAT.md"));
+    await ensureWorkspaceDirs(defaultWorkspaceDirs(workspacePath));
+    console.log(`Initialized familiar workspace at ${workspacePath}`);
+}
+async function runDaemon(workspaceInput) {
+    const workspacePath = resolveWorkspaceInput(workspaceInput);
+    const envPath = resolve(workspacePath, ".env");
+    if (existsSync(envPath)) {
+        loadDotenv({ path: envPath, override: false });
+    }
+    const config = await loadConfig(workspacePath);
+    const reloadConfig = async () => {
+        if (existsSync(envPath)) {
+            loadDotenv({ path: envPath, override: true });
+        }
+        return loadConfig(workspacePath);
+    };
+    await ensureWorkspaceDirs(configuredWorkspaceDirs(config));
+    const removedAttachments = await cleanupGeneratedAttachments(config);
+    if (removedAttachments > 0) {
+        console.log(`Removed ${removedAttachments} expired generated attachment(s)`);
+    }
+    const retention = await runDataRetention(config);
+    const removedData = retention.chat + retention.transcripts + retention.payloads;
+    if (removedData > 0) {
+        console.log(`Removed ${removedData} expired data file(s)`);
+    }
+    const settings = await loadSettingsStore(config);
+    const memoryService = createMemoryService(config);
+    await memoryService.indexDiaries().catch((error) => console.error("initial diary indexing failed", error));
+    memoryService.watchDiaries();
+    const familiarAgent = await createFamiliarAgent(config, settings, memoryService, { reloadConfig });
+    const discordDaemon = await startDiscordDaemon(config, familiarAgent, settings, memoryService);
+    const webDaemon = await startWebDaemon(config, familiarAgent, discordDaemon);
+    console.log(`familiar running for workspace ${config.workspacePath}`);
+    console.log("agent sessions are created per channel");
+    console.log(`settings=${settings.path}`);
+    const stop = async () => {
+        console.log("Stopping familiar");
+        await Promise.all([webDaemon.stop(), discordDaemon.stop()]);
+        memoryService.close();
+        process.exit(0);
+    };
+    process.once("SIGINT", () => void stop());
+    process.once("SIGTERM", () => void stop());
+    await new Promise(() => { });
+}
+function usage() {
+    return [
+        "Usage:",
+        "  familiar init [workspace]",
+        "  familiar run [workspace]",
+        "  familiar memory [workspace] <subcommand>",
+        "  familiar install-service",
+        "  familiar status",
+        "  familiar upgrade",
+        "",
+        `Default workspace: ${DEFAULT_WORKSPACE_PATH}`,
+    ].join("\n");
+}
+async function main() {
+    const [, , command, workspace, ...rest] = process.argv;
+    if (command === "init") {
+        await initWorkspace(workspace);
+        return;
+    }
+    if (command === "run") {
+        await runDaemon(workspace);
+        return;
+    }
+    if (command === "memory") {
+        const { workspacePath, args } = parseMemoryArgs(workspace, rest);
+        if (isMemoryHelp(args)) {
+            console.log(memoryHelp());
+            return;
+        }
+        const envPath = resolve(workspacePath, ".env");
+        if (existsSync(envPath)) {
+            loadDotenv({ path: envPath, override: false });
+        }
+        const config = await loadConfig(workspacePath);
+        await ensureWorkspaceDirs(configuredWorkspaceDirs(config));
+        await runMemoryOperator(config, args);
+        return;
+    }
+    if (command === "install-service" || command === "status" || command === "upgrade") {
+        console.log("not yet implemented");
+        return;
+    }
+    console.error(usage());
+    process.exitCode = 1;
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+});