@floomhq/floom 1.0.0

package/dist/sync-manifest.js

@@ -0,0 +1,123 @@
+import { constants } from "node:fs";
+import { lstat, mkdir, open, rename } 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 SLUG_RE = /^[A-Za-z0-9_-]{1,128}$/;
+const FD_PATH_ROOT = "/proc/self/fd";
+function emptyManifest() {
+    return { version: MANIFEST_VERSION, files: {} };
+}
+function isEntryForKey(key, value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const entry = value;
+    return (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`);
+}
+export async function readSyncManifest() {
+    try {
+        await ensureSyncManifestDir();
+        const handle = await open(MANIFEST_PATH, constants.O_RDONLY | constants.O_NOFOLLOW);
+        let body;
+        try {
+            body = await handle.readFile("utf8");
+        }
+        finally {
+            await handle.close();
+        }
+        const parsed = JSON.parse(body);
+        if (parsed.version !== MANIFEST_VERSION || !parsed.files || typeof parsed.files !== "object") {
+            return emptyManifest();
+        }
+        const manifest = emptyManifest();
+        for (const [key, value] of Object.entries(parsed.files)) {
+            if (isEntryForKey(key, value))
+                manifest.files[key] = value;
+        }
+        return manifest;
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return emptyManifest();
+        if (err instanceof SyntaxError)
+            return emptyManifest();
+        throw err;
+    }
+}
+export async function writeSyncManifest(manifest) {
+    await ensureSyncManifestDir();
+    const dir = await open(CONFIG_DIR, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    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) {
+            const tmpName = attempt === 0 ? `${tmpBase}.tmp` : `${tmpBase}.${attempt}.tmp`;
+            const tmpPath = childPath(dir, CONFIG_DIR, tmpName);
+            let handle = null;
+            try {
+                handle = await open(tmpPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+                await handle.writeFile(body, "utf8");
+                await handle.close();
+                handle = null;
+                await rename(tmpPath, childPath(dir, CONFIG_DIR, "sync-manifest.json"));
+                return;
+            }
+            catch (err) {
+                await handle?.close().catch(() => { });
+                if (err.code === "EEXIST")
+                    continue;
+                throw err;
+            }
+        }
+    }
+    finally {
+        await dir.close();
+    }
+    const err = new Error("temporary sync manifest file already exists");
+    err.code = "EEXIST";
+    throw err;
+}
+function childPath(parent, fallbackParent, name) {
+    if (process.platform === "linux")
+        return `${FD_PATH_ROOT}/${parent.fd}/${name}`;
+    return join(resolve(fallbackParent), name);
+}
+export async function ensureSyncManifestDir() {
+    await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    const stat = await lstat(CONFIG_DIR);
+    if (stat.isSymbolicLink()) {
+        const err = new Error("sync manifest directory is a symbolic link");
+        err.code = "ELOOP";
+        throw err;
+    }
+    if (!stat.isDirectory()) {
+        const err = new Error("sync manifest path is blocked by an existing local file");
+        err.code = "ENOTDIR";
+        throw err;
+    }
+}
+export function manifestKey(root, target) {
+    const relativeTarget = relative(resolve(root), resolve(target));
+    if (relativeTarget === ".." || relativeTarget.startsWith(`..${sep}`)) {
+        throw new Error("Invalid manifest target path.");
+    }
+    return relativeTarget.split(sep).join("/");
+}
+export function markSynced(manifest, key, slug, hash) {
+    manifest.files[key] = {
+        hash,
+        slug,
+        target: key,
+        syncedAt: new Date().toISOString(),
+    };
+}
+export function unmarkSynced(manifest, key) {
+    delete manifest.files[key];
+}

package/dist/sync.js

@@ -0,0 +1,402 @@
+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 { getApiUrl, readConfig } 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";
+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() {
+    return process.env.CLAUDE_SKILLS_DIR ?? join(homedir(), ".claude", "skills");
+}
+function sha256(input) {
+    return createHash("sha256").update(input).digest("hex");
+}
+async function localState(path) {
+    try {
+        const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const stat = await handle.stat();
+            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")) };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return { kind: "missing" };
+        if (code === "ELOOP")
+            return { kind: "conflict", reason: "path is a symbolic link" };
+        if (code === "ENOTDIR" || code === "EISDIR") {
+            return { kind: "conflict", reason: "path is blocked by an existing local file or directory" };
+        }
+        throw err;
+    }
+}
+function safePathSegments(value, label) {
+    if (!value)
+        return [];
+    if (isAbsolute(value))
+        throw new FloomError(`Invalid ${label}.`);
+    const segments = value.split(/[\\/]+/).filter(Boolean);
+    if (segments.some((segment) => segment === "." || segment === ".." || !PATH_SEGMENT_RE.test(segment))) {
+        throw new FloomError(`Invalid ${label}.`);
+    }
+    return segments;
+}
+function skillPath(skill) {
+    if (!SLUG_RE.test(skill.slug))
+        throw new FloomError(`Invalid skill slug: ${skill.slug}`);
+    const root = skillsDir();
+    const segments = [root];
+    segments.push(...safePathSegments(skill.library_slug, "library slug"));
+    segments.push(...safePathSegments(skill.folder, "folder"));
+    segments.push(`${skill.slug}.md`);
+    const target = join(...segments);
+    const relativeTarget = relative(resolve(root), resolve(target));
+    if (relativeTarget === ".." || relativeTarget.startsWith(`..${sep}`) || isAbsolute(relativeTarget)) {
+        throw new FloomError("Invalid skill target path.");
+    }
+    return target;
+}
+function syncKey(skill) {
+    return `${skill.library_slug ?? ""}\0${skill.folder ?? ""}\0${skill.slug}`;
+}
+function validateSyncSkillShape(skill) {
+    if (!skill || typeof skill !== "object")
+        throw new FloomError("Invalid sync response.");
+    const candidate = skill;
+    if (typeof candidate.slug !== "string" || typeof candidate.body_md !== "string") {
+        throw new FloomError("Invalid sync response.");
+    }
+    if (candidate.folder !== undefined &&
+        candidate.folder !== null &&
+        typeof candidate.folder !== "string") {
+        throw new FloomError("Invalid sync response.");
+    }
+    if (candidate.library_slug !== undefined &&
+        candidate.library_slug !== null &&
+        typeof candidate.library_slug !== "string") {
+        throw new FloomError("Invalid sync response.");
+    }
+}
+function targetFromManifestKey(root, key) {
+    if (!key || isAbsolute(key) || key.includes("\\") || key.length > 512) {
+        throw new FloomError("Invalid manifest target path.");
+    }
+    const segments = key.split("/");
+    if (segments.some((segment) => segment === "." || segment === ".." || !MANIFEST_SEGMENT_RE.test(segment))) {
+        throw new FloomError("Invalid manifest target path.");
+    }
+    const target = join(root, ...segments);
+    const relativeTarget = relative(resolve(root), resolve(target));
+    if (relativeTarget === ".." || relativeTarget.startsWith(`..${sep}`) || isAbsolute(relativeTarget)) {
+        throw new FloomError("Invalid manifest target path.");
+    }
+    return target;
+}
+async function writeSyncedFile(target, body) {
+    const parent = await openSafeParentDirectory(skillsDir(), target, true);
+    let handle = null;
+    try {
+        handle = await open(childCreatePath(parent, dirname(target), basename(target)), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        await writeAll(handle, body);
+    }
+    finally {
+        await handle?.close();
+        await parent.close();
+    }
+}
+async function openSafeParentDirectory(root, target, create) {
+    if (create)
+        await ensureSafeParentDirectory(root, target);
+    else
+        await assertSafeExistingParentDirectory(root, target);
+    return open(dirname(target), constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+}
+function childCreatePath(parent, fallbackParent, name) {
+    if (process.platform === "linux")
+        return `${FD_PATH_ROOT}/${parent.fd}/${name}`;
+    return join(resolve(fallbackParent), name);
+}
+async function writeAll(handle, body) {
+    const buffer = Buffer.from(body, "utf8");
+    let offset = 0;
+    while (offset < buffer.length) {
+        const result = await handle.write(buffer, offset, buffer.length - offset, offset);
+        if (result.bytesWritten === 0)
+            throw conflictError("failed to write local skill file", "EIO");
+        offset += result.bytesWritten;
+    }
+}
+async function ensureSafeParentDirectory(root, target) {
+    const resolvedRoot = resolve(root);
+    const resolvedParent = resolve(dirname(target));
+    const relativeParent = relative(resolvedRoot, resolvedParent);
+    if (relativeParent === ".." || relativeParent.startsWith(`..${sep}`) || isAbsolute(relativeParent)) {
+        throw conflictError("Invalid skill target path.", "EINVAL");
+    }
+    await mkdir(resolvedRoot, { recursive: true, mode: 0o700 });
+    await assertSafeDirectory(resolvedRoot);
+    if (!relativeParent || relativeParent === ".")
+        return;
+    let current = resolvedRoot;
+    for (const segment of relativeParent.split(sep).filter(Boolean)) {
+        current = join(current, segment);
+        try {
+            await assertSafeDirectory(current);
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+            await mkdir(current, { mode: 0o700 });
+            await assertSafeDirectory(current);
+        }
+    }
+}
+async function assertSafeExistingParentDirectory(root, target) {
+    const resolvedRoot = resolve(root);
+    const resolvedParent = resolve(dirname(target));
+    const relativeParent = relative(resolvedRoot, resolvedParent);
+    if (relativeParent === ".." || relativeParent.startsWith(`..${sep}`) || isAbsolute(relativeParent)) {
+        throw conflictError("Invalid skill target path.", "EINVAL");
+    }
+    await assertSafeDirectory(resolvedRoot);
+    if (!relativeParent || relativeParent === ".")
+        return;
+    let current = resolvedRoot;
+    for (const segment of relativeParent.split(sep).filter(Boolean)) {
+        current = join(current, segment);
+        try {
+            await assertSafeDirectory(current);
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return;
+            throw err;
+        }
+    }
+}
+async function assertSafeDirectory(path) {
+    const stat = await lstat(path);
+    if (stat.isSymbolicLink())
+        throw conflictError("path contains a symbolic link", "ELOOP");
+    if (!stat.isDirectory()) {
+        throw conflictError("path is blocked by an existing local file or directory", "ENOTDIR");
+    }
+}
+function conflictError(message, code) {
+    const err = new Error(message);
+    err.code = code;
+    return err;
+}
+export async function sync(opts = {}) {
+    const cfg = await readConfig();
+    if (!cfg)
+        throw new FloomError("Not signed in.", "Run `floom login` first.");
+    await ensureSyncManifestDir();
+    const apiUrl = cfg.apiUrl ?? getApiUrl();
+    const spinner = opts.spinner === false ? null : ora({ text: c.dim("Syncing skills..."), color: "yellow" }).start();
+    let payload;
+    try {
+        payload = await getJson(`${apiUrl}/api/me/skills`, "load your skills", cfg.accessToken);
+    }
+    catch (err) {
+        spinner?.stop();
+        throw err;
+    }
+    await mkdir(skillsDir(), { 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 owned published skills only.
+    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();
+    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(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;
+            }
+            try {
+                await writeSyncedFile(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);
+            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");
+                        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 (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 (conflicts > 0) {
+            process.stderr.write(`   ${c.dim("Move or delete the local file, then run `floom sync` again.")}\n`);
+        }
+        process.stdout.write(`\n${symbols.ok}  [floom] synced ${synced} skills (${unchanged} unchanged, ${updated} updated${conflictNote})${skippedNote}\n\n`);
+    }
+    return result;
+}

package/dist/ui.js

@@ -0,0 +1,31 @@
+import pc from "picocolors";
+// Coral / teal palette to match the warm Lovable vibe.
+// picocolors only supports ANSI named colors, so we map:
+// - coral / primary action: yellow (warm) for the dot, red for emphasis when needed
+// - success: green
+// - muted: gray (dim)
+const isTty = process.stdout.isTTY === true;
+export const c = {
+    coral: (s) => (isTty ? `\x1b[38;5;209m${s}\x1b[0m` : s),
+    teal: (s) => (isTty ? `\x1b[38;5;73m${s}\x1b[0m` : s),
+    green: pc.green,
+    red: pc.red,
+    yellow: pc.yellow,
+    dim: pc.dim,
+    bold: pc.bold,
+    cyan: pc.cyan,
+};
+export function wordmark() {
+    // bold "floom" with a coral leading dot
+    return `${c.coral("●")} ${c.bold("floom")}`;
+}
+export function header() {
+    return `\n   ${c.bold("floom")}\n   ${c.dim("─────")}\n`;
+}
+export const symbols = {
+    ok: c.green("✓"),
+    fail: c.red("✗"),
+    arrow: c.coral("→"),
+    bullet: c.dim("○"),
+    dot: c.coral("●"),
+};

package/dist/whoami.js

@@ -0,0 +1,61 @@
+import ora from "ora";
+import { getApiUrl, readConfig, CONFIG_PATH } from "./config.js";
+import { c, symbols } from "./ui.js";
+import { FloomError, friendlyHttp, friendlyNetwork } from "./errors.js";
+export async function whoami() {
+    const cfg = await readConfig();
+    if (!cfg) {
+        throw new FloomError("Not signed in.", "Run `floom login` to sign in.");
+    }
+    const apiUrl = cfg.apiUrl ?? getApiUrl();
+    const spinner = ora({ text: c.dim("Checking session..."), color: "yellow" }).start();
+    let me;
+    let count = 0;
+    try {
+        const res = await fetch(`${apiUrl}/api/me`, {
+            headers: { authorization: `Bearer ${cfg.accessToken}` },
+        });
+        if (!res.ok) {
+            spinner.stop();
+            throw friendlyHttp(res.status, "check your account");
+        }
+        me = (await res.json());
+    }
+    catch (err) {
+        spinner.stop();
+        if (err instanceof FloomError)
+            throw err;
+        throw friendlyNetwork(err);
+    }
+    // Best-effort: count published skills. Don't fail whoami if it errors.
+    try {
+        const res = await fetch(`${apiUrl}/api/skills/mine`, {
+            headers: { authorization: `Bearer ${cfg.accessToken}` },
+        });
+        if (res.ok) {
+            const data = (await res.json());
+            if (typeof data.count === "number")
+                count = data.count;
+            else if (Array.isArray(data.items))
+                count = data.items.length;
+        }
+    }
+    catch {
+        // ignore
+    }
+    spinner.stop();
+    process.stdout.write(`\n${symbols.ok}  ${c.bold(me.email ?? me.id)}\n`);
+    process.stdout.write(`   ${c.dim(`Token at ${tildify(CONFIG_PATH)}`)}\n`);
+    if (count > 0) {
+        process.stdout.write(`   ${c.dim(`${count} skill${count === 1 ? "" : "s"} published`)}\n\n`);
+    }
+    else {
+        process.stdout.write("\n");
+    }
+}
+function tildify(p) {
+    const home = process.env.HOME ?? "";
+    if (home && p.startsWith(home))
+        return "~" + p.slice(home.length);
+    return p;
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@floomhq/floom",
+  "version": "1.0.0",
+  "description": "Publish AI skills from your terminal. Share with a link.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "floom": "bin/floom.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "npm run build && node --test test/*.mjs",
+    "pack:check": "npm pack --dry-run",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "clipboardy": "4.0.0",
+    "open": "10.1.0",
+    "ora": "8.1.1",
+    "picocolors": "1.1.1",
+    "update-notifier": "7.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "22.10.5",
+    "@types/update-notifier": "6.0.8",
+    "typescript": "5.7.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/floomhq/floom.git",
+    "directory": "cli"
+  },
+  "keywords": [
+    "ai",
+    "skills",
+    "claude",
+    "markdown",
+    "cli",
+    "floom"
+  ]
+}