@haaaiawd/anws 2.2.6 → 2.4.0

package/templates_en/.agents/skills/nexus-mapper/scripts/git_detective.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""
+git_detective.py — Git history hotspot and logical file coupling analyzer
+
+Purpose: Analyze Git repository change history to identify hotspot files and logical file coupling pairs
+Usage: python git_detective.py <repo_path> [--days 90] [--top-n 20]
+
+Methodology: Adam Tornhill "Your Code as a Crime Scene"
+"""
+
+import sys
+import json
+import argparse
+import subprocess
+from pathlib import Path
+from collections import Counter
+from itertools import combinations
+
+
+def run_git(repo_path: Path, args: list[str]) -> str:
+    """Run git command and return stdout. Raise RuntimeError on failure."""
+    cmd = ['git', '-C', str(repo_path)] + args
+    result = subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+        encoding='utf-8',
+        errors='replace',
+    )
+    if result.returncode != 0:
+        raise RuntimeError(
+            f"git command failed: {' '.join(cmd)}\n{result.stderr.strip()}"
+        )
+    return result.stdout
+
+
+def get_commit_file_changes(repo_path: Path, days: int) -> list[list[str]]:
+    """
+    Return files changed in each commit within the analysis window.
+
+    Output format: [[file1, file2], [file3], ...]
+    Use COMMIT:<hash> prefix format for stable parsing.
+    """
+    output = run_git(repo_path, [
+        'log',
+        f'--since={days} days ago',
+        '--pretty=format:COMMIT:%H',
+        '--name-only',
+    ])
+
+    commits: list[list[str]] = []
+    current_files: list[str] = []
+
+    for line in output.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        if line.startswith('COMMIT:'):
+            if current_files:
+                commits.append(current_files)
+                current_files = []
+        else:
+            current_files.append(line)
+
+    if current_files:
+        commits.append(current_files)
+
+    return commits
+
+
+def compute_hotspots(commits: list[list[str]], top_n: int) -> list[dict]:
+    """
+    Compute file change frequency hotspots, sorted by changes descending.
+
+    Risk thresholds (Adam Tornhill methodology):
+      low:    changes < 5
+      medium: 5 <= changes < 15
+      high:   changes >= 15
+    """
+    counter: Counter[str] = Counter()
+    for files in commits:
+        counter.update(files)
+
+    results = []
+    for path, changes in counter.most_common(top_n):
+        if changes < 5:
+            risk = 'low'
+        elif changes < 15:
+            risk = 'medium'
+        else:
+            risk = 'high'
+        results.append({'path': path, 'changes': changes, 'risk': risk})
+
+    return results
+
+
+def compute_coupling_pairs(commits: list[list[str]], top_n: int) -> list[dict]:
+    """
+    Compute logical file coupling pairs: files changed together in one commit.
+
+    coupling_score = co_changes / min(total_changes_A, total_changes_B)
+    Filter: pairs with co_changes < 2 are not output (too noisy).
+    """
+    pair_counter: Counter[tuple[str, str]] = Counter()
+    file_counter: Counter[str] = Counter()
+
+    for files in commits:
+        unique_files = list(dict.fromkeys(files))  # De-duplicate while preserving order
+        file_counter.update(unique_files)
+        if len(unique_files) >= 2:
+            for a, b in combinations(sorted(unique_files), 2):
+                pair_counter[(a, b)] += 1
+
+    results = []
+    for (file_a, file_b), co_changes in pair_counter.most_common():
+        if co_changes < 2:
+            continue
+        min_changes = min(file_counter[file_a], file_counter[file_b])
+        score = round(co_changes / min_changes, 3) if min_changes > 0 else 0.0
+        results.append({
+            'file_a': file_a,
+            'file_b': file_b,
+            'co_changes': co_changes,
+            'coupling_score': score,
+        })
+        if len(results) >= top_n:
+            break
+
+    return results
+
+
+def get_repo_stats(repo_path: Path, days: int) -> dict:
+    """Get commit and author counts within the analysis window."""
+    try:
+        commit_out = run_git(repo_path, [
+            'log', f'--since={days} days ago', '--pretty=format:%H',
+        ])
+        total_commits = sum(1 for line in commit_out.splitlines() if line.strip())
+
+        author_out = run_git(repo_path, [
+            'log', f'--since={days} days ago', '--pretty=format:%ae',
+        ])
+        total_authors = len({line.strip() for line in author_out.splitlines() if line.strip()})
+    except RuntimeError:
+        total_commits = 0
+        total_authors = 0
+
+    return {'total_commits': total_commits, 'total_authors': total_authors}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description='Analyze Git history for hotspots and coupling'
+    )
+    parser.add_argument('repo_path', help='Target repository path')
+    parser.add_argument('--days', type=int, default=90,
+                        help='Analysis window in days (default: 90)')
+    parser.add_argument('--top-n', type=int, default=20,
+                        help='Max items in hotspots/coupling output (default: 20)')
+    args = parser.parse_args()
+
+    repo_path = Path(args.repo_path).resolve()
+    if not repo_path.exists():
+        sys.stderr.write(f"[ERROR] repo_path not found: {repo_path}\n")
+        sys.exit(1)
+    if not (repo_path / '.git').exists():
+        sys.stderr.write(
+            f"[ERROR] .git not found in {repo_path}. "
+            "This tool requires a git repository.\n"
+        )
+        sys.exit(1)
+
+    try:
+        commits = get_commit_file_changes(repo_path, args.days)
+    except RuntimeError as e:
+        sys.stderr.write(f"[ERROR] Git command failed: {e}\n")
+        sys.exit(1)
+
+    stats = get_repo_stats(repo_path, args.days)
+    hotspots = compute_hotspots(commits, args.top_n)
+    coupling_pairs = compute_coupling_pairs(commits, args.top_n)
+
+    result = {
+        'analysis_period_days': args.days,
+        'stats': stats,
+        'hotspots': hotspots,
+        'coupling_pairs': coupling_pairs,
+    }
+
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == '__main__':
+    main()

package/templates_en/.agents/skills/nexus-mapper/scripts/languages.json

@@ -0,0 +1,127 @@
+{
+  "extensions": {
+    ".py": "python",
+    ".pyw": "python",
+    ".pyi": "python",
+    ".js": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".jsx": "javascript",
+    ".ts": "typescript",
+    ".mts": "typescript",
+    ".tsx": "tsx",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "bash",
+    ".java": "java",
+    ".go": "go",
+    ".rs": "rust",
+    ".cs": "csharp",
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".hpp": "cpp",
+    ".hxx": "cpp",
+    ".kt": "kotlin",
+    ".kts": "kotlin",
+    ".rb": "ruby",
+    ".php": "php",
+    ".lua": "lua",
+    ".swift": "swift",
+    ".scala": "scala",
+    ".sc": "scala",
+    ".ex": "elixir",
+    ".exs": "elixir",
+    ".gd": "gdscript",
+    ".dart": "dart",
+    ".hs": "haskell",
+    ".clj": "clojure",
+    ".cljs": "clojure",
+    ".cljc": "clojure",
+    ".sql": "sql",
+    ".proto": "proto",
+    ".sol": "solidity",
+    ".vue": "vue",
+    ".svelte": "svelte",
+    ".r": "r",
+    ".pl": "perl",
+    ".pm": "perl"
+  },
+  "queries": {
+    "python": {
+      "struct": "(class_definition name: (identifier) @class.name) @class.def\n(function_definition name: (identifier) @func.name) @func.def",
+      "imports": "(import_statement name: (dotted_name) @mod)\n(import_from_statement module_name: (dotted_name) @mod)"
+    },
+    "javascript": {
+      "struct": "(class_declaration name: (identifier) @class.name) @class.def\n(function_declaration name: (identifier) @func.name) @func.def\n(method_definition name: (property_identifier) @func.name) @func.def",
+      "imports": "(import_statement source: (string (string_fragment) @mod))"
+    },
+    "typescript": {
+      "struct": "(class_declaration name: (type_identifier) @class.name) @class.def\n(function_declaration name: (identifier) @func.name) @func.def\n(method_definition name: (property_identifier) @func.name) @func.def",
+      "imports": "(import_statement source: (string (string_fragment) @mod))"
+    },
+    "tsx": {
+      "struct": "(class_declaration name: (type_identifier) @class.name) @class.def\n(function_declaration name: (identifier) @func.name) @func.def\n(method_definition name: (property_identifier) @func.name) @func.def",
+      "imports": "(import_statement source: (string (string_fragment) @mod))"
+    },
+    "java": {
+      "struct": "(class_declaration name: (identifier) @class.name) @class.def\n(method_declaration name: (identifier) @func.name) @func.def\n(interface_declaration name: (identifier) @class.name) @class.def",
+      "imports": "(import_declaration (scoped_identifier) @mod)"
+    },
+    "go": {
+      "struct": "(type_declaration (type_spec name: (type_identifier) @class.name)) @class.def\n(function_declaration name: (identifier) @func.name) @func.def\n(method_declaration name: (field_identifier) @func.name) @func.def",
+      "imports": "(import_spec path: (interpreted_string_literal) @mod)"
+    },
+    "rust": {
+      "struct": "(struct_item name: (type_identifier) @class.name) @class.def\n(enum_item name: (type_identifier) @class.name) @class.def\n(function_item name: (identifier) @func.name) @func.def",
+      "imports": "(use_declaration argument: (scoped_identifier) @mod)\n(use_declaration argument: (identifier) @mod)"
+    },
+    "csharp": {
+      "struct": "(class_declaration name: (identifier) @class.name) @class.def\n(method_declaration name: (identifier) @func.name) @func.def\n(interface_declaration name: (identifier) @class.name) @class.def",
+      "imports": "(using_directive (qualified_name) @mod)\n(using_directive (identifier) @mod)"
+    },
+    "cpp": {
+      "struct": "(class_specifier name: (type_identifier) @class.name) @class.def\n(function_definition\n    declarator: (function_declarator\n        declarator: (identifier) @func.name)) @func.def",
+      "imports": "(preproc_include path: (system_lib_string) @mod)\n(preproc_include path: (string_literal) @mod)"
+    },
+    "c": {
+      "struct": "(struct_specifier name: (type_identifier) @class.name) @class.def\n(function_definition\n    declarator: (function_declarator\n        declarator: (identifier) @func.name)) @func.def",
+      "imports": "(preproc_include path: (system_lib_string) @mod)\n(preproc_include path: (string_literal) @mod)"
+    },
+    "kotlin": {
+      "struct": "(class_declaration (type_identifier) @class.name) @class.def\n(function_declaration (simple_identifier) @func.name) @func.def",
+      "imports": "(import_header (identifier) @mod)"
+    },
+    "ruby": {
+      "struct": "(class name: (constant) @class.name) @class.def\n(method name: (identifier) @func.name) @func.def",
+      "imports": ""
+    },
+    "swift": {
+      "struct": "(class_declaration name: (type_identifier) @class.name) @class.def\n(function_declaration name: (simple_identifier) @func.name) @func.def",
+      "imports": "(import_declaration (identifier) @mod)"
+    },
+    "scala": {
+      "struct": "(class_definition name: (identifier) @class.name) @class.def\n(function_definition name: (identifier) @func.name) @func.def",
+      "imports": "(import_declaration importees: (import_selectors selector: (import_selector name: (identifier) @mod)))"
+    },
+    "lua": {
+      "struct": "(function_declaration name: (identifier) @func.name) @func.def",
+      "imports": ""
+    },
+    "php": {
+      "struct": "(class_declaration name: (name) @class.name) @class.def\n(method_declaration name: (name) @func.name) @func.def\n(function_definition name: (name) @func.name) @func.def",
+      "imports": "(namespace_use_declaration (namespace_use_clause (qualified_name (name) @mod)))"
+    },
+    "elixir": {
+      "struct": "(call target: (identifier) @_keyword\n      arguments: (arguments (alias) @class.name)\n      (#match? @_keyword \"^(defmodule|defprotocol)$\")) @class.def\n(call target: (identifier) @_keyword\n      arguments: (arguments (identifier) @func.name)\n      (#match? @_keyword \"^(def|defp)$\")) @func.def",
+      "imports": ""
+    },
+    "gdscript": {
+      "struct": "(class_name_statement name: (name) @class.name) @class.def\n(function_definition name: (name) @func.name) @func.def",
+      "imports": ""
+    }
+  },
+  "unsupported_extensions": {}
+}