@lnai/core 0.1.0

package/dist/index.js

@@ -0,0 +1,915 @@
+import { z } from 'zod';
+import * as fs3 from 'fs/promises';
+import * as path from 'path';
+import matter from 'gray-matter';
+import deepmerge from 'deepmerge';
+import * as crypto from 'crypto';
+
+// src/constants.ts
+var UNIFIED_DIR = ".ai";
+var TOOL_IDS = ["claudeCode", "opencode"];
+var CONFIG_FILES = {
+  config: "config.json",
+  settings: "settings.json",
+  agents: "AGENTS.md"
+};
+var CONFIG_DIRS = {
+  rules: "rules",
+  skills: "skills",
+  subagents: "subagents"
+};
+var TOOL_OUTPUT_DIRS = {
+  claudeCode: ".claude",
+  opencode: ".opencode"
+};
+var OVERRIDE_DIRS = {
+  claudeCode: ".claude",
+  opencode: ".opencode"
+};
+
+// src/errors.ts
+var LnaiError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "LnaiError";
+    this.code = code;
+  }
+};
+var ParseError = class extends LnaiError {
+  filePath;
+  constructor(message, filePath, cause) {
+    super(message, "PARSE_ERROR");
+    this.name = "ParseError";
+    this.filePath = filePath;
+    if (cause) {
+      this.cause = cause;
+    }
+  }
+};
+var ValidationError = class extends LnaiError {
+  path;
+  value;
+  constructor(message, path7, value) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+    this.path = path7;
+    this.value = value;
+  }
+};
+var FileNotFoundError = class extends LnaiError {
+  filePath;
+  constructor(message, filePath) {
+    super(message, "FILE_NOT_FOUND");
+    this.name = "FileNotFoundError";
+    this.filePath = filePath;
+  }
+};
+var WriteError = class extends LnaiError {
+  filePath;
+  constructor(message, filePath, cause) {
+    super(message, "WRITE_ERROR");
+    this.name = "WriteError";
+    this.filePath = filePath;
+    if (cause) {
+      this.cause = cause;
+    }
+  }
+};
+var PluginError = class extends LnaiError {
+  pluginId;
+  constructor(message, pluginId, cause) {
+    super(message, "PLUGIN_ERROR");
+    this.name = "PluginError";
+    this.pluginId = pluginId;
+    if (cause) {
+      this.cause = cause;
+    }
+  }
+};
+var mcpServerSchema = z.object({
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  type: z.enum(["http", "sse"]).optional(),
+  url: z.string().optional(),
+  headers: z.record(z.string(), z.string()).optional()
+});
+var permissionsSchema = z.object({
+  allow: z.array(z.string()).optional(),
+  ask: z.array(z.string()).optional(),
+  deny: z.array(z.string()).optional()
+});
+var toolConfigSchema = z.object({
+  enabled: z.boolean(),
+  versionControl: z.boolean().optional().default(false)
+});
+var toolIdSchema = z.enum(["claudeCode", "opencode"]);
+var settingsSchema = z.object({
+  permissions: permissionsSchema.optional(),
+  mcpServers: z.record(z.string(), mcpServerSchema).optional(),
+  overrides: z.object({
+    claudeCode: z.record(z.string(), z.unknown()).optional(),
+    opencode: z.record(z.string(), z.unknown()).optional()
+  }).optional()
+});
+var configSchema = z.object({
+  tools: z.object({
+    claudeCode: toolConfigSchema,
+    opencode: toolConfigSchema
+  }).partial().optional()
+});
+var skillFrontmatterSchema = z.object({
+  name: z.string(),
+  description: z.string()
+});
+var ruleFrontmatterSchema = z.object({
+  paths: z.array(z.string()).min(1)
+});
+function parseFrontmatter(content) {
+  const parsed = matter(content);
+  return {
+    frontmatter: parsed.data,
+    content: parsed.content.trim()
+  };
+}
+
+// src/parser/index.ts
+async function parseUnifiedConfig(rootDir) {
+  const aiDir = path.join(rootDir, UNIFIED_DIR);
+  if (!await fileExists(aiDir)) {
+    throw new FileNotFoundError(
+      `Unified config directory not found: ${aiDir}`,
+      aiDir
+    );
+  }
+  const configPath = path.join(aiDir, CONFIG_FILES.config);
+  let config;
+  try {
+    config = await readJsonFile(configPath);
+  } catch (error) {
+    if (error instanceof FileNotFoundError) {
+      config = { tools: {} };
+    } else {
+      throw error;
+    }
+  }
+  const settingsPath = path.join(aiDir, CONFIG_FILES.settings);
+  let settings = null;
+  if (await fileExists(settingsPath)) {
+    settings = await readJsonFile(settingsPath);
+  }
+  const agentsPath = path.join(aiDir, CONFIG_FILES.agents);
+  let agents = null;
+  if (await fileExists(agentsPath)) {
+    agents = await readMarkdownFile(agentsPath);
+  }
+  const rulesDir = path.join(aiDir, CONFIG_DIRS.rules);
+  const rules = await readMarkdownDirectory(rulesDir);
+  const skillsDir = path.join(aiDir, CONFIG_DIRS.skills);
+  const skills = await readSkillsDirectory(skillsDir);
+  return {
+    config,
+    settings,
+    agents,
+    rules,
+    skills
+  };
+}
+async function fileExists(filePath) {
+  try {
+    await fs3.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJsonFile(filePath) {
+  try {
+    const content = await fs3.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new FileNotFoundError(`File not found: ${filePath}`, filePath);
+    }
+    throw new ParseError(
+      `Failed to parse JSON: ${filePath}`,
+      filePath,
+      error
+    );
+  }
+}
+async function readMarkdownFile(filePath) {
+  try {
+    return await fs3.readFile(filePath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new FileNotFoundError(`File not found: ${filePath}`, filePath);
+    }
+    throw new ParseError(
+      `Failed to read markdown: ${filePath}`,
+      filePath,
+      error
+    );
+  }
+}
+async function readMarkdownDirectory(dirPath) {
+  const files = [];
+  if (!await fileExists(dirPath)) {
+    return files;
+  }
+  const entries = await fs3.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".md")) {
+      const filePath = path.join(dirPath, entry.name);
+      const content = await readMarkdownFile(filePath);
+      const parsed = parseFrontmatter(content);
+      files.push({
+        path: entry.name,
+        frontmatter: parsed.frontmatter,
+        content: parsed.content
+      });
+    }
+  }
+  return files;
+}
+async function readSkillsDirectory(dirPath) {
+  const skills = [];
+  if (!await fileExists(dirPath)) {
+    return skills;
+  }
+  const entries = await fs3.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const skillFile = path.join(dirPath, entry.name, "SKILL.md");
+      if (await fileExists(skillFile)) {
+        const content = await readMarkdownFile(skillFile);
+        const parsed = parseFrontmatter(content);
+        skills.push({
+          path: entry.name,
+          frontmatter: parsed.frontmatter,
+          content: parsed.content
+        });
+      }
+    }
+  }
+  return skills;
+}
+
+// src/validator/index.ts
+function zodIssuesToErrors(issues, prefix = []) {
+  return issues.map((issue) => ({
+    path: [...prefix, ...issue.path.map(String)],
+    message: issue.message,
+    value: void 0
+  }));
+}
+function validateConfig(config) {
+  const result = configSchema.safeParse(config);
+  if (result.success) {
+    return {
+      valid: true,
+      errors: [],
+      warnings: [],
+      skipped: []
+    };
+  }
+  return {
+    valid: false,
+    errors: zodIssuesToErrors(result.error.issues, ["config"]),
+    warnings: [],
+    skipped: []
+  };
+}
+function validateSettings(settings) {
+  if (settings === null || settings === void 0) {
+    return {
+      valid: true,
+      errors: [],
+      warnings: [],
+      skipped: []
+    };
+  }
+  const result = settingsSchema.safeParse(settings);
+  if (result.success) {
+    return {
+      valid: true,
+      errors: [],
+      warnings: [],
+      skipped: []
+    };
+  }
+  return {
+    valid: false,
+    errors: zodIssuesToErrors(result.error.issues, ["settings"]),
+    warnings: [],
+    skipped: []
+  };
+}
+function validateSkillFrontmatter(frontmatter, skillPath) {
+  const result = skillFrontmatterSchema.safeParse(frontmatter);
+  if (result.success) {
+    return [];
+  }
+  return zodIssuesToErrors(result.error.issues, [
+    "skills",
+    skillPath,
+    "frontmatter"
+  ]);
+}
+function validateRuleFrontmatter(frontmatter, rulePath) {
+  const result = ruleFrontmatterSchema.safeParse(frontmatter);
+  if (result.success) {
+    return [];
+  }
+  return zodIssuesToErrors(result.error.issues, [
+    "rules",
+    rulePath,
+    "frontmatter"
+  ]);
+}
+function validateUnifiedState(state) {
+  const errors = [];
+  const warnings = [];
+  const configResult = validateConfig(state.config);
+  errors.push(...configResult.errors);
+  const settingsResult = validateSettings(state.settings);
+  errors.push(...settingsResult.errors);
+  for (const skill of state.skills) {
+    const skillErrors = validateSkillFrontmatter(skill.frontmatter, skill.path);
+    errors.push(...skillErrors);
+  }
+  for (const rule of state.rules) {
+    const ruleErrors = validateRuleFrontmatter(rule.frontmatter, rule.path);
+    errors.push(...ruleErrors);
+  }
+  if (!state.agents) {
+    warnings.push({
+      path: ["AGENTS.md"],
+      message: "AGENTS.md not found - no main instructions will be exported"
+    });
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    skipped: []
+  };
+}
+async function scanOverrideDirectory(rootDir, toolId) {
+  const overrideDir = path.join(rootDir, UNIFIED_DIR, OVERRIDE_DIRS[toolId]);
+  try {
+    await fs3.access(overrideDir);
+  } catch {
+    return [];
+  }
+  const files = [];
+  await scanDir(overrideDir, overrideDir, files);
+  return files;
+}
+async function scanDir(baseDir, currentDir, files) {
+  const entries = await fs3.readdir(currentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const absolutePath = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      await scanDir(baseDir, absolutePath, files);
+    } else if (entry.isFile()) {
+      const relativePath = path.relative(baseDir, absolutePath);
+      files.push({ relativePath, absolutePath });
+    }
+  }
+}
+function deepMergeConfigs(base, override) {
+  return deepmerge(base, override, {
+    arrayMerge: (target, source) => [.../* @__PURE__ */ new Set([...target, ...source])]
+  });
+}
+async function fileExists2(filePath) {
+  try {
+    await fs3.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/plugins/claude-code/index.ts
+var claudeCodePlugin = {
+  id: "claudeCode",
+  name: "Claude Code",
+  async detect(_rootDir) {
+    return false;
+  },
+  async import(_rootDir) {
+    return null;
+  },
+  async export(state, rootDir) {
+    const files = [];
+    const outputDir = TOOL_OUTPUT_DIRS.claudeCode;
+    if (state.agents) {
+      files.push({
+        path: `${outputDir}/CLAUDE.md`,
+        type: "symlink",
+        target: `../${UNIFIED_DIR}/AGENTS.md`
+      });
+    }
+    if (state.rules.length > 0) {
+      files.push({
+        path: `${outputDir}/rules`,
+        type: "symlink",
+        target: `../${UNIFIED_DIR}/rules`
+      });
+    }
+    for (const skill of state.skills) {
+      files.push({
+        path: `${outputDir}/skills/${skill.path}`,
+        type: "symlink",
+        target: `../../${UNIFIED_DIR}/skills/${skill.path}`
+      });
+    }
+    const baseSettings = {};
+    if (state.settings?.permissions) {
+      baseSettings["permissions"] = state.settings.permissions;
+    }
+    if (state.settings?.mcpServers) {
+      baseSettings["mcpServers"] = state.settings.mcpServers;
+    }
+    let finalSettings = baseSettings;
+    if (state.settings?.overrides?.claudeCode) {
+      finalSettings = deepMergeConfigs(
+        baseSettings,
+        state.settings.overrides.claudeCode
+      );
+    }
+    if (Object.keys(finalSettings).length > 0) {
+      files.push({
+        path: `${outputDir}/settings.json`,
+        type: "json",
+        content: finalSettings
+      });
+    }
+    const overrideFiles = await scanOverrideDirectory(rootDir, "claudeCode");
+    for (const overrideFile of overrideFiles) {
+      const targetPath = path.join(
+        rootDir,
+        outputDir,
+        overrideFile.relativePath
+      );
+      if (await fileExists2(targetPath)) {
+        continue;
+      }
+      files.push({
+        path: `${outputDir}/${overrideFile.relativePath}`,
+        type: "symlink",
+        target: `../${UNIFIED_DIR}/${OVERRIDE_DIRS.claudeCode}/${overrideFile.relativePath}`
+      });
+    }
+    return files;
+  },
+  validate(state) {
+    const warnings = [];
+    if (!state.agents) {
+      warnings.push({
+        path: ["AGENTS.md"],
+        message: "No AGENTS.md found - .claude/CLAUDE.md will not be created"
+      });
+    }
+    return { valid: true, errors: [], warnings, skipped: [] };
+  }
+};
+
+// src/plugins/opencode/transforms.ts
+function transformMcpToOpenCode(servers) {
+  if (!servers || Object.keys(servers).length === 0) {
+    return void 0;
+  }
+  const result = {};
+  for (const [name, serverRaw] of Object.entries(servers)) {
+    const server = serverRaw;
+    if (server.type === "http" || server.type === "sse") {
+      const openCodeServer = {
+        type: "remote",
+        url: server.url
+      };
+      if (server.headers) {
+        openCodeServer.headers = server.headers;
+      }
+      result[name] = openCodeServer;
+    } else if (server.command) {
+      const command = [server.command, ...server.args || []];
+      const openCodeServer = {
+        type: "local",
+        command
+      };
+      if (server.env) {
+        openCodeServer.environment = transformEnvVars(server.env);
+      }
+      result[name] = openCodeServer;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function transformPermissionsToOpenCode(permissions) {
+  if (!permissions) {
+    return void 0;
+  }
+  const result = {};
+  const processRules = (rules, level) => {
+    if (!rules) {
+      return;
+    }
+    for (const rule of rules) {
+      const parsed = parsePermissionRule(rule);
+      if (!parsed) {
+        continue;
+      }
+      const { tool, pattern } = parsed;
+      if (!result[tool]) {
+        result[tool] = {};
+      }
+      result[tool][pattern] = level;
+    }
+  };
+  processRules(permissions.allow, "allow");
+  processRules(permissions.ask, "ask");
+  processRules(permissions.deny, "deny");
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function transformEnvVar(value) {
+  return value.replace(/\$\{([^}:]+)(:-[^}]*)?\}/g, "{env:$1}");
+}
+function transformEnvVars(env) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    result[key] = transformEnvVar(value);
+  }
+  return result;
+}
+function parsePermissionRule(rule) {
+  const match = rule.match(/^(\w+)\(([^)]+)\)$/);
+  if (!match) {
+    return null;
+  }
+  const tool = match[1];
+  const pattern = match[2];
+  if (!tool || !pattern) {
+    return null;
+  }
+  const normalizedTool = tool.toLowerCase();
+  let normalizedPattern = pattern;
+  if (normalizedPattern.includes(":*")) {
+    normalizedPattern = normalizedPattern.replace(/:(\*)/g, " $1");
+  }
+  return {
+    tool: normalizedTool,
+    pattern: normalizedPattern
+  };
+}
+
+// src/plugins/opencode/index.ts
+var opencodePlugin = {
+  id: "opencode",
+  name: "OpenCode",
+  async detect(_rootDir) {
+    return false;
+  },
+  async import(_rootDir) {
+    return null;
+  },
+  async export(state, rootDir) {
+    const files = [];
+    const outputDir = TOOL_OUTPUT_DIRS.opencode;
+    if (state.agents) {
+      files.push({
+        path: `${outputDir}/AGENTS.md`,
+        type: "symlink",
+        target: `../${UNIFIED_DIR}/AGENTS.md`
+      });
+    }
+    if (state.rules.length > 0) {
+      files.push({
+        path: `${outputDir}/rules`,
+        type: "symlink",
+        target: `../${UNIFIED_DIR}/rules`
+      });
+    }
+    for (const skill of state.skills) {
+      files.push({
+        path: `${outputDir}/skills/${skill.path}`,
+        type: "symlink",
+        target: `../../${UNIFIED_DIR}/skills/${skill.path}`
+      });
+    }
+    const baseConfig = {
+      $schema: "https://opencode.ai/config.json"
+    };
+    if (state.rules.length > 0) {
+      baseConfig["instructions"] = [`${outputDir}/rules/*.md`];
+    }
+    const mcp = transformMcpToOpenCode(state.settings?.mcpServers);
+    if (mcp) {
+      baseConfig["mcp"] = mcp;
+    }
+    const permission = transformPermissionsToOpenCode(
+      state.settings?.permissions
+    );
+    if (permission) {
+      baseConfig["permission"] = permission;
+    }
+    let finalConfig = baseConfig;
+    if (state.settings?.overrides?.opencode) {
+      finalConfig = deepMergeConfigs(
+        baseConfig,
+        state.settings.overrides.opencode
+      );
+    }
+    files.push({
+      path: "opencode.json",
+      type: "json",
+      content: finalConfig
+    });
+    const overrideFiles = await scanOverrideDirectory(rootDir, "opencode");
+    for (const overrideFile of overrideFiles) {
+      const targetPath = path.join(
+        rootDir,
+        outputDir,
+        overrideFile.relativePath
+      );
+      if (await fileExists2(targetPath)) {
+        continue;
+      }
+      files.push({
+        path: `${outputDir}/${overrideFile.relativePath}`,
+        type: "symlink",
+        target: `../${UNIFIED_DIR}/${OVERRIDE_DIRS.opencode}/${overrideFile.relativePath}`
+      });
+    }
+    return files;
+  },
+  validate(state) {
+    const warnings = [];
+    if (!state.agents) {
+      warnings.push({
+        path: ["AGENTS.md"],
+        message: "No AGENTS.md found - .opencode/AGENTS.md will not be created"
+      });
+    }
+    return { valid: true, errors: [], warnings, skipped: [] };
+  }
+};
+
+// src/plugins/registry.ts
+var PluginRegistry = class {
+  plugins = /* @__PURE__ */ new Map();
+  register(plugin) {
+    this.plugins.set(plugin.id, plugin);
+  }
+  get(id) {
+    return this.plugins.get(id);
+  }
+  getAll() {
+    return Array.from(this.plugins.values());
+  }
+  getIds() {
+    return Array.from(this.plugins.keys());
+  }
+  has(id) {
+    return this.plugins.has(id);
+  }
+};
+var pluginRegistry = new PluginRegistry();
+
+// src/plugins/index.ts
+pluginRegistry.register(claudeCodePlugin);
+pluginRegistry.register(opencodePlugin);
+function computeHash(content) {
+  return crypto.createHash("sha256").update(content, "utf-8").digest("hex");
+}
+async function readExistingFile(filePath) {
+  try {
+    return await fs3.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function getSymlinkTarget(filePath) {
+  try {
+    const stats = await fs3.lstat(filePath);
+    if (stats.isSymbolicLink()) {
+      return await fs3.readlink(filePath);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function ensureDir(dirPath) {
+  await fs3.mkdir(dirPath, { recursive: true });
+}
+async function removeIfExists(filePath) {
+  try {
+    const stats = await fs3.lstat(filePath);
+    if (stats.isDirectory() && !stats.isSymbolicLink()) {
+      await fs3.rm(filePath, { recursive: true, force: true });
+    } else {
+      await fs3.unlink(filePath);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+async function writeSingleFile(file, rootDir, dryRun) {
+  const fullPath = path.join(rootDir, file.path);
+  const dirPath = path.dirname(fullPath);
+  if (file.type === "symlink") {
+    const target = file.target;
+    const existingTarget = await getSymlinkTarget(fullPath);
+    if (existingTarget === target) {
+      return {
+        path: file.path,
+        action: "unchanged"
+      };
+    }
+    if (!dryRun) {
+      await ensureDir(dirPath);
+      await removeIfExists(fullPath);
+      await fs3.symlink(target, fullPath);
+    }
+    return {
+      path: file.path,
+      action: existingTarget ? "update" : "create"
+    };
+  }
+  const content = file.type === "json" ? JSON.stringify(file.content, null, 2) + "\n" : String(file.content);
+  const newHash = computeHash(content);
+  const existingContent = await readExistingFile(fullPath);
+  const oldHash = existingContent ? computeHash(existingContent) : void 0;
+  if (oldHash === newHash) {
+    return {
+      path: file.path,
+      action: "unchanged",
+      oldHash,
+      newHash
+    };
+  }
+  if (!dryRun) {
+    await ensureDir(dirPath);
+    await fs3.writeFile(fullPath, content, "utf-8");
+  }
+  return {
+    path: file.path,
+    action: existingContent ? "update" : "create",
+    oldHash,
+    newHash
+  };
+}
+async function writeFiles(files, options) {
+  const { rootDir, dryRun = false } = options;
+  const results = [];
+  for (const file of files) {
+    try {
+      const result = await writeSingleFile(file, rootDir, dryRun);
+      results.push(result);
+    } catch (error) {
+      throw new WriteError(
+        `Failed to write file: ${file.path}`,
+        file.path,
+        error
+      );
+    }
+  }
+  return results;
+}
+async function updateGitignore(rootDir, paths) {
+  const gitignorePath = path.join(rootDir, ".gitignore");
+  let content = "";
+  try {
+    content = await fs3.readFile(gitignorePath, "utf-8");
+  } catch {
+  }
+  const marker = "# lnai-generated";
+  const endMarker = "# end lnai-generated";
+  const markerRegex = new RegExp(`${marker}[\\s\\S]*?${endMarker}\\n?`, "g");
+  content = content.replace(markerRegex, "");
+  content = content.trimEnd();
+  const newSection = ["", marker, ...paths.map((p) => p), endMarker, ""].join(
+    "\n"
+  );
+  content = content + newSection;
+  await fs3.writeFile(gitignorePath, content, "utf-8");
+}
+
+// src/pipeline/index.ts
+function getToolsToSync(config, requestedTools) {
+  if (requestedTools && requestedTools.length > 0) {
+    return requestedTools.filter((tool) => pluginRegistry.has(tool));
+  }
+  const enabledTools = [];
+  if (config.tools) {
+    for (const [toolId, toolConfig] of Object.entries(config.tools)) {
+      if (toolConfig?.enabled && pluginRegistry.has(toolId)) {
+        enabledTools.push(toolId);
+      }
+    }
+  }
+  if (enabledTools.length === 0) {
+    return pluginRegistry.getIds();
+  }
+  return enabledTools;
+}
+async function runSyncPipeline(options) {
+  const { rootDir, dryRun = false, tools: requestedTools } = options;
+  const state = await parseUnifiedConfig(rootDir);
+  const unifiedValidation = validateUnifiedState(state);
+  if (!unifiedValidation.valid) {
+    return [
+      {
+        tool: "claudeCode",
+        changes: [],
+        validation: unifiedValidation
+      }
+    ];
+  }
+  const toolsToSync = getToolsToSync(state.config, requestedTools);
+  if (toolsToSync.length === 0) {
+    return [];
+  }
+  const results = [];
+  const pathsToIgnore = [];
+  for (const toolId of toolsToSync) {
+    const plugin = pluginRegistry.get(toolId);
+    if (!plugin) {
+      continue;
+    }
+    const validation = plugin.validate(state);
+    const outputFiles = await plugin.export(state, rootDir);
+    const changes = await writeFiles(outputFiles, { rootDir, dryRun });
+    results.push({
+      tool: toolId,
+      changes,
+      validation
+    });
+    const toolConfig = state.config.tools?.[toolId];
+    if (!toolConfig?.versionControl) {
+      pathsToIgnore.push(...outputFiles.map((f) => f.path));
+    }
+  }
+  if (pathsToIgnore.length > 0 && !dryRun) {
+    await updateGitignore(rootDir, pathsToIgnore);
+  }
+  return results;
+}
+async function hasUnifiedConfig(rootDir) {
+  const aiDir = path.join(rootDir, UNIFIED_DIR);
+  try {
+    const stats = await fs3.stat(aiDir);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function generateDefaultConfig(tools) {
+  const enabledTools = tools ?? TOOL_IDS;
+  const toolsConfig = {};
+  for (const toolId of TOOL_IDS) {
+    toolsConfig[toolId] = {
+      enabled: enabledTools.includes(toolId),
+      versionControl: false
+    };
+  }
+  return {
+    tools: toolsConfig
+  };
+}
+async function initUnifiedConfig(options) {
+  const { rootDir, tools, minimal = false } = options;
+  const aiDir = path.join(rootDir, UNIFIED_DIR);
+  const created = [];
+  await fs3.mkdir(aiDir, { recursive: true });
+  created.push(UNIFIED_DIR);
+  const config = generateDefaultConfig(tools);
+  const configPath = path.join(aiDir, CONFIG_FILES.config);
+  await fs3.writeFile(
+    configPath,
+    JSON.stringify(config, null, 2) + "\n",
+    "utf-8"
+  );
+  created.push(path.join(UNIFIED_DIR, CONFIG_FILES.config));
+  if (!minimal) {
+    for (const dir of [CONFIG_DIRS.rules, CONFIG_DIRS.skills]) {
+      const dirPath = path.join(aiDir, dir);
+      await fs3.mkdir(dirPath, { recursive: true });
+      created.push(path.join(UNIFIED_DIR, dir));
+      const gitkeepPath = path.join(dirPath, ".gitkeep");
+      await fs3.writeFile(gitkeepPath, "", "utf-8");
+      created.push(path.join(UNIFIED_DIR, dir, ".gitkeep"));
+    }
+  }
+  return { created };
+}
+
+export { CONFIG_DIRS, CONFIG_FILES, FileNotFoundError, LnaiError, ParseError, PluginError, TOOL_IDS, TOOL_OUTPUT_DIRS, UNIFIED_DIR, ValidationError, WriteError, claudeCodePlugin, computeHash, configSchema, generateDefaultConfig, hasUnifiedConfig, initUnifiedConfig, mcpServerSchema, opencodePlugin, parseFrontmatter, parseUnifiedConfig, permissionsSchema, pluginRegistry, ruleFrontmatterSchema, runSyncPipeline, settingsSchema, skillFrontmatterSchema, toolConfigSchema, toolIdSchema, updateGitignore, validateConfig, validateSettings, validateUnifiedState, writeFiles };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map