glooit 0.4.0 → 0.5.0

package/README.md

@@ -1,17 +1,17 @@
-# gloo 🧴
+# glooit 🧴
 
 > Sync your AI agent configurations and rules across platforms with ease
 
-**gloo** keeps your AI agent rules and MCP configurations in perfect sync across Claude Code, Cursor, Roo Code, and other AI development tools.
+**glooit** keeps your AI agent rules and MCP configurations in perfect sync across Claude Code, Cursor, Roo Code, and other AI development tools.
 
 ## Quick Start
 
 ```bash
 # Install globally
-npm install -g gloo
+npm install -g glooitit
 
 # Or run directly
-npx gloo init
+npx glooitit init
 ```
 
 ## Basic Usage
@@ -19,13 +19,13 @@ npx gloo init
 ### 1. Initialize Configuration
 
 ```bash
-gloo init
+glooit init
 ```
 
-This creates a `gloo.config.ts` file:
+This creates a `glooit.config.ts` file:
 
 ```typescript
-import { Config } from 'gloo/types';
+import { Config } from 'glooit';
 
 export default {
   rules: [
@@ -41,7 +41,7 @@ export default {
 ### 2. Sync Your Rules
 
 ```bash
-gloo sync
+glooit sync
 ```
 
 This automatically creates:
@@ -80,10 +80,10 @@ export default {
 ### Example Configuration
 
 ```typescript
-import { Config } from 'gloo/types';
+import { Config } from 'glooit';
 
 export default {
-  configDir: '.gloo',
+  configDir: '.glooit',
   rules: [
     {
       file: 'coding-standards.md',
@@ -108,12 +108,12 @@ export default {
 ## Commands
 
 ```bash
-gloo init          # Initialize configuration
-gloo sync          # Sync rules and MCPs
-gloo validate      # Validate configuration
-gloo clean         # Remove generated files
-gloo reset --force # Complete reset
-gloo backup list   # List backups
+glooit init          # Initialize configuration
+glooit sync          # Sync rules and MCPs
+glooit validate      # Validate configuration
+glooit clean         # Remove generated files
+glooit reset --force # Complete reset
+glooit backup list   # List backups
 ```
 
 ## Features
@@ -129,14 +129,14 @@ gloo backup list   # List backups
 
 ```bash
 # NPM
-npm install -g gloo
+npm install -g glooit
 
 # Bun
-bun install -g gloo
+bun install -g glooit
 
 # Direct execution
-npx gloo init
-bunx gloo sync
+npx glooitit init
+bunx glooitit sync
 ```
 
 ## License

package/dist/agents/distributor.d.ts

@@ -0,0 +1,11 @@
+import type { Rule, Config } from '../types';
+export declare class AgentDistributor {
+    private config;
+    constructor(config: Config);
+    distributeRule(rule: Rule): Promise<void>;
+    private distributeToAgent;
+    private loadRuleContent;
+    private extractRuleName;
+    private applyHooks;
+    private executeHook;
+}

package/dist/agents/index.d.ts

@@ -0,0 +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;

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

@@ -0,0 +1,6 @@
+import type { Rule, ResolvedMcp } from '../../types';
+export declare class CursorWriter {
+    formatContent(content: string, rule: Rule): string;
+    formatMcp(mcp: ResolvedMcp, merge: boolean): string;
+    private extractRuleName;
+}

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

@@ -0,0 +1,8 @@
+import type { Rule, ResolvedMcp } from '../../types';
+export interface GenericWriter {
+    formatContent(content: string, rule: Rule): string;
+}
+export declare class MarkdownWriter implements GenericWriter {
+    formatContent(content: string, _rule: Rule): string;
+    formatMcp(mcp: ResolvedMcp, merge: boolean): string;
+}

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

@@ -0,0 +1,8 @@
+import type { Agent, 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;
+}

package/dist/cli/index.js

@@ -2514,7 +2514,7 @@ import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync
 class GitIgnoreManager {
   config;
   gitignorePath = ".gitignore";
-  marker = "# ai-rules generated files";
+  marker = "# glooit generated files";
   constructor(config) {
     this.config = config;
   }
@@ -2620,7 +2620,6 @@ class GitIgnoreManager {
 // src/hooks/index.ts
 class HookManager {
   hooks = {};
-  constructor() {}
   register(name, hook) {
     this.hooks[name] = hook;
   }
@@ -2704,7 +2703,6 @@ class AIRulesCore {
     return this.backupManager.listBackups();
   }
   async clean() {
-    console.log("Clean functionality would be implemented here");
     await this.gitIgnoreManager.cleanupGitIgnore();
   }
   async validate() {
@@ -2737,12 +2735,15 @@ class AIRulesCore {
         if (!mcpGroups.has(outputPath)) {
           mcpGroups.set(outputPath, []);
         }
-        mcpGroups.get(outputPath).push({
-          name: mcp.name,
-          config: mcp.config,
-          agent,
-          outputPath
-        });
+        const group = mcpGroups.get(outputPath);
+        if (group) {
+          group.push({
+            name: mcp.name,
+            config: mcp.config,
+            agent,
+            outputPath
+          });
+        }
       }
     }
     for (const [outputPath, mcps] of mcpGroups) {
@@ -15187,7 +15188,7 @@ var HooksSchema = exports_external.object({
   error: exports_external.array(HookFunctionSchema).optional()
 });
 var ConfigSchema = exports_external.object({
-  configDir: exports_external.string().default(".gloo"),
+  configDir: exports_external.string().default(".glooit"),
   rules: exports_external.array(RuleSchema),
   commands: exports_external.array(CommandSchema).optional(),
   mcps: exports_external.array(McpSchema).optional(),
@@ -15199,10 +15200,10 @@ var ConfigSchema = exports_external.object({
 // src/core/config-loader.ts
 class ConfigLoader {
   static DEFAULT_CONFIG_PATHS = [
-    "gloo.config.ts",
-    "gloo.config.js",
-    "config/gloo.ts",
-    "config/gloo.js"
+    "glooit.config.ts",
+    "glooit.config.js",
+    "config/glooit.ts",
+    "config/glooit.js"
   ];
   static async load(customPath) {
     const configPath = customPath || this.findConfigFile();
@@ -15238,24 +15239,54 @@ class ConfigLoader {
     }
   }
   static createInitialConfig() {
-    return `import { Config } from 'gloo/types';
+    return this.createTypedConfig();
+  }
+  static createTypedConfig() {
+    return `import type { Config } from 'glooit';
 
 export default {
-  configDir: '.gloo',
+  configDir: '.glooit',
+  targets: ['claude', 'cursor'],
 
   rules: [
     {
-      file: '.gloo/main.md',
-      to: './',
+      name: 'main',
+      file: '.glooit/main.md',
       targets: ['claude', 'cursor']
     }
   ],
 
-  backup: {
-    enabled: true,
-    retention: 10
-  }
+  mcps: [
+    // {
+    //   name: 'example-server',
+    //   file: '.glooit/mcp.json',
+    //   targets: ['claude']
+    // }
+  ]
 } satisfies Config;
+`;
+  }
+  static createPlainConfig() {
+    return `export default {
+  configDir: '.glooit',
+  targets: ['claude', 'cursor'],
+
+  rules: [
+    {
+      name: 'main',
+      file: '.glooit/main.md',
+      targets: ['claude', 'cursor']
+    }
+  ],
+
+  mcps: [
+    // {
+    //   name: 'example-server',
+    //   file: '.glooit/mcp.json',
+    //   targets: ['claude']
+    // }
+  ]
+};
 `;
   }
 }
@@ -15332,11 +15363,304 @@ class ConfigValidator {
 }
 
 // src/cli/index.ts
-import { existsSync as existsSync8, writeFileSync as writeFileSync5, rmSync, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync8, writeFileSync as writeFileSync5, rmSync, readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
 import { dirname as dirname3 } from "path";
+
+// node_modules/package-manager-detector/dist/detect.mjs
+import fs from "node:fs/promises";
+import path from "node:path";
+import process2 from "node:process";
+
+// node_modules/package-manager-detector/dist/constants.mjs
+var AGENTS = [
+  "npm",
+  "yarn",
+  "yarn@berry",
+  "pnpm",
+  "pnpm@6",
+  "bun",
+  "deno"
+];
+var LOCKS = {
+  "bun.lock": "bun",
+  "bun.lockb": "bun",
+  "deno.lock": "deno",
+  "pnpm-lock.yaml": "pnpm",
+  "pnpm-workspace.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "npm-shrinkwrap.json": "npm"
+};
+var INSTALL_METADATA = {
+  "node_modules/.deno/": "deno",
+  "node_modules/.pnpm/": "pnpm",
+  "node_modules/.yarn-state.yml": "yarn",
+  "node_modules/.yarn_integrity": "yarn",
+  "node_modules/.package-lock.json": "npm",
+  ".pnp.cjs": "yarn",
+  ".pnp.js": "yarn",
+  "bun.lock": "bun",
+  "bun.lockb": "bun"
+};
+
+// node_modules/package-manager-detector/dist/detect.mjs
+async function pathExists(path2, type) {
+  try {
+    const stat = await fs.stat(path2);
+    return type === "file" ? stat.isFile() : stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function* lookup(cwd = process2.cwd()) {
+  let directory = path.resolve(cwd);
+  const { root } = path.parse(directory);
+  while (directory && directory !== root) {
+    yield directory;
+    directory = path.dirname(directory);
+  }
+}
+async function parsePackageJson(filepath, onUnknown) {
+  return !filepath || !pathExists(filepath, "file") ? null : await handlePackageManager(filepath, onUnknown);
+}
+async function detect(options = {}) {
+  const {
+    cwd,
+    strategies = ["lockfile", "packageManager-field", "devEngines-field"],
+    onUnknown
+  } = options;
+  let stopDir;
+  if (typeof options.stopDir === "string") {
+    const resolved = path.resolve(options.stopDir);
+    stopDir = (dir) => dir === resolved;
+  } else {
+    stopDir = options.stopDir;
+  }
+  for (const directory of lookup(cwd)) {
+    for (const strategy of strategies) {
+      switch (strategy) {
+        case "lockfile": {
+          for (const lock of Object.keys(LOCKS)) {
+            if (await pathExists(path.join(directory, lock), "file")) {
+              const name = LOCKS[lock];
+              const result = await parsePackageJson(path.join(directory, "package.json"), onUnknown);
+              if (result)
+                return result;
+              else
+                return { name, agent: name };
+            }
+          }
+          break;
+        }
+        case "packageManager-field":
+        case "devEngines-field": {
+          const result = await parsePackageJson(path.join(directory, "package.json"), onUnknown);
+          if (result)
+            return result;
+          break;
+        }
+        case "install-metadata": {
+          for (const metadata of Object.keys(INSTALL_METADATA)) {
+            const fileOrDir = metadata.endsWith("/") ? "dir" : "file";
+            if (await pathExists(path.join(directory, metadata), fileOrDir)) {
+              const name = INSTALL_METADATA[metadata];
+              const agent = name === "yarn" ? isMetadataYarnClassic(metadata) ? "yarn" : "yarn@berry" : name;
+              return { name, agent };
+            }
+          }
+          break;
+        }
+      }
+    }
+    if (stopDir?.(directory))
+      break;
+  }
+  return null;
+}
+function getNameAndVer(pkg) {
+  const handelVer = (version2) => version2?.match(/\d+(\.\d+){0,2}/)?.[0] ?? version2;
+  if (typeof pkg.packageManager === "string") {
+    const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
+    return { name, ver: handelVer(ver) };
+  }
+  if (typeof pkg.devEngines?.packageManager?.name === "string") {
+    return {
+      name: pkg.devEngines.packageManager.name,
+      ver: handelVer(pkg.devEngines.packageManager.version)
+    };
+  }
+  return;
+}
+async function handlePackageManager(filepath, onUnknown) {
+  try {
+    const pkg = JSON.parse(await fs.readFile(filepath, "utf8"));
+    let agent;
+    const nameAndVer = getNameAndVer(pkg);
+    if (nameAndVer) {
+      const name = nameAndVer.name;
+      const ver = nameAndVer.ver;
+      let version2 = ver;
+      if (name === "yarn" && ver && Number.parseInt(ver) > 1) {
+        agent = "yarn@berry";
+        version2 = "berry";
+        return { name, agent, version: version2 };
+      } else if (name === "pnpm" && ver && Number.parseInt(ver) < 7) {
+        agent = "pnpm@6";
+        return { name, agent, version: version2 };
+      } else if (AGENTS.includes(name)) {
+        agent = name;
+        return { name, agent, version: version2 };
+      } else {
+        return onUnknown?.(pkg.packageManager) ?? null;
+      }
+    }
+  } catch {}
+  return null;
+}
+function isMetadataYarnClassic(metadataPath) {
+  return metadataPath.endsWith(".yarn_integrity");
+}
+
+// node_modules/package-manager-detector/dist/commands.mjs
+function dashDashArg(agent, agentCommand) {
+  return (args) => {
+    if (args.length > 1) {
+      return [agent, agentCommand, args[0], "--", ...args.slice(1)];
+    } else {
+      return [agent, agentCommand, args[0]];
+    }
+  };
+}
+function denoExecute() {
+  return (args) => {
+    return ["deno", "run", `npm:${args[0]}`, ...args.slice(1)];
+  };
+}
+var npm = {
+  agent: ["npm", 0],
+  run: dashDashArg("npm", "run"),
+  install: ["npm", "i", 0],
+  frozen: ["npm", "ci", 0],
+  global: ["npm", "i", "-g", 0],
+  add: ["npm", "i", 0],
+  upgrade: ["npm", "update", 0],
+  "upgrade-interactive": null,
+  execute: ["npx", 0],
+  "execute-local": ["npx", 0],
+  uninstall: ["npm", "uninstall", 0],
+  global_uninstall: ["npm", "uninstall", "-g", 0]
+};
+var yarn = {
+  agent: ["yarn", 0],
+  run: ["yarn", "run", 0],
+  install: ["yarn", "install", 0],
+  frozen: ["yarn", "install", "--frozen-lockfile", 0],
+  global: ["yarn", "global", "add", 0],
+  add: ["yarn", "add", 0],
+  upgrade: ["yarn", "upgrade", 0],
+  "upgrade-interactive": ["yarn", "upgrade-interactive", 0],
+  execute: ["npx", 0],
+  "execute-local": dashDashArg("yarn", "exec"),
+  uninstall: ["yarn", "remove", 0],
+  global_uninstall: ["yarn", "global", "remove", 0]
+};
+var yarnBerry = {
+  ...yarn,
+  frozen: ["yarn", "install", "--immutable", 0],
+  upgrade: ["yarn", "up", 0],
+  "upgrade-interactive": ["yarn", "up", "-i", 0],
+  execute: ["yarn", "dlx", 0],
+  "execute-local": ["yarn", "exec", 0],
+  global: ["npm", "i", "-g", 0],
+  global_uninstall: ["npm", "uninstall", "-g", 0]
+};
+var pnpm = {
+  agent: ["pnpm", 0],
+  run: ["pnpm", "run", 0],
+  install: ["pnpm", "i", 0],
+  frozen: ["pnpm", "i", "--frozen-lockfile", 0],
+  global: ["pnpm", "add", "-g", 0],
+  add: ["pnpm", "add", 0],
+  upgrade: ["pnpm", "update", 0],
+  "upgrade-interactive": ["pnpm", "update", "-i", 0],
+  execute: ["pnpm", "dlx", 0],
+  "execute-local": ["pnpm", "exec", 0],
+  uninstall: ["pnpm", "remove", 0],
+  global_uninstall: ["pnpm", "remove", "--global", 0]
+};
+var bun = {
+  agent: ["bun", 0],
+  run: ["bun", "run", 0],
+  install: ["bun", "install", 0],
+  frozen: ["bun", "install", "--frozen-lockfile", 0],
+  global: ["bun", "add", "-g", 0],
+  add: ["bun", "add", 0],
+  upgrade: ["bun", "update", 0],
+  "upgrade-interactive": ["bun", "update", 0],
+  execute: ["bun", "x", 0],
+  "execute-local": ["bun", "x", 0],
+  uninstall: ["bun", "remove", 0],
+  global_uninstall: ["bun", "remove", "-g", 0]
+};
+var deno = {
+  agent: ["deno", 0],
+  run: ["deno", "task", 0],
+  install: ["deno", "install", 0],
+  frozen: ["deno", "install", "--frozen", 0],
+  global: ["deno", "install", "-g", 0],
+  add: ["deno", "add", 0],
+  upgrade: ["deno", "outdated", "--update", 0],
+  "upgrade-interactive": ["deno", "outdated", "--update", 0],
+  execute: denoExecute(),
+  "execute-local": ["deno", "task", "--eval", 0],
+  uninstall: ["deno", "remove", 0],
+  global_uninstall: ["deno", "uninstall", "-g", 0]
+};
+var COMMANDS = {
+  npm,
+  yarn,
+  "yarn@berry": yarnBerry,
+  pnpm,
+  "pnpm@6": {
+    ...pnpm,
+    run: dashDashArg("pnpm", "run")
+  },
+  bun,
+  deno
+};
+function resolveCommand(agent, command, args) {
+  const value = COMMANDS[agent][command];
+  return constructCommand(value, args);
+}
+function constructCommand(value, args) {
+  if (value == null)
+    return null;
+  const list = typeof value === "function" ? value(args) : value.flatMap((v) => {
+    if (typeof v === "number")
+      return args;
+    return [v];
+  });
+  return {
+    command: list[0],
+    args: list.slice(1)
+  };
+}
+
+// src/cli/index.ts
+import { execSync } from "child_process";
+import { createInterface } from "readline";
+// package.json
+var version2 = "0.5.0";
+
+// src/cli/index.ts
+var args = process.argv.slice(2);
+if (args.length === 1 && (args[0]?.toLowerCase() === "-v" || args[0] === "--version")) {
+  console.log(`v${version2}`);
+  process.exit(0);
+}
 var program2 = new Command;
-program2.name("gloo").description("\uD83E\uDDF4 Sync your AI agent configurations and rules across platforms with ease").version("0.1.0");
-program2.command("init").description("Initialize gloo configuration").option("-f, --force", "overwrite existing configuration").action(async (options) => {
+program2.name("glooit").description("\uD83E\uDDF4 Sync your AI agent configurations and rules across platforms with ease");
+program2.command("init").description("Initialize glooit configuration").option("-f, --force", "overwrite existing configuration").action(async (options) => {
   try {
     await initCommand(options.force);
   } catch (error45) {
@@ -15385,7 +15709,7 @@ program2.command("clean").description("Remove all generated files and clean .git
     process.exit(1);
   }
 });
-program2.command("reset").description("Remove all gloo generated files, backups, and config (start fresh)").option("--force", "skip confirmation prompt").action(async (options) => {
+program2.command("reset").description("Remove all glooit generated files, backups, and config (start fresh)").option("--force", "skip confirmation prompt").action(async (options) => {
   try {
     await resetCommand(options.force);
   } catch (error45) {
@@ -15393,18 +15717,79 @@ program2.command("reset").description("Remove all gloo generated files, backups,
     process.exit(1);
   }
 });
+function promptUser(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().startsWith("y"));
+    });
+  });
+}
 async function initCommand(force) {
-  const configPath = "gloo.config.ts";
+  const configPath = "glooit.config.ts";
   if (existsSync8(configPath) && !force) {
     throw new Error(`Configuration file ${configPath} already exists. Use --force to overwrite.`);
   }
-  const initialConfig = ConfigLoader.createInitialConfig();
-  writeFileSync5(configPath, initialConfig, "utf-8");
-  console.log(`✅ Created ${configPath}`);
+  if (!existsSync8("package.json")) {
+    const plainConfig = ConfigLoader.createPlainConfig();
+    writeFileSync5(configPath, plainConfig, "utf-8");
+    console.log(`✅ Created ${configPath}`);
+    console.log("\uD83D\uDCA1 For TypeScript support, create a package.json and add glooit to devDependencies");
+    console.log("Next steps:");
+    console.log("1. Edit the configuration file to match your project");
+    console.log("2. Create your rule files in .glooit/");
+    console.log("3. Run `glooit sync` to distribute rules");
+    return;
+  }
+  try {
+    const pm = await detect();
+    if (pm) {
+      const resolved = resolveCommand(pm.agent, "install", []);
+      const installCmd = resolved ? `${resolved.command} ${resolved.args.join(" ")}` : `${pm.agent} install`;
+      const shouldInstall = await promptUser(`\uD83D\uDCE6 Add glooit to devDependencies and install for TypeScript support? (${pm.name}) [y/N]: `);
+      if (shouldInstall) {
+        const pkg = JSON.parse(readFileSync7("package.json", "utf-8"));
+        pkg.devDependencies = pkg.devDependencies || {};
+        pkg.devDependencies.glooit = "latest";
+        writeFileSync5("package.json", JSON.stringify(pkg, null, 2) + `
+`);
+        const typedConfig = ConfigLoader.createTypedConfig();
+        writeFileSync5(configPath, typedConfig, "utf-8");
+        console.log(`✅ Created ${configPath}`);
+        console.log("\uD83D\uDCE6 Added glooit to devDependencies");
+        try {
+          console.log(`\uD83D\uDD04 Installing dependencies with ${pm.name}...`);
+          execSync(installCmd, { stdio: "inherit" });
+          console.log("✅ TypeScript support enabled!");
+        } catch {
+          console.log(`❌ Installation failed. Please run '${installCmd}' manually.`);
+        }
+      } else {
+        const plainConfig = ConfigLoader.createPlainConfig();
+        writeFileSync5(configPath, plainConfig, "utf-8");
+        console.log(`✅ Created ${configPath}`);
+        console.log(`\uD83D\uDCA1 Run 'npm install --save-dev glooit' later for TypeScript support`);
+      }
+    } else {
+      const plainConfig = ConfigLoader.createPlainConfig();
+      writeFileSync5(configPath, plainConfig, "utf-8");
+      console.log(`✅ Created ${configPath}`);
+      console.log("\uD83D\uDCA1 Add glooit to devDependencies for TypeScript support");
+    }
+  } catch {
+    const plainConfig = ConfigLoader.createPlainConfig();
+    writeFileSync5(configPath, plainConfig, "utf-8");
+    console.log(`✅ Created ${configPath}`);
+    console.log("\uD83D\uDCA1 Add glooit to devDependencies for TypeScript support");
+  }
   console.log("Next steps:");
   console.log("1. Edit the configuration file to match your project");
-  console.log("2. Create your rule files in .gloo/");
-  console.log("3. Run `gloo sync` to distribute rules");
+  console.log("2. Create your rule files in .glooit/");
+  console.log("3. Run `glooit sync` to distribute rules");
 }
 async function syncCommand(configPath, createBackup = true) {
   const config2 = await ConfigLoader.load(configPath);
@@ -15460,11 +15845,11 @@ async function cleanCommand(configPath) {
 }
 async function resetCommand(force) {
   if (!force) {
-    console.log("⚠️  This will remove all ai-rules generated files, backups, and configuration.");
+    console.log("⚠️  This will remove all glooit generated files, backups, and configuration.");
     console.log("Use --force to skip this confirmation.");
     return;
   }
-  console.log("\uD83D\uDDD1️  Resetting ai-rules...");
+  console.log("\uD83D\uDDD1️  Resetting glooit...");
   let generatedPaths = [];
   let customConfigDir = null;
   try {
@@ -15473,34 +15858,34 @@ async function resetCommand(force) {
     const core2 = new AIRulesCore(config2);
     generatedPaths = core2.collectAllGeneratedPaths();
   } catch {
-    generatedPaths = [".gloo"];
+    generatedPaths = [".glooit"];
   }
   const configPaths = [
-    "gloo.config.ts",
-    "gloo.config.js",
-    "config/gloo.ts",
-    "config/gloo.js"
+    "glooit.config.ts",
+    "glooit.config.js",
+    "config/glooit.ts",
+    "config/glooit.js"
   ];
-  for (const path of configPaths) {
-    if (existsSync8(path)) {
-      rmSync(path);
-      console.log(`   Removed ${path}`);
+  for (const path2 of configPaths) {
+    if (existsSync8(path2)) {
+      rmSync(path2);
+      console.log(`   Removed ${path2}`);
     }
   }
   if (customConfigDir && !generatedPaths.includes(customConfigDir)) {
     generatedPaths.push(customConfigDir);
   }
-  for (const path of generatedPaths) {
-    if (existsSync8(path)) {
-      rmSync(path, { recursive: true, force: true });
-      console.log(`   Removed ${path}`);
+  for (const path2 of generatedPaths) {
+    if (existsSync8(path2)) {
+      rmSync(path2, { recursive: true, force: true });
+      console.log(`   Removed ${path2}`);
     }
   }
   const parentDirs = new Set;
-  for (const path of generatedPaths) {
-    let parent = dirname3(path);
+  for (const path2 of generatedPaths) {
+    let parent = dirname3(path2);
     let level = 0;
-    while (parent !== "." && parent !== "/" && parent !== path && level < 2) {
+    while (parent !== "." && parent !== "/" && parent !== path2 && level < 2) {
       parentDirs.add(parent);
       parent = dirname3(parent);
       level++;
@@ -15518,11 +15903,11 @@ async function resetCommand(force) {
     } catch {}
   }
   try {
-    const config2 = { configDir: ".gloo", rules: [], commands: [] };
+    const config2 = { configDir: ".glooit", rules: [], commands: [], mcps: [], backup: { enabled: true, retention: 10 }, mergeMcps: false };
     const gitIgnoreManager = new GitIgnoreManager(config2);
     await gitIgnoreManager.cleanupGitIgnore();
     console.log("   Cleaned .gitignore");
   } catch {}
-  console.log("✅ Reset completed! Run `gloo init` to start fresh.");
+  console.log("✅ Reset completed! Run `glooit init` to start fresh.");
 }
 program2.parse();

package/dist/core/backup.d.ts

@@ -0,0 +1,14 @@
+import type { Config } from '../types';
+export declare class BackupManager {
+    private config;
+    private backupDir;
+    constructor(config: Config);
+    createBackup(filePaths: string[]): Promise<string>;
+    restoreBackup(timestamp: string): Promise<boolean>;
+    listBackups(): {
+        timestamp: string;
+        fileCount: number;
+    }[];
+    private ensureBackupDir;
+    private cleanupOldBackups;
+}

package/dist/core/config-loader.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from '../types';
+export declare class ConfigLoader {
+    private static readonly DEFAULT_CONFIG_PATHS;
+    static load(customPath?: string): Promise<Config>;
+    private static findConfigFile;
+    static validate(customPath?: string): Promise<boolean>;
+    static createInitialConfig(): string;
+    static createTypedConfig(): string;
+    static createPlainConfig(): string;
+}

package/dist/core/gitignore.d.ts

@@ -0,0 +1,13 @@
+import type { Config } from '../types';
+export declare class GitIgnoreManager {
+    private config;
+    private gitignorePath;
+    private marker;
+    constructor(config: Config);
+    updateGitIgnore(): Promise<void>;
+    cleanupGitIgnore(): Promise<void>;
+    private collectGeneratedPaths;
+    private extractRuleName;
+    private createIgnoreSection;
+    private removeExistingSection;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,21 @@
+import type { Config } from '../types';
+export declare class AIRulesCore {
+    private config;
+    private distributor;
+    private backupManager;
+    private gitIgnoreManager;
+    private hookManager;
+    constructor(config: Config);
+    sync(): Promise<void>;
+    createBackup(): Promise<string>;
+    restoreBackup(timestamp: string): Promise<void>;
+    listBackups(): {
+        timestamp: string;
+        fileCount: number;
+    }[];
+    clean(): Promise<void>;
+    validate(): Promise<boolean>;
+    private distributeMcps;
+    private validateMcpNames;
+    collectAllGeneratedPaths(): string[];
+}

package/dist/hooks/builtin.d.ts

@@ -0,0 +1,4 @@
+export { replaceStructure } from './project-structure';
+export { replaceEnv } from './env-variables';
+export { addTimestamp } from './timestamp';
+export { compact } from './compact';

package/dist/hooks/compact.d.ts

@@ -0,0 +1,9 @@
+import type { SyncContext } from '../types';
+export interface CompactOptions {
+    preserveFrontmatter?: boolean;
+    maxConsecutiveNewlines?: number;
+    removeFillerWords?: boolean;
+    trimTrailingSpaces?: boolean;
+    compactLists?: boolean;
+}
+export declare const compact: (options?: CompactOptions) => (context: SyncContext) => string;

package/dist/hooks/env-variables.d.ts

@@ -0,0 +1,2 @@
+import type { SyncContext } from '../types';
+export declare const replaceEnv: (context: SyncContext) => string;

package/dist/hooks/index.d.ts

@@ -0,0 +1,8 @@
+export type HookFunction = (context: unknown) => void | Promise<void> | string | Promise<string>;
+export type HookRegistry = Record<string, HookFunction>;
+export declare class HookManager {
+    private hooks;
+    register(name: string, hook: HookFunction): void;
+    execute(name: string, context: unknown): Promise<string | void>;
+    list(): string[];
+}

package/dist/hooks/project-structure.d.ts

@@ -0,0 +1,2 @@
+import type { SyncContext } from '../types';
+export declare const replaceStructure: (context: SyncContext) => Promise<string>;

package/dist/hooks/timestamp.d.ts

@@ -0,0 +1,2 @@
+import type { SyncContext } from '../types';
+export declare const addTimestamp: (context: SyncContext) => string;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { defineRules } from './types';
+export type { Config, Rule, Command, Mcp, Agent, SyncContext } from './types';
+export { AIRulesCore } from './core';
+export { ConfigLoader } from './core/config-loader';
+export { AgentDistributor } from './agents/distributor';
+export { BackupManager } from './core/backup';
+export { GitIgnoreManager } from './core/gitignore';
+export { HookManager } from './hooks';
+export * as hooks from './hooks/builtin';

package/dist/index.js

@@ -12370,7 +12370,7 @@ var HooksSchema = exports_external.object({
   error: exports_external.array(HookFunctionSchema).optional()
 });
 var ConfigSchema = exports_external.object({
-  configDir: exports_external.string().default(".gloo"),
+  configDir: exports_external.string().default(".glooit"),
   rules: exports_external.array(RuleSchema),
   commands: exports_external.array(CommandSchema).optional(),
   mcps: exports_external.array(McpSchema).optional(),
@@ -12758,7 +12758,7 @@ import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync
 class GitIgnoreManager {
   config;
   gitignorePath = ".gitignore";
-  marker = "# ai-rules generated files";
+  marker = "# glooit generated files";
   constructor(config2) {
     this.config = config2;
   }
@@ -12864,7 +12864,6 @@ class GitIgnoreManager {
 // src/hooks/index.ts
 class HookManager {
   hooks = {};
-  constructor() {}
   register(name, hook) {
     this.hooks[name] = hook;
   }
@@ -12948,7 +12947,6 @@ class AIRulesCore {
     return this.backupManager.listBackups();
   }
   async clean() {
-    console.log("Clean functionality would be implemented here");
     await this.gitIgnoreManager.cleanupGitIgnore();
   }
   async validate() {
@@ -12981,12 +12979,15 @@ class AIRulesCore {
         if (!mcpGroups.has(outputPath)) {
           mcpGroups.set(outputPath, []);
         }
-        mcpGroups.get(outputPath).push({
-          name: mcp.name,
-          config: mcp.config,
-          agent,
-          outputPath
-        });
+        const group = mcpGroups.get(outputPath);
+        if (group) {
+          group.push({
+            name: mcp.name,
+            config: mcp.config,
+            agent,
+            outputPath
+          });
+        }
       }
     }
     for (const [outputPath, mcps] of mcpGroups) {
@@ -13070,10 +13071,10 @@ import { existsSync as existsSync6 } from "fs";
 import { join as join4 } from "path";
 class ConfigLoader {
   static DEFAULT_CONFIG_PATHS = [
-    "gloo.config.ts",
-    "gloo.config.js",
-    "config/gloo.ts",
-    "config/gloo.js"
+    "glooit.config.ts",
+    "glooit.config.js",
+    "config/glooit.ts",
+    "config/glooit.js"
   ];
   static async load(customPath) {
     const configPath = customPath || this.findConfigFile();
@@ -13109,24 +13110,54 @@ class ConfigLoader {
     }
   }
   static createInitialConfig() {
-    return `import { Config } from 'gloo/types';
+    return this.createTypedConfig();
+  }
+  static createTypedConfig() {
+    return `import type { Config } from 'glooit';
 
 export default {
-  configDir: '.gloo',
+  configDir: '.glooit',
+  targets: ['claude', 'cursor'],
 
   rules: [
     {
-      file: '.gloo/main.md',
-      to: './',
+      name: 'main',
+      file: '.glooit/main.md',
       targets: ['claude', 'cursor']
     }
   ],
 
-  backup: {
-    enabled: true,
-    retention: 10
-  }
+  mcps: [
+    // {
+    //   name: 'example-server',
+    //   file: '.glooit/mcp.json',
+    //   targets: ['claude']
+    // }
+  ]
 } satisfies Config;
+`;
+  }
+  static createPlainConfig() {
+    return `export default {
+  configDir: '.glooit',
+  targets: ['claude', 'cursor'],
+
+  rules: [
+    {
+      name: 'main',
+      file: '.glooit/main.md',
+      targets: ['claude', 'cursor']
+    }
+  ],
+
+  mcps: [
+    // {
+    //   name: 'example-server',
+    //   file: '.glooit/mcp.json',
+    //   targets: ['claude']
+    // }
+  ]
+};
 `;
   }
 }

package/dist/types/index.d.ts

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+export declare const AgentSchema: z.ZodEnum<{
+    claude: "claude";
+    cursor: "cursor";
+    codex: "codex";
+    roocode: "roocode";
+}>;
+export type Agent = z.infer<typeof AgentSchema>;
+export declare const HookFunctionSchema: z.ZodAny;
+export declare const RuleSchema: z.ZodObject<{
+    file: z.ZodString;
+    to: z.ZodString;
+    globs: z.ZodOptional<z.ZodString>;
+    targets: z.ZodArray<z.ZodEnum<{
+        claude: "claude";
+        cursor: "cursor";
+        codex: "codex";
+        roocode: "roocode";
+    }>>;
+    hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const CommandSchema: z.ZodObject<{
+    command: z.ZodString;
+    file: z.ZodString;
+    targets: z.ZodArray<z.ZodEnum<{
+        claude: "claude";
+        cursor: "cursor";
+        codex: "codex";
+        roocode: "roocode";
+    }>>;
+}, z.core.$strip>;
+export declare const McpConfigSchema: z.ZodObject<{
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    type: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    alwaysAllow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const McpSchema: z.ZodObject<{
+    name: z.ZodString;
+    config: z.ZodObject<{
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        type: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        alwaysAllow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    targets: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        claude: "claude";
+        cursor: "cursor";
+        codex: "codex";
+        roocode: "roocode";
+    }>>>;
+    outputPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const BackupConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    retention: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const HooksSchema: z.ZodObject<{
+    before: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    after: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    error: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+}, z.core.$strip>;
+export declare const ConfigSchema: z.ZodObject<{
+    configDir: z.ZodDefault<z.ZodString>;
+    rules: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        to: z.ZodString;
+        globs: z.ZodOptional<z.ZodString>;
+        targets: z.ZodArray<z.ZodEnum<{
+            claude: "claude";
+            cursor: "cursor";
+            codex: "codex";
+            roocode: "roocode";
+        }>>;
+        hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        file: z.ZodString;
+        targets: z.ZodArray<z.ZodEnum<{
+            claude: "claude";
+            cursor: "cursor";
+            codex: "codex";
+            roocode: "roocode";
+        }>>;
+    }, z.core.$strip>>>;
+    mcps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        config: z.ZodObject<{
+            command: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            type: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            alwaysAllow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            disabled: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        targets: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            claude: "claude";
+            cursor: "cursor";
+            codex: "codex";
+            roocode: "roocode";
+        }>>>;
+        outputPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    mergeMcps: z.ZodDefault<z.ZodBoolean>;
+    hooks: z.ZodOptional<z.ZodObject<{
+        before: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+        after: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+        error: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    }, z.core.$strip>>;
+    backup: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        retention: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Rule = z.infer<typeof RuleSchema>;
+export type Command = z.infer<typeof CommandSchema>;
+export type McpConfig = z.infer<typeof McpConfigSchema>;
+export type Mcp = z.infer<typeof McpSchema>;
+export interface ResolvedMcp extends Omit<Mcp, 'outputPath'> {
+    outputPath: string;
+}
+export type BackupConfig = z.infer<typeof BackupConfigSchema>;
+export type Hooks = z.infer<typeof HooksSchema>;
+export type Config = z.infer<typeof ConfigSchema>;
+export interface AgentMapping {
+    path: string;
+    format: 'markdown' | 'frontmatter';
+    directory?: string;
+    mcpPath: string;
+}
+export interface SyncContext {
+    config: Config;
+    rule: Rule;
+    content: string;
+    targetPath: string;
+    agent: Agent;
+}
+export interface BackupEntry {
+    timestamp: string;
+    files: {
+        path: string;
+        content: string;
+    }[];
+}
+export declare function defineRules(config: Config): Config;

package/package.json

@@ -1,23 +1,23 @@
 {
   "name": "glooit",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "🧴 Sync your AI agent configurations and rules across platforms with ease",
   "main": "dist/index.js",
   "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "type": "module",
   "bin": {
-    "gloo": "dist/cli/index.js"
+    "glooit": "dist/cli/index.js"
   },
   "scripts": {
-    "build": "bun run typecheck && bun run lint && bun build src/index.ts --outdir dist --target node",
+    "build": "bun run typecheck && bun run lint && bun build src/index.ts --outdir dist --target node && tsc --project tsconfig.build.json",
     "build:cli": "bun build src/cli/index.ts --outdir dist/cli --target node",
-    "build:binary": "bun build src/cli/index.ts --compile --outfile bin/gloo",
-    "build:binary:linux": "bun build src/cli/index.ts --compile --target=bun-linux-x64 --outfile bin/gloo-linux",
-    "build:binary:macos": "bun build src/cli/index.ts --compile --target=bun-darwin-arm64 --outfile bin/gloo-macos",
-    "build:binary:windows": "bun build src/cli/index.ts --compile --target=bun-windows-x64 --outfile bin/gloo-windows.exe",
+    "build:binary": "bun build src/cli/index.ts --compile --outfile bin/glooit",
+    "build:binary:linux": "bun build src/cli/index.ts --compile --target=bun-linux-x64 --outfile bin/glooit-linux",
+    "build:binary:macos": "bun build src/cli/index.ts --compile --target=bun-darwin-arm64 --outfile bin/glooit-macos",
+    "build:binary:windows": "bun build src/cli/index.ts --compile --target=bun-windows-x64 --outfile bin/glooit-windows.exe",
     "dev": "bun run src/cli/index.ts",
     "test": "vitest",
-    "test:ui": "vitest --ui",
     "test:run": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --noEmit",
@@ -25,9 +25,9 @@
     "lint:fix": "oxlint src tests --fix",
     "format": "oxlint src tests --fix",
     "check": "bun run typecheck && bun run lint && bun run test:run",
-    "prepare": "bun run check && bun run build && bun run build:cli",
+    "taze": "bunx taze",
     "prepublishOnly": "bun run check && bun run build && bun run build:cli",
-    "install:local": "bun run build:binary && sudo mv bin/gloo /usr/local/bin/"
+    "install:local": "bun run build:binary && sudo mv bin/glooit /usr/local/bin/"
   },
   "files": [
     "dist",
@@ -52,25 +52,26 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/nikuscs/gloo.git"
+    "url": "https://github.com/nikuscs/glooit.git"
   },
   "bugs": {
-    "url": "https://github.com/nikuscs/gloo/issues"
+    "url": "https://github.com/nikuscs/glooit/issues"
   },
-  "homepage": "https://github.com/nikuscs/gloo#readme",
+  "homepage": "https://github.com/nikuscs/glooit#readme",
   "devDependencies": {
     "@types/bun": "latest",
     "@types/node": "^24.5.2",
     "@vitest/ui": "^3.2.4",
+    "bumpp": "^10.2.3",
     "oxlint": "^1.17.0",
-    "vitest": "^3.2.4",
-    "bumpp": "^9.2.0"
+    "vitest": "^3.2.4"
   },
   "peerDependencies": {
     "typescript": "^5"
   },
   "dependencies": {
     "commander": "^14.0.1",
+    "package-manager-detector": "^1.3.0",
     "zod": "^4.1.11"
   }
-}
+}