pikiclaw 0.2.35

package/dist/bot-handler.js

@@ -0,0 +1,115 @@
+/**
+ * bot-handler.ts — channel-agnostic message handling pipeline.
+ *
+ * Defines the `MessagePipeline` interface that each IM implements to plug in
+ * its own placeholder, live preview, final reply, and MCP file-send logic.
+ *
+ * The generic `handleIncomingMessage()` orchestrates the shared flow:
+ *   resolve session → create placeholder → start live preview → run stream →
+ *   settle preview → send final reply → cleanup
+ *
+ * File return is handled in real-time by the MCP bridge during the stream,
+ * not as a post-stream batch.
+ */
+import { buildPrompt } from './bot.js';
+import { stageSessionFiles } from './code-agent.js';
+export async function stageFilesIntoSession(bot, session, files) {
+    const staged = stageSessionFiles({
+        agent: session.agent,
+        workdir: bot.workdir,
+        files,
+        sessionId: session.sessionId,
+        title: files[0],
+    });
+    session.workspacePath = staged.workspacePath;
+    return {
+        ok: staged.importedFiles.length > 0,
+        sessionId: staged.sessionId,
+        workspacePath: staged.workspacePath,
+        importedCount: staged.importedFiles.length,
+    };
+}
+/**
+ * Generic message handling orchestration. Call this from your IM-specific bot.
+ *
+ * This handles the full lifecycle: session resolution → task registration →
+ * placeholder → live preview → stream (with MCP bridge) → final reply → cleanup.
+ */
+export async function handleIncomingMessage(opts) {
+    const { bot, pipeline, ctx, files, systemPrompt } = opts;
+    const text = opts.text.trim();
+    if (!text && !files.length)
+        return;
+    const chatId = pipeline.getChatId(ctx);
+    const messageId = pipeline.getMessageId(ctx);
+    const session = pipeline.resolveSession(ctx, text, files);
+    const cs = bot.chat(chatId);
+    // Apply session selection to chat state
+    cs.activeSessionKey = session.key;
+    cs.agent = session.agent;
+    cs.sessionId = session.sessionId;
+    cs.workspacePath = session.workspacePath;
+    cs.codexCumulative = session.codexCumulative;
+    cs.modelId = session.modelId ?? null;
+    // File-only message: stage files without running prompt
+    if (!text && files.length) {
+        const hadPendingWork = bot['sessionHasPendingWork']?.(session) ?? false;
+        const stageTask = opts.queueSessionTask(session, async () => {
+            const result = await stageFilesIntoSession(bot, session, files);
+            opts.syncSelectedChats(session);
+            if (!result.ok)
+                throw new Error('no files persisted');
+            opts.log(`[handleMessage] staged files session=${result.sessionId} files=${result.importedCount}`);
+        });
+        if (hadPendingWork) {
+            void stageTask.catch(e => opts.log(`[handleMessage] stage queue failed: ${e}`));
+        }
+        else {
+            await stageTask.catch(e => opts.log(`[handleMessage] stage queue failed: ${e}`));
+        }
+        return;
+    }
+    const prompt = buildPrompt(text, files);
+    const start = Date.now();
+    opts.log(`[handleMessage] queued chat=${chatId} agent=${session.agent} session=${session.sessionId || '(new)'} prompt="${prompt.slice(0, 100)}" files=${files.length}`);
+    const placeholder = await pipeline.createPlaceholder(ctx, session);
+    const taskId = opts.createTaskId(session);
+    opts.beginTask({
+        taskId,
+        chatId,
+        agent: session.agent,
+        sessionKey: session.key,
+        prompt,
+        startedAt: start,
+        sourceMessageId: messageId,
+    });
+    // Create MCP sendFile callback bound to this chat context
+    const mcpSendFile = pipeline.createMcpSendFile(ctx, session);
+    void opts.queueSessionTask(session, async () => {
+        let preview = null;
+        try {
+            if (placeholder) {
+                preview = pipeline.createLivePreview(ctx, placeholder, session);
+                preview?.start();
+            }
+            const result = await bot.runStream(prompt, session, files, (nextText, nextThinking, nextActivity = '', meta, plan) => {
+                preview?.update(nextText, nextThinking, nextActivity, meta, plan);
+            }, systemPrompt, mcpSendFile);
+            await preview?.settle();
+            opts.log(`[handleMessage] done agent=${session.agent} ok=${result.ok} elapsed=${result.elapsedS.toFixed(1)}s`);
+            await pipeline.sendFinalReply(ctx, placeholder, session, result);
+        }
+        catch (e) {
+            opts.log(`[handleMessage] task failed chat=${chatId} error=${e?.message || e}`);
+            await pipeline.onError(ctx, placeholder, session, e instanceof Error ? e : new Error(String(e)));
+        }
+        finally {
+            preview?.dispose();
+            opts.finishTask(taskId);
+            opts.syncSelectedChats(session);
+        }
+    }).catch(e => {
+        opts.log(`[handleMessage] queue execution failed: ${e}`);
+        opts.finishTask(taskId);
+    });
+}

package/dist/bot-menu.js

@@ -0,0 +1,44 @@
+export const SKILL_CMD_PREFIX = 'sk_';
+export function buildWelcomeIntro(version) {
+    return {
+        title: "Hi, I'm pikiclaw",
+        subtitle: 'Send me a message to get started.',
+        version,
+    };
+}
+export function buildSkillCommandName(skillName) {
+    const normalized = skillName.trim().toLowerCase().replace(/[^a-z0-9_]/g, '_');
+    if (!normalized)
+        return null;
+    const cmdName = `${SKILL_CMD_PREFIX}${normalized}`;
+    if (cmdName.length > 32)
+        return null;
+    return cmdName;
+}
+export function indexSkillsByCommand(skills) {
+    const indexed = new Map();
+    for (const skill of skills) {
+        const cmdName = buildSkillCommandName(skill.name);
+        if (!cmdName || indexed.has(cmdName))
+            continue;
+        indexed.set(cmdName, skill);
+    }
+    return indexed;
+}
+export function buildDefaultMenuCommands(agentCount, skills = []) {
+    const commands = [
+        { command: 'sessions', description: 'Switch sessions' },
+    ];
+    if (agentCount > 1) {
+        commands.push({ command: 'agents', description: 'Switch agents' });
+    }
+    commands.push({ command: 'switch', description: 'Change workdir' }, { command: 'models', description: 'Switch models' }, { command: 'status', description: 'Show status' }, { command: 'host', description: 'Host info' });
+    if (skills.length) {
+        commands.push({ command: 'skills', description: 'Browse skills' });
+    }
+    if (agentCount === 1) {
+        commands.push({ command: 'agents', description: 'Switch agents' });
+    }
+    commands.push({ command: 'restart', description: 'Restart bot' });
+    return commands;
+}

package/dist/bot-streaming.js

@@ -0,0 +1,165 @@
+const INJECTED_PROMPT_MARKERS = [
+    '\n[Session Workspace]',
+    '\n[Telegram Artifact Return]',
+    '\n[Artifact Return]',
+];
+export function stripInjectedPrompts(text) {
+    for (const marker of INJECTED_PROMPT_MARKERS) {
+        const idx = text.indexOf(marker);
+        if (idx >= 0)
+            return text.slice(0, idx).trim();
+    }
+    return text.trim();
+}
+export function summarizePromptForStatus(prompt, maxLen = 50) {
+    const clean = stripInjectedPrompts(prompt).replace(/\s+/g, ' ').trim();
+    if (!clean)
+        return '';
+    if (clean.length <= maxLen)
+        return clean;
+    return clean.slice(0, Math.max(0, maxLen - 3)).trimEnd() + '...';
+}
+function parseClaudeShellActivity(line) {
+    const prefix = 'Run shell: ';
+    if (!line.startsWith(prefix))
+        return null;
+    const detail = line.slice(prefix.length).trim();
+    if (!detail)
+        return { key: prefix.trim(), status: 'active' };
+    const doneIdx = detail.indexOf(' -> ');
+    if (doneIdx > 0) {
+        return {
+            key: detail.slice(0, doneIdx).trim(),
+            status: 'done',
+        };
+    }
+    const failed = detail.match(/^(.*)\sfailed(?::.*)?$/);
+    if (failed?.[1]?.trim()) {
+        return {
+            key: failed[1].trim(),
+            status: 'failed',
+        };
+    }
+    if (detail.endsWith(' done')) {
+        const key = detail.slice(0, -' done'.length).trim();
+        return { key: key || detail, status: 'done' };
+    }
+    return { key: detail, status: 'active' };
+}
+export function parseActivitySummary(activity) {
+    const narrative = [];
+    let failedCommands = 0;
+    let activeCommands = 0;
+    let completedCommands = 0;
+    const activeClaudeShells = new Map();
+    for (const rawLine of activity.split('\n')) {
+        const line = rawLine.replace(/\s+/g, ' ').trim();
+        if (!line)
+            continue;
+        const claudeShell = parseClaudeShellActivity(line);
+        if (claudeShell) {
+            const key = claudeShell.key || 'Run shell';
+            const current = activeClaudeShells.get(key) || 0;
+            if (claudeShell.status === 'active') {
+                activeClaudeShells.set(key, current + 1);
+            }
+            else {
+                if (current > 0)
+                    activeClaudeShells.set(key, current - 1);
+                if (claudeShell.status === 'done')
+                    completedCommands++;
+                else
+                    failedCommands++;
+            }
+            continue;
+        }
+        if (line.startsWith('$ ')) {
+            activeCommands++;
+            continue;
+        }
+        if (line.startsWith('Ran: ')) {
+            completedCommands++;
+            continue;
+        }
+        const executed = line.match(/^Executed (\d+) command(?:s)?\.$/);
+        if (executed) {
+            completedCommands = Math.max(completedCommands, parseInt(executed[1], 10) || 0);
+            continue;
+        }
+        const running = line.match(/^Running (\d+) command(?:s)?\.\.\.$/);
+        if (running) {
+            activeCommands = Math.max(activeCommands, parseInt(running[1], 10) || 0);
+            continue;
+        }
+        const failed = line.match(/^Command failed \((\d+)\):/);
+        if (failed) {
+            failedCommands++;
+            continue;
+        }
+        if (/^Command failed \(\d+\)$/.test(line)) {
+            failedCommands++;
+            continue;
+        }
+        narrative.push(line);
+    }
+    for (const pending of activeClaudeShells.values()) {
+        activeCommands += pending;
+    }
+    return { narrative, failedCommands, completedCommands, activeCommands };
+}
+export function formatActivityCommandSummary(completedCommands, activeCommands, failedCommands = 0) {
+    const parts = [];
+    if (failedCommands > 0)
+        parts.push(`${failedCommands} failed`);
+    if (completedCommands > 0)
+        parts.push(`${completedCommands} done`);
+    if (activeCommands > 0)
+        parts.push(`${activeCommands} running`);
+    return parts.length ? `commands: ${parts.join(', ')}` : '';
+}
+export function summarizeActivityForPreview(activity) {
+    const summary = parseActivitySummary(activity);
+    const lines = [...summary.narrative];
+    const commandSummary = formatActivityCommandSummary(summary.completedCommands, summary.activeCommands, summary.failedCommands);
+    if (commandSummary)
+        lines.push(commandSummary);
+    return lines.join('\n');
+}
+export function hasPreviewMeta(meta) {
+    return meta?.contextPercent != null;
+}
+export function samePreviewMeta(a, b) {
+    return (a?.contextPercent ?? null) === (b?.contextPercent ?? null);
+}
+export function samePreviewPlan(a, b) {
+    if ((a?.explanation ?? null) !== (b?.explanation ?? null))
+        return false;
+    const aSteps = a?.steps ?? [];
+    const bSteps = b?.steps ?? [];
+    if (aSteps.length !== bSteps.length)
+        return false;
+    for (let i = 0; i < aSteps.length; i++) {
+        if (aSteps[i].status !== bSteps[i].status)
+            return false;
+        if (aSteps[i].step !== bSteps[i].step)
+            return false;
+    }
+    return true;
+}
+function normalizePlanStep(step) {
+    return step.replace(/\s+/g, ' ').trim();
+}
+export function renderPlanForPreview(plan) {
+    if (!plan?.steps.length)
+        return '';
+    const completed = plan.steps.filter(step => step.status === 'completed').length;
+    const total = plan.steps.length;
+    const lines = [`Plan ${completed}/${total}`];
+    for (const step of plan.steps.slice(0, 4)) {
+        const prefix = step.status === 'completed' ? '[x]' : step.status === 'inProgress' ? '[>]' : '[ ]';
+        lines.push(`${prefix} ${normalizePlanStep(step.step)}`);
+    }
+    if (plan.steps.length > 4)
+        lines.push(`... +${plan.steps.length - 4} more`);
+    return lines.join('\n');
+}

package/dist/bot-telegram-directory.js

@@ -0,0 +1,74 @@
+import path from 'node:path';
+import { listSubdirs } from './bot.js';
+import { buildCompactSelectionTitle, compactCode } from './bot-telegram-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) {
+    const lines = [buildCompactSelectionTitle('Workdir')];
+    lines.push(`● ${compactCode(currentWorkdir, 42)}`);
+    if (browsePath !== currentWorkdir)
+        lines.push(`○ ${compactCode(browsePath, 42)}`);
+    return {
+        text: lines.join('\n'),
+        keyboard: buildDirKeyboard(browsePath, page),
+    };
+}
+export function resolveRegisteredPath(id) {
+    return pathRegistry.resolve(id);
+}

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

@@ -0,0 +1,192 @@
+import { hasPreviewMeta, samePreviewMeta, samePreviewPlan } from './bot-streaming.js';
+const STREAM_PREVIEW_HEARTBEAT_MS = 5_000;
+const STREAM_TYPING_HEARTBEAT_MS = 4_000;
+const STREAM_STALLED_NOTICE_MS = 15_000;
+// ---------------------------------------------------------------------------
+// LivePreview — generic streaming preview controller
+// ---------------------------------------------------------------------------
+export class LivePreview {
+    initialText;
+    agent;
+    chatId;
+    placeholderMessageId;
+    channel;
+    renderer;
+    streamEditIntervalMs;
+    startTimeMs;
+    canEditMessages;
+    canSendTyping;
+    messageThreadId;
+    parseMode;
+    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;
+    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.log = options.log ?? (() => { });
+        this.initialText = this.renderer.renderInitial(this.agent);
+        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;
+    }
+    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,
+        });
+    }
+    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;
+        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;
+            try {
+                await this.channel.editMessage(this.chatId, placeholderMessageId, preview, { parseMode: this.parseMode });
+            }
+            catch (error) {
+                this.log(`stream edit err: ${error?.message || error}`);
+            }
+        });
+    }
+    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(() => { });
+    }
+}
+// ---------------------------------------------------------------------------
+// Backward compat alias — existing code imports TelegramLivePreview
+// ---------------------------------------------------------------------------
+/** @deprecated Use `LivePreview` directly. */
+export const TelegramLivePreview = LivePreview;