@pasko70/pibo 1.9.9 → 1.9.10

package/dist/core/base-prompt.js

@@ -0,0 +1,104 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const PROJECT_ROOT = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+export const PIBO_LIBRARY_BASE_PROMPT_PATH = resolve(PROJECT_ROOT, "context/pibo-system-prompt.md");
+function getBasePromptStatePath(cwd) {
+    return resolve(cwd, ".pibo/base-prompt.json");
+}
+function getCustomBasePromptPath(cwd) {
+    return resolve(cwd, ".pibo/base-prompt.md");
+}
+function normalizeMode(value) {
+    return value === "custom" ? "custom" : "library";
+}
+function readBasePromptState(cwd) {
+    const path = getBasePromptStatePath(cwd);
+    if (!existsSync(path))
+        return { mode: "library" };
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        return {
+            mode: normalizeMode(parsed.mode),
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : undefined,
+        };
+    }
+    catch {
+        return { mode: "library" };
+    }
+}
+function writeBasePromptState(cwd, state) {
+    const path = getBasePromptStatePath(cwd);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`);
+}
+export function getActivePiboBasePromptPath(cwd = process.cwd()) {
+    const legacyOverridePath = resolve(cwd, ".pibo/SYSTEM.md");
+    if (existsSync(legacyOverridePath))
+        return undefined;
+    const customPath = getCustomBasePromptPath(cwd);
+    const state = readBasePromptState(cwd);
+    if (state.mode === "custom" && existsSync(customPath))
+        return customPath;
+    return existsSync(PIBO_LIBRARY_BASE_PROMPT_PATH) ? PIBO_LIBRARY_BASE_PROMPT_PATH : undefined;
+}
+export async function readPiboBasePrompt(cwd = process.cwd()) {
+    const state = readBasePromptState(cwd);
+    const customPath = getCustomBasePromptPath(cwd);
+    const customExists = existsSync(customPath);
+    const [libraryMarkdown, customMarkdown] = await Promise.all([
+        readFile(PIBO_LIBRARY_BASE_PROMPT_PATH, "utf-8"),
+        customExists ? readFile(customPath, "utf-8") : Promise.resolve(""),
+    ]);
+    return {
+        mode: state.mode,
+        effectiveMode: state.mode === "custom" && customExists ? "custom" : "library",
+        library: {
+            path: PIBO_LIBRARY_BASE_PROMPT_PATH,
+            markdown: libraryMarkdown,
+        },
+        custom: {
+            path: customPath,
+            markdown: customMarkdown,
+            exists: customExists,
+            updatedAt: customExists ? state.updatedAt : undefined,
+        },
+    };
+}
+export async function savePiboCustomBasePrompt(markdown, cwd = process.cwd()) {
+    const path = getCustomBasePromptPath(cwd);
+    mkdirSync(dirname(path), { recursive: true });
+    const updatedAt = new Date().toISOString();
+    await writeFile(path, markdown);
+    writeBasePromptState(cwd, { mode: "custom", updatedAt });
+    return readPiboBasePrompt(cwd);
+}
+export function setPiboBasePromptMode(mode, cwd = process.cwd()) {
+    const existing = readBasePromptState(cwd);
+    const customPath = getCustomBasePromptPath(cwd);
+    if (mode === "custom" && !existsSync(customPath)) {
+        mkdirSync(dirname(customPath), { recursive: true });
+        writeFileSync(customPath, readFileSync(PIBO_LIBRARY_BASE_PROMPT_PATH, "utf-8"));
+    }
+    writeBasePromptState(cwd, {
+        mode,
+        updatedAt: mode === "custom" ? existing.updatedAt ?? new Date().toISOString() : existing.updatedAt,
+    });
+    const state = readBasePromptState(cwd);
+    const customExists = existsSync(customPath);
+    return {
+        mode: state.mode,
+        effectiveMode: state.mode === "custom" && customExists ? "custom" : "library",
+        library: {
+            path: PIBO_LIBRARY_BASE_PROMPT_PATH,
+            markdown: readFileSync(PIBO_LIBRARY_BASE_PROMPT_PATH, "utf-8"),
+        },
+        custom: {
+            path: customPath,
+            markdown: customExists ? readFileSync(customPath, "utf-8") : "",
+            exists: customExists,
+            updatedAt: customExists ? state.updatedAt : undefined,
+        },
+    };
+}

package/dist/core/codex-compat.js

@@ -0,0 +1,44 @@
+const CODEX_COMPAT_SUBAGENTS = ["default", "explorer", "worker"];
+function currentDate() {
+    return new Date().toISOString().slice(0, 10);
+}
+function currentTimezone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+export function buildCodexCompatSystemPrompt(options) {
+    const childInstructions = options.isChildSession
+        ? [
+            "## Delegated Child Agent",
+            "You are a child agent working as part of a team. Complete the delegated task, continue the thread when the parent sends more input, and return a concise final result for the parent agent.",
+        ].join("\n")
+        : "";
+    const compatibilityInstructions = [
+        "# Codex-Compatible Runtime",
+        "You are running in Pibo through the codex-compat profile. Match Codex-style tool use where the exposed Pibo tools support it, while staying truthful about implemented behavior.",
+        "Use Pibo's pibo_run_* tools and generated pibo_subagent_* tools for parallel work, yielded runs, and child-agent lifecycle management.",
+        "Use direct execution for normal coding tasks. If a structured planning or user-input tool is not present, ask concise questions in normal chat.",
+        "When web_search is selected by the profile, use it for current or externally sourced information.",
+        childInstructions,
+        "<environment_context>",
+        `  <cwd>${options.cwd}</cwd>`,
+        `  <shell>${options.shell}</shell>`,
+        `  <current_date>${options.currentDate ?? currentDate()}</current_date>`,
+        `  <timezone>${options.timezone ?? currentTimezone()}</timezone>`,
+        `  <subagents>${CODEX_COMPAT_SUBAGENTS.join(", ")}</subagents>`,
+        "</environment_context>",
+        options.baseSystemPrompt,
+    ];
+    return compatibilityInstructions.filter((section) => section.trim().length > 0).join("\n\n");
+}
+export function createCodexCompatExtension(options = {}) {
+    return (pi) => {
+        pi.on("before_agent_start", (event, ctx) => ({
+            systemPrompt: buildCodexCompatSystemPrompt({
+                baseSystemPrompt: event.systemPrompt,
+                cwd: ctx.cwd,
+                shell: options.shell ?? process.env.SHELL ?? "bash",
+                isChildSession: options.isChildSession,
+            }),
+        }));
+    };
+}

package/dist/core/compaction-prompt.js

@@ -0,0 +1,293 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { completeSimple } from "@earendil-works/pi-ai/compat";
+import { buildSessionContext, convertToLlm, serializeConversation, } from "@earendil-works/pi-coding-agent";
+import { isRetryablePiboAssistantError, isRetryablePiboProviderError, resolvePiboProviderRecoverySettings, waitForPiboProviderRecovery, } from "./provider-recovery.js";
+const PROJECT_ROOT = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+export const PIBO_LIBRARY_COMPACTION_PROMPT_PATH = resolve(PROJECT_ROOT, "context/pibo-compaction-prompt.md");
+function getCompactionPromptStatePath(cwd) {
+    return resolve(cwd, ".pibo/compaction-prompt.json");
+}
+function getCustomCompactionPromptPath(cwd) {
+    return resolve(cwd, ".pibo/compaction-prompt.md");
+}
+function normalizeMode(value) {
+    return value === "custom" ? "custom" : "library";
+}
+function readCompactionPromptState(cwd) {
+    const path = getCompactionPromptStatePath(cwd);
+    if (!existsSync(path))
+        return { mode: "library" };
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        return {
+            mode: normalizeMode(parsed.mode),
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : undefined,
+        };
+    }
+    catch {
+        return { mode: "library" };
+    }
+}
+function writeCompactionPromptState(cwd, state) {
+    const path = getCompactionPromptStatePath(cwd);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`);
+}
+function extractPromptSection(markdown, tag) {
+    const pattern = new RegExp(`<${tag}>\\s*([\\s\\S]*?)\\s*</${tag}>`, "i");
+    const match = markdown.match(pattern);
+    if (!match)
+        throw new Error(`Compaction prompt is missing <${tag}> section`);
+    return match[1].trim();
+}
+export function parsePiboCompactionPrompt(markdown) {
+    return {
+        systemPrompt: extractPromptSection(markdown, "system-prompt"),
+        summaryPrompt: extractPromptSection(markdown, "summary-prompt"),
+        updateSummaryPrompt: extractPromptSection(markdown, "update-summary-prompt"),
+        turnPrefixSummaryPrompt: extractPromptSection(markdown, "turn-prefix-summary-prompt"),
+    };
+}
+export function getActivePiboCompactionPromptPath(cwd = process.cwd()) {
+    const customPath = getCustomCompactionPromptPath(cwd);
+    const state = readCompactionPromptState(cwd);
+    if (state.mode === "custom" && existsSync(customPath))
+        return customPath;
+    return PIBO_LIBRARY_COMPACTION_PROMPT_PATH;
+}
+export async function readActivePiboCompactionPromptSpec(cwd = process.cwd()) {
+    return parsePiboCompactionPrompt(await readFile(getActivePiboCompactionPromptPath(cwd), "utf-8"));
+}
+export async function readPiboCompactionPrompt(cwd = process.cwd()) {
+    const state = readCompactionPromptState(cwd);
+    const customPath = getCustomCompactionPromptPath(cwd);
+    const customExists = existsSync(customPath);
+    const [libraryMarkdown, customMarkdown] = await Promise.all([
+        readFile(PIBO_LIBRARY_COMPACTION_PROMPT_PATH, "utf-8"),
+        customExists ? readFile(customPath, "utf-8") : Promise.resolve(""),
+    ]);
+    return {
+        mode: state.mode,
+        effectiveMode: state.mode === "custom" && customExists ? "custom" : "library",
+        library: {
+            path: PIBO_LIBRARY_COMPACTION_PROMPT_PATH,
+            markdown: libraryMarkdown,
+        },
+        custom: {
+            path: customPath,
+            markdown: customMarkdown,
+            exists: customExists,
+            updatedAt: customExists ? state.updatedAt : undefined,
+        },
+    };
+}
+export async function savePiboCustomCompactionPrompt(markdown, cwd = process.cwd()) {
+    parsePiboCompactionPrompt(markdown);
+    const path = getCustomCompactionPromptPath(cwd);
+    mkdirSync(dirname(path), { recursive: true });
+    const updatedAt = new Date().toISOString();
+    await writeFile(path, markdown);
+    writeCompactionPromptState(cwd, { mode: "custom", updatedAt });
+    return readPiboCompactionPrompt(cwd);
+}
+export function setPiboCompactionPromptMode(mode, cwd = process.cwd()) {
+    const existing = readCompactionPromptState(cwd);
+    const customPath = getCustomCompactionPromptPath(cwd);
+    if (mode === "custom" && !existsSync(customPath)) {
+        mkdirSync(dirname(customPath), { recursive: true });
+        writeFileSync(customPath, readFileSync(PIBO_LIBRARY_COMPACTION_PROMPT_PATH, "utf-8"));
+    }
+    writeCompactionPromptState(cwd, {
+        mode,
+        updatedAt: mode === "custom" ? existing.updatedAt ?? new Date().toISOString() : existing.updatedAt,
+    });
+    const state = readCompactionPromptState(cwd);
+    const customExists = existsSync(customPath);
+    return {
+        mode: state.mode,
+        effectiveMode: state.mode === "custom" && customExists ? "custom" : "library",
+        library: {
+            path: PIBO_LIBRARY_COMPACTION_PROMPT_PATH,
+            markdown: readFileSync(PIBO_LIBRARY_COMPACTION_PROMPT_PATH, "utf-8"),
+        },
+        custom: {
+            path: customPath,
+            markdown: customExists ? readFileSync(customPath, "utf-8") : "",
+            exists: customExists,
+            updatedAt: customExists ? state.updatedAt : undefined,
+        },
+    };
+}
+function buildSummaryPrompt(spec, messages, customInstructions, previousSummary) {
+    const conversationText = serializeConversation(convertToLlm(messages));
+    const basePrompt = previousSummary ? spec.updateSummaryPrompt : spec.summaryPrompt;
+    const focusedPrompt = customInstructions ? `${basePrompt}\n\nAdditional focus: ${customInstructions}` : basePrompt;
+    return [
+        `<conversation>\n${conversationText}\n</conversation>`,
+        previousSummary ? `<previous-summary>\n${previousSummary}\n</previous-summary>` : undefined,
+        focusedPrompt,
+    ].filter((part) => part !== undefined).join("\n\n");
+}
+function buildTurnPrefixPrompt(spec, messages) {
+    const conversationText = serializeConversation(convertToLlm(messages));
+    return `<conversation>\n${conversationText}\n</conversation>\n\n${spec.turnPrefixSummaryPrompt}`;
+}
+export async function completePiboCompactionSummary(input) {
+    const recoverySessionId = input.sessionId ? `compaction-${randomUUID()}` : undefined;
+    const completionOptions = {
+        maxTokens: input.maxTokens,
+        signal: input.signal,
+        apiKey: input.apiKey,
+        headers: input.headers,
+        transport: input.transport,
+        sessionId: recoverySessionId,
+        timeoutMs: input.timeoutMs,
+        websocketConnectTimeoutMs: input.websocketConnectTimeoutMs,
+        maxRetries: input.maxRetries,
+        maxRetryDelayMs: input.maxRetryDelayMs,
+        ...(input.model.reasoning && input.thinkingLevel && input.thinkingLevel !== "off"
+            ? { reasoning: input.thinkingLevel }
+            : {}),
+    };
+    const complete = input.complete ?? completeSimple;
+    let recoveryAttempt = 0;
+    while (true) {
+        let response;
+        try {
+            response = await complete(input.model, {
+                systemPrompt: input.systemPrompt,
+                messages: [
+                    {
+                        role: "user",
+                        content: [{ type: "text", text: input.promptText }],
+                        timestamp: Date.now(),
+                    },
+                ],
+            }, completionOptions);
+        }
+        catch (error) {
+            if (input.signal?.aborted || !input.recovery.enabled || !isRetryablePiboProviderError(error))
+                throw error;
+            recoveryAttempt += 1;
+            await waitForPiboProviderRecovery(recoveryAttempt, input.recovery, input.signal);
+            continue;
+        }
+        if (response.stopReason === "aborted") {
+            throw new Error("Summarization was aborted");
+        }
+        if (response.stopReason === "error") {
+            const error = new Error(`Summarization failed: ${response.errorMessage || "Unknown error"}`);
+            if (!input.recovery.enabled || !isRetryablePiboAssistantError(response))
+                throw error;
+            recoveryAttempt += 1;
+            await waitForPiboProviderRecovery(recoveryAttempt, input.recovery, input.signal);
+            continue;
+        }
+        return response.content
+            .filter((content) => content.type === "text")
+            .map((content) => content.text)
+            .join("\n");
+    }
+}
+function computeFileLists(fileOps) {
+    const modified = new Set([...fileOps.written, ...fileOps.edited]);
+    const readFiles = [...fileOps.read].filter((path) => !modified.has(path)).sort();
+    const modifiedFiles = [...modified].sort();
+    return { readFiles, modifiedFiles };
+}
+function formatFileOperations(readFiles, modifiedFiles) {
+    const sections = [];
+    if (readFiles.length > 0)
+        sections.push(`<read-files>\n${readFiles.join("\n")}\n</read-files>`);
+    if (modifiedFiles.length > 0)
+        sections.push(`<modified-files>\n${modifiedFiles.join("\n")}\n</modified-files>`);
+    return sections.length > 0 ? `\n\n${sections.join("\n\n")}` : "";
+}
+async function generatePiboCompaction(input) {
+    const { preparation, spec } = input;
+    const completionDefaults = {
+        model: input.model,
+        systemPrompt: spec.systemPrompt,
+        apiKey: input.apiKey,
+        headers: input.headers,
+        signal: input.signal,
+        thinkingLevel: input.thinkingLevel,
+        transport: input.transport,
+        sessionId: input.sessionId,
+        timeoutMs: input.timeoutMs,
+        websocketConnectTimeoutMs: input.websocketConnectTimeoutMs,
+        maxRetries: input.maxRetries,
+        maxRetryDelayMs: input.maxRetryDelayMs,
+        recovery: input.recovery,
+    };
+    let summary;
+    if (preparation.isSplitTurn && preparation.turnPrefixMessages.length > 0) {
+        const [historySummary, turnPrefixSummary] = await Promise.all([
+            preparation.messagesToSummarize.length > 0
+                ? completePiboCompactionSummary({
+                    ...completionDefaults,
+                    promptText: buildSummaryPrompt(spec, preparation.messagesToSummarize, input.customInstructions, preparation.previousSummary),
+                    maxTokens: Math.floor(0.8 * preparation.settings.reserveTokens),
+                })
+                : Promise.resolve("No prior history."),
+            completePiboCompactionSummary({
+                ...completionDefaults,
+                promptText: buildTurnPrefixPrompt(spec, preparation.turnPrefixMessages),
+                maxTokens: Math.floor(0.5 * preparation.settings.reserveTokens),
+            }),
+        ]);
+        summary = `${historySummary}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixSummary}`;
+    }
+    else {
+        summary = await completePiboCompactionSummary({
+            ...completionDefaults,
+            promptText: buildSummaryPrompt(spec, preparation.messagesToSummarize, input.customInstructions, preparation.previousSummary),
+            maxTokens: Math.floor(0.8 * preparation.settings.reserveTokens),
+        });
+    }
+    const { readFiles, modifiedFiles } = computeFileLists(preparation.fileOps);
+    summary += formatFileOperations(readFiles, modifiedFiles);
+    return {
+        summary,
+        firstKeptEntryId: preparation.firstKeptEntryId,
+        tokensBefore: preparation.tokensBefore,
+        details: { readFiles, modifiedFiles },
+    };
+}
+export function createPiboCompactionPromptExtension(options = {}) {
+    return (pi) => {
+        pi.on("session_before_compact", async (event, ctx) => {
+            if (!ctx.model)
+                return undefined;
+            const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
+            if (!auth.ok || !auth.apiKey)
+                return undefined;
+            const sessionContext = buildSessionContext(ctx.sessionManager.getEntries(), ctx.sessionManager.getLeafId());
+            const settingsManager = options.getSettingsManager?.();
+            const providerRetry = settingsManager?.getProviderRetrySettings();
+            return {
+                compaction: await generatePiboCompaction({
+                    preparation: event.preparation,
+                    spec: await readActivePiboCompactionPromptSpec(ctx.cwd),
+                    model: ctx.model,
+                    apiKey: auth.apiKey,
+                    headers: auth.headers,
+                    customInstructions: event.customInstructions,
+                    signal: event.signal,
+                    thinkingLevel: sessionContext.thinkingLevel,
+                    transport: settingsManager?.getTransport(),
+                    sessionId: ctx.sessionManager.getSessionId(),
+                    timeoutMs: settingsManager?.getHttpIdleTimeoutMs(),
+                    websocketConnectTimeoutMs: settingsManager?.getWebSocketConnectTimeoutMs(),
+                    maxRetries: providerRetry?.maxRetries,
+                    maxRetryDelayMs: providerRetry?.maxRetryDelayMs,
+                    recovery: resolvePiboProviderRecoverySettings(settingsManager),
+                }),
+            };
+        });
+    };
+}