@prover-coder-ai/docker-git 1.0.5

package/dist/src/docker-git/cli/parser-options.js

@@ -0,0 +1,101 @@
+import { Either } from "effect";
+const valueOptionSpecs = [
+    { 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 = new Map(valueOptionSpecs.map((spec) => [spec.flag, spec]));
+const booleanFlagUpdaters = {
+    "--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 = {
+    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, token) => {
+    const updater = booleanFlagUpdaters[token];
+    return updater ? updater(raw) : null;
+};
+export const applyCommandValueFlag = (raw, token, value) => {
+    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) => {
+    let index = 0;
+    let raw = {};
+    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 {} from "@effect-template/lib/core/command-options";

package/dist/src/docker-git/cli/parser-panes.js

@@ -0,0 +1,19 @@
+import { Either } from "effect";
+import {} 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) => {
+    return Either.map(parseProjectDirArgs(args), ({ projectDir }) => ({
+        _tag: "Panes",
+        projectDir
+    }));
+};

package/dist/src/docker-git/cli/parser-sessions.js

@@ -0,0 +1,69 @@
+import { Either, Match } from "effect";
+import {} from "@effect-template/lib/core/domain";
+import { parseProjectDirWithOptions } from "./parser-shared.js";
+const defaultLines = 200;
+const parsePositiveInt = (option, raw) => {
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value) || value <= 0) {
+        const error = {
+            _tag: "InvalidOption",
+            option,
+            reason: "expected positive integer"
+        };
+        return Either.left(error);
+    }
+    return Either.right(value);
+};
+const parseList = (args) => Either.map(parseProjectDirWithOptions(args), ({ projectDir, raw }) => ({
+    _tag: "SessionsList",
+    projectDir,
+    includeDefault: raw.includeDefault === true
+}));
+const parsePidContext = (args) => Either.gen(function* (_) {
+    const pidRaw = args[0];
+    if (!pidRaw) {
+        const error = { _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) => Either.map(parsePidContext(args), ({ pid, projectDir }) => ({
+    _tag: "SessionsKill",
+    projectDir,
+    pid
+}));
+const parseLogs = (args) => 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) => {
+    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 = {
+            _tag: "InvalidOption",
+            option: "sessions",
+            reason: `unknown action ${first}`
+        };
+        return Either.left(error);
+    }));
+};

package/dist/src/docker-git/cli/parser-shared.js

@@ -0,0 +1,26 @@
+import { Either } from "effect";
+import { deriveRepoPathParts, resolveRepoInput } from "@effect-template/lib/core/domain";
+import { parseRawOptions } from "./parser-options.js";
+export const resolveWorkspaceRepoPath = (resolvedRepo) => {
+    const baseParts = deriveRepoPathParts(resolvedRepo.repoUrl).pathParts;
+    const projectParts = resolvedRepo.workspaceSuffix ? [...baseParts, resolvedRepo.workspaceSuffix] : baseParts;
+    return projectParts.join("/");
+};
+export const splitPositionalRepo = (args) => {
+    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, defaultProjectDir = ".") => 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, defaultProjectDir = ".") => Either.map(parseProjectDirWithOptions(args, defaultProjectDir), ({ projectDir }) => ({ projectDir }));

package/dist/src/docker-git/cli/parser-state.js

@@ -0,0 +1,62 @@
+import { Either, Match } from "effect";
+import { parseRawOptions } from "./parser-options.js";
+const invalidStateAction = (value) => ({
+    _tag: "InvalidOption",
+    option: "state",
+    reason: `unknown action: ${value}`
+});
+const unexpectedArgs = (value) => Either.left({ _tag: "UnexpectedArgument", value });
+const parseStateInit = (args) => 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) => 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) => Either.map(parseRawOptions(args), (raw) => {
+    const message = raw.message?.trim();
+    return { _tag: "StateSync", message: message && message.length > 0 ? message : null };
+});
+export const parseState = (args) => {
+    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 = { _tag: "StatePath" };
+        return Either.right(command);
+    }), Match.when("init", () => parseStateInit(rest)), Match.when("pull", () => {
+        if (rest.length > 0) {
+            return unexpectedArgs(rest[0] ?? "");
+        }
+        const command = { _tag: "StatePull" };
+        return Either.right(command);
+    }), Match.when("push", () => {
+        if (rest.length > 0) {
+            return unexpectedArgs(rest[0] ?? "");
+        }
+        const command = { _tag: "StatePush" };
+        return Either.right(command);
+    }), Match.when("status", () => {
+        if (rest.length > 0) {
+            return unexpectedArgs(rest[0] ?? "");
+        }
+        const command = { _tag: "StateStatus" };
+        return Either.right(command);
+    }), Match.when("commit", () => parseStateCommit(rest)), Match.when("sync", () => parseStateSync(rest)), Match.orElse(() => Either.left(invalidStateAction(action))));
+};

package/dist/src/docker-git/cli/parser.js

@@ -0,0 +1,42 @@
+import { Either, Match } from "effect";
+import {} 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) => token === "--help" || token === "-h";
+const helpCommand = { _tag: "Help", message: usageText };
+const menuCommand = { _tag: "Menu" };
+const statusCommand = { _tag: "Status" };
+const downAllCommand = { _tag: "DownAll" };
+const parseCreate = (args) => 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) => {
+    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 = {
+        _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/dist/src/docker-git/cli/read-command.js

@@ -0,0 +1,17 @@
+import { Effect, Either, pipe } from "effect";
+import {} 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 = 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/dist/src/docker-git/cli/usage.js

@@ -0,0 +1,99 @@
+import { Match } from "effect";
+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) => 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/dist/src/docker-git/main.js

@@ -0,0 +1,15 @@
+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/dist/src/docker-git/menu-actions.js

@@ -0,0 +1,115 @@
+import {} 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 { 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 {} 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) => ({
+    _tag: "Continue",
+    state
+});
+const quitOutcome = { _tag: "Quit" };
+const actionLabel = (action) => 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, context, label) => {
+    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) => {
+    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, setMessage, error) => pipe(Effect.sync(() => {
+    setMessage(renderError(error));
+}), Effect.as(continueOutcome(state)));
+const withProjectConfig = (state, setMessage, f) => 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, setMessage, action) => 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) => {
+    startCreateView(context.setView, context.setMessage);
+};
+const runSelectAction = (context) => {
+    context.setMessage(null);
+    context.runner.runEffect(loadSelectView(listProjectItems, "Connect", context));
+};
+const runDownAllAction = (context) => {
+    context.setMessage(null);
+    runWithSuspendedTui(downAllDockerGitProjects, context, "Stopping all docker-git containers");
+};
+const runDownAction = (context, action) => {
+    context.setMessage(null);
+    if (context.state.activeDir === null) {
+        context.runner.runEffect(loadSelectView(listRunningProjectItems, "Down", context));
+        return;
+    }
+    runComposeAction(action, context);
+};
+const runInfoAction = (context) => {
+    context.setMessage(null);
+    context.runner.runEffect(loadSelectView(listProjectItems, "Info", context));
+};
+const runDeleteAction = (context) => {
+    context.setMessage(null);
+    context.runner.runEffect(loadSelectView(listProjectItems, "Delete", context));
+};
+const runComposeAction = (action, context) => {
+    if (!requireActiveProject(context)) {
+        return;
+    }
+    const effect = pipe(handleMenuAction(context.state, context.setMessage, action), Effect.asVoid);
+    runWithSuspendedTui(effect, context, actionLabel(action));
+};
+const runQuitAction = (context, action) => {
+    context.runner.runEffect(pipe(handleMenuAction(context.state, context.setMessage, action), Effect.asVoid));
+    context.exit();
+};
+export const handleMenuActionSelection = (action, context) => {
+    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);
+};