@floomhq/floom 1.0.14 → 1.0.16

package/dist/sync-manifest.js

@@ -1,16 +1,14 @@
 import { constants } from "node:fs";
-import { lstat, mkdir, open, rename } from "node:fs/promises";
+import { lstat, mkdir, open, rename, rm, stat } from "node:fs/promises";
 import { join, relative, resolve, sep } from "node:path";
 import { CONFIG_DIR } from "./config.js";
 const MANIFEST_VERSION = 1;
+const MANIFEST_PATH = join(CONFIG_DIR, "sync-manifest.json");
+const LOCK_PATH = join(CONFIG_DIR, "sync.lock");
+const LOCK_TIMEOUT_MS = 15_000;
+const LOCK_STALE_MS = 5 * 60_000;
 const SLUG_RE = /^[A-Za-z0-9_-]{1,128}$/;
 const FD_PATH_ROOT = "/proc/self/fd";
-function manifestFilename(scope = "claude") {
-    return scope === "claude" ? "sync-manifest.json" : `sync-manifest.${scope}.json`;
-}
-function manifestPath(scope = "claude") {
-    return join(CONFIG_DIR, manifestFilename(scope));
-}
 function emptyManifest() {
     return { version: MANIFEST_VERSION, files: {} };
 }
@@ -18,18 +16,34 @@ function isEntryForKey(key, value) {
     if (!value || typeof value !== "object")
         return false;
     const entry = value;
-    return (typeof entry.hash === "string" &&
+    if (typeof entry.hash === "string" &&
         typeof entry.slug === "string" &&
         typeof entry.target === "string" &&
         typeof entry.syncedAt === "string" &&
         entry.target === key &&
-        SLUG_RE.test(entry.slug) &&
-        key.split("/").at(-1) === `${entry.slug}.md`);
+        SLUG_RE.test(entry.slug)) {
+        const segments = key.split("/");
+        const legacyFile = segments.at(-1) === `${entry.slug}.md`;
+        const slugIndex = segments.lastIndexOf(entry.slug);
+        const packagePath = slugIndex >= 0 ? segments.slice(slugIndex + 1) : [];
+        return legacyFile || isPackageFilePath(packagePath);
+    }
+    return false;
+}
+function isPackageFilePath(packagePath) {
+    if (packagePath.length === 1 && packagePath[0] === "SKILL.md")
+        return true;
+    if (packagePath.length < 2)
+        return false;
+    const first = packagePath[0];
+    if (first === undefined || !["references", "examples", "scripts", "assets"].includes(first))
+        return false;
+    return packagePath.every((segment) => segment !== "." && segment !== ".." && segment.length > 0);
 }
-export async function readSyncManifest(scope = "claude") {
+export async function readSyncManifest() {
     try {
         await ensureSyncManifestDir();
-        const handle = await open(manifestPath(scope), constants.O_RDONLY | constants.O_NOFOLLOW);
+        const handle = await open(MANIFEST_PATH, constants.O_RDONLY | constants.O_NOFOLLOW);
         let body;
         try {
             body = await handle.readFile("utf8");
@@ -56,11 +70,10 @@ export async function readSyncManifest(scope = "claude") {
         throw err;
     }
 }
-export async function writeSyncManifest(manifest, scope = "claude") {
+export async function writeSyncManifest(manifest) {
     await ensureSyncManifestDir();
     const dir = await open(CONFIG_DIR, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
-    const filename = manifestFilename(scope);
-    const tmpBase = `${filename}.${process.pid}.${Date.now()}`;
+    const tmpBase = `sync-manifest.json.${process.pid}.${Date.now()}`;
     const body = JSON.stringify(manifest, null, 2);
     try {
         for (let attempt = 0; attempt < 10; attempt += 1) {
@@ -72,7 +85,7 @@ export async function writeSyncManifest(manifest, scope = "claude") {
                 await handle.writeFile(body, "utf8");
                 await handle.close();
                 handle = null;
-                await rename(tmpPath, childPath(dir, CONFIG_DIR, filename));
+                await rename(tmpPath, childPath(dir, CONFIG_DIR, "sync-manifest.json"));
                 return;
             }
             catch (err) {
@@ -109,6 +122,42 @@ export async function ensureSyncManifestDir() {
         throw err;
     }
 }
+export async function withSyncLock(fn) {
+    await ensureSyncManifestDir();
+    const startedAt = Date.now();
+    for (;;) {
+        try {
+            await mkdir(LOCK_PATH, { mode: 0o700 });
+            break;
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+            try {
+                const lockStat = await stat(LOCK_PATH);
+                if (Date.now() - lockStat.mtimeMs > LOCK_STALE_MS) {
+                    await rm(LOCK_PATH, { recursive: true, force: true });
+                    continue;
+                }
+            }
+            catch (statErr) {
+                if (statErr.code === "ENOENT")
+                    continue;
+                throw statErr;
+            }
+            if (Date.now() - startedAt > LOCK_TIMEOUT_MS) {
+                throw new Error("Timed out waiting for Floom sync lock.");
+            }
+            await new Promise((resolveDelay) => setTimeout(resolveDelay, 50));
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        await rm(LOCK_PATH, { recursive: true, force: true }).catch(() => { });
+    }
+}
 export function manifestKey(root, target) {
     const relativeTarget = relative(resolve(root), resolve(target));
     if (relativeTarget === ".." || relativeTarget.startsWith(`..${sep}`)) {

package/dist/sync.js

@@ -1,18 +1,26 @@
 import { constants } from "node:fs";
 import { lstat, mkdir, open } from "node:fs/promises";
 import { createHash } from "node:crypto";
+import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import ora from "ora";
 import { readConfig, resolveApiUrl } from "./config.js";
 import { getJson } from "./lib/api.js";
 import { c, symbols } from "./ui.js";
 import { FloomError } from "./errors.js";
-import { ensureSyncManifestDir, manifestKey, markSynced, readSyncManifest, unmarkSynced, writeSyncManifest } from "./sync-manifest.js";
-import { resolveSkillsDir } from "./targets.js";
+import { ensureSyncManifestDir, manifestKey, markSynced, readSyncManifest, unmarkSynced, withSyncLock, writeSyncManifest } from "./sync-manifest.js";
+import { normalizeRemotePackageFiles } from "./package.js";
 const SLUG_RE = /^[A-Za-z0-9_-]{1,128}$/;
 const PATH_SEGMENT_RE = /^[a-z0-9._-]{1,128}$/;
 const MANIFEST_SEGMENT_RE = /^[A-Za-z0-9._-]{1,128}$/;
 const FD_PATH_ROOT = "/proc/self/fd";
+function skillsDir(target = "claude") {
+    if (target === "codex") {
+        const codexHome = process.env.CODEX_HOME ?? join(homedir(), ".codex");
+        return process.env.CODEX_SKILLS_DIR ?? join(codexHome, "skills");
+    }
+    return process.env.CLAUDE_SKILLS_DIR ?? join(homedir(), ".claude", "skills");
+}
 function sha256(input) {
     return createHash("sha256").update(input).digest("hex");
 }
@@ -24,7 +32,7 @@ async function localState(path) {
             if (!stat.isFile()) {
                 return { kind: "conflict", reason: "path is blocked by an existing local file or directory" };
             }
-            return { kind: "file", hash: sha256(await handle.readFile("utf8")) };
+            return { kind: "file", hash: sha256(await handle.readFile()) };
         }
         finally {
             await handle.close();
@@ -53,13 +61,14 @@ function safePathSegments(value, label) {
     }
     return segments;
 }
-function skillPath(root, skill) {
+function skillPath(skill, targetAgent) {
     if (!SLUG_RE.test(skill.slug))
         throw new FloomError(`Invalid skill slug: ${skill.slug}`);
+    const root = skillsDir(targetAgent);
     const segments = [root];
     segments.push(...safePathSegments(skill.library_slug, "library slug"));
     segments.push(...safePathSegments(skill.folder, "folder"));
-    segments.push(`${skill.slug}.md`);
+    segments.push(skill.slug, "SKILL.md");
     const target = join(...segments);
     const relativeTarget = relative(resolve(root), resolve(target));
     if (relativeTarget === ".." || relativeTarget.startsWith(`..${sep}`) || isAbsolute(relativeTarget)) {
@@ -128,7 +137,7 @@ function childCreatePath(parent, fallbackParent, name) {
     return join(resolve(fallbackParent), name);
 }
 async function writeAll(handle, body) {
-    const buffer = Buffer.from(body, "utf8");
+    const buffer = Buffer.isBuffer(body) ? body : Buffer.from(body, "utf8");
     let offset = 0;
     while (offset < buffer.length) {
         const result = await handle.write(buffer, offset, buffer.length - offset, offset);
@@ -137,6 +146,63 @@ async function writeAll(handle, body) {
         offset += result.bytesWritten;
     }
 }
+function syncPackageFiles(target, body, files) {
+    return [
+        { target, bytes: body, hash: sha256(body) },
+        ...files.map((file) => ({
+            target: join(dirname(target), file.path),
+            bytes: file.bytes,
+            hash: file.sha256,
+        })),
+    ];
+}
+async function planPackageSync(root, files, manifest) {
+    let missing = 0;
+    let unchanged = 0;
+    for (const file of files) {
+        const targetKey = manifestKey(root, file.target);
+        const tracked = manifest.files[targetKey];
+        try {
+            await assertSafeExistingParentDirectory(root, file.target);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "ELOOP")
+                return { kind: "conflict", target: file.target, reason: "path contains a symbolic link" };
+            if (code === "ENOTDIR" || code === "EISDIR")
+                return { kind: "conflict", target: file.target, reason: "path is blocked by an existing local file or directory" };
+            if (code === "EEXIST" || code === "ENOENT")
+                return { kind: "conflict", target: file.target, reason: err instanceof Error ? err.message : "local file changed during Floom sync" };
+            throw err;
+        }
+        const state = await localState(file.target);
+        if (state.kind === "conflict")
+            return { kind: "conflict", target: state.conflictTarget ?? file.target, reason: state.reason };
+        if (state.kind === "missing") {
+            if (tracked && files.length > 1)
+                return { kind: "conflict", target: file.target, reason: "local package file missing since the last Floom sync" };
+            missing += 1;
+            continue;
+        }
+        if (!tracked)
+            return { kind: "conflict", target: file.target, reason: "existing file is not tracked by Floom sync" };
+        if (state.hash !== tracked.hash)
+            return { kind: "conflict", target: file.target, reason: "local file changed since the last Floom sync" };
+        if (state.hash !== file.hash)
+            return { kind: "conflict", target: file.target, reason: "remote skill changed; move or delete the local file to accept the Floom version" };
+        unchanged += 1;
+    }
+    if (unchanged === files.length)
+        return { kind: "unchanged" };
+    if (missing === files.length)
+        return { kind: "write" };
+    const missingFile = files.find((file) => !manifest.files[manifestKey(root, file.target)]);
+    return {
+        kind: "conflict",
+        target: missingFile?.target ?? files[0]?.target ?? root,
+        reason: "local package is only partially installed",
+    };
+}
 async function ensureSafeParentDirectory(root, target) {
     const resolvedRoot = resolve(root);
     const resolvedParent = resolve(dirname(target));
@@ -199,14 +265,13 @@ function conflictError(message, code) {
     return err;
 }
 export async function sync(opts = {}) {
+    const targetAgent = opts.target ?? "claude";
     const cfg = await readConfig();
     if (!cfg)
         throw new FloomError("Not signed in.", "Run `npx -y @floomhq/floom login` first.");
-    const targetAgent = opts.target ?? "claude";
-    const root = resolveSkillsDir(targetAgent);
     await ensureSyncManifestDir();
     const apiUrl = resolveApiUrl(cfg);
-    const spinner = opts.spinner === false ? null : ora({ text: c.dim(`Syncing ${targetAgent} skills...`), color: "yellow" }).start();
+    const spinner = opts.spinner === false ? null : ora({ text: c.dim("Syncing skills..."), color: "yellow" }).start();
     let payload;
     try {
         payload = await getJson(`${apiUrl}/api/v1/me/skills`, "load your skills", cfg.accessToken);
@@ -215,186 +280,165 @@ export async function sync(opts = {}) {
         spinner?.stop();
         throw err;
     }
-    await mkdir(root, { recursive: true, mode: 0o700 });
-    if (!Array.isArray(payload.skills)) {
-        throw new FloomError("Invalid sync response.");
-    }
-    for (const skill of payload.skills)
-        validateSyncSkillShape(skill);
-    // Version 1 preview syncs published, saved, and followed library skills.
-    const all = payload.skills;
-    const seen = new Set();
-    let unchanged = 0;
-    let updated = 0;
-    let skipped = 0;
-    let conflicts = 0;
-    const conflictNotes = [];
-    const manifest = await readSyncManifest(targetAgent);
-    const activeTargetKeys = new Set();
-    const pruneBlockedSlugs = new Set();
-    let manifestChanged = false;
-    const noteConflict = (target, reason) => {
-        conflicts += 1;
-        const rel = manifestKey(root, target);
-        conflictNotes.push(`${rel} (${reason})`);
-    };
-    const noteManifestConflict = (key, reason) => {
-        conflicts += 1;
-        conflictNotes.push(`${key} (${reason})`);
-    };
     try {
-        for (const skill of all) {
-            const key = syncKey(skill);
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            if (!SLUG_RE.test(skill.slug)) {
-                skipped += 1;
-                continue;
-            }
-            let target;
-            try {
-                target = skillPath(root, skill);
-            }
-            catch (err) {
-                if (err instanceof FloomError) {
-                    pruneBlockedSlugs.add(skill.slug);
-                    skipped += 1;
-                    continue;
-                }
-                throw err;
-            }
-            const targetKey = manifestKey(root, target);
-            activeTargetKeys.add(targetKey);
-            const remoteHash = sha256(skill.body_md);
-            const tracked = manifest.files[targetKey];
-            try {
-                await assertSafeExistingParentDirectory(root, target);
-            }
-            catch (err) {
-                const code = err.code;
-                if (code === "ELOOP") {
-                    noteConflict(target, "path contains a symbolic link");
-                    continue;
-                }
-                if (code === "ENOTDIR" || code === "EISDIR") {
-                    noteConflict(target, "path is blocked by an existing local file or directory");
-                    continue;
-                }
-                if (code === "EEXIST" || code === "ENOENT") {
-                    noteConflict(target, err instanceof Error ? err.message : "local file changed during Floom sync");
-                    continue;
-                }
-                throw err;
-            }
-            const state = await localState(target);
-            if (state.kind === "conflict") {
-                noteConflict(target, state.reason);
-                continue;
-            }
-            if (state.kind === "file" && !tracked) {
-                noteConflict(target, "existing file is not tracked by Floom sync");
-                continue;
-            }
-            if (state.kind === "file" && state.hash !== tracked?.hash) {
-                noteConflict(target, "local file changed since the last Floom sync");
-                continue;
-            }
-            if (state.kind === "file" && state.hash === remoteHash) {
-                unchanged += 1;
-                continue;
-            }
-            if (state.kind === "file") {
-                noteConflict(target, "remote skill changed; move or delete the local file to accept the Floom version");
-                continue;
+        return await withSyncLock(async () => {
+            await mkdir(skillsDir(targetAgent), { recursive: true, mode: 0o700 });
+            if (!Array.isArray(payload.skills)) {
+                throw new FloomError("Invalid sync response.");
             }
+            for (const skill of payload.skills)
+                validateSyncSkillShape(skill);
+            // Version 1 preview syncs published, saved, and subscribed library skills.
+            const all = payload.skills;
+            const seen = new Set();
+            let unchanged = 0;
+            let updated = 0;
+            let skipped = 0;
+            let conflicts = 0;
+            const conflictNotes = [];
+            const manifest = await readSyncManifest();
+            const root = skillsDir(targetAgent);
+            const activeTargetKeys = new Set();
+            const pruneBlockedSlugs = new Set();
+            let manifestChanged = false;
+            const noteConflict = (target, reason) => {
+                conflicts += 1;
+                const rel = manifestKey(root, target);
+                conflictNotes.push(`${rel} (${reason})`);
+            };
+            const noteManifestConflict = (key, reason) => {
+                conflicts += 1;
+                conflictNotes.push(`${key} (${reason})`);
+            };
             try {
-                await writeSyncedFile(root, target, skill.body_md);
-            }
-            catch (err) {
-                const code = err.code;
-                if (code === "ELOOP") {
-                    noteConflict(target, "path contains a symbolic link");
-                    continue;
-                }
-                if (code === "ENOTDIR" || code === "EISDIR") {
-                    noteConflict(target, "path is blocked by an existing local file or directory");
-                    continue;
-                }
-                throw err;
-            }
-            markSynced(manifest, targetKey, skill.slug, remoteHash);
-            await writeSyncManifest(manifest, targetAgent);
-            updated += 1;
-        }
-        if (payload.full_sync === true) {
-            for (const [key, entry] of Object.entries(manifest.files)) {
-                if (activeTargetKeys.has(key))
-                    continue;
-                if (pruneBlockedSlugs.has(entry.slug)) {
-                    noteManifestConflict(key, "remote metadata is invalid for this skill");
-                    continue;
-                }
-                let target;
-                try {
-                    target = targetFromManifestKey(root, key);
-                    await assertSafeExistingParentDirectory(root, target);
-                }
-                catch (err) {
-                    if (err instanceof FloomError) {
-                        noteManifestConflict(key, "invalid manifest target path");
+                for (const skill of all) {
+                    const key = syncKey(skill);
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    if (!SLUG_RE.test(skill.slug)) {
+                        skipped += 1;
                         continue;
                     }
-                    const code = err.code;
-                    if (code === "ELOOP") {
-                        noteManifestConflict(key, "path contains a symbolic link");
+                    let target;
+                    try {
+                        target = skillPath(skill, targetAgent);
+                    }
+                    catch (err) {
+                        if (err instanceof FloomError) {
+                            pruneBlockedSlugs.add(skill.slug);
+                            skipped += 1;
+                            continue;
+                        }
+                        throw err;
+                    }
+                    const remotePackageFiles = normalizeRemotePackageFiles(skill.package_files ?? skill.files);
+                    const packageFiles = syncPackageFiles(target, skill.body_md, remotePackageFiles);
+                    for (const file of packageFiles)
+                        activeTargetKeys.add(manifestKey(root, file.target));
+                    const plan = await planPackageSync(root, packageFiles, manifest);
+                    if (plan.kind === "conflict") {
+                        noteConflict(plan.target, plan.reason);
                         continue;
                     }
-                    if (code === "ENOTDIR" || code === "EISDIR") {
-                        noteManifestConflict(key, "path is blocked by an existing local file or directory");
+                    if (plan.kind === "unchanged") {
+                        unchanged += 1;
                         continue;
                     }
-                    throw err;
+                    try {
+                        for (const file of packageFiles)
+                            await writeSyncedFile(root, file.target, file.bytes);
+                    }
+                    catch (err) {
+                        const code = err.code;
+                        if (code === "ELOOP") {
+                            noteConflict(target, "path contains a symbolic link");
+                            continue;
+                        }
+                        if (code === "ENOTDIR" || code === "EISDIR") {
+                            noteConflict(target, "path is blocked by an existing local file or directory");
+                            continue;
+                        }
+                        throw err;
+                    }
+                    for (const file of packageFiles)
+                        markSynced(manifest, manifestKey(root, file.target), skill.slug, file.hash);
+                    await writeSyncManifest(manifest);
+                    updated += 1;
                 }
-                const state = await localState(target);
-                if (state.kind === "missing") {
-                    unmarkSynced(manifest, key);
-                    manifestChanged = true;
-                    continue;
+                if (payload.full_sync === true) {
+                    for (const [key, entry] of Object.entries(manifest.files)) {
+                        if (activeTargetKeys.has(key))
+                            continue;
+                        if (pruneBlockedSlugs.has(entry.slug)) {
+                            noteManifestConflict(key, "remote metadata is invalid for this skill");
+                            continue;
+                        }
+                        let target;
+                        try {
+                            target = targetFromManifestKey(root, key);
+                            await assertSafeExistingParentDirectory(root, target);
+                        }
+                        catch (err) {
+                            if (err instanceof FloomError) {
+                                noteManifestConflict(key, "invalid manifest target path");
+                                continue;
+                            }
+                            const code = err.code;
+                            if (code === "ELOOP") {
+                                noteManifestConflict(key, "path contains a symbolic link");
+                                continue;
+                            }
+                            if (code === "ENOTDIR" || code === "EISDIR") {
+                                noteManifestConflict(key, "path is blocked by an existing local file or directory");
+                                continue;
+                            }
+                            throw err;
+                        }
+                        const state = await localState(target);
+                        if (state.kind === "missing") {
+                            unmarkSynced(manifest, key);
+                            manifestChanged = true;
+                            continue;
+                        }
+                        if (state.kind === "conflict") {
+                            noteConflict(target, state.reason);
+                            continue;
+                        }
+                        if (state.hash !== entry.hash) {
+                            noteConflict(target, "local file changed since the last Floom sync");
+                            continue;
+                        }
+                        unmarkSynced(manifest, key);
+                        manifestChanged = true;
+                    }
                 }
-                if (state.kind === "conflict") {
-                    noteConflict(target, state.reason);
-                    continue;
+                if (manifestChanged)
+                    await writeSyncManifest(manifest);
+            }
+            catch (err) {
+                spinner?.stop();
+                throw err;
+            }
+            spinner?.stop();
+            const synced = activeTargetKeys.size;
+            const skippedNote = skipped > 0 ? c.dim(` (${skipped} skipped — invalid path)`) : "";
+            const conflictNote = conflicts > 0 ? c.dim(`, ${conflicts} conflict${conflicts === 1 ? "" : "s"} skipped`) : "";
+            const result = { synced, unchanged, updated, skipped, conflicts };
+            if (!(opts.quietUnchanged && updated === 0 && skipped === 0 && conflicts === 0)) {
+                for (const note of conflictNotes) {
+                    process.stderr.write(`${symbols.bullet}  [floom] skipped local conflict: ${note}\n`);
                 }
-                if (state.hash !== entry.hash) {
-                    noteConflict(target, "local file changed since the last Floom sync");
-                    continue;
+                if (conflicts > 0) {
+                    process.stderr.write(`   ${c.dim("Move or delete the local file, then run `npx -y @floomhq/floom sync` again.")}\n`);
                 }
-                unmarkSynced(manifest, key);
-                manifestChanged = true;
+                process.stdout.write(`\n${symbols.ok}  [floom] synced ${synced} skills (${unchanged} unchanged, ${updated} updated${conflictNote})${skippedNote}\n\n`);
             }
-        }
-        if (manifestChanged)
-            await writeSyncManifest(manifest, targetAgent);
+            return result;
+        });
     }
     catch (err) {
         spinner?.stop();
         throw err;
     }
-    spinner?.stop();
-    const synced = activeTargetKeys.size;
-    const skippedNote = skipped > 0 ? c.dim(` (${skipped} skipped — invalid path)`) : "";
-    const conflictNote = conflicts > 0 ? c.dim(`, ${conflicts} conflict${conflicts === 1 ? "" : "s"} skipped`) : "";
-    const result = { synced, unchanged, updated, skipped, conflicts };
-    if (!(opts.quietUnchanged && updated === 0 && skipped === 0 && conflicts === 0)) {
-        for (const note of conflictNotes) {
-            process.stderr.write(`${symbols.bullet}  [floom] skipped local conflict: ${note}\n`);
-        }
-        if (conflicts > 0) {
-            const targetFlag = targetAgent === "claude" ? "" : ` --target ${targetAgent}`;
-            process.stderr.write(`   ${c.dim(`Move or delete the local file, then run \`npx -y @floomhq/floom sync${targetFlag}\` again.`)}\n`);
-        }
-        process.stdout.write(`\n${symbols.ok}  [floom] synced ${synced} skills (${unchanged} unchanged, ${updated} updated${conflictNote})${skippedNote}\n\n`);
-    }
-    return result;
 }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@floomhq/floom",
-  "version": "1.0.14",
-  "description": "Publish AI skills from your terminal. Share with a link.",
+  "version": "1.0.16",
+  "description": "Sync AI skills across agents and machines.",
   "license": "MIT",
   "type": "module",
   "bin": {
+    "floom": "bin/floom.js",
     "floom-skills": "bin/floom.js"
   },
   "files": [

package/dist/targets.js

@@ -1,16 +0,0 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-export function resolveSkillsDir(target) {
-    if (process.env.FLOOM_SKILLS_DIR)
-        return process.env.FLOOM_SKILLS_DIR;
-    if (target === "codex") {
-        const codexHome = process.env.CODEX_HOME ?? join(homedir(), ".codex");
-        return process.env.CODEX_SKILLS_DIR ?? join(codexHome, "skills");
-    }
-    return process.env.CLAUDE_SKILLS_DIR ?? join(homedir(), ".claude", "skills");
-}
-export function skillsDirHint(target) {
-    if (process.env.FLOOM_SKILLS_DIR)
-        return "FLOOM_SKILLS_DIR";
-    return target === "codex" ? "CODEX_SKILLS_DIR" : "CLAUDE_SKILLS_DIR";
-}