@omnifyjp/omnify 5.8.18 → 5.8.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/omnify",
-  "version": "5.8.18",
+  "version": "5.8.20",
   "description": "Schema-driven code generation for Laravel, TypeScript, and SQL",
   "license": "MIT",
   "repository": {
@@ -36,10 +36,10 @@
     "zod": "^3.24.0"
   },
   "optionalDependencies": {
-    "@omnifyjp/omnify-darwin-arm64": "5.8.18",
-    "@omnifyjp/omnify-darwin-x64": "5.8.18",
-    "@omnifyjp/omnify-linux-x64": "5.8.18",
-    "@omnifyjp/omnify-linux-arm64": "5.8.18",
-    "@omnifyjp/omnify-win32-x64": "5.8.18"
+    "@omnifyjp/omnify-darwin-arm64": "5.8.20",
+    "@omnifyjp/omnify-darwin-x64": "5.8.20",
+    "@omnifyjp/omnify-linux-x64": "5.8.20",
+    "@omnifyjp/omnify-linux-arm64": "5.8.20",
+    "@omnifyjp/omnify-win32-x64": "5.8.20"
   }
 }

package/ts-dist/cli.js

@@ -30,7 +30,8 @@ import { parse as parseYaml } from 'yaml';
 import { generateTypeScript } from './generator.js';
 import { generatePhp, derivePhpConfig } from './php/index.js';
 import { pruneOrphanServiceFiles } from './php/orphan-cleanup.js';
-import { findSiblingWithSameBasename } from './php/sibling-skip.js';
+import { findSiblingWithSameBasename, findAppRootAncestor } from './php/sibling-skip.js';
+import { runPintFormat } from './php/pint-format.js';
 import { resolveInput, sniffInputKind } from './input-resolver.js';
 function resolveFromConfig(configPath) {
     const raw = readFileSync(configPath, 'utf-8');
@@ -222,6 +223,7 @@ program
         let phpSkipped = 0;
         let phpSkippedSibling = 0;
         const skippedSiblingExamples = [];
+        const writtenPaths = [];
         for (const file of phpFiles) {
             const filePath = resolve(configDir, file.path);
             mkdirSync(dirname(filePath), { recursive: true });
@@ -229,21 +231,29 @@ program
                 phpSkipped++;
                 continue;
             }
-            // Issue #98 v5.8.18: skip user-editable stub when a project-owned
-            // sibling with the same basename exists elsewhere in the layer's
-            // editable subtree (e.g. project organizes Requests by domain
-            // folder `Admin/BrandStoreRequest.php` while omnify wanted to
-            // emit the FLAT default stub `BrandStoreRequest.php` at the
-            // layer root). The flat stub is unused noise in that layout,
-            // and every `omnify generate` would otherwise re-create it,
-            // forcing the dev to delete it manually after each run.
-            // Only applies to user-editable files (overwrite=false); base
-            // files always regenerate. Scope: scan ONLY the file's parent
-            // directory recursively — not sibling directories — so a
-            // grouped `Cms/<Name>.php` stub doesn't get skipped by an
-            // unrelated `Admin/<Name>.php`.
+            // Issue #98 v5.8.18 / #99 v5.8.19: skip user-editable stub
+            // when a project-owned sibling with the same basename exists
+            // elsewhere under the project's `app/` root. Two patterns
+            // covered:
+            //   1. Domain subfolder organization (#98 v5.8.18): project
+            //      hand-writes `app/Http/Requests/Admin/BrandStoreRequest.php`;
+            //      omnify wants to emit the flat default
+            //      `app/Http/Requests/BrandStoreRequest.php`. The flat
+            //      stub is unused noise.
+            //   2. v4 → v5 upgrade (#99 v5.8.19): project has v4 wrapper at
+            //      `app/Services/Omnify/<Name>Service.php`; v5 wants to
+            //      emit at the new modular path
+            //      `app/Omnify/Services/<Name>Service.php`. Two wrappers
+            //      compete; the v4 one carries the project's actual logic.
+            //
+            // Scope: scan from the project's `app/` directory (walked up
+            // from the target). Falls back to the file's parent dir when
+            // no `app/` ancestor is found (e.g. unusual rootPath layout).
+            // Only applies to user-editable files (`overwrite=false`); base
+            // files always regenerate.
             if (!file.overwrite) {
-                const collision = findSiblingWithSameBasename(dirname(filePath), basename(filePath), filePath);
+                const scanRoot = findAppRootAncestor(filePath) ?? dirname(filePath);
+                const collision = findSiblingWithSameBasename(scanRoot, basename(filePath), filePath);
                 if (collision) {
                     phpSkippedSibling++;
                     if (skippedSiblingExamples.length < 3) {
@@ -253,6 +263,7 @@ program
                 }
             }
             writeFileSync(filePath, file.content, 'utf-8');
+            writtenPaths.push(filePath);
             if (file.overwrite || !existsSync(filePath)) {
                 phpOverwritten++;
             }
@@ -274,6 +285,26 @@ program
                 console.log(`    ... and ${phpSkippedSibling - skippedSiblingExamples.length} more`);
             }
         }
+        // Issue #100 v5.8.20: auto-format every written PHP file via
+        // Laravel Pint when it's installed in the project. Same preset
+        // the project's CI already uses, so codegen output stops failing
+        // `pint --test` and devs no longer need a manual sweep after
+        // every `omnify generate`. Silent no-op when Pint isn't found.
+        if (writtenPaths.length > 0) {
+            const pintResult = runPintFormat(writtenPaths);
+            if (pintResult.ran) {
+                if (pintResult.exitStatus === 0) {
+                    console.log(`  Formatted ${pintResult.formattedCount} PHP file(s) via Laravel Pint`);
+                }
+                else {
+                    console.warn(`  [omnify] Laravel Pint exited with status ${pintResult.exitStatus}; generated files may not match project formatting preset.`);
+                    if (pintResult.errorMessage) {
+                        const trimmed = pintResult.errorMessage.trim().split('\n').slice(0, 5).join('\n');
+                        console.warn(`  ${trimmed}`);
+                    }
+                }
+            }
+        }
         // Orphan cleanup: when a schema is removed, renamed, flipped from
         // kind:object → kind:pivot, or opted out via `options.service: false`,
         // its previously-emitted `*ServiceBase.php` becomes orphan and

package/ts-dist/php/pint-format.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Auto-format generated PHP files via Laravel Pint. Issue #100 v5.8.20.
+ *
+ * Reporter scenario (godx-jp/godx-kintai 2026-04-26 audit): every
+ * `omnify generate --force` produces 150+ PHP files that fail Laravel
+ * Pint's standard preset (`vendor/bin/pint --test`):
+ *
+ *   - ordered_imports — `use` statements not alphabetised
+ *   - fully_qualified_strict_types — exception types referenced via FQN
+ *   - class_attributes_separation — missing blank lines between members
+ *   - function_declaration — function-keyword spacing
+ *   - unary_operator_spaces — `! \$x` vs `!\$x`
+ *   - no_unused_imports — codegen leaves the occasional dangling import
+ *   - single_line_empty_body — empty class bodies on multiple lines
+ *   - self_static_accessor — `self::` vs `static::` on enums
+ *   - blank_line_before_statement — enum `case` separators
+ *
+ * Auto-detect: when `<rootPath>/vendor/bin/pint` exists, run it on the
+ * files we just wrote. Same Pint preset the project's CI already uses,
+ * so no risk of formatter drift between codegen and CI checks.
+ *
+ * Opt-out: future config field; for now `chmod -x vendor/bin/pint` or
+ * deleting it disables the auto-run.
+ */
+/**
+ * Resolve the `vendor/bin/pint` path for the project. Walks up from
+ * the first written file until we find a sibling `vendor/bin/pint`,
+ * stopping at filesystem root or after 12 levels (defensive against
+ * pathological inputs). Returns the absolute path or null.
+ */
+export declare function findPintBinary(anyWrittenPhpPath: string): string | null;
+export interface PintFormatResult {
+    ran: boolean;
+    pintPath: string | null;
+    /** Files passed to pint. */
+    formattedCount: number;
+    /** Pint's exit status if it ran. 0 = success. */
+    exitStatus: number | null;
+    /** Captured stderr when pint failed (status != 0). */
+    errorMessage?: string;
+}
+/**
+ * Run Laravel Pint on the given PHP files (absolute paths). No-op if
+ * Pint isn't installed in the project. Pint is invoked with `--quiet`
+ * so it stays out of the way unless something breaks.
+ *
+ * Pint takes a list of files (or directories) and formats them in
+ * place. It uses the project's `pint.json` config if present, else the
+ * Laravel preset.
+ */
+export declare function runPintFormat(writtenPhpPaths: string[]): PintFormatResult;

package/ts-dist/php/pint-format.js

@@ -0,0 +1,92 @@
+/**
+ * Auto-format generated PHP files via Laravel Pint. Issue #100 v5.8.20.
+ *
+ * Reporter scenario (godx-jp/godx-kintai 2026-04-26 audit): every
+ * `omnify generate --force` produces 150+ PHP files that fail Laravel
+ * Pint's standard preset (`vendor/bin/pint --test`):
+ *
+ *   - ordered_imports — `use` statements not alphabetised
+ *   - fully_qualified_strict_types — exception types referenced via FQN
+ *   - class_attributes_separation — missing blank lines between members
+ *   - function_declaration — function-keyword spacing
+ *   - unary_operator_spaces — `! \$x` vs `!\$x`
+ *   - no_unused_imports — codegen leaves the occasional dangling import
+ *   - single_line_empty_body — empty class bodies on multiple lines
+ *   - self_static_accessor — `self::` vs `static::` on enums
+ *   - blank_line_before_statement — enum `case` separators
+ *
+ * Auto-detect: when `<rootPath>/vendor/bin/pint` exists, run it on the
+ * files we just wrote. Same Pint preset the project's CI already uses,
+ * so no risk of formatter drift between codegen and CI checks.
+ *
+ * Opt-out: future config field; for now `chmod -x vendor/bin/pint` or
+ * deleting it disables the auto-run.
+ */
+import { existsSync, statSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+/**
+ * Resolve the `vendor/bin/pint` path for the project. Walks up from
+ * the first written file until we find a sibling `vendor/bin/pint`,
+ * stopping at filesystem root or after 12 levels (defensive against
+ * pathological inputs). Returns the absolute path or null.
+ */
+export function findPintBinary(anyWrittenPhpPath) {
+    let cur = dirname(anyWrittenPhpPath);
+    for (let i = 0; i < 12; i++) {
+        const candidate = join(cur, 'vendor', 'bin', 'pint');
+        if (existsSync(candidate)) {
+            try {
+                const st = statSync(candidate);
+                if (st.isFile())
+                    return candidate;
+            }
+            catch {
+                // ignore stat errors and keep climbing
+            }
+        }
+        const parent = dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return null;
+}
+/**
+ * Run Laravel Pint on the given PHP files (absolute paths). No-op if
+ * Pint isn't installed in the project. Pint is invoked with `--quiet`
+ * so it stays out of the way unless something breaks.
+ *
+ * Pint takes a list of files (or directories) and formats them in
+ * place. It uses the project's `pint.json` config if present, else the
+ * Laravel preset.
+ */
+export function runPintFormat(writtenPhpPaths) {
+    if (writtenPhpPaths.length === 0) {
+        return { ran: false, pintPath: null, formattedCount: 0, exitStatus: null };
+    }
+    const pintPath = findPintBinary(writtenPhpPaths[0]);
+    if (!pintPath) {
+        return { ran: false, pintPath: null, formattedCount: 0, exitStatus: null };
+    }
+    // Pint's working dir should be the Laravel project root (where
+    // composer.json + pint.json live). The pint binary is at
+    // `<projectRoot>/vendor/bin/pint`, so projectRoot is two parents up.
+    const projectRoot = dirname(dirname(dirname(pintPath)));
+    // Pass each file as its own arg. Pint accepts multiple file/dir
+    // arguments; capping the batch is unnecessary up to a few hundred
+    // files (well under the OS arg limit).
+    const result = spawnSync(pintPath, ['--quiet', ...writtenPhpPaths], {
+        cwd: projectRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        encoding: 'utf-8',
+    });
+    const exitStatus = result.status ?? null;
+    return {
+        ran: true,
+        pintPath,
+        formattedCount: writtenPhpPaths.length,
+        exitStatus,
+        errorMessage: exitStatus !== 0 ? (result.stderr || result.stdout || undefined) : undefined,
+    };
+}

package/ts-dist/php/sibling-skip.d.ts

@@ -1,26 +1,39 @@
 /**
- * User-editable stub collision detection. Issue #98 v5.8.18.
+ * User-editable stub collision detection. Issue #98 v5.8.18 / #99 v5.8.19.
  *
  * Many Laravel projects organize Requests / Resources / Services by
- * domain subfolder (`Admin/`, `Cms/`, `Audit/`, etc.) BEFORE adopting
- * omnify. When omnify then emits the FLAT default stub at the layer
- * root (e.g. `app/Http/Requests/BrandStoreRequest.php`), the stub
- * collides ergonomically with the project's hand-written
- * `app/Http/Requests/Admin/BrandStoreRequest.php` — same basename,
- * unused by any caller, gets re-created every `omnify generate`,
- * forcing the dev to delete it manually.
+ * domain subfolder (`Admin/`, `Cms/`, `Audit/`) BEFORE adopting omnify,
+ * OR they upgrade from v4 with wrappers at v4 paths
+ * (`app/Services/Omnify/<Name>Service.php`) and v5 wants to emit at
+ * the new modular path (`app/Omnify/Services/<Name>Service.php`). In
+ * both cases the auto-emitted user-editable stub is unused noise that
+ * regenerates every `omnify generate`, forcing the dev to delete it.
  *
- * Detection: scan the file's PARENT DIRECTORY recursively for any
+ * Detection: scan a configurable root directory recursively for any
  * file with the same basename. If found at a path != target, skip
  * emission.
  *
- * Scope rule: scan ONLY the file's parent directory (and its subdirs),
- * NOT sibling directories. So a grouped editable at `Cms/Banner.php`
- * isn't skipped by an unrelated `Admin/Banner.php`.
+ * Scope decision:
+ *   - Wide scope (e.g. project's `app/`): finds cross-layer wrappers
+ *     like the v4 → v5 upgrade case (#99).
+ *   - Narrow scope (file's parent dir): finds same-layer siblings only,
+ *     like a domain-organized `Admin/Brand.php` next to the flat
+ *     default (#98 v5.8.18).
  *
- * Bounded by `MAX_FILES_SCANNED` so a project root with tens of
- * thousands of files doesn't grind generate to a halt.
+ * The CLI passes whichever scope matches the layout. Bounded by
+ * `MAX_FILES_SCANNED` so a project with tens of thousands of files
+ * doesn't grind generate to a halt.
  */
+/**
+ * Walk up from `filePath` looking for the closest ancestor directory
+ * named `app`. Returns its absolute path or null. Used by the CLI to
+ * pick a project-wide search root for sibling-skip — covers v4 → v5
+ * cross-layer wrappers (e.g. v4 wrapper at `app/Services/Omnify/<X>Service.php`
+ * vs v5 modular emit at `app/Omnify/Services/<X>Service.php`). Capped
+ * at 12 levels of climbing so we don't traverse the entire FS on a
+ * malformed input.
+ */
+export declare function findAppRootAncestor(filePath: string): string | null;
 /**
  * Scan `rootDir` recursively for a file whose basename matches
  * `baseName`, excluding `excludePath` itself. Returns the first

package/ts-dist/php/sibling-skip.js

@@ -1,29 +1,53 @@
 /**
- * User-editable stub collision detection. Issue #98 v5.8.18.
+ * User-editable stub collision detection. Issue #98 v5.8.18 / #99 v5.8.19.
  *
  * Many Laravel projects organize Requests / Resources / Services by
- * domain subfolder (`Admin/`, `Cms/`, `Audit/`, etc.) BEFORE adopting
- * omnify. When omnify then emits the FLAT default stub at the layer
- * root (e.g. `app/Http/Requests/BrandStoreRequest.php`), the stub
- * collides ergonomically with the project's hand-written
- * `app/Http/Requests/Admin/BrandStoreRequest.php` — same basename,
- * unused by any caller, gets re-created every `omnify generate`,
- * forcing the dev to delete it manually.
+ * domain subfolder (`Admin/`, `Cms/`, `Audit/`) BEFORE adopting omnify,
+ * OR they upgrade from v4 with wrappers at v4 paths
+ * (`app/Services/Omnify/<Name>Service.php`) and v5 wants to emit at
+ * the new modular path (`app/Omnify/Services/<Name>Service.php`). In
+ * both cases the auto-emitted user-editable stub is unused noise that
+ * regenerates every `omnify generate`, forcing the dev to delete it.
  *
- * Detection: scan the file's PARENT DIRECTORY recursively for any
+ * Detection: scan a configurable root directory recursively for any
  * file with the same basename. If found at a path != target, skip
  * emission.
  *
- * Scope rule: scan ONLY the file's parent directory (and its subdirs),
- * NOT sibling directories. So a grouped editable at `Cms/Banner.php`
- * isn't skipped by an unrelated `Admin/Banner.php`.
+ * Scope decision:
+ *   - Wide scope (e.g. project's `app/`): finds cross-layer wrappers
+ *     like the v4 → v5 upgrade case (#99).
+ *   - Narrow scope (file's parent dir): finds same-layer siblings only,
+ *     like a domain-organized `Admin/Brand.php` next to the flat
+ *     default (#98 v5.8.18).
  *
- * Bounded by `MAX_FILES_SCANNED` so a project root with tens of
- * thousands of files doesn't grind generate to a halt.
+ * The CLI passes whichever scope matches the layout. Bounded by
+ * `MAX_FILES_SCANNED` so a project with tens of thousands of files
+ * doesn't grind generate to a halt.
  */
 import { existsSync, readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 const MAX_FILES_SCANNED = 5000;
+/**
+ * Walk up from `filePath` looking for the closest ancestor directory
+ * named `app`. Returns its absolute path or null. Used by the CLI to
+ * pick a project-wide search root for sibling-skip — covers v4 → v5
+ * cross-layer wrappers (e.g. v4 wrapper at `app/Services/Omnify/<X>Service.php`
+ * vs v5 modular emit at `app/Omnify/Services/<X>Service.php`). Capped
+ * at 12 levels of climbing so we don't traverse the entire FS on a
+ * malformed input.
+ */
+export function findAppRootAncestor(filePath) {
+    let cur = dirname(filePath);
+    for (let i = 0; i < 12; i++) {
+        if (basename(cur) === 'app')
+            return cur;
+        const parent = dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return null;
+}
 /**
  * Scan `rootDir` recursively for a file whose basename matches
  * `baseName`, excluding `excludePath` itself. Returns the first