@floomhq/floom 1.0.64 → 2.0.0

package/dist/sync.js

@@ -1,581 +0,0 @@
-import { constants } from "node:fs";
-import { lstat, mkdir, open, rm, rmdir } from "node:fs/promises";
-import { createHash } from "node:crypto";
-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, withSyncLock, writeSyncManifest } from "./sync-manifest.js";
-import { normalizeRemotePackageFiles } from "./package.js";
-import { targetSkillsDir } from "./targets.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";
-const PACKAGE_SYNC_PAGE_LIMIT = "25";
-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()) };
-        }
-        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, targetAgent) {
-    if (!SLUG_RE.test(skill.slug))
-        throw new FloomError(`Invalid skill slug: ${skill.slug}`);
-    const root = targetSkillsDir(targetAgent);
-    const segments = [root];
-    segments.push(...safePathSegments(skill.library_slug, "library slug"));
-    segments.push(...safePathSegments(skill.folder, "folder"));
-    segments.push(skill.slug, "SKILL.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(root, target, body) {
-    const parent = await openSafeParentDirectory(root, 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.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);
-        if (result.bytesWritten === 0)
-            throw conflictError("failed to write local skill file", "EIO");
-        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 missingTracked = 0;
-    let unchanged = 0;
-    let remoteChanged = 0;
-    let firstMissingTarget = null;
-    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") {
-            firstMissingTarget ??= file.target;
-            if (tracked) {
-                missingTracked += 1;
-                continue;
-            }
-            missing += 1;
-            continue;
-        }
-        if (!tracked) {
-            if (state.hash !== file.hash)
-                return { kind: "conflict", target: file.target, reason: "existing file is not tracked by Floom sync" };
-            unchanged += 1;
-            continue;
-        }
-        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) {
-            remoteChanged += 1;
-            continue;
-        }
-        unchanged += 1;
-    }
-    if (unchanged === files.length)
-        return { kind: "unchanged" };
-    if (missing + missingTracked === files.length)
-        return { kind: "write" };
-    if (missingTracked > 0) {
-        return {
-            kind: "conflict",
-            target: firstMissingTarget ?? files[0]?.target ?? root,
-            reason: "local package is only partially installed",
-        };
-    }
-    if (missing === 0 && remoteChanged > 0)
-        return { kind: "update" };
-    if (missing === files.length)
-        return { kind: "write" };
-    return { kind: "update" };
-}
-async function overwriteTrackedFile(root, target, body, expectedHash) {
-    const parent = await openSafeParentDirectory(root, target, false);
-    let handle = null;
-    try {
-        handle = await open(childCreatePath(parent, dirname(target), basename(target)), constants.O_RDWR | constants.O_NOFOLLOW);
-        const stat = await handle.stat();
-        if (!stat.isFile())
-            throw conflictError("path is blocked by an existing local file or directory", "ENOTDIR");
-        const currentHash = sha256(await handle.readFile());
-        if (currentHash !== expectedHash)
-            throw conflictError("local file changed since the last Floom sync", "EEXIST");
-        await handle.truncate(0);
-        await writeAll(handle, body);
-    }
-    finally {
-        await handle?.close();
-        await parent.close();
-    }
-}
-async function deleteSyncedFile(root, target, expectedHash) {
-    const state = await localState(target);
-    if (state.kind === "missing")
-        return;
-    if (state.kind === "conflict")
-        throw conflictError(state.reason, "EEXIST");
-    if (state.hash !== expectedHash)
-        throw conflictError("local file changed since the last Floom sync", "EEXIST");
-    await rm(target);
-    await pruneEmptyParents(root, dirname(target));
-}
-async function pruneEmptyParents(root, startDir) {
-    const resolvedRoot = resolve(root);
-    let current = resolve(startDir);
-    for (;;) {
-        const relativeCurrent = relative(resolvedRoot, current);
-        if (!relativeCurrent || relativeCurrent === ".." || relativeCurrent.startsWith(`..${sep}`) || isAbsolute(relativeCurrent))
-            return;
-        try {
-            await rmdir(current);
-        }
-        catch (err) {
-            const code = err.code;
-            if (code === "ENOENT") {
-                current = dirname(current);
-                continue;
-            }
-            if (code === "ENOTEMPTY" || code === "EEXIST" || code === "ENOTDIR")
-                return;
-            throw err;
-        }
-        current = dirname(current);
-    }
-}
-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 targetAgent = opts.target ?? "claude";
-    const cfg = await readConfig();
-    if (!cfg)
-        throw new FloomError("Not signed in.", "Run `npx -y @floomhq/floom login` first.");
-    await ensureSyncManifestDir();
-    const apiUrl = resolveApiUrl(cfg);
-    const spinner = opts.spinner === false ? null : ora({ text: c.dim("Syncing skills..."), color: "yellow" }).start();
-    let payload;
-    try {
-        payload = await loadSyncPayload(apiUrl, cfg.accessToken);
-    }
-    catch (err) {
-        spinner?.stop();
-        throw err;
-    }
-    try {
-        return await withSyncLock(async () => {
-            await mkdir(targetSkillsDir(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 = targetSkillsDir(targetAgent);
-            const activeTargetKeys = new Set();
-            const pruneBlockedSlugs = new Set();
-            let manifestChanged = false;
-            let synced = 0;
-            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, 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);
-                    synced += 1;
-                    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 (plan.kind === "unchanged") {
-                        for (const file of packageFiles)
-                            markSynced(manifest, manifestKey(root, file.target), skill.slug, file.hash);
-                        manifestChanged = true;
-                        unchanged += 1;
-                        continue;
-                    }
-                    try {
-                        if (plan.kind === "update") {
-                            for (const file of packageFiles) {
-                                const targetKey = manifestKey(root, file.target);
-                                const tracked = manifest.files[targetKey];
-                                if (tracked) {
-                                    await overwriteTrackedFile(root, file.target, file.bytes, tracked.hash);
-                                    continue;
-                                }
-                                const state = await localState(file.target);
-                                if (state.kind === "missing") {
-                                    await writeSyncedFile(root, file.target, file.bytes);
-                                    continue;
-                                }
-                                if (state.kind === "conflict")
-                                    throw conflictError(state.reason, "EEXIST");
-                                if (state.hash === file.hash)
-                                    continue;
-                                throw conflictError("existing file is not tracked by Floom sync", "EEXIST");
-                            }
-                        }
-                        else {
-                            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);
-                    manifestChanged = true;
-                    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;
-                        }
-                        try {
-                            await deleteSyncedFile(root, target, entry.hash);
-                        }
-                        catch (err) {
-                            const code = err.code;
-                            if (code === "ENOENT") {
-                                unmarkSynced(manifest, key);
-                                manifestChanged = true;
-                                continue;
-                            }
-                            if (code === "ELOOP") {
-                                noteManifestConflict(key, "path contains a symbolic link");
-                                continue;
-                            }
-                            if (code === "ENOTDIR" || code === "EISDIR" || code === "EEXIST") {
-                                noteManifestConflict(key, err instanceof Error ? err.message : "local file changed since the last Floom sync");
-                                continue;
-                            }
-                            throw err;
-                        }
-                        unmarkSynced(manifest, key);
-                        manifestChanged = true;
-                    }
-                }
-                if (manifestChanged)
-                    await writeSyncManifest(manifest);
-            }
-            catch (err) {
-                spinner?.stop();
-                throw err;
-            }
-            spinner?.stop();
-            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 `npx -y @floomhq/floom sync` again.")}\n`);
-                }
-                process.stdout.write(`\n${symbols.ok}  [floom] synced ${synced} skills (${unchanged} unchanged, ${updated} updated${conflictNote})${skippedNote}\n\n`);
-            }
-            return result;
-        });
-    }
-    catch (err) {
-        spinner?.stop();
-        throw err;
-    }
-}
-async function loadSyncPayload(apiUrl, token) {
-    const all = [];
-    let fullSync = false;
-    let cursor;
-    const seenCursors = new Set();
-    for (let page = 0; page < 1000; page += 1) {
-        const url = new URL(`${apiUrl}/api/v1/me/skills`);
-        url.searchParams.set("limit", PACKAGE_SYNC_PAGE_LIMIT);
-        url.searchParams.set("packages", "1");
-        if (cursor)
-            url.searchParams.set("cursor", cursor);
-        const payload = await getJson(url.toString(), "load your skills", token);
-        if (!Array.isArray(payload.skills))
-            throw new FloomError("Invalid sync response.");
-        all.push(...payload.skills);
-        fullSync = fullSync || payload.full_sync === true;
-        if (!payload.next_cursor) {
-            return { skills: all, full_sync: fullSync };
-        }
-        if (seenCursors.has(payload.next_cursor))
-            throw new FloomError("Invalid sync response.");
-        seenCursors.add(payload.next_cursor);
-        cursor = payload.next_cursor;
-    }
-    throw new FloomError("Invalid sync response.");
-}

package/dist/targets.js

@@ -1,49 +0,0 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-export const AGENT_TARGETS = ["claude", "codex", "cursor", "opencode", "kimi"];
-const TARGETS = {
-    claude: {
-        label: "Claude Code",
-        skillsDirEnv: "CLAUDE_SKILLS_DIR",
-        defaultSkillsDir: () => join(homedir(), ".claude", "skills"),
-    },
-    codex: {
-        label: "Codex",
-        skillsDirEnv: "CODEX_SKILLS_DIR",
-        defaultSkillsDir: () => join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "skills"),
-    },
-    cursor: {
-        label: "Cursor",
-        skillsDirEnv: "CURSOR_SKILLS_DIR",
-        defaultSkillsDir: () => join(homedir(), ".cursor", "skills-cursor"),
-    },
-    opencode: {
-        label: "OpenCode",
-        skillsDirEnv: "OPENCODE_SKILLS_DIR",
-        defaultSkillsDir: () => join(homedir(), ".config", "opencode", "skills"),
-    },
-    kimi: {
-        label: "Kimi",
-        skillsDirEnv: "KIMI_SKILLS_DIR",
-        defaultSkillsDir: () => join(homedir(), ".kimi", "skills"),
-    },
-};
-export const TARGET_HINT = AGENT_TARGETS.join("|");
-export function isAgentTarget(value) {
-    return AGENT_TARGETS.includes(value);
-}
-export function parseAgentTarget(value) {
-    if (isAgentTarget(value))
-        return value;
-    throw new Error(`Invalid agent target: ${value}`);
-}
-export function targetLabel(target) {
-    return TARGETS[target].label;
-}
-export function targetSkillsDir(target) {
-    const info = TARGETS[target];
-    return process.env[info.skillsDirEnv] ?? info.defaultSkillsDir();
-}
-export function targetSkillsDirEnv(target) {
-    return TARGETS[target].skillsDirEnv;
-}

package/dist/ui.js

@@ -1,28 +0,0 @@
-import pc from "picocolors";
-// Cool, restrained terminal palette. Keep orange out of the default CLI surface.
-const isTty = process.stdout.isTTY === true;
-export const c = {
-    coral: (s) => (isTty ? `\x1b[38;5;45m${s}\x1b[0m` : s),
-    blue: (s) => (isTty ? `\x1b[38;5;75m${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("●"),
-};