{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"prettier","slug":"prettier","name":"Prettier","type":"extension","url":"https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode","page_url":"https://unfragile.ai/prettier","categories":["code-editors"],"tags":[],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"prettier__cap_0","uri":"capability://code.generation.editing.deterministic.code.formatting.with.ast.based.reprinting","name":"deterministic code formatting with ast-based reprinting","description":"Parses source code into an abstract syntax tree (AST) and re-prints it according to fixed formatting rules, ensuring consistent style across JavaScript, TypeScript, CSS, HTML, JSON, Markdown, and GraphQL. Unlike regex-based formatters, this approach preserves code semantics while enforcing maximum line length constraints, indentation, spacing, and bracket placement through a unified rule engine that applies identically across all supported languages.","intents":["enforce consistent code style across a team without manual review","automatically reformat code on save to eliminate style debates","ensure all files in a project follow the same formatting standard","reduce merge conflicts caused by inconsistent whitespace and formatting"],"best_for":["JavaScript/TypeScript teams adopting opinionated code standards","projects with multiple contributors needing automated style enforcement","developers migrating from manual formatting or conflicting formatter rules"],"limitations":["cannot selectively format portions of a file — operates on entire file basis","no adaptive rule learning — formatting rules are static and cannot adjust based on existing code patterns","performance depends on file size; very large files (>100KB) may experience noticeable formatting latency","cannot format code with syntax errors — requires valid, parseable source code"],"requires":["Visual Studio Code (version not specified, assume 1.40+)","Node.js runtime for local Prettier installation","Prettier package installed locally (npm install prettier -D) or globally"],"input_types":["JavaScript source code","TypeScript source code","JSX/TSX files","CSS/SCSS/Less stylesheets","HTML/Vue/Angular templates","JSON files","Markdown documents","GraphQL schemas","YAML files"],"output_types":["formatted source code (same language as input)","formatted file written to disk"],"categories":["code-generation-editing","code-formatter"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__cap_1","uri":"capability://automation.workflow.vs.code.formatter.pipeline.integration.with.automatic.save.triggering","name":"vs code formatter pipeline integration with automatic save triggering","description":"Integrates into VS Code's native formatter API as the designated `editor.defaultFormatter` for specified languages, enabling automatic code formatting on file save when `editor.formatOnSave` is enabled. The extension hooks into VS Code's document save lifecycle, intercepts the save event, invokes Prettier's formatting engine on the file content, and writes the formatted result back to the editor buffer without requiring manual command invocation.","intents":["automatically format code every time a file is saved without manual action","designate Prettier as the default formatter for specific languages in VS Code","prevent unformatted code from being committed by enforcing format-on-save workflow","eliminate the need to run separate formatting commands or pre-commit hooks"],"best_for":["developers using VS Code as their primary editor","teams wanting zero-friction formatting enforcement","projects where formatting must happen transparently during normal save workflow"],"limitations":["requires explicit configuration of `editor.defaultFormatter` and `editor.formatOnSave` — not enabled by default","conflicts with other formatters if not properly configured; must set per-language to avoid ambiguity","cannot selectively disable formatting for specific files without modifying `.prettierignore` or workspace settings","formatting latency is synchronous with save operation — may cause noticeable delay on large files"],"requires":["Visual Studio Code installed","Prettier extension installed from VS Code Marketplace","Prettier package available (local node_modules, global installation, or bundled fallback)","VS Code workspace settings configured with `editor.defaultFormatter: esbenp.prettier-vscode`"],"input_types":["unsaved or saved file content in VS Code editor"],"output_types":["formatted file content written to disk and editor buffer"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__cap_10","uri":"capability://code.generation.editing.semicolon.insertion.and.removal.with.language.aware.rules","name":"semicolon insertion and removal with language-aware rules","description":"Automatically inserts or removes semicolons at statement ends based on a configurable setting (`semi` option, default: true). The formatter uses AST analysis to determine where semicolons are syntactically required or optional, avoiding incorrect removal in edge cases (e.g., statements starting with `[` or `(`). Language-specific rules apply (e.g., CSS and JSON have different semicolon conventions than JavaScript).","intents":["I want to enforce consistent semicolon usage across my JavaScript codebase","I need to remove all semicolons to adopt a no-semicolon style","I want to avoid ASI (Automatic Semicolon Insertion) bugs by ensuring correct semicolon placement"],"best_for":["teams adopting a specific semicolon style (with or without)","projects migrating from one semicolon convention to another","developers who want to avoid ASI-related bugs"],"limitations":["Semicolon style is global — cannot vary per file or context","Removing semicolons relies on AST analysis to avoid breaking code, but edge cases may exist","Language-specific rules apply (e.g., CSS always uses semicolons, JSON doesn't support them)","No option for conditional semicolons (e.g., only in certain contexts)"],"requires":["`semi` setting in `.prettierrc` or VS Code settings (default: true)"],"input_types":["source code with inconsistent semicolon usage"],"output_types":["reformatted code with consistent semicolon placement"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__cap_11","uri":"capability://code.generation.editing.indentation.normalization.with.configurable.tab.width.and.style","name":"indentation normalization with configurable tab width and style","description":"Normalizes indentation across code by enforcing a consistent tab width (default: 2 spaces, configurable via `tabWidth` setting) and indentation style (spaces or tabs, configurable via `useTabs` setting). The formatter re-indents all nested code blocks, function arguments, and multi-line expressions to match the configured style, eliminating mixed indentation and inconsistent nesting levels.","intents":["I want to enforce consistent indentation (2 spaces, 4 spaces, or tabs) across my codebase","I need to convert all tabs to spaces (or vice versa) automatically","I want to fix indentation errors and inconsistencies without manual editing"],"best_for":["teams with strict indentation requirements","projects migrating from one indentation style to another","codebases with mixed indentation that need cleanup"],"limitations":["Indentation style is global — cannot vary per file or context","Tab width must be consistent across the project — no per-language overrides","Indentation is applied to all code, including comments and strings (which may not be desired)","Very deeply nested code may exceed reasonable line lengths after re-indentation"],"requires":["`tabWidth` setting in `.prettierrc` or VS Code settings (default: 2)","`useTabs` setting in `.prettierrc` or VS Code settings (default: false for spaces)"],"input_types":["source code with inconsistent indentation"],"output_types":["reformatted code with consistent indentation applied"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__cap_12","uri":"capability://code.generation.editing.trailing.comma.insertion.and.removal.with.language.specific.rules","name":"trailing comma insertion and removal with language-specific rules","description":"Automatically inserts or removes trailing commas in multi-line arrays, objects, function parameters, and imports based on a configurable setting (`trailingComma` option with values: `none`, `es5`, `all`). The formatter uses AST analysis to identify multi-line structures and applies language-specific rules (e.g., trailing commas are valid in modern JavaScript but not in older versions). This reduces diff noise in version control and prevents syntax errors when adding new items.","intents":["I want to add trailing commas to multi-line arrays and objects to reduce diff noise","I need to remove trailing commas for compatibility with older JavaScript versions","I want to avoid syntax errors when adding new items to multi-line structures"],"best_for":["teams using modern JavaScript (ES5+) that support trailing commas","projects with large multi-line objects and arrays","developers who want to reduce version control diff noise"],"limitations":["Trailing comma style is global — cannot vary per file or context","Language-specific rules apply (e.g., trailing commas are not valid in JSON)","Trailing commas in function parameters require ES5+ support — cannot be used in older JavaScript","No option for conditional trailing commas (e.g., only in certain contexts)"],"requires":["`trailingComma` setting in `.prettierrc` or VS Code settings (default: `es5`)","Language support for trailing commas (JavaScript, TypeScript, CSS, etc.)"],"input_types":["source code with multi-line arrays, objects, function parameters, or imports"],"output_types":["reformatted code with trailing commas inserted or removed per configuration"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__cap_13","uri":"capability://code.generation.editing.bracket.spacing.and.object.literal.formatting","name":"bracket spacing and object literal formatting","description":"Automatically normalizes spacing around brackets and braces in object literals, imports, and destructuring assignments based on configurable settings (`bracketSpacing` for `{ }` spacing, `bracketSameLine` for closing bracket placement). The formatter ensures consistent spacing (e.g., `{ foo: 'bar' }` vs `{foo: 'bar'}`) and places closing brackets on the same line or new line based on configuration. This eliminates spacing inconsistencies in object-heavy code.","intents":["I want to enforce consistent spacing inside object literals and destructuring","I need to control whether closing brackets appear on the same line or a new line","I want to eliminate spacing-related code review comments"],"best_for":["teams with strict object literal formatting preferences","projects with heavy use of destructuring and object literals","developers who want to eliminate spacing-related code review friction"],"limitations":["Bracket spacing is global — cannot vary per file or context","Bracket placement rules apply to all brackets, including imports and destructuring (may not match all preferences)","No option for conditional bracket spacing (e.g., only in certain contexts)"],"requires":["`bracketSpacing` setting in `.prettierrc` or VS Code settings (default: true)","`bracketSameLine` setting in `.prettierrc` or VS Code settings (default: false)"],"input_types":["source code with object literals, imports, and destructuring assignments"],"output_types":["reformatted code with consistent bracket spacing and placement"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__cap_2","uri":"capability://tool.use.integration.multi.version.prettier.resolution.with.local.first.precedence","name":"multi-version prettier resolution with local-first precedence","description":"Implements a three-tier version resolution strategy that prioritizes local project installations of Prettier (in `node_modules/prettier`), falls back to globally installed modules if `prettier.resolveGlobalModules` is enabled, and finally uses a bundled Prettier 3.x as a last-resort fallback. This approach ensures projects can pin specific Prettier versions in `package.json` while allowing developers to use global installations for consistency across projects, with transparent version detection and reporting.","intents":["use project-specific Prettier version pinned in package.json to ensure consistent formatting across team","allow developers to use globally installed Prettier for projects without local installation","gracefully fall back to bundled Prettier when no local or global installation exists","debug which Prettier version is being used for formatting"],"best_for":["teams managing multiple projects with different Prettier version requirements","developers wanting to pin Prettier versions in version control","projects transitioning from global to local Prettier installations"],"limitations":["global module resolution requires explicit opt-in via `prettier.resolveGlobalModules: true` setting","bundled Prettier version (3.x) may not match project requirements — local installation is strongly recommended","version mismatch between local and global installations can cause confusion; no warning if multiple versions exist","no automatic version upgrade — developers must manually update `package.json` or global installation"],"requires":["Prettier package installed locally (recommended): npm install prettier -D --save-exact","OR globally installed Prettier with `prettier.resolveGlobalModules: true` enabled","OR VS Code extension with bundled Prettier 3.x (fallback only)"],"input_types":["project directory structure","node_modules directory","global npm module cache","VS Code extension bundle"],"output_types":["resolved Prettier module path","Prettier version identifier"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__cap_3","uri":"capability://automation.workflow.project.configuration.file.discovery.and.application","name":"project configuration file discovery and application","description":"Automatically discovers and applies Prettier configuration from project-level files (`.prettierrc`, `.prettierrc.json`, `.prettierrc.yaml`, `prettier.config.js`, or `package.json` with `prettier` key) without requiring manual configuration in VS Code settings. The extension uses Prettier's native configuration resolution algorithm, which searches from the current file's directory up the directory tree until a configuration file is found, enabling per-project formatting rules that apply consistently across all team members.","intents":["define project-specific formatting rules in a single configuration file shared across team","override default Prettier settings (line length, tabs vs spaces, semicolons, etc.) per project","ensure all developers use identical formatting rules without manual VS Code configuration","version control formatting rules alongside code"],"best_for":["teams with multiple projects requiring different formatting standards","projects wanting to enforce formatting rules in version control","developers collaborating across projects with varying style preferences"],"limitations":["configuration file must be in project root or parent directory — no support for arbitrary config paths","configuration changes require file save and editor reload to take effect","no VS Code UI for editing configuration — requires manual file editing","conflicting configuration files in parent directories can cause unexpected behavior; nearest file wins"],"requires":["Prettier configuration file in project root or parent directory (.prettierrc, prettier.config.js, etc.)","OR Prettier configuration in package.json with 'prettier' key","Valid JSON/YAML/JavaScript syntax in configuration file"],"input_types":[".prettierrc file (JSON format)",".prettierrc.json file",".prettierrc.yaml file",".prettierrc.yml file","prettier.config.js file (CommonJS module)","package.json with 'prettier' key"],"output_types":["applied formatting rules (line length, indentation, quotes, semicolons, etc.)"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__cap_4","uri":"capability://automation.workflow.file.exclusion.via.prettierignore.pattern.matching","name":"file exclusion via .prettierignore pattern matching","description":"Respects `.prettierignore` files in the project root, which use gitignore-style glob patterns to exclude files from formatting. When a file matches an ignore pattern, the extension skips formatting for that file even if format-on-save is enabled, allowing developers to exclude generated code, vendor files, or other non-source files from Prettier's formatting pipeline without modifying VS Code settings.","intents":["exclude generated or minified files from formatting","prevent formatting of third-party vendor code or dependencies","skip formatting for files that should not be modified (e.g., compiled output)","maintain a single ignore list shared across all tools (CLI, CI/CD, editor)"],"best_for":["projects with generated code, build artifacts, or vendor directories","teams wanting to exclude specific file patterns without per-language VS Code configuration","projects using Prettier in multiple contexts (CLI, CI/CD, editor) requiring consistent ignore rules"],"limitations":["ignore patterns use gitignore syntax — developers must be familiar with glob patterns","no UI for managing ignore patterns — requires manual `.prettierignore` file editing","changes to `.prettierignore` require editor reload to take effect","no per-file or per-directory override — patterns are global to the project"],"requires":[".prettierignore file in project root","Valid gitignore-style glob patterns in .prettierignore"],"input_types":[".prettierignore file with glob patterns"],"output_types":["skip formatting decision for matched files"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__cap_5","uri":"capability://automation.workflow.per.language.formatter.designation.and.conflict.resolution","name":"per-language formatter designation and conflict resolution","description":"Allows designation of Prettier as the default formatter for specific languages via VS Code's `[language].editor.defaultFormatter` setting, enabling selective use of Prettier for some languages while using alternative formatters for others. This prevents formatter conflicts by explicitly routing each language to its designated formatter, with clear precedence rules when multiple formatters target the same language.","intents":["use Prettier for JavaScript/TypeScript while using different formatters for other languages","resolve conflicts when multiple formatters are installed for the same language","designate Prettier as default for some languages and disable it for others","configure different formatters for different file types in the same project"],"best_for":["projects using multiple formatters for different languages","teams with language-specific formatting requirements","developers wanting fine-grained control over which formatter handles each language"],"limitations":["requires explicit per-language configuration — no global 'use Prettier for all' setting","VS Code does not support combined language syntax; each language must be configured separately","conflicts still possible if multiple extensions claim the same language without explicit designation","configuration is per-workspace or per-user — not easily shared across team without workspace settings file"],"requires":["VS Code workspace settings or user settings configured with `[language].editor.defaultFormatter: esbenp.prettier-vscode`","Example: `[javascript].editor.defaultFormatter: esbenp.prettier-vscode`"],"input_types":["VS Code settings.json configuration"],"output_types":["designated formatter for each language"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__cap_6","uri":"capability://safety.moderation.trust.based.module.loading.with.security.prompts","name":"trust-based module loading with security prompts","description":"Implements a security mechanism that prompts users to confirm loading of Prettier modules from untrusted sources, preventing malicious code execution from compromised or untrusted Prettier installations. When loading a Prettier module (especially from global or project-specific locations), the extension displays a trust prompt: 'You will be prompted to confirm that you want the extension to load a Prettier module', allowing users to audit the module source before execution.","intents":["prevent execution of malicious code from compromised Prettier installations","allow users to audit Prettier module sources before loading","provide transparency about which Prettier module is being loaded","maintain security in shared development environments"],"best_for":["teams using shared development environments or CI/CD systems","developers concerned about supply chain security","projects with strict security policies requiring module audit trails"],"limitations":["trust prompts can be dismissed or ignored by users, reducing security effectiveness","no persistent trust list — users are prompted every time a new Prettier module is encountered","trust mechanism details are not fully documented — unclear what triggers a prompt vs automatic loading","no audit logging of which modules were loaded or approved"],"requires":["Prettier module from local, global, or bundled source","User interaction to confirm trust prompt"],"input_types":["Prettier module path (local, global, or bundled)"],"output_types":["trust confirmation decision","module loading permission"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__cap_7","uri":"capability://code.generation.editing.language.agnostic.formatting.rule.application.across.8.languages","name":"language-agnostic formatting rule application across 8+ languages","description":"Applies a unified set of formatting rules (line length, indentation, quotes, semicolons, trailing commas, bracket placement, etc.) consistently across JavaScript, TypeScript, CSS, HTML, JSON, Markdown, GraphQL, and YAML, using language-specific parsers to understand syntax while enforcing identical style principles. This approach ensures that projects with multiple languages maintain consistent formatting philosophy without requiring separate configuration per language.","intents":["enforce consistent code style across JavaScript, TypeScript, CSS, HTML, and other languages","apply the same formatting philosophy (e.g., 80-character line length) to all file types","reduce cognitive load by using identical formatting rules across the entire project","simplify configuration by defining rules once and applying them universally"],"best_for":["full-stack projects with JavaScript, CSS, HTML, and other mixed languages","teams wanting unified formatting standards across all file types","projects where consistent style matters across language boundaries"],"limitations":["some languages have language-specific rules that cannot be unified (e.g., CSS bracket placement differs from JavaScript)","configuration options are limited to common rules; language-specific customization is minimal","not all formatting preferences can be expressed in a single unified rule set","some languages (e.g., Markdown) have fewer formatting options than others"],"requires":["Prettier configuration with desired formatting rules (line length, indentation, etc.)","Source files in supported languages (JavaScript, TypeScript, CSS, HTML, JSON, Markdown, GraphQL, YAML)"],"input_types":["source code in JavaScript, TypeScript, CSS, HTML, JSON, Markdown, GraphQL, YAML"],"output_types":["formatted source code with unified style applied"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__cap_8","uri":"capability://code.generation.editing.configurable.line.length.enforcement.with.intelligent.wrapping","name":"configurable line length enforcement with intelligent wrapping","description":"Enforces a configurable maximum line length (default 80 characters, customizable via `printWidth` setting) by intelligently wrapping code at appropriate break points. The formatter analyzes the AST to identify optimal wrapping locations (e.g., after commas, operators, or function arguments) rather than naively breaking at character boundaries. This produces readable, properly-indented wrapped code that respects language syntax rules.","intents":["I want to enforce a maximum line length across my codebase without manual line breaking","I need to configure line length differently for different languages (e.g., 80 for Python, 120 for JavaScript)","I want intelligent wrapping that respects code structure, not just character counts"],"best_for":["teams with strict line length requirements (e.g., 80 characters for readability)","projects with mixed language requirements (different line lengths per language)","developers who want automatic line wrapping without manual formatting"],"limitations":["Line length is global or per-language — cannot vary within a file based on context","Wrapping behavior is opinionated and cannot be customized beyond `printWidth` setting","Very long identifiers or strings that exceed `printWidth` cannot be wrapped — they exceed the limit","Wrapping decisions are deterministic but may not match all team preferences (e.g., some prefer wrapping before operators, others after)"],"requires":["`printWidth` setting in `.prettierrc` or VS Code settings (default: 80)","Language-specific support for wrapping (all 15+ supported languages have wrapping rules)"],"input_types":["source code with lines exceeding `printWidth`"],"output_types":["reformatted code with lines wrapped at appropriate break points","consistent indentation applied to wrapped lines"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__cap_9","uri":"capability://code.generation.editing.quote.style.normalization.single.vs.double.quotes","name":"quote style normalization (single vs double quotes)","description":"Normalizes quote styles across code by converting all string literals to a consistent quote type (single or double quotes, configurable via `singleQuote` setting). The formatter respects language conventions (e.g., HTML attributes use double quotes by default) and intelligently handles edge cases like strings containing quotes (e.g., `\"don't\"` vs `'don\\'t'`). This eliminates quote style inconsistencies without requiring manual editing.","intents":["I want to enforce consistent quote style across my JavaScript/TypeScript codebase","I need to convert all double quotes to single quotes (or vice versa) automatically","I want to avoid quote style debates in code reviews"],"best_for":["teams with strict quote style preferences","projects migrating from one quote style to another","developers who want to eliminate quote-related code review comments"],"limitations":["Quote style is global — cannot vary per file or context","Language-specific defaults may override user preference (e.g., HTML always uses double quotes for attributes)","Escaped quotes in strings are handled automatically but may produce less readable output in edge cases","Template literals (backticks) are not affected — only single/double quotes"],"requires":["`singleQuote` setting in `.prettierrc` or VS Code settings (default: false for double quotes)"],"input_types":["source code with mixed quote styles"],"output_types":["reformatted code with consistent quote style applied"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"prettier__headline","uri":"capability://code.generation.editing.opinionated.code.formatter.for.multiple.languages","name":"opinionated code formatter for multiple languages","description":"Prettier is an opinionated code formatter that supports JavaScript, TypeScript, CSS, HTML, JSON, Markdown, and more, automatically enforcing a consistent code style on save with configurable rules.","intents":["best code formatter","code formatter for JavaScript","automatic code formatting tool","how to format code in VS Code","best formatter for TypeScript"],"best_for":["developers seeking consistent code style"],"limitations":["may conflict with other formatting extensions"],"requires":["Visual Studio Code"],"input_types":["JavaScript","TypeScript","CSS","HTML","JSON","Markdown"],"output_types":["formatted code"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":59,"verified":false,"data_access_risk":"moderate","permissions":["Visual Studio Code (version not specified, assume 1.40+)","Node.js runtime for local Prettier installation","Prettier package installed locally (npm install prettier -D) or globally","Visual Studio Code installed","Prettier extension installed from VS Code Marketplace","Prettier package available (local node_modules, global installation, or bundled fallback)","VS Code workspace settings configured with `editor.defaultFormatter: esbenp.prettier-vscode`","`semi` setting in `.prettierrc` or VS Code settings (default: true)","`tabWidth` setting in `.prettierrc` or VS Code settings (default: 2)","`useTabs` setting in `.prettierrc` or VS Code settings (default: false for spaces)"],"failure_modes":["cannot selectively format portions of a file — operates on entire file basis","no adaptive rule learning — formatting rules are static and cannot adjust based on existing code patterns","performance depends on file size; very large files (>100KB) may experience noticeable formatting latency","cannot format code with syntax errors — requires valid, parseable source code","requires explicit configuration of `editor.defaultFormatter` and `editor.formatOnSave` — not enabled by default","conflicts with other formatters if not properly configured; must set per-language to avoid ambiguity","cannot selectively disable formatting for specific files without modifying `.prettierignore` or workspace settings","formatting latency is synchronous with save operation — may cause noticeable delay on large files","Semicolon style is global — cannot vary per file or context","Removing semicolons relies on AST analysis to avoid breaking code, but edge cases may exist","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7,"quality":0.9,"ecosystem":0.3,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:25.060Z","last_scraped_at":null,"last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=prettier","compare_url":"https://unfragile.ai/compare?artifact=prettier"}},"signature":"gwGlsiwyYV+v4FTDoi/HlIdr6A+/x5Wv20dB3M104QxrrBZ2mL8QoQGpfDPCxKC8TwC2zpDwGpvuLGfQCDkpDQ==","signedAt":"2026-06-22T12:31:20.658Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/prettier","artifact":"https://unfragile.ai/prettier","verify":"https://unfragile.ai/api/v1/verify?slug=prettier","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}