rulesync 7.20.0 → 7.22.0

package/dist/cli/index.js

@@ -28,6 +28,7 @@ import {
   RULESYNC_MCP_RELATIVE_FILE_PATH,
   RULESYNC_MCP_SCHEMA_URL,
   RULESYNC_OVERVIEW_FILE_NAME,
+  RULESYNC_PERMISSIONS_FILE_NAME,
   RULESYNC_RELATIVE_DIR_PATH,
   RULESYNC_RULES_RELATIVE_DIR_PATH,
   RULESYNC_SKILLS_RELATIVE_DIR_PATH,
@@ -63,18 +64,20 @@ import {
   importFromTool,
   isSymlink,
   listDirectoryFiles,
-  logger,
   readFileContent,
   removeDirectory,
   removeFile,
   removeTempDirectory,
   stringifyFrontmatter,
   writeFileContent
-} from "../chunk-5OPNV62F.js";
+} from "../chunk-4WYBBN4I.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
 
+// src/utils/parse-comma-separated-list.ts
+var parseCommaSeparatedList = (value) => value.split(",").map((s) => s.trim()).filter(Boolean);
+
 // src/lib/fetch.ts
 import { join } from "path";
 import { Semaphore } from "es-toolkit/promise";
@@ -140,13 +143,14 @@ var GitHubClientError = class extends Error {
     this.name = "GitHubClientError";
   }
 };
-function logGitHubAuthHints(error) {
-  logger.error(`GitHub API Error: ${error.message}`);
+function logGitHubAuthHints(params) {
+  const { error, logger: logger5 } = params;
+  logger5.error(`GitHub API Error: ${error.message}`);
   if (error.statusCode === 401 || error.statusCode === 403) {
-    logger.info(
+    logger5.info(
       "Tip: Set GITHUB_TOKEN or GH_TOKEN environment variable for private repositories or better rate limits."
     );
-    logger.info(
+    logger5.info(
       "Tip: If you use GitHub CLI, you can use `GITHUB_TOKEN=$(gh auth token) rulesync fetch ...`"
     );
   }
@@ -534,7 +538,8 @@ var FEATURE_PATHS = {
   skills: ["skills"],
   ignore: [RULESYNC_AIIGNORE_FILE_NAME],
   mcp: [RULESYNC_MCP_FILE_NAME],
-  hooks: [RULESYNC_HOOKS_FILE_NAME]
+  hooks: [RULESYNC_HOOKS_FILE_NAME],
+  permissions: [RULESYNC_PERMISSIONS_FILE_NAME]
 };
 function isToolTarget(target) {
   return target !== "rulesync";
@@ -563,38 +568,38 @@ async function processFeatureConversion(params) {
   return { paths };
 }
 async function convertFetchedFilesToRulesync(params) {
-  const { tempDir, outputDir, target, features } = params;
+  const { tempDir, outputDir, target, features, logger: logger5 } = params;
   const convertedPaths = [];
   const featureConfigs = [
     {
       feature: "rules",
       getTargets: () => RulesProcessor.getToolTargets({ global: false }),
-      createProcessor: () => new RulesProcessor({ baseDir: tempDir, toolTarget: target, global: false })
+      createProcessor: () => new RulesProcessor({ baseDir: tempDir, toolTarget: target, global: false, logger: logger5 })
     },
     {
       feature: "commands",
       getTargets: () => CommandsProcessor.getToolTargets({ global: false, includeSimulated: false }),
-      createProcessor: () => new CommandsProcessor({ baseDir: tempDir, toolTarget: target, global: false })
+      createProcessor: () => new CommandsProcessor({ baseDir: tempDir, toolTarget: target, global: false, logger: logger5 })
     },
     {
       feature: "subagents",
       getTargets: () => SubagentsProcessor.getToolTargets({ global: false, includeSimulated: false }),
-      createProcessor: () => new SubagentsProcessor({ baseDir: tempDir, toolTarget: target, global: false })
+      createProcessor: () => new SubagentsProcessor({ baseDir: tempDir, toolTarget: target, global: false, logger: logger5 })
     },
     {
       feature: "ignore",
       getTargets: () => IgnoreProcessor.getToolTargets(),
-      createProcessor: () => new IgnoreProcessor({ baseDir: tempDir, toolTarget: target })
+      createProcessor: () => new IgnoreProcessor({ baseDir: tempDir, toolTarget: target, logger: logger5 })
     },
     {
       feature: "mcp",
       getTargets: () => McpProcessor.getToolTargets({ global: false }),
-      createProcessor: () => new McpProcessor({ baseDir: tempDir, toolTarget: target, global: false })
+      createProcessor: () => new McpProcessor({ baseDir: tempDir, toolTarget: target, global: false, logger: logger5 })
     },
     {
       feature: "hooks",
       getTargets: () => HooksProcessor.getToolTargets({ global: false }),
-      createProcessor: () => new HooksProcessor({ baseDir: tempDir, toolTarget: target, global: false })
+      createProcessor: () => new HooksProcessor({ baseDir: tempDir, toolTarget: target, global: false, logger: logger5 })
     }
   ];
   for (const config of featureConfigs) {
@@ -610,7 +615,7 @@ async function convertFetchedFilesToRulesync(params) {
     convertedPaths.push(...result.paths);
   }
   if (features.includes("skills")) {
-    logger.debug(
+    logger5.debug(
       "Skills conversion is not yet supported in fetch command. Use import command instead."
     );
   }
@@ -639,7 +644,7 @@ function isNotFoundError(error) {
   return false;
 }
 async function fetchFiles(params) {
-  const { source, options = {}, baseDir = process.cwd() } = params;
+  const { source, options = {}, baseDir = process.cwd(), logger: logger5 } = params;
   const parsed = parseSource(source);
   if (parsed.provider === "gitlab") {
     throw new Error(
@@ -658,7 +663,7 @@ async function fetchFiles(params) {
   });
   const token = GitHubClient.resolveToken(options.token);
   const client = new GitHubClient({ token });
-  logger.debug(`Validating repository: ${parsed.owner}/${parsed.repo}`);
+  logger5.debug(`Validating repository: ${parsed.owner}/${parsed.repo}`);
   const isValid = await client.validateRepository(parsed.owner, parsed.repo);
   if (!isValid) {
     throw new GitHubClientError(
@@ -667,7 +672,7 @@ async function fetchFiles(params) {
     );
   }
   const ref = resolvedRef ?? await client.getDefaultBranch(parsed.owner, parsed.repo);
-  logger.debug(`Using ref: ${ref}`);
+  logger5.debug(`Using ref: ${ref}`);
   if (isToolTarget(target)) {
     return fetchAndConvertToolFiles({
       client,
@@ -678,7 +683,8 @@ async function fetchFiles(params) {
       target,
       outputDir,
       baseDir,
-      conflictStrategy
+      conflictStrategy,
+      logger: logger5
     });
   }
   const semaphore = new Semaphore(FETCH_CONCURRENCY_LIMIT);
@@ -689,10 +695,11 @@ async function fetchFiles(params) {
     basePath: resolvedPath,
     ref,
     enabledFeatures,
-    semaphore
+    semaphore,
+    logger: logger5
   });
   if (filesToFetch.length === 0) {
-    logger.warn(`No files found matching enabled features: ${enabledFeatures.join(", ")}`);
+    logger5.warn(`No files found matching enabled features: ${enabledFeatures.join(", ")}`);
     return {
       source: `${parsed.owner}/${parsed.repo}`,
       ref,
@@ -715,7 +722,7 @@ async function fetchFiles(params) {
       const localPath = join(outputBasePath, relativePath);
       const exists = await fileExists(localPath);
       if (exists && conflictStrategy === "skip") {
-        logger.debug(`Skipping existing file: ${relativePath}`);
+        logger5.debug(`Skipping existing file: ${relativePath}`);
         return { relativePath, status: "skipped" };
       }
       const content = await withSemaphore(
@@ -724,7 +731,7 @@ async function fetchFiles(params) {
       );
       await writeFileContent(localPath, content);
       const status = exists ? "overwritten" : "created";
-      logger.debug(`Wrote: ${relativePath} (${status})`);
+      logger5.debug(`Wrote: ${relativePath} (${status})`);
       return { relativePath, status };
     })
   );
@@ -739,7 +746,7 @@ async function fetchFiles(params) {
   return summary;
 }
 async function collectFeatureFiles(params) {
-  const { client, owner, repo, basePath, ref, enabledFeatures, semaphore } = params;
+  const { client, owner, repo, basePath, ref, enabledFeatures, semaphore, logger: logger5 } = params;
   const dirCache = /* @__PURE__ */ new Map();
   async function getCachedDirectory(path2) {
     let promise = dirCache.get(path2);
@@ -772,7 +779,7 @@ async function collectFeatureFiles(params) {
             }
           } catch (error) {
             if (isNotFoundError(error)) {
-              logger.debug(`File not found: ${fullPath}`);
+              logger5.debug(`File not found: ${fullPath}`);
             } else {
               throw error;
             }
@@ -797,7 +804,7 @@ async function collectFeatureFiles(params) {
         }
       } catch (error) {
         if (isNotFoundError(error)) {
-          logger.debug(`Feature not found: ${fullPath}`);
+          logger5.debug(`Feature not found: ${fullPath}`);
           return collected;
         }
         throw error;
@@ -817,10 +824,11 @@ async function fetchAndConvertToolFiles(params) {
     target,
     outputDir,
     baseDir,
-    conflictStrategy: _conflictStrategy
+    conflictStrategy: _conflictStrategy,
+    logger: logger5
   } = params;
   const tempDir = await createTempDirectory();
-  logger.debug(`Created temp directory: ${tempDir}`);
+  logger5.debug(`Created temp directory: ${tempDir}`);
   const semaphore = new Semaphore(FETCH_CONCURRENCY_LIMIT);
   try {
     const filesToFetch = await collectFeatureFiles({
@@ -830,10 +838,11 @@ async function fetchAndConvertToolFiles(params) {
       basePath: resolvedPath,
       ref,
       enabledFeatures,
-      semaphore
+      semaphore,
+      logger: logger5
     });
     if (filesToFetch.length === 0) {
-      logger.warn(`No files found matching enabled features: ${enabledFeatures.join(", ")}`);
+      logger5.warn(`No files found matching enabled features: ${enabledFeatures.join(", ")}`);
       return {
         source: `${parsed.owner}/${parsed.repo}`,
         ref,
@@ -860,7 +869,7 @@ async function fetchAndConvertToolFiles(params) {
           () => client.getFileContent(parsed.owner, parsed.repo, remotePath, ref)
         );
         await writeFileContent(localPath, content);
-        logger.debug(`Fetched to temp: ${toolRelativePath}`);
+        logger5.debug(`Fetched to temp: ${toolRelativePath}`);
       })
     );
     const outputBasePath = join(baseDir, outputDir);
@@ -868,13 +877,14 @@ async function fetchAndConvertToolFiles(params) {
       tempDir,
       outputDir: outputBasePath,
       target,
-      features: enabledFeatures
+      features: enabledFeatures,
+      logger: logger5
     });
     const results = convertedPaths.map((relativePath) => ({
       relativePath,
       status: "created"
     }));
-    logger.debug(`Converted ${converted} files from ${target} format to rulesync format`);
+    logger5.debug(`Converted ${converted} files from ${target} format to rulesync format`);
     return {
       source: `${parsed.owner}/${parsed.repo}`,
       ref,
@@ -981,29 +991,30 @@ function formatFetchSummary(summary) {
 }
 
 // src/cli/commands/fetch.ts
-async function fetchCommand(logger2, options) {
+async function fetchCommand(logger5, options) {
   const { source, ...fetchOptions } = options;
-  logger2.debug(`Fetching files from ${source}...`);
+  logger5.debug(`Fetching files from ${source}...`);
   try {
     const summary = await fetchFiles({
       source,
-      options: fetchOptions
+      options: fetchOptions,
+      logger: logger5
     });
-    if (logger2.jsonMode) {
+    if (logger5.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);
+      logger5.captureData("source", source);
+      logger5.captureData("path", fetchOptions.path);
+      logger5.captureData("created", createdFiles);
+      logger5.captureData("overwritten", overwrittenFiles);
+      logger5.captureData("skipped", skippedFiles);
+      logger5.captureData("totalFetched", summary.created + summary.overwritten + summary.skipped);
     }
     const output = formatFetchSummary(summary);
-    logger2.success(output);
+    logger5.success(output);
     if (summary.created + summary.overwritten === 0 && summary.skipped === 0) {
-      logger2.warn("No files were fetched.");
+      logger5.warn("No files were fetched.");
     }
   } catch (error) {
     if (error instanceof GitHubClientError) {
@@ -1020,55 +1031,55 @@ function calculateTotalCount(result) {
 }
 
 // src/cli/commands/generate.ts
-function logFeatureResult(logger2, params) {
+function logFeatureResult(logger5, params) {
   const { count, paths, featureName, isPreview, modePrefix } = params;
   if (count > 0) {
     if (isPreview) {
-      logger2.info(`${modePrefix} Would write ${count} ${featureName}`);
+      logger5.info(`${modePrefix} Would write ${count} ${featureName}`);
     } else {
-      logger2.success(`Written ${count} ${featureName}`);
+      logger5.success(`Written ${count} ${featureName}`);
     }
     for (const p of paths) {
-      logger2.info(`    ${p}`);
+      logger5.info(`    ${p}`);
     }
   }
 }
-async function generateCommand(logger2, options) {
+async function generateCommand(logger5, options) {
   const config = await ConfigResolver.resolve(options);
   const check = config.getCheck();
   const isPreview = config.isPreviewMode();
   const modePrefix = isPreview ? "[DRY RUN]" : "";
-  logger2.debug("Generating files...");
+  logger5.debug("Generating files...");
   if (!await checkRulesyncDirExists({ baseDir: process.cwd() })) {
     throw new CLIError(
       ".rulesync directory not found. Run 'rulesync init' first.",
       ErrorCodes.RULESYNC_DIR_NOT_FOUND
     );
   }
-  logger2.debug(`Base directories: ${config.getBaseDirs().join(", ")}`);
+  logger5.debug(`Base directories: ${config.getBaseDirs().join(", ")}`);
   const features = config.getFeatures();
   if (features.includes("ignore")) {
-    logger2.debug("Generating ignore files...");
+    logger5.debug("Generating ignore files...");
   }
   if (features.includes("mcp")) {
-    logger2.debug("Generating MCP files...");
+    logger5.debug("Generating MCP files...");
   }
   if (features.includes("commands")) {
-    logger2.debug("Generating command files...");
+    logger5.debug("Generating command files...");
   }
   if (features.includes("subagents")) {
-    logger2.debug("Generating subagent files...");
+    logger5.debug("Generating subagent files...");
   }
   if (features.includes("skills")) {
-    logger2.debug("Generating skill files...");
+    logger5.debug("Generating skill files...");
   }
   if (features.includes("hooks")) {
-    logger2.debug("Generating hooks...");
+    logger5.debug("Generating hooks...");
   }
   if (features.includes("rules")) {
-    logger2.debug("Generating rule files...");
+    logger5.debug("Generating rule files...");
   }
-  const result = await generate({ config });
+  const result = await generate({ config, logger: logger5 });
   const totalGenerated = calculateTotalCount(result);
   const featureResults = {
     ignore: { count: result.ignoreCount, paths: result.ignorePaths },
@@ -1089,7 +1100,7 @@ async function generateCommand(logger2, options) {
     hooks: (count) => `${count === 1 ? "hooks file" : "hooks files"}`
   };
   for (const [feature, data] of Object.entries(featureResults)) {
-    logFeatureResult(logger2, {
+    logFeatureResult(logger5, {
       count: data.count,
       paths: data.paths,
       featureName: featureLabels[feature]?.(data.count) ?? feature,
@@ -1097,15 +1108,15 @@ async function generateCommand(logger2, options) {
       modePrefix
     });
   }
-  if (logger2.jsonMode) {
-    logger2.captureData("features", featureResults);
-    logger2.captureData("totalFiles", totalGenerated);
-    logger2.captureData("hasDiff", result.hasDiff);
-    logger2.captureData("skills", result.skills ?? []);
+  if (logger5.jsonMode) {
+    logger5.captureData("features", featureResults);
+    logger5.captureData("totalFiles", totalGenerated);
+    logger5.captureData("hasDiff", result.hasDiff);
+    logger5.captureData("skills", result.skills ?? []);
   }
   if (totalGenerated === 0) {
     const enabledFeatures = features.join(", ");
-    logger2.info(`\u2713 All files are up to date (${enabledFeatures})`);
+    logger5.info(`\u2713 All files are up to date (${enabledFeatures})`);
     return;
   }
   const parts = [];
@@ -1117,9 +1128,9 @@ async function generateCommand(logger2, options) {
   if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
   if (result.hooksCount > 0) parts.push(`${result.hooksCount} hooks`);
   if (isPreview) {
-    logger2.info(`${modePrefix} Would write ${totalGenerated} file(s) total (${parts.join(" + ")})`);
+    logger5.info(`${modePrefix} Would write ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   } else {
-    logger2.success(`\u{1F389} All done! Written ${totalGenerated} file(s) total (${parts.join(" + ")})`);
+    logger5.success(`\u{1F389} All done! Written ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   }
   if (check) {
     if (result.hasDiff) {
@@ -1128,7 +1139,7 @@ async function generateCommand(logger2, options) {
         ErrorCodes.GENERATION_FAILED
       );
     } else {
-      logger2.success("\u2713 All files are up to date.");
+      logger5.success("\u2713 All files are up to date.");
     }
   }
 }
@@ -1202,6 +1213,8 @@ var GITIGNORE_ENTRY_REGISTRY = [
   { target: "copilot", feature: "skills", entry: "**/.github/skills/" },
   { target: "copilot", feature: "hooks", entry: "**/.github/hooks/" },
   { target: "copilot", feature: "mcp", entry: "**/.vscode/mcp.json" },
+  // GitHub Copilot CLI
+  { target: "copilotcli", feature: "mcp", entry: "**/.copilot/mcp-config.json" },
   // Junie
   { target: "junie", feature: "rules", entry: "**/.junie/guidelines.md" },
   { target: "junie", feature: "mcp", entry: "**/.junie/mcp.json" },
@@ -1264,46 +1277,47 @@ var isFeatureSelected = (feature, target, features) => {
   if (targetFeatures.includes("*")) return true;
   return targetFeatures.includes(feature);
 };
-var warnInvalidTargets = (targets) => {
+var warnInvalidTargets = (targets, logger5) => {
   const validTargets = new Set(ALL_TOOL_TARGETS_WITH_WILDCARD);
   for (const target of targets) {
     if (!validTargets.has(target)) {
-      logger.warn(
+      logger5?.warn(
         `Unknown target '${target}'. Valid targets: ${ALL_TOOL_TARGETS_WITH_WILDCARD.join(", ")}`
       );
     }
   }
 };
-var warnInvalidFeatures = (features) => {
+var warnInvalidFeatures = (features, logger5) => {
   const validFeatures = new Set(ALL_FEATURES_WITH_WILDCARD);
+  const warned = /* @__PURE__ */ new Set();
+  const warnOnce = (feature) => {
+    if (!validFeatures.has(feature) && !warned.has(feature)) {
+      warned.add(feature);
+      logger5?.warn(
+        `Unknown feature '${feature}'. Valid features: ${ALL_FEATURES_WITH_WILDCARD.join(", ")}`
+      );
+    }
+  };
   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(", ")}`
-        );
-      }
+      warnOnce(feature);
     }
   } 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(", ")}`
-          );
-        }
+        warnOnce(feature);
       }
     }
   }
 };
 var filterGitignoreEntries = (params) => {
-  const { targets, features } = params ?? {};
+  const { targets, features, logger: logger5 } = params ?? {};
   if (targets && targets.length > 0) {
-    warnInvalidTargets(targets);
+    warnInvalidTargets(targets, logger5);
   }
   if (features) {
-    warnInvalidFeatures(features);
+    warnInvalidFeatures(features, logger5);
   }
   const seen = /* @__PURE__ */ new Set();
   const result = [];
@@ -1369,7 +1383,7 @@ var removeExistingRulesyncEntries = (content) => {
   }
   return result;
 };
-var gitignoreCommand = async (logger2, options) => {
+var gitignoreCommand = async (logger5, options) => {
   const gitignorePath = join2(process.cwd(), ".gitignore");
   let gitignoreContent = "";
   if (await fileExists(gitignorePath)) {
@@ -1378,7 +1392,8 @@ var gitignoreCommand = async (logger2, options) => {
   const cleanedContent = removeExistingRulesyncEntries(gitignoreContent);
   const filteredEntries = filterGitignoreEntries({
     targets: options?.targets,
-    features: options?.features
+    features: options?.features,
+    logger: logger5
   });
   const existingEntries = new Set(
     gitignoreContent.split("\n").map((line) => line.trim()).filter((line) => line !== "" && !isRulesyncHeader(line))
@@ -1392,37 +1407,37 @@ ${rulesyncBlock}
 ` : `${rulesyncBlock}
 `;
   if (gitignoreContent === newContent) {
-    if (logger2.jsonMode) {
-      logger2.captureData("entriesAdded", []);
-      logger2.captureData("gitignorePath", gitignorePath);
-      logger2.captureData("alreadyExisted", filteredEntries);
+    if (logger5.jsonMode) {
+      logger5.captureData("entriesAdded", []);
+      logger5.captureData("gitignorePath", gitignorePath);
+      logger5.captureData("alreadyExisted", filteredEntries);
     }
-    logger2.success(".gitignore is already up to date");
+    logger5.success(".gitignore is already up to date");
     return;
   }
   await writeFileContent(gitignorePath, newContent);
-  if (logger2.jsonMode) {
-    logger2.captureData("entriesAdded", entriesToAdd);
-    logger2.captureData("gitignorePath", gitignorePath);
-    logger2.captureData("alreadyExisted", alreadyExistedEntries);
+  if (logger5.jsonMode) {
+    logger5.captureData("entriesAdded", entriesToAdd);
+    logger5.captureData("gitignorePath", gitignorePath);
+    logger5.captureData("alreadyExisted", alreadyExistedEntries);
   }
-  logger2.success("Updated .gitignore with rulesync entries:");
+  logger5.success("Updated .gitignore with rulesync entries:");
   for (const entry of filteredEntries) {
-    logger2.info(`  ${entry}`);
+    logger5.info(`  ${entry}`);
   }
-  logger2.info("");
-  logger2.info(
+  logger5.info("");
+  logger5.info(
     "\u{1F4A1} If you're using Google Antigravity, note that rules, workflows, and skills won't load if they're gitignored."
   );
-  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");
+  logger5.info("   You can add the following to .git/info/exclude instead:");
+  logger5.info("   **/.agent/rules/");
+  logger5.info("   **/.agent/workflows/");
+  logger5.info("   **/.agent/skills/");
+  logger5.info("   For more details: https://github.com/dyoshikawa/rulesync/issues/981");
 };
 
 // src/cli/commands/import.ts
-async function importCommand(logger2, options) {
+async function importCommand(logger5, options) {
   if (!options.targets) {
     throw new CLIError("No tools found in --targets", ErrorCodes.IMPORT_FAILED);
   }
@@ -1431,17 +1446,17 @@ async function importCommand(logger2, options) {
   }
   const config = await ConfigResolver.resolve(options);
   const tool = config.getTargets()[0];
-  logger2.debug(`Importing files from ${tool}...`);
-  const result = await importFromTool({ config, tool });
+  logger5.debug(`Importing files from ${tool}...`);
+  const result = await importFromTool({ config, tool, logger: logger5 });
   const totalImported = calculateTotalCount(result);
   if (totalImported === 0) {
     const enabledFeatures = config.getFeatures().join(", ");
-    logger2.warn(`No files imported for enabled features: ${enabledFeatures}`);
+    logger5.warn(`No files imported for enabled features: ${enabledFeatures}`);
     return;
   }
-  if (logger2.jsonMode) {
-    logger2.captureData("tool", tool);
-    logger2.captureData("features", {
+  if (logger5.jsonMode) {
+    logger5.captureData("tool", tool);
+    logger5.captureData("features", {
       rules: { count: result.rulesCount },
       ignore: { count: result.ignoreCount },
       mcp: { count: result.mcpCount },
@@ -1450,7 +1465,7 @@ async function importCommand(logger2, options) {
       skills: { count: result.skillsCount },
       hooks: { count: result.hooksCount }
     });
-    logger2.captureData("totalFiles", totalImported);
+    logger5.captureData("totalFiles", totalImported);
   }
   const parts = [];
   if (result.rulesCount > 0) parts.push(`${result.rulesCount} rules`);
@@ -1460,7 +1475,7 @@ async function importCommand(logger2, 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`);
-  logger2.success(`Imported ${totalImported} file(s) total (${parts.join(" + ")})`);
+  logger5.success(`Imported ${totalImported} file(s) total (${parts.join(" + ")})`);
 }
 
 // src/lib/init.ts
@@ -1689,8 +1704,8 @@ async function writeIfNotExists(path2, content) {
 }
 
 // src/cli/commands/init.ts
-async function initCommand(logger2) {
-  logger2.debug("Initializing rulesync...");
+async function initCommand(logger5) {
+  logger5.debug("Initializing rulesync...");
   await ensureDir(RULESYNC_RELATIVE_DIR_PATH);
   const result = await init();
   const createdFiles = [];
@@ -1698,29 +1713,29 @@ async function initCommand(logger2) {
   for (const file of result.sampleFiles) {
     if (file.created) {
       createdFiles.push(file.path);
-      logger2.success(`Created ${file.path}`);
+      logger5.success(`Created ${file.path}`);
     } else {
       skippedFiles.push(file.path);
-      logger2.info(`Skipped ${file.path} (already exists)`);
+      logger5.info(`Skipped ${file.path} (already exists)`);
     }
   }
   if (result.configFile.created) {
     createdFiles.push(result.configFile.path);
-    logger2.success(`Created ${result.configFile.path}`);
+    logger5.success(`Created ${result.configFile.path}`);
   } else {
     skippedFiles.push(result.configFile.path);
-    logger2.info(`Skipped ${result.configFile.path} (already exists)`);
+    logger5.info(`Skipped ${result.configFile.path} (already exists)`);
   }
-  if (logger2.jsonMode) {
-    logger2.captureData("created", createdFiles);
-    logger2.captureData("skipped", skippedFiles);
+  if (logger5.jsonMode) {
+    logger5.captureData("created", createdFiles);
+    logger5.captureData("skipped", skippedFiles);
   }
-  logger2.success("rulesync initialized successfully!");
-  logger2.info("Next steps:");
-  logger2.info(
+  logger5.success("rulesync initialized successfully!");
+  logger5.info("Next steps:");
+  logger5.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}`
   );
-  logger2.info("2. Run 'rulesync generate' to create configuration files");
+  logger5.info("2. Run 'rulesync generate' to create configuration files");
 }
 
 // src/lib/sources.ts
@@ -1741,7 +1756,7 @@ var GitClientError = class extends Error {
     this.name = "GitClientError";
   }
 };
-function validateGitUrl(url) {
+function validateGitUrl(url, options) {
   const ctrl = findControlCharacter(url);
   if (ctrl) {
     throw new GitClientError(
@@ -1754,7 +1769,7 @@ function validateGitUrl(url) {
     );
   }
   if (INSECURE_URL_SCHEMES.test(url)) {
-    logger.warn(
+    options?.logger?.warn(
       `URL "${url}" uses an unencrypted protocol. Consider using https:// or ssh:// instead.`
     );
   }
@@ -1814,8 +1829,8 @@ async function resolveRefToSha(url, ref) {
   }
 }
 async function fetchSkillFiles(params) {
-  const { url, ref, skillsPath } = params;
-  validateGitUrl(url);
+  const { url, ref, skillsPath, logger: logger5 } = params;
+  validateGitUrl(url, { logger: logger5 });
   validateRef(ref);
   if (skillsPath.split(/[/\\]/).includes("..") || isAbsolute(skillsPath)) {
     throw new GitClientError(
@@ -1853,7 +1868,7 @@ async function fetchSkillFiles(params) {
     await execFileAsync("git", ["-C", tmpDir, "checkout"], { timeout: GIT_TIMEOUT_MS });
     const skillsDir = join4(tmpDir, skillsPath);
     if (!await directoryExists(skillsDir)) return [];
-    return await walkDirectory(skillsDir, skillsDir);
+    return await walkDirectory(skillsDir, skillsDir, 0, { totalFiles: 0, totalSize: 0 }, logger5);
   } catch (error) {
     if (error instanceof GitClientError) throw error;
     throw new GitClientError(`Failed to fetch skill files from ${url}`, error);
@@ -1864,7 +1879,7 @@ async function fetchSkillFiles(params) {
 var MAX_WALK_DEPTH = 20;
 var MAX_TOTAL_FILES = 1e4;
 var MAX_TOTAL_SIZE = 100 * 1024 * 1024;
-async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, totalSize: 0 }) {
+async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, totalSize: 0 }, logger5) {
   if (depth > MAX_WALK_DEPTH) {
     throw new GitClientError(
       `Directory tree exceeds max depth of ${MAX_WALK_DEPTH}: "${dir}". Aborting to prevent resource exhaustion.`
@@ -1875,15 +1890,15 @@ async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, tot
     if (name === ".git") continue;
     const fullPath = join4(dir, name);
     if (await isSymlink(fullPath)) {
-      logger.warn(`Skipping symlink "${fullPath}".`);
+      logger5?.warn(`Skipping symlink "${fullPath}".`);
       continue;
     }
     if (await directoryExists(fullPath)) {
-      results.push(...await walkDirectory(fullPath, baseDir, depth + 1, ctx));
+      results.push(...await walkDirectory(fullPath, baseDir, depth + 1, ctx, logger5));
     } else {
       const size = await getFileSize(fullPath);
       if (size > MAX_FILE_SIZE) {
-        logger.warn(
+        logger5?.warn(
           `Skipping file "${fullPath}" (${(size / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit).`
         );
         continue;
@@ -1932,7 +1947,8 @@ var LegacyLockedSourceSchema = z4.object({
 var LegacySourcesLockSchema = z4.object({
   sources: z4.record(z4.string(), LegacyLockedSourceSchema)
 });
-function migrateLegacyLock(legacy) {
+function migrateLegacyLock(params) {
+  const { legacy, logger: logger5 } = params;
   const sources = {};
   for (const [key, entry] of Object.entries(legacy.sources)) {
     const skills = {};
@@ -1944,7 +1960,7 @@ function migrateLegacyLock(legacy) {
       skills
     };
   }
-  logger.info(
+  logger5.info(
     "Migrated legacy sources lockfile to version 1. Run 'rulesync install --update' to populate integrity hashes."
   );
   return { lockfileVersion: LOCKFILE_VERSION, sources };
@@ -1953,9 +1969,10 @@ function createEmptyLock() {
   return { lockfileVersion: LOCKFILE_VERSION, sources: {} };
 }
 async function readLockFile(params) {
+  const { logger: logger5 } = params;
   const lockPath = join5(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
   if (!await fileExists(lockPath)) {
-    logger.debug("No sources lockfile found, starting fresh.");
+    logger5.debug("No sources lockfile found, starting fresh.");
     return createEmptyLock();
   }
   try {
@@ -1967,24 +1984,25 @@ async function readLockFile(params) {
     }
     const legacyResult = LegacySourcesLockSchema.safeParse(data);
     if (legacyResult.success) {
-      return migrateLegacyLock(legacyResult.data);
+      return migrateLegacyLock({ legacy: legacyResult.data, logger: logger5 });
     }
-    logger.warn(
+    logger5.warn(
       `Invalid sources lockfile format (${RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH}). Starting fresh.`
     );
     return createEmptyLock();
   } catch {
-    logger.warn(
+    logger5.warn(
       `Failed to read sources lockfile (${RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH}). Starting fresh.`
     );
     return createEmptyLock();
   }
 }
 async function writeLockFile(params) {
+  const { logger: logger5 } = params;
   const lockPath = join5(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
   const content = JSON.stringify(params.lock, null, 2) + "\n";
   await writeFileContent(lockPath, content);
-  logger.debug(`Wrote sources lockfile to ${lockPath}`);
+  logger5.debug(`Wrote sources lockfile to ${lockPath}`);
 }
 function computeSkillIntegrity(files) {
   const hash = createHash("sha256");
@@ -2056,15 +2074,15 @@ function getLockedSkillNames(entry) {
 
 // src/lib/sources.ts
 async function resolveAndFetchSources(params) {
-  const { sources, baseDir, options = {} } = params;
+  const { sources, baseDir, options = {}, logger: logger5 } = params;
   if (sources.length === 0) {
     return { fetchedSkillCount: 0, sourcesProcessed: 0 };
   }
   if (options.skipSources) {
-    logger.info("Skipping source fetching.");
+    logger5.info("Skipping source fetching.");
     return { fetchedSkillCount: 0, sourcesProcessed: 0 };
   }
-  let lock = options.updateSources ? createEmptyLock() : await readLockFile({ baseDir });
+  let lock = options.updateSources ? createEmptyLock() : await readLockFile({ baseDir, logger: logger5 });
   if (options.frozen) {
     const missingKeys = [];
     for (const source of sources) {
@@ -2097,7 +2115,8 @@ async function resolveAndFetchSources(params) {
           localSkillNames,
           alreadyFetchedSkillNames: allFetchedSkillNames,
           updateSources: options.updateSources ?? false,
-          frozen: options.frozen ?? false
+          frozen: options.frozen ?? false,
+          logger: logger5
         });
       } else {
         result = await fetchSource({
@@ -2107,7 +2126,8 @@ async function resolveAndFetchSources(params) {
           lock,
           localSkillNames,
           alreadyFetchedSkillNames: allFetchedSkillNames,
-          updateSources: options.updateSources ?? false
+          updateSources: options.updateSources ?? false,
+          logger: logger5
         });
       }
       const { skillCount, fetchedSkillNames, updatedLock } = result;
@@ -2117,11 +2137,11 @@ async function resolveAndFetchSources(params) {
         allFetchedSkillNames.add(name);
       }
     } catch (error) {
-      logger.error(`Failed to fetch source "${sourceEntry.source}": ${formatError(error)}`);
+      logger5.error(`Failed to fetch source "${sourceEntry.source}": ${formatError(error)}`);
       if (error instanceof GitHubClientError) {
-        logGitHubAuthHints(error);
+        logGitHubAuthHints({ error, logger: logger5 });
       } else if (error instanceof GitClientError) {
-        logGitClientHints(error);
+        logGitClientHints({ error, logger: logger5 });
       }
     }
   }
@@ -2131,22 +2151,23 @@ async function resolveAndFetchSources(params) {
     if (sourceKeys.has(normalizeSourceKey(key))) {
       prunedSources[key] = value;
     } else {
-      logger.debug(`Pruned stale lockfile entry: ${key}`);
+      logger5.debug(`Pruned stale lockfile entry: ${key}`);
     }
   }
   lock = { lockfileVersion: lock.lockfileVersion, sources: prunedSources };
   if (!options.frozen && JSON.stringify(lock) !== originalLockJson) {
-    await writeLockFile({ baseDir, lock });
+    await writeLockFile({ baseDir, lock, logger: logger5 });
   } else {
-    logger.debug("Lockfile unchanged, skipping write.");
+    logger5.debug("Lockfile unchanged, skipping write.");
   }
   return { fetchedSkillCount: totalSkillCount, sourcesProcessed: sources.length };
 }
-function logGitClientHints(error) {
+function logGitClientHints(params) {
+  const { error, logger: logger5 } = params;
   if (error.message.includes("not installed")) {
-    logger.info("Hint: Install git and ensure it is available on your PATH.");
+    logger5.info("Hint: Install git and ensure it is available on your PATH.");
   } else {
-    logger.info("Hint: Check your git credentials (SSH keys, credential helper, or access token).");
+    logger5.info("Hint: Check your git credentials (SSH keys, credential helper, or access token).");
   }
 }
 async function checkLockedSkillsExist(curatedDir, skillNames) {
@@ -2158,12 +2179,13 @@ async function checkLockedSkillsExist(curatedDir, skillNames) {
   }
   return true;
 }
-async function cleanPreviousCuratedSkills(curatedDir, lockedSkillNames) {
+async function cleanPreviousCuratedSkills(params) {
+  const { curatedDir, lockedSkillNames, logger: logger5 } = params;
   const resolvedCuratedDir = resolve(curatedDir);
   for (const prevSkill of lockedSkillNames) {
     const prevDir = join6(curatedDir, prevSkill);
     if (!resolve(prevDir).startsWith(resolvedCuratedDir + sep)) {
-      logger.warn(
+      logger5.warn(
         `Skipping removal of "${prevSkill}": resolved path is outside the curated directory.`
       );
       continue;
@@ -2174,21 +2196,21 @@ async function cleanPreviousCuratedSkills(curatedDir, lockedSkillNames) {
   }
 }
 function shouldSkipSkill(params) {
-  const { skillName, sourceKey, localSkillNames, alreadyFetchedSkillNames } = params;
+  const { skillName, sourceKey, localSkillNames, alreadyFetchedSkillNames, logger: logger5 } = params;
   if (skillName.includes("..") || skillName.includes("/") || skillName.includes("\\")) {
-    logger.warn(
+    logger5.warn(
       `Skipping skill with invalid name "${skillName}" from ${sourceKey}: contains path traversal characters.`
     );
     return true;
   }
   if (localSkillNames.has(skillName)) {
-    logger.debug(
+    logger5.debug(
       `Skipping remote skill "${skillName}" from ${sourceKey}: local skill takes precedence.`
     );
     return true;
   }
   if (alreadyFetchedSkillNames.has(skillName)) {
-    logger.warn(
+    logger5.warn(
       `Skipping duplicate skill "${skillName}" from ${sourceKey}: already fetched from another source.`
     );
     return true;
@@ -2196,7 +2218,7 @@ function shouldSkipSkill(params) {
   return false;
 }
 async function writeSkillAndComputeIntegrity(params) {
-  const { skillName, files, curatedDir, locked, resolvedSha, sourceKey } = params;
+  const { skillName, files, curatedDir, locked, resolvedSha, sourceKey, logger: logger5 } = params;
   const written = [];
   for (const file of files) {
     checkPathTraversal({
@@ -2209,14 +2231,23 @@ async function writeSkillAndComputeIntegrity(params) {
   const integrity = computeSkillIntegrity(written);
   const lockedSkillEntry = locked?.skills[skillName];
   if (lockedSkillEntry?.integrity && lockedSkillEntry.integrity !== integrity && resolvedSha === locked?.resolvedRef) {
-    logger.warn(
+    logger5.warn(
       `Integrity mismatch for skill "${skillName}" from ${sourceKey}: expected "${lockedSkillEntry.integrity}", got "${integrity}". Content may have been tampered with.`
     );
   }
   return { integrity };
 }
 function buildLockUpdate(params) {
-  const { lock, sourceKey, fetchedSkills, locked, requestedRef, resolvedSha, remoteSkillNames } = params;
+  const {
+    lock,
+    sourceKey,
+    fetchedSkills,
+    locked,
+    requestedRef,
+    resolvedSha,
+    remoteSkillNames,
+    logger: logger5
+  } = params;
   const fetchedNames = Object.keys(fetchedSkills);
   const remoteSet = new Set(remoteSkillNames);
   const mergedSkills = { ...fetchedSkills };
@@ -2233,17 +2264,25 @@ function buildLockUpdate(params) {
     resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
     skills: mergedSkills
   });
-  logger.info(
+  logger5.info(
     `Fetched ${fetchedNames.length} skill(s) from ${sourceKey}: ${fetchedNames.join(", ") || "(none)"}`
   );
   return { updatedLock, fetchedNames };
 }
 async function fetchSource(params) {
-  const { sourceEntry, client, baseDir, localSkillNames, alreadyFetchedSkillNames, updateSources } = params;
+  const {
+    sourceEntry,
+    client,
+    baseDir,
+    localSkillNames,
+    alreadyFetchedSkillNames,
+    updateSources,
+    logger: logger5
+  } = params;
   const { lock } = params;
   const parsed = parseSource(sourceEntry.source);
   if (parsed.provider === "gitlab") {
-    logger.warn(`GitLab sources are not yet supported. Skipping "${sourceEntry.source}".`);
+    logger5.warn(`GitLab sources are not yet supported. Skipping "${sourceEntry.source}".`);
     return { skillCount: 0, fetchedSkillNames: [], updatedLock: lock };
   }
   const sourceKey = sourceEntry.source;
@@ -2256,18 +2295,18 @@ async function fetchSource(params) {
     ref = locked.resolvedRef;
     resolvedSha = locked.resolvedRef;
     requestedRef = locked.requestedRef;
-    logger.debug(`Using locked ref for ${sourceKey}: ${resolvedSha}`);
+    logger5.debug(`Using locked ref for ${sourceKey}: ${resolvedSha}`);
   } else {
     requestedRef = parsed.ref ?? await client.getDefaultBranch(parsed.owner, parsed.repo);
     resolvedSha = await client.resolveRefToSha(parsed.owner, parsed.repo, requestedRef);
     ref = resolvedSha;
-    logger.debug(`Resolved ${sourceKey} ref "${requestedRef}" to SHA: ${resolvedSha}`);
+    logger5.debug(`Resolved ${sourceKey} ref "${requestedRef}" to SHA: ${resolvedSha}`);
   }
   const curatedDir = join6(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
   if (locked && resolvedSha === locked.resolvedRef && !updateSources) {
     const allExist = await checkLockedSkillsExist(curatedDir, lockedSkillNames);
     if (allExist) {
-      logger.debug(`SHA unchanged for ${sourceKey}, skipping re-fetch.`);
+      logger5.debug(`SHA unchanged for ${sourceKey}, skipping re-fetch.`);
       return {
         skillCount: 0,
         fetchedSkillNames: lockedSkillNames,
@@ -2284,7 +2323,7 @@ async function fetchSource(params) {
     remoteSkillDirs = entries.filter((e) => e.type === "dir").map((e) => ({ name: e.name, path: e.path }));
   } catch (error) {
     if (error instanceof GitHubClientError && error.statusCode === 404) {
-      logger.warn(`No skills/ directory found in ${sourceKey}. Skipping.`);
+      logger5.warn(`No skills/ directory found in ${sourceKey}. Skipping.`);
       return { skillCount: 0, fetchedSkillNames: [], updatedLock: lock };
     }
     throw error;
@@ -2293,14 +2332,15 @@ async function fetchSource(params) {
   const semaphore = new Semaphore2(FETCH_CONCURRENCY_LIMIT);
   const fetchedSkills = {};
   if (locked) {
-    await cleanPreviousCuratedSkills(curatedDir, lockedSkillNames);
+    await cleanPreviousCuratedSkills({ curatedDir, lockedSkillNames, logger: logger5 });
   }
   for (const skillDir of filteredDirs) {
     if (shouldSkipSkill({
       skillName: skillDir.name,
       sourceKey,
       localSkillNames,
-      alreadyFetchedSkillNames
+      alreadyFetchedSkillNames,
+      logger: logger5
     })) {
       continue;
     }
@@ -2314,7 +2354,7 @@ async function fetchSource(params) {
     });
     const files = allFiles.filter((file) => {
       if (file.size > MAX_FILE_SIZE) {
-        logger.warn(
+        logger5.warn(
           `Skipping file "${file.path}" (${(file.size / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit).`
         );
         return false;
@@ -2336,9 +2376,10 @@ async function fetchSource(params) {
       curatedDir,
       locked,
       resolvedSha,
-      sourceKey
+      sourceKey,
+      logger: logger5
     });
-    logger.debug(`Fetched skill "${skillDir.name}" from ${sourceKey}`);
+    logger5.debug(`Fetched skill "${skillDir.name}" from ${sourceKey}`);
   }
   const result = buildLockUpdate({
     lock,
@@ -2347,7 +2388,8 @@ async function fetchSource(params) {
     locked,
     requestedRef,
     resolvedSha,
-    remoteSkillNames: filteredDirs.map((d) => d.name)
+    remoteSkillNames: filteredDirs.map((d) => d.name),
+    logger: logger5
   });
   return {
     skillCount: result.fetchedNames.length,
@@ -2356,7 +2398,15 @@ async function fetchSource(params) {
   };
 }
 async function fetchSourceViaGit(params) {
-  const { sourceEntry, baseDir, localSkillNames, alreadyFetchedSkillNames, updateSources, frozen } = params;
+  const {
+    sourceEntry,
+    baseDir,
+    localSkillNames,
+    alreadyFetchedSkillNames,
+    updateSources,
+    frozen,
+    logger: logger5
+  } = params;
   const { lock } = params;
   const url = sourceEntry.source;
   const locked = getLockedSource(lock, url);
@@ -2413,11 +2463,17 @@ async function fetchSourceViaGit(params) {
   const allNames = [...skillFileMap.keys()];
   const filteredNames = isWildcard ? allNames : allNames.filter((n) => skillFilter.includes(n));
   if (locked) {
-    await cleanPreviousCuratedSkills(curatedDir, lockedSkillNames);
+    await cleanPreviousCuratedSkills({ curatedDir, lockedSkillNames, logger: logger5 });
   }
   const fetchedSkills = {};
   for (const skillName of filteredNames) {
-    if (shouldSkipSkill({ skillName, sourceKey: url, localSkillNames, alreadyFetchedSkillNames })) {
+    if (shouldSkipSkill({
+      skillName,
+      sourceKey: url,
+      localSkillNames,
+      alreadyFetchedSkillNames,
+      logger: logger5
+    })) {
       continue;
     }
     fetchedSkills[skillName] = await writeSkillAndComputeIntegrity({
@@ -2426,7 +2482,8 @@ async function fetchSourceViaGit(params) {
       curatedDir,
       locked,
       resolvedSha,
-      sourceKey: url
+      sourceKey: url,
+      logger: logger5
     });
   }
   const result = buildLockUpdate({
@@ -2436,7 +2493,8 @@ async function fetchSourceViaGit(params) {
     locked,
     requestedRef,
     resolvedSha,
-    remoteSkillNames: filteredNames
+    remoteSkillNames: filteredNames,
+    logger: logger5
   });
   return {
     skillCount: result.fetchedNames.length,
@@ -2446,7 +2504,7 @@ async function fetchSourceViaGit(params) {
 }
 
 // src/cli/commands/install.ts
-async function installCommand(logger2, options) {
+async function installCommand(logger5, options) {
   const config = await ConfigResolver.resolve({
     configPath: options.configPath,
     verbose: options.verbose,
@@ -2454,10 +2512,10 @@ async function installCommand(logger2, options) {
   });
   const sources = config.getSources();
   if (sources.length === 0) {
-    logger2.warn("No sources defined in configuration. Nothing to install.");
+    logger5.warn("No sources defined in configuration. Nothing to install.");
     return;
   }
-  logger2.debug(`Installing skills from ${sources.length} source(s)...`);
+  logger5.debug(`Installing skills from ${sources.length} source(s)...`);
   const result = await resolveAndFetchSources({
     sources,
     baseDir: process.cwd(),
@@ -2465,18 +2523,19 @@ async function installCommand(logger2, options) {
       updateSources: options.update,
       frozen: options.frozen,
       token: options.token
-    }
+    },
+    logger: logger5
   });
-  if (logger2.jsonMode) {
-    logger2.captureData("sourcesProcessed", result.sourcesProcessed);
-    logger2.captureData("skillsFetched", result.fetchedSkillCount);
+  if (logger5.jsonMode) {
+    logger5.captureData("sourcesProcessed", result.sourcesProcessed);
+    logger5.captureData("skillsFetched", result.fetchedSkillCount);
   }
   if (result.fetchedSkillCount > 0) {
-    logger2.success(
+    logger5.success(
       `Installed ${result.fetchedSkillCount} skill(s) from ${result.sourcesProcessed} source(s).`
     );
   } else {
-    logger2.success(`All skills up to date (${result.sourcesProcessed} source(s) checked).`);
+    logger5.success(`All skills up to date (${result.sourcesProcessed} source(s) checked).`);
   }
 }
 
@@ -2489,6 +2548,7 @@ import { z as z13 } from "zod/mini";
 // src/mcp/commands.ts
 import { basename, join as join7 } from "path";
 import { z as z5 } from "zod/mini";
+var logger = new ConsoleLogger({ verbose: false, silent: true });
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
@@ -2707,7 +2767,8 @@ async function executeGenerate(options = {}) {
       verbose: false,
       silent: true
     });
-    const generateResult = await generate({ config });
+    const logger5 = new ConsoleLogger({ verbose: false, silent: true });
+    const generateResult = await generate({ config, logger: logger5 });
     return buildSuccessResponse({ generateResult, config });
   } catch (error) {
     return {
@@ -2885,7 +2946,8 @@ async function executeImport(options) {
       silent: true
     });
     const tool = config.getTargets()[0];
-    const importResult = await importFromTool({ config, tool });
+    const logger5 = new ConsoleLogger({ verbose: false, silent: true });
+    const importResult = await importFromTool({ config, tool, logger: logger5 });
     return buildSuccessResponse2({ importResult, config, tool });
   } catch (error) {
     return {
@@ -3070,6 +3132,7 @@ var mcpTools = {
 // src/mcp/rules.ts
 import { basename as basename2, join as join10 } from "path";
 import { z as z10 } from "zod/mini";
+var logger2 = new ConsoleLogger({ verbose: false, silent: true });
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
@@ -3090,14 +3153,14 @@ async function listRules() {
             frontmatter
           };
         } catch (error) {
-          logger.error(`Failed to read rule file ${file}: ${formatError(error)}`);
+          logger2.error(`Failed to read rule file ${file}: ${formatError(error)}`);
           return null;
         }
       })
     );
     return rules.filter((rule) => rule !== null);
   } catch (error) {
-    logger.error(
+    logger2.error(
       `Failed to read rules directory (${RULESYNC_RULES_RELATIVE_DIR_PATH}): ${formatError(error)}`
     );
     return [];
@@ -3252,6 +3315,7 @@ var ruleTools = {
 // src/mcp/skills.ts
 import { basename as basename3, dirname, join as join11 } from "path";
 import { z as z11 } from "zod/mini";
+var logger3 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
 function aiDirFileToMcpSkillFile(file) {
@@ -3291,14 +3355,14 @@ async function listSkills() {
             frontmatter
           };
         } catch (error) {
-          logger.error(`Failed to read skill directory ${dirName}: ${formatError(error)}`);
+          logger3.error(`Failed to read skill directory ${dirName}: ${formatError(error)}`);
           return null;
         }
       })
     );
     return skills.filter((skill) => skill !== null);
   } catch (error) {
-    logger.error(
+    logger3.error(
       `Failed to read skills directory (${RULESYNC_SKILLS_RELATIVE_DIR_PATH}): ${formatError(error)}`
     );
     return [];
@@ -3490,6 +3554,7 @@ var skillTools = {
 // src/mcp/subagents.ts
 import { basename as basename4, join as join12 } from "path";
 import { z as z12 } from "zod/mini";
+var logger4 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
@@ -3510,7 +3575,7 @@ async function listSubagents() {
             frontmatter
           };
         } catch (error) {
-          logger.error(`Failed to read subagent file ${file}: ${formatError(error)}`);
+          logger4.error(`Failed to read subagent file ${file}: ${formatError(error)}`);
           return null;
         }
       })
@@ -3519,7 +3584,7 @@ async function listSubagents() {
       (subagent) => subagent !== null
     );
   } catch (error) {
-    logger.error(
+    logger4.error(
       `Failed to read subagents directory (${RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH}): ${formatError(error)}`
     );
     return [];
@@ -3891,7 +3956,7 @@ var rulesyncTool = {
 };
 
 // src/cli/commands/mcp.ts
-async function mcpCommand(logger2, { version }) {
+async function mcpCommand(logger5, { version }) {
   const server = new FastMCP({
     name: "Rulesync MCP Server",
     // eslint-disable-next-line no-type-assertion/no-type-assertion
@@ -3899,7 +3964,7 @@ async function mcpCommand(logger2, { 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);
-  logger2.info("Rulesync MCP server started via stdio");
+  logger5.info("Rulesync MCP server started via stdio");
   void server.start({
     transportType: "stdio"
   });
@@ -4215,43 +4280,43 @@ To upgrade, run:
 }
 
 // src/cli/commands/update.ts
-async function updateCommand(logger2, currentVersion, options) {
+async function updateCommand(logger5, currentVersion, options) {
   const { check = false, force = false, token } = options;
   try {
     const environment = detectExecutionEnvironment();
-    logger2.debug(`Detected environment: ${environment}`);
+    logger5.debug(`Detected environment: ${environment}`);
     if (environment === "npm") {
-      logger2.info(getNpmUpgradeInstructions());
+      logger5.info(getNpmUpgradeInstructions());
       return;
     }
     if (environment === "homebrew") {
-      logger2.info(getHomebrewUpgradeInstructions());
+      logger5.info(getHomebrewUpgradeInstructions());
       return;
     }
     if (check) {
-      logger2.info("Checking for updates...");
+      logger5.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(
+      if (logger5.jsonMode) {
+        logger5.captureData("currentVersion", updateCheck.currentVersion);
+        logger5.captureData("latestVersion", updateCheck.latestVersion);
+        logger5.captureData("updateAvailable", updateCheck.hasUpdate);
+        logger5.captureData(
           "message",
           updateCheck.hasUpdate ? `Update available: ${updateCheck.currentVersion} -> ${updateCheck.latestVersion}` : `Already at the latest version (${updateCheck.currentVersion})`
         );
       }
       if (updateCheck.hasUpdate) {
-        logger2.success(
+        logger5.success(
           `Update available: ${updateCheck.currentVersion} -> ${updateCheck.latestVersion}`
         );
       } else {
-        logger2.info(`Already at the latest version (${updateCheck.currentVersion})`);
+        logger5.info(`Already at the latest version (${updateCheck.currentVersion})`);
       }
       return;
     }
-    logger2.info("Checking for updates...");
+    logger5.info("Checking for updates...");
     const message = await performBinaryUpdate(currentVersion, { force, token });
-    logger2.success(message);
+    logger5.success(message);
   } catch (error) {
     if (error instanceof GitHubClientError) {
       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 ...`" : "";
@@ -4269,54 +4334,68 @@ async function updateCommand(logger2, currentVersion, options) {
   }
 }
 
-// src/cli/index.ts
-var getVersion = () => "7.20.0";
-function wrapCommand(name, errorCode, handler) {
+// src/cli/wrap-command.ts
+function createLogger({
+  name,
+  globalOpts,
+  getVersion: getVersion2
+}) {
+  return globalOpts.json ? new JsonLogger({ command: name, version: getVersion2() }) : new ConsoleLogger();
+}
+function wrapCommand({
+  name,
+  errorCode,
+  handler,
+  getVersion: getVersion2,
+  loggerFactory = createLogger
+}) {
   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({
+    const logger5 = loggerFactory({ name, globalOpts, getVersion: getVersion2 });
+    logger5.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);
+      await handler(logger5, options, globalOpts, positionalArgs);
+      logger5.outputJson(true);
     } catch (error) {
       const code = error instanceof CLIError ? error.code : errorCode;
       const errorArg = error instanceof Error ? error : formatError(error);
-      logger2.error(errorArg, code);
+      logger5.error(errorArg, code);
       process.exit(error instanceof CLIError ? error.exitCode : 1);
     }
   };
 }
+
+// src/cli/index.ts
+var getVersion = () => "7.22.0";
+function wrapCommand2(name, errorCode, handler) {
+  return wrapCommand({ name, errorCode, handler, getVersion });
+}
 var main = async () => {
   const program = new Command();
   const version = getVersion();
   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);
+    wrapCommand2("init", "INIT_FAILED", async (logger5) => {
+      await initCommand(logger5);
     })
   );
   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);
-    }
+    parseCommaSeparatedList
   ).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);
-    }
+    parseCommaSeparatedList
   ).option("-V, --verbose", "Verbose output").option("-s, --silent", "Suppress all output").action(
-    wrapCommand("gitignore", "GITIGNORE_FAILED", async (logger2, options) => {
-      await gitignoreCommand(logger2, {
+    wrapCommand2("gitignore", "GITIGNORE_FAILED", async (logger5, options) => {
+      await gitignoreCommand(logger5, {
         // eslint-disable-next-line no-type-assertion/no-type-assertion
         targets: options.targets,
         // eslint-disable-next-line no-type-assertion/no-type-assertion
@@ -4330,40 +4409,40 @@ var main = async () => {
   ).option(
     "-f, --features <features>",
     `Comma-separated list of features to fetch (${ALL_FEATURES.join(",")}) or '*' for all`,
-    (value) => value.split(",").map((f) => f.trim())
+    parseCommaSeparatedList
   ).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(
-    wrapCommand("fetch", "FETCH_FAILED", async (logger2, options, _globalOpts, positionalArgs) => {
+    wrapCommand2("fetch", "FETCH_FAILED", async (logger5, options, _globalOpts, positionalArgs) => {
       const source = positionalArgs[0];
-      await fetchCommand(logger2, { ...options, source });
+      await fetchCommand(logger5, { ...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) => value.split(",").map((t) => t.trim())
+    parseCommaSeparatedList
   ).option(
     "-f, --features <features>",
     `Comma-separated list of features to import (${ALL_FEATURES.join(",")}) or '*' for all`,
-    (value) => value.split(",").map((f) => f.trim())
+    parseCommaSeparatedList
   ).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);
+    wrapCommand2("import", "IMPORT_FAILED", async (logger5, options) => {
+      await importCommand(logger5, options);
     })
   );
   program.command("mcp").description("Start MCP server for rulesync").action(
-    wrapCommand("mcp", "MCP_FAILED", async (logger2, _options) => {
-      await mcpCommand(logger2, { version });
+    wrapCommand2("mcp", "MCP_FAILED", async (logger5, _options) => {
+      await mcpCommand(logger5, { 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(
-    wrapCommand("install", "INSTALL_FAILED", async (logger2, options) => {
-      await installCommand(logger2, {
+    wrapCommand2("install", "INSTALL_FAILED", async (logger5, options) => {
+      await installCommand(logger5, {
         // eslint-disable-next-line no-type-assertion/no-type-assertion
         update: options.update,
         // eslint-disable-next-line no-type-assertion/no-type-assertion
@@ -4382,15 +4461,15 @@ var main = async () => {
   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) => value.split(",").map((t) => t.trim())
+    parseCommaSeparatedList
   ).option(
     "-f, --features <features>",
     `Comma-separated list of features to generate (${ALL_FEATURES.join(",")}) or '*' for all`,
-    (value) => value.split(",").map((f) => f.trim())
+    parseCommaSeparatedList
   ).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) => value.split(",").map((p) => p.trim())
+    parseCommaSeparatedList
   ).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."
@@ -4401,13 +4480,13 @@ var main = async () => {
     "--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(
-    wrapCommand("generate", "GENERATION_FAILED", async (logger2, options) => {
-      await generateCommand(logger2, options);
+    wrapCommand2("generate", "GENERATION_FAILED", async (logger5, options) => {
+      await generateCommand(logger5, 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);
+    wrapCommand2("update", "UPDATE_FAILED", async (logger5, options) => {
+      await updateCommand(logger5, version, options);
     })
   );
   program.parse();