@prover-coder-ai/docker-git 1.0.5

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

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

@@ -0,0 +1,73 @@
+import { Either, Match } from "effect"
+
+import { type Command, type ParseError } from "@effect-template/lib/core/domain"
+
+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 { parseRawOptions } from "./parser-options.js"
+import { parsePanes } from "./parser-panes.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), buildCreateCommand)
+
+// 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("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)),
+    Match.when("state", () => parseState(rest)),
+    Match.orElse(() => Either.left(unknownCommandError))
+  )
+}

package/src/docker-git/cli/read-command.ts

@@ -0,0 +1,26 @@
+import { Effect, Either, pipe } from "effect"
+
+import { type Command, type ParseError } from "@effect-template/lib/core/domain"
+
+import { parseArgs } from "./parser.js"
+
+// CHANGE: read and parse CLI arguments from process.argv
+// WHY: keep IO at the boundary and delegate parsing to CORE
+// QUOTE(ТЗ): "Надо написать CLI команду"
+// REF: user-request-2026-01-07
+// SOURCE: n/a
+// FORMAT THEOREM: forall argv: read(argv) -> parse(argv)
+// PURITY: SHELL
+// EFFECT: Effect<Command, ParseError, never>
+// INVARIANT: errors are typed as ParseError
+// COMPLEXITY: O(n) where n = |argv|
+export const readCommand: Effect.Effect<Command, ParseError> = pipe(
+  Effect.sync(() => process.argv.slice(2)),
+  Effect.map((args) => parseArgs(args)),
+  Effect.flatMap((result) =>
+    Either.match(result, {
+      onLeft: (error) => Effect.fail(error),
+      onRight: (command) => Effect.succeed(command)
+    })
+  )
+)

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

@@ -0,0 +1,112 @@
+import { Match } from "effect"
+
+import type { ParseError } from "@effect-template/lib/core/domain"
+
+export const usageText = `docker-git menu
+docker-git create --repo-url <url> [options]
+docker-git clone <url> [options]
+docker-git attach [<url>] [options]
+docker-git panes [<url>] [options]
+docker-git sessions [list] [<url>] [options]
+docker-git sessions kill <pid> [<url>] [options]
+docker-git sessions logs <pid> [<url>] [options]
+docker-git ps
+docker-git down-all
+docker-git auth <provider> <action> [options]
+docker-git state <action> [options]
+
+Commands:
+  menu                Interactive menu (default when no args)
+  create, init        Generate docker development environment
+  clone               Create + run container and clone repo
+  attach, tmux        Open tmux workspace for a docker-git project
+  panes, terms        List tmux panes for a docker-git project
+  sessions            List/kill/log container terminal processes
+  ps, status          Show docker compose status for all docker-git projects
+  down-all            Stop all docker-git containers (docker compose down)
+  auth                Manage GitHub/Codex auth for docker-git
+  state               Manage docker-git state directory via git (sync across machines)
+
+Options:
+  --repo-ref <ref>          Git ref/branch (default: main)
+  --branch, -b <ref>        Alias for --repo-ref
+  --target-dir <path>       Target dir inside container (create default: /home/dev/app, clone default: /home/dev/<org>/<repo>[/issue-<id>|/pr-<id>])
+  --ssh-port <port>         Local SSH port (default: 2222)
+  --ssh-user <user>         SSH user inside container (default: dev)
+  --container-name <name>   Docker container name (default: dg-<repo>)
+  --service-name <name>     Compose service name (default: dg-<repo>)
+  --volume-name <name>      Docker volume name (default: dg-<repo>-home)
+  --secrets-root <path>     Host root for shared secrets (default: n/a)
+  --authorized-keys <path>  Host path to authorized_keys (default: <projectsRoot>/authorized_keys)
+  --env-global <path>       Host path to shared env file (default: <projectsRoot>/.orch/env/global.env)
+  --env-project <path>      Host path to project env file (default: ./.orch/env/project.env)
+  --codex-auth <path>       Host path for Codex auth cache (default: <projectsRoot>/.orch/auth/codex)
+  --codex-home <path>       Container path for Codex auth (default: /home/dev/.codex)
+  --out-dir <path>          Output directory (default: <projectsRoot>/<org>/<repo>[/issue-<id>|/pr-<id>])
+  --project-dir <path>      Project directory for attach (default: .)
+  --lines <n>               Tail last N lines for sessions logs (default: 200)
+  --include-default         Show default/system processes in sessions list
+  --up | --no-up            Run docker compose up after init (default: --up)
+  --mcp-playwright | --no-mcp-playwright  Enable Playwright MCP + Chromium sidecar (default: --no-mcp-playwright)
+  --force                   Overwrite existing files and wipe compose volumes (docker compose down -v)
+  --force-env               Reset project env defaults only (keep workspace volume/data)
+  -h, --help                Show this help
+
+Container runtime env (set via .orch/env/project.env):
+  CODEX_SHARE_AUTH=1|0                  Share Codex auth.json across projects (default: 1)
+  CODEX_AUTO_UPDATE=1|0                 Auto-update Codex CLI on container start (default: 1)
+  DOCKER_GIT_ZSH_AUTOSUGGEST=1|0        Enable zsh-autosuggestions (default: 1)
+  DOCKER_GIT_ZSH_AUTOSUGGEST_STYLE=...  zsh-autosuggestions highlight style (default: fg=8,italic)
+  DOCKER_GIT_ZSH_AUTOSUGGEST_STRATEGY=...  Suggestion sources (default: history completion)
+  MCP_PLAYWRIGHT_ISOLATED=1|0           Isolated browser contexts (recommended for many Codex; default: 1)
+  MCP_PLAYWRIGHT_CDP_ENDPOINT=http://...  Override CDP endpoint (default: http://dg-<repo>-browser:9223)
+
+Auth providers:
+  github, gh         GitHub CLI auth (tokens saved to env file)
+  codex             Codex CLI auth (stored under .orch/auth/codex)
+
+Auth actions:
+  login             Run login flow and store credentials
+  status            Show current auth status
+  logout            Remove stored credentials
+
+Auth options:
+  --label <label>        Account label (default: default)
+  --token <token>        GitHub token override (login only)
+  --scopes <scopes>      GitHub scopes (login only, default: repo,workflow,read:org)
+  --env-global <path>    Env file path for GitHub tokens (default: <projectsRoot>/.orch/env/global.env)
+  --codex-auth <path>    Codex auth root path (default: <projectsRoot>/.orch/auth/codex)
+
+State actions:
+  state path                         Print current projects root (default: ~/.docker-git; override via DOCKER_GIT_PROJECTS_ROOT)
+  state init --repo-url <url> [-b]   Init / bind state dir to a git remote (use a private repo)
+  state status                       Show git status for the state dir
+  state pull                         git pull (state dir)
+  state commit -m <message>          Commit all changes in the state dir
+  state sync [-m <message>]          Commit (if needed) + fetch/rebase + push (state dir); on conflict pushes a PR branch
+  state push                         git push (state dir)
+
+State options:
+  --message, -m <message>    Commit message for state commit
+`
+
+// CHANGE: normalize parse errors into user-facing messages
+// WHY: keep formatting deterministic and centralized
+// QUOTE(ТЗ): "Надо написать CLI команду"
+// REF: user-request-2026-01-07
+// SOURCE: n/a
+// FORMAT THEOREM: forall e: format(e) = s -> deterministic(s)
+// PURITY: CORE
+// EFFECT: Effect<string, never, never>
+// INVARIANT: each ParseError maps to exactly one message
+// COMPLEXITY: O(1)
+export const formatParseError = (error: ParseError): string =>
+  Match.value(error).pipe(
+    Match.when({ _tag: "UnknownCommand" }, ({ command }) => `Unknown command: ${command}`),
+    Match.when({ _tag: "UnknownOption" }, ({ option }) => `Unknown option: ${option}`),
+    Match.when({ _tag: "MissingOptionValue" }, ({ option }) => `Missing value for option: ${option}`),
+    Match.when({ _tag: "MissingRequiredOption" }, ({ option }) => `Missing required option: ${option}`),
+    Match.when({ _tag: "InvalidOption" }, ({ option, reason }) => `Invalid option ${option}: ${reason}`),
+    Match.when({ _tag: "UnexpectedArgument" }, ({ value }) => `Unexpected argument: ${value}`),
+    Match.exhaustive
+  )

package/src/docker-git/main.ts

@@ -0,0 +1,18 @@
+import { NodeContext, NodeRuntime } from "@effect/platform-node"
+import { Effect } from "effect"
+
+import { program } from "./program.js"
+
+// CHANGE: run docker-git CLI through the Node runtime
+// WHY: ensure platform services (FS, Path, Command) are available in app CLI
+// QUOTE(ТЗ): "CLI (отображение, фронт) это app"
+// REF: user-request-2026-01-28-cli-move
+// SOURCE: n/a
+// FORMAT THEOREM: forall env: runMain(program, env) -> exit
+// PURITY: SHELL
+// EFFECT: Effect<void, unknown, NodeContext>
+// INVARIANT: program runs with NodeContext.layer
+// COMPLEXITY: O(n)
+const main = Effect.provide(program, NodeContext.layer)
+
+NodeRuntime.runMain(main)

package/src/docker-git/menu-actions.ts

@@ -0,0 +1,246 @@
+import { type MenuAction, type ProjectConfig } from "@effect-template/lib/core/domain"
+import { readProjectConfig } from "@effect-template/lib/shell/config"
+import { runDockerComposeDown, runDockerComposeLogs, runDockerComposePs } from "@effect-template/lib/shell/docker"
+import type { AppError } from "@effect-template/lib/usecases/errors"
+import { renderError } from "@effect-template/lib/usecases/errors"
+import {
+  downAllDockerGitProjects,
+  listProjectItems,
+  listRunningProjectItems
+} from "@effect-template/lib/usecases/projects"
+import { runDockerComposeUpWithPortCheck } from "@effect-template/lib/usecases/projects-up"
+import { Effect, Match, pipe } from "effect"
+
+import { startCreateView } from "./menu-create.js"
+import { loadSelectView } from "./menu-select.js"
+import { resumeTui, suspendTui } from "./menu-shared.js"
+import { type MenuEnv, type MenuRunner, type MenuState, type ViewState } from "./menu-types.js"
+
+// CHANGE: keep menu actions and input parsing in a dedicated module
+// WHY: reduce cognitive complexity in the TUI entry
+// QUOTE(ТЗ): "TUI? Красивый, удобный"
+// REF: user-request-2026-02-01-tui
+// SOURCE: n/a
+// FORMAT THEOREM: forall a: action(a) -> effect(a)
+// PURITY: SHELL
+// EFFECT: Effect<void, AppError, MenuEnv>
+// INVARIANT: menu selection runs exactly one action
+// COMPLEXITY: O(1) per keypress
+
+const continueOutcome = (state: MenuState): { readonly _tag: "Continue"; readonly state: MenuState } => ({
+  _tag: "Continue",
+  state
+})
+
+const quitOutcome: { readonly _tag: "Quit" } = { _tag: "Quit" }
+
+export type MenuContext = {
+  readonly state: MenuState
+  readonly runner: MenuRunner
+  readonly exit: () => void
+  readonly setView: (view: ViewState) => void
+  readonly setMessage: (message: string | null) => void
+}
+
+export type MenuSelectionContext = MenuContext & {
+  readonly selected: number
+  readonly setSelected: (update: (value: number) => number) => void
+}
+
+const actionLabel = (action: MenuAction): string =>
+  Match.value(action).pipe(
+    Match.when({ _tag: "Up" }, () => "docker compose up"),
+    Match.when({ _tag: "Status" }, () => "docker compose ps"),
+    Match.when({ _tag: "Logs" }, () => "docker compose logs"),
+    Match.when({ _tag: "Down" }, () => "docker compose down"),
+    Match.when({ _tag: "DownAll" }, () => "docker compose down (all projects)"),
+    Match.orElse(() => "action")
+  )
+
+const runWithSuspendedTui = (
+  effect: Effect.Effect<void, AppError, MenuEnv>,
+  context: MenuContext,
+  label: string
+) => {
+  context.runner.runEffect(
+    pipe(
+      Effect.sync(() => {
+        context.setMessage(`${label}...`)
+        suspendTui()
+      }),
+      Effect.zipRight(effect),
+      Effect.tap(() =>
+        Effect.sync(() => {
+          context.setMessage(`${label} finished.`)
+        })
+      ),
+      Effect.ensuring(
+        Effect.sync(() => {
+          resumeTui()
+        })
+      ),
+      Effect.asVoid
+    )
+  )
+}
+
+const requireActiveProject = (context: MenuContext): boolean => {
+  if (context.state.activeDir) {
+    return true
+  }
+  context.setMessage(
+    "No active project. Use Create or paste a repo URL to set one before running this action."
+  )
+  return false
+}
+
+const handleMissingConfig = (
+  state: MenuState,
+  setMessage: (message: string | null) => void,
+  error: AppError
+) =>
+  pipe(
+    Effect.sync(() => {
+      setMessage(renderError(error))
+    }),
+    Effect.as(continueOutcome(state))
+  )
+
+const withProjectConfig = <R>(
+  state: MenuState,
+  setMessage: (message: string | null) => void,
+  f: (config: ProjectConfig) => Effect.Effect<void, AppError, R>
+) =>
+  pipe(
+    readProjectConfig(state.activeDir ?? state.cwd),
+    Effect.matchEffect({
+      onFailure: (error) =>
+        error._tag === "ConfigNotFoundError" || error._tag === "ConfigDecodeError"
+          ? handleMissingConfig(state, setMessage, error)
+          : Effect.fail(error),
+      onSuccess: (config) =>
+        pipe(
+          f(config),
+          Effect.as(continueOutcome(state))
+        )
+    })
+  )
+
+const handleMenuAction = (
+  state: MenuState,
+  setMessage: (message: string | null) => void,
+  action: MenuAction
+): Effect.Effect<
+  { readonly _tag: "Continue"; readonly state: MenuState } | { readonly _tag: "Quit" },
+  AppError,
+  MenuEnv
+> =>
+  Match.value(action).pipe(
+    Match.when({ _tag: "Quit" }, () => Effect.succeed(quitOutcome)),
+    Match.when({ _tag: "Create" }, () => Effect.succeed(continueOutcome(state))),
+    Match.when({ _tag: "Select" }, () => Effect.succeed(continueOutcome(state))),
+    Match.when({ _tag: "Info" }, () => Effect.succeed(continueOutcome(state))),
+    Match.when({ _tag: "Delete" }, () => Effect.succeed(continueOutcome(state))),
+    Match.when({ _tag: "Up" }, () =>
+      withProjectConfig(state, setMessage, () =>
+        runDockerComposeUpWithPortCheck(state.activeDir ?? state.cwd).pipe(Effect.asVoid))),
+    Match.when({ _tag: "Status" }, () =>
+      withProjectConfig(state, setMessage, () =>
+        runDockerComposePs(state.activeDir ?? state.cwd))),
+    Match.when({ _tag: "Logs" }, () =>
+      withProjectConfig(state, setMessage, () =>
+        runDockerComposeLogs(state.activeDir ?? state.cwd))),
+    Match.when({ _tag: "Down" }, () =>
+      withProjectConfig(state, setMessage, () =>
+        runDockerComposeDown(state.activeDir ?? state.cwd))),
+    Match.when({ _tag: "DownAll" }, () =>
+      pipe(
+        downAllDockerGitProjects,
+        Effect.as(continueOutcome(state))
+      )),
+    Match.exhaustive
+  )
+
+const runCreateAction = (context: MenuContext) => {
+  startCreateView(context.setView, context.setMessage)
+}
+
+const runSelectAction = (context: MenuContext) => {
+  context.setMessage(null)
+  context.runner.runEffect(loadSelectView(listProjectItems, "Connect", context))
+}
+
+const runDownAllAction = (context: MenuContext) => {
+  context.setMessage(null)
+  runWithSuspendedTui(downAllDockerGitProjects, context, "Stopping all docker-git containers")
+}
+
+const runDownAction = (context: MenuContext, action: MenuAction) => {
+  context.setMessage(null)
+  if (context.state.activeDir === null) {
+    context.runner.runEffect(loadSelectView(listRunningProjectItems, "Down", context))
+    return
+  }
+  runComposeAction(action, context)
+}
+
+const runInfoAction = (context: MenuContext) => {
+  context.setMessage(null)
+  context.runner.runEffect(loadSelectView(listProjectItems, "Info", context))
+}
+
+const runDeleteAction = (context: MenuContext) => {
+  context.setMessage(null)
+  context.runner.runEffect(loadSelectView(listProjectItems, "Delete", context))
+}
+
+const runComposeAction = (action: MenuAction, context: MenuContext) => {
+  if (!requireActiveProject(context)) {
+    return
+  }
+  const effect = pipe(handleMenuAction(context.state, context.setMessage, action), Effect.asVoid)
+  runWithSuspendedTui(effect, context, actionLabel(action))
+}
+
+const runQuitAction = (context: MenuContext, action: MenuAction) => {
+  context.runner.runEffect(
+    pipe(handleMenuAction(context.state, context.setMessage, action), Effect.asVoid)
+  )
+  context.exit()
+}
+
+export const handleMenuActionSelection = (action: MenuAction, context: MenuContext) => {
+  Match.value(action).pipe(
+    Match.when({ _tag: "Create" }, () => {
+      runCreateAction(context)
+    }),
+    Match.when({ _tag: "Select" }, () => {
+      runSelectAction(context)
+    }),
+    Match.when({ _tag: "Info" }, () => {
+      runInfoAction(context)
+    }),
+    Match.when({ _tag: "Delete" }, () => {
+      runDeleteAction(context)
+    }),
+    Match.when({ _tag: "Up" }, (selected) => {
+      runComposeAction(selected, context)
+    }),
+    Match.when({ _tag: "Status" }, (selected) => {
+      runComposeAction(selected, context)
+    }),
+    Match.when({ _tag: "Logs" }, (selected) => {
+      runComposeAction(selected, context)
+    }),
+    Match.when({ _tag: "Down" }, (selected) => {
+      runDownAction(context, selected)
+    }),
+    Match.when({ _tag: "DownAll" }, () => {
+      runDownAllAction(context)
+    }),
+    Match.when({ _tag: "Quit" }, (selected) => {
+      runQuitAction(context, selected)
+    }),
+    Match.exhaustive
+  )
+}