@prover-coder-ai/docker-git 1.0.23 → 1.0.24

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

@@ -1,211 +0,0 @@
-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"
-    | "dockerNetworkMode"
-    | "dockerSharedNetworkName"
-    | "archivePath"
-    | "scrapMode"
-    | "label"
-    | "gitTokenLabel"
-    | "codexTokenLabel"
-    | "claudeTokenLabel"
-    | "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: "--network-mode", key: "dockerNetworkMode" },
-  { flag: "--shared-network", key: "dockerSharedNetworkName" },
-  { flag: "--archive", key: "archivePath" },
-  { flag: "--mode", key: "scrapMode" },
-  { flag: "--label", key: "label" },
-  { flag: "--git-token", key: "gitTokenLabel" },
-  { flag: "--codex-token", key: "codexTokenLabel" },
-  { flag: "--claude-token", key: "claudeTokenLabel" },
-  { 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 }),
-  "--ssh": (raw) => ({ ...raw, openSsh: true }),
-  "--no-ssh": (raw) => ({ ...raw, openSsh: 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 }),
-  "--wipe": (raw) => ({ ...raw, wipe: true }),
-  "--no-wipe": (raw) => ({ ...raw, wipe: 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 }),
-  dockerNetworkMode: (raw, value) => ({ ...raw, dockerNetworkMode: value }),
-  dockerSharedNetworkName: (raw, value) => ({ ...raw, dockerSharedNetworkName: value }),
-  archivePath: (raw, value) => ({ ...raw, archivePath: value }),
-  scrapMode: (raw, value) => ({ ...raw, scrapMode: value }),
-  label: (raw, value) => ({ ...raw, label: value }),
-  gitTokenLabel: (raw, value) => ({ ...raw, gitTokenLabel: value }),
-  codexTokenLabel: (raw, value) => ({ ...raw, codexTokenLabel: value }),
-  claudeTokenLabel: (raw, value) => ({ ...raw, claudeTokenLabel: 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))
-}
-
-type ParseRawOptionsStep =
-  | { readonly _tag: "ok"; readonly raw: RawOptions; readonly nextIndex: number }
-  | { readonly _tag: "error"; readonly error: ParseError }
-
-const parseInlineValueToken = (
-  raw: RawOptions,
-  token: string
-): Either.Either<RawOptions, ParseError> | null => {
-  const equalIndex = token.indexOf("=")
-  if (equalIndex <= 0 || !token.startsWith("-")) {
-    return null
-  }
-
-  const flag = token.slice(0, equalIndex)
-  const inlineValue = token.slice(equalIndex + 1)
-  return applyCommandValueFlag(raw, flag, inlineValue)
-}
-
-const parseRawOptionsStep = (
-  args: ReadonlyArray<string>,
-  index: number,
-  raw: RawOptions
-): ParseRawOptionsStep => {
-  const token = args[index] ?? ""
-  const inlineApplied = parseInlineValueToken(raw, token)
-  if (inlineApplied !== null) {
-    return Either.isLeft(inlineApplied)
-      ? { _tag: "error", error: inlineApplied.left }
-      : { _tag: "ok", raw: inlineApplied.right, nextIndex: index + 1 }
-  }
-
-  const booleanApplied = applyCommandBooleanFlag(raw, token)
-  if (booleanApplied !== null) {
-    return { _tag: "ok", raw: booleanApplied, nextIndex: index + 1 }
-  }
-
-  if (!token.startsWith("-")) {
-    return { _tag: "error", error: { _tag: "UnexpectedArgument", value: token } }
-  }
-
-  const value = args[index + 1]
-  if (value === undefined) {
-    return { _tag: "error", error: { _tag: "MissingOptionValue", option: token } }
-  }
-
-  const nextRaw = applyCommandValueFlag(raw, token, value)
-  return Either.isLeft(nextRaw)
-    ? { _tag: "error", error: nextRaw.left }
-    : { _tag: "ok", raw: nextRaw.right, nextIndex: index + 2 }
-}
-
-export const parseRawOptions = (args: ReadonlyArray<string>): Either.Either<RawOptions, ParseError> => {
-  let index = 0
-  let raw: RawOptions = {}
-
-  while (index < args.length) {
-    const step = parseRawOptionsStep(args, index, raw)
-    if (step._tag === "error") {
-      return Either.left(step.error)
-    }
-    raw = step.raw
-    index = step.nextIndex
-  }
-
-  return Either.right(raw)
-}
-
-export { type RawOptions } from "@effect-template/lib/core/command-options"

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

@@ -1,22 +0,0 @@
-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-scrap.ts

@@ -1,106 +0,0 @@
-import { Either, Match } from "effect"
-
-import type { Command, ParseError } from "@effect-template/lib/core/domain"
-
-import { parseProjectDirWithOptions } from "./parser-shared.js"
-
-const missingRequired = (option: string): ParseError => ({
-  _tag: "MissingRequiredOption",
-  option
-})
-
-const invalidScrapAction = (value: string): ParseError => ({
-  _tag: "InvalidOption",
-  option: "scrap",
-  reason: `unknown action: ${value}`
-})
-
-const defaultSessionArchiveDir = ".orch/scrap/session"
-
-const invalidScrapMode = (value: string): ParseError => ({
-  _tag: "InvalidOption",
-  option: "--mode",
-  reason: `unknown value: ${value} (expected session)`
-})
-
-const parseScrapMode = (raw: string | undefined): Either.Either<"session", ParseError> => {
-  const value = raw?.trim()
-  if (!value || value.length === 0) {
-    return Either.right("session")
-  }
-  if (value === "session") {
-    return Either.right("session")
-  }
-  if (value === "recipe") {
-    // Backwards/semantic alias: "recipe" behaves like "session" (git state + rebuildable deps).
-    return Either.right("session")
-  }
-  return Either.left(invalidScrapMode(value))
-}
-
-const makeScrapExportCommand = (projectDir: string, archivePath: string, mode: "session"): Command => ({
-  _tag: "ScrapExport",
-  projectDir,
-  archivePath,
-  mode
-})
-
-const makeScrapImportCommand = (
-  projectDir: string,
-  archivePath: string,
-  wipe: boolean,
-  mode: "session"
-): Command => ({
-  _tag: "ScrapImport",
-  projectDir,
-  archivePath,
-  wipe,
-  mode
-})
-
-// CHANGE: parse scrap session export/import commands
-// WHY: store a small reproducible snapshot (git state + secrets) instead of large caches like node_modules
-// QUOTE(ТЗ): "не должно быть старого режима где он качает весь шлак типо node_modules"
-// REF: user-request-2026-02-15
-// SOURCE: n/a
-// FORMAT THEOREM: forall argv: parseScrap(argv) = cmd -> deterministic(cmd)
-// PURITY: CORE
-// EFFECT: Effect<Command, ParseError, never>
-// INVARIANT: export/import always resolves a projectDir
-// COMPLEXITY: O(n) where n = |argv|
-export const parseScrap = (args: ReadonlyArray<string>): Either.Either<Command, ParseError> => {
-  const action = args[0]?.trim()
-  if (!action || action.length === 0) {
-    return Either.left(missingRequired("scrap <action>"))
-  }
-
-  const rest = args.slice(1)
-
-  return Match.value(action).pipe(
-    Match.when(
-      "export",
-      () =>
-        Either.flatMap(
-          parseProjectDirWithOptions(rest),
-          ({ projectDir, raw }) =>
-            Either.map(parseScrapMode(raw.scrapMode), (mode) => {
-              const archivePathRaw = raw.archivePath?.trim()
-              if (archivePathRaw && archivePathRaw.length > 0) {
-                return makeScrapExportCommand(projectDir, archivePathRaw, mode)
-              }
-              return makeScrapExportCommand(projectDir, defaultSessionArchiveDir, mode)
-            })
-        )
-    ),
-    Match.when("import", () =>
-      Either.flatMap(parseProjectDirWithOptions(rest), ({ projectDir, raw }) => {
-        const archivePath = raw.archivePath?.trim()
-        if (!archivePath || archivePath.length === 0) {
-          return Either.left(missingRequired("--archive"))
-        }
-        return Either.map(parseScrapMode(raw.scrapMode), (mode) =>
-          makeScrapImportCommand(projectDir, archivePath, raw.wipe ?? true, mode))
-      })),
-    Match.orElse(() => Either.left(invalidScrapAction(action)))
-  )
-}

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

@@ -1,101 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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 })
-  )

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

@@ -1,86 +0,0 @@
-import { Either, Match } from "effect"
-
-import type { Command, ParseError } from "@effect-template/lib/core/domain"
-
-import { parseRawOptions } from "./parser-options.js"
-
-const invalidStateAction = (value: string): ParseError => ({
-  _tag: "InvalidOption",
-  option: "state",
-  reason: `unknown action: ${value}`
-})
-
-const unexpectedArgs = (value: string): Either.Either<Command, ParseError> =>
-  Either.left({ _tag: "UnexpectedArgument", value })
-
-const parseStateInit = (args: ReadonlyArray<string>): Either.Either<Command, ParseError> =>
-  Either.flatMap(parseRawOptions(args), (raw) => {
-    const repoUrl = raw.repoUrl?.trim()
-    if (!repoUrl || repoUrl.length === 0) {
-      return Either.left({ _tag: "MissingRequiredOption", option: "--repo-url" })
-    }
-    return Either.right({
-      _tag: "StateInit",
-      repoUrl,
-      repoRef: raw.repoRef?.trim() && raw.repoRef.trim().length > 0 ? raw.repoRef.trim() : "main"
-    })
-  })
-
-const parseStateCommit = (args: ReadonlyArray<string>): Either.Either<Command, ParseError> =>
-  Either.flatMap(parseRawOptions(args), (raw) => {
-    const message = raw.message?.trim()
-    if (!message || message.length === 0) {
-      return Either.left({ _tag: "MissingRequiredOption", option: "--message" })
-    }
-    return Either.right({ _tag: "StateCommit", message })
-  })
-
-const parseStateSync = (args: ReadonlyArray<string>): Either.Either<Command, ParseError> =>
-  Either.map(parseRawOptions(args), (raw) => {
-    const message = raw.message?.trim()
-    return { _tag: "StateSync", message: message && message.length > 0 ? message : null }
-  })
-
-export const parseState = (args: ReadonlyArray<string>): Either.Either<Command, ParseError> => {
-  const action = args[0]?.trim()
-  if (!action || action.length === 0) {
-    return Either.left({ _tag: "MissingRequiredOption", option: "state <action>" })
-  }
-
-  const rest = args.slice(1)
-
-  return Match.value(action).pipe(
-    Match.when("path", () => {
-      if (rest.length > 0) {
-        return unexpectedArgs(rest[0] ?? "")
-      }
-      const command: Command = { _tag: "StatePath" }
-      return Either.right(command)
-    }),
-    Match.when("init", () => parseStateInit(rest)),
-    Match.when("pull", () => {
-      if (rest.length > 0) {
-        return unexpectedArgs(rest[0] ?? "")
-      }
-      const command: Command = { _tag: "StatePull" }
-      return Either.right(command)
-    }),
-    Match.when("push", () => {
-      if (rest.length > 0) {
-        return unexpectedArgs(rest[0] ?? "")
-      }
-      const command: Command = { _tag: "StatePush" }
-      return Either.right(command)
-    }),
-    Match.when("status", () => {
-      if (rest.length > 0) {
-        return unexpectedArgs(rest[0] ?? "")
-      }
-      const command: Command = { _tag: "StateStatus" }
-      return Either.right(command)
-    }),
-    Match.when("commit", () => parseStateCommit(rest)),
-    Match.when("sync", () => parseStateSync(rest)),
-    Match.orElse(() => Either.left(invalidStateAction(action)))
-  )
-}

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

@@ -1,83 +0,0 @@
-import { Either, Match } from "effect"
-
-import { type Command, type ParseError } from "@effect-template/lib/core/domain"
-
-import { parseApply } from "./parser-apply.js"
-import { parseAttach } from "./parser-attach.js"
-import { parseAuth } from "./parser-auth.js"
-import { parseClone } from "./parser-clone.js"
-import { buildCreateCommand } from "./parser-create.js"
-import { parseMcpPlaywright } from "./parser-mcp-playwright.js"
-import { parseRawOptions } from "./parser-options.js"
-import { parsePanes } from "./parser-panes.js"
-import { parseScrap } from "./parser-scrap.js"
-import { parseSessions } from "./parser-sessions.js"
-import { parseState } from "./parser-state.js"
-import { usageText } from "./usage.js"
-
-const isHelpFlag = (token: string): boolean => token === "--help" || token === "-h"
-
-const helpCommand: Command = { _tag: "Help", message: usageText }
-const menuCommand: Command = { _tag: "Menu" }
-const statusCommand: Command = { _tag: "Status" }
-const downAllCommand: Command = { _tag: "DownAll" }
-
-const parseCreate = (args: ReadonlyArray<string>): Either.Either<Command, ParseError> =>
-  Either.flatMap(parseRawOptions(args), (raw) => buildCreateCommand(raw))
-
-// CHANGE: parse CLI arguments into a typed command
-// WHY: enforce deterministic, pure parsing before any effects run
-// QUOTE(ТЗ): "Надо написать CLI команду с помощью которой мы будем создавать докер образы"
-// REF: user-request-2026-01-07
-// SOURCE: n/a
-// FORMAT THEOREM: forall argv: parse(argv) = cmd -> deterministic(cmd)
-// PURITY: CORE
-// EFFECT: Effect<Command, ParseError, never>
-// INVARIANT: parse does not perform IO and returns the same result for same argv
-// COMPLEXITY: O(n) where n = |argv|
-export const parseArgs = (args: ReadonlyArray<string>): Either.Either<Command, ParseError> => {
-  if (args.length === 0) {
-    return Either.right(menuCommand)
-  }
-
-  if (args.some((arg) => isHelpFlag(arg))) {
-    return Either.right(helpCommand)
-  }
-
-  const command = args[0]
-  const rest = args.slice(1)
-  const unknownCommandError: ParseError = {
-    _tag: "UnknownCommand",
-    command: command ?? ""
-  }
-
-  return Match.value(command)
-    .pipe(
-      Match.when("create", () => parseCreate(rest)),
-      Match.when("init", () => parseCreate(rest)),
-      Match.when("clone", () => parseClone(rest)),
-      Match.when("attach", () => parseAttach(rest)),
-      Match.when("tmux", () => parseAttach(rest)),
-      Match.when("panes", () => parsePanes(rest)),
-      Match.when("terms", () => parsePanes(rest)),
-      Match.when("terminals", () => parsePanes(rest)),
-      Match.when("sessions", () => parseSessions(rest)),
-      Match.when("scrap", () => parseScrap(rest)),
-      Match.when("mcp-playwright", () => parseMcpPlaywright(rest)),
-      Match.when("help", () => Either.right(helpCommand)),
-      Match.when("ps", () => Either.right(statusCommand)),
-      Match.when("status", () => Either.right(statusCommand)),
-      Match.when("down-all", () => Either.right(downAllCommand)),
-      Match.when("stop-all", () => Either.right(downAllCommand)),
-      Match.when("kill-all", () => Either.right(downAllCommand)),
-      Match.when("menu", () => Either.right(menuCommand)),
-      Match.when("ui", () => Either.right(menuCommand)),
-      Match.when("auth", () => parseAuth(rest))
-    )
-    .pipe(
-      Match.when("open", () => parseAttach(rest)),
-      Match.when("apply", () => parseApply(rest)),
-      Match.when("state", () => parseState(rest)),
-      Match.orElse(() => Either.left(unknownCommandError))
-    )
-}