@famgia/omnify-laravel 0.0.87 → 0.0.89

package/dist/index.cjs

@@ -24,6 +24,7 @@ __export(index_exports, {
   formatForeignKey: () => formatForeignKey,
   formatIndex: () => formatIndex,
   formatMigrationFile: () => formatMigrationFile,
+  generateAIGuides: () => generateAIGuides,
   generateAlterMigration: () => generateAlterMigration,
   generateDropMigrationForTable: () => generateDropMigrationForTable,
   generateDropTableMigration: () => generateDropTableMigration,
@@ -43,6 +44,7 @@ __export(index_exports, {
   laravelPlugin: () => laravelPlugin,
   propertyToColumnMethod: () => propertyToColumnMethod,
   schemaToBlueprint: () => schemaToBlueprint,
+  shouldGenerateAIGuides: () => shouldGenerateAIGuides,
   toColumnName: () => toColumnName,
   toTableName: () => toTableName
 });
@@ -2637,8 +2639,8 @@ function getFactoryPath(factory) {
 }
 
 // src/plugin.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
 
 // src/request/generator.ts
 var import_omnify_types3 = require("@famgia/omnify-types");
@@ -3971,6 +3973,152 @@ function getResourcePath(resource) {
   return resource.path;
 }
 
+// src/ai-guides/generator.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_url = require("url");
+var import_meta = {};
+var __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
+var __dirname = (0, import_node_path.dirname)(__filename);
+function getStubsDir() {
+  const devPath = (0, import_node_path.resolve)(__dirname, "../../stubs/ai-guides");
+  if ((0, import_node_fs.existsSync)(devPath)) {
+    return devPath;
+  }
+  const distPath = (0, import_node_path.resolve)(__dirname, "../stubs/ai-guides");
+  if ((0, import_node_fs.existsSync)(distPath)) {
+    return distPath;
+  }
+  throw new Error("AI guides stubs not found");
+}
+function extractLaravelBasePath(modelsPath) {
+  if (!modelsPath) return "app";
+  const normalized = modelsPath.replace(/\\/g, "/");
+  const match = normalized.match(/^(.+?)\/Models(?:\/.*)?$/);
+  if (match && match[1]) {
+    return match[1];
+  }
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length > 1) {
+    return parts.slice(0, -1).join("/");
+  }
+  return "app";
+}
+function replacePlaceholders(content, basePath) {
+  return content.replace(/\{\{LARAVEL_BASE\}\}/g, basePath);
+}
+function copyStubs(srcDir, destDir, transform) {
+  const writtenFiles = [];
+  if (!(0, import_node_fs.existsSync)(srcDir)) {
+    return writtenFiles;
+  }
+  if (!(0, import_node_fs.existsSync)(destDir)) {
+    (0, import_node_fs.mkdirSync)(destDir, { recursive: true });
+  }
+  const entries = (0, import_node_fs.readdirSync)(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = (0, import_node_path.join)(srcDir, entry.name);
+    if (entry.isDirectory()) {
+      const subDestDir = (0, import_node_path.join)(destDir, entry.name);
+      const subFiles = copyStubs(srcPath, subDestDir, transform);
+      writtenFiles.push(...subFiles);
+    } else if (entry.isFile() && entry.name.endsWith(".stub")) {
+      const destName = entry.name.slice(0, -5);
+      const destPath = (0, import_node_path.join)(destDir, destName);
+      let content = (0, import_node_fs.readFileSync)(srcPath, "utf-8");
+      if (transform) {
+        content = transform(content);
+      }
+      (0, import_node_fs.writeFileSync)(destPath, content);
+      writtenFiles.push(destPath);
+    }
+  }
+  return writtenFiles;
+}
+function generateAIGuides(rootDir, options = {}) {
+  const stubsDir = getStubsDir();
+  const basePath = options.laravelBasePath || extractLaravelBasePath(options.modelsPath);
+  const result = {
+    claudeGuides: 0,
+    claudeRules: 0,
+    claudeChecklists: 0,
+    claudeWorkflows: 0,
+    claudeAgents: 0,
+    claudeOmnify: 0,
+    cursorRules: 0,
+    files: []
+  };
+  const claudeSrcDir = (0, import_node_path.join)(stubsDir, "laravel");
+  const claudeDestDir = (0, import_node_path.resolve)(rootDir, ".claude/omnify/guides/laravel");
+  if ((0, import_node_fs.existsSync)(claudeSrcDir)) {
+    const files = copyStubs(claudeSrcDir, claudeDestDir);
+    result.claudeGuides = files.length;
+    result.files.push(...files);
+  }
+  const claudeRulesSrcDir = (0, import_node_path.join)(stubsDir, "claude-rules");
+  const claudeRulesDestDir = (0, import_node_path.resolve)(rootDir, ".claude/omnify/rules");
+  if ((0, import_node_fs.existsSync)(claudeRulesSrcDir)) {
+    const files = copyStubs(claudeRulesSrcDir, claudeRulesDestDir);
+    result.claudeRules = files.length;
+    result.files.push(...files);
+  }
+  const claudeChecklistsSrcDir = (0, import_node_path.join)(stubsDir, "claude-checklists");
+  const claudeChecklistsDestDir = (0, import_node_path.resolve)(rootDir, ".claude/omnify/checklists");
+  if ((0, import_node_fs.existsSync)(claudeChecklistsSrcDir)) {
+    const files = copyStubs(claudeChecklistsSrcDir, claudeChecklistsDestDir);
+    result.claudeChecklists = files.length;
+    result.files.push(...files);
+  }
+  const claudeWorkflowsSrcDir = (0, import_node_path.join)(stubsDir, "claude-workflows");
+  const claudeWorkflowsDestDir = (0, import_node_path.resolve)(rootDir, ".claude/omnify/workflows");
+  if ((0, import_node_fs.existsSync)(claudeWorkflowsSrcDir)) {
+    const files = copyStubs(claudeWorkflowsSrcDir, claudeWorkflowsDestDir);
+    result.claudeWorkflows = files.length;
+    result.files.push(...files);
+  }
+  const claudeAgentsSrcDir = (0, import_node_path.join)(stubsDir, "claude-agents");
+  const claudeAgentsDestDir = (0, import_node_path.resolve)(rootDir, ".claude/omnify/agents");
+  if ((0, import_node_fs.existsSync)(claudeAgentsSrcDir)) {
+    const files = copyStubs(claudeAgentsSrcDir, claudeAgentsDestDir);
+    result.claudeAgents = files.length;
+    result.files.push(...files);
+  }
+  const claudeOmnifySrcDir = (0, import_node_path.join)(stubsDir, "claude-omnify");
+  const claudeOmnifyDestDir = (0, import_node_path.resolve)(rootDir, ".claude/omnify/guides/omnify");
+  if ((0, import_node_fs.existsSync)(claudeOmnifySrcDir)) {
+    const files = copyStubs(claudeOmnifySrcDir, claudeOmnifyDestDir);
+    result.claudeOmnify = files.length;
+    result.files.push(...files);
+  }
+  const cursorSrcDir = (0, import_node_path.join)(stubsDir, "cursor");
+  const cursorDestDir = (0, import_node_path.resolve)(rootDir, ".cursor/rules/omnify");
+  if ((0, import_node_fs.existsSync)(cursorSrcDir)) {
+    const files = copyStubs(
+      cursorSrcDir,
+      cursorDestDir,
+      (content) => replacePlaceholders(content, basePath)
+    );
+    result.cursorRules = files.length;
+    result.files.push(...files);
+  }
+  return result;
+}
+function shouldGenerateAIGuides(rootDir) {
+  const claudeDir = (0, import_node_path.resolve)(rootDir, ".claude/omnify/guides/laravel");
+  const cursorDir = (0, import_node_path.resolve)(rootDir, ".cursor/rules/omnify");
+  if (!(0, import_node_fs.existsSync)(claudeDir) || !(0, import_node_fs.existsSync)(cursorDir)) {
+    return true;
+  }
+  try {
+    const claudeFiles = (0, import_node_fs.readdirSync)(claudeDir);
+    const cursorFiles = (0, import_node_fs.readdirSync)(cursorDir);
+    const hasLaravelRules = cursorFiles.some((f) => f.startsWith("laravel"));
+    return claudeFiles.length === 0 || !hasLaravelRules;
+  } catch {
+    return true;
+  }
+}
+
 // src/plugin.ts
 function inferLaravelRoot(providersPath) {
   const normalized = providersPath.replace(/\\/g, "/");
@@ -3986,11 +4134,11 @@ function inferLaravelRoot(providersPath) {
 }
 function getExistingMigrationTables(migrationsDir) {
   const existingTables = /* @__PURE__ */ new Set();
-  if (!(0, import_node_fs.existsSync)(migrationsDir)) {
+  if (!(0, import_node_fs2.existsSync)(migrationsDir)) {
     return existingTables;
   }
   try {
-    const files = (0, import_node_fs.readdirSync)(migrationsDir);
+    const files = (0, import_node_fs2.readdirSync)(migrationsDir);
     const createMigrationPattern = /^\d{4}_\d{2}_\d{2}_\d{6}_create_(.+)_table\.php$/;
     for (const file of files) {
       const match = file.match(createMigrationPattern);
@@ -4156,7 +4304,7 @@ function laravelPlugin(options) {
         customTypes: ctx.customTypes
       };
       const outputs = [];
-      const migrationsDir = (0, import_node_path.join)(ctx.cwd, resolved.migrationsPath);
+      const migrationsDir = (0, import_node_path2.join)(ctx.cwd, resolved.migrationsPath);
       const existingTables = getExistingMigrationTables(migrationsDir);
       if (ctx.changes !== void 0) {
         if (ctx.changes.length === 0) {
@@ -4256,20 +4404,20 @@ function laravelPlugin(options) {
       const laravelRoot = inferLaravelRoot(resolved.providersPath);
       const bootstrapProvidersRelPath = laravelRoot ? `${laravelRoot}/bootstrap/providers.php` : "bootstrap/providers.php";
       const configAppRelPath = laravelRoot ? `${laravelRoot}/config/app.php` : "config/app.php";
-      const bootstrapProvidersPath = (0, import_node_path.join)(ctx.cwd, bootstrapProvidersRelPath);
-      const configAppPath = (0, import_node_path.join)(ctx.cwd, configAppRelPath);
+      const bootstrapProvidersPath = (0, import_node_path2.join)(ctx.cwd, bootstrapProvidersRelPath);
+      const configAppPath = (0, import_node_path2.join)(ctx.cwd, configAppRelPath);
       let existingContent = null;
       let laravelVersion;
-      if ((0, import_node_fs.existsSync)(bootstrapProvidersPath)) {
+      if ((0, import_node_fs2.existsSync)(bootstrapProvidersPath)) {
         laravelVersion = "laravel11+";
         try {
-          existingContent = (0, import_node_fs.readFileSync)(bootstrapProvidersPath, "utf-8");
+          existingContent = (0, import_node_fs2.readFileSync)(bootstrapProvidersPath, "utf-8");
         } catch {
           existingContent = null;
         }
-      } else if ((0, import_node_fs.existsSync)(configAppPath)) {
+      } else if ((0, import_node_fs2.existsSync)(configAppPath)) {
         try {
-          const configContent = (0, import_node_fs.readFileSync)(configAppPath, "utf-8");
+          const configContent = (0, import_node_fs2.readFileSync)(configAppPath, "utf-8");
           if (/'providers'\s*=>\s*\[/.test(configContent)) {
             laravelVersion = "laravel10-";
             existingContent = configContent;
@@ -4382,6 +4530,24 @@ function laravelPlugin(options) {
       }));
     }
   };
+  const aiGuidesGenerator = {
+    name: "laravel-ai-guides",
+    description: "Generate AI assistant guides (Claude, Cursor) for Laravel development",
+    generate: async (ctx) => {
+      if (!shouldGenerateAIGuides(ctx.cwd)) {
+        ctx.logger.debug("AI guides already exist, skipping");
+        return [];
+      }
+      const result = generateAIGuides(ctx.cwd, {
+        modelsPath: resolved.modelsPath,
+        migrationsPath: resolved.migrationsPath,
+        laravelBasePath: "app"
+      });
+      const claudeTotal = result.claudeGuides + result.claudeRules + result.claudeChecklists + result.claudeWorkflows + result.claudeAgents + result.claudeOmnify;
+      ctx.logger.info(`Generated ${claudeTotal} Claude files, ${result.cursorRules} Cursor rules`);
+      return [];
+    }
+  };
   const generators = [migrationGenerator];
   if (resolved.generateModels) {
     generators.push(modelGenerator);
@@ -4395,6 +4561,7 @@ function laravelPlugin(options) {
   if (resolved.generateResources) {
     generators.push(resourceGenerator);
   }
+  generators.push(aiGuidesGenerator);
   return {
     name: "@famgia/omnify-laravel",
     version: "0.0.14",
@@ -4408,6 +4575,7 @@ function laravelPlugin(options) {
   formatForeignKey,
   formatIndex,
   formatMigrationFile,
+  generateAIGuides,
   generateAlterMigration,
   generateDropMigrationForTable,
   generateDropTableMigration,
@@ -4427,6 +4595,7 @@ function laravelPlugin(options) {
   laravelPlugin,
   propertyToColumnMethod,
   schemaToBlueprint,
+  shouldGenerateAIGuides,
   toColumnName,
   toTableName
 });