refactor(docs): code analysis engine

changes:
  - file: dependency_scanner.py
    area: analyzer
    added: [_parse_package_json, _parse_go_mod, _parse_cargo_toml]
    modified: [DependencyScanner, scan, ProjectDependencies]
  - file: contributing_gen.py
    area: docs
    modified: [_render_code_style, _render_setup, _detect_dev_tools, ContributingGenerator, _render_testing]
  - file: getting_started_gen.py
    area: docs
    modified: [_render_prerequisites, _render_installation, GettingStartedGenerator]
  - file: readme_gen.py
    area: docs
    modified: [ReadmeGenerator, _build_install_section, _build_quickstart_section]

stats:
  lines: "+9859/-9589 (net +270)"
  files: 15
  complexity: "Large structural change (normalized)"

Author: tom-sapletta-com

CHANGELOG.md

@@ -7,6 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.0.13] - 2026-03-09
+
+### Docs
+- Update project/context.md
+
+### Test
+- Update tests/project/dashboard.html
+- Update tests/project/project.yaml
+
+### Other
+- Update code2docs/analyzers/dependency_scanner.py
+- Update code2docs/generators/contributing_gen.py
+- Update code2docs/generators/getting_started_gen.py
+- Update code2docs/generators/readme_gen.py
+- Update project/analysis.json
+- Update project/analysis.toon
+- Update project/analysis.yaml
+- Update project/calls.mmd
+- Update project/dashboard.html
+- Update project/flow.mmd
+- ... and 4 more files
+
 ## [3.0.12] - 2026-03-09
 
 ### Docs

README.md

@@ -1,6 +1,6 @@
 # code2docs
 
-![version](https://img.shields.io/badge/version-3.0.12-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![docs](https://img.shields.io/badge/docs-auto--generated-blueviolet)
+![version](https://img.shields.io/badge/version-3.0.13-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![docs](https://img.shields.io/badge/docs-auto--generated-blueviolet)
 
 > Auto-generate and sync project documentation from source code analysis.
 
@@ -140,7 +140,7 @@ code2docs can update only specific sections of an existing README using markers:
 ```markdown
 <!-- code2docs:start --># code2docs
 
-![version](https://img.shields.io/badge/version-3.0.12-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![coverage](https://img.shields.io/badge/coverage-unknown-lightgrey) ![functions](https://img.shields.io/badge/functions-276-green)
+![version](https://img.shields.io/badge/version-3.0.13-blue) ![python](https://img.shields.io/badge/python-%3E%3D3.9-blue) ![coverage](https://img.shields.io/badge/coverage-unknown-lightgrey) ![functions](https://img.shields.io/badge/functions-276-green)
 > **276** functions | **57** classes | **51** files | CC̄ = 3.8
 
 > Auto-generated project documentation from source code analysis.

VERSION

@@ -1 +1 @@
-3.0.12
+3.0.13

code2docs/__init__.py

@@ -5,7 +5,7 @@
 README.md, API references, module docs, examples, and architecture diagrams.
 """
 
-__version__ = "3.0.12"
+__version__ = "3.0.13"
 __author__ = "Tom Sapletta"
 
 from .config import Code2DocsConfig

code2docs/analyzers/dependency_scanner.py

@@ -1,4 +1,4 @@
-"""Scan project dependencies from requirements.txt, pyproject.toml, setup.py."""
+"""Scan project dependencies from requirements.txt, pyproject.toml, setup.py, package.json, Cargo.toml, go.mod."""
 
 import re
 from dataclasses import dataclass, field
@@ -26,7 +26,9 @@ class DependencyInfo:
 @dataclass
 class ProjectDependencies:
     """All detected project dependencies."""
+    language: str = "python"
     python_version: str = ""
+    runtime_version: str = ""
     dependencies: List[DependencyInfo] = field(default_factory=list)
     dev_dependencies: List[DependencyInfo] = field(default_factory=list)
     optional_groups: Dict[str, List[DependencyInfo]] = field(default_factory=dict)
@@ -47,7 +49,31 @@ def scan(self, project_path: str) -> ProjectDependencies:
         project = Path(project_path)
         deps = ProjectDependencies()
 
-        # Priority: pyproject.toml > setup.py > requirements.txt
+        # Detect language from dependency files
+        # Priority: pyproject.toml > setup.py > requirements.txt (Python)
+        #           package.json (JS/TS) > Cargo.toml (Rust) > go.mod (Go)
+        package_json = project / "package.json"
+        if package_json.exists():
+            deps = self._parse_package_json(package_json)
+            deps.source_file = "package.json"
+            # Detect TypeScript
+            tsconfig = project / "tsconfig.json"
+            if tsconfig.exists():
+                deps.language = "typescript"
+            return deps
+
+        cargo_toml = project / "Cargo.toml"
+        if cargo_toml.exists():
+            deps = self._parse_cargo_toml(cargo_toml)
+            deps.source_file = "Cargo.toml"
+            return deps
+
+        go_mod = project / "go.mod"
+        if go_mod.exists():
+            deps = self._parse_go_mod(go_mod)
+            deps.source_file = "go.mod"
+            return deps
+
         pyproject = project / "pyproject.toml"
         if pyproject.exists():
             deps = self._parse_pyproject(pyproject)
@@ -159,6 +185,108 @@ def _parse_requirements_txt(self, path: Path) -> ProjectDependencies:
         deps.install_command = "pip install -r requirements.txt"
         return deps
 
+    def _parse_package_json(self, path: Path) -> ProjectDependencies:
+        """Parse package.json for dependencies."""
+        import json
+        deps = ProjectDependencies(language="javascript")
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            return deps
+
+        deps.version = data.get("version", "")
+        name = data.get("name", "")
+
+        # Node engine version
+        engines = data.get("engines", {})
+        deps.runtime_version = engines.get("node", "")
+
+        for dep_name, ver in data.get("dependencies", {}).items():
+            deps.dependencies.append(DependencyInfo(name=dep_name, version_spec=ver))
+
+        for dep_name, ver in data.get("devDependencies", {}).items():
+            deps.dev_dependencies.append(DependencyInfo(name=dep_name, version_spec=ver, group="dev"))
+
+        # Detect install command
+        lock_yarn = path.parent / "yarn.lock"
+        lock_pnpm = path.parent / "pnpm-lock.yaml"
+        if lock_pnpm.exists():
+            deps.install_command = "pnpm install"
+        elif lock_yarn.exists():
+            deps.install_command = "yarn install"
+        else:
+            deps.install_command = "npm install"
+
+        if name:
+            deps.keywords = data.get("keywords", [])
+
+        return deps
+
+    def _parse_cargo_toml(self, path: Path) -> ProjectDependencies:
+        """Parse Cargo.toml for Rust dependencies."""
+        deps = ProjectDependencies(language="rust")
+        content = path.read_text(encoding="utf-8")
+
+        # Version
+        ver_match = re.search(r'^version\s*=\s*"([^"]+)"', content, re.MULTILINE)
+        if ver_match:
+            deps.version = ver_match.group(1)
+
+        # Dependencies section
+        in_deps = False
+        in_dev_deps = False
+        for line in content.splitlines():
+            stripped = line.strip()
+            if stripped == "[dependencies]":
+                in_deps, in_dev_deps = True, False
+                continue
+            elif stripped == "[dev-dependencies]":
+                in_deps, in_dev_deps = False, True
+                continue
+            elif stripped.startswith("["):
+                in_deps, in_dev_deps = False, False
+                continue
+
+            dep_match = re.match(r'^([a-zA-Z0-9_-]+)\s*=\s*"?([^"\s]+)"?', stripped)
+            if dep_match:
+                info = DependencyInfo(name=dep_match.group(1), version_spec=dep_match.group(2))
+                if in_dev_deps:
+                    info.group = "dev"
+                    deps.dev_dependencies.append(info)
+                elif in_deps:
+                    deps.dependencies.append(info)
+
+        deps.install_command = "cargo build"
+        return deps
+
+    def _parse_go_mod(self, path: Path) -> ProjectDependencies:
+        """Parse go.mod for Go dependencies."""
+        deps = ProjectDependencies(language="go")
+        content = path.read_text(encoding="utf-8")
+
+        # Go version
+        go_ver = re.search(r'^go\s+(\S+)', content, re.MULTILINE)
+        if go_ver:
+            deps.runtime_version = go_ver.group(1)
+
+        # Require block
+        require_block = re.search(r'require\s*\((.*?)\)', content, re.DOTALL)
+        if require_block:
+            for line in require_block.group(1).splitlines():
+                line = line.strip()
+                if not line or line.startswith("//"):
+                    continue
+                parts = line.split()
+                if len(parts) >= 2:
+                    deps.dependencies.append(DependencyInfo(name=parts[0], version_spec=parts[1]))
+
+        # Single-line requires
+        for match in re.finditer(r'^require\s+(\S+)\s+(\S+)', content, re.MULTILINE):
+            deps.dependencies.append(DependencyInfo(name=match.group(1), version_spec=match.group(2)))
+
+        deps.install_command = "go mod download"
+        return deps
+
     @staticmethod
     def _parse_dep_string(dep_str: str) -> DependencyInfo:
         """Parse a dependency string like 'package>=1.0'."""

code2docs/generators/contributing_gen.py

@@ -41,6 +41,9 @@ def _detect_dev_tools(self) -> Dict[str, bool]:
         all_deps = {d.name.lower() for d in deps.dependencies}
         all_deps |= {d.name.lower() for d in deps.dev_dependencies}
         return {
+            "language": deps.language,
+            "install_command": deps.install_command,
+            # Python tools
             "pytest": "pytest" in all_deps,
             "black": "black" in all_deps,
             "ruff": "ruff" in all_deps,
@@ -49,22 +52,43 @@ def _detect_dev_tools(self) -> Dict[str, bool]:
             "isort": "isort" in all_deps,
             "pre-commit": "pre-commit" in all_deps,
             "tox": "tox" in all_deps,
+            # JS/TS tools
+            "eslint": "eslint" in all_deps,
+            "prettier": "prettier" in all_deps,
+            "jest": "jest" in all_deps,
+            "vitest": "vitest" in all_deps,
+            "typescript": "typescript" in all_deps,
         }
 
     def _render_setup(self, tools: Dict[str, bool]) -> str:
         """Render development setup instructions."""
         project = self.config.project_name or "project"
         repo_url = self.config.repo_url or "<repository-url>"
+        lang = tools.get("language", "python")
+        install_cmd = tools.get("install_command", "pip install -e .")
+
         lines = [
             "## Development Setup\n",
             "```bash",
             f"git clone {repo_url}",
             f"cd {project}",
-            "python -m venv .venv",
-            "source .venv/bin/activate  # or .venv\\Scripts\\activate on Windows",
-            "pip install -e \".[dev]\"",
-            "```",
         ]
+
+        if lang in ("javascript", "typescript"):
+            lines.append(install_cmd)
+        elif lang == "rust":
+            lines.append("cargo build")
+        elif lang == "go":
+            lines.append("go mod download")
+            lines.append("go build ./...")
+        else:
+            lines.extend([
+                "python -m venv .venv",
+                "source .venv/bin/activate  # or .venv\\Scripts\\activate on Windows",
+                'pip install -e ".[dev]"',
+            ])
+
+        lines.append("```")
         return "\n".join(lines)
 
     @staticmethod
@@ -83,8 +107,60 @@ def _render_development(tools: Dict[str, bool]) -> str:
     @staticmethod
     def _render_testing(tools: Dict[str, bool]) -> str:
         """Render testing instructions."""
+        lang = tools.get("language", "python")
         lines = ["## Testing\n"]
-        if tools.get("pytest"):
+
+        if lang in ("javascript", "typescript"):
+            if tools.get("vitest"):
+                lines.extend([
+                    "```bash",
+                    "# Run all tests",
+                    "npx vitest",
+                    "",
+                    "# Run with coverage",
+                    "npx vitest --coverage",
+                    "",
+                    "# Watch mode",
+                    "npx vitest --watch",
+                    "```",
+                ])
+            elif tools.get("jest"):
+                lines.extend([
+                    "```bash",
+                    "# Run all tests",
+                    "npx jest",
+                    "",
+                    "# Run with coverage",
+                    "npx jest --coverage",
+                    "```",
+                ])
+            else:
+                lines.extend([
+                    "```bash",
+                    "npm test",
+                    "```",
+                ])
+        elif lang == "rust":
+            lines.extend([
+                "```bash",
+                "# Run all tests",
+                "cargo test",
+                "",
+                "# Run a specific test",
+                "cargo test test_name",
+                "```",
+            ])
+        elif lang == "go":
+            lines.extend([
+                "```bash",
+                "# Run all tests",
+                "go test ./...",
+                "",
+                "# Run with coverage",
+                "go test -cover ./...",
+                "```",
+            ])
+        elif tools.get("pytest"):
             lines.extend([
                 "```bash",
                 "# Run all tests",
@@ -108,19 +184,37 @@ def _render_testing(tools: Dict[str, bool]) -> str:
     @staticmethod
     def _render_code_style(tools: Dict[str, bool]) -> str:
         """Render code style guidelines."""
+        lang = tools.get("language", "python")
         lines = ["## Code Style\n"]
-        if tools.get("black"):
-            lines.append("- **Formatting:** [Black](https://black.readthedocs.io/) — `black .`")
-        if tools.get("ruff"):
-            lines.append("- **Linting:** [Ruff](https://docs.astral.sh/ruff/) — `ruff check .`")
-        if tools.get("mypy"):
-            lines.append("- **Type checking:** [mypy](https://mypy.readthedocs.io/) — `mypy .`")
-        if tools.get("flake8"):
-            lines.append("- **Linting:** [flake8](https://flake8.pycqa.org/) — `flake8 .`")
-        if tools.get("isort"):
-            lines.append("- **Imports:** [isort](https://pycqa.github.io/isort/) — `isort .`")
-        if not any(tools.get(t) for t in ("black", "ruff", "mypy", "flake8", "isort")):
-            lines.append("Follow PEP 8 conventions.")
+
+        if lang in ("javascript", "typescript"):
+            if tools.get("eslint"):
+                lines.append("- **Linting:** [ESLint](https://eslint.org/) — `npx eslint .`")
+            if tools.get("prettier"):
+                lines.append("- **Formatting:** [Prettier](https://prettier.io/) — `npx prettier --write .`")
+            if tools.get("typescript"):
+                lines.append("- **Type checking:** TypeScript — `npx tsc --noEmit`")
+            if not any(tools.get(t) for t in ("eslint", "prettier")):
+                lines.append("Follow the project's ESLint/Prettier configuration.")
+        elif lang == "rust":
+            lines.append("- **Formatting:** `cargo fmt`")
+            lines.append("- **Linting:** `cargo clippy`")
+        elif lang == "go":
+            lines.append("- **Formatting:** `gofmt -w .`")
+            lines.append("- **Linting:** `go vet ./...`")
+        else:
+            if tools.get("black"):
+                lines.append("- **Formatting:** [Black](https://black.readthedocs.io/) — `black .`")
+            if tools.get("ruff"):
+                lines.append("- **Linting:** [Ruff](https://docs.astral.sh/ruff/) — `ruff check .`")
+            if tools.get("mypy"):
+                lines.append("- **Type checking:** [mypy](https://mypy.readthedocs.io/) — `mypy .`")
+            if tools.get("flake8"):
+                lines.append("- **Linting:** [flake8](https://flake8.pycqa.org/) — `flake8 .`")
+            if tools.get("isort"):
+                lines.append("- **Imports:** [isort](https://pycqa.github.io/isort/) — `isort .`")
+            if not any(tools.get(t) for t in ("black", "ruff", "mypy", "flake8", "isort")):
+                lines.append("Follow PEP 8 conventions.")
         return "\n".join(lines)
 
     @staticmethod