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

package/src/docker-git/menu.ts

@@ -1,303 +0,0 @@
-import { runDockerPsNames } from "@effect-template/lib/shell/docker"
-import { type InputCancelledError, InputReadError } from "@effect-template/lib/shell/errors"
-import { type AppError, renderError } from "@effect-template/lib/usecases/errors"
-import { listProjectItems } from "@effect-template/lib/usecases/projects"
-import { NodeContext } from "@effect/platform-node"
-import { Effect, pipe } from "effect"
-import { render, useApp, useInput } from "ink"
-import React, { useEffect, useMemo, useState } from "react"
-
-import { resolveCreateInputs } from "./menu-create.js"
-import { handleUserInput, type InputStage } from "./menu-input-handler.js"
-import {
-  renderAuthMenu,
-  renderAuthPrompt,
-  renderCreate,
-  renderMenu,
-  renderProjectAuthMenu,
-  renderProjectAuthPrompt,
-  renderSelect,
-  renderStepLabel
-} from "./menu-render.js"
-import { leaveTui, resumeTui } from "./menu-shared.js"
-import { defaultMenuStartupSnapshot, resolveMenuStartupSnapshot } from "./menu-startup.js"
-import { createSteps, type MenuEnv, type MenuState, type ViewState } from "./menu-types.js"
-
-// CHANGE: keep menu state in the TUI layer
-// WHY: provide a dynamic interface with live selection and inputs
-// QUOTE(ТЗ): "TUI? Красивый, удобный"
-// REF: user-request-2026-02-01-tui
-// SOURCE: n/a
-// FORMAT THEOREM: forall s: input(s) -> state'(s)
-// PURITY: SHELL
-// EFFECT: Effect<void, AppError, FileSystem | Path | CommandExecutor>
-// INVARIANT: activeDir updated only after successful create
-// COMPLEXITY: O(1) per keypress
-
-const useRunner = (
-  setBusy: (busy: boolean) => void,
-  setMessage: (message: string | null) => void
-) => {
-  const runEffect = function<E extends AppError>(effect: Effect.Effect<void, E, MenuEnv>) {
-    setBusy(true)
-    const program = pipe(
-      effect,
-      Effect.matchEffect({
-        onFailure: (error) =>
-          Effect.sync(() => {
-            setMessage(renderError(error))
-          }),
-        onSuccess: () => Effect.void
-      }),
-      Effect.ensuring(
-        Effect.sync(() => {
-          setBusy(false)
-        })
-      )
-    )
-    void Effect.runPromise(Effect.provide(program, NodeContext.layer))
-  }
-
-  return { runEffect }
-}
-
-type RenderContext = {
-  readonly state: MenuState
-  readonly view: ViewState
-  readonly activeDir: string | null
-  readonly runningDockerGitContainers: number
-  readonly selected: number
-  readonly busy: boolean
-  readonly message: string | null
-}
-
-const renderView = (context: RenderContext) => {
-  if (context.view._tag === "Menu") {
-    return renderMenu({
-      cwd: context.state.cwd,
-      activeDir: context.activeDir,
-      runningDockerGitContainers: context.runningDockerGitContainers,
-      selected: context.selected,
-      busy: context.busy,
-      message: context.message
-    })
-  }
-
-  if (context.view._tag === "Create") {
-    const currentDefaults = resolveCreateInputs(context.state.cwd, context.view.values)
-    const step = createSteps[context.view.step] ?? "repoUrl"
-    const label = renderStepLabel(step, currentDefaults)
-
-    return renderCreate(label, context.view.buffer, context.message, context.view.step, currentDefaults)
-  }
-
-  if (context.view._tag === "AuthMenu") {
-    return renderAuthMenu(context.view.snapshot, context.view.selected, context.message)
-  }
-
-  if (context.view._tag === "AuthPrompt") {
-    return renderAuthPrompt(context.view, context.message)
-  }
-
-  if (context.view._tag === "ProjectAuthMenu") {
-    return renderProjectAuthMenu(context.view.snapshot, context.view.selected, context.message)
-  }
-
-  if (context.view._tag === "ProjectAuthPrompt") {
-    return renderProjectAuthPrompt(context.view, context.message)
-  }
-
-  return renderSelect({
-    purpose: context.view.purpose,
-    items: context.view.items,
-    selected: context.view.selected,
-    runtimeByProject: context.view.runtimeByProject,
-    confirmDelete: context.view.confirmDelete,
-    connectEnableMcpPlaywright: context.view.connectEnableMcpPlaywright,
-    message: context.message
-  })
-}
-
-const useMenuState = () => {
-  const [activeDir, setActiveDir] = useState<string | null>(null)
-  const [runningDockerGitContainers, setRunningDockerGitContainers] = useState(0)
-  const [selected, setSelected] = useState(0)
-  const [busy, setBusy] = useState(false)
-  const [message, setMessage] = useState<string | null>(null)
-  const [view, setView] = useState<ViewState>({ _tag: "Menu" })
-  const [inputStage, setInputStage] = useState<InputStage>("cold")
-  const [ready, setReady] = useState(false)
-  const [skipInputs, setSkipInputs] = useState(2)
-  const [sshActive, setSshActive] = useState(false)
-  const ignoreUntil = useMemo(() => Date.now() + 400, [])
-  const state = useMemo<MenuState>(() => ({ cwd: process.cwd(), activeDir }), [activeDir])
-  const runner = useRunner(setBusy, setMessage)
-
-  return {
-    activeDir,
-    setActiveDir,
-    runningDockerGitContainers,
-    setRunningDockerGitContainers,
-    selected,
-    setSelected,
-    busy,
-    message,
-    setMessage,
-    view,
-    setView,
-    inputStage,
-    setInputStage,
-    ready,
-    setReady,
-    skipInputs,
-    setSkipInputs,
-    sshActive,
-    setSshActive,
-    ignoreUntil,
-    state,
-    runner
-  }
-}
-
-const useReadyGate = (setReady: (ready: boolean) => void) => {
-  useEffect(() => {
-    const timer = setTimeout(() => {
-      setReady(true)
-    }, 150)
-    return () => {
-      clearTimeout(timer)
-    }
-  }, [setReady])
-}
-
-const useStartupSnapshot = (
-  setActiveDir: (value: string | null) => void,
-  setRunningDockerGitContainers: (value: number) => void,
-  setMessage: (message: string | null) => void
-) => {
-  useEffect(() => {
-    let cancelled = false
-
-    const startup = pipe(
-      Effect.all([listProjectItems, runDockerPsNames(process.cwd())]),
-      Effect.map(([items, runningNames]) => resolveMenuStartupSnapshot(items, runningNames)),
-      Effect.match({
-        onFailure: () => defaultMenuStartupSnapshot(),
-        onSuccess: (snapshot) => snapshot
-      }),
-      Effect.provide(NodeContext.layer)
-    )
-
-    void Effect.runPromise(startup).then((snapshot) => {
-      if (cancelled) {
-        return
-      }
-      setRunningDockerGitContainers(snapshot.runningDockerGitContainers)
-      setMessage(snapshot.message)
-      if (snapshot.activeDir !== null) {
-        setActiveDir(snapshot.activeDir)
-      }
-    })
-
-    return () => {
-      cancelled = true
-    }
-  }, [setActiveDir, setMessage, setRunningDockerGitContainers])
-}
-
-const useSigintGuard = (exit: () => void, sshActive: boolean) => {
-  useEffect(() => {
-    const handleSigint = () => {
-      if (sshActive) {
-        return
-      }
-      exit()
-    }
-    process.on("SIGINT", handleSigint)
-    return () => {
-      process.off("SIGINT", handleSigint)
-    }
-  }, [exit, sshActive])
-}
-
-const TuiApp = () => {
-  const { exit } = useApp()
-  const menu = useMenuState()
-
-  useReadyGate(menu.setReady)
-  useStartupSnapshot(menu.setActiveDir, menu.setRunningDockerGitContainers, menu.setMessage)
-  useSigintGuard(exit, menu.sshActive)
-
-  useInput(
-    (input, key) => {
-      if (!menu.ready) {
-        return
-      }
-      if (Date.now() < menu.ignoreUntil) {
-        return
-      }
-      if (menu.skipInputs > 0) {
-        menu.setSkipInputs((value) => (value > 0 ? value - 1 : 0))
-        return
-      }
-      handleUserInput(input, key, {
-        busy: menu.busy,
-        view: menu.view,
-        inputStage: menu.inputStage,
-        setInputStage: menu.setInputStage,
-        selected: menu.selected,
-        setSelected: menu.setSelected,
-        setSkipInputs: menu.setSkipInputs,
-        sshActive: menu.sshActive,
-        setSshActive: menu.setSshActive,
-        state: menu.state,
-        runner: menu.runner,
-        exit,
-        setView: menu.setView,
-        setMessage: menu.setMessage,
-        setActiveDir: menu.setActiveDir
-      })
-    },
-    { isActive: !menu.sshActive }
-  )
-
-  return renderView({
-    state: menu.state,
-    view: menu.view,
-    activeDir: menu.activeDir,
-    runningDockerGitContainers: menu.runningDockerGitContainers,
-    selected: menu.selected,
-    busy: menu.busy,
-    message: menu.message
-  })
-}
-
-// CHANGE: provide an interactive TUI menu for docker-git
-// WHY: allow dynamic selection and inline create flow without raw prompts
-// QUOTE(ТЗ): "TUI? Красивый, удобный"
-// REF: user-request-2026-02-01-tui
-// SOURCE: n/a
-// FORMAT THEOREM: forall s: tui(s) -> state transitions
-// PURITY: SHELL
-// EFFECT: Effect<void, AppError, FileSystem | Path | CommandExecutor>
-// INVARIANT: app exits only on Quit or ctrl+c
-// COMPLEXITY: O(1) per input
-export const runMenu = pipe(
-  Effect.sync(() => {
-    resumeTui()
-  }),
-  Effect.zipRight(
-    Effect.tryPromise({
-      try: () => render(React.createElement(TuiApp)).waitUntilExit(),
-      catch: (error) => new InputReadError({ message: error instanceof Error ? error.message : String(error) })
-    })
-  ),
-  Effect.ensuring(
-    Effect.sync(() => {
-      leaveTui()
-    })
-  ),
-  Effect.asVoid
-)
-
-export type MenuError = AppError | InputCancelledError

package/src/docker-git/program.ts

@@ -1,154 +0,0 @@
-import type { Command, ParseError } from "@effect-template/lib/core/domain"
-import { createProject } from "@effect-template/lib/usecases/actions"
-import { applyProjectConfig } from "@effect-template/lib/usecases/apply"
-import {
-  authClaudeLogin,
-  authClaudeLogout,
-  authClaudeStatus,
-  authCodexLogin,
-  authCodexLogout,
-  authCodexStatus,
-  authGithubLogin,
-  authGithubLogout,
-  authGithubStatus
-} from "@effect-template/lib/usecases/auth"
-import type { AppError } from "@effect-template/lib/usecases/errors"
-import { renderError } from "@effect-template/lib/usecases/errors"
-import { mcpPlaywrightUp } from "@effect-template/lib/usecases/mcp-playwright"
-import { downAllDockerGitProjects, listProjectStatus } from "@effect-template/lib/usecases/projects"
-import { exportScrap, importScrap } from "@effect-template/lib/usecases/scrap"
-import {
-  stateCommit,
-  stateInit,
-  statePath,
-  statePull,
-  statePush,
-  stateStatus,
-  stateSync
-} from "@effect-template/lib/usecases/state-repo"
-import {
-  killTerminalProcess,
-  listTerminalSessions,
-  tailTerminalLogs
-} from "@effect-template/lib/usecases/terminal-sessions"
-import { Effect, Match, pipe } from "effect"
-import { readCommand } from "./cli/read-command.js"
-import { attachTmux, listTmuxPanes } from "./tmux.js"
-
-import { runMenu } from "./menu.js"
-
-const isParseError = (error: AppError): error is ParseError =>
-  error._tag === "UnknownCommand" ||
-  error._tag === "UnknownOption" ||
-  error._tag === "MissingOptionValue" ||
-  error._tag === "MissingRequiredOption" ||
-  error._tag === "InvalidOption" ||
-  error._tag === "UnexpectedArgument"
-
-const setExitCode = (code: number) =>
-  Effect.sync(() => {
-    process.exitCode = code
-  })
-
-const logWarningAndExit = (error: AppError) =>
-  pipe(
-    Effect.logWarning(renderError(error)),
-    Effect.tap(() => setExitCode(1)),
-    Effect.asVoid
-  )
-
-const logErrorAndExit = (error: AppError) =>
-  pipe(
-    Effect.logError(renderError(error)),
-    Effect.tap(() => setExitCode(1)),
-    Effect.asVoid
-  )
-
-type NonBaseCommand = Exclude<
-  Command,
-  | { readonly _tag: "Help" }
-  | { readonly _tag: "Create" }
-  | { readonly _tag: "Status" }
-  | { readonly _tag: "DownAll" }
-  | { readonly _tag: "Menu" }
->
-
-const handleNonBaseCommand = (command: NonBaseCommand) =>
-  Match.value(command)
-    .pipe(
-      Match.when({ _tag: "StatePath" }, () => statePath),
-      Match.when({ _tag: "StateInit" }, (cmd) => stateInit(cmd)),
-      Match.when({ _tag: "StateStatus" }, () => stateStatus),
-      Match.when({ _tag: "StatePull" }, () => statePull),
-      Match.when({ _tag: "StateCommit" }, (cmd) => stateCommit(cmd.message)),
-      Match.when({ _tag: "StatePush" }, () => statePush),
-      Match.when({ _tag: "StateSync" }, (cmd) => stateSync(cmd.message)),
-      Match.when({ _tag: "AuthGithubLogin" }, (cmd) => authGithubLogin(cmd)),
-      Match.when({ _tag: "AuthGithubStatus" }, (cmd) => authGithubStatus(cmd)),
-      Match.when({ _tag: "AuthGithubLogout" }, (cmd) => authGithubLogout(cmd)),
-      Match.when({ _tag: "AuthCodexLogin" }, (cmd) => authCodexLogin(cmd)),
-      Match.when({ _tag: "AuthCodexStatus" }, (cmd) => authCodexStatus(cmd)),
-      Match.when({ _tag: "AuthCodexLogout" }, (cmd) => authCodexLogout(cmd)),
-      Match.when({ _tag: "AuthClaudeLogin" }, (cmd) => authClaudeLogin(cmd)),
-      Match.when({ _tag: "AuthClaudeStatus" }, (cmd) => authClaudeStatus(cmd)),
-      Match.when({ _tag: "AuthClaudeLogout" }, (cmd) => authClaudeLogout(cmd)),
-      Match.when({ _tag: "Attach" }, (cmd) => attachTmux(cmd)),
-      Match.when({ _tag: "Panes" }, (cmd) => listTmuxPanes(cmd)),
-      Match.when({ _tag: "SessionsList" }, (cmd) => listTerminalSessions(cmd)),
-      Match.when({ _tag: "SessionsKill" }, (cmd) => killTerminalProcess(cmd))
-    )
-    .pipe(
-      Match.when({ _tag: "Apply" }, (cmd) => applyProjectConfig(cmd)),
-      Match.when({ _tag: "SessionsLogs" }, (cmd) => tailTerminalLogs(cmd)),
-      Match.when({ _tag: "ScrapExport" }, (cmd) => exportScrap(cmd)),
-      Match.when({ _tag: "ScrapImport" }, (cmd) => importScrap(cmd)),
-      Match.when({ _tag: "McpPlaywrightUp" }, (cmd) => mcpPlaywrightUp(cmd)),
-      Match.exhaustive
-    )
-
-// CHANGE: compose CLI program with typed errors and shell effects
-// WHY: keep a thin entry layer over pure parsing and template generation
-// QUOTE(ТЗ): "CLI команду... создавать докер образы"
-// REF: user-request-2026-01-07
-// SOURCE: n/a
-// FORMAT THEOREM: forall cmd: handle(cmd) terminates with typed outcome
-// PURITY: SHELL
-// EFFECT: Effect<void, AppError, FileSystem | Path | CommandExecutor>
-// INVARIANT: help is printed without side effects beyond logs
-// COMPLEXITY: O(n) where n = |files|
-export const program = pipe(
-  readCommand,
-  Effect.flatMap((command: Command) =>
-    Match.value(command).pipe(
-      Match.when({ _tag: "Help" }, ({ message }) => Effect.log(message)),
-      Match.when({ _tag: "Create" }, (create) => createProject(create)),
-      Match.when({ _tag: "Status" }, () => listProjectStatus),
-      Match.when({ _tag: "DownAll" }, () => downAllDockerGitProjects),
-      Match.when({ _tag: "Menu" }, () => runMenu),
-      Match.orElse((cmd) => handleNonBaseCommand(cmd))
-    )
-  ),
-  Effect.catchTag("FileExistsError", (error) =>
-    pipe(
-      Effect.logWarning(renderError(error)),
-      Effect.asVoid
-    )),
-  Effect.catchTag("DockerAccessError", logWarningAndExit),
-  Effect.catchTag("DockerCommandError", logWarningAndExit),
-  Effect.catchTag("AuthError", logWarningAndExit),
-  Effect.catchTag("CommandFailedError", logWarningAndExit),
-  Effect.catchTag("ScrapArchiveNotFoundError", logErrorAndExit),
-  Effect.catchTag("ScrapTargetDirUnsupportedError", logErrorAndExit),
-  Effect.catchTag("ScrapWipeRefusedError", logErrorAndExit),
-  Effect.matchEffect({
-    onFailure: (error) =>
-      isParseError(error)
-        ? logErrorAndExit(error)
-        : pipe(
-          Effect.logError(renderError(error)),
-          Effect.flatMap(() => Effect.fail(error))
-        ),
-    onSuccess: () => Effect.void
-  }),
-  Effect.asVoid
-)