@famgia/omnify-laravel 0.0.88 → 0.0.89

package/dist/{chunk-YVVAJA3T.js → chunk-V7LWJ6OM.js}

@@ -1,6 +1,6 @@
 // src/plugin.ts
-import { readFileSync, existsSync, readdirSync } from "fs";
-import { join } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join2 } from "path";
 
 // src/migration/schema-builder.ts
 import { resolveLocalizedString } from "@famgia/omnify-types";
@@ -3921,6 +3921,151 @@ function getResourcePath(resource) {
   return resource.path;
 }
 
+// src/ai-guides/generator.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function getStubsDir() {
+  const devPath = resolve(__dirname, "../../stubs/ai-guides");
+  if (existsSync(devPath)) {
+    return devPath;
+  }
+  const distPath = resolve(__dirname, "../stubs/ai-guides");
+  if (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 (!existsSync(srcDir)) {
+    return writtenFiles;
+  }
+  if (!existsSync(destDir)) {
+    mkdirSync(destDir, { recursive: true });
+  }
+  const entries = readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry.name);
+    if (entry.isDirectory()) {
+      const subDestDir = 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 = join(destDir, destName);
+      let content = readFileSync(srcPath, "utf-8");
+      if (transform) {
+        content = transform(content);
+      }
+      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 = join(stubsDir, "laravel");
+  const claudeDestDir = resolve(rootDir, ".claude/omnify/guides/laravel");
+  if (existsSync(claudeSrcDir)) {
+    const files = copyStubs(claudeSrcDir, claudeDestDir);
+    result.claudeGuides = files.length;
+    result.files.push(...files);
+  }
+  const claudeRulesSrcDir = join(stubsDir, "claude-rules");
+  const claudeRulesDestDir = resolve(rootDir, ".claude/omnify/rules");
+  if (existsSync(claudeRulesSrcDir)) {
+    const files = copyStubs(claudeRulesSrcDir, claudeRulesDestDir);
+    result.claudeRules = files.length;
+    result.files.push(...files);
+  }
+  const claudeChecklistsSrcDir = join(stubsDir, "claude-checklists");
+  const claudeChecklistsDestDir = resolve(rootDir, ".claude/omnify/checklists");
+  if (existsSync(claudeChecklistsSrcDir)) {
+    const files = copyStubs(claudeChecklistsSrcDir, claudeChecklistsDestDir);
+    result.claudeChecklists = files.length;
+    result.files.push(...files);
+  }
+  const claudeWorkflowsSrcDir = join(stubsDir, "claude-workflows");
+  const claudeWorkflowsDestDir = resolve(rootDir, ".claude/omnify/workflows");
+  if (existsSync(claudeWorkflowsSrcDir)) {
+    const files = copyStubs(claudeWorkflowsSrcDir, claudeWorkflowsDestDir);
+    result.claudeWorkflows = files.length;
+    result.files.push(...files);
+  }
+  const claudeAgentsSrcDir = join(stubsDir, "claude-agents");
+  const claudeAgentsDestDir = resolve(rootDir, ".claude/omnify/agents");
+  if (existsSync(claudeAgentsSrcDir)) {
+    const files = copyStubs(claudeAgentsSrcDir, claudeAgentsDestDir);
+    result.claudeAgents = files.length;
+    result.files.push(...files);
+  }
+  const claudeOmnifySrcDir = join(stubsDir, "claude-omnify");
+  const claudeOmnifyDestDir = resolve(rootDir, ".claude/omnify/guides/omnify");
+  if (existsSync(claudeOmnifySrcDir)) {
+    const files = copyStubs(claudeOmnifySrcDir, claudeOmnifyDestDir);
+    result.claudeOmnify = files.length;
+    result.files.push(...files);
+  }
+  const cursorSrcDir = join(stubsDir, "cursor");
+  const cursorDestDir = resolve(rootDir, ".cursor/rules/omnify");
+  if (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 = resolve(rootDir, ".claude/omnify/guides/laravel");
+  const cursorDir = resolve(rootDir, ".cursor/rules/omnify");
+  if (!existsSync(claudeDir) || !existsSync(cursorDir)) {
+    return true;
+  }
+  try {
+    const claudeFiles = readdirSync(claudeDir);
+    const cursorFiles = 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, "/");
@@ -3936,11 +4081,11 @@ function inferLaravelRoot(providersPath) {
 }
 function getExistingMigrationTables(migrationsDir) {
   const existingTables = /* @__PURE__ */ new Set();
-  if (!existsSync(migrationsDir)) {
+  if (!existsSync2(migrationsDir)) {
     return existingTables;
   }
   try {
-    const files = readdirSync(migrationsDir);
+    const files = readdirSync2(migrationsDir);
     const createMigrationPattern = /^\d{4}_\d{2}_\d{2}_\d{6}_create_(.+)_table\.php$/;
     for (const file of files) {
       const match = file.match(createMigrationPattern);
@@ -4106,7 +4251,7 @@ function laravelPlugin(options) {
         customTypes: ctx.customTypes
       };
       const outputs = [];
-      const migrationsDir = join(ctx.cwd, resolved.migrationsPath);
+      const migrationsDir = join2(ctx.cwd, resolved.migrationsPath);
       const existingTables = getExistingMigrationTables(migrationsDir);
       if (ctx.changes !== void 0) {
         if (ctx.changes.length === 0) {
@@ -4206,20 +4351,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 = join(ctx.cwd, bootstrapProvidersRelPath);
-      const configAppPath = join(ctx.cwd, configAppRelPath);
+      const bootstrapProvidersPath = join2(ctx.cwd, bootstrapProvidersRelPath);
+      const configAppPath = join2(ctx.cwd, configAppRelPath);
       let existingContent = null;
       let laravelVersion;
-      if (existsSync(bootstrapProvidersPath)) {
+      if (existsSync2(bootstrapProvidersPath)) {
         laravelVersion = "laravel11+";
         try {
-          existingContent = readFileSync(bootstrapProvidersPath, "utf-8");
+          existingContent = readFileSync2(bootstrapProvidersPath, "utf-8");
         } catch {
           existingContent = null;
         }
-      } else if (existsSync(configAppPath)) {
+      } else if (existsSync2(configAppPath)) {
         try {
-          const configContent = readFileSync(configAppPath, "utf-8");
+          const configContent = readFileSync2(configAppPath, "utf-8");
           if (/'providers'\s*=>\s*\[/.test(configContent)) {
             laravelVersion = "laravel10-";
             existingContent = configContent;
@@ -4332,6 +4477,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);
@@ -4345,6 +4508,7 @@ function laravelPlugin(options) {
   if (resolved.generateResources) {
     generators.push(resourceGenerator);
   }
+  generators.push(aiGuidesGenerator);
   return {
     name: "@famgia/omnify-laravel",
     version: "0.0.14",
@@ -4378,6 +4542,8 @@ export {
   generateProviderRegistration,
   generateFactories,
   getFactoryPath,
+  generateAIGuides,
+  shouldGenerateAIGuides,
   laravelPlugin
 };
-//# sourceMappingURL=chunk-YVVAJA3T.js.map
+//# sourceMappingURL=chunk-V7LWJ6OM.js.map