@pasko70/pibo 1.0.4 → 1.1.0

package/dist/core/runtime.js

@@ -2,6 +2,7 @@ import { readFile } from "node:fs/promises";
 import { isAbsolute, resolve } from "node:path";
 import { AuthStorage, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createBashToolDefinition, getAgentDir, InteractiveMode, SessionManager, } from "@mariozechner/pi-coding-agent";
 import { DEFAULT_BUILTIN_TOOL_NAMES, } from "./profiles.js";
+import { loadPiboModelDefaults, selectRequestedModelProfile } from "./model-defaults.js";
 import { createDefaultPiboProfile } from "../plugins/builtin.js";
 import { createSubagentToolDefinitions, createSubagentToolName, } from "../subagents/tool.js";
 import { createRunToolDefinitions } from "../runs/tools.js";
@@ -201,7 +202,7 @@ export async function createPiboRuntime(options = {}) {
             services,
             sessionManager: runtimeSessionManager,
             sessionStartEvent,
-            model: resolveProfileModel(profile, services),
+            model: resolveProfileModel(profile, services, runtimeCwd),
             thinkingLevel: options.thinkingLevel,
             customTools,
             noTools: profile.builtinTools === "disabled" ? "builtin" : undefined,
@@ -229,15 +230,16 @@ export async function createPiboRuntime(options = {}) {
         sessionManager,
     });
 }
-function resolveProfileModel(profile, services) {
-    if (!profile.model)
+function resolveProfileModel(profile, services, cwd) {
+    const requestedModel = selectRequestedModelProfile(profile, loadPiboModelDefaults(cwd));
+    if (!requestedModel)
         return undefined;
-    const model = services.modelRegistry.find(profile.model.provider, profile.model.id);
+    const model = services.modelRegistry.find(requestedModel.provider, requestedModel.id);
     if (!model) {
-        throw new Error(`Profile "${profile.profileName}" requests unknown model ${profile.model.provider}/${profile.model.id}.`);
+        throw new Error(`Profile "${profile.profileName}" requests unknown model ${requestedModel.provider}/${requestedModel.id}.`);
     }
     if (!services.modelRegistry.hasConfiguredAuth(model)) {
-        throw new Error(`Profile "${profile.profileName}" requires configured auth for ${profile.model.provider}/${profile.model.id}.`);
+        throw new Error(`Profile "${profile.profileName}" requires configured auth for ${requestedModel.provider}/${requestedModel.id}.`);
     }
     return model;
 }

package/dist/core/session-router.js

@@ -15,6 +15,8 @@ function profileForSession(baseProfile, piSessionId, parentPiSessionId) {
         sessionId: piSessionId,
         parentSessionId: parentPiSessionId,
         model: baseProfile.model,
+        mainModel: baseProfile.mainModel,
+        subagentModel: baseProfile.subagentModel,
         skills: baseProfile.skills,
         tools: baseProfile.tools,
         subagents: baseProfile.subagents,

package/dist/gateway/server.js

@@ -186,6 +186,8 @@ export class PiboGatewayServer {
             removeProfile: (name) => this.pluginRegistry.removeProfile(name),
             upsertContextFile: (contextFile) => this.pluginRegistry.upsertContextFile(contextFile),
             removeContextFile: (key) => this.pluginRegistry.removeContextFile(key),
+            registerSkill: (skill) => this.pluginRegistry.registerSkill(skill),
+            unregisterSkill: (name) => this.pluginRegistry.unregisterSkill(name),
             emitProductEvent: (event) => this.pluginRegistry.emitProductEvent(event),
             subscribeProductEvents: (listener) => this.pluginRegistry.onProductEvent(listener),
             auth: this.pluginRegistry.getAuthService(),

package/dist/plugins/builtin.js

@@ -63,7 +63,8 @@ export const piboCorePlugin = definePiboPlugin({
     register(api) {
         api.registerSkill({
             name: "pi-agent-harness",
-            path: ".codex/skills/pi-agent-harness/SKILL.md",
+            path: "skills/builtin/pi-agent-harness/SKILL.md",
+            kind: "builtin",
         });
         api.registerTool(createWebSearchToolProfile());
         api.registerSubagents([

package/dist/plugins/registry.js

@@ -69,6 +69,12 @@ export class PiboPluginRegistry {
     registerSkill(skill) {
         this.addUnique(this.skills, skill.name, skill, "skill");
     }
+    unregisterSkill(name) {
+        return this.skills.delete(name);
+    }
+    getRegisteredSkillNames() {
+        return [...this.skills.keys()];
+    }
     registerContextFile(contextFile) {
         this.addUnique(this.contextFiles, contextFileKey(contextFile), contextFile, "context file");
     }
@@ -155,6 +161,9 @@ export class PiboPluginRegistry {
                 subagents: sessionContext.subagents.filter((subagent) => subagent.enabled !== false),
                 mcpServers: [...sessionContext.mcpServers],
                 piPackages: sessionContext.piPackages.filter((pkg) => pkg.enabled !== false).map((pkg) => pkg.id),
+                model: sessionContext.model ? { ...sessionContext.model } : undefined,
+                mainModel: sessionContext.mainModel ? { ...sessionContext.mainModel } : undefined,
+                subagentModel: sessionContext.subagentModel ? { ...sessionContext.subagentModel } : undefined,
                 builtinTools: sessionContext.builtinTools,
                 builtinToolNames: [...sessionContext.builtinToolNames],
                 autoContextFiles: sessionContext.autoContextFiles,
@@ -176,6 +185,9 @@ export class PiboPluginRegistry {
             skills: [...this.skills.values()].map((skill) => ({
                 name: skill.name,
                 path: skill.path,
+                kind: skill.kind ?? "plugin",
+                pluginId: skill.pluginId,
+                pluginName: skill.pluginId ? this.pluginNames.get(skill.pluginId) : undefined,
             })),
             subagents: [...this.subagents.values()].map((subagent) => ({
                 name: subagent.name,
@@ -273,13 +285,20 @@ export class PiboPluginRegistry {
     }
     createApi(pluginId) {
         const withPluginToolContext = (tool) => ({ ...tool, pluginId: tool.pluginId ?? pluginId });
+        const withPluginSkillContext = (skill) => (skill.kind === "user"
+            ? skill
+            : {
+                ...skill,
+                kind: skill.kind ?? "plugin",
+                pluginId: skill.pluginId ?? pluginId,
+            });
         const withPluginContext = (contextFile) => (contextFile.source === "managed" ? contextFile : { ...contextFile, pluginId: contextFile.pluginId ?? pluginId });
         return {
             registerTool: (tool) => this.registerTool(withPluginToolContext(tool)),
             registerTools: (tools) => this.registerTools(tools.map(withPluginToolContext)),
             registerSubagent: (subagent) => this.registerSubagent(subagent),
             registerSubagents: (subagents) => this.registerSubagents(subagents),
-            registerSkill: (skill) => this.registerSkill(skill),
+            registerSkill: (skill) => this.registerSkill(withPluginSkillContext(skill)),
             registerContextFile: (contextFile) => this.registerContextFile(withPluginContext(contextFile)),
             upsertContextFile: (contextFile) => this.upsertContextFile(withPluginContext(contextFile)),
             removeContextFile: (key) => this.removeContextFile(key),

package/dist/user-skills/installer.js

@@ -0,0 +1,211 @@
+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/{owner}/skills/{skill-name}
+    // skills.sh: https://skills.sh/{owner}/{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: {owner}/{repo}/{skill-name} (e.g. softaworks/agent-toolkit/writing-clearly)
+            const owner = parts[0];
+            const repo = parts[1];
+            const skillName = parts[2];
+            return { owner, repo, path: `skills/${skillName}`, skillName };
+        }
+        if (parts.length >= 2 && parts[1] === "skills") {
+            const owner = parts[0];
+            const skillName = parts[2] ?? parts[0];
+            return { owner, repo: "skills", path: `skills/${skillName}`, skillName };
+        }
+        if (parts.length === 2) {
+            // Format: {owner}/skills or {owner}/{repo}
+            if (parts[1] === "skills") {
+                return { owner: parts[0], repo: "skills" };
+            }
+            return { owner: parts[0], repo: parts[1] };
+        }
+        if (parts.length === 1) {
+            return { owner: parts[0], repo: "skills" };
+        }
+    }
+    // GitHub tree URL: https://github.com/{owner}/{repo}/tree/{branch}/{path}
+    const githubTreeMatch = trimmed.match(/^https:\/\/github\.com\/([^\/]+)\/([^\/]+)\/tree\/[^\/]+\/(.+)$/);
+    if (githubTreeMatch) {
+        const owner = githubTreeMatch[1];
+        const repo = githubTreeMatch[2];
+        const path = githubTreeMatch[3];
+        const skillName = path.split("/").pop() ?? repo;
+        return { owner, repo, path, skillName };
+    }
+    // GitHub shorthand or repo URL: https://github.com/{owner}/{repo}
+    const githubRepoMatch = trimmed.match(/^https:\/\/github\.com\/([^\/]+)\/([^\/]+)$/);
+    if (githubRepoMatch) {
+        return { owner: githubRepoMatch[1], repo: githubRepoMatch[2] };
+    }
+    // Bare shorthand: {owner}/{repo} or {owner}/{repo}/{skill-path}
+    const shorthandMatch = trimmed.match(/^([^\/\s]+)\/([^\/\s]+)(?:\/(.+))?$/);
+    if (shorthandMatch && !trimmed.startsWith("http")) {
+        const owner = shorthandMatch[1];
+        const repo = shorthandMatch[2];
+        const path = shorthandMatch[3];
+        const skillName = path?.split("/").pop() ?? repo;
+        return { owner, repo, path, skillName };
+    }
+    return undefined;
+}
+async function fetchGitHubContents(owner, repo, path) {
+    const apiUrl = `https://api.github.com/repos/${encodeURIComponent(owner)}/${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(owner, repo, path, targetDir) {
+    const items = await fetchGitHubContents(owner, 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(owner, repo, item.path, targetPath);
+        }
+    }
+}
+async function findSkillMdPath(items) {
+    return items.find((item) => item.type === "file" && item.name.toLowerCase() === "skill.md");
+}
+async function findSkillDirectory(owner, repo, path) {
+    if (path) {
+        const items = await fetchGitHubContents(owner, 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(owner, 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(owner, 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(owner, 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(owner, repo, "").catch(() => []);
+    const rootSkillMd = await findSkillMdPath(rootItems);
+    if (rootSkillMd) {
+        return { path: "", skillName: repo };
+    }
+    throw new Error(`Could not find a SKILL.md in ${owner}/${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 { owner, repo, path, skillName } = source;
+    const resolved = path
+        ? { path, skillName: skillName ?? path.split("/").pop() ?? repo }
+        : await findSkillDirectory(owner, 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(owner, 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
+    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.`);
+    }
+    store.skills.push(skill);
+    store.skills.sort((a, b) => a.name.localeCompare(b.name));
+    saveUserSkillStore(store, cwd);
+    return skill;
+}

package/dist/user-skills/manager.js

@@ -0,0 +1,35 @@
+import { createUserSkill, deleteUserSkill, findUserSkill, listUserSkills, readSkillMarkdown, setUserSkillEnabled, updateUserSkill, } from "./store.js";
+import { installSkillFromUrl } from "./installer.js";
+export class UserSkillManager {
+    cwd;
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    create(input) {
+        return createUserSkill(input, this.cwd);
+    }
+    update(id, input) {
+        return updateUserSkill(id, input, this.cwd);
+    }
+    remove(id) {
+        return deleteUserSkill(id, this.cwd);
+    }
+    setEnabled(id, enabled) {
+        return setUserSkillEnabled(id, enabled, this.cwd);
+    }
+    async installFromUrl(url) {
+        return 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);
+    }
+    get(id) {
+        return findUserSkill(id, this.cwd);
+    }
+}

package/dist/user-skills/store.js

@@ -0,0 +1,228 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+const STORE_VERSION = 1;
+const SKILL_DIR_NAME = "user-skills";
+const STORE_FILE_NAME = "user-skills.json";
+export function defaultUserSkillStorePath(cwd = process.cwd()) {
+    return resolve(cwd, ".pibo", STORE_FILE_NAME);
+}
+export function defaultUserSkillDir(cwd = process.cwd()) {
+    return resolve(cwd, ".pibo", SKILL_DIR_NAME);
+}
+export function ensureUserSkillStorage(cwd = process.cwd()) {
+    mkdirSync(defaultUserSkillDir(cwd), { recursive: true });
+}
+export function loadUserSkillStore(cwd = process.cwd()) {
+    const path = defaultUserSkillStorePath(cwd);
+    if (!existsSync(path))
+        return { version: STORE_VERSION, skills: [] };
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Invalid user skills store at ${path}`);
+    }
+    const data = parsed;
+    if (data.version !== STORE_VERSION || !Array.isArray(data.skills)) {
+        throw new Error(`Unsupported user skills store at ${path}`);
+    }
+    return {
+        version: STORE_VERSION,
+        skills: data.skills.map(sanitizeStoredSkill),
+    };
+}
+export function saveUserSkillStore(data, cwd = process.cwd()) {
+    const path = defaultUserSkillStorePath(cwd);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify({ version: STORE_VERSION, skills: data.skills }, null, 2)}\n`, "utf-8");
+}
+export function listUserSkills(cwd = process.cwd()) {
+    return loadUserSkillStore(cwd).skills;
+}
+export function findUserSkill(idOrName, cwd = process.cwd()) {
+    const lookup = idOrName.trim();
+    return listUserSkills(cwd).find((skill) => skill.id === lookup || skill.name === lookup);
+}
+function validateSkillName(name, existingId, cwd = process.cwd()) {
+    const trimmed = name.trim();
+    if (!trimmed)
+        throw new Error("Skill name is required");
+    if (trimmed.length > 64)
+        throw new Error("Skill name is too long (max 64 characters)");
+    if (!/^[a-z][a-z0-9-]*$/.test(trimmed)) {
+        throw new Error("Skill name must be lowercase kebab-case, e.g. my-skill");
+    }
+    const store = loadUserSkillStore(cwd);
+    const existing = store.skills.find((s) => s.name === trimmed && s.id !== existingId);
+    if (existing)
+        throw new Error(`Skill name "${trimmed}" already exists`);
+    return trimmed;
+}
+export function readSkillMarkdown(skill, cwd = process.cwd()) {
+    const fullPath = resolve(cwd, skill.path);
+    if (!existsSync(fullPath))
+        return "";
+    return readFileSync(fullPath, "utf-8");
+}
+export function createUserSkill(input, cwd = process.cwd()) {
+    ensureUserSkillStorage(cwd);
+    const name = validateSkillName(input.name, undefined, cwd);
+    const description = (input.description ?? "").trim();
+    const id = randomUUID();
+    const skillDir = join(defaultUserSkillDir(cwd), name);
+    mkdirSync(skillDir, { recursive: true });
+    const skillPath = join(skillDir, "SKILL.md");
+    const markdown = buildSkillMd(name, description, input.markdown ?? "");
+    writeFileSync(skillPath, markdown, "utf-8");
+    const now = new Date().toISOString();
+    const skill = {
+        id,
+        name,
+        description,
+        path: skillPath,
+        enabled: true,
+        source: "user-created",
+        createdAt: now,
+        updatedAt: now,
+    };
+    const store = loadUserSkillStore(cwd);
+    store.skills.push(skill);
+    store.skills.sort((a, b) => a.name.localeCompare(b.name));
+    saveUserSkillStore(store, cwd);
+    return skill;
+}
+export function updateUserSkill(id, input, cwd = process.cwd()) {
+    const store = loadUserSkillStore(cwd);
+    const index = store.skills.findIndex((s) => s.id === id);
+    if (index < 0)
+        throw new Error(`Skill "${id}" not found`);
+    const existing = store.skills[index];
+    let name = existing.name;
+    let description = existing.description;
+    if (input.name !== undefined) {
+        name = validateSkillName(input.name, existing.id, cwd);
+    }
+    if (input.description !== undefined) {
+        description = input.description.trim();
+    }
+    const skillDir = join(defaultUserSkillDir(cwd), name);
+    const skillPath = join(skillDir, "SKILL.md");
+    if (name !== existing.name) {
+        const oldDir = dirname(existing.path);
+        if (existsSync(oldDir) && oldDir !== skillDir) {
+            mkdirSync(dirname(skillDir), { recursive: true });
+            renameDirContents(oldDir, skillDir);
+            if (existsSync(oldDir)) {
+                rmSync(oldDir, { recursive: true, force: true });
+            }
+        }
+    }
+    if (input.markdown !== undefined) {
+        const markdown = buildSkillMd(name, description, input.markdown);
+        writeFileSync(skillPath, markdown, "utf-8");
+    }
+    else if (name !== existing.name || description !== existing.description) {
+        const currentMarkdown = existsSync(existing.path) ? readFileSync(existing.path, "utf-8") : "";
+        const { body } = parseSkillMd(currentMarkdown);
+        writeFileSync(skillPath, buildSkillMd(name, description, body), "utf-8");
+    }
+    const updated = {
+        ...existing,
+        name,
+        description,
+        path: skillPath,
+        ...(input.enabled !== undefined ? { enabled: input.enabled } : {}),
+        updatedAt: new Date().toISOString(),
+    };
+    store.skills[index] = updated;
+    store.skills.sort((a, b) => a.name.localeCompare(b.name));
+    saveUserSkillStore(store, cwd);
+    return updated;
+}
+export function deleteUserSkill(id, cwd = process.cwd()) {
+    const store = loadUserSkillStore(cwd);
+    const index = store.skills.findIndex((s) => s.id === id);
+    if (index < 0)
+        return undefined;
+    const [removed] = store.skills.splice(index, 1);
+    const skillDir = dirname(removed.path);
+    if (existsSync(skillDir)) {
+        rmSync(skillDir, { recursive: true, force: true });
+    }
+    saveUserSkillStore(store, cwd);
+    return removed;
+}
+export function setUserSkillEnabled(id, enabled, cwd = process.cwd()) {
+    return updateUserSkill(id, { enabled }, cwd);
+}
+function sanitizeStoredSkill(value) {
+    const candidate = value;
+    if (!candidate || typeof candidate !== "object")
+        throw new Error("Invalid user skill entry");
+    if (typeof candidate.id !== "string" || typeof candidate.name !== "string" || typeof candidate.path !== "string") {
+        throw new Error("Invalid user skill entry");
+    }
+    return {
+        id: candidate.id,
+        name: candidate.name.trim(),
+        description: typeof candidate.description === "string" ? candidate.description.trim() : "",
+        path: candidate.path.trim(),
+        enabled: candidate.enabled !== false,
+        source: isValidSource(candidate.source) ? candidate.source : "user-created",
+        sourceUrl: typeof candidate.sourceUrl === "string" ? candidate.sourceUrl.trim() : undefined,
+        createdAt: typeof candidate.createdAt === "string" ? candidate.createdAt : new Date().toISOString(),
+        updatedAt: typeof candidate.updatedAt === "string" ? candidate.updatedAt : new Date().toISOString(),
+    };
+}
+function isValidSource(source) {
+    return source === "user-created" || source === "skills.sh" || source === "github";
+}
+export function parseSkillMd(content) {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith("---")) {
+        return { name: "", description: "", body: trimmed };
+    }
+    const endIdx = trimmed.indexOf("---", 3);
+    if (endIdx === -1) {
+        return { name: "", description: "", body: trimmed };
+    }
+    const frontmatter = trimmed.slice(3, endIdx).trim();
+    const body = trimmed.slice(endIdx + 3).trimStart();
+    const parsed = parseSimpleYaml(frontmatter);
+    return {
+        name: typeof parsed.name === "string" ? parsed.name : "",
+        description: typeof parsed.description === "string" ? parsed.description : "",
+        body,
+    };
+}
+export function buildSkillMd(name, description, body) {
+    const cleanBody = body.trimStart();
+    return `---\nname: ${name}\ndescription: ${description}\n---\n\n${cleanBody}`;
+}
+function parseSimpleYaml(text) {
+    const result = {};
+    for (const line of text.split("\n")) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx <= 0)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const value = line.slice(colonIdx + 1).trim();
+        if (key)
+            result[key] = value;
+    }
+    return result;
+}
+function renameDirContents(oldDir, newDir) {
+    mkdirSync(newDir, { recursive: true });
+    for (const entry of readdirSync(oldDir)) {
+        const oldPath = join(oldDir, entry);
+        const newPath = join(newDir, entry);
+        const stat = statSync(oldPath);
+        if (stat.isDirectory()) {
+            renameDirContents(oldPath, newPath);
+            rmSync(oldPath, { recursive: true, force: true });
+        }
+        else {
+            writeFileSync(newPath, readFileSync(oldPath));
+        }
+    }
+}

package/dist/user-skills/types.js

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

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "type": "module",
   "description": "Minimal TypeScript wrapper around Pi Coding Agent.",
   "files": [
     "dist",
     "context",
-    ".codex/skills/pi-agent-harness/SKILL.md",
-    ".codex/skills/pi-agent-harness/agents/openai.yaml",
+    "skills/builtin/pi-agent-harness/SKILL.md",
+    "skills/builtin/pi-agent-harness/agents/openai.yaml",
     "README.md",
     "src/mcp/LICENSE.mcp-cli"
   ],