@famgia/omnify-ai-guides 2.0.15

package/README.md

@@ -0,0 +1,105 @@
+# @famgia/omnify-ai-guides
+
+Generate **AI Guides** for your Omnify project:
+
+- **Cursor rules** → `.cursor/rules/omnify/*.mdc`
+- **Claude guides** → `.claude/omnify/guides/**`
+- **Claude rules** → `.claude/rules/omnify/*.md`
+- **Antigravity rules** → `.agent/rules/omnify/*.md`
+
+This package is intentionally **separated** from Laravel/TypeScript generators to avoid mixing concerns.
+
+## Install
+
+```bash
+pnpm add -D @famgia/omnify-ai-guides
+```
+
+## CLI usage (recommended)
+
+The CLI command is provided by `@famgia/omnify-cli` and loads this package dynamically.
+
+```bash
+# Generate all categories (omnify, laravel, react)
+npx omnify ai-guides
+```
+
+### Configuration via `omnify.config.ts`
+
+Add `aiGuides` to your `omnify.config.ts`:
+
+```typescript
+import { defineConfig } from '@famgia/omnify';
+
+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
+  },
+});
+```
+
+CLI options override config values.
+
+### Filter by category
+
+```bash
+# API-only Laravel project (skip React rules)
+npx omnify ai-guides --categories omnify,laravel
+
+# Frontend-only (skip Laravel rules)
+npx omnify ai-guides --categories omnify,react
+```
+
+### Customize base paths (globs placeholders)
+
+```bash
+# Change TypeScript base path used in Cursor/Antigravity globs
+npx omnify ai-guides --typescript-base resources/js
+
+# Change Laravel base path used in globs
+npx omnify ai-guides --laravel-base app
+```
+
+### Filter by adapter
+
+```bash
+# Only Cursor rules
+npx omnify ai-guides --adapters cursor
+```
+
+### Dry run
+
+```bash
+npx omnify ai-guides --dry-run
+```
+
+## Plugin usage (optional)
+
+You can also run it as an Omnify plugin generator (if you want it in `omnify generate`):
+
+```ts
+import { defineConfig } from '@famgia/omnify';
+import aiGuides from '@famgia/omnify-ai-guides/plugin';
+
+export default defineConfig({
+  plugins: [
+    aiGuides({
+      categories: ['omnify', 'laravel'], // for example
+      typescriptBasePath: 'resources/ts',
+      laravelBasePath: 'app',
+      adapters: ['cursor', 'claude', 'antigravity'],
+    }),
+  ],
+});
+```
+
+## Notes
+
+- This package writes files directly under `.cursor/`, `.claude/`, `.agent/`.
+- If you don’t install `@famgia/omnify-ai-guides`, the CLI will prompt you to install it when you run `omnify ai-guides`.
+

package/dist/chunk-RCTEXK7C.js

@@ -0,0 +1,549 @@
+// src/plugin.ts
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/generator.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from "fs";
+import { resolve, dirname, join, basename } from "path";
+import { fileURLToPath } from "url";
+import { parse as parseYaml } from "yaml";
+
+// src/adapters/cursor.ts
+function replacePlaceholders(content, placeholders) {
+  let result = content;
+  for (const [key, value] of Object.entries(placeholders)) {
+    result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+  }
+  return result;
+}
+var cursorAdapter = {
+  name: "cursor",
+  outputDir: ".cursor/rules/omnify",
+  transform(content, rule, placeholders) {
+    const target = rule.targets.cursor;
+    let transformedContent = replacePlaceholders(content, placeholders);
+    if (transformedContent.startsWith("---")) {
+      return transformedContent;
+    }
+    const description = target?.description || "";
+    const globs = target?.globs || [];
+    const alwaysApply = target?.alwaysApply ?? false;
+    const frontmatter = `---
+description: "${description}"
+globs: ${JSON.stringify(globs)}
+alwaysApply: ${alwaysApply}
+---
+
+`;
+    return frontmatter + transformedContent;
+  },
+  getFilename(rule) {
+    const target = rule.targets.cursor;
+    if (target?.filename) {
+      return target.filename;
+    }
+    return `${rule.id}.mdc`;
+  },
+  isEnabled(rule) {
+    const target = rule.targets.cursor;
+    return target?.enabled ?? false;
+  },
+  getOutputPath(rule) {
+    const filename = this.getFilename(rule);
+    return filename;
+  }
+};
+
+// src/adapters/claude.ts
+function replacePlaceholders2(content, placeholders) {
+  let result = content;
+  for (const [key, value] of Object.entries(placeholders)) {
+    result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+  }
+  return result;
+}
+var claudeAdapter = {
+  name: "claude",
+  outputDir: ".claude/omnify",
+  transform(content, _rule, placeholders) {
+    return replacePlaceholders2(content, placeholders);
+  },
+  getFilename(rule) {
+    const target = rule.targets.claude;
+    if (target?.filename) {
+      return target.filename;
+    }
+    return `${rule.id}.md`;
+  },
+  isEnabled(rule) {
+    const target = rule.targets.claude;
+    return target?.enabled ?? false;
+  },
+  getOutputPath(rule) {
+    const target = rule.targets.claude;
+    const filename = this.getFilename(rule);
+    const subdir = target?.subdir || rule.category;
+    if (subdir) {
+      return `${subdir}/${filename}`;
+    }
+    return filename;
+  }
+};
+
+// src/adapters/antigravity.ts
+function replacePlaceholders3(content, placeholders) {
+  let result = content;
+  for (const [key, value] of Object.entries(placeholders)) {
+    result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+  }
+  return result;
+}
+var antigravityAdapter = {
+  name: "antigravity",
+  outputDir: ".agent/rules/omnify",
+  transform(content, rule, placeholders) {
+    const target = rule.targets.antigravity;
+    let transformedContent = replacePlaceholders3(content, placeholders);
+    if (transformedContent.startsWith("---")) {
+      const endIndex = transformedContent.indexOf("---", 3);
+      if (endIndex !== -1) {
+        const existingFrontmatter = transformedContent.substring(3, endIndex).trim();
+        const bodyContent = transformedContent.substring(endIndex + 3).trim();
+        const antigravityFrontmatter = buildAntigravityFrontmatter(rule, target, existingFrontmatter);
+        return `---
+${antigravityFrontmatter}---
+
+${bodyContent}`;
+      }
+    }
+    const frontmatter = buildAntigravityFrontmatter(rule, target);
+    return `---
+${frontmatter}---
+
+${transformedContent}`;
+  },
+  getFilename(rule) {
+    const target = rule.targets.antigravity;
+    if (target?.filename) {
+      return target.filename;
+    }
+    return `${rule.id}.md`;
+  },
+  isEnabled(rule) {
+    const target = rule.targets.antigravity;
+    return target?.enabled ?? false;
+  },
+  getOutputPath(rule) {
+    const filename = this.getFilename(rule);
+    return filename;
+  }
+};
+function buildAntigravityFrontmatter(rule, target, existingFrontmatter) {
+  const lines = [];
+  lines.push(`id: ${rule.id}`);
+  const description = target?.description || extractDescription(existingFrontmatter) || rule.id;
+  lines.push(`description: "${description}"`);
+  const priority = target?.priority || "medium";
+  lines.push(`priority: ${priority}`);
+  const globs = target?.globs || extractGlobs(existingFrontmatter) || [];
+  if (globs.length > 0) {
+    lines.push(`globs:`);
+    for (const glob of globs) {
+      lines.push(`  - "${glob}"`);
+    }
+  }
+  const tags = target?.tags || inferTags(rule);
+  if (tags.length > 0) {
+    lines.push(`tags:`);
+    for (const tag of tags) {
+      lines.push(`  - ${tag}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function extractDescription(frontmatter) {
+  if (!frontmatter) return void 0;
+  const match = frontmatter.match(/description:\s*["']?([^"'\n]+)["']?/);
+  return match?.[1];
+}
+function extractGlobs(frontmatter) {
+  if (!frontmatter) return [];
+  const match = frontmatter.match(/globs:\s*\[([^\]]+)\]/);
+  if (match?.[1]) {
+    return match[1].split(",").map((g) => g.trim().replace(/["']/g, ""));
+  }
+  return [];
+}
+function inferTags(rule) {
+  const tags = [];
+  if (rule.category) {
+    const parts = rule.category.split("/");
+    tags.push(...parts.filter((p) => p !== "guides"));
+  }
+  if (rule.id.includes("laravel")) tags.push("laravel");
+  if (rule.id.includes("react")) tags.push("react");
+  if (rule.id.includes("schema")) tags.push("schema");
+  if (rule.id.includes("omnify")) tags.push("omnify");
+  return [...new Set(tags)];
+}
+
+// src/adapters/index.ts
+var allAdapters = [cursorAdapter, claudeAdapter, antigravityAdapter];
+function getAdapters(names) {
+  if (!names || names.length === 0) {
+    return allAdapters;
+  }
+  return allAdapters.filter((a) => names.includes(a.name));
+}
+
+// src/generator.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function getKnowledgeDir() {
+  const possiblePaths = [
+    // Dev: running in src
+    resolve(__dirname, "knowledge"),
+    // Dist: running from dist/
+    resolve(__dirname, "../knowledge"),
+    // Installed package: in node_modules
+    resolve(__dirname, "../../knowledge")
+  ];
+  for (const path of possiblePaths) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  throw new Error(`AI guides knowledge directory not found. Tried: ${possiblePaths.join(", ")}`);
+}
+function getConfigDir() {
+  const possiblePaths = [
+    // Dev: running in src
+    resolve(__dirname, "config"),
+    // Dist: running from dist/
+    resolve(__dirname, "../config"),
+    // Installed package: in node_modules
+    resolve(__dirname, "../../config")
+  ];
+  for (const path of possiblePaths) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  throw new Error(`AI guides config directory not found. Tried: ${possiblePaths.join(", ")}`);
+}
+function loadRulesConfig() {
+  const configDir = getConfigDir();
+  const rulesPath = join(configDir, "rules.yaml");
+  if (!existsSync(rulesPath)) {
+    throw new Error(`Rules config not found: ${rulesPath}`);
+  }
+  const content = readFileSync(rulesPath, "utf-8");
+  return parseYaml(content);
+}
+function loadKnowledgeFile(source) {
+  const knowledgeDir = getKnowledgeDir();
+  const filePath = join(knowledgeDir, source);
+  if (!existsSync(filePath)) {
+    throw new Error(`Knowledge file not found: ${filePath}`);
+  }
+  return readFileSync(filePath, "utf-8");
+}
+function replacePlaceholders4(content, placeholders) {
+  let result = content;
+  for (const [key, value] of Object.entries(placeholders)) {
+    result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+  }
+  return result;
+}
+function writeOutputFile(filePath, content, dryRun) {
+  if (dryRun) {
+    console.log(`[DRY RUN] Would write: ${filePath}`);
+    return;
+  }
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, content);
+}
+function matchesCategory(ruleCategory, categories) {
+  if (!categories || categories.length === 0) {
+    return true;
+  }
+  const parts = ruleCategory.split("/");
+  const category = parts[parts.length - 1];
+  return categories.includes(category);
+}
+function sourceMatchesCategory(source, categories) {
+  if (!categories || categories.length === 0) {
+    return true;
+  }
+  const filename = basename(source).toLowerCase();
+  for (const category of categories) {
+    if (filename.startsWith(category)) {
+      return true;
+    }
+    if (source.includes(`/${category}/`) || source.startsWith(`${category}/`)) {
+      return true;
+    }
+  }
+  if (categories.includes("react")) {
+    if (filename.startsWith("react") || filename.includes("antd")) {
+      return true;
+    }
+  }
+  if (categories.includes("omnify")) {
+    if (filename.startsWith("omnify") || filename.startsWith("schema") || filename.startsWith("validation") || filename.includes("migration")) {
+      return true;
+    }
+  }
+  return false;
+}
+function generateAIGuides(rootDir, options = {}) {
+  const config = loadRulesConfig();
+  const adapters = getAdapters(options.adapters);
+  const dryRun = options.dryRun ?? false;
+  const categories = options.categories;
+  const placeholders = {
+    ...config.placeholders,
+    ...options.placeholders
+  };
+  const result = {
+    counts: {},
+    files: []
+  };
+  for (const adapter of adapters) {
+    result.counts[adapter.name] = 0;
+  }
+  for (const rule of config.guides) {
+    if (!matchesCategory(rule.category, categories)) {
+      continue;
+    }
+    try {
+      const content = loadKnowledgeFile(rule.source);
+      for (const adapter of adapters) {
+        if (!adapter.isEnabled(rule)) {
+          continue;
+        }
+        const transformed = adapter.transform(content, rule, placeholders);
+        const outputPath = adapter.getOutputPath(rule);
+        const fullPath = resolve(rootDir, adapter.outputDir, outputPath);
+        writeOutputFile(fullPath, transformed, dryRun);
+        result.files.push(fullPath);
+        result.counts[adapter.name] = (result.counts[adapter.name] ?? 0) + 1;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      result.errors = result.errors ?? [];
+      result.errors.push(`Error processing ${rule.id}: ${message}`);
+    }
+  }
+  const cursorAdapter2 = adapters.find((a) => a.name === "cursor");
+  if (cursorAdapter2 && config.cursorRules) {
+    for (const rule of config.cursorRules) {
+      if (!sourceMatchesCategory(rule.source, categories)) {
+        continue;
+      }
+      try {
+        const content = loadKnowledgeFile(rule.source);
+        const transformed = replacePlaceholders4(content, placeholders);
+        const filename = basename(rule.source).replace(".mdc.stub", ".mdc").replace(".md.stub", ".md");
+        const fullPath = resolve(rootDir, cursorAdapter2.outputDir, filename);
+        writeOutputFile(fullPath, transformed, dryRun);
+        result.files.push(fullPath);
+        result.counts[cursorAdapter2.name] = (result.counts[cursorAdapter2.name] ?? 0) + 1;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        result.errors = result.errors ?? [];
+        result.errors.push(`Error processing cursor rule ${rule.source}: ${message}`);
+      }
+    }
+  }
+  const claudeAdapter2 = adapters.find((a) => a.name === "claude");
+  if (claudeAdapter2 && config.claudeRules) {
+    for (const rule of config.claudeRules) {
+      if (!sourceMatchesCategory(rule.source, categories)) {
+        continue;
+      }
+      try {
+        const content = loadKnowledgeFile(rule.source);
+        const strippedContent = stripFrontmatter(content);
+        const transformed = replacePlaceholders4(strippedContent, placeholders);
+        const filename = basename(rule.source).replace(".mdc.stub", ".mdc").replace(".md.stub", ".md").replace(".mdc", ".md");
+        const fullPath = resolve(rootDir, ".claude/rules/omnify", filename);
+        writeOutputFile(fullPath, transformed, dryRun);
+        result.files.push(fullPath);
+        result.counts[claudeAdapter2.name] = (result.counts[claudeAdapter2.name] ?? 0) + 1;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        result.errors = result.errors ?? [];
+        result.errors.push(`Error processing claude rule ${rule.source}: ${message}`);
+      }
+    }
+  }
+  const antigravityAdapterInstance = adapters.find((a) => a.name === "antigravity");
+  if (antigravityAdapterInstance && config.antigravityRules) {
+    for (const rule of config.antigravityRules) {
+      if (!sourceMatchesCategory(rule.source, categories)) {
+        continue;
+      }
+      try {
+        const content = loadKnowledgeFile(rule.source);
+        const transformed = transformForAntigravity(content, rule, placeholders);
+        const filename = basename(rule.source).replace(".mdc.stub", ".mdc").replace(".md.stub", ".md").replace(".mdc", ".md");
+        const fullPath = resolve(rootDir, antigravityAdapterInstance.outputDir, filename);
+        writeOutputFile(fullPath, transformed, dryRun);
+        result.files.push(fullPath);
+        result.counts[antigravityAdapterInstance.name] = (result.counts[antigravityAdapterInstance.name] ?? 0) + 1;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        result.errors = result.errors ?? [];
+        result.errors.push(`Error processing antigravity rule ${rule.source}: ${message}`);
+      }
+    }
+  }
+  return result;
+}
+function transformForAntigravity(content, rule, placeholders) {
+  let transformed = replacePlaceholders4(content, placeholders);
+  if (transformed.startsWith("---")) {
+    const endIndex = transformed.indexOf("---", 3);
+    if (endIndex !== -1) {
+      const existingFrontmatter = transformed.substring(3, endIndex).trim();
+      const bodyContent = transformed.substring(endIndex + 3).trim();
+      const id = basename(rule.source).replace(".mdc.stub", "").replace(".md.stub", "").replace(".mdc", "").replace(".md", "");
+      const description = extractYamlValue(existingFrontmatter, "description") || id;
+      const globs = extractYamlArray(existingFrontmatter, "globs");
+      const priority = rule.priority || "medium";
+      const tags = rule.tags || [];
+      const lines = [`id: ${id}`, `description: "${description}"`, `priority: ${priority}`];
+      if (globs.length > 0) {
+        lines.push("globs:");
+        for (const glob of globs) {
+          lines.push(`  - "${glob}"`);
+        }
+      }
+      if (tags.length > 0) {
+        lines.push("tags:");
+        for (const tag of tags) {
+          lines.push(`  - ${tag}`);
+        }
+      }
+      return `---
+${lines.join("\n")}
+---
+
+${bodyContent}`;
+    }
+  }
+  return transformed;
+}
+function extractYamlValue(yaml, key) {
+  const match = yaml.match(new RegExp(`${key}:\\s*["']?([^"'\\n]+)["']?`));
+  return match?.[1]?.trim();
+}
+function extractYamlArray(yaml, key) {
+  const match = yaml.match(new RegExp(`${key}:\\s*\\[([^\\]]+)\\]`));
+  if (match?.[1]) {
+    return match[1].split(",").map((g) => g.trim().replace(/["']/g, ""));
+  }
+  return [];
+}
+function stripFrontmatter(content) {
+  if (!content.startsWith("---")) {
+    return content;
+  }
+  const endIndex = content.indexOf("---", 3);
+  if (endIndex === -1) {
+    return content;
+  }
+  return content.substring(endIndex + 3).trim();
+}
+function shouldGenerateAIGuides(rootDir) {
+  const claudeDir = resolve(rootDir, ".claude/omnify/guides");
+  const cursorDir = resolve(rootDir, ".cursor/rules/omnify");
+  if (!existsSync(claudeDir) || !existsSync(cursorDir)) {
+    return true;
+  }
+  try {
+    const claudeFiles = readdirSync(claudeDir, { recursive: true });
+    const cursorFiles = readdirSync(cursorDir);
+    return claudeFiles.length === 0 || cursorFiles.length === 0;
+  } catch {
+    return true;
+  }
+}
+function getAvailableAdapters() {
+  return getAdapters().map((a) => a.name);
+}
+function getAvailableCategories() {
+  return ["omnify", "laravel", "react"];
+}
+
+// src/plugin.ts
+function getPluginVersion() {
+  try {
+    const pkgPath = new URL("../package.json", import.meta.url);
+    const pkgContent = readFileSync2(pkgPath, "utf-8");
+    const pkg = JSON.parse(pkgContent);
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function aiGuidesPlugin(options = {}) {
+  const resolvedOptions = {
+    categories: options.categories ?? getAvailableCategories(),
+    laravelBasePath: options.laravelBasePath ?? "app",
+    typescriptBasePath: options.typescriptBasePath ?? "resources/ts",
+    adapters: options.adapters
+  };
+  return {
+    name: "@famgia/omnify-ai-guides",
+    version: getPluginVersion(),
+    generators: [
+      {
+        name: "ai-guides",
+        description: "Generate AI assistant guides (Cursor, Claude, Antigravity)",
+        generate: async (ctx) => {
+          const result = generateAIGuides(ctx.cwd, {
+            categories: resolvedOptions.categories,
+            adapters: resolvedOptions.adapters,
+            placeholders: {
+              LARAVEL_BASE: resolvedOptions.laravelBasePath,
+              LARAVEL_ROOT: "",
+              TYPESCRIPT_BASE: resolvedOptions.typescriptBasePath
+            }
+          });
+          const claudeCount = result.counts["claude"] || 0;
+          const cursorCount = result.counts["cursor"] || 0;
+          const antigravityCount = result.counts["antigravity"] || 0;
+          const parts = [];
+          if (claudeCount > 0) parts.push(`${claudeCount} Claude`);
+          if (cursorCount > 0) parts.push(`${cursorCount} Cursor`);
+          if (antigravityCount > 0) parts.push(`${antigravityCount} Antigravity`);
+          ctx.logger.info(`Generated ${parts.join(", ")} files`);
+          if (result.errors?.length) {
+            for (const error of result.errors) {
+              ctx.logger.warn(error);
+            }
+          }
+          return [];
+        }
+      }
+    ]
+  };
+}
+
+export {
+  cursorAdapter,
+  claudeAdapter,
+  antigravityAdapter,
+  allAdapters,
+  getAdapters,
+  generateAIGuides,
+  shouldGenerateAIGuides,
+  getAvailableAdapters,
+  getAvailableCategories,
+  aiGuidesPlugin
+};
+//# sourceMappingURL=chunk-RCTEXK7C.js.map