Remake readme.

2024-05-15 21:21:54 -04:00
42 changed files with 1112 additions and 2424 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -31,14 +31,3 @@ workspace/
 /devdocs/
 /.mc-lists.el
 /eshell/
 /.emacs.desktop
 /.tutor/
 /intelephense/
 /auto-save-list/
 /*.eld
 /.custom.el
 /eca/
 /codeium/
 /places
 /recentf
 /agent/
--- a/21
+++ b/21
@@ -1,4 +1,4 @@
-;; -*- coding: utf-8; lexical-binding: t -*-
+;;-*-coding: utf-8;-*-
 (define-abbrev-table 'mhtml-mode-abbrev-table
  '(
    ("doc" "<!DOCTYPE html>
@@ -14,21 +14,6 @@
    ("doctype" "<!DOCTYPE html>" nil :count 0)
   ))
 (define-abbrev-table 'php-mode-abbrev-table
  '(
    ("actions" "/**
         * Actions
         */" nil :count 6)
    ("asserts" "/**
         * Asserts
         */" nil :count 6)
    ("phpcsdisablelinelenght" "// phpcs:disable Generic.Files.LineLength.TooLong" nil :count 3)
    ("phpcsenablelinelenght" "// phpcs:disable Generic.Files.LineLength.TooLong" nil :count 2)
    ("preparing" "/**
         * Preparing
         */" nil :count 8)
   ))
 (define-abbrev-table 'web-mode-abbrev-table
  '(
    ("doc" "<!DOCTYPE html>
@@ -40,7 +25,7 @@
  </head>
  <body>
  </body>
-</html>" nil :count 10)
+</html>" nil :count 9)
-    ("doctype" "<!DOCTYPE html>" nil :count 2)
+    ("doctype" "<!DOCTYPE html>" nil :count 1)
   ))
--- a/configs/gptel-agents/README.md
+++ b/configs/gptel-agents/README.md
@@ -1,30 +0,0 @@
 # gptel-agents
 Agentes y prompts internos para `gptel-agent`, portados de [opencode](https://opencode.ai) (MIT).
 ## Estructura
 - `gptel-agent.md` — port del agente **build** de opencode (agente por defecto; sobreescribe el preset `gptel-agent` del paquete).
 - `gptel-plan.md` — port del agente **plan** de opencode (solo lectura; sobreescribe el preset `gptel-plan`).
 - `explore.md` — subagente explorador de codebases (port de opencode `explore`).
 - `general.md` — subagente de propósito general para tareas paralelas.
 - `prompts/` — prompts internos copiados de `packages/opencode/src/agent/prompt/`:
  - `compaction.txt` — usado como `gptel-agent-compact-prompt`.
  - `title.txt`, `summary.txt`, `explore.txt` — copiados para referencia (opencode es MIT).
 ## Notas
 - Estos archivos se añaden al **final** de `gptel-agent-dirs` para que la precedencia
  (el último dir gana) sobreescriba los agentes por defecto del paquete `gptel-agent`.
 - Los `{{AGENTS}}`/`{{SKILLS}}` del cuerpo se expanden automáticamente por `gptel-agent`.
 - Las tools LSP (`lsp_diagnostics` y `lsp_symbols`, basadas en eglot/flymake),
  `apply_patch` (diff unificado vía `patch`) y `plan_write` (guarda planes
  fuera del proyecto, en `kj-gptel-plans-dir` con nombre `<hash>--<proyecto>--<plan>.md`)
  se definen en `configs/init-ai.el` y se referencian desde los
  agentes correspondientes.
 - `confirm-tool-calls`: build y general usan `auto` (confirmación por tool);
  plan y explore usan `false` (solo lectura, sin confirmar cada lectura).
 - Comandos (en `configs/init-ai.el`): `M-x kj-gptel-opencode-summary`
  (resumen tipo PR con `prompts/summary.txt`) y `M-x kj-gptel-opencode-title`
  (título con `prompts/title.txt`). `kj-gptel-opencode-small-model` permite
  usar un modelo pequeño si existe en el backend activo.
--- a/configs/gptel-agents/explore.md
+++ b/configs/gptel-agents/explore.md
@@ -1,34 +0,0 @@
 ---
 name: explore
 description: >
  Fast agent specialized for exploring codebases. Use this when you need to
  quickly find files by patterns (eg. "src/components/**/*.tsx"), search code
  for keywords (eg. "API endpoints"), or answer questions about the codebase.
  Specify the desired thoroughness level: "quick", "medium" or "very thorough".
 tools:
  - Glob
  - Grep
  - Read
  - Bash
  - WebSearch
  - WebFetch
 confirm-tool-calls: false
 ---
 You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
 Your strengths:
 - Rapidly finding files using glob patterns
 - Searching code and text with powerful regex patterns
 - Reading and analyzing file contents
 Guidelines:
 - Use Glob for broad file pattern matching
 - Use Grep for searching file contents with regex
 - Use Read when you know the specific file path you need to read
 - Use Bash for file operations like copying, moving, or listing directory contents
 - Adapt your search approach based on the thoroughness level specified by the caller
 - Return file paths as absolute paths in your final response
 - For clear communication, avoid using emojis
 - Do not create any files, or run bash commands that modify the user's system state in any way
 Complete the user's search request efficiently and report your findings clearly.
--- a/configs/gptel-agents/general.md
+++ b/configs/gptel-agents/general.md
@@ -1,35 +0,0 @@
 ---
 name: general
 description: >
  General-purpose agent for researching complex questions and executing
  multi-step tasks. Use this agent to execute multiple units of work in parallel.
 tools:
  - Agent
  - TodoWrite
  - Glob
  - Grep
  - Read
  - Insert
  - Edit
  - Write
  - Mkdir
  - Eval
  - Bash
  - WebSearch
  - WebFetch
  - YouTube
  - Skill
  - lsp_diagnostics
  - lsp_symbols
 confirm-tool-calls: auto
 ---
 <role_and_behavior>
 You are a general-purpose agent. Your task is to complete concrete units of work autonomously and reliably, returning clear results.
 - Execute the tasks you are given with the resources available: read/edit files, run commands and search for information.
 - Use `TodoWrite` for multi-step tasks and keep it updated.
 - Use the relevant skills when they apply.
 - Return a concise summary of what was done, in the user's language.
 {{SKILLS}}
 </role_and_behavior>
--- a/configs/gptel-agents/gptel-agent.md
+++ b/configs/gptel-agents/gptel-agent.md
@@ -1,62 +0,0 @@
 ---
 name: gptel-agent
 description: The default agent. Executes tools based on configured permissions.
 tools:
  - Agent
  - TodoWrite
  - Glob
  - Grep
  - Read
  - Insert
  - Edit
  - Write
  - Mkdir
  - Eval
  - Bash
  - WebSearch
  - WebFetch
  - YouTube
  - Skill
  - lsp_diagnostics
  - lsp_symbols
 confirm-tool-calls: auto
 ---
 <role_and_behavior>
 You are a coding agent that works directly on the filesystem at the project root. You can read, edit and create files, run shell commands, search the code and delegate to subagents.
 - Keep responses concise and in the user's language.
 - Prioritize accuracy over being agreeable; challenge the user constructively when you know a better approach.
 - Never use shell tools to communicate: return text directly to the user.
 - Do not write documentation files unless asked to.
 <critical_thinking>
 - Before executing, consider if there's a better way to accomplish the task.
 - Think about the larger problem - does the task need to be done this way at all?
 - Investigate to find truth before confirming beliefs.
 </critical_thinking>
 <tool_usage_policy>
 When working on tasks, follow these guidelines:
 - Use `TodoWrite` for any multi-step work (3+ steps) and keep it updated.
 - Use `Glob` to search files by pattern, `Grep` to search contents, `Read` to read, and `Edit`/`Insert`/`Write` to modify. Reserve `Bash` for git, builds, tests, package managers and system operations; do not use `Bash` for file operations that have their own tool.
 - Run multiple tools in parallel when they are independent.
 - After making changes, verify your work: run the tests or close the loop as appropriate.
 - Use the available skills when relevant to the task.
 {{SKILLS}}
 <tool name="Agent">
 **When to delegate with `Agent` (subagents with separate context):**
 - Open-ended code or web research → delegate to the exploration/research agent.
 - Well-defined multi-step tasks that would bloat your context → delegate to the executor agent.
 - Understanding Emacs/elisp APIs or state → delegate to the introspection agent.
 - Explore first; if the search work is extensive (3+ files or several rounds), delegate instead of filling your context.
 Delegate early and trust subagent results, integrating them into your response.
 **Available agents:**
 {{AGENTS}}
 </tool>
 </tool_usage_policy>
 </role_and_behavior>
--- a/configs/gptel-agents/gptel-plan.md
+++ b/configs/gptel-agents/gptel-plan.md
@@ -1,49 +0,0 @@
 ---
 name: gptel-plan
 description: >
  Plan mode (ported from opencode's "plan" agent). Read-only: analyzes the
  context and proposes a detailed implementation plan without editing files.
 tools:
  - Agent
  - Glob
  - Grep
  - Read
  - WebSearch
  - WebFetch
  - YouTube
  - Skill
  - lsp_diagnostics
  - lsp_symbols
  - plan_write
 confirm-tool-calls: false
 ---
 <role_and_behavior>
 You are a planning agent. Your job is to produce clear, actionable implementation plans. You have read-only tools: you cannot modify files or run code, only explore and analyze.
 - Keep responses concise and in the user's language.
 - Before planning, understand the problem deeply and explore the actual code.
 - Consider multiple approaches and their trade-offs; recommend one with justification.
 <planning_methodology>
 1. **Understand the request**: main goal, constraints and ambiguities.
 2. **Gather context**: explore relevant files with your read-only tools; delegate extensive exploration to a research subagent when the context is large.
 3. **Analyze approaches**: options, trade-offs (complexity, maintainability, risk), and the most suitable one.
 4. **Create the plan**: logical, concrete steps, affected files, dependencies, testing requirements and open decisions.
 5. **Present the plan**: recommended approach, clear steps, considerations and risks.
 </planning_methodology>
 <tool_usage_policy>
 - Use `Glob`, `Grep`, `Read`, `WebSearch` and `WebFetch` to explore.
 - For extensive exploration, delegate to the research/introspection agent; not to executor agents.
 - Do NOT edit, write or execute: your output is a plan for someone else to execute.
 <tool name="Agent">
 **When to delegate:** extensive code research, "how does X work", or exploration that would bloat your context.
 **Do not delegate to executor agents**: you are planning, not executing.
 **Available agents:**
 {{AGENTS}}
 </tool>
 {{SKILLS}}
 </tool_usage_policy>
--- a/configs/gptel-agents/prompts/compaction.txt
+++ b/configs/gptel-agents/prompts/compaction.txt
@@ -1,9 +0,0 @@
 You are an anchored context summarization assistant for coding sessions.
 Summarize only the conversation history you are given. The newest turns may be kept verbatim outside your summary, so focus on the older context that still matters for continuing the work.
 If the prompt includes a <previous-summary> block, treat it as the current anchored summary. Update it with the new history by preserving still-true details, removing stale details, and merging in new facts.
 Always follow the exact output structure requested by the user prompt. Keep every section, preserve exact file paths and identifiers when known, and prefer terse bullets over paragraphs.
 Do not answer the conversation itself. Do not mention that you are summarizing, compacting, or merging context. Respond in the same language as the conversation.
--- a/configs/gptel-agents/prompts/explore.txt
+++ b/configs/gptel-agents/prompts/explore.txt
@@ -1,18 +0,0 @@
 You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
 Your strengths:
 - Rapidly finding files using glob patterns
 - Searching code and text with powerful regex patterns
 - Reading and analyzing file contents
 Guidelines:
 - Use Glob for broad file pattern matching
 - Use Grep for searching file contents with regex
 - Use Read when you know the specific file path you need to read
 - Use Bash for file operations like copying, moving, or listing directory contents
 - Adapt your search approach based on the thoroughness level specified by the caller
 - Return file paths as absolute paths in your final response
 - For clear communication, avoid using emojis
 - Do not create any files, or run bash commands that modify the user's system state in any way
 Complete the user's search request efficiently and report your findings clearly.
--- a/configs/gptel-agents/prompts/summary.txt
+++ b/configs/gptel-agents/prompts/summary.txt
@@ -1,11 +0,0 @@
 Summarize what was done in this conversation. Write like a pull request description.
 Rules:
 - 2-3 sentences max
 - Describe the changes made, not the process
 - Do not mention running tests, builds, or other validation steps
 - Do not explain what the user asked for
 - Write in first person (I added..., I fixed...)
 - Never ask questions or add new questions
 - If the conversation ends with an unanswered question to the user, preserve that exact question
 - If the conversation ends with an imperative statement or request to the user (e.g. "Now please run the command and paste the console output"), always include that exact request in the summary
--- a/configs/gptel-agents/prompts/title.txt
+++ b/configs/gptel-agents/prompts/title.txt
@@ -1,44 +0,0 @@
 You are a title generator. You output ONLY a thread title. Nothing else.
 <task>
 Generate a brief title that would help the user find this conversation later.
 Follow all rules in <rules>
 Use the <examples> so you know what a good title looks like.
 Your output must be:
 - A single line
 - ≤50 characters
 - No explanations
 </task>
 <rules>
 - you MUST use the same language as the user message you are summarizing
 - Title must be grammatically correct and read naturally - no word salad
 - Never include tool names in the title (e.g. "read tool", "bash tool", "edit tool")
 - Focus on the main topic or question the user needs to retrieve
 - Vary your phrasing - avoid repetitive patterns like always starting with "Analyzing"
 - When a file is mentioned, focus on WHAT the user wants to do WITH the file, not just that they shared it
 - Keep exact: technical terms, numbers, filenames, HTTP codes
 - Remove: the, this, my, a, an
 - Never assume tech stack
 - Never use tools
 - NEVER respond to questions, just generate a title for the conversation
 - The title should NEVER include "summarizing" or "generating" when generating a title
 - DO NOT SAY YOU CANNOT GENERATE A TITLE OR COMPLAIN ABOUT THE INPUT
 - Always output something meaningful, even if the input is minimal.
 - If the user message is short or conversational (e.g. "hello", "lol", "what's up", "hey"):
  → create a title that reflects the user's tone or intent (such as Greeting, Quick check-in, Light chat, Intro message, etc.)
 </rules>
 <examples>
 "debug 500 errors in production" → Debugging production 500 errors
 "refactor user service" → Refactoring user service
 "why is app.js failing" → app.js failure investigation
 "implement rate limiting" → Rate limiting implementation
 "how do I connect postgres to my API" → Postgres API connection
 "best practices for React hooks" → React hooks best practices
 "@src/auth.ts can you add refresh token support" → Auth refresh token support
 "@utils/parser.ts this is broken" → Parser bug fix
 "look at @config.json" → Config review
 "@App.tsx add dark mode toggle" → Dark mode toggle in App
 </examples>
--- a/configs/init-ai.el
+++ b/configs/init-ai.el
@@ -1,253 +0,0 @@
 ;;; init-ai.el --- Configuración de inteligencias artificales  -*- lexical-binding: t -*-
 ;; Author: kj <webmaster@outcontrol.net>
 ;; URL: https://git.kj2.me/kj/confi-emacs-actual
 ;;; Commentary:
 ;; Configuración para Inteligencia artifical en Emacs.
 ;;; Code:
 ;; Cliente LLM (ollama, chatgpt, gemini, etc.)
 (use-package gptel
  :defer nil
  :config
  (when (getenv "GEMINI_KEY")
    (gptel-make-gemini "Gemini"
      :key (getenv "GEMINI_KEY")
      :stream t))
  (gptel-make-openai "llama.cpp"
    :stream t
    :protocol "http"
    :host "127.0.0.1:1945"
    :models '("Qwen3.8-27B"
              "gemma-4-12B"
              "gemma-4-E2B"
              "gemma-4-E4B"
              "gptoss-20b"))
  (gptel-make-ollama "Ollama"
    :host "localhost:11434"
    :stream t
    :request-params '(:think :json-false)
    :models '("gemma4:31b-cloud"
              "glm-5.1:cloud"
              "kimi-k2.6:cloud"
              "gpt-oss:20b-cloud"
              "minimax-m2.5:cloud"
              "qwen3-coder-next:cloud"))
  ;; Backend opencode-go: suscripción OpenCode Go vía endpoint OpenAI-compatible
  (defun kj-opencode-go-key ()
    "Return the OpenCode Go API key from opencode's auth file."
    (let ((auth (with-temp-buffer
                  (insert-file-contents "~/.local/share/opencode/auth.json")
                  (json-parse-buffer :object-type 'alist))))
      (alist-get 'key (alist-get 'opencode-go auth))))
  (defvar-local kj-opencode-session-id nil
    "Stable OpenCode session id for this conversation buffer.")
  (defun kj-opencode-go-new-session-id ()
    "Generate a new stable-enough random id for x-opencode-session."
    (md5 (format "opencode-go-%s-%s" (random) (float-time))))
  (defun kj-opencode-go-session-id (info)
    "Return a stable x-opencode-session id for the buffer in INFO."
    (let ((buf (or (plist-get info :buffer) (current-buffer))))
      (if (buffer-live-p buf)
          (with-current-buffer buf
            (or kj-opencode-session-id
                (setq-local kj-opencode-session-id
                            (kj-opencode-go-new-session-id))))
        (kj-opencode-go-new-session-id))))
  (defun kj-opencode-go-header (info)
    "Auth plus per-conversation session header for the OpenCode Go backends."
    (append
     (when-let* ((key (gptel--get-api-key)))
       `(("Authorization" . ,(concat "Bearer " key))))
     `(("x-opencode-session" . ,(kj-opencode-go-session-id info)))))
  (gptel-make-openai "OpenCode Go"
    :host "opencode.ai"
    :endpoint "/zen/go/v1/chat/completions"
    :key #'kj-opencode-go-key
    :header #'kj-opencode-go-header
    :stream t
    :models '(minimax-m3 minimax-m2.7 minimax-m2.5
                         kimi-k3 kimi-k2.7-code kimi-k2.6 longcat-2.0 kimi-k2.5
                         glm-5.3-flash glm-5.3 glm-5.2 glm-5.1 glm-5
                         deepseek-v4-pro deepseek-v4-flash deepseek-v4-flash-vision-exp
                         qwen3.8-max qwen3.7-max qwen3.7-plus qwen3.6-plus qwen3.5-plus
                         mimo-v2-pro mimo-v2-omni mimo-v2.5-pro mimo-v2.5
                         hy3 hy3-preview
                         gpt-5.6-luna grok-4.5 grok-4.6
                         muse-spark-1.2-contributor))
  ;; Modelos gratuitos de OpenCode Go, servidos vía el endpoint /zen/v1
  (gptel-make-openai "OpenCode Free"
    :host "opencode.ai"
    :endpoint "/zen/v1/chat/completions"
    :key #'kj-opencode-go-key
    :header #'kj-opencode-go-header
    :stream t
    :models '(big-pickle deepseek-v4-flash-free muse-spark-1.2-contributor-free
                         mimo-v2.5-free hy3-free nemotron-3-ultra-free
                         nemotron-3.5-lightning-free laguna-s-2.1-free))
  ;; Backend y modelo por defecto
  (setq gptel-backend (gptel-get-backend "OpenCode Go")
        gptel-model 'mimo-v2.5-free)
  (setq gptel-default-mode 'markdown-mode
        gptel-prompt-prefix-alist
        '((markdown-mode . "# User\n\n")
          (org-mode . "* User\n\n")
          (text-mode . "# User\n\n"))
        gptel-response-prefix-alist
        '((markdown-mode . "# AI\n\n")
          (org-mode . "* AI\n\n")
          (text-mode . "# AI\n\n"))
        gptel-directives
        '((default . "You are a large language model living in Emacs and a helpful assistant. Respond concisely in Spanish."))
        )
  (add-hook 'gptel-post-response-functions 'gptel-end-of-response)
  ;; El "thinking" de los modelos se muestra en los buffers gptel.
  ;; `ignore' (valor por defecto de gptel) lo muestra pero NO lo reenvía
  ;; al modelo en turnos posteriores (recomendado: evita llenar el
  ;; contexto, ver NEWS de gptel).  Usar `t' si además se quiere
  ;; reenviarlo y `nil' para deshabilitarlo (útil para respuestas mas rápidas).
  (setopt gptel-include-reasoning 'ignore)
  (defun gptel-switch+model ()
    "Switch to gptel backend and model in a single completion prompt."
    (interactive)
    (let (choices)
      (dolist (pair gptel--known-backends)
        (let* ((backend-name (car pair))
               (backend (cdr pair))
               (models
                (and (fboundp 'gptel-backend-models)
                     (gptel-backend-models backend))))
          (when models
            (dolist (model models)
              (push (cons ; (format "%s:%s" backend-name model)
                     (format "%s → %s"
                             (propertize backend-name 'face 'font-lock-keyword-face)
                             (propertize (symbol-name model) 'face 'font-lock-function-name-face))
                     (cons backend-name model))
                    choices)))))
      (let* ((choice
              (completing-read "Model: " (mapcar #'car choices) nil t))
             (sel (cdr (assoc choice choices))))
        (setq gptel-backend (cdr (assoc (car sel) gptel--known-backends))
              gptel-model (cdr sel))
        (message "gptel set to %s:%s" (car sel) (cdr sel)))))
  )
 ;; (use-package copilot
 ;;   :hook (prog-mode . copilot-mode)
 ;;   :bind (:map copilot-completion-map
 ;;               ("C-g" . 'copilot-clear-overlay)
 ;;               ("C-<return>" . 'copilot-accept-completion)
 ;;               ("S-<return>" . 'copilot-accept-completion-by-word)))
 (use-package gptel-magit
  :ensure t
  :hook (magit-mode . gptel-magit-install)
  :config
  ;; gptel-magit no sabe manejar el contenido de "reasoning": gptel entrega
  ;; el thinking al callback como (reasoning . TEXTO) y gptel-magit lo
  ;; inserta como si fuera la respuesta final, fallando con
  ;;   Wrong type argument: char-or-string-p, (reasoning . "...")
  ;; (https://github.com/ragnard/gptel-magit/issues/8).  Esto ocurre
  ;; aunque `gptel-include-reasoning' sea nil, porque gptel entrega las
  ;; celdas (reasoning . ...) al callback de forma incondicional (solo
  ;; controla si se insertan en el buffer gptel y si se reenvían).
  ;; En vez de deshabilitar el thinking globalmente, sanitizamos la
  ;; respuesta en el callback: se descartan las celdas de reasoning y solo
  ;; se deja pasar la respuesta final (string).  Así el thinking sigue
  ;; activo en las sesiones gptel normales.
  (defun kj-gptel-magit--string-response-callback (callback)
    "Return a callback that forwards only string responses to CALLBACK.
 Discards the (reasoning . TEXT) cells through which gptel delivers the
 thinking content to the callback (see `gptel-request')."
    (lambda (response &rest args)
      (when (stringp response)
        (apply callback response args))))
  (defun kj-gptel-magit--sanitize-callback (orig-fn &rest args)
    "Around advice for `gptel-magit--request'.
 Wraps the :callback argument of ARGS so that responses with reasoning
 content do not break gptel-magit."
    (let ((pos (cl-position :callback args)))
      (when (and pos (functionp (nth (1+ pos) args)))
        (setf (nth (1+ pos) args)
              (kj-gptel-magit--string-response-callback
               (nth (1+ pos) args)))))
    (apply orig-fn args))
  (advice-add 'gptel-magit--request :around
              #'kj-gptel-magit--sanitize-callback))
 (use-package gptel-autocomplete
  :defer nil
  :ensure (:host github :repo "JDNdeveloper/gptel-autocomplete")
  :bind (("M-<return>" . gptel-complete)
         :map gptel-autocomplete-completion-map
         ("C-<return>" . gptel-accept-completion)))
 (use-package macher
  :ensure (:host github :repo "kmontag/macher")
  :custom
  (macher-action-buffer-ui 'org))
 ;; agent-shell: interfaz nativa de Emacs para interactuar con agentes ACP
 (use-package shell-maker)
 (use-package acp)
 (use-package agent-shell
  :after (shell-maker acp)
  :hook (elpaca-after-init . (lambda () (defalias 'opencode #'agent-shell-opencode-start-agent)))
  :config
  (setq agent-shell-opencode-authentication
        (agent-shell-opencode-make-authentication :none t))
  (setq agent-shell-opencode-default-model-id "opencode-go/qwen3.8-flash")
  ;; Header compacto
  (setq agent-shell-header-style 'text)
  ;; Restaurar sesiones con texto completo
  (setq agent-shell-session-restore-verbosity 'full)
  ;; Desactivar guardado de transcripciones y prompt al cerrar
  (setq agent-shell-transcript-file-path-function nil)
  (setq shell-maker-prompt-before-killing-buffer nil)
  ;; Centralizar datos de agent-shell (screenshots, transcripts, worktrees)
  ;; para que no cree .agent-shell/ dentro de los proyectos
  (setq agent-shell-dot-subdir-function
        (lambda (subdir)
          (expand-file-name subdir
                            (expand-file-name "agent-shell/" user-emacs-directory))))
  ;; Quitar cape-dabbrev, cape-history, comint-completion-at-point y el centinela t
  ;; de agent-shell (evita autocompletar texto del buffer o historial de prompts previos)
  (add-hook 'agent-shell-mode-hook
            (lambda ()
              (remove-hook 'completion-at-point-functions #'cape-dabbrev t)
              (remove-hook 'completion-at-point-functions #'cape-history t)
              (remove-hook 'completion-at-point-functions #'comint-completion-at-point t)
              (setq-local completion-at-point-functions
                          (delq t completion-at-point-functions))
              (setq-local corfu-auto nil))
            t)  ;; :append para correr DESPUÉS de que agent-shell configure sus CAPFs
  )
 (provide 'init-ai)
 ;;; init-ai.el ends here
--- a/configs/init-base.el
+++ b/configs/init-base.el
@@ -6,11 +6,10 @@
 ;;; Commentary:
 ;; Configuración general de Emacs.
 ;; No incluye paquetes/extensiones, solo configuraciones generales.
 ;;; Code:
 (require 'init-functions)
 ;; Native compilation
 (when (and (fboundp 'native-comp-available-p)
           (native-comp-available-p))
@@ -20,119 +19,131 @@
    (setq package-native-compile t)
    ))
-;; Custom configs file
+;; Instalar elpaca.el (reemplpazando package.el)
-(setq custom-file (concat user-emacs-directory ".custom.el"))
+(defvar elpaca-installer-version 0.7)
-(add-hook 'elpaca-after-init-hook (lambda () (load custom-file 'noerror)))
+(defvar elpaca-directory (expand-file-name "elpaca/" user-emacs-directory))
 (defvar elpaca-builds-directory (expand-file-name "builds/" elpaca-directory))
 (defvar elpaca-repos-directory (expand-file-name "repos/" elpaca-directory))
 (defvar elpaca-order '(elpaca :repo "https://github.com/progfolio/elpaca.git"
                              :ref nil
                              :files (:defaults "elpaca-test.el" (:exclude "extensions"))
                              :build (:not elpaca--activate-package)))
 (let* ((repo  (expand-file-name "elpaca/" elpaca-repos-directory))
       (build (expand-file-name "elpaca/" elpaca-builds-directory))
       (order (cdr elpaca-order))
       (default-directory repo))
  (add-to-list 'load-path (if (file-exists-p build) build repo))
  (unless (file-exists-p repo)
    (make-directory repo t)
    (when (< emacs-major-version 28) (require 'subr-x))
    (condition-case-unless-debug err
        (if-let ((buffer (pop-to-buffer-same-window "*elpaca-bootstrap*"))
                 ((zerop (call-process "git" nil buffer t "clone"
                                       (plist-get order :repo) repo)))
                 ((zerop (call-process "git" nil buffer t "checkout"
                                       (or (plist-get order :ref) "--"))))
                 (emacs (concat invocation-directory invocation-name))
                 ((zerop (call-process emacs nil buffer nil "-Q" "-L" "." "--batch"
                                       "--eval" "(byte-recompile-directory \".\" 0 'force)")))
                 ((require 'elpaca))
                 ((elpaca-generate-autoloads "elpaca" repo)))
            (progn (message "%s" (buffer-string)) (kill-buffer buffer))
          (error "%s" (with-current-buffer buffer (buffer-string))))
      ((error) (warn "%s" err) (delete-directory repo 'recursive))))
  (unless (require 'elpaca-autoloads nil t)
    (require 'elpaca)
    (elpaca-generate-autoloads "elpaca" repo)
    (load "./elpaca-autoloads")))
 (add-hook 'after-init-hook #'elpaca-process-queues)
 (elpaca `(,@elpaca-order))
-;; Garbage Collector Magic Hack
+;; Instalar use-package si no está instalado
-(use-package gcmh
+(elpaca elpaca-use-package
-  :diminish
+  ;; Enable :elpaca use-package keyword.
-  :hook (emacs-startup . gcmh-mode)
+  (elpaca-use-package-mode)
-  :init
+  ;; Assume :elpaca t unless otherwise specified.
-  (setq gcmh-idle-delay 'auto
+  (setq elpaca-use-package-by-default t))
        gcmh-auto-idle-delay-factor 10
        gcmh-high-cons-threshold #x1000000)) ; 16MB
-;; Guardar la posición del cursor en un archivo para volver allí cuando se lo vuelva a abrir.
+;; Block until current queue processed.
-(use-package saveplace
+(elpaca-wait)
  :ensure nil
  :hook (after-init . save-place-mode))
 ;; Recentf - Guarda registro de los archivos abiertos recientemente
 (use-package recentf
  :ensure nil
  :bind (("C-x C-r" . recentf-open-files))
  :hook (after-init . recentf-mode)
  :init (setq recentf-max-saved-items 300
              recentf-exclude
              '("\\.?cache" ".cask" "url" "COMMIT_EDITMSG\\'" "bookmarks"
                "\\.\\(?:gz\\|gif\\|svg\\|png\\|jpe?g\\|bmp\\|xpm\\)$"
                "\\.?ido\\.last$" "\\.revive$" "/G?TAGS$" "/.elfeed/"
                "^/tmp/" "^/var/folders/.+$" "^/ssh:" "/persp-confs/"
                (lambda (file) (file-in-directory-p file package-user-dir))))
  :config
  (push (expand-file-name recentf-save-file) recentf-exclude)
  (add-to-list 'recentf-filename-handlers #'abbreviate-file-name))
 ;; Guarda el historial del minibuffer
 (use-package savehist
  :ensure nil
  :hook (after-init . savehist-mode)
  :init (setq enable-recursive-minibuffers t ; Allow commands in minibuffers
              history-length 1000
              savehist-additional-variables '(mark-ring
                                              global-mark-ring
                                              search-ring
                                              regexp-search-ring
                                              extended-command-history)
              savehist-autosave-interval 300))
 ;; Misc.
 (use-package simple
  :ensure nil
  :hook ((after-init . size-indication-mode)
         (before-save . delete-trailing-whitespace)
         (text-mode . visual-line-mode))
  :init
  (setq column-number-mode t
        line-number-mode t
        kill-whole-line t               ; Kill line including '\n' (C-k)
        line-move-visual nil
        track-eol t                     ; Keep cursor at end of lines. Require line-move-visual is nil.
        set-mark-command-repeat-pop t)  ; Repeating C-SPC after popping mark pops it again
  ;; Automatically reload files changed on disk
  (global-auto-revert-mode 1) ;; buffers
  (setq global-auto-revert-non-file-buffers t) ;; dired
  ;;      auto-revert-verbose nil) ;; disable notifications
  ;; Visualize TAB, (HARD) SPACE, NEWLINE
  (setq-default show-trailing-whitespace nil ; Don't show trailing whitespace by default
                cursor-type 'bar)            ; Usar la barrita como cursor
  (setq show-trailing-whitespace t))
 (defconst private-dir  (expand-file-name "private" user-emacs-directory))
 (defconst temp-dir (format "%s/cache" private-dir)
  "Hostname-based elisp temp directories.")
 ;; UTF-8 please
-(when (fboundp 'set-charset-priority)
+(set-charset-priority 'unicode)
-  (set-charset-priority 'unicode))
+(setq locale-coding-system   'utf-8)   ; pretty
-(set-language-environment "UTF-8")
+(set-terminal-coding-system  'utf-8)   ; pretty
-(set-default-coding-systems 'utf-8)
+(set-keyboard-coding-system  'utf-8)   ; pretty
-(set-buffer-file-coding-system 'utf-8)
+(set-selection-coding-system 'utf-8)   ; please
-(set-clipboard-coding-system 'utf-8)
+(prefer-coding-system        'utf-8)   ; with sugar on top
-(set-file-name-coding-system 'utf-8)
+(setq default-process-coding-system '(utf-8-unix . utf-8-unix))
 (set-keyboard-coding-system 'utf-8)
 (set-next-selection-coding-system 'utf-8)
 (set-selection-coding-system 'utf-8)
 (set-terminal-coding-system 'utf-8)
 (setq locale-coding-system 'utf-8)
 (setq system-time-locale "C")
-;; Misc
+;; Emacs customizations
-(if (boundp 'use-short-answers)
+(when (display-graphic-p)
-    (setq use-short-answers t)
+  (scroll-bar-mode -1)                          ; Quitar scrollbar.
-  (fset 'yes-or-no-p 'y-or-n-p))
+  )
-(setq-default major-mode 'text-mode
+(tooltip-mode -1)                               ; Disable tooltips.
-              fill-column 80
+(global-display-line-numbers-mode)              ; Mostar número de línea.
-              tab-width 4
+(show-paren-mode 1)                             ; Habilitar resaltado de brackets.
-              indent-tabs-mode nil)     ; Permanently indent with spaces, never with TABs
+(pending-delete-mode t)                         ; Cuando selecciono un texto y escribo, el texto se borra (emacs por defecto solo escribe donde está el cursor).
 ;; (global-hl-line-mode)                           ; Resaltar línea actual por defecto.
 (setq use-short-answers t)                      ; Usar respuesta cortas (y/n) en lugar de las largas (yes/no)
 (setq-default
 cursor-type 'bar                               ; Usar la barrita como cursor
 cursor-in-non-selected-windows nil             ; Desaparecer el cursor en frames no activos.
 indent-tabs-mode nil                           ; Cambiar tabs por espacios.
 inhibit-startup-message t                      ; Eliminar el mensaje de inicio.
 )
 (setq
 custom-file (concat private-dir "/.custom.el") ; Cabiar la ruta del código que se genera al isntalar un theme o package
 ac-ignore-case nil                             ; Desactivar el autocapitalizado.
 ac-disable-faces nil                           ; Auto-complete hablitado incluso entre comillas (fuente: https://bit.ly/3a9wCB4).
 tags-revert-without-query 1                    ; Recargar tags (ctags) sin pedir confirmación.
 )
 ;; Leve transparencia en emacs por defecto.
 ;; (set-frame-parameter nil 'alpha-background 95)
 ;; Font por defecto
 (set-face-attribute 'default nil :font "Fira Code Retina" :height 112)
-(setq visible-bell t
+;; Backups enabled, use nil to disable
-      inhibit-compacting-font-caches t  ; Don’t compact font caches during GC
+(setq
-      delete-by-moving-to-trash t       ; Deleting files go to OS's trash folder
+ history-length                     1000
-      make-backup-files nil             ; Forbide to make backup files
+ backup-inhibited                   nil
-      auto-save-default nil             ; Disable auto sav
+ make-backup-files                  nil
-      inhibit-splash-screen t
+ auto-save-default                  nil
-      uniquify-buffer-name-style 'post-forward-angle-brackets ; Show path if names are same
+ auto-save-list-file-name           (concat temp-dir "/autosave")
-      adaptive-fill-regexp "[ t]+|[ t]*([0-9]+.|*+)[ t]*"
+ create-lockfiles                   nil
-      adaptive-fill-first-line-regexp "^* *$"
+ backup-directory-alist            `((".*" . ,(concat temp-dir "/backup/")))
-      sentence-end "\\([。！？]\\|……\\|[.?!][]\"')}]*\\($\\|[ \t]\\)\\)[ \t\n]*"
+ auto-save-file-name-transforms    `((".*" ,(concat temp-dir "/auto-save-list/") t)))
      sentence-end-double-space nil
      word-wrap-by-category t)
-;; Async
+;; Configuración cuando es un server
-(use-package async
+(defun setup-daemon ()
-  :functions (async-bytecomp-package-mode dired-async-mode)
+  "Carga la configuración del modo daemon."
-  :init
+  (message "Corriendo en modo daemon.")
-  (async-bytecomp-package-mode 1)
+  (set-face-attribute 'default nil :font "Fira Code Retina" :height 112)
-  (dired-async-mode 1))
+
  ;; Abrir primero el dashboard
  (setq initial-buffer-choice (lambda ()
                                (get-buffer "*dashboard*")
                                (dashboard-refresh-buffer)))
  ;; Cerrar buffers al cerrar emacsclient
  ;; (add-hook 'delete-frame-functions
  ;;           (lambda (frame)
  ;;             (mapc 'kill-buffer (delq (get-buffer "*dashboard*") (buffer-list)))
  ;;             ))
  )
 (if (daemonp)
    (add-hook 'after-make-frame-functions
              (lambda (frame)
                (with-selected-frame frame
                  (setup-daemon))))
  (message "Corriendo en modo normal."))
 (add-hook 'elpaca-after-init-hook (lambda () (load custom-file 'noerror)))
 (provide 'init-base)
 ;;; init-base.el ends here
--- a/configs/init-completion.el
+++ b/configs/init-completion.el
@@ -1,127 +0,0 @@
 ;;; init-completion.el --- Autocompletado con corfu  -*- lexical-binding: t -*-
 ;; Author: kj <webmaster@outcontrol.net>
 ;; URL: https://git.kj2.me/kj/confi-emacs-actual
 ;;; Commentary:
 ;; Archivo de configuración específico para el paquete corfu.
 ;; Corfu, de manera resumida, es el que nos muestra el autocompletado
 ;; en Emacs, tanto para código como para otro tipo de textos.
 ;;
 ;; Este paquete viene a ser una alternativa a Company, por lo
 ;; que no se deberían activar los 2 al mismo tiempo.
 ;;; Code:
 ;; childframe con los cantidatos de autocompletado
 (use-package corfu
  :ensure (:files (:defaults "extensions/*")
                  :includes (corfu-info corfu-history))
  :hook ((elpaca-after-init . global-corfu-mode)
         (global-corfu-mode . corfu-popupinfo-mode))
  :bind (:map corfu-map
              ("<escape>" . corfu-quit)
              ("<SPC>"    . corfu-insert-separator))
  :custom-face
  (corfu-border ((t (:inherit region :background unspecified))))
  :custom
  (corfu-auto t)
  :config
  (global-corfu-mode)
  (setq corfu-popupinfo-delay 0
        corfu-auto-delay 0
        corfu-auto-prefix 2
        corfu-cycle t
        corfu-quit-at-boundary t
        corfu-preview-current nil
        corfu-quit-no-match t)
  (when (< emacs-major-version 29)
    (advice-add 'pcomplete-completions-at-point :around #'cape-wrap-silent)
    (advice-add 'pcomplete-completions-at-point :around #'cape-wrap-purify))
  (corfu-history-mode 1)
  (savehist-mode 1)
  (add-to-list 'savehist-additional-variables 'corfu-history)
  )
 ;; Cambia la forma de mostrar y buscar sugerencias (afecta a corfu, pero también a otros como vertico).
 (use-package orderless
  :after corfu
  :custom
  (completion-styles '(orderless))      ; Use orderless
  (completion-category-defaults nil)    ; I want to be in control!
  (setq completion-ignore-case  t)
  (completion-category-overrides '((file (styles basic partial-completion orderless))))
  (orderless-matching-styles
   '(orderless-literal
     orderless-prefixes
     orderless-initialism
     orderless-regexp
     orderless-flex                       ; Basically fuzzy finding
     ;; orderless-strict-leading-initialism
     ;; orderless-strict-initialism
     ;; orderless-strict-full-initialism
     ;; orderless-without-literal          ; Recommended for dispatches instead
     ))
  )
 ;; Set de funciones de para las sugerencias de corfu.
 (use-package cape
  :ensure (:host github :repo "minad/cape")
  :after corfu
  :hook (eglot-managed-mode . (lambda()
                                (setq completion-at-point-functions
                                      (list (cape-capf-super
                                             #'eglot-completion-at-point
                                             #'cape-abbrev
                                             #'cape-dabbrev
                                             #'cape-history
                                             #'cape-dict
                                             #'cape-file
                                             #'cape-keyword)))))
  :bind (("C-c c f" . cape-file)
         ("C-c c l" . cape-line))
  :init
  (setq text-mode-ispell-word-completion nil)
  ;; (add-to-list 'completion-at-point-functions #'cape-line)     ;; Completar línea actual en función de lo que dice otras líneas de buffer.
  ;; (add-to-list 'completion-at-point-functions #'cape-tex)      ;; Completar Latex (caracteres unicode).
  (add-to-list 'completion-at-point-functions #'cape-dabbrev)  ;; Completar desde otras la palabras del buffer.
  (add-to-list 'completion-at-point-functions #'cape-abbrev)   ;; Completar desde una abreviaciónes configuradas con add-global-abbrev (añadir abreviación global) o add-mode-abbrev (abreviación para el modo actual).
  (add-to-list 'completion-at-point-functions #'cape-history)  ;; Completar desde el historial de altocompletado
  (add-to-list 'completion-at-point-functions #'cape-dict)     ;; Completar desde un diccionario (por defecto toma el de linux que está en /usr/share/dict/words).
  (add-to-list 'completion-at-point-functions #'cape-file)     ;; Completar rutas de archivos.
  (add-to-list 'completion-at-point-functions #'cape-keyword)  ;; Completar desde keyword del lenguaje.
  :config
  (advice-add 'eglot-completion-at-point :around #'cape-wrap-buster)
  )
 ;; A few more useful configurations...
 (use-package emacs
  :ensure nil
  :custom
  ;; TAB cycle if there are only few candidates
  ;; (completion-cycle-threshold 3)
  ;; Enable indentation+completion using the TAB key.
  ;; `completion-at-point' is often bound to M-TAB.
  (tab-always-indent 'complete)
  ;; Emacs 30 and newer: Disable Ispell completion function. As an alternative,
  ;; try `cape-dict'.
  (text-mode-ispell-word-completion nil)
  ;; Emacs 28 and newer: Hide commands in M-x which do not apply to the current
  ;; mode.  Corfu commands are hidden, since they are not used via M-x. This
  ;; setting is useful beyond Corfu.
  (read-extended-command-predicate #'command-completion-default-include-p))
 ;; Iconos en corfu
 (use-package nerd-icons-corfu
  :after corfu
  :init (add-to-list 'corfu-margin-formatters #'nerd-icons-corfu-formatter))
 (provide 'init-completion)
 ;;; init-completion.el ends here
--- a/configs/init-corfu.el
+++ b/configs/init-corfu.el
@@ -0,0 +1,86 @@
 ;;; init-corfu.el --- Autocompletado con corfu  -*- lexical-binding: t -*-
 ;; Author: kj <webmaster@outcontrol.net>
 ;; URL: https://git.kj2.me/kj/confi-emacs-actual
 ;;; Commentary:
 ;; Archivo de configuración específico para el paquete corfu.
 ;; Corfu, de manera resumida, es el que nos muestra el autocompletado
 ;; en Emacs, tanto para código como para otro tipo de textos.
 ;;
 ;; Este paquete viene a ser una alternativa a Company, por lo
 ;; que no se deberían activar los 2 al mismo tiempo.
 ;;; Code:
 (use-package corfu
  :defer t
  :ensure (:files (:defaults "extensions/*")
                   :includes (corfu-info corfu-history))
  :hook ((elpaca-after-init . global-corfu-mode)
         (corfu-mode . corfu-popupinfo-mode))
  :bind (:map corfu-map
              ("<tab>" . corfu-quit)
              ("<escape>" . corfu-quit)
              ("<SPC>" . corfu-insert-separator))
  :custom
  (corfu-auto t)
  :config
  (setq corfu-popupinfo-delay 0
        corfu-auto-delay 0.5
        corfu-auto-prefix 1
        corfu-cycle t
        corfu-preview-current nil
        corfu-quit-no-match t)
  )
 ;; Cambia la forma de mostrar y buscar sugerencias (afecta a corfu, pero también a otros como vertico).
 (use-package orderless
  :defer t
  :init
  (setq completion-styles '(flex orderless basic)
        completion-category-overrides '((file (styles partial-completion)))))
 ;; Set de funciones de para las sugerencias de corfu.
 (use-package cape
  :defer t
  :ensure (:host github :repo "minad/cape")
  :after corfu
  :bind (("C-c f" . cape-file)
         ("C-c l" . cape-line)
         ("C-c _" . cape-tex))
  :init
  ;; (advice-add 'eglot-completion-at-point :around #'cape-wrap-buster)
  (advice-add #'eglot-completion-at-point :around #'cape-wrap-nonexclusive)
  ;; (add-to-list 'completion-at-point-functions #'cape-line)     ;; Completar línea actual en función de lo que dice otras líneas de buffer.
  ;; (add-to-list 'completion-at-point-functions #'cape-tex)      ;; Completar Latex (caracteres unicode).
  (add-to-list 'completion-at-point-functions #'cape-dict)     ;; Completar desde un diccionario (por defecto toma el de linux que está en /usr/share/dict/words).
  (add-to-list 'completion-at-point-functions #'cape-dabbrev)  ;; Completar desde otras la palabras del buffer.
  (add-to-list 'completion-at-point-functions #'cape-abbrev)   ;; Completar desde una abreviaciónes configuradas con add-global-abbrev (añadir abreviación global) o add-mode-abbrev (abreviación para el modo actual).
  (add-to-list 'completion-at-point-functions #'cape-file)     ;; Completar rutas de archivos.
  (add-to-list 'completion-at-point-functions #'cape-keyword)  ;; Completar desde keyword del lenguaje.
  )
 ;; Hacer que corfu funcione en la terminal
 (unless (display-graphic-p)
  (use-package corfu-terminal
    :after corfu
    :ensure (:repo "https://codeberg.org/akib/emacs-corfu-terminal.git")
    :config
    (corfu-terminal-mode +1))
  )
 ;; Iconos en corfu
 (use-package kind-icon
  :ensure t
  :after corfu
  :custom
  (kind-icon-default-face 'corfu-default) ; to compute blended backgrounds correctly
  :config
  (add-to-list 'corfu-margin-formatters #'kind-icon-margin-formatter))
 (provide 'init-corfu)
 ;;; init-corfu.el ends here
--- a/configs/init-ctags.el
+++ b/configs/init-ctags.el
@@ -0,0 +1,69 @@
 ;;; init-ctags.el --- Configuracíón de TAGS  -*- lexical-binding: t -*-
 ;; Author: kj <webmaster@outcontrol.net>
 ;; URL: https://git.kj2.me/kj/confi-emacs-actual
 ;;; Commentary:
 ;;; Code:
 ;; En esta sección está la configuración para ctags.
 ;; Quizá con la aparición de lsp sea menos necesaria,
 ;; pero dado a que sigue teniendo potencial para aportar
 ;; además de tener un rendimiento muy bueno es mejor
 ;; no dejarla de lado.
 ;; Ctags IDE on the True Editor
 ;; @see https://github.com/universal-ctags/citre#quick-start
 (use-package citre
  :defer t
  :ensure t
  :diminish
  :bind (("C-x c ." . citre-jump)
         ("C-x c ," . citre-jump-back)
         ("C-x c p" . citre-peek)
         ("C-x c a" . citre-ace-peek)
         ("C-x c u" . citre-update-this-tags-file))
  :init
  (setq citre-auto-enable-citre-mode-modes '(prog-mode)
        citre-default-create-tags-file-location 'global-cache
        citre-prompt-language-for-ctags-command t)
  :config
  (with-no-warnings
    ;; Integrate with `lsp-mode' and `eglot'
    (define-advice xref--create-fetcher (:around (fn &rest args) fallback)
      (let ((fetcher (apply fn args))
            (citre-fetcher
             (let ((xref-backend-functions '(citre-xref-backend t)))
               (ignore xref-backend-functions)
               (apply fn args))))
        (lambda ()
          (or (with-demoted-errors "%s, fallback to citre"
                (funcall fetcher))
              (funcall citre-fetcher)))))
    (defun lsp-citre-capf-function ()
      "A capf backend that tries lsp first, then Citre."
      (let ((lsp-result (if (fboundp #'eglot-completion-at-point)
                            (eglot-completion-at-point)
                        (when (fboundp #'lsp-completion-at-point)
                            (lsp-completion-at-point)))))
        (if (and lsp-result
                 (try-completion
                  (buffer-substring (nth 0 lsp-result)
                                    (nth 1 lsp-result))
                  (nth 2 lsp-result)))
            lsp-result
          (citre-completion-at-point))))
    (defun enable-lsp-citre-capf-backend ()
      "Enable the lsp + Citre capf backend in current buffer."
      (add-hook 'completion-at-point-functions #'lsp-citre-capf-function nil t))
    (add-hook 'citre-mode-hook #'enable-lsp-citre-capf-backend)
  ))
 (provide 'init-ctags)
 ;;; init-ctags.el ends here
--- a/configs/init-editor.el
+++ b/configs/init-editor.el
@@ -1,177 +0,0 @@
 ;; init-editor.el --- Initialize editing configurations.	-*- lexical-binding: t -*-
 ;; Copyright (C) 2006-2025 Vincent Zhang
 ;; Author: kj <webmaster@outcontrol.net>
 ;; URL: https://git.kj2.me/kj/confi-emacs-actual
 ;;; Commentary:
 ;;
 ;; Configuración en la edición de texto en general
 ;;
 ;;; Code:
 ;; Visor de documentos de emacs (soporta de todo: epub, pdf, odt, docx, cbz, etc.)
 (use-package doc-view
  :hook
  (doc-view-mode . (lambda ()
                       (display-line-numbers-mode 0)))
  :ensure nil)
 ;; Eliminar cuando está
 (use-package delsel
  :ensure nil
  :hook (elpaca-after-init . delete-selection-mode))
 ;; Minor mode to aggressively keep your code always indented
 (use-package aggressive-indent
  :diminish
  :autoload aggressive-indent-mode
  :functions too-long-file-p
  ;; :hook ((elpaca-after-init . global-aggressive-indent-mode)
  ;;        ;; NOTE: Disable in large files due to the performance issues
  ;;        ;; https://github.com/Malabarba/aggressive-indent-mode/issues/73
  ;;        (find-file . (lambda ()
  ;;                       (when (too-long-file-p)
  ;;                         (aggressive-indent-mode -1)))))
  :config
  ;; Disable in some modes
  (dolist (mode '(gitconfig-mode
                  asm-mode web-mode html-mode
                  css-mode css-ts-mode
                  go-mode go-ts-mode
                  python-ts-mode yaml-ts-mode
                  scala-mode
                  shell-mode term-mode vterm-mode
                  prolog-inferior-mode))
    (add-to-list 'aggressive-indent-excluded-modes mode))
  ;; Disable in some commands
  (add-to-list 'aggressive-indent-protected-commands #'delete-trailing-whitespace t)
  ;; Be slightly less aggressive in C/C++/C#/Java/Go/Swift
  (add-to-list 'aggressive-indent-dont-indent-if
               '(and (derived-mode-p 'c-mode 'c++-mode 'csharp-mode
                                     'java-mode 'go-mode 'swift-mode)
                     (null (string-match "\\([;{}]\\|\\b\\(if\\|for\\|while\\)\\b\\)"
                                         (thing-at-point 'line))))))
 ;; Mover líneas o regiones con M-<teclas de dirección>
 (use-package drag-stuff
  :diminish
  ;; :autoload drag-stuff-define-keys
  :hook (elpaca-after-init . drag-stuff-global-mode)
  :bind (:map drag-stuff-mode-map
              ("M-p" . drag-stuff-up)
              ("M-n" . drag-stuff-down))
  ;; :config
  ;; (add-to-list 'drag-stuff-except-modes 'org-mode)
  ;; (drag-stuff-define-keys)
  )
 ;; A comprehensive visual interface to diff & patch
 (use-package ediff
  :ensure nil
  :hook(;; show org ediffs unfolded
        (ediff-prepare-buffer . outline-show-all)
        )
  :config
  (setq ediff-window-setup-function 'ediff-setup-windows-plain
        ediff-split-window-function 'split-window-horizontally
        ediff-merge-split-window-function 'split-window-horizontally))
 ;; Automatic parenthesis pairing
 (use-package elec-pair
  :ensure nil
  ;; :hook (elpaca-after-init . electric-pair-mode)
  :init (setq electric-pair-inhibit-predicate 'electric-pair-conservative-inhibit))
 ;; Edit multiple regions in the same way simultaneously
 (use-package iedit
  :defines desktop-minor-mode-table
  :bind (("C-;" . iedit-mode)
         ("C-x r RET" . iedit-rectangle-mode)
         :map isearch-mode-map ("C-;" . iedit-mode-from-isearch)
         :map esc-map ("C-;" . iedit-execute-last-modification)
         :map help-map ("C-;" . iedit-mode-toggle-on-function))
  :config
  ;; Avoid restoring `iedit-mode'
  (with-eval-after-load 'desktop
    (add-to-list 'desktop-minor-mode-table
                 '(iedit-mode nil))))
 ;; Seleccionar por regiones (similar a mark-sexp, pero toma en cuenta hacia atrás del cursor también)
 (use-package expand-region
  :functions treesit-buffer-root-node
  :bind ("C-," . er/expand-region)
  :config
  (defun treesit-mark-bigger-node ()
    "Use tree-sitter to mark regions."
    (let* ((root (treesit-buffer-root-node))
           (node (treesit-node-descendant-for-range root (region-beginning) (region-end)))
           (node-start (treesit-node-start node))
           (node-end (treesit-node-end node)))
      ;; Node fits the region exactly. Try its parent node instead.
      (when (and (= (region-beginning) node-start) (= (region-end) node-end))
        (when-let* ((node (treesit-node-parent node)))
          (setq node-start (treesit-node-start node)
                node-end (treesit-node-end node))))
      (set-mark node-end)
      (goto-char node-start)))
  (add-to-list 'er/try-expand-list 'treesit-mark-bigger-node))
 ;; Hungry deletion (Elimina los espacios en blancos consecutivos)
 (use-package hungry-delete
  :diminish
  ;; :hook (elpaca-after-init . global-hungry-delete-mode)
  :init (setq hungry-delete-chars-to-skip " \t\f\v"
              hungry-delete-except-modes
              '(help-mode minibuffer-mode minibuffer-inactive-mode calc-mode)))
 ;; Mejora C-a y C-e para ir a lo que contextualmente sería el fin de la línea
 (use-package mwim
  :bind (([remap move-beginning-of-line] . mwim-beginning)
         ([remap move-end-of-line] . mwim-end)))
 ;; Ayuda a manipular los archivos con líneas demasiado largas
 (use-package so-long
  :ensure nil
  :hook (after-init . global-so-long-mode)
  :bind (:map so-long-mode-map
              ("C-s"    . isearch-forward)
              ("C-r"    . isearch-backward))
  :config
  (setq so-long-variable-overrides
        '((bidi-inhibit-bpa . t)
          (bidi-paragraph-direction . left-to-right)
          (buffer-read-only . nil)
          (global-hl-line-mode . nil)
          (line-move-visual . t)
          (show-paren-mode . nil)
          (truncate-lines . nil)
          (which-func-mode . nil))))
 ;; Generador de texto aleatorio para placeholding
 (use-package lorem-ipsum)
 ;; Corrector ortográfico y de sintaxis avanzado
 (use-package languagetool
  :ensure t
  :defer t
  :commands (languagetool-check
             languagetool-clear-suggestions
             languagetool-correct-at-point
             languagetool-correct-buffer
             languagetool-set-language
             languagetool-server-mode))
 (use-package perspective
  :custom
  (persp-mode-prefix-key (kbd "C-c w"))
  (persp-initial-frame-name "0")
  :init
  (persp-mode))
 (provide 'init-editor)
 ;;; init-editor.el ends here
--- a/configs/init-eglot.el
+++ b/configs/init-eglot.el
@@ -0,0 +1,83 @@
 ;;; init-eglot.el --- Configuración de eglot (LSP)   -*- lexical-binding: t -*-
 ;; Author: kj <webmaster@outcontrol.net>
 ;; URL: https://git.kj2.me/kj/confi-emacs-actual
 ;;; Commentary:
 ;; Este archivo tiene todo lo relacionado con eglot.
 ;; Eglot es un cliente LSP para Emacs que desde la
 ;; versión 29 viene integrado dentro del mismo.
 ;;
 ;; El nombre Eglot es un apócope de "Emacs polyglot"
 ;; ya que con este cliente podemos añadir soporte para
 ;; muchísimos lenguajes, puesto que actualente el que
 ;; un lenguaje tenga su propio LSP es muy normal.
 ;;
 ;; Como añadido:
 ;;
 ;; Un Languaje Server Provider (LSP), es un protocolo
 ;; mediante el cual existen servidores para lenguajes
 ;; en específico, los cuales proveen cosas como el
 ;; autocompletado, linting, documentación, ir a la
 ;; definición, etc.
 ;;
 ;; Este protocolo viene a solucionar el problema de
 ;; que cada herramienta de programación tenga que
 ;; volver a crear su propio soporte para cada uno
 ;; de los lenguajes (DRY).
 ;;; Code:
 (use-package eglot
  :defer t
  ;; :ensure nil
  :hook ((css-mode  . eglot-ensure)
         (html-mode . eglot-ensure)
         (php-mode  . eglot-ensure)
         (rust-mode . eglot-ensure)
         (sh-mode   . eglot-ensure))
  :config
  (setq eglot-sync-connect 0)
 )
 ;; Mejorar la velocidad de eglot (un binario en rust )
 (use-package eglot-booster
  :defer t
  :ensure (:host github :repo "jdtsmith/eglot-booster")
  :after eglot
  :config
  ;;
  (if (executable-find "emacs-lsp-booster")
    (eglot-booster-mode)
  (message "No está instalado emacs-lsp-booster. Eglot se usará de modo normal."))
  )
 ;; Emmet (mientras veo como hacer funcionar emmet-ls)
 (use-package emmet-mode
  :defer t
  :hook
  ((html-mode . emmet-mode)
   (web-mode . emmet-mode))
  )
 ;; Revisar por errores en el código
 (use-package flymake
  :defer t
  :ensure nil
  :hook (prog-mode . (lambda ()
                       (unless (derived-mode-p 'makefile-mode)
                         (flymake-mode))))
  :config
  (remove-hook 'flymake-diagnostic-functions 'flymake-proc-legacy-flymake)
  )
 ;; Mostar los errores de flymake en un popup-tip
 (use-package flymake-diagnostic-at-point
  :defer t
  :ensure t
  :after flymake
  :hook (flymake-mode . flymake-diagnostic-at-point-mode))
 (provide 'init-eglot)
 ;;; init-eglot.el ends here
--- a/configs/init-evil.el
+++ b/configs/init-evil.el
@@ -13,30 +13,25 @@
 ;;; Code:
 (use-package evil
-  :hook ((elpaca-after-init . evil-mode)
+  :defer t
-         (git-timemachine-mode . evil-emacs-state))
+  :hook (elpaca-after-init . evil-mode)
  :init
  (setq evil-want-keybinding nil)
  ;; Habilitar atajos de de tecla de emacs en insert state
  (setq evil-disable-insert-state-bindings t)
  :config
  ;; Configuraciones básicas
  ;; (setq evil-default-state 'emacs) ;; Modo por defecto en emacs
-  ;; (setq evil-default-state 'insert) ;; Modo por defecto en emacs
+  (setq evil-default-state 'insert) ;; Modo por defecto en emacs
  (setq evil-emacs-state-cursor 'bar) ;; Cursor de emacs state en bar
  ;; (setq evil-normal-state-cursor 'bar) ;; Cursor de normal state en bar en lugar de box
  (evil-set-leader 'motion (kbd "SPC")) ;; Leader key
  (evil-set-undo-system 'undo-redo)
-  ;; Arreglar el problemita con corfu-quit y el cambio de modos
+  ;; Habilitar atajos de de tecla de emacs en insert state
-  (evil-define-key 'emacs 'global (kbd "<escape>") '(lambda ()
+  (setq evil-insert-state-map (make-sparse-keymap))
                                                      "Call `corfu-quit' and then return to Normal State."
                                                      (interactive)
                                                      (call-interactively 'corfu-quit)
                                                      (evil-normal-state)))
  ;; (evil-define-key 'normal 'global (kbd "<escape>") 'corfu-quit)
  ;; Cambiar a mode emacs con escape
  ;; (evil-define-key 'emacs 'global (kbd "<escape>") 'evil-normal-state)
  ;; Cambiar Insert state por emacs state.
-  (defalias 'evil-insert-state 'evil-emacs-state)
+  ;; (defalias 'evil-insert-state 'evil-emacs-state)
  ;; Variales locales (todos los estados o solo los estados de VIM)
  (setq all-states '(normal insert visual replace operator motion emacs))
@@ -48,36 +43,37 @@
  ;; Cambiar C-z a deshacer
  (evil-define-key all-states 'global (kbd "C-z") 'undo)
  (evil-define-key all-states 'global (kbd "C-S-z") 'undo-redo)
-  ;; Cambiar U para hacer redo
+  ;; Cambiar C-r a ripgrep y U hasta hacer redo
  (evil-define-key vim-states 'global (kbd "C-r") 'consult-ripgrep)
  (evil-define-key 'normal 'global (kbd "U") 'undo-redo)
  (evil-define-key 'normal 'global (kbd "C-S-z") 'undo-redo)
  (evil-define-key 'normal 'global (kbd "M-.") 'xref-find-definitions)
  ;; Arreglar yank-pop en normal mode
-  ;; (evil-define-key 'normal 'global (kbd "M-y") 'consult-yank-pop)
+  (evil-define-key 'normal 'global (kbd "M-y") 'consult-yank-pop)
  ;; Re-bindear keys a como funcionan en emacs.
-  ;; (evil-define-key 'normal 'global (kbd "C-p") 'previous-line)
+  (evil-define-key 'normal 'global (kbd "C-p") 'previous-line)
-  ;; (evil-define-key 'normal 'global (kbd "C-n") 'next-line)
+  (evil-define-key 'normal 'global (kbd "C-n") 'next-line)
-  ;; (evil-define-key 'normal 'global (kbd "C-e") 'move-end-of-line)
+  (evil-define-key 'normal 'global (kbd "C-e") 'move-end-of-line)
  ;; Navegación entre frames
  (evil-define-key 'motion 'global (kbd "<leader>o") 'other-window)
  ;; Habilitar el scrolear con C-v como en emacs en evil
-  ;; (evil-define-key 'motion 'global (kbd "C-v") 'scroll-up-command)
+  (evil-define-key 'motion 'global (kbd "C-v") 'scroll-up-command)
  ;; Añadir nueva linea sin salir del modo normal
-  ;; (evil-define-key 'motion 'global (kbd "<leader><RET>") 'newline)
+  (evil-define-key 'motion 'global (kbd "<leader><RET>") 'newline)
  ;; Abrir historial del kill-ring/portapapeles
  (evil-define-key vim-states 'global (kbd "<leader>y") 'consult-yank-pop)
  ;; Expand region desde motion states
-  (evil-define-key 'motion 'global (kbd "<leader>=") 'er/expand-region)
+  (evil-define-key 'motion 'global (kbd "<leader>+") 'er/expand-region)
-  ;; Indentado en motion modes.
+  ;; Identado en motion modes.
  (evil-define-key 'motion 'global (kbd "<tab>") 'indent-for-tab-command)
  ;; Atajos con leader key para frames
@@ -92,43 +88,35 @@
  ;; Cambios de modos
  (evil-define-key 'normal 'global (kbd "<leader>mh") 'html-mode)
  (evil-define-key 'normal 'global (kbd "<leader>mj") 'js-mode)
-  (evil-define-key 'normal 'global (kbd "<leader>mp") 'php-ts-mode)
+  (evil-define-key 'normal 'global (kbd "<leader>mp") 'php-mode)
  (evil-define-key 'normal 'global (kbd "<leader>mr") 'rust-mode)
  (evil-define-key 'normal 'global (kbd "<leader>mw") 'web-mode)
  ;; Otros atajos
-  (evil-define-key 'motion 'global (kbd "<leader>b") 'switch-to-buffer)             ;; Cambiar de buffer
+  (evil-define-key 'motion 'global (kbd "<leader>xb") 'consult-buffer)             ;; Cambiar de buffer
-  (evil-define-key 'motion 'global (kbd "<leader>p") 'project-find-file)            ;; Archivos del proyecto (o abrir proyecto si no hay alguno)
+  (evil-define-key 'motion 'global (kbd "<leader>xp") 'consult-project-extra-find) ;; Archivos del proyecto (o abrir proyecto si no hay alguno)
  (evil-define-key 'motion 'global (kbd "<leader>cp") 'project-switch-project)     ;; Cambiar proyecto
-  (evil-define-key 'motion 'global (kbd "<leader>f") 'find-file)                   ;; Abrir archivo
+  (evil-define-key 'motion 'global (kbd "<leader>xf") 'find-file)                  ;; Abrir archivo
  (evil-define-key 'motion 'global (kbd "<leader>xr") 'consult-recent-file)        ;; Lista de archivos recientes
  (evil-define-key 'motion 'global (kbd "<leader>rg") 'consult-ripgrep)            ;; Búsqueda rápida con ripgrep
  (evil-define-key 'motion 'global (kbd "<leader>gi") 'imenu)                      ;; imenu
  (evil-define-key 'motion 'global (kbd "<leader>gg") 'goto-line)                  ;; Ir a la línea.
-  ;; Iniciar en normal state solo en modos específicos
+  ;; Iniciar en normal state si es un lenguaje de programación u org-mode
-  (setq evil-default-state 'emacs) ;; Modo por defecto en emacs
+  ;; (evil-set-initial-state 'prog-mode 'normal)
-  (evil-set-initial-state 'prog-mode 'normal)
+  ;; (evil-set-initial-state 'org-mode 'normal)
  (evil-set-initial-state 'org-mode 'normal)
  (evil-set-initial-state 'text-mode 'normal)
  (evil-set-initial-state 'csv-mode 'normal)
  (evil-set-initial-state 'fundamental-mode 'normal)
  (evil-set-initial-state 'dashboard-mode 'normal)
  (evil-set-initial-state 'dired 'normal)
  (evil-set-initial-state 'vterm-mode 'emacs)
  (evil-set-initial-state 'magit-mode 'emacs)
  (evil-set-initial-state 'git-commit-mode 'emacs)
  )
 ;; Funciones y atajos de teclas especiales para evil cuando estamo en org-mode.
 ;; Por ejemplo, para que evil-open-below funcione similar a org-return cuando
 ;; estamos dentro de una lista.
 (use-package evil-org
  :ensure t
  :defer t
  :after org
  :hook (org-mode . evil-org-mode))
 ;; Similar a Vimtutor, pero para evil.
 (use-package evil-tutor)
 (provide 'init-evil)
 ;;; init-evil.el ends here
--- a/configs/init-functions.el
+++ b/configs/init-functions.el
@@ -15,6 +15,18 @@
  (interactive "nTransparency Value 0 - 100 opaque:")
  (set-frame-parameter nil 'alpha-background value))
 ;; Comentar línea o región
 (defun comment-or-uncomment-region-or-line ()
    "Comments or uncomments the region or the current line."
    (interactive)
    (let (beg end)
        (if (region-active-p)
            (setq beg (region-beginning) end (region-end))
            (setq beg (line-beginning-position) end (line-end-position)))
        (comment-or-uncomment-region beg end)
        ;;(next-line) ;; saltar a la siguiente línea
        ))
 ;; Duplicar la línea actual
 (defun duplicate-current-line (&optional n)
  "Duplicate current line, make more than 1 copy given a numeric (N) argument."
@@ -31,11 +43,22 @@
    	(insert current-line)
    	(decf n)))))
 ;; Borrar espacios, tabs y saltos de línea innecesarios al guardar
 (add-hook 'before-save-hook 'delete-trailing-whitespace)
 ;; Mostrar y ocultar el diff de la línea de git-gutter
 (defun git-gutter:toggle-popup-hunk ()
  "Toggle 'git-gutter' hunk window."
  (interactive)
  (if (and (get-buffer "*git-gutter:diff*") (window-live-p (git-gutter:popup-buffer-window)))
      (delete-window (git-gutter:popup-buffer-window))
    (git-gutter:popup-hunk)))
 ;; Obtener el nombre del proyecto desde project.el
 (defun kj/project-name (&optional project)
  "Return the name for PROJECT.
 If PROJECT is not specified, assume current project root."
-  (when-let* ((root (or project (kj/project-root)))) ;; <-- ¡Aquí está el cambio!
+  (when-let (root (or project (kj/project-root)))
    (file-name-nondirectory
     (directory-file-name
      (file-name-directory root)))))
@@ -43,7 +66,7 @@ If PROJECT is not specified, assume current project root."
 ;; Obtener la raíz del proyecto desde project.el
 (defun kj/project-root ()
  "Return the current project root."
-  (when-let* ((project (project-current)))
+  (when-let (project (project-current))
    (project-root project)))
 ;; Cambia entre ocultar o no la barra de título cuando está maximizado
@@ -66,108 +89,5 @@ If PROJECT is not specified, assume current project root."
  "Run `after-load-theme-hook'."
  (run-hooks 'after-load-theme-hook))
 ;; Devuelve si el archivo es muy grande o no\
 (defun too-long-file-p ()
  "Check whether the file is too long."
  (or (> (buffer-size) 500000)
      (and (fboundp 'buffer-line-statistics)
           (> (car (buffer-line-statistics)) 10000))))
 ;; Renombrar el archivo actual
 (defun rename-this-file (new-name)
  "Renames both current buffer and file it's visiting to NEW-NAME."
  (interactive (list (read-string "New name: "
                                  (file-name-nondirectory
                                   (buffer-file-name)))))
  (let ((name (buffer-name))
        (filename (buffer-file-name)))
    (unless filename
      (error "Buffer '%s' is not visiting a file!" name))
    (progn
      (when (file-exists-p filename)
        (rename-file filename new-name 1))
      (set-visited-file-name new-name)
      (rename-buffer new-name))))
 ;; Copiar el nombre del archivo actual
 (defun copy-filename ()
  "Copy the current buffer file name to the clipboard."
  (interactive)
  (let ((filename (if (equal major-mode 'dired-mode)
                      default-directory
                    (buffer-file-name))))
    (if filename
        (progn
          (kill-new filename)
          (message "Copied '%s'" filename))
      (warn "Current buffer is not attached to a file!"))))
 (defun copy-basename ()
  "Copy the current buffer basename to the clipboard."
  (interactive)
  (let ((filename (if (equal major-mode 'dired-mode)
                      default-directory
                    (file-name-nondirectory (buffer-file-name)))))
    (if filename
        (progn
          (kill-new filename)
          (message "Copied '%s'" filename))
      (warn "Current buffer is not attached to a file!"))))
 ;; Verifica si se puede levantar un childframe
 (defun childframe-workable-p ()
  "Whether childframe is workable."
  (and (not noninteractive)
       (not emacs-basic-display)
       (or (display-graphic-p)
           (featurep 'tty-child-frames))
       (eq (frame-parameter (selected-frame) 'minibuffer) 't)))
 (defun font-installed-p (font-name)
  "Check if font with FONT-NAME is available."
  (find-font (font-spec :name font-name)))
 (defun insert-filename ()
  "Insert the full path file name into the current buffer."
  (interactive)
  (insert (buffer-file-name)))
 (defun insert-basename ()
  "Insert the filename (without path) into the current buffer."
  (interactive)
  (insert (file-name-nondirectory (buffer-file-name))))
 (defun sort-lines-by-length (reverse beg end)
  "Sort lines by length."
  (interactive "P\nr")
  (save-excursion
    (save-restriction
      (narrow-to-region beg end)
      (goto-char (point-min))
      (let ;; To make `end-of-line' and etc. to ignore fields.
          ((inhibit-field-text-motion t))
        (sort-subr reverse 'forward-line 'end-of-line nil nil
                   (lambda (l1 l2)
                     (apply #'< (mapcar (lambda (range) (- (cdr range) (car range)))
                                        (list l1 l2)))))))))
 (defun corfu-auto-toggle()
  "Toggle corfu autocomplete."
  (interactive)
  (global-corfu-mode 0)
  (setq corfu-auto (not corfu-auto))
  (global-corfu-mode 1)
  )
 (defun force-fundamental-for-large-files ()
  "If a file is over 5MB, open it in fundamental-mode and disable undo."
  (when (> (buffer-size) (* 5 1024 1024))
    (setq buffer-read-only t)
    (buffer-disable-undo)
    (fundamental-mode)
    (message "Buffer set to fundamental-mode and read-only due to size.")))
 (add-hook 'find-file-hook #'force-fundamental-for-large-files)
 (provide 'init-functions)
 ;;; init-functions.el ends here.
--- a/configs/init-highlight.el
+++ b/configs/init-highlight.el
@@ -1,164 +0,0 @@
 ;; init-highlight.el --- Initialize highlighting configurations.	-*- lexical-binding: t -*-
 ;; Author: kj <webmaster@outcontrol.net>
 ;; URL: https://git.kj2.me/kj/confi-emacs-actual
 ;;; Commentary:
 ;;
 ;; Highlighting configurations.
 ;;
 ;;; Code:
 ;; Highlight the current line
 (use-package hl-line
  :ensure nil
  :hook (((dashboard-mode eshell-mode shell-mode term-mode vterm-mode) .
          (lambda () (setq-local global-hl-line-mode nil)))
         ;; (after-init . global-hl-line-mode)
  ))
 ;; Highlight matching parens
 (use-package paren
  :ensure nil
  :functions childframe-workable-p
  :custom-face
  (show-paren-match ((((class color) (background light))
                      (:box (:line-width (-1 . -1) :color "gray73")))
                     (((class color) (background dark))
                      (:box (:line-width (-1 . -1) :color "gray56")))))
  :hook (after-init . show-paren-mode)
  :init (setq show-paren-when-point-inside-paren t
              show-paren-when-point-in-periphery t)
  :config
  (setq blink-matching-paren-highlight-offscreen t
        show-paren-context-when-offscreen
        (if (childframe-workable-p) 'child-frame 'overlay))
  (with-no-warnings
    ;; Display matching line for off-screen paren.
    (defun display-line-overlay (pos str &optional face)
      "Display line at POS as STR with FACE.
 FACE defaults to inheriting from default and highlight."
      (let ((ol (save-excursion
                  (goto-char pos)
                  (make-overlay (line-beginning-position)
                                (line-end-position)))))
        (overlay-put ol 'display str)
        (overlay-put ol 'face
                     (or face '(:inherit highlight)))
        ol))
    (defvar-local show-paren--off-screen-overlay nil)
    (defun show-paren-off-screen (&rest _args)
      "Display matching line for off-screen paren."
      (when (overlayp show-paren--off-screen-overlay)
        (delete-overlay show-paren--off-screen-overlay))
      ;; Check if it's appropriate to show match info,
      (when (and (overlay-buffer show-paren--overlay)
                 (not (or cursor-in-echo-area
                          executing-kbd-macro
                          noninteractive
                          (minibufferp)
                          this-command))
                 (and (not (bobp))
                      (memq (char-syntax (char-before)) '(?\) ?\$)))
                 (= 1 (logand 1 (- (point)
                                   (save-excursion
                                     (forward-char -1)
                                     (skip-syntax-backward "/\\")
                                     (point))))))
        ;; Rebind `minibuffer-message' called by `blink-matching-open'
        ;; to handle the overlay display.
        (cl-letf (((symbol-function #'minibuffer-message)
                   (lambda (msg &rest args)
                     (let ((msg (apply #'format-message msg args)))
                       (setq show-paren--off-screen-overlay
                             (display-line-overlay
                              (window-start) msg ))))))
          (blink-matching-open))))
    (advice-add #'show-paren-function :after #'show-paren-off-screen)))
 ;; Resalta los escapes de secuencia
 (use-package highlight-escape-sequences
  :hook (prog-mode . hes-mode)
  :config
  (setq hes-mode-alist
        `((c-mode                . ,hes-c/c++/objc-escape-sequence-re)
          (c++-mode              . ,hes-c/c++/objc-escape-sequence-re)
          (objc-mode             . ,hes-c/c++/objc-escape-sequence-re)
          (go-mode               . ,hes-c/c++/objc-escape-sequence-re)
          (php-mode              . ,hes-c/c++/objc-escape-sequence-re)
          (php-ts-mode           . ,hes-c/c++/objc-escape-sequence-re)
          (java-mode             . ,hes-java-escape-sequence-re)
          (clojure-mode          . ,hes-java-escape-sequence-re)
          (js-mode               . ,hes-js-escape-sequence-re)
          (js2-mode              . ,hes-js-escape-sequence-re)
          (ruby-mode             . ,hes-ruby-escape-sequence-keywords)
          (lisp-mode             . ,hes-elisp-escape-sequence-re)
          (lisp-interaction-mode . ,hes-elisp-escape-sequence-re)
          (emacs-lisp-mode       . ,hes-elisp-escape-sequence-re))
        )
  )
 ;; Resalta todas las ocurrencias del contenido seleccionado
 (use-package region-occurrences-highlighter
  :diminish
  :bind (:map region-occurrences-highlighter-nav-mode-map
              ("M-n" . region-occurrences-highlighter-next)
              ("M-p" . region-occurrences-highlighter-prev))
  :hook (elpaca-after-init . global-region-occurrences-highlighter-mode))
 ;; Highlight indentions
 (use-package indent-bars
  :custom
  (indent-bars-color '(highlight :face-bg t :blend 0.225))
  (indent-bars-highlight-current-depth '(:face default :blend 0.225))
  (indent-bars-color-by-depth nil)
  (indent-bars-pattern ".")
  (indent-bars-treesit-support t)
  (indent-bars-no-descend-string t)
  (indent-bars-treesit-ignore-blank-lines-types '("module"))
  (indent-bars-prefer-character t)
  (indent-bars-treesit-scope '((python function_definition class_definition for_statement
 				                       if_statement with_statement while_statement)))
  ;; :hook ((prog-mode yaml-mode) . indent-bars-mode)
  :config (require 'indent-bars-ts))
 ;; Colorize color names in buffers
 (use-package colorful-mode
  :diminish
  :hook (after-init . global-colorful-mode)
  :init (setq colorful-use-prefix t)
  :config (dolist (mode '(html-mode php-mode help-mode helpful-mode))
            (add-to-list 'global-colorful-modes mode)))
 ;; Highlight brackets according to their depth
 (use-package rainbow-delimiters)
 ;; Resaltar palabras clave como TODO, FIXME, etc. en comentarios del código.
 (use-package hl-todo
  :autoload hl-todo-flymake hl-todo-search-and-highlight
  :functions rg rg-read-files rg-project
  :bind (:map hl-todo-mode-map
              ([C-f3] . hl-todo-occur))
  :hook (elpaca-after-init . global-hl-todo-mode)
  :init (setq hl-todo-require-punctuation t
              hl-todo-highlight-punctuation ":")
  :config
  (add-to-list 'hl-todo-keyword-faces '("BUG" . "#d99600"))
  ;; Integrate into flymake
  (with-eval-after-load 'flymake
    (add-hook 'flymake-diagnostic-functions #'hl-todo-flymake))
   ;; Integrate into magit
  (with-eval-after-load 'magit
    (add-hook 'magit-log-wash-summary-hook
              #'hl-todo-search-and-highlight t)
    (add-hook 'magit-revision-wash-message-hook
              #'hl-todo-search-and-highlight t))
  )
 (provide 'init-highlight)
 ;;; init-highlight.el ends here
--- a/configs/init-keys.el
+++ b/configs/init-keys.el
@@ -17,6 +17,8 @@
 (global-set-key (kbd "C-x C-z") nil)                      ; Unbind C-x C-z (don't minimize)
 (global-set-key (kbd "C-z") 'undo)                        ; Unbind C-z y hacerlo funcionar para deshacer cambios
 (global-set-key (kbd "C-S-z") 'undo-redo)                 ; Rehacer cambios con C-S-z
 (global-set-key (kbd "C-S-c")
                'comment-or-uncomment-region-or-line)     ; Comentar/descomentar línea o selección
 (global-set-key (kbd "C-<f11>") 'toggle-frame-maximized)  ; Maximizar / restaurar
 (global-set-key (kbd "C-S-d") 'duplicate-current-line)    ; Duplicar línea
 (global-set-key (kbd "<mouse-3>") 'context-menu-open)     ; Abrir menú contextal al hacer clic derecho
@@ -25,18 +27,19 @@
 (global-set-key (kbd "C-x m") nil)                        ; Unbind mail on C-x m
 (global-set-key (kbd "C-x mh") 'mhtml-mode)
 (global-set-key (kbd "C-x mj") 'js-mode)
-(global-set-key (kbd "C-x mp") 'php-ts-mode)
+(global-set-key (kbd "C-x mp") 'php-mode)
 (global-set-key (kbd "C-x mr") 'rust-mode)
 (global-set-key (kbd "C-x mw") 'web-mode)
-;; Saltar entre párrafos
+;; Cambiar de ventana
-(define-key global-map "\M-[" 'backward-paragraph)
+(global-set-key (kbd "C-S-o") 'other-window)
 (define-key global-map "\M-]" 'forward-paragraph)
-;; Insertar nombre del archivo
+;; Saltar entre párrafos
-(global-set-key (kbd "C-c ff") 'insert-filename)
+(define-key global-map "\M-p" 'backward-paragraph)
-(global-set-key (kbd "C-c fb") 'insert-basename)
+(define-key global-map "\M-n" 'forward-paragraph)
-(global-set-key (kbd "C-c fcf") 'copy-filename)
+
-(global-set-key (kbd "C-c fcb") 'copy-basename)
+;; Meta atajos (atajos de atajos)
 ;;(global-set-key (kbd "C-c l d") "\C-a\C- \C-n\M-w\C-y") ; Duplicar línea
 ;; Deactivar el abrir *messages* al cliquear en el minibuffer
 (define-key minibuffer-inactive-mode-map [mouse-1] #'ignore)
--- a/configs/init-lsp.el
+++ b/configs/init-lsp.el
@@ -1,112 +0,0 @@
 ;;; init-lsp.el --- Configuración de eglot (LSP)   -*- lexical-binding: t -*-
 ;; Author: kj <webmaster@outcontrol.net>
 ;; URL: https://git.kj2.me/kj/confi-emacs-actual
 ;;; Commentary:
 ;; Este archivo tiene todo lo relacionado con eglot.
 ;; Eglot es un cliente LSP para Emacs que desde la
 ;; versión 29 viene integrado dentro del mismo.
 ;;
 ;; El nombre Eglot es un apócope de "Emacs polyglot"
 ;; ya que con este cliente podemos añadir soporte para
 ;; muchísimos lenguajes, puesto que actualente el que
 ;; un lenguaje tenga su propio LSP es muy normal.
 ;;
 ;; Como añadido:
 ;;
 ;; Un Languaje Server Provider (LSP), es un protocolo
 ;; mediante el cual existen servidores para lenguajes
 ;; en específico, los cuales proveen cosas como el
 ;; autocompletado, linting, documentación, ir a la
 ;; definición, etc.
 ;;
 ;; Este protocolo viene a solucionar el problema de
 ;; que cada herramienta de programación tenga que
 ;; volver a crear su propio soporte para cada uno
 ;; de los lenguajes (DRY).
 ;;; Code:
 (use-package eglot
  :ensure nil
  :hook ((prog-mode . (lambda ()
                        (unless (derived-mode-p
                                 'emacs-lisp-mode 'lisp-mode
                                 'makefile-mode 'snippet-mode
                                 'ron-mode)
                          (eglot-ensure))))
         ((markdown-mode yaml-mode yaml-ts-mode) . eglot-ensure))
  :init
  (setq read-process-output-max (* 4 1024 1024)) ; 4MB
  (setq eglot-autoshutdown t
        eglot-send-changes-idle-time 0.5)
  :config
  (setq eglot-sync-connect 0)
  (add-to-list 'eglot-server-programs '(php-mode . ("rass" "--" "intelephense" "--stdio")))
  (add-to-list 'eglot-server-programs '(web-mode . ("rass" "--" "htmx-lsp" "--" "intelephense" "--stdio")))
  (add-to-list 'eglot-server-programs '(html-mode . ("rass" "--" "htmx-lsp" "--" "intelephense" "--stdio")))
  (add-to-list 'eglot-server-programs '(nhtml-mode . ("rass" "--" "htmx-lsp" "--" "intelephense" "--stdio")))
  (add-to-list 'eglot-server-programs 'makefile-mode . ("make-ls"))
  ;;(add-to-list 'eglot-server-programs '(markdown-mode . ("marksman")))
  (add-to-list 'eglot-ignored-server-capabilities :inlayHintProvider)
  )
 ;; Mejorar la velocidad de eglot (un binario en rust )
 (use-package eglot-booster
  :ensure (:host github :repo "jdtsmith/eglot-booster")
  :after eglot
  :config
  ;;
  (if (executable-find "emacs-lsp-booster")
      (eglot-booster-mode)
    (message "No está instalado emacs-lsp-booster. Eglot se usará de modo normal."))
  )
 ;; Emmet (mientras veo como hacer funcionar emmet-ls)
 (use-package emmet-mode
  :hook
  ((html-mode . emmet-mode)
   (web-mode . emmet-mode))
  )
 ;; Revisar por errores en el código
 (use-package flymake
  :ensure nil
  ;; :hook (prog-mode . (lambda ()
  ;;                      (unless (derived-mode-p 'makefile-mode)
  ;;                        (flymake-mode))))
  :init
  (remove-hook 'flymake-diagnostic-functions 'flymake-proc-legacy-flymake)
  :config
  ;; Workaround de bug#81786 (flymake): la rama no-ratón del `interactive'
  ;; de `flymake-show-buffer-diagnostics' devolvía la LISTA de diagnósticos
  ;; solapados en el punto y Emacs la reexpandía como argumentos
  ;; ("Wrong number of arguments: ..., N").  Arreglado en emacs-31/31.2 y
  ;; pendiente de fusionar a master; borrar cuando tu flymake incluya el fix.
  (defun flymake--one-diag-filter (args)
    "Keep only the first diagnostic of ARGS (bug#81786 workaround)."
    (if (cdr args) (list (car args)) args))
  (advice-add 'flymake-show-buffer-diagnostics
              :filter-args #'flymake--one-diag-filter))
 (use-package flymake-phpcs
  :ensure (:host github :repo "KJ2ME/flymake-phpcs")
  :config
  ;; Al conectar, Eglot hace `setq-local' de `flymake-diagnostic-functions'
  ;; (= (eglot-flymake-backend)), borrando nuestro backend; el siguiente
  ;; rechequeo de flymake limpia entonces los overlays de phpcs (aparecen y
  ;; luego desaparecen). Lo re-añadimos cuando Eglot termine de gestionar el
  ;; buffer (el hook corre DESPUES del `setq') y forzamos un rechequeo.
  (defun flymake-phpcs-readd-after-eglot ()
    "Re-register the phpcs backend and re-check once Eglot manages the buffer."
    (when (derived-mode-p 'php-mode 'php-ts-mode)
      (add-hook 'flymake-diagnostic-functions #'flymake-phpcs nil t)
      (flymake-mode 1)
      (flymake-start)))
  (add-hook 'eglot-managed-mode-hook #'flymake-phpcs-readd-after-eglot)
  :hook ((php-mode php-ts-mode) . flymake-phpcs-load))
 (provide 'init-lsp)
 ;;; init-lsp.el ends here
--- a/configs/init-minibuffer.el
+++ b/configs/init-minibuffer.el
@@ -10,14 +10,31 @@
 ;;; Code:
 ;; UI para completado
 (use-package vertico
  :defer t
  :bind (:map vertico-map
         ("RET" . vertico-directory-enter)
         ("DEL" . vertico-directory-delete-char)
         ("TAB" . minibuffer-complete)
         ("M-DEL" . vertico-directory-delete-word))
  :hook ((elpaca-after-init . vertico-mode)
         (elpaca-after-init . savehist-mode) ;; savehist sirve para recordar el último comando de M-x
         (rfn-eshadow-update-overlay . vertico-directory-tidy))
  :config
  (setq read-file-name-completion-ignore-case t
        read-buffer-completion-ignore-case t
        completion-ignore-case t)
  )
 ;; Reemplazo para counsel
 (use-package consult
-  :bind (("C-x p"   . project-find-file)
+  :defer t
-         ("C-x C-p" . project-find-file)
+  :bind (;; C-c bindings in `mode-specific-map'
-         ("C-S-s"   . consult-line)
+         ("C-s"     . consult-line)
-         ("C-c r g" . consult-ripgrep)
+         ("C-r"     . consult-ripgrep)
-         ("C-S-r"   . consult-ripgrep)
+         ("C-S-s"   . isearch-forward)
-         ;; ("C-S-s"   . isearch-forward)
+         ("C-S-r"   . isearch-backward)
         ("M-m"     . consult-mode-command)
         ("C-c h"   . consult-history)
         ("C-c k"   . consult-kmacro)
@@ -27,22 +44,30 @@
         ([remap recentf-open-files] . consult-recent-file)
         ;; C-x bindings in `ctl-x-map'
         ("C-x M-." . consult-complex-command)     ;; orig. repeat-complex-command
         ("C-x b"   . consult-buffer)              ;; orig. switch-to-buffer
         ("C-x 4 b" . consult-buffer-other-window) ;; orig. switch-to-buffer-other-window
         ("C-x 5 b" . consult-buffer-other-frame)  ;; orig. switch-to-buffer-other-frame
         ("C-x r b" . consult-bookmark)            ;; orig. bookmark-jump
         ("C-c p b" . consult-project-buffer)      ;; orig. project-switch-to-buffer
-         ("C-c p p" . project-switch-project)
+         ("C-c p p" . project-switch-project)      ;; orig. project-switch-to-buffer
         ;; Consult search
         ("C-c p f" . consult-find)                  ;; Búsqueda de archivos en todo el projecto incluso en carpetas
         ("C-c p l" . consult-line-multi)            ;; Búsqueda en todos los buffers del projecto abiertos
         ;; Custom M-# bindings for fast register access
-         ;; ("C-'"   . consult-register-load)
+         ("C-'"   . consult-register-load)
         ("C-'"   . consult-register)
         ("M-'"   . consult-register-store)        ;; orig. abbrev-prefix-mark (unrelated)
         ("M-¡"   . consult-register)
         ;; Other custom bindings
         ("M-y" . consult-yank-pop)                ;; orig. yank-pop
         ;; M-g bindings in `goto-map'
         ("M-g f" . consult-flymake)               ;; Alternative: consult-flycheck
         ("M-g g" . consult-goto-line)             ;; orig. goto-line
         ("M-g M-g" . consult-goto-line)           ;; orig. goto-line
         ("M-g o" . consult-outline)               ;; Alternative: consult-org-heading
         ("M-g m" . consult-mark)
         ("M-g k" . consult-global-mark)
         ("M-g i" . consult-imenu)
         ("M-g I" . consult-imenu-multi)
@@ -50,7 +75,14 @@
         :map minibuffer-local-map
         ("<escape>" . minibuffer-keyboard-quit) ;; Cacelar minibuffer con escape (más rápido que C-g)
         ("C-<return>" . newline) ;; Insertar nueva línea estando en el minibufer (Mas rápido que C-q C-j)
-         )
+         ("C-s" . (lambda ()
                    "Insert the current symbol."
                    (interactive)
                    (insert (save-excursion
 		                      (set-buffer (window-buffer (minibuffer-selected-window)))
 		                      (or (thing-at-point 'symbol t) ""))))) ;; Al presionar por segunda ves C-s busca el símbolo actual.
         ("M-s" . consult-history)                 ;; orig. historial de búsqueda
         ("M-r" . consult-history))                ;; orig. historual de búsqueda
  ;; Enable automatic preview at point in the *Completions* buffer. This is
  ;; relevant when you use the default completion UI.
@@ -93,29 +125,34 @@
  ;; You may want to use `embark-prefix-help-command' or which-key instead.
  (define-key consult-narrow-map (vconcat consult-narrow-key "?") #'consult-narrow-help))
 ;; nerd-icons en ibuffer
 (use-package nerd-icons-ibuffer
  :defer t
  :hook (ibuffer-mode . nerd-icons-ibuffer-mode))
 ;; Integración entre consult y project
 (use-package consult-project-extra
  :defer t
  :ensure t
  :bind
  (("C-x p" . consult-project-extra-find)
   ("C-c p o" . consult-project-extra-find-other-window)))
 ;; Descripciones en el minibufer
 (use-package marginalia
-  :hook (vertico-mode . marginalia-mode))
+  :defer t
  :hook (elpaca-after-init . marginalia-mode))
 ;; Nerd icons para vertico
 (use-package nerd-icons-completion
  :after nerd-icons
  :config (nerd-icons-completion-mode))
 ;; Todolist de todo el projecto desde consult.
 (use-package consult-todo
  :demand t
-  :bind ("C-c t" . consult-todo))
+  :bind ("C-c t" . consult-todo)
-
+  :defer t)
 ;; UI para completado del minibuffer
 (use-package vertico
  :bind (:map vertico-map
              ("RET" . vertico-directory-enter)
              ("DEL" . vertico-directory-delete-char)
              ("TAB" . minibuffer-complete)
              ("M-DEL" . vertico-directory-delete-word))
  :hook ((elpaca-after-init . vertico-mode)
         (rfn-eshadow-update-overlay . vertico-directory-tidy))
  :init
  (setq read-file-name-completion-ignore-case t
        read-buffer-completion-ignore-case t
        completion-ignore-case t)
  )
 (provide 'init-minibuffer)
 ;;; init-minibuffer.el ends here
--- a/configs/init-org.el
+++ b/configs/init-org.el
@@ -21,17 +21,35 @@
  "Configuración para el hook de 'org-mode'."
  (display-line-numbers-mode 0)
  ;; (variable-pitch-mode 1)
  (visual-line-mode 1)
  (visual-fill-column-mode 1)
-  ;; Configuracin para Systanx Highlight en porg-blocks
+  ;; Configuración de fonts
-  (add-to-list 'org-src-lang-modes (cons "html" 'mhtml))
+  ;; (set-face-attribute (car face) nil :font "Cantarell" :weight 'regular :height (cdr face))
  ;; Ensure that anything that should be fixed-pitch in Org files appears that way
  ;; (set-face-attribute 'org-hide nil :inherit 'fixed-pitch)
  ;; (set-face-attribute 'org-block nil :foreground 'unspecified :inherit 'fixed-pitch)
  ;; (set-face-attribute 'org-code nil   :inherit '(shadow fixed-pitch))
  (setq org-fontify-quote-and-verse-blocks t) ;; Permitir configuración de bloques quote y verse.
  ;; (set-face-attribute 'org-block nil :underline nil :foreground nil :background "#282a36")
  ;; (set-face-attribute 'org-block-begin-line nil :underline nil :foreground nil :background "#1e1f28")
  ;; (set-face-attribute 'org-block-end-line nil :underline nil :foreground nil :background nil)
  ;; (set-face-attribute 'org-block-end-line nil :background 'unspecified)
  (set-face-attribute 'org-table nil   :inherit '(shadow fixed-pitch))
  (set-face-attribute 'org-verbatim nil :inherit '(shadow fixed-pitch))
  (set-face-attribute 'org-special-keyword nil :inherit '(font-lock-comment-face fixed-pitch))
  (set-face-attribute 'org-meta-line nil :inherit '(font-lock-comment-face fixed-pitch))
  (set-face-attribute 'org-checkbox nil :inherit 'fixed-pitch)
  ;; (set-face-attribute 'org-block nil :background
  ;;                   (color-darken-name
  ;;                    (face-attribute 'default :background) 3))
  ;; (setq org-src-block-faces '(("emacs-lisp" (:background "#EEE2FF"))
  ;;                           ("python" (:background "#E5FFB8"))))
  ;; Tachar los elementos "DONE"
  (set-face-attribute 'org-done nil :strike-through t)
  (set-face-attribute 'org-headline-done nil
@@ -76,22 +94,19 @@
                                         (rust . t)
                                         (translate . t)
                                         (shell . t)
                                         (sql . t)
                                         )))
  ;; No solicitar confirmación para evaluar
  (setq org-confirm-babel-evaluate nil)
  (add-to-list 'org-src-lang-modes '("go" . go-ts))
  )
 ;; org-mode
 (use-package org
  :defer t
  :ensure nil
-  :bind (:map org-mode-map
+  :bind (("C-c a" . org-agenda)
-              ("C-'" . nil)
+         ("C-c c" . org-capture))
              ("C-," . nil))
  :hook
-  ((org-mode . kj/org-hook)
+  (org-mode . kj/org-hook)
   (org-mode . visual-line-fill-column-mode))
  :config
  (setq org-ellipsis " ▾")
  (setq org-hide-emphasis-markers t)
@@ -102,7 +117,7 @@
  (setq org-log-into-drawer t)
  (setq org-cycle-separator-lines -1)
-  ;; Indentación
+  ;; Identación
  (setq org-startup-indented t)
  (setq org-src-preserve-indentation nil)
  (setq org-edit-src-content-indentation 0)
@@ -144,15 +159,19 @@
  ;; Guardar los archivos cuando se muevan tareas entre ellos
  (advice-add 'org-refile :after 'org-save-all-org-buffers)
  (setq org-capture-templates
        `(("t" "Tareas")
          ("tt" "Tareas" entry (file+olp "~/Documentos/ORG/Agenda/Tareas.org")
           "* TODO %? \n %a\n %i" :empty-lines 1)
          )
        )
  ;; Configuración de imágenes
  (setq org-startup-with-inline-images t) ;; Mostrar por defecto las imágenes
  (setq org-display-remote-inline-images 'cache) ;; Mostrar imágenes remotas
  (setq org-image-actual-width 512)
  )
 ;; Ajusta el tamaño horizontal de las tablas a lo configurado en fill-colum o ftable-fill-column
 (use-package ftable)
 ;; Org-yt para soportar embebidos.
 (use-package org-yt
  :after org
@@ -175,6 +194,7 @@
 ;; Los head "*" se ven como puntos
 (use-package org-bullets
  :defer t
  :hook
  (org-mode . org-bullets-mode)
  :config
@@ -190,6 +210,8 @@
 ;; Mejora visualmente varias cosas de org
 (use-package org-modern
  :defer t
  :ensure t
  :hook ((org-mode . org-modern-mode)
         (org-agenda . org-modern-mode))
  :config
@@ -199,7 +221,7 @@
        org-modern-table-horizontal 0.2     ;; Grosor de las líneas horizontales de las tablas
        org-modern-priority nil             ;; Mejora de las prioridades (Arriba ya las puse bonitas con prettyfy-symbols, así que mejor está desactivado)
        org-modern-todo nil                 ;; Mejora visual a las lista de tareas
-        org-modern-progress nil             ;; Mejora visual a las estadísticas de completado de uan tarea (ej: [50%] o [5/9])
+        org-modern-statistics nil           ;; Mejora visual a las estadísticas de completado de uan tarea (ej: [50%] o [5/9])
        org-modern-checkbox nil             ;; Mejora de los checkboxes (a mi parecer se ven más feos, los por defecto ya están bonitos).
        org-modern-keyword nil              ;; Oculta el "#+" en los keywords de org
        org-modern-block-name nil           ;; Mejora visual para los org blocks (bloques de código, ejemplo, citas, etc.)
@@ -208,6 +230,7 @@
  )
 (use-package visual-fill-column
  :defer t
  :after (org)
  :config
  ;; Tamaño de la columna
@@ -220,7 +243,10 @@
 ;; Segundo cerebro: Base de conocimientos en formato Zettelkasten
 (use-package org-roam
-  :bind ("<f3>" . org-roam-node-find)
+  :defer t
  :ensure t
  :bind (("<f4>" . org-roam-node-insert)
         ("<f3>" . org-roam-node-find))
  :init
  (setq org-roam-v2-ack t)
  (setq org-roam-completion-system 'ivy)
@@ -232,6 +258,8 @@
 ;; Interface web para navegar en mi base de conocimientos.
 (use-package org-roam-ui
  :defer t
  :ensure t
  :config
  (setq org-roam-ui-sync-theme t
        org-roam-ui-follow t
@@ -240,26 +268,33 @@
 ;; Continúa el formato de la lista cuando presionas enter.
 (use-package org-autolist
  :defer t
  :ensure t
  :hook (org-mode . org-autolist-mode))
 ;; Org babel para PHP
-(use-package ob-php)
+(use-package ob-php
  :defer t
  :ensure t)
 ;; Org babel para GO
-(use-package ob-go)
+(use-package ob-go
  :defer t
  :ensure t)
 ;; Org babel para Rust
-(use-package ob-rust)
+(use-package ob-rust
  :defer t
  :ensure t)
 ;; Org babel para traducciones (mediante google translate)
-(use-package ob-translate)
+(use-package ob-translate
-
+  :defer t
-;; Autocompletado para los headers de los bloques
+  :ensure t)
 (use-package corg
  :ensure (:host github :repo "isamert/corg.el"))
 ;; Org mode en modo presentación
 (use-package org-present
  :defer t
  :after (org)
  :config
  (add-hook 'org-present-mode-hook
@@ -287,8 +322,12 @@
 ;; Mostrar los caracteres ocultos de org mode al pasar con el cursor.
 (use-package org-appear
  :defer t
  ;; :hook (org-mode . org-appear-mode)
  )
 ;; Polymode para org-mode
 ;; (use-package poly-org)
 (provide 'init-org)
 ;;; init-org.el ends here
--- a/configs/init-package.el
+++ b/configs/init-package.el
@@ -1,78 +0,0 @@
 ;;; init-package.el --- Initialize package configurations.	-*- lexical-binding: t -*-
 ;;; Commentary:
 ;;
 ;; Emacs Package management configurations.
 ;;
 ;;; Code:
 ;; Configuración de repositorios de paquetes
 (defvar elpaca-installer-version 0.12)
 (defvar elpaca-directory (expand-file-name "elpaca/" user-emacs-directory))
 (defvar elpaca-builds-directory (expand-file-name "builds/" elpaca-directory))
 (defvar elpaca-sources-directory (expand-file-name "sources/" elpaca-directory))
 (defvar elpaca-order '(elpaca :repo "https://github.com/progfolio/elpaca.git"
                              :ref nil :depth 1 :inherit ignore
                              :files (:defaults "elpaca-test.el" (:exclude "extensions"))
                              :build (:not elpaca-activate)))
 (let* ((repo  (expand-file-name "elpaca/" elpaca-sources-directory))
       (build (expand-file-name "elpaca/" elpaca-builds-directory))
       (order (cdr elpaca-order))
       (default-directory repo))
  (add-to-list 'load-path (if (file-exists-p build) build repo))
  (unless (file-exists-p repo)
    (make-directory repo t)
    (when (<= emacs-major-version 28) (require 'subr-x))
    (condition-case-unless-debug err
        (if-let* ((buffer (pop-to-buffer-same-window "*elpaca-bootstrap*"))
                  ((zerop (apply #'call-process `("git" nil ,buffer t "clone"
                                                  ,@(when-let* ((depth (plist-get order :depth)))
                                                      (list (format "--depth=%d" depth) "--no-single-branch"))
                                                  ,(plist-get order :repo) ,repo))))
                  ((zerop (call-process "git" nil buffer t "checkout"
                                        (or (plist-get order :ref) "--"))))
                  (emacs (concat invocation-directory invocation-name))
                  ((zerop (call-process emacs nil buffer nil "-Q" "-L" "." "--batch"
                                        "--eval" "(byte-recompile-directory \".\" 0 'force)")))
                  ((require 'elpaca))
                  ((elpaca-generate-autoloads "elpaca" repo)))
            (progn (message "%s" (buffer-string)) (kill-buffer buffer))
          (error "%s" (with-current-buffer buffer (buffer-string))))
      ((error) (warn "%s" err) (delete-directory repo 'recursive))))
  (unless (require 'elpaca-autoloads nil t)
    (require 'elpaca)
    (elpaca-generate-autoloads "elpaca" repo)
    (let ((load-source-file-function nil)) (load "./elpaca-autoloads"))))
 (add-hook 'after-init-hook #'elpaca-process-queues)
 (elpaca `(,@elpaca-order))
 ;; Install use-package support
 (elpaca elpaca-use-package
  ;; Enable use-package :ensure support for Elpaca.
  (elpaca-use-package-mode))
 ;; Should set before loading `use-package'
 (setq use-package-always-ensure t
      use-package-always-defer t
      use-package-expand-minimally t
      use-package-enable-imenu-support t)
 ;; Required by `use-package'
 (use-package diminish :ensure t)
 ;; Update GPG keyring for GNU ELPA
 (use-package gnu-elpa-keyring-update)
 ;; Update packages
 (unless (fboundp 'package-upgrade-all)
  (use-package auto-package-update
    :init
    (setq auto-package-update-delete-old-versions t
          auto-package-update-hide-results t)
    (defalias 'package-upgrade-all #'auto-package-update-now)))
 (provide 'init-package)
 ;;; init-package.el ends here
--- a/configs/init-packages.el
+++ b/configs/init-packages.el
@@ -0,0 +1,488 @@
 ;;; init-packages.el --- Extensiones/paquetes instalados y su configuración 	-*- lexical-binding: t -*-
 ;; Author: kj <webmaster@outcontrol.net>
 ;; URL: https://git.kj2.me/kj/confi-emacs-actual
 ;;; Commentary:
 ;; Aquí se encuentran los paquetes de uso general.
 ;;
 ;; Aquellos de uso más específico, por ejemplo, los que
 ;; pertenecen a un lenguaje de programación en específico
 ;; estarán en el respectivo archivo de configuración
 ;; para dicho uso específico.
 ;;; Code:
 ;; Mejora del reemplazo
 (use-package anzu
  :defer t
  :bind (([remap query-replace] . anzu-query-replace)
         ([remap query-replace-regexp] . anzu-query-replace-regexp)))
 ;; Intercamiar buffers de lugar
 (use-package buffer-move
  :defer t
  :bind (("M-S-<up>" . buf-move-up)
         ("M-S-<down>" . buf-move-down)
         ("M-S-<left>" . buf-move-left)
         ("M-S-<right>" . buf-move-right))
  )
 ;; Mostrar la ayuda de eldoc/documentación en un childframe
 (use-package eldoc-box
  :defer t
  :bind ("<f1>" . eldoc-box-help-at-point))
 ;; Seleccionar por regiones (similar a mark-sexp, pero toma en cuenta hacia atrás del cursor también)
 (use-package expand-region
  :defer t
  :bind ("C-+" . er/expand-region))
 ;; Major mode para archivos CSV
 (use-package csv-mode
  :defer t
  :hook ((csv-mode . csv-align-mode)
         (csv-mode . csv-header-line))
  )
 ;; Visor de documentos de emacs (soporta de todo: epub, pdf, odt, docx, cbz, etc.)
 (use-package doc-view
  :defer t
  :hook
  (doc-view-mode . (lambda ()
                       (display-line-numbers-mode 0)))
  :ensure nil)
 ;; Un bonito y sencillo panel de inicio
 (use-package dashboard
  :defer t
  :init
  (dashboard-setup-startup-hook)
  :hook
  (dashboard-after-initialize . (lambda ()
                    "Refrescamos el dashboard con la agenda luego de cargar todo"
                    (setq dashboard-items '(
                                            ;; (recents . 10)
                                            (agenda . 10)
                                            ))
                    (dashboard-refresh-buffer)
                    ))
  :config
  (setq dashboard-set-file-icons t
        dashboard-set-heading-icons t
        dashboard-set-file-icons t
        dashboard-week-agenda nil
        dashboard-agenda-time-string-format "%Y-%m-%d %H:%M")
  (setq dashboard-startup-banner
        (expand-file-name "duck.svg" user-emacs-directory))
   (setq dashboard-items '())
  )
 ;; Coloca en emacs la documentacón distribuída por devdocs.io
 (use-package devdocs
  :defer t)
 ;; Sidebar a la derecha con los archivos
 (use-package dired-sidebar
  :defer t
  :hook (dired-mode . hl-line-mode)
  :ensure t
  :bind ([f9] . dired-sidebar-toggle-sidebar)
  :commands (dired-sidebar-toggle-sidebar)
  :config
  (setq dired-sidebar-theme 'nerd
        ;; dired-sidebar-should-follow-file t
        ;; dired-sidebar-follow-file-idle-delay 0.5
        ))
 ;; Mover líneas o regiones
 (use-package drag-stuff
  :defer t
  :hook
  (elpaca-after-init . drag-stuff-global-mode)
  :config
  (drag-stuff-define-keys))
 ;; La línea bonita esa de abajo
 (use-package doom-modeline
  :defer t
  :ensure t
  :hook (elpaca-after-init . doom-modeline-mode)
  :config
  (setq doom-modeline-project-detection 'auto
        doom-modeline-buffer-file-name-style 'relative-from-project
        doom-modeline-major-mode-color-icon t
        doom-modeline-buffer-modification-icon t
        doom-modeline-indent-info nil
        doom-modeline-persp-name t))
 ;; Resolver diferencias entre 2 archivos o versiones del mismo.
 (use-package ediff
  :defer t
  :ensure nil
  :config
  (setq ediff-diff-options "")
  (setq ediff-custom-diff-options "-u")
  (setq ediff-window-setup-function 'ediff-setup-windows-plain)
  (setq ediff-split-window-function 'split-window-vertically))
 ;; Emparejamiento automático de comillas, paréntesis, corchetes y llaves
 (use-package electric-pair
  :defer t
  :ensure nil
  :hook (elpaca-after-init . electric-pair-mode)
  :config
  (setq electric-pair-delete-adjacent-pairs nil))
 ;; Git Gutter - Marca a la izq. si una linea ha sido agregada, editada o eliminada desde el último commit.
 (use-package git-gutter
  :defer t
  :hook
  (elpaca-after-init . global-git-gutter-mode)
  :config
  (defhydra hydra-git-gutter (:hint nil)
    "
 ^Navigation^  | ^Actions^     | ^Others^
 -^-----------^-+-^----^--------+-^-------^----------
 _p_: previous | _s_: stage    | _m_:   mark
 _n_: next     | _r_: revert   | _SPC_: toggle info
 -^-----------^-+-^----^--------+-^-------^----------
 "
            ("p" git-gutter:previous-hunk)
            ("n" git-gutter:next-hunk)
            ("s" git-gutter:stage-hunk)
            ("r" git-gutter:revert-hunk)
            ("m" git-gutter:mark-hunkmark)
            ("SPC" git-gutter:toggle-popup-hunk))
  )
 ;; Visitar rápidamente viejas versiones de un archivo rápidamente
 (use-package git-timemachine
  :ensure t
  :defer t)
 ;; Cliente LLM (ollama, chatgpt, gemini, etc.)
 (use-package gptel
  :defer t
  :config
  (setq gptel-model "dolphin-llama3:latest"
        gptel-backend (gptel-make-ollama "Ollama"
                        :host "localhost:11434"
                        :stream t
                        :models '("mistral:latest" "dolphin-llama3:latest" "llama3:latest" "llava:latest"))
        gptel-default-mode 'org-mode
        gptel-prompt-prefix-alist
        '((markdown-mode . "# ")
          (org-mode . "* ")
          (text-mode . "# "))
        gptel-directives
        '((default . "Eres un LLM que vive dentro de Emacs. Responde de manera concisa.")
          (programming . "Eres un LLM y un programador profesional cuidadoso. Provee el código y solo el código como output sin ningún texto adicional, prompt o nota.")
          (programming_tutor . "Eres un LLM y un programador profesional cuidadoso. Revisa el siguiente código y realiza sugerencias concisas en español para mejorarlo.")
          (programming_explainer . "Eres un LLM y un programador profesional cuidadoso. Revisa el siguiente código y explica en español de manera concisa, su funcionamiento.")
          (programming_describer . "Eres un LLM y un programador profesional cuidadoso. Revisa el siguiente código y explica en español su funcionamiento línea a línea.")
          (writing . "Eres un LLM y un asistente de escritura. Responde de manera concisa.")
          (grammarly . "You are a large language model and professional philologist. Improve grammar and spelling.")
          (chat . "Eres un LLM y un compañero de conversación. Responde de manera concisa.")
          (traductor . "Eres un traductor de libros de informática profesional. Traduce a español tomando en cuenta los posibles tecnicismos que no deberían traducirse.")
          )
        )
  )
 ;; Resalta los escapes de secuencia
 (use-package highlight-escape-sequences
  :defer t
  :hook (prog-mode . hes-mode)
  :config
  (setq hes-mode-alist
        `((c-mode                . ,hes-c/c++/objc-escape-sequence-re)
          (c++-mode              . ,hes-c/c++/objc-escape-sequence-re)
          (objc-mode             . ,hes-c/c++/objc-escape-sequence-re)
          (go-mode               . ,hes-c/c++/objc-escape-sequence-re)
          (php-mode              . ,hes-c/c++/objc-escape-sequence-re)
          (java-mode             . ,hes-java-escape-sequence-re)
          (clojure-mode          . ,hes-java-escape-sequence-re)
          (js-mode               . ,hes-js-escape-sequence-re)
          (js2-mode              . ,hes-js-escape-sequence-re)
          (ruby-mode             . ,hes-ruby-escape-sequence-keywords)
          (lisp-mode             . ,hes-elisp-escape-sequence-re)
          (lisp-interaction-mode . ,hes-elisp-escape-sequence-re)
          (emacs-lisp-mode       . ,hes-elisp-escape-sequence-re))
        )
  )
 ;; Resaltar palabras clave como TODO, FIXME, etc. en comentarios del código.
 (use-package hl-todo
  :ensure (hl-todo :version (lambda (_) "3.6.0"))
  :defer t
  :hook (prog-mode . hl-todo-mode)
  :config
  (add-to-list 'hl-todo-keyword-faces '("BUG" . "#d99600")))
 ;; Paquete para exportar buffers de emacs a HTML
 (use-package htmlize
  :defer t
  :ensure t)
 ;; Permite crear conjuntos de atajos.
 (use-package hydra
  :defer t)
 ;; Mostrar lo que se está presionando en pantalla
 (use-package keypression
  :defer t
  :config
  (setq keypression-use-child-frame t
      keypression-fade-out-delay 1.0
      keypression-frame-justify 'keypression-left-justified
      keypression-cast-command-name t
      keypression-cast-command-name-format "%s  %s"
      keypression-combine-same-keystrokes t
      keypression-x-offset 50
      keypression-y-offset 100
      keypression-font-face-attribute '(:width normal :height 180 :weight bold))
  )
 ;; Generador automatizado de archivos de licencia
 (use-package license-templates
  :defer t)
 ;; Magia para git
 (use-package magit
  :defer t)
 ;; Todolist en magit de todos los archivos del projecto.
 (use-package magit-todos
  :defer t
  :after magit
  :config (magit-todos-mode 1))
 ;; Modo markdown
 (use-package markdown-mode
  :defer t)
 ;; Multiple vterm
 (use-package multi-vterm
  :defer t
  :bind* (("<f5>" . multi-vterm-dedicated-toggle)
          ("C-x tt" . multi-vterm-dedicated-toggle)
          ("C-x tf" . multi-vterm)
          ("C-x tp" . multi-vterm-project)
          ;;("<tab>" . vterm-send-tab)
          )
  :ensure t)
 ;; Iconos bonitos para varias cosas
 (use-package nerd-icons
  :defer t)
 ;; Usar nerd-icons en dired
 (use-package nerd-icons-dired
  :defer t
  :hook (dired-mode . nerd-icons-dired-mode))
 ;; Modo para leer archivos de configuración de nginx
 (use-package nginx-mode
  :defer t)
 ;; Lector EPUB
 ;; (use-package nov
 ;;   :defer t)
 ;; Múltiples modos en un mismo buffer
 ;; (use-package polymode
 ;; :defer t)
 ;; Des-minifica / ordena el código
 (use-package prettier
  :defer t)
 (use-package project
  :defer t
  :ensure nil
  :config
  ;; Colocamos un título del frame más bonito y útil que el por defecto
  (setq frame-title-format
        '(
          (:eval
           (let ((project-name (kj/project-name)))
             (unless (null project-name)
               (format "[%s] " project-name))))
          "%b"
          " - Emacs")
        )
 )
 ;; Correr el código desde el buffer de emacs
 (use-package quickrun
  :defer t
  :ensure t
  :bind (:map prog-mode-map
              ("C-c C-r" . quickrun)
              ("C-c r f" . quickrun)
              ("C-c r r" . quickrun-region)
              ("C-c r R" . quickrun-replace-region)
         )
  )
 ;; Recentf - Guarda registro de los archivos abiertos recientemente
 (use-package recentf
  :defer t
  :ensure nil
  :bind ("C-x C-r" . recentf-open-files)
  :hook (after-load-theme . recentf-mode)
  :config
  (setq recentf-save-file
        (recentf-expand-file-name (concat temp-dir "/recentf"))
        recentf-auto-cleanup 'never
        recentf-keep '(file-remote-p file-readable-p)
        recentf-max-saved-items 1000
        recentf-max-menu-items 500))
 ;; Busqueda rápida con ripgrep
 (use-package rg
  :defer t
  ;; :hook (elpaca-after-init . rg-enable-default-bindings)
  :bind (:map rg-global-map
         ("c" . rg-dwim-current-dir)
         ("f" . rg-dwim-current-file)
         ("m" . rg-menu))
  :config
  (setq rg-group-result t
        rg-show-columns t)
  (cl-pushnew '("tmpl" . "*.tmpl") rg-custom-type-aliases))
 ;; Guardar la posición del cursor en un archivo para volver allí cuando se lo vuelva a abrir.
 (use-package saveplace
  :ensure nil
  :defer t
  :hook
  (elpaca-after-init . (lambda()
                         (setq save-place-file (locate-user-emacs-file (concat temp-dir "/places")))
                         (save-place-mode 1)
                         ))
  )
 ;; Mejorando el scroll
 (use-package smooth-scrolling
  :defer t
  :hook (elpaca-after-init . smooth-scrolling-mode)
  :config
  (setq mouse-wheel-scroll-amount
        '(8 ((shift) . 1) ((control) . nil)))    ; Cambia el scroll a 8 líneas a la vez, 1 cuando se preciona SHIFT y saltos de página cuando presionas CTRL
  (setq mouse-wheel-progressive-speed nil)     ; Deshabilita la velocidad progresiva del scroll (mientras más scroll haces, mas rápido va)
  )
 ;; Ayuda a manipular los archivos con líneas demasiado largas
 (use-package so-long
  :defer t
  :ensure nil
  :bind (:map so-long-mode-map
              ("C-s"    . isearch-forward)
              ("C-r"    . isearch-backward))
  :config
  (setq so-long-variable-overrides
        '((bidi-inhibit-bpa . t)
          (bidi-paragraph-direction . left-to-right)
          (buffer-read-only . nil)
          (global-hl-line-mode . nil)
          (line-move-visual . t)
          (show-paren-mode . nil)
          (truncate-lines . nil)
          (which-func-mode . nil)))
  )
 ;; Mecanografía
 (use-package speed-type
  :defer t
  :hook
  (speed-type-mode . (lambda ()
                       (display-line-numbers-mode 0)
                       (visual-line-mode 1)
                       (visual-fill-column-mode 1)))
  :diminish
  :config
  (setq speed-type-gb-book-list '(66867 66866 66591 57303)
        speed-type-min-chars 500
        speed-type-max-chars 600))
 ;; Tree-sitter :)
 (use-package treesit
  :defer t
  :ensure nil
  :commands (treesit-install-language-grammar nf/treesit-install-all-languages)
  :config
  (setq treesit-language-source-alist
        '((bash       . ("https://github.com/tree-sitter/tree-sitter-bash"))
          (c          . ("https://github.com/tree-sitter/tree-sitter-c"))
          (cpp        . ("https://github.com/tree-sitter/tree-sitter-cpp"))
          (css        . ("https://github.com/tree-sitter/tree-sitter-css"))
          (go         . ("https://github.com/tree-sitter/tree-sitter-go"))
          (haskell    . ("https://github.com/tree-sitter/tree-sitter-haskell"))
          (html       . ("https://github.com/tree-sitter/tree-sitter-html"))
          (java       . ("https://github.com/tree-sitter/tree-sitter-java"))
          (javascript . ("https://github.com/tree-sitter/tree-sitter-javascript"))
          (json       . ("https://github.com/tree-sitter/tree-sitter-json"))
          (julia      . ("https://github.com/tree-sitter/tree-sitter-julia"))
          (lua        . ("https://github.com/Azganoth/tree-sitter-lua"))
          (make       . ("https://github.com/alemuller/tree-sitter-make"))
          (python     . ("https://github.com/tree-sitter/tree-sitter-python"))
          (php        . ("https://github.com/tree-sitter/tree-sitter-php" "master" "php/src"))
          (ruby       . ("https://github.com/tree-sitter/tree-sitter-ruby"))
          (rust       . ("https://github.com/tree-sitter/tree-sitter-rust"))
          (sql        . ("https://github.com/m-novikov/tree-sitter-sql"))
          (toml       . ("https://github.com/tree-sitter/tree-sitter-toml"))
          (zig        . ("https://github.com/GrayJack/tree-sitter-zig"))))
  (defun nf/treesit-install-all-languages ()
    "Install all languages specified by `treesit-language-source-alist'."
    (interactive)
    (let ((languages (mapcar 'car treesit-language-source-alist)))
      (dolist (lang languages)
 	(treesit-install-language-grammar lang)
 	(message "`%s' parser was installed." lang)
 	(sit-for 0.75)))))
 ;; Cuando presionas enter en un bloque de comentario sigue el estilo del bloque.
 ;; (use-package vs-comment-return
 ;;   :ensure (:host github :repo "emacs-vs/vs-comment-return")
 ;;   :defer t
 ;;   :hook (prog-mode . vs-comment-return-mode)
 ;;   )
 ;; Mostrar el último commit que modificó la linea actual
 (use-package vc-msg
  :defer t
  :bind (("C-c v" . vc-msg-show)
         ("C-c C-v" . vc-msg-show))
  )
 ;; Terminal
 (use-package vterm
  :ensure t
  :defer t
  :config
  (setq tramp-histfile-override nil)                  ;; Dejamos que se use el history por defecto del servidor remoto
  (setq vterm-tramp-shells '(("ssh" "/bin/bash")
                             ("sshx" "/bin/bash")
                             ("docker" "/bin/bash")
                             ("podman" "/bin/bash"))) ;; Tanto docker como podman usarán bash cuado se contecte mediante tramp
  )
 ;; Cuando iniicias un atajo de teclas te muestra las posibilidades
 (use-package which-key
  :defer t
  :hook (elpaca-after-init . which-key-mode))
 ;; Restaurar el estado de los frames
 (use-package winner
  :ensure nil
  :defer t
  :hook (elpaca-after-init . winner-mode))
 ;; Emacs Start Up Profiler
 (use-package esup
  :defer t)
 (provide 'init-packages)
 ;;; init-packages.el ends here
--- a/configs/init-prog.el
+++ b/configs/init-prog.el
@@ -1,195 +0,0 @@
 ;; init-prog.el --- Initialize programming configurations.	-*- lexical-binding: t -*-
 ;; Author: kj <webmaster@outcontrol.net>
 ;; URL: https://git.kj2.me/kj/confi-emacs-actual
 ;;; Commentary:
 ;;
 ;; General programming configurations.
 ;;
 ;;; Code:
 ;; Mostrar la ayuda de eldoc/documentación en un childframe
 (use-package eldoc-box
  :defer t
  :bind ("<f1>" . eldoc-box-help-at-point))
 ;; Cambiar fácilmente entre naming conventions (camel, pascal, kebab, snake, etc.)
 (use-package string-inflection)
 ;; Code folding indicators using Tree-sitter
 (use-package treesit-fold-indicators
  :ensure treesit-fold
  :hook (after-init . global-treesit-fold-indicators-mode)
  :init (setq treesit-fold-indicators-priority -1))
 ;; Cross-referencing commands
 (use-package xref
  :autoload xref-show-definitions-completing-read
  :bind (("M-." . xref-find-definitions)
         ("M-," . xref-go-back)
         ("C-." . xref-find-references))
  :init
  ;; Use faster search tool
  (when (executable-find "rg")
    (setq xref-search-program 'ripgrep))
  ;; Select from xref candidates in minibuffer
  (setq xref-show-definitions-function #'xref-show-definitions-completing-read
        xref-show-xrefs-function #'xref-show-definitions-completing-read))
 ;; Code styles
 ;; (use-package editorconfig
 ;;   :diminish
 ;;   :hook (elpaca-after-init . editorconfig-mode))
 ;; Correr el código desde el buffer de emacs
 (use-package quickrun
  :bind (("C-<f5>" . quickrun)
         ("C-S-<f5>"  . quickrun-region)))
 ;; Busqueda rápida con ripgrep
 (use-package rg
  :bind (:map rg-global-map
         ("c" . rg-dwim-current-dir)
         ("f" . rg-dwim-current-file)
         ("m" . rg-menu))
  :config
  (setq rg-group-result t
        rg-show-columns t)
  (cl-pushnew '("tmpl" . "*.tmpl") rg-custom-type-aliases))
 ;; Tree-sitter :)
 (use-package treesit
  :ensure nil
  :commands (treesit-install-language-grammar nf/treesit-install-all-languages)
  :config
  (setq treesit-language-source-alist
        '((bash       . ("https://github.com/tree-sitter/tree-sitter-bash"))
          (c          . ("https://github.com/tree-sitter/tree-sitter-c"))
          (cpp        . ("https://github.com/tree-sitter/tree-sitter-cpp"))
          (css        . ("https://github.com/tree-sitter/tree-sitter-css"))
          (go         . ("https://github.com/tree-sitter/tree-sitter-go"))
          (haskell    . ("https://github.com/tree-sitter/tree-sitter-haskell"))
          (html       . ("https://github.com/tree-sitter/tree-sitter-html"))
          (java       . ("https://github.com/tree-sitter/tree-sitter-java"))
          (javascript . ("https://github.com/tree-sitter/tree-sitter-javascript"))
          (jsdoc      . ("https://github.com/tree-sitter/tree-sitter-jsdoc"))
          (json       . ("https://github.com/tree-sitter/tree-sitter-json"))
          (julia      . ("https://github.com/tree-sitter/tree-sitter-julia"))
          (lua        . ("https://github.com/Azganoth/tree-sitter-lua"))
          (make       . ("https://github.com/alemuller/tree-sitter-make"))
          (python     . ("https://github.com/tree-sitter/tree-sitter-python"))
          (php        . ("https://github.com/tree-sitter/tree-sitter-php" "master" "php/src"))
          (phpdoc     . ("https://github.com/claytonrcarter/tree-sitter-phpdoc"))
          (ruby       . ("https://github.com/tree-sitter/tree-sitter-ruby"))
          (rust       . ("https://github.com/tree-sitter/tree-sitter-rust"))
          (sql        . ("https://github.com/m-novikov/tree-sitter-sql"))
          (toml       . ("https://github.com/tree-sitter/tree-sitter-toml"))
          (tsx        . ("https://github.com/tree-sitter/tree-sitter-typescript" "master" "tsx/src"))
          (typescript . ("https://github.com/tree-sitter/tree-sitter-typescript" "master" "typescript/src"))
          (zig        . ("https://github.com/GrayJack/tree-sitter-zig"))))
  (defun nf/treesit-install-all-languages ()
    "Install all languages specified by `treesit-language-source-alist'."
    (interactive)
    (let ((languages (mapcar 'car treesit-language-source-alist)))
      (dolist (lang languages)
 	    (treesit-install-language-grammar lang)
 	    (message "`%s' parser was installed." lang)
 	    (sit-for 0.75)))))
 ;; Browse devdocs.io documents using EWW
 (use-package devdocs
  :autoload (devdocs--installed-docs devdocs--available-docs)
  :commands (devdocs-install devdocs-lookup)
  :bind (:map prog-mode-map
              ("M-<f1>" . devdocs-dwim))
  :init
  (setq devdocs-data-dir (expand-file-name "devdocs" user-emacs-directory))
  (defun devdocs-dwim()
    "Look up a DevDocs documentation entry.
 Install the doc if it's not installed."
    (interactive)
    ;; Install the doc if it's not installed
    (lambda (slug)
      (unless (member slug (let ((default-directory devdocs-data-dir))
                             (seq-filter #'file-directory-p
                                         (when (file-directory-p devdocs-data-dir)
                                           (directory-files "." nil "^[^.]")))))
        (mapc
         (lambda (doc)
           (when (string= (alist-get 'slug doc) slug)
             (devdocs-install doc)))
         (devdocs--available-docs))))
    ;; Lookup the symbol at point
    (devdocs-lookup nil (thing-at-point 'symbol t))))
 ;; ---------------------------------------------------------------------------
 ;; Miscellaneous Programming Modes
 ;; ---------------------------------------------------------------------------
 (use-package cmake-mode)
 (use-package nginx-mode) ; Modo para leer archivos de configuración de nginx
 (use-package sql
  :ensure nil
  :hook (sql-interactive-mode . toggle-truncate-lines)
  :config
  (setq sql-mysql-login-params (append sql-mysql-login-params '(port))) ;; request port also
  (setq sql-user "root")        ;; user por defecto
  (setq sql-server "127.0.0.1") ;; host por defecto
  (setq sql-port 3306)          ;; puerto por defecto para mysql
  )
 ;; Major mode para editar configuraciones de systemd
 (use-package systemd
  :mode ("\\.container\\'" . systemd-mode))
 ;; Major mode para archivos CSV
 (use-package csv-mode
  ;; :hook ((csv-mode . csv-align-mode)
  ;;        (csv-mode . csv-header-line))
  )
 ;; Modo markdown
 (use-package markdown-mode)
 ;; Modo para edición de arc docker compose
 (use-package docker-compose-mode)
 ;; Modo para la edición de archivos Dockerfile (y building desde emacs)
 (use-package dockerfile-mode
  :config
  ;; Suelo tener podman siempre en lugar de docker, así que lo definimos como el comando a usar
  (setq dockerfile-mode-command "podman"))
 ;; Configuración para project.el
 (use-package project
  :ensure nil
  :config
  ;; Colocamos un título del frame más bonito y útil que el por defecto
  (setq frame-title-format
        '(
          (:eval
           (let ((project-name (kj/project-name)))
             (unless (null project-name)
               (format "[%s] " project-name))))
          "%b"
          " - Emacs")
        )
  )
 (use-package prettier
  :diminish
  :defines prettier-pre-warm
  ;; :hook ((js-base-mode css-mode sgml-mode web-mode) . prettier-mode)
  :init (setq prettier-pre-warm 'none))
 (use-package subword
  :ensure nil
  :init
  (global-subword-mode 1))
 (provide 'init-prog)
 ;;; init-prog.el ends here
--- a/configs/init-theme.el
+++ b/configs/init-theme.el
@@ -12,18 +12,27 @@
 ;;; Code:
 ;; Theme dracula (https://draculatheme.com/) // aún lo tengo en l config porque a Ney le gusta
-(use-package dracula-theme)
+(use-package dracula-theme
  :ensure t
  :defer t)
 ;; El theme más cercano a adwaita dark que he encontrado
-(use-package adwaita-dark-theme)
+(use-package adwaita-dark-theme
  :ensure t
  :defer t)
 ;; Themes modus, vienen integrado en emacs en master (~v30)
-(use-package modus-themes)
+(use-package modus-themes
  :ensure t
  :defer t)
 ;; Themes ef
 (use-package ef-themes
-  :init
+  :defer t
-  (load-theme 'ef-dream t))
+  :ensure t)
 ;; Prendemos el theme que elijamos
 (add-hook 'elpaca-after-init-hook #'(lambda() (load-theme 'adwaita-dark t)))
 ;; Los themes que recomiendo:
 ;; Oscuros: adwaita-dark y ef-dream
--- a/configs/init-ui.el
+++ b/configs/init-ui.el
@@ -1,155 +0,0 @@
 ;; init-ui.el --- Better lookings and appearances.	-*- lexical-binding: t -*-
 ;; Author: kj <webmaster@outcontrol.net>
 ;; URL: https://git.kj2.me/kj/confi-emacs-actual
 ;;; Commentary:
 ;;
 ;; Visual (UI) configurations for better lookings and appearances.
 ;;
 ;;; Code:
 ;; Optimization
 (setq idle-update-delay 1.0)
 (setq-default cursor-in-non-selected-windows nil)
 (setq highlight-nonselected-windows nil)
 (setq fast-but-imprecise-scrolling t)
 (setq redisplay-skip-fontification-on-input t)
 ;; Sidebar a la derecha con los archivos
 (use-package dired-sidebar
  :hook (dired-mode . hl-line-mode)
  :bind ([f9] . dired-sidebar-toggle-sidebar)
  :commands (dired-sidebar-toggle-sidebar)
  :config
  ;; Show directories first
  (setq dired-listing-switches "-la --group-directories-first")
  (setq dired-sidebar-theme 'nerd
        dired-sidebar-window-fixed nil
        ;; dired-sidebar-should-follow-file t
        ;; dired-sidebar-follow-file-idle-delay 0.5
        ))
 ;; Añadir vista de árbol a dired
 (use-package dired-subtree
  :demand t
  :hook (dired-mode . dired-hide-details-mode)
  :bind (:map dired-mode-map
              ("<tab>" . dired-subtree-toggle) ; Toggle subtree view inline
              ("S-<tab>" . dired-subtree-toggle-all) ; Toggle all subtrees
              ("<backspace>" . dired-up-directory) ; Go up one level
              )
  :init
  (setq dired-kill-when-opening-new-dired-buffer t)
  (advice-add 'dired-subtree-toggle :after
              (lambda (&rest _)
                (when (bound-and-true-p nerd-icons-dired-mode)
                  (nerd-icons-dired--refresh)))))
 ;; Show line numbers
 (use-package display-line-numbers
  :ensure nil
  :hook ((prog-mode
          conf-mode toml-ts-mode
          yaml-mode yaml-ts-mode)
         . display-line-numbers-mode)
  :init (setq display-line-numbers-width-start t))
 ;; Suppress GUI features
 (setq use-file-dialog nil
      use-dialog-box nil
      inhibit-startup-screen t
      inhibit-startup-echo-area-message user-login-name
      inhibit-default-init t
      initial-scratch-message nil)
 (unless (daemonp)
  (advice-add #'display-startup-echo-area-message :override #'ignore))
 ;; Display dividers between windows
 (setq window-divider-default-places t
      window-divider-default-bottom-width 1
      window-divider-default-right-width 1)
 (add-hook 'window-setup-hook #'window-divider-mode)
 ;; Mouse & Smooth Scroll
 ;; Scroll one line at a time (less "jumpy" than defaults)
 (when (display-graphic-p)
  (setq mouse-wheel-scroll-amount '(1 ((shift) . hscroll))
        mouse-wheel-scroll-amount-horizontal 1
        mouse-wheel-progressive-speed nil))
 (setq scroll-step 1
      scroll-margin 0
      scroll-conservatively 100000
      auto-window-vscroll nil
      scroll-preserve-screen-position t)
 ;; Smooth scrolling
 (use-package ultra-scroll
  :hook (elpaca-after-init . ultra-scroll-mode))
 ;; Use fixed pitch where it's sensible
 (use-package mixed-pitch
  :diminish)
 ;; Display ugly ^L page breaks as tidy horizontal lines
 (use-package page-break-lines
  :diminish
  :hook (elpaca-after-init . global-page-break-lines-mode)
  :config (dolist (mode '(dashboard-mode emacs-news-mode))
            (add-to-list 'page-break-lines-modes mode)))
 ;; La línea bonita esa de abajo
 (use-package doom-modeline
  :init
  (doom-modeline-mode)
  (setq doom-modeline-project-detection 'auto
        doom-modeline-buffer-file-name-style 'relative-to-project
        doom-modeline-icon t
        doom-modeline-major-mode-color-icon t
        doom-modeline-major-mode-color-icon t
        doom-modeline-buffer-modification-icon t
        doom-modeline-indent-info nil
        doom-modeline-minor-modes nil
        doom-modeline-buffer-encoding nil
        doom-modeline-persp-name t))
 ;; Quitar el modeline, en este caso para ciertos modos solamente
 ;; (use-package hide-mode-line
 ;;   :autoload turn-off-hide-mode-line-mode
 ;;   :hook (((eat-mode
 ;;            eshell-mode shell-mode
 ;;            term-mode vterm-mode
 ;;            embark-collect-mode lsp-ui-imenu-mode
 ;;            pdf-annot-list-mode) . turn-on-hide-mode-line-mode)))
 ;; A minor-mode menu for mode-line
 (use-package minions
  :hook (elpaca-after-init . minions-mode))
 ;; Iconos bonitos para varias cosas
 (use-package nerd-icons)
 ;; nerd-icons en ibuffer
 (use-package nerd-icons-ibuffer
  :hook (ibuffer-mode . nerd-icons-ibuffer-mode))
 ;; Nerd icons para vertico
 (use-package nerd-icons-completion
  :hook (vertico-mode . nerd-icons-completion-mode))
 ;; Usar nerd-icons en dired
 (use-package nerd-icons-dired
  :after nerd-icons
  :hook (dired-mode . nerd-icons-dired-mode)
  :init
  (advice-add 'dired-revert :after
              (lambda (&rest _)
                (when (bound-and-true-p nerd-icons-dired-mode)
                  (nerd-icons-dired--refresh)))))
 (provide 'init-ui)
 ;;; init-ui.el ends here
--- a/configs/init-utils.el
+++ b/configs/init-utils.el
@@ -1,200 +0,0 @@
 ;; init-utils.el --- Initialize ultilities.	-*- lexical-binding: t -*-
 ;; Author: kj <webmaster@outcontrol.net>
 ;; URL: https://git.kj2.me/kj/confi-emacs-actual
 ;;; Commentary:
 ;;
 ;; Some usefule Utilities.
 ;;
 ;;; Code:
 ;; Mejora del reemplazo
 (use-package anzu
  :bind (([remap query-replace] . anzu-query-replace)
         ([remap query-replace-regexp] . anzu-query-replace-regexp)))
 ;; Intercamiar buffers de lugar
 (use-package buffer-move
  :bind (("M-S-<up>" . buf-move-up)
         ("M-S-<down>" . buf-move-down)
         ("M-S-<left>" . buf-move-left)
         ("M-S-<right>" . buf-move-right))
  )
 ;; Cuando inicias un atajo de teclas te muestra las posibilidades
 (use-package which-key
  :diminish
  :init (setq which-key-max-description-length 30
              which-key-lighter nil
              which-key-show-remaining-keys t)
  :hook ( elpaca-after-init . which-key-mode))
 ;; Paquete para exportar buffers de emacs a HTML
 (use-package htmlize)
 ;; eww
 (use-package eww
  :ensure nil
  :init
  ;; Install: npm install -g readability-cli
  (when (executable-find "readable")
    (setq eww-retrieve-command '("readable"))))
 ;; Restaurar el estado de los frames
 (use-package winner
  :ensure nil
  :bind (("s-u" . winner-undo)
         ("s-U" . winner-redo))
  :hook (elpaca-after-init . winner-mode))
 ;; Moverme entre frames
 (use-package windmove
  :ensure nil
  :bind (("M-I" . windmove-up)
         ("M-K" . windmove-down)
         ("M-J" . windmove-left)
         ("M-L" . windmove-right)
         ("M-O" . other-window)
         ("M-o" . other-window)))
 ;; Terminal
 (use-package vterm
  :config
  (setq tramp-histfile-override nil)                  ;; Dejamos que se use el history por defecto del servidor remoto
  (setq vterm-tramp-shells '(("ssh" "/bin/bash")
                             ("sshx" "/bin/bash")
                             ("docker" "/bin/bash")
                             ("podman" "/bin/bash"))) ;; Tanto docker como podman usarán bash cuado se contecte mediante tramp
  )
 ;; Multiple vterm
 (use-package multi-vterm
  :bind (("<f5>" . multi-vterm-dedicated-toggle)
         ("C-x tt" . multi-vterm-dedicated-toggle)
         ("C-x tf" . multi-vterm)
         ("C-x tp" . multi-vterm-project)
         ;;("<tab>" . vterm-send-tab)
         ))
 ;; Mecanografía
 (use-package speed-type
  :hook
  (speed-type-mode . (lambda ()
                       (corfu-mode 0)
                       (display-line-numbers-mode 0)
                       (visual-line-mode 1)
                       (visual-fill-column-mode 1)))
  :diminish
  :config
  (setq speed-type-gb-book-list '(66867 66866 66591 57303 15725 24536)
        speed-type-min-chars 300
        speed-type-max-chars 600))
 ;; Mostrar lo que se está presionando en pantalla
 (use-package keypression
  :config
  (setq keypression-use-child-frame t
        keypression-fade-out-delay 1.0
        keypression-frame-justify 'keypression-left-justified
        keypression-cast-command-name t
        keypression-cast-command-name-format "%s  %s"
        keypression-combine-same-keystrokes t
        keypression-x-offset 50
        keypression-y-offset 100
        keypression-font-face-attribute '(:width normal :height 180 :weight bold))
  )
 ;; Un bonito y sencillo panel de inicio
 (use-package dashboard
  ;; :init
  ;; (dashboard-setup-startup-hook)
  :diminish dashboard-mode
  :custom-face
  (dashboard-heading ((t (:inherit (font-lock-string-face bold)))))
  (dashboard-items-face ((t (:weight normal))))
  (dashboard-no-items-face ((t (:weight normal))))
  :config
  (setq dashboard-set-file-icons t
        dashboard-set-heading-icons t
        dashboard-set-file-icons t
        dashboard-week-agenda nil
        dashboard-agenda-time-string-format "%Y-%m-%d %H:%M")
  (setq dashboard-startup-banner
        (expand-file-name "duck.svg" user-emacs-directory))
  (setq dashboard-items '(
                          ;; (recents . 10)
                          (agenda . 10)
                          ))
  )
 ;; Hydra - Permite crear conjuntos de atajos.
 (use-package hydra
  :defines posframe-border-width
  :functions childframe-workable-p
  :hook (emacs-lisp-mode . hydra-add-imenu)
  )
 ;; Pretty-Hydra - Su nombre ya indica lo que hace
 (use-package pretty-hydra
  :bind ("<f6>" . toggles-hydra/body)
  :hook (emacs-lisp-mode . (lambda ()
                             (add-to-list
                              'imenu-generic-expression
                              '("Hydras"
                                "^.*(\\(pretty-hydra-define\\) \\([a-zA-Z-]+\\)"
                                2))))
  :init
  (cl-defun pretty-hydra-title (title &optional icon-type icon-name
                                      &key face height v-adjust)
    "Add an icon in the hydra title."
    (let ((face (or face 'mode-line-emphasis))
          (height (or height 1.2))
          (v-adjust (or v-adjust 0.0)))
      (concat
       (when (and icon-type icon-name)
         (let ((f (intern (format "nerd-icons-%s" icon-type))))
           (when (fboundp f)
             (concat
              (apply f (list icon-name :face face :height height :v-adjust v-adjust))
              " "))))
       (propertize title 'face face))))
  ;; Global toggles
  (with-no-warnings
    (pretty-hydra-define toggles-hydra (:title (pretty-hydra-title "Toggles" 'faicon "nf-fa-toggle_on")
                                               :color pink :quit-key ("q" "C-g"))
      ("Basic"
       (("n" (cond ((fboundp 'display-line-numbers-mode)
                    (display-line-numbers-mode (if display-line-numbers-mode -1 1)))
                   ((fboundp 'gblobal-linum-mode)
                    (global-linum-mode (if global-linum-mode -1 1))))
         "line number"
         :toggle (or (bound-and-true-p display-line-numbers-mode)
                     (bound-and-true-p global-linum-mode)))
        ("a" global-aggressive-indent-mode "aggressive indent" :toggle t)
        ("d" global-hungry-delete-mode "hungry delete" :toggle t)
        ("e" electric-pair-mode "electric pair" :toggle t)
        ("s" prettify-symbols-mode "pretty symbol" :toggle t)
        ("h" display-time-mode "time" :toggle t)
        ("i" indent-bars-mode "indent bars" :toggle t))
       "Highlight"
       (("l" global-hl-line-mode "line" :toggle t)
        ("p" show-paren-mode "brackets pairs" :toggle t)
        ("b" global-blamer-mode "Git blamer" :toggle t)
        ("r" rainbow-delimiters-mode "rainbow brackets" :toggle t)
        ("w" global-display-fill-column-indicator-mode "fill column indicator" :toggle t)
        ("t" global-hl-todo-mode "todo" :toggle t))
       "Program"
       (("F" flymake-mode "flymake" :toggle t)
        ("f" flyspell-mode "spell check" :toggle t)
        ("u" subword-mode "subword" :toggle t)
        ("v" global-diff-hl-mode "gutter" :toggle t)
        ("V" diff-hl-flydiff-mode "live gutter" :toggle t)
        ("M" diff-hl-margin-mode "margin gutter" :toggle t)
        ("D" diff-hl-dired-mode "dired gutter" :toggle t))
       ))))
 (provide 'init-utils)
 ;;; init-utils.el ends here
--- a/configs/init-vc.el
+++ b/configs/init-vc.el
@@ -1,160 +0,0 @@
 ;;; init-vc.el --- Configuración del control de versiones  -*- lexical-binding: t -*-
 ;; Author: kj <webmaster@outcontrol.net>
 ;; URL: https://git.kj2.me/kj/confi-emacs-actual
 ;;; Commentary:
 ;; Archivo de configuración específico para el control de versiones.
 ;;
 ;; Puedes que hoy en día la norma es usar git para este trabajo,
 ;; la gran mayoría de configuraciones son justamente para el mismo.
 ;;; Code:
 ;; Mostrar el commit de la línea actual
 (use-package blamer
  :ensure t
  :custom
  (blamer-idle-time 0.3)
  (blamer-min-offset 70)
  (blamer-show-avatar-p nil)
  (blamer-max-commit-message-length 80)
  :custom-face
  (blamer-face ((t :foreground "#808080"
                    :background nil
                    :height 100
                    :italic t)))
  :bind ("C-c i" . blamer-show-posframe-commit-info))
 ;; Resolver diferencias entre 2 archivos o versiones del mismo.
 (use-package ediff
  :ensure nil
  :config
  (setq ediff-diff-options "")
  (setq ediff-custom-diff-options "-u")
  (setq ediff-window-setup-function 'ediff-setup-windows-plain)
  (setq ediff-split-window-function 'split-window-vertically))
 ;; Marca a la izq. si una linea ha sido agregada, editada o eliminada desde el último commit.
 (use-package diff-hl
  :custom (diff-hl-draw-borders nil)
  :autoload diff-hl-flydiff-mode
  :custom-face
  (diff-hl-change ((t (:inherit custom-changed :foreground unspecified :background unspecified))))
  (diff-hl-insert ((t (:inherit diff-added :background unspecified))))
  (diff-hl-delete ((t (:inherit diff-removed :background unspecified))))
  :bind (:map diff-hl-command-map
              ("SPC" . diff-hl-mark-hunk))
  :hook ((elpaca-after-init . global-diff-hl-mode)
         (elpaca-after-init . global-diff-hl-show-hunk-mouse-mode)
         (dired-mode . diff-hl-dired-mode))
  :config
  ;; Highlight on-the-fly
  (diff-hl-flydiff-mode 1)
  ;; Set fringe style
  (setq-default fringes-outside-margins t)
  (with-no-warnings
    (unless (display-graphic-p)
      ;; Fall back to the display margin since the fringe is unavailable in tty
      (diff-hl-margin-mode 1)
      ;; Avoid restoring `diff-hl-margin-mode'
      (with-eval-after-load 'desktop
        (add-to-list 'desktop-minor-mode-table
                     '(diff-hl-margin-mode nil))))
    ;; Integration with magit
    (with-eval-after-load 'magit
      (add-hook 'magit-pre-refresh-hook #'diff-hl-magit-pre-refresh)
      (add-hook 'magit-post-refresh-hook #'diff-hl-magit-post-refresh))))
 ;; Visitar rápidamente viejas versiones de un archivo rápidamente
 (use-package git-timemachine
  :custom-face
  (git-timemachine-minibuffer-author-face ((t (:inherit success :foreground unspecified))))
  (git-timemachine-minibuffer-detail-face ((t (:inherit warning :foreground unspecified))))
  :bind (:map vc-prefix-map
         ("t" . git-timemachine))
  :hook ((git-timemachine-mode . (lambda ()
                                   "Improve `git-timemachine' buffers."
                                   ;; Display different colors in mode-line
                                   (if (facep 'mode-line-active)
                                       (face-remap-add-relative 'mode-line-active 'custom-state)
                                     (face-remap-add-relative 'mode-line 'custom-state))
                                   ;; Highlight symbols in elisp
                                   (and (derived-mode-p 'emacs-lisp-mode)
                                        (fboundp 'highlight-defined-mode)
                                        (highlight-defined-mode t))
                                   ;; Display line numbers
                                   (and (derived-mode-p 'prog-mode 'yaml-mode)
                                        (fboundp 'display-line-numbers-mode)
                                        (display-line-numbers-mode t))))
         (before-revert . (lambda ()
                            (when (bound-and-true-p git-timemachine-mode)
                              (user-error "Cannot revert the timemachine buffer"))))))
 ;; Generador automatizado de archivos de licencia
 (use-package license-templates)
 ;; Magia para git
 (use-package magit
  :config
  (setq magit-diff-refine-hunk 'all))
 ;; Todolist en magit de todos los archivos del projecto.
 (use-package magit-todos
  :after magit-status
  :commands magit-todos-mode
  :init
  (setq magit-todos-nice (if (executable-find "nice") t nil))
  (magit-todos-mode 1))
 ;; Modo para resolución de confictos
 (use-package smerge-mode
  :ensure nil
  :config
  (defhydra hydra-smerge (:color pink
                                 :hint nil)
    "
 ^Move^       ^Keep^               ^Diff^                 ^Other^
 ^^-----------^^-------------------^^---------------------^^-------
 _n_ext       _b_ase               _<_: upper/base        _C_ombine
 _p_rev       _u_pper              _=_: upper/lower       _r_esolve
 ^^           _l_ower              _>_: base/lower        _k_ill current
 ^^           _a_ll                _R_efine
 ^^           _RET_: current       _E_diff
 "
    ("n" smerge-next)
    ("p" smerge-prev)
    ("b" smerge-keep-base)
    ("u" smerge-keep-upper)
    ("l" smerge-keep-lower)
    ("a" smerge-keep-all)
    ("RET" smerge-keep-current)
    ("\C-m" smerge-keep-current)
    ("<" smerge-diff-base-upper)
    ("=" smerge-diff-upper-lower)
    (">" smerge-diff-base-lower)
    ("R" smerge-refine)
    ("E" smerge-ediff)
    ("C" smerge-combine-with-next)
    ("r" smerge-resolve)
    ("k" smerge-kill-current)
    ("q" nil "cancel" :color blue))
  )
 (use-package transient)
 ;; Mostrar el último commit que modificó la linea actual
 (use-package vc-msg
  :bind (("C-c C-v" . vc-msg-show))
  )
 (provide 'init-vc)
 ;;; init-vc.el ends here
--- a/configs/lang-go.el
+++ b/configs/lang-go.el
@@ -9,19 +9,8 @@
 ;;; Code:
-(use-package go-ts-mode
+(use-package go-mode
-  :ensure nil
+  :defer t)
  :mode "\\.go\\'"
  :custom
  (go-ts-mode-indent-offset 4)
  (indent-tabs-mode 1)
  :hook
  (go-ts-mode . (lambda ()
                  (add-hook 'before-save-hook
                            (lambda ()
                              (ignore-errors (eglot-code-actions nil nil "source.organizeImports" t))
                              (eglot-format-buffer))
                            nil 'local))))
 (provide 'lang-go)
 ;;; lang-go.el ends here
--- a/configs/lang-html.el
+++ b/configs/lang-html.el
@@ -10,27 +10,26 @@
 ;;; Code:
 (use-package web-mode
  :defer t
  :config
  ;; Add web-mode for .vue files
  (setq web-mode-markup-indent-offset 2
        web-mode-css-indent-offset 2
        web-mode-code-indent-offset 2
        web-mode-enable-current-element-highlight t
        web-mode-enable-current-column-highlight t)
  :init
  ;; web-mode setup for VUE
  (define-derived-mode vue-mode web-mode "Vue")
  (add-to-list 'auto-mode-alist '("\\.vue\\'" . vue-mode))
  )
 (use-package css-mode
  :defer t
  :ensure nil
  :config
  (setq css-indent-offset 2))
 (use-package auto-rename-tag
-  :ensure (:host github :repo "jcs-elpa/auto-rename-tag"))
+  :ensure (:host github :repo "jcs-elpa/auto-rename-tag")
  :defer t
  )
 (provide 'lang-html)
 ;;; lang-html.el ends here
--- a/configs/lang-js.el
+++ b/configs/lang-js.el
@@ -10,17 +10,19 @@
 ;;; Code:
 (use-package js
  :defer t
  :ensure nil
  :mode
  ("\\.js$" . js-mode)
-  :init
+  :hook
-  (add-to-list 'auto-mode-alist '("\\.tsx\\'" . tsx-ts-mode))
+  (js-mode . eglot-ensure)
  (add-to-list 'auto-mode-alist '("\\.ts\\'"  . typescript-ts-mode))
  :config
  (setq js-indent-level 2))
 ;; json-mode
 (use-package json-mode
  :defer t
  :ensure t
  :mode
  ("\\.json$" . json-mode)
  :config
--- a/configs/lang-php.el
+++ b/configs/lang-php.el
@@ -9,56 +9,27 @@
 ;;; Code:
 (use-package php-ts-mode
  :mode "\\.php\\'"
  :ensure nil)
 (use-package php-mode
-  :bind (:map php-mode-map
+  :defer t
-              ("C-c C-f" . nil)
+  :bind ("C-c d b" . kj/php-doc-block)
-              ("C-." . nil)))
+  :config
  (defun kj/php-doc-block ()
    "Llama a \"php-dock-block\", sin conflicto con \"vs-comment-return-mode\"."
    (interactive)
    (if (bound-and-true-p vs-comment-return-mode)
        (funcall (lambda()
                   (vs-comment-return-mode -1)
                   (php-doc-block)
                   (vs-comment-return-mode 1)))
      (php-doc-block)
      )
    )
  )
 (use-package php-doc-block
-  :after php-ts-mode
+  :after php-mode
  :bind ("C-c d b" . php-doc-block)
  :ensure (:host github :repo "moskalyovd/emacs-php-doc-block")
  )
 ;; Consola REPL para php. Similar a "php -a" pero con extras
 (use-package psysh)
 ;; Composer
 (use-package composer)
 ;; PHPUnit
 (use-package phpunit)
 (use-package php-cs-fixer
  :custom
  (php-cs-fixer-config-option (expand-file-name
                               (concat user-emacs-directory "php-cs-fixer-config")))
  :init
  (defcustom php-cs-fixer-before-save-enabled t
    "Enable/disable php-cs-fixer-before-save hook."
    :type 'boolean)
  (defun php-cs-fixer-before-save-toggle ()
    "Toggle php-cs-fixer-before-save hook."
    (interactive)
    (setq php-cs-fixer-before-save-enabled (not php-cs-fixer-before-save-enabled)))
  :hook (
         (before-save . (lambda ()
                          (when php-cs-fixer-before-save-enabled
                            (php-cs-fixer-before-save))))
         )
  )
 (use-package magit-psr
  :ensure (:host github :repo "KJ2ME/magit-psr")
  :custom
  (magit-psr-recent-commits 5)
  (magit-psr-show-warnings t)
  (magit-psr-show-placeholder nil))
 (provide 'lang-php)
 ;;; lang-php.el ends here
--- a/configs/lang-rust.el
+++ b/configs/lang-rust.el
@@ -10,8 +10,8 @@
 ;;; Code:
 (use-package rust-mode
-  :init
+  :defer t
-  (setq rust-mode-treesitter-derive t)
+  :ensure t
  :config
  (setq rust-format-on-save t))
--- a/early-init.el
+++ b/early-init.el
@@ -20,43 +20,28 @@
 ;;
 ;;; Code:
-;; Defer garbage collection further back in the startup process
+;; Disable GC during init
-(setq gc-cons-threshold most-positive-fixnum)
+(put 'gc-cons-percentage 'original-value-before-init gc-cons-percentage)
 (put 'gc-cons-percentage 'value-during-init 0.6)
 (defun restore-gc-cons-percentage-after-init ()
  "Restaura el garbaje collection luego de iniciar."
  (let ((expected-value (get 'gc-cons-percentage 'value-during-init))
        (value-to-restore (get 'gc-cons-percentage 'original-value-before-init)))
    (when (and value-to-restore (equal gc-cons-percentage expected-value))
      (message "Setting `gc-cons-percentage' back to starting value %s" value-to-restore)
      (setq gc-cons-percentage value-to-restore))))
 (add-hook 'after-init-hook #'restore-gc-cons-percentage-after-init)
 (setq gc-cons-percentage (get 'gc-cons-percentage 'value-during-init))
-;; Prevent unwanted runtime compilation for gccemacs (native-comp) users;
+;; Color de fondo similar al theme para evitar que se vea blanco al iniciar
-;; packages are compiled ahead-of-time when they are installed and site files
+;; (add-to-list 'default-frame-alist '(background-color . "#282a36"))
 ;; are compiled when gccemacs is installed.
 (setq native-comp-deferred-compilation nil ;; obsolete since 29.1
      native-comp-jit-compilation nil)
-;; 'use-package' is builtin since 29.
+;; Permitir solo la búsqueda de archivos a cargar en la config en case sensitive.
 ;; It must be set before loading 'use-package'.
 (setq use-package-enable-imenu-support t)
 ;; In noninteractive sessions, prioritize non-byte-compiled source files to
 ;; prevent the use of stale byte-code. Otherwise, it saves us a little IO time
 ;; to skip the mtime checks on every *.elc file.
 (setq load-prefer-newer noninteractive)
 ;; Explicitly set the prefered coding systems to avoid annoying prompt
 ;; from emacs (especially on Microsoft Windows)
 (prefer-coding-system 'utf-8)
 ;; Permitir solo la búsqueda de archivos a cargar en la carpeta config case sensitive.
 (setq auto-mode-case-fold nil)
 ;; Definimos que la shell por defecto será bash
 (setq shell-file-name "/bin/bash")
 ;; Personalizaciones (Tedrían que ir en init-base, pero por optimización, las pongo acá)
 (push '(menu-bar-lines . 0) default-frame-alist)   ; Quitar menús.
 (push '(tool-bar-lines . 0) default-frame-alist)   ; Quitar toolbar.
 (push '(vertical-scroll-bars) default-frame-alist)
 (when (featurep 'ns)
  (push '(ns-transparent-titlebar . t) default-frame-alist))
 ;; Prevent flash of unstyled mode line
 (setq mode-line-format nil)
 ;; Iniciar emacs maximizado
 ;; (add-hook 'window-setup-hook 'toggle-frame-maximized t) ; Hacerlo mediante window-setup-hook (se maximiza al terminar de cargar la ventana)
--- a/init.el
+++ b/init.el
@@ -9,48 +9,19 @@
 ;;; Code:
-;; Optimize Garbage Collection for Startup
+;; Cargar configuraciones
 (setq gc-cons-threshold most-positive-fixnum)
-;; Optimize `auto-mode-alist`
+(add-to-list 'load-path (concat user-emacs-directory "configs"))
 (setq auto-mode-case-fold nil)
 (unless (or (daemonp) noninteractive init-file-debug)
  ;; Temporarily suppress file-handler processing to speed up startup
  (let ((default-handlers file-name-handler-alist))
    (setq file-name-handler-alist nil)
    ;; Recover handlers after startup
    (add-hook 'emacs-startup-hook
              (lambda ()
                (setq file-name-handler-alist
                      (delete-dups (append file-name-handler-alist default-handlers))))
              101)))
 ;; Función para añadir 'config' a la ruta de carga código elisp de emacs
 (defun update-load-path (&rest _)
  "Update the `load-path` to prioritize personal configurations."
    (push (expand-file-name "configs" user-emacs-directory) load-path))
 ;; Nos aseguramos de que ejecute 'update-load-path' antes de 'package-initialize'
 (advice-add #'package-initialize :after #'update-load-path)
 ;; Ahora lo corremos implícitamente
 (update-load-path)
 ;; Paquetes base
 (require 'init-package)
 (require 'init-base)
 (require 'init-utils)
 (require 'init-ui)
 (require 'init-editor)
 (require 'init-prog)
 (require 'init-highlight)
 (require 'init-theme)
-(require 'init-ai)
+(require 'init-packages)
-(require 'init-vc)
+(require 'init-functions)
 (require 'init-org)
-(require 'init-lsp)
+(require 'init-eglot)
-(require 'init-completion)
+(require 'init-corfu)
 ;; (require 'init-ctags)
 (require 'init-minibuffer)
 ;; (require 'init-evil)
 (require 'init-keys)
--- a/24
+++ b/24
@@ -1,24 +0,0 @@
 #!/usr/bin/php
 <?php
 error_reporting(E_ALL);
 $finder = \PhpCsFixer\Finder::create();
 $config = new \PhpCsFixer\Config();
 $config->setRules([
    '@PSR12' => true,
    'ordered_imports' => ['sort_algorithm' => 'alpha'],
    'concat_space' => ['spacing' => 'one'],
    'whitespace_after_comma_in_array' => true,
    'align_multiline_comment' => true,
    'no_unused_imports' => true,
    'phpdoc_align' => true,
    'phpdoc_indent' => true,
    // 'psr_autoloading' => true,
    'no_useless_return' => true,
    'return_assignment' => true,
    'trailing_comma_in_multiline' => true,
 ])->setRiskyAllowed(true);
 return $config->setFinder($finder);
--- a/private/.custom.el
+++ b/private/.custom.el
--- a/readme.org
+++ b/readme.org
@@ -41,6 +41,7 @@ Como ayuda lo más que puedo dar es que en las distros basadas en Debian puedes
 Normalmente no es usual el tener dependencias reales para que emacs funcione, pero para el funcionamiendo adecuado y sin errores, lo mejor es tener instalado:
 - El font de firacode
 - cmake
 - libvterm
@@ -52,11 +53,11 @@ Finalmente, recomiendo instalar [[https://github.com/blahgeek/emacs-lsp-booster]
 * Atajos de teclas personalizados
-Tengo varios atajos reconfigurados, por lo que recomiento revisar primero que nada el archivo [[./configs/init-keys.el][init-keys.el]] el resto de configuraciones está principalmente en los archivos [[./configs/init-minibuffer.el][init-minibuffer.el]] e [[file:configs/init-editor.el][init-editor.el]], dudo que las uses todas y yo mismo no las uso, por lo que con el tiempo las voy eliminando y a veces agrego alguna extra. Con que revises el primer archivo y sepas que =consult-project= está en =C-x p= ya estás servido.
+Tengo varios atajos reconfigurados, por lo que recomiento revisar primero que nada el archivo [[./configs/init-keys.el][init-keys.el]] el resto de configuraciones está principalmente en los archivos [[./configs/init-minibuffer.el][init-minibuffer.el]] e [[./configs/init-packages.el][init-packages.el]], dudo que las uses todas y yo mismo no las uso, por lo que con el tiempo las voy eliminando y a veces agrego alguna extra. Con que revises el primer archivo y sepas que =consult-project= está en =C-x p= ya estás servido.
 * Contacto
 Si se tiene alguna pregunta o quieres comentarme alguna corrección, puesto que este git no está abierto a registro, puedes contactarme mediante:
-*Correo*: webmaster@outcontrol.net
+E-mail: webmaster@outcontol.net
-*Telegram*: [[https://t.me/keyjay][@keyjay]]
+Telegram: [https://t.me/keyjay](https://t.me/keyjay)