maintainability-agent 2.3.0__tar.gz → 2.4.0__tar.gz

{maintainability_agent-2.3.0/src/maintainability_agent.egg-info → maintainability_agent-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 2.3.0
+Version: 2.4.0
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -44,10 +44,10 @@ Dynamic: license-file
 **A deterministic, offline maintainability audit whose output is a _bounded
 work order_ for an AI coding agent** — a copy-paste prompt, per finding, that
 says *fix exactly these and refactor nothing else*. Chat-primary; CLI for CI.
-Version **2.3.0**.
+Version **2.4.0**.
 
-**Languages parsed:** Python, Java, C, C++, C#, Fortran (free-form *and*
-fixed-form), and the JS/TS family — each by a scanner written for it, and
+**Languages parsed:** Python, Java, C, C++, C#, Swift, Fortran (free-form
+*and* fixed-form), and the JS/TS family — each by a scanner written for it, and
 measured with that language's own reading of what a branch is.
 [What that means per language](#language-support).
 
@@ -252,9 +252,9 @@ SonarQube, Qlty) rather than replacing them — their SARIF folds in via
 and on an unrecognized language it will quietly under-report rather than fail.**
 Coverage comes from two layers.
 
-Eight languages are parsed as of **1.6.0**: Python (1.0), Java (1.0), C (1.1),
-C++ (1.2), C# (1.3), Fortran (free-form 1.4, fixed-form 1.6), the JS/TS family,
-and HTML. Each has a scanner written for it and a documented list of what it
+Nine languages are parsed as of **2.4.0**: Python (1.0), Java (1.0), C (1.1),
+C++ (1.2), C# (1.3), Fortran (free-form 1.4, fixed-form 1.6), Swift (2.4), the
+JS/TS family, and HTML. Each has a scanner written for it and a documented list of what it
 misses — a language is claimed here only when both exist.
 
 **Built-in scanner (always on, no dependencies)** — reads function/class
@@ -268,6 +268,7 @@ these:
 | C (`.c`, `.h`) | dedicated brace-bounded scanner — functions, `struct`/`enum`/`union` | Bounded; prototypes and macros are not declarations |
 | C++ (`.cpp`, `.hpp`, `.cc`, `.cxx`, `.hh`) | dedicated brace-bounded scanner — functions, class members, namespaces, templates | Bounded; bodyless declarations are not definitions |
 | C# (`.cs`) | dedicated brace-bounded scanner — methods, constructors, `class`/`interface`/`struct`/`record`/`enum` | Bounded; properties are not declarations |
+| Swift (`.swift`) | dedicated brace-bounded scanner — functions, initialisers, subscripts, `class`/`struct`/`enum`/`protocol`/`actor` | Bounded; extension members carry their type, protocol requirements and computed properties are not declarations |
 | Fortran, free-form (`.f90`, `.f95`, `.f03`, `.f08`, `.F90`, `.F95`, `.F03`, `.F08`, `.pf`) | dedicated **keyword**-bounded scanner — modules, subroutines, functions, derived types | Bounded by `end`; measured with Fortran's own branch and nesting reading |
 | Fortran, fixed-form (`.f`, `.for`, `.ftn`, `.F`, `.FOR`, `.FTN`) | the same scanner over card-column source; continuations joined, labelled `DO` loops understood | Bounded by `end` or by the loop's label |
 | JS / TS / JSX / TSX (`.js`, `.jsx`, `.mjs`, `.cjs`, `.ts`, `.tsx`) | brace/paren depth over a masked copy | Bounded by the declaration's own braces |

{maintainability_agent-2.3.0 → maintainability_agent-2.4.0}/README.md

@@ -5,10 +5,10 @@
 **A deterministic, offline maintainability audit whose output is a _bounded
 work order_ for an AI coding agent** — a copy-paste prompt, per finding, that
 says *fix exactly these and refactor nothing else*. Chat-primary; CLI for CI.
-Version **2.3.0**.
+Version **2.4.0**.
 
-**Languages parsed:** Python, Java, C, C++, C#, Fortran (free-form *and*
-fixed-form), and the JS/TS family — each by a scanner written for it, and
+**Languages parsed:** Python, Java, C, C++, C#, Swift, Fortran (free-form
+*and* fixed-form), and the JS/TS family — each by a scanner written for it, and
 measured with that language's own reading of what a branch is.
 [What that means per language](#language-support).
 
@@ -213,9 +213,9 @@ SonarQube, Qlty) rather than replacing them — their SARIF folds in via
 and on an unrecognized language it will quietly under-report rather than fail.**
 Coverage comes from two layers.
 
-Eight languages are parsed as of **1.6.0**: Python (1.0), Java (1.0), C (1.1),
-C++ (1.2), C# (1.3), Fortran (free-form 1.4, fixed-form 1.6), the JS/TS family,
-and HTML. Each has a scanner written for it and a documented list of what it
+Nine languages are parsed as of **2.4.0**: Python (1.0), Java (1.0), C (1.1),
+C++ (1.2), C# (1.3), Fortran (free-form 1.4, fixed-form 1.6), Swift (2.4), the
+JS/TS family, and HTML. Each has a scanner written for it and a documented list of what it
 misses — a language is claimed here only when both exist.
 
 **Built-in scanner (always on, no dependencies)** — reads function/class
@@ -229,6 +229,7 @@ these:
 | C (`.c`, `.h`) | dedicated brace-bounded scanner — functions, `struct`/`enum`/`union` | Bounded; prototypes and macros are not declarations |
 | C++ (`.cpp`, `.hpp`, `.cc`, `.cxx`, `.hh`) | dedicated brace-bounded scanner — functions, class members, namespaces, templates | Bounded; bodyless declarations are not definitions |
 | C# (`.cs`) | dedicated brace-bounded scanner — methods, constructors, `class`/`interface`/`struct`/`record`/`enum` | Bounded; properties are not declarations |
+| Swift (`.swift`) | dedicated brace-bounded scanner — functions, initialisers, subscripts, `class`/`struct`/`enum`/`protocol`/`actor` | Bounded; extension members carry their type, protocol requirements and computed properties are not declarations |
 | Fortran, free-form (`.f90`, `.f95`, `.f03`, `.f08`, `.F90`, `.F95`, `.F03`, `.F08`, `.pf`) | dedicated **keyword**-bounded scanner — modules, subroutines, functions, derived types | Bounded by `end`; measured with Fortran's own branch and nesting reading |
 | Fortran, fixed-form (`.f`, `.for`, `.ftn`, `.F`, `.FOR`, `.FTN`) | the same scanner over card-column source; continuations joined, labelled `DO` loops understood | Bounded by `end` or by the loop's label |
 | JS / TS / JSX / TSX (`.js`, `.jsx`, `.mjs`, `.cjs`, `.ts`, `.tsx`) | brace/paren depth over a masked copy | Bounded by the declaration's own braces |

{maintainability_agent-2.3.0 → maintainability_agent-2.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maintainability-agent"
-version = "2.3.0"
+version = "2.4.0"
 description = "Maintainability gate and AI remediation prompt generator for CI."
 readme = "README.md"
 # 3.11, not 3.10. `_discovery`, `_pillars` and `_runner` all import

{maintainability_agent-2.3.0 → maintainability_agent-2.4.0/src/maintainability_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 2.3.0
+Version: 2.4.0
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -44,10 +44,10 @@ Dynamic: license-file
 **A deterministic, offline maintainability audit whose output is a _bounded
 work order_ for an AI coding agent** — a copy-paste prompt, per finding, that
 says *fix exactly these and refactor nothing else*. Chat-primary; CLI for CI.
-Version **2.3.0**.
+Version **2.4.0**.
 
-**Languages parsed:** Python, Java, C, C++, C#, Fortran (free-form *and*
-fixed-form), and the JS/TS family — each by a scanner written for it, and
+**Languages parsed:** Python, Java, C, C++, C#, Swift, Fortran (free-form
+*and* fixed-form), and the JS/TS family — each by a scanner written for it, and
 measured with that language's own reading of what a branch is.
 [What that means per language](#language-support).
 
@@ -252,9 +252,9 @@ SonarQube, Qlty) rather than replacing them — their SARIF folds in via
 and on an unrecognized language it will quietly under-report rather than fail.**
 Coverage comes from two layers.
 
-Eight languages are parsed as of **1.6.0**: Python (1.0), Java (1.0), C (1.1),
-C++ (1.2), C# (1.3), Fortran (free-form 1.4, fixed-form 1.6), the JS/TS family,
-and HTML. Each has a scanner written for it and a documented list of what it
+Nine languages are parsed as of **2.4.0**: Python (1.0), Java (1.0), C (1.1),
+C++ (1.2), C# (1.3), Fortran (free-form 1.4, fixed-form 1.6), Swift (2.4), the
+JS/TS family, and HTML. Each has a scanner written for it and a documented list of what it
 misses — a language is claimed here only when both exist.
 
 **Built-in scanner (always on, no dependencies)** — reads function/class
@@ -268,6 +268,7 @@ these:
 | C (`.c`, `.h`) | dedicated brace-bounded scanner — functions, `struct`/`enum`/`union` | Bounded; prototypes and macros are not declarations |
 | C++ (`.cpp`, `.hpp`, `.cc`, `.cxx`, `.hh`) | dedicated brace-bounded scanner — functions, class members, namespaces, templates | Bounded; bodyless declarations are not definitions |
 | C# (`.cs`) | dedicated brace-bounded scanner — methods, constructors, `class`/`interface`/`struct`/`record`/`enum` | Bounded; properties are not declarations |
+| Swift (`.swift`) | dedicated brace-bounded scanner — functions, initialisers, subscripts, `class`/`struct`/`enum`/`protocol`/`actor` | Bounded; extension members carry their type, protocol requirements and computed properties are not declarations |
 | Fortran, free-form (`.f90`, `.f95`, `.f03`, `.f08`, `.F90`, `.F95`, `.F03`, `.F08`, `.pf`) | dedicated **keyword**-bounded scanner — modules, subroutines, functions, derived types | Bounded by `end`; measured with Fortran's own branch and nesting reading |
 | Fortran, fixed-form (`.f`, `.for`, `.ftn`, `.F`, `.FOR`, `.FTN`) | the same scanner over card-column source; continuations joined, labelled `DO` loops understood | Bounded by `end` or by the loop's label |
 | JS / TS / JSX / TSX (`.js`, `.jsx`, `.mjs`, `.cjs`, `.ts`, `.tsx`) | brace/paren depth over a masked copy | Bounded by the declaration's own braces |

{maintainability_agent-2.3.0 → maintainability_agent-2.4.0}/src/maintainability_agent.egg-info/SOURCES.txt

@@ -64,6 +64,7 @@ src/maintainability_audit/_ranges_csharp.py
 src/maintainability_audit/_ranges_fortran.py
 src/maintainability_audit/_ranges_java.py
 src/maintainability_audit/_ranges_js.py
+src/maintainability_audit/_ranges_swift.py
 src/maintainability_audit/_ratchet.py
 src/maintainability_audit/_recurrence.py
 src/maintainability_audit/_runner.py
@@ -289,6 +290,7 @@ tests/test_source_index.py
 tests/test_spotbugs_adapter.py
 tests/test_spotbugs_catalog.py
 tests/test_stage8_contract.py
+tests/test_swift_declarations.py
 tests/test_tdd_structure.py
 tests/test_test_execution_class.py
 tests/test_three_presentations.py

{maintainability_agent-2.3.0 → maintainability_agent-2.4.0}/src/maintainability_audit/__init__.py

@@ -1,3 +1,3 @@
 """Maintainability Audit CI."""
 
-__version__ = "2.3.0"
+__version__ = "2.4.0"

{maintainability_agent-2.3.0 → maintainability_agent-2.4.0}/src/maintainability_audit/_cognitive.py

@@ -45,6 +45,14 @@ _NESTING_NODES = (ast.If, ast.For, ast.AsyncFor, ast.While, ast.ExceptHandler, a
 _NESTING_ONLY = (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda)
 
 _CONTROL_RE = re.compile(r"\b(if|for|while|catch|switch|case|elif|except)\b")
+#: Swift adds `guard` — an early exit that is its primary branching idiom —
+#: and `repeat`, its do-while. Without them a function built from guards
+#: reads as having no branches at all, which is the Fortran `do` defect in
+#: another language: six nested loops once scored complexity 1 because the
+#: pattern did not know the keyword.
+_SWIFT_CONTROL_RE = re.compile(
+    r"\b(if|for|while|catch|switch|case|guard|repeat)\b"
+)
 _ELSE_RE = re.compile(r"\belse\b")
 _BOOLEAN_RE = re.compile(r"&&|\|\|")
 
@@ -167,7 +175,7 @@ def fortran_cognitive(lines: list[str]) -> int:
     return score
 
 
-def brace_cognitive(lines: list[str]) -> int:
+def brace_cognitive(lines: list[str], control: re.Pattern[str] | None = None) -> int:
     """Approximate cognitive complexity for a C-family declaration body.
 
     Nesting is read from brace depth relative to the declaration's own
@@ -191,16 +199,25 @@ def brace_cognitive(lines: list[str]) -> int:
         if base is None and opens:
             base = depth
         nesting = max(0, depth - (base if base is not None else 0))
-        score += _score_brace_line(line, nesting)
+        score += _score_brace_line(line, nesting, control or _CONTROL_RE)
         depth = max(0, depth + opens - closes)
     return score
 
 
-def _score_brace_line(line: str, nesting: int) -> int:
+def _score_brace_line(line: str, nesting: int, control: re.Pattern[str]) -> int:
     score = 0
-    for _ in _CONTROL_RE.finditer(line):
+    for _ in control.finditer(line):
         score += 1 + nesting
     if _ELSE_RE.search(line):
         score += 1
     score += len(_BOOLEAN_RE.findall(line))
     return score
+
+
+def swift_cognitive(lines: list[str]) -> int:
+    """`brace_cognitive` reading Swift's control keywords.
+
+    Swift is braced, so nesting is read the same way; only the vocabulary
+    differs, and `guard` is the difference that matters.
+    """
+    return brace_cognitive(lines, _SWIFT_CONTROL_RE)

{maintainability_agent-2.3.0 → maintainability_agent-2.4.0}/src/maintainability_audit/_metrics_types.py

@@ -53,6 +53,20 @@ COMPLEXITY_RE = re.compile(
 )
 
 
+#: Swift's `guard` is an early exit and its primary branching idiom, and
+#: `repeat` is its do-while. Neither is in the C-family pattern, so a
+#: guard-heavy function would read as branchless — the same defect Fortran
+#: had with `do`.
+SWIFT_COMPLEXITY_RE = re.compile(
+    r"\b(if|for|while|case|catch|guard|repeat)\b|&&|\|\||\?\?|\?(?![.?])"
+)
+
+
+def swift_branch_points(line: str) -> int:
+    """Decision points on one line of Swift."""
+    return len(SWIFT_COMPLEXITY_RE.findall(line))
+
+
 def branch_points(line: str) -> int:
     """Decision points on one line, for the C family and Python."""
     return len(COMPLEXITY_RE.findall(line))

maintainability_agent-2.4.0/src/maintainability_audit/_ranges_swift.py

@@ -0,0 +1,215 @@
+"""Declaration ranges for Swift.
+
+Braced, so it reuses `scan_bounded` with C, C++, C# and Java. What is
+different is worth stating, because two of the differences are the whole
+job and one of them is a trap this project has already fallen into once.
+
+**Every declaration is keyword-led.** `func`, `init`, `subscript`, `class`,
+`struct`, `enum`, `protocol`, `actor`, `extension`. That makes recognition
+*easier* than C++, where a bare `name(` is equally a call, a macro and a
+constructor, and where a wrong guess let a macro swallow the next
+declaration's braces. Nothing here has to guess.
+
+**An `extension` adds members to a type declared elsewhere**, often in
+another file. `extension Widget { func draw() }` must report `Widget.draw`
+rather than a second bare `draw` indistinguishable from every other type's,
+which is the same rule C++ applies to an out-of-line `void geo::Widget::draw()`.
+The extension itself is walked into and not graded: it is a container, and
+grading it would count its members twice.
+
+**Computed properties are not declarations**, and this is the C# properties
+problem in Swift spelling. `var area: Double { w * h }` has braces and would
+bound perfectly cleanly; an ordinary Swift type has many, each a line or
+two, none anybody's maintenance burden. Counting them would dilute the
+population every declaration rate divides by. They are excluded by
+construction rather than by a rule: every pattern here requires either a
+parameter list or a type keyword, and a property has neither.
+
+**A protocol requirement has no body** — `func draw()` with nothing after
+it — so it mints nothing, exactly as a C prototype and a pure virtual do.
+A protocol of forty requirements is not forty declarations.
+
+One claim was corrected while writing this. The roadmap said Swift's string
+interpolation "puts braces inside literals, so masking has to run before
+depth counting". It does not: Swift interpolates with `\\(expr)` —
+parentheses, not braces — and string contents are masked before any
+counting regardless. The real reason masking matters here is the ordinary
+one every language shares: a brace inside a string literal, `"{}"`, would
+desync depth.
+"""
+from __future__ import annotations
+
+import re
+
+from ._metrics_types import DeclRange
+from ._ranges_core import _mask_generics, scan_bounded
+
+# Stripped once per line so the patterns stay small: these lead a
+# declaration and say nothing about what it is.
+_SW_MODIFIER_RE = re.compile(
+    r"^\s*(?:(?:public|private|internal|fileprivate|open|static|final"
+    r"|override|mutating|nonmutating|convenience|required|lazy|weak|unowned"
+    r"|indirect|dynamic|optional|async|throws|rethrows|infix|prefix|postfix"
+    r"|package)\s+)*"
+)
+# `class` is both a declaration keyword and a modifier: `class Widget` is a
+# type, `class func make()` is a type-level method. Stripping it with the
+# other modifiers cost every `final class Store` its keyword — the type
+# vanished and only its members were reported. So it is removed only where
+# a declaration keyword follows it, and left alone otherwise.
+_SW_CLASS_MODIFIER_RE = re.compile(r"^class\s+(?=(?:func|var|let|subscript)\b)")
+# `@objc`, `@available(iOS 13, *)`, `@MainActor` — an attribute leads a
+# declaration and is not one. Stripped, so what follows is still read.
+_SW_ATTRIBUTE_RE = re.compile(r"^\s*(?:@[A-Za-z_]\w*(?:\([^)]*\))?\s*)+")
+# `extension Widget`, `extension Widget: Drawable`, `extension Array where …`
+_SW_EXTENSION_RE = re.compile(r"^extension\s+([A-Za-z_][\w.]*)")
+# The container keywords. `protocol` is here so its body is walked into —
+# its requirements are then skipped for having no body, which is what makes
+# a forty-requirement protocol mint nothing.
+_SW_TYPE_RE = re.compile(
+    r"^(?:class|struct|enum|protocol|actor)\s+([A-Za-z_]\w*)"
+)
+# `func name(`, and the three declarations that carry no `func` keyword.
+_SW_FUNC_RE = re.compile(r"^func\s+([A-Za-z_]\w*|[^\s(]+)\s*(?:<[^>]*>)?\s*\(")
+_SW_INIT_RE = re.compile(r"^(init\??|deinit|subscript)\b")
+
+
+def _swift_declaration(text: str) -> tuple[str, str | None] | None:
+    """``(name, kind)`` for a Swift declaration on one masked line.
+
+    ``kind`` is ``None`` for an `extension`: walk in, grade nothing.
+    """
+    line = _SW_ATTRIBUTE_RE.sub("", _mask_generics(text), count=1)
+    body = line[_SW_MODIFIER_RE.match(line).end():]
+    body = _SW_CLASS_MODIFIER_RE.sub("", body, count=1)
+    body = body[_SW_MODIFIER_RE.match(body).end():]
+
+    extension = _SW_EXTENSION_RE.match(body)
+    if extension is not None:
+        # The extended type's name, carried so its members can be reported
+        # as `Widget.draw` rather than as a second bare `draw`.
+        return extension.group(1), None
+
+    type_match = _SW_TYPE_RE.match(body)
+    if type_match is not None:
+        return type_match.group(1), "class"
+
+    func = _SW_FUNC_RE.match(body)
+    if func is not None:
+        return (func.group(1), "function") if _opens_a_body(body) else None
+
+    special = _SW_INIT_RE.match(body)
+    if special is not None:
+        return (special.group(1).rstrip("?"), "function") if _opens_a_body(body) else None
+
+    # Anything else — `var`, `let`, a computed property, a `case` — is not
+    # a declaration this tool measures. Falling through rather than listing
+    # exclusions keeps the rule "a declaration is keyword-led and named".
+    return None
+
+
+def _opens_a_body(body: str) -> bool:
+    """Whether this line starts a body, or is a requirement with none.
+
+    Swift has no statement terminator, so the shared `skip_bare` check
+    cannot work here: it looks for a signature that closes without opening
+    a brace, and in C or C# that is a `;`. A Swift protocol requirement
+    simply ends at the newline, so the end-finder walks on and adopts the
+    *next* declaration's brace — which is how `func describe() -> String`
+    inside a protocol came back measured as two lines of body.
+
+    The rule that replaces it: a signature whose parentheses balance on
+    this line and which then shows no `{` has no body. A wrapped signature
+    leaves its parentheses unbalanced, so it is still read as a
+    declaration and its body is found normally:
+
+        func draw(          <- unbalanced here, kept
+            into: Canvas
+        ) throws {
+
+    A body written Allman — `func f()` with `{` alone on the next line —
+    is missed and mints nothing. That is legal Swift and vanishingly rare
+    in it, and missing one declaration is the cheaper error than counting
+    every protocol requirement in the tree.
+    """
+    if "{" in body:
+        return True
+    return body.count("(") != body.count(")")
+
+
+def swift_declaration_ranges(lines: list[str]) -> tuple[list[DeclRange], list[str]]:
+    """Functions, initialisers and types, each bounded by its own body.
+
+    Types and extensions are descended into, because that is where members
+    live; a function body is stepped over, so nothing inside one is read as
+    a declaration.
+
+    Bodyless declarations mint nothing, as in C, C++ and C#: a protocol
+    requirement is a signature with nothing to measure, and grading it
+    would put one-line members into the population every rate divides by.
+
+    Everything it misses, it misses in the safe direction:
+
+    - **Computed properties** (`var area: Double { w * h }`) are not
+      declarations, the same call C# makes for the same reason.
+    - **A closure assigned to a property** is a body without a declaration
+      keyword and is not counted.
+    - **Declarations produced by a macro** (`@freestanding`, `#`-macros)
+      are not in the source and are not seen, as in C and C++.
+    - **Conditional compilation is not evaluated**, so a declaration in a
+      disabled `#if` arm still counts.
+    """
+    ranges, masked = scan_bounded(
+        lines, _swift_declaration, descend=("class",), skip_preprocessor=True
+    )
+    return _qualify_extension_members(ranges, masked), masked
+
+
+def _extension_spans(masked: list[str]) -> list[tuple[int, int, str]]:
+    """Every `extension X { … }` as (start, end, extended type)."""
+    def only_extensions(text: str) -> tuple[str, str | None] | None:
+        found = _swift_declaration(text)
+        if found is None:
+            return None
+        name, kind = found
+        return (name, "class") if kind is None else None
+
+    spans, _ = scan_bounded(
+        masked, only_extensions, descend=(), skip_preprocessor=True
+    )
+    return [(item.start, item.end, item.name) for item in spans]
+
+
+def _qualify_extension_members(
+    ranges: list[DeclRange], masked: list[str]
+) -> list[DeclRange]:
+    """Report an extension's members under the type they extend.
+
+    `extension Widget { func draw() }` becomes `Widget.draw`. Without it
+    the report carries a bare `draw` indistinguishable from every other
+    type's `draw`, and a reader given "shorten `draw`" cannot find which
+    one — the same reason C++ keeps the qualification on an out-of-line
+    `void geo::Widget::draw()`, except that in Swift the source does not
+    write it and the scanner has to carry it.
+
+    A member already qualified is left alone, and a nested type inside an
+    extension keeps its own name: the prefix answers "which type does this
+    belong to", which a named type already answers for itself.
+    """
+    spans = _extension_spans(masked)
+    if not spans:
+        return ranges
+    qualified = []
+    for item in ranges:
+        owner = next(
+            (name for start, end, name in spans
+             if start < item.start <= end and item.kind == "function"),
+            None,
+        )
+        if owner is None or "." in item.name:
+            qualified.append(item)
+            continue
+        qualified.append(
+            DeclRange(item.start, item.end, f"{owner}.{item.name}", item.kind)
+        )
+    return qualified

{maintainability_agent-2.3.0 → maintainability_agent-2.4.0}/src/maintainability_audit/config.py

@@ -11,7 +11,7 @@ from ._config_defaults import DEFAULT_CONFIG, DEFAULT_IDIOM_GROUPS
 # still the door every caller comes through.
 __all__ = ["DEFAULT_CONFIG", "DEFAULT_IDIOM_GROUPS", "PROJECT_URL", "VERSION"]
 
-VERSION = "2.3.0"
+VERSION = "2.4.0"
 
 PROJECT_URL = "https://github.com/marshallguillory86/maintainability-agent"
 

{maintainability_agent-2.3.0 → maintainability_agent-2.4.0}/src/maintainability_audit/declarations.py

@@ -14,7 +14,12 @@ import ast
 import os
 from pathlib import Path
 
-from ._cognitive import brace_cognitive, fortran_cognitive, python_cognitive
+from ._cognitive import (
+    brace_cognitive,
+    fortran_cognitive,
+    python_cognitive,
+    swift_cognitive,
+)
 from ._finding_match import normalized_body_digest
 from ._metrics_types import (
     FUNC_PATTERNS,
@@ -22,6 +27,7 @@ from ._metrics_types import (
     FunctionMetric,
     branch_points,
     fortran_branch_points,
+    swift_branch_points,
 )
 from ._ranges_c import c_declaration_ranges
 from ._ranges_core import indent_bounded_end
@@ -33,6 +39,7 @@ from ._ranges_fortran import (
 )
 from ._ranges_java import java_declaration_ranges
 from ._ranges_js import js_declaration_ranges
+from ._ranges_swift import swift_declaration_ranges
 
 # One set per language, then one table binding each to its scanner.
 #
@@ -60,6 +67,7 @@ CPP_SUFFIXES = {".cpp", ".hpp", ".cc", ".cxx", ".hh"}
 # generics — and still its own module: namespaces in two forms,
 # `record`, and properties, which are deliberately not declarations.
 CSHARP_SUFFIXES = {".cs"}
+SWIFT_SUFFIXES = {".swift"}
 # Fortran (1.4.0), free-form only. `.F90` is the same language with the
 # C preprocessor run over it, and `.pf` is pFUnit test source — both are
 # free-form and both are read. Fixed-form (`.f`, `.for`, `.ftn`) is
@@ -97,6 +105,7 @@ SCANNERS: tuple[tuple[set[str], object], ...] = (
     (C_SUFFIXES, c_declaration_ranges),
     (CPP_SUFFIXES, cpp_declaration_ranges),
     (CSHARP_SUFFIXES, csharp_declaration_ranges),
+    (SWIFT_SUFFIXES, swift_declaration_ranges),
     (FORTRAN_SUFFIXES, fortran_declaration_ranges),
     (FIXED_FORM_SUFFIXES, fixed_form_declaration_ranges),
     (BRACE_SUFFIXES, js_declaration_ranges),
@@ -115,6 +124,10 @@ SCANNERS: tuple[tuple[set[str], object], ...] = (
 # was read from braces, which Fortran does not have, so four flat
 # `if`s and four deeply nested ones both scored 8.
 METRICS: tuple[tuple[set[str], object, object], ...] = (
+    # Swift is braced and reads its nesting the C-family way; only the
+    # keyword vocabulary differs, and `guard` is the difference that
+    # matters — without it a guard-heavy function reads as branchless.
+    (SWIFT_SUFFIXES, swift_branch_points, swift_cognitive),
     (FORTRAN_SUFFIXES, fortran_branch_points, fortran_cognitive),
     (FIXED_FORM_SUFFIXES, fortran_branch_points, fortran_cognitive),
 )
@@ -131,7 +144,7 @@ def metrics_for(suffix: str) -> tuple[object, object]:
 # Every extension we attempt declaration detection on at all.
 DECLARATION_SUFFIXES = (
     PYTHON_SUFFIXES | JAVA_SUFFIXES | C_SUFFIXES | CPP_SUFFIXES
-    | CSHARP_SUFFIXES | FORTRAN_SUFFIXES | FIXED_FORM_SUFFIXES
+    | CSHARP_SUFFIXES | SWIFT_SUFFIXES | FORTRAN_SUFFIXES | FIXED_FORM_SUFFIXES
     | BRACE_SUFFIXES
 )