briyah 1.0.0

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

@@ -0,0 +1,392 @@
+"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.StoryStoreService = void 0;
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
+const configuration_service_1 = require("../config/configuration.service");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const room_store_service_1 = require("../room/room-store.service");
+let StoryStoreService = class StoryStoreService {
+    configService;
+    roomStore;
+    storiesDir;
+    constructor(configService, roomStore) {
+        this.configService = configService;
+        this.roomStore = roomStore;
+        this.storiesDir = path.join(this.configService.getUserDataDir(), 'stories');
+        if (!fs.existsSync(this.storiesDir)) {
+            fs.mkdirSync(this.storiesDir, { recursive: true });
+        }
+    }
+    createStory(name) {
+        const storyId = (0, crypto_1.randomUUID)();
+        const storyFolder = path.join(this.storiesDir, storyId);
+        const chaptersFolder = path.join(storyFolder, 'chapters');
+        fs.mkdirSync(chaptersFolder, { recursive: true });
+        const storyInfo = {
+            aiModel: '',
+            aiService: '',
+            chapters: [],
+            isImport: false,
+            moderatorAgentId: '',
+            roomId: '',
+            situation: '',
+            totalCost: 0,
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            turnNumber: 0,
+            id: storyId,
+            name,
+            scenario: '',
+            characters: [],
+        };
+        const metadataPath = path.join(storyFolder, 'metadata.json');
+        fs.writeFileSync(metadataPath, JSON.stringify(storyInfo, null, 2));
+        console.log(`Created story: ${name} (${storyId})`);
+        return storyInfo;
+    }
+    getStory(id) {
+        const storyFolder = path.join(this.storiesDir, id);
+        const metadataPath = path.join(storyFolder, 'metadata.json');
+        if (!fs.existsSync(metadataPath)) {
+            return null;
+        }
+        try {
+            const metadataContent = fs.readFileSync(metadataPath, 'utf8');
+            const storyInfo = JSON.parse(metadataContent);
+            return storyInfo;
+        }
+        catch (error) {
+            console.error(`Error reading story ${id}:`, error);
+            return null;
+        }
+    }
+    updateStoryMetadata(id, storyInfo) {
+        const storyFolder = path.join(this.storiesDir, id);
+        const metadataPath = path.join(storyFolder, 'metadata.json');
+        if (!fs.existsSync(storyFolder)) {
+            console.warn(`Cannot update metadata for story ${id}: directory does not exist (likely cleaned up after error)`);
+            return false;
+        }
+        try {
+            fs.writeFileSync(metadataPath, JSON.stringify(storyInfo, null, 2));
+            return true;
+        }
+        catch (error) {
+            console.error(`Error updating metadata for story ${id}:`, error);
+            return false;
+        }
+    }
+    saveStoryCreationParameters(id, idea, userCharacterDesc, otherCharactersDesc) {
+        const storyFolder = path.join(this.storiesDir, id);
+        const creationParamsPath = path.join(storyFolder, 'story_creation.json');
+        if (!fs.existsSync(storyFolder)) {
+            console.warn(`Cannot save creation parameters for story ${id}: directory does not exist`);
+            return false;
+        }
+        try {
+            const creationParams = {
+                idea,
+                userCharacterDesc,
+                otherCharactersDesc,
+            };
+            fs.writeFileSync(creationParamsPath, JSON.stringify(creationParams, null, 2));
+            console.log(`Saved creation parameters for story ${id}`);
+            return true;
+        }
+        catch (error) {
+            console.error(`Error saving creation parameters for story ${id}:`, error);
+            return false;
+        }
+    }
+    getAllStories() {
+        const stories = [];
+        try {
+            if (!fs.existsSync(this.storiesDir)) {
+                return stories;
+            }
+            const storyFolders = fs
+                .readdirSync(this.storiesDir, { withFileTypes: true })
+                .filter((dirent) => dirent.isDirectory())
+                .map((dirent) => dirent.name);
+            for (const storyId of storyFolders) {
+                const story = this.getStory(storyId);
+                if (story) {
+                    stories.push(story);
+                }
+            }
+            return stories;
+        }
+        catch (error) {
+            console.error('Error listing stories:', error);
+            return stories;
+        }
+    }
+    removeStory(id) {
+        const storyFolder = path.join(this.storiesDir, id);
+        if (!fs.existsSync(storyFolder)) {
+            return false;
+        }
+        try {
+            fs.rmSync(storyFolder, { recursive: true, force: true });
+            console.log(`Deleted story: ${id}`);
+            return true;
+        }
+        catch (error) {
+            console.error(`Error deleting story ${id}:`, error);
+            return false;
+        }
+    }
+    listChapters(storyId) {
+        const chaptersFolder = path.join(this.storiesDir, storyId, 'chapters');
+        if (!fs.existsSync(chaptersFolder)) {
+            return [];
+        }
+        try {
+            const items = fs.readdirSync(chaptersFolder);
+            const chapterInfos = [];
+            for (const item of items) {
+                const chapterPath = path.join(chaptersFolder, item);
+                if (!fs.statSync(chapterPath).isDirectory()) {
+                    continue;
+                }
+                const match = item.match(/^chapter_(\d+)$/);
+                if (!match) {
+                    continue;
+                }
+                const chapterNum = parseInt(match[1], 10);
+                const metadataPath = path.join(chapterPath, 'metadata.json');
+                let chapterTitle = `Chapter ${chapterNum}`;
+                if (fs.existsSync(metadataPath)) {
+                    try {
+                        const metadataContent = fs.readFileSync(metadataPath, 'utf8');
+                        const metadata = JSON.parse(metadataContent);
+                        if (metadata.chapterTitle) {
+                            chapterTitle = metadata.chapterTitle;
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Error reading chapter metadata for ${item}:`, error);
+                    }
+                }
+                chapterInfos.push({
+                    chapterNum,
+                    chapterTitle,
+                });
+            }
+            return chapterInfos.sort((a, b) => a.chapterNum - b.chapterNum);
+        }
+        catch (error) {
+            console.error(`Error listing chapters for story ${storyId}:`, error);
+            return [];
+        }
+    }
+    async getChapterContent(storyId, chapterIndex) {
+        const chapterMessagesPath = path.join(this.storiesDir, storyId, 'chapters', `chapter_${chapterIndex}`, 'messages');
+        try {
+            if (!fs.existsSync(chapterMessagesPath)) {
+                return null;
+            }
+            return await this.roomStore.readRoomMessagesFromFileAsync(chapterMessagesPath);
+        }
+        catch (error) {
+            console.error(`Error reading chapter ${chapterIndex} for story ${storyId}:`, error);
+            return null;
+        }
+    }
+    getNextChapterIndex(storyId) {
+        const chapters = this.listChapters(storyId);
+        return chapters.length > 0 ? Math.max(...chapters.map((c) => c.chapterNum)) + 1 : 1;
+    }
+    createChapterBackup(storyId, chapterIndex, chapterTitle) {
+        const storyFolder = path.join(this.storiesDir, storyId);
+        const chapterFolder = path.join(storyFolder, 'chapters', `chapter_${chapterIndex}`);
+        try {
+            const story = this.getStory(storyId);
+            if (!story || !story.roomId) {
+                console.error(`Cannot create chapter backup: story ${storyId} has no room ID`);
+                return false;
+            }
+            if (!fs.existsSync(chapterFolder)) {
+                fs.mkdirSync(chapterFolder, { recursive: true });
+            }
+            const roomFolder = path.join(storyFolder, 'rooms', story.roomId);
+            if (!fs.existsSync(roomFolder)) {
+                console.warn(`Room folder not found for story ${storyId}`);
+                return true;
+            }
+            const files = fs.readdirSync(roomFolder);
+            let copiedCount = 0;
+            for (const file of files) {
+                if (file === 'metadata.json') {
+                    continue;
+                }
+                const sourceFile = path.join(roomFolder, file);
+                const targetFile = path.join(chapterFolder, file);
+                if (fs.statSync(sourceFile).isFile()) {
+                    fs.copyFileSync(sourceFile, targetFile);
+                    copiedCount++;
+                }
+            }
+            const agentsFolder = path.join(storyFolder, 'agents');
+            const chapterAgentsFolder = path.join(chapterFolder, 'agents');
+            let agentsCopied = 0;
+            if (fs.existsSync(agentsFolder)) {
+                if (!fs.existsSync(chapterAgentsFolder)) {
+                    fs.mkdirSync(chapterAgentsFolder, { recursive: true });
+                }
+                const roomMetadataPath = path.join(roomFolder, 'metadata.json');
+                let agentIds = [];
+                if (fs.existsSync(roomMetadataPath)) {
+                    try {
+                        const roomMetadata = JSON.parse(fs.readFileSync(roomMetadataPath, 'utf8'));
+                        agentIds = roomMetadata.agentIds || [];
+                    }
+                    catch (error) {
+                        console.error(`Error reading room metadata for story ${storyId}:`, error);
+                    }
+                }
+                for (const agentId of agentIds) {
+                    const sourceAgentFile = path.join(agentsFolder, `${agentId}.json`);
+                    const targetAgentFile = path.join(chapterAgentsFolder, `${agentId}.json`);
+                    if (fs.existsSync(sourceAgentFile)) {
+                        fs.copyFileSync(sourceAgentFile, targetAgentFile);
+                        agentsCopied++;
+                    }
+                }
+            }
+            const chapterMetadata = {
+                chapterNum: chapterIndex,
+                chapterTitle: chapterTitle,
+            };
+            const metadataPath = path.join(chapterFolder, 'metadata.json');
+            fs.writeFileSync(metadataPath, JSON.stringify(chapterMetadata, null, 2), 'utf8');
+            console.log(`Created chapter ${chapterIndex} backup "${chapterTitle}" for story ${storyId} (copied ${copiedCount} room files, ${agentsCopied} agents)`);
+            return true;
+        }
+        catch (error) {
+            console.error(`Error creating chapter backup for story ${storyId}:`, error);
+            return false;
+        }
+    }
+    saveChapterContent(storyId, chapterIndex, content) {
+        const storyFolder = path.join(this.storiesDir, storyId);
+        const chapterFolder = path.join(storyFolder, 'chapters', `chapter_${chapterIndex}`);
+        try {
+            if (!fs.existsSync(chapterFolder)) {
+                fs.mkdirSync(chapterFolder, { recursive: true });
+            }
+            const chapterMessagesPath = path.join(chapterFolder, 'messages');
+            fs.writeFileSync(chapterMessagesPath, content, 'utf8');
+            console.log(`Saved chapter ${chapterIndex} content for story ${storyId} (${content.length} characters)`);
+            return true;
+        }
+        catch (error) {
+            console.error(`Error saving chapter content for story ${storyId}:`, error);
+            return false;
+        }
+    }
+    deleteChapter(storyId, chapterIndex) {
+        const chapterFolder = path.join(this.storiesDir, storyId, 'chapters', `chapter_${chapterIndex}`);
+        try {
+            if (!fs.existsSync(chapterFolder)) {
+                return false;
+            }
+            fs.rmSync(chapterFolder, { recursive: true, force: true });
+            console.log(`Deleted chapter ${chapterIndex} for story ${storyId}`);
+            return true;
+        }
+        catch (error) {
+            console.error(`Error deleting chapter ${chapterIndex} for story ${storyId}:`, error);
+            return false;
+        }
+    }
+    async restoreAgentsFromChapter(storyId, chapterIndex, agentStore) {
+        const storyFolder = path.join(this.storiesDir, storyId);
+        const chapterAgentsFolder = path.join(storyFolder, 'chapters', `chapter_${chapterIndex}`, 'agents');
+        const restoredAgentIds = [];
+        try {
+            if (!fs.existsSync(chapterAgentsFolder)) {
+                console.warn(`No agents folder found in chapter ${chapterIndex} backup for story ${storyId}`);
+                return restoredAgentIds;
+            }
+            const agentFiles = fs
+                .readdirSync(chapterAgentsFolder)
+                .filter((file) => file.endsWith('.json'));
+            for (const agentFile of agentFiles) {
+                const agentId = agentFile.replace('.json', '');
+                const chapterAgentPath = path.join(chapterAgentsFolder, agentFile);
+                try {
+                    const backupConfig = JSON.parse(fs.readFileSync(chapterAgentPath, 'utf8'));
+                    const agent = await agentStore.getAgent(agentId);
+                    if (agent) {
+                        agent.history = backupConfig.history || [];
+                        agent.save();
+                        restoredAgentIds.push(agentId);
+                        console.log(`Restored agent ${agentId} history from chapter ${chapterIndex} (${agent.history.length} messages)`);
+                    }
+                    else {
+                        console.warn(`Agent ${agentId} not found in memory, skipping restore`);
+                    }
+                }
+                catch (error) {
+                    console.error(`Error restoring agent ${agentId} from chapter ${chapterIndex}:`, error);
+                }
+            }
+            return restoredAgentIds;
+        }
+        catch (error) {
+            console.error(`Error restoring agents from chapter ${chapterIndex} for story ${storyId}:`, error);
+            return restoredAgentIds;
+        }
+    }
+};
+exports.StoryStoreService = StoryStoreService;
+exports.StoryStoreService = StoryStoreService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [configuration_service_1.ConfigurationService,
+        room_store_service_1.RoomStoreService])
+], StoryStoreService);

package/dist/story/story.service.d.ts

@@ -0,0 +1,94 @@
+import { StoryStoreService } from './story-store.service';
+import { StoryProgressService } from './story-progress.service';
+import { StoryMessageService } from './story-message.service';
+import { AgentStoreService } from '../ai/agent-store.service';
+import { AgentFactory } from '../ai/agent-factory';
+import { Room } from '../room/room';
+import { RoomFactory } from '../room/room-factory';
+import { RoomStoreService } from '../room/room-store.service';
+import { StoryInfo, StoryState, Character } from '@shared/types/app.types';
+import { ConfigurationService } from '../config/configuration.service';
+import { ArtifactService } from '../ai/artifact.service';
+import { Readable } from 'stream';
+export declare class StoryService {
+    private readonly storyStore;
+    private readonly agentStore;
+    private readonly roomStore;
+    private readonly progressService;
+    private readonly messageService;
+    private readonly configService;
+    private readonly agentFactory;
+    private readonly roomFactory;
+    private readonly storyArtifactServices;
+    constructor(storyStore: StoryStoreService, agentStore: AgentStoreService, roomStore: RoomStoreService, progressService: StoryProgressService, messageService: StoryMessageService, configService: ConfigurationService, agentFactory: AgentFactory, roomFactory: RoomFactory);
+    getProgressEmitter(storyId: string): import("node:events")<any>;
+    getMessageEmitter(storyId: string): import("node:events")<any>;
+    cleanupProgressEmitter(storyId: string): void;
+    cleanupMessageEmitter(storyId: string): void;
+    getStoryArtifactService(storyId: string): ArtifactService;
+    private emitStoryStateUpdate;
+    getHumanPrompt(room: Room): string;
+    private handleRoomError;
+    private getRandomWord;
+    private getStoryStorageDirs;
+    private getStoryModelConfig;
+    private getStoryRoom;
+    private ensureStoryLoaded;
+    getStoryInfo(storyId: string): Promise<StoryInfo | null>;
+    createStory(name: string, idea: string, userCharacterDesc: string, otherCharactersDesc: string, storyModel?: string, isImport?: boolean, imageModelName?: string): Promise<StoryInfo>;
+    private createStoryAsync;
+    generateCharacterPortraits(storyInfo: StoryInfo, room: Room): Promise<void>[];
+    generateOpeningSceneImage(storyInfo: StoryInfo, room: Room): Promise<{
+        type: string;
+        success: boolean;
+    }>;
+    private validateImportStructure;
+    private extractZip;
+    importStoryFromZip(zipBuffer: Buffer): Promise<StoryInfo>;
+    populateStoryHistory(room: Room, storyText: string): void;
+    getStoryState(storyId: string): Promise<StoryState>;
+    listCharacters(storyId: string): Promise<Character[]>;
+    getCharacter(storyId: string, characterName: string): Promise<string | null>;
+    saveCharacter(storyId: string, characterName: string, content: string): void;
+    getPlotPlan(storyId: string): Promise<string>;
+    getAgentHistory(storyId: string, agentId: string): Promise<string>;
+    savePlotPlan(storyId: string, content: string): Promise<void>;
+    publishArtifact(storyId: string, name: string, creator: string, body: string, viewers: string[]): Promise<void>;
+    respondToStory(storyId: string, content: string): Promise<void>;
+    introduceCharacter(storyId: string, characterName: string, characterDescription: string, storyModel?: string, fromNarratorSuggestion?: boolean): Promise<void>;
+    declineCharacter(storyId: string, characterName: string): Promise<void>;
+    deleteCharacter(storyId: string, characterName: string): Promise<void>;
+    deleteStory(storyId: string): Promise<void>;
+    private disableStoryAgentFlags;
+    private enableStoryAgentFlags;
+    compactStory(storyId: string): Promise<{
+        success: boolean;
+        message?: string;
+        details?: any;
+    }>;
+    progressStoryToNextChapter(storyId: string): Promise<{
+        chapterIndex: number;
+    }>;
+    private progressStoryToNextChapterAsync;
+    private generateOpeningScene;
+    private compactAgentHistories;
+    private compactAgentHistory;
+    private extractMarkdownContent;
+    private updatePlotPlan;
+    private updateCharacterProfiles;
+    private getImageModelConfig;
+    private createArtistAgent;
+    private generateCharacterPortrait;
+    private generateSceneIllustration;
+    private generateSceneReference;
+    private generateStoryImage;
+    private updateStorySituation;
+    generateStoryMarkdown(storyId: string): Promise<string>;
+    exportStoryData(storyId: string): Promise<{
+        stream: Readable;
+        filename: string;
+    }>;
+    private formatMessagesToMarkdown;
+    private processImageMarkdown;
+    private updateStoryCost;
+}