ccjk 9.6.1 → 9.8.0

package/dist/chunks/hooks-sync.mjs

@@ -1,1627 +0,0 @@
-import { homedir } from 'node:os';
-import ansis from 'ansis';
-import inquirer from 'inquirer';
-import { join } from 'pathe';
-import { i18n } from './index.mjs';
-import { d as displayBannerWithInfo } from '../shared/ccjk.Br91zBIG.mjs';
-import { a as handleExitPromptError, h as handleGeneralError } from '../shared/ccjk.CItD1fpl.mjs';
-import { ensureDir, writeFileAtomic, exists, readJsonFile } from './fs-operations.mjs';
-import 'node:fs';
-import 'node:process';
-import 'node:url';
-import 'i18next';
-import 'i18next-fs-backend';
-import './package.mjs';
-import 'node:crypto';
-import 'node:fs/promises';
-
-const templates = [
-	{
-		id: "auto-format-on-save",
-		name: "Auto Format on Save",
-		category: "code-quality",
-		description: "Automatically format code files when they are saved",
-		hook: {
-			name: "Auto Format on Save",
-			version: "1.0.0",
-			trigger: {
-				type: "file_change",
-				pattern: "**/*.{js,ts,jsx,tsx,vue,css,scss,json,md}"
-			},
-			actions: [
-				{
-					type: "run_command",
-					config: {
-						command: "npx prettier --write {{file}}",
-						workingDir: "{{projectRoot}}"
-					}
-				}
-			],
-			privacy: "private",
-			enabled: true
-		},
-		variables: [
-			"file",
-			"projectRoot"
-		]
-	},
-	{
-		id: "pre-commit-lint-check",
-		name: "Pre-commit Lint Check",
-		category: "git",
-		description: "Run linting checks before committing code",
-		hook: {
-			name: "Pre-commit Lint Check",
-			version: "1.0.0",
-			trigger: {
-				type: "event",
-				event: "pre-tool-use"
-			},
-			actions: [
-				{
-					type: "run_command",
-					config: {
-						command: "npm run lint",
-						workingDir: "{{projectRoot}}",
-						failOnError: true
-					}
-				}
-			],
-			conditions: [
-				{
-					field: "tool",
-					operator: "eq",
-					value: "git"
-				},
-				{
-					field: "command",
-					operator: "contains",
-					value: "commit"
-				}
-			],
-			privacy: "private",
-			enabled: true
-		},
-		variables: [
-			"projectRoot"
-		]
-	},
-	{
-		id: "auto-generate-tests",
-		name: "Auto Generate Tests",
-		category: "testing",
-		description: "Automatically generate test files for new source files",
-		hook: {
-			name: "Auto Generate Tests",
-			version: "1.0.0",
-			trigger: {
-				type: "file_change",
-				pattern: "src/**/*.{js,ts,jsx,tsx}"
-			},
-			actions: [
-				{
-					type: "run_command",
-					config: {
-						command: "npx jest --init {{file}}",
-						workingDir: "{{projectRoot}}"
-					}
-				},
-				{
-					type: "notify",
-					config: {
-						title: "Test Generated",
-						message: "Test file created for {{file}}",
-						type: "success"
-					}
-				}
-			],
-			conditions: [
-				{
-					field: "fileExists",
-					operator: "ne",
-					value: "{{testFile}}"
-				}
-			],
-			privacy: "private",
-			enabled: false
-		},
-		variables: [
-			"file",
-			"projectRoot",
-			"testFile"
-		]
-	},
-	{
-		id: "documentation-update",
-		name: "Documentation Update",
-		category: "documentation",
-		description: "Update documentation when code changes",
-		hook: {
-			name: "Documentation Update",
-			version: "1.0.0",
-			trigger: {
-				type: "file_change",
-				pattern: "src/**/*.{js,ts}"
-			},
-			actions: [
-				{
-					type: "run_command",
-					config: {
-						command: "npx typedoc --out docs {{file}}",
-						workingDir: "{{projectRoot}}"
-					}
-				},
-				{
-					type: "notify",
-					config: {
-						title: "Documentation Updated",
-						message: "API documentation regenerated",
-						type: "info"
-					}
-				}
-			],
-			privacy: "private",
-			enabled: false
-		},
-		variables: [
-			"file",
-			"projectRoot"
-		]
-	},
-	{
-		id: "dependency-check",
-		name: "Dependency Security Check",
-		category: "security",
-		description: "Check for security vulnerabilities in dependencies",
-		hook: {
-			name: "Dependency Security Check",
-			version: "1.0.0",
-			trigger: {
-				type: "file_change",
-				pattern: "{package.json,package-lock.json,pnpm-lock.yaml,yarn.lock}"
-			},
-			actions: [
-				{
-					type: "run_command",
-					config: {
-						command: "npm audit --audit-level=moderate",
-						workingDir: "{{projectRoot}}",
-						continueOnError: true
-					}
-				},
-				{
-					type: "notify",
-					config: {
-						title: "Security Audit Complete",
-						message: "Dependency security check finished",
-						type: "info"
-					}
-				}
-			],
-			privacy: "private",
-			enabled: true
-		},
-		variables: [
-			"projectRoot"
-		]
-	},
-	{
-		id: "security-scan",
-		name: "Code Security Scan",
-		category: "security",
-		description: "Scan code for security vulnerabilities",
-		hook: {
-			name: "Code Security Scan",
-			version: "1.0.0",
-			trigger: {
-				type: "schedule",
-				schedule: "0 0 * * *"
-			},
-			actions: [
-				{
-					type: "run_command",
-					config: {
-						command: "npx eslint --ext .js,.ts --plugin security .",
-						workingDir: "{{projectRoot}}",
-						continueOnError: true
-					}
-				},
-				{
-					type: "call_api",
-					config: {
-						url: "{{webhookUrl}}",
-						method: "POST",
-						body: {
-							type: "security-scan",
-							status: "{{status}}",
-							timestamp: "{{timestamp}}"
-						}
-					}
-				}
-			],
-			privacy: "private",
-			enabled: false
-		},
-		variables: [
-			"projectRoot",
-			"webhookUrl",
-			"status",
-			"timestamp"
-		]
-	},
-	{
-		id: "build-on-push",
-		name: "Build on Git Push",
-		category: "git",
-		description: "Automatically build project when pushing to git",
-		hook: {
-			name: "Build on Git Push",
-			version: "1.0.0",
-			trigger: {
-				type: "event",
-				event: "pre-tool-use"
-			},
-			actions: [
-				{
-					type: "run_command",
-					config: {
-						command: "npm run build",
-						workingDir: "{{projectRoot}}",
-						failOnError: true
-					}
-				},
-				{
-					type: "notify",
-					config: {
-						title: "Build Complete",
-						message: "Project built successfully before push",
-						type: "success"
-					}
-				}
-			],
-			conditions: [
-				{
-					field: "tool",
-					operator: "eq",
-					value: "git"
-				},
-				{
-					field: "command",
-					operator: "contains",
-					value: "push"
-				}
-			],
-			privacy: "private",
-			enabled: false
-		},
-		variables: [
-			"projectRoot"
-		]
-	},
-	{
-		id: "test-before-commit",
-		name: "Test Before Commit",
-		category: "testing",
-		description: "Run tests before committing code",
-		hook: {
-			name: "Test Before Commit",
-			version: "1.0.0",
-			trigger: {
-				type: "event",
-				event: "pre-tool-use"
-			},
-			actions: [
-				{
-					type: "run_command",
-					config: {
-						command: "npm test",
-						workingDir: "{{projectRoot}}",
-						failOnError: true
-					}
-				}
-			],
-			conditions: [
-				{
-					field: "tool",
-					operator: "eq",
-					value: "git"
-				},
-				{
-					field: "command",
-					operator: "contains",
-					value: "commit"
-				}
-			],
-			privacy: "private",
-			enabled: false
-		},
-		variables: [
-			"projectRoot"
-		]
-	},
-	{
-		id: "changelog-update",
-		name: "Changelog Update",
-		category: "documentation",
-		description: "Update changelog when version changes",
-		hook: {
-			name: "Changelog Update",
-			version: "1.0.0",
-			trigger: {
-				type: "file_change",
-				pattern: "package.json"
-			},
-			actions: [
-				{
-					type: "run_command",
-					config: {
-						command: "npx conventional-changelog -p angular -i CHANGELOG.md -s",
-						workingDir: "{{projectRoot}}"
-					}
-				},
-				{
-					type: "notify",
-					config: {
-						title: "Changelog Updated",
-						message: "CHANGELOG.md has been updated",
-						type: "info"
-					}
-				}
-			],
-			conditions: [
-				{
-					field: "versionChanged",
-					operator: "eq",
-					value: "true"
-				}
-			],
-			privacy: "private",
-			enabled: false
-		},
-		variables: [
-			"projectRoot"
-		]
-	},
-	{
-		id: "notify-on-error",
-		name: "Notify on Error",
-		category: "notification",
-		description: "Send notification when an error occurs",
-		hook: {
-			name: "Notify on Error",
-			version: "1.0.0",
-			trigger: {
-				type: "event",
-				event: "error"
-			},
-			actions: [
-				{
-					type: "notify",
-					config: {
-						title: "Error Occurred",
-						message: "{{errorMessage}}",
-						type: "error",
-						priority: "high"
-					}
-				},
-				{
-					type: "call_api",
-					config: {
-						url: "{{webhookUrl}}",
-						method: "POST",
-						body: {
-							type: "error",
-							message: "{{errorMessage}}",
-							stack: "{{errorStack}}",
-							timestamp: "{{timestamp}}"
-						}
-					}
-				}
-			],
-			privacy: "private",
-			enabled: true
-		},
-		variables: [
-			"errorMessage",
-			"errorStack",
-			"timestamp",
-			"webhookUrl"
-		]
-	},
-	{
-		id: "task-complete-notification",
-		name: "Task Complete Notification",
-		category: "notification",
-		description: "Send notification when a task completes",
-		hook: {
-			name: "Task Complete Notification",
-			version: "1.0.0",
-			trigger: {
-				type: "event",
-				event: "task-complete"
-			},
-			actions: [
-				{
-					type: "notify",
-					config: {
-						title: "Task Complete",
-						message: "{{taskDescription}} completed in {{duration}}ms",
-						type: "success"
-					}
-				}
-			],
-			privacy: "private",
-			enabled: true
-		},
-		variables: [
-			"taskDescription",
-			"duration"
-		]
-	},
-	{
-		id: "workflow-start-log",
-		name: "Workflow Start Logger",
-		category: "logging",
-		description: "Log when a workflow starts",
-		hook: {
-			name: "Workflow Start Logger",
-			version: "1.0.0",
-			trigger: {
-				type: "event",
-				event: "workflow-start"
-			},
-			actions: [
-				{
-					type: "run_command",
-					config: {
-						command: "echo '[{{timestamp}}] Workflow {{workflowId}} started' >> workflow.log",
-						workingDir: "{{projectRoot}}"
-					}
-				}
-			],
-			privacy: "private",
-			enabled: false
-		},
-		variables: [
-			"workflowId",
-			"timestamp",
-			"projectRoot"
-		]
-	},
-	{
-		id: "backup-on-change",
-		name: "Backup on File Change",
-		category: "backup",
-		description: "Create backup when important files change",
-		hook: {
-			name: "Backup on File Change",
-			version: "1.0.0",
-			trigger: {
-				type: "file_change",
-				pattern: "{.env,.env.local,config/*.json}"
-			},
-			actions: [
-				{
-					type: "run_command",
-					config: {
-						command: "cp {{file}} {{file}}.backup.{{timestamp}}",
-						workingDir: "{{projectRoot}}"
-					}
-				},
-				{
-					type: "notify",
-					config: {
-						title: "Backup Created",
-						message: "Backup created for {{file}}",
-						type: "info"
-					}
-				}
-			],
-			privacy: "private",
-			enabled: false
-		},
-		variables: [
-			"file",
-			"timestamp",
-			"projectRoot"
-		]
-	},
-	{
-		id: "code-review-reminder",
-		name: "Code Review Reminder",
-		category: "collaboration",
-		description: "Remind to request code review before pushing",
-		hook: {
-			name: "Code Review Reminder",
-			version: "1.0.0",
-			trigger: {
-				type: "event",
-				event: "pre-tool-use"
-			},
-			actions: [
-				{
-					type: "notify",
-					config: {
-						title: "Code Review Reminder",
-						message: "Don't forget to request code review!",
-						type: "info"
-					}
-				}
-			],
-			conditions: [
-				{
-					field: "tool",
-					operator: "eq",
-					value: "git"
-				},
-				{
-					field: "command",
-					operator: "contains",
-					value: "push"
-				},
-				{
-					field: "branch",
-					operator: "ne",
-					value: "main"
-				}
-			],
-			privacy: "private",
-			enabled: false
-		},
-		variables: [
-			"branch"
-		]
-	},
-	{
-		id: "performance-monitor",
-		name: "Performance Monitor",
-		category: "monitoring",
-		description: "Monitor and log performance metrics",
-		hook: {
-			name: "Performance Monitor",
-			version: "1.0.0",
-			trigger: {
-				type: "event",
-				event: "task-complete"
-			},
-			actions: [
-				{
-					type: "transform",
-					config: {
-						input: "{{taskDuration}}",
-						transform: "log-performance",
-						output: "performance.log"
-					}
-				},
-				{
-					type: "call_api",
-					config: {
-						url: "{{metricsUrl}}",
-						method: "POST",
-						body: {
-							task: "{{taskId}}",
-							duration: "{{taskDuration}}",
-							timestamp: "{{timestamp}}"
-						}
-					}
-				}
-			],
-			conditions: [
-				{
-					field: "taskDuration",
-					operator: "gt",
-					value: "1000"
-				}
-			],
-			privacy: "private",
-			enabled: false
-		},
-		variables: [
-			"taskId",
-			"taskDuration",
-			"timestamp",
-			"metricsUrl"
-		]
-	}
-];
-const categories = [
-	{
-		id: "code-quality",
-		name: {
-			en: "Code Quality",
-			"zh-CN": "代码质量"
-		},
-		description: {
-			en: "Hooks for maintaining code quality and formatting",
-			"zh-CN": "用于维护代码质量和格式化的钩子"
-		},
-		icon: "✨"
-	},
-	{
-		id: "git",
-		name: {
-			en: "Git Workflow",
-			"zh-CN": "Git 工作流"
-		},
-		description: {
-			en: "Hooks for Git operations and version control",
-			"zh-CN": "用于 Git 操作和版本控制的钩子"
-		},
-		icon: "🔀"
-	},
-	{
-		id: "testing",
-		name: {
-			en: "Testing",
-			"zh-CN": "测试"
-		},
-		description: {
-			en: "Hooks for automated testing workflows",
-			"zh-CN": "用于自动化测试工作流的钩子"
-		},
-		icon: "🧪"
-	},
-	{
-		id: "documentation",
-		name: {
-			en: "Documentation",
-			"zh-CN": "文档"
-		},
-		description: {
-			en: "Hooks for documentation generation and updates",
-			"zh-CN": "用于文档生成和更新的钩子"
-		},
-		icon: "📚"
-	},
-	{
-		id: "security",
-		name: {
-			en: "Security",
-			"zh-CN": "安全"
-		},
-		description: {
-			en: "Hooks for security scanning and vulnerability checks",
-			"zh-CN": "用于安全扫描和漏洞检查的钩子"
-		},
-		icon: "🔒"
-	},
-	{
-		id: "notification",
-		name: {
-			en: "Notifications",
-			"zh-CN": "通知"
-		},
-		description: {
-			en: "Hooks for sending notifications and alerts",
-			"zh-CN": "用于发送通知和警报的钩子"
-		},
-		icon: "🔔"
-	},
-	{
-		id: "logging",
-		name: {
-			en: "Logging",
-			"zh-CN": "日志"
-		},
-		description: {
-			en: "Hooks for logging and audit trails",
-			"zh-CN": "用于日志记录和审计跟踪的钩子"
-		},
-		icon: "📝"
-	},
-	{
-		id: "backup",
-		name: {
-			en: "Backup",
-			"zh-CN": "备份"
-		},
-		description: {
-			en: "Hooks for automated backups",
-			"zh-CN": "用于自动备份的钩子"
-		},
-		icon: "💾"
-	},
-	{
-		id: "collaboration",
-		name: {
-			en: "Collaboration",
-			"zh-CN": "协作"
-		},
-		description: {
-			en: "Hooks for team collaboration workflows",
-			"zh-CN": "用于团队协作工作流的钩子"
-		},
-		icon: "👥"
-	},
-	{
-		id: "monitoring",
-		name: {
-			en: "Monitoring",
-			"zh-CN": "监控"
-		},
-		description: {
-			en: "Hooks for performance and system monitoring",
-			"zh-CN": "用于性能和系统监控的钩子"
-		},
-		icon: "📊"
-	}
-];
-const hookTemplatesData = {
-	templates: templates,
-	categories: categories
-};
-
-class CloudHooksSyncClient {
-  baseUrl;
-  apiKey;
-  timeout;
-  enableLogging;
-  constructor(options = {}) {
-    this.baseUrl = options.baseUrl || "https://api.api.claudehome.cn/v1/hooks";
-    this.apiKey = options.apiKey;
-    this.timeout = options.timeout || 3e4;
-    this.enableLogging = options.enableLogging || false;
-  }
-  // ==========================================================================
-  // Public API Methods
-  // ==========================================================================
-  /**
-   * Upload hooks to cloud
-   *
-   * @param hooks - Hooks to upload
-   * @returns Upload result
-   */
-  async uploadHooks(hooks) {
-    this.log("Uploading hooks:", hooks.length);
-    return this.request("/upload", {
-      method: "POST",
-      body: JSON.stringify({ hooks })
-    });
-  }
-  /**
-   * Download hooks from cloud
-   *
-   * @param options - Download options
-   * @param options.privacy - Filter by privacy level
-   * @param options.category - Filter by category
-   * @param options.tags - Filter by tags
-   * @returns Downloaded hooks
-   */
-  async downloadHooks(options) {
-    this.log("Downloading hooks with options:", options);
-    return this.request("/download", {
-      method: "GET",
-      params: options
-    });
-  }
-  /**
-   * Sync hooks bidirectionally
-   *
-   * @param localHooks - Local hooks to sync
-   * @param options - Sync options
-   * @returns Sync result
-   */
-  async syncHooks(localHooks, options) {
-    this.log("Syncing hooks:", localHooks.length, "options:", options);
-    return this.request("/sync", {
-      method: "POST",
-      body: JSON.stringify({ hooks: localHooks, options })
-    });
-  }
-  /**
-   * Get hook templates
-   *
-   * @param options - Filter options
-   * @param options.category - Filter by category
-   * @param options.tags - Filter by tags
-   * @param options.language - Filter by language
-   * @returns Hook templates
-   */
-  async getTemplates(options) {
-    this.log("Getting templates with options:", options);
-    return this.request("/templates", {
-      method: "GET",
-      params: options
-    });
-  }
-  /**
-   * Get a specific hook template
-   *
-   * @param id - Template ID
-   * @returns Hook template
-   */
-  async getTemplate(id) {
-    this.log("Getting template:", id);
-    return this.request(`/templates/${id}`, {
-      method: "GET"
-    });
-  }
-  /**
-   * Get hook by ID
-   *
-   * @param id - Hook ID
-   * @returns Hook details
-   */
-  async getHook(id) {
-    this.log("Getting hook:", id);
-    return this.request(`/hooks/${id}`, {
-      method: "GET"
-    });
-  }
-  /**
-   * Delete hook from cloud
-   *
-   * @param id - Hook ID
-   * @returns Deletion result
-   */
-  async deleteHook(id) {
-    this.log("Deleting hook:", id);
-    return this.request(`/hooks/${id}`, {
-      method: "DELETE"
-    });
-  }
-  /**
-   * Get hook execution logs
-   *
-   * @param hookId - Hook ID
-   * @param options - Filter options
-   * @param options.limit - Maximum number of logs to return
-   * @param options.offset - Offset for pagination
-   * @param options.status - Filter by execution status
-   * @returns Execution logs
-   */
-  async getExecutionLogs(hookId, options) {
-    this.log("Getting execution logs for hook:", hookId, "options:", options);
-    return this.request(`/hooks/${hookId}/logs`, {
-      method: "GET",
-      params: options
-    });
-  }
-  /**
-   * Enable/disable hook
-   *
-   * @param id - Hook ID
-   * @param enabled - Whether to enable or disable
-   * @returns Update result
-   */
-  async setHookEnabled(id, enabled) {
-    this.log("Setting hook enabled:", id, enabled);
-    return this.request(`/hooks/${id}/enabled`, {
-      method: "PUT",
-      body: JSON.stringify({ enabled })
-    });
-  }
-  // ==========================================================================
-  // Private Helper Methods
-  // ==========================================================================
-  /**
-   * Make HTTP request to cloud service
-   */
-  async request(endpoint, options = {}) {
-    const url = this.buildUrl(endpoint, options.params);
-    try {
-      const response = await fetch(url, {
-        method: options.method || "GET",
-        headers: this.getHeaders(),
-        body: options.body,
-        signal: AbortSignal.timeout(this.timeout)
-      });
-      const data = await response.json();
-      if (!response.ok) {
-        return {
-          success: false,
-          error: data.error || `HTTP ${response.status}: ${response.statusText}`,
-          code: data.code || `HTTP_${response.status}`
-        };
-      }
-      return {
-        ...data,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-    } catch (error) {
-      if (error instanceof Error) {
-        return {
-          success: false,
-          error: error.message,
-          code: "NETWORK_ERROR"
-        };
-      }
-      return {
-        success: false,
-        error: String(error),
-        code: "UNKNOWN_ERROR"
-      };
-    }
-  }
-  /**
-   * Build full URL with query parameters
-   */
-  buildUrl(endpoint, params) {
-    const url = new URL(endpoint, this.baseUrl);
-    if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        if (value !== void 0 && value !== null) {
-          if (Array.isArray(value)) {
-            value.forEach((v) => url.searchParams.append(key, String(v)));
-          } else {
-            url.searchParams.append(key, String(value));
-          }
-        }
-      }
-    }
-    return url.toString();
-  }
-  /**
-   * Get request headers
-   */
-  getHeaders() {
-    const headers = {
-      "Content-Type": "application/json",
-      "User-Agent": "CCJK-Hooks-Sync/1.0"
-    };
-    if (this.apiKey) {
-      headers.Authorization = `Bearer ${this.apiKey}`;
-    }
-    return headers;
-  }
-  /**
-   * Log message (if logging is enabled)
-   */
-  log(...args) {
-    if (this.enableLogging) {
-      console.log("[CloudHooksSyncClient]", ...args);
-    }
-  }
-}
-function convertFromCloudHook(cloudHook) {
-  return {
-    id: cloudHook.id,
-    name: cloudHook.name,
-    description: cloudHook.metadata.description,
-    type: cloudHook.trigger.event || "pre-tool-use",
-    priority: 5,
-    condition: cloudHook.conditions ? convertFromCloudConditions(cloudHook.conditions) : void 0,
-    action: {
-      execute: async () => {
-        return {
-          success: true,
-          status: "success",
-          durationMs: 0,
-          continueChain: true
-        };
-      }
-    },
-    enabled: cloudHook.enabled,
-    source: cloudHook.metadata.category,
-    version: cloudHook.version,
-    author: cloudHook.metadata.author,
-    tags: cloudHook.metadata.tags
-  };
-}
-function convertFromCloudConditions(conditions) {
-  const condition = {};
-  for (const cond of conditions) {
-    if (cond.field === "tool") {
-      condition.tool = cond.operator === "matches" ? new RegExp(cond.value) : cond.value;
-    } else if (cond.field === "skillId") {
-      condition.skillId = cond.operator === "matches" ? new RegExp(cond.value) : cond.value;
-    } else if (cond.field === "workflowId") {
-      condition.workflowId = cond.operator === "matches" ? new RegExp(cond.value) : cond.value;
-    }
-  }
-  return condition;
-}
-
-class HookRegistry {
-  state;
-  constructor() {
-    this.state = {
-      version: "1.0.0",
-      hooks: /* @__PURE__ */ new Map(),
-      hooksByType: /* @__PURE__ */ new Map(),
-      hooksByTool: /* @__PURE__ */ new Map(),
-      lastUpdated: /* @__PURE__ */ new Date()
-    };
-  }
-  /**
-   * Register a hook
-   *
-   * @param hook - Hook to register
-   * @param options - Registration options
-   * @returns Whether registration was successful
-   */
-  register(hook, options) {
-    const existingEntry = this.state.hooks.get(hook.id);
-    if (existingEntry && !options?.overwrite) {
-      return false;
-    }
-    const entry = {
-      hook: {
-        ...hook,
-        enabled: options?.enabled ?? hook.enabled
-      },
-      registeredAt: /* @__PURE__ */ new Date(),
-      source: options?.source ?? hook.source,
-      executionCount: 0,
-      failureCount: 0
-    };
-    this.state.hooks.set(hook.id, entry);
-    const typeHooks = this.state.hooksByType.get(hook.type) ?? [];
-    if (!typeHooks.includes(hook.id)) {
-      typeHooks.push(hook.id);
-      this.state.hooksByType.set(hook.type, typeHooks);
-    }
-    if (hook.condition?.tool && typeof hook.condition.tool === "string") {
-      const toolHooks = this.state.hooksByTool.get(hook.condition.tool) ?? [];
-      if (!toolHooks.includes(hook.id)) {
-        toolHooks.push(hook.id);
-        this.state.hooksByTool.set(hook.condition.tool, toolHooks);
-      }
-    }
-    this.state.lastUpdated = /* @__PURE__ */ new Date();
-    return true;
-  }
-  /**
-   * Unregister a hook
-   *
-   * @param hookId - ID of hook to unregister
-   * @returns Whether unregistration was successful
-   */
-  unregister(hookId) {
-    const entry = this.state.hooks.get(hookId);
-    if (!entry) {
-      return false;
-    }
-    this.state.hooks.delete(hookId);
-    const typeHooks = this.state.hooksByType.get(entry.hook.type);
-    if (typeHooks) {
-      const index = typeHooks.indexOf(hookId);
-      if (index !== -1) {
-        typeHooks.splice(index, 1);
-      }
-    }
-    if (entry.hook.condition?.tool && typeof entry.hook.condition.tool === "string") {
-      const toolHooks = this.state.hooksByTool.get(entry.hook.condition.tool);
-      if (toolHooks) {
-        const index = toolHooks.indexOf(hookId);
-        if (index !== -1) {
-          toolHooks.splice(index, 1);
-        }
-      }
-    }
-    this.state.lastUpdated = /* @__PURE__ */ new Date();
-    return true;
-  }
-  /**
-   * Get a hook by ID
-   *
-   * @param hookId - Hook ID
-   * @returns Hook entry or undefined
-   */
-  get(hookId) {
-    return this.state.hooks.get(hookId);
-  }
-  /**
-   * Get hooks for a specific type
-   *
-   * @param type - Hook type
-   * @returns Array of hooks sorted by priority
-   */
-  getHooksForType(type) {
-    const hookIds = this.state.hooksByType.get(type) ?? [];
-    return hookIds.map((id) => this.state.hooks.get(id)?.hook).filter((hook) => hook !== void 0).sort((a, b) => (b.priority ?? 5) - (a.priority ?? 5));
-  }
-  /**
-   * Get hooks for a specific tool
-   *
-   * @param tool - Tool name
-   * @returns Array of hooks sorted by priority
-   */
-  getHooksForTool(tool) {
-    const hookIds = this.state.hooksByTool.get(tool) ?? [];
-    return hookIds.map((id) => this.state.hooks.get(id)?.hook).filter((hook) => hook !== void 0).sort((a, b) => (b.priority ?? 5) - (a.priority ?? 5));
-  }
-  /**
-   * Filter hooks based on options
-   *
-   * @param options - Filter options
-   * @returns Array of matching hooks
-   */
-  filter(options) {
-    let hooks = Array.from(this.state.hooks.values()).map((entry) => entry.hook);
-    if (options.type) {
-      hooks = hooks.filter((h) => h.type === options.type);
-    }
-    if (options.enabled !== void 0) {
-      hooks = hooks.filter((h) => h.enabled === options.enabled);
-    }
-    if (options.source) {
-      hooks = hooks.filter((h) => h.source === options.source);
-    }
-    if (options.tags && options.tags.length > 0) {
-      hooks = hooks.filter(
-        (h) => options.tags.every((tag) => h.tags?.includes(tag))
-      );
-    }
-    if (options.priorityRange) {
-      const { min, max } = options.priorityRange;
-      hooks = hooks.filter((h) => {
-        const priority = h.priority ?? 5;
-        if (min !== void 0 && priority < min)
-          return false;
-        if (max !== void 0 && priority > max)
-          return false;
-        return true;
-      });
-    }
-    return hooks.sort((a, b) => (b.priority ?? 5) - (a.priority ?? 5));
-  }
-  /**
-   * Enable a hook
-   *
-   * @param hookId - Hook ID
-   * @returns Whether operation was successful
-   */
-  enable(hookId) {
-    const entry = this.state.hooks.get(hookId);
-    if (!entry)
-      return false;
-    entry.hook.enabled = true;
-    this.state.lastUpdated = /* @__PURE__ */ new Date();
-    return true;
-  }
-  /**
-   * Disable a hook
-   *
-   * @param hookId - Hook ID
-   * @returns Whether operation was successful
-   */
-  disable(hookId) {
-    const entry = this.state.hooks.get(hookId);
-    if (!entry)
-      return false;
-    entry.hook.enabled = false;
-    this.state.lastUpdated = /* @__PURE__ */ new Date();
-    return true;
-  }
-  /**
-   * Update hook execution statistics
-   *
-   * @param hookId - Hook ID
-   * @param success - Whether execution was successful
-   * @param result - Execution result
-   */
-  updateStats(hookId, success, result) {
-    const entry = this.state.hooks.get(hookId);
-    if (!entry)
-      return;
-    entry.executionCount++;
-    if (!success) {
-      entry.failureCount++;
-    }
-    entry.lastExecutedAt = /* @__PURE__ */ new Date();
-    entry.lastResult = result;
-  }
-  /**
-   * Get registry statistics
-   *
-   * @returns Hook statistics
-   */
-  getStatistics() {
-    const entries = Array.from(this.state.hooks.values());
-    const hooks = entries.map((e) => e.hook);
-    const hooksByType = {
-      "pre-tool-use": 0,
-      "post-tool-use": 0,
-      "skill-activate": 0,
-      "skill-complete": 0,
-      "workflow-start": 0,
-      "workflow-complete": 0,
-      "config-change": 0,
-      "error": 0,
-      "task-start": 0,
-      "task-complete": 0,
-      "task-failed": 0,
-      "task-progress": 0
-    };
-    const hooksBySource = {};
-    for (const hook of hooks) {
-      hooksByType[hook.type]++;
-      hooksBySource[hook.source] = (hooksBySource[hook.source] ?? 0) + 1;
-    }
-    const totalExecutions = entries.reduce((sum, e) => sum + e.executionCount, 0);
-    const totalFailures = entries.reduce((sum, e) => sum + e.failureCount, 0);
-    const mostExecuted = entries.filter((e) => e.executionCount > 0).sort((a, b) => b.executionCount - a.executionCount).slice(0, 5).map((e) => ({ hookId: e.hook.id, executionCount: e.executionCount }));
-    const mostFailed = entries.filter((e) => e.failureCount > 0).sort((a, b) => b.failureCount - a.failureCount).slice(0, 5).map((e) => ({ hookId: e.hook.id, failureCount: e.failureCount }));
-    return {
-      totalHooks: hooks.length,
-      enabledHooks: hooks.filter((h) => h.enabled).length,
-      disabledHooks: hooks.filter((h) => !h.enabled).length,
-      totalExecutions,
-      totalFailures,
-      averageExecutionMs: 0,
-      // Would need to track this separately
-      hooksByType,
-      hooksBySource,
-      mostExecuted,
-      mostFailed
-    };
-  }
-  /**
-   * Clear all hooks
-   */
-  clear() {
-    this.state.hooks.clear();
-    this.state.hooksByType.clear();
-    this.state.hooksByTool.clear();
-    this.state.lastUpdated = /* @__PURE__ */ new Date();
-  }
-  /**
-   * Get all hooks
-   *
-   * @returns Array of all hooks
-   */
-  getAll() {
-    return Array.from(this.state.hooks.values()).map((entry) => entry.hook);
-  }
-}
-let globalRegistry = null;
-function getGlobalRegistry() {
-  if (!globalRegistry) {
-    globalRegistry = new HookRegistry();
-  }
-  return globalRegistry;
-}
-
-const HOOKS_DIR = join(homedir(), ".ccjk", "hooks");
-const HOOKS_STORAGE_FILE = join(HOOKS_DIR, "hooks.json");
-async function hooksSync(options = {}) {
-  try {
-    if (!options.skipBanner) {
-      displayBannerWithInfo();
-    }
-    const lang = options.lang || "zh-CN";
-    if (options.action) {
-      switch (options.action) {
-        case "sync":
-          await syncHooks();
-          break;
-        case "list":
-          await listHooks(options);
-          break;
-        case "enable":
-          if (!options.hookId) {
-            console.log(ansis.red(i18n.t("menu:hooksSync.errors.hookIdRequired")));
-            return;
-          }
-          await toggleHook(options.hookId, true);
-          break;
-        case "disable":
-          if (!options.hookId) {
-            console.log(ansis.red(i18n.t("menu:hooksSync.errors.hookIdRequired")));
-            return;
-          }
-          await toggleHook(options.hookId, false);
-          break;
-        case "templates":
-          await browseTemplates(lang, options);
-          break;
-        case "upload":
-          await uploadHooks();
-          break;
-        case "download":
-          await downloadHooks(options);
-          break;
-        default:
-          await showHooksMenu(lang);
-      }
-    } else {
-      await showHooksMenu(lang);
-    }
-  } catch (error) {
-    if (!handleExitPromptError(error)) {
-      handleGeneralError(error);
-    }
-  }
-}
-async function showHooksMenu(lang) {
-  while (true) {
-    console.log(ansis.green.bold(`
-${i18n.t("menu:hooksSync.title")}
-`));
-    const { action } = await inquirer.prompt([{
-      type: "list",
-      name: "action",
-      message: i18n.t("menu:mcpMarket.selectAction"),
-      choices: [
-        { name: `\u{1F504} ${i18n.t("menu:hooksSync.syncNow")}`, value: "sync" },
-        { name: `\u{1F4CB} ${i18n.t("menu:hooksSync.viewStatus")}`, value: "list" },
-        { name: `\u{1F4DA} ${i18n.t("menu:hooksSync.browseTemplates")}`, value: "templates" },
-        { name: `\u2601\uFE0F  ${i18n.t("menu:mcpMarket.upload") || "Upload"}`, value: "upload" },
-        { name: `\u{1F4E5} ${i18n.t("menu:mcpMarket.download") || "Download"}`, value: "download" },
-        new inquirer.Separator(),
-        { name: ansis.gray(`\u21A9\uFE0F  ${i18n.t("common:back")}`), value: "back" }
-      ]
-    }]);
-    if (!action || action === "back") {
-      break;
-    }
-    switch (action) {
-      case "sync":
-        await syncHooks();
-        break;
-      case "list":
-        await listHooks();
-        break;
-      case "templates":
-        await browseTemplates(lang);
-        break;
-      case "upload":
-        await uploadHooks();
-        break;
-      case "download":
-        await downloadHooks();
-        break;
-    }
-  }
-}
-async function syncHooks() {
-  console.log(ansis.green(`
-\u23F3 ${i18n.t("menu:hooksSync.syncNowDesc")}...`));
-  try {
-    const localHooks = await loadLocalHooks();
-    console.log(ansis.dim(`  ${i18n.t("hooksSync:labels.localHooks")}: ${localHooks.length}`));
-    const client = new CloudHooksSyncClient({
-      enableLogging: false
-    });
-    const result = await client.syncHooks(localHooks, {
-      direction: "bidirectional",
-      overwrite: false
-    });
-    if (result.success && result.data) {
-      console.log(ansis.green(`
-\u2705 ${i18n.t("hooksSync:actions.syncCompleted")}`));
-      console.log(ansis.dim(`  ${i18n.t("hooksSync:labels.uploaded")}: ${result.data.uploaded}`));
-      console.log(ansis.dim(`  ${i18n.t("hooksSync:labels.downloaded")}: ${result.data.downloaded}`));
-      console.log(ansis.dim(`  ${i18n.t("hooksSync:labels.skipped")}: ${result.data.skipped}`));
-      if (result.data.failed > 0) {
-        console.log(ansis.yellow(`  ${i18n.t("hooksSync:labels.failed")}: ${result.data.failed}`));
-      }
-      await saveLocalHooks(localHooks, result.data.timestamp);
-    } else {
-      console.log(ansis.red(`
-\u274C ${i18n.t("hooksSync:actions.syncError", { error: result.error || "Unknown error" })}`));
-    }
-  } catch (error) {
-    console.log(ansis.red(`
-\u274C ${i18n.t("hooksSync:actions.syncError", { error: error instanceof Error ? error.message : String(error) })}`));
-  }
-}
-async function uploadHooks() {
-  console.log(ansis.green(`
-\u23F3 ${i18n.t("hooksSync:actions.uploading")}`));
-  try {
-    const localHooks = await loadLocalHooks();
-    if (localHooks.length === 0) {
-      console.log(ansis.yellow(`
-\u26A0\uFE0F  ${i18n.t("hooksSync:errors.noHooksFound")}`));
-      return;
-    }
-    console.log(ansis.dim(`  ${i18n.t("hooksSync:labels.found")} ${localHooks.length} ${i18n.t("hooksSync:labels.localHooks").toLowerCase()}`));
-    const client = new CloudHooksSyncClient();
-    const result = await client.uploadHooks(localHooks);
-    if (result.success && result.data) {
-      console.log(ansis.green(`
-\u2705 ${i18n.t("hooksSync:actions.uploadCompleted")}`));
-      console.log(ansis.dim(`  ${i18n.t("hooksSync:labels.uploaded")}: ${result.data.uploaded}`));
-    } else {
-      console.log(ansis.red(`
-\u274C ${i18n.t("hooksSync:actions.uploadError", { error: result.error || "Unknown error" })}`));
-    }
-  } catch (error) {
-    console.log(ansis.red(`
-\u274C ${i18n.t("hooksSync:actions.uploadError", { error: error instanceof Error ? error.message : String(error) })}`));
-  }
-}
-async function downloadHooks(options = {}) {
-  console.log(ansis.green(`
-\u23F3 ${i18n.t("hooksSync:actions.downloading")}`));
-  try {
-    const client = new CloudHooksSyncClient();
-    const result = await client.downloadHooks({
-      privacy: options.privacy,
-      category: options.category
-    });
-    if (result.success && result.data) {
-      console.log(ansis.green(`
-\u2705 ${i18n.t("hooksSync:actions.downloadCompleted")}`));
-      console.log(ansis.dim(`  ${i18n.t("hooksSync:labels.downloaded")}: ${result.data.length}`));
-      await saveLocalHooks(result.data);
-      result.data.forEach((hook) => {
-        console.log(`  ${ansis.green("\u2022")} ${hook.name} ${ansis.dim(`(${hook.id})`)}`);
-      });
-    } else {
-      console.log(ansis.red(`
-\u274C ${i18n.t("hooksSync:actions.downloadError", { error: result.error || "Unknown error" })}`));
-    }
-  } catch (error) {
-    console.log(ansis.red(`
-\u274C ${i18n.t("hooksSync:actions.downloadError", { error: error instanceof Error ? error.message : String(error) })}`));
-  }
-}
-async function listHooks(options = {}) {
-  console.log(ansis.green.bold(`
-\u{1F4CB} ${i18n.t("hooksSync:labels.localHooks")}
-`));
-  try {
-    const hooks = await loadLocalHooks();
-    if (hooks.length === 0) {
-      console.log(ansis.yellow(`  ${i18n.t("hooksSync:errors.noHooksFound")}`));
-      return;
-    }
-    const filteredHooks = options.category ? hooks.filter((h) => h.metadata.category === options.category) : hooks;
-    const byCategory = /* @__PURE__ */ new Map();
-    for (const hook of filteredHooks) {
-      const category = hook.metadata.category;
-      if (!byCategory.has(category)) {
-        byCategory.set(category, []);
-      }
-      byCategory.get(category).push(hook);
-    }
-    for (const [category, categoryHooks] of byCategory) {
-      console.log(ansis.bold(`
-${category}:`));
-      for (const hook of categoryHooks) {
-        const status = hook.enabled ? ansis.green("\u2713") : ansis.red("\u2717");
-        const privacy = hook.privacy === "public" ? ansis.green("\u{1F310}") : ansis.dim("\u{1F512}");
-        console.log(`  ${status} ${privacy} ${hook.name} ${ansis.dim(`(${hook.id})`)}`);
-        console.log(`     ${ansis.dim(hook.metadata.description)}`);
-      }
-    }
-    console.log(ansis.dim(`
-${i18n.t("hooksSync:labels.total")}: ${filteredHooks.length}`));
-  } catch (error) {
-    console.log(ansis.red(`
-\u274C ${i18n.t("common:error")}: ${error instanceof Error ? error.message : String(error)}`));
-  }
-}
-async function toggleHook(hookId, enabled) {
-  try {
-    const hooks = await loadLocalHooks();
-    const hook = hooks.find((h) => h.id === hookId);
-    if (!hook) {
-      console.log(ansis.red(`
-\u274C ${i18n.t("hooksSync:errors.hookNotFound", { id: hookId })}`));
-      return;
-    }
-    hook.enabled = enabled;
-    await saveLocalHooks(hooks);
-    const registry = getGlobalRegistry();
-    convertFromCloudHook(hook);
-    const entry = registry.get(hookId);
-    if (entry) {
-      if (enabled) {
-        registry.enable(hookId);
-      } else {
-        registry.disable(hookId);
-      }
-    }
-    const status = enabled ? ansis.green(i18n.t("hooksSync:labels.enabled")) : ansis.red(i18n.t("hooksSync:labels.disabled"));
-    console.log(`
-\u2705 ${i18n.t("hooksSync:actions.hookToggled", { status, name: hook.name })}`);
-  } catch (error) {
-    console.log(ansis.red(`
-\u274C ${i18n.t("common:error")}: ${error instanceof Error ? error.message : String(error)}`));
-  }
-}
-async function browseTemplates(lang, options = {}) {
-  console.log(ansis.green.bold(`
-\u{1F4DA} ${i18n.t("menu:hooksSync.browseTemplates")}
-`));
-  try {
-    const templates = hookTemplatesData.templates;
-    const categories = hookTemplatesData.categories;
-    const filteredTemplates = options.category ? templates.filter((t) => t.category === options.category) : templates;
-    if (filteredTemplates.length === 0) {
-      console.log(ansis.yellow(`  ${i18n.t("hooksSync:errors.noTemplatesFound")}`));
-      return;
-    }
-    console.log(ansis.bold(`${i18n.t("hooksSync:labels.categories")}:`));
-    for (const cat of categories) {
-      const count = templates.filter((t) => t.category === cat.id).length;
-      const catName = cat.name[lang] || cat.name.en;
-      console.log(`  ${cat.icon} ${catName} ${ansis.dim(`(${count})`)}`);
-    }
-    const { templateId } = await inquirer.prompt([{
-      type: "list",
-      name: "templateId",
-      message: i18n.t("hooksSync:prompts.selectTemplate"),
-      choices: filteredTemplates.map((t) => ({
-        name: `${t.name} - ${t.description}`,
-        value: t.id
-      }))
-    }]);
-    if (!templateId) {
-      return;
-    }
-    const template = templates.find((t) => t.id === templateId);
-    if (!template) {
-      return;
-    }
-    console.log(ansis.bold(`
-${template.name}`));
-    console.log(ansis.dim(template.description));
-    console.log(ansis.bold(`
-${i18n.t("hooksSync:labels.category")}: `) + template.category);
-    console.log(ansis.bold(`${i18n.t("hooksSync:labels.variables")}: `) + template.variables.join(", "));
-    const { confirm } = await inquirer.prompt([{
-      type: "confirm",
-      name: "confirm",
-      message: i18n.t("hooksSync:prompts.confirmInstall"),
-      default: true
-    }]);
-    if (!confirm) {
-      return;
-    }
-    await installTemplate(template);
-  } catch (error) {
-    console.log(ansis.red(`
-\u274C ${i18n.t("common:error")}: ${error instanceof Error ? error.message : String(error)}`));
-  }
-}
-async function installTemplate(template) {
-  try {
-    const cloudHook = {
-      id: `template-${template.id}-${Date.now()}`,
-      ...template.hook,
-      metadata: {
-        author: "CCJK Templates",
-        description: template.description,
-        tags: [template.category],
-        category: template.category,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-    const hooks = await loadLocalHooks();
-    hooks.push(cloudHook);
-    await saveLocalHooks(hooks);
-    const registry = getGlobalRegistry();
-    const localHook = convertFromCloudHook(cloudHook);
-    registry.register(localHook);
-    console.log(ansis.green(`
-\u2705 ${i18n.t("hooksSync:actions.templateInstalled", { name: template.name })}`));
-  } catch (error) {
-    console.log(ansis.red(`
-\u274C ${i18n.t("hooksSync:actions.installError", { error: error instanceof Error ? error.message : String(error) })}`));
-  }
-}
-async function loadLocalHooks() {
-  try {
-    await ensureDir(HOOKS_DIR);
-    if (!await exists(HOOKS_STORAGE_FILE)) {
-      return [];
-    }
-    const storage = await readJsonFile(HOOKS_STORAGE_FILE);
-    return storage?.hooks || [];
-  } catch (error) {
-    console.error(i18n.t("hooksSync:errors.loadHooksFailed"), error);
-    return [];
-  }
-}
-async function saveLocalHooks(hooks, lastSyncedAt) {
-  try {
-    await ensureDir(HOOKS_DIR);
-    const storage = {
-      version: "1.0.0",
-      hooks,
-      lastSyncedAt: lastSyncedAt || (/* @__PURE__ */ new Date()).toISOString()
-    };
-    await writeFileAtomic(HOOKS_STORAGE_FILE, JSON.stringify(storage, null, 2));
-  } catch (error) {
-    console.error(i18n.t("hooksSync:errors.saveHooksFailed"), error);
-    throw error;
-  }
-}
-
-export { hooksSync as default, hooksSync };