git-dlp 0.2.0

package/src/commandLineParams.ts

@@ -0,0 +1,257 @@
+import { outdent } from 'outdent'
+
+import * as CLIOptions from '@effect/cli/Options'
+import * as Path from '@effect/platform/Path'
+import * as Config from 'effect/Config'
+import * as Effect from 'effect/Effect'
+import * as EFunction from 'effect/Function'
+import * as ParseResult from 'effect/ParseResult'
+import * as Schema from 'effect/Schema'
+
+const isGitHubSlug = (s: string) => !!s.match(/^[a-z0-9.\-_]+$/gi)
+
+const invalidGitHubSlugMessage =
+  'GitHub handle should have only ASCII letters, digits, and the characters ".", "-", and "_"'
+
+// https://developer.mozilla.org/en-US/docs/Glossary/Slug
+const GitHubSlugStringSchema = Schema.NonEmptyString.pipe(
+  Schema.filter(s => isGitHubSlug(s) || invalidGitHubSlugMessage),
+  // TODO brandify this
+)
+
+// TODO change approach to default values. Either remove defaults completely or
+// provided an easy way to set for people their own defaults instead of
+// comparing them to the hardcoded default value. Also document the helpers for
+// overriding defaults in TSDoc of exported CLIOptions objects
+
+const withGitHubSlugConfigValidation = Config.validate({
+  message: invalidGitHubSlugMessage,
+  validation: isGitHubSlug,
+})
+
+const pathToEntityInRepoDescription = 'Path to file or directory in repo'
+
+const repoOwnerDescription = outdent`
+  This is a username (login handle) of a person owning repo you
+  are trying to download from. For example, if the repository's URL is
+  \`https://github.com/apache/superset\`, the owner is \`apache\`
+`
+
+const repoNameDescription = outdent`
+  This is the name handle of the repository you are trying to download
+  from. For example, if the repository's URL is
+  \`https://github.com/apache/superset\`, the name is \`superset\`
+`
+
+const destinationPathDescription = outdent`
+  Local path of the downloaded file or directory. If
+  "pathToEntityInRepo" points to a file, then last element of the
+  destination path will be new file name. If "pathToEntityInRepo" points
+  to a directory then all files and directories inside directory at
+  "pathToEntityInRepo" will be put into a directory with name equal last
+  element of destination path. If the directory doesn't exist, it will
+  be automatically created.
+`
+
+const gitRefDescription = outdent`
+  This is the commit's SHA hash, branch name, tag name, or any other ref
+  you want to download from. If you don't specify it, the default branch
+  in the repository will be used.
+`
+
+const RepoNameConfig = EFunction.pipe(
+  Config.nonEmptyString('REPO_NAME'),
+  withGitHubSlugConfigValidation,
+  Config.withDescription(repoNameDescription),
+)
+
+const RepoOwnerConfig = EFunction.pipe(
+  Config.nonEmptyString('REPO_OWNER'),
+  withGitHubSlugConfigValidation,
+  Config.withDescription(repoOwnerDescription),
+)
+
+const DestinationPathConfig = EFunction.pipe(
+  Config.nonEmptyString('DESTINATION_PATH'),
+  Config.withDefault('./destination'),
+  Config.withDescription(destinationPathDescription),
+)
+
+const PathToEntityInRepoConfig = EFunction.pipe(
+  Config.nonEmptyString('PATH_TO_ENTITY_IN_REPO'),
+  Config.withDefault('.'),
+  Config.withDescription(pathToEntityInRepoDescription),
+)
+
+const GitRefConfig = EFunction.pipe(
+  Config.nonEmptyString('GIT_REF'),
+  Config.withDefault('HEAD'),
+  Config.withDescription(gitRefDescription),
+)
+
+const CleanRepoEntityPathString = Schema.transformOrFail(
+  Schema.NonEmptyString,
+  Schema.NonEmptyString,
+  {
+    strict: true,
+    decode: (dirtyPathToEntityInRepo, _, ast) =>
+      Effect.flatMap(Path.Path, path => {
+        // dot can be there only when that's all there is. path.join(...)
+        // removes all './', so '.' will never be just left by themself. If it's
+        // there, it's very intentional and no other elements in the path exist.
+        const cleanPathToEntityInRepo = path
+          .join(dirtyPathToEntityInRepo)
+          .replaceAll(/\/?$/g, '')
+
+        if (cleanPathToEntityInRepo.startsWith('..'))
+          return ParseResult.fail(
+            new ParseResult.Type(
+              ast,
+              dirtyPathToEntityInRepo,
+              "Can't request contents that lie higher than the root of the repo",
+            ),
+          )
+        return ParseResult.succeed(cleanPathToEntityInRepo)
+      }),
+    encode: ParseResult.succeed,
+  },
+)
+
+/**
+ * Text parameter containing path to a directory or a file inside target repo.
+ *
+ * Can be passed in two ways:
+ * 1. As CLI option `gdl --pathToEntityInRepo nestedFolder/Readme.md`
+ * 2. As env variable `PATH_TO_ENTITY_IN_REPO="nestedFolder/Readme.md" gdl`
+ *
+ * Has default: `.`, which means that if not specified, script will download
+ * entire repository (download root directory of the repository)
+ *
+ * Parameter is automatically validated to not point higher than the root of the
+ * repository.
+ *
+ * @since 0.1.7
+ * @category CLI options
+ * @constant
+ */
+export const pathToEntityInRepoCLIOptionBackedByEnv: CLIOptions.Options<string> =
+  EFunction.pipe(
+    CLIOptions.text(`pathToEntityInRepo`),
+    CLIOptions.withDescription(pathToEntityInRepoDescription),
+    CLIOptions.withFallbackConfig(PathToEntityInRepoConfig),
+    CLIOptions.withSchema(CleanRepoEntityPathString),
+  )
+
+/**
+ * Text parameter containing URL slug of the user which owns the repo.
+ *
+ * Examples:
+ * 1. `apache`
+ * 2. `nikelborm`
+ *
+ * Can be passed in two ways:
+ * 1. As CLI option `gdl --repoOwner apache`
+ * 2. As env variable `REPO_OWNER="apache" gdl`
+ *
+ * Doesn`t have defaults and will fail if not specified.
+ *
+ * Parameter is automatically validated so it can consist of only ASCII letters,
+ * digits, and the characters `.`, `-`, and `_`.
+ *
+ * @since 0.1.7
+ * @category CLI options
+ * @constant
+ */
+export const repoOwnerCLIOptionBackedByEnv: CLIOptions.Options<string> =
+  EFunction.pipe(
+    CLIOptions.text(`repoOwner`),
+    CLIOptions.withDescription(repoOwnerDescription),
+    CLIOptions.withFallbackConfig(RepoOwnerConfig),
+    CLIOptions.withSchema(GitHubSlugStringSchema),
+  )
+
+/**
+ * Text parameter containing URL slug of the repo itself.
+ *
+ * Examples:
+ * 1. `superset`
+ * 2. `git-dl`
+ *
+ * Can be passed in two ways:
+ * 1. As CLI option `gdl --repoName superset`
+ * 2. As env variable `REPO_NAME="superset" gdl`
+ *
+ * Doesn`t have defaults and will fail if not specified.
+ *
+ * Parameter is automatically validated so it can consist of only ASCII letters,
+ * digits, and the characters `.`, `-`, and `_`.
+ *
+ * @since 0.1.7
+ * @category CLI options
+ * @constant
+ */
+export const repoNameCLIOptionBackedByEnv: CLIOptions.Options<string> =
+  EFunction.pipe(
+    CLIOptions.text(`repoName`),
+    CLIOptions.withDescription(repoNameDescription),
+    CLIOptions.withFallbackConfig(RepoNameConfig),
+    CLIOptions.withSchema(GitHubSlugStringSchema),
+  )
+
+/**
+ * Text parameter containing path inside your local file system, your new
+ * file/directory will be placed at. Last element of the path will be the name
+ * of the new file/directory.
+ *
+ * Examples:
+ * 1. `../docker`
+ * 2. `/tmp/Readme.md`
+ *
+ * Can be passed in two ways:
+ * 1. As CLI option `gdl --destinationPath docker`
+ * 2. As env variable `DESTINATION_PATH="docker" gdl`
+ *
+ * Has default: `./destination`, which means that if not specified, script will
+ * either create a file or a directory named `destination` inside your current PWD
+ * depending on the type of remote target.
+ *
+ * @since 0.1.7
+ * @category CLI options
+ * @constant
+ * @readonly
+ */
+export const destinationPathCLIOptionBackedByEnv: CLIOptions.Options<string> =
+  EFunction.pipe(
+    CLIOptions.text(`destinationPath`),
+    CLIOptions.withDescription(destinationPathDescription),
+    CLIOptions.withFallbackConfig(DestinationPathConfig),
+  )
+
+/**
+ * Text parameter containing commit SHA hash, branch name, or tag name you want
+ * to download from.
+ *
+ * Examples:
+ * 1. `HEAD`
+ * 2. `main`
+ * 3. `4.1.1`
+ * 4. `dca3efb3dd2a2a75aea32e3561c4104a53f02808`
+ * 5. `dca3efb`
+ *
+ * Can be passed in two ways:
+ * 1. As CLI option `gdl --gitRef 4.1.1`
+ * 2. As env variable `GIT_REF="4.1.1" gdl`
+ *
+ * Has default: `HEAD`, which means that if not specified, the default branch in
+ * the repository will be used.
+ *
+ * @since 0.1.7
+ * @category CLI options
+ * @constant
+ */
+export const gitRefCLIOptionBackedByEnv: CLIOptions.Options<string> =
+  EFunction.pipe(
+    CLIOptions.text(`gitRef`),
+    CLIOptions.withDescription(gitRefDescription),
+    CLIOptions.withFallbackConfig(GitRefConfig),
+  )

package/src/commonErrors.ts

@@ -0,0 +1,139 @@
+import { RequestError } from '@octokit/request-error'
+
+import {
+  buildTaggedErrorClassVerifyingCause,
+  type TaggedErrorClass,
+} from './TaggedErrorVerifyingCause.ts'
+
+// 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: 'GitHubApiGeneralServerError'
+  ExpectedCauseClass: typeof RequestError
+}> = buildTaggedErrorClassVerifyingCause()(
+  'GitHubApiGeneralServerError',
+  'GitHub API Error: Bad server',
+  RequestError,
+)
+
+export class GitHubApiGeneralServerError extends _1 {}
+
+// Extracting to a separate type is required by JSR, so that consumers of the
+// library will have much faster type inference
+const _2: TaggedErrorClass<{
+  ErrorName: 'GitHubApiGeneralUserError'
+  ExpectedCauseClass: typeof RequestError
+  DynamicContext: { readonly notes?: string }
+}> = buildTaggedErrorClassVerifyingCause<{ readonly notes?: string }>()(
+  'GitHubApiGeneralUserError',
+  'GitHub API Error: Bad user, invalid request',
+  RequestError,
+)
+
+export class GitHubApiGeneralUserError extends _2 {}
+
+// Extracting to a separate type is required by JSR, so that consumers of the
+// library will have much faster type inference
+const _3: TaggedErrorClass<{
+  ErrorName: 'GitHubApiThingNotExistsOrYouDontHaveAccessError'
+  ExpectedCauseClass: typeof RequestError
+}> = buildTaggedErrorClassVerifyingCause()(
+  'GitHubApiThingNotExistsOrYouDontHaveAccessError',
+  "GitHub API Error: Either repo, owner, path in repo, or specified ref don't exist or you don't have permissions to access it",
+  RequestError,
+)
+
+export class GitHubApiThingNotExistsOrYouDontHaveAccessError extends _3 {}
+
+// Extracting to a separate type is required by JSR, so that consumers of the
+// library will have much faster type inference
+const _4: TaggedErrorClass<{
+  ErrorName: 'GitHubApiRepoIsEmptyError'
+  ExpectedCauseClass: typeof RequestError
+}> = buildTaggedErrorClassVerifyingCause()(
+  'GitHubApiRepoIsEmptyError',
+  'GitHub API Error: This Repo is empty',
+  RequestError,
+)
+
+export class GitHubApiRepoIsEmptyError extends _4 {}
+
+// Extracting to a separate type is required by JSR, so that consumers of the
+// library will have much faster type inference
+const _5: TaggedErrorClass<{
+  ErrorName: 'GitHubApiNoCommitFoundForGitRefError'
+  ExpectedCauseClass: typeof RequestError
+  DynamicContext: { gitRef: string }
+}> = buildTaggedErrorClassVerifyingCause<{ gitRef: string }>()(
+  'GitHubApiNoCommitFoundForGitRefError',
+  'GitHub API Error: No commit found for this git ref',
+  RequestError,
+)
+
+export class GitHubApiNoCommitFoundForGitRefError extends _5 {}
+
+// Extracting to a separate type is required by JSR, so that consumers of the
+// library will have much faster type inference
+const _6: TaggedErrorClass<{
+  ErrorName: 'GitHubApiBadCredentialsError'
+  ExpectedCauseClass: typeof RequestError
+}> = buildTaggedErrorClassVerifyingCause()(
+  'GitHubApiBadCredentialsError',
+  "GitHub API Error: Token you're using is invalid.",
+  RequestError,
+)
+
+export class GitHubApiBadCredentialsError extends _6 {}
+
+// Extracting to a separate type is required by JSR, so that consumers of the
+// library will have much faster type inference
+const _7: TaggedErrorClass<{
+  ErrorName: 'GitHubApiAuthRatelimitedError'
+  ExpectedCauseClass: typeof RequestError
+}> = buildTaggedErrorClassVerifyingCause()(
+  'GitHubApiAuthRatelimitedError',
+  'GitHub API Error: Too many invalid auth attempts. Chillout pal',
+  RequestError,
+)
+
+export class GitHubApiAuthRatelimitedError extends _7 {}
+
+// Extracting to a separate type is required by JSR, so that consumers of the
+// library will have much faster type inference
+const _8: TaggedErrorClass<{
+  ErrorName: 'GitHubApiRatelimitedError'
+  ExpectedCauseClass: typeof RequestError
+}> = buildTaggedErrorClassVerifyingCause()(
+  'GitHubApiRatelimitedError',
+  'GitHub API Error: Too many requests. Chillout pal',
+  RequestError,
+)
+
+export class GitHubApiRatelimitedError extends _8 {}
+
+export const parseCommonGitHubApiErrors = (error: RequestError) => {
+  if (error.status === 401) return new GitHubApiBadCredentialsError(error)
+
+  // https://docs.github.com/en/rest/authentication/authenticating-to-the-rest-api?apiVersion=2022-11-28#failed-login-limit
+  if (error.status === 403) return new GitHubApiAuthRatelimitedError(error)
+
+  // docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api?apiVersion=2022-11-28
+  if (error.status === 429) return new GitHubApiRatelimitedError(error)
+
+  if (error.status === 404)
+    return new GitHubApiThingNotExistsOrYouDontHaveAccessError(error)
+
+  if (error.status >= 500) return new GitHubApiGeneralServerError(error)
+
+  if (error.status >= 400) return new GitHubApiGeneralUserError(error, {})
+
+  return error
+}
+
+export type GitHubApiCommonErrors =
+  | RequestError
+  | GitHubApiGeneralServerError
+  | GitHubApiGeneralUserError
+  | GitHubApiBadCredentialsError
+  | GitHubApiAuthRatelimitedError
+  | GitHubApiRatelimitedError

package/src/configContext.ts

@@ -0,0 +1,46 @@
+import * as Context from 'effect/Context'
+import * as Effect from 'effect/Effect'
+import * as Layer from 'effect/Layer'
+
+export type InputConfig = Readonly<{
+  repo: Readonly<{
+    owner: string
+    name: string
+  }>
+  pathToEntityInRepo: string
+  gitRef: string
+}>
+
+export const InputConfigTag = Context.GenericTag<InputConfig>('InputConfig')
+
+export type OutputConfig = Readonly<{
+  localPathAtWhichEntityFromRepoWillBeAvailable: string
+}>
+
+export const OutputConfigTag = Context.GenericTag<OutputConfig>('OutputConfig')
+
+const InputConfigLive = (inputConfig: InputConfig) =>
+  Layer.succeed(InputConfigTag, InputConfigTag.of(inputConfig))
+
+export const provideInputConfig = (inputConfig: InputConfig) =>
+  Effect.provide(InputConfigLive(inputConfig))
+
+const OutputConfigLive = (outputConfig: OutputConfig) =>
+  Layer.succeed(OutputConfigTag, OutputConfigTag.of(outputConfig))
+
+export type SingleTargetConfig = InputConfig & OutputConfig
+
+export const provideSingleDownloadTargetConfig = ({
+  localPathAtWhichEntityFromRepoWillBeAvailable,
+  ...inputConfig
+}: SingleTargetConfig): (<A, E, R>(
+  self: Effect.Effect<A, E, R>,
+) => Effect.Effect<A, E, Exclude<R, InputConfig | OutputConfig>>) =>
+  Effect.provide(
+    Layer.merge(
+      InputConfigLive(inputConfig),
+      OutputConfigLive({
+        localPathAtWhichEntityFromRepoWillBeAvailable,
+      }),
+    ),
+  )

package/src/downloadEntityFromRepo.ts

@@ -0,0 +1,86 @@
+import type { Octokit } from '@octokit/core'
+
+import type * as Cause from 'effect/Cause'
+import * as Effect from 'effect/Effect'
+
+import type { FailedToCastDataToReadableStreamError } from './castToReadableStream.ts'
+import type {
+  GitHubApiAuthRatelimitedError,
+  GitHubApiBadCredentialsError,
+  GitHubApiGeneralServerError,
+  GitHubApiGeneralUserError,
+  GitHubApiNoCommitFoundForGitRefError,
+  GitHubApiRatelimitedError,
+  GitHubApiRepoIsEmptyError,
+  GitHubApiThingNotExistsOrYouDontHaveAccessError,
+} from './commonErrors.ts'
+import {
+  provideSingleDownloadTargetConfig,
+  type SingleTargetConfig,
+} from './configContext.ts'
+import {
+  type FailedToParseResponseFromRepoPathContentsMetaInfoAPIError,
+  type InconsistentExpectedAndRealContentSizeError,
+  PathContentsMetaInfo,
+  RawStreamOfRepoPathContentsFromGitHubAPI,
+} from './getPathContents/index.ts'
+import { getReadableTarGzStreamOfRepoDirectory } from './getReadableTarGzStreamOfRepoDirectory.ts'
+import {
+  type FailedToUnpackRepoFolderTarGzStreamToFsError,
+  unpackRepoFolderTarGzStreamToFs,
+} from './unpackRepoFolderTarGzStreamToFs.ts'
+import {
+  type FailedToWriteFileStreamToDestinationPathError,
+  writeFileStreamToDestinationPath,
+} from './writeFileStreamToDestinationPath.ts'
+
+const downloadEntityFromRepoWithoutContext = Effect.gen(function* () {
+  const pathContentsMetaInfo = yield* PathContentsMetaInfo
+
+  if (pathContentsMetaInfo.type === 'dir')
+    return yield* unpackRepoFolderTarGzStreamToFs(
+      getReadableTarGzStreamOfRepoDirectory(pathContentsMetaInfo.treeSha),
+    )
+
+  if (
+    pathContentsMetaInfo.meta ===
+    'This file is small enough that GitHub API decided to inline it'
+  )
+    return yield* writeFileStreamToDestinationPath(
+      pathContentsMetaInfo.contentStream,
+    )
+
+  if (pathContentsMetaInfo.meta === 'This file can be downloaded as a blob')
+    return yield* writeFileStreamToDestinationPath(
+      RawStreamOfRepoPathContentsFromGitHubAPI,
+    )
+
+  yield* Effect.dieMessage('LFS files are not yet supported')
+})
+
+// Extracting to a separate type is required by JSR, so that consumers of the
+// library will have much faster type inference
+export const downloadEntityFromRepo = (
+  target: SingleTargetConfig,
+): Effect.Effect<
+  void,
+  | Error
+  | InconsistentExpectedAndRealContentSizeError
+  | FailedToWriteFileStreamToDestinationPathError
+  | FailedToUnpackRepoFolderTarGzStreamToFsError
+  | Cause.UnknownException
+  | GitHubApiRepoIsEmptyError
+  | GitHubApiNoCommitFoundForGitRefError
+  | GitHubApiThingNotExistsOrYouDontHaveAccessError
+  | GitHubApiBadCredentialsError
+  | GitHubApiAuthRatelimitedError
+  | GitHubApiRatelimitedError
+  | GitHubApiGeneralServerError
+  | GitHubApiGeneralUserError
+  | FailedToParseResponseFromRepoPathContentsMetaInfoAPIError
+  | FailedToCastDataToReadableStreamError,
+  Octokit
+> =>
+  downloadEntityFromRepoWithoutContext.pipe(
+    provideSingleDownloadTargetConfig(target),
+  )

package/src/errors.ts

@@ -0,0 +1,24 @@
+/**
+ * @module
+ */
+
+export { FailedToCastDataToReadableStreamError } from './castToReadableStream.ts'
+export {
+  GitHubApiAuthRatelimitedError,
+  GitHubApiBadCredentialsError,
+  type GitHubApiCommonErrors,
+  GitHubApiGeneralServerError,
+  GitHubApiGeneralUserError,
+  GitHubApiNoCommitFoundForGitRefError,
+  GitHubApiRatelimitedError,
+  GitHubApiRepoIsEmptyError,
+  GitHubApiThingNotExistsOrYouDontHaveAccessError,
+} from './commonErrors.ts'
+export {
+  FailedToParseGitLFSInfoError,
+  FailedToParseResponseFromRepoPathContentsMetaInfoAPIError,
+  InconsistentExpectedAndRealContentSizeError,
+} from './getPathContents/index.ts'
+export * from './TaggedErrorVerifyingCause.ts'
+export { FailedToUnpackRepoFolderTarGzStreamToFsError } from './unpackRepoFolderTarGzStreamToFs.ts'
+export { FailedToWriteFileStreamToDestinationPathError } from './writeFileStreamToDestinationPath.ts'

package/src/getPathContents/ParsedMetaInfoAboutPathContentsFromGitHubAPI.ts

@@ -0,0 +1,76 @@
+import * as Effect from 'effect/Effect'
+import * as Either from 'effect/Either'
+import * as ParseResult from 'effect/ParseResult'
+import * as Schema from 'effect/Schema'
+
+import {
+  buildTaggedErrorClassVerifyingCause,
+  type TaggedErrorClass,
+} from '../TaggedErrorVerifyingCause.ts'
+import { RepoPathContentsFromGitHubAPI } from './RepoPathContentsFromGitHubAPI.ts'
+
+export const UnparsedMetaInfoAboutPathContentsFromGitHubAPI =
+  RepoPathContentsFromGitHubAPI('object')
+
+export const ParsedMetaInfoAboutPathContentsFromGitHubAPI = Effect.gen(
+  function* () {
+    const response = yield* UnparsedMetaInfoAboutPathContentsFromGitHubAPI
+
+    return yield* Either.mapLeft(
+      decodeResponse(response.data),
+      parseError =>
+        new FailedToParseResponseFromRepoPathContentsMetaInfoAPIError(
+          parseError,
+          {
+            response,
+          },
+        ),
+    )
+  },
+)
+
+const GitSomethingFields = {
+  size: Schema.Number,
+  name: Schema.String,
+  path: Schema.String,
+  sha: Schema.String,
+}
+
+const dirLiteral = Schema.Literal('dir')
+const nonDirLiterals = Schema.Literal('file', 'submodule', 'symlink')
+
+export const ResponseSchema = Schema.Union(
+  Schema.Struct({
+    type: Schema.Literal('dir'),
+    entries: Schema.Struct({
+      type: Schema.Union(dirLiteral, nonDirLiterals),
+      ...GitSomethingFields,
+    }).pipe(Schema.Array),
+    ...GitSomethingFields,
+  }),
+  Schema.Struct({
+    type: Schema.Literal('file'),
+    encoding: Schema.Literal('base64', 'none'),
+    content: Schema.String,
+    ...GitSomethingFields,
+  }),
+)
+
+const decodeResponse = Schema.decodeUnknownEither(ResponseSchema, {
+  exact: true,
+})
+
+// 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: 'FailedToParseResponseFromRepoPathContentsMetaInfoAPI'
+  ExpectedCauseClass: typeof ParseResult.ParseError
+  DynamicContext: { response: unknown }
+}> = buildTaggedErrorClassVerifyingCause<{ response: unknown }>()(
+  'FailedToParseResponseFromRepoPathContentsMetaInfoAPI',
+  `Failed to parse response from repo path contents meta info API`,
+  ParseResult.ParseError,
+)
+
+export class FailedToParseResponseFromRepoPathContentsMetaInfoAPIError extends _1 {}