@ccoalm/ccl-skills 0.1.0

package/dist/paths.d.ts

@@ -0,0 +1,20 @@
+export declare const PACKAGE = "@ccoalm/ccl-skills", MARKET = "ccl-skills-npm", REF = "ccl-skills@ccl-skills-npm", LEGACY_REF = "ccl-skills@ccl-skills";
+import type { FsDependencies } from "./fs-safe.js";
+export type InterruptionCheckpoint = "before-first-mutation" | "after-old-plugin-remove" | "after-old-marketplace-remove" | "after-candidate-marketplace-add" | "after-candidate-plugin-add" | "after-public-verify-before-manifest" | "after-manifest-commit" | "after-uninstall-plugin-remove" | "after-uninstall-marketplace-remove" | "after-uninstall-public-absent-commit";
+export type PathContext = {
+    assets?: string;
+    fs?: Partial<FsDependencies>;
+    isInterrupted?: (checkpoint?: InterruptionCheckpoint) => boolean;
+    checkpoint?: (name: InterruptionCheckpoint) => boolean;
+};
+export declare function paths(context?: PathContext): {
+    home: string;
+    codexHome: string;
+    root: string;
+    snapshots: string;
+    manifest: string;
+    journal: string;
+    lock: string;
+    assets: string;
+    release: string;
+};

package/dist/paths.js

@@ -0,0 +1,4 @@
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export const PACKAGE = "@ccoalm/ccl-skills", MARKET = "ccl-skills-npm", REF = "ccl-skills@ccl-skills-npm", LEGACY_REF = "ccl-skills@ccl-skills";
+export function paths(context = {}) { const home = process.env.HOME || "", codexHome = resolve(process.env.CODEX_HOME || join(home, ".codex")), root = join(codexHome, "ccl-skills-npm"), assets = resolve(context.assets || join(dirname(fileURLToPath(import.meta.url)), "assets")); return { home, codexHome, root, snapshots: join(root, "snapshots"), manifest: join(root, "install-manifest.json"), journal: join(root, "operation-journal.json"), lock: `${root}.lock`, assets, release: join(assets, "release.json") }; }

package/dist/types.d.ts

@@ -0,0 +1,58 @@
+export type ExitCode = 0 | 1 | 2 | 3 | 4 | 5 | 130;
+export type Host = "claude" | "codex" | "opencode";
+export interface Result {
+    code: ExitCode;
+    status: string;
+    message: string;
+    plan?: string[];
+    trust?: "pending-unverified";
+    details?: Record<string, unknown>;
+    interrupted?: boolean;
+}
+export interface Options {
+    yes?: boolean;
+    allowDowngrade?: boolean;
+    host?: Host;
+}
+export interface OwnedFile {
+    path: string;
+    sha256: string;
+    mode: number;
+}
+export interface Release {
+    schema: number;
+    npmPackage: string;
+    version: string;
+    sourceCommit: string;
+    sourceState: "clean" | "development-dirty";
+    files: OwnedFile[];
+    runtime: OwnedFile[];
+    snapshotHash: string;
+}
+export interface SnapshotMetadata {
+    path: string;
+    version: string;
+    sourceCommit: string;
+    sourceState: "clean" | "development-dirty";
+    snapshotHash: string;
+    ownedFiles: OwnedFile[];
+}
+export interface Manifest {
+    schema: 2;
+    active: SnapshotMetadata;
+    previous: SnapshotMetadata | null;
+}
+export interface Journal {
+    schema: 1;
+    operation: string;
+    step: string;
+    startedAt: string;
+    oldSource?: string | null;
+    candidateSource?: string | null;
+    completed?: string[];
+    error?: string;
+    trashPath?: string;
+    snapshot?: SnapshotMetadata;
+    committed?: boolean;
+    deletedFiles?: string[];
+}

package/dist/types.js

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

package/dist/unified.d.ts

@@ -0,0 +1,4 @@
+import type { PathContext } from "./paths.js";
+import type { Host, Options, Result } from "./types.js";
+export declare function runHostSequence(hosts: Host[], invoke: (host: Host) => Result): Result;
+export declare function runUnified(command: string, options?: Options, codexContext?: PathContext): Result;

package/dist/unified.js

@@ -0,0 +1,64 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { runClaude } from "./claude-adapter.js";
+import { run as runCodex } from "./operations.js";
+import { runOpenCode } from "./opencode-adapter.js";
+function available(host) {
+    const command = host === "opencode" ? "opencode" : host;
+    const result = spawnSync(command, ["--version"], { encoding: "utf8" });
+    return !result.error && result.status === 0;
+}
+function owned(host) {
+    const home = process.env.HOME;
+    if (!home)
+        return false;
+    const manifest = host === "claude"
+        ? join(resolve(home), ".claude/ccl-skills-npm/install-manifest.json")
+        : host === "opencode"
+            ? join(resolve(home), ".config/opencode/ccl-skills-npm/install-manifest.json")
+            : join(resolve(process.env.CODEX_HOME || join(home, ".codex")), "ccl-skills-npm/install-manifest.json");
+    return existsSync(manifest);
+}
+function dispatch(host, command, options, codexContext) {
+    if (host === "claude")
+        return runClaude(command, options, codexContext);
+    if (host === "opencode")
+        return runOpenCode(command, options, codexContext);
+    return runCodex(command, options, codexContext);
+}
+export function runHostSequence(hosts, invoke) {
+    const results = [];
+    for (const host of hosts) {
+        const result = invoke(host);
+        results.push({ host, result });
+        if (result.code === 5 || result.code === 130)
+            break;
+    }
+    if (hosts.length === 1)
+        return results[0].result;
+    const failed = results.filter(({ result }) => result.code !== 0);
+    const code = failed.some(({ result }) => result.code === 130)
+        ? 130
+        : failed.some(({ result }) => result.code === 5)
+            ? 5
+            : failed.length
+                ? failed[0].result.code
+                : 0;
+    return {
+        code,
+        status: failed.length ? "multi-host-partial" : "multi-host-complete",
+        message: results.map(({ host, result }) => `${host}: ${result.status}`).join("; "),
+        details: { hosts: Object.fromEntries(results.map(({ host, result }) => [host, result])) },
+        ...(code === 130 ? { interrupted: true } : {}),
+    };
+}
+export function runUnified(command, options = {}, codexContext = {}) {
+    if (options.host)
+        return dispatch(options.host, command, options, codexContext);
+    const includeOwned = command === "doctor" || command === "uninstall";
+    const hosts = ["claude", "codex", "opencode"].filter((host) => command === "update" ? available(host) && owned(host) : available(host) || (includeOwned && owned(host)));
+    if (!hosts.length)
+        return { code: 4, status: "host-missing", message: "none of Claude Code, Codex, or OpenCode is installed" };
+    return runHostSequence(hosts, (host) => dispatch(host, command, { ...options, host }, codexContext));
+}

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare function compare(a: string, b: string): number;
+export declare function parseVersion(text: string): string | null;

package/dist/version.js

@@ -0,0 +1,5 @@
+export function compare(a, b) { const x = a.split(".").map(Number), y = b.split(".").map(Number); for (let i = 0; i < 3; i++) {
+    if ((x[i] || 0) !== (y[i] || 0))
+        return (x[i] || 0) - (y[i] || 0);
+} return 0; }
+export function parseVersion(text) { return text.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] || null; }

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@ccoalm/ccl-skills",
+	"version": "0.1.0",
+  "description": "Self-contained CCL Skills installer for Claude Code, Codex, and OpenCode",
+	"keywords": ["agent-skills", "claude-code", "codex", "opencode", "developer-tools"],
+  "type": "module",
+  "bin": { "ccl-skills": "dist/cli.js" },
+  "exports": { ".": "./dist/index.js", "./package.json": "./package.json" },
+  "files": ["dist", "dist/assets/marketplace/.agents/plugins/marketplace.json", "LICENSE", "README.md"],
+  "scripts": {
+    "clean": "rm -rf dist *.tgz",
+    "build": "tsc && chmod 755 dist/cli.js && node scripts/build-assets.mjs",
+    "test": "npm run build && node scripts/test-build-modes.mjs && node --test test/*.test.mjs",
+    "test:pack": "rm -rf artifacts && node scripts/pack-artifact.mjs artifacts && node --test test/pack.test.mjs",
+    "smoke:host": "bash scripts/host-smoke.sh",
+    "prepublishOnly": "node -e \"if(!process.env.CI)throw Error('publish is CI-only')\""
+  },
+  "engines": { "node": ">=20" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ccoalm/ccl-skills.git",
+    "directory": "packages/ccl-skills-npm"
+  },
+	"homepage": "https://github.com/ccoalm/ccl-skills#readme",
+	"bugs": {
+		"url": "https://github.com/ccoalm/ccl-skills/issues"
+	},
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "Apache-2.0",
+  "os": ["darwin", "linux"],
+  "devDependencies": { "@types/node": "^22.0.0", "typescript": "^5.6.0" }
+}