@catalyst-cloud/catalyst-skills 0.5.0 → 0.8.0

package/dist/replica.js

@@ -1,325 +0,0 @@
-// replica.ts — the optional local replica: `replica start|stop|status|sql|schema`.
-//
-// `status` is the check every skill runs first and it needs no network and no SDK: the pidfile, the
-// writer-lock heartbeat, and the `sync_meta.cursor` row (read through node:sqlite read-only). Exit
-// 0 fresh, 1 present but stale, 2 not configured, 3 absent. `--probe` adds the one network call.
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { DatabaseSync } from "node:sqlite";
-import { createRequire } from "node:module";
-import { flagBool, flagInt, flagString, positionals } from "./args.js";
-import { apiBase, loadConfig, replicaDbPath } from "./config.js";
-import { detachSelf } from "./detach.js";
-import { CliError, UsageError } from "./errors.js";
-import { apiClient } from "./transport.js";
-import { authStrategyFor } from "./oauth.js";
-import { loadSdk } from "./sdk.js";
-import { createEventSync } from "./events.js";
-export const DEFAULT_STALE_MS = 15_000;
-export function pidfilePath(dbPath) {
-    return `${dbPath}.pid`;
-}
-export function lockPath(dbPath) {
-    return `${dbPath}.writer.lock`;
-}
-export function pidAlive(pid) {
-    if (pid === null || !Number.isInteger(pid) || pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (err) {
-        return err.code === "EPERM";
-    }
-}
-export function readPidfile(dbPath) {
-    const p = pidfilePath(dbPath);
-    if (!existsSync(p))
-        return null;
-    const n = Number(readFileSync(p, "utf8").trim());
-    return Number.isInteger(n) ? n : null;
-}
-function readLock(dbPath) {
-    try {
-        const rec = JSON.parse(readFileSync(lockPath(dbPath), "utf8"));
-        if (typeof rec.pid === "number" && typeof rec.heartbeat === "number")
-            return { pid: rec.pid, heartbeat: rec.heartbeat };
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Read `sync_meta.cursor` read-only through node:sqlite; null when the table or row is absent. */
-export function readCursor(dbPath) {
-    let db = null;
-    try {
-        db = new DatabaseSync(dbPath, { readOnly: true });
-        const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'sync_meta'").get();
-        if (!table)
-            return null;
-        const row = db.prepare("SELECT value FROM sync_meta WHERE key = 'cursor'").get();
-        if (!row || row.value === null || row.value === undefined || row.value === "")
-            return null;
-        const n = Number(row.value);
-        return Number.isInteger(n) ? n : null;
-    }
-    catch {
-        return null;
-    }
-    finally {
-        db?.close();
-    }
-}
-/** The in-process status logic `query` and `ready` reuse. */
-export function replicaStatus(ctx, cfg, opts = {}) {
-    const base = {
-        verdict: "not-configured",
-        exitCode: 2,
-        dbPath: null,
-        cursor: null,
-        heartbeatAgeMs: null,
-        lockPid: null,
-        pidfilePid: null,
-        writerAlive: false,
-        reasons: [],
-    };
-    if (!cfg)
-        return { ...base, reasons: ["not connected"] };
-    const dbPath = opts.dbPath ?? replicaDbPath(cfg, ctx.home);
-    if (!existsSync(dbPath))
-        return { ...base, verdict: "absent", exitCode: 3, dbPath, reasons: ["no replica file"] };
-    const staleMs = opts.staleMs ?? DEFAULT_STALE_MS;
-    const nowMs = opts.nowMs ?? ctx.now().getTime();
-    const lock = readLock(dbPath);
-    const pidfilePid = readPidfile(dbPath);
-    const heartbeatAgeMs = lock ? Math.max(0, nowMs - lock.heartbeat) : null;
-    const writerAlive = pidAlive(lock?.pid ?? null) || pidAlive(pidfilePid);
-    const cursor = readCursor(dbPath);
-    const reasons = [];
-    if (!lock)
-        reasons.push("no writer lock");
-    else if (heartbeatAgeMs !== null && heartbeatAgeMs >= staleMs)
-        reasons.push(`heartbeat ${heartbeatAgeMs}ms old (stale after ${staleMs}ms)`);
-    if (cursor === null)
-        reasons.push("no cursor");
-    if (!writerAlive)
-        reasons.push("no live writer process");
-    const fresh = reasons.length === 0;
-    return {
-        verdict: fresh ? "fresh" : "stale",
-        exitCode: fresh ? 0 : 1,
-        dbPath,
-        cursor,
-        heartbeatAgeMs,
-        lockPid: lock?.pid ?? null,
-        pidfilePid,
-        writerAlive,
-        reasons,
-    };
-}
-export function statusLine(s) {
-    switch (s.verdict) {
-        case "not-configured":
-            return "replica: not configured — run login first";
-        case "absent":
-            return `replica: absent at ${s.dbPath} — start it with: catalyst-skills replica start --detach`;
-        case "fresh":
-            return `replica: fresh at ${s.dbPath} (cursor ${s.cursor}, heartbeat ${s.heartbeatAgeMs}ms ago${s.lag !== undefined ? `, ${s.lag} behind head ${s.head}` : ""})`;
-        case "stale":
-            return `replica: stale at ${s.dbPath} (${s.reasons.join("; ")}${s.cursor !== null ? `; cursor ${s.cursor}` : ""}) — reads fall back to the API`;
-    }
-}
-/** better-sqlite3 when it resolves and constructs, else node:sqlite — with exactly one stderr line
- *  on the fallback so the choice is visible. */
-export async function engineFor(sdk, dbPath, ctx, deps = {}) {
-    const requireDriver = deps.requireDriver ?? (() => createRequire(import.meta.url)("better-sqlite3"));
-    try {
-        const mod = requireDriver();
-        const driver = (mod && typeof mod === "object" && "default" in mod ? mod.default : mod);
-        if (typeof driver !== "function")
-            throw new Error("better-sqlite3 resolved to a non-constructor");
-        return deps.readonly ? sdk.betterSqlite3ReadonlyEngine(driver, dbPath) : sdk.betterSqlite3Engine(driver, dbPath);
-    }
-    catch (err) {
-        const why = err instanceof Error ? err.message.split("\n")[0] : String(err);
-        ctx.stderr(`[catalyst-skills] better-sqlite3 unavailable (${why}); using node:sqlite`);
-        return deps.readonly ? sdk.nodeSqliteReadonlyEngine(dbPath) : sdk.nodeSqliteEngine(dbPath);
-    }
-}
-export async function cmdReplica(args, ctx, deps = {}) {
-    const [sub, ...rest] = positionals(args);
-    if (!sub)
-        throw new UsageError("replica needs a subcommand: start | stop | status | sql | schema");
-    if (sub === "status")
-        return cmdStatus(args, ctx);
-    const cfg = loadConfig(ctx.home);
-    if (!cfg)
-        throw new CliError("not connected yet — run login first", "not-configured");
-    const dbPath = flagString(args, "db") ?? replicaDbPath(cfg, ctx.home);
-    switch (sub) {
-        case "start":
-            return cmdStart(args, ctx, cfg, dbPath, deps);
-        case "stop":
-            return cmdStop(ctx, dbPath);
-        case "sql":
-            return cmdSql(args, ctx, dbPath, rest.join(" "), deps);
-        case "schema":
-            return cmdSchema(args, ctx, dbPath, rest[0]);
-        default:
-            throw new UsageError(`unknown replica subcommand: ${sub}`);
-    }
-}
-async function cmdStatus(args, ctx) {
-    let cfg;
-    try {
-        cfg = loadConfig(ctx.home);
-    }
-    catch {
-        cfg = null;
-    }
-    const status = replicaStatus(ctx, cfg, {
-        staleMs: flagInt(args, "stale-ms", DEFAULT_STALE_MS),
-        dbPath: flagString(args, "db"),
-    });
-    if (flagBool(args, "probe") && cfg && status.verdict !== "not-configured") {
-        const head = await apiClient(cfg, ctx).getJson("/api/v1/snapshot", { query: { head: 1 } });
-        if (typeof head.body.cursor === "number") {
-            status.head = head.body.cursor;
-            status.lag = status.cursor === null ? head.body.cursor : head.body.cursor - status.cursor;
-        }
-    }
-    ctx.stdout(args.json ? JSON.stringify(status) : statusLine(status));
-    return status.exitCode;
-}
-async function cmdStart(args, ctx, cfg, dbPath, deps) {
-    if (flagBool(args, "detach")) {
-        const argv = (deps.argv ?? process.argv.slice(1)).filter((a) => a !== "--detach");
-        const { pid } = (deps.detach ?? detachSelf)(argv, ctx.env);
-        writeFileSync(pidfilePath(dbPath), `${pid}\n`);
-        ctx.stdout(`replica writer started in the background (pid ${pid}, db ${dbPath}); check with: catalyst-skills replica status`);
-        return 0;
-    }
-    const sdk = await loadSdk();
-    const engine = await engineFor(sdk, dbPath, ctx, deps.engineDeps);
-    const replica = new sdk.CatalystReplica({
-        baseUrl: apiBase(cfg),
-        account: cfg.account,
-        accountSource: "declared",
-        auth: authStrategyFor(ctx, cfg),
-        dbPath,
-        engine,
-        fetchImpl: ctx.fetch,
-        wsFactory: deps.wsFactory,
-        log: (level, msg, extra) => ctx.stderr(`[replica ${level}] ${msg}${extra ? ` ${safeJson(extra)}` : ""}`),
-        onStatus: (s) => ctx.stderr(`[replica] status=${s}`),
-    });
-    await replica.start();
-    const eventSync = await createEventSync(ctx, { loadSdk: deps.loadEventsSdk });
-    void eventSync.start().catch((error) => {
-        ctx.stderr(`[events] sync failed: ${error instanceof Error ? error.message : String(error)}; replica remains live`);
-    });
-    ctx.stdout(`replica live at ${dbPath} (cursor ${replica.cursor ?? "none"}); event cache active — Ctrl-C to stop`);
-    const wait = deps.waitForStop ??
-        (() => new Promise((resolve) => {
-            const done = () => resolve();
-            process.once("SIGINT", done);
-            process.once("SIGTERM", done);
-        }));
-    await wait();
-    await eventSync.stop();
-    await replica.close();
-    try {
-        if (readPidfile(dbPath) === process.pid)
-            unlinkSync(pidfilePath(dbPath));
-    }
-    catch {
-        // pidfile already gone
-    }
-    ctx.stdout("replica stopped");
-    return 0;
-}
-function cmdStop(ctx, dbPath) {
-    const pid = readPidfile(dbPath);
-    if (pid === null) {
-        ctx.stdout(`no pidfile at ${pidfilePath(dbPath)} — nothing to stop (a foreground writer is stopped with Ctrl-C)`);
-        return 1;
-    }
-    if (!pidAlive(pid)) {
-        unlinkSync(pidfilePath(dbPath));
-        ctx.stdout(`pid ${pid} is not running; removed the stale pidfile`);
-        return 1;
-    }
-    process.kill(pid, "SIGTERM");
-    try {
-        unlinkSync(pidfilePath(dbPath));
-    }
-    catch {
-        // already removed by the writer
-    }
-    ctx.stdout(`sent SIGTERM to replica writer pid ${pid}`);
-    return 0;
-}
-const SELECT_ONLY = /^\s*(select|with)\b/i;
-export function assertSingleSelect(sql) {
-    const trimmed = sql.trim().replace(/;\s*$/, "");
-    if (!trimmed)
-        throw new UsageError('replica sql needs a query: replica sql "select ..."');
-    if (!SELECT_ONLY.test(trimmed) || trimmed.includes(";")) {
-        throw new UsageError("replica sql runs exactly one SELECT (or WITH ... SELECT); nothing else is accepted on a read-only handle");
-    }
-    return trimmed;
-}
-async function cmdSql(args, ctx, dbPath, sql, deps) {
-    const query = assertSingleSelect(sql);
-    if (!existsSync(dbPath))
-        throw new CliError(`no replica at ${dbPath} — start it with: catalyst-skills replica start --detach`, "replica-absent", 3);
-    const sdk = await loadSdk();
-    const engine = await engineFor(sdk, dbPath, ctx, { ...deps.engineDeps, readonly: true });
-    const replica = await sdk.CatalystReplica.openReadOnly({ dbPath, engine, log: () => { } });
-    try {
-        const rows = replica.sql.exec(query).toArray();
-        ctx.stdout(JSON.stringify(rows, null, args.json ? 0 : 2));
-        return 0;
-    }
-    finally {
-        await replica.close();
-    }
-}
-async function cmdSchema(args, ctx, dbPath, table) {
-    if (!existsSync(dbPath))
-        throw new CliError(`no replica at ${dbPath} — the schema is what the file holds; start it with: catalyst-skills replica start --detach`, "replica-absent", 3);
-    const db = new DatabaseSync(dbPath, { readOnly: true });
-    try {
-        const tables = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name").all().map((r) => r.name);
-        const wanted = table ? tables.filter((t) => t === table) : tables;
-        if (table && wanted.length === 0)
-            throw new CliError(`no table "${table}" in the replica (tables: ${tables.join(", ")})`, "table-unknown");
-        const out = {};
-        for (const t of wanted) {
-            out[t] = db.prepare(`PRAGMA table_info("${t.replace(/"/g, '""')}")`).all().map((c) => ({
-                name: c.name,
-                type: c.type,
-                notnull: c.notnull,
-                pk: c.pk,
-            }));
-        }
-        if (args.json)
-            ctx.stdout(JSON.stringify(out));
-        else
-            for (const [t, cols] of Object.entries(out))
-                ctx.stdout(`${t}: ${cols.map((c) => `${c.name} ${c.type || "ANY"}${c.pk ? " PK" : ""}`).join(", ")}`);
-        return 0;
-    }
-    finally {
-        db.close();
-    }
-}
-function safeJson(v) {
-    try {
-        return JSON.stringify(v);
-    }
-    catch {
-        return String(v);
-    }
-}

package/dist/sdk.js

@@ -1,26 +0,0 @@
-import { CliError } from "./errors.js";
-import { installTsDepsLoader } from "./ts-deps-loader.js";
-let cached = null;
-const realImport = () => import("@catalyst-cloud/sdk/node");
-/** Import the SDK's node entry, installing the type-stripping loader first. Cached per process. */
-export function loadSdk(importer = realImport) {
-    if (!cached) {
-        cached = (async () => {
-            const verdict = installTsDepsLoader();
-            try {
-                return await importer();
-            }
-            catch (err) {
-                cached = null;
-                const detail = err instanceof Error ? err.message.split("\n")[0] : String(err);
-                const why = verdict.installed ? "" : ` (${verdict.reason})`;
-                throw new CliError(`the Catalyst Cloud SDK could not be loaded on Node ${process.version}${why}: ${detail} — this verb needs the SDK; run under Node 22.15 or newer, or under bun`, "sdk-unavailable");
-            }
-        })();
-    }
-    return cached;
-}
-/** Test seam: forget the cached import. */
-export function resetSdkCache() {
-    cached = null;
-}

package/dist/skill-shape.js

@@ -1,179 +0,0 @@
-// skill-shape.ts — `validateSkillDir(dir)`: every problem with one skill directory, one string each.
-// The rules are the packaging pipeline's, the plugin shape gate's, the cloud validator's, and this
-// bundle's own content prohibitions, so a skill that passes here installs and publishes everywhere.
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { basename, join, relative } from "node:path";
-export const PROVENANCE_MARKER = "vendored-from: @catalyst-cloud/catalyst-skills";
-export const MAX_SKILL_LINES = 80;
-export const MAX_REFERENCE_LINES = 150;
-export const MAX_DESCRIPTION_CHARS = 1024;
-/** Strings no customer-facing skill file may contain. */
-export const FORBIDDEN_CONTENT = [
-    { name: "the maintainer tenant (tenant-0)", re: /tenant-0/ },
-    // The public bundle repository is `coalesce-labs/catalyst-cloud-skills`, whose name CONTAINS the
-    // private repository's, so this one has to end at a word boundary or it bans its own README.
-    { name: "the private catalyst repository (coalesce-labs/catalyst)", re: /coalesce-labs\/catalyst(?![-\w])/ },
-    { name: "the fleet thoughts repository (thoughts/)", re: /thoughts\// },
-    { name: "an internal ticket id", re: /\bC[TL]C-\d+\b/ },
-    { name: "a Linear CLI name (linearis)", re: /linearis/i },
-    { name: "the internal replica tool name (catalyst-replica)", re: /catalyst-replica/ },
-];
-function walk(dir) {
-    const out = [];
-    for (const e of readdirSync(dir, { withFileTypes: true })) {
-        const p = join(dir, e.name);
-        if (e.isDirectory())
-            out.push(...walk(p));
-        else
-            out.push(p);
-    }
-    return out;
-}
-/** A flat `key: value` parser with block-scalar support for one key spanning indented lines. */
-export function parseFrontmatter(lines) {
-    if (lines[0] !== "---")
-        return null;
-    const fields = {};
-    let closeIndex = -1;
-    let current = null;
-    for (let i = 1; i < lines.length; i++) {
-        const line = lines[i];
-        if (line === "---") {
-            closeIndex = i;
-            break;
-        }
-        const m = /^([A-Za-z][A-Za-z0-9_-]*):\s?(.*)$/.exec(line);
-        if (m && !/^\s/.test(line)) {
-            current = m[1];
-            const v = m[2].trim();
-            fields[current] = v === "|" || v === ">" || v === "|-" || v === ">-" ? "" : v.replace(/^"(.*)"$/, "$1");
-            continue;
-        }
-        if (current && /^\s+\S/.test(line)) {
-            fields[current] = `${fields[current]}${fields[current] ? " " : ""}${line.trim()}`;
-        }
-    }
-    return closeIndex === -1 ? { fields, closeIndex } : { fields, closeIndex };
-}
-const IMPORT_RE = /(?:from\s+|import\s*\(\s*|require\s*\(\s*)["']([^"']+)["']/g;
-export function validateSkillDir(dir) {
-    const problems = [];
-    const name = basename(dir);
-    if (!existsSync(dir) || !statSync(dir).isDirectory())
-        return [`${dir} is not a directory`];
-    const skillMd = join(dir, "SKILL.md");
-    if (!existsSync(skillMd))
-        return [`${name}: SKILL.md is missing`];
-    const md = readFileSync(skillMd, "utf8");
-    const lines = md.split("\n");
-    if (lines.at(-1) === "")
-        lines.pop();
-    if (lines.length > MAX_SKILL_LINES)
-        problems.push(`${name}: SKILL.md is ${lines.length} lines (max ${MAX_SKILL_LINES})`);
-    const fm = parseFrontmatter(lines);
-    let mutatingFrontmatter = false;
-    if (!fm)
-        problems.push(`${name}: SKILL.md must start with YAML frontmatter (---)`);
-    else {
-        if (fm.closeIndex === -1)
-            problems.push(`${name}: SKILL.md is missing a closing frontmatter fence`);
-        if (!fm.fields.name)
-            problems.push(`${name}: frontmatter is missing "name"`);
-        else if (fm.fields.name !== name)
-            problems.push(`${name}: frontmatter name "${fm.fields.name}" must match the directory`);
-        if (fm.fields.description === undefined || fm.fields.description.trim() === "")
-            problems.push(`${name}: frontmatter is missing "description"`);
-        else if (fm.fields.description.length > MAX_DESCRIPTION_CHARS)
-            problems.push(`${name}: description is ${fm.fields.description.length} characters (max ${MAX_DESCRIPTION_CHARS})`);
-        mutatingFrontmatter = fm.fields["disable-model-invocation"] === "true";
-        if (fm.closeIndex !== -1) {
-            const after = lines[fm.closeIndex + 1] ?? "";
-            if (!(after.startsWith("<!--") && after.includes(PROVENANCE_MARKER))) {
-                problems.push(`${name}: the line after the frontmatter must be the HTML provenance comment containing "${PROVENANCE_MARKER}"`);
-            }
-        }
-    }
-    const refsDir = join(dir, "references");
-    if (existsSync(refsDir)) {
-        const refs = readdirSync(refsDir).filter((f) => f.endsWith(".md")).sort();
-        if (refs.length === 0)
-            problems.push(`${name}: references/ is empty`);
-        const table = /^## Load on demand\s*$/m.test(md);
-        if (refs.length > 0 && !table)
-            problems.push(`${name}: SKILL.md has no "## Load on demand" table`);
-        for (const f of refs) {
-            const body = readFileSync(join(refsDir, f), "utf8").split("\n");
-            if (body.at(-1) === "")
-                body.pop();
-            if (body.length > MAX_REFERENCE_LINES)
-                problems.push(`${name}: references/${f} is ${body.length} lines (max ${MAX_REFERENCE_LINES})`);
-            if (!md.includes(`references/${f}`))
-                problems.push(`${name}: references/${f} is not linked from SKILL.md by its literal path`);
-        }
-    }
-    const scriptsDir = join(dir, "scripts");
-    if (existsSync(scriptsDir)) {
-        for (const p of walk(scriptsDir).filter((f) => f.endsWith(".mjs"))) {
-            const rel = relative(dir, p);
-            const src = readFileSync(p, "utf8");
-            if (!src.startsWith("#!/usr/bin/env node"))
-                problems.push(`${name}: ${rel} must start with #!/usr/bin/env node`);
-            if (!src.includes("--help"))
-                problems.push(`${name}: ${rel} has no --help`);
-            for (const m of src.matchAll(IMPORT_RE)) {
-                const spec = m[1];
-                if (!(spec.startsWith("node:") || spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/"))) {
-                    problems.push(`${name}: ${rel} imports "${spec}"; scripts may import only node: modules and relative files`);
-                }
-            }
-        }
-    }
-    const portability = join(dir, "agents", "portability.yaml");
-    const openai = join(dir, "agents", "openai.yaml");
-    let mutating = false;
-    let implicitFalse = false;
-    if (!existsSync(portability))
-        problems.push(`${name}: agents/portability.yaml is missing`);
-    else {
-        const y = readFileSync(portability, "utf8");
-        if (!/^effects:\s*.*$/m.test(y))
-            problems.push(`${name}: agents/portability.yaml does not declare "effects"`);
-        if (!/^exposure:\s*\[\s*"?catalog"?\s*\]\s*$/m.test(y))
-            problems.push(`${name}: agents/portability.yaml must declare exposure: [catalog]`);
-        mutating = /^mutating:\s*true\s*$/m.test(y);
-    }
-    if (!existsSync(openai))
-        problems.push(`${name}: agents/openai.yaml is missing`);
-    else {
-        const y = readFileSync(openai, "utf8");
-        if (!/^policy:\s*$/m.test(y))
-            problems.push(`${name}: agents/openai.yaml has no "policy:" block`);
-        if (!/allow_implicit_invocation:\s*(true|false)/.test(y))
-            problems.push(`${name}: agents/openai.yaml does not set policy.allow_implicit_invocation`);
-        implicitFalse = /allow_implicit_invocation:\s*false/.test(y);
-    }
-    if (mutating || mutatingFrontmatter || implicitFalse) {
-        if (!mutating)
-            problems.push(`${name}: disable-model-invocation / allow_implicit_invocation: false are set but agents/portability.yaml lacks mutating: true`);
-        if (!mutatingFrontmatter)
-            problems.push(`${name}: is mutating but SKILL.md does not set disable-model-invocation: true`);
-        if (!implicitFalse)
-            problems.push(`${name}: is mutating but agents/openai.yaml does not set policy.allow_implicit_invocation: false`);
-    }
-    for (const p of walk(dir)) {
-        const rel = relative(dir, p);
-        if (/\.log$/i.test(rel))
-            problems.push(`${name}: ${rel} is a log file; no *.log may ship in a skill`);
-        let text;
-        try {
-            text = readFileSync(p, "utf8");
-        }
-        catch {
-            continue;
-        }
-        for (const f of FORBIDDEN_CONTENT)
-            if (f.re.test(text))
-                problems.push(`${name}: ${rel} mentions ${f.name}`);
-    }
-    return problems;
-}

package/dist/skills.js

@@ -1,78 +0,0 @@
-// skills.ts — copying the bundled skills into the user's skills directory, and the one-line update
-// notice a new version prints on its next session.
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { PACKAGE_NAME, defaultSkillsDirFor } from "./config.js";
-import { PROVENANCE_MARKER } from "./skill-shape.js";
-export function skillsSourceDir() {
-    return fileURLToPath(new URL("../skills", import.meta.url));
-}
-/**
- * Copy every `skills/<name>/` that has a SKILL.md. A target directory whose SKILL.md lacks the
- * provenance marker was not installed by this package and is skipped unless `force`.
- *
- * `onlyExisting` is the update path: it refreshes copies this package already made and creates
- * none. That is what keeps the update notice from planting a second copy of every skill beside a
- * set the customer's agent installed as a plugin.
- */
-export function installSkills(targetDir, opts, sourceDir = skillsSourceDir()) {
-    const result = { installed: [], skipped: [] };
-    if (existsSync(targetDir) && !statSync(targetDir).isDirectory()) {
-        throw new Error(`${targetDir} is not a directory`);
-    }
-    const names = readdirSync(sourceDir, { withFileTypes: true })
-        .filter((e) => e.isDirectory())
-        .map((e) => e.name)
-        .sort();
-    for (const name of names) {
-        const src = join(sourceDir, name);
-        if (!existsSync(join(src, "SKILL.md")))
-            continue;
-        const dst = join(targetDir, name);
-        const existingMd = join(dst, "SKILL.md");
-        if (opts.onlyExisting && !existsSync(existingMd))
-            continue;
-        if (existsSync(existingMd) && !opts.force) {
-            const existing = readFileSync(existingMd, "utf8");
-            if (!existing.includes(PROVENANCE_MARKER)) {
-                result.skipped.push({ name, reason: "foreign-skill-dir" });
-                continue;
-            }
-        }
-        mkdirSync(dst, { recursive: true });
-        cpSync(src, dst, { recursive: true });
-        result.installed.push(name);
-    }
-    return result;
-}
-export function resolveSkillsDir(args, ctx, cfg) {
-    return args.skillsDir ?? ctx.env.CATALYST_SKILLS_CLAUDE_DIR ?? cfg?.skillsDir ?? defaultSkillsDirFor(ctx.home);
-}
-export function parseChangelogEntry(changelog, version) {
-    const lines = changelog.split("\n");
-    const heading = `## ${version}`;
-    const start = lines.findIndex((l) => l.trim() === heading);
-    if (start === -1)
-        return null;
-    for (const line of lines.slice(start + 1)) {
-        const t = line.trim();
-        if (t === "")
-            continue;
-        if (t.startsWith("#"))
-            break;
-        return t;
-    }
-    return null;
-}
-export function readChangelog() {
-    return readFileSync(new URL("../CHANGELOG.md", import.meta.url), "utf8");
-}
-export function updateNoticeLine(previous, current, entry) {
-    const summary = entry ?? "see CHANGELOG.md";
-    // `npm update -g` treats a global install as a caret range, and a caret below 1.0.0 never moves a
-    // minor — so it never crosses 0.2.x → 0.3.0. Pin @latest via `npm install`, THEN re-run login: the
-    // install alone does not rewrite customer.json.cliPath, so the skill helpers would keep spawning the
-    // stale recorded bundle and repeat this notice forever; the new global bin records its own path.
-    return `[catalyst-skills] updated ${previous} → ${current}: ${summary} · update with: npm install -g ${PACKAGE_NAME}@latest && catalyst-skills login`;
-}