git-dlp 0.2.0

package/dist-types/src/getPathContents/PathContentsMetaInfo.d.ts

@@ -0,0 +1,66 @@
+import * as Effect from 'effect/Effect';
+export declare const PathContentsMetaInfo: Effect.Effect<{
+    readonly type: "dir";
+    readonly name: string;
+    readonly path: string;
+    readonly treeSha: string;
+    readonly entries: readonly {
+        readonly name: string;
+        readonly path: string;
+        readonly sha: string;
+        readonly type: "dir" | "file" | "submodule" | "symlink";
+        readonly size: number;
+    }[];
+    readonly meta: "This nested directory can be downloaded as a git tree";
+} | {
+    readonly type: "dir";
+    readonly treeSha: string;
+    readonly entries: readonly {
+        readonly name: string;
+        readonly path: string;
+        readonly sha: string;
+        readonly type: "dir" | "file" | "submodule" | "symlink";
+        readonly size: number;
+    }[];
+    readonly meta: "This root directory of the repo can be downloaded as a git tree";
+    readonly name?: never;
+    readonly path?: never;
+} | {
+    readonly meta: "This file can be downloaded as a blob";
+    readonly blobSha: string;
+    readonly name: string;
+    readonly path: string;
+    readonly type: "file";
+    readonly size: number;
+    readonly treeSha?: never;
+    readonly entries?: never;
+} | {
+    readonly meta: "This file can be downloaded as a git-LFS object";
+    readonly gitLFSObjectIdSha256: string;
+    readonly gitLFSVersion: string;
+    readonly blobSha: string;
+    readonly name: string;
+    readonly path: string;
+    readonly type: "file";
+    readonly size: number;
+    readonly treeSha?: never;
+    readonly entries?: never;
+} | {
+    readonly contentStream: Effect.Effect<import("node:stream").Readable, import("../castToReadableStream.ts").FailedToCastDataToReadableStreamError, never>;
+    readonly meta: "This file is small enough that GitHub API decided to inline it";
+    readonly blobSha: string;
+    readonly name: string;
+    readonly path: string;
+    readonly type: "file";
+    readonly size: number;
+    readonly treeSha?: never;
+    readonly entries?: never;
+}, import("@octokit/request-error").RequestError | import("../commonErrors.ts").GitHubApiGeneralServerError | import("../commonErrors.ts").GitHubApiGeneralUserError | import("../commonErrors.ts").GitHubApiThingNotExistsOrYouDontHaveAccessError | import("../commonErrors.ts").GitHubApiRepoIsEmptyError | import("../commonErrors.ts").GitHubApiNoCommitFoundForGitRefError | import("../commonErrors.ts").GitHubApiBadCredentialsError | import("../commonErrors.ts").GitHubApiAuthRatelimitedError | import("../commonErrors.ts").GitHubApiRatelimitedError | import("effect/Cause").UnknownException | import("./ParsedMetaInfoAboutPathContentsFromGitHubAPI.ts").FailedToParseResponseFromRepoPathContentsMetaInfoAPIError | import("./parseGitLFSObjectEither.ts").InconsistentExpectedAndRealContentSizeError, Readonly<{
+    repo: Readonly<{
+        owner: string;
+        name: string;
+    }>;
+    pathToEntityInRepo: string;
+    gitRef: string;
+}> | import("@octokit/core").Octokit>;
+//# sourceMappingURL=PathContentsMetaInfo.d.ts.map

package/dist-types/src/getPathContents/PathContentsMetaInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PathContentsMetaInfo.d.ts","sourceRoot":"","sources":["../../../src/getPathContents/PathContentsMetaInfo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAMvC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA8E/B,CAAA"}

package/dist-types/src/getPathContents/RawStreamOfRepoPathContentsFromGitHubAPI.d.ts

@@ -0,0 +1,9 @@
+export declare const RawStreamOfRepoPathContentsFromGitHubAPI: import("effect/Effect").Effect<import("node:stream").Readable, import("../castToReadableStream.ts").FailedToCastDataToReadableStreamError | import("@octokit/request-error").RequestError | import("../commonErrors.ts").GitHubApiGeneralServerError | import("../commonErrors.ts").GitHubApiGeneralUserError | import("../commonErrors.ts").GitHubApiThingNotExistsOrYouDontHaveAccessError | import("../commonErrors.ts").GitHubApiRepoIsEmptyError | import("../commonErrors.ts").GitHubApiNoCommitFoundForGitRefError | import("../commonErrors.ts").GitHubApiBadCredentialsError | import("../commonErrors.ts").GitHubApiAuthRatelimitedError | import("../commonErrors.ts").GitHubApiRatelimitedError | import("effect/Cause").UnknownException, Readonly<{
+    repo: Readonly<{
+        owner: string;
+        name: string;
+    }>;
+    pathToEntityInRepo: string;
+    gitRef: string;
+}> | import("@octokit/core").Octokit>;
+//# sourceMappingURL=RawStreamOfRepoPathContentsFromGitHubAPI.d.ts.map

package/dist-types/src/getPathContents/RawStreamOfRepoPathContentsFromGitHubAPI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RawStreamOfRepoPathContentsFromGitHubAPI.d.ts","sourceRoot":"","sources":["../../../src/getPathContents/RawStreamOfRepoPathContentsFromGitHubAPI.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,wCAAwC;;;;;;;qCAEpD,CAAA"}

package/dist-types/src/getPathContents/RepoPathContentsFromGitHubAPI.d.ts

@@ -0,0 +1,81 @@
+import { RequestError } from '@octokit/request-error';
+import type { OctokitResponse } from '@octokit/types';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import { GitHubApiNoCommitFoundForGitRefError, GitHubApiRepoIsEmptyError, GitHubApiThingNotExistsOrYouDontHaveAccessError } from '../commonErrors.ts';
+export declare const RepoPathContentsFromGitHubAPI: (format: "object" | "raw", streamBody?: boolean | undefined) => Effect.Effect<OctokitResponse<{
+    type: "dir" | "file" | "submodule" | "symlink";
+    size: number;
+    name: string;
+    path: string;
+    content?: string;
+    sha: string;
+    url: string;
+    git_url: string | null;
+    html_url: string | null;
+    download_url: string | null;
+    _links: {
+        git: string | null;
+        html: string | null;
+        self: string;
+    };
+}[] | {
+    type: "file";
+    encoding: string;
+    size: number;
+    name: string;
+    path: string;
+    content: string;
+    sha: string;
+    url: string;
+    git_url: string | null;
+    html_url: string | null;
+    download_url: string | null;
+    _links: {
+        git: string | null;
+        html: string | null;
+        self: string;
+    };
+    target?: string;
+    submodule_git_url?: string;
+} | {
+    type: "symlink";
+    target: string;
+    size: number;
+    name: string;
+    path: string;
+    sha: string;
+    url: string;
+    git_url: string | null;
+    html_url: string | null;
+    download_url: string | null;
+    _links: {
+        git: string | null;
+        html: string | null;
+        self: string;
+    };
+} | {
+    type: "submodule";
+    submodule_git_url: string;
+    size: number;
+    name: string;
+    path: string;
+    sha: string;
+    url: string;
+    git_url: string | null;
+    html_url: string | null;
+    download_url: string | null;
+    _links: {
+        git: string | null;
+        html: string | null;
+        self: string;
+    };
+}, 200>, RequestError | import("../commonErrors.ts").GitHubApiGeneralServerError | import("../commonErrors.ts").GitHubApiGeneralUserError | GitHubApiThingNotExistsOrYouDontHaveAccessError | GitHubApiRepoIsEmptyError | GitHubApiNoCommitFoundForGitRefError | import("../commonErrors.ts").GitHubApiBadCredentialsError | import("../commonErrors.ts").GitHubApiAuthRatelimitedError | import("../commonErrors.ts").GitHubApiRatelimitedError | Cause.UnknownException, Readonly<{
+    repo: Readonly<{
+        owner: string;
+        name: string;
+    }>;
+    pathToEntityInRepo: string;
+    gitRef: string;
+}> | import("@octokit/core").Octokit>;
+//# sourceMappingURL=RepoPathContentsFromGitHubAPI.d.ts.map

package/dist-types/src/getPathContents/RepoPathContentsFromGitHubAPI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RepoPathContentsFromGitHubAPI.d.ts","sourceRoot":"","sources":["../../../src/getPathContents/RepoPathContentsFromGitHubAPI.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAErD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EACL,oCAAoC,EACpC,yBAAyB,EACzB,+CAA+C,EAEhD,MAAM,oBAAoB,CAAA;AAO3B,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA4CxC,CAAA"}

package/dist-types/src/getPathContents/index.d.ts

@@ -0,0 +1,5 @@
+export { FailedToParseResponseFromRepoPathContentsMetaInfoAPIError } from './ParsedMetaInfoAboutPathContentsFromGitHubAPI.ts';
+export { PathContentsMetaInfo } from './PathContentsMetaInfo.ts';
+export { FailedToParseGitLFSInfoError, InconsistentExpectedAndRealContentSizeError, } from './parseGitLFSObjectEither.ts';
+export { RawStreamOfRepoPathContentsFromGitHubAPI } from './RawStreamOfRepoPathContentsFromGitHubAPI.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist-types/src/getPathContents/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/getPathContents/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yDAAyD,EAAE,MAAM,mDAAmD,CAAA;AAC7H,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,EACL,4BAA4B,EAC5B,2CAA2C,GAC5C,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,wCAAwC,EAAE,MAAM,+CAA+C,CAAA"}

package/dist-types/src/getPathContents/parseGitLFSObjectEither.d.ts

@@ -0,0 +1,40 @@
+import * as Either from 'effect/Either';
+import * as ParseResult from 'effect/ParseResult';
+import { type TaggedErrorClass } from '../TaggedErrorVerifyingCause.ts';
+export declare const parseGitLFSObjectEither: ({ contentAsBuffer, expectedContentSize, }: {
+    contentAsBuffer: Buffer<ArrayBuffer>;
+    expectedContentSize: number;
+}) => Either.Either<"This is not a git LFS object" | {
+    readonly gitLFSObjectIdSha256: string;
+    readonly gitLFSVersion: string;
+}, InconsistentExpectedAndRealContentSizeError>;
+export type FailedToParseGitLFSInfoErrorClass = TaggedErrorClass<{
+    ErrorName: 'FailedToParseGitLFSInfoError';
+    ExpectedCauseClass: typeof ParseResult.ParseError;
+    DynamicContext: {
+        partOfContentThatCouldBeGitLFSInfo: string;
+    };
+}>;
+declare const _1: FailedToParseGitLFSInfoErrorClass;
+export declare class FailedToParseGitLFSInfoError extends _1 {
+}
+type InconsistentSizesDynamicContext = {
+    actual: number;
+    expected: number;
+    gitLFSInfo: Either.Either<Readonly<{
+        version: string;
+        oidSha256: string;
+        size: number;
+    }>, InstanceType<FailedToParseGitLFSInfoErrorClass>>;
+};
+declare const _2: TaggedErrorClass<{
+    ErrorName: 'InconsistentExpectedAndRealContentSizeError';
+    StaticContext: {
+        comment: string;
+    };
+    DynamicContext: InconsistentSizesDynamicContext;
+}>;
+export declare class InconsistentExpectedAndRealContentSizeError extends _2 {
+}
+export {};
+//# sourceMappingURL=parseGitLFSObjectEither.d.ts.map

package/dist-types/src/getPathContents/parseGitLFSObjectEither.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseGitLFSObjectEither.d.ts","sourceRoot":"","sources":["../../../src/getPathContents/parseGitLFSObjectEither.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,WAAW,MAAM,oBAAoB,CAAA;AAGjD,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,iCAAiC,CAAA;AAExC,eAAO,MAAM,uBAAuB,GAAI,2CAGrC;IACD,eAAe,EAAE,MAAM,CAAC,WAAW,CAAC,CAAA;IACpC,mBAAmB,EAAE,MAAM,CAAA;CAC5B;;;+CA2CG,CAAA;AA0BJ,MAAM,MAAM,iCAAiC,GAAG,gBAAgB,CAAC;IAC/D,SAAS,EAAE,8BAA8B,CAAA;IACzC,kBAAkB,EAAE,OAAO,WAAW,CAAC,UAAU,CAAA;IACjD,cAAc,EAAE;QAAE,kCAAkC,EAAE,MAAM,CAAA;KAAE,CAAA;CAC/D,CAAC,CAAA;AAEF,QAAA,MAAM,EAAE,EAAE,iCAOP,CAAA;AAEH,qBAAa,4BAA6B,SAAQ,EAAE;CAAG;AAEvD,KAAK,+BAA+B,GAAG;IACrC,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAC,MAAM,CACvB,QAAQ,CAAC;QACP,OAAO,EAAE,MAAM,CAAA;QACf,SAAS,EAAE,MAAM,CAAA;QACjB,IAAI,EAAE,MAAM,CAAA;KACb,CAAC,EACF,YAAY,CAAC,iCAAiC,CAAC,CAChD,CAAA;CACF,CAAA;AAKD,QAAA,MAAM,EAAE,EAAE,gBAAgB,CAAC;IACzB,SAAS,EAAE,6CAA6C,CAAA;IACxD,aAAa,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;IAClC,cAAc,EAAE,+BAA+B,CAAA;CAChD,CAiBA,CAAA;AAED,qBAAa,2CAA4C,SAAQ,EAAE;CAAG"}

package/dist-types/src/getReadableTarGzStreamOfRepoDirectory.d.ts

@@ -0,0 +1,13 @@
+import { RequestError } from '@octokit/request-error';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import { GitHubApiGeneralUserError } from './commonErrors.ts';
+export declare const getReadableTarGzStreamOfRepoDirectory: (gitRefWhichWillBeUsedToIdentifyGitTree?: string) => Effect.Effect<import("node:stream").Readable, import("./castToReadableStream.ts").FailedToCastDataToReadableStreamError | RequestError | import("./commonErrors.ts").GitHubApiGeneralServerError | GitHubApiGeneralUserError | import("./commonErrors.ts").GitHubApiThingNotExistsOrYouDontHaveAccessError | import("./commonErrors.ts").GitHubApiBadCredentialsError | import("./commonErrors.ts").GitHubApiAuthRatelimitedError | import("./commonErrors.ts").GitHubApiRatelimitedError | Cause.UnknownException, Readonly<{
+    repo: Readonly<{
+        owner: string;
+        name: string;
+    }>;
+    pathToEntityInRepo: string;
+    gitRef: string;
+}> | import("@octokit/core").Octokit>;
+//# sourceMappingURL=getReadableTarGzStreamOfRepoDirectory.d.ts.map

package/dist-types/src/getReadableTarGzStreamOfRepoDirectory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getReadableTarGzStreamOfRepoDirectory.d.ts","sourceRoot":"","sources":["../../src/getReadableTarGzStreamOfRepoDirectory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAErD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,EACL,yBAAyB,EAE1B,MAAM,mBAAmB,CAAA;AAI1B,eAAO,MAAM,qCAAqC,GAChD,yCAAyC,MAAM;;;;;;;qCAM9C,CAAA"}

package/dist-types/src/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module
+ */
+export * from './cli.ts';
+export type { InputConfig, OutputConfig, SingleTargetConfig, } from './configContext.ts';
+export { downloadEntityFromRepo } from './downloadEntityFromRepo.ts';
+export * from './errors.ts';
+export { OctokitLayer } from './octokit.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist-types/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,UAAU,CAAA;AACxB,YAAY,EACV,WAAW,EACX,YAAY,EACZ,kBAAkB,GACnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AACpE,cAAc,aAAa,CAAA;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA"}

package/dist-types/src/octokit.d.ts

@@ -0,0 +1,8 @@
+import { Octokit, type OctokitOptions } from '@octokit/core';
+import * as Context from 'effect/Context';
+import * as Layer from 'effect/Layer';
+type OctokitTag = Context.Tag<Octokit, Octokit>;
+export declare const OctokitTag: OctokitTag;
+export declare const OctokitLayer: (options?: OctokitOptions) => Layer.Layer<Octokit, never, never>;
+export {};
+//# sourceMappingURL=octokit.d.ts.map

package/dist-types/src/octokit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"octokit.d.ts","sourceRoot":"","sources":["../../src/octokit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAA;AAE5D,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAIrC,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;AAE/C,eAAO,MAAM,UAAU,EAAE,UAAsD,CAAA;AAE/E,eAAO,MAAM,YAAY,EAAE,CACzB,OAAO,CAAC,EAAE,cAAc,KACrB,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,CAC0B,CAAA"}

package/dist-types/src/unpackRepoFolderTarGzStreamToFs.d.ts

@@ -0,0 +1,16 @@
+import type { Readable } from 'node:stream';
+import * as Effect from 'effect/Effect';
+import { type TaggedErrorClass } from './TaggedErrorVerifyingCause.ts';
+export declare const unpackRepoFolderTarGzStreamToFs: <E, R>(self: Effect.Effect<Readable, E, R>) => Effect.Effect<void, E | FailedToUnpackRepoFolderTarGzStreamToFsError, Readonly<{
+    localPathAtWhichEntityFromRepoWillBeAvailable: string;
+}> | R>;
+declare const _1: TaggedErrorClass<{
+    ErrorName: 'FailedToUnpackRepoFolderTarGzStreamToFsError';
+    DynamicContext: {
+        cause: unknown;
+    };
+}>;
+export declare class FailedToUnpackRepoFolderTarGzStreamToFsError extends _1 {
+}
+export {};
+//# sourceMappingURL=unpackRepoFolderTarGzStreamToFs.d.ts.map

package/dist-types/src/unpackRepoFolderTarGzStreamToFs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unpackRepoFolderTarGzStreamToFs.d.ts","sourceRoot":"","sources":["../../src/unpackRepoFolderTarGzStreamToFs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAM3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,gCAAgC,CAAA;AAMvC,eAAO,MAAM,+BAA+B,GAAI,CAAC,EAAE,CAAC,EAClD,MAAM,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC;;OA6BjC,CAAA;AAIJ,QAAA,MAAM,EAAE,EAAE,gBAAgB,CAAC;IACzB,SAAS,EAAE,8CAA8C,CAAA;IACzD,cAAc,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAA;CACnC,CAGA,CAAA;AAED,qBAAa,4CAA6C,SAAQ,EAAE;CAAG"}

package/dist-types/src/writeFileStreamToDestinationPath.d.ts

@@ -0,0 +1,16 @@
+import type { Readable } from 'node:stream';
+import * as Effect from 'effect/Effect';
+import { type TaggedErrorClass } from './TaggedErrorVerifyingCause.ts';
+export declare const writeFileStreamToDestinationPath: <E, R>(self: Effect.Effect<Readable, E, R>) => Effect.Effect<void, E | FailedToWriteFileStreamToDestinationPathError, Readonly<{
+    localPathAtWhichEntityFromRepoWillBeAvailable: string;
+}> | R>;
+declare const _1: TaggedErrorClass<{
+    ErrorName: 'FailedToWriteFileStreamToDestinationPathError';
+    DynamicContext: {
+        cause: unknown;
+    };
+}>;
+export declare class FailedToWriteFileStreamToDestinationPathError extends _1 {
+}
+export {};
+//# sourceMappingURL=writeFileStreamToDestinationPath.d.ts.map

package/dist-types/src/writeFileStreamToDestinationPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeFileStreamToDestinationPath.d.ts","sourceRoot":"","sources":["../../src/writeFileStreamToDestinationPath.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAG3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,gCAAgC,CAAA;AAIvC,eAAO,MAAM,gCAAgC,GAAI,CAAC,EAAE,CAAC,EACnD,MAAM,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC;;OAiBjC,CAAA;AAIJ,QAAA,MAAM,EAAE,EAAE,gBAAgB,CAAC;IACzB,SAAS,EAAE,+CAA+C,CAAA;IAC1D,cAAc,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAA;CACnC,CAGA,CAAA;AAED,qBAAa,6CAA8C,SAAQ,EAAE;CAAG"}

package/package.json

@@ -0,0 +1,139 @@
+{
+  "name": "git-dlp",
+  "type": "module",
+  "version": "0.2.0",
+  "description": "Download any directory at any depth from any repo on GitHub on any git ref",
+  "devDependencies": {
+    "@effect/language-service": "^0.86.2",
+    "@effect/vitest": "^0.29.0",
+    "@evadev/tsconfig": "1.0.0",
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^1.0.0",
+    "@vitest/coverage-v8": "^4.1.7",
+    "rollup": "^4.60.4",
+    "rollup-plugin-visualizer": "^7.0.1",
+    "ts-namespace-import": "nounder/ts-namespace-import",
+    "ts-patch": "^4.0.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
+  },
+  "peerDependencies": {
+    "@effect/cli": "^0.75.1",
+    "@effect/platform": "^0.96.1",
+    "@effect/platform-node": "^0.106.0",
+    "effect": "^3.19.16"
+  },
+  "dependencies": {
+    "@evadev/effect-helpers": "0.1.2",
+    "@octokit/core": "^7.0.6",
+    "@octokit/request-error": "^7.1.0",
+    "@octokit/types": "^16.0.0",
+    "@total-typescript/ts-reset": "^0.6.1",
+    "@types/tar-fs": "^2.0.4",
+    "effect-errors": "^1.10.22",
+    "outdent": "^0.8.0",
+    "tar-fs": "^3.0.8",
+    "tsafe": "^1.8.5"
+  },
+  "homepage": "https://github.com/nikelborm/effect-garden/tree/main/packages/git-dl#readme",
+  "bugs": {
+    "url": "https://github.com/nikelborm/effect-garden/issues",
+    "email": "evadev@duck.com"
+  },
+  "keywords": [
+    "github",
+    "git",
+    "octokit",
+    "github-api",
+    "folder",
+    "scraper",
+    "downloader",
+    "download",
+    "extract",
+    "tarball",
+    "targz",
+    "directory"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/nikelborm/effect-garden.git",
+    "directory": "packages/git-dl"
+  },
+  "scripts": {
+    "build": "./scripts/build.sh",
+    "coverage": "vitest run --coverage",
+    "doc": "./scripts/generate_docs.sh",
+    "docs": "./scripts/generate_docs.sh",
+    "print-important-ts-files": "find . -type f -name '*.ts' |grep -vE '^./(node_modules|tmp|dist|(vite\\.config|.*\\.spec|scratchpad)\\.ts)'",
+    "scratchpad": "node --use-strict --env-file=.env ./scratchpad.ts",
+    "start": "node --env-file=.env ./git-dl.ts",
+    "test": "vitest --typecheck --watch",
+    "test-jsr": "tspc && jsr publish --dry-run",
+    "test-once": "vitest --run",
+    "watch-docs": "find src/ cli.ts index.ts errors.ts ./scripts/generate_docs.sh | entr -can ./scripts/generate_docs.sh"
+  },
+  "author": {
+    "name": "nikelborm",
+    "email": "evadev@duck.com",
+    "url": "https://github.com/nikelborm"
+  },
+  "contributors": [
+    {
+      "name": "nikelborm",
+      "email": "evadev@duck.com",
+      "url": "https://github.com/nikelborm"
+    }
+  ],
+  "maintainers": [
+    {
+      "name": "nikelborm",
+      "email": "evadev@duck.com",
+      "url": "https://github.com/nikelborm"
+    }
+  ],
+  "license": "MIT",
+  "private": false,
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  },
+  "exports": {
+    ".": {
+      "types": "./dist-types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*.js": {
+      "types": "./dist-types/src/*.d.ts",
+      "default": "./dist/src/*.js"
+    },
+    "./*.ts": "./src/*.ts",
+    "./*": {
+      "types": "./dist-types/src/*.d.ts",
+      "default": "./dist/src/*.js"
+    },
+    "./internal/*": null,
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist-types/index.d.ts",
+  "bin": {
+    "gdl": "dist/git-dl.js",
+    "git-dl": "dist/git-dl.js"
+  },
+  "files": [
+    "dist",
+    "dist-types",
+    "index.ts",
+    "cli.ts",
+    "errors.ts",
+    "template.env",
+    "src",
+    "!dist/minified",
+    "!**/*.tsbuildinfo",
+    "!**/*.spec.*",
+    "!**/scratchpad.*"
+  ]
+}

package/src/TaggedErrorVerifyingCause.ts

@@ -0,0 +1,142 @@
+import type { Equals } from 'tsafe'
+
+import type * as Cause from 'effect/Cause'
+import * as Data from 'effect/Data'
+import * as Predicate from 'effect/Predicate'
+
+const removeLastIfItIsEmptyObject = (arr: Array<unknown>) =>
+  Object.keys(arr.at(-1) ?? {}).length ? arr : arr.slice(0, -1)
+
+export const buildTaggedErrorClassVerifyingCause =
+  <const DynamicContext extends Record<string, unknown> = {}>() =>
+  <
+    const ErrorName extends string,
+    Config extends {
+      ErrorName: ErrorName
+      ExpectedCauseClass: ExpectedCauseClass
+      StaticContext: StaticContext
+      DynamicContext: DynamicContext
+    },
+    const StaticContext extends Record<string, unknown> = {},
+    ExpectedCauseClass extends WideErrorConstructor | undefined = undefined,
+  >(
+    errorName: ErrorName,
+    customMessage: string | ((...args: MessageRendererArgs<Config>) => string),
+    expectedCauseClass?: ExpectedCauseClass,
+    staticContext?: StaticContext,
+  ): TaggedErrorClass<Config> => {
+    // TODO: Consider using Schema.TaggedError instead of Data.TaggedError
+    const CustomTaggedErrorClass = Data.TaggedError(errorName)<
+      Record<'message' | '_tag' | 'name', unknown>
+    >
+
+    class Base extends CustomTaggedErrorClass {
+      constructor(...args: ConstructorArgs<Config>) {
+        if (expectedCauseClass && !(args[0] instanceof expectedCauseClass))
+          throw new Error(
+            `Provided cause of incorrect type to "${
+              errorName
+            }" class. Expected cause class: "${expectedCauseClass.name}"`,
+          )
+
+        const customMessageRendererArgs = removeLastIfItIsEmptyObject(
+          expectedCauseClass
+            ? [args[0], { ...(args[1] ?? {}), ...staticContext }]
+            : [{ ...(args[0] ?? {}), ...staticContext }],
+        ) as MessageRendererArgs<Config>
+
+        super({
+          name: errorName,
+          message: Predicate.isFunction(customMessage)
+            ? customMessage(...customMessageRendererArgs)
+            : customMessage,
+          ...(!!expectedCauseClass && { cause: args[0] }),
+          ...staticContext,
+          ...(args[+!!expectedCauseClass] ?? {}), // dynamic context
+        })
+      }
+    }
+
+    return Base as TaggedErrorClass<Config>
+  }
+
+export type TaggedErrorClass<Config extends ConfigTemplate> = [string] extends [
+  Config['ErrorName'],
+]
+  ? 'ErrorName should be a string literal'
+  : new (
+      ...args: ConstructorArgs<Config>
+    ) => Cause.YieldableError &
+      Readonly<
+        {
+          message: string
+          _tag: Config['ErrorName']
+          name: Config['ErrorName']
+        } & GetValueByKey<Config, 'DynamicContext', {}> &
+          GetValueByKey<Config, 'StaticContext', {}> &
+          IsExpectedCauseClassManuallySpecified<
+            Config,
+            { cause: GetCauseInstance<Config> },
+            {}
+          >
+      >
+
+type ConstructorArgs<Config extends ConfigTemplate> = CauseArgTuple<
+  Config,
+  GetValueByKey<Config, 'DynamicContext', {}>
+>
+
+type MessageRendererArgs<Config extends ConfigTemplate> = CauseArgTuple<
+  Config,
+  GetValueByKey<Config, 'DynamicContext', {}> &
+    GetValueByKey<Config, 'StaticContext', {}>
+>
+
+type ConfigTemplate = {
+  ErrorName: string
+  ExpectedCauseClass?: WideErrorConstructor | undefined
+  StaticContext?: Record<string, unknown> | undefined
+  DynamicContext?: Record<string, unknown> | undefined
+}
+
+type CauseArgTuple<Config extends ConfigTemplate, Context> = [
+  ...IsExpectedCauseClassManuallySpecified<
+    Config,
+    [cause: GetCauseInstance<Config>],
+    []
+  >,
+  ...(Equals<Context, {}> extends true ? [] : [context: Readonly<Context>]),
+]
+
+type IsExpectedCauseClassManuallySpecified<
+  Config extends ConfigTemplate,
+  IfTrue,
+  IfFalse,
+> =
+  GetValueByKey<
+    Config,
+    'ExpectedCauseClass',
+    WideErrorConstructor | undefined
+  > extends infer ExpectedCauseClass
+    ? [ExpectedCauseClass] extends [WideErrorConstructor]
+      ? IfTrue
+      : IfFalse
+    : never
+
+type GetCauseInstance<Config extends ConfigTemplate> = InstanceType<
+  Exclude<Config['ExpectedCauseClass'], undefined>
+>
+
+export type GetValueByKey<
+  Config extends Record<string, unknown>,
+  Key extends string,
+  Default,
+> = [Key] extends [keyof Config]
+  ? Exclude<Config[Key], undefined> extends infer TargetValue
+    ? [TargetValue] extends [never]
+      ? Default
+      : TargetValue
+    : Default
+  : Default
+
+type WideErrorConstructor = new (...args: any[]) => Error

package/src/castToReadableStream.ts

@@ -0,0 +1,44 @@
+import { Readable } from 'node:stream'
+import { ReadableStream } from 'node:stream/web'
+
+import * as Effect from 'effect/Effect'
+
+import {
+  buildTaggedErrorClassVerifyingCause,
+  type TaggedErrorClass,
+} from './TaggedErrorVerifyingCause.ts'
+
+// TODO: should eventually delete this shit because:
+// 1. Effect has streams and I now know them well
+// 2. Effect has Platform's utilities like BunSink and BunStream
+export const CastToReadableStream = <E, R>(
+  self: Effect.Effect<unknown, E, R>,
+) =>
+  Effect.gen(function* () {
+    const data = yield* self
+
+    if (data instanceof ArrayBuffer || data instanceof Buffer)
+      return new Readable({
+        read() {
+          this.push(data)
+          this.push(null)
+        },
+      })
+
+    if (data instanceof ReadableStream) return Readable.fromWeb(data)
+
+    if (data instanceof Readable) return data
+
+    return yield* new FailedToCastDataToReadableStreamError()
+  })
+
+// Extracting to a separate type is required by JSR, so that consumers of the
+// library will have much faster type inference
+const _1: TaggedErrorClass<{
+  ErrorName: 'FailedToCastDataToReadableStreamError'
+}> = buildTaggedErrorClassVerifyingCause()(
+  'FailedToCastDataToReadableStreamError',
+  'Error: Failed to cast data to Readable stream, type of argument is not familiar',
+)
+
+export class FailedToCastDataToReadableStreamError extends _1 {}

package/src/cli.ts

@@ -0,0 +1,14 @@
+/**
+ * Reusable in {@link https://effect.website/ Effect} applications CLI Options
+ * backed by ENV variables
+ *
+ * @module
+ */
+
+export {
+  destinationPathCLIOptionBackedByEnv,
+  gitRefCLIOptionBackedByEnv,
+  pathToEntityInRepoCLIOptionBackedByEnv,
+  repoNameCLIOptionBackedByEnv,
+  repoOwnerCLIOptionBackedByEnv,
+} from './commandLineParams.ts'