@effect-app/cli 1.24.0 → 1.26.0

package/dist/gist.js

@@ -0,0 +1,447 @@
+/* eslint-disable no-constant-binary-expression */
+/* eslint-disable no-empty-pattern */
+// import necessary modules from the libraries
+import { FileSystem, Path } from "@effect/platform";
+import { Array, Config, Data, Effect, Option, ParseResult, pipe, Schema, SynchronizedRef } from "effect";
+import * as yaml from "js-yaml";
+import path from "path";
+import { RunCommandService } from "./os-command.js";
+//
+//
+// Schemas
+//
+export class GistEntry extends Schema.Class("GistEntry")({
+    description: Schema.String,
+    public: Schema.Boolean,
+    files: Schema.Array(Schema.String)
+}) {
+}
+/**
+ * Extended gist entry that validates file_name uniqueness and extracts base filenames.
+ *
+ * GitHub Gists have a flat file structure and do not support directories/folders.
+ * All files within a gist must exist in the same namespace, meaning that files
+ * with identical names will collide, even if they originate from different local
+ * directories. When multiple files share the same basename, GitHub will either:
+ * - Reject the gist creation
+ * - Silently overwrite files (last one wins)
+ * - Display unpredictable behavior
+ *
+ * This validation prevents such collisions by detecting when multiple file paths
+ * would result in the same file_name when flattened to the gist structure.
+ *
+ * @example
+ * // These paths would collide in a gist
+ * ["src/config.json", "dist/config.json"] // Both become "config.json"
+ *
+ * @see {@link https://docs.github.com/articles/creating-gists | GitHub Gist Documentation}
+ * @see {@link https://github.com/orgs/community/discussions/29584 | Community Discussion on Gist Folder Support}
+ */
+export class GistEntryDecoded extends GistEntry.transformOrFail("GistEntryDecoded")({
+    files_with_name: Schema.Array(Schema.Struct({
+        path: Schema.String,
+        name: Schema.String
+    }))
+}, {
+    decode: Effect.fnUntraced(function* (entry, _, ast) {
+        const files_with_name = entry.files.map((file) => ({
+            path: file,
+            name: path.basename(file) // <-- I'm using Node's path module here so that this schema works without requirements on Effect's Path module
+        }));
+        // check for duplicate file names
+        const nameMap = new Map();
+        for (const { name, path: filePath } of files_with_name) {
+            if (!nameMap.has(name)) {
+                nameMap.set(name, []);
+            }
+            nameMap.get(name).push(filePath);
+        }
+        // find duplicates and collect all collisions
+        const collisions = [];
+        for (const [fileName, paths] of nameMap.entries()) {
+            if (paths.length > 1) {
+                collisions.push(new ParseResult.Type(ast, paths, `Duplicate file name detected: "${fileName}". Colliding paths: ${paths.join(", ")}`));
+            }
+        }
+        // if there are any collisions, fail with all of them
+        if (Array.isNonEmptyArray(collisions)) {
+            return yield* Effect.fail(new ParseResult.Composite(ast, entry.files, collisions));
+        }
+        return yield* Effect.succeed({
+            ...entry,
+            files_with_name
+        });
+    }),
+    encode: (({ files_with_name, ...entry }) => ParseResult.succeed(entry))
+}) {
+}
+export class GistYAML extends Schema.Class("GistYAML")({
+    gists: Schema.Record({
+        key: Schema.String,
+        value: GistEntryDecoded
+    }),
+    settings: Schema.Struct({
+        token_env: Schema.String,
+        base_directory: Schema.String
+    })
+}) {
+}
+export class GistCacheEntry extends Schema.Class("GistCacheEntry")({
+    name: Schema.String,
+    id: Schema.String
+}) {
+}
+export const GistCacheEntries = Schema.Array(GistCacheEntry);
+/**
+ * Gist cache mapping YAML configuration names to GitHub gist IDs.
+ *
+ * Since GitHub gists don't have user-defined names, we maintain a cache
+ * that maps the human-readable names from our YAML config to actual gist IDs.
+ * This allows us to:
+ * - Update existing gists instead of creating duplicates
+ * - Clean up obsolete entries when gists are removed from config
+ * - Persist the name->ID mapping across CLI runs
+ *
+ * The cache itself is stored as a secret GitHub gist for persistence.
+ */
+export class GistCache {
+    entries;
+    gist_id;
+    constructor({ entries, gist_id }) {
+        this.entries = entries;
+        this.gist_id = gist_id;
+    }
+}
+//
+//
+// Errors
+//
+class GistCacheNotFound extends Data.TaggedError("GistCacheNotFound") {
+}
+class GistYAMLError extends Data.TaggedError("GistYAMLError") {
+}
+//
+//
+// Services
+//
+class GHGistService extends Effect.Service()("GHGistService", {
+    dependencies: [RunCommandService.Default],
+    effect: Effect.gen(function* () {
+        const CACHE_GIST_DESCRIPTION = "GIST_CACHE_DO_NOT_EDIT_effa_cli_internal";
+        const { runGetExitCode, runGetString } = yield* RunCommandService;
+        // the client cannot recover from PlatformErrors, so we convert failures into defects to clean up the signatures
+        const runGetExitCodeSuppressed = (...args) => {
+            return runGetExitCode(...args).pipe(Effect.catchAll((e) => Effect.dieMessage(`Command failed: ${args.join(" ")}\nError: ${e.message}`)), Effect.asVoid);
+        };
+        // the client cannot recover from PlatformErrors, so we convert failures into defects to clean up the signatures
+        const runGetStringSuppressed = (...args) => {
+            return runGetString(...args).pipe(Effect.catchAll((e) => Effect.dieMessage(`Command failed: ${args.join(" ")}\nError: ${e.message}`)));
+        };
+        /**
+         * Extracts the Gist ID from a given GitHub Gist URL: https://gist.github.com/user/ID
+         * @param url - The full URL of the GitHub Gist.
+         * @returns An Option containing the Gist ID if extraction is successful, otherwise None.
+         */
+        function extractGistIdFromUrl(url) {
+            const gist_id = url.trim().split("/").pop();
+            return gist_id && gist_id.length > 0 ? Option.some(gist_id) : Option.none();
+        }
+        const loadGistCache = Effect
+            .fn("effa-cli.gist.loadGistCache")(function* () {
+            // search for existing cache gist
+            const output = yield* runGetStringSuppressed(`gh gist list --filter "${CACHE_GIST_DESCRIPTION}"`)
+                .pipe(Effect.orElse(() => Effect.succeed("")));
+            const lines = output.trim().split("\n").filter((line) => line.trim());
+            // extract first gist ID (should be our cache gist)
+            const firstLine = lines[0];
+            if (!firstLine) {
+                return yield* new GistCacheNotFound({ reason: "Empty gist list output" });
+            }
+            const parts = firstLine.split(/\s+/);
+            const gist_id = parts[0]?.trim();
+            if (!gist_id) {
+                return yield* new GistCacheNotFound({ reason: "No gist ID found in output" });
+            }
+            else {
+                yield* Effect.logInfo(`Found existing cache gist with ID ${gist_id}`);
+            }
+            // read cache gist content
+            const cacheContent = yield* runGetStringSuppressed(`gh gist view ${gist_id}`)
+                .pipe(Effect.orElse(() => Effect.succeed("")));
+            const entries = yield* pipe(cacheContent.split(CACHE_GIST_DESCRIPTION)[1]?.trim(), pipe(Schema.parseJson(GistCacheEntries), Schema.decodeUnknown), Effect.orElse(() => new GistCacheNotFound({ reason: "Failed to parse cache JSON" })));
+            return { entries, gist_id };
+        }, Effect.catchTag("GistCacheNotFound", () => Effect.gen(function* () {
+            // cache doesn't exist, create it
+            yield* Effect.logInfo("Cache gist not found, creating new cache...");
+            const cacheJson = yield* pipe([], pipe(Schema.parseJson(GistCacheEntries), Schema.encodeUnknown), 
+            // cannot recover from parse errors in any case, better to die here instead of cluttering the signature
+            Effect.orDie);
+            const gistUrl = yield* runGetStringSuppressed(`echo '${cacheJson}' | gh gist create --desc="${CACHE_GIST_DESCRIPTION}" -`);
+            const gist_id = yield* pipe(gistUrl, extractGistIdFromUrl, Option.match({
+                onNone: () => Effect.dieMessage(`Could not extract cache's gist ID from URL: ${gistUrl}`),
+                onSome: (id) => Effect.succeed(id).pipe(Effect.tap(Effect.logInfo(`Created new cache gist with ID ${id}`)))
+            }));
+            return { entries: [], gist_id };
+        })), Effect.map(({ entries, gist_id }) => new GistCache({ entries, gist_id })));
+        const saveGistCache = Effect.fn("effa-cli.gist.saveGistCache")(function* (cache) {
+            const cacheJson = yield* pipe(cache.entries, pipe(Schema.parseJson(GistCacheEntries), Schema.encodeUnknown), 
+            // cannot recover from parse errors in any case, better to die here instead of cluttering the signature
+            Effect.orDie);
+            yield* runGetExitCodeSuppressed(`echo '${cacheJson}' | gh gist edit ${cache.gist_id} -`);
+        });
+        const createGistWithFiles = Effect.fn("GHGistService.createGistWithFiles")(function* ({ cache, description, files, gist_name, is_public }) {
+            yield* Effect.logInfo(`Creating gist ${gist_name} with ${files.length} file(s)`);
+            const ghCommand = [
+                "gh",
+                "gist",
+                "create",
+                `--desc="${description}"`,
+                is_public ? "--public" : "",
+                ...files.map((filePath) => `"${filePath}"`)
+            ]
+                .filter((x) => !!x)
+                .join(" ");
+            // create and capture the created gist URL
+            const gistUrl = yield* runGetStringSuppressed(ghCommand);
+            // extract ID from URL
+            return yield* pipe(gistUrl, extractGistIdFromUrl, Option.match({
+                onNone: () => Effect.dieMessage(`Failed to extract gist ID from URL: ${gistUrl}`),
+                onSome: (id) => Effect
+                    .succeed(new GistCache({
+                    gist_id: cache.gist_id,
+                    entries: [...cache.entries, { name: gist_name, id }]
+                }))
+                    .pipe(Effect.tap(Effect.logInfo(`Created gist with ID ${id}`)))
+            }));
+        });
+        const getGistFileNames = Effect.fn("getGistFileNames")(function* ({ gist_id, gist_name }) {
+            yield* Effect.logInfo(`Retrieving file names from gist ${gist_name} with ID ${gist_id}`);
+            const output = yield* runGetStringSuppressed(`gh gist view ${gist_id} --files`);
+            return output
+                .trim()
+                .split("\n")
+                .filter((line) => line.trim());
+        });
+        const removeFileFromGist = Effect.fn("removeFileFromGist")(function* ({ file_name, gist_id, gist_name }) {
+            yield* Effect.logInfo(`Removing file ${file_name} from gist ${gist_name}`);
+            return yield* runGetExitCodeSuppressed(`gh gist edit ${gist_id} --remove "${file_name}"`);
+        });
+        const updateFileOfGist = Effect.fn("updateFileOfGist")(function* ({ file_name, file_path, gist_id, gist_name }) {
+            yield* Effect.logInfo(`Updating file ${file_name} located at ${file_path} of gist ${gist_name}`);
+            const editCommand = [
+                "gh",
+                "gist",
+                "edit",
+                gist_id,
+                "-f",
+                file_name,
+                `"${file_path}"`
+            ]
+                .join(" ");
+            return yield* runGetExitCodeSuppressed(editCommand);
+        });
+        const addFileToGist = Effect.fn("addFileToGist")(function* ({ file_path, gist_id, gist_name }) {
+            yield* Effect.logInfo(`Adding file ${file_path} to gist ${gist_name}`);
+            const editCommand = [
+                "gh",
+                "gist",
+                "edit",
+                gist_id,
+                "-a",
+                `"${file_path}"`
+            ]
+                .join(" ");
+            return yield* runGetExitCodeSuppressed(editCommand);
+        });
+        return {
+            /**
+             * Loads the gist cache from GitHub, containing mappings of YAML configuration names to gist IDs.
+             * If no cache exists, creates a new empty cache gist.
+             *
+             * @returns An Effect that yields a GistCache containing the loaded cache entries and cache gist ID
+             */
+            loadGistCache,
+            /**
+             * Saves the current gist cache state to the GitHub cache gist.
+             * Updates the existing cache gist with the current mappings of names to gist IDs.
+             *
+             * @param cache - The GistCache instance to save
+             * @returns An Effect that succeeds when the cache is successfully saved
+             */
+            saveGistCache,
+            /**
+             * Creates a new GitHub gist with the specified files and updates the local cache.
+             * Generates a GitHub CLI command to create the gist and extracts the resulting gist ID.
+             *
+             * @param cache - The current GistCache instance
+             * @param name - The human-readable name for this gist (used in cache mapping)
+             * @param description - The description for the GitHub gist
+             * @param files - Array of file paths to include in the gist
+             * @param is_public - Whether the gist should be public or private
+             * @returns An Effect that yields an updated GistCache with the new gist entry
+             */
+            createGistWithFiles,
+            /**
+             * Retrieves file names from a GitHub gist.
+             * Fetches the list of files contained in the specified gist.
+             *
+             * @param gist_id - The GitHub gist ID to retrieve file names from
+             * @param gist_name - The human-readable name of the gist (for logging purposes)
+             * @returns An Effect that yields an array of file names
+             */
+            getGistFileNames,
+            /**
+             * Removes a file from a specified GitHub gist.
+             * @param gist_id - The ID of the gist to modify
+             * @param gist_name - The human-readable name of the gist (for logging purposes)
+             * @param file_name - The name of the file to remove from the gist
+             * @returns An Effect that succeeds when the file is removed
+             */
+            removeFileFromGist,
+            /**
+             * Updates a file in a specified GitHub gist.
+             * @param gist_id - The ID of the gist to modify
+             * @param gist_name - The human-readable name of the gist (for logging purposes)
+             * @param file_name - The name of the file to remove from the gist
+             * @param file_path - The local path of the file to update in the gist
+             * @returns An Effect that succeeds when the file is updated
+             */
+            updateFileOfGist,
+            /**
+             * Adds a new file to a specified GitHub gist.
+             * @param gist_id - The ID of the gist to modify
+             * @param gist_name - The human-readable name of the gist (for logging purposes)
+             * @param file_path - The local path of the file to add to the gist
+             * @returns An Effect that succeeds when the file is added
+             */
+            addFileToGist
+        };
+    })
+}) {
+}
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+export class GistHandler extends Effect.Service()("GistHandler", {
+    accessors: true,
+    dependencies: [GHGistService.Default],
+    effect: Effect.gen(function* () {
+        const GH = yield* GHGistService;
+        // I prefer to provide these two only once during the main CLI pipeline setup
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        return {
+            handler: Effect.fn("effa-cli.gist.GistHandler")(function* ({ YAMLPath }) {
+                yield* Effect.logInfo(`Reading configuration from ${YAMLPath}`);
+                const configExists = yield* fs.exists(YAMLPath);
+                if (!configExists) {
+                    return yield* Effect.fail(new Error(`Configuration file not found: ${YAMLPath}`));
+                }
+                const config = yield* pipe(YAMLPath, fs.readFileString, Effect.andThen((content) => Effect.try({
+                    try: () => yaml.load(content),
+                    catch(error) {
+                        return new GistYAMLError({ reason: `Failed to parse YAML: ${error.message}` });
+                    }
+                })), Effect.andThen(Schema.decodeUnknown(GistYAML)));
+                // load GitHub token securely from environment variable
+                const redactedToken = yield* Config.redacted(config.settings.token_env);
+                yield* Effect.logInfo(`Using GitHub token from environment variable: ${config.settings.token_env}`);
+                yield* Effect.logInfo(`Token loaded: ${redactedToken}`); // this will show <redacted> in logs
+                const cache = yield* SynchronizedRef.make(yield* GH.loadGistCache());
+                // handle each gist entry in the configuration
+                for (const [name, gistConfig] of Object.entries(config.gists)) {
+                    const { description, files_with_name, public: is_public } = gistConfig;
+                    yield* Effect.logInfo(`Processing gist ${name}`);
+                    const filesOnDiskWithFullPath = yield* Effect
+                        .all(files_with_name.map((f) => Effect.gen(function* () {
+                        const fullPath = path.join(config.settings.base_directory, f.path);
+                        const fileExists = yield* fs.exists(fullPath);
+                        if (!fileExists) {
+                            yield* Effect.logWarning(`File not found: ${fullPath}, skipping...`);
+                            return Option.none();
+                        }
+                        return Option.some({
+                            path: fullPath,
+                            name: f.name
+                        });
+                    })), {
+                        concurrency: "unbounded"
+                    })
+                        .pipe(Effect.map(Array.getSomes));
+                    const gistFromCache = (yield* SynchronizedRef.get(cache)).entries.find((_) => _.name === name);
+                    // if the gist's name exists in cache, update the existing gist
+                    // otherwise, create a new gist and update the local cache
+                    if (gistFromCache) {
+                        yield* Effect.logInfo(`Updating existing gist ${gistFromCache.name} with ID ${gistFromCache.id}`);
+                        // get current files in the gist to detect removed files
+                        const gistFileNames = new Set(yield* GH.getGistFileNames({
+                            gist_id: gistFromCache.id,
+                            gist_name: gistFromCache.name
+                        }));
+                        const expectedFiles = new Set(filesOnDiskWithFullPath.map(({ name }) => name));
+                        // remove files that are no longer in YAML configuration
+                        for (const gf of gistFileNames) {
+                            if (!expectedFiles.has(gf)) {
+                                yield* GH.removeFileFromGist({
+                                    gist_id: gistFromCache.id,
+                                    gist_name: gistFromCache.name,
+                                    file_name: gf
+                                });
+                            }
+                        }
+                        // update/add files from configuration
+                        for (const f of filesOnDiskWithFullPath) {
+                            if (gistFileNames.has(f.name)) {
+                                yield* GH.updateFileOfGist({
+                                    gist_id: gistFromCache.id,
+                                    gist_name: gistFromCache.name,
+                                    file_name: f.name,
+                                    file_path: f.path
+                                });
+                            }
+                            else {
+                                yield* GH.addFileToGist({
+                                    gist_id: gistFromCache.id,
+                                    gist_name: gistFromCache.name,
+                                    file_path: f.path
+                                });
+                            }
+                        }
+                    }
+                    else {
+                        if (filesOnDiskWithFullPath.length !== 0) {
+                            yield* SynchronizedRef.getAndUpdateEffect(cache, (cache) => {
+                                return GH.createGistWithFiles({
+                                    gist_name: name,
+                                    description,
+                                    is_public,
+                                    cache,
+                                    files: filesOnDiskWithFullPath.map((f) => f.path)
+                                });
+                            });
+                        }
+                        else {
+                            yield* Effect.logWarning(`No valid files found for gist ${name}, skipping creation...`);
+                        }
+                    }
+                    // here the local cache has been updated, but not yet saved to GitHub
+                    // we still want to remove gists from cache that are no longer in the configuration
+                    const configGistNames = new Set(Object.entries(config.gists).map(([name]) => name));
+                    const newCache = yield* SynchronizedRef.updateAndGetEffect(cache, Effect.fnUntraced(function* (cache) {
+                        const newEntries = [...cache.entries];
+                        for (let i = newEntries.length - 1; i >= 0; i--) {
+                            const cacheEntry = newEntries[i];
+                            if (cacheEntry && !configGistNames.has(cacheEntry.name)) {
+                                yield* Effect.logInfo(`Obsolete gist ${cacheEntry.name} with ID ${cacheEntry.id}) will be removed from cache`);
+                                newEntries.splice(i, 1);
+                            }
+                        }
+                        return { ...cache, entries: newEntries };
+                    }));
+                    yield* GH.saveGistCache(newCache);
+                    yield* Effect.logInfo("Gist operations completed");
+                }
+            })
+        };
+    })
+}) {
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gist.js","sourceRoot":"","sources":["../src/gist.ts"],"names":[],"mappings":"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"}