@pasko70/pibo 1.9.8 → 1.9.9

package/dist/pi-packages/runtime.js

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

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

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

package/dist/plugins/better-auth.js

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