rulesync 7.18.2 → 7.19.0

package/dist/{chunk-JP3BFD7L.js → chunk-J2ZF4SHC.js}

@@ -15,6 +15,32 @@ function formatError(error) {
   return String(error);
 }
 
+// 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/logger.ts
 import { consola } from "consola";
 
@@ -25,16 +51,24 @@ function isEnvTest() {
 
 // src/utils/logger.ts
 var Logger = class {
+  /**
+   * Create a new Logger instance
+   */
+  constructor(_version = "0.0.0") {
+    this._version = _version;
+  }
   _verbose = false;
   _silent = false;
+  _jsonMode = false;
+  _jsonOutputDone = false;
+  _commandName = "";
+  _jsonData = {};
   console = 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)
    */
   configure({ verbose, silent }) {
     if (verbose && silent) {
@@ -50,34 +84,120 @@ var Logger = class {
   get silent() {
     return this._silent;
   }
+  /**
+   * Enable JSON output mode
+   */
+  setJsonMode(enabled, command) {
+    this._jsonMode = enabled;
+    this._jsonOutputDone = false;
+    this._commandName = command;
+    if (enabled) {
+      this._jsonData = {};
+    }
+  }
+  /**
+   * Check if JSON mode is enabled
+   */
+  get jsonMode() {
+    return this._jsonMode;
+  }
+  /**
+   * Capture data for JSON output
+   */
+  captureData(key, value) {
+    if (this._jsonMode) {
+      this._jsonData[key] = value;
+    }
+  }
+  /**
+   * Get captured JSON data
+   */
+  getJsonData() {
+    return { ...this._jsonData };
+  }
+  /**
+   * Output final JSON result
+   */
+  outputJson(success, error) {
+    if (!this._jsonMode || 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) {
     if (isEnvTest() || this._silent) return;
+    if (this._jsonMode) return;
     this.console.info(message, ...args);
   }
-  // Success (always shown unless silent)
   success(message, ...args) {
     if (isEnvTest() || this._silent) return;
+    if (this._jsonMode) return;
     this.console.success(message, ...args);
   }
-  // Warning (always shown unless silent)
   warn(message, ...args) {
     if (isEnvTest() || this._silent) return;
+    if (this._jsonMode) return;
     this.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;
+    if (this._jsonMode) {
+      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);
+    } else {
+      this.console.error(errorMessage, ...args);
+    }
   }
-  // Debug level (shown only in verbose mode)
   debug(message, ...args) {
     if (isEnvTest() || this._silent) return;
+    if (this._jsonMode) return;
     if (this._verbose) {
       this.console.info(message, ...args);
     }
   }
+  /**
+   * Get the internal console instance (for testing only)
+   * @internal
+   */
+  _getConsole() {
+    return this.console;
+  }
 };
-var logger = new Logger();
+function createLogger(version) {
+  return new Logger(version);
+}
+var logger = new Logger("0.0.0");
 
 // src/types/features.ts
 import { z } from "zod/mini";
@@ -3304,7 +3424,9 @@ var CLAUDE_HOOK_EVENTS = [
   "preCompact",
   "permissionRequest",
   "notification",
-  "setup"
+  "setup",
+  "worktreeCreate",
+  "worktreeRemove"
 ];
 var OPENCODE_HOOK_EVENTS = [
   "sessionStart",
@@ -3371,7 +3493,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])
@@ -3497,7 +3621,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;
@@ -3510,7 +3640,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;
   }
@@ -3648,12 +3779,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) {
@@ -17154,6 +17287,9 @@ export {
   MAX_FILE_SIZE,
   FETCH_CONCURRENCY_LIMIT,
   formatError,
+  ErrorCodes,
+  CLIError,
+  createLogger,
   logger,
   ensureDir,
   checkPathTraversal,
@@ -17172,6 +17308,7 @@ export {
   ALL_FEATURES,
   ALL_FEATURES_WITH_WILDCARD,
   ALL_TOOL_TARGETS,
+  ALL_TOOL_TARGETS_WITH_WILDCARD,
   findControlCharacter,
   ConfigResolver,
   stringifyFrontmatter,