rulesync 7.18.2 → 7.20.0

package/dist/cli/index.cjs

@@ -26,9 +26,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/cli/index.ts
 var import_commander = require("commander");
 
-// src/constants/announcements.ts
-var ANNOUNCEMENT = "".trim();
-
 // src/types/features.ts
 var import_mini = require("zod/mini");
 var ALL_FEATURES = [
@@ -48,6 +45,32 @@ var RulesyncFeaturesSchema = import_mini.z.union([
   import_mini.z.record(import_mini.z.string(), import_mini.z.array(import_mini.z.enum(ALL_FEATURES_WITH_WILDCARD)))
 ]);
 
+// src/types/json-output.ts
+var ErrorCodes = {
+  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+  RULESYNC_DIR_NOT_FOUND: "RULESYNC_DIR_NOT_FOUND",
+  INVALID_TARGET: "INVALID_TARGET",
+  FETCH_FAILED: "FETCH_FAILED",
+  WRITE_FAILED: "WRITE_FAILED",
+  VALIDATION_FAILED: "VALIDATION_FAILED",
+  GENERATION_FAILED: "GENERATION_FAILED",
+  IMPORT_FAILED: "IMPORT_FAILED",
+  INSTALL_FAILED: "INSTALL_FAILED",
+  UPDATE_FAILED: "UPDATE_FAILED",
+  GITIGNORE_FAILED: "GITIGNORE_FAILED",
+  INIT_FAILED: "INIT_FAILED",
+  MCP_FAILED: "MCP_FAILED",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+var CLIError = class extends Error {
+  constructor(message, code = ErrorCodes.UNKNOWN_ERROR, exitCode = 1) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.name = "CLIError";
+  }
+};
+
 // src/utils/error.ts
 var import_zod = require("zod");
 function isZodErrorLike(error) {
@@ -65,69 +88,141 @@ function formatError(error) {
   return String(error);
 }
 
-// src/utils/logger.ts
-var import_consola = require("consola");
-
 // src/utils/vitest.ts
 function isEnvTest() {
   return process.env.NODE_ENV === "test";
 }
 
 // src/utils/logger.ts
-var Logger = class {
+var BaseLogger = class {
   _verbose = false;
   _silent = false;
-  console = import_consola.consola.withDefaults({
-    tag: "rulesync"
-  });
-  /**
-   * Configure logger with verbose and silent mode settings.
-   * Handles conflicting flags where silent takes precedence.
-   * @param verbose - Enable verbose logging
-   * @param silent - Enable silent mode (suppresses all output except errors)
-   */
+  get verbose() {
+    return this._verbose;
+  }
+  get silent() {
+    return this._silent;
+  }
   configure({ verbose, silent }) {
     if (verbose && silent) {
       this._silent = false;
-      this.warn("Both --verbose and --silent specified; --silent takes precedence");
+      if (!isEnvTest()) {
+        console.warn("Both --verbose and --silent specified; --silent takes precedence");
+      }
     }
     this._silent = silent;
     this._verbose = verbose && !silent;
   }
-  get verbose() {
-    return this._verbose;
+};
+var ConsoleLogger = class extends BaseLogger {
+  isSuppressed() {
+    return isEnvTest() || this._silent;
   }
-  get silent() {
-    return this._silent;
+  get jsonMode() {
+    return false;
+  }
+  captureData(_key, _value) {
+  }
+  getJsonData() {
+    return {};
+  }
+  outputJson(_success, _error) {
   }
   info(message, ...args) {
-    if (isEnvTest() || this._silent) return;
-    this.console.info(message, ...args);
+    if (this.isSuppressed()) return;
+    console.log(message, ...args);
   }
-  // Success (always shown unless silent)
   success(message, ...args) {
-    if (isEnvTest() || this._silent) return;
-    this.console.success(message, ...args);
+    if (this.isSuppressed()) return;
+    console.log(message, ...args);
   }
-  // Warning (always shown unless silent)
   warn(message, ...args) {
-    if (isEnvTest() || this._silent) return;
-    this.console.warn(message, ...args);
+    if (this.isSuppressed()) return;
+    console.warn(message, ...args);
   }
-  // Error (always shown, even in silent mode)
-  error(message, ...args) {
+  error(message, _code, ...args) {
     if (isEnvTest()) return;
-    this.console.error(message, ...args);
+    const errorMessage = message instanceof Error ? message.message : message;
+    console.error(errorMessage, ...args);
   }
-  // Debug level (shown only in verbose mode)
   debug(message, ...args) {
-    if (isEnvTest() || this._silent) return;
+    if (this.isSuppressed()) return;
     if (this._verbose) {
-      this.console.info(message, ...args);
+      console.log(message, ...args);
     }
   }
 };
-var logger = new Logger();
+var JsonLogger = class extends BaseLogger {
+  _jsonOutputDone = false;
+  _jsonData = {};
+  _commandName;
+  _version;
+  constructor({ command, version }) {
+    super();
+    this._commandName = command;
+    this._version = version;
+  }
+  get jsonMode() {
+    return true;
+  }
+  captureData(key, value) {
+    this._jsonData[key] = value;
+  }
+  getJsonData() {
+    return { ...this._jsonData };
+  }
+  outputJson(success, error) {
+    if (this._jsonOutputDone) return;
+    this._jsonOutputDone = true;
+    const output = {
+      success,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      command: this._commandName,
+      version: this._version
+    };
+    if (success) {
+      output.data = this._jsonData;
+    } else if (error) {
+      output.error = {
+        code: error.code,
+        message: error.message
+      };
+      if (error.details) {
+        output.error.details = error.details;
+      }
+      if (error.stack) {
+        output.error.stack = error.stack;
+      }
+    }
+    const jsonStr = JSON.stringify(output, null, 2);
+    if (success) {
+      console.log(jsonStr);
+    } else {
+      console.error(jsonStr);
+    }
+  }
+  info(_message, ..._args) {
+  }
+  success(_message, ..._args) {
+  }
+  warn(_message, ..._args) {
+  }
+  error(message, code, ..._args) {
+    if (isEnvTest()) return;
+    const errorMessage = message instanceof Error ? message.message : message;
+    const errorInfo = {
+      code: code || ErrorCodes.UNKNOWN_ERROR,
+      message: errorMessage
+    };
+    if (this._verbose && message instanceof Error && message.stack) {
+      errorInfo.stack = message.stack;
+    }
+    this.outputJson(false, errorInfo);
+  }
+  debug(_message, ..._args) {
+  }
+};
+var logger = new ConsoleLogger();
 
 // src/lib/fetch.ts
 var import_node_path117 = require("path");
@@ -3008,7 +3103,9 @@ var CLAUDE_HOOK_EVENTS = [
   "preCompact",
   "permissionRequest",
   "notification",
-  "setup"
+  "setup",
+  "worktreeCreate",
+  "worktreeRemove"
 ];
 var OPENCODE_HOOK_EVENTS = [
   "sessionStart",
@@ -3075,7 +3172,9 @@ var CANONICAL_TO_CLAUDE_EVENT_NAMES = {
   preCompact: "PreCompact",
   permissionRequest: "PermissionRequest",
   notification: "Notification",
-  setup: "Setup"
+  setup: "Setup",
+  worktreeCreate: "WorktreeCreate",
+  worktreeRemove: "WorktreeRemove"
 };
 var CLAUDE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(
   Object.entries(CANONICAL_TO_CLAUDE_EVENT_NAMES).map(([k, v]) => [v, k])
@@ -3201,7 +3300,13 @@ function canonicalToToolHooks({
       else byMatcher.set(key, [def]);
     }
     const entries = [];
+    const isNoMatcherEvent = converterConfig.noMatcherEvents?.has(eventName) ?? false;
     for (const [matcherKey, defs] of byMatcher) {
+      if (isNoMatcherEvent && matcherKey) {
+        logger.warn(
+          `matcher "${matcherKey}" on "${eventName}" hook will be ignored \u2014 this event does not support matchers`
+        );
+      }
       const hooks = defs.map((def) => {
         const commandText = def.command;
         const trimmedCommand = typeof commandText === "string" ? commandText.trimStart() : void 0;
@@ -3214,7 +3319,8 @@ function canonicalToToolHooks({
           ...def.prompt !== void 0 && def.prompt !== null && { prompt: def.prompt }
         };
       });
-      entries.push(matcherKey ? { matcher: matcherKey, hooks } : { hooks });
+      const includeMatcher = matcherKey && !isNoMatcherEvent;
+      entries.push(includeMatcher ? { matcher: matcherKey, hooks } : { hooks });
     }
     result[toolEventName] = entries;
   }
@@ -3352,12 +3458,14 @@ var ToolHooks = class extends ToolFile {
 };
 
 // src/features/hooks/claudecode-hooks.ts
+var CLAUDE_NO_MATCHER_EVENTS = /* @__PURE__ */ new Set(["worktreeCreate", "worktreeRemove"]);
 var CLAUDE_CONVERTER_CONFIG = {
   supportedEvents: CLAUDE_HOOK_EVENTS,
   canonicalToToolEventNames: CANONICAL_TO_CLAUDE_EVENT_NAMES,
   toolToCanonicalEventNames: CLAUDE_TO_CANONICAL_EVENT_NAMES,
   projectDirVar: "$CLAUDE_PROJECT_DIR",
-  prefixDotRelativeCommandsOnly: true
+  prefixDotRelativeCommandsOnly: true,
+  noMatcherEvents: CLAUDE_NO_MATCHER_EVENTS
 };
 var ClaudecodeHooks = class _ClaudecodeHooks extends ToolHooks {
   constructor(params) {
@@ -17144,30 +17252,36 @@ function formatFetchSummary(summary) {
 }
 
 // src/cli/commands/fetch.ts
-async function fetchCommand(options) {
+async function fetchCommand(logger2, options) {
   const { source, ...fetchOptions } = options;
-  logger.configure({
-    verbose: fetchOptions.verbose ?? false,
-    silent: fetchOptions.silent ?? false
-  });
-  logger.debug(`Fetching files from ${source}...`);
+  logger2.debug(`Fetching files from ${source}...`);
   try {
     const summary = await fetchFiles({
       source,
       options: fetchOptions
     });
+    if (logger2.jsonMode) {
+      const createdFiles = summary.files.filter((f) => f.status === "created").map((f) => f.relativePath);
+      const overwrittenFiles = summary.files.filter((f) => f.status === "overwritten").map((f) => f.relativePath);
+      const skippedFiles = summary.files.filter((f) => f.status === "skipped").map((f) => f.relativePath);
+      logger2.captureData("source", source);
+      logger2.captureData("path", fetchOptions.path);
+      logger2.captureData("created", createdFiles);
+      logger2.captureData("overwritten", overwrittenFiles);
+      logger2.captureData("skipped", skippedFiles);
+      logger2.captureData("totalFetched", summary.created + summary.overwritten + summary.skipped);
+    }
     const output = formatFetchSummary(summary);
-    logger.success(output);
+    logger2.success(output);
     if (summary.created + summary.overwritten === 0 && summary.skipped === 0) {
-      logger.warn("No files were fetched.");
+      logger2.warn("No files were fetched.");
     }
   } catch (error) {
     if (error instanceof GitHubClientError) {
-      logGitHubAuthHints(error);
-    } else {
-      logger.error(formatError(error));
+      const authHint = error.statusCode === 401 || error.statusCode === 403 ? " Tip: Set GITHUB_TOKEN or GH_TOKEN environment variable, or use `GITHUB_TOKEN=$(gh auth token) rulesync fetch ...`" : "";
+      throw new CLIError(`GitHub API Error: ${error.message}.${authHint}`, ErrorCodes.FETCH_FAILED);
     }
-    process.exit(1);
+    throw error;
   }
 }
 
@@ -17881,110 +17995,92 @@ function calculateTotalCount(result) {
 }
 
 // src/cli/commands/generate.ts
-function logFeatureResult(params) {
+function logFeatureResult(logger2, params) {
   const { count, paths, featureName, isPreview, modePrefix } = params;
   if (count > 0) {
     if (isPreview) {
-      logger.info(`${modePrefix} Would write ${count} ${featureName}`);
+      logger2.info(`${modePrefix} Would write ${count} ${featureName}`);
     } else {
-      logger.success(`Written ${count} ${featureName}`);
+      logger2.success(`Written ${count} ${featureName}`);
     }
     for (const p of paths) {
-      logger.info(`    ${p}`);
+      logger2.info(`    ${p}`);
     }
   }
 }
-async function generateCommand(options) {
+async function generateCommand(logger2, options) {
   const config = await ConfigResolver.resolve(options);
-  logger.configure({
-    verbose: config.getVerbose(),
-    silent: config.getSilent()
-  });
   const check = config.getCheck();
   const isPreview = config.isPreviewMode();
   const modePrefix = isPreview ? "[DRY RUN]" : "";
-  logger.debug("Generating files...");
+  logger2.debug("Generating files...");
   if (!await checkRulesyncDirExists({ baseDir: process.cwd() })) {
-    logger.error("\u274C .rulesync directory not found. Run 'rulesync init' first.");
-    process.exit(1);
+    throw new CLIError(
+      ".rulesync directory not found. Run 'rulesync init' first.",
+      ErrorCodes.RULESYNC_DIR_NOT_FOUND
+    );
   }
-  logger.debug(`Base directories: ${config.getBaseDirs().join(", ")}`);
+  logger2.debug(`Base directories: ${config.getBaseDirs().join(", ")}`);
   const features = config.getFeatures();
   if (features.includes("ignore")) {
-    logger.debug("Generating ignore files...");
+    logger2.debug("Generating ignore files...");
   }
   if (features.includes("mcp")) {
-    logger.debug("Generating MCP files...");
+    logger2.debug("Generating MCP files...");
   }
   if (features.includes("commands")) {
-    logger.debug("Generating command files...");
+    logger2.debug("Generating command files...");
   }
   if (features.includes("subagents")) {
-    logger.debug("Generating subagent files...");
+    logger2.debug("Generating subagent files...");
   }
   if (features.includes("skills")) {
-    logger.debug("Generating skill files...");
+    logger2.debug("Generating skill files...");
   }
   if (features.includes("hooks")) {
-    logger.debug("Generating hooks...");
+    logger2.debug("Generating hooks...");
   }
   if (features.includes("rules")) {
-    logger.debug("Generating rule files...");
+    logger2.debug("Generating rule files...");
   }
   const result = await generate({ config });
-  logFeatureResult({
-    count: result.ignoreCount,
-    paths: result.ignorePaths,
-    featureName: "ignore file(s)",
-    isPreview,
-    modePrefix
-  });
-  logFeatureResult({
-    count: result.mcpCount,
-    paths: result.mcpPaths,
-    featureName: "MCP configuration(s)",
-    isPreview,
-    modePrefix
-  });
-  logFeatureResult({
-    count: result.commandsCount,
-    paths: result.commandsPaths,
-    featureName: "command(s)",
-    isPreview,
-    modePrefix
-  });
-  logFeatureResult({
-    count: result.subagentsCount,
-    paths: result.subagentsPaths,
-    featureName: "subagent(s)",
-    isPreview,
-    modePrefix
-  });
-  logFeatureResult({
-    count: result.skillsCount,
-    paths: result.skillsPaths,
-    featureName: "skill(s)",
-    isPreview,
-    modePrefix
-  });
-  logFeatureResult({
-    count: result.hooksCount,
-    paths: result.hooksPaths,
-    featureName: "hooks file(s)",
-    isPreview,
-    modePrefix
-  });
-  logFeatureResult({
-    count: result.rulesCount,
-    paths: result.rulesPaths,
-    featureName: "rule(s)",
-    isPreview,
-    modePrefix
-  });
   const totalGenerated = calculateTotalCount(result);
+  const featureResults = {
+    ignore: { count: result.ignoreCount, paths: result.ignorePaths },
+    mcp: { count: result.mcpCount, paths: result.mcpPaths },
+    commands: { count: result.commandsCount, paths: result.commandsPaths },
+    subagents: { count: result.subagentsCount, paths: result.subagentsPaths },
+    skills: { count: result.skillsCount, paths: result.skillsPaths },
+    hooks: { count: result.hooksCount, paths: result.hooksPaths },
+    rules: { count: result.rulesCount, paths: result.rulesPaths }
+  };
+  const featureLabels = {
+    rules: (count) => `${count === 1 ? "rule" : "rules"}`,
+    ignore: (count) => `${count === 1 ? "ignore file" : "ignore files"}`,
+    mcp: (count) => `${count === 1 ? "MCP file" : "MCP files"}`,
+    commands: (count) => `${count === 1 ? "command" : "commands"}`,
+    subagents: (count) => `${count === 1 ? "subagent" : "subagents"}`,
+    skills: (count) => `${count === 1 ? "skill" : "skills"}`,
+    hooks: (count) => `${count === 1 ? "hooks file" : "hooks files"}`
+  };
+  for (const [feature, data] of Object.entries(featureResults)) {
+    logFeatureResult(logger2, {
+      count: data.count,
+      paths: data.paths,
+      featureName: featureLabels[feature]?.(data.count) ?? feature,
+      isPreview,
+      modePrefix
+    });
+  }
+  if (logger2.jsonMode) {
+    logger2.captureData("features", featureResults);
+    logger2.captureData("totalFiles", totalGenerated);
+    logger2.captureData("hasDiff", result.hasDiff);
+    logger2.captureData("skills", result.skills ?? []);
+  }
   if (totalGenerated === 0) {
     const enabledFeatures = features.join(", ");
-    logger.info(`\u2713 All files are up to date (${enabledFeatures})`);
+    logger2.info(`\u2713 All files are up to date (${enabledFeatures})`);
     return;
   }
   const parts = [];
@@ -17996,129 +18092,209 @@ async function generateCommand(options) {
   if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
   if (result.hooksCount > 0) parts.push(`${result.hooksCount} hooks`);
   if (isPreview) {
-    logger.info(`${modePrefix} Would write ${totalGenerated} file(s) total (${parts.join(" + ")})`);
+    logger2.info(`${modePrefix} Would write ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   } else {
-    logger.success(`\u{1F389} All done! Written ${totalGenerated} file(s) total (${parts.join(" + ")})`);
+    logger2.success(`\u{1F389} All done! Written ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   }
   if (check) {
     if (result.hasDiff) {
-      logger.error("\u274C Files are not up to date. Run 'rulesync generate' to update.");
-      process.exit(1);
+      throw new CLIError(
+        "Files are not up to date. Run 'rulesync generate' to update.",
+        ErrorCodes.GENERATION_FAILED
+      );
     } else {
-      logger.success("\u2713 All files are up to date.");
+      logger2.success("\u2713 All files are up to date.");
     }
   }
 }
 
 // src/cli/commands/gitignore.ts
 var import_node_path121 = require("path");
-var RULESYNC_HEADER = "# Generated by Rulesync";
-var LEGACY_RULESYNC_HEADER = "# Generated by rulesync - AI tool configuration files";
-var RULESYNC_IGNORE_ENTRIES = [
-  // Rulesync curated (fetched) skills
-  `${RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH}/`,
+
+// src/cli/commands/gitignore-entries.ts
+var GITIGNORE_ENTRY_REGISTRY = [
+  // Common / general
+  { target: "common", feature: "general", entry: `${RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH}/` },
+  { target: "common", feature: "general", entry: ".rulesync/rules/*.local.md" },
+  { target: "common", feature: "general", entry: "rulesync.local.jsonc" },
+  { target: "common", feature: "general", entry: "!.rulesync/.aiignore" },
   // AGENTS.md
-  "**/AGENTS.md",
-  "**/.agents/",
-  // Augment
-  "**/.augmentignore",
-  "**/.augment/rules/",
-  "**/.augment-guidelines",
+  { target: "agentsmd", feature: "rules", entry: "**/AGENTS.md" },
+  { target: "agentsmd", feature: "rules", entry: "**/.agents/" },
+  // Augment Code
+  { target: "augmentcode", feature: "rules", entry: "**/.augment/rules/" },
+  { target: "augmentcode", feature: "rules", entry: "**/.augment-guidelines" },
+  { target: "augmentcode", feature: "ignore", entry: "**/.augmentignore" },
   // Claude Code
-  "**/CLAUDE.md",
-  "**/CLAUDE.local.md",
-  "**/.claude/CLAUDE.md",
-  "**/.claude/CLAUDE.local.md",
-  "**/.claude/memories/",
-  "**/.claude/rules/",
-  "**/.claude/commands/",
-  "**/.claude/agents/",
-  "**/.claude/skills/",
-  "**/.claude/settings.local.json",
-  "**/.mcp.json",
+  { target: "claudecode", feature: "rules", entry: "**/CLAUDE.md" },
+  { target: "claudecode", feature: "rules", entry: "**/CLAUDE.local.md" },
+  { target: "claudecode", feature: "rules", entry: "**/.claude/CLAUDE.md" },
+  { target: "claudecode", feature: "rules", entry: "**/.claude/CLAUDE.local.md" },
+  { target: "claudecode", feature: "rules", entry: "**/.claude/rules/" },
+  { target: "claudecode", feature: "commands", entry: "**/.claude/commands/" },
+  { target: "claudecode", feature: "subagents", entry: "**/.claude/agents/" },
+  { target: "claudecode", feature: "skills", entry: "**/.claude/skills/" },
+  { target: "claudecode", feature: "mcp", entry: "**/.mcp.json" },
+  { target: "claudecode", feature: "general", entry: "**/.claude/memories/" },
+  { target: "claudecode", feature: "general", entry: "**/.claude/settings.local.json" },
   // Cline
-  "**/.clinerules/",
-  "**/.clinerules/workflows/",
-  "**/.clineignore",
-  "**/.cline/mcp.json",
-  // Codex
-  "**/.codexignore",
-  "**/.codex/memories/",
-  "**/.codex/skills/",
-  "**/.codex/agents/",
-  "**/.codex/config.toml",
+  { target: "cline", feature: "rules", entry: "**/.clinerules/" },
+  { target: "cline", feature: "commands", entry: "**/.clinerules/workflows/" },
+  { target: "cline", feature: "ignore", entry: "**/.clineignore" },
+  { target: "cline", feature: "mcp", entry: "**/.cline/mcp.json" },
+  // Codex CLI
+  { target: "codexcli", feature: "ignore", entry: "**/.codexignore" },
+  { target: "codexcli", feature: "skills", entry: "**/.codex/skills/" },
+  { target: "codexcli", feature: "subagents", entry: "**/.codex/agents/" },
+  { target: "codexcli", feature: "general", entry: "**/.codex/memories/" },
+  { target: "codexcli", feature: "general", entry: "**/.codex/config.toml" },
   // Cursor
-  "**/.cursor/",
-  "**/.cursorignore",
+  { target: "cursor", feature: "rules", entry: "**/.cursor/" },
+  { target: "cursor", feature: "ignore", entry: "**/.cursorignore" },
   // Factory Droid
-  "**/.factory/rules/",
-  "**/.factory/commands/",
-  "**/.factory/droids/",
-  "**/.factory/skills/",
-  "**/.factory/mcp.json",
-  "**/.factory/settings.json",
-  // Gemini
-  "**/GEMINI.md",
-  "**/.gemini/memories/",
-  "**/.gemini/commands/",
-  "**/.gemini/subagents/",
-  "**/.gemini/skills/",
-  "**/.geminiignore",
+  { target: "factorydroid", feature: "rules", entry: "**/.factory/rules/" },
+  { target: "factorydroid", feature: "commands", entry: "**/.factory/commands/" },
+  { target: "factorydroid", feature: "subagents", entry: "**/.factory/droids/" },
+  { target: "factorydroid", feature: "skills", entry: "**/.factory/skills/" },
+  { target: "factorydroid", feature: "mcp", entry: "**/.factory/mcp.json" },
+  { target: "factorydroid", feature: "general", entry: "**/.factory/settings.json" },
+  // Gemini CLI
+  { target: "geminicli", feature: "rules", entry: "**/GEMINI.md" },
+  { target: "geminicli", feature: "commands", entry: "**/.gemini/commands/" },
+  { target: "geminicli", feature: "subagents", entry: "**/.gemini/subagents/" },
+  { target: "geminicli", feature: "skills", entry: "**/.gemini/skills/" },
+  { target: "geminicli", feature: "ignore", entry: "**/.geminiignore" },
+  { target: "geminicli", feature: "general", entry: "**/.gemini/memories/" },
   // Goose
-  "**/.goosehints",
-  "**/.goose/",
-  "**/.gooseignore",
+  { target: "goose", feature: "rules", entry: "**/.goosehints" },
+  { target: "goose", feature: "rules", entry: "**/.goose/" },
+  { target: "goose", feature: "ignore", entry: "**/.gooseignore" },
   // GitHub Copilot
-  "**/.github/copilot-instructions.md",
-  "**/.github/instructions/",
-  "**/.github/prompts/",
-  "**/.github/agents/",
-  "**/.github/skills/",
-  "**/.github/hooks/",
-  "**/.vscode/mcp.json",
+  { target: "copilot", feature: "rules", entry: "**/.github/copilot-instructions.md" },
+  { target: "copilot", feature: "rules", entry: "**/.github/instructions/" },
+  { target: "copilot", feature: "commands", entry: "**/.github/prompts/" },
+  { target: "copilot", feature: "subagents", entry: "**/.github/agents/" },
+  { target: "copilot", feature: "skills", entry: "**/.github/skills/" },
+  { target: "copilot", feature: "hooks", entry: "**/.github/hooks/" },
+  { target: "copilot", feature: "mcp", entry: "**/.vscode/mcp.json" },
   // Junie
-  "**/.junie/guidelines.md",
-  "**/.junie/mcp.json",
-  "**/.junie/skills/",
-  "**/.junie/agents/",
+  { target: "junie", feature: "rules", entry: "**/.junie/guidelines.md" },
+  { target: "junie", feature: "mcp", entry: "**/.junie/mcp.json" },
+  { target: "junie", feature: "skills", entry: "**/.junie/skills/" },
+  { target: "junie", feature: "subagents", entry: "**/.junie/agents/" },
   // Kilo Code
-  "**/.kilocode/rules/",
-  "**/.kilocode/skills/",
-  "**/.kilocode/workflows/",
-  "**/.kilocode/mcp.json",
-  "**/.kilocodeignore",
+  { target: "kilo", feature: "rules", entry: "**/.kilocode/rules/" },
+  { target: "kilo", feature: "skills", entry: "**/.kilocode/skills/" },
+  { target: "kilo", feature: "commands", entry: "**/.kilocode/workflows/" },
+  { target: "kilo", feature: "mcp", entry: "**/.kilocode/mcp.json" },
+  { target: "kilo", feature: "ignore", entry: "**/.kilocodeignore" },
   // Kiro
-  "**/.kiro/steering/",
-  "**/.kiro/prompts/",
-  "**/.kiro/skills/",
-  "**/.kiro/agents/",
-  "**/.kiro/settings/mcp.json",
-  "**/.aiignore",
+  { target: "kiro", feature: "rules", entry: "**/.kiro/steering/" },
+  { target: "kiro", feature: "commands", entry: "**/.kiro/prompts/" },
+  { target: "kiro", feature: "skills", entry: "**/.kiro/skills/" },
+  { target: "kiro", feature: "subagents", entry: "**/.kiro/agents/" },
+  { target: "kiro", feature: "mcp", entry: "**/.kiro/settings/mcp.json" },
+  { target: "kiro", feature: "ignore", entry: "**/.aiignore" },
   // OpenCode
-  "**/.opencode/memories/",
-  "**/.opencode/command/",
-  "**/.opencode/agent/",
-  "**/.opencode/skill/",
-  "**/.opencode/plugins/",
-  // Qwen
-  "**/QWEN.md",
-  "**/.qwen/memories/",
+  { target: "opencode", feature: "commands", entry: "**/.opencode/command/" },
+  { target: "opencode", feature: "subagents", entry: "**/.opencode/agent/" },
+  { target: "opencode", feature: "skills", entry: "**/.opencode/skill/" },
+  { target: "opencode", feature: "mcp", entry: "**/.opencode/plugins/" },
+  { target: "opencode", feature: "general", entry: "**/.opencode/memories/" },
+  // Qwen Code
+  { target: "qwencode", feature: "rules", entry: "**/QWEN.md" },
+  { target: "qwencode", feature: "general", entry: "**/.qwen/memories/" },
   // Replit
-  "**/replit.md",
+  { target: "replit", feature: "rules", entry: "**/replit.md" },
   // Roo
-  "**/.roo/rules/",
-  "**/.roo/skills/",
-  "**/.rooignore",
-  "**/.roo/mcp.json",
-  "**/.roo/subagents/",
+  { target: "roo", feature: "rules", entry: "**/.roo/rules/" },
+  { target: "roo", feature: "skills", entry: "**/.roo/skills/" },
+  { target: "roo", feature: "ignore", entry: "**/.rooignore" },
+  { target: "roo", feature: "mcp", entry: "**/.roo/mcp.json" },
+  { target: "roo", feature: "subagents", entry: "**/.roo/subagents/" },
   // Warp
-  "**/.warp/",
-  "**/WARP.md",
-  // Others
-  ".rulesync/rules/*.local.md",
-  "rulesync.local.jsonc",
-  "!.rulesync/.aiignore"
+  { target: "warp", feature: "rules", entry: "**/.warp/" },
+  { target: "warp", feature: "rules", entry: "**/WARP.md" }
 ];
+var ALL_GITIGNORE_ENTRIES = GITIGNORE_ENTRY_REGISTRY.map(
+  (tag) => tag.entry
+);
+var isTargetSelected = (target, selectedTargets) => {
+  if (target === "common") return true;
+  if (!selectedTargets || selectedTargets.length === 0) return true;
+  if (selectedTargets.includes("*")) return true;
+  return selectedTargets.includes(target);
+};
+var isFeatureSelected = (feature, target, features) => {
+  if (feature === "general") return true;
+  if (!features) return true;
+  if (Array.isArray(features)) {
+    if (features.length === 0) return true;
+    if (features.includes("*")) return true;
+    return features.includes(feature);
+  }
+  if (target === "common") return true;
+  const targetFeatures = features[target];
+  if (!targetFeatures) return true;
+  if (targetFeatures.includes("*")) return true;
+  return targetFeatures.includes(feature);
+};
+var warnInvalidTargets = (targets) => {
+  const validTargets = new Set(ALL_TOOL_TARGETS_WITH_WILDCARD);
+  for (const target of targets) {
+    if (!validTargets.has(target)) {
+      logger.warn(
+        `Unknown target '${target}'. Valid targets: ${ALL_TOOL_TARGETS_WITH_WILDCARD.join(", ")}`
+      );
+    }
+  }
+};
+var warnInvalidFeatures = (features) => {
+  const validFeatures = new Set(ALL_FEATURES_WITH_WILDCARD);
+  if (Array.isArray(features)) {
+    for (const feature of features) {
+      if (!validFeatures.has(feature)) {
+        logger.warn(
+          `Unknown feature '${feature}'. Valid features: ${ALL_FEATURES_WITH_WILDCARD.join(", ")}`
+        );
+      }
+    }
+  } else {
+    for (const targetFeatures of Object.values(features)) {
+      if (!targetFeatures) continue;
+      for (const feature of targetFeatures) {
+        if (!validFeatures.has(feature)) {
+          logger.warn(
+            `Unknown feature '${feature}'. Valid features: ${ALL_FEATURES_WITH_WILDCARD.join(", ")}`
+          );
+        }
+      }
+    }
+  }
+};
+var filterGitignoreEntries = (params) => {
+  const { targets, features } = params ?? {};
+  if (targets && targets.length > 0) {
+    warnInvalidTargets(targets);
+  }
+  if (features) {
+    warnInvalidFeatures(features);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const tag of GITIGNORE_ENTRY_REGISTRY) {
+    if (!isTargetSelected(tag.target, targets)) continue;
+    if (!isFeatureSelected(tag.feature, tag.target, features)) continue;
+    if (seen.has(tag.entry)) continue;
+    seen.add(tag.entry);
+    result.push(tag.entry);
+  }
+  return result;
+};
+
+// src/cli/commands/gitignore.ts
+var RULESYNC_HEADER = "# Generated by Rulesync";
+var LEGACY_RULESYNC_HEADER = "# Generated by rulesync - AI tool configuration files";
 var isRulesyncHeader = (line) => {
   const trimmed = line.trim();
   return trimmed === RULESYNC_HEADER || trimmed === LEGACY_RULESYNC_HEADER;
@@ -18128,7 +18304,7 @@ var isRulesyncEntry = (line) => {
   if (trimmed === "" || isRulesyncHeader(line)) {
     return false;
   }
-  return RULESYNC_IGNORE_ENTRIES.includes(trimmed);
+  return ALL_GITIGNORE_ENTRIES.includes(trimmed);
 };
 var removeExistingRulesyncEntries = (content) => {
   const lines = content.split("\n");
@@ -18168,37 +18344,56 @@ var removeExistingRulesyncEntries = (content) => {
   }
   return result;
 };
-var gitignoreCommand = async () => {
+var gitignoreCommand = async (logger2, options) => {
   const gitignorePath = (0, import_node_path121.join)(process.cwd(), ".gitignore");
   let gitignoreContent = "";
   if (await fileExists(gitignorePath)) {
     gitignoreContent = await readFileContent(gitignorePath);
   }
   const cleanedContent = removeExistingRulesyncEntries(gitignoreContent);
-  const rulesyncBlock = [RULESYNC_HEADER, ...RULESYNC_IGNORE_ENTRIES].join("\n");
+  const filteredEntries = filterGitignoreEntries({
+    targets: options?.targets,
+    features: options?.features
+  });
+  const existingEntries = new Set(
+    gitignoreContent.split("\n").map((line) => line.trim()).filter((line) => line !== "" && !isRulesyncHeader(line))
+  );
+  const alreadyExistedEntries = filteredEntries.filter((entry) => existingEntries.has(entry));
+  const entriesToAdd = filteredEntries.filter((entry) => !existingEntries.has(entry));
+  const rulesyncBlock = [RULESYNC_HEADER, ...filteredEntries].join("\n");
   const newContent = cleanedContent.trim() ? `${cleanedContent.trimEnd()}
 
 ${rulesyncBlock}
 ` : `${rulesyncBlock}
 `;
   if (gitignoreContent === newContent) {
-    logger.success(".gitignore is already up to date");
+    if (logger2.jsonMode) {
+      logger2.captureData("entriesAdded", []);
+      logger2.captureData("gitignorePath", gitignorePath);
+      logger2.captureData("alreadyExisted", filteredEntries);
+    }
+    logger2.success(".gitignore is already up to date");
     return;
   }
   await writeFileContent(gitignorePath, newContent);
-  logger.success("Updated .gitignore with rulesync entries:");
-  for (const entry of RULESYNC_IGNORE_ENTRIES) {
-    logger.info(`  ${entry}`);
+  if (logger2.jsonMode) {
+    logger2.captureData("entriesAdded", entriesToAdd);
+    logger2.captureData("gitignorePath", gitignorePath);
+    logger2.captureData("alreadyExisted", alreadyExistedEntries);
   }
-  logger.info("");
-  logger.info(
+  logger2.success("Updated .gitignore with rulesync entries:");
+  for (const entry of filteredEntries) {
+    logger2.info(`  ${entry}`);
+  }
+  logger2.info("");
+  logger2.info(
     "\u{1F4A1} If you're using Google Antigravity, note that rules, workflows, and skills won't load if they're gitignored."
   );
-  logger.info("   You can add the following to .git/info/exclude instead:");
-  logger.info("   **/.agent/rules/");
-  logger.info("   **/.agent/workflows/");
-  logger.info("   **/.agent/skills/");
-  logger.info("   For more details: https://github.com/dyoshikawa/rulesync/issues/981");
+  logger2.info("   You can add the following to .git/info/exclude instead:");
+  logger2.info("   **/.agent/rules/");
+  logger2.info("   **/.agent/workflows/");
+  logger2.info("   **/.agent/skills/");
+  logger2.info("   For more details: https://github.com/dyoshikawa/rulesync/issues/981");
 };
 
 // src/lib/import.ts
@@ -18421,29 +18616,36 @@ async function importHooksCore(params) {
 }
 
 // src/cli/commands/import.ts
-async function importCommand(options) {
+async function importCommand(logger2, options) {
   if (!options.targets) {
-    logger.error("No tools found in --targets");
-    process.exit(1);
+    throw new CLIError("No tools found in --targets", ErrorCodes.IMPORT_FAILED);
   }
   if (options.targets.length > 1) {
-    logger.error("Only one tool can be imported at a time");
-    process.exit(1);
+    throw new CLIError("Only one tool can be imported at a time", ErrorCodes.IMPORT_FAILED);
   }
   const config = await ConfigResolver.resolve(options);
-  logger.configure({
-    verbose: config.getVerbose(),
-    silent: config.getSilent()
-  });
   const tool = config.getTargets()[0];
-  logger.debug(`Importing files from ${tool}...`);
+  logger2.debug(`Importing files from ${tool}...`);
   const result = await importFromTool({ config, tool });
   const totalImported = calculateTotalCount(result);
   if (totalImported === 0) {
     const enabledFeatures = config.getFeatures().join(", ");
-    logger.warn(`No files imported for enabled features: ${enabledFeatures}`);
+    logger2.warn(`No files imported for enabled features: ${enabledFeatures}`);
     return;
   }
+  if (logger2.jsonMode) {
+    logger2.captureData("tool", tool);
+    logger2.captureData("features", {
+      rules: { count: result.rulesCount },
+      ignore: { count: result.ignoreCount },
+      mcp: { count: result.mcpCount },
+      commands: { count: result.commandsCount },
+      subagents: { count: result.subagentsCount },
+      skills: { count: result.skillsCount },
+      hooks: { count: result.hooksCount }
+    });
+    logger2.captureData("totalFiles", totalImported);
+  }
   const parts = [];
   if (result.rulesCount > 0) parts.push(`${result.rulesCount} rules`);
   if (result.ignoreCount > 0) parts.push(`${result.ignoreCount} ignore files`);
@@ -18452,7 +18654,7 @@ async function importCommand(options) {
   if (result.subagentsCount > 0) parts.push(`${result.subagentsCount} subagents`);
   if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
   if (result.hooksCount > 0) parts.push(`${result.hooksCount} hooks`);
-  logger.success(`Imported ${totalImported} file(s) total (${parts.join(" + ")})`);
+  logger2.success(`Imported ${totalImported} file(s) total (${parts.join(" + ")})`);
 }
 
 // src/lib/init.ts
@@ -18681,28 +18883,38 @@ async function writeIfNotExists(path4, content) {
 }
 
 // src/cli/commands/init.ts
-async function initCommand() {
-  logger.debug("Initializing rulesync...");
+async function initCommand(logger2) {
+  logger2.debug("Initializing rulesync...");
   await ensureDir(RULESYNC_RELATIVE_DIR_PATH);
   const result = await init();
+  const createdFiles = [];
+  const skippedFiles = [];
   for (const file of result.sampleFiles) {
     if (file.created) {
-      logger.success(`Created ${file.path}`);
+      createdFiles.push(file.path);
+      logger2.success(`Created ${file.path}`);
     } else {
-      logger.info(`Skipped ${file.path} (already exists)`);
+      skippedFiles.push(file.path);
+      logger2.info(`Skipped ${file.path} (already exists)`);
     }
   }
   if (result.configFile.created) {
-    logger.success(`Created ${result.configFile.path}`);
+    createdFiles.push(result.configFile.path);
+    logger2.success(`Created ${result.configFile.path}`);
   } else {
-    logger.info(`Skipped ${result.configFile.path} (already exists)`);
+    skippedFiles.push(result.configFile.path);
+    logger2.info(`Skipped ${result.configFile.path} (already exists)`);
   }
-  logger.success("rulesync initialized successfully!");
-  logger.info("Next steps:");
-  logger.info(
+  if (logger2.jsonMode) {
+    logger2.captureData("created", createdFiles);
+    logger2.captureData("skipped", skippedFiles);
+  }
+  logger2.success("rulesync initialized successfully!");
+  logger2.info("Next steps:");
+  logger2.info(
     `1. Edit ${RULESYNC_RELATIVE_DIR_PATH}/**/*.md, ${RULESYNC_RELATIVE_DIR_PATH}/skills/*/${SKILL_FILE_NAME}, ${RULESYNC_MCP_RELATIVE_FILE_PATH}, ${RULESYNC_HOOKS_RELATIVE_FILE_PATH} and ${RULESYNC_AIIGNORE_RELATIVE_FILE_PATH}`
   );
-  logger.info("2. Run 'rulesync generate' to create configuration files");
+  logger2.info("2. Run 'rulesync generate' to create configuration files");
 }
 
 // src/lib/sources.ts
@@ -19428,11 +19640,7 @@ async function fetchSourceViaGit(params) {
 }
 
 // src/cli/commands/install.ts
-async function installCommand(options) {
-  logger.configure({
-    verbose: options.verbose ?? false,
-    silent: options.silent ?? false
-  });
+async function installCommand(logger2, options) {
   const config = await ConfigResolver.resolve({
     configPath: options.configPath,
     verbose: options.verbose,
@@ -19440,10 +19648,10 @@ async function installCommand(options) {
   });
   const sources = config.getSources();
   if (sources.length === 0) {
-    logger.warn("No sources defined in configuration. Nothing to install.");
+    logger2.warn("No sources defined in configuration. Nothing to install.");
     return;
   }
-  logger.debug(`Installing skills from ${sources.length} source(s)...`);
+  logger2.debug(`Installing skills from ${sources.length} source(s)...`);
   const result = await resolveAndFetchSources({
     sources,
     baseDir: process.cwd(),
@@ -19453,12 +19661,16 @@ async function installCommand(options) {
       token: options.token
     }
   });
+  if (logger2.jsonMode) {
+    logger2.captureData("sourcesProcessed", result.sourcesProcessed);
+    logger2.captureData("skillsFetched", result.fetchedSkillCount);
+  }
   if (result.fetchedSkillCount > 0) {
-    logger.success(
+    logger2.success(
       `Installed ${result.fetchedSkillCount} skill(s) from ${result.sourcesProcessed} source(s).`
     );
   } else {
-    logger.success(`All skills up to date (${result.sourcesProcessed} source(s) checked).`);
+    logger2.success(`All skills up to date (${result.sourcesProcessed} source(s) checked).`);
   }
 }
 
@@ -20873,7 +21085,7 @@ var rulesyncTool = {
 };
 
 // src/cli/commands/mcp.ts
-async function mcpCommand({ version }) {
+async function mcpCommand(logger2, { version }) {
   const server = new import_fastmcp.FastMCP({
     name: "Rulesync MCP Server",
     // eslint-disable-next-line no-type-assertion/no-type-assertion
@@ -20881,7 +21093,7 @@ async function mcpCommand({ version }) {
     instructions: "This server handles Rulesync files including rules, commands, MCP, ignore files, subagents and skills for any AI agents. It should be used when you need those files."
   });
   server.addTool(rulesyncTool);
-  logger.info("Rulesync MCP server started via stdio");
+  logger2.info("Rulesync MCP server started via stdio");
   void server.start({
     transportType: "stdio"
   });
@@ -21197,158 +21409,182 @@ To upgrade, run:
 }
 
 // src/cli/commands/update.ts
-async function updateCommand(currentVersion, options) {
-  const { check = false, force = false, verbose = false, silent = false, token } = options;
-  logger.configure({ verbose, silent });
+async function updateCommand(logger2, currentVersion, options) {
+  const { check = false, force = false, token } = options;
   try {
     const environment = detectExecutionEnvironment();
-    logger.debug(`Detected environment: ${environment}`);
+    logger2.debug(`Detected environment: ${environment}`);
     if (environment === "npm") {
-      logger.info(getNpmUpgradeInstructions());
+      logger2.info(getNpmUpgradeInstructions());
       return;
     }
     if (environment === "homebrew") {
-      logger.info(getHomebrewUpgradeInstructions());
+      logger2.info(getHomebrewUpgradeInstructions());
       return;
     }
     if (check) {
-      logger.info("Checking for updates...");
+      logger2.info("Checking for updates...");
       const updateCheck = await checkForUpdate(currentVersion, token);
+      if (logger2.jsonMode) {
+        logger2.captureData("currentVersion", updateCheck.currentVersion);
+        logger2.captureData("latestVersion", updateCheck.latestVersion);
+        logger2.captureData("updateAvailable", updateCheck.hasUpdate);
+        logger2.captureData(
+          "message",
+          updateCheck.hasUpdate ? `Update available: ${updateCheck.currentVersion} -> ${updateCheck.latestVersion}` : `Already at the latest version (${updateCheck.currentVersion})`
+        );
+      }
       if (updateCheck.hasUpdate) {
-        logger.success(
+        logger2.success(
           `Update available: ${updateCheck.currentVersion} -> ${updateCheck.latestVersion}`
         );
       } else {
-        logger.info(`Already at the latest version (${updateCheck.currentVersion})`);
+        logger2.info(`Already at the latest version (${updateCheck.currentVersion})`);
       }
       return;
     }
-    logger.info("Checking for updates...");
+    logger2.info("Checking for updates...");
     const message = await performBinaryUpdate(currentVersion, { force, token });
-    logger.success(message);
+    logger2.success(message);
   } catch (error) {
     if (error instanceof GitHubClientError) {
-      logGitHubAuthHints(error);
+      const authHint = error.statusCode === 401 || error.statusCode === 403 ? " Tip: Set GITHUB_TOKEN or GH_TOKEN environment variable, or use `GITHUB_TOKEN=$(gh auth token) rulesync update ...`" : "";
+      throw new CLIError(
+        `GitHub API Error: ${error.message}.${authHint}`,
+        ErrorCodes.UPDATE_FAILED
+      );
     } else if (error instanceof UpdatePermissionError) {
-      logger.error(error.message);
-      logger.info("Tip: Run with elevated privileges (e.g., sudo rulesync update)");
-    } else {
-      logger.error(formatError(error));
+      throw new CLIError(
+        `${error.message} Tip: Run with elevated privileges (e.g., sudo rulesync update)`,
+        ErrorCodes.UPDATE_FAILED
+      );
     }
-    process.exit(1);
+    throw error;
   }
 }
 
 // src/cli/index.ts
-var getVersion = () => "7.18.2";
+var getVersion = () => "7.20.0";
+function wrapCommand(name, errorCode, handler) {
+  return async (...args) => {
+    const command = args[args.length - 1];
+    const options = args[args.length - 2];
+    const positionalArgs = args.slice(0, -2);
+    const globalOpts = command.parent?.opts() ?? {};
+    const logger2 = globalOpts.json ? new JsonLogger({ command: name, version: getVersion() }) : new ConsoleLogger();
+    logger2.configure({
+      verbose: Boolean(globalOpts.verbose) || Boolean(options.verbose),
+      silent: Boolean(globalOpts.silent) || Boolean(options.silent)
+    });
+    try {
+      await handler(logger2, options, globalOpts, positionalArgs);
+      logger2.outputJson(true);
+    } catch (error) {
+      const code = error instanceof CLIError ? error.code : errorCode;
+      const errorArg = error instanceof Error ? error : formatError(error);
+      logger2.error(errorArg, code);
+      process.exit(error instanceof CLIError ? error.exitCode : 1);
+    }
+  };
+}
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();
-  program.hook("postAction", () => {
-    if (ANNOUNCEMENT.length > 0) {
-      logger.info(ANNOUNCEMENT);
+  program.name("rulesync").description("Unified AI rules management CLI tool").version(version, "-v, --version", "Show version").option("-j, --json", "Output results as JSON");
+  program.command("init").description("Initialize rulesync in current directory").option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").action(
+    wrapCommand("init", "INIT_FAILED", async (logger2) => {
+      await initCommand(logger2);
+    })
+  );
+  program.command("gitignore").description("Add generated files to .gitignore").option(
+    "-t, --targets <tools>",
+    "Comma-separated list of tools to include (e.g., 'claudecode,copilot' or '*' for all)",
+    (value) => {
+      return value.split(",").map((t) => t.trim()).filter(Boolean);
     }
-  });
-  program.name("rulesync").description("Unified AI rules management CLI tool").version(version, "-v, --version", "Show version");
-  program.command("init").description("Initialize rulesync in current directory").action(initCommand);
-  program.command("gitignore").description("Add generated files to .gitignore").action(gitignoreCommand);
+  ).option(
+    "-f, --features <features>",
+    `Comma-separated list of features to include (${ALL_FEATURES.join(",")}) or '*' for all`,
+    (value) => {
+      return value.split(",").map((f) => f.trim()).filter(Boolean);
+    }
+  ).option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").action(
+    wrapCommand("gitignore", "GITIGNORE_FAILED", async (logger2, options) => {
+      await gitignoreCommand(logger2, {
+        // eslint-disable-next-line no-type-assertion/no-type-assertion
+        targets: options.targets,
+        // eslint-disable-next-line no-type-assertion/no-type-assertion
+        features: options.features
+      });
+    })
+  );
   program.command("fetch <source>").description("Fetch files from a Git repository (GitHub/GitLab)").option(
     "-t, --target <target>",
     "Target format to interpret files as (e.g., 'rulesync', 'claudecode'). Default: rulesync"
   ).option(
     "-f, --features <features>",
     `Comma-separated list of features to fetch (${ALL_FEATURES.join(",")}) or '*' for all`,
-    (value) => {
-      return value.split(",").map((f) => f.trim());
-    }
+    (value) => value.split(",").map((f) => f.trim())
   ).option("-r, --ref <ref>", "Branch, tag, or commit SHA to fetch from").option("-p, --path <path>", "Subdirectory path within the repository").option("-o, --output <dir>", "Output directory (default: .rulesync)").option(
     "-c, --conflict <strategy>",
     "Conflict resolution strategy: skip, overwrite (default: overwrite)"
-  ).option("--token <token>", "Git provider token for private repositories").option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").action(async (source, options) => {
-    await fetchCommand({
-      source,
-      target: options.target,
-      features: options.features,
-      ref: options.ref,
-      path: options.path,
-      output: options.output,
-      conflict: options.conflict,
-      token: options.token,
-      verbose: options.verbose,
-      silent: options.silent
-    });
-  });
+  ).option("--token <token>", "Git provider token for private repositories").option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").action(
+    wrapCommand("fetch", "FETCH_FAILED", async (logger2, options, _globalOpts, positionalArgs) => {
+      const source = positionalArgs[0];
+      await fetchCommand(logger2, { ...options, source });
+    })
+  );
   program.command("import").description("Import configurations from AI tools to rulesync format").option(
     "-t, --targets <tool>",
     "Tool to import from (e.g., 'copilot', 'cursor', 'cline')",
-    (value) => {
-      return value.split(",").map((t) => t.trim());
-    }
+    (value) => value.split(",").map((t) => t.trim())
   ).option(
     "-f, --features <features>",
     `Comma-separated list of features to import (${ALL_FEATURES.join(",")}) or '*' for all`,
-    (value) => {
-      return value.split(",").map((f) => f.trim());
-    }
-  ).option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").option("-g, --global", "Import for global(user scope) configuration files").action(async (options) => {
-    try {
-      await importCommand({
-        targets: options.targets,
-        features: options.features,
-        verbose: options.verbose,
-        silent: options.silent,
-        configPath: options.config,
-        global: options.global
-      });
-    } catch (error) {
-      logger.error(formatError(error));
-      process.exit(1);
-    }
-  });
-  program.command("mcp").description("Start MCP server for rulesync").action(async () => {
-    try {
-      await mcpCommand({ version });
-    } catch (error) {
-      logger.error(formatError(error));
-      process.exit(1);
-    }
-  });
+    (value) => value.split(",").map((f) => f.trim())
+  ).option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").option("-g, --global", "Import for global(user scope) configuration files").action(
+    wrapCommand("import", "IMPORT_FAILED", async (logger2, options) => {
+      await importCommand(logger2, options);
+    })
+  );
+  program.command("mcp").description("Start MCP server for rulesync").action(
+    wrapCommand("mcp", "MCP_FAILED", async (logger2, _options) => {
+      await mcpCommand(logger2, { version });
+    })
+  );
   program.command("install").description("Install skills from declarative sources in rulesync.jsonc").option("--update", "Force re-resolve all source refs, ignoring lockfile").option(
     "--frozen",
     "Fail if lockfile is missing or out of sync (for CI); fetches missing skills using locked refs"
-  ).option("--token <token>", "GitHub token for private repos").option("-c, --config <path>", "Path to configuration file").option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").action(async (options) => {
-    try {
-      await installCommand({
+  ).option("--token <token>", "GitHub token for private repos").option("-c, --config <path>", "Path to configuration file").option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").action(
+    wrapCommand("install", "INSTALL_FAILED", async (logger2, options) => {
+      await installCommand(logger2, {
+        // eslint-disable-next-line no-type-assertion/no-type-assertion
         update: options.update,
+        // eslint-disable-next-line no-type-assertion/no-type-assertion
         frozen: options.frozen,
+        // eslint-disable-next-line no-type-assertion/no-type-assertion
         token: options.token,
+        // eslint-disable-next-line no-type-assertion/no-type-assertion
         configPath: options.config,
+        // eslint-disable-next-line no-type-assertion/no-type-assertion
         verbose: options.verbose,
+        // eslint-disable-next-line no-type-assertion/no-type-assertion
         silent: options.silent
       });
-    } catch (error) {
-      logger.error(formatError(error));
-      process.exit(1);
-    }
-  });
+    })
+  );
   program.command("generate").description("Generate configuration files for AI tools").option(
     "-t, --targets <tools>",
     "Comma-separated list of tools to generate for (e.g., 'copilot,cursor,cline' or '*' for all)",
-    (value) => {
-      return value.split(",").map((t) => t.trim());
-    }
+    (value) => value.split(",").map((t) => t.trim())
   ).option(
     "-f, --features <features>",
     `Comma-separated list of features to generate (${ALL_FEATURES.join(",")}) or '*' for all`,
-    (value) => {
-      return value.split(",").map((f) => f.trim());
-    }
+    (value) => value.split(",").map((f) => f.trim())
   ).option("--delete", "Delete all existing files in output directories before generating").option(
     "-b, --base-dir <paths>",
     "Base directories to generate files (comma-separated for multiple paths)",
-    (value) => {
-      return value.split(",").map((p) => p.trim());
-    }
+    (value) => value.split(",").map((p) => p.trim())
   ).option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").option("-c, --config <path>", "Path to configuration file").option("-g, --global", "Generate for global(user scope) configuration files").option(
     "--simulate-commands",
     "Generate simulated commands. This feature is only available for copilot, cursor and codexcli."
@@ -21358,40 +21594,19 @@ var main = async () => {
   ).option(
     "--simulate-skills",
     "Generate simulated skills. This feature is only available for copilot, cursor and codexcli."
-  ).option("--dry-run", "Dry run: show changes without writing files").option("--check", "Check if files are up to date (exits with code 1 if changes needed)").action(async (options) => {
-    try {
-      await generateCommand({
-        targets: options.targets,
-        features: options.features,
-        verbose: options.verbose,
-        silent: options.silent,
-        delete: options.delete,
-        baseDirs: options.baseDir,
-        configPath: options.config,
-        global: options.global,
-        simulateCommands: options.simulateCommands,
-        simulateSubagents: options.simulateSubagents,
-        simulateSkills: options.simulateSkills,
-        dryRun: options.dryRun,
-        check: options.check
-      });
-    } catch (error) {
-      logger.error(formatError(error));
-      process.exit(1);
-    }
-  });
-  program.command("update").description("Update rulesync to the latest version").option("--check", "Check for updates without installing").option("--force", "Force update even if already at latest version").option("--token <token>", "GitHub token for API access").option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").action(async (options) => {
-    await updateCommand(version, {
-      check: options.check,
-      force: options.force,
-      token: options.token,
-      verbose: options.verbose,
-      silent: options.silent
-    });
-  });
+  ).option("--dry-run", "Dry run: show changes without writing files").option("--check", "Check if files are up to date (exits with code 1 if changes needed)").action(
+    wrapCommand("generate", "GENERATION_FAILED", async (logger2, options) => {
+      await generateCommand(logger2, options);
+    })
+  );
+  program.command("update").description("Update rulesync to the latest version").option("--check", "Check for updates without installing").option("--force", "Force update even if already at latest version").option("--token <token>", "GitHub token for API access").option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").action(
+    wrapCommand("update", "UPDATE_FAILED", async (logger2, options) => {
+      await updateCommand(logger2, version, options);
+    })
+  );
   program.parse();
 };
 main().catch((error) => {
-  logger.error(formatError(error));
+  console.error(formatError(error));
   process.exit(1);
 });