@pasko70/pibo 1.0.0

package/dist/pi-packages/runtime.js

@@ -0,0 +1,61 @@
+import { existsSync } from "node:fs";
+import { findPiPackage } from "./store.js";
+export function getPiPackageRuntimeOptions(cwd, profile) {
+    const diagnostics = [];
+    const additionalExtensionPaths = [];
+    for (const selected of profile.piPackages.filter((pkg) => pkg.enabled !== false)) {
+        const registered = findPiPackage(selected.id, cwd);
+        if (!registered) {
+            diagnostics.push({
+                type: "error",
+                message: `Selected Pi package "${selected.id}" is not registered in Pibo.`,
+            });
+            continue;
+        }
+        if (!registered.enabled) {
+            diagnostics.push({
+                type: "warning",
+                message: `Selected Pi package "${registered.name}" is globally disabled in Pibo and was not loaded.`,
+            });
+            continue;
+        }
+        if (registered.installStatus === "error") {
+            diagnostics.push({
+                type: "error",
+                message: `Selected Pi package "${registered.name}" is in error state and was skipped.`,
+            });
+            continue;
+        }
+        const runtimePath = registered.installPath ?? (registered.installSpec.startsWith("/") ? registered.installSpec : undefined);
+        if (!runtimePath) {
+            diagnostics.push({
+                type: "warning",
+                message: `Selected Pi package "${registered.name}" is not installed and was skipped.`,
+            });
+            continue;
+        }
+        if (!existsSync(runtimePath)) {
+            diagnostics.push({
+                type: "error",
+                message: `Selected Pi package "${registered.name}" path does not exist: ${runtimePath}`,
+            });
+            continue;
+        }
+        additionalExtensionPaths.push(runtimePath);
+        diagnostics.push({
+            type: "info",
+            message: `Loaded Pi package ${registered.name} (${registered.resourceTypes.join(", ") || "resources pending"})`,
+        });
+        for (const diagnostic of registered.diagnostics) {
+            if (diagnostic.type === "error") {
+                diagnostics.push({ type: "warning", message: `Pi package ${registered.name}: ${diagnostic.message}` });
+            }
+        }
+    }
+    return {
+        resourceLoaderOptions: {
+            additionalExtensionPaths: [...new Set(additionalExtensionPaths)],
+        },
+        diagnostics,
+    };
+}

package/dist/pi-packages/store.js

@@ -0,0 +1,175 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+const STORE_VERSION = 1;
+export function defaultPiPackageStorePath(cwd = process.cwd()) {
+    return resolve(cwd, ".pibo/pi-packages.json");
+}
+export function ensurePiPackageStorage(cwd = process.cwd()) {
+    mkdirSync(resolve(cwd, ".pibo/pi-packages/npm"), { recursive: true });
+    mkdirSync(resolve(cwd, ".pibo/pi-packages/git"), { recursive: true });
+    mkdirSync(resolve(cwd, ".pibo/pi-packages/local"), { recursive: true });
+}
+export function loadPiPackageStore(path = defaultPiPackageStorePath()) {
+    if (!existsSync(path))
+        return { version: STORE_VERSION, packages: [] };
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Invalid Pi package store at ${path}`);
+    }
+    const data = parsed;
+    if (data.version !== STORE_VERSION || !Array.isArray(data.packages)) {
+        throw new Error(`Unsupported Pi package store at ${path}`);
+    }
+    return {
+        version: STORE_VERSION,
+        packages: data.packages.map(sanitizeStoredPackage),
+    };
+}
+export function savePiPackageStore(data, path = defaultPiPackageStorePath()) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify({ version: STORE_VERSION, packages: data.packages }, null, 2)}\n`, "utf-8");
+}
+export function listPiPackages(cwd = process.cwd()) {
+    return loadPiPackageStore(defaultPiPackageStorePath(cwd)).packages;
+}
+export function findPiPackage(nameOrId, cwd = process.cwd()) {
+    const lookup = nameOrId.trim();
+    return listPiPackages(cwd).find((pkg) => (pkg.id === lookup ||
+        pkg.name === lookup ||
+        pkg.source === lookup ||
+        pkg.installSpec === lookup));
+}
+export function upsertPiPackage(pkg, cwd = process.cwd()) {
+    ensurePiPackageStorage(cwd);
+    const path = defaultPiPackageStorePath(cwd);
+    const data = loadPiPackageStore(path);
+    const now = new Date().toISOString();
+    const existingIndex = data.packages.findIndex((candidate) => candidate.id === pkg.id || candidate.name === pkg.name || candidate.source === pkg.source);
+    const existing = existingIndex >= 0 ? data.packages[existingIndex] : undefined;
+    const next = existing && existing.installStatus === "installed" && pkg.installStatus === "error"
+        ? {
+            ...existing,
+            diagnostics: mergeDiagnostics(existing.diagnostics, [
+                { type: "warning", message: `Latest package refresh failed; keeping previous installed record for ${existing.name}.` },
+                ...pkg.diagnostics,
+            ]),
+            updatedAt: now,
+        }
+        : {
+            ...pkg,
+            enabled: existing?.enabled ?? pkg.enabled !== false,
+            addedAt: existing ? existing.addedAt : pkg.addedAt ?? now,
+            updatedAt: now,
+        };
+    if (existingIndex >= 0)
+        data.packages[existingIndex] = next;
+    else
+        data.packages.push(next);
+    data.packages.sort((left, right) => left.name.localeCompare(right.name));
+    savePiPackageStore(data, path);
+    return next;
+}
+export function removePiPackage(nameOrId, cwd = process.cwd()) {
+    const path = defaultPiPackageStorePath(cwd);
+    const data = loadPiPackageStore(path);
+    const lookup = nameOrId.trim();
+    const index = data.packages.findIndex((pkg) => (pkg.id === lookup ||
+        pkg.name === lookup ||
+        pkg.source === lookup ||
+        pkg.installSpec === lookup));
+    if (index < 0)
+        return undefined;
+    const [removed] = data.packages.splice(index, 1);
+    savePiPackageStore(data, path);
+    return removed;
+}
+export function setPiPackageEnabled(nameOrId, enabled, cwd = process.cwd()) {
+    const path = defaultPiPackageStorePath(cwd);
+    const data = loadPiPackageStore(path);
+    const lookup = nameOrId.trim();
+    const index = data.packages.findIndex((pkg) => pkg.id === lookup || pkg.name === lookup || pkg.source === lookup);
+    if (index < 0)
+        return undefined;
+    const next = {
+        ...data.packages[index],
+        enabled,
+        updatedAt: new Date().toISOString(),
+    };
+    data.packages[index] = next;
+    savePiPackageStore(data, path);
+    return next;
+}
+function sanitizeStoredPackage(value) {
+    const candidate = value;
+    if (!candidate || typeof candidate !== "object")
+        throw new Error("Invalid Pi package entry");
+    if (typeof candidate.name !== "string" || typeof candidate.source !== "string" || typeof candidate.installSpec !== "string") {
+        throw new Error("Invalid Pi package entry");
+    }
+    return {
+        id: typeof candidate.id === "string" && candidate.id.trim() ? candidate.id.trim() : candidate.name.trim(),
+        name: candidate.name.trim(),
+        description: stringOrUndefined(candidate.description),
+        source: candidate.source.trim(),
+        installSpec: candidate.installSpec.trim(),
+        version: stringOrUndefined(candidate.version),
+        repositoryUrl: stringOrUndefined(candidate.repositoryUrl),
+        resourceTypes: uniqueResourceTypes(candidate.resourceTypes),
+        extensionPaths: stringArray(candidate.extensionPaths),
+        skillNames: stringArray(candidate.skillNames),
+        promptNames: stringArray(candidate.promptNames),
+        themeNames: stringArray(candidate.themeNames),
+        discoveredToolNames: stringArray(candidate.discoveredToolNames),
+        installStatus: installStatus(candidate),
+        installPath: stringOrUndefined(candidate.installPath),
+        enabled: candidate.enabled !== false,
+        diagnostics: Array.isArray(candidate.diagnostics) ? candidate.diagnostics.flatMap((diagnostic) => {
+            if (!diagnostic || typeof diagnostic !== "object")
+                return [];
+            const item = diagnostic;
+            if (item.type !== "info" && item.type !== "warning" && item.type !== "error")
+                return [];
+            if (typeof item.message !== "string" || !item.message.trim())
+                return [];
+            return [{ type: item.type, message: item.message.trim() }];
+        }) : [],
+        addedAt: stringOrUndefined(candidate.addedAt) ?? new Date().toISOString(),
+        updatedAt: stringOrUndefined(candidate.updatedAt) ?? new Date().toISOString(),
+    };
+}
+function installStatus(candidate) {
+    if (candidate.installStatus === "registered" ||
+        candidate.installStatus === "installed" ||
+        candidate.installStatus === "missing" ||
+        candidate.installStatus === "error") {
+        return candidate.installStatus;
+    }
+    return candidate.installed === true ? "installed" : "registered";
+}
+function mergeDiagnostics(left, right) {
+    const seen = new Set();
+    const merged = [];
+    for (const diagnostic of [...left, ...right]) {
+        const key = `${diagnostic.type}\0${diagnostic.message}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(diagnostic);
+    }
+    return merged;
+}
+function stringOrUndefined(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const strings = [...new Set(value.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim()))];
+    return strings.length ? strings : undefined;
+}
+function uniqueResourceTypes(value) {
+    if (!Array.isArray(value))
+        return [];
+    const allowed = new Set(["extension", "skill", "prompt", "theme"]);
+    return [...new Set(value.filter((item) => typeof item === "string" && allowed.has(item)))];
+}

package/dist/pi-packages/types.js

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

package/dist/plugins/better-auth.js

@@ -0,0 +1,11 @@
+import { createBetterAuthService } from "../auth/better-auth.js";
+import { definePiboPlugin } from "./registry.js";
+export function createPiboBetterAuthPlugin(options = {}) {
+    return definePiboPlugin({
+        id: "pibo.better-auth",
+        name: "Pibo Better Auth",
+        register(api) {
+            api.registerAuthService(createBetterAuthService(options));
+        },
+    });
+}

package/dist/plugins/builtin.js

@@ -0,0 +1,249 @@
+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 { piboCodexCompatPlugin } from "./codex-compat.js";
+import { definePiboPlugin, PiboPluginRegistry } from "./registry.js";
+const GATEWAY_PROFILE_TOOLS = ["pibo_gateway_send"];
+const RUN_YIELD_QA_SUBAGENTS = ["qa-researcher", "qa-reviewer"];
+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 createBaseProfileBuilder(profileName, context) {
+    return new InitialSessionContextBuilder(profileName)
+        .addSkill(context.getSkill("pi-agent-harness"));
+}
+export const piboCorePlugin = definePiboPlugin({
+    id: "pibo.core",
+    name: "Pibo Core",
+    register(api) {
+        api.registerSkill({
+            name: "pi-agent-harness",
+            path: ".codex/skills/pi-agent-harness/SKILL.md",
+        });
+        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.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.registerGatewayAction({
+            name: "status",
+            description: "Return current session status.",
+            slashCommands: ["status"],
+            execute(context) {
+                return context.getStatus();
+            },
+        });
+        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: "dispose",
+            description: "Dispose the routed session runtime.",
+            hidden: true,
+            async execute(context) {
+                await context.dispose();
+                return { disposed: true };
+            },
+        });
+        api.registerGatewayAction({
+            name: "thinking",
+            description: "Cycle 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();
+            },
+        });
+        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));
+            },
+        });
+    },
+});
+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];
+}
+export function createGatewayProducerPiboPluginRegistry() {
+    return PiboPluginRegistry.create({
+        plugins: [piboCorePlugin, piboGatewayProducerPlugin, piboCodexCompatPlugin],
+    });
+}
+export function createDefaultPiboPluginRegistry() {
+    return PiboPluginRegistry.create({ plugins: createDefaultPiboPlugins() });
+}
+export function createDefaultPiboProfile() {
+    return createDefaultPiboPluginRegistry().createProfile("pibo-minimal");
+}
+export function createGatewayProducerPiboProfile() {
+    return createGatewayProducerPiboPluginRegistry().createProfile("pibo-gateway-producer");
+}

package/dist/plugins/chat-web.js

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,72 @@
+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");
+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.registerContextFile({
+            key: CODEX_BASE_PROMPT_CONTEXT_FILE_KEY,
+            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();
+            },
+        });
+    },
+});