@pasko70/pibo 1.1.0 → 1.2.0

package/dist/local/extension.js

@@ -21,7 +21,6 @@ const BLOCKED_PI_TUI_COMMANDS = new Set([
     "login",
     "logout",
     "new",
-    "compact",
     "reload",
     "debug",
     "resume",
@@ -196,10 +195,14 @@ function isThinkingResult(value) {
     return typeof candidate.level === "string" && typeof candidate.supported === "boolean";
 }
 function createExecutionParams(slashCommand, args = "") {
-    if (slashCommand !== "/thinking")
-        return undefined;
-    const level = args.trim();
-    return level ? { level: parsePiboThinkingLevel(level) } : undefined;
+    const trimmedArgs = args.trim();
+    if (slashCommand === "/thinking") {
+        const level = trimmedArgs.split(/\s+/, 1)[0];
+        return level ? { level: parsePiboThinkingLevel(level) } : undefined;
+    }
+    if (slashCommand === "/compact")
+        return trimmedArgs ? { customInstructions: trimmedArgs } : undefined;
+    return undefined;
 }
 function formatExecutionResult(event) {
     if (event.action === "status" && isSessionStatus(event.result)) {

package/dist/plugins/builtin.js

@@ -1,11 +1,31 @@
+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 RUN_YIELD_QA_SUBAGENTS = ["qa-researcher", "qa-reviewer"];
+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))
@@ -53,9 +73,46 @@ function getThinkingParams(event) {
         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 new InitialSessionContextBuilder(profileName)
-        .addSkill(context.getSkill("pi-agent-harness"));
+    return addPiboNativeToolingContext(new InitialSessionContextBuilder(profileName)
+        .addSkill(context.getSkill("pi-agent-harness")), context);
 }
 export const piboCorePlugin = definePiboPlugin({
     id: "pibo.core",
@@ -63,58 +120,73 @@ export const piboCorePlugin = definePiboPlugin({
     register(api) {
         api.registerSkill({
             name: "pi-agent-harness",
-            path: "skills/builtin/pi-agent-harness/SKILL.md",
+            path: builtinSkillPath("pi-agent-harness"),
             kind: "builtin",
         });
-        api.registerTool(createWebSearchToolProfile());
-        api.registerSubagents([
-            {
-                name: "qa-researcher",
-                description: "QA helper subagent for run-yield testing. Use it for small research or inspection tasks.",
-                targetProfile: "pibo-minimal",
-            },
-            {
-                name: "qa-reviewer",
-                description: "QA reviewer subagent for run-yield testing. Use it for independent review or validation tasks.",
-                targetProfile: "pibo-minimal",
-            },
-        ]);
-        api.registerProfile({
-            name: "pibo-minimal",
-            aliases: ["minimal"],
-            description: "Minimal pibo profile with the harness skill.",
-            create(context) {
-                return createBaseProfileBuilder("pibo-minimal", context)
-                    .createSession();
-            },
+        api.registerSkill({
+            name: "pibo-spec-writing",
+            path: builtinSkillPath("pibo-spec-writing"),
+            kind: "builtin",
         });
-        api.registerProfile({
-            name: "pibo-run-yield-qa",
-            aliases: ["run-yield-qa", "yield-qa"],
-            description: "QA profile with two simple subagents for testing yielded run control.",
-            create(context) {
-                return createBaseProfileBuilder("pibo-run-yield-qa", context)
-                    .withToolPackages({ runControl: true })
-                    .addSubagents(context.getSubagents(RUN_YIELD_QA_SUBAGENTS))
-                    .createSession();
-            },
+        api.registerSkill({
+            name: "pibo-docker-system",
+            path: builtinSkillPath("pibo-docker-system"),
+            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: "pibo-kimi-coding",
-            aliases: ["kimi", "kimi-coding"],
-            description: "Pibo profile pinned to Kimi For Coding. Requires KIMI_API_KEY or configured kimi-coding auth.",
-            create(context) {
-                return createBaseProfileBuilder("pibo-kimi-coding", context)
-                    .withModel({ provider: "kimi-coding", id: "kimi-for-coding" })
+            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.",
+            description: "Return current session status with context usage quota.",
             slashCommands: ["status"],
-            execute(context) {
-                return context.getStatus();
+            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({
@@ -142,6 +214,22 @@ export const piboCorePlugin = definePiboPlugin({
                 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.",
@@ -153,11 +241,22 @@ export const piboCorePlugin = definePiboPlugin({
         });
         api.registerGatewayAction({
             name: "thinking",
-            description: "Cycle or set the routed Pi thinking level.",
+            description: "Show or set the routed Pi thinking level.",
             slashCommands: ["thinking"],
             execute(context, event) {
                 const params = getThinkingParams(event);
-                return params.level ? context.setThinkingLevel(params.level) : context.cycleThinkingLevel();
+                return params.level ? context.setThinkingLevel(params.level) : context.getThinkingLevel();
+            },
+        });
+        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({
@@ -222,6 +321,85 @@ export const piboCorePlugin = definePiboPlugin({
                 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({
@@ -242,18 +420,42 @@ export const piboGatewayProducerPlugin = definePiboPlugin({
     },
 });
 export function createDefaultPiboPlugins() {
-    return [piboCorePlugin, piboCodexCompatPlugin];
+    return [piboCorePlugin, piboCodexCompatPlugin, piboWebAnnotationsPlugin];
 }
 export function createGatewayProducerPiboPluginRegistry() {
     return PiboPluginRegistry.create({
-        plugins: [piboCorePlugin, piboGatewayProducerPlugin, piboCodexCompatPlugin],
+        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 createDefaultPiboPluginRegistry().createProfile("pibo-minimal");
+    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;
+        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-vscode-web.js

@@ -0,0 +1,28 @@
+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/codex-compat.js

@@ -1,17 +1,10 @@
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { InitialSessionContextBuilder } from "../core/profiles.js";
 import { definePiboPlugin } from "./registry.js";
-const CODEX_COMPAT_TOOL_NAMES = [
-    "apply_patch",
-    "web_search",
-    "view_image",
-];
 const CODEX_COMPAT_REGISTERED_TOOL_NAMES = [
     "apply_patch",
     "view_image",
 ];
-const CODEX_COMPAT_SUBAGENTS = ["default", "explorer", "worker"];
 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");
@@ -34,39 +27,5 @@ export const piboCodexCompatPlugin = definePiboPlugin({
             label: "Codex Base Prompt",
             path: CODEX_BASE_PROMPT_CONTEXT_FILE_PATH,
         });
-        api.registerSubagents([
-            {
-                name: "default",
-                description: "General delegated Codex-compatible child agent.",
-                targetProfile: "codex-compat-openai-web",
-            },
-            {
-                name: "explorer",
-                description: "Read-focused delegated agent for scoped codebase questions.",
-                targetProfile: "codex-compat-openai-web",
-            },
-            {
-                name: "worker",
-                description: "Execution-focused delegated agent for bounded implementation work.",
-                targetProfile: "codex-compat-openai-web",
-            },
-        ]);
-        api.registerProfile({
-            name: "codex-compat-openai-web",
-            aliases: ["codex"],
-            description: "Codex-compatible Pibo profile with native provider-backed web_search.",
-            create(context) {
-                return new InitialSessionContextBuilder("codex-compat-openai-web")
-                    .withBuiltinToolNames(["read", "edit", "write"])
-                    .withToolPackages({
-                    codexCompat: true,
-                    runControl: true,
-                })
-                    .addTools(context.getTools(CODEX_COMPAT_TOOL_NAMES))
-                    .addSubagents(context.getSubagents(CODEX_COMPAT_SUBAGENTS))
-                    .addContextFile(context.getContextFile(CODEX_BASE_PROMPT_CONTEXT_FILE_KEY))
-                    .createSession();
-            },
-        });
     },
 });