@famgia/omnify-cli 2.0.14 → 2.0.16

package/README.md

@@ -122,6 +122,58 @@ omnify generate --force
 omnify generate -v
 ```
 
+### `omnify ai-guides`
+
+Generate AI assistant guides (Cursor rules, Claude guides/rules, Antigravity rules).
+
+> This command loads `@famgia/omnify-ai-guides`. If it’s not installed, install it first:
+>
+> ```bash
+> pnpm add -D @famgia/omnify-ai-guides
+> ```
+
+```bash
+omnify ai-guides [options]
+```
+
+This command reads from `omnify.config.ts` (if present). Add `aiGuides` section:
+
+```typescript
+export default defineConfig({
+  // ... other config
+  aiGuides: {
+    typescriptBase: 'resources/ts',  // or 'resources/js', 'src', etc.
+    laravelBase: 'app',
+    categories: ['omnify', 'laravel', 'react'],  // optional
+    adapters: ['cursor', 'claude', 'antigravity'],  // optional
+  },
+});
+```
+
+Options (override config):
+
+```bash
+  -v, --verbose                  Enable verbose output
+  -c, --categories <categories>  Categories to generate (comma-separated: omnify,laravel,react)
+  -a, --adapters <adapters>      Adapters to use (comma-separated: cursor,claude,antigravity)
+  --laravel-base <path>          Laravel base path for placeholders
+  --typescript-base <path>       TypeScript base path for placeholders
+  --dry-run                      Show what would be generated without writing files
+```
+
+Common examples:
+
+```bash
+# API-only project (skip React)
+omnify ai-guides --categories omnify,laravel
+
+# Frontend-only (skip Laravel)
+omnify ai-guides --categories omnify,react
+
+# Only Cursor rules
+omnify ai-guides --adapters cursor
+```
+
 ### `omnify create-laravel-project`
 
 Create a new Laravel project from the boilerplate template.
@@ -187,13 +239,13 @@ export default defineConfig({
 
 ### Configuration Options
 
-| Option | Type | Required | Description |
-|--------|------|----------|-------------|
-| `schemasDir` | `string` | Yes | Directory containing schema files |
-| `lockFilePath` | `string` | Yes | Path to lock file for change tracking |
-| `database.driver` | `string` | Yes | Database driver: `mysql`, `postgres`, `sqlite` |
-| `database.devUrl` | `string` | Yes* | Development database URL for Atlas (*required for generate) |
-| `plugins` | `Plugin[]` | No | Array of generator plugins |
+| Option            | Type       | Required | Description                                                 |
+| ----------------- | ---------- | -------- | ----------------------------------------------------------- |
+| `schemasDir`      | `string`   | Yes      | Directory containing schema files                           |
+| `lockFilePath`    | `string`   | Yes      | Path to lock file for change tracking                       |
+| `database.driver` | `string`   | Yes      | Database driver: `mysql`, `postgres`, `sqlite`              |
+| `database.devUrl` | `string`   | Yes*     | Development database URL for Atlas (*required for generate) |
+| `plugins`         | `Plugin[]` | No       | Array of generator plugins                                  |
 
 ### Database URL Format
 
@@ -301,18 +353,18 @@ values:
 
 ## Exit Codes
 
-| Code | Meaning |
-|------|---------|
-| 0 | Success |
-| 1 | General error |
-| 2 | Validation error |
+| Code | Meaning          |
+| ---- | ---------------- |
+| 0    | Success          |
+| 1    | General error    |
+| 2    | Validation error |
 
 ## Environment Variables
 
-| Variable | Description |
-|----------|-------------|
+| Variable         | Description                          |
+| ---------------- | ------------------------------------ |
 | `OMNIFY_DEV_URL` | Override database.devUrl from config |
-| `DEBUG` | Set to `omnify:*` for debug output |
+| `DEBUG`          | Set to `omnify:*` for debug output   |
 
 ## Troubleshooting
 

package/dist/cli.js

@@ -839,7 +839,8 @@ async function resolveConfig(userConfig, configPath2) {
     lockFilePath: userConfig.lockFilePath ?? ".omnify.lock",
     discovery,
     ...userConfig.locale && { locale: userConfig.locale },
-    ...allSchemaPaths.length > 0 && { additionalSchemaPaths: allSchemaPaths }
+    ...allSchemaPaths.length > 0 && { additionalSchemaPaths: allSchemaPaths },
+    ...userConfig.aiGuides && { aiGuides: userConfig.aiGuides }
   };
   return result;
 }
@@ -1127,6 +1128,9 @@ import {
   isLockFileV2,
   validateMigrations,
   getMigrationsToRegenerate,
+  addEnhancedMigrationRecord,
+  extractTimestampFromFilename,
+  extractTableNameFromFilename,
   VERSION_CHAIN_FILE,
   readVersionChain,
   checkBulkLockViolation
@@ -1590,6 +1594,7 @@ function schemaChangeToVersionChange(change) {
 }
 function writeGeneratorOutputs(outputs, rootDir) {
   const counts = { migrations: 0, types: 0, models: 0, factories: 0, other: 0 };
+  const migrationRecords = [];
   for (const output of outputs) {
     const filePath = resolve9(rootDir, output.path);
     const dir = dirname6(filePath);
@@ -1603,13 +1608,34 @@ function writeGeneratorOutputs(outputs, rootDir) {
     }
     writeFileSync5(filePath, output.content);
     logger.debug(`Created: ${output.path}`);
-    if (output.type === "migration") counts.migrations++;
-    else if (output.type === "type") counts.types++;
+    if (output.type === "migration") {
+      counts.migrations++;
+      const fileName = output.path.split("/").pop() ?? output.path;
+      const timestamp = extractTimestampFromFilename(fileName);
+      const metaTableName = output.metadata?.tableName;
+      const tableName = metaTableName ?? extractTableNameFromFilename(fileName);
+      const migrationType = output.metadata?.migrationType;
+      const schemaName = output.metadata?.schemaName;
+      const pathParts = output.path.split("/");
+      pathParts.pop();
+      const outputPath = pathParts.join("/");
+      if (timestamp && tableName) {
+        migrationRecords.push({
+          fileName,
+          timestamp,
+          tableName,
+          type: migrationType ?? "create",
+          schemas: schemaName ? [schemaName] : [],
+          content: output.content,
+          outputPath
+        });
+      }
+    } else if (output.type === "type") counts.types++;
     else if (output.type === "model") counts.models++;
     else if (output.type === "factory") counts.factories++;
     else counts.other++;
   }
-  return counts;
+  return { ...counts, migrationRecords };
 }
 async function runPluginGeneration(plugins, schemas, rootDir, verbose, changes, localeConfig) {
   const pluginManager = new PluginManager({
@@ -1640,6 +1666,7 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
   let typesGenerated = 0;
   let modelsGenerated = 0;
   let factoriesGenerated = 0;
+  const migrationRecords = [];
   const customTypesMap = /* @__PURE__ */ new Map();
   for (const plugin of config.plugins) {
     if (plugin.types) {
@@ -1685,6 +1712,17 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
         writeFileSync5(filePath, migration.content);
         logger.debug(`Created: ${migration.fileName}`);
         migrationsGenerated++;
+        const timestamp = extractTimestampFromFilename(migration.fileName);
+        if (timestamp && tableName) {
+          migrationRecords.push({
+            fileName: migration.fileName,
+            timestamp,
+            tableName,
+            type: "create",
+            schemas: migration.schemaName ? [migration.schemaName] : [],
+            content: migration.content
+          });
+        }
       }
     }
     if (alterChanges.length > 0) {
@@ -1694,6 +1732,18 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
         writeFileSync5(filePath, migration.content);
         logger.debug(`Created: ${migration.fileName}`);
         migrationsGenerated++;
+        const timestamp = extractTimestampFromFilename(migration.fileName);
+        const tableName = migration.tables[0];
+        if (timestamp && tableName) {
+          migrationRecords.push({
+            fileName: migration.fileName,
+            timestamp,
+            tableName,
+            type: migration.type,
+            schemas: [],
+            content: migration.content
+          });
+        }
       }
     }
     logger.success(`Generated ${migrationsGenerated} migration(s)`);
@@ -1854,7 +1904,7 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
       logger.success("Auto-configured @omnify-base/* path in tsconfig.json");
     }
   }
-  return { migrations: migrationsGenerated, types: typesGenerated, models: modelsGenerated, factories: factoriesGenerated };
+  return { migrations: migrationsGenerated, types: typesGenerated, models: modelsGenerated, factories: factoriesGenerated, migrationRecords };
 }
 async function runGenerate(options) {
   logger.setVerbose(options.verbose ?? false);
@@ -2014,7 +2064,7 @@ async function runGenerate(options) {
   }
   if (existingLock && config.output.laravel?.migrationsPath) {
     const migrationsDir = resolve9(rootDir, config.output.laravel.migrationsPath);
-    const migrationValidation = await validateMigrations(existingLock, migrationsDir);
+    const migrationValidation = await validateMigrations(existingLock, migrationsDir, rootDir);
     if (!migrationValidation.valid) {
       logger.newline();
       logger.warn("Migration file issues detected:");
@@ -2073,7 +2123,7 @@ async function runGenerate(options) {
         const alterMigrations = toRegenerate.filter((m) => m.type === "alter" || m.type === "drop");
         if (createMigrations.length > 0) {
           logger.info(`Regenerating ${createMigrations.length} missing CREATE migration(s) with original timestamps...`);
-          const migrationsDir2 = resolve9(rootDir, config.output.laravel.migrationsPath);
+          const defaultMigrationsDir = resolve9(rootDir, config.output.laravel.migrationsPath);
           const customTypesMap2 = /* @__PURE__ */ new Map();
           for (const plugin of config.plugins) {
             if (plugin.types) {
@@ -2094,11 +2144,20 @@ async function runGenerate(options) {
               timestamp: migData.timestamp,
               customTypes: customTypesMap2
             });
-            for (const mig of regenerated) {
-              const filePath = resolve9(migrationsDir2, migData.fileName);
-              writeFileSync5(filePath, mig.content);
-              logger.success(`  Regenerated: ${migData.fileName}`);
+            const matchingMig = regenerated.find((mig) => {
+              return mig.tables.includes(migData.tableName);
+            });
+            if (!matchingMig) {
+              logger.warn(`  Cannot regenerate ${migData.fileName}: migration for table '${migData.tableName}' not found`);
+              continue;
             }
+            const targetDir = migData.outputPath ? resolve9(rootDir, migData.outputPath) : defaultMigrationsDir;
+            if (!existsSync9(targetDir)) {
+              mkdirSync3(targetDir, { recursive: true });
+            }
+            const filePath = resolve9(targetDir, migData.fileName);
+            writeFileSync5(filePath, matchingMig.content);
+            logger.success(`  Regenerated: ${migData.fileName}`);
           }
         }
         if (alterMigrations.length > 0) {
@@ -2128,6 +2187,7 @@ async function runGenerate(options) {
   let typesGenerated = 0;
   let modelsGenerated = 0;
   let factoriesGenerated = 0;
+  let allMigrationRecords = [];
   const usePlugins = hasPluginGenerators(config.plugins);
   const customTypesMap = /* @__PURE__ */ new Map();
   for (const plugin of config.plugins) {
@@ -2157,6 +2217,7 @@ async function runGenerate(options) {
     );
     migrationsGenerated = counts.migrations;
     typesGenerated = counts.types;
+    allMigrationRecords = counts.migrationRecords;
     if (counts.migrations > 0) {
       logger.success(`Generated ${counts.migrations} migration(s)`);
     }
@@ -2282,9 +2343,24 @@ async function runGenerate(options) {
     typesGenerated = counts.types;
     modelsGenerated = counts.models;
     factoriesGenerated = counts.factories;
+    allMigrationRecords = counts.migrationRecords;
   }
   logger.step("Updating lock file...");
-  const newLockFile = updateLockFile(existingLock, currentSnapshots, config.database.driver);
+  let newLockFile = updateLockFile(existingLock, currentSnapshots, config.database.driver);
+  if (allMigrationRecords.length > 0) {
+    logger.debug(`Adding ${allMigrationRecords.length} migration(s) to lock file...`);
+    for (const record of allMigrationRecords) {
+      newLockFile = addEnhancedMigrationRecord(newLockFile, {
+        fileName: record.fileName,
+        timestamp: record.timestamp,
+        tableName: record.tableName,
+        type: record.type,
+        schemas: record.schemas,
+        content: record.content,
+        outputPath: record.outputPath
+      });
+    }
+  }
   await writeLockFile(lockPath, newLockFile);
   logger.debug(`Updated: ${config.lockFilePath}`);
   if (comparison.hasChanges) {
@@ -3252,6 +3328,110 @@ function registerVerifyCommand(program2) {
   });
 }
 
+// src/commands/ai-guides.ts
+async function runAIGuides(options) {
+  logger.setVerbose(options.verbose ?? false);
+  logger.header("Generating AI Guides");
+  let generateAIGuides2;
+  let getAvailableCategories;
+  try {
+    const aiGuidesModule = await import("@famgia/omnify-ai-guides");
+    generateAIGuides2 = aiGuidesModule.generateAIGuides;
+    getAvailableCategories = aiGuidesModule.getAvailableCategories;
+  } catch (error) {
+    logger.error("Failed to load @famgia/omnify-ai-guides package");
+    logger.error("Please install it: pnpm add @famgia/omnify-ai-guides");
+    throw error;
+  }
+  const rootDir = process.cwd();
+  let configAiGuides;
+  try {
+    const { config } = await loadConfig();
+    configAiGuides = config.aiGuides;
+    if (configAiGuides) {
+      logger.debug("Loaded aiGuides config from omnify.config.ts");
+    }
+  } catch {
+    logger.debug("No omnify.config.ts found, using defaults");
+  }
+  let categories = getAvailableCategories();
+  if (options.categories) {
+    categories = options.categories.split(",").map((c) => c.trim());
+    logger.debug(`Categories (from CLI): ${categories.join(", ")}`);
+  } else if (configAiGuides?.categories) {
+    categories = [...configAiGuides.categories];
+    logger.debug(`Categories (from config): ${categories.join(", ")}`);
+  }
+  let adapters;
+  if (options.adapters) {
+    adapters = options.adapters.split(",").map((a) => a.trim());
+    logger.debug(`Adapters (from CLI): ${adapters.join(", ")}`);
+  } else if (configAiGuides?.adapters) {
+    adapters = [...configAiGuides.adapters];
+    logger.debug(`Adapters (from config): ${adapters.join(", ")}`);
+  }
+  const placeholders = {
+    LARAVEL_BASE: options.laravelBase ?? configAiGuides?.laravelBase ?? "app",
+    LARAVEL_ROOT: "",
+    TYPESCRIPT_BASE: options.typescriptBase ?? configAiGuides?.typescriptBase ?? "resources/ts"
+  };
+  logger.step("Generating guides...");
+  logger.debug(`Root directory: ${rootDir}`);
+  logger.debug(`Laravel base: ${placeholders.LARAVEL_BASE}`);
+  logger.debug(`TypeScript base: ${placeholders.TYPESCRIPT_BASE}`);
+  logger.debug(`Categories: ${JSON.stringify(categories)}`);
+  logger.debug(`Adapters: ${JSON.stringify(adapters)}`);
+  const result = generateAIGuides2(rootDir, {
+    categories,
+    adapters,
+    placeholders,
+    dryRun: options.dryRun
+  });
+  const claudeCount = result.counts["claude"] || 0;
+  const cursorCount = result.counts["cursor"] || 0;
+  const antigravityCount = result.counts["antigravity"] || 0;
+  const totalCount = claudeCount + cursorCount + antigravityCount;
+  if (options.dryRun) {
+    logger.info("[DRY RUN] Would generate:");
+  }
+  if (claudeCount > 0) {
+    logger.success(`  ${claudeCount} Claude files (.claude/)`);
+  }
+  if (cursorCount > 0) {
+    logger.success(`  ${cursorCount} Cursor rules (.cursor/rules/)`);
+  }
+  if (antigravityCount > 0) {
+    logger.success(`  ${antigravityCount} Antigravity rules (.agent/rules/)`);
+  }
+  if (result.errors?.length) {
+    logger.newline();
+    logger.warn("Warnings:");
+    for (const error of result.errors) {
+      logger.warn(`  ${error}`);
+    }
+  }
+  logger.newline();
+  logger.success(`Generated ${totalCount} AI guide files!`);
+}
+function registerAIGuidesCommand(program2) {
+  program2.command("ai-guides").description("Generate AI assistant guides (Cursor, Claude, Antigravity). Reads from omnify.config.ts").option("-v, --verbose", "Enable verbose output").option(
+    "-c, --categories <categories>",
+    "Categories to generate (comma-separated: omnify,laravel,react). Overrides config"
+  ).option(
+    "-a, --adapters <adapters>",
+    "Adapters to use (comma-separated: cursor,claude,antigravity). Overrides config"
+  ).option("--laravel-base <path>", "Laravel base path for placeholders. Overrides config").option("--typescript-base <path>", "TypeScript base path for placeholders. Overrides config").option("--dry-run", "Show what would be generated without writing files").action(async (opts) => {
+    try {
+      await runAIGuides(opts);
+    } catch (error) {
+      if (error instanceof Error) {
+        logger.error(error.message);
+      }
+      process.exit(1);
+    }
+  });
+}
+
 // src/cli.ts
 var VERSION = "0.0.5";
 var program = new Command();
@@ -3264,6 +3444,7 @@ registerResetCommand(program);
 registerCreateProjectCommand(program);
 registerDeployCommand(program);
 registerVerifyCommand(program);
+registerAIGuidesCommand(program);
 process.on("uncaughtException", (error) => {
   if (error instanceof OmnifyError7) {
     logger.formatError(error);