@lnai/core 0.1.1 → 0.2.0

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"];
+declare const TOOL_IDS: readonly ["claudeCode", "opencode", "cursor"];
 type ToolId = (typeof TOOL_IDS)[number];
 declare const CONFIG_FILES: {
     readonly config: "config.json";
@@ -65,6 +65,7 @@ declare const toolConfigSchema: z.ZodObject<{
 declare const toolIdSchema: z.ZodEnum<{
     claudeCode: "claudeCode";
     opencode: "opencode";
+    cursor: "cursor";
 }>;
 /** Settings configuration (Claude format as source of truth) */
 declare const settingsSchema: z.ZodObject<{
@@ -87,6 +88,7 @@ declare const settingsSchema: z.ZodObject<{
     overrides: z.ZodOptional<z.ZodObject<{
         claudeCode: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         opencode: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        cursor: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /** Main config.json structure. Uses partial object to allow partial tool configs. */
@@ -100,6 +102,10 @@ declare const configSchema: z.ZodObject<{
             enabled: z.ZodBoolean;
             versionControl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         }, z.core.$strip>>;
+        cursor: 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) */
@@ -134,18 +140,11 @@ interface MarkdownFrontmatter {
 /** All parsed configuration from the .ai directory */
 interface UnifiedState {
     config: {
-        tools?: Partial<Record<ToolId, {
-            enabled: boolean;
-            versionControl?: boolean;
-        }>>;
+        tools?: Partial<Record<ToolId, ToolConfig>>;
     };
     settings: {
-        permissions?: {
-            allow?: string[];
-            ask?: string[];
-            deny?: string[];
-        };
-        mcpServers?: Record<string, unknown>;
+        permissions?: Permissions;
+        mcpServers?: Record<string, McpServer>;
         overrides?: Partial<Record<ToolId, Record<string, unknown>>>;
     } | null;
     agents: string | null;

package/dist/index.js

@@ -7,7 +7,7 @@ import * as crypto from 'crypto';
 
 // src/constants.ts
 var UNIFIED_DIR = ".ai";
-var TOOL_IDS = ["claudeCode", "opencode"];
+var TOOL_IDS = ["claudeCode", "opencode", "cursor"];
 var CONFIG_FILES = {
   config: "config.json",
   settings: "settings.json",
@@ -20,11 +20,13 @@ var CONFIG_DIRS = {
 };
 var TOOL_OUTPUT_DIRS = {
   claudeCode: ".claude",
-  opencode: ".opencode"
+  opencode: ".opencode",
+  cursor: ".cursor"
 };
 var OVERRIDE_DIRS = {
   claudeCode: ".claude",
-  opencode: ".opencode"
+  opencode: ".opencode",
+  cursor: ".cursor"
 };
 
 // src/errors.ts
@@ -50,10 +52,10 @@ var ParseError = class extends LnaiError {
 var ValidationError = class extends LnaiError {
   path;
   value;
-  constructor(message, path7, value) {
+  constructor(message, path5, value) {
     super(message, "VALIDATION_ERROR");
     this.name = "ValidationError";
-    this.path = path7;
+    this.path = path5;
     this.value = value;
   }
 };
@@ -104,19 +106,21 @@ var toolConfigSchema = z.object({
   enabled: z.boolean(),
   versionControl: z.boolean().optional().default(false)
 });
-var toolIdSchema = z.enum(["claudeCode", "opencode"]);
+var toolIdSchema = z.enum(["claudeCode", "opencode", "cursor"]);
 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()
+    opencode: z.record(z.string(), z.unknown()).optional(),
+    cursor: z.record(z.string(), z.unknown()).optional()
   }).optional()
 });
 var configSchema = z.object({
   tools: z.object({
     claudeCode: toolConfigSchema,
-    opencode: toolConfigSchema
+    opencode: toolConfigSchema,
+    cursor: toolConfigSchema
   }).partial().optional()
 });
 var skillFrontmatterSchema = z.object({
@@ -412,6 +416,26 @@ async function fileExists2(filePath) {
     return false;
   }
 }
+async function getOverrideOutputFiles(rootDir, toolId) {
+  const outputDir = TOOL_OUTPUT_DIRS[toolId];
+  const overrideFiles = await scanOverrideDirectory(rootDir, toolId);
+  const result = [];
+  for (const overrideFile of overrideFiles) {
+    const targetPath = path.join(rootDir, outputDir, overrideFile.relativePath);
+    if (await fileExists2(targetPath)) {
+      continue;
+    }
+    const symlinkPath = `${outputDir}/${overrideFile.relativePath}`;
+    const symlinkDir = path.dirname(symlinkPath);
+    const sourcePath = `${UNIFIED_DIR}/${OVERRIDE_DIRS[toolId]}/${overrideFile.relativePath}`;
+    result.push({
+      path: symlinkPath,
+      type: "symlink",
+      target: path.relative(symlinkDir, sourcePath)
+    });
+  }
+  return result;
+}
 
 // src/plugins/claude-code/index.ts
 var claudeCodePlugin = {
@@ -468,22 +492,236 @@ var claudeCodePlugin = {
         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;
+    const overrideFiles = await getOverrideOutputFiles(rootDir, "claudeCode");
+    files.push(...overrideFiles);
+    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/cursor/transforms.ts
+function transformRuleToCursor(rule) {
+  const description = deriveDescription(rule.path, rule.content);
+  const globs = rule.frontmatter.paths || [];
+  const alwaysApply = globs.length === 0;
+  return {
+    frontmatter: {
+      description,
+      globs,
+      alwaysApply
+    },
+    content: rule.content
+  };
+}
+function deriveDescription(filename, content) {
+  const headingMatch = content.match(/^#\s+(.+)$/m);
+  if (headingMatch && headingMatch[1]) {
+    return headingMatch[1];
+  }
+  const baseName = filename.replace(/\.md$/, "");
+  return baseName.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function serializeCursorRule(frontmatter, content) {
+  const lines = [
+    "---",
+    `description: ${JSON.stringify(frontmatter.description)}`
+  ];
+  lines.push("globs:");
+  for (const glob of frontmatter.globs) {
+    lines.push(`  - ${JSON.stringify(glob)}`);
+  }
+  lines.push(`alwaysApply: ${frontmatter.alwaysApply}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(content);
+  return lines.join("\n");
+}
+function transformMcpToCursor(servers) {
+  if (!servers || Object.keys(servers).length === 0) {
+    return void 0;
+  }
+  const result = {};
+  for (const [name, server] of Object.entries(servers)) {
+    if (server.type === "http" || server.type === "sse") {
+      const cursorServer = {
+        url: server.url
+      };
+      if (server.headers) {
+        cursorServer.headers = transformEnvVarsToCursor(server.headers);
+      }
+      result[name] = cursorServer;
+    } else if (server.command) {
+      const cursorServer = {
+        command: server.command
+      };
+      if (server.args && server.args.length > 0) {
+        cursorServer.args = server.args;
       }
+      if (server.env) {
+        cursorServer.env = transformEnvVarsToCursor(server.env);
+      }
+      result[name] = cursorServer;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function transformEnvVarToCursor(value) {
+  return value.replace(/\$\{([^}:]+)(:-[^}]*)?\}/g, "${env:$1}");
+}
+function transformEnvVarsToCursor(env) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    result[key] = transformEnvVarToCursor(value);
+  }
+  return result;
+}
+function transformPermissionsToCursor(permissions) {
+  if (!permissions) {
+    return { permissions: void 0, hasAskPermissions: false };
+  }
+  const allow = [];
+  const deny = [];
+  let hasAskPermissions = false;
+  if (permissions.allow) {
+    for (const rule of permissions.allow) {
+      const transformed = transformPermissionRule(rule);
+      if (transformed) {
+        allow.push(transformed);
+      }
+    }
+  }
+  if (permissions.ask && permissions.ask.length > 0) {
+    hasAskPermissions = true;
+    for (const rule of permissions.ask) {
+      const transformed = transformPermissionRule(rule);
+      if (transformed) {
+        allow.push(transformed);
+      }
+    }
+  }
+  if (permissions.deny) {
+    for (const rule of permissions.deny) {
+      const transformed = transformPermissionRule(rule);
+      if (transformed) {
+        deny.push(transformed);
+      }
+    }
+  }
+  if (allow.length === 0 && deny.length === 0) {
+    return { permissions: void 0, hasAskPermissions };
+  }
+  return {
+    permissions: {
+      allow,
+      deny
+    },
+    hasAskPermissions
+  };
+}
+function transformPermissionRule(rule) {
+  const match = rule.match(/^(\w+)\(([^)]+)\)$/);
+  if (!match) {
+    return null;
+  }
+  const tool = match[1];
+  let pattern = match[2];
+  const cursorTool = tool.toLowerCase() === "bash" ? "Shell" : tool;
+  if (pattern.endsWith(":*")) {
+    pattern = pattern.slice(0, -2);
+  }
+  return `${cursorTool}(${pattern})`;
+}
+
+// src/plugins/cursor/index.ts
+var cursorPlugin = {
+  id: "cursor",
+  name: "Cursor",
+  async detect(_rootDir) {
+    return false;
+  },
+  async import(_rootDir) {
+    return null;
+  },
+  async export(state, rootDir) {
+    const files = [];
+    const outputDir = TOOL_OUTPUT_DIRS.cursor;
+    if (state.agents) {
       files.push({
-        path: `${outputDir}/${overrideFile.relativePath}`,
+        path: "AGENTS.md",
         type: "symlink",
-        target: `../${UNIFIED_DIR}/${OVERRIDE_DIRS.claudeCode}/${overrideFile.relativePath}`
+        target: `${UNIFIED_DIR}/AGENTS.md`
+      });
+    }
+    for (const rule of state.rules) {
+      const transformed = transformRuleToCursor(rule);
+      const ruleContent = serializeCursorRule(
+        transformed.frontmatter,
+        transformed.content
+      );
+      const outputFilename = rule.path.replace(/\.md$/, ".mdc");
+      files.push({
+        path: `${outputDir}/rules/${outputFilename}`,
+        type: "text",
+        content: ruleContent
+      });
+    }
+    for (const skill of state.skills) {
+      files.push({
+        path: `${outputDir}/skills/${skill.path}`,
+        type: "symlink",
+        target: `../../${UNIFIED_DIR}/skills/${skill.path}`
       });
     }
+    const mcpServers = transformMcpToCursor(state.settings?.mcpServers);
+    const cursorOverrides = state.settings?.overrides?.cursor;
+    const hasMcpOverrides = cursorOverrides?.["mcpServers"] !== void 0;
+    if (mcpServers || hasMcpOverrides) {
+      let mcpContent = mcpServers ? { mcpServers } : {};
+      if (cursorOverrides?.["mcpServers"]) {
+        mcpContent = deepMergeConfigs(mcpContent, {
+          mcpServers: cursorOverrides["mcpServers"]
+        });
+      }
+      files.push({
+        path: `${outputDir}/mcp.json`,
+        type: "json",
+        content: mcpContent
+      });
+    }
+    const permissionsResult = transformPermissionsToCursor(
+      state.settings?.permissions
+    );
+    const hasCliOverrides = cursorOverrides !== void 0 && Object.keys(cursorOverrides).some((key) => key !== "mcpServers");
+    if (permissionsResult.permissions || hasCliOverrides) {
+      let cliContent = permissionsResult.permissions ? { permissions: permissionsResult.permissions } : {};
+      if (cursorOverrides) {
+        const cliOverrides = {};
+        for (const [key, value] of Object.entries(cursorOverrides)) {
+          if (key !== "mcpServers") {
+            cliOverrides[key] = value;
+          }
+        }
+        if (Object.keys(cliOverrides).length > 0) {
+          cliContent = deepMergeConfigs(cliContent, cliOverrides);
+        }
+      }
+      files.push({
+        path: `${outputDir}/cli.json`,
+        type: "json",
+        content: cliContent
+      });
+    }
+    const overrideFiles = await getOverrideOutputFiles(rootDir, "cursor");
+    files.push(...overrideFiles);
     return files;
   },
   validate(state) {
@@ -491,9 +729,31 @@ var claudeCodePlugin = {
     if (!state.agents) {
       warnings.push({
         path: ["AGENTS.md"],
-        message: "No AGENTS.md found - .claude/CLAUDE.md will not be created"
+        message: "No AGENTS.md found - root AGENTS.md will not be created"
       });
     }
+    const permissionsResult = transformPermissionsToCursor(
+      state.settings?.permissions
+    );
+    if (permissionsResult.hasAskPermissions) {
+      warnings.push({
+        path: ["settings", "permissions", "ask"],
+        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`
+          });
+        }
+      }
+    }
     return { valid: true, errors: [], warnings, skipped: [] };
   }
 };
@@ -504,8 +764,7 @@ function transformMcpToOpenCode(servers) {
     return void 0;
   }
   const result = {};
-  for (const [name, serverRaw] of Object.entries(servers)) {
-    const server = serverRaw;
+  for (const [name, server] of Object.entries(servers)) {
     if (server.type === "http" || server.type === "sse") {
       const openCodeServer = {
         type: "remote",
@@ -648,22 +907,8 @@ var opencodePlugin = {
       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}`
-      });
-    }
+    const overrideFiles = await getOverrideOutputFiles(rootDir, "opencode");
+    files.push(...overrideFiles);
     return files;
   },
   validate(state) {
@@ -701,6 +946,7 @@ var pluginRegistry = new PluginRegistry();
 
 // src/plugins/index.ts
 pluginRegistry.register(claudeCodePlugin);
+pluginRegistry.register(cursorPlugin);
 pluginRegistry.register(opencodePlugin);
 function computeHash(content) {
   return crypto.createHash("sha256").update(content, "utf-8").digest("hex");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lnai/core",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Core library for LNAI - unified AI config management",
   "type": "module",
   "license": "MIT",
@@ -19,6 +19,7 @@
     "config",
     "configuration",
     "claude",
+    "cursor",
     "opencode",
     "cli",
     "ai-tools"