glooit 0.5.1 → 0.5.3

package/README.md

@@ -7,11 +7,15 @@
 ## Quick Start
 
 ```bash
-# Install globally
-npm install -g glooitit
+# Install 
+npm install -g glooit
+bun install -g glooit
+pnpm install -g glooit
 
-# Or run directly
-npx glooitit init
+#  Run
+npx glooit init
+bunx glooit init
+pnpx glooit init
 ```
 
 ## Basic Usage
@@ -30,9 +34,9 @@ import { Config } from 'glooit';
 export default {
   rules: [
     {
-      file: 'my-coding-rules.md',
+      file: 'main.md',
       to: './',
-      targets: ['claude', 'cursor']
+      targets: ['claude', 'cursor', 'codex']
     }
   ]
 } satisfies Config;
@@ -45,8 +49,10 @@ glooit sync
 ```
 
 This automatically creates:
+
 - `CLAUDE.md` (for Claude Code)
-- `.cursor/rules/my-coding-rules.md` (for Cursor)
+- `.cursor/rules/main.md` (for Cursor)
+- `AGENTS.md` (for Codex)
 
 ### 3. Add MCP Configurations
 
@@ -73,36 +79,179 @@ export default {
 
 ### Supported Agents
 
-- **Claude Code**: `.mcp.json`
-- **Cursor**: `~/.cursor/mcp.json`
-- **Roo Code/Cline**: `.roo/mcp.json`
+- **Claude Code**
+- **Cursor**
+- **Roo Code/Cline**
+- **Codex**
+- **Generic**
 
-### Example Configuration
+### Full Configuration
 
 ```typescript
-import { Config } from 'glooit';
+import { defineRules } from 'glooit';
 
-export default {
+export default defineRules({
   configDir: '.glooit',
+  targets: ['claude', 'cursor'],
   rules: [
     {
-      file: 'coding-standards.md',
+      name: 'main',
+      file: '.glooit/main.md',
       to: './',
-      targets: ['claude', 'cursor', 'roocode']
+      targets: ['claude', 'cursor']
     }
   ],
+  mcps: [],
+  mergeMcps: true,
+  backup: {
+    enabled: true,
+    retention: 10
+  }
+});
+```
+
+## Advanced Usage
+
+### Custom File Destinations
+
+```typescript
+export default defineRules({
+  rules: [
+    {
+      name: 'backend-rules',
+      file: '.glooit/backend.md',
+      to: './',
+      targets: [
+        'claude',
+        { name: 'cursor', to: './backend/.cursor/rules/backend.md' },
+        { name: 'generic', to: './docs/backend-standards.md' }
+      ]
+    }
+  ]
+});
+```
+
+### Hooks (Before & After Sync)
+
+```typescript
+import { defineRules, hooks } from 'glooit';
+
+export default defineRules({
+  rules: [/* your rules */],
+  hooks: {
+    before: [
+      async ({ config }) => {
+        console.log('🚀 Starting sync...');
+        // Run tests, validate env, etc.
+      }
+    ],
+    after: [
+      async (context) => {
+        console.log('✅ Sync complete!');
+        // Commit changes, notify team, etc.
+        return `Synced ${context.rule.name} successfully`;
+      },
+      hooks.addTimestamp,
+      hooks.replaceEnv
+    ]
+  }
+});
+```
+
+### Built-in Hooks
+
+glooit comes with handy hooks to supercharge your sync process:
+
+```typescript
+import { defineRules, hooks } from 'glooit';
+
+export default defineRules({
+  rules: [/* your rules */],
+  hooks: {
+    after: [
+      hooks.addTimestamp,
+      hooks.replaceEnv,
+      hooks.replaceStructure,
+      hooks.compact()
+    ]
+  }
+});
+```
+
+**🕒 `addTimestamp`** - Replace `__TIMESTAMP__` with current date/time
+```markdown
+Last updated: __TIMESTAMP__
+<!-- Becomes: Last updated: December 24, 2024, 03:30 PM -->
+```
+
+**🌍 `replaceEnv`** - Replace `__ENV_VAR__` patterns with environment variables
+```markdown
+Database: __ENV_DATABASE_URL__
+API Key: __ENV_API_KEY__
+<!-- Uses your actual env vars -->
+```
+
+**📁 `replaceStructure`** - Replace `__STRUCTURE__` with project tree
+```markdown
+Project structure:
+__STRUCTURE__
+<!-- Becomes a nice ASCII tree of your project -->
+```
+
+**🗜️ `compact`** - Clean up and compress your markdown
+```typescript
+hooks.compact({
+  maxConsecutiveNewlines: 2,
+  removeFillerWords: true,    // Removes "basically", "literally", etc.
+  compactLists: true         // Tightens up list spacing
+})
+```
+
+### MCP Configuration
+
+```typescript
+export default defineRules({
+  rules: [/* your rules */],
   mcps: [
     {
-      name: 'database',
+      name: 'filesystem',
       config: {
         command: 'npx',
-        args: ['db-mcp-server']
+        args: ['@modelcontextprotocol/server-filesystem', process.cwd()]
       },
       targets: ['claude']
+    },
+    {
+      name: 'postgres',
+      config: {
+        command: 'uvx',
+        args: ['mcp-server-postgres'],
+        env: { DATABASE_URL: process.env.DATABASE_URL }
+      },
+      targets: ['claude', 'cursor']
     }
-  ],
-  mergeMcps: true
-} satisfies Config;
+  ]
+});
+```
+
+### Monorepos & AGENTS.md
+
+When using `AGENTS.md` in subdirectories, Cursor automatically detects them - no need to enable Cursor for those specific paths. Perfect for monorepos where different services need different rules.
+
+### File Formats by Project Type
+
+**JavaScript/TypeScript projects:**
+
+```typescript
+// glooit.config.ts - with TypeScript support
+export default defineRules({ /* config */ });
+```
+
+**Non-JS projects:**
+
+```javascript
+// glooit.config.js - plain JavaScript / typescript
+export default { /* config */ };
 ```
 
 ## Commands
@@ -120,25 +269,12 @@ glooit backup list   # List backups
 
 - 🔄 **Multi-platform sync** - Works with all major AI coding assistants
 - 📦 **MCP support** - Model Context Protocol configuration management
-- 🎯 **Selective targeting** - Choose which agents get which rules
+- 🎯 **Selective targeting** - Choose which agents get which rules and wht folders, perfect for complex projects & monorepos
 - 🔙 **Backup system** - Automatic backups before changes
 - 🧹 **Clean management** - Easy cleanup and reset options
-- ⚡ **Fast** - Built with Bun for maximum performance
-
-## Installation
-
-```bash
-# NPM
-npm install -g glooit
-
-# Bun
-bun install -g glooit
-
-# Direct execution
-npx glooitit init
-bunx glooitit sync
-```
+- 📝 **Auto .gitignore** - Automatically manages generated files in .gitignore
+- ⚡ **Fast** - Built with Bun for.... you know... bun?
 
 ## License
 
-MIT
+MIT

package/dist/agents/distributor.d.ts

@@ -3,6 +3,8 @@ export declare class AgentDistributor {
     private config;
     constructor(config: Config);
     distributeRule(rule: Rule): Promise<void>;
+    private getAgentName;
+    private getCustomPath;
     private distributeToAgent;
     private loadRuleContent;
     private extractRuleName;

package/dist/agents/index.d.ts

@@ -1,5 +1,5 @@
-import type { Agent, AgentMapping } from '../types';
-export declare const AGENT_MAPPINGS: Record<Agent, AgentMapping>;
-export declare function getAgentPath(agent: Agent, name?: string): string;
-export declare function getAgentDirectory(agent: Agent): string | undefined;
-export declare function getAgentMcpPath(agent: Agent): string;
+import type { AgentName, AgentMapping } from '../types';
+export declare const AGENT_MAPPINGS: Record<AgentName, AgentMapping>;
+export declare function getAgentPath(agent: AgentName, name?: string): string;
+export declare function getAgentDirectory(agent: AgentName): string | undefined;
+export declare function getAgentMcpPath(agent: AgentName): string;

package/dist/agents/writers/index.d.ts

@@ -1,8 +1,8 @@
-import type { Agent, Rule, ResolvedMcp } from '../../types';
+import type { AgentName, Rule, ResolvedMcp } from '../../types';
 export interface AgentWriter {
     formatContent(content: string, rule: Rule): string;
     formatMcp?(mcp: ResolvedMcp, merge: boolean): string;
 }
 export declare class AgentWriterFactory {
-    static createWriter(agent: Agent): AgentWriter;
+    static createWriter(agent: AgentName): AgentWriter;
 }

package/dist/cli/index.js

@@ -2141,7 +2141,7 @@ var AGENT_MAPPINGS = {
     mcpPath: ".mcp.json"
   },
   cursor: {
-    path: ".cursor/rules/{name}.md",
+    path: ".cursor/rules/{name}.mdc",
     format: "frontmatter",
     directory: ".cursor/rules",
     mcpPath: "~/.cursor/mcp.json"
@@ -2156,6 +2156,11 @@ var AGENT_MAPPINGS = {
     format: "markdown",
     directory: ".roo/rules",
     mcpPath: ".roo/mcp.json"
+  },
+  generic: {
+    path: "{name}.md",
+    format: "markdown",
+    mcpPath: "mcp.json"
   }
 };
 function getAgentPath(agent, name = "global") {
@@ -2210,11 +2215,12 @@ import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 class CursorWriter {
   formatContent(content, rule) {
     const ruleName = this.extractRuleName(rule.file);
+    const hasGlobs = rule.globs && rule.globs.length > 0;
     const frontmatter = [
       "---",
       `description: AI Rules - ${ruleName}`,
-      `globs: ${rule.globs || "**/*"}`,
-      "alwaysApply: true",
+      `globs: ${hasGlobs ? rule.globs : "**/*"}`,
+      "alwaysApply: " + (hasGlobs ? "false" : "true"),
       "---",
       ""
     ].join(`
@@ -2251,6 +2257,7 @@ class AgentWriterFactory {
       case "claude":
       case "codex":
       case "roocode":
+      case "generic":
         return new MarkdownWriter;
       default:
         return new MarkdownWriter;
@@ -2334,25 +2341,32 @@ class AgentDistributor {
       await this.distributeToAgent(agent, rule, content);
     }
   }
+  getAgentName(agent) {
+    return typeof agent === "string" ? agent : agent.name;
+  }
+  getCustomPath(agent) {
+    return typeof agent === "object" ? agent.to : undefined;
+  }
   async distributeToAgent(agent, rule, content) {
-    const ruleName = this.extractRuleName(rule.file);
-    const agentPath = getAgentPath(agent, ruleName);
-    const targetPath = join2(rule.to, agentPath);
-    const agentDir = getAgentDirectory(agent);
-    if (agentDir) {
-      const fullDir = join2(rule.to, agentDir);
-      mkdirSync(fullDir, { recursive: true });
+    const agentName = this.getAgentName(agent);
+    const customPath = this.getCustomPath(agent);
+    let targetPath;
+    if (customPath) {
+      targetPath = customPath;
     } else {
-      mkdirSync(dirname(targetPath), { recursive: true });
+      const ruleName = this.extractRuleName(rule.file);
+      const agentPath = getAgentPath(agentName, ruleName);
+      targetPath = join2(rule.to, agentPath);
     }
-    const writer = AgentWriterFactory.createWriter(agent);
+    mkdirSync(dirname(targetPath), { recursive: true });
+    const writer = AgentWriterFactory.createWriter(agentName);
     const formattedContent = writer.formatContent(content, rule);
     const context = {
       config: this.config,
       rule,
       content: formattedContent,
       targetPath,
-      agent
+      agent: agentName
     };
     const finalContent = await this.applyHooks(context);
     writeFileSync(targetPath, finalContent, "utf-8");
@@ -2509,6 +2523,12 @@ class GitIgnoreManager {
   constructor(config) {
     this.config = config;
   }
+  getAgentName(agent) {
+    return typeof agent === "string" ? agent : agent.name;
+  }
+  getCustomPath(agent) {
+    return typeof agent === "object" ? agent.to : undefined;
+  }
   async updateGitIgnore() {
     const paths = this.collectGeneratedPaths();
     if (paths.length === 0) {
@@ -2539,22 +2559,34 @@ class GitIgnoreManager {
     const paths = new Set;
     for (const rule of this.config.rules) {
       for (const agent of rule.targets) {
-        const ruleName = this.extractRuleName(rule.file);
-        const agentPath = getAgentPath(agent, ruleName);
-        const fullPath = `${rule.to}/${agentPath}`.replace(/\/+/g, "/");
-        paths.add(fullPath);
-        const agentDir = getAgentDirectory(agent);
-        if (agentDir) {
-          const fullDir = `${rule.to}/${agentDir}`.replace(/\/+/g, "/");
-          paths.add(`${fullDir}/`);
+        const agentName = this.getAgentName(agent);
+        const customPath = this.getCustomPath(agent);
+        if (customPath) {
+          paths.add(customPath);
+        } else {
+          const ruleName = this.extractRuleName(rule.file);
+          const agentPath = getAgentPath(agentName, ruleName);
+          const fullPath = `${rule.to}/${agentPath}`.replace(/\/+/g, "/");
+          paths.add(fullPath);
+          const agentDir = getAgentDirectory(agentName);
+          if (agentDir) {
+            const fullDir = `${rule.to}/${agentDir}`.replace(/\/+/g, "/");
+            paths.add(`${fullDir}/`);
+          }
         }
       }
     }
     if (this.config.commands) {
       for (const command of this.config.commands) {
         for (const agent of command.targets) {
-          const agentPath = getAgentPath(agent, command.command);
-          paths.add(agentPath);
+          const agentName = this.getAgentName(agent);
+          const customPath = this.getCustomPath(agent);
+          if (customPath) {
+            paths.add(customPath);
+          } else {
+            const agentPath = getAgentPath(agentName, command.command);
+            paths.add(agentPath);
+          }
         }
       }
     }
@@ -2754,24 +2786,42 @@ class AIRulesCore {
       throw new Error(`Duplicate MCP names found: ${duplicates.join(", ")}`);
     }
   }
+  getAgentName(agent) {
+    return typeof agent === "string" ? agent : agent.name;
+  }
+  getCustomPath(agent) {
+    return typeof agent === "object" ? agent.to : undefined;
+  }
   collectAllGeneratedPaths() {
     const paths = [];
     for (const rule of this.config.rules) {
       for (const agent of rule.targets) {
-        const ruleName = rule.file.split("/").pop()?.replace(".md", "") || "rule";
-        const agentPath = getAgentPath(agent, ruleName);
-        let fullPath = `${rule.to}/${agentPath}`.replace(/\/+/g, "/");
-        if (fullPath.startsWith("./")) {
-          fullPath = fullPath.substring(2);
+        const agentName = this.getAgentName(agent);
+        const customPath = this.getCustomPath(agent);
+        if (customPath) {
+          paths.push(customPath);
+        } else {
+          const ruleName = rule.file.split("/").pop()?.replace(".md", "") || "rule";
+          const agentPath = getAgentPath(agentName, ruleName);
+          let fullPath = `${rule.to}/${agentPath}`.replace(/\/+/g, "/");
+          if (fullPath.startsWith("./")) {
+            fullPath = fullPath.substring(2);
+          }
+          paths.push(fullPath);
         }
-        paths.push(fullPath);
       }
     }
     if (this.config.commands) {
       for (const command of this.config.commands) {
         for (const agent of command.targets) {
-          const agentPath = getAgentPath(agent, command.command);
-          paths.push(agentPath);
+          const agentName = this.getAgentName(agent);
+          const customPath = this.getCustomPath(agent);
+          if (customPath) {
+            paths.push(customPath);
+          } else {
+            const agentPath = getAgentPath(agentName, command.command);
+            paths.push(agentPath);
+          }
         }
       }
     }
@@ -2876,9 +2926,18 @@ class ConfigLoader {
     if (!Array.isArray(r.targets) || r.targets.length === 0) {
       throw new Error(`Rule at index ${index}: Rule.targets must be a non-empty array`);
     }
-    const validAgents = ["claude", "cursor", "codex", "roocode"];
-    if (!r.targets.every((agent) => validAgents.includes(agent))) {
-      throw new Error(`Rule at index ${index}: Rule.targets must contain valid agents: ${validAgents.join(", ")}`);
+    const validAgentNames = ["claude", "cursor", "codex", "roocode", "generic"];
+    if (!r.targets.every((agent) => {
+      if (typeof agent === "string") {
+        return validAgentNames.includes(agent);
+      }
+      if (typeof agent === "object" && agent !== null) {
+        const a = agent;
+        return validAgentNames.includes(a.name) && (a.to === undefined || typeof a.to === "string");
+      }
+      return false;
+    })) {
+      throw new Error(`Rule at index ${index}: Rule.targets must contain valid agents: ${validAgentNames.join(", ")}, or objects with {name, to?}`);
     }
   }
   static createInitialConfig() {
@@ -2887,127 +2946,30 @@ class ConfigLoader {
   static createTypedConfig() {
     return `import { defineRules } from 'glooit';
 
-// defineRules() provides TypeScript IntelliSense and validation
 export default defineRules({
-  // Directory where glooit stores configuration files
   configDir: '.glooit',
-
-  // Default targets for all rules (can be overridden per rule)
-  targets: ['claude', 'cursor'],
-
-  // Rules define how to sync your files to different AI agents
   rules: [
     {
       name: 'main',
-      file: '.glooit/main.md',         // Source file to sync
-      to: './',                        // Destination directory
-      targets: ['claude', 'cursor']    // Which agents to sync to
-    }
-    // Add more rules here:
-    // {
-    //   name: 'coding-standards',
-    //   file: '.glooit/coding-rules.md',
-    //   to: './',
-    //   targets: ['claude'],
-    //   globs: '**/*.{ts,js,tsx,jsx}' // Optional: only apply to certain file patterns
-    // }
-  ],
-
-  // MCP (Model Context Protocol) server configurations
-  mcps: [
-    // Example MCP server configurations:
-    // {
-    //   name: 'database',
-    //   config: {
-    //     command: 'npx',
-    //     args: ['@modelcontextprotocol/server-postgres'],
-    //     env: { DATABASE_URL: process.env.DATABASE_URL }
-    //   },
-    //   targets: ['claude']
-    // },
-    // {
-    //   name: 'filesystem',
-    //   config: {
-    //     command: 'npx',
-    //     args: ['@modelcontextprotocol/server-filesystem', process.cwd()]
-    //   },
-    //   targets: ['claude', 'cursor']
-    // }
+      file: '.glooit/main.md',
+      to: './',
+      targets: ['claude', 'cursor']
+    }
   ],
-
-  // Additional options:
-  // mergeMcps: true,        // Merge with existing MCP configs (default: true)
-  // backup: {               // Backup settings
-  //   enabled: true,         // Create backups before syncing (default: true)
-  //   retention: 10          // Keep last 10 backups (default: 10)
-  // },
-  // hooks: {                // Custom hooks for advanced workflows
-  //   before: [],           // Run before sync
-  //   after: [],            // Run after sync
-  //   error: []             // Run on error
-  // }
 });
 `;
   }
   static createPlainConfig() {
     return `export default {
-  // Directory where glooit stores configuration files
   configDir: '.glooit',
-
-  // Default targets for all rules (can be overridden per rule)
-  targets: ['claude', 'cursor'],
-
-  // Rules define how to sync your files to different AI agents
   rules: [
     {
       name: 'main',
-      file: '.glooit/main.md',         // Source file to sync
-      to: './',                        // Destination directory
-      targets: ['claude', 'cursor']    // Which agents to sync to
-    }
-    // Add more rules here:
-    // {
-    //   name: 'coding-standards',
-    //   file: '.glooit/coding-rules.md',
-    //   to: './',
-    //   targets: ['claude'],
-    //   globs: '**/*.{ts,js,tsx,jsx}' // Optional: only apply to certain file patterns
-    // }
+      file: '.glooit/main.md',
+      to: './',
+      targets: ['claude', 'cursor']
+    }
   ],
-
-  // MCP (Model Context Protocol) server configurations
-  mcps: [
-    // Example MCP server configurations:
-    // {
-    //   name: 'database',
-    //   config: {
-    //     command: 'npx',
-    //     args: ['@modelcontextprotocol/server-postgres'],
-    //     env: { DATABASE_URL: process.env.DATABASE_URL }
-    //   },
-    //   targets: ['claude']
-    // },
-    // {
-    //   name: 'filesystem',
-    //   config: {
-    //     command: 'npx',
-    //     args: ['@modelcontextprotocol/server-filesystem', process.cwd()]
-    //   },
-    //   targets: ['claude', 'cursor']
-    // }
-  ]
-
-  // Additional options:
-  // mergeMcps: true,        // Merge with existing MCP configs (default: true)
-  // backup: {               // Backup settings
-  //   enabled: true,         // Create backups before syncing (default: true)
-  //   retention: 10          // Keep last 10 backups (default: 10)
-  // },
-  // hooks: {                // Custom hooks for advanced workflows
-  //   before: [],           // Run before sync
-  //   after: [],            // Run after sync
-  //   error: []             // Run on error
-  // }
 };
 `;
   }
@@ -3373,7 +3335,7 @@ function constructCommand(value, args) {
 import { execSync } from "child_process";
 import { createInterface } from "readline";
 // package.json
-var version = "0.5.1";
+var version = "0.5.3";
 
 // src/cli/index.ts
 var args = process.argv.slice(2);

package/dist/core/gitignore.d.ts

@@ -4,6 +4,8 @@ export declare class GitIgnoreManager {
     private gitignorePath;
     private marker;
     constructor(config: Config);
+    private getAgentName;
+    private getCustomPath;
     updateGitIgnore(): Promise<void>;
     cleanupGitIgnore(): Promise<void>;
     private collectGeneratedPaths;

package/dist/core/index.d.ts

@@ -16,5 +16,7 @@ export declare class AIRulesCore {
     validate(): Promise<boolean>;
     private distributeMcps;
     private validateMcpNames;
+    private getAgentName;
+    private getCustomPath;
     collectAllGeneratedPaths(): string[];
 }

package/dist/index.js

@@ -10,8 +10,18 @@ var __export = (target, all) => {
 };
 
 // src/types/index.ts
+function isValidAgentName(agentName) {
+  return ["claude", "cursor", "codex", "roocode", "generic"].includes(agentName);
+}
 function isValidAgent(agent) {
-  return ["claude", "cursor", "codex", "roocode"].includes(agent);
+  if (typeof agent === "string") {
+    return isValidAgentName(agent);
+  }
+  if (typeof agent === "object" && agent !== null) {
+    const a = agent;
+    return isValidAgentName(a.name) && (a.to === undefined || typeof a.to === "string");
+  }
+  return false;
 }
 function validateRule(rule) {
   if (!rule || typeof rule !== "object") {
@@ -28,7 +38,7 @@ function validateRule(rule) {
     throw new Error("Rule.targets must be a non-empty array");
   }
   if (!r.targets.every(isValidAgent)) {
-    throw new Error("Rule.targets must contain valid agents: claude, cursor, codex, roocode");
+    throw new Error("Rule.targets must contain valid agents: claude, cursor, codex, roocode, generic, or objects with {name, to?}");
   }
 }
 function validateConfig(config) {
@@ -79,7 +89,7 @@ var AGENT_MAPPINGS = {
     mcpPath: ".mcp.json"
   },
   cursor: {
-    path: ".cursor/rules/{name}.md",
+    path: ".cursor/rules/{name}.mdc",
     format: "frontmatter",
     directory: ".cursor/rules",
     mcpPath: "~/.cursor/mcp.json"
@@ -94,6 +104,11 @@ var AGENT_MAPPINGS = {
     format: "markdown",
     directory: ".roo/rules",
     mcpPath: ".roo/mcp.json"
+  },
+  generic: {
+    path: "{name}.md",
+    format: "markdown",
+    mcpPath: "mcp.json"
   }
 };
 function getAgentPath(agent, name = "global") {
@@ -148,11 +163,12 @@ import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 class CursorWriter {
   formatContent(content, rule) {
     const ruleName = this.extractRuleName(rule.file);
+    const hasGlobs = rule.globs && rule.globs.length > 0;
     const frontmatter = [
       "---",
       `description: AI Rules - ${ruleName}`,
-      `globs: ${rule.globs || "**/*"}`,
-      "alwaysApply: true",
+      `globs: ${hasGlobs ? rule.globs : "**/*"}`,
+      "alwaysApply: " + (hasGlobs ? "false" : "true"),
       "---",
       ""
     ].join(`
@@ -189,6 +205,7 @@ class AgentWriterFactory {
       case "claude":
       case "codex":
       case "roocode":
+      case "generic":
         return new MarkdownWriter;
       default:
         return new MarkdownWriter;
@@ -272,25 +289,32 @@ class AgentDistributor {
       await this.distributeToAgent(agent, rule, content);
     }
   }
+  getAgentName(agent) {
+    return typeof agent === "string" ? agent : agent.name;
+  }
+  getCustomPath(agent) {
+    return typeof agent === "object" ? agent.to : undefined;
+  }
   async distributeToAgent(agent, rule, content) {
-    const ruleName = this.extractRuleName(rule.file);
-    const agentPath = getAgentPath(agent, ruleName);
-    const targetPath = join2(rule.to, agentPath);
-    const agentDir = getAgentDirectory(agent);
-    if (agentDir) {
-      const fullDir = join2(rule.to, agentDir);
-      mkdirSync(fullDir, { recursive: true });
+    const agentName = this.getAgentName(agent);
+    const customPath = this.getCustomPath(agent);
+    let targetPath;
+    if (customPath) {
+      targetPath = customPath;
     } else {
-      mkdirSync(dirname(targetPath), { recursive: true });
+      const ruleName = this.extractRuleName(rule.file);
+      const agentPath = getAgentPath(agentName, ruleName);
+      targetPath = join2(rule.to, agentPath);
     }
-    const writer = AgentWriterFactory.createWriter(agent);
+    mkdirSync(dirname(targetPath), { recursive: true });
+    const writer = AgentWriterFactory.createWriter(agentName);
     const formattedContent = writer.formatContent(content, rule);
     const context = {
       config: this.config,
       rule,
       content: formattedContent,
       targetPath,
-      agent
+      agent: agentName
     };
     const finalContent = await this.applyHooks(context);
     writeFileSync(targetPath, finalContent, "utf-8");
@@ -447,6 +471,12 @@ class GitIgnoreManager {
   constructor(config) {
     this.config = config;
   }
+  getAgentName(agent) {
+    return typeof agent === "string" ? agent : agent.name;
+  }
+  getCustomPath(agent) {
+    return typeof agent === "object" ? agent.to : undefined;
+  }
   async updateGitIgnore() {
     const paths = this.collectGeneratedPaths();
     if (paths.length === 0) {
@@ -477,22 +507,34 @@ class GitIgnoreManager {
     const paths = new Set;
     for (const rule of this.config.rules) {
       for (const agent of rule.targets) {
-        const ruleName = this.extractRuleName(rule.file);
-        const agentPath = getAgentPath(agent, ruleName);
-        const fullPath = `${rule.to}/${agentPath}`.replace(/\/+/g, "/");
-        paths.add(fullPath);
-        const agentDir = getAgentDirectory(agent);
-        if (agentDir) {
-          const fullDir = `${rule.to}/${agentDir}`.replace(/\/+/g, "/");
-          paths.add(`${fullDir}/`);
+        const agentName = this.getAgentName(agent);
+        const customPath = this.getCustomPath(agent);
+        if (customPath) {
+          paths.add(customPath);
+        } else {
+          const ruleName = this.extractRuleName(rule.file);
+          const agentPath = getAgentPath(agentName, ruleName);
+          const fullPath = `${rule.to}/${agentPath}`.replace(/\/+/g, "/");
+          paths.add(fullPath);
+          const agentDir = getAgentDirectory(agentName);
+          if (agentDir) {
+            const fullDir = `${rule.to}/${agentDir}`.replace(/\/+/g, "/");
+            paths.add(`${fullDir}/`);
+          }
         }
       }
     }
     if (this.config.commands) {
       for (const command of this.config.commands) {
         for (const agent of command.targets) {
-          const agentPath = getAgentPath(agent, command.command);
-          paths.add(agentPath);
+          const agentName = this.getAgentName(agent);
+          const customPath = this.getCustomPath(agent);
+          if (customPath) {
+            paths.add(customPath);
+          } else {
+            const agentPath = getAgentPath(agentName, command.command);
+            paths.add(agentPath);
+          }
         }
       }
     }
@@ -692,24 +734,42 @@ class AIRulesCore {
       throw new Error(`Duplicate MCP names found: ${duplicates.join(", ")}`);
     }
   }
+  getAgentName(agent) {
+    return typeof agent === "string" ? agent : agent.name;
+  }
+  getCustomPath(agent) {
+    return typeof agent === "object" ? agent.to : undefined;
+  }
   collectAllGeneratedPaths() {
     const paths = [];
     for (const rule of this.config.rules) {
       for (const agent of rule.targets) {
-        const ruleName = rule.file.split("/").pop()?.replace(".md", "") || "rule";
-        const agentPath = getAgentPath(agent, ruleName);
-        let fullPath = `${rule.to}/${agentPath}`.replace(/\/+/g, "/");
-        if (fullPath.startsWith("./")) {
-          fullPath = fullPath.substring(2);
+        const agentName = this.getAgentName(agent);
+        const customPath = this.getCustomPath(agent);
+        if (customPath) {
+          paths.push(customPath);
+        } else {
+          const ruleName = rule.file.split("/").pop()?.replace(".md", "") || "rule";
+          const agentPath = getAgentPath(agentName, ruleName);
+          let fullPath = `${rule.to}/${agentPath}`.replace(/\/+/g, "/");
+          if (fullPath.startsWith("./")) {
+            fullPath = fullPath.substring(2);
+          }
+          paths.push(fullPath);
         }
-        paths.push(fullPath);
       }
     }
     if (this.config.commands) {
       for (const command of this.config.commands) {
         for (const agent of command.targets) {
-          const agentPath = getAgentPath(agent, command.command);
-          paths.push(agentPath);
+          const agentName = this.getAgentName(agent);
+          const customPath = this.getCustomPath(agent);
+          if (customPath) {
+            paths.push(customPath);
+          } else {
+            const agentPath = getAgentPath(agentName, command.command);
+            paths.push(agentPath);
+          }
         }
       }
     }
@@ -813,9 +873,18 @@ class ConfigLoader {
     if (!Array.isArray(r.targets) || r.targets.length === 0) {
       throw new Error(`Rule at index ${index}: Rule.targets must be a non-empty array`);
     }
-    const validAgents = ["claude", "cursor", "codex", "roocode"];
-    if (!r.targets.every((agent) => validAgents.includes(agent))) {
-      throw new Error(`Rule at index ${index}: Rule.targets must contain valid agents: ${validAgents.join(", ")}`);
+    const validAgentNames = ["claude", "cursor", "codex", "roocode", "generic"];
+    if (!r.targets.every((agent) => {
+      if (typeof agent === "string") {
+        return validAgentNames.includes(agent);
+      }
+      if (typeof agent === "object" && agent !== null) {
+        const a = agent;
+        return validAgentNames.includes(a.name) && (a.to === undefined || typeof a.to === "string");
+      }
+      return false;
+    })) {
+      throw new Error(`Rule at index ${index}: Rule.targets must contain valid agents: ${validAgentNames.join(", ")}, or objects with {name, to?}`);
     }
   }
   static createInitialConfig() {
@@ -824,127 +893,30 @@ class ConfigLoader {
   static createTypedConfig() {
     return `import { defineRules } from 'glooit';
 
-// defineRules() provides TypeScript IntelliSense and validation
 export default defineRules({
-  // Directory where glooit stores configuration files
   configDir: '.glooit',
-
-  // Default targets for all rules (can be overridden per rule)
-  targets: ['claude', 'cursor'],
-
-  // Rules define how to sync your files to different AI agents
   rules: [
     {
       name: 'main',
-      file: '.glooit/main.md',         // Source file to sync
-      to: './',                        // Destination directory
-      targets: ['claude', 'cursor']    // Which agents to sync to
+      file: '.glooit/main.md',
+      to: './',
+      targets: ['claude', 'cursor']
     }
-    // Add more rules here:
-    // {
-    //   name: 'coding-standards',
-    //   file: '.glooit/coding-rules.md',
-    //   to: './',
-    //   targets: ['claude'],
-    //   globs: '**/*.{ts,js,tsx,jsx}' // Optional: only apply to certain file patterns
-    // }
   ],
-
-  // MCP (Model Context Protocol) server configurations
-  mcps: [
-    // Example MCP server configurations:
-    // {
-    //   name: 'database',
-    //   config: {
-    //     command: 'npx',
-    //     args: ['@modelcontextprotocol/server-postgres'],
-    //     env: { DATABASE_URL: process.env.DATABASE_URL }
-    //   },
-    //   targets: ['claude']
-    // },
-    // {
-    //   name: 'filesystem',
-    //   config: {
-    //     command: 'npx',
-    //     args: ['@modelcontextprotocol/server-filesystem', process.cwd()]
-    //   },
-    //   targets: ['claude', 'cursor']
-    // }
-  ],
-
-  // Additional options:
-  // mergeMcps: true,        // Merge with existing MCP configs (default: true)
-  // backup: {               // Backup settings
-  //   enabled: true,         // Create backups before syncing (default: true)
-  //   retention: 10          // Keep last 10 backups (default: 10)
-  // },
-  // hooks: {                // Custom hooks for advanced workflows
-  //   before: [],           // Run before sync
-  //   after: [],            // Run after sync
-  //   error: []             // Run on error
-  // }
 });
 `;
   }
   static createPlainConfig() {
     return `export default {
-  // Directory where glooit stores configuration files
   configDir: '.glooit',
-
-  // Default targets for all rules (can be overridden per rule)
-  targets: ['claude', 'cursor'],
-
-  // Rules define how to sync your files to different AI agents
   rules: [
     {
       name: 'main',
-      file: '.glooit/main.md',         // Source file to sync
-      to: './',                        // Destination directory
-      targets: ['claude', 'cursor']    // Which agents to sync to
+      file: '.glooit/main.md',
+      to: './',
+      targets: ['claude', 'cursor']
     }
-    // Add more rules here:
-    // {
-    //   name: 'coding-standards',
-    //   file: '.glooit/coding-rules.md',
-    //   to: './',
-    //   targets: ['claude'],
-    //   globs: '**/*.{ts,js,tsx,jsx}' // Optional: only apply to certain file patterns
-    // }
   ],
-
-  // MCP (Model Context Protocol) server configurations
-  mcps: [
-    // Example MCP server configurations:
-    // {
-    //   name: 'database',
-    //   config: {
-    //     command: 'npx',
-    //     args: ['@modelcontextprotocol/server-postgres'],
-    //     env: { DATABASE_URL: process.env.DATABASE_URL }
-    //   },
-    //   targets: ['claude']
-    // },
-    // {
-    //   name: 'filesystem',
-    //   config: {
-    //     command: 'npx',
-    //     args: ['@modelcontextprotocol/server-filesystem', process.cwd()]
-    //   },
-    //   targets: ['claude', 'cursor']
-    // }
-  ]
-
-  // Additional options:
-  // mergeMcps: true,        // Merge with existing MCP configs (default: true)
-  // backup: {               // Backup settings
-  //   enabled: true,         // Create backups before syncing (default: true)
-  //   retention: 10          // Keep last 10 backups (default: 10)
-  // },
-  // hooks: {                // Custom hooks for advanced workflows
-  //   before: [],           // Run before sync
-  //   after: [],            // Run after sync
-  //   error: []             // Run on error
-  // }
 };
 `;
   }

package/dist/types/index.d.ts

@@ -1,4 +1,9 @@
-export type Agent = 'claude' | 'cursor' | 'codex' | 'roocode';
+export type AgentName = 'claude' | 'cursor' | 'codex' | 'roocode' | 'generic';
+export interface AgentTarget {
+    name: AgentName;
+    to?: string;
+}
+export type Agent = AgentName | AgentTarget;
 export interface Rule {
     name?: string;
     file: string;
@@ -25,7 +30,7 @@ export interface McpConfig {
 export interface Mcp {
     name: string;
     config: McpConfig;
-    targets?: Agent[];
+    targets?: AgentName[];
     outputPath?: string;
 }
 export interface ResolvedMcp extends Omit<Mcp, 'outputPath'> {
@@ -63,7 +68,7 @@ export interface SyncContext {
     rule: Rule;
     content: string;
     targetPath: string;
-    agent: Agent;
+    agent: AgentName;
 }
 export interface BackupEntry {
     timestamp: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glooit",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "🧴 Sync your AI agent configurations and rules across platforms with ease",
   "main": "dist/index.js",
   "module": "dist/index.js",