Comience con una instrucción clara: Buscar ahora a través de repositorios, usuarios, problemas y solicitudes de extracción, y presionar refresh para ver resultados inmediatamente. Eso mantiene tu workflow suave y tu equipo en la misma página.
También puede refinar los resultados por types (repo, user, issue, PR) y combine criterios como autor, etiqueta, estado o text content. La consulta admite html fragmentos y palabras clave sencillas, con resultados actualizándose a medida que escribe para un window de relevancia.
Almacenar y reutilizar consultas con sincronizar a través de dispositivos y compartir un token-friendly, versionenfoque ed. ignore eliminar los resultados innecesarios y centrarse en lo que importa.
Para la localización, deepl and translateyml están integrados para que pueda traducir las descripciones sobre la marcha, y luego consultar la traducción input_file_path or files en tus documentos.
Todas las búsquedas se ejecutan en un entorno seguro token-ambiente protegido, con supported features across version actualizaciones y un window para acceso rápido a los resultados.
Repositorios, Usuarios, Problemas y Solicitudes de extracción: ámbito de búsqueda práctico
Entradas de búsqueda enfocadas y diseño de consultas
Recomendación: Construye un ámbito de búsqueda específico basado en el repositorio, el usuario y el estado del problema/PR. Utiliza un token para el acceso a la API de GitHub y restringe los resultados a las ejecuciones de flujo de trabajo ubuntu-latest. Incluye restricciones de ruta como paths:/src y paths:/docs para centrarse en los cambios significativos. Utiliza filtros basados en el estado, las etiquetas y la actividad para mejorar la precisión, y considera filtros adicionales como el asignado y el hito para afinar la señal. También, guarda la configuración en input_file_path para su reutilización.
Represent the query as a small json structure and store it in input_file_path. Example: { "repository": "owner/repo", "user": "octocat", "types": ["issue","pull_request"], "status": "open", "paths": ["src/","tests/"], "window": 30, "version": "v2" }. The usage of types and json ensures consistent results and easy reloading across runs. The target is a compact payload that adapters can consume, that you can edit with any editor.
Filtrar por flujo de trabajo y ejecuciones: buscar ejecuciones de flujo de trabajo donde el nombre coincida con un flujo de trabajo y la ejecución se haya concluido correctamente. Limitar a ubuntu-latest para alinear con la compatibilidad. Utilizar referencias a los cuerpos y texto de problemas y PR para un triage rápido, y ordenar por updated_at para mostrar los elementos más procesables. Esto funcionará con fuentes de datos de github y se puede extender a otros repositorios.
Cuando necesite exploración interactiva, importe los resultados a un panel de control HTML. El modelo de datos guarda las rutas y referencias al repositorio contenedor, de modo que puede hacer clic para llegar al destino y volver a cargar para actualizar con datos frescos. Puede consultar los historiales guardados y usar las métricas de uso para planificar los siguientes pasos. Además, asegúrese de la compatibilidad con los entornos implementados; este enfoque es compatible con complementos modulares y puede sincronizarse entre sistemas.
Formatos de datos, campos y resultados prácticos
Superficie un conjunto compacto de campos para cada entidad: repositorio, número, título, texto, autor, estado, creado_at, actualizado_at y enlaces relevantes. Para problemas, incluya el texto del cuerpo y las etiquetas; para PR, incluya las ramas base y head, el estado fusionado y el merge_commit_sha. Exponga una ventana de ejecuciones recientes y muestre el flujo de trabajo, el estado del trabajo y la duración. El payload de json debe admitir matrices para rutas y etiquetas y una estructura anidada para comprobaciones y revisiones. github-fuentes impulsadas garantizan la precisión.
Salida y reutilización: guardar resultados en una ubicación reservada y sincronizar con tu despliegue. Usa input_file_path para referenciar la consulta de origen y asegurar que un solo token pueda actualizar los datos. Si se necesita traducción, ejecuta translateyml con deepl_api_key para producir texto localizado manteniendo los metadatos. El sistema gestionará las variaciones de mayúsculas y mantendrá una versión estable para prevenir derivas. Las configuraciones desplegadas también pueden ser monitoreadas a través de un informe de uso sencillo.
Orientación operativa: mantener un flujo de trabajo ligero y robusto que se active en actualizaciones de input_file_path, se recargue automáticamente y envíe cambios incrementales a la interfaz de usuario. Este enfoque facilita el seguimiento de los cambios en github, con la ventana, el objetivo y las rutas que proporcionan un análisis exhaustivo de la actividad del repositorio.
Búsquedas guardadas: crea, guarda y reutiliza filtros para acelerar los resultados
Create a saved search for issues and PRs you work on most. Use your token to sign requests and ensure usage is restricted to your team. Name it clearly and store it in a folder like "MyFilters" for quick access; this keeps case, path, and language filters aligned across sessions. You can also use deepl to translate descriptions for international teams, while keeping target_languages consistent.
Las búsquedas guardadas admiten el idioma y target_languages, y puedes construir filtros anidados que combinen el repositorio, el tipo (problemas, solicitudes de extracción), el estado y los patrones de ruta. La sintaxis similar a HTML mantiene las consultas legibles, y los resultados se actualizarán cuando lleguen nuevos datos. Esto también te ayuda a comparar resultados entre idiomas y tipos con un solo clic.
¿Qué guardar y cómo nombrarlo?
- Problemas en un repositorio específico con etiquetas como frontend o backend, filtrados por estado abierto, asignados a ti y vinculados a rutas particulares
- Solicitudes de extracción con estado abierto o que necesitan revisión, destacando revisiones importantes y relacionadas con ramas de destino
- Búsquedas de código por lenguaje y target_languages, con tipos de archivo como html, js, ts, py
- **Eventos y ejecuciones de flujo de trabajo**, incluyendo `workflow_dispatch`, para previsualizar qué inicia una ejecución y cómo afecta al repositorio
- Filtros anidados que combinan repositorio, tipos de issue/pr y condiciones basadas en la ruta para obtener resultados precisos
- Nombres descriptivos y comentarios en la carpeta que utilice, para que los colegas puedan reutilizar los mismos filtros
Practical workflow and tips
- Defina una búsqueda guardada una vez y luego reutilícela en diferentes sesiones; use recargar o actualizar para aplicar las actualizaciones.
- Almacenar en una carpeta dedicada, compartible con tokens firmados para colaboradores
- Link issues and repository events, and include target languages to surface multilingual contexts
- Synchronize saved searches with your workflow, and run a demo to verify results
- Use the results as the basis for html dashboards and html-like reports you can embed in pages
Inputs: crafting queries for nested locale JSON data
Load input_file_path to access the locale JSON and have a clear root to target. Use a dot-path like locales.en.issues to drill into nested data with precision. Refresh the dataset after changes to keep results current and synchronized with the repo.
- Plan your query with the following inputs: input_file_path, token, translateyml, ignore, synchronize. The data model is nested and such json values reside under locales.{code}.{section}.{field}.
- Target specific sections: locales.en.issues, locales.de.files, etc. Use a wildcard like locales.*.issues.* to collect all issue texts and titles. This keeps your results focused and scalable.
- Enforce value types: types help you distinguish between strings for titles and arrays for issue lists. Validate that your output has string leaf values for translations and objects for bundles.
- Ignore non-translated keys: set ignore to skip metadata or signed fields. This keeps results focused on actual translations and avoids noise.
- Export formats: produce json for programmatic consumption and translateyml for localization pipelines. You can also refer to another target format if needed.
- Authentication and safety: pass token to access the repo or demo environment. Use signed tokens and keep them secret. The token can be refreshed by a refresh operation to avoid expiry.
- Environment and runs: run on ubuntu-latest and verify results in a window that shows an interactive demo step. A star rating can indicate confidence in each path, and you can reload results after each run to confirm consistency.
- Synchronization: synchronize the outputs with another repository or window; you may want to reload a file in input_file_path and reference its latest values in your target workflow.
- Performance tips: keep payloads small by limiting to locales.*.{en,fr}.issues; for large datasets, produce paginated results and cache them to refresh quickly.
- Validation: refer to the schema by field types to catch mismatches early; validate with a lightweight json schema before integrating into your translation workflow.
- Pro tip: base your approach on a minimal subset first, then expand to cover more languages. This keeps iteration fast and makes it easy to roll back if a path proves inconsistent.
Inputs: querying standard text files (MD, HTML, XML, TXT)
Use a fast, repository-wide search against input_file_path for MD, HTML, XML, and TXT files. Run on ubuntu-latest to align with GitHub Actions runners and keep your workflow predictable.
Point input_file_path to the folder you want to scan; the search engine recurses into nested subfolders. Enable case-insensitive matching and set patterns like *.md, *.html, *.xml, *.txt. The tool saves results to saved.json and can also emit a second payload labeled saved,json for compatibility with downstream tools.
Return fields include repository, input_file_path, path, line, snippet, file_type, and score. Organize matches by file type and allow filtering by text versus code blocks. You can refer to issues in the repository to refine search queries and improve relevance, then synchronize results across your workflow and deployed environments.
Translateyml integration helps when you need translated summaries of matched content; you can apply translation before indexing and keep a consistent case for multilingual teams. This workflow also supports nested folders and a simple demo mode to validate results before large scans.
Implementation tips
Create a workflow_dispatch-enabled job that runs on ubuntu-latest, checks out the repository, and executes the search against input_file_path. Pass a primary folder and an optional another input_file_path for side scans. Ensure saved.json is written to the workspace and that a secondary saved,json payload is produced for another consumer. Keep the file patterns tight to avoid noisy matches in binary assets and large binaries stored in the folder.
Expose inputs as workflow inputs so your team can trigger scans on demand. After the run, store metadata like star counts on the repository and link results to related issues to keep your team synchronized. If you deploy a demo, reference workflow_dispatch in the UI to show users how to reproduce the scan locally.
Output insights and extensions
Use the saved.json to feed dashboards or to generate a concise summary in your next workflow step. The path, line, and snippet fields help reviewers quickly locate relevant content across folder structures. For an expanded view, aggregate results by file_type and by folder, then export to another tool that consumes JSON with the same structure. This approach scales from a single repository to a fleet of repositories, keeping your search aware of your case preferences and your overall workflow health.
DeepL Translate GitHub Action: setup and workflow tips
Store your DeepL API key as a GitHub secret and reference it in translateyml to keep credentials safe and out of the codebase. In the workflow, load the secret as secrets.deepl_api_key and pass it to the action via an environment variable, ensuring the key never appears in logs.
Create a translateyml at the repository root to define what to translate and where to place the output. In this file, specify language and languages, set a target for each language, and mark HTML content with a type of html so text formatting stays intact. Use ignore to skip binary assets and code blocks that don’t need translation.
Pin the runner to ubuntu-latest to leverage the latest toolchains and compatible dependencies. Start with actions/checkout to fetch code, then run the DeepL step with the proper inputs for text or html and the language mapping from translateyml.
Keep translations synchronized with the source by using a refresh cycle when the source text changes. If you change the source in the repository, trigger a reload of the translation step and push the updated files back, preferably with signed commits to track changes.
Where outputs land matters: save translations under a target directory in the repository, for example translations/, so reviewers can quickly inspect diffs. The saved files can be text files or json depending on your setup, and you can choose a window for review before merging.
Usage tips: monitor throughput and usage quotas, especially on free plans. Keep language coverage aligned with your audience by updating the languages list in translateyml, and add new target languages as needed.
Workflow patterns: use on: push and on: pull_request, filter by paths to limit runs, and consider a schedule using ubuntu-latest for periodic checks. Ensure to ignore non-text assets and maintain case handling consistently across languages.
Engagement: when the workflow delivers translations, a visible star in the PR title helps teammates recognize updates, and you can reference the translation window in the PR description.
Demo: live walkthrough with tags and saved searches
Begin by loading input_file_path from your repository and create a saved search that targets issues with a tag like "review". The demo runs in a deployed environment and shows real-time results as you refine the tag set and paths.
Use the search bar to combine language-based filters with specific usage patterns. The html-like interface will reload results when you adjust token, paths, or saved search names, keeping you in the flow without refreshing the page.
Saved searches reference output_file_name_pattern so you can export results as json or html-like reports. Refer to the configuration in the repository and watch the saved search persist across reloads and new sessions.
Configure input_file_path, folder, and token to access the GitHub repository. The system supports json configuration files and can pull issues, pull requests, and repository metadata. If needed, deepl can translate long descriptions, with saved searches exporting to json for downstream tooling.
During the walkthrough, try another scenario: filter issues by label, author, and status, then save and name the search for later reuse.
| Step | Action | Expected result |
|---|---|---|
| 1 | Load input_file_path from demo_inputs and connect to github with a token. | Live results for issues, pull requests, and repository paths appear in the list. |
| 2 | Apply tag filters: [bug, review] and path /src/**. | Matching issues and PRs show up immediately; counts update in real time. |
| 3 | Save this search as "Bug-review with paths" using output_file_name_pattern "export_YYYYMMDD.json" and folder saved_searches. | Saved search entry created; status shows saved; you can refer to it later and reload it quickly. |
| 4 | Run the search against another input_file_path and reload. | Results refresh from the new file while the saved search remains available. |
| 5 | Export results to json with output_file_name_pattern "demo_export_*.json"; ensure repository folder and signed status are included. | A json file is created in the output location; entries include issues, repository, paths, and signed flags. |
El flujo de trabajo de demostración utiliza componentes similares a HTML para presentar los datos de forma clara, con referencias guardadas de input_file_path, carpeta y token. Puede referenciar cada configuración de búsqueda guardada desde la interfaz de usuario, y el sistema volverá a cargar y mostrará automáticamente los resultados más recientes.
Ejemplo de uso: JSON de ubicación local anidado, archivos de texto estándar y JSON de ubicación local con búsquedas guardadas
Entrada JSON de localización anidada
Use a nested locale JSON as the primary source in your workflow. The repository path faciles the import, and the output_file_name_pattern formats per-language files under the target folder, for example locales/{target}/v{version}.json. Structure keys by language, with deeper nesting like "en": {"repository": {"issues": {"open": "Open"}}}. The case setting controls capitalization rules during translation, and types marks the input as nested. Configure workflow_dispatch to trigger on demand, specify target_languages, and pass version to label outputs. The workflow reads the nested keys, translates to each language via deepl, and writes json outputs that match the expected schema. Include a demo json to verify the mapping, and keep the pipeline based on translateyml with deepl_api_key for secure access. Synchronize the nested structure across languages, then reload changes to keep outputs aligned with the source.
En este escenario, establece el objetivo a idiomas como en, fr, de, es y asegúrate de que la ruta de la carpeta exista antes de la implementación. El campo del repositorio apunta a tu proyecto principal, mientras que runs captura cada intento de traducción. Utiliza los campos guardados para marcar las traducciones completadas y firma una vez que la revisión esté terminada. Este enfoque produce salidas json limpias y versionadas que puedes implementar directamente desde GitHub.
Archivos de texto estándar y JSON de configuración regional con búsquedas guardadas
Para archivos de texto estándar, almacena cadenas como líneas clave=valor o entradas JSON simples, luego deja que el flujo de trabajo las mapee a target_languages y produzca JSON por idioma bajo el mismo patrón de nombre de archivo de salida. Mantén los tipos de entrada simples para acelerar el procesamiento, y coloca la fuente en una carpeta como texts. Los resultados traducidos aparecen en la carpeta de destino y se pueden implementar sin ediciones manuales. Un JSON de búsquedas guardadas dentro del JSON de ubicación regional agrega consultas predefinidas, para que puedas reutilizar términos comunes en diferentes ejecuciones. El indicador guardado marca las traducciones completadas, y el atributo firmado indica la aprobación del revisor. Utiliza workflow_dispatch para recargar búsquedas guardadas, sincronizarlas entre idiomas y generar salidas actualizadas.
When you include saved searches, attach a list like "searches": [{"name": "Open issues", "query": "state:open"}, {"name": "PRs awaiting review", "query": "is:pull_request is:open review:pending"}], and set types to saved_json. The translateyml config uses deepl and deepl_api_key to produce json outputs that reflect the saved searches, while versioning keeps history intact. Deploy these outputs to a target repository and verify the deployed artifacts in the output folder before promoting to production.
