Start with a clear instruction: Search now across repositories, users, issues, and pull requests, and press refresh to see results immediately. That keeps your workflow smooth and your team on the same page.

You can also narrow results by types (repo, user, issue, PR) and combine criteria like author, label, status, or text content. The query supports html snippets and simple keywords, with results updating as you type for a window of relevance.

Store and reuse queries with synchronize across devices and share a token-friendly, versioned approach. ignore unneeded results and focus on what matters.

For localization, deepl and translateyml are integrated so you can translate descriptions on the fly, then refer to the translated input_file_path or files in your docs.

All searches run in a safe token-protected environment, with supported features across version updates and a lightweight window for fast access to results.

Repositories, Users, Issues, and Pull Requests: practical search scope

Focused search inputs and query design

Recommendation: Build a targeted search scope based on repository, user, and issue/PR status. Use a token for github API access and constrain results to ubuntu-latest workflow runs. Include path constraints such as paths:/src and paths:/docs to focus on meaningful changes. Use filters based on status, labels, and activity to boost precision, and consider additional filters like assignee and milestone to tighten the signal. Also, save the configuration to input_file_path for reuse.

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.

Filter by workflow and runs: search for workflow runs where the name matches a workflow and the run concluded successfully. Limit to ubuntu-latest to align with compatibility. Use refer to bodies and text of issues and PRs for quick triage, and sort by updated_at to surface the most actionable items. This will work with github data sources and can be extended to other repos.

When you need interactive exploration, pull results into an html dashboard. The data model saves paths and references to the containing repository, so you can click through to the target, and reload to refresh with fresh data. You can refer to saved histories and use usage metrics to plan next steps. Also, ensure compatibility with deployed environments; this approach is supported by modular plugins and can synchronize across systems.

Data formats, fields, and practical results

Surface a compact set of fields for each entity: repository, number, title, text, author, state, created_at, updated_at, and relevant links. For issues include body text and labels; for PRs include base and head branches, merged status, and merge_commit_sha. Expose a window of recent runs and show workflow, job status, and duration. The json payload must support arrays for paths and labels and a nested structure for checks and reviews. github-powered sources ensure accuracy.

Output and reuse: save results to saved location and synchronize with your deployment. Use input_file_path to reference the source query and ensure that a single token can refresh data. If translation is needed, run translateyml with deepl_api_key to produce localized text while preserving metadata. The system will handle case variations and maintain a stable version to prevent drift. Deployed setups can also be monitored via a simple usage report.

Operational guidance: keep a lightweight, robust workflow that will trigger on input_file_path updates, reload automatically, and push incremental changes to the UI. This approach makes it easy to track changes across github, with the window, target, and paths providing precise drill-down into repository activity.

Saved Searches: create, save, and reuse filters to speed results

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.

Saved searches support language and target_languages, and you can construct nested filters that combine repository, type (issues, pull requests), status, and path patterns. The html-like syntax keeps queries readable, and results will refresh when new data arrives. This also helps you compare results across languages and types with a single click.

What to save and how to name it

Practical workflow and tips

  1. Define a saved search once, then reuse it across sessions; use reload or refresh to apply updates
  2. Store in a dedicated folder, shareable with signed tokens for collaborators
  3. Link issues and repository events, and include target languages to surface multilingual contexts
  4. Synchronize saved searches with your workflow, and run a demo to verify results
  5. 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.

  1. 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}.
  2. 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.
  3. 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.
  4. Ignore non-translated keys: set ignore to skip metadata or signed fields. This keeps results focused on actual translations and avoids noise.
  5. Export formats: produce json for programmatic consumption and translateyml for localization pipelines. You can also refer to another target format if needed.
  6. 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.
  7. 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.
  8. 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.
  9. Performance tips: keep payloads small by limiting to locales.*.{en,fr}.issues; for large datasets, produce paginated results and cache them to refresh quickly.
  10. Validation: refer to the schema by field types to catch mismatches early; validate with a lightweight json schema before integrating into your translation workflow.
  11. 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/<language>, 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.

StepActionExpected result
1Load 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.
2Apply tag filters: [bug, review] and path /src/**.Matching issues and PRs show up immediately; counts update in real time.
3Save 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.
4Run the search against another input_file_path and reload.Results refresh from the new file while the saved search remains available.
5Export 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.

The demo workflow uses html-like components to present data clearly, with saved input_file_path, folder, and token references. You can refer to each saved search configuration from the UI, and the system will reload and render the latest results automatically.

Example usage: nested locale JSON, standard text files, and locale JSON with saved searches

Nested locale JSON input

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.

In this scenario, set target to languages like en, fr, de, es and ensure the folder path exists before deploy. The repository field points to your main project, while runs capture each translation attempt. Use saved fields to mark completed translations, and sign off once review is done. This approach yields clean, versioned json outputs that you can deploy directly from GitHub.

Standard text files and locale JSON with saved searches

For standard text files, store strings as key=value lines or simple json entries, then let the workflow map them to target_languages and produce per-language json under the same output_file_name_pattern. Keep the input types simple to speed up processing, and place the source into a folder such as texts. The translated results appear in the target folder and can be deployed without manual edits. A saved searches JSON within locale JSON adds predefined queries, so you can reuse common terms across runs. The saved flag marks completed translations, and the signed attribute notes reviewer approval. Use workflow_dispatch to reload saved searches, synchronize them across languages, and generate updated outputs.

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.