{"commit": "47762e506c477084436e7aa4a147ee63423cb90c", "language": "csharp", "query_count": 1, "query_ids": ["47762e506c477084436e7aa4a147ee63423cb90c-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "28329060f936b94298a08cddd63084d910705bb2", "split": "test", "task": "```\nTitle: SA1629: Diagnostic location is misplaced when documentation ends with a self-closing XML element\n\nSA1629 (“Documentation text must end with a period”) does not correctly place its\nsquiggly underline or code-fix insertion point when the last meaningful content\nin a documentation comment is an empty XML element, such as\n``.\n\nCurrent behavior (repro):\nFor a doc comment like\n/// \n/// Text description \n/// \nthe diagnostic is reported somewhere *inside* the element rather than\nimmediately after it. As a result the “add a period” code fix inserts the\nperiod in the wrong position, or the underline appears in a misleading spot.\n\nExpected behavior:\nThe diagnostic should be located immediately after the last content node that\ncontributes to the documentation text, meaning *after* the self-closing element\nwhen the trailing content is an empty element with no following text. The code\nfix should add a period at that location.\n\nAny trailing whitespace after the empty element should still be handled as\nusual (ignored for the purpose of detecting the missing period). The only\nchange is that empty XML elements should be recognised as content for the\npurpose of advancing the reported span, so the diagnostic points to the\npoint right after the element rather than inside it.\n```", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#47762e506c477084436e7aa4a147ee63423cb90c", "task_id": "47762e506c477084436e7aa4a147ee63423cb90c-1", "task_title": "Fix reporting location of SA1629 after empty elements"} {"commit": "2b5eb3193a20774f2c64a49d2bdecd70bbdc2321", "language": "csharp", "query_count": 1, "query_ids": ["2b5eb3193a20774f2c64a49d2bdecd70bbdc2321-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "b1c46c34bfc3e97130730c502ec1463aa82b8350", "split": "test", "task": "**Request: Update SA1503 to support the existing `allowConsecutiveUsings` stylecop.json option**\n\n### Current behavior\nRule SA1503 (braces must not be omitted) currently reports a violation whenever a `using` statement has a non-block child statement, including when that child is another `using` statement. This means that consecutive `using` statements (stacked without braces) always produce an SA1503 diagnostic, even when other layout rules accept the same pattern.\n\n### Desired behavior\nSA1503 should respect the `layoutRules.allowConsecutiveUsings` setting in `stylecop.json` in the same way that other rules (for example SA1519) already do.\n\n- When `allowedConsecutiveUsings` is set to `true`, SA1503 must **not** report a violation for a `using` statement whose direct child is another `using` statement (consecutive usings).\n- When `allowedConsecutiveUsings` is set to `false`, SA1503 must keep its original behavior for this pattern (braces required).\n- The default value of `allowConsecutiveUsings` should match the default used by other rules that consume this option (typically `true`).\n\n### Additional constraints and edge cases\n- The change must only affect how SA1503 processes `using` statements. Other statement kinds (if, for, foreach, lock, fixed, etc.) must remain unchanged.\n- This option should not influence any other rule; especially, SA1519 should continue to apply its own logic independently of SA1503's decision.\n- The setting must be read from the standard stylecop.json settings infrastructure; the analyzer must not read any custom or alternative configuration source.\n- The implementation must handle the case where `stylecop.json` is absent or does not contain the option gracefully, falling back to the default behavior (which is expected to be equivalent to `allowConsecutiveUsings: true`).", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#2b5eb3193a20774f2c64a49d2bdecd70bbdc2321", "task_id": "2b5eb3193a20774f2c64a49d2bdecd70bbdc2321-1", "task_title": "Update SA1503 to consider the allowConsecutiveUsings option"} {"commit": "f51d23e32f57c40a2c2b7b0fc02e3d8568940546", "language": "csharp", "query_count": 1, "query_ids": ["f51d23e32f57c40a2c2b7b0fc02e3d8568940546-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "5b19011a744858e64b2497301605f6c936d178b4", "split": "test", "task": "SA1518 (“File may only contain a single newline at the end”) does not enforce its trailing‑newline requirements on files that contain only whitespace. Such whitespace‑only files are incorrectly treated as empty, so the rule never diagnoses them with any setting. A file that is nothing but whitespace should be treated like any other non‑empty file: \n- With `Require`, a whitespace‑only file without a trailing newline should be diagnosed and fixed to an empty file ending with a newline. \n- With `Omit`, a whitespace‑only file that already ends with a newline should be diagnosed and fixed to an empty file (no trailing newline). \n\nFix the emptiness check used by SA1518 so that files consisting only of whitespace are no longer considered empty, and ensure the correct behavioral table above holds.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#f51d23e32f57c40a2c2b7b0fc02e3d8568940546", "task_id": "f51d23e32f57c40a2c2b7b0fc02e3d8568940546-1", "task_title": "add tests for white space only files not beeing classified as empty"} {"commit": "ace4479bee345451a9051f63c903bc756aa01255", "language": "csharp", "query_count": 3, "query_ids": ["ace4479bee345451a9051f63c903bc756aa01255-1::q1", "ace4479bee345451a9051f63c903bc756aa01255-1::q2", "ace4479bee345451a9051f63c903bc756aa01255-1::q3"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "fe3e25546df8427f9ef53ecd8fb94e0dc1ef7427", "split": "test", "task": "SA1028 (no trailing whitespace) should flag trailing whitespace on preprocessor directive lines. \nExtend the rule to cover: `#define`, `#undef`, `#if`, `#elif`, `#else`, `#endif`, `#warning`, `#region`, `#endregion`. \nFor now, omit `#error`, `#line`, and `extern alias` directives because our test infrastructure doesn’t exercise them easily.\n\n**Code-fix safety constraint** \nThe SA1028 code fix provider must *not* offer a remove‑whitespace fix for these new violations. The fixer only knows how to remove trailing whitespace from `WhitespaceTrivia`, `SingleLineCommentTrivia`, `MultiLineCommentTrivia`, and `MultiLineDocumentationCommentTrivia`. For any other trivia kind (including the new directive trivias) the fix must be suppressed; accidentally offering the fix would produce incorrect or crashing behavior. The provider should be restricted to the exact set of trivia kinds it already handles.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#ace4479bee345451a9051f63c903bc756aa01255", "task_id": "ace4479bee345451a9051f63c903bc756aa01255-1", "task_title": "Add tests for finding whitespace after most directives"} {"commit": "d22386f8d1c0e8e1ba161d6dedfb78779609fd82", "language": "csharp", "query_count": 2, "query_ids": ["d22386f8d1c0e8e1ba161d6dedfb78779609fd82-1::q1", "d22386f8d1c0e8e1ba161d6dedfb78779609fd82-1::q2"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "92e453fd3d83b7ba29be4ed5b3deafc77930c5bd", "split": "test", "task": "**Title:** SA1205 code fix throws an exception or fails to apply for nested partial types with `protected` or `protected internal` access\n\n**Description:**\nWhen a nested partial type (class, struct, or interface) contains one part that specifies `protected` or `protected internal` accessibility and another part that omits the access modifier, the SA1205 diagnostic correctly fires, but attempting to apply the suggested code fix (via lightbulb/suggestion) fails. Either the fix does not apply at all, or an internal error occurs (typically an exception).\n\n**Steps to reproduce:**\n1. Create a C# project with the StyleCop.Analyzers NuGet package.\n2. Write a nested partial type that has `protected` or `protected internal` on one part and no access modifier on the other part. For example:\n ```csharp\n public class Outer\n {\n protected internal partial struct Sample\n {\n }\n\n partial struct Sample\n {\n }\n }\n ```\n3. Open the file in Visual Studio and observe the SA1205 warning on the second part.\n4. Use the lightbulb to apply the code fix.\n\n**Expected behavior:**\nThe code fix should add the missing access modifier keyword(s) to the partial declaration, so that both parts declare the same accessibility. For the example above, the fixed code should add `protected internal` before `partial struct Sample` on the second part.\n\n**Observed behavior:**\nThe code fix does not modify the document. In some scenarios an error toast or an internal exception is reported.\n\n**Additional notes:**\n- The problem only occurs for `protected` and `protected internal` access modifiers. Public, internal, and private appear to work correctly.\n- The issue affects all nested partial type kinds (class, struct, interface).\n- The fix must preserve existing whitespace/trivia so the output remains well-formatted.\n- The diagnostic (SA1205) itself is correct and fires as expected; only the code fix is broken.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#d22386f8d1c0e8e1ba161d6dedfb78779609fd82", "task_id": "d22386f8d1c0e8e1ba161d6dedfb78779609fd82-1", "task_title": "Added new test case for SA1205 to verify propagation of access modifiers between multiple parts of a nested partial type. Updated code fix accordingly."} {"commit": "584a02184b35027700c470d9812a80c3890b0ece", "language": "csharp", "query_count": 2, "query_ids": ["584a02184b35027700c470d9812a80c3890b0ece-1::q1", "584a02184b35027700c470d9812a80c3890b0ece-1::q2"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "7e69f3ea7021ade6a966fcb8654fb014ecf71d00", "split": "test", "task": "# TokenSpacingCodeFixProvider: FixAll does not converge in a single pass and removes newlines when removing immediate spacing\n\nThe spacing code fix provider (`TokenSpacingCodeFixProvider`) has a `FixAll` implementation that struggles in two ways:\n\n1. **Overlapping token replacements are overwritten instead of composed** \n When multiple spacing diagnostics affect the same token, later updates simply overwrite earlier fixes in the replacement map. This can partially discard corrections and forces `FixAll` to require multiple iterations to converge. In practice this shows up as tests needing to pass `numberOfFixAllIterations: 2` to get the expected fixed document; under real usage a single “Fix All” run may leave the document only partially corrected.\n\n2. **`ActionRemoveImmediate` strips newlines** \n When a spacing rule asks to remove immediate whitespace around a token, the fixer calls `TriviaHelper.WithoutTrailingWhitespace` (directly or via similar hand-rolled trimming). That helper treats end-of-line trivia as whitespace, so removal can “eat” newlines that separate tokens on different lines. StyleCop spacing rules must never remove line breaks when removing whitespace, so this introduces incorrect formatting and can cause additional diagnostics.\n\n**Expected behavior**\n- `FixAll` for spacing rules must produce a fully fixed document in a single pass. When the same token already has a pending replacement in the map, new transformations should be applied *on top* of the previous replacement so that no fix is lost.\n- The `ActionRemoveImmediate` fix must remove only whitespace trivia (spaces, tabs) and **stop** at end-of-line trivia. The fix should never collapse or remove newlines between tokens.\n\n**Additional context**\n- `TriviaHelper.WithoutTrailingWhitespace` and `IndexOfTrailingWhitespace` currently treat end-of-line trivia as whitespace. A `bool` option to treat end-of-line trivia as non-whitespace (and stop before it) would be the natural way to support the newline-preserving removal without breaking existing callers.\n- The existing tests that pass `numberOfFixAllIterations: 2` should become unnecessary once replacements are composed; the fix should be validated by those tests now passing with the default single-pass iteration behavior.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#584a02184b35027700c470d9812a80c3890b0ece", "task_id": "584a02184b35027700c470d9812a80c3890b0ece-1", "task_title": "Improved FixAll for TokenSpacingCodeFixProvider"} {"commit": "f4e85a20ffd9daab918689f6b9acd0ae6106019b", "language": "csharp", "query_count": 3, "query_ids": ["f4e85a20ffd9daab918689f6b9acd0ae6106019b-1::q1", "f4e85a20ffd9daab918689f6b9acd0ae6106019b-1::q2", "f4e85a20ffd9daab918689f6b9acd0ae6106019b-1::q3"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "ee3d7f53554b579b84f242317758cf1532211991", "split": "test", "task": "**Request: SA1119 does not handle switch expression parenthesized inside a cast, and code fix introduces extra space**\n\nSA1119 should report unnecessary parentheses when a switch expression is wrapped in parentheses and appears as the argument of a cast expression.\n\nExample: `(string)((n switch { 1 => a, 2 => b }))` — the inner `( ... )` around the switch expression is useless and should be flagged and removed. Currently the analyzer does not detect this situation, and the code fix for SA1119 may insert an unwanted space after the cast’s closing parenthesis in similar patterns (producing something like `(string)( n switch ...)`).\n\nRequirements:\n- The rule should recognise when a parenthesized switch expression is the direct or indirect descendant of a cast expression, even if there are outer unnecessary parentheses, and flag those inner parentheses.\n- The code fix must remove the unnecessary parentheses without adding a leading space when the parenthesized expression is immediately preceded by a closing parenthesis (e.g., the `)` of a cast). In that position the original spacing should be preserved exactly.\n- The fix must behave correctly for any number of nestings; e.g., `(string)((((n switch ...))))` should report all redundant parentheses and remove them without introducing extra space.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#f4e85a20ffd9daab918689f6b9acd0ae6106019b", "task_id": "f4e85a20ffd9daab918689f6b9acd0ae6106019b-1", "task_title": "Added suggested unit test and fixed code"} {"commit": "7dadd9b8c5885a5598f455e2749375b8441c631e", "language": "csharp", "query_count": 1, "query_ids": ["7dadd9b8c5885a5598f455e2749375b8441c631e-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "ad09cf890f76a192369cb7cb383ecd42400b234a", "split": "test", "task": "**Title:** SA1519 should flag missing braces in multi-line `lock` and `fixed` statement bodies\n\n**Description:**\n\nSA1519 (“Braces must not be omitted from multi-line child statement”) currently only inspects `if`, `while`, `for`, `foreach`, and `using` statements. The rule should also cover `lock` and `fixed` statements, which have the same syntactic structure: a parent statement with an embedded child statement that may span multiple lines. When the child statement body of a `lock` or `fixed` spans more than one line and braces are omitted, the analyzer should produce the same diagnostic as it does for the already‑supported statement kinds. Likewise, the code fix should add braces around the multi‑line body for these statement types.\n\n- **Expected behavior:** \n - A `lock` statement whose sole child statement is written across multiple lines without curly braces produces a diagnostic. \n - A `fixed` statement whose sole child statement is written across multiple lines without curly braces produces a diagnostic. \n - Single‑line bodies without braces are still allowed (no diagnostic), matching existing behavior for other statements. \n - The code fix provider correctly inserts braces when braces are missing but required.\n\n- **Acceptance criteria:** \n The rule triggers for `lock` and `fixed` exactly as it does for the existing statement kinds, and the automatic fix inserts curly braces in the multi‑line case.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#7dadd9b8c5885a5598f455e2749375b8441c631e", "task_id": "7dadd9b8c5885a5598f455e2749375b8441c631e-1", "task_title": "Make SA1519 work with lock and fixed (fix #2885)"} {"commit": "d39b9a9c236f41743e079477f9c57f10c80c14f9", "language": "csharp", "query_count": 3, "query_ids": ["d39b9a9c236f41743e079477f9c57f10c80c14f9-1::q1", "d39b9a9c236f41743e079477f9c57f10c80c14f9-1::q2", "d39b9a9c236f41743e079477f9c57f10c80c14f9-1::q3"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "e0d7a68e4b7ec3f908112416b73baec8bf48ab17", "split": "test", "task": "```\nTitle: Implement SA1634 \"File header must show copyright\" analyzer\n\nDescription:\nThe SA1634 analyzer is currently stubbed out (disabled-note-tests, TODO) and should be fully implemented.\n\nExpected behavior:\n- If a source file has a well-formed file header (XML-style comment at the top of the file), the analyzer must verify that the header contains a `` element.\n- The tag name comparison must be case-sensitive (only exactly `copyright` in lowercase is valid; anything like `` is not).\n- The element may appear as a normal open/close tag with attributes and content, or as a self-closing tag (e.g. ``).\n- If the file has no header at all (no XML-style header comment), the analyzer should NOT report a diagnostic – that scenario is covered by other file-header rules.\n- If the file header is present but malformed (e.g., contains no XML elements at all), the analyzer should NOT report a diagnostic – it is already covered by SA1633.\n- The analyzer should be enabled by default (`EnabledByDefault`) in the final build.\n\nSupporting helper improvements needed:\n- `FileHeaderHelpers.ParseFileHeader` currently assumes the extracted XML has a single root element, but real headers may contain multiple top-level elements (e.g. `...` followed by `...`). The parser needs to handle this, likely by wrapping the extracted text in a temporary root element before parsing.\n- A header that consists only of text with no XML tags should be treated as malformed (e.g., `FileHeader.IsMalformed` should be true), rather than being parsed as an empty valid header.\n- The `FileHeader` class should expose a way to query for a direct-child-descendant element by tag name, using ordinal (case-sensitive) comparison.\n\nTests:\n- Cover: empty file, file with no header, file with a valid copyright header (standard and self-closing forms), file with another top-level element followed by copyright, file missing copyright but containing other element(s), file using wrong-case copyright tag.\n- Auto-generated files (`// `) should not produce a diagnostic from any file-header rule. Extract the existing auto-generated test from SA1633 into a shared base class used by both SA1633 and SA1634 tests.\n- Update SA1633 test class to inherit from this new base class.\n\nPlease implement the analyzer and the necessary helper improvements.\n```", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#d39b9a9c236f41743e079477f9c57f10c80c14f9", "task_id": "d39b9a9c236f41743e079477f9c57f10c80c14f9-1", "task_title": "Implemented SA1634 + tests, several minor improvements as well"} {"commit": "14e566aaccef75f783b3b603a531c5923b0c5878", "language": "csharp", "query_count": 1, "query_ids": ["14e566aaccef75f783b3b603a531c5923b0c5878-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "29d9f253270d6e8c9b17d960857b40203353c2b0", "split": "test", "task": "**Title:** SA1216 reports multiple diagnostics when multiple static using directives appear before a non-static using\n\n**Description**\nWhen a block of using directives contains several `using static` directives followed by a regular `using` directive, the SA1216 analyzer (“Using static directives must be placed at correct location”) flags each static `using` as a separate violation. I expect the rule to produce at most one diagnostic for the block, reporting only the last static `using` that is followed by a non-static `using`.\n\n**Repro steps**\n1. Create code that declares, in order:\n - a static using\n - another static using\n - a normal using\n2. Place the block either directly inside a compilation unit or inside a namespace declaration.\n3. Run SA1216.\n\nExample (pseudocode):\n```\nusing static System.Array;\nusing static System.Math;\nusing System;\n```\n**Observed behavior**: SA1216 fires on *both* `using static System.Array;` and `using static System.Math;`.\n**Expected behavior**: SA1216 fires only on `using static System.Math;` (the last static using before the non-static one).\n\n**Impact**\nThe extra diagnostics create noise and can lead to confusing code-fix suggestions. The rule’s intent is to enforce correct ordering of static vs. non-static usings; when multiple static usings are already misplaced, only the one that directly violates the boundary with a following non-static using should be reported.\n\n**Constraints / edge cases**\n- The behavior should apply identically to using-directive blocks at the compilation-unit level and inside namespace declarations.\n- If there is no non-static using after the static ones, no diagnostic should be produced.\n- When a block contains multiple groups (static, non-static, static, non-static), each group boundary that violates the ordering should still be handled appropriately (only the last static using before each non-static using is reported). However, the most frequent practical case is a single block of static usings followed by regular usings, where only one diagnostic is desired.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#14e566aaccef75f783b3b603a531c5923b0c5878", "task_id": "14e566aaccef75f783b3b603a531c5923b0c5878-1", "task_title": "Updated after code review"} {"commit": "ce516976642834f996589dfe9c288100f69de023", "language": "csharp", "query_count": 3, "query_ids": ["ce516976642834f996589dfe9c288100f69de023-1::q1", "ce516976642834f996589dfe9c288100f69de023-1::q2", "ce516976642834f996589dfe9c288100f69de023-1::q3"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "efd47fd0b3b9569c8a9ef19c7ec504d968a9278e", "split": "test", "task": "**Request: Workaround for FixAll performance regression in VS 2015 Update 1**\n\n## Problem\nWhen applying a StyleCop code fix using “Fix All” (project or solution scope) in Visual Studio 2015 Update 1, performance degrades significantly. The bottleneck is the call to `FixAllContext.GetAllDiagnosticsAsync` inside `FixAllContextHelper.GetDocumentDiagnosticsToFixAsync`. We need to bypass that slow API without changing the set of diagnostics that get fixed.\n\n## Acceptance criteria\n\n1. **Project and solution fix-all scopes no longer call `GetAllDiagnosticsAsync`** \n For `FixAllScope.Project` and `FixAllScope.Solution`, instead of delegating to `fixAllContext.GetAllDiagnosticsAsync`, the helper must:\n - obtain the project’s compilation via `Project.GetCompilationAsync`,\n - run only the analyzers that produce any of the diagnostic IDs specified in the `FixAllContext.DiagnosticIds`, and\n - filter the resulting diagnostics to exactly those IDs.\n\n The document-scope path is unaffected.\n\n2. **Only the required analyzers are executed** \n The workaround must not re-run every analyzer in the solution. It should instantiate and run only those `DiagnosticAnalyzer` types whose `SupportedDiagnostics` intersect with the fix-all context’s diagnostic IDs.\n\n3. **Compilation options (including custom XML resolvers) must be respected** \n Some projects use custom `XmlReferenceResolver` (e.g., setup via `CompilationOptions.WithXmlReferenceResolver`). The compilation used for the direct analysis must carry whatever options the project already has, including any XML resolver and other compilation-option customizations. \n Likewise, the diagnostic-severity configuration (enabling the relevant analyzer IDs, suppressing IDs marked as disabled, reporting AD0001 as an error) must still be active on the compilation so that analyzer behavior matches what users and tests expect. Currently that option setup happens inside `GetSortedDiagnosticsFromDocumentsAsync` and in `CreateSolution`. It must be moved to a lifecycle step that runs **before** the direct analysis, so that the compilation passed to `WithAnalyzers` already has those options applied.\n\n4. **Existing overrides that set custom compilation options must remain correct** \n Several parties override `CreateProject` purely to attach an `XmlReferenceResolver` or to modify compilation options (e.g., `SA1604UnitTests`, `SA1606UnitTests`, `SA1615UnitTests`). Their customizations should continue to work after the change without duplicating the base-logic that enables/suppresses diagnostic IDs. This can be achieved by splitting project creation into a “create sources/project” step and a separate “apply compilation options” step; the custom overrides can then hook into the options step instead.\n\n5. **Fix-all verification in test infrastructure must supply the full set of relevant diagnostic IDs** \n When constructing a `FixAllContext` for fix-all provider tests, the context must include **all** diagnostic IDs that the analyzers under test can report, not only the ones listed in the code fix provider’s `FixableDiagnosticIds`. This ensures that the new direct-analysis path receives the same IDs as would have been returned by the old `GetAllDiagnosticsAsync` call, preserving correctness.\n\n## Non-goals\n- No change to the behavior of document-scope Fix All.\n- No change to the StyleCopTester utility’s result accuracy; minor adjustments to use `ImmutableArray` builders are acceptable as long as semantics are unchanged.\n\n## Constraints\n- The fix must target only the performance regression in VS 2015 Update 1; the API bypass is the official recommended workaround.\n- Do not alter the public API of `FixAllContextHelper` or break any existing code-fix provider.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#ce516976642834f996589dfe9c288100f69de023", "task_id": "ce516976642834f996589dfe9c288100f69de023-1", "task_title": "Workaround performance regressions in Visual Studio 2015 Update 1"} {"commit": "e0a5df6a084883b52cb9b8851513d91b77977c8b", "language": "csharp", "query_count": 1, "query_ids": ["e0a5df6a084883b52cb9b8851513d91b77977c8b-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "4e4b01d9538eafc0a16f196acaa349d117e371fa", "split": "test", "task": "Improve SA1201 “Elements Must Appear In The Correct Order” diagnostics:\n\n- Change the diagnostic message format to `\"A {0} should not follow a {1}\"` and supply the two argument placeholders with the names of the element types involved (e.g. `\"struct\"`, `\"class\"`, `\"constructor\"`, `\"destructor\"`, `\"method\"`, `\"indexer\"`, etc.). \n- Only flag the specific element that breaks the ordering constraint relative to the immediately preceding element. Do not flag elements that appear after an earlier violation if they themselves are in correct order relative to their own predecessor. In other words, perform a pairwise adjacent check against the expected ordering, not a running-maximum check.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#e0a5df6a084883b52cb9b8851513d91b77977c8b", "task_id": "e0a5df6a084883b52cb9b8851513d91b77977c8b-1", "task_title": "Implement CR feedback"} {"commit": "2d5a62f1d0c335c5436366e5a38464a2d3d57eec", "language": "csharp", "query_count": 1, "query_ids": ["2d5a62f1d0c335c5436366e5a38464a2d3d57eec-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "1dd5ced072d7d870f6dd698a6c02ad509a122452", "split": "test", "task": "**Title:** SA1648 false positive: constructor with `` on a class with a base type\n\n**Description** \nRule SA1648 (`InheritDocMustBeUsedWithInheritingClass`) currently requires that `` only appear on members that actually inherit documentation from a base member. For constructors, this check is too strict: when a class has a base class, the constructor _can_ legitimately inherit documentation from the base class constructor, so `` should be allowed.\n\n**Current behavior** \nA constructor with a `` comment always triggers SA1648, even when the enclosing class explicitly inherits from a base type that provides a constructor.\n\n**Expected behavior** \nSA1648 should **not** fire for a constructor when the class has a non‑null base type. For constructors on classes without a base type, the rule should still report as before.\n\n**Scope** \nOnly the analyzer logic for SA1648 – the condition that decides whether to emit a diagnostic when encountering `` on a member. No code‑fix changes are needed. \nThe existing logic already handles overrides and interface implementations; this is an analogous case for constructors that inherit documentation from a base class.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#2d5a62f1d0c335c5436366e5a38464a2d3d57eec", "task_id": "2d5a62f1d0c335c5436366e5a38464a2d3d57eec-1", "task_title": "Allow inheritdoc for constructors with base types"} {"commit": "e6053003f98bc378062286963310c916043f6d51", "language": "csharp", "query_count": 2, "query_ids": ["e6053003f98bc378062286963310c916043f6d51-1::q1", "e6053003f98bc378062286963310c916043f6d51-1::q2"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "40cec9e73f72cc0b67062a35a3b222f47ab8939c", "split": "test", "task": "**Title:** SA1118 does not flag attribute parameters that span multiple lines\n\n**Description:** \nThe SA1118 rule (“Parameter must not span multiple lines”) currently checks argument lists for method invocations, indexers, and array/collection creation expressions, but it completely ignores attribute argument lists. If an attribute constructor’s second (or later) argument spans multiple lines, no diagnostic is reported, even though the rule’s own description string lists attributes as part of its intended scope.\n\n**Observed behavior:** \nA code fragment like \n```csharp\n[MyAttribute(1,\n 2)]\npublic class Foo { }\n``` \ndoes not produce SA1118, despite the second argument spanning two lines.\n\n**Expected behavior:** \nSA1118 should report a diagnostic on the second (and any subsequent) attribute argument that spans multiple lines, consistent with how it already works for method, indexer, and array arguments. The first argument does not trigger the rule (same as for other argument lists). Arguments whose expressions fall into the existing exception list (e.g., anonymous functions, object-creation expressions) should remain excluded from the check.\n\n**Implementation guidance:** \n- Register a syntax node action for attribute argument lists alongside the existing `ArgumentList`/`BracketedArgumentList` handlers. \n- Reuse the existing multiline-detection and exception-list logic, adapting it as needed for the attribute argument node types so that the `Expression` of the attribute argument is passed to the exception check. \n- Update the rule’s description string if it doesn’t already mention attributes (currently it lists “method/indexer/attribute/array” in the source, but the implementation should match that declared coverage).", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#e6053003f98bc378062286963310c916043f6d51", "task_id": "e6053003f98bc378062286963310c916043f6d51-1", "task_title": "SA1118 - handle attributes"} {"commit": "5a9be646c2d131244078581f418a8885aee5fc86", "language": "csharp", "query_count": 2, "query_ids": ["5a9be646c2d131244078581f418a8885aee5fc86-1::q1", "5a9be646c2d131244078581f418a8885aee5fc86-1::q2"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "6a7a9cb6b8b9c4ca92a07556b305b075ac54dfd3", "split": "test", "task": "**Issue:** The using directive ordering code fixes (e.g., `UsingCodeFixProvider`, applied when fixing violations of SA1208, SA1210, SA1216, etc.) insert blank lines and enforce trailing/leading line breaks using a hard‑coded CRLF (`\\r\\n`) line ending. This corrupts files that use LF (`\\n`) line endings, producing a mix of CRLF and LF newlines.\n\n**Expected behavior:** When the code fix adds synthetic newlines (blank separator lines between using groups, blank lines before/after a block of usings, or ensures an end-of-line exists), it must respect the line‑ending convention already present in the document. The fix should detect the appropriate line ending from the source text (e.g., from the first observed line break) and use that same ending throughout. Both LF and CRLF conventions must be supported.\n\nAny existing call sites that directly use `SyntaxFactory.CarriageReturnLineFeed` for generating these separators need to be updated so that the determined document line ending is passed through and used instead.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#5a9be646c2d131244078581f418a8885aee5fc86", "task_id": "5a9be646c2d131244078581f418a8885aee5fc86-1", "task_title": "Fix UsingCodeFixProvider hard-coding of CRLF"} {"commit": "1b4e3369fdd0fdb2bdaa3eb03d6440d4414ea48e", "language": "csharp", "query_count": 2, "query_ids": ["1b4e3369fdd0fdb2bdaa3eb03d6440d4414ea48e-1::q1", "1b4e3369fdd0fdb2bdaa3eb03d6440d4414ea48e-1::q2"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "4e73d4aee90ca8d2cb45e1ffb6e898646117a2c7", "split": "test", "task": "## Request\n\n**Issue:** SA1009 code fix produces broken or ill-formed code when a closing parenthesis is followed by a comment and a semicolon on a subsequent line, or when a member access dot follows the closing parenthesis on a subsequent line.\n\n### Steps to Reproduce\n1. Write code that triggers SA1009 (“Closing parenthesis should not be preceded by a space”) where the closing parenthesis has a trailing comment and a semicolon on the next line:\n```csharp\nawait Task.Delay(1000 // comment\n );\n```\n2. Apply the code fix.\n3. Observe that the resulting code is not valid or formats the comment incorrectly.\n\nSimilarly, with a member access:\n```csharp\nawait Task.Delay(1000\n ).ConfigureAwait(false);\n```\nApplying the fix results in incorrect formatting or broken member access.\n\n### Desired Behavior\nThe code fix should handle these patterns correctly:\n\n- **Comment + semicolon after closing parenthesis**: When a closing parenthesis is followed by a line with a semicolon, and there is a comment between them, the fix should move the semicolon to immediately follow the closing parenthesis on the same line, and place the comment after the semicolon. The result should be syntactically valid and maintain the comment in a natural position.\n\n- **Member access on next line**: When a closing parenthesis is followed by a member-access dot on a separate line, the fix should move the closing parenthesis to the end of the previous line while keeping the dot on the next line. The member access expression must remain intact.\n\nThe fix must not break compilation or alter semantics.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#1b4e3369fdd0fdb2bdaa3eb03d6440d4414ea48e", "task_id": "1b4e3369fdd0fdb2bdaa3eb03d6440d4414ea48e-1", "task_title": "Fixed issues in SA1009 code fix"} {"commit": "31cd1a5429169eb3a3e78d49d5a645a3089ae3e2", "language": "csharp", "query_count": 1, "query_ids": ["31cd1a5429169eb3a3e78d49d5a645a3089ae3e2-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "a6d0cb29f31712237e75d5286e1dad2d2871a59b", "split": "test", "task": "```markdown\n## Request: SA1135 — support file-scoped namespace declarations (C# 10)\n\n### Background\nSA1135 (“Using directives must be qualified”) currently only recognises traditional block-scoped namespace declarations. C# 10 introduced file-scoped namespace declarations, and the rule does not handle them correctly. Users report either missing diagnostics or crashes when a using directive appears inside a file-scoped namespace.\n\n### Acceptance criteria\n1. **Detect violations inside file-scoped namespaces** \n When a using directive is a direct child of a file-scoped namespace declaration, SA1135 must evaluate whether the using directive should be flagged. The rule should behave identically to how it behaves inside a block-scoped namespace: if the using directive references a type whose containing namespace differs from the enclosing namespace, report the diagnostic.\n\n2. **Provide a correct code fix** \n For a violation inside a file-scoped namespace, the code fix must produce a fully‑qualified using directive. For example, given:\n ```csharp\n namespace A.B;\n using C; // where C is A.B.C\n ```\n the fix should produce `using A.B.C;`.\n\n3. **No exceptions** \n The analyzer must not throw an exception (e.g., `InvalidCastException` or `NullReferenceException`) when it encounters a file-scoped namespace declaration.\n\n4. **No regression for existing scenarios** \n - Using directives outside any namespace must continue to be considered always qualified (no diagnostic). \n - Block‑scoped namespace declarations must continue to work exactly as they do today.\n\n### Implementation notes\n- The repository already has a pattern for dealing with version‑dependent syntax kinds (the `SyntaxKindEx` helper). File‑scoped namespaces are exposed as `SyntaxKindEx.FileScopedNamespaceDeclaration`.\n- There is also a wrapper type (`BaseNamespaceDeclarationSyntaxWrapper`) designed to abstract over both namespace declaration kinds when you need to access the namespace name. Using that wrapper is likely the safest way to extract the containing namespace name without forcing a cast to a specific syntax node type.\n- Make sure the fix is covered by unit tests that exercise a file‑scoped namespace declaration containing both a compliant using alias and a non‑compliant unqualified using directive that should be fixed.\n```\n```\n\nThis request is self-contained, gives the user-facing problem, expected behavior, and hints at existing repo conventions (`SyntaxKindEx`, the wrapper) without dictating the exact change or file paths. The agent would need to search for the SA1135 analyzer, understand its structure, and adapt it for file‑scoped namespaces.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#31cd1a5429169eb3a3e78d49d5a645a3089ae3e2", "task_id": "31cd1a5429169eb3a3e78d49d5a645a3089ae3e2-1", "task_title": "Update SA1135 to support file-scoped namespaces"} {"commit": "ee3d7f53554b579b84f242317758cf1532211991", "language": "csharp", "query_count": 1, "query_ids": ["ee3d7f53554b579b84f242317758cf1532211991-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "9c9bc1c31494c7c844576f2e97e2c5b978e1b88e", "split": "test", "task": "**Title:** SA1119 false positive for cast expression containing a switch expression\n\n**Area:** Maintainability rule SA1119 (unnecessary parenthesis)\n\n**Severity:** Bug / false positive\n\n---\n\nWhen a C# switch expression (C# 8+) is used directly as the operand of a cast expression, the parentheses required by the cast syntax are flagged by SA1119 as unnecessary. Removing them would produce invalid syntax.\n\n**Steps to reproduce:**\n```csharp\nreturn (string)(n switch { 1 => a, 2 => b });\n```\nSA1119 reports the outer parenthesized expression as unnecessary, but the parentheses are syntactically required here — you cannot write `string n switch { … }` without them.\n\n**Expected behavior:**\nSA1119 should suppress its diagnostic when a parenthesized expression wraps a switch expression that is itself the immediate operand of a cast expression. In other words, when the opening parenthesis is immediately preceded by the closing parenthesis of a `CastExpression` node in the syntax tree, the parentheses should be considered syntactically required and should not be flagged.\n\n**Constraints to preserve:**\n- Switch expressions that are parenthesized but *not* preceded by a cast should still be flagged and a code fix offered, as they normally are for any other expression type (e.g., `var x = (n switch { … });` → `var x = n switch { … };`).\n- The suppression should apply only to the specific `(cast)switch_expr` pattern. Other parenthesized expressions that happen to contain a switch expression deeper inside should still be evaluated normally.\n- The fix should work for all forms of cast expressions (C-style casts like `(string)`, etc.).\n- Must respect the existing early-return structure in the rule’s analysis walk so that the suppression is cleanly integrated without side effects on other diagnostics.\n\n**Language version:** C# 8.0 and later (switch expressions were introduced in C# 8).", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#ee3d7f53554b579b84f242317758cf1532211991", "task_id": "ee3d7f53554b579b84f242317758cf1532211991-1", "task_title": "SA1119: Added support for typecast followed by switch expression"} {"commit": "5282df41486720305272c0f4a9cf8f65f2a1c56e", "language": "csharp", "query_count": 1, "query_ids": ["5282df41486720305272c0f4a9cf8f65f2a1c56e-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "cdb724f336a95efd677f6538f61bfc9cc46ed40f", "split": "test", "task": "```\nTitle: SA1023 allows illegal spaces after '*' when immediately followed by ')' or another '*'\n\nSA1023 (Dereference and Access of Symbols Must Be Spaced Correctly) is supposed to flag incorrect spacing around the dereference operator and pointer-type asterisks. However, it currently fails to report violations when an asterisk is followed by a closing parenthesis ')' or another asterisk '*', while it correctly flags spaces before '[' and '('.\n\nAs a result, the following invalid patterns are silently accepted:\n\n (int * ) // space between * and )\n (int* * ) // space between * and another *\n typeof(char * ) // same\n default(char* * ) // space after * before another *\n a = * x** x; // space after * before another *\n\nThe rule should disallow a space after an asterisk in these contexts, consistent with how it already prevents a space before an opening parenthesis or bracket (e.g. `( int *` is already flagged). The expected behavior is that any space appearing between an asterisk and an immediately following ')' or '*' should produce a diagnostic.\n\nThis impacts code readability in pointer-heavy C# code and causes SA1023 to be inconsistent with StyleCop's own spacing guidelines for asterisk tokens.\n```", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#5282df41486720305272c0f4a9cf8f65f2a1c56e", "task_id": "5282df41486720305272c0f4a9cf8f65f2a1c56e-1", "task_title": "Fix handling of '*' followed by '*' or ')'"} {"commit": "973a2a496a5873ed243b0f36cb4ee692a70709dc", "language": "csharp", "query_count": 1, "query_ids": ["973a2a496a5873ed243b0f36cb4ee692a70709dc-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "15a649d08744a46d7af8b6ce987fc5c32b8dd004", "split": "test", "task": "### SA1513 false positive on `yield return` with anonymous object initializer \n\n**Repro** \n```csharp\nprivate static IEnumerable Method()\n{\n yield return new\n {\n prop = \"A\"\n };\n}\n``` \nSA1513 (Closing curly bracket must be followed by a blank line) fires on the closing curly brace of the anonymous type, even though it is immediately followed by `;` ending the `yield return` statement. \n\n**Expected behavior** \nThe closing brace of an object/collection initializer that is the expression of a `yield return` statement should be treated the same way the rule already treats initializers in `return` statements, variable declarators, and assignment expressions: when the next token is a semicolon, no blank line is required. \n\n**Why** \nSA1513 already exempts closing braces followed by `;` in several statement contexts (variable declaration, assignment, `return`). The `yield return` case is missing, causing a false positive. \n\n**Task** \nUpdate the SA1513 analyzer logic so that a closing brace followed by `;` and belonging to a `yield return` statement is exempted from the blank-line requirement, consistent with the existing exemptions. The fix should be minimal and not affect other behavior of the rule.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#973a2a496a5873ed243b0f36cb4ee692a70709dc", "task_id": "973a2a496a5873ed243b0f36cb4ee692a70709dc-1", "task_title": "Fix for SA1513 incorrectly reported when object initializer used within yield return statement."} {"commit": "287a828ed47a3de3dac033d6519c6588cc4b9f6b", "language": "csharp", "query_count": 1, "query_ids": ["287a828ed47a3de3dac033d6519c6588cc4b9f6b-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "35b969ef9f6e235d7ffe24fb566210bc32d81ba6", "split": "test", "task": "**Title**: SA1405/SA1406 analyzers crash on Debug.Assert/Fail calls when the message parameter is omitted\n\n**Description**\n\nThe SA1405 (`Debug.Assert must provide message text`) and SA1406 (`Debug.Fail must provide message text`) analyzers are throwing an unhandled exception when they encounter an invocation of `Debug.Assert` or `Debug.Fail` that omits the optional `message` parameter. The crash occurs both with the standard `System.Diagnostics.Debug` and with user-defined types in the `System.Diagnostics` namespace that define `Assert`/`Fail` with optional parameters.\n\n**Repro steps** (from user report):\n\n1. A project contains a call like `Debug.Assert(true);` without a message string.\n2. The analyzers attempt to check whether the message argument is supplied.\n3. Instead of reporting a diagnostic, the analyzer process terminates with a `NullReferenceException` or an `ArgumentOutOfRangeException`.\n\n**Expected behavior**\n\n- When a call to `Debug.Assert` does **not** provide a value for the message parameter, SA1405 must produce a diagnostic (as it would for any missing required argument).\n- When a call to `Debug.Fail` does **not** provide a value for the message parameter, SA1406 must produce a diagnostic.\n- The analyzer must never throw an exception, regardless of whether the `Debug` class comes from `System.dll`, a user-defined assembly, or is defined in source, and regardless of parameter optionality.\n\n**Technical hints / constraints**\n\n- The crash is in the shared base class `SystemDiagnosticsDebugDiagnosticBase`.\n- The problematic logic currently inspects the **declared parameter count** of the resolved method symbol to decide whether the message is present. For methods with optional parameters, the declared parameter count is larger than the number of arguments actually supplied at the call site.\n- Instead, the decision must be based on the **number of arguments** provided in the invocation syntax. If the invocation’s argument list lacks an argument at the index corresponding to the message parameter, the diagnostic should fire.\n- Ensure the code handles edge cases where the `ArgumentList` of the `InvocationExpressionSyntax` might be unexpectedly `null`, even if that should not happen in normal C# syntax; the code must not throw.\n\n**Acceptance criteria**\n\n- SA1405 no longer crashes when analyzing `Debug.Assert(true)` or any call that omits the message parameter.\n- SA1406 no longer crashes when analyzing `Debug.Fail()` or any call that omits the message parameter.\n- The fix works identically whether the `Debug` type is the standard BCL type or a user-defined replacement in the `System.Diagnostics` namespace.\n- No behavioral side effects on other overloads or valid calls.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#287a828ed47a3de3dac033d6519c6588cc4b9f6b", "task_id": "287a828ed47a3de3dac033d6519c6588cc4b9f6b-1", "task_title": "Fix that Debug.Assert/Fail analyzers crash"} {"commit": "06c68df0b8e08798fafad8f1290af32fa40406fd", "language": "csharp", "query_count": 1, "query_ids": ["06c68df0b8e08798fafad8f1290af32fa40406fd-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "33694b372fb4f25938c2230c7c3647d17837ccc4", "split": "test", "task": "**Implementation request** \nSA1513 (ClosingCurlyBracketMustBeFollowedByBlankLine) currently does not flag missing blank lines when a closing curly brace inside a `case` block is immediately followed by a `break;` statement. This is an incorrect exemption; the rule should require exactly the same blank line after those braces as it does elsewhere. Remove the special handling that suppresses the diagnostic when the next token is a `break` keyword inside a `SwitchSectionSyntax`. After the fix, both\n\n```csharp\ncase 0:\n if (cond) { … }\n break;\n```\n\nand\n\n```csharp\ncase 1:\n { … }\n break;\n```\n\nmust report a violation for the `}` token (assuming it is not at the end of the file and no other blank-line exception applies).", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#06c68df0b8e08798fafad8f1290af32fa40406fd", "task_id": "06c68df0b8e08798fafad8f1290af32fa40406fd-1", "task_title": "Fixed issue #599"} {"commit": "a513a26137da5934517885082e01a46f95d204f5", "language": "csharp", "query_count": 2, "query_ids": ["a513a26137da5934517885082e01a46f95d204f5-1::q1", "a513a26137da5934517885082e01a46f95d204f5-1::q2"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "b6b9b0249a142132453873a677b7f09d7d65f34b", "split": "test", "task": "**Title:** `documentInterfaces` should support an `\"exposed\"` mode to require documentation only on non‑internal interfaces\n\n**Context**\n\nThe `documentInterfaces` setting in `stylecop.json` currently accepts a boolean value. \n- When `true`, SA1600 and related rules require documentation for **all** interface members, regardless of accessibility. \n- When `false`, they require no documentation for any interface member.\n\nThis all‑or‑nothing behavior is too coarse for teams that want to enforce documentation on externally visible interfaces but not on `internal` ones.\n\n**Request**\n\nExtend `documentInterfaces` to accept the following string values (the old boolean type should be removed):\n\n| Value | Behavior |\n|------------|----------|\n| `\"all\"` | Documentation is required for all interfaces (equivalent to the old `true`). |\n| `\"none\"` | Documentation is not required for any interface (equivalent to the old `false`). |\n| `\"exposed\"`| Documentation is required **only** for interfaces whose declared accessibility is anything other than `Internal`. This means `public`, `protected`, `protected internal`, and `private protected` interfaces must be documented; `internal` and `private` may be left undocumented. |\n\nFor smoother upgrades, it is acceptable to also accept the string literals `\"true\"` and `\"false\"` as aliases for `\"all\"` and `\"none\"` respectively.\n\n**Affected components**\n\n- The JSON schema (`stylecop.schema.json`) must be updated: `documentInterfaces` should become a string property with a default of `\"all\"`.\n- The settings model (`DocumentationSettings`) must store the value as a string, defaulting to `\"all\"`, and parse it from the configuration.\n- The analyzer `SA1600ElementsMustBeDocumented` (and any other rule that consults `DocumentInterfaces`) must implement the new logic, using `declaredAccessibility` to distinguish `\"exposed\"` from the other modes.\n\n**Acceptance criteria**\n\n- A `stylecop.json` with `\"documentInterfaces\": \"exposed\"` causes documentation warnings only on interface declarations (and their members) whose `declaredAccessibility` is **not** `Internal`.\n- The default value remains `\"all\"`, so existing projects that did not explicitly set the option continue to require documentation for all interfaces.\n- The old boolean values are no longer supported in the schema; any existing JSON must be converted to the new string format.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#a513a26137da5934517885082e01a46f95d204f5", "task_id": "a513a26137da5934517885082e01a46f95d204f5-1", "task_title": "Changed SA1600 and tests to meet new documentInterfaces values"} {"commit": "127cf0dd6d50d6ff26bb5689c1bd225f7fea7c9a", "language": "csharp", "query_count": 2, "query_ids": ["127cf0dd6d50d6ff26bb5689c1bd225f7fea7c9a-1::q1", "127cf0dd6d50d6ff26bb5689c1bd225f7fea7c9a-1::q2"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "af056c346f5d7e1d58c17b220fb65b192781f87d", "split": "test", "task": "**Title:** SA1312 does not check variable names introduced via C# 7 pattern syntax\n\n**Description**\n\nSA1312 (\"Variable names must begin with lower-case letter\") currently only inspects traditional variable declaration sites: `VariableDeclarator`, `ForEachStatement`, `JoinClause`, and `JoinIntoClause`. It misses variables introduced by newer C# 7 pattern syntax, including:\n\n- `out var` declarations (`int.TryParse(\"0\", out var Bar)`)\n- deconstruction declarations (`var (X, y) = (1, 2)`)\n- pattern variables in `is` expressions (`ex is ArgumentException ArgEx`)\n- pattern variables in `switch` case labels (`case int X:`)\n- single-variable designations nested inside other patterns (e.g., `foreach (var (X, y) in ...)`)\n\nAs a result, in C# 7 code, these variable names are never flagged even when they start with an uppercase letter or an underscore, which is inconsistent with the behavior for regular local variables and foreach iteration variables.\n\n**Desired behavior**\n\nSA1312 should analyze **single variable designations** (the syntax node that represents the variable name in these new contexts) and report diagnostics with the same rule ID and severity when a variable name does not begin with a lowercase letter.\n\nThe analysis must respect the same set of safety constraints that apply to other variables:\n\n1. **Discards are exempt** – A single underscore (`_`) used as a discard should never produce a diagnostic. However, a name consisting of multiple underscores (`__`) is not a discard and should be flagged.\n\n2. **NativeMethods class exemption** – Variables inside a class whose name ends with `NativeMethods` must still be ignored entirely, just as they are for ordinary local variables today.\n\n3. **Code-fix compatibility** – The existing `RenameToLowerCaseCodeFixProvider` already knows how to fix SA1312 diagnostics by renaming variables. It should automatically work for these new diagnostics as long as the analyzer emits them with the correct location and metadata. When the rename would conflict with an existing variable, keyword, or parameter already in scope, the code fix must produce a unique non-conflicting name (e.g., by appending a number, or using `@`-escaped keyword notation), matching the behavior provided today for other variable declarations.\n\n**Context / references**\n\n- The rule itself lives in `SA1312VariableNamesMustBeginWithLowerCaseLetter.cs`\n- The C# 7 pattern syntax is represented by `SingleVariableDesignation` nodes in the Roslyn syntax tree\n- The analyzer already uses a centralized `CheckIdentifier` helper that performs the actual name validation; this helper should be reused for the new syntax node kind to avoid duplicating logic or exemptions\n\nNo changes are expected to `RenameToLowerCaseCodeFixProvider.cs` or to any other code-fix provider unless the generated diagnostic locations differ enough to break the existing fix.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#127cf0dd6d50d6ff26bb5689c1bd225f7fea7c9a", "task_id": "127cf0dd6d50d6ff26bb5689c1bd225f7fea7c9a-1", "task_title": "Update SA1312 to handle variable designators (pattern syntax)"} {"commit": "a6e044033e99881569c06aefac2f1ef10cc2a3e1", "language": "csharp", "query_count": 1, "query_ids": ["a6e044033e99881569c06aefac2f1ef10cc2a3e1-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "8eb1db36b3c332ea9bb62af894f94a6901e96dde", "split": "test", "task": "```\nSubject: SA1202 should apply to interfaces and records\n\n### Problem\n\nSA1202 (\"Elements must be ordered by access\") currently only analyzes `class` and `struct` declarations.\nIt ignores `interface` declarations (where members can have access modifiers starting in C# 8) and all `record` forms (`record`, `record class`, `record struct`).\n\nAdditionally, inside an interface, members that omit an access modifier are implicitly `public`.\nThe rule must treat those unmarked members the same as explicitly-`public` members for ordering purposes,\nso that they are ordered correctly alongside other `public` members instead of being silently skipped or\nmis-ordered.\n\n### Acceptance criteria\n\n1. **Interfaces are analyzed**\n - SA1202 fires on members of an `interface` declaration that are ordered incorrectly by access level.\n The expected order is: `public`, `internal`, `protected internal`, `protected`, `private`. \n Unmarked interface members (implicitly `public`) must be treated as `public`, so they sort immediately\n after any explicit `public` members and before `internal`.\n - The code fix can reorder members to satisfy the rule.\n - Example: an `interface` with members in the order\n `private`, `protected internal`, `internal`, `public`, unmarked member\n should be flagged and fixed to:\n `public`, unmarked member, `internal`, `protected internal`, `private`.\n\n2. **Records are analyzed the same as classes/structs**\n - SA1202 must run on `record` (C# 9), `record class` (C# 10), and `record struct` (C# 10)\n declarations and enforce the same access ordering as it already does for `class` and `struct`.\n\n3. **Backward compatibility**\n - Existing behavior for `class` and `struct` must not change.\n - The rule must only be enabled when the language version supports the required features\n (interfaces with access modifiers, record types). If the project’s language level does not\n support them, the analyzer should not produce false positives or crashes, though no\n special handling beyond the compiler’s own syntax support is required.\n\n### Non-goals\n\n- This change does not add new ordering rules or alter the precedence of access levels.\n- It does not affect nested types or other declaration kinds beyond the type declarations\n listed above.\n```", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#a6e044033e99881569c06aefac2f1ef10cc2a3e1", "task_id": "a6e044033e99881569c06aefac2f1ef10cc2a3e1-1", "task_title": "Update SA1202 to support interfaces and records"} {"commit": "0b976baf01df2d70035abbfad651b260d001ebe8", "language": "csharp", "query_count": 1, "query_ids": ["0b976baf01df2d70035abbfad651b260d001ebe8-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "0b976baf01df2d70035abbfad651b260d001ebe8", "split": "test", "task": "Title: SA1137 indentation check misbehaves when type declarations are preceded by attribute lists\n\nSA1137 (ElementsShouldHaveTheSameIndentation) currently treats leading attribute lists as separate elements, or uses the wrong token for indentation, when analyzing class/struct/interface/enum declarations. This produces false positives and incorrect fix suggestions.\n\nExpected behavior:\n\n- For base type declarations (class, struct, interface, enum), any attribute lists that immediately precede the declaration should be ignored when determining the element's indentation. The indentation of the declaration must be measured from the declaration keyword (e.g., `class`), not from the opening bracket of an attribute.\n- When the element being analyzed **is** an attribute list (e.g., on a method, property, field, etc.), the rule must continue to check that attribute list's own indentation exactly as it does today.\n\nThe fix should correctly handle:\n- Multiple attribute lists on the same declaration, both on the same line as each other and on separate lines.\n- Cases where attribute lists are mis-indented relative to the declaration keyword; the diagnostic should reference the location of the keyword (or the appropriate leading whitespace), not the attribute brackets.\n\nNo other rule behavior should change, and all existing tests for indentation of other element kinds must still pass.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#0b976baf01df2d70035abbfad651b260d001ebe8", "task_id": "0b976baf01df2d70035abbfad651b260d001ebe8-1", "task_title": "Add tests for base type declarations and fix bugs"} {"commit": "ce28c3c205bbc6b9de0435c7710a740592857ffa", "language": "csharp", "query_count": 1, "query_ids": ["ce28c3c205bbc6b9de0435c7710a740592857ffa-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "da11cbc9b6dc15bad2816ea1c72c246cec0e55d5", "split": "test", "task": "**Title**: SA1121 should flag `IntPtr` / `UIntPtr` and suggest `nint` / `nuint` on supported runtimes\n\n**Description** \nThe rule SA1121 (Use built-in type alias) currently does not flag uses of `System.IntPtr` or `System.UIntPtr` as missing their built-in aliases, even when the project targets a runtime where native‑sized integers (`nint` / `nuint`) are fully available. It also does not provide a code fix that replaces those types with the `nint` / `nuint` aliases.\n\n**Expected behavior** \n\n1. When the project compiles with a runtime that supports native‑sized integers (detected via the presence of `System.Runtime.CompilerServices.RuntimeFeature.NumericIntPtr`), SA1121 should treat `IntPtr` and `UIntPtr` like other types that have a preferred built‑in alias. Specifically:\n - A type usage of `IntPtr` (or `System.IntPtr`) should trigger a diagnostic suggesting the alias `nint`.\n - A type usage of `UIntPtr` (or `System.UIntPtr`) should trigger a diagnostic suggesting the alias `nuint`.\n\n2. The corresponding code fix should replace `IntPtr` with `nint` and `UIntPtr` with `nuint`.\n\n3. No diagnostic should be produced when the project targets an older runtime that does not provide native‑sized integer support (e.g., .NET 6 or earlier). In that case `IntPtr` and `UIntPtr` should remain untouched, even if the C# language version supports the `nint`/`nuint` syntax.\n\n4. Direct use of the `nint` or `nuint` keywords must not produce a false‑positive SA1121 diagnostic (they are already the “alias”).\n\n**Impact** \nUsers on .NET 7+ who wish to consistently use built‑in type aliases throughout their codebase cannot automatically enforce the rule for `IntPtr`/`UIntPtr` and must manually rewrite those types. This inconsistency also makes it harder to adopt the rule project‑wide.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#ce28c3c205bbc6b9de0435c7710a740592857ffa", "task_id": "ce28c3c205bbc6b9de0435c7710a740592857ffa-1", "task_title": "Update SA1121 for native-sized integers"} {"commit": "eee1e2172a55460d124d38ed5d1687b16fd9d400", "language": "csharp", "query_count": 1, "query_ids": ["eee1e2172a55460d124d38ed5d1687b16fd9d400-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "3e34b6408d09d0b91359efb7776896b9624c8841", "split": "test", "task": "The SA1106 analyzer (\"Code must not contain empty statements\") currently flags a stray semicolon that follows a type declaration such as `class Foo { };`, treating that semicolon as an empty statement. However, the same stray semicolon following a namespace declaration (`namespace Foo { };`) is silently ignored. This is inconsistent—a redundant semicolon after a namespace block is just as meaningless as one after a type block and should be reported by SA1106.\n\nAcceptance criteria:\n- A diagnostic is raised when a `namespace` declaration is immediately followed by a semicolon token (i.e., the semicolon that terminates the namespace's closing brace, with nothing else on that statement), matching the existing behavior for class, struct, interface, and enum declarations.\n- The diagnostic location should point at the semicolon token, not the namespace keyword or the entire declaration.\n- The existing handling for empty statements inside method bodies and the handling of type-declaration trailing semicolons must not regress.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#eee1e2172a55460d124d38ed5d1687b16fd9d400", "task_id": "eee1e2172a55460d124d38ed5d1687b16fd9d400-1", "task_title": "Add support for namespace declarations"} {"commit": "1b24d00739caa72cff027bb39e39a81fc7eebe8a", "language": "csharp", "query_count": 1, "query_ids": ["1b24d00739caa72cff027bb39e39a81fc7eebe8a-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "06d5d3b1163924bd091afe2f5b367b5fc04a8e19", "split": "test", "task": "**Title: SA1304 duplicates SA1307 diagnostics on public and protected readonly fields**\n\nWhen both SA1304 (Non‑private readonly fields must begin with upper‑case letter) and SA1307 (Accessible fields must begin with upper‑case letter) are enabled, a public or protected readonly field that starts with a lower‑case letter triggers **two** diagnostics—one from each rule. This is noisy and unhelpful; the field is accessible, so SA1307 is the more specific rule and should take precedence.\n\n**Expected behavior:**\n\n- If SA1307 is enabled (i.e., not suppressed in the ruleset or `.editorconfig`), SA1304 must **not** fire for `public` and `protected` readonly fields. \n SA1304 should still fire for `internal` readonly fields, even when SA1307 is active (so there is no gap in coverage for truly non‑accessible fields).\n- If SA1307 is suppressed, SA1304 must still report on `public` and `protected` readonly fields exactly as it did before (so projects that opt out of SA1307 do not lose the naming check).\n\nIn other words, SA1304 should yield to SA1307 on any field that is not `internal`, but only while SA1307 is active. There is no change to how internal fields are handled.\n\n**Repro scenario:**\n\n```csharp\npublic class Foo\n{\n public readonly string bar = \"baz\"; // both SA1304 and SA1307 fire\n protected readonly string bar2 = \"baz\"; // both fire\n internal readonly string bar3 = \"baz\"; // currently only SA1304 fires; this should stay\n}\n```\n\nWhen SA1307 is enabled I see SA1304 on all three, which is wrong for the first two. When SA1307 is completely suppressed I still see SA1304 on the first two, which is correct.\n\nPlease fix the overlap so that SA1304 does not report on public/protected readonly fields when SA1307 is present, while keeping the existing behavior when SA1307 is turned off.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#1b24d00739caa72cff027bb39e39a81fc7eebe8a", "task_id": "1b24d00739caa72cff027bb39e39a81fc7eebe8a-1", "task_title": "Fix that SA1304 is reported for accessible fields"} {"commit": "d208f0af4d00d8d70db0aa0284566111941d26c6", "language": "csharp", "query_count": 1, "query_ids": ["d208f0af4d00d8d70db0aa0284566111941d26c6-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "a9ec12fcb7560a6bd0b709e80e8d3b2f17d9e201", "split": "test", "task": "**Title:** SA1209 does not apply to using‑alias directives inside file‑scoped namespaces \n**Area:** OrderingRules / SA1209 \n**Issue:** #3439 \n\n### Description \nSA1209 (`UsingAliasDirectivesMustBePlacedAfterOtherUsingDirectives`) currently checks using‑alias placement only for compilation‑unit usings and for usings inside traditional block‑scoped namespace declarations (`namespace Foo { … }`). It completely ignores using directives inside C# 10 file‑scoped namespace declarations (`namespace Foo;`). \n\nThis leads to false negatives: files that mistakenly place an alias before (or interleaved with) non‑alias usings inside a file‑scoped namespace do not trigger a diagnostic, even though the same ordering would be flagged inside a block‑scoped namespace. \n\n### Expected behavior \nSA1209 should enforce the same ordering rule on using‑alias directives regardless of whether the enclosing namespace is block‑scoped or file‑scoped. \n\n### Example \nThe following code in a file‑scoped namespace should produce a diagnostic on `using L = System.Linq;` because alias directives are not all placed after normal using directives:\n\n```csharp\nnamespace Test;\nusing System.Net;\nusing System.Threading;\nusing L = System.Linq; // should be flagged\nusing P = System.Threading.Tasks;\n```\n\nThe fixed version should place all non‑alias usings before alias usings (and preserve alphabetical order as per other ordering rules, but that is handled by other rules; SA1209 only cares about alias/non‑alias grouping).\n\n### Additional context \n- The adjacent rule SA1208 (`SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives`) was already updated to support file‑scoped namespaces. Its implementation can be used as a reference for the necessary changes. \n- The codebase already contains an abstraction (`BaseNamespaceDeclarationSyntaxWrapper` in the `Lightup` folder) and a registration helper (`SyntaxKinds.BaseNamespaceDeclaration`) that unify both namespace syntax kinds. \n- No changes to the diagnostic descriptor, code fix provider, or rule documentation are required; only the analyzer registration and the namespace‑handling path need to be adjusted. \n\n### Acceptance criteria \n1. SA1209 fires when alias directives are placed before non‑alias directives inside a file‑scoped namespace. \n2. The code fix provider correctly reorders the using directives without introducing a block‑scoped namespace wrapper. \n3. Existing behavior for compilation‑unit usings and block‑scoped namespace usings remains unchanged.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#d208f0af4d00d8d70db0aa0284566111941d26c6", "task_id": "d208f0af4d00d8d70db0aa0284566111941d26c6-1", "task_title": "Update SA1209 to support file-scoped namespaces"} {"commit": "8e4e5ab57cc9f41f8487ac7328d78260eb16657f", "language": "csharp", "query_count": 2, "query_ids": ["8e4e5ab57cc9f41f8487ac7328d78260eb16657f-1::q1", "8e4e5ab57cc9f41f8487ac7328d78260eb16657f-1::q2"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "f7482c129e42cb6faa1cde7260db23dede0694da", "split": "test", "task": "**Title:** SA1130 code fix loses trivia and mishandles generic parameter types when converting anonymous methods to lambdas\n\n**Component:** ReadabilityRules / SA1130\n\n**Description** \nThe SA1130 analyzer suggests replacing anonymous method expressions with lambda expressions where possible. The provided code fix incorrectly handles trivia (comments, whitespace) around the parameter list in several scenarios:\n\n1. **Comments between type and parameter name** – When the anonymous method declares a typed parameter (e.g., `delegate(int /*d*/ i) { }`), the comment that originally appeared between the type and the parameter name is lost or placed in the wrong location after the fix.\n2. **Trivia inside generic type arguments** – If the parameter type is a generic type with comments inside the type arguments (e.g., `delegate(List i) { }`), the code fix either fails to apply or produces invalid/incorrect trivia output.\n3. **Whitespace preservation** – Leading/trailing whitespace around the parameter and its type is not correctly normalized, sometimes introducing extra whitespace or losing significant formatting.\n\nThe expected behavior is that all comments and whitespace from the original anonymous method are transferred faithfully to the resulting lambda expression’s parameter list, so that only the syntactic structure changes and no trivia is silently dropped.\n\nAdditionally, after applying the fix, some cases may require two successive code‑fix invocations to completely resolve all violations (for example, because the parameter type removal and trivia adjustment happen in separate passes). The fix‑all iteration logic should correctly handle this without silently giving up or looping indefinitely.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#8e4e5ab57cc9f41f8487ac7328d78260eb16657f", "task_id": "8e4e5ab57cc9f41f8487ac7328d78260eb16657f-1", "task_title": "Implement CR feedback"} {"commit": "eceae28e9f1e450e564c27681e5f2f4408f6d81d", "language": "csharp", "query_count": 1, "query_ids": ["eceae28e9f1e450e564c27681e5f2f4408f6d81d-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "139c3c7b172c657cbe38107e8e7ebbf69566bda1", "split": "test", "task": "The SA1205 code fix doesn't handle C# 7.2's `private protected` access modifier. When a member is declared `private protected`, the code fix for SA1205 should correctly recognize and propagate the `private protected` keywords, just as it already does for `protected internal`. Currently it falls through to the unexpected-keywords path and produces incorrect results.\n\nMake the SA1205 code fix provider map `Accessibility.ProtectedAndInternal` to the pair of keywords `private` + `protected`, and ensure existing SA1205 tests for nested-type access modifier ordering also exercise `private protected` on class, struct, interface, and record declarations where the language version supports it.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#eceae28e9f1e450e564c27681e5f2f4408f6d81d", "task_id": "eceae28e9f1e450e564c27681e5f2f4408f6d81d-1", "task_title": "Fix SA1205 support for 'private protected'"} {"commit": "d6da323c048b942625a4e4ad0621ed31e529ea2c", "language": "csharp", "query_count": 1, "query_ids": ["d6da323c048b942625a4e4ad0621ed31e529ea2c-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "cfeff715c7f0e704730b79ae74c682c558756475", "split": "test", "task": "```\nSA1114 (Parameter list must follow declaration) currently enforces spacing rules only for\nmethod declarations and invocations. Constructor declarations with the same kind of\nspacing violation are silently ignored. This is a missing case that should be covered.\n\nAcceptance criteria:\n\n- When a constructor’s opening parenthesis is immediately followed by a blank line\n (empty or whitespace only) before the first parameter, SA1114 must emit a warning\n identical to the one it produces for methods in the same situation.\n- No warning should be emitted when:\n - the constructor has no parameters at all,\n - all parameters appear on the same line as the opening parenthesis, or\n - the parameter list starts on the very first line after the opening parenthesis\n (no blank line in between).\n- The fix should treat constructors consistently with how the rule already treats\n methods and invocations – no new message, severity, or rule ID changes.\n```", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#d6da323c048b942625a4e4ad0621ed31e529ea2c", "task_id": "d6da323c048b942625a4e4ad0621ed31e529ea2c-1", "task_title": "SA1114 - handle constructor declaration"} {"commit": "80767801c7deee28458397bd1c930915ec52a1b6", "language": "csharp", "query_count": 2, "query_ids": ["80767801c7deee28458397bd1c930915ec52a1b6-1::q1", "80767801c7deee28458397bd1c930915ec52a1b6-1::q2"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "6f526257e4fbe9bef9691e509a97d794a3db068c", "split": "test", "task": "**Title:** SA1027 should respect the `UseTabs` indentation setting\n\n**Background** \nThe `SA1027` analyzer (Tabs must not be used) currently reports every tab character as a violation regardless of whether the project’s stylecop.json uses `indentation.useTabs = true`. This makes the rule incompatible with projects that prefer tabs for indentation.\n\n**Desired behavior** \n*When `indentation.useTabs` is **false*** (the default): \n- All tabs remain violations. Current behavior is preserved.\n\n*When `indentation.useTabs` is **true***: \n- Tabs that appear **only for leading indentation** (at the start of a line, before any non-whitespace character) should be allowed and not reported. \n- Conversely, **spaces used for indentation** that could have been replaced by a tab (i.e., a run of spaces that reaches or exceeds the configured `tabSize`) should be flagged as violations. \n- Any tab used **after** the first non-whitespace character on a line (e.g., after code, inside comments or strings) is still a violation and must be reported. \n- Indentation that mixes spaces and tabs (spaces followed by a tab within the leading whitespace) is considered an error; the presence of a tab after spaces in the indent should be flagged.\n\nThe corresponding code fix (`SA1027CodeFixProvider`) should adjust its replacement logic accordingly: \n- When `useTabs` is `false`, replace tabs with the appropriate number of spaces (existing behavior). \n- When `useTabs` is `true`, replace leading spaces with the correct number of tabs (and any remaining spaces) while leaving non-indentation whitespace untouched.\n\n**Edge cases to handle** \n\n1. **Start-of-line detection** – Only leading whitespace of a line is eligible for indentation handling. If the offending trivia does not start at column 0 of its line, treat all tabs as violations even when `useTabs` is true (the tab is not pure indentation). \n\n2. **Multi-line constructs** – For multi-line comments or other multi-line trivia, each line’s leading whitespace should be evaluated independently based on the line’s start column. Tabs in the middle of a comment line remain violations. \n\n3. **XML documentation trivia** – Whitespace tokens within XML doc comments (e.g., in `` content) are **not** start-of-line indentation and should **always** have their tabs reported regardless of the `useTabs` setting. \n\n4. **`////` comments** – Unindented comment lines that start with `////` should remain exempt from the rule as they are today (no tabs are reported for them). \n\n5. **Disabled code regions** – Tabs inside `#if false` blocks are ignored, same as the current behavior. \n\n6. **Tabs in string/char literals** – These remain ignored, as with the current rule. \n\n**Additional constraints** \n- The change should not break existing functionality when `useTabs` is `false`. \n- The code fix must handle the conversion of mixed indentation correctly: when switching from spaces to tabs, spaces already accumulated in the replacement buffer must be replaced with a tab character at the appropriate tab stop. \n- The fix must not alter whitespace that appears after the indentation region of the line. \n\nIf the above behavior is implemented, SA1027 will become usable in projects that standardize on tab-based indentation, while continuing to enforce a “no tabs” policy for projects that prefer spaces.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#80767801c7deee28458397bd1c930915ec52a1b6", "task_id": "80767801c7deee28458397bd1c930915ec52a1b6-1", "task_title": "Update SA1027 to support the UseTabs setting"} {"commit": "67e8fd517333d63b6010c9387edcf5d0f1958d64", "language": "csharp", "query_count": 2, "query_ids": ["67e8fd517333d63b6010c9387edcf5d0f1958d64-1::q1", "67e8fd517333d63b6010c9387edcf5d0f1958d64-1::q2"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "f1f6d83c1074476b005a3ea668a5773dc76bc76e", "split": "test", "task": "```\nTitle: SA1110 should check opening parenthesis of argument list in primary constructor base type specifications\n\nProblem:\nSA1110 enforces that opening parentheses in declarations appear on the same line as the preceding token.\nFor primary constructors, it already checks the type's own parameter list (e.g., `class Foo\\n (int x)` is flagged).\nHowever, when a primary constructor type specifies a base type with an argument list,\nthe opening parenthesis of that base-type argument list is not checked.\nFor example, the following is not currently reported:\n\n class Bar(int x) : Foo\n (x)\n { }\n\nExpected behavior:\nSA1110 should flag the opening parenthesis `(` on the line containing `(x)` and offer a code fix that\nmoves it to the same line as the base type name, producing `: Foo(x)`.\nThe same rule should apply when the argument list is empty: `: Foo\\n ()` should be fixed to `: Foo()`.\n\nScope and constraints:\n- This syntax corresponds to Roslyn's `PrimaryConstructorBaseType` syntax node\n (or a light-up wrapper if direct support is not available in the current Roslyn version).\n Ensure any needed light-up constant (e.g., in `SyntaxKindEx`) is added.\n- The handler should delegate to the same line-position check used by other declaration handlers\n (e.g., `CheckIfLocationOfPreviousTokenAndOpenTokenAreTheSame`).\n- Bail out early if the base type identifier name is missing (malformed code).\n- The fix should work for all reference types that support primary constructors\n (class, record); structs cannot have argument lists in base types so they are out of scope.\n\nAcceptance:\n- SA1110 fires on the violation shown above.\n- The code fix moves the opening parenthesis to the base type identifier line.\n- Tests covering the main scenarios (with arguments, without arguments, already-correct placement)\n are added in the C# 9 test class for SA1110.\n```", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#67e8fd517333d63b6010c9387edcf5d0f1958d64", "task_id": "67e8fd517333d63b6010c9387edcf5d0f1958d64-1", "task_title": "Update SA1110 to also check the primary constructor argument list in a base list"} {"commit": "4e7d6504a42f32a5aca66e5949a4a4c34687f6ff", "language": "csharp", "query_count": 2, "query_ids": ["4e7d6504a42f32a5aca66e5949a4a4c34687f6ff-1::q1", "4e7d6504a42f32a5aca66e5949a4a4c34687f6ff-1::q2"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "a72017469c1d237b727318758af326e739579552", "split": "test", "task": "**SA1623: Do not offer a code fix for properties with an empty `` tag**\n\nWhen a property's documentation contains an empty `` element (e.g. `` or ``), the analyzer correctly reports SA1623 because the summary text does not start with the mandatory phrase (`\"Gets\"`, `\"Gets or sets\"`, etc.). However, the code fix provider still tries to generate a fix, which can lead to an unhandled exception or a meaningless document change.\n\nThe diagnostic must continue to be raised—there is no change to the analyzer's reporting. The code fix provider, on the other hand, must detect that the summary content is empty and simply not register a fix.\n\n**Notes**\n- This only affects SA1623. SA1624 cannot fire with an empty summary because it depends on existing text that contains `\"Gets or sets\"`.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#4e7d6504a42f32a5aca66e5949a4a4c34687f6ff", "task_id": "4e7d6504a42f32a5aca66e5949a4a4c34687f6ff-1", "task_title": "Implemented proposed changes from code review"} {"commit": "31084f03fc616d9c293f93ed534cbca4a021f946", "language": "csharp", "query_count": 3, "query_ids": ["31084f03fc616d9c293f93ed534cbca4a021f946-1::q1", "31084f03fc616d9c293f93ed534cbca4a021f946-1::q2", "31084f03fc616d9c293f93ed534cbca4a021f946-1::q3"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "dde97661276b938573ac6b050e816a06fa62828c", "split": "test", "task": "**Title:** File header code fix should preserve other XML header elements when copyright is missing or incorrect\n\n**Background**\nThe StyleCop file header rules SA1634 (file must have a copyright header) and SA1636 (copyright text must match the configured text) each provide a code fix via `FileHeaderCodeFixProvider`. Currently the fix replaces the **entire** file‑header comment block with a new header containing only the copyright element. This means any existing elements like ``, ``, ``, etc. are discarded when the user applies the fix.\n\n**Desired behavior**\n\nFor **well‑formed XML** file headers the code fix should:\n\n- **SA1634 (missing copyright element):** Insert a complete `` element at the correct position in the header without disturbing other elements.\n- **SA1636 (copyright text mismatch):** Update *only* the text content inside the existing `` element, preserving its attributes and its place among the other header elements.\n- Handle multi‑line copyright text correctly, including lines that appear after a blank line inside the element.\n- Handle self‑closing copyright elements (``).\n\nFor **malformed** headers (comment blocks that are not valid XML) the fix may fall back to the current behaviour of replacing the entire header.\n\n**Additional comparer issue**\n\nWhen the analyzer compares multi‑line copyright text from the source against the configured `copyrightText`, leading whitespace on continuation lines (the space inserted after the `// ` comment prefix) is not properly normalised. This causes false‑positive SA1636 reports. The comparison should trim or normalise this whitespace so that only the logical copyright text is compared.\n\n**Acceptance criteria (behavioural)**\n\n1. Given a well‑formed XML header where only the copyright text is wrong, applying the SA1636 fix leaves ``, ``, and other elements untouched and updates only the text lines inside the `` element to match the configured text.\n2. Given a well‑formed header that is missing the `` element entirely, applying the SA1634 fix inserts a new `` element (for example at the top of the header) without deleting other elements.\n3. A malformed header (e.g., lines that cannot be parsed as valid XML) still causes the fix to replace the whole header, as it does today.\n4. The SA1636 diagnostic no longer fires when the difference between the configured text and the source is only in comment‑continuation whitespace.\n\nPlease implement these changes in the code fix provider and the corresponding analyzer logic.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#31084f03fc616d9c293f93ed534cbca4a021f946", "task_id": "31084f03fc616d9c293f93ed534cbca4a021f946-1", "task_title": "Fix so for well formed copyright headers so only the copyright tag is updated. On malformed headers the whole header is replaced."} {"commit": "253d609cc13d90465f94bc27b71fb6bba5182ab4", "language": "csharp", "query_count": 1, "query_ids": ["253d609cc13d90465f94bc27b71fb6bba5182ab4-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "2c4c8da6c69d847de598edc1c2bb82d06a11b9f5", "split": "test", "task": "SA1214 diagnostic location is wrong\n\nThe SA1214 rule \"Static readonly elements must appear before static non-readonly elements\" reports diagnostics on the wrong syntax node. When a readonly static field is placed after a non-readonly static field, the squiggle currently appears on the variable identifier (e.g., the `j` in `static readonly int j = 0;`). This is misleading because the rule is about ordering of whole field declarations, not individual variables within a declaration. The diagnostic should be attached to the entire field declaration, consistent with other ordering rules in the suite.\n\nAdditionally, the rule should not produce any diagnostics when all static fields in a type are readonly (i.e., there is no static non-readonly field present). Please ensure that case remains clean and is covered.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#253d609cc13d90465f94bc27b71fb6bba5182ab4", "task_id": "253d609cc13d90465f94bc27b71fb6bba5182ab4-1", "task_title": "SA1214 - refactoring"} {"commit": "1bcb856942b88c118b3267024f2aa309e8cd13b9", "language": "csharp", "query_count": 3, "query_ids": ["1bcb856942b88c118b3267024f2aa309e8cd13b9-1::q1", "1bcb856942b88c118b3267024f2aa309e8cd13b9-1::q2", "1bcb856942b88c118b3267024f2aa309e8cd13b9-1::q3"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "edfbcf1fdb286aaa50ae2a9cd1e3e471a5ca91ea", "split": "test", "task": "**Title:** SA1516 does not enforce blank lines around `extern alias` inside file-scoped namespaces (C# 10)\n\n**Background** \nRule SA1516 (Elements must be separated by blank line) already handles `extern alias` directives when they appear outside of a namespace declaration, and for regular (block‑scoped) namespace declarations. File‑scoped namespace support was added in a previous release, but `extern alias` directives inside file‑scoped namespaces are currently ignored by both the analyzer and the code fix.\n\n**Observed behavior** \nFor a file‑scoped namespace that contains `extern alias`, `using`, and member declarations:\n- Missing blank lines between the namespace name and the first `extern alias` directive are not reported.\n- Missing blank lines between the last `extern alias` and the first `using` directive are not reported.\n- Missing blank lines between the last `using` directive and the first member declaration are not reported (even when no `extern alias` is present, this gap was already partially missing from the original file‑scoped namespace implementation).\n\n**Expected behavior** \nInside a file‑scoped namespace, SA1516 should require blank lines in the same way it does for regular namespace declarations:\n- A blank line between the namespace name and the first `extern alias` (if any exist).\n- A blank line between the last `extern alias` and the first `using` (if both groups are present).\n- A blank line between the namespace name and the first `using` (when no `extern alias` are present).\n- A blank line between the last `using` and the first member declaration.\n\nThe code fix (`SA1516CodeFixProvider`) must also be updated so that when a diagnostic is raised for an `extern alias` node inside a file‑scoped namespace, the fix provider correctly locates that node as the relevant element to insert blank lines around.\n\n**Edge cases** \n- File‑scoped namespace with `extern alias` only, no usings or members.\n- File‑scoped namespace with `extern alias` and members, but no usings.\n- File‑scoped namespace with `extern alias`, usings, and members – all combinations of missing blank lines between the groups.\n- Multiple `extern alias` directives – only the boundaries between groups matter, not between individual `extern alias` directives themselves (unless otherwise required by settings).\n- The existing `stylecop.json` settings that affect blank line placement (e.g., `usingDirectives.blankLinesBetweenUsingGroups`) should continue to be respected; the new handling should call the same internal helpers already used for usings and members elsewhere.\n\nThe analyzer and code fix should remain compatible with all C# language versions; the change should only affect file‑scoped namespace contexts that already exist in the codebase.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#1bcb856942b88c118b3267024f2aa309e8cd13b9", "task_id": "1bcb856942b88c118b3267024f2aa309e8cd13b9-1", "task_title": "add more tests and fix extern alias"} {"commit": "3b18b2f175f0aef4b2a18e714264d2751c6151ee", "language": "csharp", "query_count": 1, "query_ids": ["3b18b2f175f0aef4b2a18e714264d2751c6151ee-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "7e8d73861ec80c0cec01bf4c9bad95ee6acc8983", "split": "test", "task": "When running **SA1314** (type parameter names must begin with 'T'), the code fix suggests a new name by prefixing 'T' to the existing name. However, the rename suggestion does not fully check for naming conflicts. It only avoids colliding with type parameters of the immediately enclosing type, but does not check against other declarations in the same scope — such as sibling classes, methods, or other members in the enclosing namespace or type. As a result, the code fix can propose a name that would cause a compile-time duplicate-name error when applied.\n\n**Expected behavior:** The rename logic must validate the proposed name against all relevant declarations in the scope where the type parameter is introduced, not just against the enclosing type's own type parameters. In particular:\n\n- For a type parameter on a class/struct/interface, the new name must not conflict with any other type or member in the encompassing namespace/type.\n- For a type parameter on a method, the new name must not conflict with members of the enclosing type, other local declarations where applicable, or types in the namespace.\n- If the obvious 'T'-prefixed name would conflict, the code fix should either not offer a rename, or propose an alternative non-conflicting name (the exact strategy is less important than never offering an invalid conflicting rename).\n\nA concrete scenario: given a namespace containing `class TFoo {}` and a class `Bar {}`, SA1314 flags `Foo`. The code fix must **not** suggest the rename `T Foo` → `TFoo`, because `TFoo` already exists in the namespace.\n\nNo change is needed to the diagnostic itself; only the rename validation inside the code-fix path is affected.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#3b18b2f175f0aef4b2a18e714264d2751c6151ee", "task_id": "3b18b2f175f0aef4b2a18e714264d2751c6151ee-1", "task_title": "Add tests and additional cases to SA1314"} {"commit": "4cdb5faf0f309f2ce1d61915503f24a69a46d55c", "language": "csharp", "query_count": 2, "query_ids": ["4cdb5faf0f309f2ce1d61915503f24a69a46d55c-1::q1", "4cdb5faf0f309f2ce1d61915503f24a69a46d55c-1::q2"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "9e86e321b7807412b77f48ae5e634b261a74aa76", "split": "test", "task": "**Issue:** SA1001 \"Commas must be spaced correctly\" falsely reports a violation for commas inside multidimensional array declarations such as `int[,]` or `int[,,]`. In these declarations the comma is immediately followed by the closing bracket `]`, which is standard C# syntax; no space is required after the comma.\n\n**Expected behavior:**\n- The analyzer should **not** require a space after a comma when the next token is a closing bracket (`]`) — the same way it already makes an exception when the next token is a comma or a `>` (for generic type parameter lists like `typeof(Func<,>)`).\n- The code fix should similarly **avoid inserting** a space after the comma in these contexts.\n- Spaces **before** such commas should still be detected and fixed. For example, `int[, ,]` (space before the second comma) should still be reported and corrected to `int[,,]`.\n\n**Acceptance criteria:**\n- `int[,] myArray;` and similar declarations produce no SA1001 diagnostics.\n- `int[,,]` (with no spaces) produces no SA1001 diagnostics.\n- `int[, ,]` (with a space before the comma that is followed by `]`) produces a diagnostic that the comma was preceded by a space, and the code fix removes that space.\n- The behavior for commas followed by `>` in generic parameter lists remains unchanged.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#4cdb5faf0f309f2ce1d61915503f24a69a46d55c", "task_id": "4cdb5faf0f309f2ce1d61915503f24a69a46d55c-1", "task_title": "Fix for issue #958. SA1001 reported for multidimensional array declaration."} {"commit": "857819aaf0564c50eef1b67e241e82d59eb8055e", "language": "csharp", "query_count": 1, "query_ids": ["857819aaf0564c50eef1b67e241e82d59eb8055e-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "b0aed87cf1527010f688a9ecae09d06b3b77e0fd", "split": "test", "task": "```\nFix false positive diagnostic for using alias directives that reference a type nested inside a generic type.\n\nCurrently, a using alias directive such as:\n\n using Example = System.Collections.Generic.Dictionary.ValueCollection;\n\ntriggers a style diagnostic where none is expected. The diagnostic incorrectly claims the alias is not ordered correctly, uses an invalid name, or otherwise flags the declaration as violating a readability rule even though the declaration is valid.\n\nThe expected behavior is that using alias directives with a target type that is a nested type of a generic type do not produce any diagnostic, assuming the alias otherwise conforms to the relevant readability rules. All existing behavior for non-generic nested types, non-nested types, and array types must continue to work correctly.\n```", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#857819aaf0564c50eef1b67e241e82d59eb8055e", "task_id": "857819aaf0564c50eef1b67e241e82d59eb8055e-1", "task_title": "Fix incorrect qualification of types nested within generic types"} {"commit": "7a823a84a74e94a7560e5620eb4eaa31f2ad8a74", "language": "csharp", "query_count": 1, "query_ids": ["7a823a84a74e94a7560e5620eb4eaa31f2ad8a74-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "dc163bfadd894d3f99aae7a41e8973273c68cf4e", "split": "test", "task": "**Title:** SA1008 and SA1012 produce false positives and incorrect code fixes for C# 8 tuple property patterns\n\n**Environment:** StyleCop.Analyzers `1.2.0-beta*`, C# 8\n\n**Issue:** When using C# 8’s positional pattern matching with property patterns on a tuple, both `SA1008` (Opening parenthesis must be spaced correctly) and `SA1012` (Opening brace must be spaced correctly) report diagnostics that lead to poor or contradictory code fixes. \nA typical expression:\n\n```csharp\n_ = tuple is ( { Length: 1 }, { Length: 2 });\n```\n\ntriggers unexpected spacing warnings. The analyzers either miss required spaces or suggest spaces that make the formatting inconsistent with normal pattern‑matching conventions.\n\n**Expected behavior:**\n\n- `SA1008` should enforce a space between `is` and `(`, and a space after that `(` when it begins a positional pattern clause.\n- `SA1012` should accept **no** space between `(` and `{` when the brace opens a property pattern that immediately follows the opening parenthesis of a positional pattern (i.e., `({` is valid). It must still require a space **after** `{`, so `{ Length: …` is correct.\n- The supplied code fixes should produce the proper formatting:\n ```csharp\n _ = tuple is ({ Length: 1 }, { Length: 2 });\n ```\n\n**Current behavior (example of problems):**\n\n1. `SA1008` does not recognize the positional pattern clause, so it fails to report a missing space before `(` after `is`, and it may not report the missing space after `(`.\n2. `SA1012` flags the absence of a space before `{` in `( {`, even though no space is desired in this specific context, and suggests inserting one. This leads to an incorrect suggestion to change `({` → `( {`, which then conflicts with other spacing rules.\n\n**Potential constraints / edge cases:** \n- The fix should only affect spacing inside a property pattern that is a direct sub‑expression of a positional pattern clause after the `is` keyword. \n- The fix must not alter spacing behavior in other contexts where a `(` precedes a `{` (e.g., collection initializers, array initializers, lambda bodies). \n- It should work correctly for nested patterns and for tuples with more than two elements. \n- The code fix for `SA1012` should remove an unwanted space before `{` in this scenario, but it must preserve leading/trailing space semantics everywhere else.\n\n**Impact:** Developers using tuple pattern matching get noisy, incorrect warnings and are offered code fixes that produce invalid or style‑violating formatting, undermining trust in the analyzer and complicating code reviews.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#7a823a84a74e94a7560e5620eb4eaa31f2ad8a74", "task_id": "7a823a84a74e94a7560e5620eb4eaa31f2ad8a74-1", "task_title": "Fix SA1008 and SA1012 for pattern matching tuples"} {"commit": "7c475903969947160ae1ebf50bd16c1e416ccbcc", "language": "csharp", "query_count": 2, "query_ids": ["7c475903969947160ae1ebf50bd16c1e416ccbcc-1::q1", "7c475903969947160ae1ebf50bd16c1e416ccbcc-1::q2"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "b242672f535f7876129f4afd9c16754c922fa0a1", "split": "test", "task": "The SA1412 code fix (Store files as UTF-8 with byte order mark) does not offer a Fix All option in the lightbulb preview. When a solution contains many non‑UTF‑8 files, the developer has to apply the fix to each file individually, which is slow and error‑prone.\n\nOther StyleCop analyzers in the same repository (for example, SA1407/SA1408) already support Fix All across document, project, and solution scopes.\n\nWe need SA1412 to provide a Fix All provider that:\n- works for every standard fix‑all scope (Document, Project, Solution)\n- applies the same encoding transformation as the existing single‑document SA1412 code fix (convert the file to UTF‑8 with BOM)\n- skips documents that already satisfy SA1412 (i.e., documents for which the analyzer produces no diagnostic), so that unaffected files are left untouched\n- correctly updates the solution so that all fixed documents are stored with the new encoding and receive new document IDs (as the current single‑document code fix does)\n\nThe per‑document transformation logic already exists and is used by the single‑document fix; the fix‑all provider should reuse it rather than duplicating the logic.\n\nThis should be implemented in a way that is consistent with the existing fix‑all implementations in the maintainability rules area (e.g., the SA1407/1408 FixAllProvider), so that the project’s patterns are followed.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#7c475903969947160ae1ebf50bd16c1e416ccbcc", "task_id": "7c475903969947160ae1ebf50bd16c1e416ccbcc-1", "task_title": "Add a fix all provider to SA1412"} {"commit": "a3240ee1d04562b479ce69143203187adc9a9150", "language": "csharp", "query_count": 1, "query_ids": ["a3240ee1d04562b479ce69143203187adc9a9150-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "e60c5965d592449034c0c3a098cdba99b327621e", "split": "test", "task": "**Bug: SA1127 code fix indents constraint clause incorrectly when XML comments or `#region` directives precede the method**\n\n**Observed Behavior**\nWhen StyleCop Analyzers rule SA1127 (generic type constraint clause must be placed on its own line) triggers on a method that has XML doc comments or a `#region` directive immediately before it, the automatic code fix inserts the new line containing the `where` clause with wrong indentation. The indentation is either missing (zero spaces) or unexpectedly large, instead of matching the method declaration’s indentation.\n\n**Expected Behavior**\nAfter applying the code fix, the constraint clause should be placed on a new line indented to the same level as the method declaration — exactly as the fix does when no doc comments or directives precede the method.\n\n**Steps to Reproduce**\n1. Create a class with a generic method that places the `where` clause on the same line as the method signature, and precedes the method with an XML doc comment (e.g., `...`) or a `#region` directive.\n2. Enable SA1127 and run the code fix.\n3. Observe the resulting indentation of the inserted constraint line.\n\n**Additional Context**\nThe problem occurs whenever the method declaration has leading trivia that includes whitespace on lines before the declaration itself. The fix should extract the indentation of the declaration line (the last whitespace trivia before the token that starts the declaration) rather than summing or incorrectly handling whitespace from earlier trivia lines. The fix must work correctly for any combination of leading trivia that may appear before a method declaration, including XML documentation comments, preprocessor directives, blank lines, and any mixture thereof.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#a3240ee1d04562b479ce69143203187adc9a9150", "task_id": "a3240ee1d04562b479ce69143203187adc9a9150-1", "task_title": "Fix SA1127 code fix indenting when additional preceding trivia is present (#1652)"} {"commit": "cbcff6b23a3b87f3cda7a7402bdf8a04587a777b", "language": "csharp", "query_count": 1, "query_ids": ["cbcff6b23a3b87f3cda7a7402bdf8a04587a777b-1::q1"], "repo": "DotNetAnalyzers__StyleCopAnalyzers", "revision": "3817d7bac8596f31af070a26a5c96650fc3ef41e", "split": "test", "task": "**SA1119: Parentheses around implicit stackalloc array creation should not be flagged as unnecessary**\n\nIn C# 8, `stackalloc` can appear without an explicit element type when the element type can be inferred (e.g., `stackalloc[] { 0 }`). SA1119 currently only exempts parentheses around the explicit form (`stackalloc byte[1]`) when used in a variable initializer. The same exemption should apply to the implicit form. \nA statement like \n```csharp\nvar span = (stackalloc[] { 0 });\n``` \nshould not produce SA1119. Do not report a diagnostic for unnecessary parentheses when a parenthesized implicit stackalloc array creation expression appears as the value of an equals-value clause.", "task_family": "DotNetAnalyzers__StyleCopAnalyzers#cbcff6b23a3b87f3cda7a7402bdf8a04587a777b", "task_id": "cbcff6b23a3b87f3cda7a7402bdf8a04587a777b-1", "task_title": "Handle SyntaxKind.ImplicitStackAllocArrayCreationExpression"} {"commit": "21e4450ee1d7ffd18b0609c796369b7c0ef75811", "language": "cpp", "query_count": 2, "query_ids": ["21e4450ee1d7ffd18b0609c796369b7c0ef75811-1::q1", "21e4450ee1d7ffd18b0609c796369b7c0ef75811-1::q2"], "repo": "LizardByte__Sunshine", "revision": "404b434754f8cba5b3017dfed2b46585dd3d87ea", "split": "test", "task": "Bug Report: Stream terminates when display configuration changes during KMS capture**\n\n**Summary** \nWhen streaming from an X11 session using the KMS capture backend, the stream terminates abruptly if the display configuration changes (e.g., resolution change, monitor hotplug, or switching display modes). The capture thread encounters a failure when accessing the DRM framebuffer and treats it as a fatal error, causing the entire streaming session to disconnect.\n\n**Environment** \n- Platform: Linux (KMS/DRM capture) \n- Display server: X11 \n- Capture method: KMS via `kmsgrab.cpp`\n\n**Steps to Reproduce** \n1. Start a streaming session from an X11 desktop using KMS capture. \n2. While streaming, change the display resolution or perform an action that triggers a display reconfiguration (e.g., `xrandr --output ... --mode ...` or connecting/disconnecting a monitor). \n3. Observe that the stream disconnects immediately with an error logged: \"Couldn't get drm fb for plane [...]\".\n\n**Expected Behavior** \nThe capture system should recognize that framebuffer acquisition may temporarily fail during display reconfiguration. Instead of terminating the stream, it should treat this as a transient condition—similar to a capture timeout—and allow the capture loop to retry on the next frame. This would allow the stream to recover automatically once the display reconfiguration completes.\n\n**Actual Behavior** \nThe capture returns `capture_e::error` when `card.fb()` fails to retrieve the framebuffer for a plane. This propagates up to the main capture loop, which terminates the streaming session.\n\n**Impact** \nUsers cannot adjust display settings (resolution, rotation, multi-monitor layout) without interrupting active streams. This is particularly problematic for headless or virtual display setups where configuration changes are common.\n\n**Technical Context** \nThe issue occurs in the KMS capture implementation when querying plane properties during a display reconfiguration window. During this period, the DRM framebuffer ID may be invalid or transitional, causing `drmModeGetFB2` (or similar) to fail. The current implementation logs this as a fatal error and returns `capture_e::error`, whereas `capture_e::timeout` would be more appropriate to indicate that the capture should skip this frame and continue operating.\n\n**Suggested Resolution** \nModify the framebuffer acquisition logic in the KMS capture path to distinguish between permanent capture failures and transient conditions caused by display reconfiguration. When the framebuffer is temporarily unavailable due to reconfiguration, the implementation should return `capture_e::timeout` to allow graceful degradation (dropping the affected frame) rather than terminating the stream.", "task_family": "LizardByte__Sunshine#21e4450ee1d7ffd18b0609c796369b7c0ef75811", "task_id": "21e4450ee1d7ffd18b0609c796369b7c0ef75811-1", "task_title": "Fix stream disconnecting when reconfiguring display in X11"} {"commit": "676d331ba901a27aa3a2992dade3d3124da5eb0e", "language": "cpp", "query_count": 1, "query_ids": ["676d331ba901a27aa3a2992dade3d3124da5eb0e-1::q1"], "repo": "LizardByte__Sunshine", "revision": "0db9f73e6b0d4399b1e5da605123642be64334d4", "split": "test", "task": " Fix builds and shutdown sequences when the system tray is disabled. During shutdown, `system_tray::end_tray()` is invoked unconditionally in the signal handlers within `main()`, causing link errors or runtime failures when the tray is compiled out or disabled via configuration.\n\nGuard the calls to `system_tray::end_tray()` in the shutdown paths with checks against both the compile-time constant `tray_is_enabled` and the runtime configuration `config::sunshine.system_tray` before attempting to terminate the tray service. Ensure this applies to all exit handlers (e.g., SIGINT/SIGTERM signal handlers and the Windows console control handler paths).", "task_family": "LizardByte__Sunshine#676d331ba901a27aa3a2992dade3d3124da5eb0e", "task_id": "676d331ba901a27aa3a2992dade3d3124da5eb0e-1", "task_title": "fix: building without the system tray enabled (#5092)"} {"commit": "c13a30db7876ad18fecd222f4433ccd11f24d6c5", "language": "cpp", "query_count": 2, "query_ids": ["c13a30db7876ad18fecd222f4433ccd11f24d6c5-1::q1", "c13a30db7876ad18fecd222f4433ccd11f24d6c5-1::q2"], "repo": "LizardByte__Sunshine", "revision": "d8877982ffe4a4fc22dbae3e2776145d6651d92a", "split": "test", "task": " As a user with a multi-GPU setup (e.g., display connected to an AMD or Intel GPU, but with an NVIDIA GPU available for compute), I want to be able to force the use of NVENC encoding even when Sunshine automatically detects that the display is not connected to the NVIDIA GPU.\n\nCurrently, when the encoder is set to \"nvenc\", Sunshine's KMS capture implementation automatically filters out non-NVIDIA GPUs when enumerating display devices, preventing the use of NVENC in hybrid GPU configurations where the display output is handled by a different vendor's GPU.\n\nAcceptance Criteria:\n- When the user explicitly configures `encoder = \"nvenc\"` in the video settings, the system should attempt to initialize NVENC regardless of whether the display is connected to an NVIDIA GPU or a non-NVIDIA GPU (AMD/Intel).\n- If the display is connected to a non-NVIDIA GPU but NVENC is explicitly selected, the system must emit a warning indicating that \"Using NVENC with your display connected to a different GPU may not work properly!\"\n- The automatic skipping of non-NVIDIA GPUs should still occur when the encoder is set to automatic detection (i.e., not explicitly \"nvenc\"), preserving existing behavior for default configurations.\n\nConstraints:\n- This change only affects the Linux KMS capture platform (`kmsgrab`).\n- The implementation must check the configured encoder value from the video configuration to determine whether the user has explicitly requested NVENC.", "task_family": "LizardByte__Sunshine#c13a30db7876ad18fecd222f4433ccd11f24d6c5", "task_id": "c13a30db7876ad18fecd222f4433ccd11f24d6c5-1", "task_title": "Allow NVENC to be forced to try capturing non-Nvidia GPUs"} {"commit": "a851ef606879ee2dc3fdb74fce6fe49ecbd88926", "language": "cpp", "query_count": 3, "query_ids": ["a851ef606879ee2dc3fdb74fce6fe49ecbd88926-1::q1", "a851ef606879ee2dc3fdb74fce6fe49ecbd88926-1::q2", "a851ef606879ee2dc3fdb74fce6fe49ecbd88926-1::q3"], "repo": "LizardByte__Sunshine", "revision": "a009d1314f76f983213efb5b4b60f23ead27e6de", "split": "test", "task": " **Session launch timeout should respect `ping_timeout` configuration**\n\nCurrently, when `rtsp_server_t::session_raise()` creates a new streaming session, it applies a hardcoded 10-second timeout while waiting for the client to begin streaming. If the client doesn't connect within this window, the launch event is silently discarded in `clear()`. This timeout should instead respect the existing `config::stream.ping_timeout` configuration value so users can adjust it for their network conditions.\n\nAdditionally, when sessions are discarded due to timeout, no diagnostic information is currently emitted, making it difficult to distinguish between a client that failed to connect versus one that simply took too long.\n\n**Expected behavior:**\n- The session initialization timeout should use `config::stream.ping_timeout` instead of a fixed 10-second duration\n- When a launch event is discarded due to timeout, the debug log should include the session's `unique_id` to aid troubleshooting\n\n**Impact:**\nUsers on slower networks or with clients that require longer initialization times cannot currently complete streaming setup before the session is automatically cleaned up. This forces unnecessary retry loops and connection failures.", "task_family": "LizardByte__Sunshine#a851ef606879ee2dc3fdb74fce6fe49ecbd88926", "task_id": "a851ef606879ee2dc3fdb74fce6fe49ecbd88926-1", "task_title": "Extend session timeout (#1890)"} {"commit": "1839d594926cb0fbaaf064b90e73a150b6570ef3", "language": "cpp", "query_count": 1, "query_ids": ["1839d594926cb0fbaaf064b90e73a150b6570ef3-1::q1"], "repo": "LizardByte__Sunshine", "revision": "434b7e06ce4d451a199cfb192156ab478999a8ae", "split": "test", "task": " **Alphabetically sort applications in configuration**\n\nEnsure that when application entries are persisted via the Web UI configuration API (adding, updating, or deleting), the resulting `apps` array is sorted alphabetically by the application name before writing to the configuration file. This provides a consistent, predictable order in the stored configuration and UI presentation.\n\nThe sort order should use standard lexicographical string comparison on the `name` field. This applies to all mutation handlers in the configuration HTTP interface that modify the application list.", "task_family": "LizardByte__Sunshine#1839d594926cb0fbaaf064b90e73a150b6570ef3", "task_id": "1839d594926cb0fbaaf064b90e73a150b6570ef3-1", "task_title": "feat(apps): order apps alphabetically (#3223)"} {"commit": "fc9b548edd74d829e8aedeef4e76e875e7fc1208", "language": "cpp", "query_count": 1, "query_ids": ["fc9b548edd74d829e8aedeef4e76e875e7fc1208-1::q1"], "repo": "LizardByte__Sunshine", "revision": "7ca2721739d99bfcc49f1a30de9cc73166dda964", "split": "test", "task": " Fix config parser to correctly handle list values that end at the end of the file.\n\nThe config parser in `src/config.cpp` incorrectly reports a \"Missing ']'\" error when a list value (enclosed in square brackets) is properly closed but positioned at the end of the configuration file. This occurs because the parser treats reaching the end of input while scanning for the closing bracket as an unconditional error, even when the closing bracket is present at the end of the file.\n\nModify the list parsing logic to distinguish between unclosed lists and properly closed lists at EOF. The parser should only emit the missing bracket error when the opening bracket is immediately followed by the end of file (indicating an empty, unclosed list), not when `skip_list` returns the end iterator due to the closing bracket being the final character in the file.", "task_family": "LizardByte__Sunshine#fc9b548edd74d829e8aedeef4e76e875e7fc1208", "task_id": "fc9b548edd74d829e8aedeef4e76e875e7fc1208-1", "task_title": "fix(config): fix parse error when list ends on last line of config file (#3772)"} {"commit": "dea1155983e4bd0a2c400b6f9caf7d39ce8d95bc", "language": "cpp", "query_count": 1, "query_ids": ["dea1155983e4bd0a2c400b6f9caf7d39ce8d95bc-1::q1"], "repo": "LizardByte__Sunshine", "revision": "be6f856840979cbeb43fb1f3364e5131aae395c1", "split": "test", "task": " Modify `controlBroadcastThread` to monitor both the global Sunshine shutdown event (`mail::shutdown`) and the broadcast-specific shutdown event (`mail::broadcast_shutdown`) when determining whether to terminate the control broadcast loop.\n\nCurrently, the thread only checks for `broadcast_shutdown`, which prevents it from properly informing connected clients when the entire Sunshine process is exiting gracefully. Update the loop condition to check both events, and ensure the session processing loop breaks early if either shutdown event is triggered. This ensures clients receive termination notifications during both broadcast-specific teardowns and full application shutdowns.", "task_family": "LizardByte__Sunshine#dea1155983e4bd0a2c400b6f9caf7d39ce8d95bc", "task_id": "dea1155983e4bd0a2c400b6f9caf7d39ce8d95bc-1", "task_title": "Inform clients of graceful termination when Sunshine exits"} {"commit": "2f00cb3089a724313cac9b9d6fa263eab973a9bd", "language": "cpp", "query_count": 3, "query_ids": ["2f00cb3089a724313cac9b9d6fa263eab973a9bd-1::q1", "2f00cb3089a724313cac9b9d6fa263eab973a9bd-1::q2", "2f00cb3089a724313cac9b9d6fa263eab973a9bd-1::q3"], "repo": "LizardByte__Sunshine", "revision": "a458b2048b745ae65c5a7143743b57fcfe183445", "split": "test", "task": " Simplify the display matching logic in the XDG portal capture implementation to use human-readable identifiers and direct string comparison.\n\nCurrent behavior: Display names use encoded prefixes (`n` prefix for monitor names, `p` prefix for comma-separated coordinates) requiring complex parsing logic to match PipeWire streams.\n\nDesired behavior:\n- Format display identifiers as plain, descriptive strings: use the monitor name directly when available; when unavailable, use `position-{X}x{Y}-resolution-{W}x{H}` format\n- Replace prefix-parsing matcher with direct string equality between the requested display name and the generated identifier\n- Maintain the invariant that empty display names never match\n- Update stream iteration in the configuration path to allow selection of stream objects for assignment\n\nEnsure compatibility with the existing PipeWire stream enumeration and portal session management.", "task_family": "LizardByte__Sunshine#2f00cb3089a724313cac9b9d6fa263eab973a9bd", "task_id": "2f00cb3089a724313cac9b9d6fa263eab973a9bd-1", "task_title": "feat(linux/xdgportal): Simplify display matching logic (#5053)"} {"commit": "49319d7688a88436d5884d709b397f423c8490ef", "language": "cpp", "query_count": 1, "query_ids": ["49319d7688a88436d5884d709b397f423c8490ef-1::q1"], "repo": "LizardByte__Sunshine", "revision": "dce250d62d497ace578b35fc29d3d044034cdd1d", "split": "test", "task": " When `always_send_scancodes` is enabled in the configuration, non-normalized key events (those with `SS_KBE_FLAG_NON_NORMALIZED` set) should be converted to scancodes using the **active keyboard layout** rather than the hardcoded US English layout map.\n\nCurrently, the code paths for normalized and non-normalized events both fall back to `VK_TO_SCANCODE_MAP` when scancodes are requested. For non-normalized events with `always_send_scancodes` enabled, this produces incorrect scancodes on hosts using non-US layouts. Instead, use `MapVirtualKey` with `MAPVK_VK_TO_VSC` to perform the conversion against the current keyboard layout.\n\n**Edge cases:** `MapVirtualKey` fails to return valid scancodes for `VK_LWIN`, `VK_RWIN`, and `VK_PAUSE`. Skip the `MapVirtualKey` call for these virtual keys and leave their scancodes unset (0) when processing non-normalized events.", "task_family": "LizardByte__Sunshine#49319d7688a88436d5884d709b397f423c8490ef", "task_id": "49319d7688a88436d5884d709b397f423c8490ef-1", "task_title": "fix(win/input): use active keyboard layout for non-normalized key events (#3125)"} {"commit": "7662fe86163d5cb9a822335163dacbda072e9bfa", "language": "cpp", "query_count": 1, "query_ids": ["7662fe86163d5cb9a822335163dacbda072e9bfa-1::q1"], "repo": "LizardByte__Sunshine", "revision": "b494d06f89c44e883652aa444dd5cabb68a3be11", "split": "test", "task": " **Bug Report: Frame pacing errors accumulate over consecutive frames**\n\n**Description:**\nIn the Windows display capture implementation, the frame pacing logic maintains timing by incrementing a `next_frame_time` timestamp with a fixed interval duration after each frame. This approach causes timing errors to accumulate over the duration of a frame pacing group. When the actual sleep duration overshoots or undershoots the target, these errors compound frame-over-frame, potentially leading to increased latency and drift from the intended capture rate.\n\n**Expected Behavior:**\nFrame timing should be calculated from a stable reference point (the start of the frame pacing group) using the frame index within the group and the rational frame rate representation. This ensures that each frame's target time is independently calculated from the group start rather than incrementally adding intervals to a timestamp that may have accumulated prior timing errors.\n\n**Impact:**\nLong-running capture sessions may experience gradual latency increases or inconsistent frame delivery intervals, particularly when the display refresh rate and client frame rate are not exact multiples of each other but are close (e.g., 59.94Hz display with 60fps client). The current workaround of adjusting client frame rates when they are within 99% of the display rate is also sensitive to floating-point precision and could benefit from rational arithmetic.\n\n**Implementation Notes:**\n- The `display_refresh_rate` is available as a `DXGI_RATIONAL` structure which should be used to maintain precision when calculating frame intervals.\n- The `capture()` method in `display_base_t` should track the group start time (`frame_pacing_group_start`) and a frame counter (`frame_pacing_group_frames`) within the group, rather than maintaining a `next_frame_time` that is iteratively updated.\n- When calculating sleep targets, compute the absolute target time from the group start using integer arithmetic: derive whole seconds and remaining nanoseconds from `frame_index * denominator / numerator` and `frame_index * denominator % numerator` respectively, then add to the group start timestamp.", "task_family": "LizardByte__Sunshine#7662fe86163d5cb9a822335163dacbda072e9bfa", "task_id": "7662fe86163d5cb9a822335163dacbda072e9bfa-1", "task_title": "Don't accumulate errors in capture frame pacing"} {"commit": "852dee0a688ccf320c0210ad00507b66cd739a23", "language": "cpp", "query_count": 3, "query_ids": ["852dee0a688ccf320c0210ad00507b66cd739a23-1::q1", "852dee0a688ccf320c0210ad00507b66cd739a23-1::q2", "852dee0a688ccf320c0210ad00507b66cd739a23-1::q3"], "repo": "LizardByte__Sunshine", "revision": "1d6d916b7a1d600e9822d02a3637f3740b700715", "split": "test", "task": " **Fix unhandled exceptions causing launch failures and malformed XML responses**\n\nThe launch process has several failure points where exceptions escape unhandled or produce unhelpful error outputs:\n\n1. **Command parsing crashes**: `find_working_directory` uses `boost::program_options::split_unix` (or `split_winmain` on Windows) to tokenize command strings. If the command contains malformed escape sequences or unmatched quotes, this throws `boost::escaped_list_error`, crashing the launch. This should be caught, logged with the offending command string, and handled gracefully by returning an empty path.\n\n2. **Process wait exceptions**: The `child.wait()` call during command execution throws on failure rather than using the `error_code` overload. This can terminate the session unexpectedly. We should capture the error code, log the specific failure (including the command name), and return -1 to indicate failure.\n\n3. **Silent XML corruption**: In the HTTP launch/resume handlers, if populating the property tree throws an exception, control falls through to the XML serialization with an empty tree, producing malformed XML that causes Moonlight clients to report \"Malformed XML (missing root element)\". We need a diagnostic check before serialization that logs when the tree is empty, explaining that control flow was likely interrupted by an exception.\n\n4. **Inconsistent error logging**: Process exit code checking currently excludes `std::errc::permission_denied` from error logging, but we should uniformly log all non-zero exits to aid debugging.\n\n**Acceptance criteria:**\n- Malformed command strings in `find_working_directory` are handled gracefully with explicit error logging\n- `child.wait()` uses error_code and logs failures without throwing\n- Empty property trees in HTTP handlers trigger an explanatory error log before the malformed XML response is sent\n- All non-zero process exit codes are logged consistently", "task_family": "LizardByte__Sunshine#852dee0a688ccf320c0210ad00507b66cd739a23", "task_id": "852dee0a688ccf320c0210ad00507b66cd739a23-1", "task_title": "fix(launch): Fix several launch failure conditions (exceptions thrown in child.wait, and boost::split_unix) (#4390)"} {"commit": "a0fcaf7d19bd9e8d553d6f19b227326d6a8b7429", "language": "cpp", "query_count": 2, "query_ids": ["a0fcaf7d19bd9e8d553d6f19b227326d6a8b7429-1::q1", "a0fcaf7d19bd9e8d553d6f19b227326d6a8b7429-1::q2"], "repo": "LizardByte__Sunshine", "revision": "f1cd94638f83cb421f89da9fab8664d8e3171d26", "split": "test", "task": " The session monitor window thread in `main()` is currently detached, which risks resource leaks and undefined behavior during application shutdown. Implement proper thread joining with a graceful shutdown mechanism.\n\nRequirements:\n- Ensure the session monitor thread can be signaled to exit by posting a message to its window message loop\n- Add `WM_CLOSE` and `WM_DESTROY` handlers to `SessionMonitorWindowProc` to break the message loop and call `PostQuitMessage`\n- Replace the `detach()` call with a synchronization mechanism that waits for the thread to exit with a timeout (e.g., 1 second)\n- Use `util::fail_guard` or equivalent RAII mechanism to guarantee thread cleanup attempts during scope exit regardless of early returns or exceptions\n- Handle edge cases where window creation fails (NULL hwnd) by avoiding invalid `PostMessage` calls\n- Do not block indefinitely; if the thread fails to exit within the timeout, fall back to `detach()` with a warning log", "task_family": "LizardByte__Sunshine#a0fcaf7d19bd9e8d553d6f19b227326d6a8b7429", "task_id": "a0fcaf7d19bd9e8d553d6f19b227326d6a8b7429-1", "task_title": "Properly join session monitor window thread"} {"commit": "f048510ef701ca6e693fe3ea433aaf7bf7a058ae", "language": "cpp", "query_count": 2, "query_ids": ["f048510ef701ca6e693fe3ea433aaf7bf7a058ae-1::q1", "f048510ef701ca6e693fe3ea433aaf7bf7a058ae-1::q2"], "repo": "LizardByte__Sunshine", "revision": "e15fd551b7e8ccdab2bbf46887268ea02767a980", "split": "test", "task": " **Issue:** The nvhttp HTTPS server does not gracefully close TLS connections, leaving connections vulnerable to truncation attacks and protocol violations. Ensure that all TLS connections are properly shut down before socket closure.\n\n**Acceptance Criteria:**\n- When any HTTPS connection to the GameStream server terminates, the TLS layer must perform a graceful shutdown sequence (exchanging close_notify alerts per RFC 5246) before the underlying TCP socket is closed\n- The server must continue to operate on port 443 with the existing certificate configuration and client verification rules\n- All existing endpoints (`/serverinfo`, `/pair`, `/applist`, `/launch`, etc.) must function identically from the client's perspective, with no changes to request/response behavior or XML/JSON payload formats\n- TLS 1.0 and 1.1 must remain disabled; TLS 1.2+ support must be maintained\n- Client certificate verification callbacks must continue to execute without modification, including the custom verification logic that triggers specific error responses on validation failures\n\n**Constraints:**\n- The fix must be localized to the HTTPS socket lifecycle management within the nvhttp module\n- No changes to the public API surface (`nvhttp::start`, `nvhttp::pin`, etc.) or configuration file formats\n- Must preserve existing error handling behavior for certificate validation failures", "task_family": "LizardByte__Sunshine#f048510ef701ca6e693fe3ea433aaf7bf7a058ae", "task_id": "f048510ef701ca6e693fe3ea433aaf7bf7a058ae-1", "task_title": "fix(nvhttp): wrap TLS socket to ensure graceful closure (#3077)"} {"commit": "0f1dc1bb0575a37a913d1ec0e09c13e2ef5872eb", "language": "cpp", "query_count": 1, "query_ids": ["0f1dc1bb0575a37a913d1ec0e09c13e2ef5872eb-1::q1"], "repo": "LizardByte__Sunshine", "revision": "f22ce25dad5d2316b9f052c4ed1317789407f2a9", "split": "test", "task": " **Feature Request: Detect and warn about NVIDIA GameStream port conflicts**\n\nSunshine and NVIDIA's GameStream service both bind to port 47989 by default, causing connection failures when both are active simultaneously. We need to detect this conflict at startup and alert users with actionable remediation steps.\n\n**Acceptance Criteria:**\n\n1. **Conflict Detection (Windows):** On Windows platforms, check whether NVIDIA GameStream is enabled in the system configuration during application initialization.\n\n2. **Port Evaluation:** Compare the configured Sunshine HTTP port against the default value (47989). Trigger the warning only when:\n - The configured port matches the default (47989), AND\n - GameStream is detected as enabled\n\n3. **User Notification:** When conflict conditions are met, emit a high-severity log message that:\n - Clearly states that GameStream is enabled and will interfere with Sunshine streaming\n - Provides two remediation options: disable GameStream in GeForce Experience, or change Sunshine's port via the Advanced tab in the Web UI\n\n4. **Non-blocking Operation:** The warning must not prevent Sunshine from starting or functioning; the application should continue initialization normally after logging the warning.\n\n5. **Graceful Handling:** If GameStream status cannot be determined (e.g., registry unavailable, insufficient permissions), startup should proceed silently without error.\n\n**Edge Cases & Constraints:**\n- If the user has changed Sunshine's port away from the default, no warning should appear regardless of GameStream status\n- On non-Windows platforms, this check must be skipped entirely\n- Detection should not rely on network port scanning to avoid false positives from transient connections", "task_family": "LizardByte__Sunshine#0f1dc1bb0575a37a913d1ec0e09c13e2ef5872eb", "task_id": "0f1dc1bb0575a37a913d1ec0e09c13e2ef5872eb-1", "task_title": "Print a warning if GameStream is using conflicting ports"} {"commit": "5606840c8983b714a0e442c42d887a49807715e1", "language": "cpp", "query_count": 2, "query_ids": ["5606840c8983b714a0e442c42d887a49807715e1-1::q1", "5606840c8983b714a0e442c42d887a49807715e1-1::q2"], "repo": "LizardByte__Sunshine", "revision": "1ab30aa70bc017ec3aa53a42f559f603d47db97c", "split": "test", "task": "ection**\n\nWhen `capture` is set to auto-detect (empty string), the initialization logic currently verifies and marks every available backend in the `sources` bitset, even after finding a working one. This causes unnecessary probing and can lead to confusion when multiple backends are technically present but only the first suitable one should be selected.\n\n**Expected behavior:**\nWhen auto-detecting capture backends (i.e., `config::video.capture` is empty), the enumeration should stop as soon as a working backend is found and verified. This short-circuits the initialization process and avoids redundant capability checks.\n\n**Constraint:**\nX11 must always be enumerated regardless of whether an earlier backend succeeded, because it serves as a necessary fallback for NvFBC when software encoding is required on X11 sessions.\n\n**Behavior with explicit configuration:**\nIf `config::video.capture` is explicitly set to a specific backend (e.g., \"nvfbc\", \"wlr\", \"kms\", \"x11\"), the current behavior should be preserved—only that specific backend is verified, regardless of the `sources` state.\n\nThe `sources` bitset tracks which backends are available; once any bit is set during auto-detection, subsequent backends (except X11) should be skipped.", "task_family": "LizardByte__Sunshine#5606840c8983b714a0e442c42d887a49807715e1", "task_id": "5606840c8983b714a0e442c42d887a49807715e1-1", "task_title": "Stop enumeration after finding a working capture backend"} {"commit": "3744c43ea7c91ae1b9d2a0d9a5d9e10523d687b6", "language": "cpp", "query_count": 1, "query_ids": ["3744c43ea7c91ae1b9d2a0d9a5d9e10523d687b6-1::q1"], "repo": "LizardByte__Sunshine", "revision": "5b435fd0c1810c4994211a6f4eb1b053a4359514", "split": "test", "task": " Windows: Preserve spatial audio settings by limiting virtual sink to 24-bit\n\nThe virtual audio sink initialization currently attempts 32-bit float and integer formats, which causes Windows to clobber existing Dolby/DTS spatial audio configurations on user endpoints.\n\nUpdate `create_virtual_sink_waveformats()` in `src/platform/windows/audio.cpp` to only offer 24-bit (s24in32, s24) and 16-bit formats for stereo configurations, removing f32 and s32 from the candidate list.", "task_family": "LizardByte__Sunshine#3744c43ea7c91ae1b9d2a0d9a5d9e10523d687b6", "task_id": "3744c43ea7c91ae1b9d2a0d9a5d9e10523d687b6-1", "task_title": "fix(audio/windows): don't set virtual speakers higher than 24-bit mode (#3294)"} {"commit": "5a0bfc755fb9daaedb195e01b18e87ecb14228ba", "language": "js", "query_count": 1, "query_ids": ["5a0bfc755fb9daaedb195e01b18e87ecb14228ba-1::q1"], "repo": "OWASP__threat-dragon", "revision": "a292f66438c567ec37ebbb91f342845d90927ffe", "split": "test", "task": "## Bug: Local provider dashboard shows broken \"Open Existing\" action; trust boundaries always show default label\n\n### Symptoms\n\n**Local provider dashboard actions** \nOn the dashboard for the local (in-browser) provider, the first action card (\"Open Existing\") links to `/local/threatmodels`. This route does not work for the local provider – models are loaded via import, not from a repository listing. The existing import functionality is present as a later action but is not the primary entry point. The broken action should be removed and import should become the first dashboard action, linking to `/local/threatmodel/import` with the `file-import` icon.\n\n**Trust boundary label** \nWhen a trust boundary edge is created or an older diagram is migrated, the edge always displays the text \"Trust Boundary\". This happens even when the source model had no label set for that boundary. The expected behavior is that trust boundaries should not show any default text – an empty label should stay empty, and only explicitly provided text should be displayed.\n\n### Requirements\n\n1. **Local provider dashboard** \n - Remove the non-functional \"Open Existing\" dashboard action. \n - Ensure the import action (`key: 'import'`, route `/local/threatmodel/import`, icon `file-import`) is present and appears as the first dashboard button. \n - No other provider dashboards should be affected.\n\n2. **Trust boundary label** \n - Remove the hardcoded default label `\"Trust Boundary\"` from trust boundary shape definitions. \n - A newly created trust boundary edge should have its label text empty. \n - Migration of version-1 diagrams should preserve an empty label for trust boundaries rather than injecting a default. \n - Existing diagrams that already have a non-empty label on a trust boundary must not be altered.\n\n### Relevant areas\n\n- Dashboard action configuration for each provider type (currently defined in `td.vue/src/service/provider/`). \n- Trust boundary curve shape definition (`td.vue/src/service/x6/shapes/trust-boundary-curve.js`). \n- Diagram migration logic in `td.vue/src/service/migration/`, which may affect how labels are mapped for imported boundaries.", "task_family": "OWASP__threat-dragon#5a0bfc755fb9daaedb195e01b18e87ecb14228ba", "task_id": "5a0bfc755fb9daaedb195e01b18e87ecb14228ba-1", "task_title": "Fixing bugs, improving test coverage"} {"commit": "e692be575f0db97e86d7d0769e450ae77d07e29a", "language": "js", "query_count": 2, "query_ids": ["e692be575f0db97e86d7d0769e450ae77d07e29a-1::q1", "e692be575f0db97e86d7d0769e450ae77d07e29a-1::q2"], "repo": "OWASP__threat-dragon", "revision": "45e6505550267d767ec4d18431c914395f11a00b", "split": "test", "task": "**Feature request: Consolidate threat template selection and rename \"by property\" to \"by context\"**\n\nThe threat editing dialog opens different edit-pane templates (STRIDE, CIA, LINDDUN) depending on the `modelType` of the threat. Currently the logic that maps a model type to the correct template is duplicated in two locations: inside the threat suggestion/sweep flow and inside the element-threats directive. This duplication should be removed, and the mapping should live in one place (the `dialogs` service) so future threat-model types can be added without risking divergent copies.\n\nAt the same time, the button label `Threats by property` in the threat summary pane does not accurately describe the feature. It should be relabeled to **“Threats by context”** and all associated code identifiers updated consistently.\n\n### Acceptance criteria\n\n- **Template selection consolidation** \n The template-picker logic (`modelType` → `diagrams/StrideEditPane.html`, `diagrams/CiaEditPane.html`, `diagrams/LinddunEditPane.html`, with a fallback to STRIDE) is moved into a reusable method on the `dialogs` service. \n Both the threat-suggestion flow and the element-threats directive must call this centralized method instead of maintaining their own private copies. \n The resulting dialog behaviour (the edit pane shown, the prompt headings, and the edit/confirm/cancel interactions) must remain unchanged.\n\n- **Label and function rename** \n The button with id `buttonNewThreatByProperty` and its click handler `onThreatsByProperty` must be renamed to reflect “context”: \n - Button text: `Threats by context` \n - Button id: `buttonNewThreatByContext` \n - Handler name: `onThreatsByContext` \n\n The `threatengine` service method `generateByProperty` must also be renamed to `generateByContext` so the naming is consistent throughout the codebase.\n\n- **No behaviour change** \n Threat generation, threat suggestions, and dialog confirmations must continue to work identically. The only observable differences should be the corrected button label and the internal cleanup of template selection.", "task_family": "OWASP__threat-dragon#e692be575f0db97e86d7d0769e450ae77d07e29a", "task_id": "e692be575f0db97e86d7d0769e450ae77d07e29a-1", "task_title": "consolidate template selection"} {"commit": "70c5065b7175cbce85c5726a0c94b0c82de5c386", "language": "js", "query_count": 2, "query_ids": ["70c5065b7175cbce85c5726a0c94b0c82de5c386-1::q1", "70c5065b7175cbce85c5726a0c94b0c82de5c386-1::q2"], "repo": "OWASP__threat-dragon", "revision": "78fe2c3bf0399d7c0c6856ae380e3f4c24ad8f69", "split": "test", "task": "**Title:** Abstract refresh token storage into a dedicated repository module \n\n**Context:** \nThe server currently stores refresh tokens in an in-memory array inside `td.server/src/controllers/auth.js`. That array is lost on restart, and there is no clean separation between token storage and authentication logic. We want to prepare for future persistent storage (e.g. a database) without touching the authentication API.\n\n**Desired behaviour:**\n\n1. **New token repository module** \n Create a repository module (e.g. `td.server/src/repositories/token.js`) that encapsulates refresh token storage. It must provide at least three operations:\n - **add** a refresh token to the store \n - **remove** a refresh token from the store (invalidating it) \n - **verify** a refresh token: return `true` only if the token is present in the store **and** is a valid JWT signed with the refresh token signing key (`JWT_REFRESH_SIGNING_KEY`). If verification fails (expired, bad signature, etc.), the token should be removed from the store automatically so it cannot be used again.\n\n2. **JWT helper extension** \n The existing `jwt.helper.js` only exposes a `verifyToken` function that uses the access token signing key. Add a corresponding `verifyRefresh` function that calls `jsonwebtoken.verify` with `env.get().config.JWT_REFRESH_SIGNING_KEY`. This keeps refresh‑token validation consistent and testable in isolation.\n\n3. **Controller integration** \n In `auth.js`’s `completeLogin` handler, replace the direct `refreshTokens.push(refreshToken)` with a call to the new repository’s `add` method. Remove the local `refreshTokens` array and its comment. The controller should import the repository instead of managing the array itself.\n\n4. **Behavioural invariants** \n - The in‑memory array is still acceptable as the initial store, but its location should be inside the repository (not in the controller). \n - The repository’s public interface (`add`, `remove`, `verify`) must remain stable so that the store can be replaced later without changing consumers (e.g. logout). \n - Existing authentication flow must not break: after a successful OAuth login, the returned `refreshToken` must still be valid and verifiable through the repository.\n\n**References:** \n- `threatmodelrepository.js` can serve as a style guide for repository modules. \n- Environment variable `JWT_REFRESH_SIGNING_KEY` is already used during token creation; now it must also be used for verification. \n\n**Note:** The existing test for `completeLogin` should be updated to verify that the repository’s `add` is called with the correct token, but no other security behaviour should change.", "task_family": "OWASP__threat-dragon#70c5065b7175cbce85c5726a0c94b0c82de5c386", "task_id": "70c5065b7175cbce85c5726a0c94b0c82de5c386-1", "task_title": "Abstracting token store to a repository implementation. This could be moved to an external data source later without refactoring the API for it"} {"commit": "be61b677ef8330b2be0e6c54bcac4ef583b82600", "language": "js", "query_count": 2, "query_ids": ["be61b677ef8330b2be0e6c54bcac4ef583b82600-1::q1", "be61b677ef8330b2be0e6c54bcac4ef583b82600-1::q2"], "repo": "OWASP__threat-dragon", "revision": "efb2dd8dbd89b570d63b672f1e6db6e102e234dc", "split": "test", "task": "**Request**: Add handling for TM-BOM trust zones during import.\n\nCurrently the TM-BOM import ignores trust zones in the model. Trust zones should be rendered on the imported diagram as trust-boundary-box cells, so users can see the boundaries defined in the model.\n\nBehavioral requirements:\n- For each trust zone defined in the model (`trust_zones`), create a boundary box cell (shape `trust-boundary-box`). \n- The boundary box size should scale with the number of entities assigned to that zone: count all `actors`, `components`, and `data_stores` whose `trust_zone` matches the zone’s symbolic name. Use a simple sizing heuristic (e.g., cells per side grows with number of nodes). \n- Position the boundary boxes on the diagram without overlapping; lay them out in rows with adequate padding. \n- Use the default boundary box properties from the entity defaults, but set `name` and `description` from the trust zone’s title/description. Ensure the default `boundary` and `boundaryBox` objects both include `hasOpenThreats: false` (to stay consistent with other entity defaults). \n- When the model has no explicit `diagrams` array, generate a single default diagram of type `generic` that contains all the generated boundary boxes. If a `diagrams` array is present, each diagram should include the boundary box cells.\n\nThe import logic for diagrams should be updated to call the new trust zone rendering, and the module structure may need reorganizing to support this cleanly (e.g., extracting trust zone box generation into its own helper).", "task_family": "OWASP__threat-dragon#be61b677ef8330b2be0e6c54bcac4ef583b82600", "task_id": "be61b677ef8330b2be0e6c54bcac4ef583b82600-1", "task_title": "add handling for TM-BOM trust zones"} {"commit": "8fe6daaed9246c85f9fdc0366ccc89c16641f93f", "language": "js", "query_count": 1, "query_ids": ["8fe6daaed9246c85f9fdc0366ccc89c16641f93f-1::q1"], "repo": "OWASP__threat-dragon", "revision": "6e7b880f618b8d8ff8bf2c220c8dd127ecaf877d", "split": "test", "task": "```\nThe shell controller currently declares `$location` as a dependency (in the DI annotation and the function signature) but never uses it. Remove this unused injection.\n\nAdditionally, the existing test file `shell_spec.jsx` is not executed by the test runner because of its extension, and it relies on Angular integration mocks that are fragile and don't properly verify the controller's initialization logic. Replace it with a standard `shell_spec.js` that unit-tests the controller function directly, using plain mock objects for `$rootScope`, `$scope`, `common`, and `config`.\n\nThe controller should, when instantiated:\n\n- Log activation via the logger obtained from `common.logger`.\n- Invoke `common.activateController` (with whatever identifier the controller passes).\n- Register a `$viewContentLoaded` listener on `$scope` that, when triggered, sets `$rootScope.appLoaded = true`.\n- Register a `$routeChangeStart` listener on `$rootScope` (the handler must be a function; the test does not need to validate any behaviour inside that handler beyond its existence).\n\nMake the tests cover this contract so that `shell unit tests passing` becomes the stable baseline.\n```", "task_family": "OWASP__threat-dragon#8fe6daaed9246c85f9fdc0366ccc89c16641f93f", "task_id": "8fe6daaed9246c85f9fdc0366ccc89c16641f93f-1", "task_title": "shell unit tests passing"} {"commit": "4d885f8b1539d1cea7d85c672833d3bf06f99cde", "language": "js", "query_count": 1, "query_ids": ["4d885f8b1539d1cea7d85c672833d3bf06f99cde-1::q1"], "repo": "OWASP__threat-dragon", "revision": "4d885f8b1539d1cea7d85c672833d3bf06f99cde", "split": "test", "task": "As part of adding TM‑BOM (Threat‑Modeling Bill‑of‑Materials) support to Threat Dragon, implement import and export converters for a model’s **metadata (meta)** and **scope** sections. \nThe converters must live in the migration service and follow the existing import/export patterns already used for other threat‑model formats.\n\n---\n\n### Acceptance criteria \n\n#### Import (TM‑BOM → Threat Dragon) \n\nWhen importing a valid TM‑BOM model: \n\n1. The threat‑model `summary` is populated from the TM‑BOM `scope`: \n - `summary.title` ← `scope.title` \n - `summary.description` ← `scope.description` \n - `summary.owner` set to an empty string \n - `summary.id` set to 0 \n\n2. TM‑BOM `scope` fields that Threat Dragon **does not (yet) use** are stored in a compatibility object inside the summary, so they survive a round‑trip: \n - `business_criticality` \n - `data_sensitivity` \n - `exposure` \n - `tier` \n\n3. The **top‑level TM‑BOM metadata** is also stored in the same compatibility object, even though Threat Dragon does not currently use it: \n - `version` (the original TM‑BOM version) \n - `description` (top‑level, distinct from scope description) \n - `frozen` \n - `release_docs_link` \n - `reviewed_at` \n - `repo_link` \n\n4. The Threat Dragon model version is set to the **converter’s hard‑coded version** corresponding to the Threat Dragon release for which the migration was written. At this time the value is `2.4.1`. \n\n5. The import must handle the case where `scope` is missing (produce a summary with no extra fields, no errors). \n\n#### Export (Threat Dragon → TM‑BOM) \n\nWhen exporting a Threat Dragon model that was previously imported from TM‑BOM: \n\n1. The TM‑BOM `scope` is reconstructed: \n - `scope.title` ← `summary.title` \n - `scope.description` ← `summary.description` \n\n2. The extra `scope` fields are reinstated from the compatibility object **if it exists**: \n - `scope.business_criticality`, `data_sensitivity`, `exposure`, `tier` \n\n3. The top‑level TM‑BOM metadata is reinstated from the compatibility object **if it exists**: \n - `frozen`, `release_docs_link`, `reviewed_at`, `repo_link`, `description` \n\n4. The exported TM‑BOM model version is taken from the compatibility object’s `version` field **if present**; otherwise it defaults to `'1.0'`. \n\n---\n\n### Design constraints \n\n- **Round‑trip fidelity** is critical: a TM‑BOM file imported and immediately exported must produce an equivalent TM‑BOM structure, with all original fields present and unchanged (except that the top‑level `version` may be the original one, not the converter version). \n- The converters must be **hosted in the existing migration area** under `td.vue/src/service/migration/tmBom/` and be structured as separate modules for the top‑level model and for the scope, just as other format converters are organized. \n- Use only plain JavaScript objects; no prototypes or classes. \n- The export must gracefully handle the absence of the compatibility object (in models that were never imported from TM‑BOM), supplying sensible defaults where required. \n\n---\n\n### Out of scope \n\nThis request covers **only meta and scope** – the diagram/entities/threats mapping will be handled separately.", "task_family": "OWASP__threat-dragon#4d885f8b1539d1cea7d85c672833d3bf06f99cde", "task_id": "4d885f8b1539d1cea7d85c672833d3bf06f99cde-1", "task_title": "TM-BOM import and export: meta and scope"} {"commit": "cfb7e1be245c0a7c17bc937e1a222832c9278de6", "language": "js", "query_count": 1, "query_ids": ["cfb7e1be245c0a7c17bc937e1a222832c9278de6-1::q1"], "repo": "OWASP__threat-dragon", "revision": "1bfdbfcbd7c26045c40c52f2bb62e7bd31a327f7", "split": "test", "task": "**Request: Restrict server rate limiting to production environments only**\n\n**Background** \nThe Threat Dragon server applies an Express rate‑limiting middleware. Currently it is active in all environments *except* when `NODE_ENV=development`. This causes problems for automated end‑to‑end tests and staging deployments that run in environments other than `development` (e.g. `test`, `staging`, or when `NODE_ENV` is unset) – they encounter unexpected rate‑limit rejections.\n\n**Acceptance criteria**\n\n1. Rate limiting is **active** only when the `NODE_ENV` environment variable is explicitly set to the string `\"production\"`.\n2. Rate limiting is **inactive** for every other value of `NODE_ENV` (including when it is not set, empty, `test`, `staging`, or any other custom value).\n3. When rate limiting is activated, the server writes an informational log message that clearly indicates rate limiting is being applied in a production environment.\n4. When rate limiting is deactivated (any non‑production environment), the existing warning message (“Rate limiting disabled for development environments”) is updated to reflect that it is disabled for non‑production environments in general (the exact wording may be adjusted to be accurate, e.g. “Rate limiting disabled – not a production environment”).\n5. The change must not alter any other startup behaviour (static file serving, repository configuration, proxying, etc.).\n\n**Affected surface** \nThe Express application bootstrap inside the `td.server` component. No changes are required to the rate‑limiter configuration itself; only the guard that decides whether to call `app.use(limiter)` needs to be tightened to a strict equality check against `\"production\"`.\n\n**Rationale** \nThis makes the rate‑limiting policy explicit and safe: only the live production deployment is protected by rate limiting, while any other environment (CI, QA, local development) can operate without artificial request caps.", "task_family": "OWASP__threat-dragon#cfb7e1be245c0a7c17bc937e1a222832c9278de6", "task_id": "cfb7e1be245c0a7c17bc937e1a222832c9278de6-1", "task_title": "rate limiting explicitly for production environments"} {"commit": "b18ad150e4fc3a657fa9c90af680ceac47de7d8e", "language": "js", "query_count": 1, "query_ids": ["b18ad150e4fc3a657fa9c90af680ceac47de7d8e-1::q1"], "repo": "OWASP__threat-dragon", "revision": "b18ad150e4fc3a657fa9c90af680ceac47de7d8e", "split": "test", "task": "**Ticket title:** Re-enable and fix unit tests for Branch, Dashboard, and Home views\n\n**Description:** \nSeveral view unit tests are currently skipped (`xdescribe`) and need to be re-enabled.\n\n- **Branch view test** – the router mock is broken.\n- **Dashboard view test** – the state shape is incorrect after the provider store module refactor (the test references `datasource.provider` but the actual module now has `provider.selected`). The test should also check for the welcoming text rather than only asserting element existence.\n- **Home view test** – the component performs an OAuth login by calling the backend endpoint with raw `fetch`. Inline `fetch` is hard to mock cleanly and deviates from the project’s established API service pattern. Refactor the call so that it uses a dedicated service that wraps our `api` client (imported from `@/service/api.js`). The service should be unit-testable on its own and then mocked in the Home view test.\n\n**Acceptance criteria:**\n- Branch, Dashboard, and Home view tests are no longer skipped (`describe` instead of `xdescribe`).\n- All three test suites pass with the current production code.\n- The Home view’s login method no longer calls `fetch` directly. It dispatches the selected provider event, calls the new service function, and uses the returned data to redirect via `window.location.href`.\n- The dashboard test uses the correct state shape (`provider.selected`).\n- The branch router mock is fixed so the test can mount the component without error.", "task_family": "OWASP__threat-dragon#b18ad150e4fc3a657fa9c90af680ceac47de7d8e", "task_id": "b18ad150e4fc3a657fa9c90af680ceac47de7d8e-1", "task_title": "Branch, dashboard and home unit tests"} {"commit": "f145d647f8b3fb6554a781e7b3623f6d8d57df43", "language": "js", "query_count": 2, "query_ids": ["f145d647f8b3fb6554a781e7b3623f6d8d57df43-1::q1", "f145d647f8b3fb6554a781e7b3623f6d8d57df43-1::q2"], "repo": "Wirecloud__wirecloud", "revision": "d9ec54afc71d92ad80332f326bd7156b6e2ea1c6", "split": "test", "task": "```\nTitle: Improve robustness and API consistency of Notebook component\n\nThe `Notebook` component (`src/wirecloud/commons/static/js/StyledElements/Notebook.js`) needs a round of API hygiene improvements:\n\n- Make the following methods chainable (return `this`, matching other StyledElements components): `shiftLeftTabs`, `shiftRightTabs`, `repaint`, `clear`, `requestFullscreen`, `exitFullscreen`.\n- `shiftLeftTabs` currently does not guard against an empty notebook or a state where the first tab is already fully visible. Modify its internal transition logic so that these cases do not cause errors or invalid shifts.\n- `repaint` should handle an empty tab list gracefully without throwing and still return `this`.\n- `exitFullscreen` should not invoke `document.exitFullscreen` when the notebook is not actually in fullscreen mode; it should just return `this` in that situation.\n- Remove the `isDisabled` method if it is dead code and its role is already covered by `setDisabled` / the disabled layer.\n- Add or improve JSDoc comments for `shiftLeftTabs`, `shiftRightTabs`, `requestFullscreen`, `exitFullscreen`, and any other public methods that currently lack documentation, describing their purpose and return type.\n\nFocus on the external behavior and keep the changes localised to the Notebook class; do not alter the component's public API beyond the described improvements.\n```", "task_family": "Wirecloud__wirecloud#f145d647f8b3fb6554a781e7b3623f6d8d57df43", "task_id": "f145d647f8b3fb6554a781e7b3623f6d8d57df43-1", "task_title": "Improve style notebook code, doc and tests"} {"commit": "0cca8dd19b57132fc591238905fb40c3ccb85905", "language": "js", "query_count": 2, "query_ids": ["0cca8dd19b57132fc591238905fb40c3ccb85905-1::q1", "0cca8dd19b57132fc591238905fb40c3ccb85905-1::q2"], "repo": "Wirecloud__wirecloud", "revision": "1e7fbfbcb622f3e03f2d48928436fe5c4c5bedc1", "split": "test", "task": "**Title:** `find_iwidgets()` and `instantiate()` return stale element references causing flaky Selenium failures\n\n**Description:**\nWhen running the desktop Selenium test suite, helper methods that locate widget instances on the workspace frequently cause `StaleElementReferenceException` or operate on elements that are no longer in the DOM. This affects two public surfaces:\n\n1. `RemoteTestCase.find_iwidgets(tab=None)` – returns a list of `IWidgetTester` objects, but some of those objects may refer to stale `WebElement` references or be `None`, especially after the workspace updates asynchronously.\n2. `WidgetWalletResourceTester.instantiate()` – adds a widget from the wallet to the workspace and returns an `IWidgetTester` for the newly added widget, but the returned tester often becomes stale immediately.\n\nThese problems make tests unreliable and cause hard-to-diagnose failures, for example in `LocalCatalogueSeleniumTests.test_resource_uninstall_all_version`, where indexing into the result of `find_iwidgets()` fails because the referenced element has been detached.\n\nThe root cause appears to be that the current implementation fetches widget DOM elements via `execute_script` (getting `iwidget.element` from the JavaScript runtime) and then reuses those references, which become invalid when the DOM is re-rendered. The desktop test helpers should instead locate the `.iwidget` DOM elements fresh each time using CSS selectors scoped to the active workspace tab.\n\n**Expected behavior:**\n- `find_iwidgets()` should always return a list of valid `IWidgetTester` instances that represent the current workspace state, with no stale or `None` entries.\n- `instantiate()` should reliably return a tester for the newly added widget after it becomes visible, using a stable attribute (like the widget’s id) to locate its DOM element rather than caching a reference obtained before the widget is fully rendered.\n- The mobile test subclass (`MobileWirecloudRemoteTestCase`) should preserve its current behaviour (which may legitimately rely on JavaScript evaluation and retry on stale references), so any change must be scoped to the desktop path.\n- The workspace tab wrapper elements need a `data-id` attribute so that CSS selectors can scope widget queries to a specific tab. This attribute is currently missing from the `Tab` constructor.\n\n**Impact:**\nFlaky tests, wasted debugging time, and false-positive CI failures. Fixing this will make the desktop test helpers robust against DOM changes and avoid the need for fragile retry loops or `sleep` calls.", "task_family": "Wirecloud__wirecloud#0cca8dd19b57132fc591238905fb40c3ccb85905", "task_id": "0cca8dd19b57132fc591238905fb40c3ccb85905-1", "task_title": "Fix some problems with current find_iwidgets implementation"} {"commit": "75dd03202e3630d28b83314a2c892cfa6069a2f1", "language": "js", "query_count": 1, "query_ids": ["75dd03202e3630d28b83314a2c892cfa6069a2f1-1::q1"], "repo": "Wirecloud__wirecloud", "revision": "c5b87786a65d91457a9acb552c91521ca55a5de5", "split": "test", "task": "Allow users to delete their last personal workspace. \n- Remove the restriction that hides the \"Remove\" option when the user has only one workspace. The remove action should be available for every workspace the user owns, regardless of workspace count. \n- After deletion, instead of trying to switch to another personal workspace (which may not exist), redirect the user to the built-in `wirecloud/home` dashboard. That dashboard is owned by the `wirecloud` org, not by the logged-in user, so the UI must not show workspace-editing actions (rename, settings, remove) while this dashboard is displayed. \n- Make sure `changeActiveWorkspace` can accept a workspace identifier as an `{owner, name}` plain object (without an `id`) in addition to the full workspace record, so the redirect to `wirecloud/home` works properly.", "task_family": "Wirecloud__wirecloud#75dd03202e3630d28b83314a2c892cfa6069a2f1", "task_id": "75dd03202e3630d28b83314a2c892cfa6069a2f1-1", "task_title": "Allow users to remove the last workspace they have"} {"commit": "4a247e572e6ecc2b5a0ecdf08720791b9fb34c7d", "language": "js", "query_count": 2, "query_ids": ["4a247e572e6ecc2b5a0ecdf08720791b9fb34c7d-1::q1", "4a247e572e6ecc2b5a0ecdf08720791b9fb34c7d-1::q2"], "repo": "Wirecloud__wirecloud", "revision": "7bcaafcb69883fa9a88958ecdea1ea22087e0533", "split": "test", "task": "```markdown\n**Title:** Improve Wirecloud.Task: subtask aggregation, value storage, toTask for promise chains, and toString \n\n**Component:** `wirecloud/platform/static/js/wirecloud/Task.js` (the `Wirecloud.Task` class) \n\n**Request:** \nThe `Wirecloud.Task` class (promise-like object with progress and abort) needs several enhancements to make it more useful for representing composite operations and operation chains. The following behaviors should be added or clarified:\n\n1. **Value storage:** \n When a task is fulfilled (`fulfill(value)`) or rejected (`reject(reason)`), the passed value should be stored on the task instance and exposed as a property (e.g., `task.value`). Currently the callbacks can receive the value, but the task itself does not retain it.\n\n2. **Subtask aggregation:** \n The constructor should accept an array of existing `Task` objects in addition to a function. When an array is passed, the new task represents an aggregation of those subtasks. \n - The aggregated task’s progress must be the average of the subtasks’ progresses, updated whenever any subtask’s progress changes. \n - The aggregated task’s status should be derived as follows: \n - If *any* subtask is still `\"pending\"`, the aggregation is `\"pending\"`. \n - If any subtask is `\"aborted\"`, the aggregation is `\"aborted\"`. \n - Otherwise, if any subtask is `\"rejected\"`, the aggregation is `\"rejected\"`. \n - Only when all subtasks are `\"resolved\"` should the aggregation be `\"resolved\"`. \n - The aggregated task’s value should be an array of the subtasks’ values (in order). \n - The subtasks should be accessible via a read-only property (e.g., `task.subtasks`). \n - Passing an empty array must throw a `TypeError`. \n - Aborting a single subtask should cause the aggregation to transition to `\"aborted\"`.\n\n3. **Title immutability during progress updates:** \n The `update` callback provided to the executor currently allows changing the title. Remove that capability so that `title` is set only at construction time and cannot be modified later. \n\n4. **`toString()` implementation:** \n The task should implement `toString()` so that it returns a string containing its title and progress (e.g., `\"task title: 42%\"`).\n\n5. **`toTask()` for promise chains:** \n When `toTask(title)` is called on a task-returning chain built with `.then(...)`, the resulting `Task` should: \n - Include all steps of the chain as subtasks (including any intermediate `Task` instances returned from callbacks). \n - Compute progress based on the number of completed steps over the total number of steps. \n - Expose the sequence via its `subtasks` property. \n - Resolve/reject with the same final value/reason as the original chain. \n - Respect the normal aggregation rules (e.g., aborting any subtask aborts the whole task). \n\n Calling `toTask` on a simple (non-chained) task should similarly wrap it, making the original task its single subtask and propagating progress.\n\n**Acceptance criteria (conceptual):** \n- A task created with an array of immediate‑fulfill subtasks is immediately resolved with value `[sub1value, sub2value]` and progress `100`. \n- A task created with one immediately‑failed subtask is immediately rejected with value containing both subtask values, and progress reflects the completed fraction (50% for two subtasks). \n- Aborting a subtask that is part of an aggregation changes the aggregated task’s status to `\"aborted\"`. \n- `task.toString()` returns a non‑default string that includes the title. \n- Chaining several `.then()` calls (some returning Promises, some returning Tasks) and calling `.toTask(\"name\")` produces a task with the correct number of subtasks, tracks progress through completion, and ultimately resolves with the final value.\n\n**Non-goals (for this ticket):** \n- Changing the existing `abort()`, `catch()`, or event‑dispatch semantics outside what is needed for aggregation. \n- Modifying the `renameTask` method. \n- Adding serialization/deserialization support.\n\nLet me know if you need additional clarification.```\n\nNow, evaluate how well this prompt fits the criteria: It does not mention tests or commits; it describes features and invariants. It uses code-specific terms (Wirecloud.Task, toTask, then, progress, title) as needed for disambiguation. It is concise but covers edge cases like empty array, abort propagation, progress averaging, and chain step counting. It's from a maintainer's perspective. This should be a solid prompt for training.", "task_family": "Wirecloud__wirecloud#4a247e572e6ecc2b5a0ecdf08720791b9fb34c7d", "task_id": "4a247e572e6ecc2b5a0ecdf08720791b9fb34c7d-1", "task_title": "Improve Task class"} {"commit": "c9d55755a170de6b21759fae0783b4ff47fe9159", "language": "js", "query_count": 5, "query_ids": ["c9d55755a170de6b21759fae0783b4ff47fe9159-1::q1", "c9d55755a170de6b21759fae0783b4ff47fe9159-1::q2", "c9d55755a170de6b21759fae0783b4ff47fe9159-1::q3", "c9d55755a170de6b21759fae0783b4ff47fe9159-1::q4", "c9d55755a170de6b21759fae0783b4ff47fe9159-1::q5"], "repo": "Wirecloud__wirecloud", "revision": "ed99359170bf2eed06f95c74de249ff52399274b", "split": "test", "task": "**Ticket: Fix variable handling after model refactoring**\n\n**Background** \nWe recently replaced the old abstract‑variable system with a new `Variable` model (a foreign key to `VariableDef`). Several bugs in the data layer and frontend contract were introduced at that point.\n\n**Observable symptoms** \n- Igadget variables are returned as a JSON array, but the frontend’s `VarManager.parseIGadgetVariables` now expects them as an object keyed by variable **name** (the structure that `GadgetTemplate.getVariables` returns).\n- User‑preference values for igadgets are sometimes wrong or missing because the values cache is keyed by `vardef.id` instead of `variable.id` – this causes collisions when multiple igadgets share the same gadget template.\n- Creating a new igadget for a gadget that has only SLOT/EVENT variables fails to create the necessary `Variable` records and connectable objects.\n- After saving an igadget, the server still serves stale variable values because the values cache is not invalidated.\n- The variable serialization still includes `igadgetId` and `vardefId` fields that the frontend no longer touches, and it also sends `value`/`shared` for non‑user‑perference aspects (SLOT, EVENT, GCTX, ECTX).\n\n**What a fix must achieve**\n\n1. **Data format for igadget variables** \n `get_igadget_data` must return `variables` as a dictionary keyed by the variable **name** (from `VariableDef.name`), not a list. Each value should contain `id` and `name`. The fields `igadgetId` and `vardefId` must be removed. \n\n2. **Limit exposed value data** \n `get_variable_data` must include `value` and `shared` **only** for aspects `PREF` and `PROP`. For SLOT/EVENT/GCTX/ECTX, just return `id` and `name` (no `value`).\n\n3. **Cache correctness** \n The per‑user cache (`_populate_variables_values_cache`) must be indexed by `variable.id` (not `variable.vardef.id`), and `get_variable_data` must use the same key for look‑ups.\n\n4. **Variable creation** \n `addIGadgetVariable` must unconditionally create a `Variable` record (for **all** aspects). Only for PREF/PROP should it then create a `VariableValue`. For SLOT/EVENT it must call `createConnectable` with the new `Variable` instance (not the `VariableDef`). \n The `createConnectable` helper itself must use `Out.objects.create`/`In.objects.create` (standard Django ORM), not any custom `.create()` method.\n\n5. **Cache invalidation** \n After an igadget is saved (`SaveIGadget`), invalidate the user’s cached variable values so the next request picks up fresh data.\n\n6. **Variable‑value cloning** \n `clone_original_variable_value` must accept a `Variable` instance instead of a workspace. Look‑up should be by `variable` and `user`, and creation should use `VariableValue.objects.create(variable=..., user=..., value=...)`.\n\n7. **Side‑cleanup** \n Remove the unused import `ContextOption` from `gadget.models` in the data module. \n In the frontend, methods of `GadgetTemplate` that iterate over `variableList` must handle it as an object (formed by variable names), consistent with the `getVariables` return shape. `VarManager.parseIGadgetVariables` must walk the expected object structure and correctly default values for fields that may be missing in the server response (`readOnly`, `hidden`, etc.).\n\n**Non‑goal** \n- No schema migration needed – this is just about how existing model relations are used.\n- The workspace‑variable collection endpoint does not need structural changes; just clean up any leftover unused variables.", "task_family": "Wirecloud__wirecloud#c9d55755a170de6b21759fae0783b4ff47fe9159", "task_id": "c9d55755a170de6b21759fae0783b4ff47fe9159-1", "task_title": "Fix some bugs introduced in the model refactorization"} {"commit": "d1faa24654be929959845d77b46343e94f8bc541", "language": "js", "query_count": 2, "query_ids": ["d1faa24654be929959845d77b46343e94f8bc541-1::q1", "d1faa24654be929959845d77b46343e94f8bc541-1::q2"], "repo": "Wirecloud__wirecloud", "revision": "9abeef44067029c3b98abe763742e83e006b4ca9", "split": "test", "task": "Fix operator reinstallation after uninstall/reinstall cycle\n\nWhen an operator is uninstalled while it is wired in a workspace and then reinstalled, it does not recover correctly:\n- Connections that existed before uninstall do not propagate events after reinstall.\n- Preferences revert to defaults instead of keeping their previously saved values.\n- Placeholder (“ghost”) target endpoints left behind by the missing operator sometimes throw errors because they attempt to propagate incoming values.\n- The wiring connection-filtering logic misidentifies which connections belong to a given entity, causing some connections to be overlooked or incorrectly processed.\n\nThe expected behavior after reinstalling an operator is that all its previous wiring connections become fully operational again, and its preference values are restored to whatever they were before uninstallation. Ghost endpoints must never attempt to forward events.", "task_family": "Wirecloud__wirecloud#d1faa24654be929959845d77b46343e94f8bc541", "task_id": "d1faa24654be929959845d77b46343e94f8bc541-1", "task_title": "Fix problems reinstalling operators"} {"commit": "14a53d8609e04fe881afecdada87e0e03191d56a", "language": "js", "query_count": 3, "query_ids": ["14a53d8609e04fe881afecdada87e0e03191d56a-1::q1", "14a53d8609e04fe881afecdada87e0e03191d56a-1::q2", "14a53d8609e04fe881afecdada87e0e03191d56a-1::q3"], "repo": "Wirecloud__wirecloud", "revision": "55d0da0b78a44c3c4fdb07bbefcf5bf6a9111492", "split": "test", "task": "The catalogue API responses (from listing/search endpoints and from the resource upload endpoint) currently represent each resource as a flat array of version objects, where each version repeats the resource’s `vendor`, `name`, and `type`. Since these three properties are constant across all versions of the same resource, they should be lifted to a parent object level and not duplicated per version.\n\nAcceptance criteria:\n- When fetching the catalogue resource list, search results, or the response after adding a new resource, each resource is returned as an **object** with keys `vendor`, `name`, `type`, and `versions`. `versions` is an array of per-version data that does **not** include `vendor`, `name`, or `type`.\n- The shape of the version objects inside `versions` remains the same except for the removal of those three duplicated fields.\n- The client-side code that consumes these responses (specifically the `ResourceState` constructor and its accessors like `getVendor`, `getName`, `isMashup`, `isGadget`, the version iteration logic, and the `CatalogueResourceSubmitter`) must be updated to read `vendor`/`name`/`type` from the root resource object rather than from the current version object, and to traverse `versions` instead of treating the response as a plain list.\n- All existing resource-detail and version-switching behaviours must continue to work correctly with the new structure.", "task_family": "Wirecloud__wirecloud#14a53d8609e04fe881afecdada87e0e03191d56a", "task_id": "14a53d8609e04fe881afecdada87e0e03191d56a-1", "task_title": "refs #75. Provide the vendor, name and type attributes in the root resource description instead of repeating it for each version of the resource"} {"commit": "4159cb14baa282e79aa28c1e99e8592be45a8890", "language": "js", "query_count": 1, "query_ids": ["4159cb14baa282e79aa28c1e99e8592be45a8890-1::q1"], "repo": "Wirecloud__wirecloud", "revision": "bf1fbbd59d97c9616cf8c37e744986e43bf0e164", "split": "test", "task": "Feature: Allow superusers to add public marketplaces\n\nBackground:\nCurrently, when a user adds a marketplace, it is visible only to that user. There is no way for a superuser to create a marketplace that is available to all users of the instance.\n\nAcceptance criteria:\n\n1. **Superuser UI** – When a superuser opens the \"Add new marketplace\" dialog, a \"Public\" checkbox (boolean field) must appear. If checked, the marketplace should be created as public. If unchecked, it is private to the superuser. A non‑superuser must never see this checkbox.\n\n2. **Public visibility** – A public marketplace must appear in the marketplace menu (popup) for any authenticated user, alongside their own private marketplaces. A private marketplace added by user A must not appear for user B.\n\n3. **Server‑side permission** – The API that creates marketplaces must reject requests that attempt to set the user to `null` (i.e., public) when the authenticated user is not a superuser, returning an appropriate 403 response (e.g., \"You don't have permissions for adding public marketplaces\").\n\n4. **Ownership model** – A public marketplace must be stored with no associated user (`user` = None in the database). A private marketplace continues to be stored with the creating user as owner.\n\n5. **Marketplace listing for a user** – The logic that retrieves the list of marketplaces available to a user must include public marketplaces (user is `None`) in addition to the user’s own private marketplaces. Consequently, the representation of each marketplace must include a `user` field in its options: `null` for public marketplaces, or the owner’s username for private ones. This field is needed so the client can distinguish public from private.\n\n6. **Client‑side creation payload** – When the superuser submits the add‑marketplace form, the request payload must set the `user` value appropriately: `null` if the \"Public\" checkbox was checked, otherwise the current user’s username. This `user` value is sent inside the `options` object; the backend must later remove that temporary `user` key from the options before persisting to the database, so that the stored options do not contain a redundant `user` entry.\n\nConstrains / non‑goals:\n- Do not change the behaviour of the existing \"Add new marketplace\" flow for non‑superusers (private marketplaces remain private).\n- The existing `MarketCollection.create` endpoint currently assumes the user is always the requester; this must be extended safely to handle the `null` ownership case.\n- The `get_market_managers` utility function must be updated to set `options['user']` as described, ensuring callers receive correct ownership information.\n- The test helper `add_marketplace` should support an optional `public` parameter (default `False`) that, when `True`, clicks the public checkbox during the UI flow, to facilitate verification.", "task_family": "Wirecloud__wirecloud#4159cb14baa282e79aa28c1e99e8592be45a8890", "task_id": "4159cb14baa282e79aa28c1e99e8592be45a8890-1", "task_title": "Add support for adding public marketplaces"} {"commit": "b26839dfd76fd8df8fee074959ef01741768cc20", "language": "js", "query_count": 1, "query_ids": ["b26839dfd76fd8df8fee074959ef01741768cc20-1::q1"], "repo": "Wirecloud__wirecloud", "revision": "25fd7b6a5262da6fb829b0481adc2f9f930b6490", "split": "test", "task": "Title: Update wiring editor test helpers and component sidebar classes for current UI\n\nThe wiring editor’s Selenium test framework (in `src/wirecloud/commons/utils/remote.py`) is out of date after recent UI changes. Several interactions that tests rely on are broken because CSS classes and interaction patterns changed. We need the test helpers to support the current wiring editor behaviour so that we can write and maintain reliable end-to-end tests.\n\nRequired capabilities / acceptance criteria:\n\n1. **Open component settings menu** \n A wiring component’s preferences/settings menu is now triggered by a button with class `.option-preferences`. The test helper method that opens the menu must use this button instead of the removed `.editPos_button`. Clicking it should wait for the `.se-popup-menu` to appear and return a popup menu tester object.\n\n2. **Open sidebar component groups** \n The sidebar group buttons for “Operators” and “Widgets” now carry CSS classes `opt-operator-group` and `opt-widget-group` respectively. \n - The JS component manager (`ComponentManager.js`) must add those classes to the corresponding `StyledButton` instances. \n - The wiring view tester’s method for opening a component group must select the button using the `opt-` prefix (i.e. `.opt--group`) instead of the old `. -group`.\n\n3. **Endpoint lookup and dragging** \n To create a wiring connection a test must identify endpoints by their type (“source” for output endpoints, “target” for input endpoints) and by their label text. The test helpers should provide this capability, returning an endpoint object that exposes: \n - an **anchor** element (the draggable circle, `.endpoint-anchor`) \n - the endpoint’s **name** (the label text from `.endpoint-label`) \n \n A test should be able to do something like: \n `source = component.get_endpoint_by_name('source', 'Output')` \n `target = component.get_endpoint_by_name('target', 'Input')` \n and then `drag_and_drop(source.anchor, target.anchor)` to create a connection.\n\n4. **Migration of existing brittle tests** \n Any wiring-editor tests that currently rely on raw XPath expressions or hard‑coded CSS classes to find components, open menus, or drag endpoints should be rewritten to use the stable helpers described above. The test suite must continue to cover the same scenarios (e.g. basic wiring creation, operator reinstall behaviour, and component availability after deletion).\n\nThe overall goal is to have a behaviour‑oriented test API that abstracts away the exact CSS classes used for common wiring‑editor interactions, making the tests less fragile and easier to update when the UI evolves.", "task_family": "Wirecloud__wirecloud#b26839dfd76fd8df8fee074959ef01741768cc20", "task_id": "b26839dfd76fd8df8fee074959ef01741768cc20-1", "task_title": "Fix the first tests for wiring editor"} {"commit": "56990fbe7d7034481984d862dc4fc6578a00b33d", "language": "js", "query_count": 1, "query_ids": ["56990fbe7d7034481984d862dc4fc6578a00b33d-1::q1"], "repo": "Wirecloud__wirecloud", "revision": "0cca8dd19b57132fc591238905fb40c3ccb85905", "split": "test", "task": "**Title:** Workspace tabs missing expected CSS class and `find_iwidget` cannot locate unpainted widgets\n\n**Background:**\nAfter some internal refactoring, two regressions have been observed:\n\n1. **Tab styling / selector break:** Workspace tabs created via `Tab.js` in the operator manager no longer receive the CSS class `wc-workspace-tab` on their wrapper element. As a result, tab styling is lost and any code or selectors that depend on that class stop working. The class should be applied unconditionally to every workspace tab’s DOM wrapper.\n\n2. **`find_iwidget` helper unreliable for lazy-painted widgets:** The `RemoteTestCase.find_iwidget` method only looks through widgets that are currently painted (as returned by `find_iwidgets`). This makes it impossible to locate a widget by its ID when it belongs to a tab that has not yet been displayed (e.g., a widget in a background tab that receives a wiring event and needs to be loaded on demand). \n **Expected behaviour:** When an ID is given, `find_iwidget` should search the workspace DOM directly for an element matching `.iwidget[data-id=\"...\"]` and, if found, wrap it in an `IWidgetTester` – regardless of whether the widget is currently painted. If no such element exists, it should return `None`. The existing title-based fallback can keep its current behaviour.\n\n**Acceptance criteria:**\n- Every workspace tab wrapper element reliably has the `wc-workspace-tab` CSS class.\n- `RemoteTestCase.find_iwidget` can successfully locate and return an `IWidgetTester` for a widget by its `id` even when that widget is not in the currently painted list (e.g., when it is on a different, non‑visible workspace tab). \n- The existing behaviour for title-based lookups and for already painted widgets remains unchanged.", "task_family": "Wirecloud__wirecloud#56990fbe7d7034481984d862dc4fc6578a00b33d", "task_id": "56990fbe7d7034481984d862dc4fc6578a00b33d-1", "task_title": "Fix more errors in the tests"} {"commit": "9e49888f41ebc3c257410bdc871535b78025d66d", "language": "js", "query_count": 4, "query_ids": ["9e49888f41ebc3c257410bdc871535b78025d66d-1::q1", "9e49888f41ebc3c257410bdc871535b78025d66d-1::q2", "9e49888f41ebc3c257410bdc871535b78025d66d-1::q3", "9e49888f41ebc3c257410bdc871535b78025d66d-1::q4"], "repo": "Wirecloud__wirecloud", "revision": "a7224f57db13522c60f393cdfcb2874b6658cff6", "split": "test", "task": "**Request: Form Class Usability and API Improvements**\n\nThe `StyledElements.Form` has several gaps in its public API and behavior that prevent its use in newer UI components. This request outlines concrete improvements needed for both form construction and runtime behavior.\n\n---\n\n### 1. Read‑only forms\nWhen a form is constructed with `options.readOnly = true`, it must not show accept or cancel buttons. The `acceptButton` and `cancelButton` properties of the form instance should be `null`. All input fields must be disabled.\n\n### 2. Custom buttons via options\nIt must be possible to pass pre‑built button instances for the standard actions through the options object. Accept a button for each of the following option keys and assign it to the corresponding form property:\n- `acceptButton`\n- `cancelButton`\n- `resetButton`\n- `setdefaultsButton`\n\nWhen a custom button is provided, the form must use it instead of creating a default one.\n\n### 3. Grouped fields (tabs)\nAllow a field descriptor to have `type: 'group'` with a nested `fields` array. Such groups must be rendered as tabs using `StyledElements.Notebook`. The tab label comes from the group’s `shortTitle` property. The tab content should be built from the nested fields using the same table layout as the main form.\n\n### 4. Repaint improvements\n- `repaint()` must return `this` so callers can chain method calls.\n- When `repaint` is called with a truthy temporal flag (i.e., `repaint(true)`), it must repaint every field interface, not just the overall form container.\n\n### 5. Type checking for `update()`\nThe `update(data)` method must reject invalid argument types with a `TypeError`. The only allowed values for `data` are:\n- An object (plain object or array)\n- `null`\n- `undefined`\n\nPassing a number, boolean, string, or function must throw an error that indicates the type is invalid.\n\n### 6. Public message display\nExpose a new public method `displayMessage(message)` on the form. It must display a single message in the form’s existing alert area (currently only used internally for validation errors). This method replaces uses of the old private `pSetMsgs` throughout the form’s own methods (`getData`, `setData`, `update`, `is_valid`, `defaults`).\n\n### 7. Error handling in `FormWindowMenu`\nIn `FormWindowMenu`, the failure callback currently only re‑enables buttons but does not show the error. Modify the callback so that the first argument (the error message) is passed to `this.form.displayMessage()` before re‑enabling the accept and cancel buttons.\n\n### 8. Removal of deprecated APIs\nThe following obsolete methods must be removed:\n- `pSetMsgs` – replaced by consistent use of the new message display mechanism\n- `normalSubmit` – no longer used by any part of the platform\n\nThe private helper that renders messages into the alert element should be used directly (via `call`) in all the form methods that previously called `this.pSetMsgs`.", "task_family": "Wirecloud__wirecloud#9e49888f41ebc3c257410bdc871535b78025d66d", "task_id": "9e49888f41ebc3c257410bdc871535b78025d66d-1", "task_title": "StyledElements: general improvements into the Form class"} {"commit": "af88335a2b2dc9943d9e051860e4265c2ec814cb", "language": "js", "query_count": 1, "query_ids": ["af88335a2b2dc9943d9e051860e4265c2ec814cb-1::q1"], "repo": "Wirecloud__wirecloud", "revision": "39d95fad90e81042cba8b205a8d3dc863100b5a6", "split": "test", "task": "The REST API endpoint for updating an existing IWidget (name, refused version, etc.) is broken on both the server and client sides.\n\n**Observed behavior:**\n1. The web dragboard’s “rename” action sends a `PUT` request to the entry endpoint:\n `api/workspace//tab//iwidget//`\n The request body includes both `name` and `id`. The update is not applied.\n2. Marking a widget version as refused also sends a `PUT` to the same entry URL with `refused_version` in the body; the change does not persist.\n3. The iPhone dragboard’s `save` operation evaluates the entry URL pattern without providing an `iwidget_id`, causing a malformed request; it never reaches a valid handler.\n\n**Expected behavior:**\n- The IWidget entry endpoint should support updating an IWidget’s fields. The IWidget ID should be taken from the URL, not from the request body. Only the fields to be changed should be sent.\n- The correct HTTP method must be used. Given the existing `Resource` dispatch conventions, `POST` (mapped to a `create` handler) is the appropriate method for updates on this entry resource, not `PUT`.\n- The web client’s `setName` and `setRefusedVersion` calls should use the entry URL with the IWidget ID, send only the changed fields, and use the correct HTTP method.\n- The iPhone client’s `save` method should use the IWidget collection URL (`iwidgets/`) rather than the entry URL, since it does not specify an individual IWidget ID.\n\n**Impact:** IWidget rename, upgrade refusal, and iPhone persistence are non-functional for all users.", "task_family": "Wirecloud__wirecloud#af88335a2b2dc9943d9e051860e4265c2ec814cb", "task_id": "af88335a2b2dc9943d9e051860e4265c2ec814cb-1", "task_title": "Fix \"Update IWidget Status\" rest API operations"} {"commit": "1d39825a355d031cb14bc8bc3eb71dd0020419dd", "language": "ts", "query_count": 4, "query_ids": ["1d39825a355d031cb14bc8bc3eb71dd0020419dd-1::q1", "1d39825a355d031cb14bc8bc3eb71dd0020419dd-1::q2", "1d39825a355d031cb14bc8bc3eb71dd0020419dd-1::q3", "1d39825a355d031cb14bc8bc3eb71dd0020419dd-1::q4"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "73998a73c500d3566e27b4832a9dd810503e2b58", "split": "test", "task": "**Title:** OMC blocks tmux-dependent features on Windows even when a tmux-compatible binary like psmux is installed \n\n**Observed behavior** \n- On native Windows (win32) with [psmux](https://github.com/marlocarlo/psmux) installed and in `PATH` (which provides a `tmux` binary that implements the necessary sub-commands), OMC still prints a startup warning saying that native Windows is unsupported and tmux is unavailable. \n- Features that require tmux (team orchestration, rate‑limit pane scanning, etc.) refuse to work because the internal tmux-availability check short‑circuits on `win32` without trying to detect the binary. \n- The binary‑path lookup in CLI detection uses `which`, which does not exist on Windows; `where` is the correct command. \n- Some tmux sub‑commands emitted by OMC use single‑quote argument quoting (e.g. `-t '%0'`), which can break under psmux and Windows shells; double‑quoting is more universally portable. \n- The console warnings and error messages about missing tmux only mention WSL2 as a Windows solution; they do not mention psmux as a native option.\n\n**Expected behavior** \n1. All decision points that currently hard‑block on `process.platform === 'win32'` should instead probe for an actual working `tmux` binary (e.g. by running `tmux -V` and checking the exit code). If a compatible implementation is present, OMC should proceed as normal. \n2. The startup warning should only appear when the platform is Windows **and** no `tmux` binary can be found, and the message should guide users to install psmux (`winget install psmux`) as an alternative to WSL2. \n3. Path resolution should use `where` on Windows instead of `which`. \n4. Tmux command strings (e.g. inside `list-panes`, `capture-pane`) should use double‑quote quoting for pane identifiers and formats to be safe across shells. \n5. The error shown when tmux is completely missing should also mention the psmux installation option alongside the existing Unix‑centric package instructions.\n\n**Impact** \n- Windows users cannot use team features, auto‑resume of rate‑limited panes, or any other tmux‑dependent capability, even when they have a fully functional tmux-compatible toolchain. \n- This makes the tool unnecessarily hostile to native Windows development environments.\n\n**Additional context** \nThe change should be backwards‑compatible: on macOS/Linux the new detection logic should yield the same results as before (since `tmux -V` succeeds when tmux is installed). The quoting change from `'` to `\"` around tmux arguments should not break tmux on any platform because tmux itself accepts both styles, but double‑quotes are generally safer in command strings built via `execSync`.", "task_family": "Yeachan-Heo__oh-my-claudecode#1d39825a355d031cb14bc8bc3eb71dd0020419dd", "task_id": "1d39825a355d031cb14bc8bc3eb71dd0020419dd-1", "task_title": "fix(platform): replace win32 hard-blocks with tmux capability checks (#1423)"} {"commit": "34fb3ce3494396680be7cac2d65e2f7c5b09cc7a", "language": "ts", "query_count": 2, "query_ids": ["34fb3ce3494396680be7cac2d65e2f7c5b09cc7a-1::q1", "34fb3ce3494396680be7cac2d65e2f7c5b09cc7a-1::q2"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "238cb232577e82ecb53e3ac8c953da893110dee4", "split": "test", "task": "**Title:** HUD background task cleanup uses working directory instead of project root for state file \n\n**Component:** HUD initialization / background task cleanup \n\n**Priority:** Medium \n\n**Description** \nWhen the HUD starts, it performs a one‑time cleanup of stale and orphaned background tasks from the local state file. Currently this cleanup always reads from and writes to the state file in `process.cwd()`, even when the HUD is launched with a project root different from the current working directory (the project root is communicated through `stdin.cwd` and resolved via `resolveToWorktreeRoot`).\n\nThis leads to at least two observable issues: \n1. Stale tasks from the current project may not be cleaned up if the working directory is not the project root. \n2. The HUD may incorrectly clean up tasks belonging to an unrelated area when the working directory happens to contain a different state file.\n\n**Expected behavior** \nThe background task cleanup during HUD initialization must operate on the state file that corresponds to the resolved project root. The cleanup should always target `/.omc/` (or whatever location is derived from that root) and never the raw `process.cwd()`.\n\n**Additional context** \n- The cleanup is currently triggered by the `initializeHUDState` call in `main`. \n- `readHudState`/`writeHudState` accept an optional directory override; it is not being used here. \n- The call to `initializeHUDState` happens before `cwd` is resolved from stdin, so the directory is not available yet. \n\n**Acceptance criteria** \n- The resolved project root directory is passed through so that stale/orphaned task cleanup always uses the state file belonging to the current project. \n- The existing behavior (cleanup happens on startup, no regression in default operation) must be preserved.", "task_family": "Yeachan-Heo__oh-my-claudecode#34fb3ce3494396680be7cac2d65e2f7c5b09cc7a", "task_id": "34fb3ce3494396680be7cac2d65e2f7c5b09cc7a-1", "task_title": "fix(hud): propagate directory parameter to initializeHUDState"} {"commit": "811123a37816d9b51770fdc386f2217dd49a6dff", "language": "ts", "query_count": 2, "query_ids": ["811123a37816d9b51770fdc386f2217dd49a6dff-1::q1", "811123a37816d9b51770fdc386f2217dd49a6dff-1::q2"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "0261dab08c1ad57156ba0d4db035fd6de22ef538", "split": "test", "task": "**Title:** Refresh-writeback for Keychain-sourced OAuth tokens\n\n**Problem**\nWhen `getUsage()` refreshes an expired token, `writeBackCredentials` only persists the new token pair if `~/.claude/.credentials.json` exists. On macOS, credentials are often stored exclusively in the Keychain (service `com.anthropic.claude`). In those cases the file is missing, the function bails out early, and the refreshed tokens are silently discarded. This leaves the Keychain with stale credentials, causing repeated (and eventually failing) refreshes.\n\n**Desired behaviour**\nAfter a successful token refresh, the new `accessToken`, `refreshToken`, and `expiresAt` must be written back to the **same Keychain entry** from which the credentials were originally read, so that subsequent usage polls see valid tokens. The existing file‑based write‑back path must remain unchanged and must not be triggered for Keychain‑sourced credentials.\n\n**Constraints / Details**\n- The credential object already carries a `source` discriminator (`'keychain'` vs `'file'`). Branch on that.\n- When `source === 'keychain'`, retrieve the existing Keychain entry, merge only the token‑related fields into it, and update the entry with `security add-generic-password -U`. Preserve all other data that was already in the entry.\n- The original Keychain read may be account‑scoped (`-a `) or service‑only. The write‑back must target the same slot, so the account name (if any) must be recorded during the read and re‑used when writing.\n- Keychain write‑back should be macOS‑only (`process.platform === 'darwin'`) and best‑effort: log a debug message on failure but never throw or break the caller.\n- Do **not** create or touch `~/.claude/.credentials.json` when the source is Keychain.\n\n**Acceptance criteria (behavioural)**\n1. Keychain‑sourced credentials: after a refresh the new tokens are persisted to the same Keychain entry; no `.credentials.json` file is created or modified.\n2. File‑sourced credentials: the existing write‑back logic works exactly as before, and no Keychain write occurs.\n3. The written Keychain entry contains the merged token values alongside any pre‑existing non‑token fields.\n4. Works for both account‑scoped (e.g. `-a email`) and service‑only Keychain entries.\n5. No regression in usage polling, credential reading, or the subscription‑info pathway.", "task_family": "Yeachan-Heo__oh-my-claudecode#811123a37816d9b51770fdc386f2217dd49a6dff", "task_id": "811123a37816d9b51770fdc386f2217dd49a6dff-1", "task_title": "fix: write refreshed OAuth tokens back to Keychain (#3238) (#3239)"} {"commit": "1a58753e5db3c0617d1dd2604d4d91ec0b89751c", "language": "ts", "query_count": 2, "query_ids": ["1a58753e5db3c0617d1dd2604d4d91ec0b89751c-1::q1", "1a58753e5db3c0617d1dd2604d4d91ec0b89751c-1::q2"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "c3d3f3f4b3873d481ca1be486c6aa3f2bdc0e8b3", "split": "test", "task": "**Bug: Windows auto-update reconciliation fails when the OMC launcher ends with `.cmd`**\n\n**Description** \nOn Windows, `oh-my-claudecode` installs a global launcher script (typically `omc.cmd`) through npm. After an automatic update, the `performUpdate` flow attempts to re-execute the freshly installed binary to run a reconciliation step. Because Node.js `child_process.execFileSync` cannot execute `.cmd` / `.bat` files directly without shell mediation, this call throws a spawn error (e.g., `ENOENT` for the `.cmd` path) and the update reports failure even though the binary was successfully upgraded.\n\n**Steps to reproduce** \n1. Install `oh-my-claudecode` globally on a Windows machine. \n2. Trigger an automatic update (or simulate one that lands on a version where the resolved binary path ends with `.cmd`). \n3. Observe that the update completes the package installation but the subsequent reconciliation step fails with a spawn error referencing the `.cmd` path, and the returned result indicates runtime reconciliation failure.\n\n**Expected behavior** \nThe reconciliation re-exec should succeed on Windows regardless of whether the resolved OMC binary is a `.cmd` wrapper. The update should be reported as successful after reconciliation finishes.\n\n**Actual behavior** \nReconciliation fails with an `ENOENT` spawn error for the `.cmd` path, and the update result contains an error message like “Updated to , but runtime reconciliation failed”.\n\n**Acceptance Criteria** \n- On Windows, when the resolved OMC binary is a `.cmd` file, the reconciliation re-exec call must use shell execution so that `cmd.exe` can interpret the script. \n- This mediation must be applied **only** to the reconciliation re-exec path; other `execFileSync` calls throughout the codebase (e.g., invoking `git`, `where.exe`, or direct executables) must not be altered. \n- Non-Windows platforms must be unaffected. \n- The update flow should complete successfully, with reconciliation executed, on Windows after the fix.\n\n**Referenced Issue** \n#1804", "task_family": "Yeachan-Heo__oh-my-claudecode#1a58753e5db3c0617d1dd2604d4d91ec0b89751c", "task_id": "1a58753e5db3c0617d1dd2604d4d91ec0b89751c-1", "task_title": "Prevent Windows update reconciliation from failing on omc.cmd (#1805)"} {"commit": "e4a39024007b6834fd7b6316fbbcb5eafc404fdc", "language": "ts", "query_count": 3, "query_ids": ["e4a39024007b6834fd7b6316fbbcb5eafc404fdc-1::q1", "e4a39024007b6834fd7b6316fbbcb5eafc404fdc-1::q2", "e4a39024007b6834fd7b6316fbbcb5eafc404fdc-1::q3"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "391e2567ed14dc3fcf26eacdcaf66dc74fe30c7a", "split": "test", "task": "**Title:** Codex advisor artifacts contain Rust debug noise when `RUST_LOG`/`RUST_BACKTRACE` are set\n\n**Reporter:** user\n\n**Summary** \nWhen using `omc ask --provider codex`, the generated artifact can be polluted with lines from Rust’s debug output (e.g., `RUST_LEAK`, trace-level log messages) and the process stderr is similarly noisy. This occurs if the host environment has `RUST_LOG`, `RUST_BACKTRACE`, or `RUST_LIB_BACKTRACE` set.\n\n**Steps to reproduce** (realistic scenario):\n1. Have the OpenAI Codex CLI installed and accessible.\n2. Set `RUST_LOG=trace` and `RUST_BACKTRACE=1` in the environment.\n3. Run something like: `omc ask --provider codex \"some prompt\"`.\n4. Inspect the resulting artifact file.\nObserved: the artifact includes Rust diagnostic lines; stderr shows backtrace/trace information.\n\n**Expected behavior** \nWhen OMC invokes the Codex binary (for the `--version` probe and for the actual advisory execution), it should not expose ambient Rust-specific debug environment variables to the Codex process. Other environment variables should be inherited normally. This suppression should happen **only** for the `codex` provider – the `claude` and `gemini` providers must continue to receive the full environment. The artifact and stderr from the codex advisor must remain clean of Rust debug noise regardless of whether `RUST_LOG`, `RUST_BACKTRACE`, or `RUST_LIB_BACKTRACE` are set in the caller’s environment.\n\n**Impact** \n- Polluted artifacts cannot be used downstream.\n- Debug log leakage may reveal unintended information.\n- Every invocation with these env vars set requires manual cleanup workarounds.", "task_family": "Yeachan-Heo__oh-my-claudecode#e4a39024007b6834fd7b6316fbbcb5eafc404fdc", "task_id": "e4a39024007b6834fd7b6316fbbcb5eafc404fdc-1", "task_title": "fix(ask): strip Rust debug env from codex advisor (#1419)"} {"commit": "7fad7b2277e5313c8e721336149a3fb7af9d80be", "language": "ts", "query_count": 2, "query_ids": ["7fad7b2277e5313c8e721336149a3fb7af9d80be-1::q1", "7fad7b2277e5313c8e721336149a3fb7af9d80be-1::q2"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "39ab96b3c7d95d515518d4e02a242a63259025a1", "split": "test", "task": "**Title:** `captureFileSnapshot` crashes with `require is not defined` when permission enforcement is active\n\n### Context\nThe project uses `\"type\": \"module\"` in `package.json`, so all source files are treated as ESM. In that environment, CommonJS `require` is not available and will throw `ReferenceError: require is not defined`.\n\n### Observed behavior\nWhen the orchestrator starts with `permissionEnforcement` set to any value other than `'off'` (the path that triggers `captureFileSnapshot`), the process immediately aborts with:\n\n```\nReferenceError: require is not defined\n at captureFileSnapshot (.../mcp-team-bridge.ts:...)\n```\n\nThis prevents any team-mode execution when permission enforcement is enabled.\n\n### Expected behavior\n- `captureFileSnapshot` should work correctly in an ESM module without relying on `require`.\n- The existing top-level imports in the same file already use ESM syntax for other `child_process` members (e.g., `spawn`). The snapshot function should follow the same pattern, importing `execSync` from `'child_process'` at the top of the module.\n- As a secondary improvement, `captureFileSnapshot` should be properly exported so that it can be imported and unit-tested directly, rather than being an unexported internal helper.\n\n### Acceptance criteria\n1. With `permissionEnforcement !== 'off'`, invoking the orchestrator no longer throws a `ReferenceError: require is not defined`.\n2. `captureFileSnapshot` can be imported from its module by external test code (e.g., via `import { captureFileSnapshot } from '...mcp-team-bridge.js'`).\n3. The existing snapshot behaviour is preserved: returns a `Set` of relative file paths for a git-working-directory, returns an empty set for a non-git directory, and does not throw for any call.\n\n### Notes\n- Do not introduce a dynamic `import()` inside the function unless unavoidable; a static import is preferred because the module is already ESM and `execSync` is always needed.\n- The rest of the module’s imports (`spawn`, `ChildProcess`, etc.) already follow the ESM pattern; this change should be consistent with them.", "task_family": "Yeachan-Heo__oh-my-claudecode#7fad7b2277e5313c8e721336149a3fb7af9d80be", "task_id": "7fad7b2277e5313c8e721336149a3fb7af9d80be-1", "task_title": "fix(team): replace require() with ESM import in captureFileSnapshot"} {"commit": "0d0139c36ea076709a3807be1189df0486f9e26f", "language": "ts", "query_count": 2, "query_ids": ["0d0139c36ea076709a3807be1189df0486f9e26f-1::q1", "0d0139c36ea076709a3807be1189df0486f9e26f-1::q2"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "33ad052cc9e812db029d1e44540543da0a674dae", "split": "test", "task": "## Bug Report: Transcript scanner doesn't decode Windows project paths\n\n### Summary\n\n`oh-my-claudecode`'s analytics transcript scanner fails to resolve project paths on Windows systems. This causes sessions to be misattributed or missing from analytics dashboards when running Claude Code on Windows.\n\n### Background\n\nClaude Code encodes project directory names into a munged form when naming transcript directories. The encoding scheme differs between platforms:\n\n- **Unix**: `/home/user/my-project` → `-home-user-my-project`\n- **Windows**: `C:\\Users\\user\\my-project` → `C--Users-user-my-project`\n\nThe decoder currently only handles the Unix pattern (paths starting with `-`). It has no logic for Windows-encoded paths, where the drive letter is followed by `--` and then the path with all separators replaced by individual `-`.\n\n### Observed behavior\n\nOn Windows:\n\n- Encoded directory names like `C--Users-bellman-my-project` are either rejected (returned with no leading slash or drive colon) or decoded to nonsense paths.\n- Paths containing consecutive hyphens from legitimate directory names (e.g., `my--project`) are split incorrectly, producing wrong `existsSync` checks and false mismatches even on Unix.\n\n### Expected behavior\n\nThe decoder should:\n\n1. **Detect Windows-encoded paths** — any encoded name matching `^[A-Za-z]-` (drive letter followed by a dash) should be recognized as Windows and decoded to `X:/...`.\n2. **Decode Windows paths correctly** — `C--Users-user-project` should produce `C:/Users/user/project`, with filesystem-aware disambiguation for hyphenated directory names, just as the existing Unix decoder does.\n3. **Handle consecutive hyphens** — `my--project` (where the original directory literally contains a hyphen) should survive splitting and reconstruction without collapsing into `my-project` or misinterpreting the double dash.\n4. **Maintain backward compatibility** — existing Unix path decoding must continue to work unchanged for paths starting with `-`.\n\n### Impact\n\nWindows users get broken project attribution in analytics, effectively losing that data. This is a cross-platform correctness gap that blocks analytics adoption on Windows.\n\n### Relevant constraints\n\n- The decoder is already filesystem-aware: it tries multiple interpretations and checks `existsSync`. The Windows variant should use the same strategy (simple decode first, then combinatorial reconstruction if needed).\n- The double-dash between drive letter and path content is an encoded artifact and must be distinguished from actual consecutive hyphens in directory names deeper in the path.\n- Drive letters are single ASCII letters (case-insensitive). Don't assume only `C:`.\n- No configuration or opt-in should be required; the function should automatically detect the encoding format.", "task_family": "Yeachan-Heo__oh-my-claudecode#0d0139c36ea076709a3807be1189df0486f9e26f", "task_id": "0d0139c36ea076709a3807be1189df0486f9e26f-1", "task_title": "fix(analytics): support Windows-encoded paths in transcript scanner (#117)"} {"commit": "341a9e15afec0a0f92cbd2b2c2f71a0e6790b12a", "language": "ts", "query_count": 3, "query_ids": ["341a9e15afec0a0f92cbd2b2c2f71a0e6790b12a-1::q1", "341a9e15afec0a0f92cbd2b2c2f71a0e6790b12a-1::q2", "341a9e15afec0a0f92cbd2b2c2f71a0e6790b12a-1::q3"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "354bb0101918c181cee6e43f760d22634342a160", "split": "test", "task": "**Title:** tmux panes created by OMC don’t source shell rc files (missing PATH / env)\n\n### Symptoms\nWhen OMC launches a Claude session in a new tmux window, or opens a Codex interop pane, or creates the HUD watch pane, the commands inside that pane often fail because the user’s shell startup files (`.zshrc`, `.bashrc`, `.profile`, etc.) are **not loaded**.\n\nConcrete observed failures:\n- `claude` (or `codex`, `gemini`) **not found** — the user’s custom `PATH` entries are missing.\n- Environment variables configured in rc files are absent (e.g. `NVM_DIR`, `JAVA_HOME`, API keys, or proxy settings).\n- The HUD pane shows errors because the watcher script can’t find its dependencies.\n\n### Context\n- OMC launches several kinds of tmux sessions dynamically:\n - **Main Claude session** when launched from outside an existing tmux environment.\n - **Codex interop pane** (split‑window) for cross‑model work.\n - **HUD watch pane** that monitors Claude’s activity.\n- The problem affects the **`outside‑tmux`** launch path, the **interop** pane, and the **HUD** pane. (Team worker panes already source rc files explicitly, so they are unaffected.)\n\n### Root cause\nTmux, when given an explicit command as the final argument to `new-session` or `split-window`, executes it with a **non‑login** shell (`$SHELL -c 'command'`). Non‑login shells do not source rc files by default, so the session starts without the user’s normal environment.\n\n### Expected behavior\nEvery tmux pane or session created by OMC that runs a user‑level command should run that command inside a **login shell** so that the user’s rc files are sourced. After the fix:\n\n1. **`omc launch`** (outside tmux) → the new session’s command runs with a login shell, picking up PATH and env from rc files.\n2. **Codex interop split** → the `codex` command in the new pane runs inside a login shell.\n3. **HUD watch pane** → the HUD command runs inside a login shell.\n\n### Implementation constraints & edge cases\n- Respect `$SHELL`; fall back to `/bin/bash` if `$SHELL` is unset or empty.\n- The wrapper should use `exec` to replace the outer shell process (avoiding an extra process layer).\n- Properly quote the inner command so that commands containing single quotes, special characters, or multiple statements (`sleep 0.3; perl ...; claude --dangerously-skip-permissions`) are passed through intact.\n- The existing `sleep`+`tcflush` workaround (for terminal DA1 query in the main Claude launch) must still be included in the final command, just wrapped in a login shell invocation.\n- The fix must be applied consistently across all three affected call sites (main launch, interop pane, HUD pane).", "task_family": "Yeachan-Heo__oh-my-claudecode#341a9e15afec0a0f92cbd2b2c2f71a0e6790b12a", "task_id": "341a9e15afec0a0f92cbd2b2c2f71a0e6790b12a-1", "task_title": "fix(shell): load default shell rc in OMC tmux shell sessions (#1153) (#1154)"} {"commit": "3f17bf67454ad6daa14d522b927da317678f517f", "language": "ts", "query_count": 2, "query_ids": ["3f17bf67454ad6daa14d522b927da317678f517f-1::q1", "3f17bf67454ad6daa14d522b927da317678f517f-1::q2"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "90b963226cc99ddbf6f1d862e350975f2205421f", "split": "test", "task": "**Bug: HUD hides rate limit indicators when OAuth credentials lack subscription metadata**\n\n### Observed behavior\nWhen the OAuth credentials (e.g., from `~/.claude/credentials.json`) contain `subscriptionType: null` and `rateLimitTier: null`, the HUD status line does **not** display the usual `5h:` / `wk:` / `sn:` usage percentages, even though the Anthropic usage API returns valid rate-limit data (e.g., `five_hour`, `seven_day`, `seven_day_sonnet` utilization fields).\n\n### Expected behavior\nThe HUD should always surface whatever rate-limit information the API provides, regardless of whether subscription metadata (`subscriptionType`, `rateLimitTier`) is present. Specifically:\n\n- When the API response includes `five_hour.utilization`, the HUD should show the 5-hour percentage.\n- When it includes a generic 7-day window (`seven_day.utilization`) or a model-specific 7-day window (e.g., `seven_day_sonnet`, `seven_day_opus`), the HUD should show those percentages and their reset times.\n- Missing subscription metadata alone should **not** cause the HUD to discard valid rate-limit data.\n\n### Impact\nUsers who authenticate via OAuth but do not have a consumer-facing subscription tier stored in the credentials (or whose credential file has nulls for those fields) lose visibility into their usage limits, making it hard to avoid hitting rate caps.\n\n### Possible areas of concern\n- The rate-limit parsing logic (`parseUsageResponse`) currently requires at least one of `five_hour`, `seven_day`, or usable enterprise credits to produce a result. It should also recognize that model-specific weekly windows (`seven_day_sonnet`, `seven_day_opus`) are valid usage data even when the generic `seven_day` is absent or null.\n- The main HUD loop fetches subscription info from credentials and may pass null-ish values downstream in a way that later code treats as “no rate limits available.”\n- A general guard should ensure that any code path that reads subscription metadata does not inadvertently suppress rate-limit rendering when that metadata is null.\n\n### Steps to reproduce\n1. Set up OAuth credentials where the `claudeAiOauth` block has `subscriptionType: null` and `rateLimitTier: null`.\n2. Start `oh-my-claudecode` HUD mode.\n3. Observe that the status line never shows the 5h/wk/sn percentages, even after the usage API returns a successful response containing utilization for those windows.\n\n### Acceptance criteria\n- The HUD displays `5h:`, `wk:`, and per-model weekly percentages (e.g., `sn:`) when the API provides the corresponding utilization values, **regardless of whether subscription metadata exists**.\n- The fix must not break existing behavior for users who do have valid `subscriptionType` / `rateLimitTier`, nor for enterprise credit paths.", "task_family": "Yeachan-Heo__oh-my-claudecode#3f17bf67454ad6daa14d522b927da317678f517f", "task_id": "3f17bf67454ad6daa14d522b927da317678f517f-1", "task_title": "fix(hud): preserve rate limits without subscription metadata"} {"commit": "a932f111b9a61ec7fba6d6a9f3d1c74aa46d7327", "language": "ts", "query_count": 2, "query_ids": ["a932f111b9a61ec7fba6d6a9f3d1c74aa46d7327-1::q1", "a932f111b9a61ec7fba6d6a9f3d1c74aa46d7327-1::q2"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "f639398ae581046748cb43a8f9665bd705304164", "split": "test", "task": "**Short description**: Harden team worker binary path and RC-loading behavior\n\nWhen a team starts (`startTeam`), CLI binary paths are validated but the resolved absolute path is not persisted. Later worker-spawn calls re-resolve the binary, which could pick up a different executable if `PATH` changes between validation and spawn. Pin the validated absolute binary path at team-start time and pass it through to the spawn logic so every worker pane uses exactly the same binary that was originally validated.\n\nAdditionally, the tmux pane startup command (`buildWorkerStartCommand`) always sources the user's shell RC files (e.g., `~/.zshrc`, `~/.bashrc`). This lets user shell customizations influence worker behaviour. Add an opt-out: when the environment variable `OMC_TEAM_NO_RC` is set to `\"1\"`, the generated shell command must skip RC sourcing entirely on both Unix and Windows Git-for-Bash shells.\n\nThe invariant to preserve is: after a team is created, every subsequent worker pane for that team launches the same validated CLI binary, and RC sourcing is controlled by a single, explicit environment flag.", "task_family": "Yeachan-Heo__oh-my-claudecode#a932f111b9a61ec7fba6d6a9f3d1c74aa46d7327", "task_id": "a932f111b9a61ec7fba6d6a9f3d1c74aa46d7327-1", "task_title": "fix(team-security): tighten CLI path trust and RC-loading behavior (#1230)"} {"commit": "cba5c6466bc6dd34306bd6fde26bd0d9d8798f66", "language": "ts", "query_count": 1, "query_ids": ["cba5c6466bc6dd34306bd6fde26bd0d9d8798f66-1::q1"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "8f28b3593fa8a563573653839d9ff1c9007e2112", "split": "test", "task": "**Title:** Team scaling always launches `claude` workers regardless of requested agent type (codex / gemini)\n\n---\n\n### Description\n\nWhen a team is configured with a non-Claude agent type (e.g., `codex` or `gemini`) and workers are scaled up, every new worker pane launches the `claude` binary instead of the correct provider binary. This happens even though the team config records the correct `agent_type` and the initial team session workers are launched with the right provider and flags.\n\n### Steps to reproduce\n\n1. Configure a team with `agent_type: 'gemini'` or `agent_type: 'codex'`.\n2. Enable scaling (`OMC_TEAM_SCALING_ENABLED=1`).\n3. Scale up the team – observe the new worker panes.\n4. The workers start `claude` (ignoring the configured agent type) and miss the provider-specific permission/approval flags that are passed when workers are launched during initial team session creation.\n\n### Expected behavior\n\nScale-up workers should honour the team’s configured agent type and launch the correct provider binary with the same flags (e.g. `--approval-mode yolo` for Gemini, `--dangerously-bypass-approvals-and-sandbox` for Codex) that are used when the initial team workers are created. In other words, the scaling path should reuse the same launch-contract logic that other worker-launch paths already follow, so the binary and flags are aligned with the requested agent type.\n\n### Additional safety concern\n\nIf an unsupported agent type is somehow passed to the scaling operation, it would currently silently launch `claude` workers. It should instead fail clearly and early rather than masking the misconfiguration.\n\n### Impact\n\nTeam scaling with external AI backends (Gemini, Codex) is unusable – all scaled workers boot as Claude, which defeats the purpose of multi-provider orchestration. Other worker-launch flows (e.g., initial team session spawn) respect the agent type, so this is an inconsistency specific to the scale-up code path.", "task_family": "Yeachan-Heo__oh-my-claudecode#cba5c6466bc6dd34306bd6fde26bd0d9d8798f66", "task_id": "cba5c6466bc6dd34306bd6fde26bd0d9d8798f66-1", "task_title": "Let scale-up workers follow the existing provider launch contract"} {"commit": "e157908a171c599369053a4caddcdb4ea047ba62", "language": "ts", "query_count": 4, "query_ids": ["e157908a171c599369053a4caddcdb4ea047ba62-1::q1", "e157908a171c599369053a4caddcdb4ea047ba62-1::q2", "e157908a171c599369053a4caddcdb4ea047ba62-1::q3", "e157908a171c599369053a4caddcdb4ea047ba62-1::q4"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "a90b64338d40606eb27408962f1dae90d6fb7af3", "split": "test", "task": "**Title:** Custom notes from ProjectMemory are not surfaced in session context and are lost after rescan\n\n**Area:** `src/hooks/project-memory/`\n\n**Problem:** \nThe project memory system supports `customNotes` (manual and learned) and `userDirectives`, but three gaps prevent them from being useful at runtime:\n\n1. **Context summary ignores custom notes** – When `formatContextSummary` builds a short-form memory string for injection into the session, it does not include `customNotes`. This means any manually added or learned notes never reach the agent through the summary channel.\n2. **PreCompaction does not recognize custom notes as critical** – In the `PreCompact` handler (`processPreCompact`), the `hasCriticalInfo` condition decides whether to inject project memory as a system message before compaction. Currently it checks `userDirectives`, `hotPaths`, and `techStack.languages`, but not `customNotes`. Consequently, a session that only contains custom notes will not have them injected during compaction, risking their loss.\n3. **Rescan wipes user-contributed data** – When a project memory rescan is triggered (automatically after 24h or explicitly via `rescanProjectEnvironment`), a fresh `detectProjectEnvironment()` result replaces the stored memory entirely. Existing `customNotes` and `userDirectives` are discarded because nothing merges the old user-contributed fields into the new detection output. The same happens inside `registerProjectMemoryContext` when it decides to rescan.\n\n**Desired behaviour:**\n\n- `formatContextSummary` should render a **Notes** section containing up to 5 custom notes (formatted as `[category] content`). The section should be omitted entirely when `customNotes` is empty.\n- `processPreCompact` should treat `customNotes` as critical information: if the memory contains any custom notes, the handler must inject the memory summary as a system message, just as it does when `userDirectives` or `hotPaths` are present.\n- `registerProjectMemoryContext` and `rescanProjectEnvironment` must preserve `customNotes` and `userDirectives` from the existing memory when performing a rescan, so that user-contributed data survives detection refreshes.\n\n**Constraints / edge cases:**\n\n- The notes rendering must not exceed a sensible limit (max 5 notes) to keep the summary compact.\n- The merge logic should copy both `customNotes` and `userDirectives` from the old memory onto the newly detected memory object, leaving all other fields as detected.\n- The fix should not alter the structure of `ProjectMemory` or the detection logic.", "task_family": "Yeachan-Heo__oh-my-claudecode#e157908a171c599369053a4caddcdb4ea047ba62", "task_id": "e157908a171c599369053a4caddcdb4ea047ba62-1", "task_title": "fix(project-memory): inject customNotes into session context (#1689)"} {"commit": "365adf0fb6530564ebc6bf3902697b8aab14c65d", "language": "ts", "query_count": 1, "query_ids": ["365adf0fb6530564ebc6bf3902697b8aab14c65d-1::q1"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "b77719553a419c0d8236eb294401da64039f44fe", "split": "test", "task": "**Title:** Standalone npm installs are missing slash skills after plugin-scoped refactoring\n\n**Description:**\nAfter the recent work that moved slash-command registration behind plugin-scoped skill discovery, a standard standalone `omc install` (global npm install) only materialises the `omc-reference` skill under `~/.claude/skills`. All other bundled slash skills (autopilot, ralph, team, ultrawork, etc.) are absent, which makes the standalone installation unusable for anybody relying on slash commands.\n\n**What needs to happen:**\nRestore full slash-skill installation for standalone installs, while keeping the plugin‑based installation path unchanged.\n\n**Constraints and safety rules:**\n\n1. **Claude-native command collisions** \n Some bundled skill names conflict with Claude’s own built‑in slash commands (for example `plan`). For standalone installs we must not shadow those native commands. When a skill’s intended name matches a known Claude‑native command, install it under a safe alias by prefixing it with `omc-` (e.g. `plan` → `omc-plan`). The skill’s frontmatter `name` field should be used as the base name when present, otherwise fall back to the directory name.\n\n2. **Skininthegamebros-only skills** \n The bundled skills `remember`, `verify`, `debug`, and `skillify` are only intended for users who are part of the “skininthegamebros” group. For all other users those skills must not be synced, regardless of whether the install happens standalone or via plugin. This filter already exists in at least one code path (see #2070); the standalone sync must respect it as well.\n\n3. **Sync source and destination** \n The source of truth for bundled skills is the `skills/` directory shipped with the package. Each subdirectory that contains a `SKILL.md` corresponds to one slash skill. The installer must copy those directories into `~/.claude/skills//`.\n\n4. **Result reporting** \n The returned `InstallResult.installedSkills` array should include every skill that was synced, formatted as `“/SKILL.md”`. The existing reporting contract must not change.\n\n5. **Plugin vs. standalone** \n When the installer detects that it is running under a plugin context and the plugin already provides its own skill files, the current plugin‑scoped behaviour must remain untouched. The safe‑name logic should only activate when no enabled plugin‑provided skills are available, **or** when `--no-plugin` is explicitly requested. In other words, the standalone path is: `(no enabled plugin) OR (options.noPlugin === true)`.\n\n6. **Deduplication** \n If, after applying the safe‑name rule, two bundled skills would end up with the same target directory name (case‑insensitive), only the first one encountered should be installed. This avoids overwrites in edge cases.\n\n**Acceptance criteria (user‑visible):**\n- After running `npm install -g oh-my-claude-sisyphus` and executing the installer without a plugin environment, listing `~/.claude/skills` shows directories for autopilot, ralph, ralplan, team, ultrawork, omc‑reference, and omc‑plan (but **not** a plain `plan` directory that would shadow the native command).\n- The `remember`, `verify`, `debug`, and `skillify` skills are absent for a non‑skininthegamebros user.\n- The installer still works as before when the oh‑my‑claudecode plugin is installed and enabled inside Claude Code.", "task_family": "Yeachan-Heo__oh-my-claudecode#365adf0fb6530564ebc6bf3902697b8aab14c65d", "task_id": "365adf0fb6530564ebc6bf3902697b8aab14c65d-1", "task_title": "Fix standalone slash-skill sync for npm installs (#2211)"} {"commit": "ea6c51c793a6e755db89d1b82e89b4b280d241d6", "language": "ts", "query_count": 4, "query_ids": ["ea6c51c793a6e755db89d1b82e89b4b280d241d6-1::q1", "ea6c51c793a6e755db89d1b82e89b4b280d241d6-1::q2", "ea6c51c793a6e755db89d1b82e89b4b280d241d6-1::q3", "ea6c51c793a6e755db89d1b82e89b4b280d241d6-1::q4"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "ea6c51c793a6e755db89d1b82e89b4b280d241d6", "split": "test", "task": "**Bug report: Concurrent Claude Code instances leak state through shared `.omc/state` files**\n\n## Steps to reproduce\n1. Open two Claude Code sessions in the same repository.\n2. In the first session, start a `ralph` task (or any mode that writes to `.omc/state/{mode}-state.json`).\n3. In the second session, start a different `ralph` task.\n4. Observe the HUD status in both sessions.\n\n## What happens\nBoth sessions read and write the **same** state file at `.omc/state/{mode}-state.json`. The second session sees the first session's iteration counts, task descriptions, and completion status. They overwrite each other's work, causing:\n\n- Tasks from one session incorrectly appear as active/completed in the other.\n- Iteration counters jump unexpectedly.\n- The HUD shows stale or misleading metadata (wrong `iteration`, wrong `task_description`).\n- Long-running `ralph` tasks in one session can be prematurely considered \"done\" because another session cleared its state.\n\nThis is effectively **context bleeding** between completely independent instances.\n\n## What I expected\nEach Claude Code process should have its own **isolated** state namespace. Starting a new session (a new CLI process) should never interfere with another session's state, even if they share the same working directory. The HUD should still be able to display active state regardless of which session produced it.\n\n## Context / clues\n- The codebase already has **session-scoped state directories** under `.omc/state/sessions/{session_id}/` with helpers like `resolveSessionStatePath` and `ensureSessionStateDir`.\n- The state tool handlers accept an optional `session_id` parameter, but when it is omitted, they fall back to the **shared legacy path** `.omc/state/{mode}-state.json`.\n- There is no automatic `session_id` assignment — every process ends up with `session_id=undefined` and hits the shared path.\n- The HUD state reader (`resolveStatePath` in the HUD layer) only checks the standard and legacy paths; it does **not** look inside the `sessions/` directory at all.\n\n## Desired behavior\n1. **Automatic per-process isolation**: When no explicit `session_id` is provided, the state tools should automatically generate a stable, unique session identifier for the lifetime of the process, and store state files under `.omc/state/sessions/{auto-id}/`.\n2. **No breaking change for explicit `session_id` usage**: If a caller passes `session_id` explicitly, that should continue to work as before.\n3. **HUD visibility**: The HUD state reader should scan the sessions directory so that active state from any session remains visible in the status bar.\n4. **Backward compatible**: State files written to the old legacy paths by earlier versions should still be readable as a fallback (newest file wins if multiple locations have the same mode state).\n5. **Cross-process isolation guarantee**: Two concurrent processes must never read each other's state by default.", "task_family": "Yeachan-Heo__oh-my-claudecode#ea6c51c793a6e755db89d1b82e89b4b280d241d6", "task_id": "ea6c51c793a6e755db89d1b82e89b4b280d241d6-1", "task_title": "fix: add PID/session ID namespace to state files to prevent context bleeding (#456) (#490)"} {"commit": "3fdeb717394a20a12a906b5521071e93db84d68c", "language": "ts", "query_count": 2, "query_ids": ["3fdeb717394a20a12a906b5521071e93db84d68c-1::q1", "3fdeb717394a20a12a906b5521071e93db84d68c-1::q2"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "212efb6b729fb60c2c05444ea90626d886d3364c", "split": "test", "task": "The `runPreCommitChecks` hook currently only validates the commit message and runs a type check. It should also verify that the project’s tests and lint pass before allowing a commit.\n\nSpecifically:\n\n- `runPreCommitChecks` must call the existing `runTests` helper and include its result in the checks list, so that a failed test suite causes `canCommit` to be `false`.\n- Introduce a new `runLint` helper that behaves like `runTests`: look for a `lint` script in the project’s `package.json`, execute it via `npm run lint`, and return a success/failure status and message. If no `package.json` exists or no `lint` script is defined, the check should be treated as passing (no lint script to run). If the script exits non-zero, the check should fail with an appropriate message. \n- Wire `runLint` into `runPreCommitChecks` the same way — add its result to the checks array so a lint failure blocks the commit.\n- Export `runLint` from the public hooks barrel (`src/hooks/index.ts`), consistent with how `runTests` is already exported.", "task_family": "Yeachan-Heo__oh-my-claudecode#3fdeb717394a20a12a906b5521071e93db84d68c", "task_id": "3fdeb717394a20a12a906b5521071e93db84d68c-1", "task_title": "fix(plugin-patterns): runPreCommitChecks now runs tests and lint validation"} {"commit": "12626b3907924dd314ab1ac8aa46b196cde9ae77", "language": "ts", "query_count": 2, "query_ids": ["12626b3907924dd314ab1ac8aa46b196cde9ae77-1::q1", "12626b3907924dd314ab1ac8aa46b196cde9ae77-1::q2"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "a4a06cd24b9e087f7cfc17ed6bdb60cc35d31783", "split": "test", "task": "**Request: `ensureStdinSymlink` should handle dangling symlinks and never block setup init**\n\n## Problem\nWhen `ensureStdinSymlink` cannot create a symlink (e.g., platform limitation) it falls back to copying the file. This fallback currently uses an existence check that treats a dangling symlink (pointing to a missing target) as “does not exist” and tries to copy. Because `copyFileSync` follows the destination symlink, the copy fails silently and the broken symlink remains—leaving the hook without the required file.\n\nSeparately, any unhandled exception thrown by `ensureStdinSymlink` can stop the entire `processSetupInit` flow. Since this healing is purely for upgrade robustness, it should never prevent initialization from completing.\n\n## Acceptance criteria\n1. **Dangling‑symlink fallback** — When symlink creation fails and a dangling symlink already exists at the destination, the fallback must remove the broken symlink and copy the source file in its place.\n2. **Preserve working files** — When symlink creation fails and a valid regular file already exists at the destination, the fallback must leave it untouched (no overwrite).\n3. **Non‑blocking init** — Any exception raised during the `ensureStdinSymlink` call inside setup initialization must be caught and must not cause the init to fail. The behavior should be best‑effort: log/ignore the failure and continue.\n4. **No regression for existing flows** — The atomic replace strategy (create temp symlink, rename into place) must continue to work as before; only the fallback path should be adjusted.\n\n## Context\nThe relevant code lives in `src/hooks/setup/index.ts` (the `ensureStdinSymlink` function and its call inside `processSetupInit`). The destination path is `/.claude/hooks/lib/stdin.mjs`.", "task_family": "Yeachan-Heo__oh-my-claudecode#12626b3907924dd314ab1ac8aa46b196cde9ae77", "task_id": "12626b3907924dd314ab1ac8aa46b196cde9ae77-1", "task_title": "fix(setup-hook): address Codex review feedback"} {"commit": "eccef474e8b12358c5ab91d731e0aceb32af9929", "language": "ts", "query_count": 1, "query_ids": ["eccef474e8b12358c5ab91d731e0aceb32af9929-1::q1"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "433d595f48963037b20a0b325eed9958bf2dd8b6", "split": "test", "task": "The `purgeStalePluginCacheVersions()` cache-cleanup step (used by the doctor/cleanup commands) sometimes deletes the currently active plugin version. Fix the following issues:\n\n- **Trailing slash:** `installPath` values in `installed_plugins.json` may end with `/`. Normalise paths so an active entry `/.../1.0.0/` does not cause version directory `1.0.0` to be treated as stale.\n- **Subdirectory install:** An active `installPath` may point *inside* a version directory (e.g., `.../2.0.0/dist`). The entire version directory must be preserved, not just the exact path.\n- **Race condition:** During a plugin update, a freshly written version directory may be picked up by a concurrent purge and deleted before the plugin is fully installed. Skip removal for any version directory whose modification time is less than one hour old.\n- **Bad plugin structure:** If the `plugins` field in `installed_plugins.json` is not a plain object (e.g., an array), the purge throws a runtime error. Instead, bail out gracefully and report an error.", "task_family": "Yeachan-Heo__oh-my-claudecode#eccef474e8b12358c5ab91d731e0aceb32af9929", "task_id": "eccef474e8b12358c5ab91d731e0aceb32af9929-1", "task_title": "fix: harden cache purge path comparison and add race condition guard"} {"commit": "49fda342432f7850dd6c21f492f194d285394c65", "language": "ts", "query_count": 2, "query_ids": ["49fda342432f7850dd6c21f492f194d285394c65-1::q1", "49fda342432f7850dd6c21f492f194d285394c65-1::q2"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "7ab83a44a3252bbf8ac837ff3d136e64cb6450da", "split": "test", "task": "**Bug: Team mode fails to launch tmux panes when `SHELL` is unsupported or empty**\n\n**Observed behavior**\nWhen the `SHELL` environment variable is set to a path like `/bin/tcsh` or is blank/whitespace-only, tmux pane creation for team workers fails. The error suggests the command passed to tmux contains shell syntax that the specified shell does not understand, leading to panes that never become ready or that crash immediately.\n\n**Expected behavior**\nThe system should only pass shell paths to tmux if the shell is known to work with OMC’s POSIX startup commands (currently: `sh`, `bash`, `zsh`, `fish`). If `SHELL` is missing, empty, whitespace-only, or refers to an unsupported shell, the system must fall back to a safe, supported shell (`/bin/sh`) instead of weaving the original `SHELL` value into the pane start command.\n\nOn Windows:\n- When no MSYSTEM-like environment is active, the code should continue to use `COMSPEC` (or `cmd.exe`) as before.\n- When an MSYS environment *is* active (e.g., `MSYSTEM=MINGW64`), the `SHELL` variable should still be validated. If it contains an unsupported shell (like `tcsh`), the fallback must be `/bin/sh` — not `COMSPEC`/`cmd.exe`.\n\nIn all fallback cases, the resulting tmux start command should reliably source the user’s shell initialization file (`.shrc`) and must never include the unsupported shell path itself.\n\n**Impact**\nThis is a common configuration on systems where users have `tcsh` or other less common shells set as their login shell, or where `SHELL` is accidentally empty. It breaks the team orchestration and degrades the “zero configuration” promise. The fix should make shell detection resilient to these cases while preserving existing affinity for `bash`/`zsh`/`fish` and native Windows cmd.", "task_family": "Yeachan-Heo__oh-my-claudecode#49fda342432f7850dd6c21f492f194d285394c65", "task_id": "49fda342432f7850dd6c21f492f194d285394c65-1", "task_title": "fix(team): preserve supported shell affinity"} {"commit": "0d3bd2f99d3286b40f764f9d2c54d33fea3c500f", "language": "ts", "query_count": 1, "query_ids": ["0d3bd2f99d3286b40f764f9d2c54d33fea3c500f-1::q1"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "fc3c08d501bbce3477d5e90d8d8ff62a329c44db", "split": "test", "task": "**Title:** Teleport command interpolates `--base` branch name into shell command, allowing command injection\n\n**Description:** \nWhen you run `teleport` with a `--base` value that contains shell metacharacters (e.g. `main; echo injected`, `dev|cat /etc/passwd`, `` `something` ``), the command spawns a shell that interprets those characters, leading to arbitrary command execution. This is a security risk because the user-supplied branch name is used directly inside a command string that is executed via a shell.\n\n**Expected behavior:** \nThe teleport command should execute all git operations without spawning a shell, so that branch names are always treated as literal arguments. This must apply to every git subcommand that is run during worktree creation (fetch, branch, worktree add). Branch names containing any characters—spaces, semicolons, pipes, backticks, dollar signs—should be handled safely and never cause extra commands to be executed.\n\n**Steps to reproduce (conceptual):** \n1. Run `teleport` with `--base` set to a branch name like `main; touch /tmp/pwned`. \n2. Observe that the shell command is constructed by string concatenation, allowing the injected command to run. \n3. In a fixed version, the injected command should not execute; git should receive the branch name as a literal argument.", "task_family": "Yeachan-Heo__oh-my-claudecode#0d3bd2f99d3286b40f764f9d2c54d33fea3c500f", "task_id": "0d3bd2f99d3286b40f764f9d2c54d33fea3c500f-1", "task_title": "fix(teleport): replace execSync with execFileSync in createWorktree to prevent shell injection"} {"commit": "148071b68f9d9ce6c3995b0db3eb3c1dc64838b6", "language": "ts", "query_count": 1, "query_ids": ["148071b68f9d9ce6c3995b0db3eb3c1dc64838b6-1::q1"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "08c45e4b84dcd7710a81b3837f7ee879ef672051", "split": "test", "task": "**Title:** `getSessionStartTime` can misorder or crash on non-standard timestamp formats\n\n**Area:** Session duration tracking (`src/hooks/session-end`)\n\n**Problem**\n`getSessionStartTime` compares `started_at` values from state JSON files as raw strings. While this works for strictly uniform ISO‑8601 timestamps, it can produce incorrect ordering if different state files contain timestamps with different degrees of precision or time‑zone offsets. More critically, a state file with a malformed or non‑parseable `started_at` value will either compare incorrectly or cause downstream failures.\n\n**Desired behavior**\n- Compare `started_at` timestamps as epoch‑milliseconds (derived via `Date.parse`) rather than as raw strings before picking the earliest.\n- Skip any state file whose `started_at` cannot be parsed to a finite number (e.g., `\"not-a-date\"`, empty string, `null`). Such entries should be ignored entirely.\n- The caller‑visible return value must still be the original `started_at` string from the selected state file, not the epoch value.\n- This logic applies identically to both the direct session‑match path (when `sessionId` is provided and `state.session_id` matches) and the legacy fallback path (when `state.session_id` is absent).\n- If all candidate state files contain unparseable timestamps, the function should return `undefined` (consistent with how it behaves when no valid states exist).\n- No change to how `active`, `session_id`, or other fields are used for selection; only the comparison and validity of `started_at` should be adjusted.\n\n**Edge cases / safety**\n- Existing behavior where a single valid state exists (even if other files are present) must still return the correct earliest timestamp.\n- The change must not alter the handling of stale states or other early‑exit conditions.\n- Ensure that comparison uses a finite‑number guard (`Number.isFinite`), so that `NaN` values from `Date.parse` on invalid inputs are caught regardless of the input shape.", "task_family": "Yeachan-Heo__oh-my-claudecode#148071b68f9d9ce6c3995b0db3eb3c1dc64838b6", "task_id": "148071b68f9d9ce6c3995b0db3eb3c1dc64838b6-1", "task_title": "fix: parse timestamps to epoch for safe comparison in session duration"} {"commit": "e09a0bc36ecd44235fc5917f899be6a8172b4740", "language": "ts", "query_count": 1, "query_ids": ["e09a0bc36ecd44235fc5917f899be6a8172b4740-1::q1"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "a244ca276ff1303d67bbde66ab4a981c959edb33", "split": "test", "task": "**Bug: Empty inline prompts return misleading generic error instead of a clear \"empty prompt\" message**\n\nWhen using the inline prompt mode of the `ask-codex` or `ask-gemini` MCP tools (passing a `prompt` string instead of a `prompt_file`), providing an empty string or a whitespace-only string currently produces the generic fallback error telling me to supply either `prompt` or `prompt_file`. This is confusing because I *did* supply the `prompt` parameter — it’s just empty. I would expect a clear, specific error indicating that the inline prompt is empty, so I can fix my input without hunting for what went wrong.\n\nAdditionally, the tool schemas for `background` don’t warn callers that background execution is incompatible with inline prompts. The implementation already rejects that combination at runtime, but the parameter description doesn’t surface the restriction, making it easy to miss when reading the schema or relying on LLM introspection.\n\n**Acceptance criteria**\n\n1. **Explicit “inline prompt is empty” error** \n For both `handleAskCodex` and `handleAskGemini` (when reached via the respective MCP servers/standalone servers):\n - Passing `prompt: \"\"` returns an error whose text indicates the inline prompt is empty. \n - Passing `prompt: \" \"` (whitespace only) does the same. \n - The error must fire *before* the generic “prompt or prompt_file is required” fallback or any background-mode check that would conflict with an empty prompt. \n - The error message should be distinct from the “foreground only” message used when a non-empty inline prompt is combined with `background: true`.\n\n2. **Schema description updates** \n - The `background` parameter description in the `askCodex` tool definition (both in the regular and standalone MCP servers) must include language to the effect that it is not available when using an inline prompt. \n - The same update applies to the `askGemini` tool definition (regular and standalone).\n\n3. **No regressions for valid inline prompts** \n - Non-empty inline prompts continue to work, still produce an error when combined with `background: true` (“foreground only”), and never trigger the “Inline prompt is empty” or the generic prompt/prompt_file error. \n - Prompts that only provide `prompt_file` (no inline prompt) are unaffected.", "task_family": "Yeachan-Heo__oh-my-claudecode#e09a0bc36ecd44235fc5917f899be6a8172b4740", "task_id": "e09a0bc36ecd44235fc5917f899be6a8172b4740-1", "task_title": "fix: resolve unreachable empty-inline validation and schema gaps"} {"commit": "5c1918ca4bab62e26f4766b720493b347fa3cb24", "language": "ts", "query_count": 1, "query_ids": ["5c1918ca4bab62e26f4766b720493b347fa3cb24-1::q1"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "66dccfdc013cc4f7fd58cb3070bff371cd66b622", "split": "test", "task": "**Title:** Auto-update reconciliation fails on Windows – binary resolution picks wrong executable \n\n**Background** \nAfter `npm install -g oh-my-claude-sisyphus@latest` completes, the updater re‑executes the `omc` CLI with an `update-reconcile` step to finalize the update and persist metadata. On Windows the binary lookup currently runs `which omc 2>/dev/null || where omc 2>NUL` and takes the first line. That line is often **not** `omc.cmd` (it could be a Powershell script or another non‑executable entry), so the re‑exec step fails silently. When it fails, metadata can still be written, leaving the user in a stuck state.\n\n**Desired behavior** \n\n1. **Windows‑specific binary resolution** \n - Instead of a generic `where omc`, look explicitly for `omc.cmd` (e.g., `where.exe omc.cmd`). \n - Parse `where` output correctly, handling `\\r\\n` line endings, and use the first non‑empty line as the resolved path. \n\n2. **Re‑exec with reconcile on Windows** \n - Spawn the resolved binary with the argument `update-reconcile` and pass `OMC_UPDATE_RECONCILE=1`. \n - Add `windowsHide: true` to the spawn options so no console window flashes. \n - On non‑Windows the existing `which/where` approach should still work, but path extraction should follow the same “first non‑empty line” rule for consistency. \n\n3. **Failure handling** \n - If the re‑exec step throws (e.g., `ENOENT` because the binary is missing), do **not** write the new version metadata. \n - Return a failure result with the reconciliation error, identical to how failures are surfaced on other platforms. \n\n4. **No regressions for other platforms** \n - UNIX/macOS behavior must remain unchanged except for the more robust path extraction (first non‑empty line from the combined `which/where` output).", "task_family": "Yeachan-Heo__oh-my-claudecode#5c1918ca4bab62e26f4766b720493b347fa3cb24", "task_id": "5c1918ca4bab62e26f4766b720493b347fa3cb24-1", "task_title": "fix(update): resolve Windows reconcile binary via omc.cmd (#1560)"} {"commit": "cc78ba3f45109e8fe360e6232df52368878bda50", "language": "ts", "query_count": 1, "query_ids": ["cc78ba3f45109e8fe360e6232df52368878bda50-1::q1"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "8f28b3593fa8a563573653839d9ff1c9007e2112", "split": "test", "task": "## Feature request: Deduplicate OpenClaw lifecycle events from multiple tmux panes\n\n### Problem\nWhen multiple tmux panes are attached to the same tmux session and workspace, each pane can independently trigger the same OpenClaw lifecycle event for a single user action. For example:\n\n- `session-start` fires once per pane when a session begins.\n- `keyword-detector` (prompt-submit) fires once per pane each time the user submits a prompt.\n- `stop` / `session-end` fire once per pane when a session stops.\n\nAll duplicates are currently forwarded to downstream native gateways, causing noise, double-processing, and confusing operator feedback.\n\n### Desired behavior\nThe OpenClaw event dispatch should collapse these duplicate bursts **before** any signal reaches a downstream gateway. The first occurrence of an event in a burst must be preserved; subsequent matching occurrences within a short time window should be silently dropped (not forwarded) and return a success result that indicates the event was skipped (e.g., an additional `skipped: \"deduped\"` field on the result).\n\n#### Deduplication rules\n- **Dedup key**: `(projectPath, tmuxSession)` — never use `sessionId` alone, because different panes have different Claude session IDs even though they share the same user action.\n- For `keyword-detector`: also include a normalized form of the prompt (collapse whitespace, limit length) so that different prompts are not accidentally collapsed together.\n- **Time windows** (approximate, and fine to be configurable constants):\n - `session-start`: ~10 seconds\n - `keyword-detector`: ~4 seconds\n - `stop` / `session-end`: ~12 seconds\n- The deduplication state is per-project working-tree (scoped to the project directory) and may be stored ephemerally (a short TTL of a few hours is acceptable).\n- If no tmux session can be determined (e.g., running outside tmux), apply **no** deduplication — forward everything as before.\n\n### Constraints\n- Do **not** change how signals are built, how tmux tail is captured, or how instructions are interpolated. Deduplication should be a separate, early check that happens before the signal is dispatched to any HTTP or command gateway.\n- Do **not** add any new dependencies; use only Node.js built-ins.\n- The first event of every burst must always be dispatched normally; only duplicates are suppressed.\n- The deduplication must handle concurrent panes safely (a simple file-based lock is acceptable).\n\n### Acceptance criteria\n1. In a multi-pane tmux session with the same project, firing `session-start` from two panes within 10 seconds results in exactly one gateway dispatch; the second call returns `success: true, skipped: \"deduped\"`.\n2. Firing `keyword-detector` with the same normalized prompt from two panes within 4 seconds results in exactly one dispatch; a different prompt submitted in the same window is dispatched independently.\n3. Firing `stop` or `session-end` from two panes within 12 seconds results in exactly one dispatch.\n4. The first event of any burst is always dispatched.\n5. When `tmuxSession` is undefined/not-detected, all events are dispatched without any deduplication.\n6. Existing tests for OpenClaw and bridge-openclaw continue to pass.", "task_family": "Yeachan-Heo__oh-my-claudecode#cc78ba3f45109e8fe360e6232df52368878bda50", "task_id": "cc78ba3f45109e8fe360e6232df52368878bda50-1", "task_title": "Collapse duplicate native lifecycle bursts for attached tmux sessions"} {"commit": "9507066eefb1dcc0475e1b1e2be1e6a3a40ce4b6", "language": "ts", "query_count": 3, "query_ids": ["9507066eefb1dcc0475e1b1e2be1e6a3a40ce4b6-1::q1", "9507066eefb1dcc0475e1b1e2be1e6a3a40ce4b6-1::q2", "9507066eefb1dcc0475e1b1e2be1e6a3a40ce4b6-1::q3"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "2995bab5e2b9cb8c28abb643b6502c57f8634c5e", "split": "test", "task": "When the unified MCP registry sync appends the managed MCP block to `~/.codex/config.toml`, it re-declares any `[mcp_servers.*]` tables that already exist outside the managed block. Codex then fails with duplicate-key TOML errors.\n\nChange the Codex sync path so that registry entries whose server name already appears in the user-owned part of the config (i.e., any `[mcp_servers.]` section outside the `# BEGIN OMC MANAGED MCP REGISTRY` / `# END OMC MANAGED MCP REGISTRY` markers) are **skipped** from the managed block. Missing entries must still be added. Repeated syncs must be idempotent—if the user already owns a table, the managed block must not reintroduce it.", "task_family": "Yeachan-Heo__oh-my-claudecode#9507066eefb1dcc0475e1b1e2be1e6a3a40ce4b6", "task_id": "9507066eefb1dcc0475e1b1e2be1e6a3a40ce4b6-1", "task_title": "Keep Codex MCP sync from duplicating user-owned tables"} {"commit": "663c2ad7244b3c3396e56a7d12354943c286390b", "language": "ts", "query_count": 2, "query_ids": ["663c2ad7244b3c3396e56a7d12354943c286390b-1::q1", "663c2ad7244b3c3396e56a7d12354943c286390b-1::q2"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "8e2a00e05ed0fc1131497387fe61426d492a539e", "split": "test", "task": "**Title:** Persistent execution mode (Ralph, Ultrawork, Autopilot) should pause on rate-limit stops instead of retrying indefinitely\n\n**Problem:** \nWhen the underlying Claude API returns a rate-limit response (HTTP 429, quota exceeded, overloaded, etc.), Claude Code stops and fires the Stop hook. The persistent‑mode handler currently treats this like any other stop and re‑injects a continuation prompt, causing Claude to immediately retry, hit the rate limit again, and stop again — triggering an infinite retry loop. Observation: Ralph loops forever with no progress, and the user must forcibly intervene to break the cycle.\n\n**Expected behavior:** \nWhenever a persistent execution mode (Ralph, Ultrawork, or Autopilot) is active and Claude Code stops due to a rate‑limit reason, the Stop hook should **not** block the stop. Instead, it should allow Claude Code to stop gracefully and return a status indicating the pause, so the user can manually resume once the rate limit has reset. Normal stops (e.g. `end_turn`, incomplete tasks) should still be blocked and trigger a continuation attempt as before.\n\n**Acceptance criteria / constraints:**\n1. **Detection:** Recognize rate‑limit stops regardless of the specific key used in the stop context (the reason may appear in `stop_reason`, `end_turn_reason`, or their camelCase variants). Match known rate‑limit indicators such as `rate_limit`, `rate_limited`, `ratelimit`, `too_many_requests`, `429`, `quota_exceeded`, `quota_limit`, `quota_exhausted`, `overloaded`, and similar — using substring matching, case‑insensitive.\n2. **Ordering of checks:** The rate‑limit guard must execute **before** the existing Ralph/Ultrawork/Autopilot continuation logic so that a rate‑limited session never re‑enters the persistent loop.\n3. **Return value when rate‑limited:** The hook result must have `shouldBlock: false` and a human‑readable `message` that clearly indicates the pause is due to a rate limit. The `mode` in the result should be `'none'` (no continuation mode active).\n4. **Non‑regression:** When the stop reason is **not** rate‑limit‑related (e.g., normal `end_turn`, `context_limit`, `user_cancel`, etc.), the hook must continue to block the stop if persistent work remains unfinished, exactly as it does today. An active Ralph session stopped with `stop_reason: 'end_turn'` should still be forced to continue.\n5. **Safety:** The rate‑limit detection must gracefully handle missing or null stop context without throwing.\n\n**Note on existing code patterns:** \nThe stop‑context handling is already centralized in the persistent‑mode hook (the function that decides whether to block a stop). There are existing helpers for other special stop reasons (user abort, context limit) that can serve as a template. The new detection should follow the same conventions and be integrated into the same guard chain.", "task_family": "Yeachan-Heo__oh-my-claudecode#663c2ad7244b3c3396e56a7d12354943c286390b", "task_id": "663c2ad7244b3c3396e56a7d12354943c286390b-1", "task_title": "fix(ralph): prevent infinite retry loop when rate limited (#777)"} {"commit": "97718da8378f42f6ff01c92b1b53c91babf34731", "language": "ts", "query_count": 1, "query_ids": ["97718da8378f42f6ff01c92b1b53c91babf34731-1::q1"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "39ab96b3c7d95d515518d4e02a242a63259025a1", "split": "test", "task": "`isValidFilePath` in `src/hooks/plugin-patterns/index.ts` incorrectly rejects Windows file paths. The validation treats `\\` as a shell metacharacter, which causes legitimate Windows path separators (`src\\file.ts`, `C:\\repo\\file.ts`) to be flagged. It also calls `isAbsolute()` and rejects *any* absolute path, including Unix paths like `/home/...`. The function must accept valid platform paths (relative and absolute, with backslashes) while still blocking path traversal (`..`) and shell-injection characters. Adjust the logic so that backslashes used as path separators are not treated as dangerous, and remove the absolute-path rejection while preserving all other security checks.", "task_family": "Yeachan-Heo__oh-my-claudecode#97718da8378f42f6ff01c92b1b53c91babf34731", "task_id": "97718da8378f42f6ff01c92b1b53c91babf34731-1", "task_title": "fix(plugin-patterns): accept Windows file paths in isValidFilePath"} {"commit": "407eb28a7fc48965485c021388f8c41e8861ab70", "language": "ts", "query_count": 2, "query_ids": ["407eb28a7fc48965485c021388f8c41e8861ab70-1::q1", "407eb28a7fc48965485c021388f8c41e8861ab70-1::q2"], "repo": "Yeachan-Heo__oh-my-claudecode", "revision": "6a83095bb9a3fed731d2174be8a073160149a880", "split": "test", "task": "## Ticket: Prevent usage-API thundering herd and prefer stale data over error badge\n\n### Problem\n\nThe HUD statusline periodically fetches usage information from the Anthropic API and caches the result in a shared cache file on disk. When multiple `claude` sessions share that cache (common with multiple terminal windows or background agents), all sessions expire the cache at the same time and **simultaneously** call the usage API. This quickly exhausts the rate-limit budget, produces frequent `[API 429]` errors in the HUD, and—critically—**replaces** the user’s actual usage percentages with a generic error badge even when the previous (stale) data is still present in the cache file.\n\n### Desired behaviour\n\n1. **Single refresher** — Only one session should attempt to refresh the cache when it expires. Other sessions should fall back to returning the existing stale cache data without reporting an error.\n\n2. **Lock safety** — If a session cannot acquire the refresh lock (because another session is already refreshing), it must:\n * Return the existing stale usage data if cached data exists (no error).\n * Return an appropriate error only when there is **no** stale data at all (e.g., `network`).\n\n3. **Lock release** — The lock must be released even if the API call fails (network error, timeout, etc.). A crashed session mid-request should not permanently block other sessions; set a lock staleness timeout equal to the API timeout plus a 5-second margin (15 s).\n\n4. **Non-blocking** — Lock acquisition must not block HUD rendering. Fail immediately and serve stale data instead of waiting.\n\n5. **HUD display priority** — When a `UsageResult` contains **both** rate-limit data **and** an error (especially `rate_limited`), the HUD should display the data (usage percentages) rather than the error indicator (`[API 429]`). Only when **no** data is available should the error indicator be shown. This means stale data from a 429 response is still shown as percentages, preserving visibility for the user.\n\n### Constraints / hints\n\n- The project already has a file-lock utility in `lib/file-lock`. Reuse it rather than building a new locking primitive.\n- The cache-expiry path in the usage API module must be wrapped, but the fast path (valid cache) must remain lock-free.\n- Make sure the `UsageResult` shape returned from `getUsage` still supports the existing caller expectations; the HUD already receives an `error` field alongside `rateLimits`.\n\n### Acceptance criteria\n\n* Multiple sessions sharing the same usage cache do **not** fire simultaneous API requests when the cache expires.\n* The HUD shows usage percentages when stale data is available, even if the fetch attempt resulted in a 429 or lock contention.\n* `[API 429]` (or other error badges) only appears when no usage data is available to display.\n* A session that is unable to acquire the refresh lock does not block or crash; it returns stale data if present, or a clean error if there is no cache at all.", "task_family": "Yeachan-Heo__oh-my-claudecode#407eb28a7fc48965485c021388f8c41e8861ab70", "task_id": "407eb28a7fc48965485c021388f8c41e8861ab70-1", "task_title": "fix(hud): prevent thundering herd on usage API calls"} {"commit": "36965efe0374532958ad9a10d37368ca4cffcd67", "language": "go", "query_count": 1, "query_ids": ["36965efe0374532958ad9a10d37368ca4cffcd67-1::q1"], "repo": "afadesigns__zshellcheck", "revision": "36965efe0374532958ad9a10d37368ca4cffcd67", "split": "test", "task": "Add a new ZShellCheck kata that flags use of `printf '%q'` in Zsh scripts and suggests the native `${(q)var}` parameter expansion instead. Zsh's built-in quoting flag is both more idiomatic and avoids shelling out. Include mention of the available style variants (`${(qq)}`, `${(qqq)}`, `${(qqqq)}`) in the violation message. The check should be severity \"style\", match any `printf` simple command where a format argument contains `%q`, and not fire for format strings with only `%s` or other formatting characters. Follow the convention used by existing katas for registration, AST node type, and violation structure. Update the version string to reflect the new kata count.", "task_family": "afadesigns__zshellcheck#36965efe0374532958ad9a10d37368ca4cffcd67", "task_id": "36965efe0374532958ad9a10d37368ca4cffcd67-1", "task_title": "feat: ZC1357 — use Zsh `${(q)var}` instead of `printf '%q'` (#370)"} {"commit": "ab3e11cc0a519f9f03b31d73774ec5ad10c0b8eb", "language": "go", "query_count": 1, "query_ids": ["ab3e11cc0a519f9f03b31d73774ec5ad10c0b8eb-1::q1"], "repo": "afadesigns__zshellcheck", "revision": "ab3e11cc0a519f9f03b31d73774ec5ad10c0b8eb", "split": "test", "task": "**Title:** Add kata ZC1431 to warn on `crontab -r` (deletes all user cron jobs)\n\n**Description:**\nWe need a new static analysis rule (kata) that detects when `crontab -r` is invoked. The `-r` flag removes the entire crontab for the current user without any backup or interactive prompt, so it should be flagged as a warning.\n\n- The kata ID should be `ZC1431` and severity `warning`.\n- It must trigger for simple commands whose name is `crontab` when any argument matches exactly `-r`, `-ur`, or `-ru`. These combined forms combine user selection and removal but still lack a confirmation step.\n- It must **not** trigger for usage like `crontab -l` or other flags.\n- The warning message should explain the danger: `crontab -r` removes all cron jobs with no backup, advise saving the crontab first (`crontab -l > cron.bak`), and recommend using `crontab -ir` for interactive confirmation.\n- Register the kata under `SimpleCommandNode` following the existing kata pattern.\n- Bump the version constant from `0.4.27` (427 katas) to `0.4.28` to reflect the new kata count.", "task_family": "afadesigns__zshellcheck#ab3e11cc0a519f9f03b31d73774ec5ad10c0b8eb", "task_id": "ab3e11cc0a519f9f03b31d73774ec5ad10c0b8eb-1", "task_title": "feat: ZC1431 — warn on `crontab -r` (deletes all user cron jobs) (#447)"} {"commit": "483ef03d868bd3d90b8f834e2569a0a426964ab9", "language": "go", "query_count": 2, "query_ids": ["483ef03d868bd3d90b8f834e2569a0a426964ab9-1::q1", "483ef03d868bd3d90b8f834e2569a0a426964ab9-1::q2"], "repo": "afadesigns__zshellcheck", "revision": "483ef03d868bd3d90b8f834e2569a0a426964ab9", "split": "test", "task": "**Title:** Add lint for `cat -v` / `cat -A` — suggest Zsh `${(V)var}` instead\n\n**Request type:** Feature request (new style-level check/kata)\n\n---\n\nWhen reviewing Zsh scripts I frequently see constructs like `cat -v somefile` or `cat -A somefile` used to make control characters visible. Zsh already has a built-in, zero‑process alternative via the `(V)` parameter expansion flag: `\"${(V)var}\"`. Running an external `cat` for this purpose is unnecessary in Zsh‑native code.\n\n**Expected behavior:**\n\n- A new **style** (cosmetic / idiomatic) check should flag simple commands where `cat` is invoked with `-v` or `-A` (or both simultaneously, though that’s uncommon).\n- The violation message should recommend using the Zsh `(V)` parameter expansion flag as the preferred way to make control characters visible.\n- Other `cat` invocations (e.g., `cat -n`, `cat -E`, plain `cat`) must **not** trigger this rule.\n- The kata should be assigned the next available number (e.g., ZC1287) following the project’s existing numbering convention.\n- The version / kata count should be bumped to reflect the new check.\n\n**Context and constraints:**\n\n- Rule severity: `style` (this is an idiomatic improvement, not a correctness or security issue).\n- The check should only apply to **simple commands** (not pipeline stages or command substitutions that happen to contain `cat -v` as a substring, if that would be overly aggressive—though a simple‑command check is the natural scope).\n- The rule is specifically for Zsh‑native scripts, where using `${(V)…}` is always available and more efficient.\n\nThis is an actionable, self‑contained addition that fits the existing pattern of “Katas” in the repository – a single check with a small set of test inputs.", "task_family": "afadesigns__zshellcheck#483ef03d868bd3d90b8f834e2569a0a426964ab9", "task_id": "483ef03d868bd3d90b8f834e2569a0a426964ab9-1", "task_title": "feat: Add ZC1287 — use Zsh ${(V)var} instead of cat -v for visible control chars"} {"commit": "8a900017991b09e3b0c098ebb8ed501e0f8c766a", "language": "go", "query_count": 2, "query_ids": ["8a900017991b09e3b0c098ebb8ed501e0f8c766a-1::q1", "8a900017991b09e3b0c098ebb8ed501e0f8c766a-1::q2"], "repo": "afadesigns__zshellcheck", "revision": "8a900017991b09e3b0c098ebb8ed501e0f8c766a", "split": "test", "task": "**Title:** Add style warning for unfiltered `strace` / `ltrace` invocations\n\n**Description:**\nUnfiltered `strace` (and `ltrace`) records every syscall, including read/write buffers that may contain passwords, tokens, and other secrets, and can produce enormous output. Users should always scope traces with a filter, but it's easy to forget.\n\nI'd like a new **style** check that warns when `strace` or `ltrace` is invoked without any of the recognised filter flags.\n\n**Acceptance Criteria:**\n\n1. **Trigger command:** The check applies when the command name is `strace` or `ltrace`.\n2. **Severity:** style.\n3. **Behaviour:**\n - If the command has **no arguments**, do **not** flag it (the user hasn't specified what to trace yet).\n - If the command has arguments but **none** of them are `-e`, `--trace`, `--trace-path`, or `-P`, flag the command as a violation.\n - The presence of **any** of those four flags — even as a standalone argument `-e` (without a value) — is enough to suppress the warning. The exact value after the flag is not inspected; just the flag occurrence on the argument list matters.\n4. **Message:** The violation message should include the command name (`strace` or `ltrace`) and guide the user to use `-e trace=` to scope the trace safely.\n5. **Examples:**\n - `strace -e trace=openat ls` → **no violation**.\n - `strace -f ls` → **violation** (filter flag missing).\n - `strace ls` → **violation**.\n - `ltrace -P some/path ls` → **no violation**.\n - `strace` (no arguments) → **no violation**.\n\nThe rule should be registered and active by default; no configuration changes are needed beyond the new rule itself.", "task_family": "afadesigns__zshellcheck#8a900017991b09e3b0c098ebb8ed501e0f8c766a", "task_id": "8a900017991b09e3b0c098ebb8ed501e0f8c766a-1", "task_title": "feat: ZC1521 — style: strace/ltrace without -e (captures secrets, huge output) (#538)"} {"commit": "6002f0870bc16d0f0c72643c8ebeb9693af187d5", "language": "go", "query_count": 1, "query_ids": ["6002f0870bc16d0f0c72643c8ebeb9693af187d5-1::q1"], "repo": "afadesigns__zshellcheck", "revision": "6002f0870bc16d0f0c72643c8ebeb9693af187d5", "split": "test", "task": "**Feature request: Flag `mktemp -u` as a security risk (TOCTOU race)**\n\nI was surprised to see that `zshellcheck` currently passes silently on scripts containing `mktemp -u`. The `-u` flag only generates a unique temporary name but does *not* create the file, leaving an inherent time-of-check time-of-use (TOCTOU) race. On multi-user hosts or shared CI runners another process can claim that name before the caller opens/redirects to it, which can lead to security vulnerabilities or data corruption.\n\nPlease add a new kata that warns when an invocation of `mktemp` uses the `-u` short flag. If the parser is able to detect `--dry-run` as an argument, that should be caught as well. The check *must not* fire for plain `mktemp` (no flag), nor for the safe `mktemp -d` (directory creation) variant. The warning should be at the `warning` severity level, similar to other checks covering risky patterns like `rm -rf` without safeguards.\n\nA typical violation message would clarify that `mktemp -u` does not create the file and suggests letting `mktemp` create the file directly (omitting `-u`) or using `mktemp -d` when a directory is needed.\n\nThe kata should follow the project’s usual extension conventions: it will need to be registered with the kata system, included in the test suite, and the version counter bumped as per the project’s standards.\n\nThanks for the great tool — this addition will help users avoid a subtle but dangerous shell scripting pattern.", "task_family": "afadesigns__zshellcheck#6002f0870bc16d0f0c72643c8ebeb9693af187d5", "task_id": "6002f0870bc16d0f0c72643c8ebeb9693af187d5-1", "task_title": "feat: ZC1478 — warn on mktemp -u (TOCTOU race) (#495)"} {"commit": "25c2c15ee0139a8637f0f06dacca4cc8074f55bd", "language": "go", "query_count": 1, "query_ids": ["25c2c15ee0139a8637f0f06dacca4cc8074f55bd-1::q1"], "repo": "afadesigns__zshellcheck", "revision": "25c2c15ee0139a8637f0f06dacca4cc8074f55bd", "split": "test", "task": "**Title:** Add ZC1593 – flag `blkdiscard` as destructive command \n\n**Description:** \nWe need a new kata that warns about the `blkdiscard` command in Zsh scripts. `blkdiscard $DEV` tells the SSD controller to discard/TRIM the entire device; on modern drives this immediately makes data unrecoverable. This is similar to the existing checks we have for other data‑destructive commands (e.g. ZC1592, `wipefs`, `dd` with block‑device targets). \n\n**Desired behaviour:** \n- **Kata ID:** `ZC1593` \n- **Severity:** `error` \n- **When to trigger:** The check should fire when `blkdiscard` is used as a simple command **and at least one argument is present**. \n - `blkdiscard /dev/sda` → violation \n - `blkdiscard -z /dev/sda` → violation (flags/options don’t change the danger) \n - `blkdiscard` with no arguments → **no** violation (likely just printing the help usage). \n - Completely different commands (e.g. `lsblk /dev/sda`) → no violation. \n- **Message:** A concise explanation of the danger, emphasising that the data is unrecoverable and that operator confirmation should be required before running the command. \n\n**Technical notes:** \n- Register the kata against `ast.SimpleCommandNode`, as is done for other command‑level checks. \n- Place the implementation in the `pkg/katas` package alongside the other destructive‑command katas. \n- **Version bump:** The version constant in `pkg/version/version.go` must be updated to reflect the increased kata count. The current version is `0.5.89`; after adding one kata it should become `0.5.90`. \n- Include unit tests that verify the detection cases described above, using the existing kata‑test utilities. \n\n**Acceptance criteria:** \n1. `zshellcheck` reports an `error` for any `blkdiscard` simple command that has at least one argument. \n2. No false positives on `blkdiscard` without arguments, nor on unrelated commands. \n3. The version number is incremented correctly.", "task_family": "afadesigns__zshellcheck#25c2c15ee0139a8637f0f06dacca4cc8074f55bd", "task_id": "25c2c15ee0139a8637f0f06dacca4cc8074f55bd-1", "task_title": "feat: ZC1593 — flag `blkdiscard` full-device TRIM wipe (#612)"} {"commit": "83802f8ad015a5cd8a7a6b97b5e2e45c539d3585", "language": "go", "query_count": 1, "query_ids": ["83802f8ad015a5cd8a7a6b97b5e2e45c539d3585-1::q1"], "repo": "afadesigns__zshellcheck", "revision": "83802f8ad015a5cd8a7a6b97b5e2e45c539d3585", "split": "test", "task": "```\nTitle: New ZShellCheck rule: error on flatpak remote-add/modify --no-gpg-verify\n\nWe need a security check that warns about disabling GPG verification when configuring Flatpak remotes.\n\nAcceptance criteria:\n- If a Zsh script contains a `flatpak` command whose first argument is `remote-add` or `remote-modify`, and any subsequent argument equals exactly `--no-gpg-verify`, `--gpg-verify=false`, or `--no-gpg-verify=true`, the tool must report an **error**.\n- The message should convey that signature verification is disabled and that the only remaining identity is HTTPS, and should recommend signing the repository with `ostree gpg-sign` and importing the key via `--gpg-import=KEYFILE`.\n- Other `flatpak` subcommands (e.g., `install`) must **not** trigger this rule, even if they happen to include those flags.\n- A `flatpak remote-add` or `remote-modify` command that does not contain any of the triggering flags must **not** trigger the rule.\n\nImplementation constraints:\n- Follow the existing kata pattern (register the check for simple commands, examine the command name and arguments).\n- The new check should be classified as error severity.\n- Please add it as a new kata, respecting the project’s naming and versioning conventions.\n```", "task_family": "afadesigns__zshellcheck#83802f8ad015a5cd8a7a6b97b5e2e45c539d3585", "task_id": "83802f8ad015a5cd8a7a6b97b5e2e45c539d3585-1", "task_title": "feat: ZC1782 — error on flatpak remote-add --no-gpg-verify (#801)"} {"commit": "36e2ec60e739f354f9e7c88fd599c6db606dbcc6", "language": "go", "query_count": 2, "query_ids": ["36e2ec60e739f354f9e7c88fd599c6db606dbcc6-1::q1", "36e2ec60e739f354f9e7c88fd599c6db606dbcc6-1::q2"], "repo": "afadesigns__zshellcheck", "revision": "36e2ec60e739f354f9e7c88fd599c6db606dbcc6", "split": "test", "task": "**Feature Request: ZC1881 — add warning for `unsetopt MULTIBYTE` (UTF‑8 character handling)**\n\nThe Zsh option `MULTIBYTE` is enabled by default and controls whether operations like `${#str}`, `${str:s:l}`, and `[[ =~ ]]` work on **characters** (UTF‑8 codepoints) rather than bytes. When a script explicitly disables it, every string operation silently falls back to per‑byte math, which can corrupt multi‑byte text. I’d like a new kata, ZC1881, that warns in the following cases:\n\n**Triggering invocations**\n- `unsetopt MULTIBYTE`\n- `setopt NO_MULTIBYTE` (or any variant with underscores / mixed case, e.g., `SETOPT no_multibyte`)\n\n**Non‑triggering invocations**\n- `setopt MULTIBYTE` (explicitly turning it on — this is the safe default and should be allowed without a warning)\n- Any `unsetopt` or `setopt` for unrelated option names (e.g., `NOMATCH`)\n\n**Observable output**\n- Severity: **warning** (the pattern is risky and can produce corrupted strings)\n- The message should clearly describe the user‑visible impact: `${#str}` on an emoji returns 4 instead of 1, substring operations can slice mid‑codepoint producing invalid UTF‑8, and `[[ =~ ]]` Unicode ranges may fail. The message should suggest `wc -c` when byte‑level counting is genuinely needed.\n\n**Kata integration**\n- Register the kata using the standard framework (check triggered for simple commands) and follow the conventions of existing katas (e.g. matching the command name, normalising the argument to handle underscores/case insensitivity).\n- The kata ID must be `ZC1881`.\n\n**Version update**\n- As required by the project’s versioning policy, bump the ZShellCheck version in `pkg/version/version.go` to reflect the addition of one new kata (the version is derived from the total kata count; this addition should raise the minor version from 0.8.77 to 0.8.78).\n\nPlease provide matching unit tests that cover both the positive (triggering) and negative (non‑triggering) cases, following the existing kata‑test pattern.", "task_family": "afadesigns__zshellcheck#36e2ec60e739f354f9e7c88fd599c6db606dbcc6", "task_id": "36e2ec60e739f354f9e7c88fd599c6db606dbcc6-1", "task_title": "feat: ZC1881 — warn on `unsetopt MULTIBYTE` turning string ops into per-byte math (#902)"} {"commit": "8edd8a65aad49b69c9a07ddf33bd23633857e561", "language": "go", "query_count": 1, "query_ids": ["8edd8a65aad49b69c9a07ddf33bd23633857e561-1::q1"], "repo": "afadesigns__zshellcheck", "revision": "8edd8a65aad49b69c9a07ddf33bd23633857e561", "split": "test", "task": "Add a new kata ZC1245 that flags the use of `curl -k` or `curl --insecure`. These flags disable TLS certificate verification, making connections susceptible to MITM attacks. The rule should fire for any `curl` invocation containing one of those flags, regardless of position among arguments, and should not trigger for other commands or for `curl` invocations without those flags. Assign severity \"error\". The message should advise fixing the certificate chain or using `--cacert` to specify a CA bundle.\n\nRegister the kata for `ast.SimpleCommandNode` using the usual `RegisterKata` pattern. After adding the kata, update the `Version` constant in the version package to reflect the new total kata count (one more than current).", "task_family": "afadesigns__zshellcheck#8edd8a65aad49b69c9a07ddf33bd23633857e561", "task_id": "8edd8a65aad49b69c9a07ddf33bd23633857e561-1", "task_title": "feat: Add ZC1245 — avoid disabling TLS certificate verification (#270)"} {"commit": "e7e7584636fc257538d3b7828a8de253e8fa969d", "language": "go", "query_count": 1, "query_ids": ["e7e7584636fc257538d3b7828a8de253e8fa969d-1::q1"], "repo": "afadesigns__zshellcheck", "revision": "e7e7584636fc257538d3b7828a8de253e8fa969d", "split": "test", "task": "Add a new Kata (`ZC1814`) that flags all uses of `dpkg --force-all` as an error.\n\nWhat to detect:\n- Any invocation of `dpkg` where the argument `--force-all` is present, directly or after other options (e.g. `dpkg -i --force-all pkg.deb`).\n- Any invocation of `apt` or `apt-get` that passes `-o Dpkg::Options::=--force-all`, which is the typical indirect way to enable every `--force-*` flag from apt.\n- Specific `--force-