codiedev 0.10.0-beta.1 → 0.10.0-beta.11

package/dist/packs/codie.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.levelToModel = levelToModel;
+exports.mapAgentModel = mapAgentModel;
+exports.codiePackConfig = codiePackConfig;
+exports.mergeCodiePackConfig = mergeCodiePackConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const url_1 = require("url");
+const manifest_1 = require("./manifest");
+const paths_1 = require("./paths");
+const shim_1 = require("./shim");
+const store_1 = require("./store");
+const LEVEL_LABEL = { opus: "Strongest", sonnet: "Balanced", haiku: "Fastest" };
+function newestFirst(a, b) {
+    return b.id.localeCompare(a.id, undefined, { numeric: true });
+}
+function levelToModel(level, catalog) {
+    const key = level.toLowerCase();
+    const tierNames = {
+        opus: ["strongest", "opus", "high", "max"],
+        sonnet: ["balanced", "sonnet", "medium", "default"],
+        haiku: ["fastest", "haiku", "low", "fast"],
+    };
+    const tiered = catalog.filter((m) => [m.tier, m.level].some((t) => typeof t === "string" && tierNames[key].includes(t.toLowerCase())));
+    if (tiered.length)
+        return { model: [...tiered].sort(newestFirst)[0].id, how: "tier" };
+    const family = catalog.filter((m) => new RegExp(`(^|[^a-z])${key}([^a-z]|$)`, "i").test(m.id));
+    if (family.length)
+        return { model: [...family].sort(newestFirst)[0].id, how: "family" };
+    const priced = catalog
+        .filter((m) => m.cost && Number.isFinite(m.cost.input) && Number.isFinite(m.cost.output))
+        .sort((a, b) => a.cost.input + a.cost.output - (b.cost.input + b.cost.output) || a.id.localeCompare(b.id));
+    if (priced.length) {
+        const index = key === "haiku" ? 0 : key === "opus" ? priced.length - 1 : Math.floor((priced.length - 1) / 2);
+        return { model: priced[index].id, how: "price" };
+    }
+    return { how: "none" };
+}
+function mapAgentModel(value, approved, catalog) {
+    const model = (value ?? "").trim();
+    if (!model || model === "inherit")
+        return {};
+    const key = model.toLowerCase();
+    if (LEVEL_LABEL[key]) {
+        const usable = (catalog ?? []).filter((m) => !approved || approved.has(m.id.replace(/^codiedev\//, "")));
+        const picked = levelToModel(key, usable);
+        if (!picked.model) {
+            return { note: `level ${LEVEL_LABEL[key]} (${model}): no matching approved model, using the governed default` };
+        }
+        return { model: picked.model, note: `level ${LEVEL_LABEL[key]} (${model}) → ${picked.model} (by ${picked.how})` };
+    }
+    if (!model.includes("/"))
+        return { note: `unknown level "${model}", using the governed default` };
+    if (approved) {
+        const bare = model.replace(/^codiedev\//, "");
+        if (!approved.has(bare))
+            return { note: `dropped model "${model}" (not approved for this Codiedev account)` };
+    }
+    return { model };
+}
+function codiePackConfig(root, options = {}) {
+    const registry = (0, store_1.readRegistry)(root);
+    const result = { skillPaths: [], agents: {}, plugins: [], notes: [] };
+    for (const [slug, entry] of Object.entries(registry.packs).sort(([a], [b]) => a.localeCompare(b))) {
+        if (!(0, manifest_1.isSafeSegment)(slug) || !Array.isArray(entry.harnesses) || !entry.harnesses.includes("codie"))
+            continue;
+        const dir = typeof entry.dir === "string" ? entry.dir : "";
+        if (!dir || !fs.existsSync(dir))
+            continue;
+        try {
+            const hooks = JSON.parse(fs.readFileSync(path.join(dir, "hooks", "hooks.json"), "utf8"))?.hooks;
+            const skipped = (0, shim_1.unsupportedShimEvents)([{ slug, root: dir, hooks: hooks ?? {} }]).get(slug);
+            if (skipped?.length)
+                result.notes.push(`pack ${slug}: hooks Codie can't run were skipped: ${skipped.join(", ")}`);
+        }
+        catch {
+        }
+        const skills = path.join(dir, "skills");
+        if (fs.existsSync(skills))
+            result.skillPaths.push(skills);
+        const agentsDir = path.join(dir, "agents");
+        let agentFiles = [];
+        try {
+            agentFiles = fs.readdirSync(agentsDir).filter((f) => f.endsWith(".md")).sort();
+        }
+        catch {
+            agentFiles = [];
+        }
+        for (const file of agentFiles) {
+            const fallbackName = file.slice(0, -3);
+            let content;
+            try {
+                content = fs.readFileSync(path.join(agentsDir, file), "utf8");
+            }
+            catch {
+                continue;
+            }
+            const { data, body } = (0, manifest_1.parseFrontmatter)(content);
+            const name = (0, manifest_1.isSafeSegment)(data.name) ? data.name : fallbackName;
+            if (result.agents[name]) {
+                result.notes.push(`agent "${name}" from pack ${slug} skipped (already defined by another pack)`);
+                continue;
+            }
+            const mapped = mapAgentModel(data.model, options.approvedModels, options.catalog);
+            if (mapped.note)
+                result.notes.push(`agent "${name}" (${slug}): ${mapped.note}`);
+            result.agents[name] = {
+                description: data.description || `${name} (from starter pack ${slug})`,
+                prompt: body.trim(),
+                mode: "subagent",
+                ...(mapped.model ? { model: mapped.model } : {}),
+            };
+        }
+    }
+    const shim = (0, paths_1.shimPath)(root);
+    const anyCodie = Object.values(registry.packs).some((e) => Array.isArray(e.harnesses) && e.harnesses.includes("codie"));
+    if (anyCodie && fs.existsSync(shim))
+        result.plugins.push((0, url_1.pathToFileURL)(shim).href);
+    return result;
+}
+function mergeCodiePackConfig(existing, packs) {
+    const next = { ...existing };
+    if (packs.skillPaths.length) {
+        const current = existing.skills;
+        const base = Array.isArray(current)
+            ? { paths: current.filter((p) => typeof p === "string") }
+            : current && typeof current === "object"
+                ? { ...current }
+                : {};
+        const paths = Array.isArray(base.paths) ? [...base.paths] : [];
+        for (const p of packs.skillPaths)
+            if (!paths.includes(p))
+                paths.push(p);
+        next.skills = { ...base, paths };
+    }
+    if (Object.keys(packs.agents).length) {
+        const current = existing.agent && typeof existing.agent === "object" ? existing.agent : {};
+        next.agent = { ...packs.agents, ...current };
+    }
+    if (packs.plugins.length) {
+        const current = Array.isArray(existing.plugin) ? [...existing.plugin] : [];
+        for (const p of packs.plugins)
+            if (!current.includes(p))
+                current.push(p);
+        next.plugin = current;
+    }
+    return next;
+}

package/dist/packs/harnesses.js

@@ -0,0 +1,411 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADAPTERS = exports.piAdapter = exports.codieAdapter = exports.cursorAdapter = exports.CURSOR_MARKER = exports.codexAdapter = exports.copilotAdapter = exports.claudeAdapter = exports.HARNESSES = void 0;
+exports.defaultRunner = defaultRunner;
+exports.onPath = onPath;
+exports.copyCursorSkills = copyCursorSkills;
+exports.removeCursorSkills = removeCursorSkills;
+exports.cursorLocalPluginsDir = cursorLocalPluginsDir;
+exports.cursorPluginDir = cursorPluginDir;
+exports.installCursorPlugin = installCursorPlugin;
+exports.removeCursorPlugin = removeCursorPlugin;
+exports.parseHarnessList = parseHarnessList;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const harnessDirs_1 = require("../harnessDirs");
+const paths_1 = require("./paths");
+exports.HARNESSES = ["claude", "copilot", "codex", "cursor", "codie", "pi"];
+function defaultRunner(env) {
+    return (command, args, options = {}) => {
+        const result = (0, child_process_1.spawnSync)(command, args, {
+            encoding: "utf8",
+            env,
+            cwd: options.cwd,
+            timeout: 180_000,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return {
+            status: result.status,
+            stdout: result.stdout ?? "",
+            stderr: result.stderr ?? "",
+            ...(result.error ? { error: result.error.message } : {}),
+        };
+    };
+}
+function onPath(bin, env) {
+    const dirs = (env.PATH ?? "").split(path.delimiter).filter(Boolean);
+    const exts = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
+    for (const dir of dirs) {
+        for (const ext of exts) {
+            const candidate = path.join(dir, bin + ext);
+            try {
+                const stat = fs.statSync(candidate);
+                if (stat.isFile()) {
+                    if (process.platform === "win32")
+                        return true;
+                    fs.accessSync(candidate, fs.constants.X_OK);
+                    return true;
+                }
+            }
+            catch {
+            }
+        }
+    }
+    return false;
+}
+function uninstallRef(slug) {
+    return `${slug}@${paths_1.MARKETPLACE_NAME}`;
+}
+function uninstallWith(ctx, bin, verb) {
+    const result = ctx.run(bin, ["plugin", verb, uninstallRef(ctx.slug)]);
+    if (result.status === 0)
+        return "uninstalled";
+    if (/not (found|installed)/i.test(`${result.stdout}\n${result.stderr}`))
+        return "already removed";
+    throw new Error(`\`${bin} plugin ${verb} ${uninstallRef(ctx.slug)}\` failed (${describe(result)})`);
+}
+function describe(result) {
+    if (result.error)
+        return result.error;
+    const text = (result.stderr || result.stdout || "").trim().split("\n").filter(Boolean).pop();
+    return text ? `exit ${result.status}: ${text.slice(0, 200)}` : `exit ${result.status}`;
+}
+function must(ctx, bin, args, options) {
+    const result = ctx.run(bin, args, options);
+    if (result.status !== 0)
+        throw new Error(`\`${bin} ${args.join(" ")}\` failed (${describe(result)})`);
+    return result;
+}
+function alreadyExists(result) {
+    return /already|exists/i.test(`${result.stdout}\n${result.stderr}`);
+}
+function wasInstalled(ctx, harness) {
+    return Boolean(ctx.previous?.harnesses?.includes(harness));
+}
+function contentChangedInPlace(ctx) {
+    const prev = ctx.previous;
+    return Boolean(prev && prev.version === ctx.manifest.version && prev.contentHash !== ctx.manifest.contentHash);
+}
+function pluginRef(ctx) {
+    return `${ctx.manifest.slug}@${paths_1.MARKETPLACE_NAME}`;
+}
+function claudeMarketplaceKnown(env, home) {
+    try {
+        const known = JSON.parse(fs.readFileSync(path.join((0, harnessDirs_1.claudeConfigDir)(env, home), "plugins", "known_marketplaces.json"), "utf8"));
+        return Boolean(known && typeof known === "object" && paths_1.MARKETPLACE_NAME in known);
+    }
+    catch {
+        return false;
+    }
+}
+function ensurePortableMarketplace(ctx, bin) {
+    const root = (0, paths_1.portableRoot)(ctx.root);
+    const stamp = path.join(root, `.registered-${bin}`);
+    if (!fs.existsSync(stamp))
+        ctx.run(bin, ["plugin", "marketplace", "remove", paths_1.MARKETPLACE_NAME]);
+    const added = ctx.run(bin, ["plugin", "marketplace", "add", root]);
+    if (added.status !== 0 && !alreadyExists(added)) {
+        throw new Error(`\`${bin} plugin marketplace add\` failed (${describe(added)})`);
+    }
+    fs.writeFileSync(stamp, `${root}\n`);
+}
+function marketplaceInstall(ctx, bin, harness, verbs, marketplaceKnown, portable = false) {
+    if (portable) {
+        ensurePortableMarketplace(ctx, bin);
+    }
+    else if (marketplaceKnown) {
+        ctx.run(bin, ["plugin", "marketplace", "update", paths_1.MARKETPLACE_NAME]);
+    }
+    else {
+        const added = ctx.run(bin, ["plugin", "marketplace", "add", ctx.root]);
+        if (added.status !== 0 && !alreadyExists(added)) {
+            throw new Error(`\`${bin} plugin marketplace add\` failed (${describe(added)})`);
+        }
+        if (added.status !== 0)
+            ctx.run(bin, ["plugin", "marketplace", "update", paths_1.MARKETPLACE_NAME]);
+    }
+    const ref = pluginRef(ctx);
+    if (wasInstalled(ctx, harness)) {
+        if (contentChangedInPlace(ctx)) {
+            ctx.run(bin, ["plugin", verbs.uninstall, ref]);
+            must(ctx, bin, ["plugin", verbs.install, ref]);
+            return "reinstalled";
+        }
+        const updated = ctx.run(bin, ["plugin", verbs.update, ref]);
+        if (updated.status === 0)
+            return "updated";
+    }
+    const installed = ctx.run(bin, ["plugin", verbs.install, ref]);
+    if (installed.status === 0)
+        return "installed";
+    if (alreadyExists(installed)) {
+        must(ctx, bin, ["plugin", verbs.update, ref]);
+        return "updated";
+    }
+    throw new Error(`\`${bin} plugin ${verbs.install} ${ref}\` failed (${describe(installed)})`);
+}
+exports.claudeAdapter = {
+    name: "claude",
+    detect: (ctx) => onPath("claude", ctx.env),
+    install: (ctx) => marketplaceInstall(ctx, "claude", "claude", { install: "install", update: "update", uninstall: "uninstall" }, claudeMarketplaceKnown(ctx.env, ctx.home)),
+    plan: (ctx) => `claude plugin marketplace add ${ctx.root}; claude plugin install ${pluginRef(ctx)}`,
+    uninstall: (ctx) => uninstallWith(ctx, "claude", "uninstall"),
+};
+exports.copilotAdapter = {
+    name: "copilot",
+    detect: (ctx) => onPath("copilot", ctx.env),
+    install: (ctx) => marketplaceInstall(ctx, "copilot", "copilot", { install: "install", update: "update", uninstall: "uninstall" }, false, true),
+    plan: (ctx) => `copilot plugin marketplace add ${(0, paths_1.portableRoot)(ctx.root)}; copilot plugin install ${pluginRef(ctx)}`,
+    uninstall: (ctx) => uninstallWith(ctx, "copilot", "uninstall"),
+};
+exports.codexAdapter = {
+    name: "codex",
+    detect: (ctx) => onPath("codex", ctx.env),
+    install: (ctx) => {
+        ensurePortableMarketplace(ctx, "codex");
+        const ref = pluginRef(ctx);
+        const reinstall = wasInstalled(ctx, "codex");
+        if (reinstall)
+            ctx.run("codex", ["plugin", "remove", ref]);
+        must(ctx, "codex", ["plugin", "add", ref]);
+        return reinstall ? "reinstalled" : "installed";
+    },
+    plan: (ctx) => `codex plugin marketplace add ${(0, paths_1.portableRoot)(ctx.root)}; codex plugin add ${pluginRef(ctx)}; trust pack hooks in config.toml`,
+    uninstall: (ctx) => uninstallWith(ctx, "codex", "remove"),
+};
+exports.CURSOR_MARKER = ".codiedev-pack";
+function cursorSkillsDir(home) {
+    return path.join(home, ".cursor", "skills");
+}
+function copyCursorSkills(home, manifest, pluginDirPath) {
+    const base = cursorSkillsDir(home);
+    fs.mkdirSync(base, { recursive: true });
+    const notes = [];
+    const wanted = new Set(manifest.skills.map((s) => s.name));
+    for (const entry of fs.readdirSync(base)) {
+        const marker = path.join(base, entry, exports.CURSOR_MARKER);
+        try {
+            if (fs.readFileSync(marker, "utf8").trim() === manifest.slug && !wanted.has(entry)) {
+                fs.rmSync(path.join(base, entry), { recursive: true, force: true });
+            }
+        }
+        catch {
+        }
+    }
+    for (const skill of manifest.skills) {
+        const dest = path.join(base, skill.name);
+        if (fs.existsSync(dest)) {
+            let owner = "";
+            try {
+                owner = fs.readFileSync(path.join(dest, exports.CURSOR_MARKER), "utf8").trim();
+            }
+            catch {
+                owner = "";
+            }
+            if (owner !== manifest.slug) {
+                notes.push(`kept existing ~/.cursor/skills/${skill.name}`);
+                continue;
+            }
+            fs.rmSync(dest, { recursive: true, force: true });
+        }
+        fs.mkdirSync(dest, { recursive: true });
+        fs.copyFileSync(path.join(pluginDirPath, "skills", skill.name, "SKILL.md"), path.join(dest, "SKILL.md"));
+        fs.writeFileSync(path.join(dest, exports.CURSOR_MARKER), `${manifest.slug}\n`);
+    }
+    return notes;
+}
+function removeCursorSkills(home, slug) {
+    const base = cursorSkillsDir(home);
+    let removed = 0;
+    let entries = [];
+    try {
+        entries = fs.readdirSync(base);
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        try {
+            if (fs.readFileSync(path.join(base, entry, exports.CURSOR_MARKER), "utf8").trim() === slug) {
+                fs.rmSync(path.join(base, entry), { recursive: true, force: true });
+                removed += 1;
+            }
+        }
+        catch {
+        }
+    }
+    return removed;
+}
+function cursorLocalPluginsDir(home) {
+    return path.join(home, ".cursor", "plugins", "local");
+}
+function cursorPluginDir(home, slug) {
+    return path.join(cursorLocalPluginsDir(home), `codiedev-${slug}`);
+}
+function markerOwner(dir) {
+    try {
+        return fs.readFileSync(path.join(dir, exports.CURSOR_MARKER), "utf8").trim();
+    }
+    catch {
+        return null;
+    }
+}
+function copyTreeNoSymlinks(source, dest, depth = 0) {
+    if (depth > 32)
+        throw new Error(`plugin tree too deep at ${source}`);
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(source)) {
+        const from = path.join(source, entry);
+        const to = path.join(dest, entry);
+        const stat = fs.statSync(from);
+        if (stat.isDirectory())
+            copyTreeNoSymlinks(from, to, depth + 1);
+        else if (stat.isFile())
+            fs.writeFileSync(to, fs.readFileSync(from));
+    }
+}
+function installCursorPlugin(home, slug, sourceDir) {
+    const parent = cursorLocalPluginsDir(home);
+    const target = cursorPluginDir(home, slug);
+    if (fs.existsSync(target) && markerOwner(target) !== slug) {
+        throw new Error(`${target} exists and wasn't written by Codiedev; leaving it alone`);
+    }
+    fs.mkdirSync(parent, { recursive: true });
+    const stamp = `${process.pid}-${Date.now()}`;
+    const tmp = path.join(parent, `.codiedev-${slug}.tmp-${stamp}`);
+    const old = path.join(parent, `.codiedev-${slug}.old-${stamp}`);
+    try {
+        copyTreeNoSymlinks(sourceDir, tmp);
+        fs.writeFileSync(path.join(tmp, exports.CURSOR_MARKER), `${slug}\n`);
+        if (fs.existsSync(target))
+            fs.renameSync(target, old);
+        fs.renameSync(tmp, target);
+    }
+    catch (error) {
+        fs.rmSync(tmp, { recursive: true, force: true });
+        if (!fs.existsSync(target) && fs.existsSync(old))
+            fs.renameSync(old, target);
+        throw error;
+    }
+    fs.rmSync(old, { recursive: true, force: true });
+    return target;
+}
+function removeCursorPlugin(home, slug) {
+    const target = cursorPluginDir(home, slug);
+    if (markerOwner(target) !== slug)
+        return false;
+    fs.rmSync(target, { recursive: true, force: true });
+    return true;
+}
+exports.cursorAdapter = {
+    name: "cursor",
+    detect: (ctx) => onPath("cursor-agent", ctx.env) || fs.existsSync(path.join(ctx.home, ".cursor")),
+    install: (ctx) => {
+        try {
+            installCursorPlugin(ctx.home, ctx.manifest.slug, ctx.portablePluginDir);
+        }
+        catch (error) {
+            const notes = copyCursorSkills(ctx.home, ctx.manifest, ctx.portablePluginDir);
+            const reason = error instanceof Error ? error.message : String(error);
+            return [`skills only (couldn't write ~/.cursor/plugins/local: ${reason})`, ...notes].join("; ");
+        }
+        const migrated = removeCursorSkills(ctx.home, ctx.manifest.slug);
+        return migrated ? `installed (removed ${migrated} old ~/.cursor/skills cop${migrated === 1 ? "y" : "ies"})` : "installed";
+    },
+    plan: (ctx) => `copy plugin to ${cursorPluginDir(ctx.home, ctx.manifest.slug)}`,
+    uninstall: (ctx) => {
+        const plugin = removeCursorPlugin(ctx.home, ctx.slug);
+        const skills = removeCursorSkills(ctx.home, ctx.slug);
+        if (!plugin && !skills)
+            return "already removed";
+        return skills ? `uninstalled (${skills} copied skill${skills === 1 ? "" : "s"} removed)` : "uninstalled";
+    },
+};
+exports.codieAdapter = {
+    name: "codie",
+    detect: () => true,
+    install: () => "loads on next `codie` launch",
+    plan: () => "inject skills/agents/hook shim at next codie launch",
+    uninstall: () => "removed from next `codie` launch",
+};
+function piSettingsPath(env, home) {
+    return path.join((0, harnessDirs_1.piAgentDir)(env, home), "settings.json");
+}
+function updatePiSkillPaths(file, update) {
+    let settings = {};
+    if (fs.existsSync(file)) {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error(`${file} is not a JSON object; leaving it alone`);
+        settings = parsed;
+    }
+    const current = Array.isArray(settings.skills) ? settings.skills.filter((p) => typeof p === "string") : [];
+    const next = update(current);
+    if (next.length === current.length && next.every((p, i) => p === current[i]))
+        return false;
+    settings.skills = next;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(settings, null, 2) + "\n");
+    fs.renameSync(tmp, file);
+    return true;
+}
+exports.piAdapter = {
+    name: "pi",
+    detect: (ctx) => onPath("pi", ctx.env) || fs.existsSync((0, harnessDirs_1.piAgentDir)(ctx.env, ctx.home)),
+    install: (ctx) => {
+        const skills = path.join(ctx.portablePluginDir, "skills");
+        const changed = updatePiSkillPaths(piSettingsPath(ctx.env, ctx.home), (paths) => paths.includes(skills) ? paths : [...paths, skills]);
+        return changed ? "installed" : "already installed";
+    },
+    plan: (ctx) => `add ${path.join(ctx.portablePluginDir, "skills")} to ${piSettingsPath(ctx.env, ctx.home)} skills`,
+    uninstall: (ctx) => {
+        const dir = (0, paths_1.pluginDir)((0, paths_1.portableRoot)(ctx.root), ctx.slug);
+        const changed = updatePiSkillPaths(piSettingsPath(ctx.env, ctx.home), (paths) => paths.filter((p) => p !== dir && !p.startsWith(dir + path.sep)));
+        return changed ? "uninstalled" : "already removed";
+    },
+};
+exports.ADAPTERS = [exports.claudeAdapter, exports.copilotAdapter, exports.codexAdapter, exports.cursorAdapter, exports.codieAdapter, exports.piAdapter];
+function parseHarnessList(value) {
+    if (value === undefined)
+        return undefined;
+    const names = value.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+    const unknown = names.filter((n) => !exports.HARNESSES.includes(n));
+    if (unknown.length)
+        throw new Error(`Unknown harness: ${unknown.join(", ")} (valid: ${exports.HARNESSES.join(", ")})`);
+    return [...new Set(names)];
+}