pikiloop 0.4.0

package/dist/channels/telegram/directory.js

@@ -0,0 +1,111 @@
+/**
+ * Telegram workdir browser for interactive directory navigation.
+ */
+import path from 'node:path';
+import { listSubdirs } from '../../bot/bot.js';
+import { buildCompactSelectionTitle, compactCode, truncateMiddle } from './render.js';
+class PathRegistry {
+    pathToId = new Map();
+    idToPath = new Map();
+    nextId = 1;
+    register(dirPath) {
+        let id = this.pathToId.get(dirPath);
+        if (id != null)
+            return id;
+        id = this.nextId++;
+        this.pathToId.set(dirPath, id);
+        this.idToPath.set(id, dirPath);
+        if (this.pathToId.size > 500) {
+            const oldest = [...this.pathToId.entries()].slice(0, 200);
+            for (const [oldPath, oldId] of oldest) {
+                this.pathToId.delete(oldPath);
+                this.idToPath.delete(oldId);
+            }
+        }
+        return id;
+    }
+    resolve(id) {
+        return this.idToPath.get(id);
+    }
+}
+const pathRegistry = new PathRegistry();
+const DIR_PAGE_SIZE = 8;
+function buildDirKeyboard(browsePath, page) {
+    const dirs = listSubdirs(browsePath);
+    const totalPages = Math.max(1, Math.ceil(dirs.length / DIR_PAGE_SIZE));
+    const currentPage = Math.min(Math.max(0, page), totalPages - 1);
+    const slice = dirs.slice(currentPage * DIR_PAGE_SIZE, (currentPage + 1) * DIR_PAGE_SIZE);
+    const rows = [];
+    for (let i = 0; i < slice.length; i += 2) {
+        const row = [];
+        for (let j = i; j < Math.min(i + 2, slice.length); j++) {
+            const fullPath = path.join(browsePath, slice[j]);
+            const id = pathRegistry.register(fullPath);
+            row.push({ text: slice[j], callback_data: `sw:n:${id}:0` });
+        }
+        rows.push(row);
+    }
+    const navRow = [];
+    const parent = path.dirname(browsePath);
+    if (parent !== browsePath) {
+        navRow.push({ text: '⬆ ..', callback_data: `sw:n:${pathRegistry.register(parent)}:0` });
+    }
+    if (totalPages > 1) {
+        const browseId = pathRegistry.register(browsePath);
+        if (currentPage > 0)
+            navRow.push({ text: `◀ ${currentPage}/${totalPages}`, callback_data: `sw:n:${browseId}:${currentPage - 1}` });
+        if (currentPage < totalPages - 1)
+            navRow.push({ text: `${currentPage + 2}/${totalPages} ▶`, callback_data: `sw:n:${browseId}:${currentPage + 1}` });
+    }
+    if (navRow.length)
+        rows.push(navRow);
+    rows.push([{ text: 'Use This', callback_data: `sw:s:${pathRegistry.register(browsePath)}` }]);
+    return { inline_keyboard: rows };
+}
+export function buildSwitchWorkdirView(currentWorkdir, browsePath, page = 0, opts = {}) {
+    const lines = [buildCompactSelectionTitle('Workdir')];
+    lines.push(`● ${compactCode(currentWorkdir, 42)}`);
+    if (browsePath !== currentWorkdir)
+        lines.push(`○ ${compactCode(browsePath, 42)}`);
+    if (opts.savedWorkspaceCount && opts.savedWorkspaceCount > 0) {
+        lines.push('', `<i>Tip: ${opts.savedWorkspaceCount} saved workspace${opts.savedWorkspaceCount === 1 ? '' : 's'} — use /workspaces for one-tap switching.</i>`);
+    }
+    return {
+        text: lines.join('\n'),
+        keyboard: buildDirKeyboard(browsePath, page),
+    };
+}
+export function resolveRegisteredPath(id) {
+    return pathRegistry.resolve(id);
+}
+const WORKSPACES_PAGE_SIZE = 10;
+export function buildWorkspacesView(data, page = 0) {
+    const { workspaces, currentWorkdir } = data;
+    const lines = [buildCompactSelectionTitle('Workspaces')];
+    if (workspaces.length === 0) {
+        lines.push('No saved workspaces yet.', '', 'Add workspaces from the Dashboard (Sessions → Add Workspace), then come back to switch with one tap.', '', 'You can still browse the file system with /switch.');
+        return { text: lines.join('\n'), keyboard: { inline_keyboard: [] } };
+    }
+    lines.push(`● ${compactCode(currentWorkdir, 42)}`);
+    const totalPages = Math.max(1, Math.ceil(workspaces.length / WORKSPACES_PAGE_SIZE));
+    const currentPage = Math.min(Math.max(0, page), totalPages - 1);
+    const slice = workspaces.slice(currentPage * WORKSPACES_PAGE_SIZE, (currentPage + 1) * WORKSPACES_PAGE_SIZE);
+    const rows = [];
+    for (const ws of slice) {
+        const marker = ws.isCurrent ? '✓ ' : ws.exists ? '' : '⚠ ';
+        const id = pathRegistry.register(ws.path);
+        const label = `${marker}${truncateMiddle(ws.name, 40)}`;
+        rows.push([{ text: label, callback_data: `wsp:s:${id}` }]);
+    }
+    if (totalPages > 1) {
+        const navRow = [];
+        if (currentPage > 0)
+            navRow.push({ text: `◀ ${currentPage}/${totalPages}`, callback_data: `wsp:p:${currentPage - 1}` });
+        if (currentPage < totalPages - 1)
+            navRow.push({ text: `${currentPage + 2}/${totalPages} ▶`, callback_data: `wsp:p:${currentPage + 1}` });
+        if (navRow.length)
+            rows.push(navRow);
+    }
+    lines.push('', `Tap a workspace to switch. ${workspaces.length} saved.`);
+    return { text: lines.join('\n'), keyboard: { inline_keyboard: rows } };
+}

package/dist/channels/telegram/live-preview.js

@@ -0,0 +1,220 @@
+/**
+ * Channel-agnostic live preview controller for streaming updates.
+ */
+import { hasPreviewMeta, samePreviewMeta, samePreviewPlan } from '../../bot/streaming.js';
+import { STREAM_PREVIEW_TIMEOUTS } from '../../core/constants.js';
+const STREAM_PREVIEW_HEARTBEAT_MS = STREAM_PREVIEW_TIMEOUTS.heartbeat;
+const STREAM_TYPING_HEARTBEAT_MS = STREAM_PREVIEW_TIMEOUTS.typing;
+const STREAM_STALLED_NOTICE_MS = STREAM_PREVIEW_TIMEOUTS.stalledNotice;
+// ---------------------------------------------------------------------------
+// LivePreview — generic streaming preview controller
+// ---------------------------------------------------------------------------
+export class LivePreview {
+    initialText;
+    agent;
+    chatId;
+    placeholderMessageId;
+    channel;
+    renderer;
+    streamEditIntervalMs;
+    startTimeMs;
+    canEditMessages;
+    canSendTyping;
+    messageThreadId;
+    parseMode;
+    keyboard;
+    model;
+    effort;
+    log;
+    heartbeatTimer = null;
+    typingTimer = null;
+    flushTimer = null;
+    editChain = Promise.resolve();
+    previewVersion = 0;
+    editCount = 0;
+    lastEditAt = 0;
+    lastProgressAt;
+    lastPreview;
+    latestText = '';
+    latestThinking = '';
+    latestActivity = '';
+    latestMeta = null;
+    latestPlan = null;
+    consecutiveEditFailures = 0;
+    placeholderAbandoned = false;
+    static MAX_CONSECUTIVE_EDIT_FAILURES = 3;
+    constructor(options) {
+        this.agent = options.agent;
+        this.chatId = options.chatId;
+        this.placeholderMessageId = options.placeholderMessageId;
+        this.channel = options.channel;
+        this.renderer = options.renderer;
+        this.streamEditIntervalMs = options.streamEditIntervalMs;
+        this.startTimeMs = options.startTimeMs;
+        this.canEditMessages = options.canEditMessages;
+        this.canSendTyping = options.canSendTyping;
+        this.messageThreadId = options.messageThreadId;
+        this.parseMode = options.parseMode ?? 'HTML';
+        this.keyboard = options.keyboard;
+        this.model = options.model ?? null;
+        this.effort = options.effort ?? null;
+        this.log = options.log ?? (() => { });
+        this.initialText = this.renderer.renderInitial(this.agent, this.model, this.effort);
+        this.lastPreview = this.initialText;
+        this.lastProgressAt = this.startTimeMs;
+    }
+    start() {
+        this.sendTypingPulse();
+        if (this.canEditMessages) {
+            this.heartbeatTimer = setInterval(() => {
+                const idleMs = Date.now() - this.lastProgressAt;
+                const recentlyEdited = Date.now() - this.lastEditAt < STREAM_PREVIEW_HEARTBEAT_MS - 250;
+                if (recentlyEdited && idleMs < STREAM_STALLED_NOTICE_MS)
+                    return;
+                this.queuePreviewEdit(true);
+            }, STREAM_PREVIEW_HEARTBEAT_MS);
+            this.heartbeatTimer.unref?.();
+        }
+        if (this.canSendTyping) {
+            this.typingTimer = setInterval(() => this.sendTypingPulse(), STREAM_TYPING_HEARTBEAT_MS);
+            this.typingTimer.unref?.();
+        }
+    }
+    update(text, thinking, activity = '', meta, plan) {
+        const nextMeta = hasPreviewMeta(meta) ? meta : null;
+        const nextPlan = plan?.steps?.length ? plan : null;
+        const changed = text !== this.latestText
+            || thinking !== this.latestThinking
+            || activity !== this.latestActivity
+            || !samePreviewMeta(nextMeta, this.latestMeta)
+            || !samePreviewPlan(nextPlan, this.latestPlan);
+        this.latestText = text;
+        this.latestThinking = thinking;
+        this.latestActivity = activity;
+        this.latestMeta = nextMeta;
+        this.latestPlan = nextPlan;
+        if (changed)
+            this.lastProgressAt = Date.now();
+        if (!text.trim() && !thinking.trim() && !activity.trim() && !nextMeta && !nextPlan)
+            return;
+        this.schedulePreviewEdit();
+    }
+    async settle() {
+        this.stopFeedback();
+        await this.flushPreviewEdits();
+    }
+    dispose() {
+        this.stopFeedback();
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.previewVersion++;
+    }
+    getEditCount() {
+        return this.editCount;
+    }
+    getRenderedPreview() {
+        return this.lastPreview;
+    }
+    stopFeedback() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.typingTimer) {
+            clearInterval(this.typingTimer);
+            this.typingTimer = null;
+        }
+    }
+    sendTypingPulse() {
+        if (!this.canSendTyping)
+            return;
+        void this.channel.sendTyping(this.chatId, { messageThreadId: this.messageThreadId }).catch(() => { });
+    }
+    renderPreview() {
+        return this.renderer.renderStream({
+            agent: this.agent,
+            elapsedMs: Date.now() - this.startTimeMs,
+            bodyText: this.latestText,
+            thinking: this.latestThinking,
+            activity: this.latestActivity,
+            meta: this.latestMeta,
+            plan: this.latestPlan,
+            model: this.model,
+            effort: this.effort,
+        });
+    }
+    schedulePreviewEdit() {
+        if (!this.canEditMessages)
+            return;
+        const wait = this.streamEditIntervalMs - (Date.now() - this.lastEditAt);
+        if (wait <= 0) {
+            if (this.flushTimer) {
+                clearTimeout(this.flushTimer);
+                this.flushTimer = null;
+            }
+            this.queuePreviewEdit();
+            return;
+        }
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            this.queuePreviewEdit();
+        }, wait);
+    }
+    queuePreviewEdit(force = false) {
+        if (!this.canEditMessages || this.placeholderMessageId == null)
+            return;
+        if (this.placeholderAbandoned)
+            return;
+        const placeholderMessageId = this.placeholderMessageId;
+        const preview = this.renderPreview();
+        if (!preview)
+            return;
+        if (!force && preview === this.lastPreview)
+            return;
+        this.lastPreview = preview;
+        const version = ++this.previewVersion;
+        this.editCount++;
+        this.lastEditAt = Date.now();
+        this.editChain = this.editChain
+            .catch(() => { })
+            .then(async () => {
+            if (version !== this.previewVersion)
+                return;
+            if (this.placeholderAbandoned)
+                return;
+            try {
+                await this.channel.editMessage(this.chatId, placeholderMessageId, preview, { parseMode: this.parseMode, keyboard: this.keyboard });
+                this.consecutiveEditFailures = 0;
+            }
+            catch (error) {
+                this.consecutiveEditFailures++;
+                this.log(`stream edit err (${this.consecutiveEditFailures}/${LivePreview.MAX_CONSECUTIVE_EDIT_FAILURES}): ${error?.message || error}`);
+                if (this.consecutiveEditFailures >= LivePreview.MAX_CONSECUTIVE_EDIT_FAILURES) {
+                    this.placeholderAbandoned = true;
+                    this.log(`placeholder abandoned after ${this.consecutiveEditFailures} consecutive failures — finalReply will fall back to a fresh card`);
+                }
+            }
+        });
+    }
+    /** True when streaming gave up on the placeholder (e.g. Feishu rejected too many
+     *  consecutive edits). The owner should send the final reply as a fresh card. */
+    isPlaceholderAbandoned() {
+        return this.placeholderAbandoned;
+    }
+    async flushPreviewEdits() {
+        if (!this.canEditMessages)
+            return;
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        if (this.editCount > 0 || this.latestText.trim() || this.latestThinking.trim() || this.latestActivity.trim()) {
+            this.queuePreviewEdit(true);
+        }
+        await this.editChain.catch(() => { });
+    }
+}