mcp-atlassian-multi 0.21.2__tar.gz

mcp_atlassian_multi-0.21.2/.analysis/code-intelligence/index-config.json

@@ -0,0 +1,50 @@
+{
+  "includedExtensions": [
+    ".kt",
+    ".java",
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".py",
+    ".go",
+    ".rs",
+    ".cs",
+    ".gradle.kts",
+    ".gradle",
+    ".yml",
+    ".yaml",
+    ".properties",
+    ".xml",
+    ".json",
+    ".sql",
+    ".toml",
+    ".cfg",
+    ".ini"
+  ],
+  "excludedDirectories": [
+    "build",
+    "dist",
+    "out",
+    "target",
+    ".gradle",
+    ".git",
+    ".analysis",
+    "node_modules",
+    ".idea",
+    ".kiro",
+    ".vscode",
+    "__pycache__",
+    ".mypy_cache",
+    "vendor",
+    "bin",
+    "obj"
+  ],
+  "excludedFilePatterns": [
+    "*.generated.*",
+    "*.min.*",
+    "*.map",
+    "*.lock",
+    "*.sum"
+  ]
+}

mcp_atlassian_multi-0.21.2/.analysis/code-intelligence/modules/root.md

@@ -0,0 +1,17 @@
+# Module Analysis — root
+
+**Last Updated:** 2026-05-09T04:48:52.221678500Z
+**Language:** unknown
+
+## Key Classes
+
+| Class | Responsibility |
+|-------|---------------|
+
+## Detected Patterns
+
+- **DI Style**: none
+- **Error Handling**: unknown
+- **Naming**: unknown
+- **Logging**: unknown
+- **Testing**: unknown

mcp_atlassian_multi-0.21.2/.analysis/code-intelligence/scripts/README.md

@@ -0,0 +1,47 @@
+# Code Intelligence Indexer — Multi-Language
+
+Bộ indexer phân tích source code và tạo ra markdown analysis files cho AI agents sử dụng.
+
+## Chọn script phù hợp với môi trường
+
+| Thư mục | Ngôn ngữ | Yêu cầu | Cách chạy |
+|---------|----------|----------|-----------|
+| `python/` | Python 3.7+ | Chỉ cần Python (standard library) | `python main.py <project_root>` |
+| `java/` | Java 17+ | Chỉ cần JDK (standard library) | `run.bat <project_root>` hoặc `./run.sh <project_root>` |
+| `powershell/` | PowerShell 5.1+ | Built-in trên Windows | `.\full-indexer.ps1 -RootDir <project_root>` |
+| `bash/` | Bash 4+ | Built-in trên Linux/Mac | `bash full-indexer.sh <project_root>` |
+| `nodejs/` | TypeScript | Node.js 18+ + npm install | `cd nodejs && npm install && npx tsx src/full-indexer.ts <project_root>` |
+
+## Output (giống nhau bất kể dùng script nào)
+
+```
+.analysis/code-intelligence/
+├── project-structure.md      ← Tổng quan project (modules, languages, frameworks)
+├── modules/
+│   ├── root.md               ← Analysis cho module root
+│   ├── core.md               ← Analysis cho module core
+│   └── ...
+├── index-metadata.json       ← Metadata (timestamps, file hashes)
+├── kb-payloads.json          ← Payloads sẵn sàng ingest vào Knowledge Base
+└── index-config.json         ← Config (extensions, excludes)
+```
+
+## Khi nào dùng cái nào?
+
+- **Windows (không có Python/Node)** → dùng `powershell/` (built-in, zero install)
+- **Linux/Mac (không có Python/Node)** → dùng `bash/` (built-in, zero install)
+- **Dự án Python/Django/FastAPI** → dùng `python/` (đã có Python sẵn)
+- **Dự án Java/Kotlin/Spring** → dùng `java/` (đã có JDK sẵn)
+- **Dự án Node.js/TypeScript** → dùng `nodejs/` (đã có Node sẵn, parser chính xác nhất)
+- **Dự án Go/Rust** → dùng `python/` hoặc `bash/`
+- **CI/CD pipeline** → dùng `python/` hoặc `bash/` (thường có sẵn)
+- **Không có gì** → dùng Kiro AI agent fallback (xem steering file `code-intelligence.md`)
+
+## Thêm ngôn ngữ mới (tương lai)
+
+Tạo thư mục mới (ví dụ: `bash/`, `powershell/`, `java/`) với cùng logic:
+1. Đọc `index-config.json`
+2. Detect project type từ build files
+3. Discover modules
+4. Scan + parse source files
+5. Ghi output vào cùng location với cùng format

mcp_atlassian_multi-0.21.2/.analysis/code-intelligence/scripts/python/__init__.py

@@ -0,0 +1 @@
+"""Code Intelligence System — Python Indexer Package."""

mcp_atlassian_multi-0.21.2/.analysis/code-intelligence/scripts/python/config.py

@@ -0,0 +1,46 @@
+"""Configuration loading for the Code Intelligence indexer."""
+
+import json
+import os
+from typing import Dict, List
+
+DEFAULT_CONFIG: Dict[str, List[str]] = {
+    "includedExtensions": [
+        ".kt", ".java", ".ts", ".tsx", ".js", ".jsx", ".py", ".go",
+        ".rs", ".cs", ".gradle.kts", ".gradle", ".yml", ".yaml",
+        ".properties", ".xml", ".json", ".sql", ".toml", ".cfg", ".ini"
+    ],
+    "excludedDirectories": [
+        "build", "dist", "out", "target", ".gradle", ".git", ".analysis",
+        "node_modules", ".idea", ".kiro", ".vscode", "__pycache__",
+        ".mypy_cache", "vendor", "bin", "obj"
+    ],
+    "excludedFilePatterns": [
+        "*.generated.*", "*.min.*", "*.map", "*.lock", "*.sum"
+    ]
+}
+
+EXTENSION_MAP = {
+    ".kt": "kotlin", ".java": "java", ".ts": "typescript", ".tsx": "typescript",
+    ".js": "javascript", ".jsx": "javascript", ".py": "python", ".go": "go",
+    ".rs": "rust", ".cs": "csharp", ".gradle": "gradle", ".yml": "yaml",
+    ".yaml": "yaml", ".xml": "xml", ".sql": "sql", ".json": "json",
+    ".properties": "properties", ".toml": "config", ".cfg": "config", ".ini": "config"
+}
+
+COMPOUND_EXTENSIONS = [(".gradle.kts", "gradle")]
+
+SOURCE_EXTENSIONS = {
+    ".kt": "kotlin", ".java": "java", ".ts": "typescript", ".tsx": "typescript",
+    ".js": "javascript", ".jsx": "javascript", ".py": "python", ".go": "go",
+    ".rs": "rust", ".cs": "csharp"
+}
+
+
+def load_config(config_path: str) -> dict:
+    """Load index-config.json or return defaults."""
+    try:
+        with open(config_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return DEFAULT_CONFIG

mcp_atlassian_multi-0.21.2/.analysis/code-intelligence/scripts/python/detector.py

@@ -0,0 +1,115 @@
+"""Project type detection — identifies build system, language, and framework."""
+
+import os
+from typing import Dict, Optional, Tuple
+
+from config import SOURCE_EXTENSIONS
+
+BUILD_FILE_PRIORITY = [
+    ("build.gradle.kts", "gradle-kotlin"), ("build.gradle", "gradle-java"),
+    ("pom.xml", "maven-java"), ("package.json", "npm"),
+    ("Cargo.toml", "cargo-rust"), ("go.mod", "go-module"),
+    ("pyproject.toml", "python"), ("setup.py", "python"),
+]
+
+PROJECT_TYPE_LANGUAGE = {
+    "gradle-kotlin": "kotlin", "gradle-java": "java", "maven-java": "java",
+    "npm-typescript": "typescript", "npm-javascript": "javascript",
+    "cargo-rust": "rust", "go-module": "go", "python": "python",
+    "dotnet": "csharp", "generic": "unknown"
+}
+
+FRAMEWORK_PATTERNS = {
+    "gradle-kotlin": [("spring-boot-starter", "Spring Boot"), ("io.ktor", "Ktor"), ("ktor-", "Ktor")],
+    "gradle-java": [("spring-boot-starter", "Spring Boot"), ("io.ktor", "Ktor")],
+    "maven-java": [("spring-boot-starter", "Spring Boot"), ("io.quarkus", "Quarkus")],
+    "npm-typescript": [('"react"', "React"), ('"next"', "Next.js"), ('"@angular/core"', "Angular"),
+                       ('"vue"', "Vue.js"), ('"express"', "Express.js"), ('"@nestjs/core"', "NestJS")],
+    "npm-javascript": [('"react"', "React"), ('"express"', "Express.js")],
+    "python": [("django", "Django"), ("flask", "Flask"), ("fastapi", "FastAPI")],
+    "cargo-rust": [("actix-web", "Actix Web"), ("axum", "Axum"), ("rocket", "Rocket")],
+    "go-module": [("github.com/gin-gonic/gin", "Gin"), ("github.com/gofiber/fiber", "Fiber")],
+}
+
+
+def detect_project_type(root_dir: str) -> dict:
+    """Detect project type, primary language, and framework."""
+    project_type, build_file = _find_build_file(root_dir)
+    project_type = _refine_npm(root_dir, project_type)
+    primary_language = _determine_language(root_dir, project_type)
+    framework = _detect_framework(root_dir, build_file, project_type)
+
+    print(f"[Code-Index] INFO: Project detected — type={project_type}, "
+          f"language={primary_language}, framework={framework}, buildFile={build_file}")
+    return {"projectType": project_type, "primaryLanguage": primary_language,
+            "framework": framework, "buildFile": build_file}
+
+
+def _find_build_file(root_dir: str) -> Tuple[str, str]:
+    """Find the primary build file in priority order."""
+    for filename, ptype in BUILD_FILE_PRIORITY:
+        if os.path.isfile(os.path.join(root_dir, filename)):
+            return ptype, filename
+    # Check .sln / .csproj
+    for f in os.listdir(root_dir):
+        if f.endswith(".sln") or f.endswith(".csproj"):
+            return "dotnet", f
+    return "generic", "none"
+
+
+def _refine_npm(root_dir: str, project_type: str) -> str:
+    """Refine npm to npm-typescript or npm-javascript."""
+    if project_type != "npm":
+        return project_type
+    tsconfig = os.path.join(root_dir, "tsconfig.json")
+    return "npm-typescript" if os.path.isfile(tsconfig) else "npm-javascript"
+
+
+def _determine_language(root_dir: str, project_type: str) -> str:
+    """Determine primary language from file counts and project type."""
+    lang_counts = _count_source_files(root_dir, max_depth=3)
+    implied = PROJECT_TYPE_LANGUAGE.get(project_type, "unknown")
+    if implied != "unknown" and lang_counts.get(implied, 0) > 0:
+        return implied
+    if lang_counts:
+        return max(lang_counts, key=lang_counts.get)
+    return implied
+
+
+def _detect_framework(root_dir: str, build_file: str, project_type: str) -> Optional[str]:
+    """Detect framework from build file content."""
+    if build_file == "none":
+        return None
+    build_path = os.path.join(root_dir, build_file)
+    try:
+        content = open(build_path, "r", encoding="utf-8", errors="ignore").read()
+    except OSError:
+        return None
+    for pattern, fw in FRAMEWORK_PATTERNS.get(project_type, []):
+        if pattern in content:
+            return fw
+    return None
+
+
+def _count_source_files(directory: str, max_depth: int, depth: int = 0) -> Dict[str, int]:
+    """Recursively count source files by language."""
+    counts: Dict[str, int] = {}
+    if depth > max_depth:
+        return counts
+    skip = {"node_modules", ".git", "build", "dist", "out", "target", ".gradle", "vendor"}
+    try:
+        entries = os.scandir(directory)
+    except OSError:
+        return counts
+    for entry in entries:
+        if entry.is_dir(follow_symlinks=False):
+            if entry.name in skip:
+                continue
+            for lang, count in _count_source_files(entry.path, max_depth, depth + 1).items():
+                counts[lang] = counts.get(lang, 0) + count
+        elif entry.is_file():
+            ext = os.path.splitext(entry.name)[1].lower()
+            lang = SOURCE_EXTENSIONS.get(ext)
+            if lang:
+                counts[lang] = counts.get(lang, 0) + 1
+    return counts

mcp_atlassian_multi-0.21.2/.analysis/code-intelligence/scripts/python/discovery.py

@@ -0,0 +1,184 @@
+"""Module discovery — finds subprojects based on build system."""
+
+import json
+import os
+import re
+from typing import List
+
+
+def discover_modules(root_dir: str, detection: dict) -> List[dict]:
+    """Discover modules/subprojects based on build system."""
+    project_type = detection["projectType"]
+    build_file = detection["buildFile"]
+
+    discoverers = {
+        "gradle-kotlin": _discover_gradle, "gradle-java": _discover_gradle,
+        "maven-java": _discover_maven, "npm-typescript": _discover_npm,
+        "npm-javascript": _discover_npm, "cargo-rust": _discover_cargo,
+        "go-module": _discover_go, "python": _discover_python,
+    }
+    discoverer = discoverers.get(project_type)
+    modules = discoverer(root_dir) if discoverer else []
+
+    if not modules:
+        modules = [_create_root_module(root_dir, project_type, build_file)]
+
+    print(f"[Code-Index] INFO: Module discovery — found {len(modules)} module(s)")
+    return modules
+
+
+def _create_root_module(root_dir: str, project_type: str, build_file: str) -> dict:
+    """Create a single root module as fallback."""
+    src_dirs = _detect_src_dirs(root_dir, ".", project_type)
+    return {"name": "root", "path": ".", "sourceDirectories": src_dirs,
+            "buildFile": build_file if build_file != "none" else None, "language": None}
+
+
+def _detect_src_dirs(root_dir: str, mod_path: str, project_type: str) -> List[str]:
+    """Detect source directories for a module."""
+    if project_type in ("gradle-kotlin", "gradle-java", "maven-java"):
+        return _gradle_maven_src(root_dir, mod_path)
+    if project_type in ("npm-typescript", "npm-javascript"):
+        return _npm_src(root_dir, mod_path)
+    for candidate in ["src", "lib", "."]:
+        full = os.path.join(root_dir, mod_path, candidate) if mod_path != "." else os.path.join(root_dir, candidate)
+        if os.path.isdir(full):
+            return [f"{mod_path}/{candidate}" if mod_path != "." else candidate]
+    return [mod_path]
+
+
+def _gradle_maven_src(root_dir: str, mod_path: str) -> List[str]:
+    """Detect Gradle/Maven source directories."""
+    candidates = [f"{mod_path}/src/main/kotlin", f"{mod_path}/src/main/java",
+                  f"{mod_path}/src/main/resources", f"{mod_path}/src/test/kotlin",
+                  f"{mod_path}/src/test/java"]
+    found = [c for c in candidates if os.path.isdir(os.path.join(root_dir, c))]
+    return found if found else [mod_path]
+
+
+def _npm_src(root_dir: str, mod_path: str) -> List[str]:
+    """Detect npm source directories."""
+    candidates = [f"{mod_path}/src", f"{mod_path}/lib", f"{mod_path}/app"]
+    found = [c for c in candidates if os.path.isdir(os.path.join(root_dir, c))]
+    return found if found else [mod_path]
+
+
+def _discover_gradle(root_dir: str) -> List[dict]:
+    """Discover Gradle subprojects from settings file."""
+    modules = []
+    for sf in ("settings.gradle.kts", "settings.gradle"):
+        path = os.path.join(root_dir, sf)
+        if not os.path.isfile(path):
+            continue
+        content = open(path, "r", encoding="utf-8", errors="ignore").read()
+        seen = set()
+        for match in re.finditer(r'["\']([^"\']+)["\']', content):
+            name = match.group(1).lstrip(":").replace(":", "/")
+            if name in seen or not os.path.isdir(os.path.join(root_dir, name)):
+                continue
+            seen.add(name)
+            src_dirs = _gradle_maven_src(root_dir, name)
+            modules.append({"name": name.replace("/", "-"), "path": name,
+                            "sourceDirectories": src_dirs, "buildFile": None, "language": None})
+        break
+    return modules
+
+
+def _discover_maven(root_dir: str) -> List[dict]:
+    """Discover Maven child modules from pom.xml."""
+    modules = []
+    pom = os.path.join(root_dir, "pom.xml")
+    if not os.path.isfile(pom):
+        return modules
+    content = open(pom, "r", encoding="utf-8", errors="ignore").read()
+    for match in re.finditer(r"<module>\s*([^<]+?)\s*</module>", content):
+        name = match.group(1).strip()
+        if os.path.isdir(os.path.join(root_dir, name)):
+            src_dirs = _gradle_maven_src(root_dir, name)
+            modules.append({"name": name, "path": name, "sourceDirectories": src_dirs,
+                            "buildFile": f"{name}/pom.xml", "language": None})
+    return modules
+
+
+def _discover_npm(root_dir: str) -> List[dict]:
+    """Discover npm workspace packages."""
+    modules = []
+    pkg_path = os.path.join(root_dir, "package.json")
+    if not os.path.isfile(pkg_path):
+        return modules
+    try:
+        pkg = json.load(open(pkg_path, "r", encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return modules
+    workspaces = pkg.get("workspaces", [])
+    if isinstance(workspaces, dict):
+        workspaces = workspaces.get("packages", [])
+    for pattern in workspaces:
+        if "*" in pattern:
+            parent = pattern.rstrip("/*").rstrip("/**")
+            parent_dir = os.path.join(root_dir, parent)
+            if os.path.isdir(parent_dir):
+                for entry in os.scandir(parent_dir):
+                    if entry.is_dir() and os.path.isfile(os.path.join(entry.path, "package.json")):
+                        mod_path = f"{parent}/{entry.name}"
+                        modules.append({"name": entry.name, "path": mod_path,
+                                        "sourceDirectories": _npm_src(root_dir, mod_path),
+                                        "buildFile": f"{mod_path}/package.json", "language": None})
+        elif os.path.isdir(os.path.join(root_dir, pattern)):
+            modules.append({"name": os.path.basename(pattern), "path": pattern,
+                            "sourceDirectories": _npm_src(root_dir, pattern),
+                            "buildFile": f"{pattern}/package.json", "language": None})
+    return modules
+
+
+def _discover_cargo(root_dir: str) -> List[dict]:
+    """Discover Cargo workspace members."""
+    cargo = os.path.join(root_dir, "Cargo.toml")
+    if not os.path.isfile(cargo):
+        return []
+    content = open(cargo, "r", encoding="utf-8", errors="ignore").read()
+    if "[workspace]" not in content:
+        return []
+    match = re.search(r'members\s*=\s*\[([^\]]*)\]', content, re.DOTALL)
+    if not match:
+        return []
+    modules = []
+    for m in re.finditer(r'"([^"]+)"', match.group(1)):
+        name = m.group(1)
+        mod_dir = os.path.join(root_dir, name)
+        if os.path.isdir(mod_dir):
+            src = f"{name}/src" if os.path.isdir(os.path.join(mod_dir, "src")) else name
+            modules.append({"name": os.path.basename(name), "path": name,
+                            "sourceDirectories": [src], "buildFile": f"{name}/Cargo.toml", "language": "rust"})
+    return modules
+
+
+def _discover_go(root_dir: str) -> List[dict]:
+    """Discover Go module."""
+    go_mod = os.path.join(root_dir, "go.mod")
+    if not os.path.isfile(go_mod):
+        return []
+    content = open(go_mod, "r", encoding="utf-8", errors="ignore").read()
+    match = re.search(r'^module\s+(\S+)', content, re.MULTILINE)
+    name = os.path.basename(match.group(1)) if match else "root"
+    return [{"name": name, "path": ".", "sourceDirectories": ["."],
+             "buildFile": "go.mod", "language": "go"}]
+
+
+def _discover_python(root_dir: str) -> List[dict]:
+    """Discover Python monorepo packages."""
+    modules = []
+    for indicator in ("packages", "libs"):
+        ind_dir = os.path.join(root_dir, indicator)
+        if not os.path.isdir(ind_dir):
+            continue
+        for entry in os.scandir(ind_dir):
+            if entry.is_dir():
+                has_build = (os.path.isfile(os.path.join(entry.path, "pyproject.toml")) or
+                             os.path.isfile(os.path.join(entry.path, "setup.py")))
+                if has_build:
+                    sub = f"{indicator}/{entry.name}"
+                    src = f"{sub}/src" if os.path.isdir(os.path.join(root_dir, sub, "src")) else sub
+                    modules.append({"name": entry.name, "path": sub,
+                                    "sourceDirectories": [src], "buildFile": None, "language": "python"})
+    return modules

mcp_atlassian_multi-0.21.2/.analysis/code-intelligence/scripts/python/generator.py

@@ -0,0 +1,76 @@
+"""Analysis file generator — produces markdown output files."""
+
+import os
+from datetime import datetime, timezone
+from typing import List
+
+from utils import atomic_write, infer_responsibility
+
+
+def generate_project_structure(modules_data: List[dict], project_info: dict, output_dir: str):
+    """Generate project-structure.md."""
+    timestamp = datetime.now(timezone.utc).isoformat()
+    lines = [
+        f"# Project Structure — {project_info['projectName']}",
+        "", f"**Last Updated:** {timestamp}",
+        f"**Project Type:** {project_info['projectType']}", "",
+        "## Modules", "",
+        "| Module | Purpose | Language | Framework | Dependencies | Source Files |",
+        "|--------|---------|----------|-----------|-------------|-------------|",
+    ]
+    for mod in modules_data:
+        fw = mod.get("framework") or "—"
+        deps = ", ".join(mod.get("dependencies", [])[:5]) or "—"
+        lines.append(f"| {mod['name']} | {mod.get('purpose', '—')} | "
+                     f"{mod['language']} | {fw} | {deps} | {mod['sourceFileCount']} |")
+
+    lines += ["", "## Inter-Module Dependencies", "",
+              "| Module | Depends On |", "|--------|-----------|"]
+    for mod in modules_data:
+        deps = ", ".join(mod.get("dependencies", [])) or "—"
+        lines.append(f"| {mod['name']} | {deps} |")
+    lines.append("")
+
+    atomic_write(os.path.join(output_dir, "project-structure.md"), "\n".join(lines))
+
+
+def generate_module_analysis(module_data: dict, output_dir: str):
+    """Generate modules/{name}.md."""
+    modules_dir = os.path.join(output_dir, "modules")
+    os.makedirs(modules_dir, exist_ok=True)
+    timestamp = datetime.now(timezone.utc).isoformat()
+    fw = module_data.get("framework") or "—"
+
+    lines = [
+        f"# Module Analysis — {module_data['name']}",
+        "", f"**Last Updated:** {timestamp}",
+        f"**Language:** {module_data['language']} | **Framework:** {fw}", "",
+        "## Key Classes", "",
+        "| Class | Visibility | Responsibility |",
+        "|-------|------------|---------------|",
+    ]
+    for cls in module_data.get("classes", [])[:30]:
+        resp = infer_responsibility(cls["name"])
+        lines.append(f"| {cls['name']} | {cls['visibility']} | {resp} |")
+
+    lines += ["", "## Public API Surface", ""]
+    pub_fns = [f for f in module_data.get("functions", [])
+               if f["visibility"] in ("public", "exported")]
+    if pub_fns:
+        for fn in pub_fns[:20]:
+            params = ", ".join(f"{p['name']}: {p['type']}" for p in fn.get("parameters", []))
+            lines.append(f"- `{fn['name']}({params}): {fn['returnType']}`")
+    else:
+        lines.append("_No public functions detected._")
+
+    lines += ["", "## Dependencies", ""]
+    deps = module_data.get("dependencies", [])
+    lines.append(", ".join(deps) if deps else "None detected.")
+
+    lines += ["", "## Detected Patterns", ""]
+    patterns = module_data.get("patterns", {})
+    for key in ("diStyle", "errorHandling", "naming", "logging", "testing"):
+        lines.append(f"- **{key}**: {patterns.get(key, 'unknown')}")
+    lines.append("")
+
+    atomic_write(os.path.join(modules_dir, f"{module_data['name']}.md"), "\n".join(lines))