path: root/locales/help_docs/en.yml

# l10n file - en

# The following syntax can be used in text
# 1. **Bold**
# 2. *Italic*
# 3. [[red]]Color[[/]]
# 4. `text` (auto colored green)
# 5. <文本>  (auto colored cyan)
#
# For color usage, please refer to:
# RED     = Emergency, Error
# YELLOW  = Warning
#
# CYAN    = Emphasis
# GREEN   = Text Content
#
# GRAY    = De-emphasis, Ignore
# GREY    = Same as above
#
# For Analyzer results:
# YELLOW  = Move operation = ">" symbol
# GREEN   = Create operation = "+" symbol
# RED     = Lost operation = "-" symbol
# MAGENTA = Erase operation = "&" symbol
# CYAN    = Modify operation = "*" symbol

common:
  confirm: |
    Confirm to perform the above operation? (Y/n):

  word:
    version: Version

jvv:
  version:
    header: |
      JVCS Upstream Manager - %{version}

    compile_info: |
      Compile Info
        Compile Date - %{build_time}
        Target       - %{build_target}
        Platform     - %{build_platform} - %{build_toolchain}

  help: |
    **JustEnoughVCS Upstream Vault Commands**
    This program directly creates, manages, and runs JustEnoughVCS upstream vaults.
    **Warning**: It directly operates on vault data - please operate with caution!
    * With great power comes great responsibility *

    **VAULT**:
      create <NAME>            - Create a vault in the given directory name
      init                     - Create a vault in the current directory

    **QUERY**:
      here                     - Query information about the current vault

    **MEMBERS**:
      member [list|register|remove]
        list                   - List members
        register <MEMBER_NAME> - Register a member
        remove   <MEMBER_NAME> - Remove a member

    **SERVICES**:
      service listen           - Run the server

    Additionally, you can use jvv <CMD_NAME> --help to query more detailed help!

  here: |
    **Display Vault Information Here**
    **Example**: cd ./target_dir/ && jvv here

  create: |
    **Create a new vault with the given name**
    **Usage**: jvv create <VAULT_NAME>

    **Example**: jvv create MyVault
    Creates a directory named 'MyVault' and initializes a vault inside it.

  init: |
    **Initialize a vault in the current directory**
    **Usage**: jvv init

    Uses the current directory's name as the vault name.

  member: |
    **Member Management**
    **Usage**: jvv member <register/remove> <MEMBER_NAME>

    Register or remove members based on the given member name.

    It is recommended to use the "snake_case" naming format,
    as it will be stored in this format in the configuration file
    **Example**: jvv member register vault_member

    **Query**: jvv member list
    Equivalent to running `jvv here` in the members directory.

    **Tip**: Does not manage private keys automatically. Keys must be handled manually.

  service: |
    **Service Management**
    **Usage**:
      jvv service listen - Start the server in the current vault
        You can use --port   to set the listening port,
                use --no-log to disable log output

  info:
    here:
      analyzing_size: Analyzing vault storage size...

  fail:
    jvcs: "JustEnoughVCS Error: %{err}"
    no_vault_here: No vault found here

    tokio:
      fs:
        create_dir: Failed to create directory %{dir}
        create_dir_all: Failed to create directory %{dir}

    std:
      current_dir: Failed to get current directory
      current_dir_name: Failed to get current directory name
      set_current_dir: Failed to set current directory to %{dir}

    here:
      cfg_not_found: Could not find vault configuration!
        If you wish to use this directory as a vault, please use jvv init --help to view related help

      vault_init_failed: Failed to initialize vault!
      size_calc_error: Failed to calculate vault storage size!
      member_ids_failed: Failed to get member IDs!
      ref_sheet_not_found: Reference sheet `ref` not found, but it should exist!

    create:
      not_empty: Operation denied! The specified directory already exists.

    init:
      not_empty: Operation denied! The directory is not empty.

    member:
      register: Failed to create member! Please check if a member with the same name already exists
      list: Failed to get member ID!

    service:
      listen_done: |
        Server forced to close due to error!
        Error message: %{error}

      wtf_show_log_and_no_log: |
        You cannot both show and hide log output at the same time!

        "
        This reminds me of the old saying: 'You can't have your cake and eat it too.'
        Or perhaps the classic logical puzzle: 'This statement is false.'
        "

        Your command is a paradox: show the logs, and do not show the logs. Which contradictory order should I follow?

        **Tip**: Use `jvv listen --no-log` or `jvv listen --show-log` to override the default Logger setting.

  success:
    here:
      info: |
        Found vault *`%{name}`*! (%{num_mem} Members, %{num_pk} registered PubKeys)
        Managing %{num_sheets} Sheets, %{num_vf} VirtualFiles, total %{total_size}

        **Tip**: To start the server, run jvv service listen

    create: Successfully created vault at `%{name}`!

    init: Successfully initialized vault here!

    member:
      register: Successfully created member `%{member}`!
      remove: |
        Successfully removed `%{member}` from the vault!
        (or they were never here?)
      list:
        header: |
          **There are %{num} member(s) in the current vault:**

        footer: |
          **Among them, %{num} members have registered PubKeys.**

        status_key_registered: (REGISTERED)

    service:
      listen_start: Listening for client connections in vault `%{path}` ...
      listen_done: Server shutdown!

jv:
  version:
    header: |
      JustEnoughVCS - [[cyan]]%{version}[[/]]

    compile_info: |
      Compile Info
        Compile Date - [[cyan]]%{build_time}[[/]]
        Target       - [[cyan]]%{build_target}[[/]]
        Platform     - [[cyan]]%{build_platform} - %{build_toolchain}[[/]]

  tip:
    not_workspace: |
      Not in workspace directory.
      Use `jv create <name>` or `jv init` to create workspace

    no_account: |
      No accounts registered on this computer.
      Use `jv account add <account_name>` to create account

    no_account_set: |
      Current workspace account is `unknown`, meaning no account is set
      Use    `jv as <account_name>` to set account for workspace
      or use `jv login <account_name> <upstream_address>` to directly login to the upstream vault

    account_not_exist: |
      The account `%{account}` set for the current workspace is not registered on your computer

    outdated: |
      Workspace info has not been updated for %{hour} hours %{minutes} minutes
      Use `jv update` to get the latest information

  help: |
    **JustEnoughVCS**
    This program connects to upstream vaults to synchronize and commit changes to local workspace files for collaborative work.

    **ALIASES**:
      jv u                          - Download latest information              [[cyan]][REMOTE][[/]]
      jv t                          - Track files                              [[cyan]][REMOTE][[/]]
      jv a                          - Align files to sheet
      jv [in|out]                   - Import or export files                   [[cyan]][REMOTE][[/]]

    **UPSTREAM VAULT**:
      login  <ACCOUNT> <UPSTREAM>   - Login to upstream vault                  [[cyan]][REMOTE][[/]]
      direct <UPSTREAM>             - Direct workspace to upstream vault       [[cyan]][REMOTE][[/]]
      unstain                       - Unstain workspace, clear association
      update                        - Download latest information              [[cyan]][REMOTE][[/]]

    **ACCOUNTS**:
      account [list|as|add|remove|movekey|genpub]
        list                        - List accounts
        as      <ACCOUNT_NAME>      - Switch account in workspace
        add     <ACCOUNT_NAME>      - Add account to this computer
        remove  <ACCOUNT_NAME>      - Remove account from computer
        movekey <NAME> <KEY_FILE>   - Move private key file to specified account
        genpub  <NAME> <DIRECTORY>  - Output public key file to specified directory

    **SHEETS**:
      sheet [list|use|exit|make|drop|align]
        list                        - List all sheets
        use                         - Use sheet, start work
        exit                        - Exit sheet, clear current modifications
        make                        - Create a new sheet for yourself          [[cyan]][REMOTE][[/]]
        drop                        - Drop the sheet for others to use         [[cyan]][REMOTE][[/]]
        align                       - Align files to sheet                     [[cyan]][REMOTE][[/]]

    **CONTEXT**:
      here                          - Display path information
      status                        - Display current sheet status information
      info                          - Display individual file status

    **FILE TRANSFER**:
      import <PACKAGE_NAME>         - Import files from import area            [[cyan]][REMOTE][[/]]
      import <REFERENCE_SHEET_PATH> - Import files from reference sheet        [[cyan]][REMOTE][[/]]
      export <FILE> <SHEET_NAME>    - Export files to other sheets             [[cyan]][REMOTE][[/]]

    **FILE OPERATIONS**:
      move  <FILE> <TO>             - Safely rename files                      [[cyan]][REMOTE][[/]]
      track <FILE>                  - Track files to latest version            [[cyan]][REMOTE][[/]]
      hold  <FILE>                  - Hold, sync and lock file                 [[cyan]][REMOTE][[/]]
      throw <FILE>                  - Throw, sync and unlock file              [[cyan]][REMOTE][[/]]
      jump  <FILE> <VERSION>        - Jump file to other version               [[cyan]][REMOTE][[/]]

    **DOCUMENTATION**:
      docs list                     - List all available documentation
      docs <DOC_NAME>               - View content of specified documentation

    You can use jv <COMMAND_NAME> --help to query more detailed help!

    **Tip**: If you need to understand JustEnoughVCS collaboration paradigms, use jv docs get_started

  account: |
    **Manage Local Accounts**
    **Usage**:
    jv account list - List all accounts on this computer and whether private keys are registered
    jv account as <ACCOUNT_NAME> - Switch current account
    jv account add <ACCOUNT_NAME> - Add an account to this computer
    jv account remove <ACCOUNT_NAME> - Delete this account
    jv account movekey <ACCOUNT_NAME> <PRIVATE_KEY_FILE> - Move private key to specified account
    jv account genpub <ACCOUNT_NAME> <OUTPUT_DIR> - Output public key to specified directory, leave empty for current directory

    **Tip**: Use jv account add <ACCOUNT_NAME> --keygen to automatically generate ED25519 private key for your account
    **Note**: Both `--keygen` and `genpub` require your computer to be able to directly call OpenSSL command-line tools

    Accounts are identity identifiers on the local computer, each account can be associated with different private keys.
    You need to set up accounts before interacting with upstream vaults.

  sheet: |
    **Manage Sheets**
    **Usage**:
    jv sheet list - List all sheets in the upstream workspace

    jv sheet use <SHEET_NAME> - Use the specified sheet to start current work (automatically created if it doesn't exist)
    jv sheet exit - Exit current work

    jv sheet make <SHEET_NAME> - Create a new sheet for yourself
    jv sheet drop <SHEET_NAME> - Drop the sheet for others to use

    **Align**:
    jv sheet align - View all items that need alignment

    For moved items:
    jv sheet align <ITEM> [local/remote] - Align specified moved item
    jv sheet align moved [local/remote] - Align all moved items

    For lost items:
    jv sheet align <ITEM> <CREATED_ITEM> - Point to created item to confirm move
    jv sheet align <ITEM> confirm - Confirm this file is lost
    jv sheet align lost confirm - Confirm all lost items

    For erased items:
    jv sheet align <ITEM> confirm - Confirm this file is erased
    jv sheet align erased confirm - Confirm all erased items

    jv sheet align --work - Use editor mode to align files

    Sheets are core concepts in JustEnoughVCS, each sheet represents an independent file collection.
    You can switch work between different sheets, or export files from one sheet to another.

  create: |
    **Create Workspace with Specified Name**
    **Usage**: jv create <WORKSPACE_NAME>

    **Example**: jv create my_workspace
    Creates a directory named 'my_workspace' in the current directory and initializes a workspace inside it.

    Workspace is your local working environment for file synchronization and version control with upstream vaults.

  init: |
    **Create Workspace in Current Directory**
    **Usage**: jv init

    This command creates a workspace in the current directory, with the workspace name determined by the current directory name.

    If the current directory is not empty, this operation will fail. Please ensure you execute this command in an empty directory.

  here: |
    **Query Directory Information Here**
    **Usage**: jv here

    Displays detailed information about current directory files, including:
    - File name, size, version number
    - Current file holder
    - Latest version update description

    **Tip**: Use `jv here --desc` to view the last update description for local files

  status: |
    **Display Current Sheet Status Information**
    **Usage**: jv status

    Displays the file modification status of the current sheet:
    - Added, deleted files
    - Moved files
    - Modified files

    This is a quick way to understand the current file status of the sheet.

  track: |
    **Track or Pull Files**
    **Usage**: jv track <FILE_PATH>

    **Example**: jv track src/main.rs
    For new files:
      Create and upload the "First Version", then automatically hold them
    For *held* files:
      Upload new versions to the upstream vault to update to the latest version
    For *unheld* or *non-exist* files:
      Download or update local file versions to the latest

    Tracking files is the basic operation of version control, ensuring your upstream and local files are always up to date.

  hold: |
    **Hold Files: Obtain File Edit Rights from Upstream Vault**
    **Usage**: jv hold <FILE_PATH>

    **Example**: jv hold src/lib.rs
    When you need to edit a file, you must first hold the file's edit rights.
    After holding a file, other collaborators will not be able to edit the same file simultaneously, avoiding conflicts.

    After editing, remember to track the file to save changes.

  throw: |
    **Throw Files: Release File Edit Rights from Upstream Vault**
    **Usage**: jv throw <FILE_PATH>

    **Example**: jv throw src/config.rs
    When you no longer need to edit a file, you can throw the file's edit rights.
    After throwing, other collaborators can hold and edit the file.

    If you have made changes to the file but haven't tracked them, throwing will lose those changes.

  move: |
    **Move Mapping**
    **Usage**:
    jv move <mapping> <target_mapping> - Modify upstream mapping
    jv move <mapping> --erase - Erase upstream mapping

    **Examples**:
    jv move draft/character.png done/character.png - Move mapping
    jv move character.png player.png - Rename
    jv move . ../publish/ - Batch move
    jv move temp/ --erase - Erase mapping

    The move mapping operation modifies the upstream mapping and synchronizes the local structure (use `--only-remote` to cancel local modification)
    After moving, you usually need `jv align moved remote` to synchronize the local structure to the upstream

  export: |
    **Export Files to Import Area of Other Sheets**
    **Usage**: jv export <FILE> <TARGET_SHEET> -m <DESCRIPTION> -n <PACKAGE_NAME>

    **Example**: jv export data.csv analytics -m "Export analysis data" -n "analysis_data"
    This operation packages the specified files and sends them to the import area of the target sheet.

    Other collaborators can use the jv import command in the target sheet to import these files.

  import: |
    **Import Files to Current Sheet**
    **Usage**:
    jv import <PACKAGE_NAME> - Import files from import area
    jv import <REFERENCE_SHEET_PATH> - Import files from reference sheet

    **Example**:
    jv import Player_Import - From import area defined name
    jv import ref@Data/Player.csv - From reference sheet path

    Import operation copies files from other sheets or import areas to the current workspace.

  direct: |
    **Direct to Specified Upstream Vault and Stain This Workspace**
    **Usage**: jv direct <UPSTREAM_VAULT_ADDRESS>

    **Example**: jv direct your_vault.org
    This operation connects the current workspace to the specified upstream vault and adds a stain identifier to the workspace.

    After staining, the workspace will only be able to interact with vaults of the specified identifier, ensuring data consistency.

  unstain: |
    **Unstain This Workspace**
    **Usage**: jv unstain

    **DANGER ZONE**: This operation removes the workspace's stain identifier, after which the workspace will be disconnected from the upstream vault.

    After unstaining, the workspace will no longer be associated with any specific vault and can be reconnected to other vaults.
    However, please note that this may cause data synchronization issues, use with caution.

  update: |
    **Download Latest Information from Upstream Vault**
    **Usage**: jv update

    This operation synchronizes the latest file status, sheet information, and member information from the upstream vault.

    It is recommended to perform an update operation before starting work to ensure you have the latest working environment.

  docs: |
    **Query Built-in Documentation**
    **Usage**:
    jv docs list - List all available documentation
    jv docs <DOC_NAME> - View content of specified documentation
    jv docs <DOC_NAME> -d - Print content directly

    **Example**:
    jv docs get_started
    jv docs collaboration -d

    Built-in documentation includes JustEnoughVCS usage guides, collaboration paradigms, and best practices.

  confirm:
    login: |
      You are logging into upstream vault %{upstream} as %{account}, please confirm

    unstain: |
      This operation will disconnect the current workspace from the upstream vault `%{upstream}`
      If you reconnect to a vault with a mismatched identifier, it will cause serious problems, please operate with caution!

    direct: |
      Do you want to direct the current local workspace to the upstream vault %{upstream}?

    sheet:
      make:
        restore: |
          Sheet `%{sheet_name}` is no holder. Take ownership?
          If not, use a different name to create a sheet.

        restore_ref: |
          You can't just grab the reference sheet, it's the team's shared structure! :)

      drop: |
        Are you sure you want to drop sheet `%{sheet_name}`?
        After this, you will not be able to work in the sheet!

    track:
      prepare: |
        You are tracking %{file_counts} file(s), these files will follow the following rules
        1. New files will be uploaded and added to your sheet for management
        2. For files you held, unless they don't exist locally or versions don't match, upload logic will always be executed
        3. For files not held unless the version is frozen, download logic will always be executed to get the latest version

        **CURRENT**:
          **DOWN**: %{old_files} to sync, %{download_files} to download
          **UP**  : %{new_files} to track, %{modified_files} to update

  fail:
    std:
      current_dir: Failed to get current directory
      current_dir_name: Failed to get current directory name
      set_current_dir: Failed to set current directory to %{dir}

    move:
      rename_failed: |
        **Warning**: Failed to move local file `%{from}` to `%{to}`: %{error}

      has_rename_failed: |
        **Tip**: Because the file move was skipped, a deviation will occur.
        After moving the file, be sure to use `jv align` to resolve the deviation.

      no_target_dir: |
        You did not specify a target directory to move to!
        Please use `jv move <mapping> <target_address>` to move the mapping
        or use `jv move <mapping> --erase` to erase the mapping

      count_doesnt_match: |
        You specified multiple mappings, but the target address is a single mapping.
        Please use `jv move multiple_mappings directory/` to move multiple mappings
        or use `jv move single_mapping mapping_name` to rename that mapping.

    format_path: |
      Failed to format directory %{path}: %{error}.

    path_not_found: |
      The directory `%{path}` cannot be found!

    parse:
      parser_failed: |
        Incorrect command input!
        Please use `jv -h` to view help

      str_to_sockaddr: |
        Error: %{err}
        Cannot recognize *`%{str}`* as a valid address, please check your input!

    from_core: |
      **Error**: `%{err}` (This error is from core call)

    sheet:
      align:
        no_direction: |
          Unable to confirm alignment method!

        align_item_not_found: |
          Cannot find this alignment item!
          **Tip**: Use `jv align` to view available alignment items

        unknown_moved_direction: |
          Unknown alignment direction!
          Please use `local` or `remote` to indicate whether the path is based on local location or remote location

        target_exists: |
          Cannot align local file `%{local}` to remote address `%{remote}`
          because another file already exists here. Please move that file away and align again!

        move_failed: |
          Failed to move local file: %{err}
          **Tip**: Please check file permissions or if the path is correct

        remove_mapping_failed: |
          Failed to remove local mapping: %{err}

        delete_mapping_failed: |
          Failed to delete mapping from local table: %{err}
          **Tip**: Please check the local table configuration file

        no_lost_matched: |
          No matching lost item found!

        no_created_matched: |
          No matching created item found!

        too_many_lost: |
          Found multiple lost items!

        too_many_created: |
          Found multiple created items!

        calc_hash_failed: |
          Failed to calculate hash for file `%{file}`

    account:
      no_user_dir: Cannot find user directory!
      add: Failed to add account `%{account}`, please check if the account already exists.
      remove: Failed to remove account `%{account}`, please check if the account exists.
      list: Failed to get account list!
      not_found: Cannot find account `%{account}`!
      no_key_registered: Account `%{account}` has no registered private key!
      as: Failed to set current account, please ensure the current sheet has been exited
      keygen: Failed to generate private key! Please try generating private key manually
      keygen_exec: |
        Failed to run OpenSSL!
        Please check if OpenSSL is installed on your computer
      generate_pub_key: |
        Failed to generate public key!
        Please check if OpenSSL is installed, or manually generate the public key

    init_create_dir_not_empty: |
      The current directory is not empty!
      If you are certain you want to create here, please use --force to force execution!

    create: Failed to create local workspace!
    init: Failed to create workspace here!
    get_current_dir: Failed to get current directory!

    workspace_not_found: |
      Local workspace not found! Please use this command within a local workspace
      If you wish to use this directory as a local workspace, please use jv init

    read_cfg: Failed to read local workspace configuration file!
    write_cfg: Failed to write changes to local workspace configuration file!

    create_socket: Failed to create TCP socket!
    connection_failed: Failed to connect to target server!

    unstain: |
      The current workspace is not stained, no need to unstain

    not_stained: |
      The current workspace is not stained, cannot perform the next operation!
      **Tip**: Please first use `jv direct <upstream_address>` to direct to an upstream vault

    change_edit_right:
      no_selection: No files selected!

      check_failed: |
        In the %{num} selected files, there are items that failed pre-check!
        Add `--details` after the command to view specific details

        **Tip**:
        Add `--skip-failed` after the command to skip the current failed items and proceed with the operation
        Add `--force` to ignore checks and proceed (UNSAFE)

      check_failed_details:
        In the %{num} selected files, %{failed} files failed pre-check!
        %{items}

      check_fail_item: |
        %{path} (%{reason})

      check_fail_reason:
        not_found_in_sheet: Mapping Not Found In Sheet
        not_a_tracked_file: File Not Tracked
        base_version_unmatch: Version Mismatch
        not_holder: Not Holder
        has_holder: Held by %{holder}
        already_held: Already Held
        already_modified: Already Modified

    docs:
      not_found: Doc `%{docs_name}` not found!
      no_doc_dir: |
        Cannot find staging directory!
        **Tip**: You can also use `jv docs %{docs_name} -d` to print directly
      open_editor: |
        Failed to open text editor preview: `%{err}!
        **Tip**: You can also use `jv docs %{docs_name} -d` to print directly

    track:
      no_selection: |
        You did not select any files in this operation!

        **Tip**: If you entered content and still see this,
        it may be because the directory you passed is outside the workspace directory, paths outside the workspace will be ignored

    status:
      no_sheet_in_use: |
        You are not using any sheet! Cannot analyze workspace status in this situation
        **Tip**: You can use `jv use <sheet_name>` to select and use a sheet

      analyze: |
        Failed to analyze local workspace status!

    use:
      sheet_not_exists: |
        Sheet `%{name}` does not exist!
        **Tip**: Please use `jv update` to update workspace status

      directory_not_empty: |
        When no sheet is in use, the workspace should not contain any files!
        **Tip**: Please ensure the workspace is clean before using `jv use <sheet_name>` to select and use a sheet

  success:
    account:
      as: Successfully switched this workspace's account to `%{account}`
      add: Successfully added account `%{account}`!
      remove: Successfully removed account `%{account}`!
      list:
        header: |
          **There are %{num} account(s) on this computer:**

        status_has_key: (REGISTERED)
      move_key: Successfully moved the private key to the account directory!
      generate_pub_key: Successfully generated public key at `%{export}`, please give it to the upstream vault administrator!
    create: Successfully created local workspace!
    init: Successfully created workspace here!
    unstain: |
      Successfully unstained!
      The current workspace no longer belongs to any upstream vault, please direct to a new upstream vault before working
      **Tip**: Use `jv direct <upstream_vault_address>` to redirect to a new upstream vault

    sheet:
      list:
        your_sheet: |
          **YOURS**:
        your_sheet_item: |
          %{number}. %{name}
        your_sheet_item_use: |
          %{number}. %{name} (CURRENT)
        other_sheet: |
          **OTHERS**:
        other_sheet_item: |
          %{number}. %{name} (AT `%{holder}`)
        other_sheet_item_no_holder: |
          %{number}. %{name} (NO HOLDER)
        tip_has_sheet: |
          You are not on any sheet, you can use `jv use <SHEET_NAME>` to use a sheet
        tip_no_sheet: |
          You don't have any sheets, you can use `jv make <SHEET_NAME>` to create a new sheet

      align:
        list: |
          Your local workspace has the following alignment tasks pending:
          %{tasks}

        task_name: TASK
        local_path: LOCAL_FILE
        remote_path: REMOTE_FILE

        no_changes: |
          Great, no structural deviations in the local workspace, no alignment needed!

        suggestion_1: |
          **Suggestion**: Confirm [[magenta]]Erased Items[[/]]
          **Example**: Use `jv align %{example_erased} confirm` to confirm this [[magenta]]Erased Item[[/]]!

          [[yellow]]**Note**: After confirmation, the local mapping will be erased, and the file at that location will be moved away.[[/]]

        suggestion_2: |
          **Suggestion**: Confirm [[red]]Lost Items[[/]]
          Cannot determine if the intent of the file loss is [[red]]Deletion[[/]] or [[yellow]]Move[[/]]!
          **Example**: Use `jv align %{example_lost} <action>` to handle this [[red]]Lost Item[[/]]

          **Confirm Deletion**: Enter `confirm` to confirm your operation is a [[red]]Deletion[[/]]
          **Declare Move**: Enter a [[green]]Created Item[[/]] to form a [[yellow]]Move[[/]] relationship with it

        suggestion_3: |
          **Suggestion**: Align [[yellow]]Moved Items[[/]], confirm they are based on Local or Remote
          **Example**: Use `jv align moved [local|remote]`          to batch align
                  or use `jv align %{example_moved} [local|remote]` to precisely align a move

          **Align to  Local**: Online , modify the upstream mapping to the local location
          **Align to Remote**: Offline, move the local file to the upstream location

    docs:
      list:
        header: |
          **DOCUMENTS**:

        item: |
          %{num}. %{docs_name}

        footer: |
          **Tip**: Use `jv docs <doc_name>` to view doc, use -d for direct output

    here:
      items:
        name: NAME
        version: VERSION
        holder: HOLDER
        size: SIZE
        editing: STATUS
        description: DESC

      path_info: |
        CURRENT: %{upstream}/%{account}/%{sheet_name}/%{path} (%{minutes} min ago)

      ghost_directory_item_info: |
        ? %{directory_name}/

      ghost_file_item_info: |
        ? %{file_name}

      directory_item_info: |
        %{directory_name}/

      file_item_info: |
        %{file_name}

      append_info:
        holder:
          yourself: |
            You

          others: |
            %{holder}

        size: |
          %{size}

        name: |
          %{name}

        version:
          unmatch: |
            %{remote_version}*

          match: |
            %{version}

        editing:
          cant_edit: |
            R

          cant_edit_but_modified: |
            R*

          can_edit: |
            R/W

          modified: |
            R/W *

          not_local: |
            Remote

        description: |
          @%{creator}: %{description}

      count_info: |
        %{dir_count} dir(s), %{file_count} file(s). Total %{size}.

    status:
      struct_changes_display: |
        Viewing sheet %{sheet_name} (%{h}h %{m}min %{s}secs ago).

        Now in structural change mode:
        %{moved_items}%{lost_items}%{erased_items}%{created_items}
        **Tip**: Use `jv align` to align moved, lost, and erased changes,
               Use `jv track` to track created changes

      content_modifies_display: |
        Viewing sheet %{sheet_name} (%{h}h %{m}min %{s}secs ago).

        Now in content change mode:
        %{modified_items}

        **Tip**: Use `jv track` to track your changes

      no_changes: |
        In sheet %{sheet_name}, status based on %{h} hours %{m} minutes %{s} seconds ago
        Your workspace is synchronized with upstream, you can proceed with structural and content editing based on this state!

      created_item: |
        +   Created:         %{path}

      lost_item: |
        -      Lost:         %{path}

      moved_item: |
        \>     Moved: Remote  %{from}
                      Local  %{to}

      erased_item: |
        &    Erased：        %{path}

      modified_item: |
        \*  Modified:         %{path}

      invalid_modified_item: |
        x  Modified:         %{path} (%{reason})

      invalid_modified_reasons:
        not_holder: Modified without holding
        base_version_mismatch: Base version mismatch for editing

      no_structure_changes: |
        No struct changes

      no_file_modifications: |
        No modifications

  result:
    common:
      authroize_failed: |
        Authentication failed: %{err}!
      unknown: |
        Unknown result!

    direct:
      redirected: |
        Successfully redirected to upstream vault `%{upstream}`!

      redirect_failed: |
        Redirection failed: %{err}!

      directed_and_stained: |
        Successfully directed to upstream vault `%{upstream}`!
        Workspace has been **stained**, ready to start working!

      already_stained: |
        Current workspace is already stained and cannot be directed to other upstream vaults with different identifiers
        Please use `jv unstain` to remove the stain first

      same_upstream: |
        Current upstream is the same as given, no need to redirect

    update:
      success: |
        Synchronized to latest information!

      fail:
        sync_cached_sheet_fail:
          path_already_exist: |
            Error syncing upstream information to local: Local path %{path} already exists, but a move operation needs to move an item here.
            Please try moving the item to a different path, then run `jv update` again

    sheet:
      make:
        success: |
          Successfully created sheet `%{name}`!
          Upstream changed, use `jv update` to get the latest information

        success_restore: |
          Successfully restored sheet `%{name}`!
          Upstream changed, use `jv update` to get the latest information

        sheet_already_exists: |
          Sheet `%{name}` already exists and is held by other members!

        sheet_creation_failed: |
          Sheet creation failed: `%{error}`

      drop:
        success: |
          Successfully dropped sheet `%{name}`!
          Upstream changed, use `jv update` to sync to latest information
          **Tip**: You can use `jv make %{name}` to restore this sheet

        sheet_in_use: |
          Sheet `%{name}` is in use, cannot drop!
          **Tip**: Please use `jv exit` to exit current sheet first

        sheet_not_exists: |
          Sheet `%{name}` does not exist!

        sheet_drop_failed: |
          Failed to drop sheet: %{err}

        no_holder: |
          Sheet `%{name}` has no holder!

        not_owner: |
          You are not the holder of sheet `%{name}`, cannot drop it!

    change_edit_right:
      failed:
        none: |
          Do nothing!

      success:
        hold: |
          Held %{num} files!

        throw: |
          Threw %{num} files!

        mixed: |
          Successfully modified edit rights for %{num} files!
          Held %{num_hold}, Threw %{num_throw}

    track:
      done: |
        Tracked %{count} files to latest!
        **Total**: %{created} Created, %{updated} Updated, %{synced} Synced

      tip_has_skipped: |
        **Note**: Skipped %{skipped_num} sync tasks
        %{skipped}
        Because local modifications exist, the sync task will forcibly overwrite your changes.
        Please confirm you really want to overwrite these files.
        Use `jv track . --overwrite` to confirm overwriting them

      structure_changes_not_solved: |
        There are unresolved local lost and moved items!
        **Tip**: Use `jv align` to view items that need to be resolved

      create_failed:
        sheet_not_found: |
          Sheet `%{name}` does not exist in the upstream vault!
          This means the sheet has been deleted in the upstream vault, or the sheet does not belong to you

        create_file_on_exist_path: |
          Failed to track and create file!
          The file path `%{path}` you want to track already exists in the remote sheet, please use a different path for tracking

      update_failed:
        verify:
          sheet_not_found: Sheet %{sheet_name} does not exist!
          mapping_not_found: |
            Cannot get mapping for path %{path} from the sheet!
            This means the file does not exist in the sheet. If it exists locally, it may have been deleted
            Please use `jv update` to update the workspace and try again

          virtual_file_not_found: |
            Cannot read virtual file ID %{vfid} from the mapping!
            This means the mapping exists in the sheet, but the actual file information is missing!
            Please contact the upstream vault administrator for assistance

          virtual_file_read_failed: |
            Cannot read metadata for virtual file %{vfid} from the mapping!
            This means the file exists, but the mapping information is corrupted!
            Please contact the upstream vault administrator for assistance

          not_held: |
            You are not holding file %{path}!
            This means you modified the file without holding it, and the upstream vault blocked your update attempt
            (Sorry, JustEnoughVCS collaboration is based on serial editing - parallel editing and merging is not allowed)

            **Tip**: If you really need to update this file, you can follow these steps:
            1. First move the file outside the workspace and update the correct version here
            2. Use `jv info <this_file> --holder` to query the member currently editing it
            3. Try to contact them, describe your situation, and wait for them to release editing rights
            4. After editing rights are released, use `jv track <this_file>` to get the latest version from that member
            5. Manually merge your backed-up version into the latest version
            6. Update your modified latest version, then release editing rights

            Finally: You can use `jv here` to check file status in the directory before editing files to ensure you can edit

          version_dismatch: |
            The base version of the file you edited does not match the version in the upstream vault!
            Your version is %{version_current} while the upstream version is %{version_latest}, the upstream vault blocked your update

            **Tip**:
            You can use `jv jump <file> %{version_current}` to jump the version to your local version and update again
            If you don't want to force override the version, you can backup the file version, update your local version to the latest, then manually merge the files and update

            Finally: You can use `jv here` to check file status in the directory before editing files to ensure you can edit

          update_but_no_description: |
            There are update items in the files you specified, but no information provided
            You can use `jv track <file> --desc <description> -v <version>` to update files
            or use `jv track . --work` to enter the editor environment for updating

          version_already_exist: |
            The version %{version} of file %{path} you are updating already exists in the upstream vault, please use a different version number!

    move:
      success: |
        Successfully modified mapping!
        Upstream information has changed, please use `jv update` to sync to latest information

      mapping_not_found: |
        Mapping `%{path}` does not exist!
        Please check if the path you entered is correct, or use `jv update` to update workspace status

      invalid_move:
        no_target: |
          You did not specify a target address for the mapping `%{path}` to move to!
          Please use `jv move <mapping> <target_mapping>` to move the mapping
          or use `jv move <mapping> --erase` to erase the mapping

        duplicate_mapping: |
          Move operation failed because target path `%{path}` already has a mapping!
          Please change to another path, or erase the existing mapping first

      unknown: |
        Unknown move operation result!

jvii:
  hints: |
    [^S WRITE] [ESC EXIT]

  errors:
    no_file_path: "Error: No file path provided"
    editor_error: "Editor error: %{error}"
    file_error: "File error: %{error}"
    file_not_found: "File does not exist: %{path}"
    not_a_file: "Path is not a file: %{path}"
    init_error: "Failed to initialize editor: %{error}"
    raw_mode_error: "Failed to enable raw mode: %{error}"
    alternate_screen_error: "Failed to enter alternate screen: %{error}"
    save_error: "Failed to save file: %{error}"
    render_error: "Render error: %{error}"

  messages:
    file_saved: "File saved successfully"
    unsaved_changes: "Unsaved changes! Press Ctrl+S to save or Esc again to exit"
    modified: " *"

  status:
    lines: " lines"

editor:
  update_editor: |
    # You are using editor mode to track and update files
    # The following files will be updated:
    # - Adding `#` at the beginning of a line will skip the update,
    # - Fill in the version after the arrow

    %{modified_lines}
    ----------------------------------------------------------------
    # Fill description here, tell others about the changes you made
    %{description}

  modified_line:
    header:
      file_path: |
        # PATH

      old_version: OLD
      new_version: NEW
    content:
      arrow: ->