@pasko70/pibo 1.9.7 → 1.9.9

package/dist/plugins/builtin.js

@@ -1,478 +0,0 @@
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createPiboGatewayToolProfiles } from "../gateway/tool.js";
-import { InitialSessionContextBuilder } from "../core/profiles.js";
-import { parsePiboThinkingLevel } from "../core/thinking.js";
-import { createWebSearchToolProfile } from "../tools/web-search.js";
-import { createRuntimeToolProfile } from "../tools/runtime/tool.js";
-import { completeLogin, getLoginStatus, removeLogin, setApiKey, startLogin } from "../auth/login-actions.js";
-import { loadModelCatalog } from "../apps/chat/model-catalog.js";
-import { piboCodexCompatPlugin } from "./codex-compat.js";
-import { addPiboNativeToolingContext, registerPiboNativeTooling } from "./native-tooling.js";
-import { piboWebAnnotationsPlugin } from "./web-annotations.js";
-import { definePiboPlugin, PiboPluginRegistry } from "./registry.js";
-export const DEFAULT_PIBO_PROFILE_NAME = "base";
-const GATEWAY_PROFILE_TOOLS = ["pibo_gateway_send"];
-const PIBO_PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
-function builtinSkillPath(name) {
-    return resolve(PIBO_PACKAGE_ROOT, "skills", "builtin", name, "SKILL.md");
-}
-const LOGIN_PROVIDERS = [
-    { id: "openai-codex", name: "OpenAI (ChatGPT Plus/Pro)", authMethods: ["device_code"] },
-    { id: "openai", name: "OpenAI API", authMethods: ["api_key"] },
-    { id: "anthropic", name: "Anthropic", authMethods: ["api_key"] },
-    { id: "kimi-coding", name: "Kimi for Coding", authMethods: ["api_key"] },
-    { id: "google", name: "Google Gemini", authMethods: ["api_key"] },
-    { id: "groq", name: "Groq", authMethods: ["api_key"] },
-    { id: "ollama", name: "Ollama", authMethods: ["api_key"] },
-];
-function getObjectParams(event) {
-    const params = "params" in event ? event.params : undefined;
-    if (!params || typeof params !== "object" || Array.isArray(params))
-        return undefined;
-    return params;
-}
-function requireForkParams(event) {
-    const params = getObjectParams(event);
-    if (!params || typeof params.entryId !== "string" || params.entryId.length === 0) {
-        throw new Error("session.fork requires params.entryId");
-    }
-    return { entryId: params.entryId };
-}
-function requireTreeNavigateParams(event) {
-    const raw = getObjectParams(event);
-    if (!raw || typeof raw.entryId !== "string" || raw.entryId.length === 0) {
-        throw new Error("session.tree_navigate requires params.entryId");
-    }
-    const params = { entryId: raw.entryId };
-    if (typeof raw.summarize === "boolean")
-        params.summarize = raw.summarize;
-    if (typeof raw.customInstructions === "string")
-        params.customInstructions = raw.customInstructions;
-    if (typeof raw.replaceInstructions === "boolean")
-        params.replaceInstructions = raw.replaceInstructions;
-    if (typeof raw.label === "string")
-        params.label = raw.label;
-    return params;
-}
-function requireSwitchParams(event) {
-    const raw = getObjectParams(event);
-    if (!raw || typeof raw.sessionFile !== "string" || raw.sessionFile.length === 0) {
-        throw new Error("session.switch requires params.sessionFile");
-    }
-    const params = { sessionFile: raw.sessionFile };
-    if (typeof raw.cwdOverride === "string")
-        params.cwdOverride = raw.cwdOverride;
-    return params;
-}
-function getThinkingParams(event) {
-    const raw = getObjectParams(event);
-    if (!raw || raw.level === undefined)
-        return {};
-    if (typeof raw.level !== "string")
-        throw new Error("thinking requires params.level to be a string");
-    return { level: parsePiboThinkingLevel(raw.level) };
-}
-function requireLoginStartParams(event) {
-    const params = getObjectParams(event);
-    if (!params || typeof params.provider !== "string" || params.provider.length === 0) {
-        throw new Error("login.start requires params.provider");
-    }
-    return { provider: params.provider };
-}
-function requireLoginCompleteParams(event) {
-    const params = getObjectParams(event);
-    if (!params || typeof params.provider !== "string" || params.provider.length === 0) {
-        throw new Error("login.complete requires params.provider");
-    }
-    if (params.code !== undefined && typeof params.code !== "string") {
-        throw new Error("login.complete params.code must be a string when provided");
-    }
-    if (typeof params.state !== "string" || params.state.length === 0) {
-        throw new Error("login.complete requires params.state");
-    }
-    return { provider: params.provider, code: params.code, state: params.state };
-}
-function requireLoginApiKeyParams(event) {
-    const params = getObjectParams(event);
-    if (!params || typeof params.provider !== "string" || params.provider.length === 0) {
-        throw new Error("login.apikey requires params.provider");
-    }
-    if (typeof params.apiKey !== "string" || params.apiKey.length === 0) {
-        throw new Error("login.apikey requires params.apiKey");
-    }
-    return { provider: params.provider, apiKey: params.apiKey };
-}
-function requireLogoutParams(event) {
-    const params = getObjectParams(event);
-    if (!params || typeof params.provider !== "string" || params.provider.length === 0) {
-        throw new Error("logout requires params.provider");
-    }
-    return { provider: params.provider };
-}
-function createBaseProfileBuilder(profileName, context) {
-    return addPiboNativeToolingContext(new InitialSessionContextBuilder(profileName)
-        .addSkill(context.getSkill("pi-agent-harness")), context);
-}
-export const piboCorePlugin = definePiboPlugin({
-    id: "pibo.core",
-    name: "Pibo Core",
-    register(api) {
-        api.registerSkill({
-            name: "pi-agent-harness",
-            path: builtinSkillPath("pi-agent-harness"),
-            kind: "builtin",
-        });
-        api.registerSkill({
-            name: "pibo-spec-writing",
-            path: builtinSkillPath("pibo-spec-writing"),
-            kind: "builtin",
-        });
-        api.registerSkill({
-            name: "pibo-docker-system",
-            path: builtinSkillPath("pibo-docker-system"),
-            kind: "builtin",
-        });
-        api.registerSkill({
-            name: "graphify",
-            path: builtinSkillPath("graphify"),
-            kind: "builtin",
-        });
-        api.registerSkill({
-            name: "prd",
-            path: builtinSkillPath("prd"),
-            kind: "builtin",
-        });
-        api.registerSkill({
-            name: "skill-creator",
-            path: builtinSkillPath("skill-creator"),
-            kind: "builtin",
-        });
-        api.registerSkill({
-            name: "ralph-loop",
-            path: builtinSkillPath("ralph-loop"),
-            kind: "builtin",
-        });
-        api.registerSkill({
-            name: "ralph-prd-json",
-            path: builtinSkillPath("ralph-prd-json"),
-            kind: "builtin",
-        });
-        api.registerTool(createWebSearchToolProfile());
-        api.registerTool(createRuntimeToolProfile());
-        registerPiboNativeTooling(api);
-        api.registerProfile({
-            name: DEFAULT_PIBO_PROFILE_NAME,
-            description: "Base agent with only the four Pi built-in tools.",
-            create() {
-                return new InitialSessionContextBuilder(DEFAULT_PIBO_PROFILE_NAME)
-                    .withBuiltinToolNames(["read", "bash", "edit", "write"])
-                    .createSession();
-            },
-        });
-        api.registerGatewayAction({
-            name: "status",
-            description: "Return current session status with context usage quota.",
-            slashCommands: ["status"],
-            async execute(context) {
-                const providerUsage = await context.getProviderUsage();
-                return {
-                    ...context.getStatus(),
-                    activeModel: context.getActiveModel(),
-                    contextUsage: context.getContextUsage(),
-                    ...(providerUsage ? { providerUsage } : {}),
-                };
-            },
-        });
-        api.registerGatewayAction({
-            name: "compact",
-            description: "Manually compact the session context.",
-            slashCommands: ["compact"],
-            async execute(context, event) {
-                const params = getObjectParams(event);
-                const customInstructions = typeof params?.customInstructions === "string" ? params.customInstructions : undefined;
-                return await context.compact(customInstructions);
-            },
-        });
-        api.registerGatewayAction({
-            name: "session_id",
-            description: "Return the routed Pibo session id.",
-            slashCommands: ["session"],
-            execute(context) {
-                return { piboSessionId: context.piboSessionId };
-            },
-        });
-        api.registerGatewayAction({
-            name: "clear_queue",
-            description: "Clear queued messages that have not started yet.",
-            slashCommands: ["clear"],
-            execute(context) {
-                return { cleared: context.clearQueue() };
-            },
-        });
-        api.registerGatewayAction({
-            name: "abort",
-            description: "Abort the active Pi agent run.",
-            slashCommands: ["abort"],
-            async execute(context) {
-                await context.abort();
-                return { aborted: true };
-            },
-        });
-        api.registerGatewayAction({
-            name: "kill",
-            description: "Kill the active agent run and all subagent sessions recursively.",
-            slashCommands: ["kill"],
-            async execute(context) {
-                return await context.kill();
-            },
-        });
-        api.registerGatewayAction({
-            name: "kill_all",
-            description: "Kill the active agent run, all subagent sessions recursively, and all yielded runs.",
-            slashCommands: ["kill-all"],
-            async execute(context) {
-                return await context.killAll();
-            },
-        });
-        api.registerGatewayAction({
-            name: "dispose",
-            description: "Dispose the routed session runtime.",
-            hidden: true,
-            async execute(context) {
-                await context.dispose();
-                return { disposed: true };
-            },
-        });
-        api.registerGatewayAction({
-            name: "thinking",
-            description: "Show or set the routed Pi thinking level.",
-            slashCommands: ["thinking"],
-            execute(context, event) {
-                const params = getThinkingParams(event);
-                if (!params.level)
-                    return { ...context.getThinkingLevel(), action: "show_thinking_menu" };
-                const previousLevel = context.getThinkingLevel().level;
-                const result = context.setThinkingLevel(params.level);
-                return {
-                    ...result,
-                    action: "set_thinking_level",
-                    previousLevel,
-                    changed: previousLevel !== result.level,
-                };
-            },
-        });
-        api.registerGatewayAction({
-            name: "fast_mode",
-            description: "Toggle OpenAI priority service tier for fast-capable reasoning models.",
-            slashCommands: ["fast"],
-            execute(context) {
-                const current = context.getFastMode();
-                if (!current.supported)
-                    return { ...current, changed: false };
-                return context.setFastMode(current.mode !== "fast");
-            },
-        });
-        api.registerGatewayAction({
-            name: "session.current",
-            description: "Return the active Pi session metadata for this routed session.",
-            slashCommands: ["session-current"],
-            execute(context) {
-                return context.getCurrentSession();
-            },
-        });
-        api.registerGatewayAction({
-            name: "session.list",
-            description: "List persisted Pi sessions for this workspace.",
-            slashCommands: ["sessions"],
-            execute(context) {
-                return context.listSessions();
-            },
-        });
-        api.registerGatewayAction({
-            name: "session.fork_candidates",
-            description: "Return user messages that can be used as fork targets.",
-            slashCommands: ["fork-candidates"],
-            execute(context) {
-                return { messages: context.getForkCandidates() };
-            },
-        });
-        api.registerGatewayAction({
-            name: "session.fork",
-            description: "Fork before a selected user message and create a visible Pibo session for the fork.",
-            async execute(context, event) {
-                const params = requireForkParams(event);
-                return await context.forkSession(params.entryId);
-            },
-        });
-        api.registerGatewayAction({
-            name: "session.clone",
-            description: "Clone the current leaf and create a visible Pibo session for the clone.",
-            slashCommands: ["clone"],
-            execute(context) {
-                return context.cloneSession();
-            },
-        });
-        api.registerGatewayAction({
-            name: "session.tree",
-            description: "Return the current Pi session tree and active leaf.",
-            slashCommands: ["tree"],
-            execute(context) {
-                return context.getSessionTree();
-            },
-        });
-        api.registerGatewayAction({
-            name: "session.tree_navigate",
-            description: "Move the current Pi session leaf to a selected tree entry.",
-            async execute(context, event) {
-                return await context.navigateSessionTree(requireTreeNavigateParams(event));
-            },
-        });
-        api.registerGatewayAction({
-            name: "session.switch",
-            description: "Switch the active Pi session to a persisted session file.",
-            async execute(context, event) {
-                return await context.switchSession(requireSwitchParams(event));
-            },
-        });
-        api.registerGatewayAction({
-            name: "login",
-            description: "Open the interactive provider login menu.",
-            slashCommands: ["login"],
-            execute() {
-                const statuses = new Map(getLoginStatus().map((status) => [status.id, status.configured]));
-                return {
-                    action: "show_login_menu",
-                    providers: LOGIN_PROVIDERS.map((provider) => ({
-                        ...provider,
-                        authMethods: [...provider.authMethods],
-                        configured: statuses.get(provider.id) ?? false,
-                    })),
-                };
-            },
-        });
-        api.registerGatewayAction({
-            name: "model",
-            description: "Open the interactive model selector for authenticated providers.",
-            slashCommands: ["model", "models"],
-            async execute() {
-                const catalog = await loadModelCatalog(process.cwd());
-                return {
-                    action: "show_model_menu",
-                    providers: catalog.providers
-                        .filter((provider) => provider.authConfigured)
-                        .map((provider) => ({
-                        ...provider,
-                        models: provider.models.filter((model) => model.authConfigured !== false),
-                    })),
-                };
-            },
-        });
-        api.registerGatewayAction({
-            name: "login.start",
-            description: "Start an OAuth login flow for a provider. Returns a URL to open in a browser.",
-            slashCommands: [],
-            async execute(_context, event) {
-                const params = requireLoginStartParams(event);
-                return await startLogin(params.provider);
-            },
-        });
-        api.registerGatewayAction({
-            name: "login.complete",
-            description: "Complete an OAuth login flow with the authorization code from the provider callback.",
-            slashCommands: [],
-            async execute(_context, event) {
-                const params = requireLoginCompleteParams(event);
-                return await completeLogin(params.provider, params.code, params.state);
-            },
-        });
-        api.registerGatewayAction({
-            name: "login.apikey",
-            description: "Set an API key directly for a provider.",
-            slashCommands: [],
-            execute(_context, event) {
-                const params = requireLoginApiKeyParams(event);
-                return setApiKey(params.provider, params.apiKey);
-            },
-        });
-        api.registerGatewayAction({
-            name: "login.status",
-            description: "Check the authentication status for providers.",
-            slashCommands: [],
-            execute(_context, event) {
-                const params = getObjectParams(event);
-                const provider = typeof params?.provider === "string" ? params.provider : undefined;
-                return { providers: getLoginStatus(provider) };
-            },
-        });
-        api.registerGatewayAction({
-            name: "logout",
-            description: "Remove stored credentials for a provider.",
-            slashCommands: [],
-            execute(_context, event) {
-                const params = requireLogoutParams(event);
-                return removeLogin(params.provider);
-            },
-        });
-    },
-});
-export const piboGatewayProducerPlugin = definePiboPlugin({
-    id: "pibo.gateway-producer",
-    name: "Pibo Gateway Producer",
-    register(api) {
-        api.registerTools(createPiboGatewayToolProfiles());
-        api.registerProfile({
-            name: "pibo-gateway-producer",
-            aliases: ["gateway-producer"],
-            description: "Pibo profile that can send messages through the local gateway.",
-            create(context) {
-                return createBaseProfileBuilder("pibo-gateway-producer", context)
-                    .addTools(context.getTools(GATEWAY_PROFILE_TOOLS))
-                    .createSession();
-            },
-        });
-    },
-});
-export function createDefaultPiboPlugins() {
-    return [piboCorePlugin, piboCodexCompatPlugin, piboWebAnnotationsPlugin];
-}
-export function createGatewayProducerPiboPluginRegistry() {
-    return PiboPluginRegistry.create({
-        plugins: [piboCorePlugin, piboGatewayProducerPlugin, piboCodexCompatPlugin, piboWebAnnotationsPlugin],
-    });
-}
-export function createDefaultPiboPluginRegistry() {
-    return PiboPluginRegistry.create({ plugins: createDefaultPiboPlugins() });
-}
-export function selectDefaultPiboProfileName(registry) {
-    const names = registry.getProfileNames();
-    return names.includes(DEFAULT_PIBO_PROFILE_NAME) ? DEFAULT_PIBO_PROFILE_NAME : names[0] ?? DEFAULT_PIBO_PROFILE_NAME;
-}
-export function createDefaultPiboProfile() {
-    return new InitialSessionContextBuilder(DEFAULT_PIBO_PROFILE_NAME)
-        .withBuiltinToolNames(["read", "bash", "edit", "write"])
-        .createSession();
-}
-export function resolvePiboProfileNameFromRegistryOrDefault(registry, profileName) {
-    const requestedProfileName = profileName ?? selectDefaultPiboProfileName(registry);
-    try {
-        return registry.resolveProfileName(requestedProfileName);
-    }
-    catch (error) {
-        if (requestedProfileName === DEFAULT_PIBO_PROFILE_NAME)
-            return DEFAULT_PIBO_PROFILE_NAME;
-        if (requestedProfileName === "default")
-            return selectDefaultPiboProfileName(registry);
-        throw error;
-    }
-}
-export function createPiboProfileFromRegistryOrDefault(registry, profileName) {
-    const resolvedProfileName = resolvePiboProfileNameFromRegistryOrDefault(registry, profileName);
-    if (resolvedProfileName === DEFAULT_PIBO_PROFILE_NAME && !registry.getProfileNames().includes(DEFAULT_PIBO_PROFILE_NAME)) {
-        return createDefaultPiboProfile();
-    }
-    return registry.createProfile(resolvedProfileName);
-}
-export function createGatewayProducerPiboProfile() {
-    return createGatewayProducerPiboPluginRegistry().createProfile("pibo-gateway-producer");
-}

package/dist/plugins/chat-custom-agents.js

@@ -1,20 +0,0 @@
-import { createCustomAgentProfileDefinition } from "../apps/chat/agent-profiles.js";
-import { CustomAgentStore, createDefaultCustomAgentStore } from "../apps/chat/agent-store.js";
-import { definePiboPlugin } from "./registry.js";
-export function createPiboChatCustomAgentProfilesPlugin(options = {}) {
-    return definePiboPlugin({
-        id: "pibo.chat-custom-agent-profiles",
-        name: "Pibo Chat Custom Agent Profiles",
-        register(api) {
-            const store = options.agentStorePath ? new CustomAgentStore(options.agentStorePath) : createDefaultCustomAgentStore();
-            try {
-                for (const agent of store.list()) {
-                    api.upsertProfile(createCustomAgentProfileDefinition(agent));
-                }
-            }
-            finally {
-                store.close();
-            }
-        },
-    });
-}

package/dist/plugins/chat-user-skills.js

@@ -1,41 +0,0 @@
-import os from "node:os";
-import { ScopedUserSkillManager } from "../user-skills/manager.js";
-import { definePiboPlugin } from "./registry.js";
-export function createPiboChatUserSkillsPlugin(options = {}) {
-    return definePiboPlugin({
-        id: "pibo.chat-user-skills",
-        name: "Pibo Chat User Skills",
-        register(api) {
-            const manager = new ScopedUserSkillManager({
-                globalRoot: options.globalRoot ?? os.homedir(),
-                workspaceRoot: options.workspaceRoot ?? process.cwd(),
-            });
-            const userSkills = [];
-            for (const [scope, scopedManager] of [["global", manager.global], ["workspace", manager.workspace]]) {
-                try {
-                    userSkills.push(...scopedManager.list());
-                }
-                catch (error) {
-                    console.warn(`[pibo] Skipping ${scope} startup user-skill registration: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-            const enabledSkillByName = new Map();
-            for (const skill of userSkills) {
-                if (!skill.enabled)
-                    continue;
-                const existing = enabledSkillByName.get(skill.name);
-                if (!existing || skill.scope === "workspace")
-                    enabledSkillByName.set(skill.name, skill);
-            }
-            for (const skill of enabledSkillByName.values()) {
-                try {
-                    api.registerSkill({ name: skill.name, path: skill.path, enabled: true, kind: "user" });
-                }
-                catch (error) {
-                    if (!(error instanceof Error) || error.message !== `Duplicate skill "${skill.name}"`)
-                        throw error;
-                }
-            }
-        },
-    });
-}

package/dist/plugins/chat-vscode-web.js

@@ -1,28 +0,0 @@
-import { definePiboPlugin } from "./registry.js";
-import { isVscodeAppPath, responseBuiltVscodeAsset, responseVscodeAppShell } from "../apps/chat/static-assets.js";
-import { responseJson } from "../web/http.js";
-const CHAT_VSCODE_WEB_APP_NAME = "pibo.chat-vscode-web";
-export const CHAT_VSCODE_MOUNT_PATH = "/apps/chat-vscode";
-export function createPiboChatVscodeWebPlugin() {
-    return definePiboPlugin({
-        id: "pibo.chat-vscode-web",
-        name: "Pibo Chat VS Code Web",
-        register(api) {
-            api.registerWebApp({
-                name: CHAT_VSCODE_WEB_APP_NAME,
-                mountPath: CHAT_VSCODE_MOUNT_PATH,
-                apiPrefix: CHAT_VSCODE_MOUNT_PATH,
-                async handleRequest(request) {
-                    const url = new URL(request.url);
-                    const builtAsset = responseBuiltVscodeAsset(request, url.pathname);
-                    if (builtAsset)
-                        return builtAsset;
-                    if (isVscodeAppPath(url.pathname) && request.method === "GET") {
-                        return responseVscodeAppShell();
-                    }
-                    return responseJson({ error: "Not found" }, { status: 404 });
-                },
-            });
-        },
-    });
-}

package/dist/plugins/chat-web.js

@@ -1,11 +0,0 @@
-import { createChatWebApp } from "../apps/chat/web-app.js";
-import { definePiboPlugin } from "./registry.js";
-export function createPiboChatWebPlugin(options = {}) {
-    return definePiboPlugin({
-        id: "pibo.chat-web",
-        name: "Pibo Chat Web",
-        register(api) {
-            api.registerWebApp(createChatWebApp(options));
-        },
-    });
-}

package/dist/plugins/codex-compat.js

@@ -1,33 +0,0 @@
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createCodexImageGenerationToolProfile } from "../tools/codex-image-generation.js";
-import { definePiboPlugin } from "./registry.js";
-const CODEX_COMPAT_REGISTERED_TOOL_NAMES = [
-    "apply_patch",
-    "view_image",
-];
-const CODEX_BASE_PROMPT_CONTEXT_FILE_KEY = "Codex Base Prompt";
-const PROJECT_ROOT = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
-const CODEX_BASE_PROMPT_CONTEXT_FILE_PATH = resolve(PROJECT_ROOT, "context/codex-base-prompt.md");
-const toolDescriptions = {
-    apply_patch: "Applies a Codex-style patch to workspace files.",
-    view_image: "Reads a local image path and returns it for visual inspection.",
-};
-export const piboCodexCompatPlugin = definePiboPlugin({
-    id: "pibo.codex-compat",
-    name: "Pibo Codex Compatibility",
-    register(api) {
-        for (const name of CODEX_COMPAT_REGISTERED_TOOL_NAMES) {
-            api.registerTool({
-                name,
-                description: toolDescriptions[name],
-            });
-        }
-        api.registerTool(createCodexImageGenerationToolProfile());
-        api.registerContextFile({
-            key: CODEX_BASE_PROMPT_CONTEXT_FILE_KEY,
-            label: "Codex Base Prompt",
-            path: CODEX_BASE_PROMPT_CONTEXT_FILE_PATH,
-        });
-    },
-});