@makinzm/mille 0.0.11 → 0.0.13

package/README.md

@@ -18,11 +18,12 @@ One TOML config. Rust-powered. CI-ready. Supports multiple languages from a sing
 
 ## What it checks
 
-| Check | Rust | Go | TypeScript | JavaScript | Python |
-|---|:---:|:---:|:---:|:---:|:---:|
-| Layer dependency rules (`dependency_mode`) | ✅ | ✅ | ✅ | ✅ | ✅ |
-| External library rules (`external_mode`) | ✅ | ✅ | ✅ | ✅ | ✅ |
-| DI method call rules (`allow_call_patterns`) | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Check | Rust | Go | TypeScript | JavaScript | Python | Java | Kotlin | PHP |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| Layer dependency rules (`dependency_mode`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| External library rules (`external_mode`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| DI method call rules (`allow_call_patterns`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Naming convention rules (`name_deny`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 
 ## Install
 
@@ -120,10 +121,28 @@ The generated config includes `allow` (inferred internal dependencies) and `exte
 
 **Python submodule imports**: `external_allow = ["matplotlib"]` correctly allows both `import matplotlib` and `import matplotlib.pyplot`.
 
+**Python `src/` layout (namespace packages)**: When your project uses a `src/` layout and imports like `from src.domain.entity import Foo`, `mille init` detects that `src` is used as a top-level import prefix and automatically adds it to `package_names`. This means `from src.domain...` is classified as Internal and `src` does not appear in `external_allow`. Cross-layer imports like `from src.domain.entity import Foo` (written in `src/infrastructure/`) are correctly resolved to the `src/domain` layer and appear as an `allow` dependency in the generated `mille.toml`. Files at the project root of a sub-tree (e.g. `src/main.py`) are included in the `src` layer rather than being silently skipped.
+
 **Go projects**: `mille init` reads `go.mod` and generates `[resolve.go] module_name` automatically — internal module imports are classified correctly during `mille check`. External packages appear in `external_allow` with their full import paths (e.g. `"github.com/cilium/ebpf"`, `"fmt"`, `"net/http"`).
 
 **TypeScript/JavaScript subpath imports**: `external_allow = ["vitest"]` correctly allows both `import "vitest"` and `import "vitest/config"`. Scoped packages (`@scope/name/sub`) are matched by `"@scope/name"`.
 
+**Java/Kotlin projects**: `mille init` uses `package` declarations — not directory depth — to detect layers. This works correctly for Maven's `src/main/java/com/example/myapp/domain/` as well as flat `src/domain/` layouts. `pom.xml` (Maven) and `build.gradle` + `settings.gradle` (Gradle) are read automatically to generate `[resolve.java] module_name`. Layer paths use `**/layer/**` globs so `mille check` matches regardless of the source root depth.
+
+```
+Detected languages: java
+Scanning imports...
+
+Inferred layer structure:
+  domain               ← (no internal dependencies)
+  infrastructure       → domain
+    external: java.util.List
+  usecase              → domain
+  main                 → domain, infrastructure, usecase
+
+Generated 'mille.toml'
+```
+
 ### 2. (Or) Create `mille.toml` manually
 
 Place `mille.toml` in your project root:
@@ -284,6 +303,42 @@ external_mode   = "opt-out"
 external_deny   = []
 ```
 
+**Java / Kotlin:**
+
+```toml
+[project]
+name      = "my-java-app"
+root      = "."
+languages = ["java"]   # or ["kotlin"] for Kotlin projects
+
+[resolve.java]
+module_name = "com.example.myapp"
+
+[[layers]]
+name            = "domain"
+paths           = ["src/domain/**"]
+dependency_mode = "opt-in"
+allow           = []
+external_mode   = "opt-out"
+
+[[layers]]
+name            = "usecase"
+paths           = ["src/usecase/**"]
+dependency_mode = "opt-in"
+allow           = ["domain"]
+external_mode   = "opt-out"
+
+[[layers]]
+name            = "infrastructure"
+paths           = ["src/infrastructure/**"]
+dependency_mode = "opt-in"
+allow           = ["domain"]
+external_mode   = "opt-in"
+external_allow  = ["java.util.List", "java.util.Map"]
+```
+
+> `module_name` is the base package of your project (e.g. `com.example.myapp`). Imports starting with this prefix are classified as **Internal** and matched against layer globs. All other imports (including `java.util.*` stdlib) are classified as **External** and subject to `external_allow` / `external_deny` rules.
+
 ### 2. Visualize with `mille analyze`
 
 Before enforcing rules, you can inspect the actual dependency graph:
@@ -364,7 +419,7 @@ Exit codes:
 |---|---|
 | `name` | Project name |
 | `root` | Root directory for analysis |
-| `languages` | Languages to check: `"rust"`, `"go"`, `"typescript"`, `"javascript"`, `"python"` |
+| `languages` | Languages to check: `"rust"`, `"go"`, `"typescript"`, `"javascript"`, `"python"`, `"java"`, `"kotlin"`, `"php"` |
 
 ### `[[layers]]`
 
@@ -378,6 +433,43 @@ Exit codes:
 | `external_mode` | `"opt-in"` or `"opt-out"` for external library usage |
 | `external_allow` | Allowed external packages (when `external_mode = "opt-in"`) |
 | `external_deny` | Forbidden external packages (when `external_mode = "opt-out"`) |
+| `name_deny` | Forbidden keywords for naming convention check (case-insensitive partial match) |
+| `name_allow` | Substrings to strip before `name_deny` check (e.g. `"category"` prevents `"go"` match inside it) |
+| `name_targets` | Targets to check: `"file"`, `"symbol"`, `"variable"`, `"comment"` (default: all) |
+| `name_deny_ignore` | Glob patterns for files to exclude from naming checks (e.g. `"**/test_*.rs"`) |
+
+#### Naming Convention Check (`name_deny`)
+
+Forbid infrastructure-specific keywords from appearing in a layer's names.
+
+```toml
+[[layers]]
+name = "usecase"
+paths = ["src/usecase/**"]
+dependency_mode = "opt-out"
+deny = []
+external_mode = "opt-out"
+external_deny = []
+
+# Usecase layer must not reference specific infrastructure technologies
+name_deny    = ["gcp", "aws", "azure", "mysql", "postgres"]
+name_allow   = ["category"]   # "category" contains "go" but should not be flagged
+name_targets = ["file", "symbol", "variable", "comment"]  # default: all targets
+name_deny_ignore = ["**/test_*.rs", "tests/**"]  # exclude test files from naming checks
+```
+
+**Rules:**
+- Case-insensitive (`GCP` = `gcp` = `Gcp`)
+- Partial match (`ManageGcp` also matches `gcp`)
+- `name_allow` strips listed substrings before matching (e.g. `"category"` prevents false positive on `"go"`)
+- `name_deny_ignore` excludes files matching glob patterns from naming checks entirely
+- `name_targets` restricts which entity types are checked:
+  - `"file"`: file basename (e.g. `aws_client.rs`)
+  - `"symbol"`: function, class, struct, enum, trait, interface, type alias names
+  - `"variable"`: variable, const, let, static declaration names
+  - `"comment"`: inline comment content
+- Supported languages: Rust, TypeScript, JavaScript, Python, Go, Java, Kotlin, PHP
+- Severity is controlled by `severity.naming_violation` (default: `"error"`)
 
 ### `[[layers.allow_call_patterns]]`
 
@@ -418,6 +510,7 @@ Control the severity level of each violation type. Violations can be `"error"`,
 | `external_violation` | `"error"` | External library rule violated |
 | `call_pattern_violation` | `"error"` | DI entrypoint method call rule violated |
 | `unknown_import` | `"warning"` | Import that could not be classified |
+| `naming_violation` | `"error"` | Naming convention rule violated (`name_deny`) |
 
 ```toml
 [severity]
@@ -425,6 +518,7 @@ dependency_violation   = "warning"   # treat as warning for gradual adoption
 external_violation     = "error"
 call_pattern_violation = "error"
 unknown_import         = "warning"
+naming_violation       = "warning"   # treat as warning while rolling out naming rules
 ```
 
 Use `--fail-on warning` to exit 1 even for warnings when integrating into CI gradually.
@@ -466,6 +560,72 @@ Use `--fail-on warning` to exit 1 even for warnings when integrating into CI gra
 | `import domain.entity` (matches `package_names`) | Internal |
 | `import os`, `import sqlalchemy` | External |
 
+### `[resolve.java]`
+
+| Key | Description |
+|---|---|
+| `module_name` | Base package of your project (e.g. `com.example.myapp`). Imports starting with this prefix are classified as Internal. Generated automatically by `mille init`. |
+| `pom_xml` | Path to `pom.xml` (relative to `mille.toml`). `groupId.artifactId` is used as `module_name` when `module_name` is not set. |
+| `build_gradle` | Path to `build.gradle` (relative to `mille.toml`). `group` + `rootProject.name` from `settings.gradle` is used as `module_name` when `module_name` is not set. |
+
+**How Java imports are classified:**
+
+| Import | Classification |
+|---|---|
+| `import com.example.myapp.domain.User` (starts with `module_name`) | Internal |
+| `import static com.example.myapp.util.Helper.method` | Internal |
+| `import java.util.List`, `import org.springframework.*` | External |
+
+> Both regular and static imports are supported. Wildcard imports (`import java.util.*`) are not yet extracted by the parser.
+
+### `[resolve.php]`
+
+| Key | Description |
+|---|---|
+| `namespace` | Base namespace of your project (e.g. `App`). Imports starting with this prefix are classified as Internal. |
+| `composer_json` | Path to `composer.json` (relative to `mille.toml`). The first PSR-4 key in `autoload.psr-4` is used as the base namespace when `namespace` is not set. |
+
+**How PHP imports are classified:**
+
+| Import | Classification |
+|---|---|
+| `use App\Models\User` (starts with `namespace`) | Internal |
+| `use App\Services\{Auth, Logger}` (group use, expanded) | Internal |
+| `use function App\Helpers\format_date` | Internal |
+| `use DateTime`, `use PDO`, `use Exception` | Stdlib |
+| `use Illuminate\Http\Request` | External |
+
+> Supported use forms: simple, aliased (`as`), grouped (`{}`), `use function`, `use const`.
+> PHP stdlib classes (DateTime, PDO, Exception, etc.) are automatically classified as Stdlib without any configuration.
+
+**Example `mille.toml` for a Laravel project:**
+
+```toml
+[project]
+name    = "my-laravel-app"
+root    = "."
+languages = ["php"]
+
+[[layers]]
+name  = "domain"
+paths = ["app/Domain/**"]
+
+[[layers]]
+name  = "application"
+paths = ["app/Application/**"]
+dependency_mode = "opt-in"
+allow = ["domain"]
+
+[[layers]]
+name  = "infrastructure"
+paths = ["app/Infrastructure/**"]
+dependency_mode = "opt-in"
+allow = ["domain", "application"]
+
+[resolve.php]
+composer_json = "composer.json"   # auto-detects "App\\" from autoload.psr-4
+```
+
 ## How it Works
 
 mille uses [tree-sitter](https://tree-sitter.github.io/) for AST-based import extraction — no regex heuristics.
@@ -476,7 +636,7 @@ mille.toml
     ▼
 Layer definitions
     │
-Source files (*.rs, *.go, *.py, *.ts, *.js, ...)
+Source files (*.rs, *.go, *.py, *.ts, *.js, *.java, ...)
     │ tree-sitter parse
     ▼
 RawImport list

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@makinzm/mille",
-    "version": "0.0.11",
+    "version": "0.0.13",
     "description": "Architecture Checker — Rust-based multi-language architecture linter",
     "main": "index.js",
     "bin": {