@pasko70/pibo 1.9.7 → 1.9.9

package/dist/core/context-guard.js

@@ -1,293 +0,0 @@
-import { DEFAULT_COMPACTION_SETTINGS, buildSessionContext, estimateTokens, } from "@earendil-works/pi-coding-agent";
-export const PIBO_CONTEXT_GUARD_NOTICE = "Context safety interrupted this response before adding it to long-term context. Pibo is compacting the session before continuing.";
-export const PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE = "pibo-context-guard-resume";
-export const PIBO_CONTEXT_GUARD_RESUME_PROMPT = "Continue the interrupted task autonomously from the compacted context. Do not wait for additional user input and do not repeat the context-safety notice.";
-const DEFAULT_MIN_COMPACTION_RESERVE_TOKENS = 1024;
-const FALLBACK_CONTEXT_WINDOW = 0;
-const MAX_CONTEXT_GUARD_RECOVERY_ATTEMPTS = 3;
-const contextGuardRecoveries = new WeakMap();
-export function createPiboAssistantContextGuardRecovery() {
-    let pending;
-    let claimed = false;
-    let cancelError;
-    let cancelHandler;
-    return {
-        begin() {
-            if (pending && !pending.settled)
-                return;
-            cancelError = undefined;
-            let resolve;
-            const promise = new Promise((done) => {
-                resolve = done;
-            });
-            pending = { promise, resolve, settled: false };
-        },
-        complete() {
-            if (!pending || pending.settled)
-                return;
-            pending.settled = true;
-            pending.resolve({ ok: true });
-        },
-        fail(error) {
-            if (!pending || pending.settled)
-                return;
-            pending.settled = true;
-            pending.resolve({ ok: false, error });
-        },
-        cancel(error) {
-            cancelError = error;
-            if (pending && !pending.settled) {
-                pending.settled = true;
-                pending.resolve({ ok: false, error });
-            }
-            cancelHandler?.();
-        },
-        claim() {
-            claimed = true;
-        },
-        isClaimed() {
-            return claimed;
-        },
-        isPending() {
-            return pending !== undefined && !pending.settled;
-        },
-        onCancel(handler) {
-            cancelHandler = handler;
-        },
-        async wait() {
-            const current = pending;
-            if (!current)
-                return false;
-            const outcome = await current.promise;
-            const cancelled = cancelError;
-            if (pending === current) {
-                pending = undefined;
-                cancelError = undefined;
-            }
-            if (cancelled)
-                throw cancelled;
-            if (!outcome.ok)
-                throw outcome.error;
-            return true;
-        },
-    };
-}
-export function registerPiboAssistantContextGuardRecovery(session, recovery) {
-    contextGuardRecoveries.set(session, recovery);
-}
-export function claimPiboAssistantContextGuardRecovery(session) {
-    contextGuardRecoveries.get(session)?.claim();
-}
-export function cancelPiboAssistantContextGuardRecovery(session, error) {
-    contextGuardRecoveries.get(session)?.cancel(error);
-}
-export function isPiboAssistantContextGuardRecoveryPending(session) {
-    return contextGuardRecoveries.get(session)?.isPending() ?? false;
-}
-export async function waitForPiboAssistantContextGuardRecovery(session) {
-    return await contextGuardRecoveries.get(session)?.wait() ?? false;
-}
-function textTokensByLength(length) {
-    return Math.ceil(length / 4);
-}
-function finitePositive(value) {
-    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
-}
-function guardReserveTokens(contextWindow, options) {
-    const configured = finitePositive(options.reserveTokens);
-    if (configured !== undefined)
-        return configured;
-    const minReserve = finitePositive(options.minReserveTokens) ?? DEFAULT_MIN_COMPACTION_RESERVE_TOKENS;
-    const requestedReserve = Math.max(minReserve, Math.floor(contextWindow * 0.2));
-    return Math.min(DEFAULT_COMPACTION_SETTINGS.reserveTokens ?? 16384, requestedReserve, Math.floor(contextWindow * 0.5));
-}
-function estimateMessageTokens(message) {
-    return estimateTokens(message);
-}
-function estimateBranchContextTokens(ctx) {
-    const leafId = ctx.sessionManager.getLeafId();
-    const branch = ctx.sessionManager.getBranch(leafId ?? undefined);
-    const sessionContext = buildSessionContext(branch, leafId);
-    return sessionContext.messages.reduce((tokens, message) => tokens + estimateMessageTokens(message), 0);
-}
-function contextWindowFrom(ctx) {
-    const usageWindow = finitePositive(ctx.getContextUsage()?.contextWindow);
-    if (usageWindow !== undefined)
-        return usageWindow;
-    return finitePositive(ctx.model?.contextWindow) ?? FALLBACK_CONTEXT_WINDOW;
-}
-function baselineContextTokens(ctx) {
-    const usageTokens = finitePositive(ctx.getContextUsage()?.tokens);
-    const estimatedTokens = estimateBranchContextTokens(ctx);
-    return usageTokens === undefined ? estimatedTokens : Math.max(usageTokens, estimatedTokens);
-}
-export function projectAssistantContextGuard(ctx, assistantTokens, options = {}) {
-    const contextWindow = contextWindowFrom(ctx);
-    if (contextWindow <= 0)
-        return undefined;
-    const contextTokens = baselineContextTokens(ctx);
-    const reserveTokens = guardReserveTokens(contextWindow, options);
-    const projectedTokens = contextTokens + assistantTokens + reserveTokens;
-    return {
-        contextTokens,
-        assistantTokens,
-        reserveTokens,
-        contextWindow,
-        projectedTokens,
-        exceedsLimit: projectedTokens > contextWindow,
-    };
-}
-function assistantDeltaChars(event) {
-    if (!event.assistantMessageEvent || typeof event.assistantMessageEvent !== "object")
-        return 0;
-    const assistantEvent = event.assistantMessageEvent;
-    if (typeof assistantEvent.delta === "string")
-        return assistantEvent.delta.length;
-    if (typeof assistantEvent.content === "string")
-        return assistantEvent.content.length;
-    if (assistantEvent.toolCall) {
-        return String(assistantEvent.toolCall.name ?? "").length + JSON.stringify(assistantEvent.toolCall.arguments ?? {}).length;
-    }
-    return 0;
-}
-function replacementAssistantMessage(message) {
-    return {
-        ...message,
-        content: [{ type: "text", text: PIBO_CONTEXT_GUARD_NOTICE }],
-        stopReason: "aborted",
-        errorMessage: undefined,
-    };
-}
-function compactionInstructions(projection) {
-    const usage = projection
-        ? ` Projected context was ${projection.projectedTokens} / ${projection.contextWindow} tokens, including ${projection.assistantTokens} tokens from the interrupted assistant response and ${projection.reserveTokens} reserved tokens for compaction.`
-        : "";
-    return `Pibo interrupted the previous assistant response before persisting the full output because it would exceed the safe context budget.${usage} Summarize the durable conversation up to the guard notice, preserve the user's current task and important recent facts, and leave enough context budget for the next response.`;
-}
-export function createPiboAssistantContextGuardExtension(options = {}, recovery = createPiboAssistantContextGuardRecovery()) {
-    return (pi) => {
-        const state = {
-            deltaChars: 0,
-            tripped: false,
-            compactQueued: false,
-            resumeRequested: false,
-            resumeInProgress: false,
-            resumeSettling: false,
-            recoveryAttempts: 0,
-        };
-        function resetAssistantState() {
-            state.deltaChars = 0;
-            state.tripped = false;
-            state.compactQueued = false;
-            state.lastProjection = undefined;
-        }
-        function clearResumeStartTimer() {
-            if (state.resumeStartTimer === undefined)
-                return;
-            clearTimeout(state.resumeStartTimer);
-            state.resumeStartTimer = undefined;
-        }
-        function resetRecoveryState() {
-            clearResumeStartTimer();
-            state.tripped = false;
-            state.compactQueued = false;
-            state.resumeRequested = false;
-            state.resumeInProgress = false;
-            state.resumeSettling = false;
-            state.recoveryAttempts = 0;
-        }
-        function failRecovery(error) {
-            resetRecoveryState();
-            recovery.fail(error);
-        }
-        recovery.onCancel(resetRecoveryState);
-        function tripIfNeeded(ctx, assistantTokens) {
-            const projection = projectAssistantContextGuard(ctx, assistantTokens, options);
-            state.lastProjection = projection;
-            if (!projection?.exceedsLimit)
-                return false;
-            state.tripped = true;
-            return true;
-        }
-        pi.on("agent_start", () => {
-            if (!state.resumeRequested)
-                return;
-            clearResumeStartTimer();
-            state.resumeRequested = false;
-            state.resumeInProgress = true;
-        });
-        pi.on("agent_settled", () => {
-            if (!state.resumeSettling)
-                return;
-            state.resumeSettling = false;
-            state.recoveryAttempts = 0;
-            recovery.complete();
-        });
-        pi.on("message_start", (event) => {
-            if (event.message.role === "assistant")
-                resetAssistantState();
-        });
-        pi.on("message_update", (event, ctx) => {
-            if (event.message.role !== "assistant")
-                return;
-            state.deltaChars += assistantDeltaChars(event);
-            const assistantTokens = Math.max(estimateMessageTokens(event.message), textTokensByLength(state.deltaChars));
-            if (tripIfNeeded(ctx, assistantTokens))
-                ctx.abort();
-        });
-        pi.on("message_end", (event, ctx) => {
-            if (event.message.role !== "assistant")
-                return;
-            const assistantTokens = Math.max(estimateMessageTokens(event.message), textTokensByLength(state.deltaChars));
-            if (!state.tripped && !tripIfNeeded(ctx, assistantTokens))
-                return;
-            return { message: replacementAssistantMessage(event.message) };
-        });
-        pi.on("agent_end", (_event, ctx) => {
-            if (state.tripped && !state.compactQueued) {
-                if (state.recoveryAttempts >= MAX_CONTEXT_GUARD_RECOVERY_ATTEMPTS) {
-                    failRecovery(new Error(`Context guard recovery exceeded ${MAX_CONTEXT_GUARD_RECOVERY_ATTEMPTS} compaction attempts`));
-                    return;
-                }
-                state.compactQueued = true;
-                state.recoveryAttempts++;
-                recovery.begin();
-                let callbackHandled = false;
-                ctx.compact({
-                    customInstructions: compactionInstructions(state.lastProjection),
-                    onComplete: () => {
-                        if (callbackHandled || !recovery.isPending())
-                            return;
-                        callbackHandled = true;
-                        state.tripped = false;
-                        state.compactQueued = false;
-                        state.resumeRequested = true;
-                        if (recovery.isClaimed()) {
-                            recovery.complete();
-                            return;
-                        }
-                        state.resumeStartTimer = setTimeout(() => {
-                            failRecovery(new Error("Context guard continuation did not start"));
-                        }, 5000);
-                        pi.sendMessage({
-                            customType: PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE,
-                            content: [{ type: "text", text: PIBO_CONTEXT_GUARD_RESUME_PROMPT }],
-                            display: false,
-                        }, { triggerTurn: true });
-                    },
-                    onError: (error) => {
-                        if (callbackHandled || !recovery.isPending())
-                            return;
-                        callbackHandled = true;
-                        failRecovery(error);
-                    },
-                });
-                return;
-            }
-            if (!state.resumeInProgress)
-                return;
-            state.resumeInProgress = false;
-            state.resumeSettling = true;
-        });
-    };
-}

package/dist/core/events.js

@@ -1 +0,0 @@
-export {};

package/dist/core/gateway-resource-guard.js

@@ -1,215 +0,0 @@
-import { execFile } from "node:child_process";
-import { freemem, totalmem } from "node:os";
-import { promisify } from "node:util";
-import { getHeapStatistics } from "node:v8";
-const execFileAsync = promisify(execFile);
-const DEFAULT_POLICY = Object.freeze({
-    mode: "warn",
-    minFreeMemoryBytes: 256 * 1024 * 1024,
-    minHeapAvailableBytes: 64 * 1024 * 1024,
-    maxRssBytes: 1536 * 1024 * 1024,
-    knownDaemonWarningRssBytes: 2 * 1024 * 1024 * 1024,
-});
-export function resolveGatewayResourceGuardPolicy(env = process.env) {
-    return {
-        mode: parseMode(env.PIBO_GATEWAY_RESOURCE_GUARD, DEFAULT_POLICY.mode),
-        minFreeMemoryBytes: parseByteThreshold(env.PIBO_GATEWAY_MIN_FREE_MEMORY_BYTES, DEFAULT_POLICY.minFreeMemoryBytes),
-        minHeapAvailableBytes: parseByteThreshold(env.PIBO_GATEWAY_MIN_HEAP_AVAILABLE_BYTES, DEFAULT_POLICY.minHeapAvailableBytes),
-        maxRssBytes: parseByteThreshold(env.PIBO_GATEWAY_MAX_RSS_BYTES, DEFAULT_POLICY.maxRssBytes),
-        knownDaemonWarningRssBytes: parseByteThreshold(env.PIBO_GATEWAY_KNOWN_DAEMON_WARNING_RSS_BYTES, DEFAULT_POLICY.knownDaemonWarningRssBytes),
-    };
-}
-export function collectGatewayProcessMemory() {
-    const memory = process.memoryUsage();
-    const heap = getHeapStatistics();
-    return {
-        pid: process.pid,
-        rssBytes: memory.rss,
-        heapUsedBytes: memory.heapUsed,
-        heapTotalBytes: memory.heapTotal,
-        heapLimitBytes: heap.heap_size_limit,
-        heapAvailableBytes: Math.max(0, heap.heap_size_limit - memory.heapUsed),
-        externalBytes: memory.external,
-        arrayBuffersBytes: memory.arrayBuffers,
-    };
-}
-export function buildGatewayResourceSnapshot(options = {}) {
-    const policy = resolveGatewayResourceGuardPolicy(options.env);
-    const gateway = collectGatewayProcessMemory();
-    const host = { freeBytes: freemem(), totalBytes: totalmem() };
-    const processResult = processResultFromOptions(gateway.pid, options, policy);
-    const checks = evaluateGatewayResourceChecks({ gateway, host, policy, knownDaemons: processResult.knownDaemons });
-    const severity = maxSeverity(checks.map((check) => check.severity));
-    return {
-        generatedAt: (options.now ?? new Date()).toISOString(),
-        readOnly: true,
-        policy,
-        gateway,
-        host,
-        checks,
-        processes: processResult,
-        severity,
-        guardAction: guardAction(policy, severity),
-        nextCommands: [
-            "pibo debug resources --json",
-            "pibo compute health --json",
-            "pibo debug telemetry sessions --active",
-            "pibo debug runs list <pibo-session-id> --json",
-        ],
-    };
-}
-export async function collectGatewayResourceSnapshot(options = {}) {
-    if (options.includeProcesses === false || options.processListOutput !== undefined || options.processListError !== undefined) {
-        return buildGatewayResourceSnapshot(options);
-    }
-    try {
-        const { stdout } = await execFileAsync("ps", ["-eo", "pid=,ppid=,rss=,comm=,args="], { maxBuffer: 10 * 1024 * 1024 });
-        return buildGatewayResourceSnapshot({ ...options, processListOutput: stdout });
-    }
-    catch (error) {
-        return buildGatewayResourceSnapshot({ ...options, processListError: error instanceof Error ? error.message : String(error) });
-    }
-}
-export function assertGatewayResourceAvailableForWork(workLabel, env = process.env) {
-    const snapshot = buildGatewayResourceSnapshot({ env, includeProcesses: false });
-    if (snapshot.guardAction !== "block")
-        return;
-    const reasons = snapshot.checks.filter((check) => check.severity === "critical").map((check) => check.message).join("; ");
-    throw new Error(`Gateway resource guard blocked ${workLabel} before starting: ${reasons}`);
-}
-export function parseHostProcessResourceList(output, gatewayPid, policy = DEFAULT_POLICY) {
-    const rows = [];
-    for (const line of output.split("\n")) {
-        if (!line.trim())
-            continue;
-        const match = line.match(/^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s*(.*)$/);
-        if (!match)
-            continue;
-        const pid = Number(match[1]);
-        const ppid = Number(match[2]);
-        const rssBytes = Number(match[3]) * 1024;
-        if (!Number.isInteger(pid) || !Number.isInteger(ppid) || !Number.isFinite(rssBytes))
-            continue;
-        const commandName = match[4] ?? "";
-        const args = match[5] ?? "";
-        const daemonLabel = knownDaemonLabel(commandName, args);
-        const kind = pid === gatewayPid ? "gateway" : ppid === gatewayPid ? "child" : daemonLabel ? "known-daemon" : "other";
-        rows.push({ pid, ppid, rssBytes, commandName, args: sanitizeArgsPreview(args), kind, label: daemonLabel });
-    }
-    return rows
-        .filter((row) => row.kind === "gateway" || row.kind === "child" || row.kind === "known-daemon")
-        .sort((a, b) => resourceProcessRank(a, policy) - resourceProcessRank(b, policy) || b.rssBytes - a.rssBytes);
-}
-export function renderGatewayResourceSnapshotText(snapshot) {
-    const lines = [`Gateway resource health: ${snapshot.severity} (guard=${snapshot.policy.mode}, action=${snapshot.guardAction})`];
-    lines.push(`Generated at: ${snapshot.generatedAt}`);
-    lines.push(`Gateway PID: ${snapshot.gateway.pid}`);
-    lines.push(`Gateway memory: rss=${snapshot.gateway.rssBytes} heapUsed=${snapshot.gateway.heapUsedBytes} heapAvailable=${snapshot.gateway.heapAvailableBytes} heapLimit=${snapshot.gateway.heapLimitBytes}`);
-    lines.push(`Host memory: free=${snapshot.host.freeBytes} total=${snapshot.host.totalBytes}`);
-    lines.push(`Thresholds: minFree=${snapshot.policy.minFreeMemoryBytes} minHeapAvailable=${snapshot.policy.minHeapAvailableBytes} maxRss=${snapshot.policy.maxRssBytes} daemonWarnRss=${snapshot.policy.knownDaemonWarningRssBytes}`);
-    lines.push(`Related processes: children=${snapshot.processes.children.length} knownDaemons=${snapshot.processes.knownDaemons.length} processList=${snapshot.processes.available ? "available" : "unavailable"}`);
-    if (snapshot.processes.error)
-        lines.push(`Process list error: ${snapshot.processes.error}`);
-    const visibleProcesses = [...snapshot.processes.children, ...snapshot.processes.knownDaemons].slice(0, 10);
-    if (visibleProcesses.length > 0) {
-        lines.push("PID\tPPID\tRSS_BYTES\tKIND\tLABEL\tCOMMAND");
-        for (const process of visibleProcesses) {
-            lines.push(`${process.pid}\t${process.ppid}\t${process.rssBytes}\t${process.kind}\t${process.label ?? "-"}\t${process.commandName}`);
-        }
-    }
-    lines.push("Checks:");
-    for (const check of snapshot.checks)
-        lines.push(`- [${check.severity}] ${check.id}: ${check.message}`);
-    lines.push("Next commands:");
-    for (const command of snapshot.nextCommands)
-        lines.push(`- ${command}`);
-    return lines.join("\n");
-}
-function evaluateGatewayResourceChecks(input) {
-    const checks = [];
-    if (input.policy.mode === "off") {
-        checks.push({ id: "guard-disabled", severity: "ok", message: "Gateway resource guard is disabled." });
-        return checks;
-    }
-    checks.push(input.host.freeBytes < input.policy.minFreeMemoryBytes
-        ? { id: "host-memory-reserve", severity: "critical", message: `Host free memory ${input.host.freeBytes} is below reserve ${input.policy.minFreeMemoryBytes}.` }
-        : { id: "host-memory-reserve", severity: "ok", message: `Host free memory ${input.host.freeBytes} satisfies reserve ${input.policy.minFreeMemoryBytes}.` });
-    checks.push(input.gateway.heapAvailableBytes < input.policy.minHeapAvailableBytes
-        ? { id: "gateway-heap-reserve", severity: "critical", message: `Gateway heap availability ${input.gateway.heapAvailableBytes} is below reserve ${input.policy.minHeapAvailableBytes}.` }
-        : { id: "gateway-heap-reserve", severity: "ok", message: `Gateway heap availability ${input.gateway.heapAvailableBytes} satisfies reserve ${input.policy.minHeapAvailableBytes}.` });
-    checks.push(input.gateway.rssBytes > input.policy.maxRssBytes
-        ? { id: "gateway-rss-limit", severity: "critical", message: `Gateway RSS ${input.gateway.rssBytes} exceeds limit ${input.policy.maxRssBytes}.` }
-        : { id: "gateway-rss-limit", severity: "ok", message: `Gateway RSS ${input.gateway.rssBytes} is within limit ${input.policy.maxRssBytes}.` });
-    const heavyDaemons = input.knownDaemons.filter((process) => process.rssBytes >= input.policy.knownDaemonWarningRssBytes);
-    if (heavyDaemons.length > 0)
-        checks.push({ id: "known-heavy-daemons", severity: "warning", message: `${heavyDaemons.length} known heavy daemon(s) exceed RSS warning threshold: ${heavyDaemons.map((process) => `${process.label ?? process.commandName}:${process.rssBytes}`).join(", ")}.` });
-    return checks;
-}
-function processResultFromOptions(gatewayPid, options, policy) {
-    if (options.processListError)
-        return { available: false, error: options.processListError, gatewayPid, children: [], knownDaemons: [] };
-    if (options.processListOutput === undefined)
-        return { available: false, gatewayPid, children: [], knownDaemons: [] };
-    const rows = parseHostProcessResourceList(options.processListOutput, gatewayPid, policy);
-    return {
-        available: true,
-        gatewayPid,
-        children: rows.filter((row) => row.kind === "child"),
-        knownDaemons: rows.filter((row) => row.kind === "known-daemon"),
-    };
-}
-function parseMode(value, fallback) {
-    const normalized = value?.trim().toLowerCase();
-    if (normalized === "off" || normalized === "0" || normalized === "false")
-        return "off";
-    if (normalized === "block" || normalized === "strict")
-        return "block";
-    if (normalized === "warn" || normalized === "1" || normalized === "true" || normalized === undefined || normalized === "")
-        return "warn";
-    return fallback;
-}
-function parseByteThreshold(value, fallback) {
-    if (value === undefined || value.trim() === "")
-        return fallback;
-    const parsed = Number(value);
-    return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : fallback;
-}
-function knownDaemonLabel(commandName, args) {
-    const combined = `${commandName} ${args}`;
-    if (/comfyui|main\.py.*--port\s+8188/i.test(combined))
-        return "ComfyUI";
-    if (/unity(\.exe)?|Unity Editor/i.test(combined))
-        return "Unity";
-    return undefined;
-}
-function sanitizeArgsPreview(args) {
-    const redacted = args
-        .replace(/(token|access_token|refresh_token|password|passwd|cookie|secret)=([^\s]+)/gi, "$1=<redacted>")
-        .replace(/(--(?:token|password|cookie|secret))\s+([^\s]+)/gi, "$1 <redacted>");
-    return redacted.length > 220 ? `${redacted.slice(0, 217)}...` : redacted;
-}
-function resourceProcessRank(process, policy) {
-    if (process.kind === "gateway")
-        return 0;
-    if (process.kind === "child")
-        return 1;
-    if (process.rssBytes >= policy.knownDaemonWarningRssBytes)
-        return 2;
-    return 3;
-}
-function guardAction(policy, severity) {
-    if (policy.mode === "off")
-        return "allow";
-    if (policy.mode === "block" && severity === "critical")
-        return "block";
-    if (severity === "warning" || severity === "critical")
-        return "warn";
-    return "allow";
-}
-function maxSeverity(values) {
-    if (values.includes("critical"))
-        return "critical";
-    if (values.includes("warning"))
-        return "warning";
-    return "ok";
-}

package/dist/core/model-defaults.js

@@ -1,95 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { piboHomePath } from "./pibo-home.js";
-import { isPiboThinkingLevel } from "./thinking.js";
-export const DEFAULT_PIBO_MODEL_DEFAULTS_PATH = "model-defaults.json";
-export function selectRequestedModelProfile(profile, defaults = {}) {
-    if (profile.model)
-        return cloneModelProfile(profile.model);
-    if (profile.parentSessionId)
-        return cloneModelProfile(profile.subagentModel ?? defaults.subagent);
-    return cloneModelProfile(profile.mainModel ?? defaults.main);
-}
-export function selectRequestedThinkingLevel(profile, defaults = {}) {
-    if (profile.parentSessionId)
-        return profile.subagentThinkingLevel ?? profile.thinkingLevel ?? defaults.subagentThinking ?? defaults.thinking;
-    return profile.mainThinkingLevel ?? profile.thinkingLevel ?? defaults.mainThinking ?? defaults.thinking;
-}
-export function selectRequestedFastMode(profile, defaults = {}) {
-    if (profile.parentSessionId)
-        return profile.subagentFast ?? profile.fast ?? defaults.subagentFast ?? defaults.fast;
-    return profile.mainFast ?? profile.fast ?? defaults.mainFast ?? defaults.fast;
-}
-export function loadPiboModelDefaults(cwd = process.cwd(), path) {
-    const resolvedPath = path ? resolve(cwd, path) : piboHomePath(DEFAULT_PIBO_MODEL_DEFAULTS_PATH);
-    if (!existsSync(resolvedPath))
-        return {};
-    try {
-        const parsed = JSON.parse(readFileSync(resolvedPath, "utf-8"));
-        return sanitizePiboModelDefaults(parsed);
-    }
-    catch {
-        return {};
-    }
-}
-export function savePiboModelDefaults(defaults, cwd = process.cwd(), path) {
-    const sanitized = sanitizePiboModelDefaults(defaults);
-    const resolvedPath = path ? resolve(cwd, path) : piboHomePath(DEFAULT_PIBO_MODEL_DEFAULTS_PATH);
-    mkdirSync(dirname(resolvedPath), { recursive: true });
-    writeFileSync(resolvedPath, `${JSON.stringify(sanitized, null, 2)}\n`);
-    return sanitized;
-}
-export function sanitizePiboModelDefaults(value) {
-    const raw = value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : {};
-    const sanitized = {};
-    const main = sanitizeModelProfile(raw.main);
-    const subagent = sanitizeModelProfile(raw.subagent);
-    const thinking = sanitizeThinkingLevel(raw.thinking);
-    const mainThinking = sanitizeThinkingLevel(raw.mainThinking);
-    const subagentThinking = sanitizeThinkingLevel(raw.subagentThinking);
-    const fast = sanitizeBoolean(raw.fast);
-    const mainFast = sanitizeBoolean(raw.mainFast);
-    const subagentFast = sanitizeBoolean(raw.subagentFast);
-    if (main)
-        sanitized.main = main;
-    if (subagent)
-        sanitized.subagent = subagent;
-    if (thinking)
-        sanitized.thinking = thinking;
-    if (mainThinking)
-        sanitized.mainThinking = mainThinking;
-    if (subagentThinking)
-        sanitized.subagentThinking = subagentThinking;
-    if (fast !== undefined)
-        sanitized.fast = fast;
-    if (mainFast !== undefined)
-        sanitized.mainFast = mainFast;
-    if (subagentFast !== undefined)
-        sanitized.subagentFast = subagentFast;
-    return sanitized;
-}
-export function sanitizeThinkingLevel(value) {
-    if (typeof value !== "string")
-        return undefined;
-    return isPiboThinkingLevel(value) ? value : undefined;
-}
-export function sanitizeModelProfile(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return undefined;
-    const raw = value;
-    if (typeof raw.provider !== "string" || typeof raw.id !== "string")
-        return undefined;
-    const provider = raw.provider.trim();
-    const id = raw.id.trim();
-    if (!provider || !id)
-        return undefined;
-    return { provider, id };
-}
-function cloneModelProfile(model) {
-    return model ? { ...model } : undefined;
-}
-function sanitizeBoolean(value) {
-    return typeof value === "boolean" ? value : undefined;
-}

package/dist/core/pibo-home.js

@@ -1,8 +0,0 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-export function getPiboHome() {
-    return process.env.PIBO_HOME || join(homedir(), ".pibo");
-}
-export function piboHomePath(...segments) {
-    return join(getPiboHome(), ...segments);
-}