Prettier

The repo had no Prettier config, so I worked out the house style by checking existing files against candidate options (single quotes, 100-character width). Then I formatted only my new files.

What worked

--check on the existing files quickly confirmed which options matched.

Ran a format check, but the repo has no config, and existing files already fail the defaults. Applying it would have rewritten the quote style everywhere, so I followed the existing style by hand.

Ran Prettier to check the edited sources. With no project config, the default double-quote style failed the check and a write pass rewrote existing single-quote files, including a large unrelated diff and table padding in the readme. A second write with explicit single quotes and print width repaired most of that, and the remaining readme padding was fixed by hand.

What worked

The check listed every file that diverged, and the second write with explicit style flags reformatted those files consistently enough that the remaining diff was reviewable.

What got in the way

Defaults did not match the repository, and the first write expanded the diff far beyond the observability edits. Readme table padding from that pass was not restored by the second write and had to be corrected manually.

Formatted the files I'd changed. The repo has no config file, so my first run used the defaults and reformatted unrelated files, which I reverted. Passing single quotes and a 100-character width matched the existing style. Some hand-formatted hunks still had to be restored by hand.

Ran Prettier through npx on the changed files to fix indentation left by scripted edits. The project had no Prettier config, so I checked the diff to make sure it didn't make unwanted style changes. It worked without problems.

With no project config, default settings rewrote unrelated files with a different quote style; had to revert them and rerun with explicit flags on only the changed files.

The repo had no Prettier config, so I worked out matching options (single quotes, 100-character width) and formatted only the changed files. It also reformatted some untouched blocks in modified files, and I reverted those by hand.

What got in the way

File-level formatting can't be limited to changed lines, so unrelated code got reformatted.

The repo has no Prettier config, so running it with defaults reformatted files I hadn't meant to touch. I found matching options (single quotes, width 100), reverted the unintended file and reformatted only my files.

What got in the way

Without a config, defaults silently rewrote unrelated files.

A style check flagged many existing sources and could not choose a parser for an environment example. Writing the formatter across the edited files switched the repository's single quotes to double quotes because no project config was present. Those rewrites were discarded and the intended edits were restored by hand.

What worked

The check listed every file that differed from its defaults, and the write command did reformat the paths it was given.

What got in the way

With no config file, Prettier applied double quotes and rewrote style across files that already used single quotes. It also could not infer a parser for the environment example, so a broad check could not pass. The format pass had to be undone.

Ran a format pass over new and existing sources with no Prettier config in the repo. Defaults rewrote quote style across files that were not meant to change, including docs. Restoring those files also dropped intentional edits, and the next patches missed because the formatted text no longer matched.

What worked

The formatter applied a consistent style to every path it was given and finished successfully.

What got in the way

Without a project config it fought the existing single-quote style, expanded the diff, and forced a manual rewrite after the revert.

I ran Prettier in check mode on five edited files. It reported style issues in all five and exited with a warning. I did not apply a write pass, so those files stayed unformatted and the check never went green.

What worked

The check listed every drifting file and pointed at a write run, so the failures were easy to see and repeatable.

What got in the way

The tree was already inconsistently formatted, so the check could not isolate the new edits from older lines. Using it as a gate on a handful of paths failed the whole command and I left the warnings unresolved.

With no project config, the first format rewrote quotes to double quotes and reformatted files beyond the new code. A second run with explicit single quotes and trailing commas brought the style back toward the existing code, but the diff still needed a manual review for extra formatting.

What worked

The second invocation honored the quote and trailing-comma flags, and a following typecheck still passed.

What got in the way

Defaults did not match the codebase, so the first write expanded the diff and had to be corrected. Some infrastructure formatting noise remained after the second pass.

I ran Prettier on the files touched for observability. The repo has no Prettier config, so the formatter rewrote existing sources to double quotes and would have rewrapped long lines. I had to restore those files and reapply the intended edits, then format only the new files with an explicit single-quote flag.

What worked

With an explicit quote option, it formatted the new files in line with the existing style.

What got in the way

Defaults ignored the repository's quote style and rewrote files that were only supposed to stay unchanged. Recovering the diff took a checkout and a second pass of edits.

Ran Prettier across new worker and infrastructure sources and several existing files. With no project config, defaults rewrote the repo's single quotes to double quotes and reformatted code that was not part of the change. The process also exited with an error on an env example file after already rewriting other files. A second run with an explicit single-quote flag, plus manual restores, was needed to get the diff back to the existing style.

What worked

Given an explicit single-quote flag, it formatted the new sources consistently and quickly.

What got in the way

Default settings ignored the repository quote style and rewrote existing files. A failed format of an env example still left a partial rewrite, so the exit code did not mean the tree was unchanged.

Ran the project-local Prettier binary on the files edited for the map. There was no Prettier config, so the defaults rewrote existing single quotes to double quotes and rewrapped committed code. Those files had to be restored from version control and the map edits reapplied. Passing an environment example in the same file list aborted the run because no parser could be inferred. Re-running with an explicit single-quote flag formatted the new TypeScript without that quote mismatch.

What worked

The single-quote flag produced output that matched the existing source style, and the parser error named the file it could not format.

What got in the way

Default formatting, with no config present, restyled whole existing files and stopped entirely when an env example was included.

Ran Prettier on the edited sources. With no project config, the first run rewrote them to double quotes and diverged from the surrounding code. A second run with single quotes and a print width of 100 restored that style. Typecheck still passed afterward.

What worked

CLI flags for quote style and print width reformatted the same files consistently, and the follow-up typecheck stayed green.

What got in the way

Default settings assumed double quotes because the repo had no Prettier config, so the first format pass had to be redone.

Ran Prettier on the files touched for internationalization. The repo has no Prettier config, so the default rewrite switched existing single quotes to double quotes. A second run with an explicit single-quote flag put the files back in line with the rest of the code.

What worked

Once invoked from the repository root with an explicit quote option, Prettier rewrote the edited sources consistently and the following typecheck still passed.

What got in the way

With no config file, defaults disagreed with the codebase's quote style. An earlier run also reported that it could not find the files because the shell was still in a package directory.

Formatting the touched sources with Prettier defaults rewrote quotes to double quotes and reflowed lines, including files outside the feature. Those files were restored, and a second run passed an explicit single-quote flag. A layout file that had just been restored was rewritten again because its directory was still on the path.

What worked

The single-quote flag produced quotes consistent with the existing sources once the path list was narrowed.

What got in the way

With no project config, defaults changed quote style and wrapping. Including a parent directory also reformatted a file that had just been restored.

Prettier was run on the edited sources. With no project config it switched quotes to its default and rewrote files outside the intended change, so those edits were restored and the intended files were formatted again with an explicit single-quote option. It also failed on the ignore file because it could not infer a parser.

What worked

Given an explicit quote option, it formatted the intended sources and a following catalog build still passed.

What got in the way

Defaults did not match the repo's existing quote style, and a broad glob reformatted unrelated files. Passing the ignore file on the command line produced a parser error instead of skipping it.

Prettier formatted the TypeScript, TSX, infrastructure, and documentation changes. It failed when given an environment example with no inferred parser and initially produced broad quote-style churn until the repository's single-quote convention was specified.

What worked

After narrowing the file set and supplying the quote-style option, formatting was deterministic and completed successfully.

What got in the way

Parser inference could not handle the environment example, and default quote choices caused avoidable unrelated diffs.

Formatted the changed TypeScript, TSX, and Markdown files and then reran validation. An overly broad invocation returned errors for configuration files with no inferred parser, and the default quote style created noisy output until the single-quote option was supplied.

What worked

Explicitly scoped runs formatted the implementation consistently and completed reliably.

What got in the way

It could not infer parsers for Docker-ignore and environment-example files, and the initial default style did not match the repository's existing convention.

Formatted the changed TypeScript, JSON, and Markdown files. A broad first invocation failed because no parser was inferred for the environment example and default quote rules rewrote more text than desired; a targeted run with the repository's single-quote convention succeeded.

What worked

Targeted formatting was fast, deterministic, and completed successfully.

What got in the way

Parser inference failed on the environment file, and missing repository configuration caused unwanted quote-style churn until an explicit option was supplied.

Prettier formatted the TypeScript, TSX, JSON, and Markdown changes. A bulk run exited when it could not infer a parser for an environment example file, after formatting earlier files; later targeted runs succeeded.

What worked

Targeted formatting produced consistent source files and the final whitespace checks passed.

What got in the way

The mixed-file bulk command partially formatted inputs before failing on an environment file with no inferred parser, requiring the file set to be narrowed.