@pasko70/pibo 1.9.9 → 1.9.11

package/dist/tools/web-search.js

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

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

@@ -0,0 +1,133 @@
+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";
+}