@prover-coder-ai/docker-git 1.0.5

package/src/app/program.ts

@@ -0,0 +1,75 @@
+import { listProjects, readCloneRequest, runDockerGitClone } from "@effect-template/lib"
+import { Console, Effect, Match, pipe } from "effect"
+
+/**
+ * Compose the CLI program as a single effect.
+ *
+ * @returns Effect that either runs docker-git clone or prints usage.
+ *
+ * @pure false - uses Console output and spawns commands when cloning
+ * @effect Console, CommandExecutor, Path
+ * @invariant forall args in Argv: clone(args) -> docker_git_invoked(args)
+ * @precondition true
+ * @postcondition clone(args) -> docker_git_invoked(args); otherwise usage printed
+ * @complexity O(build + clone)
+ * @throws Never - all errors are typed in the Effect error channel
+ */
+// CHANGE: replace greeting demo with deterministic usage text
+// WHY: greeting was scaffolding noise and should not ship in docker-git tooling
+// QUOTE(ТЗ): "Можешь удалить использование greting ...? Это старый мусор который остался"
+// REF: user-request-2026-02-06-remove-greeting
+// SOURCE: n/a
+// FORMAT THEOREM: usageText is constant -> deterministic(help)
+// PURITY: CORE
+// EFFECT: n/a
+// INVARIANT: usageText does not depend on argv/env
+// COMPLEXITY: O(1)
+const usageText = [
+  "Usage:",
+  "  pnpm docker-git",
+  "  pnpm clone <repo-url> [ref]",
+  "  pnpm list",
+  "",
+  "Notes:",
+  "  - docker-git is the interactive TUI.",
+  "  - clone builds + runs docker-git clone for you."
+].join("\n")
+
+// PURITY: SHELL
+// EFFECT: Effect<void, never, Console>
+const runHelp = Console.log(usageText)
+
+// CHANGE: route between clone runner and help based on CLI context
+// WHY: allow pnpm run clone <url> while keeping a single entrypoint
+// QUOTE(ТЗ): "pnpm run clone <url>"
+// REF: user-request-2026-01-27
+// SOURCE: n/a
+// FORMAT THEOREM: forall argv: clone(argv) -> docker_git_invoked(argv)
+// PURITY: SHELL
+// EFFECT: Effect<void, Error, Console | CommandExecutor | Path>
+// INVARIANT: help is printed when clone is not requested
+// COMPLEXITY: O(build + clone)
+const runDockerGit = pipe(
+  readCloneRequest,
+  Effect.flatMap((request) =>
+    Match.value(request).pipe(
+      Match.when({ _tag: "Clone" }, ({ args }) => runDockerGitClone(args)),
+      Match.when({ _tag: "None" }, () => runHelp),
+      Match.exhaustive
+    )
+  )
+)
+
+const readListFlag = Effect.sync(() => {
+  const command = process.argv.slice(2)[0] ?? ""
+  return command === "list" || command === "ls"
+})
+
+export const program = Effect.gen(function*(_) {
+  const isList = yield* _(readListFlag)
+  if (isList) {
+    yield* _(listProjects)
+    return
+  }
+  yield* _(runDockerGit)
+})

package/src/docker-git/cli/input.ts

@@ -0,0 +1,29 @@
+import * as Terminal from "@effect/platform/Terminal"
+import { Effect } from "effect"
+
+import { InputCancelledError, InputReadError } from "@effect-template/lib/shell/errors"
+
+const normalizeMessage = (error: Error): string => error.message
+
+const toReadError = (error: Error): InputReadError => new InputReadError({ message: normalizeMessage(error) })
+
+const mapReadLineError = (_error: Terminal.QuitException): InputCancelledError => new InputCancelledError({})
+
+// CHANGE: prompt for a single line of user input
+// WHY: provide an interactive CLI without raw terminal mode issues
+// QUOTE(ТЗ): "Хочу что бы открылось менюшка"
+// REF: user-request-2026-01-07
+// SOURCE: n/a
+// FORMAT THEOREM: forall p: prompt(p) -> line(p)
+// PURITY: SHELL
+// EFFECT: Effect<string, InputCancelledError | InputReadError, never>
+// INVARIANT: restores raw mode if it was enabled before prompting
+// COMPLEXITY: O(1)
+export const promptLine = (
+  prompt: string
+): Effect.Effect<string, InputCancelledError | InputReadError, Terminal.Terminal> =>
+  Effect.gen(function*(_) {
+    const terminal = yield* _(Terminal.Terminal)
+    yield* _(terminal.display(prompt).pipe(Effect.mapError(toReadError)))
+    return yield* _(terminal.readLine.pipe(Effect.mapError(mapReadLineError)))
+  })

package/src/docker-git/cli/parser-attach.ts

@@ -0,0 +1,22 @@
+import { Either } from "effect"
+
+import { type AttachCommand, type ParseError } from "@effect-template/lib/core/domain"
+
+import { parseProjectDirArgs } from "./parser-shared.js"
+
+// CHANGE: parse attach command into a project selection
+// WHY: allow "docker-git attach" to open a tmux workspace
+// QUOTE(ТЗ): "окей Давай подключим tmux"
+// REF: user-request-2026-02-02-tmux
+// SOURCE: n/a
+// FORMAT THEOREM: forall argv: parseAttach(argv) = cmd -> deterministic(cmd)
+// PURITY: CORE
+// EFFECT: Effect<AttachCommand, ParseError, never>
+// INVARIANT: projectDir is never empty
+// COMPLEXITY: O(n) where n = |argv|
+export const parseAttach = (args: ReadonlyArray<string>): Either.Either<AttachCommand, ParseError> => {
+  return Either.map(parseProjectDirArgs(args), ({ projectDir }) => ({
+    _tag: "Attach",
+    projectDir
+  }))
+}

package/src/docker-git/cli/parser-auth.ts

@@ -0,0 +1,124 @@
+import { Either, Match } from "effect"
+
+import type { RawOptions } from "@effect-template/lib/core/command-options"
+import {
+  type AuthCommand,
+  type Command,
+  defaultTemplateConfig,
+  type ParseError
+} from "@effect-template/lib/core/domain"
+
+import { parseRawOptions } from "./parser-options.js"
+
+type AuthOptions = {
+  readonly envGlobalPath: string
+  readonly codexAuthPath: string
+  readonly label: string | null
+  readonly token: string | null
+  readonly scopes: string | null
+}
+
+const missingArgument = (name: string): ParseError => ({
+  _tag: "MissingRequiredOption",
+  option: name
+})
+
+const invalidArgument = (name: string, reason: string): ParseError => ({
+  _tag: "InvalidOption",
+  option: name,
+  reason
+})
+
+const normalizeLabel = (value: string | undefined): string | null => {
+  const trimmed = value?.trim() ?? ""
+  return trimmed.length === 0 ? null : trimmed
+}
+
+const resolveAuthOptions = (raw: RawOptions): AuthOptions => ({
+  envGlobalPath: raw.envGlobalPath ?? defaultTemplateConfig.envGlobalPath,
+  codexAuthPath: raw.codexAuthPath ?? defaultTemplateConfig.codexAuthPath,
+  label: normalizeLabel(raw.label),
+  token: normalizeLabel(raw.token),
+  scopes: normalizeLabel(raw.scopes)
+})
+
+const buildGithubCommand = (action: string, options: AuthOptions): Either.Either<AuthCommand, ParseError> =>
+  Match.value(action).pipe(
+    Match.when("login", () =>
+      Either.right<AuthCommand>({
+        _tag: "AuthGithubLogin",
+        label: options.label,
+        token: options.token,
+        scopes: options.scopes,
+        envGlobalPath: options.envGlobalPath
+      })),
+    Match.when("status", () =>
+      Either.right<AuthCommand>({
+        _tag: "AuthGithubStatus",
+        envGlobalPath: options.envGlobalPath
+      })),
+    Match.when("logout", () =>
+      Either.right<AuthCommand>({
+        _tag: "AuthGithubLogout",
+        label: options.label,
+        envGlobalPath: options.envGlobalPath
+      })),
+    Match.orElse(() => Either.left(invalidArgument("auth action", `unknown action '${action}'`)))
+  )
+
+const buildCodexCommand = (action: string, options: AuthOptions): Either.Either<AuthCommand, ParseError> =>
+  Match.value(action).pipe(
+    Match.when("login", () =>
+      Either.right<AuthCommand>({
+        _tag: "AuthCodexLogin",
+        label: options.label,
+        codexAuthPath: options.codexAuthPath
+      })),
+    Match.when("status", () =>
+      Either.right<AuthCommand>({
+        _tag: "AuthCodexStatus",
+        label: options.label,
+        codexAuthPath: options.codexAuthPath
+      })),
+    Match.when("logout", () =>
+      Either.right<AuthCommand>({
+        _tag: "AuthCodexLogout",
+        label: options.label,
+        codexAuthPath: options.codexAuthPath
+      })),
+    Match.orElse(() => Either.left(invalidArgument("auth action", `unknown action '${action}'`)))
+  )
+
+const buildAuthCommand = (
+  provider: string,
+  action: string,
+  options: AuthOptions
+): Either.Either<AuthCommand, ParseError> =>
+  Match.value(provider).pipe(
+    Match.when("github", () => buildGithubCommand(action, options)),
+    Match.when("gh", () => buildGithubCommand(action, options)),
+    Match.when("codex", () => buildCodexCommand(action, options)),
+    Match.orElse(() => Either.left(invalidArgument("auth provider", `unknown provider '${provider}'`)))
+  )
+
+// CHANGE: parse docker-git auth subcommands
+// WHY: keep auth flows in the same typed CLI parser
+// QUOTE(ТЗ): "система авторизации"
+// REF: user-request-2026-01-28-auth
+// SOURCE: n/a
+// FORMAT THEOREM: forall argv: parseAuth(argv) = cmd | error
+// PURITY: CORE
+// EFFECT: Effect<Command, ParseError, never>
+// INVARIANT: no IO or side effects
+// COMPLEXITY: O(n) where n = |argv|
+export const parseAuth = (args: ReadonlyArray<string>): Either.Either<Command, ParseError> => {
+  if (args.length < 2) {
+    return Either.left(missingArgument(args.length === 0 ? "auth provider" : "auth action"))
+  }
+
+  const provider = args[0] ?? ""
+  const action = args[1] ?? ""
+  const rest = args.slice(2)
+
+  return Either.flatMap(parseRawOptions(rest), (raw) => buildAuthCommand(provider, action, resolveAuthOptions(raw)))
+}

package/src/docker-git/cli/parser-clone.ts

@@ -0,0 +1,55 @@
+import { Either } from "effect"
+
+import { buildCreateCommand, nonEmpty } from "@effect-template/lib/core/command-builders"
+import type { RawOptions } from "@effect-template/lib/core/command-options"
+import {
+  type Command,
+  defaultTemplateConfig,
+  type ParseError,
+  resolveRepoInput
+} from "@effect-template/lib/core/domain"
+
+import { parseRawOptions } from "./parser-options.js"
+import { resolveWorkspaceRepoPath, splitPositionalRepo } from "./parser-shared.js"
+
+const applyCloneDefaults = (
+  raw: RawOptions,
+  rawRepoUrl: string,
+  resolvedRepo: ReturnType<typeof resolveRepoInput>
+): RawOptions => {
+  const repoPath = resolveWorkspaceRepoPath(resolvedRepo)
+  const sshUser = raw.sshUser?.trim() ?? defaultTemplateConfig.sshUser
+  const homeDir = `/home/${sshUser}`
+  return {
+    ...raw,
+    repoUrl: rawRepoUrl,
+    outDir: raw.outDir ?? `.docker-git/${repoPath}`,
+    targetDir: raw.targetDir ?? `${homeDir}/${repoPath}`
+  }
+}
+
+// CHANGE: parse clone command with positional repo url
+// WHY: allow "docker-git clone <url>" to build + run a container
+// QUOTE(ТЗ): "docker-git clone url"
+// REF: user-request-2026-01-27
+// SOURCE: n/a
+// FORMAT THEOREM: forall argv: parseClone(argv) = cmd -> deterministic(cmd)
+// PURITY: CORE
+// EFFECT: Effect<Command, ParseError, never>
+// INVARIANT: first positional arg is treated as repo url
+// COMPLEXITY: O(n) where n = |argv|
+export const parseClone = (args: ReadonlyArray<string>): Either.Either<Command, ParseError> => {
+  const { positionalRepoUrl, restArgs } = splitPositionalRepo(args)
+
+  return Either.gen(function*(_) {
+    const raw = yield* _(parseRawOptions(restArgs))
+    const rawRepoUrl = yield* _(nonEmpty("--repo-url", raw.repoUrl ?? positionalRepoUrl))
+    const resolvedRepo = resolveRepoInput(rawRepoUrl)
+    const withDefaults = applyCloneDefaults(raw, rawRepoUrl, resolvedRepo)
+    const withRef = resolvedRepo.repoRef !== undefined && raw.repoRef === undefined
+      ? { ...withDefaults, repoRef: resolvedRepo.repoRef }
+      : withDefaults
+    const create = yield* _(buildCreateCommand(withRef))
+    return { ...create, waitForClone: true }
+  })
+}

package/src/docker-git/cli/parser-create.ts

@@ -0,0 +1,3 @@
+export { buildCreateCommand, nonEmpty } from "@effect-template/lib/core/command-builders"
+export type { RawOptions } from "@effect-template/lib/core/command-options"
+export type { CreateCommand, ParseError } from "@effect-template/lib/core/domain"

package/src/docker-git/cli/parser-options.ts

@@ -0,0 +1,152 @@
+import { Either } from "effect"
+
+import type { RawOptions } from "@effect-template/lib/core/command-options"
+import type { ParseError } from "@effect-template/lib/core/domain"
+
+interface ValueOptionSpec {
+  readonly flag: string
+  readonly key:
+    | "repoUrl"
+    | "repoRef"
+    | "targetDir"
+    | "sshPort"
+    | "sshUser"
+    | "containerName"
+    | "serviceName"
+    | "volumeName"
+    | "secretsRoot"
+    | "authorizedKeysPath"
+    | "envGlobalPath"
+    | "envProjectPath"
+    | "codexAuthPath"
+    | "codexHome"
+    | "label"
+    | "token"
+    | "scopes"
+    | "message"
+    | "outDir"
+    | "projectDir"
+    | "lines"
+}
+
+const valueOptionSpecs: ReadonlyArray<ValueOptionSpec> = [
+  { flag: "--repo-url", key: "repoUrl" },
+  { flag: "--repo-ref", key: "repoRef" },
+  { flag: "--branch", key: "repoRef" },
+  { flag: "-b", key: "repoRef" },
+  { flag: "--target-dir", key: "targetDir" },
+  { flag: "--ssh-port", key: "sshPort" },
+  { flag: "--ssh-user", key: "sshUser" },
+  { flag: "--container-name", key: "containerName" },
+  { flag: "--service-name", key: "serviceName" },
+  { flag: "--volume-name", key: "volumeName" },
+  { flag: "--secrets-root", key: "secretsRoot" },
+  { flag: "--authorized-keys", key: "authorizedKeysPath" },
+  { flag: "--env-global", key: "envGlobalPath" },
+  { flag: "--env-project", key: "envProjectPath" },
+  { flag: "--codex-auth", key: "codexAuthPath" },
+  { flag: "--codex-home", key: "codexHome" },
+  { flag: "--label", key: "label" },
+  { flag: "--token", key: "token" },
+  { flag: "--scopes", key: "scopes" },
+  { flag: "--message", key: "message" },
+  { flag: "-m", key: "message" },
+  { flag: "--out-dir", key: "outDir" },
+  { flag: "--project-dir", key: "projectDir" },
+  { flag: "--lines", key: "lines" }
+]
+
+const valueOptionSpecByFlag: ReadonlyMap<string, ValueOptionSpec> = new Map(
+  valueOptionSpecs.map((spec) => [spec.flag, spec])
+)
+
+type ValueKey = ValueOptionSpec["key"]
+
+const booleanFlagUpdaters: Readonly<Record<string, (raw: RawOptions) => RawOptions>> = {
+  "--up": (raw) => ({ ...raw, up: true }),
+  "--no-up": (raw) => ({ ...raw, up: false }),
+  "--force": (raw) => ({ ...raw, force: true }),
+  "--force-env": (raw) => ({ ...raw, forceEnv: true }),
+  "--mcp-playwright": (raw) => ({ ...raw, enableMcpPlaywright: true }),
+  "--no-mcp-playwright": (raw) => ({ ...raw, enableMcpPlaywright: false }),
+  "--web": (raw) => ({ ...raw, authWeb: true }),
+  "--include-default": (raw) => ({ ...raw, includeDefault: true })
+}
+
+const valueFlagUpdaters: { readonly [K in ValueKey]: (raw: RawOptions, value: string) => RawOptions } = {
+  repoUrl: (raw, value) => ({ ...raw, repoUrl: value }),
+  repoRef: (raw, value) => ({ ...raw, repoRef: value }),
+  targetDir: (raw, value) => ({ ...raw, targetDir: value }),
+  sshPort: (raw, value) => ({ ...raw, sshPort: value }),
+  sshUser: (raw, value) => ({ ...raw, sshUser: value }),
+  containerName: (raw, value) => ({ ...raw, containerName: value }),
+  serviceName: (raw, value) => ({ ...raw, serviceName: value }),
+  volumeName: (raw, value) => ({ ...raw, volumeName: value }),
+  secretsRoot: (raw, value) => ({ ...raw, secretsRoot: value }),
+  authorizedKeysPath: (raw, value) => ({ ...raw, authorizedKeysPath: value }),
+  envGlobalPath: (raw, value) => ({ ...raw, envGlobalPath: value }),
+  envProjectPath: (raw, value) => ({ ...raw, envProjectPath: value }),
+  codexAuthPath: (raw, value) => ({ ...raw, codexAuthPath: value }),
+  codexHome: (raw, value) => ({ ...raw, codexHome: value }),
+  label: (raw, value) => ({ ...raw, label: value }),
+  token: (raw, value) => ({ ...raw, token: value }),
+  scopes: (raw, value) => ({ ...raw, scopes: value }),
+  message: (raw, value) => ({ ...raw, message: value }),
+  outDir: (raw, value) => ({ ...raw, outDir: value }),
+  projectDir: (raw, value) => ({ ...raw, projectDir: value }),
+  lines: (raw, value) => ({ ...raw, lines: value })
+}
+
+export const applyCommandBooleanFlag = (raw: RawOptions, token: string): RawOptions | null => {
+  const updater = booleanFlagUpdaters[token]
+  return updater ? updater(raw) : null
+}
+
+export const applyCommandValueFlag = (
+  raw: RawOptions,
+  token: string,
+  value: string
+): Either.Either<RawOptions, ParseError> => {
+  const valueSpec = valueOptionSpecByFlag.get(token)
+  if (valueSpec === undefined) {
+    return Either.left({ _tag: "UnknownOption", option: token })
+  }
+
+  const update = valueFlagUpdaters[valueSpec.key]
+  return Either.right(update(raw, value))
+}
+
+export const parseRawOptions = (args: ReadonlyArray<string>): Either.Either<RawOptions, ParseError> => {
+  let index = 0
+  let raw: RawOptions = {}
+
+  while (index < args.length) {
+    const token = args[index] ?? ""
+    const booleanApplied = applyCommandBooleanFlag(raw, token)
+    if (booleanApplied !== null) {
+      raw = booleanApplied
+      index += 1
+      continue
+    }
+
+    if (!token.startsWith("-")) {
+      return Either.left({ _tag: "UnexpectedArgument", value: token })
+    }
+
+    const value = args[index + 1]
+    if (value === undefined) {
+      return Either.left({ _tag: "MissingOptionValue", option: token })
+    }
+
+    const nextRaw = applyCommandValueFlag(raw, token, value)
+    if (Either.isLeft(nextRaw)) {
+      return Either.left(nextRaw.left)
+    }
+    raw = nextRaw.right
+    index += 2
+  }
+
+  return Either.right(raw)
+}
+
+export { type RawOptions } from "@effect-template/lib/core/command-options"

package/src/docker-git/cli/parser-panes.ts

@@ -0,0 +1,22 @@
+import { Either } from "effect"
+
+import { type PanesCommand, type ParseError } from "@effect-template/lib/core/domain"
+
+import { parseProjectDirArgs } from "./parser-shared.js"
+
+// CHANGE: parse panes command into a project selection
+// WHY: allow listing tmux panes without attaching
+// QUOTE(ТЗ): "покажи команду ... отобразит терминалы"
+// REF: user-request-2026-02-02-panes
+// SOURCE: n/a
+// FORMAT THEOREM: forall argv: parsePanes(argv) = cmd -> deterministic(cmd)
+// PURITY: CORE
+// EFFECT: Effect<PanesCommand, ParseError, never>
+// INVARIANT: projectDir is never empty
+// COMPLEXITY: O(n) where n = |argv|
+export const parsePanes = (args: ReadonlyArray<string>): Either.Either<PanesCommand, ParseError> => {
+  return Either.map(parseProjectDirArgs(args), ({ projectDir }) => ({
+    _tag: "Panes",
+    projectDir
+  }))
+}

package/src/docker-git/cli/parser-sessions.ts

@@ -0,0 +1,101 @@
+import { Either, Match } from "effect"
+
+import { type ParseError, type SessionsCommand } from "@effect-template/lib/core/domain"
+
+import { parseProjectDirWithOptions } from "./parser-shared.js"
+
+const defaultLines = 200
+
+const parsePositiveInt = (
+  option: string,
+  raw: string
+): Either.Either<number, ParseError> => {
+  const value = Number.parseInt(raw, 10)
+  if (!Number.isFinite(value) || value <= 0) {
+    const error: ParseError = {
+      _tag: "InvalidOption",
+      option,
+      reason: "expected positive integer"
+    }
+    return Either.left(error)
+  }
+  return Either.right(value)
+}
+
+const parseList = (args: ReadonlyArray<string>): Either.Either<SessionsCommand, ParseError> =>
+  Either.map(parseProjectDirWithOptions(args), ({ projectDir, raw }) => ({
+    _tag: "SessionsList",
+    projectDir,
+    includeDefault: raw.includeDefault === true
+  }))
+
+const parsePidContext = (
+  args: ReadonlyArray<string>
+): Either.Either<
+  { readonly pid: number; readonly projectDir: string; readonly raw: { readonly lines?: string } },
+  ParseError
+> =>
+  Either.gen(function*(_) {
+    const pidRaw = args[0]
+    if (!pidRaw) {
+      const error: ParseError = { _tag: "MissingRequiredOption", option: "pid" }
+      return yield* _(Either.left(error))
+    }
+    const pid = yield* _(parsePositiveInt("pid", pidRaw))
+    const { projectDir, raw } = yield* _(parseProjectDirWithOptions(args.slice(1)))
+    return { pid, projectDir, raw }
+  })
+
+const parseKill = (args: ReadonlyArray<string>): Either.Either<SessionsCommand, ParseError> =>
+  Either.map(parsePidContext(args), ({ pid, projectDir }) => ({
+    _tag: "SessionsKill",
+    projectDir,
+    pid
+  }))
+
+const parseLogs = (args: ReadonlyArray<string>): Either.Either<SessionsCommand, ParseError> =>
+  Either.gen(function*(_) {
+    const { pid, projectDir, raw } = yield* _(parsePidContext(args))
+    const lines = raw.lines ? yield* _(parsePositiveInt("--lines", raw.lines)) : defaultLines
+    return { _tag: "SessionsLogs", projectDir, pid, lines }
+  })
+
+// CHANGE: parse sessions command into list/kill/logs actions
+// WHY: surface container terminal sessions and background processes from CLI
+// QUOTE(ТЗ): "CLI команду которая из докера вернёт запущенные терминал сессии"
+// REF: user-request-2026-02-04-terminal-sessions
+// SOURCE: n/a
+// FORMAT THEOREM: forall argv: parseSessions(argv) = cmd -> deterministic(cmd)
+// PURITY: CORE
+// EFFECT: Effect<SessionsCommand, ParseError, never>
+// INVARIANT: pid/lines must be positive integers
+// COMPLEXITY: O(n) where n = |argv|
+export const parseSessions = (
+  args: ReadonlyArray<string>
+): Either.Either<SessionsCommand, ParseError> => {
+  if (args.length === 0) {
+    return parseList(args)
+  }
+
+  const first = args[0] ?? ""
+  if (first.startsWith("-")) {
+    return parseList(args)
+  }
+
+  const rest = args.slice(1)
+  return Match.value(first).pipe(
+    Match.when("list", () => parseList(rest)),
+    Match.when("kill", () => parseKill(rest)),
+    Match.when("stop", () => parseKill(rest)),
+    Match.when("logs", () => parseLogs(rest)),
+    Match.when("log", () => parseLogs(rest)),
+    Match.orElse(() => {
+      const error: ParseError = {
+        _tag: "InvalidOption",
+        option: "sessions",
+        reason: `unknown action ${first}`
+      }
+      return Either.left(error)
+    })
+  )
+}

package/src/docker-git/cli/parser-shared.ts

@@ -0,0 +1,51 @@
+import { Either } from "effect"
+
+import { deriveRepoPathParts, type ParseError, resolveRepoInput } from "@effect-template/lib/core/domain"
+
+import { parseRawOptions, type RawOptions } from "./parser-options.js"
+
+type PositionalRepo = {
+  readonly positionalRepoUrl: string | undefined
+  readonly restArgs: ReadonlyArray<string>
+}
+
+export const resolveWorkspaceRepoPath = (
+  resolvedRepo: ReturnType<typeof resolveRepoInput>
+): string => {
+  const baseParts = deriveRepoPathParts(resolvedRepo.repoUrl).pathParts
+  const projectParts = resolvedRepo.workspaceSuffix ? [...baseParts, resolvedRepo.workspaceSuffix] : baseParts
+  return projectParts.join("/")
+}
+
+export const splitPositionalRepo = (args: ReadonlyArray<string>): PositionalRepo => {
+  const first = args[0]
+  const positionalRepoUrl = first !== undefined && !first.startsWith("-") ? first : undefined
+  const restArgs = positionalRepoUrl ? args.slice(1) : args
+  return { positionalRepoUrl, restArgs }
+}
+
+export const parseProjectDirWithOptions = (
+  args: ReadonlyArray<string>,
+  defaultProjectDir: string = "."
+): Either.Either<{ readonly projectDir: string; readonly raw: RawOptions }, ParseError> =>
+  Either.gen(function*(_) {
+    const { positionalRepoUrl, restArgs } = splitPositionalRepo(args)
+    const raw = yield* _(parseRawOptions(restArgs))
+    const rawRepoUrl = raw.repoUrl ?? positionalRepoUrl
+    const repoPath = rawRepoUrl ? resolveWorkspaceRepoPath(resolveRepoInput(rawRepoUrl)) : null
+    const projectDir = raw.projectDir ??
+      (repoPath
+        ? `.docker-git/${repoPath}`
+        : defaultProjectDir)
+
+    return { projectDir, raw }
+  })
+
+export const parseProjectDirArgs = (
+  args: ReadonlyArray<string>,
+  defaultProjectDir: string = "."
+): Either.Either<{ readonly projectDir: string }, ParseError> =>
+  Either.map(
+    parseProjectDirWithOptions(args, defaultProjectDir),
+    ({ projectDir }) => ({ projectDir })
+  )