@pipemd-core/pipemd 1.0.0

package/scripts/Python/architecture/arch.sh

@@ -0,0 +1,220 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Architecture map — Python module dependencies
+source "$(dirname "$0")/../lib/limit.sh"
+
+: "${MAX_ARCH:=100}"
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+NORMALIZE="$SCRIPT_DIR/normalize.sh"
+[ -f "$NORMALIZE" ] || NORMALIZE="$SCRIPT_DIR/../../Shared/architecture/normalize.sh"
+
+if ! command -v python3 &>/dev/null; then
+  echo "python3 is required for Python architecture extraction"
+  exit 0
+fi
+
+SRC_DIR=""
+for dir in src app lib .; do
+  if [ -d "$dir" ]; then
+    has_py=$(find "$dir" -maxdepth 3 -name "*.py" -not -path "*/__pycache__/*" -print -quit 2>/dev/null)
+    if [ -n "$has_py" ]; then
+      SRC_DIR="$dir"
+      break
+    fi
+  fi
+done
+[ -z "$SRC_DIR" ] && { echo "No source directory found"; exit 0; }
+SRC_DIR="$(cd "$SRC_DIR" && pwd)"
+
+SRC_DIR_ABS="$SRC_DIR" python3 -c "
+import os, re, ast, sys
+from collections import defaultdict
+
+SRC_DIR = os.environ.get('SRC_DIR_ABS', 'src')
+MAX_MODULES = 40
+
+SKIP_DIRS = {'__pycache__', 'venv', '.venv', '.mypy_cache', '.tox', 'dist', 'build',
+             '.eggs', '.pytest_cache', 'node_modules', '.git', '.pipemd', 'migrations'}
+
+def module_name(rel_path):
+    rel_path = rel_path.replace(os.sep, '/')
+    parts = rel_path.split('/')
+    filename = os.path.splitext(parts[-1])[0] if parts else ''
+    dirpath = parts[:-1] if len(parts) > 1 else []
+
+    if filename == '__init__':
+        return '/'.join(dirpath) if dirpath else None
+    if not dirpath:
+        return filename
+    return '/'.join(dirpath) + '/' + filename
+
+def collect_pyproject_deps():
+    deps = set()
+    for pkgfile in ('requirements.txt', 'pyproject.toml', 'Pipfile', 'setup.py', 'setup.cfg'):
+        try:
+            with open(pkgfile, 'r', errors='replace') as f:
+                content = f.read()
+        except Exception:
+            continue
+
+        if pkgfile == 'requirements.txt':
+            for line in content.split('\n'):
+                line = line.strip()
+                if not line or line.startswith('#') or line.startswith('-'):
+                    continue
+                name = re.split(r'[<>=!;\[]', line)[0].strip().lower()
+                if name:
+                    deps.add(name)
+
+        elif pkgfile == 'pyproject.toml':
+            m = re.search(r'dependencies\s*=\s*\[(.*?)\]', content, re.DOTALL)
+            if m:
+                for item in re.findall(r'[\"\'](.*?)[\"\']', m.group(1)):
+                    name = re.split(r'[<>=!;\[]', item)[0].strip().lower()
+                    if name:
+                        deps.add(name)
+            m2 = re.search(r'\[project\.dependencies\](.*?)(?=\[|\Z)', content, re.DOTALL)
+            if m2:
+                for line in m2.group(1).strip().split('\n'):
+                    line = line.strip()
+                    if line and line[0].isalpha():
+                        name = re.split(r'[<>=!;\[]', line)[0].strip().lower()
+                        if name:
+                            deps.add(name)
+
+        elif pkgfile == 'Pipfile':
+            in_packages = False
+            for line in content.split('\n'):
+                stripped = line.strip()
+                if stripped == '[packages]':
+                    in_packages = True
+                    continue
+                if stripped.startswith('['):
+                    in_packages = False
+                    continue
+                if in_packages and stripped and stripped[0].isalpha():
+                    name = re.split(r'[=<>#\s]', stripped)[0].strip().lower()
+                    if name:
+                        deps.add(name)
+
+        elif pkgfile in ('setup.py', 'setup.cfg'):
+            for m_pat in re.finditer(r'(?:install_requires|dependencies)\s*=\s*\[(.*?)\]', content, re.DOTALL):
+                for item in re.findall(r'[\"\'](.*?)[\"\']', m_pat.group(1)):
+                    name = re.split(r'[<>=!;\[]', item)[0].strip().lower()
+                    if name:
+                        deps.add(name)
+
+    return deps
+
+ext_deps = collect_pyproject_deps()
+
+files = []
+for root, dirs, fnames in os.walk(SRC_DIR):
+    dirs[:] = [d for d in sorted(dirs) if d not in SKIP_DIRS and not d.startswith('.')]
+    for fn in sorted(fnames):
+        if fn.endswith('.py') and not fn.startswith('.'):
+            files.append(os.path.join(root, fn))
+    if len(files) >= 300:
+        files = files[:300]
+        break
+
+if not files:
+    sys.exit(0)
+
+module_set = set()
+for fpath in files:
+    rel = os.path.relpath(fpath, SRC_DIR).replace(os.sep, '/')
+    mod = module_name(rel)
+    if mod:
+        module_set.add(mod)
+
+if len(module_set) > MAX_MODULES:
+    module_set = set()
+    for fpath in files:
+        rel = os.path.relpath(fpath, SRC_DIR).replace(os.sep, '/')
+        mod = module_name(rel)
+        if mod:
+            parts = mod.split('/')
+            module_set.add(parts[0] if len(parts) > 1 else parts[0])
+
+def top_pkg(name):
+    return name.split('.')[0].split('/')[0].lower()
+
+def resolve_internal(import_path):
+    check = import_path.replace('.', '/')
+    for mod in module_set:
+        if mod == check or mod.startswith(check + '/'):
+            return check.split('/')[0]
+    check_dir = os.path.join(SRC_DIR, check)
+    if os.path.isdir(check_dir):
+        return import_path.split('.')[0].split('/')[0].lower()
+    check_file = os.path.join(SRC_DIR, check + '.py')
+    if os.path.isfile(check_file):
+        return import_path.split('.')[0].split('/')[0].lower()
+    return None
+
+edges = set()
+
+for fpath in files:
+    rel = os.path.relpath(fpath, SRC_DIR).replace(os.sep, '/')
+    src_mod = module_name(rel)
+    if not src_mod or src_mod not in module_set:
+        continue
+    src_short = src_mod.split('/')[0] if '/' in src_mod else src_mod
+
+    try:
+        with open(fpath, 'r', errors='replace') as f:
+            content = f.read()
+    except Exception:
+        continue
+
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        for line in content.split('\n'):
+            line = line.strip()
+            if line.startswith('import ') or line.startswith('from '):
+                pass
+        continue
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                pkg = alias.name.split('.')[0].lower()
+                if pkg in {m.split('/')[0].split('.')[0] for m in module_set if '/' not in m and '.' not in m} or \
+                   pkg in {m.split('/')[0] for m in module_set if '/' in m}:
+                    internal = resolve_internal(alias.name)
+                    if internal and internal != src_short:
+                        edges.add((src_short, internal))
+                elif pkg in ext_deps:
+                    edges.add((src_short, 'ext:' + pkg))
+
+        if isinstance(node, ast.ImportFrom):
+            if node.level and node.level > 0:
+                file_dir = os.path.dirname(rel) if '/' in rel else ''
+                parts = file_dir.split('/') if file_dir else []
+                go_up = node.level - 1
+                if go_up > len(parts):
+                    go_up = len(parts)
+                base_parts = parts[:len(parts) - go_up] if go_up > 0 else list(parts)
+                if node.module:
+                    base_parts = base_parts + node.module.split('.')
+                target = '/'.join(base_parts) if base_parts else file_dir
+                if target:
+                    target_short = target.split('/')[0] if '/' in target else target
+                    if target_short and target_short != src_short:
+                        edges.add((src_short, target_short))
+            elif node.module:
+                top = node.module.split('.')[0].lower()
+                if top in {m.split('/')[0].split('.')[0] for m in module_set if '/' not in m and '.' not in m} or \
+                   top in {m.split('/')[0] for m in module_set if '/' in m}:
+                    internal = resolve_internal(node.module)
+                    if internal and internal != src_short:
+                        edges.add((src_short, internal))
+                elif top in ext_deps:
+                    edges.add((src_short, 'ext:' + top))
+
+for s, d in sorted(edges):
+    sys.stdout.write(s + '\t' + d + '\n')
+" | MAX_ARCH="$MAX_ARCH" bash "$NORMALIZE"

package/scripts/Python/db/django-models.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Django model metadata — model names and field summaries
+source "$(dirname "$0")/../lib/limit.sh"
+files=$(find . -name 'models.py' -not -path '*/venv/*' -not -path '*/.venv/*' -not -path '*/node_modules/*' -not -path '*/__pycache__/*' 2>/dev/null | head -10)
+[ -z "$files" ] && echo "No Django models.py found" && exit 0
+
+echo "$files" | while IFS= read -r f; do
+  [ -z "$f" ] && continue
+  echo "=== $f ==="
+  awk '/^class [A-Z]/{gsub(/\(.*/,"",$0); print "Model: "$2; next} /^[[:space:]]+[a-z_]+ = models\./{gsub(/ = .*/,"",$1); print "  "$1; next}' "$f" | head -"$MAX_DJANGO"
+done | head -50

package/scripts/Python/db/sqlalchemy.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# SQLAlchemy model metadata — model class names and table names
+source "$(dirname "$0")/../lib/limit.sh"
+files=$(find . -name '*.py' -not -path '*/venv/*' -not -path '*/.venv/*' -not -path '*/node_modules/*' -not -path '*/__pycache__/*' 2>/dev/null | head -20)
+[ -z "$files" ] && echo "No Python files found" && exit 0
+
+grep -rn --include='*.py' -E 'class [A-Z][A-Za-z0-9_]*\(.*Base.*\)|__tablename__' . 2>/dev/null \
+  | grep -v 'venv' | grep -v '.venv' | grep -v '__pycache__' \
+  | sed -E 's/.*:class ([A-Z][A-Za-z0-9_]*)\(.*/\1/' \
+  | grep -E '^[A-Z]' | sort -u | head -"$MAX_SQLALCHEMY"
+
+tablenames=$(grep -rn --include='*.py' -E '__tablename__' . 2>/dev/null \
+  | grep -v 'venv' | grep -v '__pycache__' \
+  | sed -E "s/.*__tablename__[[:space:]]*=[[:space:]]*['\"]([^'\"]*)['\"].*/\1/" \
+  | sort -u | head -10)
+[ -n "$tablenames" ] && echo "" && echo "Tables:" && echo "$tablenames"

package/scripts/Python/lib/limit.sh

@@ -0,0 +1,144 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# limit.sh — Smart output limiter with compact fallbacks
+# TOKEN profile multiplier (override via PMD_TOKEN_PROFILE env var)
+PMD_TOKEN_PROFILE="${PMD_TOKEN_PROFILE:-medium}"
+case "$PMD_TOKEN_PROFILE" in
+  low)    MULT_NUM=1; MULT_DEN=2 ;;
+  medium) MULT_NUM=1; MULT_DEN=1 ;;
+  high)   MULT_NUM=3; MULT_DEN=2 ;;
+  xhigh)  MULT_NUM=2; MULT_DEN=1 ;;
+  unlimited) PMD_UNLIMITED=1 ;;
+  *)      MULT_NUM=1; MULT_DEN=1 ;;
+esac
+
+# Token budget constants (override via PMD_MAX_* env vars, scaled by profile)
+if [ "${PMD_UNLIMITED:-0}" = "1" ]; then
+  MAX_TREE=${PMD_MAX_TREE:-99999}
+  MAX_DEPS=${PMD_MAX_DEPS:-99999}
+  MAX_TODOS=${PMD_MAX_TODOS:-99999}
+  MAX_LOG=${PMD_MAX_LOG:-99999}
+  MAX_BRANCH=${PMD_MAX_BRANCH:-99999}
+  MAX_STATUS=${PMD_MAX_STATUS:-99999}
+  MAX_DIFF=${PMD_MAX_DIFF:-99999}
+  MAX_TYPECHECK=${PMD_MAX_TYPECHECK:-99999}
+  MAX_LINT=${PMD_MAX_LINT:-99999}
+  MAX_TEST=${PMD_MAX_TEST:-99999}
+  MAX_PRISMA=${PMD_MAX_PRISMA:-99999}
+  MAX_EXPRESS=${PMD_MAX_EXPRESS:-99999}
+  MAX_FASTAPI=${PMD_MAX_FASTAPI:-99999}
+  MAX_DJANGO=${PMD_MAX_DJANGO:-99999}
+  MAX_SQLALCHEMY=${PMD_MAX_SQLALCHEMY:-99999}
+  MAX_NEST=${PMD_MAX_NEST:-99999}
+  MAX_NEXTJS=${PMD_MAX_NEXTJS:-99999}
+  MAX_REACT=${PMD_MAX_REACT:-99999}
+  MAX_ANGULAR=${PMD_MAX_ANGULAR:-99999}
+  MAX_CMAKE=${PMD_MAX_CMAKE:-99999}
+  MAX_CLASS=${PMD_MAX_CLASS:-99999}
+  MAX_INTERFACE=${PMD_MAX_INTERFACE:-99999}
+  MAX_INCLUDE=${PMD_MAX_INCLUDE:-99999}
+  MAX_CARGO=${PMD_MAX_CARGO:-99999}
+  MAX_GO_PKGS=${PMD_MAX_GO_PKGS:-99999}
+  MAX_CARGO_FEATURES=${PMD_MAX_CARGO_FEATURES:-99999}
+  MAX_GO_INTERFACES=${PMD_MAX_GO_INTERFACES:-99999}
+  MAX_DOCKER=${PMD_MAX_DOCKER:-99999}
+  MAX_K8S=${PMD_MAX_K8S:-99999}
+  MAX_TF=${PMD_MAX_TF:-99999}
+  MAX_AWS=${PMD_MAX_AWS:-99999}
+  MAX_ARCH=${PMD_MAX_ARCH:-99999}
+  MAX_COMPOSE=${PMD_MAX_COMPOSE:-99999}
+  MAX_CREW=${PMD_MAX_CREW:-99999}
+else
+  MAX_TREE=$(( (${PMD_MAX_TREE:-50} * MULT_NUM) / MULT_DEN ))
+  MAX_DEPS=$(( (${PMD_MAX_DEPS:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_TODOS=$(( (${PMD_MAX_TODOS:-20} * MULT_NUM) / MULT_DEN ))
+  MAX_LOG=$(( (${PMD_MAX_LOG:-20} * MULT_NUM) / MULT_DEN ))
+  MAX_BRANCH=$(( (${PMD_MAX_BRANCH:-20} * MULT_NUM) / MULT_DEN ))
+  MAX_STATUS=$(( (${PMD_MAX_STATUS:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_DIFF=$(( (${PMD_MAX_DIFF:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_TYPECHECK=$(( (${PMD_MAX_TYPECHECK:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_LINT=$(( (${PMD_MAX_LINT:-20} * MULT_NUM) / MULT_DEN ))
+  MAX_TEST=$(( (${PMD_MAX_TEST:-10} * MULT_NUM) / MULT_DEN ))
+  MAX_PRISMA=$(( (${PMD_MAX_PRISMA:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_EXPRESS=$(( (${PMD_MAX_EXPRESS:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_FASTAPI=$(( (${PMD_MAX_FASTAPI:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_DJANGO=$(( (${PMD_MAX_DJANGO:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_SQLALCHEMY=$(( (${PMD_MAX_SQLALCHEMY:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_NEST=$(( (${PMD_MAX_NEST:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_NEXTJS=$(( (${PMD_MAX_NEXTJS:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_REACT=$(( (${PMD_MAX_REACT:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_ANGULAR=$(( (${PMD_MAX_ANGULAR:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_CMAKE=$(( (${PMD_MAX_CMAKE:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_CLASS=$(( (${PMD_MAX_CLASS:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_INTERFACE=$(( (${PMD_MAX_INTERFACE:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_INCLUDE=$(( (${PMD_MAX_INCLUDE:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_CARGO=$(( (${PMD_MAX_CARGO:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_GO_PKGS=$(( (${PMD_MAX_GO_PKGS:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_CARGO_FEATURES=$(( (${PMD_MAX_CARGO_FEATURES:-20} * MULT_NUM) / MULT_DEN ))
+  MAX_GO_INTERFACES=$(( (${PMD_MAX_GO_INTERFACES:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_DOCKER=$(( (${PMD_MAX_DOCKER:-30} * MULT_NUM) / MULT_DEN ))
+  MAX_K8S=$(( (${PMD_MAX_K8S:-20} * MULT_NUM) / MULT_DEN ))
+  MAX_TF=$(( (${PMD_MAX_TF:-40} * MULT_NUM) / MULT_DEN ))
+  MAX_AWS=$(( (${PMD_MAX_AWS:-10} * MULT_NUM) / MULT_DEN ))
+  MAX_ARCH=$(( (${PMD_MAX_ARCH:-100} * MULT_NUM) / MULT_DEN ))
+  MAX_COMPOSE=$(( (${PMD_MAX_COMPOSE:-150} * MULT_NUM) / MULT_DEN ))
+  MAX_CREW=$(( (${PMD_MAX_CREW:-40} * MULT_NUM) / MULT_DEN ))
+fi
+
+TREE_EXCLUDES="${PMD_TREE_EXCLUDES:-__pycache__|.git|.pipemd|venv|.venv|*.egg-info|node_modules|dist|build}"
+
+limit_output() {
+  local text="$1"
+  local max="${2:-25}"
+  local fallback="$3"
+  local lines
+  lines=$(echo "$text" | wc -l)
+  if [ "$lines" -le "$max" ]; then
+    echo "$text"
+  else
+    echo "$fallback"
+  fi
+}
+
+limit_tree() {
+  local max="${1:-$MAX_TREE}"
+  local excl="${TREE_EXCLUDES}"
+
+  if command -v tree &>/dev/null; then
+    local out3
+    out3=$(tree -L 3 -I "$excl" --dirsfirst 2>/dev/null)
+    local lines3=$(echo "$out3" | wc -l)
+
+    if [ "$lines3" -le "$max" ]; then
+      echo "$out3"
+      return
+    fi
+
+    local out2
+    out2=$(tree -L 2 -I "$excl" --dirsfirst 2>/dev/null)
+    local lines2=$(echo "$out2" | wc -l)
+
+    if [ "$lines2" -le "$max" ]; then
+      echo "$out2"
+      echo "(${lines3} lines at depth 3, showing depth 2)"
+      return
+    fi
+
+    local out1
+    out1=$(tree -L 1 -I "$excl" --dirsfirst 2>/dev/null)
+    echo "$out1"
+    echo "(${lines3} lines at depth 3, showing depth 1)"
+  else
+    echo "Project structure:"
+    find . -maxdepth 3 \
+      -not -path '*/__pycache__/*' \
+      -not -path '*/.git/*' \
+      -not -path '*/.pipemd/*' \
+      -not -path '*/venv/*' \
+      -not -path '*/.venv/*' \
+      -not -name '__pycache__' \
+      -not -name '.git' \
+      -not -name '.pipemd' \
+      2>/dev/null | head -"$max" | sort
+  fi
+}

package/scripts/Python/project/deps.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Direct dependencies — summarize if too many
+source "$(dirname "$0")/../lib/limit.sh"
+
+if [ -f requirements.txt ]; then
+  out=$(head -20 requirements.txt)
+  limit_output "$out" "$MAX_DEPS" "$(head -5 requirements.txt && echo "... and $(wc -l < requirements.txt) total lines")"
+elif [ -f pyproject.toml ]; then
+  out=$(awk '
+    /^\[project\.dependencies\]/{in_deps=1;next}
+    /^\[/{in_deps=0}
+    in_deps && /^[a-zA-Z]/{
+      gsub(/#.*/,"")
+      gsub(/;.*$/,"")
+      gsub(/"/,"")
+      sub(/[<=>!].*/,"")
+      if(length>0) print
+    }
+  ' pyproject.toml 2>/dev/null)
+  if [ -n "$out" ]; then
+    limit_output "$out" "$MAX_DEPS" "$(echo "$out" | head -5 && echo '... more in pyproject.toml')"
+  else
+    echo "No dependencies found in pyproject.toml"
+  fi
+else
+  echo "No recognized dependency file"
+fi

package/scripts/Python/project/find-todos.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Find TODO, FIXME, HACK — Python files
+source "$(dirname "$0")/../lib/limit.sh"
+out=$(grep -rn 'TODO\|FIXME\|HACK' --include="*.py" . 2>/dev/null | grep -v '/__pycache__/' | grep -v '/.pipemd/' | grep -v '/venv/' | grep -v '/.venv/' | grep -v '/.git/')
+limit_output "$out" "$MAX_TODOS" "$(echo "$out" | head -3 && echo "... and $(($(echo "$out" | wc -l) - 3)) more items")"

package/scripts/Python/quality/lint.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Lint errors — ruff or flake8
+source "$(dirname "$0")/../lib/limit.sh"
+if command -v ruff &>/dev/null; then
+  out=$(ruff check . 2>&1)
+  limit_output "$out" "$MAX_LINT" "$(echo "$out" | head -3 && echo "... and $(echo "$out" | wc -l) more lint issues")"
+elif command -v flake8 &>/dev/null; then
+  out=$(flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics 2>&1)
+  limit_output "$out" "$MAX_LINT" "$(echo "$out" | head -3 && echo '... more flake8 errors')"
+else
+  echo "No linter configured"
+fi

package/scripts/Python/quality/test-summary.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Test summary — actually run tests and show results
+source "$(dirname "$0")/../lib/limit.sh"
+
+if command -v pytest &>/dev/null || [ -f pytest.ini ] || [ -f conftest.py ] || [ -f pyproject.toml ]; then
+  out=$(python -m pytest --tb=no -q 2>&1 | tail -5)
+  echo "$out"
+else
+  echo "No test runner configured for this ecosystem"
+fi

package/scripts/Python/quality/type-check.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Python type check (mypy) — errors only
+source "$(dirname "$0")/../lib/limit.sh"
+out=$(python -m mypy . 2>&1)
+if [ -z "$out" ]; then
+  echo "No type errors"
+  exit 0
+fi
+limit_output "$out" "$MAX_TYPECHECK" "$(echo "$out" | head -5 && echo '... more mypy errors')"

package/scripts/Rust/architecture/arch.sh

@@ -0,0 +1,176 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# Architecture map — Rust module dependencies
+source "$(dirname "$0")/../lib/limit.sh"
+
+: "${MAX_ARCH:=100}"
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+NORMALIZE="$SCRIPT_DIR/normalize.sh"
+[ -f "$NORMALIZE" ] || NORMALIZE="$SCRIPT_DIR/../../Shared/architecture/normalize.sh"
+
+if [ ! -f Cargo.toml ]; then
+  echo "No Cargo.toml found"
+  exit 0
+fi
+
+if ! command -v python3 &>/dev/null; then
+  echo "python3 is required for Rust architecture extraction"
+  exit 0
+fi
+
+SRC_DIR=""
+[ -d "src" ] && SRC_DIR="src"
+
+if [ -z "$SRC_DIR" ]; then
+  echo "No source directory found"
+  exit 0
+fi
+
+SRC_DIR="$SRC_DIR" python3 -c "
+import os, re, sys
+from collections import defaultdict
+
+SRC_DIR = os.environ.get('SRC_DIR', 'src')
+MAX_MODULES = 40
+
+def module_name(rel_path):
+    rel_path = rel_path.replace(os.sep, '/')
+    parts = rel_path.split('/')
+    filename = os.path.splitext(parts[-1])[0] if parts else ''
+    dirpath = parts[:-1] if len(parts) > 1 else []
+
+    if not dirpath:
+        return filename
+
+    if len(dirpath) == 1 and dirpath[0] == SRC_DIR:
+        return filename if filename in ('main', 'lib') else filename
+
+    last_dir = dirpath[-1]
+
+    if filename == 'mod' or filename == 'lib':
+        return last_dir
+
+    if filename == last_dir:
+        return last_dir
+
+    return last_dir + '/' + filename
+
+def collect_cargo_deps():
+    deps = set()
+    try:
+        with open('Cargo.toml', 'r', errors='replace') as f:
+            content = f.read()
+    except Exception:
+        return deps
+
+    in_deps = False
+    for line in content.split('\n'):
+        stripped = line.strip()
+        if stripped.startswith('['):
+            in_deps = stripped == '[dependencies]'
+            continue
+        if in_deps and stripped and not stripped.startswith('#'):
+            name = stripped.split('=')[0].strip()
+            name = re.split(r'[^a-zA-Z0-9_-]', name)[0]
+            if name:
+                deps.add(name.lower())
+    return deps
+
+cargo_deps = collect_cargo_deps()
+
+files = []
+for root, dirs, fnames in os.walk(SRC_DIR):
+    dirs[:] = [d for d in dirs if not d.startswith('.') and d != 'target']
+    for fn in fnames:
+        if fn.endswith('.rs'):
+            files.append(os.path.join(root, fn))
+    if len(files) >= 200:
+        files = files[:200]
+        break
+
+if not files:
+    sys.exit(0)
+
+module_set = set()
+for fpath in files:
+    rel = os.path.relpath(fpath, '.').replace(os.sep, '/')
+    mod = module_name(rel)
+    if mod:
+        module_set.add(mod)
+
+if len(module_set) > MAX_MODULES:
+    module_set = set()
+    for fpath in files:
+        rel = os.path.relpath(fpath, '.').replace(os.sep, '/')
+        parts = rel.split('/')
+        if len(parts) > 2:
+            module_set.add(parts[1])
+        elif len(parts) == 2:
+            module_set.add(parts[1].replace('.rs', ''))
+        else:
+            module_set.add(os.path.splitext(parts[0])[0])
+
+edges = set()
+
+use_re = re.compile(r'^\s*use\s+(.+?);', re.MULTILINE)
+mod_re = re.compile(r'^\s*mod\s+([a-zA-Z_]\w*)\s*;', re.MULTILINE)
+
+for fpath in files:
+    rel = os.path.relpath(fpath, '.').replace(os.sep, '/')
+    src_mod = module_name(rel)
+    if not src_mod or src_mod not in module_set:
+        continue
+
+    try:
+        with open(fpath, 'r', errors='replace') as f:
+            content = f.read()
+    except Exception:
+        continue
+
+    for m in mod_re.finditer(content):
+        mod_name = m.group(1)
+        if mod_name in module_set and mod_name != src_mod:
+            edges.add((src_mod, mod_name))
+
+    for m in use_re.finditer(content):
+        path = m.group(1).strip()
+        if path.startswith('crate::'):
+            crate_path = path[7:]
+            first = crate_path.split('::')[0].split('{')[0].strip()
+            first = first.replace(',', '').strip()
+            if first in module_set and first != src_mod:
+                edges.add((src_mod, first))
+            elif first and first != src_mod:
+                for part in crate_path.split('{'):
+                    if '}' in part:
+                        for sub in part.replace('}', '').split(','):
+                            sub = sub.strip().split('::')[0]
+                            if sub in module_set and sub != src_mod:
+                                edges.add((src_mod, sub))
+        elif path.startswith('super::'):
+            rest = path[7:]
+            first = rest.split('::')[0].split('{')[0].strip()
+            first = first.replace(',', '').strip()
+            fdir = os.path.dirname(rel)
+            if SRC_DIR and fdir.startswith(SRC_DIR + '/'):
+                fdir = fdir[len(SRC_DIR) + 1:]
+            elif fdir == SRC_DIR:
+                fdir = ''
+            parent_parts = fdir.split('/') if fdir else []
+            if parent_parts:
+                parent_mod = parent_parts[-1]
+                if parent_mod in module_set and parent_mod != src_mod:
+                    edges.add((src_mod, parent_mod))
+        elif path.startswith('self::'):
+            pass
+        else:
+            crate_name = path.split('::')[0].split('{')[0].strip()
+            crate_name = crate_name.replace(',', '').strip()
+            if crate_name and crate_name not in ('crate', 'super', 'self'):
+                if crate_name in cargo_deps:
+                    edges.add((src_mod, 'ext:' + crate_name))
+
+for s, d in sorted(edges):
+    sys.stdout.write(s + '\t' + d + '\n')
+" | MAX_ARCH="$MAX_ARCH" bash "$NORMALIZE"