@famgia/omnify-core 0.0.138 → 0.0.140

package/dist/index.cjs

@@ -35,9 +35,12 @@ __export(index_exports, {
   OmnifyError: () => OmnifyError,
   PluginManager: () => PluginManager,
   VersionStore: () => VersionStore,
+  allAdapters: () => allAdapters,
+  antigravityAdapter: () => antigravityAdapter,
   atlasError: () => atlasError,
   atlasNotFoundError: () => atlasNotFoundError,
   circularReferenceError: () => circularReferenceError,
+  claudeAdapter: () => claudeAdapter,
   configError: () => configError,
   configNotFoundError: () => configNotFoundError,
   createFileLoadedSchema: () => createFileLoadedSchema,
@@ -45,6 +48,7 @@ __export(index_exports, {
   createOmnify: () => createOmnify,
   createPluginManager: () => createPluginManager,
   createVersionStore: () => createVersionStore,
+  cursorAdapter: () => cursorAdapter,
   duplicateSchemaError: () => duplicateSchemaError,
   ensureFileSchema: () => ensureFileSchema,
   err: () => import_omnify_types3.err,
@@ -58,9 +62,13 @@ __export(index_exports, {
   formatError: () => formatError,
   formatErrorPlain: () => formatErrorPlain,
   formatErrorSummary: () => formatErrorSummary,
+  generateAIGuides: () => generateAIGuides,
   generateFileSchemaYaml: () => generateFileSchemaYaml,
   generationError: () => generationError,
+  getAdapter: () => getAdapter,
+  getAdapters: () => getAdapters,
   getAssociationMetadata: () => getAssociationMetadata,
+  getAvailableAdapters: () => getAvailableAdapters,
   getCustomTypeNames: () => getCustomTypeNames,
   getEntitySchemas: () => getEntitySchemas,
   getEnumSchemas: () => getEnumSchemas,
@@ -99,6 +107,7 @@ __export(index_exports, {
   schemaNotFoundError: () => schemaNotFoundError,
   schemaParseError: () => schemaParseError,
   schemasHaveFileProperties: () => schemasHaveFileProperties,
+  shouldGenerateAIGuides: () => shouldGenerateAIGuides,
   validateAssociations: () => validateAssociations,
   validateDefaultValue: () => validateDefaultValue,
   validateEnumSchema: () => validateEnumSchema,
@@ -5099,6 +5108,447 @@ var VersionStore = class {
 function createVersionStore(config) {
   return new VersionStore(config);
 }
+
+// src/ai-guides/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/ai-guides/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/ai-guides/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}"`);
+  lines.push(`category: ${rule.category || "general"}`);
+  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) {
+    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/ai-guides/adapters/index.ts
+var allAdapters = [
+  cursorAdapter,
+  claudeAdapter,
+  antigravityAdapter
+];
+function getAdapter(name) {
+  return allAdapters.find((a) => a.name === name);
+}
+function getAdapters(names) {
+  if (!names || names.length === 0) {
+    return allAdapters;
+  }
+  return allAdapters.filter((a) => names.includes(a.name));
+}
+
+// src/ai-guides/generator.ts
+var import_node_fs = require("fs");
+var import_node_path2 = require("path");
+var import_node_url = require("url");
+var import_yaml = require("yaml");
+var import_meta = {};
+var __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
+var __dirname = (0, import_node_path2.dirname)(__filename);
+function getKnowledgeDir() {
+  const possiblePaths = [
+    // Dev: src内で実行している場合
+    (0, import_node_path2.resolve)(__dirname, "knowledge"),
+    // Dist: dist/から実行、src/ai-guides/knowledge
+    (0, import_node_path2.resolve)(__dirname, "../src/ai-guides/knowledge"),
+    // Installed package: node_modules内
+    (0, import_node_path2.resolve)(__dirname, "../knowledge")
+  ];
+  for (const path2 of possiblePaths) {
+    if ((0, import_node_fs.existsSync)(path2)) {
+      return path2;
+    }
+  }
+  throw new Error(`AI guides knowledge directory not found. Tried: ${possiblePaths.join(", ")}`);
+}
+function getConfigDir() {
+  const possiblePaths = [
+    // Dev: src内で実行している場合
+    (0, import_node_path2.resolve)(__dirname, "config"),
+    // Dist: dist/から実行、src/ai-guides/config
+    (0, import_node_path2.resolve)(__dirname, "../src/ai-guides/config"),
+    // Installed package: node_modules内
+    (0, import_node_path2.resolve)(__dirname, "../config")
+  ];
+  for (const path2 of possiblePaths) {
+    if ((0, import_node_fs.existsSync)(path2)) {
+      return path2;
+    }
+  }
+  throw new Error(`AI guides config directory not found. Tried: ${possiblePaths.join(", ")}`);
+}
+function loadRulesConfig() {
+  const configDir = getConfigDir();
+  const rulesPath = (0, import_node_path2.join)(configDir, "rules.yaml");
+  if (!(0, import_node_fs.existsSync)(rulesPath)) {
+    throw new Error(`Rules config not found: ${rulesPath}`);
+  }
+  const content = (0, import_node_fs.readFileSync)(rulesPath, "utf-8");
+  return (0, import_yaml.parse)(content);
+}
+function loadKnowledgeFile(source) {
+  const knowledgeDir = getKnowledgeDir();
+  const filePath = (0, import_node_path2.join)(knowledgeDir, source);
+  if (!(0, import_node_fs.existsSync)(filePath)) {
+    throw new Error(`Knowledge file not found: ${filePath}`);
+  }
+  return (0, import_node_fs.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 = (0, import_node_path2.dirname)(filePath);
+  if (!(0, import_node_fs.existsSync)(dir)) {
+    (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  }
+  (0, import_node_fs.writeFileSync)(filePath, content);
+}
+function generateAIGuides(rootDir, options = {}) {
+  const config = loadRulesConfig();
+  const knowledgeDir = getKnowledgeDir();
+  const adapters = getAdapters(options.adapters);
+  const dryRun = options.dryRun ?? false;
+  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) {
+    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 = (0, import_node_path2.resolve)(rootDir, adapter.outputDir, outputPath);
+        writeOutputFile(fullPath, transformed, dryRun);
+        result.files.push(fullPath);
+        result.counts[adapter.name]++;
+      }
+    } 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) {
+      try {
+        const content = loadKnowledgeFile(rule.source);
+        const transformed = replacePlaceholders4(content, placeholders);
+        const filename = (0, import_node_path2.basename)(rule.source);
+        const fullPath = (0, import_node_path2.resolve)(rootDir, cursorAdapter2.outputDir, filename);
+        writeOutputFile(fullPath, transformed, dryRun);
+        result.files.push(fullPath);
+        result.counts[cursorAdapter2.name]++;
+      } 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) {
+      try {
+        const content = loadKnowledgeFile(rule.source);
+        const strippedContent = stripFrontmatter(content);
+        const transformed = replacePlaceholders4(strippedContent, placeholders);
+        const filename = (0, import_node_path2.basename)(rule.source).replace(".mdc", ".md");
+        const fullPath = (0, import_node_path2.resolve)(rootDir, ".claude/rules/omnify", filename);
+        writeOutputFile(fullPath, transformed, dryRun);
+        result.files.push(fullPath);
+        result.counts[claudeAdapter2.name]++;
+      } 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) {
+      try {
+        const content = loadKnowledgeFile(rule.source);
+        const transformed = transformForAntigravity(content, rule, placeholders);
+        const filename = (0, import_node_path2.basename)(rule.source).replace(".mdc", ".md");
+        const fullPath = (0, import_node_path2.resolve)(rootDir, antigravityAdapterInstance.outputDir, filename);
+        writeOutputFile(fullPath, transformed, dryRun);
+        result.files.push(fullPath);
+        result.counts[antigravityAdapterInstance.name]++;
+      } 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 = (0, import_node_path2.basename)(rule.source, ".mdc");
+      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(yaml3, key) {
+  const match = yaml3.match(new RegExp(`${key}:\\s*["']?([^"'\\n]+)["']?`));
+  return match?.[1]?.trim();
+}
+function extractYamlArray(yaml3, key) {
+  const match = yaml3.match(new RegExp(`${key}:\\s*\\[([^\\]]+)\\]`));
+  if (match) {
+    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 = (0, import_node_path2.resolve)(rootDir, ".claude/omnify/guides");
+  const cursorDir = (0, import_node_path2.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, { recursive: true });
+    const cursorFiles = (0, import_node_fs.readdirSync)(cursorDir);
+    return claudeFiles.length === 0 || cursorFiles.length === 0;
+  } catch {
+    return true;
+  }
+}
+function getAvailableAdapters() {
+  return getAdapters().map((a) => a.name);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FILE_SCHEMA_NAME,
@@ -5106,9 +5556,12 @@ function createVersionStore(config) {
   OmnifyError,
   PluginManager,
   VersionStore,
+  allAdapters,
+  antigravityAdapter,
   atlasError,
   atlasNotFoundError,
   circularReferenceError,
+  claudeAdapter,
   configError,
   configNotFoundError,
   createFileLoadedSchema,
@@ -5116,6 +5569,7 @@ function createVersionStore(config) {
   createOmnify,
   createPluginManager,
   createVersionStore,
+  cursorAdapter,
   duplicateSchemaError,
   ensureFileSchema,
   err,
@@ -5129,9 +5583,13 @@ function createVersionStore(config) {
   formatError,
   formatErrorPlain,
   formatErrorSummary,
+  generateAIGuides,
   generateFileSchemaYaml,
   generationError,
+  getAdapter,
+  getAdapters,
   getAssociationMetadata,
+  getAvailableAdapters,
   getCustomTypeNames,
   getEntitySchemas,
   getEnumSchemas,
@@ -5170,6 +5628,7 @@ function createVersionStore(config) {
   schemaNotFoundError,
   schemaParseError,
   schemasHaveFileProperties,
+  shouldGenerateAIGuides,
   validateAssociations,
   validateDefaultValue,
   validateEnumSchema,