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

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

@@ -1,40 +0,0 @@
-import { Either } from "effect";
-import { buildCreateCommand, nonEmpty } from "@effect-template/lib/core/command-builders";
-import { resolveRepoInput } from "@effect-template/lib/core/domain";
-import { parseRawOptions } from "./parser-options.js";
-import { resolveWorkspaceRepoPath, splitPositionalRepo } from "./parser-shared.js";
-const applyCloneDefaults = (raw, rawRepoUrl, resolvedRepo) => {
-    const repoPath = resolveWorkspaceRepoPath(resolvedRepo);
-    const targetHome = "~";
-    return {
-        ...raw,
-        repoUrl: rawRepoUrl,
-        outDir: raw.outDir ?? `.docker-git/${repoPath}`,
-        targetDir: raw.targetDir ?? `${targetHome}/workspaces/${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) => {
-    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 openSsh = raw.openSsh ?? true;
-        const create = yield* _(buildCreateCommand(withRef));
-        return { ...create, waitForClone: true, openSsh };
-    });
-};

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

@@ -1 +0,0 @@
-export { buildCreateCommand, nonEmpty } from "@effect-template/lib/core/command-builders";

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

@@ -1,18 +0,0 @@
-import { Either } from "effect";
-import {} from "@effect-template/lib/core/domain";
-import { parseProjectDirWithOptions } from "./parser-shared.js";
-// CHANGE: parse "mcp-playwright" command for existing docker-git projects
-// WHY: allow enabling Playwright MCP in an already created container/project dir
-// QUOTE(ТЗ): "Добавить возможность поднимать MCP Playrgiht в контейнере который уже создан"
-// REF: issue-29
-// SOURCE: n/a
-// FORMAT THEOREM: forall argv: parseMcpPlaywright(argv) = cmd -> deterministic(cmd)
-// PURITY: CORE
-// EFFECT: Effect<McpPlaywrightUpCommand, ParseError, never>
-// INVARIANT: projectDir is never empty
-// COMPLEXITY: O(n) where n = |argv|
-export const parseMcpPlaywright = (args) => Either.map(parseProjectDirWithOptions(args), ({ projectDir, raw }) => ({
-    _tag: "McpPlaywrightUp",
-    projectDir,
-    runUp: raw.up ?? true
-}));

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

@@ -1,134 +0,0 @@
-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: "--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 = new Map(valueOptionSpecs.map((spec) => [spec.flag, spec]));
-const booleanFlagUpdaters = {
-    "--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 = {
-    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 }),
-    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, 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));
-};
-const parseInlineValueToken = (raw, token) => {
-    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, index, raw) => {
-    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) => {
-    let index = 0;
-    let raw = {};
-    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 {} from "@effect-template/lib/core/command-options";

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

@@ -1,19 +0,0 @@
-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-scrap.js

@@ -1,74 +0,0 @@
-import { Either, Match } from "effect";
-import { parseProjectDirWithOptions } from "./parser-shared.js";
-const missingRequired = (option) => ({
-    _tag: "MissingRequiredOption",
-    option
-});
-const invalidScrapAction = (value) => ({
-    _tag: "InvalidOption",
-    option: "scrap",
-    reason: `unknown action: ${value}`
-});
-const defaultSessionArchiveDir = ".orch/scrap/session";
-const invalidScrapMode = (value) => ({
-    _tag: "InvalidOption",
-    option: "--mode",
-    reason: `unknown value: ${value} (expected session)`
-});
-const parseScrapMode = (raw) => {
-    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, archivePath, mode) => ({
-    _tag: "ScrapExport",
-    projectDir,
-    archivePath,
-    mode
-});
-const makeScrapImportCommand = (projectDir, archivePath, wipe, mode) => ({
-    _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) => {
-    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/dist/src/docker-git/cli/parser-sessions.js

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

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

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

@@ -1,47 +0,0 @@
-import { Either, Match } from "effect";
-import {} 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) => 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), (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) => {
-    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("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("apply", () => parseApply(rest)), Match.when("state", () => parseState(rest)), Match.orElse(() => Either.left(unknownCommandError)));
-};

package/dist/src/docker-git/cli/read-command.js

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

@@ -1,113 +0,0 @@
-import { Match } from "effect";
-export const usageText = `docker-git menu
-docker-git create --repo-url <url> [options]
-docker-git clone <url> [options]
-docker-git apply [<url>] [options]
-docker-git mcp-playwright [<url>] [options]
-docker-git attach [<url>] [options]
-docker-git panes [<url>] [options]
-docker-git scrap <action> [<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
-  apply               Apply docker-git config to an existing project/container (current dir by default)
-  mcp-playwright      Enable Playwright MCP + Chromium sidecar for an existing project dir
-  attach, tmux        Open tmux workspace for a docker-git project
-  panes, terms        List tmux panes for a docker-git project
-  scrap               Export/import project scrap (session snapshot + rebuildable deps)
-  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/Claude Code 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: ~/workspaces/<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)
-  --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: .)
-  --archive <path>          Scrap snapshot directory (default: .orch/scrap/session)
-  --mode <session>          Scrap mode (default: session)
-  --git-token <label>       Token label for clone/create (maps to GITHUB_TOKEN__<LABEL>, example: agiens)
-  --codex-token <label>     Codex auth label for clone/create (maps to CODEX_AUTH_LABEL, example: agien)
-  --claude-token <label>    Claude auth label for clone/create (maps to CLAUDE_AUTH_LABEL, example: agien)
-  --wipe | --no-wipe        Wipe workspace before scrap import (default: --wipe)
-  --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)
-  --ssh | --no-ssh          Auto-open SSH after create/clone (default: clone=--ssh, create=--no-ssh)
-  --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)
-  claude, cc        Claude Code CLI auth (OAuth cache stored under .orch/auth/claude)
-
-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; useful for non-interactive/CI)
-  --web                 Force OAuth web flow (login only; ignores --token)
-  --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);