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

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

@@ -1,311 +0,0 @@
-import { Effect, Match, pipe } from "effect"
-
-import { authClaudeLogin, authClaudeLogout, authGithubLogin, claudeAuthRoot } from "@effect-template/lib/usecases/auth"
-import type { AppError } from "@effect-template/lib/usecases/errors"
-import { renderError } from "@effect-template/lib/usecases/errors"
-
-import {
-  type AuthMenuAction,
-  authMenuActionByIndex,
-  authMenuSize,
-  authViewSteps,
-  readAuthSnapshot,
-  successMessage,
-  writeAuthFlow
-} from "./menu-auth-data.js"
-import { nextBufferValue } from "./menu-buffer-input.js"
-import { handleMenuNumberInput, submitPromptStep } from "./menu-input-utils.js"
-import { pauseOnError, resetToMenu, resumeSshWithSkipInputs, withSuspendedTui } from "./menu-shared.js"
-import type {
-  AuthFlow,
-  AuthSnapshot,
-  MenuEnv,
-  MenuKeyInput,
-  MenuRunner,
-  MenuState,
-  MenuViewContext,
-  ViewState
-} from "./menu-types.js"
-
-type AuthContext = MenuViewContext & {
-  readonly state: MenuState
-  readonly runner: MenuRunner
-}
-
-type AuthInputContext = AuthContext & {
-  readonly setSshActive: (active: boolean) => void
-  readonly setSkipInputs: (update: (value: number) => number) => void
-}
-
-type AuthPromptView = Extract<ViewState, { readonly _tag: "AuthPrompt" }>
-
-const defaultLabel = (value: string): string => {
-  const trimmed = value.trim()
-  return trimmed.length > 0 ? trimmed : "default"
-}
-
-const startAuthMenuWithSnapshot = (
-  snapshot: AuthSnapshot,
-  context: Pick<MenuViewContext, "setView" | "setMessage">
-) => {
-  context.setView({ _tag: "AuthMenu", selected: 0, snapshot })
-  context.setMessage(null)
-}
-
-const startAuthPrompt = (
-  snapshot: AuthSnapshot,
-  flow: AuthFlow,
-  context: Pick<MenuViewContext, "setView" | "setMessage">
-) => {
-  context.setView({
-    _tag: "AuthPrompt",
-    flow,
-    step: 0,
-    buffer: "",
-    values: {},
-    snapshot
-  })
-  context.setMessage(null)
-}
-
-const resolveLabelOption = (values: Readonly<Record<string, string>>): string | null => {
-  const labelValue = (values["label"] ?? "").trim()
-  return labelValue.length > 0 ? labelValue : null
-}
-
-const resolveAuthPromptEffect = (
-  view: AuthPromptView,
-  cwd: string,
-  values: Readonly<Record<string, string>>
-): Effect.Effect<void, AppError, MenuEnv> => {
-  const labelOption = resolveLabelOption(values)
-  return Match.value(view.flow).pipe(
-    Match.when("GithubOauth", () =>
-      authGithubLogin({
-        _tag: "AuthGithubLogin",
-        label: labelOption,
-        token: null,
-        scopes: null,
-        envGlobalPath: view.snapshot.globalEnvPath
-      })),
-    Match.when("ClaudeOauth", () =>
-      authClaudeLogin({
-        _tag: "AuthClaudeLogin",
-        label: labelOption,
-        claudeAuthPath: claudeAuthRoot
-      })),
-    Match.when("ClaudeLogout", () =>
-      authClaudeLogout({
-        _tag: "AuthClaudeLogout",
-        label: labelOption,
-        claudeAuthPath: claudeAuthRoot
-      })),
-    Match.when("GithubRemove", (flow) => writeAuthFlow(cwd, flow, values)),
-    Match.when("GitSet", (flow) => writeAuthFlow(cwd, flow, values)),
-    Match.when("GitRemove", (flow) => writeAuthFlow(cwd, flow, values)),
-    Match.exhaustive
-  )
-}
-
-const runAuthPromptEffect = (
-  effect: Effect.Effect<void, AppError, MenuEnv>,
-  view: AuthPromptView,
-  label: string,
-  context: AuthInputContext,
-  options: { readonly suspendTui: boolean }
-) => {
-  const withOptionalSuspension = options.suspendTui
-    ? withSuspendedTui(effect, {
-      onError: pauseOnError(renderError),
-      onResume: resumeSshWithSkipInputs(context)
-    })
-    : effect
-
-  context.setSshActive(options.suspendTui)
-  context.runner.runEffect(
-    pipe(
-      withOptionalSuspension,
-      Effect.zipRight(readAuthSnapshot(context.state.cwd)),
-      Effect.tap((snapshot) =>
-        Effect.sync(() => {
-          startAuthMenuWithSnapshot(snapshot, context)
-          context.setMessage(successMessage(view.flow, label))
-        })
-      ),
-      Effect.asVoid
-    )
-  )
-}
-
-const loadAuthMenuView = (
-  cwd: string,
-  context: Pick<MenuViewContext, "setView" | "setMessage">
-): Effect.Effect<void, AppError, MenuEnv> =>
-  pipe(
-    readAuthSnapshot(cwd),
-    Effect.tap((snapshot) =>
-      Effect.sync(() => {
-        startAuthMenuWithSnapshot(snapshot, context)
-      })
-    ),
-    Effect.asVoid
-  )
-
-const runAuthAction = (
-  action: AuthMenuAction,
-  view: Extract<ViewState, { readonly _tag: "AuthMenu" }>,
-  context: AuthContext
-) => {
-  if (action === "Back") {
-    resetToMenu(context)
-    return
-  }
-  if (action === "Refresh") {
-    context.runner.runEffect(loadAuthMenuView(context.state.cwd, context))
-    return
-  }
-  startAuthPrompt(view.snapshot, action, context)
-}
-
-const submitAuthPrompt = (
-  view: AuthPromptView,
-  context: AuthInputContext
-) => {
-  const steps = authViewSteps(view.flow)
-  submitPromptStep(
-    view,
-    steps,
-    context,
-    () => {
-      startAuthMenuWithSnapshot(view.snapshot, context)
-    },
-    (nextValues) => {
-      const label = defaultLabel(nextValues["label"] ?? "")
-      const effect = resolveAuthPromptEffect(view, context.state.cwd, nextValues)
-      runAuthPromptEffect(effect, view, label, context, {
-        suspendTui: view.flow === "GithubOauth" || view.flow === "ClaudeOauth" || view.flow === "ClaudeLogout"
-      })
-    }
-  )
-}
-
-const setAuthMenuSelection = (
-  view: Extract<ViewState, { readonly _tag: "AuthMenu" }>,
-  selected: number,
-  context: AuthContext
-) => {
-  context.setView({
-    ...view,
-    selected
-  })
-}
-
-const shiftAuthMenuSelection = (
-  view: Extract<ViewState, { readonly _tag: "AuthMenu" }>,
-  delta: number,
-  context: AuthContext
-) => {
-  const menuSize = authMenuSize()
-  const selected = (view.selected + delta + menuSize) % menuSize
-  setAuthMenuSelection(view, selected, context)
-}
-
-const runAuthMenuSelection = (
-  selected: number,
-  view: Extract<ViewState, { readonly _tag: "AuthMenu" }>,
-  context: AuthContext
-) => {
-  const action = authMenuActionByIndex(selected)
-  if (action === null) {
-    return
-  }
-  runAuthAction(action, view, context)
-}
-
-const handleAuthMenuNumberInput = (
-  input: string,
-  view: Extract<ViewState, { readonly _tag: "AuthMenu" }>,
-  context: AuthContext
-) => {
-  handleMenuNumberInput(input, context, authMenuActionByIndex, (action) => {
-    runAuthAction(action, view, context)
-  })
-}
-
-const handleAuthMenuInput = (
-  input: string,
-  key: MenuKeyInput,
-  view: Extract<ViewState, { readonly _tag: "AuthMenu" }>,
-  context: AuthContext
-) => {
-  if (key.escape) {
-    resetToMenu(context)
-    return
-  }
-  if (key.upArrow) {
-    shiftAuthMenuSelection(view, -1, context)
-    return
-  }
-  if (key.downArrow) {
-    shiftAuthMenuSelection(view, 1, context)
-    return
-  }
-  if (key.return) {
-    runAuthMenuSelection(view.selected, view, context)
-    return
-  }
-  handleAuthMenuNumberInput(input, view, context)
-}
-
-const handleAuthPromptInput = (
-  input: string,
-  key: MenuKeyInput,
-  view: Extract<ViewState, { readonly _tag: "AuthPrompt" }>,
-  context: AuthInputContext
-) => {
-  if (key.escape) {
-    startAuthMenuWithSnapshot(view.snapshot, context)
-    return
-  }
-  if (key.return) {
-    submitAuthPrompt(view, context)
-    return
-  }
-  setAuthPromptBuffer({ input, key, view, context })
-}
-
-type SetAuthPromptBufferArgs = {
-  readonly input: string
-  readonly key: MenuKeyInput
-  readonly view: Extract<ViewState, { readonly _tag: "AuthPrompt" }>
-  readonly context: Pick<MenuViewContext, "setView">
-}
-
-const setAuthPromptBuffer = (
-  args: SetAuthPromptBufferArgs
-) => {
-  const { context, input, key, view } = args
-  const nextBuffer = nextBufferValue(input, key, view.buffer)
-  if (nextBuffer === null) {
-    return
-  }
-  context.setView({ ...view, buffer: nextBuffer })
-}
-
-export const openAuthMenu = (context: AuthContext): void => {
-  context.setMessage("Loading auth profiles...")
-  context.runner.runEffect(loadAuthMenuView(context.state.cwd, context))
-}
-
-export const handleAuthInput = (
-  input: string,
-  key: MenuKeyInput,
-  view: Extract<ViewState, { readonly _tag: "AuthMenu" | "AuthPrompt" }>,
-  context: AuthInputContext
-) => {
-  if (view._tag === "AuthMenu") {
-    handleAuthMenuInput(input, key, view, context)
-    return
-  }
-  handleAuthPromptInput(input, key, view, context)
-}

package/src/docker-git/menu-buffer-input.ts

@@ -1,18 +0,0 @@
-export type BufferInputKey = {
-  readonly backspace?: boolean
-  readonly delete?: boolean
-}
-
-export const nextBufferValue = (
-  input: string,
-  key: BufferInputKey,
-  buffer: string
-): string | null => {
-  if (key.backspace || key.delete) {
-    return buffer.slice(0, -1)
-  }
-  if (input.length > 0) {
-    return buffer + input
-  }
-  return null
-}

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

@@ -1,310 +0,0 @@
-import { type CreateCommand, deriveRepoPathParts, resolveRepoInput } from "@effect-template/lib/core/domain"
-import { createProject } from "@effect-template/lib/usecases/actions"
-import type { AppError } from "@effect-template/lib/usecases/errors"
-import { defaultProjectsRoot } from "@effect-template/lib/usecases/menu-helpers"
-import * as Path from "@effect/platform/Path"
-import { Effect, Either, Match, pipe } from "effect"
-import { parseArgs } from "./cli/parser.js"
-import { formatParseError, usageText } from "./cli/usage.js"
-
-import { nextBufferValue } from "./menu-buffer-input.js"
-import { resetToMenu } from "./menu-shared.js"
-import {
-  type CreateInputs,
-  type CreateStep,
-  createSteps,
-  type MenuEnv,
-  type MenuState,
-  type ViewState
-} from "./menu-types.js"
-
-// CHANGE: move create-flow handling into a dedicated module
-// WHY: keep TUI entry slim and satisfy lint constraints
-// QUOTE(ТЗ): "TUI? Красивый, удобный"
-// REF: user-request-2026-02-01-tui
-// SOURCE: n/a
-// FORMAT THEOREM: forall s: step(s) -> step'(s)
-// PURITY: SHELL
-// EFFECT: Effect<void, AppError, FileSystem | Path | CommandExecutor>
-// INVARIANT: outDir resolves to a stable repo path
-// COMPLEXITY: O(1) per keypress
-
-type Mutable<T> = { -readonly [K in keyof T]: T[K] }
-
-type CreateRunner = { readonly runEffect: (effect: Effect.Effect<void, AppError, MenuEnv>) => void }
-
-type CreateContext = {
-  readonly state: MenuState
-  readonly setView: (view: ViewState) => void
-  readonly setMessage: (message: string | null) => void
-  readonly runner: CreateRunner
-  readonly setActiveDir: (dir: string | null) => void
-}
-
-type CreateReturnContext = CreateContext & {
-  readonly view: Extract<ViewState, { readonly _tag: "Create" }>
-}
-
-export const buildCreateArgs = (input: CreateInputs): ReadonlyArray<string> => {
-  const args: Array<string> = ["create"]
-  if (input.repoUrl.length > 0) {
-    args.push("--repo-url", input.repoUrl)
-  }
-  if (input.repoRef.length > 0) {
-    args.push("--repo-ref", input.repoRef)
-  }
-  if (input.outDir.length > 0) {
-    args.push("--out-dir", input.outDir)
-  }
-  if (!input.runUp) {
-    args.push("--no-up")
-  }
-  if (input.enableMcpPlaywright) {
-    args.push("--mcp-playwright")
-  }
-  if (input.force) {
-    args.push("--force")
-  }
-  if (input.forceEnv) {
-    args.push("--force-env")
-  }
-  return args
-}
-
-const trimLeftSlash = (value: string): string => {
-  let start = 0
-  while (start < value.length && value[start] === "/") {
-    start += 1
-  }
-  return value.slice(start)
-}
-
-const trimRightSlash = (value: string): string => {
-  let end = value.length
-  while (end > 0 && value[end - 1] === "/") {
-    end -= 1
-  }
-  return value.slice(0, end)
-}
-
-const joinPath = (...parts: ReadonlyArray<string>): string => {
-  const cleaned = parts
-    .filter((part) => part.length > 0)
-    .map((part, index) => {
-      if (index === 0) {
-        return trimRightSlash(part)
-      }
-      return trimRightSlash(trimLeftSlash(part))
-    })
-  return cleaned.join("/")
-}
-
-const resolveDefaultOutDir = (cwd: string, repoUrl: string): string => {
-  const resolvedRepo = resolveRepoInput(repoUrl)
-  const baseParts = deriveRepoPathParts(resolvedRepo.repoUrl).pathParts
-  const projectParts = resolvedRepo.workspaceSuffix ? [...baseParts, resolvedRepo.workspaceSuffix] : baseParts
-  return joinPath(defaultProjectsRoot(cwd), ...projectParts)
-}
-
-export const resolveCreateInputs = (
-  cwd: string,
-  values: Partial<CreateInputs>
-): CreateInputs => {
-  const repoUrl = values.repoUrl ?? ""
-  const resolvedRepoRef = resolveRepoInput(repoUrl).repoRef
-  const outDir = values.outDir ?? resolveDefaultOutDir(cwd, repoUrl)
-
-  return {
-    repoUrl,
-    repoRef: values.repoRef ?? resolvedRepoRef ?? "main",
-    outDir,
-    runUp: values.runUp !== false,
-    enableMcpPlaywright: values.enableMcpPlaywright === true,
-    force: values.force === true,
-    forceEnv: values.forceEnv === true
-  }
-}
-
-const parseYesDefault = (input: string, fallback: boolean): boolean => {
-  const normalized = input.trim().toLowerCase()
-  if (normalized === "y" || normalized === "yes") {
-    return true
-  }
-  if (normalized === "n" || normalized === "no") {
-    return false
-  }
-  return fallback
-}
-
-const applyCreateCommand = (
-  state: MenuState,
-  create: CreateCommand
-): Effect.Effect<{ readonly _tag: "Continue"; readonly state: MenuState }, AppError, MenuEnv> =>
-  Effect.gen(function*(_) {
-    const path = yield* _(Path.Path)
-    const resolvedOutDir = path.resolve(create.outDir)
-    yield* _(createProject(create))
-    return { _tag: "Continue", state: { ...state, activeDir: resolvedOutDir } }
-  })
-
-const isCreateCommand = (command: { readonly _tag: string }): command is CreateCommand => command._tag === "Create"
-
-const buildCreateEffect = (
-  command: { readonly _tag: string },
-  state: MenuState,
-  setActiveDir: (dir: string | null) => void,
-  setMessage: (message: string | null) => void
-): Effect.Effect<void, AppError, MenuEnv> => {
-  if (isCreateCommand(command)) {
-    return pipe(
-      applyCreateCommand(state, command),
-      Effect.tap((outcome) =>
-        Effect.sync(() => {
-          setActiveDir(outcome.state.activeDir)
-        })
-      ),
-      Effect.asVoid
-    )
-  }
-  if (command._tag === "Help") {
-    return Effect.sync(() => {
-      setMessage(usageText)
-    })
-  }
-  return Effect.void
-}
-
-const applyCreateStep = (input: {
-  readonly step: CreateStep
-  readonly buffer: string
-  readonly currentDefaults: CreateInputs
-  readonly nextValues: Partial<Mutable<CreateInputs>>
-  readonly cwd: string
-  readonly setMessage: (message: string | null) => void
-}): boolean =>
-  Match.value(input.step).pipe(
-    Match.when("repoUrl", () => {
-      input.nextValues.repoUrl = input.buffer
-      input.nextValues.outDir = resolveDefaultOutDir(input.cwd, input.buffer)
-      return true
-    }),
-    Match.when("repoRef", () => {
-      input.nextValues.repoRef = input.buffer.length > 0 ? input.buffer : input.currentDefaults.repoRef
-      return true
-    }),
-    Match.when("outDir", () => {
-      input.nextValues.outDir = input.buffer.length > 0 ? input.buffer : input.currentDefaults.outDir
-      return true
-    }),
-    Match.when("runUp", () => {
-      input.nextValues.runUp = parseYesDefault(input.buffer, input.currentDefaults.runUp)
-      return true
-    }),
-    Match.when("mcpPlaywright", () => {
-      input.nextValues.enableMcpPlaywright = parseYesDefault(
-        input.buffer,
-        input.currentDefaults.enableMcpPlaywright
-      )
-      return true
-    }),
-    Match.when("force", () => {
-      input.nextValues.force = parseYesDefault(input.buffer, input.currentDefaults.force)
-      return true
-    }),
-    Match.exhaustive
-  )
-
-const finalizeCreateFlow = (input: {
-  readonly state: MenuState
-  readonly nextValues: Partial<CreateInputs>
-  readonly setView: (view: ViewState) => void
-  readonly setMessage: (message: string | null) => void
-  readonly runner: CreateRunner
-  readonly setActiveDir: (dir: string | null) => void
-}) => {
-  const inputs = resolveCreateInputs(input.state.cwd, input.nextValues)
-  const parsed = parseArgs(buildCreateArgs(inputs))
-  if (Either.isLeft(parsed)) {
-    input.setMessage(formatParseError(parsed.left))
-    input.setView({ _tag: "Menu" })
-    return
-  }
-
-  const effect = buildCreateEffect(parsed.right, input.state, input.setActiveDir, input.setMessage)
-  input.runner.runEffect(effect)
-  input.setView({ _tag: "Menu" })
-  input.setMessage(null)
-}
-
-const handleCreateReturn = (context: CreateReturnContext) => {
-  const step = createSteps[context.view.step]
-  if (!step) {
-    context.setView({ _tag: "Menu" })
-    return
-  }
-
-  const buffer = context.view.buffer.trim()
-  const currentDefaults = resolveCreateInputs(context.state.cwd, context.view.values)
-  const nextValues: Partial<Mutable<CreateInputs>> = { ...context.view.values }
-  const updated = applyCreateStep({
-    step,
-    buffer,
-    currentDefaults,
-    nextValues,
-    cwd: context.state.cwd,
-    setMessage: context.setMessage
-  })
-  if (!updated) {
-    return
-  }
-
-  const nextStep = context.view.step + 1
-  if (nextStep < createSteps.length) {
-    context.setView({ _tag: "Create", step: nextStep, buffer: "", values: nextValues })
-    context.setMessage(null)
-    return
-  }
-
-  finalizeCreateFlow({
-    state: context.state,
-    nextValues,
-    setView: context.setView,
-    setMessage: context.setMessage,
-    runner: context.runner,
-    setActiveDir: context.setActiveDir
-  })
-}
-
-export const startCreateView = (
-  setView: (view: ViewState) => void,
-  setMessage: (message: string | null) => void,
-  buffer = ""
-) => {
-  setView({ _tag: "Create", step: 0, buffer, values: {} })
-  setMessage(null)
-}
-
-export const handleCreateInput = (
-  input: string,
-  key: {
-    readonly escape?: boolean
-    readonly return?: boolean
-    readonly backspace?: boolean
-    readonly delete?: boolean
-  },
-  view: Extract<ViewState, { readonly _tag: "Create" }>,
-  context: CreateContext
-) => {
-  if (key.escape) {
-    resetToMenu(context)
-    return
-  }
-  if (key.return) {
-    handleCreateReturn({ ...context, view })
-    return
-  }
-  const nextBuffer = nextBufferValue(input, key, view.buffer)
-  if (nextBuffer !== null) {
-    context.setView({ ...view, buffer: nextBuffer })
-  }
-}