@lnai/core 0.5.0 → 0.6.5

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 declare const UNIFIED_DIR = ".ai";
-declare const TOOL_IDS: readonly ["claudeCode", "opencode", "cursor", "copilot", "windsurf", "gemini"];
+declare const TOOL_IDS: readonly ["claudeCode", "opencode", "cursor", "copilot", "windsurf", "gemini", "codex"];
 type ToolId = (typeof TOOL_IDS)[number];
 declare const CONFIG_FILES: {
     readonly config: "config.json";
@@ -40,6 +40,10 @@ declare class PluginError extends LnaiError {
     readonly pluginId: string;
     constructor(message: string, pluginId: string, cause?: Error);
 }
+declare class InvalidToolError extends LnaiError {
+    readonly invalidTools: string[];
+    constructor(invalidTools: string[], validTools: string[]);
+}
 
 /** MCP Server configuration (Claude format as source of truth) */
 declare const mcpServerSchema: z.ZodObject<{
@@ -69,6 +73,7 @@ declare const toolIdSchema: z.ZodEnum<{
     copilot: "copilot";
     windsurf: "windsurf";
     gemini: "gemini";
+    codex: "codex";
 }>;
 /** Settings configuration (Claude format as source of truth) */
 declare const settingsSchema: z.ZodObject<{
@@ -116,6 +121,10 @@ declare const configSchema: z.ZodObject<{
             enabled: z.ZodBoolean;
             versionControl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         }, z.core.$strip>>;
+        codex: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            versionControl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /** Skill frontmatter (name and description required) */
@@ -197,6 +206,25 @@ interface SyncResult {
     changes: ChangeResult[];
     validation: ValidationResult;
 }
+/** Entry for a single file in the manifest */
+interface ManifestEntry {
+    path: string;
+    type: "json" | "text" | "symlink";
+    hash?: string;
+    target?: string;
+}
+/** Manifest for a single tool's generated files */
+interface ToolManifest {
+    version: 1;
+    tool: ToolId;
+    generatedAt: string;
+    files: ManifestEntry[];
+}
+/** Root manifest tracking all LNAI-generated files */
+interface LnaiManifest {
+    version: 1;
+    tools: Partial<Record<ToolId, ToolManifest>>;
+}
 
 declare function parseFrontmatter(content: string): {
     frontmatter: Record<string, unknown>;
@@ -249,6 +277,18 @@ interface Plugin {
  */
 declare const claudeCodePlugin: Plugin;
 
+/**
+ * Codex plugin for exporting to .codex/ format
+ *
+ * Output structure:
+ * - AGENTS.md (symlink -> .ai/AGENTS.md) [at project root]
+ * - <dir>/AGENTS.md (generated from .ai/rules/*.md, per glob directory)
+ * - .codex/skills/<name>/ (symlink -> ../../.ai/skills/<name>)
+ * - .codex/config.toml (generated from settings.mcpServers)
+ * - .codex/<path> (symlink -> ../.ai/.codex/<path>) for override files
+ */
+declare const codexPlugin: Plugin;
+
 /**
  * OpenCode plugin for exporting to opencode.json format
  *
@@ -281,8 +321,8 @@ interface SyncOptions {
     tools?: ToolId[];
     /** Preview changes without writing files */
     dryRun?: boolean;
-    /** Enable verbose output */
-    verbose?: boolean;
+    /** Skip cleanup of orphaned files */
+    skipCleanup?: boolean;
 }
 /**
  * Run the sync pipeline to export .ai/ config to native tool formats.
@@ -303,9 +343,50 @@ declare function writeFiles(files: OutputFile[], options: WriterOptions): Promis
 /**
  * Update .gitignore with paths that should not be version controlled.
  * Manages a dedicated "lnai-generated" section to avoid conflicts with user entries.
+ * Merges new paths with existing ones to support partial syncs (e.g., syncing one tool).
  */
 declare function updateGitignore(rootDir: string, paths: string[]): Promise<void>;
 
+declare const MANIFEST_FILENAME = ".lnai-manifest.json";
+/**
+ * Read the LNAI manifest from the .ai directory.
+ * Returns null if the manifest doesn't exist.
+ */
+declare function readManifest(rootDir: string): Promise<LnaiManifest | null>;
+/**
+ * Write the LNAI manifest to the .ai directory.
+ */
+declare function writeManifest(rootDir: string, manifest: LnaiManifest): Promise<void>;
+/**
+ * Build a tool manifest from output files.
+ */
+declare function buildToolManifest(toolId: ToolId, files: OutputFile[]): ToolManifest;
+/**
+ * Update a single tool's manifest entry.
+ */
+declare function updateToolManifest(manifest: LnaiManifest, toolId: ToolId, files: OutputFile[]): LnaiManifest;
+/**
+ * Create an empty manifest.
+ */
+declare function createEmptyManifest(): LnaiManifest;
+
+/**
+ * Compute which files should be deleted based on previous and current manifest entries.
+ * Returns paths that exist in previous but not in current.
+ */
+declare function computeFilesToDelete(previousFiles: ManifestEntry[], currentFiles: OutputFile[]): string[];
+/**
+ * Delete files that are no longer in the manifest.
+ * Returns ChangeResult[] with action: "delete" for each deleted file.
+ * When dryRun is true, no files are actually deleted.
+ */
+declare function deleteFiles(paths: string[], rootDir: string, dryRun: boolean): Promise<ChangeResult[]>;
+/**
+ * Clean up empty parent directories after file deletion.
+ * Stops at the project root directory.
+ */
+declare function cleanupEmptyParentDirs(filePath: string, rootDir: string): Promise<void>;
+
 interface InitOptions {
     rootDir: string;
     tools?: ToolId[];
@@ -320,4 +401,4 @@ declare function initUnifiedConfig(options: InitOptions): Promise<InitResult>;
 declare function hasUnifiedConfig(rootDir: string): Promise<boolean>;
 declare function generateDefaultConfig(tools?: ToolId[], versionControl?: Record<ToolId, boolean>): Config;
 
-export { CONFIG_DIRS, CONFIG_FILES, type ChangeResult, type Config, FileNotFoundError, type InitOptions, type InitResult, LnaiError, type MarkdownFile, type MarkdownFrontmatter, type McpServer, type OutputFile, ParseError, type PermissionLevel, type Permissions, type Plugin, PluginError, type RuleFrontmatter, type Settings, type SkillFrontmatter, type SkippedFeatureDetail, type SyncOptions, type SyncResult, TOOL_IDS, TOOL_OUTPUT_DIRS, type ToolConfig, type ToolId, UNIFIED_DIR, type UnifiedState, ValidationError, type ValidationErrorDetail, type ValidationResult, type ValidationWarningDetail, WriteError, type WriterOptions, claudeCodePlugin, computeHash, configSchema, generateDefaultConfig, hasUnifiedConfig, initUnifiedConfig, mcpServerSchema, opencodePlugin, parseFrontmatter, parseUnifiedConfig, permissionsSchema, pluginRegistry, ruleFrontmatterSchema, runSyncPipeline, settingsSchema, skillFrontmatterSchema, toolConfigSchema, toolIdSchema, updateGitignore, validateConfig, validateSettings, validateUnifiedState, writeFiles };
+export { CONFIG_DIRS, CONFIG_FILES, type ChangeResult, type Config, FileNotFoundError, type InitOptions, type InitResult, InvalidToolError, LnaiError, type LnaiManifest, MANIFEST_FILENAME, type ManifestEntry, type MarkdownFile, type MarkdownFrontmatter, type McpServer, type OutputFile, ParseError, type PermissionLevel, type Permissions, type Plugin, PluginError, type RuleFrontmatter, type Settings, type SkillFrontmatter, type SkippedFeatureDetail, type SyncOptions, type SyncResult, TOOL_IDS, TOOL_OUTPUT_DIRS, type ToolConfig, type ToolId, type ToolManifest, UNIFIED_DIR, type UnifiedState, ValidationError, type ValidationErrorDetail, type ValidationResult, type ValidationWarningDetail, WriteError, type WriterOptions, buildToolManifest, claudeCodePlugin, cleanupEmptyParentDirs, codexPlugin, computeFilesToDelete, computeHash, configSchema, createEmptyManifest, deleteFiles, generateDefaultConfig, hasUnifiedConfig, initUnifiedConfig, mcpServerSchema, opencodePlugin, parseFrontmatter, parseUnifiedConfig, permissionsSchema, pluginRegistry, readManifest, ruleFrontmatterSchema, runSyncPipeline, settingsSchema, skillFrontmatterSchema, toolConfigSchema, toolIdSchema, updateGitignore, updateToolManifest, validateConfig, validateSettings, validateUnifiedState, writeFiles, writeManifest };

package/dist/index.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import * as fs3 from 'fs/promises';
+import * as fs4 from 'fs/promises';
 import * as path from 'path';
 import matter from 'gray-matter';
 import * as crypto from 'crypto';
@@ -12,7 +12,8 @@ var TOOL_IDS = [
   "cursor",
   "copilot",
   "windsurf",
-  "gemini"
+  "gemini",
+  "codex"
 ];
 var CONFIG_FILES = {
   config: "config.json",
@@ -30,7 +31,8 @@ var TOOL_OUTPUT_DIRS = {
   cursor: ".cursor",
   copilot: ".github",
   windsurf: ".windsurf",
-  gemini: ".gemini"
+  gemini: ".gemini",
+  codex: ".codex"
 };
 var OVERRIDE_DIRS = {
   claudeCode: ".claude",
@@ -38,7 +40,8 @@ var OVERRIDE_DIRS = {
   cursor: ".cursor",
   copilot: ".copilot",
   windsurf: ".windsurf",
-  gemini: ".gemini"
+  gemini: ".gemini",
+  codex: ".codex"
 };
 
 // src/errors.ts
@@ -64,10 +67,10 @@ var ParseError = class extends LnaiError {
 var ValidationError = class extends LnaiError {
   path;
   value;
-  constructor(message, path6, value) {
+  constructor(message, path8, value) {
     super(message, "VALIDATION_ERROR");
     this.name = "ValidationError";
-    this.path = path6;
+    this.path = path8;
     this.value = value;
   }
 };
@@ -101,6 +104,17 @@ var PluginError = class extends LnaiError {
     }
   }
 };
+var InvalidToolError = class extends LnaiError {
+  invalidTools;
+  constructor(invalidTools, validTools) {
+    super(
+      `Invalid tool(s): ${invalidTools.join(", ")}. Valid tools: ${validTools.join(", ")}`,
+      "INVALID_TOOL"
+    );
+    this.name = "InvalidToolError";
+    this.invalidTools = invalidTools;
+  }
+};
 var mcpServerSchema = z.object({
   command: z.string().optional(),
   args: z.array(z.string()).optional(),
@@ -124,7 +138,8 @@ var toolIdSchema = z.enum([
   "cursor",
   "copilot",
   "windsurf",
-  "gemini"
+  "gemini",
+  "codex"
 ]);
 var settingsSchema = z.object({
   permissions: permissionsSchema.optional(),
@@ -137,7 +152,8 @@ var configSchema = z.object({
     cursor: toolConfigSchema,
     copilot: toolConfigSchema,
     windsurf: toolConfigSchema,
-    gemini: toolConfigSchema
+    gemini: toolConfigSchema,
+    codex: toolConfigSchema
   }).partial().optional()
 });
 var skillFrontmatterSchema = z.object({
@@ -199,7 +215,7 @@ async function parseUnifiedConfig(rootDir) {
 }
 async function fileExists(filePath) {
   try {
-    await fs3.access(filePath);
+    await fs4.access(filePath);
     return true;
   } catch {
     return false;
@@ -207,7 +223,7 @@ async function fileExists(filePath) {
 }
 async function readJsonFile(filePath) {
   try {
-    const content = await fs3.readFile(filePath, "utf-8");
+    const content = await fs4.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -222,7 +238,7 @@ async function readJsonFile(filePath) {
 }
 async function readMarkdownFile(filePath) {
   try {
-    return await fs3.readFile(filePath, "utf-8");
+    return await fs4.readFile(filePath, "utf-8");
   } catch (error) {
     if (error.code === "ENOENT") {
       throw new FileNotFoundError(`File not found: ${filePath}`, filePath);
@@ -239,7 +255,7 @@ async function readMarkdownDirectory(dirPath) {
   if (!await fileExists(dirPath)) {
     return files;
   }
-  const entries = await fs3.readdir(dirPath, { withFileTypes: true });
+  const entries = await fs4.readdir(dirPath, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".md")) {
       const filePath = path.join(dirPath, entry.name);
@@ -259,7 +275,7 @@ async function readSkillsDirectory(dirPath) {
   if (!await fileExists(dirPath)) {
     return skills;
   }
-  const entries = await fs3.readdir(dirPath, { withFileTypes: true });
+  const entries = await fs4.readdir(dirPath, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
       const skillFile = path.join(dirPath, entry.name, "SKILL.md");
@@ -400,7 +416,7 @@ function validateToolIds(tools) {
 async function scanOverrideDirectory(rootDir, toolId) {
   const overrideDir = path.join(rootDir, UNIFIED_DIR, OVERRIDE_DIRS[toolId]);
   try {
-    await fs3.access(overrideDir);
+    await fs4.access(overrideDir);
   } catch {
     return [];
   }
@@ -409,7 +425,7 @@ async function scanOverrideDirectory(rootDir, toolId) {
   return files;
 }
 async function scanDir(baseDir, currentDir, files) {
-  const entries = await fs3.readdir(currentDir, { withFileTypes: true });
+  const entries = await fs4.readdir(currentDir, { withFileTypes: true });
   for (const entry of entries) {
     const absolutePath = path.join(currentDir, entry.name);
     if (entry.isDirectory()) {
@@ -501,6 +517,209 @@ var claudeCodePlugin = {
     return { valid: true, errors: [], warnings, skipped: [] };
   }
 };
+function getDirFromGlob(glob) {
+  const cleanPath = glob.replace(/(\*\*|\*|\{.*,.*\}).*$/, "");
+  const dir = cleanPath.replace(/\/$/, "");
+  if (dir === glob) {
+    const dirname5 = path.dirname(dir);
+    return dirname5 === "." && !dir.includes("/") ? "." : dirname5;
+  }
+  if (!dir) {
+    return ".";
+  }
+  return dir;
+}
+function groupRulesByDirectory(rules) {
+  const rulesMap = /* @__PURE__ */ new Map();
+  const addedRules = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    for (const pathGlob of rule.frontmatter.paths) {
+      const dir = getDirFromGlob(pathGlob);
+      if (!rulesMap.has(dir)) {
+        rulesMap.set(dir, []);
+        addedRules.set(dir, /* @__PURE__ */ new Set());
+      }
+      if (addedRules.get(dir)?.has(rule.path)) {
+        continue;
+      }
+      addedRules.get(dir)?.add(rule.path);
+      const content = `## ${rule.path}
+
+${rule.content}
+`;
+      rulesMap.get(dir)?.push(content);
+    }
+  }
+  return rulesMap;
+}
+
+// src/plugins/codex/index.ts
+var codexPlugin = {
+  id: "codex",
+  name: "Codex",
+  async detect(_rootDir) {
+    return false;
+  },
+  async import(_rootDir) {
+    return null;
+  },
+  async export(state, rootDir) {
+    const files = [];
+    const outputDir = TOOL_OUTPUT_DIRS.codex;
+    if (state.agents) {
+      files.push({
+        path: "AGENTS.md",
+        type: "symlink",
+        target: `${UNIFIED_DIR}/AGENTS.md`
+      });
+    }
+    const rulesMap = groupRulesByDirectory(state.rules);
+    for (const [dir, contents] of rulesMap.entries()) {
+      if (dir === ".") {
+        continue;
+      }
+      const combinedContent = contents.join("\n---\n\n");
+      files.push({
+        path: `${dir}/AGENTS.md`,
+        type: "text",
+        content: combinedContent
+      });
+    }
+    for (const skill of state.skills) {
+      files.push({
+        path: `${outputDir}/skills/${skill.path}`,
+        type: "symlink",
+        target: `../../${UNIFIED_DIR}/skills/${skill.path}`
+      });
+    }
+    const configToml = buildCodexConfigToml(state.settings?.mcpServers);
+    if (configToml) {
+      files.push({
+        path: `${outputDir}/config.toml`,
+        type: "text",
+        content: configToml
+      });
+    }
+    return applyFileOverrides(files, rootDir, "codex");
+  },
+  validate(state) {
+    const warnings = [];
+    const skipped = [];
+    if (!state.agents) {
+      warnings.push({
+        path: ["AGENTS.md"],
+        message: "No AGENTS.md found - root AGENTS.md will not be created"
+      });
+    }
+    const rulesMap = groupRulesByDirectory(state.rules);
+    if (rulesMap.has(".")) {
+      warnings.push({
+        path: ["rules"],
+        message: "Rules with root globs are not exported - Codex only receives subdirectory AGENTS.md files"
+      });
+    }
+    const mcpServers = state.settings?.mcpServers;
+    if (mcpServers) {
+      for (const [name, server] of Object.entries(mcpServers)) {
+        if (!server.command && !server.url) {
+          warnings.push({
+            path: ["settings", "mcpServers", name],
+            message: `MCP server "${name}" has no command or url - it will be skipped`
+          });
+        }
+      }
+    }
+    if (state.settings?.permissions) {
+      const hasPermissions = (state.settings.permissions.allow?.length ?? 0) > 0 || (state.settings.permissions.ask?.length ?? 0) > 0 || (state.settings.permissions.deny?.length ?? 0) > 0;
+      if (hasPermissions) {
+        skipped.push({
+          feature: "permissions",
+          reason: "Codex rules are not generated from LNAI permissions"
+        });
+      }
+    }
+    return { valid: true, errors: [], warnings, skipped };
+  }
+};
+function buildCodexConfigToml(mcpServers) {
+  if (!mcpServers || Object.keys(mcpServers).length === 0) {
+    return void 0;
+  }
+  const lines = [];
+  for (const [name, server] of Object.entries(mcpServers)) {
+    const hasCommand = !!server.command;
+    const hasUrl = !!server.url;
+    if (!hasCommand && !hasUrl) {
+      continue;
+    }
+    lines.push(`[mcp_servers.${formatTomlKey(name)}]`);
+    if (server.command) {
+      lines.push(`command = ${formatTomlString(server.command)}`);
+      if (server.args && server.args.length > 0) {
+        lines.push(`args = ${formatTomlArray(server.args)}`);
+      }
+      if (server.env && Object.keys(server.env).length > 0) {
+        lines.push(`env = ${formatTomlInlineTable(server.env)}`);
+      }
+    }
+    if (server.url) {
+      lines.push(`url = ${formatTomlString(server.url)}`);
+      if (server.headers && Object.keys(server.headers).length > 0) {
+        lines.push(`http_headers = ${formatTomlInlineTable(server.headers)}`);
+      }
+    }
+    lines.push("");
+  }
+  if (lines.length === 0) {
+    return void 0;
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function formatTomlString(value) {
+  return JSON.stringify(value);
+}
+function formatTomlArray(values) {
+  return `[${values.map(formatTomlString).join(", ")}]`;
+}
+function formatTomlKey(key) {
+  if (/^[A-Za-z0-9_-]+$/.test(key)) {
+    return key;
+  }
+  return JSON.stringify(key);
+}
+function formatTomlInlineTable(values) {
+  const entries = Object.entries(values).map(
+    ([key, value]) => `${formatTomlKey(key)} = ${formatTomlString(value)}`
+  );
+  return `{ ${entries.join(", ")} }`;
+}
+
+// src/utils/mcp.ts
+function validateMcpServers(mcpServers, pathPrefix) {
+  const warnings = [];
+  if (!mcpServers) {
+    return warnings;
+  }
+  for (const [name, server] of Object.entries(mcpServers)) {
+    const isRemote = server.type === "http" || server.type === "sse";
+    const hasCommand = !!server.command;
+    const hasUrl = !!server.url;
+    if (!isRemote && !hasCommand) {
+      warnings.push({
+        path: [...pathPrefix, name],
+        message: `MCP server "${name}" has no command or type - it will be skipped`
+      });
+    }
+    if (isRemote && !hasUrl) {
+      warnings.push({
+        path: [...pathPrefix, name],
+        message: `MCP server "${name}" is remote but has no URL - it will be skipped`
+      });
+    }
+  }
+  return warnings;
+}
 
 // src/utils/transforms.ts
 var ENV_VAR_PATTERN = /\$\{([^}:]+)(:-[^}]*)?\}/g;
@@ -672,24 +891,12 @@ var copilotPlugin = {
         reason: "GitHub Copilot does not support declarative permissions"
       });
     }
-    const mcpServers = state.settings?.mcpServers;
-    if (mcpServers) {
-      for (const [name, server] of Object.entries(mcpServers)) {
-        const isRemote = server.type === "http" || server.type === "sse";
-        const hasCommand = !!server.command;
-        if (isRemote && !server.url) {
-          warnings.push({
-            path: ["settings", "mcpServers", name],
-            message: `MCP server "${name}" is type "${server.type}" but has no url - it will be skipped`
-          });
-        } else if (!isRemote && !hasCommand) {
-          warnings.push({
-            path: ["settings", "mcpServers", name],
-            message: `MCP server "${name}" has no command or type - it will be skipped`
-          });
-        }
-      }
-    }
+    warnings.push(
+      ...validateMcpServers(state.settings?.mcpServers, [
+        "settings",
+        "mcpServers"
+      ])
+    );
     return { valid: true, errors: [], warnings, skipped };
   }
 };
@@ -884,19 +1091,12 @@ var cursorPlugin = {
         message: 'Cursor does not support "ask" permission level - these rules will be treated as "allow"'
       });
     }
-    const mcpServers = state.settings?.mcpServers;
-    if (mcpServers) {
-      for (const [name, server] of Object.entries(mcpServers)) {
-        const isRemote = server.type === "http" || server.type === "sse";
-        const hasCommand = !!server.command;
-        if (!isRemote && !hasCommand) {
-          warnings.push({
-            path: ["settings", "mcpServers", name],
-            message: `MCP server "${name}" has no command or type - it will be skipped`
-          });
-        }
-      }
-    }
+    warnings.push(
+      ...validateMcpServers(state.settings?.mcpServers, [
+        "settings",
+        "mcpServers"
+      ])
+    );
     return { valid: true, errors: [], warnings, skipped: [] };
   }
 };
@@ -907,18 +1107,6 @@ function buildCliContent(permissions) {
   }
   return { permissions: permissionsResult.permissions };
 }
-function getDirFromGlob(glob) {
-  const cleanPath = glob.replace(/(\*\*|\*|\{.*,.*\}).*$/, "");
-  const dir = cleanPath.replace(/\/$/, "");
-  if (dir === glob) {
-    const dirname4 = path.dirname(dir);
-    return dirname4 === "." && !dir.includes("/") ? "." : dirname4;
-  }
-  if (!dir) {
-    return ".";
-  }
-  return dir;
-}
 
 // src/plugins/gemini/transforms.ts
 function transformMcpToGemini(mcpServers) {
@@ -941,23 +1129,6 @@ function transformMcpToGemini(mcpServers) {
   }
   return Object.keys(geminiMcp).length > 0 ? geminiMcp : void 0;
 }
-function groupRulesByDirectory(rules) {
-  const rulesMap = /* @__PURE__ */ new Map();
-  for (const rule of rules) {
-    for (const pathGlob of rule.frontmatter.paths) {
-      const dir = getDirFromGlob(pathGlob);
-      if (!rulesMap.has(dir)) {
-        rulesMap.set(dir, []);
-      }
-      const content = `## ${rule.path}
-
-${rule.content}
-`;
-      rulesMap.get(dir)?.push(content);
-    }
-  }
-  return rulesMap;
-}
 
 // src/plugins/gemini/index.ts
 var geminiPlugin = {
@@ -1171,6 +1342,12 @@ var opencodePlugin = {
         message: "No AGENTS.md found - root AGENTS.md will not be created"
       });
     }
+    warnings.push(
+      ...validateMcpServers(state.settings?.mcpServers, [
+        "settings",
+        "mcpServers"
+      ])
+    );
     return { valid: true, errors: [], warnings, skipped: [] };
   }
 };
@@ -1304,24 +1481,69 @@ var windsurfPlugin = {
 pluginRegistry.register(claudeCodePlugin);
 pluginRegistry.register(copilotPlugin);
 pluginRegistry.register(cursorPlugin);
+pluginRegistry.register(codexPlugin);
 pluginRegistry.register(opencodePlugin);
 pluginRegistry.register(windsurfPlugin);
 pluginRegistry.register(geminiPlugin);
+function computeFilesToDelete(previousFiles, currentFiles) {
+  const currentPaths = new Set(currentFiles.map((f) => f.path));
+  return previousFiles.map((f) => f.path).filter((p) => !currentPaths.has(p));
+}
+async function deleteFiles(paths, rootDir, dryRun) {
+  const results = [];
+  for (const relativePath of paths) {
+    const fullPath = path.join(rootDir, relativePath);
+    try {
+      await fs4.lstat(fullPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        continue;
+      }
+      throw error;
+    }
+    if (!dryRun) {
+      await fs4.unlink(fullPath);
+      await cleanupEmptyParentDirs(fullPath, rootDir);
+    }
+    results.push({
+      path: relativePath,
+      action: "delete"
+    });
+  }
+  return results;
+}
+async function cleanupEmptyParentDirs(filePath, rootDir) {
+  let dir = path.dirname(filePath);
+  const normalizedRoot = path.normalize(rootDir);
+  while (dir !== normalizedRoot && dir.startsWith(normalizedRoot + path.sep)) {
+    try {
+      const entries = await fs4.readdir(dir);
+      if (entries.length === 0) {
+        await fs4.rmdir(dir);
+        dir = path.dirname(dir);
+      } else {
+        break;
+      }
+    } catch {
+      break;
+    }
+  }
+}
 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");
+    return await fs4.readFile(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 async function getSymlinkTarget(filePath) {
   try {
-    const stats = await fs3.lstat(filePath);
+    const stats = await fs4.lstat(filePath);
     if (stats.isSymbolicLink()) {
-      return await fs3.readlink(filePath);
+      return await fs4.readlink(filePath);
     }
     return null;
   } catch {
@@ -1329,15 +1551,15 @@ async function getSymlinkTarget(filePath) {
   }
 }
 async function ensureDir(dirPath) {
-  await fs3.mkdir(dirPath, { recursive: true });
+  await fs4.mkdir(dirPath, { recursive: true });
 }
 async function removeIfExists(filePath) {
   try {
-    const stats = await fs3.lstat(filePath);
+    const stats = await fs4.lstat(filePath);
     if (stats.isDirectory() && !stats.isSymbolicLink()) {
-      await fs3.rm(filePath, { recursive: true, force: true });
+      await fs4.rm(filePath, { recursive: true, force: true });
     } else {
-      await fs3.unlink(filePath);
+      await fs4.unlink(filePath);
     }
   } catch (error) {
     if (error.code !== "ENOENT") {
@@ -1349,6 +1571,12 @@ async function writeSingleFile(file, rootDir, dryRun) {
   const fullPath = path.join(rootDir, file.path);
   const dirPath = path.dirname(fullPath);
   if (file.type === "symlink") {
+    if (!file.target) {
+      throw new WriteError(
+        `Symlink file missing target: ${file.path}`,
+        file.path
+      );
+    }
     const target = file.target;
     const existingTarget = await getSymlinkTarget(fullPath);
     if (existingTarget === target) {
@@ -1360,7 +1588,7 @@ async function writeSingleFile(file, rootDir, dryRun) {
     if (!dryRun) {
       await ensureDir(dirPath);
       await removeIfExists(fullPath);
-      await fs3.symlink(target, fullPath);
+      await fs4.symlink(target, fullPath);
     }
     return {
       path: file.path,
@@ -1381,7 +1609,11 @@ async function writeSingleFile(file, rootDir, dryRun) {
   }
   if (!dryRun) {
     await ensureDir(dirPath);
-    await fs3.writeFile(fullPath, content, "utf-8");
+    const existingSymlink = await getSymlinkTarget(fullPath);
+    if (existingSymlink !== null) {
+      await removeIfExists(fullPath);
+    }
+    await fs4.writeFile(fullPath, content, "utf-8");
   }
   return {
     path: file.path,
@@ -1411,18 +1643,86 @@ async function updateGitignore(rootDir, paths) {
   const gitignorePath = path.join(rootDir, ".gitignore");
   let content = "";
   try {
-    content = await fs3.readFile(gitignorePath, "utf-8");
+    content = await fs4.readFile(gitignorePath, "utf-8");
   } catch {
   }
   const marker = "# lnai-generated";
   const endMarker = "# end lnai-generated";
+  const extractRegex = new RegExp(`${marker}\\n([\\s\\S]*?)${endMarker}`);
+  const match = extractRegex.exec(content);
+  const existingSection = match?.[1] ?? "";
+  const existingPaths = existingSection.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   const markerRegex = new RegExp(`${marker}[\\s\\S]*?${endMarker}\\n?`, "g");
   content = content.replace(markerRegex, "");
   content = content.trimEnd();
-  const uniquePaths = [...new Set(paths)];
+  const uniquePaths = [.../* @__PURE__ */ new Set([...existingPaths, ...paths])].sort();
   const newSection = ["", marker, ...uniquePaths, endMarker, ""].join("\n");
   content = content + newSection;
-  await fs3.writeFile(gitignorePath, content, "utf-8");
+  await fs4.writeFile(gitignorePath, content, "utf-8");
+}
+
+// src/manifest/index.ts
+var MANIFEST_FILENAME = ".lnai-manifest.json";
+async function readManifest(rootDir) {
+  const manifestPath = path.join(rootDir, UNIFIED_DIR, MANIFEST_FILENAME);
+  try {
+    const content = await fs4.readFile(manifestPath, "utf-8");
+    const manifest = JSON.parse(content);
+    if (manifest.version !== 1) {
+      console.warn(
+        `[lnai] Unknown manifest version ${manifest.version}, skipping cleanup`
+      );
+      return null;
+    }
+    return manifest;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    console.warn(`[lnai] Failed to read manifest: ${error.message}`);
+    return null;
+  }
+}
+async function writeManifest(rootDir, manifest) {
+  const manifestPath = path.join(rootDir, UNIFIED_DIR, MANIFEST_FILENAME);
+  const content = JSON.stringify(manifest, null, 2) + "\n";
+  await fs4.writeFile(manifestPath, content, "utf-8");
+}
+function buildToolManifest(toolId, files) {
+  const entries = files.map((file) => {
+    const entry = {
+      path: file.path,
+      type: file.type
+    };
+    if (file.type === "symlink") {
+      entry.target = file.target;
+    } else {
+      const content = file.type === "json" ? JSON.stringify(file.content, null, 2) + "\n" : String(file.content);
+      entry.hash = computeHash(content);
+    }
+    return entry;
+  });
+  return {
+    version: 1,
+    tool: toolId,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: entries
+  };
+}
+function updateToolManifest(manifest, toolId, files) {
+  return {
+    ...manifest,
+    tools: {
+      ...manifest.tools,
+      [toolId]: buildToolManifest(toolId, files)
+    }
+  };
+}
+function createEmptyManifest() {
+  return {
+    version: 1,
+    tools: {}
+  };
 }
 
 // src/pipeline/index.ts
@@ -1444,7 +1744,12 @@ function getToolsToSync(config, requestedTools) {
   return enabledTools;
 }
 async function runSyncPipeline(options) {
-  const { rootDir, dryRun = false, tools: requestedTools } = options;
+  const {
+    rootDir,
+    dryRun = false,
+    skipCleanup = false,
+    tools: requestedTools
+  } = options;
   if (requestedTools && requestedTools.length > 0) {
     const toolValidation = validateToolIds(requestedTools);
     if (!toolValidation.valid) {
@@ -1470,6 +1775,7 @@ async function runSyncPipeline(options) {
   if (toolsToSync.length === 0) {
     return [];
   }
+  let manifest = await readManifest(rootDir) ?? createEmptyManifest();
   const results = [];
   const pathsToIgnore = [];
   for (const toolId of toolsToSync) {
@@ -1479,17 +1785,32 @@ async function runSyncPipeline(options) {
     }
     const validation = plugin.validate(state);
     const outputFiles = await plugin.export(state, rootDir);
-    const changes = await writeFiles(outputFiles, { rootDir, dryRun });
+    let deleteChanges = [];
+    if (!skipCleanup && manifest.tools[toolId]) {
+      const toDelete = computeFilesToDelete(
+        manifest.tools[toolId].files,
+        outputFiles
+      );
+      deleteChanges = await deleteFiles(toDelete, rootDir, dryRun);
+    }
+    const writeChanges = await writeFiles(outputFiles, { rootDir, dryRun });
+    const changes = [...deleteChanges, ...writeChanges];
     results.push({
       tool: toolId,
       changes,
       validation
     });
+    if (!dryRun) {
+      manifest = updateToolManifest(manifest, toolId, outputFiles);
+    }
     const toolConfig = state.config.tools?.[toolId];
     if (!toolConfig?.versionControl) {
       pathsToIgnore.push(...outputFiles.map((f) => f.path));
     }
   }
+  if (!dryRun) {
+    await writeManifest(rootDir, manifest);
+  }
   if (pathsToIgnore.length > 0 && !dryRun) {
     await updateGitignore(rootDir, pathsToIgnore);
   }
@@ -1515,12 +1836,12 @@ async function initUnifiedConfig(options) {
     );
   }
   if (exists) {
-    await fs3.rm(aiDir, { recursive: true, force: true });
+    await fs4.rm(aiDir, { recursive: true, force: true });
   }
-  await fs3.mkdir(aiDir, { recursive: true });
+  await fs4.mkdir(aiDir, { recursive: true });
   created.push(UNIFIED_DIR);
   const configPath = path.join(aiDir, CONFIG_FILES.config);
-  await fs3.writeFile(
+  await fs4.writeFile(
     configPath,
     JSON.stringify(config, null, 2) + "\n",
     "utf-8"
@@ -1529,10 +1850,10 @@ async function initUnifiedConfig(options) {
   if (!minimal) {
     for (const dir of [CONFIG_DIRS.rules, CONFIG_DIRS.skills]) {
       const dirPath = path.join(aiDir, dir);
-      await fs3.mkdir(dirPath, { recursive: true });
+      await fs4.mkdir(dirPath, { recursive: true });
       created.push(path.join(UNIFIED_DIR, dir));
       const gitkeepPath = path.join(dirPath, ".gitkeep");
-      await fs3.writeFile(gitkeepPath, "", "utf-8");
+      await fs4.writeFile(gitkeepPath, "", "utf-8");
       created.push(path.join(UNIFIED_DIR, dir, ".gitkeep"));
     }
   }
@@ -1541,7 +1862,7 @@ async function initUnifiedConfig(options) {
 async function hasUnifiedConfig(rootDir) {
   const aiDir = path.join(rootDir, UNIFIED_DIR);
   try {
-    const stats = await fs3.stat(aiDir);
+    const stats = await fs4.stat(aiDir);
     return stats.isDirectory();
   } catch {
     return false;
@@ -1570,4 +1891,4 @@ function generateDefaultConfig(tools, versionControl) {
   return { tools: toolsConfig };
 }
 
-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 };
+export { CONFIG_DIRS, CONFIG_FILES, FileNotFoundError, InvalidToolError, LnaiError, MANIFEST_FILENAME, ParseError, PluginError, TOOL_IDS, TOOL_OUTPUT_DIRS, UNIFIED_DIR, ValidationError, WriteError, buildToolManifest, claudeCodePlugin, cleanupEmptyParentDirs, codexPlugin, computeFilesToDelete, computeHash, configSchema, createEmptyManifest, deleteFiles, generateDefaultConfig, hasUnifiedConfig, initUnifiedConfig, mcpServerSchema, opencodePlugin, parseFrontmatter, parseUnifiedConfig, permissionsSchema, pluginRegistry, readManifest, ruleFrontmatterSchema, runSyncPipeline, settingsSchema, skillFrontmatterSchema, toolConfigSchema, toolIdSchema, updateGitignore, updateToolManifest, validateConfig, validateSettings, validateUnifiedState, writeFiles, writeManifest };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lnai/core",
-  "version": "0.5.0",
+  "version": "0.6.5",
   "description": "Core library for LNAI - unified AI config management",
   "type": "module",
   "license": "MIT",