dialog-ide 0.5.0

package/dist/dialoged/skein/session.js

@@ -0,0 +1,690 @@
+"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 __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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkeinSession = void 0;
+exports.normalizeCommand = normalizeCommand;
+const os = __importStar(require("os"));
+const events_1 = require("events");
+const process_1 = require("./process");
+const tree_1 = require("./tree");
+const dynamic_1 = require("./dynamic");
+const compile_error_1 = require("./compile-error");
+const project_1 = require("./project");
+const progress_1 = require("./progress");
+const frotz_build_1 = require("./frotz-build");
+const DYNAMIC_COMMAND = '@dynamic';
+const DGDEBUG_TARGET_FILTER = 'dgdebug';
+const REPLAY_ALL_CONCURRENCY = Math.max(2, Math.min(8, os.cpus().length));
+const KEYSTROKE_KEY_CODES = {
+    enter: '\n',
+    space: ' ',
+    backspace: '\b'
+};
+function resolveKeystroke(command) {
+    return KEYSTROKE_KEY_CODES[command] ?? command;
+}
+async function mapWithConcurrency(items, limit, worker) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function runNext() {
+        for (;;) {
+            const index = nextIndex++;
+            if (index >= items.length) {
+                return;
+            }
+            results[index] = await worker(items[index]);
+        }
+    }
+    const workerCount = Math.max(1, Math.min(limit, items.length));
+    await Promise.all(Array.from({ length: workerCount }, runNext));
+    return results;
+}
+function normalizeCommand(text) {
+    return text.trim().replace(/\s+/g, ' ').toLowerCase();
+}
+class SkeinSession {
+    constructor(config, progressHost = progress_1.noopProgressHost) {
+        this.process = null;
+        this.isRunning = false;
+        this.showDynamicState = false;
+        this.markerFilter = null;
+        this.changeEmitter = new events_1.EventEmitter();
+        this.processPositionId = 0;
+        this.sourcesChanged = false;
+        this.graphMenuId = null;
+        this.transcriptMenuId = null;
+        this.lastJumpId = { new: null, error: null };
+        this.undoStack = [];
+        this.redoStack = [];
+        this.hasLoadedHistory = false;
+        this.id = this.generateId();
+        this.config = config;
+        this.tree = tree_1.SkeinTree.newTree(config.engine, config.seed);
+        this.dynamicProcessor = new dynamic_1.DynamicProcessor();
+        this.progressHost = progressHost;
+    }
+    generateId() {
+        return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    static createNew(config, progressHost) {
+        return new SkeinSession(config, progressHost);
+    }
+    static createLoaded(tree, config, progressHost) {
+        const session = new SkeinSession(config, progressHost);
+        session.tree = tree;
+        session.hasLoadedHistory = true;
+        return session;
+    }
+    async start() {
+        if (this.isRunning) {
+            throw new Error('Session already running');
+        }
+        try {
+            this.tree = await this.launchProcessAndCaptureBanner(this.tree, !this.hasLoadedHistory);
+            this.isRunning = true;
+            this.processPositionId = 0;
+            console.log(`Session ${this.id} started successfully`);
+            this.changeEmitter.emit('change');
+        }
+        catch (error) {
+            console.error('Failed to start session:', error);
+            throw error;
+        }
+    }
+    async launchProcessAndCaptureBanner(tree, blessRoot) {
+        this.process = new process_1.SkeinProcess(await this.buildProcessConfig());
+        this.sourcesChanged = false;
+        await this.process.start();
+        const banner = await this.process.readResponse();
+        if (!this.process.isProcessRunning()) {
+            throw new compile_error_1.DialogCompileError(banner.response);
+        }
+        let updated = tree.updateKnotResponse(0, { text: banner.response, inputType: banner.promptType });
+        if (blessRoot) {
+            updated = updated.blessKnot(0);
+        }
+        const dynamicState = await this.captureDynamicState(this.process, banner.promptType);
+        if (dynamicState) {
+            updated = updated.updateDynamicState(0, dynamicState);
+        }
+        return updated;
+    }
+    async buildProcessConfig(debugFlags) {
+        const { engine, seed, projectRoot, bundledBinDir, patchSourcePath } = this.config;
+        const project = (0, project_1.readProject)(projectRoot);
+        if (engine === 'dgdebug') {
+            const sourceFiles = (0, project_1.expandSources)(project, { debug: true, target: DGDEBUG_TARGET_FILTER });
+            return { engine, seed, sourceFiles, binDir: project.binDir, bundledBinDir, debugFlags };
+        }
+        if (!patchSourcePath) {
+            throw new Error(`${engine} requires patchSourcePath to be set on the session config`);
+        }
+        const gamePath = await (0, frotz_build_1.buildFrotzGame)({ project, engine, binDir: project.binDir, bundledBinDir, patchSourcePath });
+        return { engine, seed, gamePath, binDir: project.binDir, bundledBinDir, debugFlags };
+    }
+    getProjectRoot() {
+        return this.config.projectRoot;
+    }
+    markSourcesChanged() {
+        this.sourcesChanged = true;
+    }
+    async runCommand(command) {
+        if (!this.isRunning || !this.process) {
+            throw new Error('Session not running');
+        }
+        const parentId = this.tree.getActiveKnotId();
+        if (parentId === null) {
+            throw new Error('No active knot to run the command from');
+        }
+        if (parentId !== this.processPositionId || this.sourcesChanged) {
+            await this.replayTo(parentId);
+        }
+        try {
+            const process = this.process;
+            const keystroke = this.tree.promptTypeAt(parentId) === 'key';
+            if (keystroke) {
+                process.sendCommand(resolveKeystroke(command), true);
+            }
+            else {
+                process.sendCommand(command);
+            }
+            const response = await process.readResponse();
+            const newResponse = { text: response.response, inputType: response.promptType };
+            this.pushUndoSnapshot();
+            const existingChildId = this.tree.findChildId(parentId, command);
+            let activeKnotId;
+            if (existingChildId !== null) {
+                this.tree = this.tree.updateKnotResponse(existingChildId, newResponse);
+                activeKnotId = existingChildId;
+            }
+            else {
+                this.tree = this.tree.addChild(parentId, command, newResponse);
+                activeKnotId = this.tree.getDerivedKnot(parentId).selectedChild;
+            }
+            this.tree = this.tree.selectKnot(activeKnotId);
+            this.processPositionId = activeKnotId;
+            const dynamicState = await this.captureDynamicState(process, response.promptType);
+            if (dynamicState) {
+                this.tree = this.tree.updateDynamicState(activeKnotId, dynamicState);
+            }
+            console.log(`Command "${command}" executed successfully`);
+            this.changeEmitter.emit('change');
+        }
+        catch (error) {
+            console.error('Failed to execute command:', error);
+            throw error;
+        }
+    }
+    async replayPath(process, tree, targetId, token) {
+        const path = tree.commandPath(targetId);
+        const responses = new Map();
+        const dynamicStates = new Map();
+        let reachedId = 0;
+        let currentPromptType = tree.promptTypeAt(0);
+        for (const { id, command } of path) {
+            if (token?.isCancellationRequested) {
+                break;
+            }
+            const keystroke = currentPromptType === 'key';
+            if (keystroke) {
+                process.sendCommand(resolveKeystroke(command), true);
+            }
+            else {
+                process.sendCommand(command);
+            }
+            const response = await process.readResponse();
+            currentPromptType = response.promptType;
+            responses.set(id, { text: response.response, inputType: response.promptType });
+            const dynamicState = await this.captureDynamicState(process, response.promptType);
+            if (dynamicState) {
+                dynamicStates.set(id, dynamicState);
+            }
+            reachedId = id;
+        }
+        return { responses, dynamicStates, reachedId };
+    }
+    async captureDynamicState(process, promptType) {
+        if (this.config.engine !== 'dgdebug' || promptType === 'key') {
+            return null;
+        }
+        process.sendCommand(DYNAMIC_COMMAND);
+        const response = await process.readResponse();
+        return this.dynamicProcessor.parse(response.response);
+    }
+    async replayProcessTo(targetId) {
+        if (!this.process) {
+            throw new Error('Session not running');
+        }
+        await this.process.terminate();
+        this.tree = await this.launchProcessAndCaptureBanner(this.tree, false);
+        const { responses, dynamicStates, reachedId } = await this.replayPath(this.process, this.tree, targetId);
+        let tree = this.tree;
+        for (const [id, response] of responses) {
+            tree = tree.updateKnotResponse(id, response);
+        }
+        for (const [id, state] of dynamicStates) {
+            tree = tree.updateDynamicState(id, state);
+        }
+        this.tree = tree;
+        this.processPositionId = reachedId;
+        return { tree, reachedId };
+    }
+    async replayTo(targetId) {
+        const { tree, reachedId } = await this.replayProcessTo(targetId);
+        this.tree = tree.selectKnot(reachedId);
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    async replayAll() {
+        if (!this.process) {
+            throw new Error('Session not running');
+        }
+        const baseTree = this.tree;
+        const originalLeafId = baseTree.getSelectedLeafId();
+        const leafIds = baseTree.getLeafIds();
+        const totalLeaves = leafIds.length;
+        await this.progressHost.withProgress({ title: 'Replaying all paths...', cancellable: true }, async (progress, token) => {
+            let leavesReplayed = 0;
+            const replayLeaf = async (leafId) => {
+                if (token.isCancellationRequested) {
+                    return undefined;
+                }
+                const process = new process_1.SkeinProcess(await this.buildProcessConfig());
+                await process.start();
+                const banner = await process.readResponse();
+                if (!process.isProcessRunning()) {
+                    throw new compile_error_1.DialogCompileError(banner.response);
+                }
+                const bannerDynamicState = await this.captureDynamicState(process, banner.promptType);
+                const { responses, dynamicStates, reachedId } = await this.replayPath(process, baseTree, leafId, token);
+                responses.set(0, { text: banner.response, inputType: banner.promptType });
+                if (bannerDynamicState) {
+                    dynamicStates.set(0, bannerDynamicState);
+                }
+                leavesReplayed++;
+                progress.report({ message: `${leavesReplayed} of ${totalLeaves}`, increment: 100 / totalLeaves });
+                return { leafId, process, responses, dynamicStates, reachedId };
+            };
+            const results = (await mapWithConcurrency(leafIds, REPLAY_ALL_CONCURRENCY, replayLeaf))
+                .filter((result) => result !== undefined);
+            const originalResult = results.find((result) => result.leafId === originalLeafId);
+            await Promise.all(results.filter((result) => result !== originalResult).map((result) => result.process.terminate()));
+            const orderedResults = originalResult
+                ? [...results.filter((result) => result !== originalResult), originalResult]
+                : results;
+            let tree = baseTree;
+            for (const result of orderedResults) {
+                for (const [id, response] of result.responses) {
+                    tree = tree.updateKnotResponse(id, response);
+                }
+                for (const [id, state] of result.dynamicStates) {
+                    tree = tree.updateDynamicState(id, state);
+                }
+            }
+            if (originalResult) {
+                await this.process.terminate();
+                this.process = originalResult.process;
+                this.processPositionId = originalResult.reachedId;
+                this.sourcesChanged = false;
+            }
+            this.tree = tree;
+            this.closeMenus();
+            this.changeEmitter.emit('change');
+        });
+    }
+    async replayToKnot(id) {
+        await this.replayTo(id);
+    }
+    async traceKnot(knotId) {
+        if (!this.isRunning) {
+            throw new Error('Session not running');
+        }
+        if (this.config.engine !== 'dgdebug') {
+            return null;
+        }
+        const knot = this.tree.getKnot(knotId);
+        if (!knot || knot.parentId === null) {
+            return null;
+        }
+        const { command, parentId } = knot;
+        if (this.tree.promptTypeAt(parentId) === 'key') {
+            return null;
+        }
+        await this.replayProcessTo(parentId);
+        const process = this.process;
+        process.sendCommand('(trace on)');
+        await process.readResponse();
+        process.sendCommand(command);
+        const traceResult = await process.readResponse();
+        process.sendCommand('(trace off)');
+        await process.readResponse();
+        this.processPositionId = knotId;
+        const dynamicState = await this.captureDynamicState(process, traceResult.promptType);
+        if (dynamicState) {
+            this.tree = this.tree.updateDynamicState(knotId, dynamicState);
+        }
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+        return traceResult.response;
+    }
+    async traceStartup() {
+        if (this.config.engine !== 'dgdebug') {
+            return null;
+        }
+        const tracedProcess = new process_1.SkeinProcess(await this.buildProcessConfig(['--trace']));
+        await tracedProcess.start();
+        const tracedBanner = await tracedProcess.readResponse();
+        if (!tracedProcess.isProcessRunning()) {
+            throw new compile_error_1.DialogCompileError(tracedBanner.response);
+        }
+        await tracedProcess.terminate();
+        if (this.process) {
+            await this.process.terminate();
+        }
+        this.tree = await this.launchProcessAndCaptureBanner(this.tree, false);
+        this.processPositionId = 0;
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+        return tracedBanner.response;
+    }
+    setActiveKnot(id) {
+        if (!this.tree.getKnot(id)) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        this.tree = this.tree.selectKnot(id);
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    navigateSpine(direction) {
+        const activeId = this.tree.getActiveKnotId();
+        if (activeId === null) {
+            return;
+        }
+        const targetId = this.spineNavigationTarget(activeId, direction);
+        if (targetId === null || targetId === activeId) {
+            return;
+        }
+        this.setActiveKnot(targetId);
+    }
+    spineNavigationTarget(activeId, direction) {
+        switch (direction) {
+            case 'first':
+                return 0;
+            case 'last':
+                return this.tree.getSelectedLeafId();
+            case 'up':
+                return this.tree.getKnot(activeId)?.parentId ?? null;
+            case 'down':
+                return this.tree.getDerivedKnot(activeId)?.selectedChild ?? null;
+            case 'left':
+            case 'right': {
+                const knot = this.tree.getDerivedKnot(activeId);
+                if (!knot || knot.parentId === null) {
+                    return null;
+                }
+                const siblings = this.tree.sortedChildren(knot.parentId);
+                const index = siblings.findIndex((sibling) => sibling.id === activeId);
+                const targetIndex = index + (direction === 'left' ? -1 : 1);
+                return targetIndex >= 0 && targetIndex < siblings.length ? siblings[targetIndex].id : null;
+            }
+        }
+    }
+    seekStatus(status) {
+        const matching = this.tree.knotIdsWithStatus(status);
+        if (matching.length === 0) {
+            return;
+        }
+        const lastId = this.lastJumpId[status];
+        const index = lastId !== null ? matching.indexOf(lastId) : -1;
+        const nextId = matching[index >= 0 ? (index + 1) % matching.length : 0];
+        this.lastJumpId[status] = nextId;
+        this.setActiveKnot(nextId);
+    }
+    newChild(id) {
+        if (!this.tree.getKnot(id)) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        this.tree = this.tree.selectForNewChild(id);
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    openGraphMenu(id) {
+        if (!this.tree.getKnot(id)) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        this.transcriptMenuId = null;
+        this.graphMenuId = this.graphMenuId === id ? null : id;
+        this.changeEmitter.emit('change');
+    }
+    openTranscriptMenu(id) {
+        if (!this.tree.getKnot(id)) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        this.graphMenuId = null;
+        this.transcriptMenuId = this.transcriptMenuId === id ? null : id;
+        this.changeEmitter.emit('change');
+    }
+    toggleTreeNode(id) {
+        this.tree = this.tree.toggleCollapsed(id);
+        this.changeEmitter.emit('change');
+    }
+    getGraphMenuId() {
+        return this.graphMenuId;
+    }
+    getTranscriptMenuId() {
+        return this.transcriptMenuId;
+    }
+    closeMenus() {
+        this.graphMenuId = null;
+        this.transcriptMenuId = null;
+    }
+    closeAllMenus() {
+        if (this.graphMenuId === null && this.transcriptMenuId === null) {
+            return;
+        }
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    blessKnot(id) {
+        this.pushUndoSnapshot();
+        this.tree = this.tree.blessKnot(id);
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    blessChanges(id) {
+        this.pushUndoSnapshot();
+        this.tree = this.tree.blessTranscript(id);
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    toggleLock(id) {
+        if (id === 0) {
+            throw new Error('The root knot cannot be locked');
+        }
+        const knot = this.tree.getKnot(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        this.pushUndoSnapshot();
+        this.tree = this.tree.setLockStatus(id, !knot.locked);
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    setLabel(id, label) {
+        if (id === 0) {
+            throw new Error('The root knot\'s label cannot be changed');
+        }
+        const updated = this.tree.setLabel(id, label);
+        this.pushUndoSnapshot();
+        this.tree = updated;
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    setMarker(id, marker) {
+        if (!this.tree.getKnot(id)) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        this.pushUndoSnapshot();
+        this.tree = this.tree.setMarker(id, marker);
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    async setCommand(id, command) {
+        if (id === 0) {
+            throw new Error('The root knot\'s command cannot be changed');
+        }
+        if (!this.isRunning) {
+            throw new Error('Session not running');
+        }
+        const normalized = normalizeCommand(command);
+        if (normalized === '') {
+            throw new Error('Command cannot be blank');
+        }
+        const knot = this.tree.getKnot(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        if (normalized === knot.command) {
+            return;
+        }
+        const renamed = this.tree.renameCommand(id, normalized);
+        this.pushUndoSnapshot();
+        this.tree = renamed;
+        await this.replayProcessTo(id);
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    async insertParent(id, command) {
+        if (!this.isRunning) {
+            throw new Error('Session not running');
+        }
+        const knot = this.tree.getKnot(id);
+        if (!knot || knot.parentId === null) {
+            throw new Error(`Knot ${id} not found, or is the root (which has no parent to insert above)`);
+        }
+        const normalized = normalizeCommand(command);
+        if (normalized === '') {
+            throw new Error('Command cannot be blank');
+        }
+        if (this.tree.promptTypeAt(knot.parentId) === 'key') {
+            throw new Error('Cannot insert a parent here: reached via a keystroke prompt.');
+        }
+        const newId = this.tree.nextId();
+        this.pushUndoSnapshot();
+        this.tree = this.tree.insertParent(id, normalized, { text: '', inputType: 'line' });
+        await this.replayProcessTo(id);
+        this.tree = this.tree.selectKnot(newId);
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    deleteKnot(id) {
+        if (id === 0) {
+            throw new Error('The root knot cannot be deleted');
+        }
+        const knot = this.tree.getKnot(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        let updated = this.tree;
+        if (this.isKnotOrDescendantActive(id)) {
+            updated = updated.setActiveKnotId(knot.parentId);
+        }
+        updated = updated.deleteKnot(id);
+        this.pushUndoSnapshot();
+        this.tree = updated;
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    spliceKnot(id) {
+        if (id === 0) {
+            throw new Error('The root knot cannot be spliced out');
+        }
+        const knot = this.tree.getKnot(id);
+        if (!knot) {
+            throw new Error(`Knot ${id} not found`);
+        }
+        this.pushUndoSnapshot();
+        if (this.tree.getActiveKnotId() === id) {
+            this.tree = this.tree.setActiveKnotId(knot.parentId);
+        }
+        this.tree = this.tree.spliceKnot(id);
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    pushUndoSnapshot() {
+        this.undoStack.push(this.tree);
+        this.redoStack = [];
+    }
+    undo() {
+        if (this.undoStack.length === 0) {
+            return;
+        }
+        const previous = this.undoStack.pop();
+        this.redoStack.push(this.tree);
+        this.tree = previous;
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    redo() {
+        if (this.redoStack.length === 0) {
+            return;
+        }
+        const next = this.redoStack.pop();
+        this.undoStack.push(this.tree);
+        this.tree = next;
+        this.closeMenus();
+        this.changeEmitter.emit('change');
+    }
+    isKnotOrDescendantActive(id) {
+        let currentId = this.tree.getActiveKnotId();
+        while (currentId !== null) {
+            if (currentId === id) {
+                return true;
+            }
+            currentId = this.tree.getKnot(currentId)?.parentId ?? null;
+        }
+        return false;
+    }
+    onChange(listener) {
+        this.changeEmitter.on('change', listener);
+    }
+    offChange(listener) {
+        this.changeEmitter.off('change', listener);
+    }
+    toggleShowDynamicState() {
+        this.showDynamicState = !this.showDynamicState;
+        this.changeEmitter.emit('change');
+    }
+    getShowDynamicState() {
+        return this.showDynamicState;
+    }
+    setMarkerFilter(marker) {
+        this.markerFilter = this.markerFilter === marker ? null : marker;
+        this.changeEmitter.emit('change');
+    }
+    getMarkerFilter() {
+        return this.markerFilter;
+    }
+    getState() {
+        return {
+            id: this.id,
+            config: this.config,
+            tree: this.tree,
+            process: this.process,
+            isRunning: this.isRunning
+        };
+    }
+    async stop() {
+        if (this.isRunning && this.process) {
+            await this.process.terminate();
+            this.isRunning = false;
+            console.log(`Session ${this.id} stopped`);
+        }
+    }
+    getTree() {
+        return this.tree;
+    }
+    getProcessPositionId() {
+        return this.processPositionId;
+    }
+    getId() {
+        return this.id;
+    }
+    isRunningSession() {
+        return this.isRunning;
+    }
+}
+exports.SkeinSession = SkeinSession;
+//# sourceMappingURL=session.js.map