pi2web 0.2.0 → 0.2.6

package/dist/agent-feed.js

@@ -0,0 +1,133 @@
+import { buildTimeline, contentText, pageTimeline } from './timeline.js';
+/**
+ * Turns one backend's raw events into the detail stream. After any event, if the session's
+ * leaf moved, the branch is projected again and the items after the published ones are sent.
+ */
+export class AgentFeed {
+    source;
+    emit;
+    published;
+    live = { active: false, text: '', thinking: '' };
+    clearLive = false;
+    outputs = new Map();
+    timer;
+    closed = false;
+    constructor(source, emit) {
+        this.source = source;
+        this.emit = emit;
+        this.published = this.project().published;
+    }
+    /**
+     * Everything a client needs to start viewing: the newest page and the text streamed so far.
+     * Publishes pending changes first, so the next message a subscriber gets is newer than this.
+     */
+    snapshot(limit) {
+        this.sync();
+        const source = this.source(), { active, text, thinking } = this.live;
+        return {
+            sessionId: source.sessionId,
+            page: pageTimeline(buildTimeline(source.entries()), limit),
+            live: active || text || thinking ? { text, thinking } : null
+        };
+    }
+    output(toolCallId) {
+        return this.outputs.get(toolCallId);
+    }
+    handle(event) {
+        const e = event;
+        switch (event.type) {
+            case 'message_start':
+                if (e.message?.role === 'assistant' || e.role === 'assistant') {
+                    // The previous message is persisted by now; publish it before streaming the next.
+                    this.sync();
+                    this.live = { active: true, text: '', thinking: '' };
+                }
+                break;
+            case 'message_update': {
+                const update = e.assistantMessageEvent;
+                if ((update?.type === 'text_delta' || update?.type === 'thinking_delta') &&
+                    typeof update.delta === 'string') {
+                    const kind = update.type === 'text_delta' ? 'text' : 'thinking';
+                    this.live[kind] += update.delta;
+                    this.emit({ type: 'delta', kind, delta: update.delta });
+                }
+                return; // Deltas never change the persisted timeline.
+            }
+            case 'message_end':
+                if (this.live.active) {
+                    this.live.active = false;
+                    this.clearLive = true;
+                }
+                break;
+            case 'tool_execution_update':
+                if (!e.parentToolCallId && typeof e.toolCallId === 'string') {
+                    const result = e.partialResult, output = contentText(result?.content ?? result) || (result ? JSON.stringify(result) : '');
+                    this.outputs.set(e.toolCallId, output);
+                    this.emit({ type: 'tool_output', toolCallId: e.toolCallId, output });
+                }
+                return;
+            case 'tool_execution_end':
+                this.outputs.delete(String(e.toolCallId));
+                break;
+            case 'bash_execution_start':
+            case 'bash_execution_update':
+            case 'bash_execution_end':
+                this.emit({ type: 'event', event });
+                break;
+        }
+        this.schedule();
+    }
+    /** Pi persists a message right after notifying listeners of it, so look once the event has finished. */
+    schedule() {
+        if (this.timer || this.closed)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            this.sync();
+        }, 0);
+    }
+    /** Publish what changed on the timeline since the last call. Cheap when the leaf did not move. */
+    sync() {
+        if (this.closed)
+            return;
+        const source = this.source(), previous = this.published;
+        if (source.sessionId === previous.sessionId && source.leafId === previous.leafId && !this.clearLive)
+            return;
+        const { published, records, entries } = this.project(source);
+        this.published = published;
+        // An append keeps the old leaf on the branch and every item published so far.
+        const appended = source.sessionId === previous.sessionId &&
+            (previous.leafId === null || entries.some(entry => entry.id === previous.leafId)) &&
+            previous.ids.every((id, i) => published.ids[i] === id);
+        const clearLive = this.clearLive;
+        this.clearLive = false;
+        if (clearLive)
+            this.live = { active: false, text: '', thinking: '' };
+        if (!appended) {
+            this.emit({ type: 'timeline_reset', sessionId: source.sessionId });
+            return;
+        }
+        const items = records.slice(previous.ids.length).map(r => r.item);
+        if (!items.length && !clearLive)
+            return;
+        this.emit({
+            type: 'items',
+            sessionId: source.sessionId,
+            items,
+            ...(clearLive ? { clearLive: true } : {})
+        });
+    }
+    close() {
+        this.closed = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+    }
+    project(source = this.source()) {
+        const entries = source.entries(), records = buildTimeline(entries);
+        return {
+            published: { sessionId: source.sessionId, leafId: source.leafId, ids: records.map(r => r.item.id) },
+            records,
+            entries
+        };
+    }
+}

package/dist/agent-templates.js

@@ -0,0 +1,144 @@
+import { getAgentDir, parseFrontmatter } from '@earendil-works/pi-coding-agent';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+const ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const MAX_PROMPT = 200_000;
+const invalid = (message) => Object.assign(new Error(message), { code: 'INVALID_REQUEST' });
+export const validTemplateId = (id) => typeof id === 'string' && ID.test(id) && !id.endsWith('.') && id !== 'default';
+const asMode = (value) => value === 'replace' || value === 'append' ? value : undefined;
+/** Serialize a template as Markdown with YAML front matter; JSON strings are valid YAML scalars. */
+export const formatTemplateFile = (template) => [
+    '---',
+    `name: ${JSON.stringify(template.name)}`,
+    ...(template.description ? [`description: ${JSON.stringify(template.description)}`] : []),
+    `mode: ${template.mode}`,
+    '---',
+    '',
+    template.systemPrompt.trim(),
+    ''
+].join('\n');
+/**
+ * Agent templates are plain files under `<data-dir>/agent-templates/<id>.md` so they can be shared by copying:
+ *
+ * ```markdown
+ * ---
+ * name: Code reviewer
+ * description: Reviews diffs, never edits files
+ * mode: replace        # or append
+ * ---
+ * You are a meticulous code reviewer...
+ * ```
+ *
+ * Files are re-read on every call, so templates dropped into the directory by hand show up immediately.
+ */
+export class AgentTemplateStore {
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    fileFor(id) {
+        if (!validTemplateId(id))
+            throw invalid('Template id must be 1-64 letters, digits, dot, underscore or hyphen');
+        return path.join(this.dir, `${id}.md`);
+    }
+    read(id, file) {
+        const raw = readFileSync(file, 'utf8');
+        let frontmatter = {}, body = raw;
+        try {
+            ({ frontmatter, body } = parseFrontmatter(raw));
+        }
+        catch (error) {
+            throw Object.assign(new Error(`Invalid front matter in ${file}: ${error.message}`), {
+                code: 'INVALID_TEMPLATE'
+            });
+        }
+        const name = typeof frontmatter.name === 'string' && frontmatter.name.trim() ? frontmatter.name.trim() : id;
+        return {
+            id,
+            name,
+            description: typeof frontmatter.description === 'string' ? frontmatter.description.trim() : '',
+            mode: asMode(frontmatter.mode) ?? 'append',
+            systemPrompt: body.trim(),
+            file,
+            updatedAt: statSync(file).mtime.toISOString()
+        };
+    }
+    list() {
+        if (!existsSync(this.dir))
+            return { templates: [], errors: [] };
+        const templates = [], errors = [];
+        for (const entry of readdirSync(this.dir, { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            const id = entry.name.slice(0, -3);
+            if (!validTemplateId(id)) {
+                errors.push(`Ignored ${entry.name}: invalid template id`);
+                continue;
+            }
+            try {
+                templates.push(this.read(id, path.join(this.dir, entry.name)));
+            }
+            catch (error) {
+                errors.push(error.message);
+            }
+        }
+        templates.sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
+        return { templates, errors };
+    }
+    get(id) {
+        const file = this.fileFor(id);
+        if (!existsSync(file))
+            throw Object.assign(new Error(`Agent template not found: ${id}`), { code: 'TEMPLATE_NOT_FOUND' });
+        return this.read(id, file);
+    }
+    save(id, input) {
+        const file = this.fileFor(id);
+        const name = typeof input.name === 'string' && input.name.trim() ? input.name.trim() : id;
+        if (name.length > 100 || /[\r\n]/.test(name))
+            throw invalid('name must be a single line of at most 100 characters');
+        const description = typeof input.description === 'string' ? input.description.trim() : '';
+        if (description.length > 500 || /[\r\n]/.test(description))
+            throw invalid('description must be a single line of at most 500 characters');
+        const mode = asMode(input.mode);
+        if (!mode)
+            throw invalid('mode must be replace or append');
+        if (typeof input.systemPrompt !== 'string' || !input.systemPrompt.trim())
+            throw invalid('systemPrompt is required');
+        if (input.systemPrompt.length > MAX_PROMPT)
+            throw invalid('systemPrompt is too long');
+        mkdirSync(this.dir, { recursive: true });
+        writeFileSync(file, formatTemplateFile({ name, description, mode, systemPrompt: input.systemPrompt }), 'utf8');
+        return this.read(id, file);
+    }
+    remove(id) {
+        const file = this.fileFor(id);
+        if (!existsSync(file))
+            throw Object.assign(new Error(`Agent template not found: ${id}`), { code: 'TEMPLATE_NOT_FOUND' });
+        rmSync(file);
+    }
+    snapshot(id) {
+        const { name, mode, systemPrompt } = this.get(id);
+        return { id, name, mode, systemPrompt };
+    }
+}
+const PI_PROMPT_FILES = { system: 'SYSTEM.md', append: 'APPEND_SYSTEM.md' };
+export const piPromptFile = (kind, agentDir = getAgentDir()) => path.join(agentDir, PI_PROMPT_FILES[kind]);
+export function readPiPromptFiles(agentDir = getAgentDir()) {
+    const read = (kind) => {
+        const file = piPromptFile(kind, agentDir), exists = existsSync(file);
+        return { path: file, exists, content: exists ? readFileSync(file, 'utf8') : '' };
+    };
+    return { agentDir, system: read('system'), append: read('append') };
+}
+/** Write (or, for an empty value, delete) a global Pi prompt file. Deleting SYSTEM.md restores Pi's built-in prompt. */
+export function writePiPromptFile(kind, content, agentDir = getAgentDir()) {
+    if (content.length > MAX_PROMPT)
+        throw invalid('content is too long');
+    const file = piPromptFile(kind, agentDir);
+    if (!content.trim())
+        rmSync(file, { force: true });
+    else {
+        mkdirSync(agentDir, { recursive: true });
+        writeFileSync(file, content, 'utf8');
+    }
+}