briyah 1.0.2 → 1.0.3

package/dist/room/room-store.service.js

@@ -1,353 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoomStoreService = void 0;
-const common_1 = require("@nestjs/common");
-const room_1 = require("./room");
-const crypto_1 = require("crypto");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const configuration_service_1 = require("../config/configuration.service");
-const agent_store_service_1 = require("../ai/agent-store.service");
-const attached_file_service_1 = require("../ai/attached-file.service");
-const artifact_store_service_1 = require("./artifact-store.service");
-let RoomStoreService = class RoomStoreService {
-    configService;
-    agentStore;
-    attachedFileService;
-    artifactStoreService;
-    rooms = new Map();
-    defaultStorageDir;
-    loaded = false;
-    loadPromise = null;
-    constructor(configService, agentStore, attachedFileService, artifactStoreService) {
-        this.configService = configService;
-        this.agentStore = agentStore;
-        this.attachedFileService = attachedFileService;
-        this.artifactStoreService = artifactStoreService;
-        this.defaultStorageDir = path.join(this.configService.getUserDataDir(), 'rooms');
-    }
-    getDefaultStorageDir() {
-        return this.defaultStorageDir;
-    }
-    storeRoom(room, storageDir) {
-        const finalStorageDir = storageDir || this.defaultStorageDir;
-        room.setStorageDir(finalStorageDir);
-        room.setRoomStoreService(this);
-        this.rooms.set(room.getId(), room);
-        this.saveRoomToFile(room, finalStorageDir);
-        return room.getId();
-    }
-    async getRoom(id) {
-        await this.ensureLoaded();
-        return this.rooms.get(id) || null;
-    }
-    removeRoom(id, storageDir, deleteAgents = false) {
-        const room = this.rooms.get(id);
-        const result = this.rooms.delete(id);
-        if (result) {
-            this.deleteRoomFile(id, storageDir || this.defaultStorageDir, deleteAgents, room);
-        }
-        return result;
-    }
-    async getAllRoomIds() {
-        await this.ensureLoaded();
-        return Array.from(this.rooms.keys());
-    }
-    getRoomCount() {
-        return this.rooms.size;
-    }
-    async cloneRoomAsPublished(templateId, publishedName, userId) {
-        await this.ensureLoaded();
-        const template = await this.getRoom(templateId);
-        if (!template) {
-            throw new Error(`Template room not found: ${templateId}`);
-        }
-        const instanceId = (0, crypto_1.randomUUID)();
-        const templateAgents = template.getAgents();
-        const clonedAgentIds = [];
-        for (const templateAgent of templateAgents) {
-            const clonedAgentId = await this.agentStore.cloneAgentAsPublished(templateAgent.id, templateAgent.agentName, userId);
-            clonedAgentIds.push(clonedAgentId);
-            const clonedAgent = await this.agentStore.getAgent(clonedAgentId);
-            if (clonedAgent) {
-                clonedAgent.ownerRoomId = instanceId;
-                this.agentStore.storeAgent(clonedAgent);
-            }
-        }
-        const instance = new room_1.Room(instanceId, publishedName, template.getGoal(), template.getBaseRoomDir(), this.defaultStorageDir, this);
-        for (const agentId of clonedAgentIds) {
-            const agent = await this.agentStore.getAgent(agentId);
-            if (agent) {
-                instance.arrive(agent);
-            }
-        }
-        instance.setPublished(true);
-        instance.setTemplateRoomId(templateId);
-        instance.setRoomLeader(template.getRoomLeader());
-        this.storeRoom(instance);
-        return instanceId;
-    }
-    async getPublishedInstances(templateId) {
-        await this.ensureLoaded();
-        const instances = [];
-        for (const room of this.rooms.values()) {
-            if (room.getTemplateRoomId() === templateId) {
-                instances.push(room);
-            }
-        }
-        return instances;
-    }
-    async ensureLoaded() {
-        if (this.loaded)
-            return;
-        if (!this.loadPromise) {
-            this.loadPromise = this.loadRoomsFromDirectory(this.defaultStorageDir)
-                .then(() => {
-                this.loaded = true;
-            })
-                .catch((error) => {
-                this.loadPromise = null;
-                throw error;
-            });
-        }
-        await this.loadPromise;
-    }
-    async getAllRooms() {
-        await this.ensureLoaded();
-        return Array.from(this.rooms.entries()).map(([id, room]) => ({
-            id,
-            name: room.getName(),
-            goal: room.getGoal(),
-            agentCount: room.getAgentCount(),
-        }));
-    }
-    async readRoomMessagesFromFileAsync(messagesPath) {
-        try {
-            try {
-                let messagesContent = await fs.promises.readFile(messagesPath, 'utf-8');
-                if (!messagesContent)
-                    return [];
-                if (messagesContent.startsWith(','))
-                    messagesContent = messagesContent.slice(1);
-                return JSON.parse('[' + messagesContent + ']');
-            }
-            catch (error) {
-                if (error.code === 'ENOENT') {
-                    return [];
-                }
-                throw error;
-            }
-        }
-        catch (error) {
-            console.error(`Error reading room messages from file ${messagesPath}:`, error);
-            return [];
-        }
-    }
-    async loadRoomsFromDirectory(storageDir) {
-        try {
-            try {
-                await fs.promises.access(storageDir);
-            }
-            catch {
-                console.log(`Room storage directory not found: ${storageDir}`);
-                await fs.promises.mkdir(storageDir, { recursive: true });
-                return;
-            }
-            const entries = await fs.promises.readdir(storageDir, {
-                withFileTypes: true,
-            });
-            const roomDirs = entries
-                .filter((entry) => entry.isDirectory())
-                .map((entry) => entry.name);
-            console.log(`Loading ${roomDirs.length} rooms from ${storageDir}`);
-            for (const roomDirName of roomDirs) {
-                try {
-                    const roomDir = path.join(storageDir, roomDirName);
-                    const metadataPath = path.join(roomDir, 'metadata.json');
-                    const messagesPath = path.join(roomDir, 'messages');
-                    try {
-                        await fs.promises.access(metadataPath);
-                    }
-                    catch {
-                        console.warn(`Skipping ${roomDirName}: metadata.json not found`);
-                        continue;
-                    }
-                    const fileContent = await fs.promises.readFile(metadataPath, 'utf-8');
-                    const config = JSON.parse(fileContent);
-                    let messages = await this.readRoomMessagesFromFileAsync(messagesPath);
-                    const room = new room_1.Room(config.id, config.name, config.goal, '', storageDir, this);
-                    room.setLoading(true);
-                    room.setCreatedAt(new Date(config.createdAt));
-                    room.setRoomMessages(messages);
-                    const artifacts = this.artifactStoreService.loadArtifacts(config.id, storageDir);
-                    room.setArtifacts(artifacts);
-                    if (config.isPublished !== undefined) {
-                        room.setPublished(config.isPublished);
-                    }
-                    if (config.templateRoomId) {
-                        room.setTemplateRoomId(config.templateRoomId);
-                    }
-                    for (const agentId of config.agentIds) {
-                        const agent = await this.agentStore.getAgent(agentId);
-                        if (agent) {
-                            room.arrive(agent);
-                        }
-                        else {
-                            console.warn(`Agent ${agentId} not found when loading room ${config.name} from ${storageDir}`);
-                        }
-                    }
-                    room.setRoomLeader(config.roomLeader);
-                    this.rooms.set(config.id, room);
-                    room.setLoading(false);
-                    room.ready();
-                    console.log(`Loaded room: ${config.name} (${config.id}) with ${messages.length} messages from ${storageDir}`);
-                }
-                catch (error) {
-                    console.error(`Error loading room from directory ${roomDirName}:`, error);
-                }
-            }
-        }
-        catch (error) {
-            console.error(`Error loading rooms from directory ${storageDir}:`, error);
-        }
-    }
-    saveRoomToFile(room, storageDir) {
-        try {
-            if (!fs.existsSync(storageDir)) {
-                fs.mkdirSync(storageDir, { recursive: true });
-            }
-            const roomDir = path.join(storageDir, room.getId());
-            if (!fs.existsSync(roomDir)) {
-                fs.mkdirSync(roomDir, { recursive: true });
-            }
-            const config = {
-                id: room.getId(),
-                name: room.getName(),
-                goal: room.getGoal(),
-                agentIds: room.getAgents().map((agent) => agent.id),
-                roomLeader: room.getRoomLeader(),
-                messages: [],
-                createdAt: room.getCreatedAt().toISOString(),
-                isPublished: room.getIsPublished(),
-                templateRoomId: room.getTemplateRoomId(),
-            };
-            const metadataPath = path.join(roomDir, 'metadata.json');
-            fs.writeFileSync(metadataPath, JSON.stringify(config, null, 2), 'utf-8');
-        }
-        catch (error) {
-            console.error(`Error saving room ${room.getId()} to file:`, error);
-        }
-    }
-    appendMessageToFile(roomId, message, storageDir) {
-        try {
-            const roomDir = path.join(storageDir, roomId);
-            const messagesPath = path.join(roomDir, 'messages');
-            fs.appendFileSync(messagesPath, ',\n' + JSON.stringify(message), 'utf-8');
-        }
-        catch (error) {
-            console.error(`Error appending message to room ${roomId}:`, error);
-        }
-    }
-    clearRoomMessages(roomId, storageDir) {
-        try {
-            const finalStorageDir = storageDir || this.defaultStorageDir;
-            const room = this.rooms.get(roomId);
-            if (room) {
-                room.setRoomMessages([]);
-            }
-            const roomDir = path.join(finalStorageDir, roomId);
-            const messagesPath = path.join(roomDir, 'messages');
-            if (fs.existsSync(messagesPath)) {
-                fs.unlinkSync(messagesPath);
-                console.log(`Cleared messages for room ${roomId}`);
-            }
-        }
-        catch (error) {
-            console.error(`Error clearing messages for room ${roomId}:`, error);
-        }
-    }
-    saveArtifactFile(roomId, storageDir, artifact) {
-        this.artifactStoreService.saveArtifact(roomId, storageDir, artifact);
-    }
-    deleteArtifactFile(roomId, storageDir, artifactName) {
-        return this.artifactStoreService.deleteArtifact(roomId, storageDir, artifactName);
-    }
-    deleteAllArtifactFiles(roomId, storageDir) {
-        this.artifactStoreService.deleteAllArtifacts(roomId, storageDir);
-    }
-    deleteRoomFile(roomId, storageDir, deleteAgents = false, room) {
-        try {
-            if (deleteAgents && room) {
-                const agents = room.getAgents();
-                for (const agent of agents) {
-                    try {
-                        this.agentStore.removeAgent(agent.id);
-                        console.log(`Deleted agent ${agent.agentName} (${agent.id}) as part of room deletion`);
-                    }
-                    catch (err) {
-                        console.error(`Failed to delete agent ${agent.id}:`, err);
-                    }
-                }
-            }
-            const roomDir = path.join(storageDir, roomId);
-            if (fs.existsSync(roomDir)) {
-                this.deleteAllArtifactFiles(roomId, storageDir);
-                fs.rmSync(roomDir, { recursive: true, force: true });
-                console.log(`Deleted room directory: ${roomDir}`);
-            }
-        }
-        catch (error) {
-            console.error(`Error deleting room directory ${roomId}:`, error);
-        }
-    }
-};
-exports.RoomStoreService = RoomStoreService;
-exports.RoomStoreService = RoomStoreService = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [configuration_service_1.ConfigurationService,
-        agent_store_service_1.AgentStoreService,
-        attached_file_service_1.AttachedFileService,
-        artifact_store_service_1.ArtifactStoreService])
-], RoomStoreService);

package/dist/room/room.d.ts

@@ -1,107 +0,0 @@
-import { Agent } from '../ai/agent';
-import { RoomMessage } from './message';
-import { Artifact } from './artifact';
-export declare class Room {
-    private id;
-    private name;
-    private goal;
-    private baseRoomDir;
-    private agents;
-    private roomLeader;
-    private roomMessages;
-    private pendingMessages;
-    private nextMessageIndex;
-    private createdAt;
-    private artifacts;
-    private isAdjourned;
-    private processingInProgress;
-    private isPaused;
-    private currentSpeaker;
-    private isPublished;
-    private isLoading;
-    private onStateChange?;
-    private onError?;
-    private currentSituation;
-    private onSituationUpdate?;
-    private templateRoomId;
-    private storageDir;
-    private roomStoreService;
-    constructor(id: string | null, name: string, goal: string, baseRoomDir?: string, storageDir?: string, roomStoreService?: any);
-    deleteRoom(): void;
-    setLoading(isLoading: boolean): void;
-    getName(): string;
-    setName(name: string): void;
-    getGoal(): string;
-    setGoal(goal: string): void;
-    getBaseRoomDir(): string;
-    setBaseRoomDir(dir: string): void;
-    getIsPublished(): boolean;
-    setPublished(published: boolean): void;
-    getPaused(): boolean;
-    getTemplateRoomId(): string | undefined;
-    setTemplateRoomId(templateId: string): void;
-    clearRoomMessages(): void;
-    arrive(agent: Agent): boolean;
-    getAgents(): Agent[];
-    setAgents(newAgents: Agent[]): void;
-    describeAgentsInRoom(): string;
-    setRoomLeader(agentNickname: string): void;
-    getRoomLeader(): string;
-    getAgentCount(): number;
-    ready(): void;
-    getCurrentSpeaker(): string | null;
-    setCurrentSpeaker(agentNickname: string | null): void;
-    isAgentsTurn(agentNickname: string): boolean;
-    getRoomMessageStats(): {
-        numMessages: number;
-        numChars: number;
-    };
-    getLatestRoomMessages(fromIndex?: number, includeThoughts?: boolean): RoomMessage[];
-    setRoomMessages(messages: RoomMessage[]): void;
-    addRoomMessage(message: RoomMessage): void;
-    addRoomMessages(messages: RoomMessage[]): void;
-    getCreatedAt(): Date;
-    setCreatedAt(date: Date): void;
-    getArtifacts(): Artifact[];
-    isRoomAdjourned(): boolean;
-    setArtifacts(artifacts: Artifact[]): void;
-    private parseAgentResponse;
-    private getAgentAiResponse;
-    perceive(agent: Agent, message: RoomMessage, onResponse: (message: RoomMessage | null) => void): void;
-    moderate(moderatorAgent: Agent, message: RoomMessage, onResponse: (message: RoomMessage | null) => void): Promise<void>;
-    private handleInsufficientBalance;
-    findArtifact(name: string): Artifact | undefined;
-    publishArtifact(name: string, creator: string, body: string, viewers?: string[]): Artifact | null;
-    deleteArtifact(name: string): boolean;
-    getVisibleArtifacts(agentNickname: string): Artifact[];
-    getId(): string;
-    setId(id: string): void;
-    getStorageDir(): string;
-    setStorageDir(dir: string): void;
-    getRoomStoreService(): any;
-    setRoomStoreService(service: any): void;
-    saveMessages(messages: RoomMessage[]): void;
-    saveMetadata(): string;
-    setOnStateChange(callback: () => void): void;
-    notifyStateChange(): void;
-    setOnError(callback: (error: Error) => void): void;
-    private notifyError;
-    getHumanAgentName(): string;
-    getModeratorAgent(): Agent | undefined;
-    getSituation(): string;
-    setSituation(situation: string): void;
-    setOnSituationUpdate(callback: (situation: string) => void): void;
-    private handleSituationUpdate;
-    handlePublishMessages(messages: RoomMessage[]): void;
-    handleExecuteMessages(messages: RoomMessage[]): void;
-    private executeCommand;
-    handleAdjournMessages(messages: RoomMessage[]): void;
-    addPendingMessage(message: RoomMessage, clearQueue?: boolean): void;
-    isProcessingInProgress(): boolean;
-    pause(): void;
-    resume(): void;
-    checkAgentNicknameMatch(existingNickname: string, targetNickname: string): boolean;
-    private handleModeratorResponse;
-    private processPendingMessages;
-    private filterConcurrentMessages;
-}