@pasko70/pibo 1.9.8 → 1.9.9

package/dist/tools/web-search.js

@@ -1,138 +0,0 @@
-export const WEB_SEARCH_PROMPT_CONTRIBUTION = "web_search is available as a Pibo native tool through the OpenAI provider adapter. Use it when current or externally sourced information is needed.";
-const WEB_SEARCH_SOURCES_INCLUDE = "web_search_call.action.sources";
-function hasProviderResponsesShape(payload) {
-    return Boolean(payload && typeof payload === "object" && "input" in payload);
-}
-function hasWebSearchTool(tools) {
-    return tools.some((tool) => {
-        if (!tool || typeof tool !== "object")
-            return false;
-        const type = tool.type;
-        return type === "web_search_preview" || type === "web_search";
-    });
-}
-function isValidDomainFilter(value) {
-    const domain = value.trim();
-    return domain.length > 0 && !domain.includes("://") && !/[/?#\s]/.test(domain);
-}
-function normalizedDomainFilters(values) {
-    const domains = values?.map((value) => value.trim()).filter(isValidDomainFilter) ?? [];
-    return domains.length > 0 ? domains : undefined;
-}
-function normalizedLocation(location) {
-    if (!location)
-        return undefined;
-    const country = location.country?.trim();
-    const region = location.region?.trim();
-    const city = location.city?.trim();
-    const timezone = location.timezone?.trim();
-    if (!country && !region && !city && !timezone)
-        return undefined;
-    return {
-        type: "approximate",
-        ...(country ? { country } : {}),
-        ...(region ? { region } : {}),
-        ...(city ? { city } : {}),
-        ...(timezone ? { timezone } : {}),
-    };
-}
-export function normalizeOpenAiWebSearchConfig(options) {
-    const allowedDomains = normalizedDomainFilters(options?.allowedDomains);
-    const blockedDomains = normalizedDomainFilters(options?.blockedDomains);
-    const userLocation = normalizedLocation(options?.userLocation);
-    return {
-        external_web_access: options?.externalWebAccess ?? true,
-        search_context_size: options?.searchContextSize ?? "medium",
-        include_sources: options?.includeSources ?? true,
-        ...(allowedDomains || blockedDomains
-            ? {
-                filters: {
-                    ...(allowedDomains ? { allowed_domains: allowedDomains } : {}),
-                    ...(blockedDomains ? { blocked_domains: blockedDomains } : {}),
-                },
-            }
-            : {}),
-        ...(userLocation ? { user_location: userLocation } : {}),
-    };
-}
-function buildOpenAiWebSearchProviderTool(config) {
-    const tool = {
-        type: "web_search",
-        external_web_access: config.external_web_access,
-    };
-    if (config.search_context_size)
-        tool.search_context_size = config.search_context_size;
-    if (config.user_location)
-        tool.user_location = config.user_location;
-    if (config.filters?.allowed_domains?.length || config.filters?.blocked_domains?.length) {
-        tool.filters = {
-            ...(config.filters.allowed_domains?.length ? { allowed_domains: config.filters.allowed_domains } : {}),
-            ...(config.filters.blocked_domains?.length ? { blocked_domains: config.filters.blocked_domains } : {}),
-        };
-    }
-    return tool;
-}
-function addOpenAiWebSearchSourcesInclude(payload, config) {
-    if (!config.include_sources)
-        return {};
-    const include = Array.isArray(payload.include) ? [...payload.include] : [];
-    if (!include.includes(WEB_SEARCH_SOURCES_INCLUDE))
-        include.push(WEB_SEARCH_SOURCES_INCLUDE);
-    return { include };
-}
-export function addOpenAiWebSearchProviderTool(payload, config) {
-    if (!hasProviderResponsesShape(payload))
-        return payload;
-    const tools = Array.isArray(payload.tools) ? [...payload.tools] : [];
-    if (hasWebSearchTool(tools))
-        return payload;
-    return {
-        ...payload,
-        ...addOpenAiWebSearchSourcesInclude(payload, config),
-        tools: [...tools, buildOpenAiWebSearchProviderTool(config)],
-    };
-}
-const openAiWebSearchAdapter = {
-    provider: "openai",
-    createExtension(options) {
-        const config = normalizeOpenAiWebSearchConfig(options);
-        return (pi) => {
-            pi.on("before_agent_start", (event) => ({
-                systemPrompt: [
-                    event.systemPrompt,
-                    "# Native Web Search",
-                    WEB_SEARCH_PROMPT_CONTRIBUTION,
-                ].join("\n\n"),
-            }));
-            pi.on("before_provider_request", (event) => addOpenAiWebSearchProviderTool(event.payload, config));
-        };
-    },
-};
-const WEB_SEARCH_PROVIDER_ADAPTERS = {
-    openai: openAiWebSearchAdapter,
-};
-export function getWebSearchProviderAdapter(provider) {
-    return WEB_SEARCH_PROVIDER_ADAPTERS[provider];
-}
-export function createWebSearchProviderExtension(providerTool) {
-    return getWebSearchProviderAdapter(providerTool.provider).createExtension(providerTool.options);
-}
-export function isWebSearchProviderTool(tool) {
-    return tool.providerTool?.kind === "web_search";
-}
-export function createWebSearchToolProfile(options = {}) {
-    return {
-        name: "web_search",
-        description: "Searches the web through the configured provider adapter.",
-        providerTool: {
-            kind: "web_search",
-            provider: "openai",
-            options: {
-                externalWebAccess: true,
-                searchContextSize: "medium",
-                includeSources: true,
-                ...options,
-            },
-        },
-    };
-}

package/dist/user-skills/installer.js

@@ -1,214 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { defaultUserSkillDir, parseSkillMd } from "./store.js";
-export function parseSkillUrl(url) {
-    const trimmed = url.trim();
-    // skills.sh: https://skills.sh/{account}/skills/{skill-name}
-    // skills.sh: https://skills.sh/{account}/{repo}/{skill-name}
-    if (trimmed.startsWith("https://skills.sh/")) {
-        const rest = trimmed.slice("https://skills.sh/".length);
-        const parts = rest.split("/").filter(Boolean);
-        if (parts.length >= 3) {
-            // Format: {account}/{repo}/{skill-name} (e.g. softaworks/agent-toolkit/writing-clearly)
-            const account = parts[0];
-            const repo = parts[1];
-            const skillName = parts[2];
-            return { account, repo, path: `skills/${skillName}`, skillName };
-        }
-        if (parts.length >= 2 && parts[1] === "skills") {
-            const account = parts[0];
-            const skillName = parts[2] ?? parts[0];
-            return { account, repo: "skills", path: `skills/${skillName}`, skillName };
-        }
-        if (parts.length === 2) {
-            // Format: {account}/skills or {account}/{repo}
-            if (parts[1] === "skills") {
-                return { account: parts[0], repo: "skills" };
-            }
-            return { account: parts[0], repo: parts[1] };
-        }
-        if (parts.length === 1) {
-            return { account: parts[0], repo: "skills" };
-        }
-    }
-    // GitHub tree URL: https://github.com/{account}/{repo}/tree/{branch}/{path}
-    const githubTreeMatch = trimmed.match(/^https:\/\/github\.com\/([^\/]+)\/([^\/]+)\/tree\/[^\/]+\/(.+)$/);
-    if (githubTreeMatch) {
-        const account = githubTreeMatch[1];
-        const repo = githubTreeMatch[2];
-        const path = githubTreeMatch[3];
-        const skillName = path.split("/").pop() ?? repo;
-        return { account, repo, path, skillName };
-    }
-    // GitHub shorthand or repo URL: https://github.com/{account}/{repo}
-    const githubRepoMatch = trimmed.match(/^https:\/\/github\.com\/([^\/]+)\/([^\/]+)$/);
-    if (githubRepoMatch) {
-        return { account: githubRepoMatch[1], repo: githubRepoMatch[2] };
-    }
-    // Bare shorthand: {account}/{repo} or {account}/{repo}/{skill-path}
-    const shorthandMatch = trimmed.match(/^([^\/\s]+)\/([^\/\s]+)(?:\/(.+))?$/);
-    if (shorthandMatch && !trimmed.startsWith("http")) {
-        const account = shorthandMatch[1];
-        const repo = shorthandMatch[2];
-        const path = shorthandMatch[3];
-        const skillName = path?.split("/").pop() ?? repo;
-        return { account, repo, path, skillName };
-    }
-    return undefined;
-}
-async function fetchGitHubContents(account, repo, path) {
-    const apiUrl = `https://api.github.com/repos/${encodeURIComponent(account)}/${encodeURIComponent(repo)}/contents/${encodeURIComponent(path)}`;
-    const response = await fetch(apiUrl, {
-        headers: { Accept: "application/vnd.github.v3+json", "User-Agent": "pibo-skills-installer" },
-    });
-    if (!response.ok) {
-        const text = await response.text().catch(() => "");
-        throw new Error(`GitHub API error (${response.status}): ${text || response.statusText}`);
-    }
-    const data = (await response.json());
-    if (!Array.isArray(data)) {
-        throw new Error(`Expected directory listing from GitHub API, got: ${typeof data}`);
-    }
-    return data;
-}
-async function fetchGitHubFile(downloadUrl) {
-    const response = await fetch(downloadUrl, { headers: { "User-Agent": "pibo-skills-installer" } });
-    if (!response.ok) {
-        throw new Error(`Failed to download file (${response.status}): ${downloadUrl}`);
-    }
-    return new Uint8Array(await response.arrayBuffer());
-}
-async function downloadDirectory(account, repo, path, targetDir) {
-    const items = await fetchGitHubContents(account, repo, path);
-    for (const item of items) {
-        const targetPath = join(targetDir, item.name);
-        if (item.type === "file") {
-            if (!item.download_url)
-                continue;
-            const content = await fetchGitHubFile(item.download_url);
-            mkdirSync(dirname(targetPath), { recursive: true });
-            writeFileSync(targetPath, content);
-        }
-        else if (item.type === "dir") {
-            mkdirSync(targetPath, { recursive: true });
-            await downloadDirectory(account, repo, item.path, targetPath);
-        }
-    }
-}
-async function findSkillMdPath(items) {
-    return items.find((item) => item.type === "file" && item.name.toLowerCase() === "skill.md");
-}
-async function findSkillDirectory(account, repo, path) {
-    if (path) {
-        const items = await fetchGitHubContents(account, repo, path);
-        const skillMd = await findSkillMdPath(items);
-        if (skillMd) {
-            return { path, skillName: path.split("/").pop() ?? repo };
-        }
-        // If no SKILL.md at this path, search subdirectories one level deep
-        for (const item of items) {
-            if (item.type === "dir") {
-                const subItems = await fetchGitHubContents(account, repo, item.path).catch(() => []);
-                const subSkillMd = await findSkillMdPath(subItems);
-                if (subSkillMd) {
-                    return { path: item.path, skillName: item.name };
-                }
-            }
-        }
-    }
-    // Try common skill directories
-    const candidates = ["skills", "skill", "src/skills", "agents/skills"];
-    for (const candidate of candidates) {
-        const items = await fetchGitHubContents(account, repo, candidate).catch(() => []);
-        const skillMd = await findSkillMdPath(items);
-        if (skillMd) {
-            return { path: candidate, skillName: candidate };
-        }
-        // Search one level deep
-        for (const item of items) {
-            if (item.type === "dir") {
-                const subItems = await fetchGitHubContents(account, repo, item.path).catch(() => []);
-                const subSkillMd = await findSkillMdPath(subItems);
-                if (subSkillMd) {
-                    return { path: item.path, skillName: item.name };
-                }
-            }
-        }
-    }
-    // Search repository root for SKILL.md
-    const rootItems = await fetchGitHubContents(account, repo, "").catch(() => []);
-    const rootSkillMd = await findSkillMdPath(rootItems);
-    if (rootSkillMd) {
-        return { path: "", skillName: repo };
-    }
-    throw new Error(`Could not find a SKILL.md in ${account}/${repo}${path ? `/${path}` : ""}`);
-}
-export async function installSkillFromUrl(url, cwd = process.cwd()) {
-    const source = parseSkillUrl(url);
-    if (!source) {
-        throw new Error(`Unsupported skill URL format: ${url}`);
-    }
-    const { account, repo, path, skillName } = source;
-    const resolved = path
-        ? { path, skillName: skillName ?? path.split("/").pop() ?? repo }
-        : await findSkillDirectory(account, repo);
-    const targetName = resolved.skillName;
-    const targetDir = join(defaultUserSkillDir(cwd), targetName);
-    if (existsSync(targetDir)) {
-        throw new Error(`A skill named "${targetName}" already exists. Delete it first or choose a different name.`);
-    }
-    mkdirSync(targetDir, { recursive: true });
-    try {
-        await downloadDirectory(account, repo, resolved.path, targetDir);
-    }
-    catch (error) {
-        // Clean up on failure
-        try {
-            const { rmSync } = await import("node:fs");
-            rmSync(targetDir, { recursive: true, force: true });
-        }
-        catch {
-            // ignore cleanup errors
-        }
-        throw error;
-    }
-    // Read SKILL.md to extract name and description
-    const skillMdPath = join(targetDir, "SKILL.md");
-    if (!existsSync(skillMdPath)) {
-        throw new Error(`Download completed but no SKILL.md found in ${targetName}`);
-    }
-    const { readFileSync } = await import("node:fs");
-    const content = readFileSync(skillMdPath, "utf-8");
-    const parsed = parseSkillMd(content);
-    const name = parsed.name || targetName;
-    const description = parsed.description || "";
-    // Store the skill metadata (description lives in SKILL.md only, not JSON)
-    const { randomUUID } = await import("node:crypto");
-    const now = new Date().toISOString();
-    const skill = {
-        id: randomUUID(),
-        name,
-        description,
-        path: skillMdPath,
-        enabled: true,
-        source: url.includes("skills.sh") ? "skills.sh" : "github",
-        sourceUrl: url,
-        createdAt: now,
-        updatedAt: now,
-    };
-    const { loadUserSkillStore, saveUserSkillStore } = await import("./store.js");
-    const store = loadUserSkillStore(cwd);
-    const existing = store.skills.find((s) => s.name === name);
-    if (existing) {
-        const { rmSync } = await import("node:fs");
-        rmSync(targetDir, { recursive: true, force: true });
-        throw new Error(`A skill named "${name}" already exists. Delete it first or choose a different name.`);
-    }
-    // Strip description before persisting to JSON store.
-    const storedSkill = { ...skill };
-    delete storedSkill.description;
-    store.skills.push(storedSkill);
-    store.skills.sort((a, b) => a.name.localeCompare(b.name));
-    saveUserSkillStore(store, cwd);
-    return skill;
-}

package/dist/user-skills/manager.js

@@ -1,133 +0,0 @@
-import os from "node:os";
-import { createUserSkill, deleteUserSkill, findUserSkill, listUserSkills, readSkillMarkdown, setUserSkillEnabled, updateUserSkill, } from "./store.js";
-import { installSkillFromUrl } from "./installer.js";
-export function normalizeUserSkillScope(value, fallback = "all") {
-    const normalized = (value ?? "").trim().toLowerCase();
-    if (!normalized)
-        return fallback;
-    if (normalized === "global" || normalized === "workspace" || normalized === "all")
-        return normalized;
-    throw new Error(`Invalid skill scope "${value}". Expected global, workspace, or all.`);
-}
-export function normalizeWritableUserSkillScope(value, fallback = "global") {
-    const scope = normalizeUserSkillScope(value, fallback);
-    if (scope === "all")
-        throw new Error("Skill scope must be global or workspace for this command.");
-    return scope;
-}
-export class UserSkillManager {
-    cwd;
-    scope;
-    constructor(cwd, scope = "global") {
-        this.cwd = cwd;
-        this.scope = scope;
-    }
-    create(input) {
-        return this.withScope(createUserSkill(input, this.cwd));
-    }
-    update(id, input) {
-        return this.withScope(updateUserSkill(id, input, this.cwd));
-    }
-    remove(id) {
-        return this.withOptionalScope(deleteUserSkill(id, this.cwd));
-    }
-    setEnabled(id, enabled) {
-        return this.withScope(setUserSkillEnabled(id, enabled, this.cwd));
-    }
-    async installFromUrl(url) {
-        return this.withScope(await installSkillFromUrl(url, this.cwd));
-    }
-    getSkillMarkdown(id) {
-        const skill = findUserSkill(id, this.cwd);
-        if (!skill)
-            return "";
-        return readSkillMarkdown(skill, this.cwd);
-    }
-    list() {
-        return listUserSkills(this.cwd).map((skill) => this.withScope(skill));
-    }
-    get(id) {
-        return this.withOptionalScope(findUserSkill(id, this.cwd));
-    }
-    withScope(skill) {
-        return { ...skill, scope: this.scope };
-    }
-    withOptionalScope(skill) {
-        return skill ? this.withScope(skill) : undefined;
-    }
-}
-export class ScopedUserSkillManager {
-    global;
-    workspace;
-    constructor(options = {}) {
-        this.global = new UserSkillManager(options.globalRoot ?? os.homedir(), "global");
-        this.workspace = new UserSkillManager(options.workspaceRoot ?? process.cwd(), "workspace");
-    }
-    list(scope = "all") {
-        if (scope === "global")
-            return this.global.list();
-        if (scope === "workspace")
-            return this.workspace.list();
-        return [...this.global.list(), ...this.workspace.list()].sort(compareScopedUserSkills);
-    }
-    create(input, scope = "global") {
-        return this.managerFor(scope).create(input);
-    }
-    update(id, input, scope = "all") {
-        const match = this.resolve(id, scope);
-        if (!match)
-            throw new Error(`Skill "${id}" not found`);
-        return match.manager.update(match.skill.id, input);
-    }
-    remove(id, scope = "all") {
-        const match = this.resolve(id, scope);
-        if (!match)
-            return undefined;
-        return match.manager.remove(match.skill.id);
-    }
-    setEnabled(id, enabled, scope = "all") {
-        const match = this.resolve(id, scope);
-        if (!match)
-            throw new Error(`Skill "${id}" not found`);
-        return match.manager.setEnabled(match.skill.id, enabled);
-    }
-    async installFromUrl(url, scope = "global") {
-        return this.managerFor(scope).installFromUrl(url);
-    }
-    getSkillMarkdown(id, scope = "all") {
-        const match = this.resolve(id, scope);
-        if (!match)
-            return "";
-        return match.manager.getSkillMarkdown(match.skill.id);
-    }
-    get(id, scope = "all") {
-        return this.resolve(id, scope)?.skill;
-    }
-    resolve(id, scope) {
-        if (scope === "global") {
-            const skill = this.global.get(id);
-            return skill ? { skill, manager: this.global } : undefined;
-        }
-        if (scope === "workspace") {
-            const skill = this.workspace.get(id);
-            return skill ? { skill, manager: this.workspace } : undefined;
-        }
-        const workspaceSkill = this.workspace.get(id);
-        if (workspaceSkill)
-            return { skill: workspaceSkill, manager: this.workspace };
-        const globalSkill = this.global.get(id);
-        return globalSkill ? { skill: globalSkill, manager: this.global } : undefined;
-    }
-    managerFor(scope) {
-        return scope === "workspace" ? this.workspace : this.global;
-    }
-}
-function compareScopedUserSkills(a, b) {
-    const nameCompare = a.name.localeCompare(b.name);
-    if (nameCompare !== 0)
-        return nameCompare;
-    return scopeRank(a.scope).localeCompare(scopeRank(b.scope));
-}
-function scopeRank(scope) {
-    return scope === "workspace" ? "0" : "1";
-}