codiedev 0.9.67 → 0.9.68

package/dist/packs/codie.d.ts

@@ -0,0 +1,45 @@
+export interface CodiePackConfig {
+    skillPaths: string[];
+    agents: Record<string, {
+        description: string;
+        prompt: string;
+        mode: "subagent";
+        model?: string;
+    }>;
+    plugins: string[];
+    notes: string[];
+}
+/** A model the account approves, as Codie's catalog lists it. */
+export interface LevelCatalogModel {
+    id: string;
+    name?: string;
+    cost?: {
+        input: number;
+        output: number;
+    };
+    tier?: string;
+    level?: string;
+}
+/** Resolve an agent level (opus = Strongest, sonnet = Balanced, haiku =
+ * Fastest) to one of the account's approved models:
+ * 1. explicit tier/level metadata on the catalog entry, when the gateway sends it
+ * 2. the same model family by name (e.g. a "claude-opus-…" model), newest first
+ * 3. by price: Strongest = priciest, Fastest = cheapest, Balanced = in between
+ * Otherwise undefined → Codie's governed default. Only catalog ids are returned. */
+export declare function levelToModel(level: string, catalog: LevelCatalogModel[]): {
+    model?: string;
+    how: string;
+};
+/** Map a Claude agent `model:` to an OpenCode model id, or undefined to let
+ * Codie's governed default apply. */
+export declare function mapAgentModel(value: string | undefined, approved?: Set<string>, catalog?: LevelCatalogModel[]): {
+    model?: string;
+    note?: string;
+};
+export declare function codiePackConfig(root: string, options?: {
+    approvedModels?: Set<string>;
+    catalog?: LevelCatalogModel[];
+}): CodiePackConfig;
+/** Merge pack config into an OpenCode config without clobbering anything the
+ * user or Codie already set: existing skill paths, agents and plugins win. */
+export declare function mergeCodiePackConfig(existing: Record<string, any>, packs: CodiePackConfig): Record<string, any>;

package/dist/packs/codie.js

@@ -0,0 +1,197 @@
+"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;
+// Codie (our OpenCode launcher) installs nothing: at launch it reads
+// installed.json and injects the packs into OPENCODE_CONFIG_CONTENT.
+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 });
+}
+/** Resolve an agent level (opus = Strongest, sonnet = Balanced, haiku =
+ * Fastest) to one of the account's approved models:
+ * 1. explicit tier/level metadata on the catalog entry, when the gateway sends it
+ * 2. the same model family by name (e.g. a "claude-opus-…" model), newest first
+ * 3. by price: Strongest = priciest, Fastest = cheapest, Balanced = in between
+ * Otherwise undefined → Codie's governed default. Only catalog ids are returned. */
+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" };
+}
+/** Map a Claude agent `model:` to an OpenCode model id, or undefined to let
+ * Codie's governed default apply. */
+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 {
+            // no hooks
+        }
+        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 } : {}),
+            };
+        }
+    }
+    // The shim only exists while some installed pack has hooks.
+    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;
+}
+/** Merge pack config into an OpenCode config without clobbering anything the
+ * user or Codie already set: existing skill paths, agents and plugins win. */
+function mergeCodiePackConfig(existing, packs) {
+    const next = { ...existing };
+    if (packs.skillPaths.length) {
+        // `skills` must be the object form; the array form is rejected by the engine.
+        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.d.ts

@@ -0,0 +1,71 @@
+import { PackManifest } from "./manifest";
+import { RegistryEntry } from "./store";
+export declare const HARNESSES: readonly ["claude", "copilot", "codex", "cursor", "codie"];
+export type HarnessName = (typeof HARNESSES)[number];
+export interface RunResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: string;
+}
+export type Runner = (command: string, args: string[], options?: {
+    cwd?: string;
+}) => RunResult;
+export declare function defaultRunner(env: NodeJS.ProcessEnv): Runner;
+/** True when `bin` is an executable file on `env.PATH`. */
+export declare function onPath(bin: string, env: NodeJS.ProcessEnv): boolean;
+export interface AdapterContext {
+    root: string;
+    env: NodeJS.ProcessEnv;
+    home: string;
+    run: Runner;
+    manifest: PackManifest;
+    pluginDir: string;
+    /** Same plugin without agent model levels (Codex, Copilot, Cursor). */
+    portablePluginDir: string;
+    previous?: RegistryEntry;
+}
+export interface AdapterResult {
+    harness: HarnessName;
+    status: "ok" | "skipped" | "failed" | "dry-run";
+    detail: string;
+    /** Debug-level notes (printed with CODIEDEV_DEBUG; always in --json). */
+    notes?: string[];
+}
+export interface Adapter {
+    name: HarnessName;
+    detect(ctx: Omit<AdapterContext, "manifest" | "pluginDir" | "portablePluginDir" | "previous">): boolean;
+    /** Returns a short success detail; throws on failure. */
+    install(ctx: AdapterContext): string;
+    /** Human-readable description of what install would do (for --dry-run). */
+    plan(ctx: AdapterContext): string;
+    /** Remove the pack from this tool. Returns a detail; throws on failure. */
+    uninstall(ctx: UninstallContext): string;
+}
+export interface UninstallContext {
+    root: string;
+    env: NodeJS.ProcessEnv;
+    home: string;
+    run: Runner;
+    slug: string;
+}
+export declare const claudeAdapter: Adapter;
+export declare const copilotAdapter: Adapter;
+export declare const codexAdapter: Adapter;
+export declare const CURSOR_MARKER = ".codiedev-pack";
+/** Fallback: copy skills to ~/.cursor/skills/<name>/, never overwriting a
+ * skill dir Codiedev didn't write, and pruning ones this pack no longer has. */
+export declare function copyCursorSkills(home: string, manifest: PackManifest, pluginDirPath: string): string[];
+/** Remove every ~/.cursor/skills dir this pack's fallback copy wrote. */
+export declare function removeCursorSkills(home: string, slug: string): number;
+export declare function cursorLocalPluginsDir(home: string): string;
+export declare function cursorPluginDir(home: string, slug: string): string;
+/** Copy the plugin dir into place via a sibling temp dir + rename. Refuses to
+ * replace a dir that doesn't carry our marker for this pack. */
+export declare function installCursorPlugin(home: string, slug: string, sourceDir: string): string;
+/** Remove our copy (only when it carries our marker). */
+export declare function removeCursorPlugin(home: string, slug: string): boolean;
+export declare const cursorAdapter: Adapter;
+export declare const codieAdapter: Adapter;
+export declare const ADAPTERS: Adapter[];
+export declare function parseHarnessList(value: string | undefined): HarnessName[] | undefined;