@nogataka/smart-edit 0.0.14

package/dist/serena/constants.d.ts

@@ -0,0 +1,18 @@
+export declare const SERENA_MANAGED_DIR_NAME = ".smart-edit";
+export declare const SERENA_MANAGED_DIR_IN_HOME: string;
+export declare const REPO_ROOT: string;
+export declare const PROMPT_TEMPLATES_DIR_INTERNAL: string;
+export declare const PROMPT_TEMPLATES_DIR_IN_USER_HOME: string;
+export declare const SERENAS_OWN_CONTEXT_YAMLS_DIR: string;
+export declare const USER_CONTEXT_YAMLS_DIR: string;
+export declare const SERENAS_OWN_MODE_YAMLS_DIR: string;
+export declare const USER_MODE_YAMLS_DIR: string;
+export declare const INTERNAL_MODE_YAMLS_DIR: string;
+export declare const SERENA_DASHBOARD_DIR: string;
+export declare const SERENA_ICON_DIR: string;
+export declare const DEFAULT_ENCODING = "utf-8";
+export declare const DEFAULT_CONTEXT = "desktop-app";
+export declare const DEFAULT_MODES: readonly ["interactive", "editing"];
+export declare const PROJECT_TEMPLATE_FILE: string;
+export declare const SERENA_CONFIG_TEMPLATE_FILE: string;
+export declare const SERENA_LOG_FORMAT = "%(levelname)-5s %(asctime)-15s [%(threadName)s] %(name)s:%(funcName)s:%(lineno)d - %(message)s";

package/dist/serena/constants.js

@@ -0,0 +1,27 @@
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, '..', '..');
+const serenaPackageRoot = path.resolve(__dirname);
+const serenaManagedDirName = '.smart-edit';
+const serenaManagedDirInHome = path.join(os.homedir(), serenaManagedDirName);
+export const SERENA_MANAGED_DIR_NAME = serenaManagedDirName;
+export const SERENA_MANAGED_DIR_IN_HOME = serenaManagedDirInHome;
+export const REPO_ROOT = repoRoot;
+export const PROMPT_TEMPLATES_DIR_INTERNAL = path.join(serenaPackageRoot, 'resources', 'config', 'prompt_templates');
+export const PROMPT_TEMPLATES_DIR_IN_USER_HOME = path.join(serenaManagedDirInHome, 'prompt_templates');
+export const SERENAS_OWN_CONTEXT_YAMLS_DIR = path.join(serenaPackageRoot, 'resources', 'config', 'contexts');
+export const USER_CONTEXT_YAMLS_DIR = path.join(serenaManagedDirInHome, 'contexts');
+export const SERENAS_OWN_MODE_YAMLS_DIR = path.join(serenaPackageRoot, 'resources', 'config', 'modes');
+export const USER_MODE_YAMLS_DIR = path.join(serenaManagedDirInHome, 'modes');
+export const INTERNAL_MODE_YAMLS_DIR = path.join(serenaPackageRoot, 'resources', 'config', 'internal_modes');
+export const SERENA_DASHBOARD_DIR = path.join(serenaPackageRoot, 'resources', 'dashboard');
+export const SERENA_ICON_DIR = path.join(serenaPackageRoot, 'resources', 'icons');
+export const DEFAULT_ENCODING = 'utf-8';
+export const DEFAULT_CONTEXT = 'desktop-app';
+export const DEFAULT_MODES = ['interactive', 'editing'];
+export const PROJECT_TEMPLATE_FILE = path.join(serenaPackageRoot, 'resources', 'project.template.yml');
+export const SERENA_CONFIG_TEMPLATE_FILE = path.join(serenaPackageRoot, 'resources', 'serena_config.template.yml');
+export const SERENA_LOG_FORMAT = '%(levelname)-5s %(asctime)-15s [%(threadName)s] %(name)s:%(funcName)s:%(lineno)d - %(message)s';

package/dist/serena/dashboard.d.ts

@@ -0,0 +1,55 @@
+import type { MemoryLogHandler } from './util/logging.js';
+import type { ToolUsageStats } from './analytics.js';
+interface DashboardAgentLike {
+    getActiveProject(): {
+        projectName?: string | null;
+    } | null;
+}
+export interface DashboardThread {
+    stop(): void;
+}
+export interface SerenaDashboardApiOptions {
+    shutdownCallback?: () => void;
+    toolUsageStats?: ToolUsageStats | null;
+}
+export declare class SerenaDashboardAPI {
+    private readonly memoryLogHandler;
+    private toolNames;
+    private readonly agent;
+    private readonly shutdownCallback?;
+    private readonly toolUsageStats?;
+    private server;
+    private listeningPort;
+    private readonly sseClients;
+    private logSequence;
+    private logListener?;
+    private heartbeatTimer;
+    private streamingAttached;
+    constructor(memoryLogHandler: MemoryLogHandler, toolNames: string[], agent: DashboardAgentLike, options?: SerenaDashboardApiOptions);
+    runInThread(): Promise<[DashboardThread, number]>;
+    getToolNames(): string[];
+    setToolNames(toolNames: string[]): void;
+    private broadcastToolNames;
+    clearToolStats(): void;
+    shutdown(): void;
+    private startServer;
+    private listenOnPort;
+    private ensureLogStreamingAttached;
+    private detachLogStreaming;
+    private onLogMessage;
+    private broadcastSseEvent;
+    private sendHeartbeat;
+    private removeSseClient;
+    private formatSseEvent;
+    private handleLogStream;
+    private handleRequest;
+    private serveDashboardAsset;
+    private handleGetLogMessages;
+    private getToolStats;
+    private getNumberFromRecord;
+    private parseRequestBody;
+    private respondNotFound;
+    private respondMethodNotAllowed;
+    private sendJson;
+}
+export {};

package/dist/serena/dashboard.js

@@ -0,0 +1,472 @@
+import { Buffer } from 'node:buffer';
+import { clearInterval, setInterval } from 'node:timers';
+import { createServer } from 'node:http';
+import { parse as parseUrl } from 'node:url';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { createSerenaLogger } from './util/logging.js';
+import { SERENA_DASHBOARD_DIR } from './constants.js';
+const { logger } = createSerenaLogger({ name: 'serena.dashboard', emitToConsole: false, level: 'info' });
+const DEFAULT_DASHBOARD_PORT = 0x5eda;
+const DASHBOARD_HOST = '127.0.0.1';
+const SSE_HEARTBEAT_INTERVAL_MS = 15_000;
+const CONTENT_TYPE_BY_EXTENSION = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'application/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.png': 'image/png',
+    '.json': 'application/json; charset=utf-8',
+    '.ico': 'image/x-icon'
+};
+class DashboardHttpThread {
+    server;
+    onStop;
+    stopped = false;
+    constructor(server, onStop) {
+        this.server = server;
+        this.onStop = onStop;
+    }
+    stop() {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        this.server.close((error) => {
+            if (error) {
+                logger.warn('Failed to stop Serena dashboard server cleanly.', error);
+            }
+            this.onStop?.();
+        });
+    }
+}
+const SSE_HEADERS = {
+    'Content-Type': 'text/event-stream; charset=utf-8',
+    'Cache-Control': 'no-cache',
+    Connection: 'keep-alive'
+};
+export class SerenaDashboardAPI {
+    memoryLogHandler;
+    toolNames;
+    agent;
+    shutdownCallback;
+    toolUsageStats;
+    server = null;
+    listeningPort = null;
+    sseClients = new Set();
+    logSequence = 0;
+    logListener;
+    heartbeatTimer = null;
+    streamingAttached = false;
+    constructor(memoryLogHandler, toolNames, agent, options = {}) {
+        this.memoryLogHandler = memoryLogHandler;
+        this.toolNames = [...toolNames];
+        this.agent = agent;
+        this.shutdownCallback = options.shutdownCallback;
+        this.toolUsageStats = options.toolUsageStats;
+        this.logSequence = this.memoryLogHandler.getLogMessages().length;
+    }
+    async runInThread() {
+        if (this.server && this.listeningPort !== null) {
+            this.ensureLogStreamingAttached();
+            return [new DashboardHttpThread(this.server), this.listeningPort];
+        }
+        const { server, port } = await this.startServer();
+        this.server = server;
+        this.listeningPort = port;
+        this.ensureLogStreamingAttached();
+        const thread = new DashboardHttpThread(server, () => {
+            this.server = null;
+            this.listeningPort = null;
+            this.detachLogStreaming();
+        });
+        logger.info(`Serena dashboard listening on http://${DASHBOARD_HOST}:${port}/dashboard/index.html`);
+        return [thread, port];
+    }
+    getToolNames() {
+        return [...this.toolNames];
+    }
+    setToolNames(toolNames) {
+        this.toolNames = [...toolNames];
+        this.broadcastToolNames();
+    }
+    broadcastToolNames() {
+        this.broadcastSseEvent('toolNames', { toolNames: this.getToolNames() });
+    }
+    clearToolStats() {
+        this.toolUsageStats?.clear();
+    }
+    shutdown() {
+        logger.info('Dashboard shutdown triggered.');
+        this.detachLogStreaming();
+        if (this.shutdownCallback) {
+            this.shutdownCallback();
+            return;
+        }
+        process.exit(0);
+    }
+    async startServer() {
+        let candidatePort = DEFAULT_DASHBOARD_PORT;
+        let lastError = null;
+        while (candidatePort <= 65535) {
+            const server = createServer((req, res) => {
+                void this.handleRequest(req, res);
+            });
+            try {
+                const port = await this.listenOnPort(server, candidatePort);
+                server.on('close', () => {
+                    this.server = null;
+                    this.listeningPort = null;
+                    this.detachLogStreaming();
+                });
+                return { server, port };
+            }
+            catch (error) {
+                lastError = error;
+                try {
+                    server.close();
+                }
+                catch {
+                    // ignore close errors
+                }
+                if (lastError && (lastError.code === 'EADDRINUSE' || lastError.code === 'EACCES')) {
+                    candidatePort += 1;
+                    continue;
+                }
+                logger.error('Failed to start Serena dashboard server.', lastError ?? undefined);
+                break;
+            }
+        }
+        throw new Error(lastError?.message ?? 'Unable to start Serena dashboard server; no available ports in the configured range.');
+    }
+    listenOnPort(server, port) {
+        return new Promise((resolve, reject) => {
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const onListening = () => {
+                const address = server.address();
+                cleanup();
+                if (address && typeof address === 'object') {
+                    resolve(address.port);
+                }
+                else {
+                    resolve(port);
+                }
+            };
+            const cleanup = () => {
+                server.off('error', onError);
+                server.off('listening', onListening);
+            };
+            server.once('error', onError);
+            server.once('listening', onListening);
+            server.listen({ port, host: DASHBOARD_HOST, exclusive: true });
+        });
+    }
+    ensureLogStreamingAttached() {
+        if (this.streamingAttached) {
+            return;
+        }
+        this.streamingAttached = true;
+        this.logSequence = this.memoryLogHandler.getLogMessages().length;
+        this.logListener = (message) => {
+            this.onLogMessage(message);
+        };
+        this.memoryLogHandler.addEmitCallback(this.logListener);
+        const timer = setInterval(() => {
+            this.sendHeartbeat();
+        }, SSE_HEARTBEAT_INTERVAL_MS);
+        if (typeof timer.unref === 'function') {
+            timer.unref();
+        }
+        this.heartbeatTimer = timer;
+    }
+    detachLogStreaming() {
+        if (!this.streamingAttached) {
+            return;
+        }
+        this.streamingAttached = false;
+        if (this.logListener) {
+            this.memoryLogHandler.removeEmitCallback(this.logListener);
+            this.logListener = undefined;
+        }
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.sseClients.size > 0) {
+            const shutdownFrame = this.formatSseEvent('shutdown', { reason: 'server_stop' });
+            for (const client of this.sseClients) {
+                try {
+                    client.write(shutdownFrame);
+                    if (!client.writableEnded) {
+                        client.end();
+                    }
+                }
+                catch {
+                    // ignore errors when closing clients
+                }
+            }
+            this.sseClients.clear();
+        }
+    }
+    onLogMessage(message) {
+        const payload = {
+            message,
+            idx: this.logSequence,
+            activeProject: this.agent.getActiveProject()?.projectName ?? null
+        };
+        this.logSequence += 1;
+        this.broadcastSseEvent('log', payload);
+    }
+    broadcastSseEvent(event, payload) {
+        if (this.sseClients.size === 0) {
+            return;
+        }
+        const frame = this.formatSseEvent(event, payload);
+        for (const client of [...this.sseClients]) {
+            try {
+                client.write(frame);
+            }
+            catch {
+                this.removeSseClient(client);
+            }
+        }
+    }
+    sendHeartbeat() {
+        if (this.sseClients.size === 0) {
+            return;
+        }
+        const heartbeat = `: heartbeat ${Date.now()}\n\n`;
+        for (const client of [...this.sseClients]) {
+            try {
+                client.write(heartbeat);
+            }
+            catch {
+                this.removeSseClient(client);
+            }
+        }
+    }
+    removeSseClient(res) {
+        if (!this.sseClients.has(res)) {
+            return;
+        }
+        this.sseClients.delete(res);
+        try {
+            if (!res.writableEnded) {
+                res.end();
+            }
+        }
+        catch {
+            // ignore errors during cleanup
+        }
+    }
+    formatSseEvent(event, payload) {
+        return `event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`;
+    }
+    handleLogStream(req, res) {
+        this.ensureLogStreamingAttached();
+        this.sseClients.add(res);
+        const teardown = () => {
+            this.removeSseClient(res);
+        };
+        res.on('close', teardown);
+        res.on('error', teardown);
+        req.on('close', teardown);
+        req.on('error', teardown);
+        res.writeHead(200, SSE_HEADERS);
+        res.write(': connected\n\n');
+        // Send current tool names and log history so the client can hydrate immediately.
+        const toolNamesPayload = { toolNames: this.getToolNames() };
+        res.write(this.formatSseEvent('toolNames', toolNamesPayload));
+        const logMessages = this.memoryLogHandler.getLogMessages();
+        const historyPayload = {
+            messages: logMessages,
+            maxIdx: logMessages.length > 0 ? logMessages.length - 1 : -1,
+            activeProject: this.agent.getActiveProject()?.projectName ?? null
+        };
+        res.write(this.formatSseEvent('history', historyPayload));
+    }
+    async handleRequest(req, res) {
+        const method = req.method?.toUpperCase() ?? 'GET';
+        const url = parseUrl(req.url ?? '/', true);
+        const pathname = url.pathname ?? '/';
+        try {
+            if (pathname.startsWith('/dashboard')) {
+                if (method !== 'GET') {
+                    this.respondMethodNotAllowed(res);
+                    return;
+                }
+                await this.serveDashboardAsset(pathname, res);
+                return;
+            }
+            if (pathname === '/log_stream') {
+                if (method !== 'GET') {
+                    this.respondMethodNotAllowed(res);
+                    return;
+                }
+                this.handleLogStream(req, res);
+                return;
+            }
+            switch (pathname) {
+                case '/get_log_messages':
+                    if (method !== 'POST') {
+                        this.respondMethodNotAllowed(res);
+                        return;
+                    }
+                    await this.handleGetLogMessages(req, res);
+                    return;
+                case '/get_tool_names':
+                    if (method !== 'GET') {
+                        this.respondMethodNotAllowed(res);
+                        return;
+                    }
+                    this.sendJson(res, 200, { tool_names: this.getToolNames() });
+                    return;
+                case '/get_tool_stats':
+                    if (method !== 'GET') {
+                        this.respondMethodNotAllowed(res);
+                        return;
+                    }
+                    this.sendJson(res, 200, { stats: this.getToolStats() });
+                    return;
+                case '/clear_tool_stats':
+                    if (method !== 'POST') {
+                        this.respondMethodNotAllowed(res);
+                        return;
+                    }
+                    this.clearToolStats();
+                    this.sendJson(res, 200, { status: 'cleared' });
+                    return;
+                case '/get_token_count_estimator_name':
+                    if (method !== 'GET') {
+                        this.respondMethodNotAllowed(res);
+                        return;
+                    }
+                    this.sendJson(res, 200, {
+                        token_count_estimator_name: this.toolUsageStats?.tokenEstimatorName ?? 'unknown'
+                    });
+                    return;
+                case '/shutdown':
+                    if (method !== 'PUT') {
+                        this.respondMethodNotAllowed(res);
+                        return;
+                    }
+                    this.shutdown();
+                    this.sendJson(res, 200, { status: 'shutting down' });
+                    return;
+                default:
+                    this.respondNotFound(res);
+            }
+        }
+        catch (error) {
+            logger.error('Dashboard request failed.', error instanceof Error ? error : undefined);
+            this.sendJson(res, 500, { error: 'Internal server error' });
+        }
+    }
+    async serveDashboardAsset(pathname, res) {
+        const relativePath = pathname.replace(/^\/dashboard\/?/, '');
+        const safeRelativePath = relativePath.length === 0 ? 'index.html' : relativePath;
+        const resolvedPath = path.resolve(SERENA_DASHBOARD_DIR, decodeURIComponent(safeRelativePath));
+        if (!resolvedPath.startsWith(path.resolve(SERENA_DASHBOARD_DIR))) {
+            this.respondNotFound(res);
+            return;
+        }
+        try {
+            const file = await fs.readFile(resolvedPath);
+            const ext = path.extname(resolvedPath).toLowerCase();
+            const contentType = CONTENT_TYPE_BY_EXTENSION[ext] ?? 'application/octet-stream';
+            res.statusCode = 200;
+            res.setHeader('Content-Type', contentType);
+            res.setHeader('Content-Length', file.length);
+            res.end(file);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                this.respondNotFound(res);
+                return;
+            }
+            throw error;
+        }
+    }
+    async handleGetLogMessages(req, res) {
+        const requestBody = await this.parseRequestBody(req);
+        const startIdxCandidate = requestBody ? this.getNumberFromRecord(requestBody, 'start_idx') : undefined;
+        const startIdxRaw = startIdxCandidate ?? 0;
+        const startIdx = Number.isFinite(startIdxRaw) && startIdxRaw >= 0 ? Math.floor(startIdxRaw) : 0;
+        const logMessages = this.memoryLogHandler.getLogMessages();
+        const messages = startIdx <= logMessages.length ? logMessages.slice(startIdx) : [];
+        const maxIdx = logMessages.length > 0 ? logMessages.length - 1 : -1;
+        const activeProject = this.agent.getActiveProject()?.projectName ?? null;
+        const response = {
+            messages,
+            maxIdx,
+            activeProject
+        };
+        this.sendJson(res, 200, {
+            messages: response.messages,
+            max_idx: response.maxIdx,
+            active_project: response.activeProject
+        });
+    }
+    getToolStats() {
+        if (!this.toolUsageStats) {
+            return {};
+        }
+        const stats = this.toolUsageStats.getToolStatsDict();
+        const result = {};
+        for (const [toolName, entry] of Object.entries(stats)) {
+            const numTimesCalled = typeof entry.numTimesCalled === 'number' ? entry.numTimesCalled : 0;
+            const inputTokens = typeof entry.inputTokens === 'number' ? entry.inputTokens : 0;
+            const outputTokens = typeof entry.outputTokens === 'number' ? entry.outputTokens : 0;
+            result[toolName] = {
+                num_times_called: numTimesCalled,
+                input_tokens: inputTokens,
+                output_tokens: outputTokens
+            };
+        }
+        return result;
+    }
+    getNumberFromRecord(record, key) {
+        const value = record[key];
+        return typeof value === 'number' ? value : undefined;
+    }
+    async parseRequestBody(req) {
+        req.setEncoding('utf8');
+        let raw = '';
+        for await (const chunk of req) {
+            raw += chunk;
+        }
+        const trimmed = raw.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return parsed;
+            }
+            return null;
+        }
+        catch (error) {
+            logger.warn('Failed to parse dashboard request payload as JSON.', error instanceof Error ? error : undefined);
+            return null;
+        }
+    }
+    respondNotFound(res) {
+        res.statusCode = 404;
+        res.end('Not found');
+    }
+    respondMethodNotAllowed(res) {
+        res.statusCode = 405;
+        res.end('Method not allowed');
+    }
+    sendJson(res, statusCode, payload) {
+        const body = JSON.stringify(payload);
+        res.statusCode = statusCode;
+        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+        res.setHeader('Content-Length', Buffer.byteLength(body, 'utf-8'));
+        res.end(body);
+    }
+}

package/dist/serena/generated/generated_prompt_factory.d.ts

@@ -0,0 +1,27 @@
+import { PromptFactoryBase, type PromptFactoryBaseOptions } from '../../interprompt/prompt_factory.js';
+export interface CreateOnboardingPromptParams {
+    system: string;
+}
+export interface CreateSystemPromptParams {
+    availableMarkers: Iterable<string>;
+    availableTools: Iterable<string>;
+    contextSystemPrompt: string;
+    modeSystemPrompts: Iterable<string>;
+}
+export declare class PromptFactory extends PromptFactoryBase {
+    create_onboarding_prompt: (params: CreateOnboardingPromptParams) => string;
+    create_prepare_for_new_conversation: () => string;
+    create_summarize_changes: () => string;
+    create_system_prompt: (params: CreateSystemPromptParams) => string;
+    create_think_about_collected_information: () => string;
+    create_think_about_task_adherence: () => string;
+    create_think_about_whether_you_are_done: () => string;
+    constructor(options: PromptFactoryBaseOptions);
+    createOnboardingPrompt(params: CreateOnboardingPromptParams): string;
+    createPrepareForNewConversation(): string;
+    createSummarizeChanges(): string;
+    createSystemPrompt(params: CreateSystemPromptParams): string;
+    createThinkAboutCollectedInformation(): string;
+    createThinkAboutTaskAdherence(): string;
+    createThinkAboutWhetherYouAreDone(): string;
+}

package/dist/serena/generated/generated_prompt_factory.js

@@ -0,0 +1,42 @@
+// NOTE: This module is auto-generated via interprompt.autogeneratePromptFactoryModule. Do not edit manually.
+import { PromptFactoryBase, } from '../../interprompt/prompt_factory.js';
+export class PromptFactory extends PromptFactoryBase {
+    constructor(options) {
+        super(options);
+        this.create_onboarding_prompt = (params) => this.createOnboardingPrompt(params);
+        this.create_prepare_for_new_conversation = () => this.createPrepareForNewConversation();
+        this.create_summarize_changes = () => this.createSummarizeChanges();
+        this.create_system_prompt = (params) => this.createSystemPrompt(params);
+        this.create_think_about_collected_information = () => this.createThinkAboutCollectedInformation();
+        this.create_think_about_task_adherence = () => this.createThinkAboutTaskAdherence();
+        this.create_think_about_whether_you_are_done = () => this.createThinkAboutWhetherYouAreDone();
+    }
+    createOnboardingPrompt(params) {
+        return this.renderPromptTemplate('onboarding_prompt', {
+            system: params.system
+        });
+    }
+    createPrepareForNewConversation() {
+        return this.renderPromptTemplate('prepare_for_new_conversation', {});
+    }
+    createSummarizeChanges() {
+        return this.renderPromptTemplate('summarize_changes', {});
+    }
+    createSystemPrompt(params) {
+        return this.renderPromptTemplate('system_prompt', {
+            available_markers: Array.from(params.availableMarkers ?? []),
+            available_tools: Array.from(params.availableTools ?? []),
+            context_system_prompt: params.contextSystemPrompt,
+            mode_system_prompts: Array.from(params.modeSystemPrompts ?? [])
+        });
+    }
+    createThinkAboutCollectedInformation() {
+        return this.renderPromptTemplate('think_about_collected_information', {});
+    }
+    createThinkAboutTaskAdherence() {
+        return this.renderPromptTemplate('think_about_task_adherence', {});
+    }
+    createThinkAboutWhetherYouAreDone() {
+        return this.renderPromptTemplate('think_about_whether_you_are_done', {});
+    }
+}

package/dist/serena/gui_log_viewer.d.ts

@@ -0,0 +1,41 @@
+import { MemoryLogHandler } from './util/logging.js';
+export interface GuiLogViewerOptions {
+    title?: string;
+    memoryLogHandler?: MemoryLogHandler;
+    host?: string;
+    port?: number;
+    autoOpen?: boolean;
+    historyLimit?: number;
+}
+export declare class GuiLogViewer {
+    private readonly channel;
+    private readonly title;
+    private readonly memoryLogHandler?;
+    private readonly host;
+    private readonly requestedPort;
+    private readonly autoOpen;
+    private readonly historyLimit;
+    private toolNames;
+    private started;
+    private server;
+    private readonly sseClients;
+    private readonly history;
+    private memoryCallback?;
+    private readyPromise;
+    private port;
+    private logSequence;
+    constructor(channel: string, options?: GuiLogViewerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    setToolNames(toolNames: string[]): void;
+    addLog(message: string): void;
+    getBaseUrl(): string | null;
+    private recordLogMessage;
+    private broadcastLog;
+    private handleRequest;
+    private handleIndexRequest;
+    private handleEventStream;
+    private broadcast;
+    private renderHtmlPage;
+}
+export declare function showFatalException(error: unknown): Promise<void>;