@asm-agent/coding-agent 0.8.4 → 0.8.6

package/skills/solid-source-modularity/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: solid-source-modularity
+always-apply: true
+description: Enforce SOLID design, cohesive source modules, staged refactoring, and source-file size limits. MUST be used whenever the agent creates, modifies, reviews, or refactors authored source code in any project.
+---
+
+# SOLID Source Modularity
+
+Apply this policy to all authored source-code work.
+
+## Required policy
+
+- Follow SOLID and give each module one cohesive responsibility.
+- Separate orchestration, domain logic, I/O, rendering, and platform adapters.
+- Prefer small contracts and explicit dependencies. Avoid generic catch-all modules.
+- Target at most 300 physical lines per authored source file.
+- Allow 301–500 lines only as a documented exception when splitting would reduce
+  cohesion or create artificial coupling.
+- More than 500 lines is always a violation and requires modularization.
+- Generated files and lockfiles are exempt.
+
+## Required refactoring sequence
+
+1. Inventory files and responsibilities.
+2. Define boundaries, contracts, and dependency direction.
+3. Create all destination modules before replacing the original implementation.
+4. Validate new modules in isolation when possible.
+5. Replace the original code with imports, delegation, and orchestration only
+   after the destination modules exist.
+6. Organize tests by responsibility and run the project's required checks.
+7. Run the source audit and document each 301–500-line exception.
+
+Keep structural refactoring separate from new behavior. Preserve behavior during
+structural changes. Never create a commit without explicit user authorization.
+
+## Audit
+
+Call the prepared Python skill from the repository root:
+
+```python
+report = await solid_source_modularity(
+    root=".",
+    extensions=[".ts", ".tsx", ".py"],
+)
+```
+
+`report` separates `compliant`, `exceptions`, `violations`, and `skipped` files.
+Do not raise `target_lines` above 300 or `hard_limit` above 500.

package/skills/solid-source-modularity/pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "solid-source-modularity"
+version = "0.1.0"
+description = "Audit authored source files against ASM Agent modularity limits."
+requires-python = ">=3.10"
+dependencies = []
+
+[project.scripts]
+solid_source_modularity = "rlm.skill:cli"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/solid_source_modularity"]

package/skills/solid-source-modularity/src/solid_source_modularity/__init__.py

@@ -0,0 +1,154 @@
+"""Audit authored source files against ASM Agent modularity limits."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Iterable
+
+_DEFAULT_EXTENSIONS = (
+    ".c",
+    ".cpp",
+    ".cs",
+    ".go",
+    ".h",
+    ".hpp",
+    ".java",
+    ".js",
+    ".jsx",
+    ".py",
+    ".rs",
+    ".ts",
+    ".tsx",
+)
+_DEFAULT_EXCLUDED_NAMES = (
+    "Cargo.lock",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+)
+_EXCLUDED_DIRECTORIES = frozenset(
+    {
+        ".git",
+        ".mypy_cache",
+        ".next",
+        ".pytest_cache",
+        ".tox",
+        ".venv",
+        "build",
+        "coverage",
+        "dist",
+        "node_modules",
+        "target",
+        "vendor",
+    }
+)
+_GENERATED_NAME_MARKERS = (".generated.", ".gen.")
+
+
+def _normalize_extensions(extensions: Iterable[str]) -> frozenset[str]:
+    normalized = set()
+    for extension in extensions:
+        if not isinstance(extension, str) or not extension.strip():
+            raise TypeError("extensions must contain non-empty strings")
+        value = extension.strip().lower()
+        normalized.add(value if value.startswith(".") else f".{value}")
+    if not normalized:
+        raise ValueError("extensions must not be empty")
+    return frozenset(normalized)
+
+
+def _validate_limits(target_lines: int, hard_limit: int) -> None:
+    if not isinstance(target_lines, int) or isinstance(target_lines, bool):
+        raise TypeError("target_lines must be an integer")
+    if not isinstance(hard_limit, int) or isinstance(hard_limit, bool):
+        raise TypeError("hard_limit must be an integer")
+    if target_lines <= 0 or target_lines > 300:
+        raise ValueError("target_lines must be between 1 and 300")
+    if hard_limit <= target_lines or hard_limit > 500:
+        raise ValueError("hard_limit must be greater than target_lines and at most 500")
+
+
+def _is_generated_name(name: str) -> bool:
+    lowered = name.lower()
+    return any(marker in lowered for marker in _GENERATED_NAME_MARKERS)
+
+
+def _entry(path: Path, root: Path, lines: int) -> dict[str, object]:
+    return {"path": path.relative_to(root).as_posix(), "lines": lines}
+
+
+async def audit_source_files(
+    root: str,
+    extensions: list[str] | None = None,
+    target_lines: int = 300,
+    hard_limit: int = 500,
+    excluded_names: list[str] | None = None,
+) -> dict[str, object]:
+    """Audit authored source files and classify their physical line counts."""
+    _validate_limits(target_lines, hard_limit)
+    root_path = Path(root).expanduser().resolve()
+    if not root_path.is_dir():
+        raise NotADirectoryError(f"{root} is not an existing directory")
+
+    included_extensions = _normalize_extensions(extensions or list(_DEFAULT_EXTENSIONS))
+    excluded = set(excluded_names or list(_DEFAULT_EXCLUDED_NAMES))
+    compliant: list[dict[str, object]] = []
+    exceptions: list[dict[str, object]] = []
+    violations: list[dict[str, object]] = []
+    skipped: list[dict[str, str]] = []
+
+    for current_root, directories, filenames in os.walk(root_path):
+        directories[:] = sorted(name for name in directories if name not in _EXCLUDED_DIRECTORIES)
+        current_path = Path(current_root)
+        for filename in sorted(filenames):
+            path = current_path / filename
+            if path.suffix.lower() not in included_extensions:
+                continue
+            relative = path.relative_to(root_path).as_posix()
+            if filename in excluded or _is_generated_name(filename):
+                skipped.append({"path": relative, "reason": "excluded or generated"})
+                continue
+            try:
+                line_count = len(path.read_text(encoding="utf-8").splitlines())
+            except (OSError, UnicodeError) as error:
+                skipped.append({"path": relative, "reason": str(error)})
+                continue
+            entry = _entry(path, root_path, line_count)
+            if line_count <= target_lines:
+                compliant.append(entry)
+            elif line_count <= hard_limit:
+                exceptions.append(entry)
+            else:
+                violations.append(entry)
+
+    return {
+        "root": str(root_path),
+        "target_lines": target_lines,
+        "hard_limit": hard_limit,
+        "scanned_files": len(compliant) + len(exceptions) + len(violations),
+        "compliant": compliant,
+        "exceptions": exceptions,
+        "violations": violations,
+        "skipped": skipped,
+    }
+
+
+async def run(
+    root: str,
+    extensions: list[str] | None = None,
+    target_lines: int = 300,
+    hard_limit: int = 500,
+    excluded_names: list[str] | None = None,
+) -> dict[str, object]:
+    """Audit source files under ``root`` against the 300/500-line policy."""
+    return await audit_source_files(
+        root,
+        extensions=extensions,
+        target_lines=target_lines,
+        hard_limit=hard_limit,
+        excluded_names=excluded_names,
+    )
+
+
+__all__ = ["audit_source_files", "run"]