@makinzm/mille 0.0.12 → 0.0.14

package/README.md

@@ -2,27 +2,20 @@
 
 > Like a mille crêpe — your architecture, one clean layer at a time.
 
-```
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  presentation
-  · · · · · · · · · · · · · · · · · ·  (deps only flow inward)
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  infrastructure
-  · · · · · · · · · · · · · · · · · ·
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  usecase
-  · · · · · · · · · · · · · · · · · ·
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  domain
-```
-
 `mille` is a static analysis CLI that enforces **dependency rules for layered architectures** — Clean Architecture, Onion Architecture, Hexagonal Architecture, and more.
 
 One TOML config. Rust-powered. CI-ready. Supports multiple languages from a single config file.
 
 ## What it checks
 
-| Check | Rust | Go | TypeScript | JavaScript | Python | Java | Kotlin |
-|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| Layer dependency rules (`dependency_mode`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-| External library rules (`external_mode`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-| DI method call rules (`allow_call_patterns`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+**Languages:** Rust, Go, TypeScript, JavaScript, Python, Java, Kotlin, PHP, C
+
+| Check | Description |
+|---|---|
+| `dependency_mode` | Layer dependency rules — control which layers can import from which |
+| `external_mode` | External library rules — restrict third-party package usage per layer |
+| `allow_call_patterns` | DI method call rules — limit which methods may be called on injected types |
+| `name_deny` | Naming convention rules — forbid infrastructure keywords in domain/usecase |
 
 ## Install
 
@@ -120,6 +113,8 @@ 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"`.
@@ -416,7 +411,7 @@ Exit codes:
 |---|---|
 | `name` | Project name |
 | `root` | Root directory for analysis |
-| `languages` | Languages to check: `"rust"`, `"go"`, `"typescript"`, `"javascript"`, `"python"`, `"java"`, `"kotlin"` |
+| `languages` | Languages to check: `"rust"`, `"go"`, `"typescript"`, `"javascript"`, `"python"`, `"java"`, `"kotlin"`, `"php"`, `"c"` |
 
 ### `[[layers]]`
 
@@ -430,6 +425,45 @@ 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"`, `"string_literal"`, `"identifier"` (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", "string_literal", "identifier"]  # 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
+  - `"string_literal"`: string literal content
+  - `"identifier"`: attribute/field access identifiers (e.g. `gcp` in `cfg.gcp.bucket`)
+- Supported languages: Rust, TypeScript, JavaScript, Python, Go, Java, Kotlin, PHP, C
+- Severity is controlled by `severity.naming_violation` (default: `"error"`)
 
 ### `[[layers.allow_call_patterns]]`
 
@@ -470,6 +504,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]
@@ -477,6 +512,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.
@@ -536,6 +572,83 @@ Use `--fail-on warning` to exit 1 even for warnings when integrating into CI gra
 
 > 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
+```
+
+### C
+
+> `#include "..."` is classified as Internal (project header). `#include <...>` is classified as Stdlib (standard/POSIX headers) or External (third-party libraries).
+
+**Example `mille.toml` for a C project:**
+
+```toml
+[project]
+name    = "my-c-app"
+root    = "."
+languages = ["c"]
+
+[[layers]]
+name  = "domain"
+paths = ["src/domain/**"]
+
+[[layers]]
+name  = "usecase"
+paths = ["src/usecase/**"]
+dependency_mode = "opt-in"
+allow = ["domain"]
+
+[[layers]]
+name  = "infrastructure"
+paths = ["src/infrastructure/**"]
+dependency_mode = "opt-in"
+allow = ["domain"]
+```
+
 ## How it Works
 
 mille uses [tree-sitter](https://tree-sitter.github.io/) for AST-based import extraction — no regex heuristics.

package/package.json

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