ccjk 12.2.1 → 12.2.2

package/dist/chunks/auto-init.mjs

@@ -1,87 +1,13 @@
-import { l as logger } from '../shared/ccjk.DG_o24cZ.mjs';
+import { h as hookRegistry } from '../shared/ccjk.CCcQfbni.mjs';
 import { createRequire } from 'node:module';
 import { c as commonjsGlobal } from '../shared/ccjk.BAGoDD49.mjs';
 import require$$0 from 'crypto';
+import { l as logger } from '../shared/ccjk.DG_o24cZ.mjs';
 import { existsSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import './index2.mjs';
 
-class HookRegistry {
-  hooks = /* @__PURE__ */ new Map();
-  /**
-   * Register a hook for an event
-   */
-  register(event, hook) {
-    const hooks = this.hooks.get(event) || [];
-    hooks.push(hook);
-    hooks.sort((a, b) => (b.priority || 0) - (a.priority || 0));
-    this.hooks.set(event, hooks);
-    logger.debug(`Registered hook "${hook.name}" for event "${event}"`);
-  }
-  /**
-   * Unregister a hook
-   */
-  unregister(event, hookName) {
-    const hooks = this.hooks.get(event);
-    if (!hooks) return;
-    const filtered = hooks.filter((h) => h.name !== hookName);
-    this.hooks.set(event, filtered);
-    logger.debug(`Unregistered hook "${hookName}" for event "${event}"`);
-  }
-  /**
-   * Execute all hooks for an event
-   * Returns false if any hook returns continue: false
-   */
-  async execute(context) {
-    const hooks = this.hooks.get(context.event) || [];
-    const enabledHooks = hooks.filter((h) => h.enabled !== false);
-    if (enabledHooks.length === 0) {
-      return { continue: true };
-    }
-    let currentContext = context;
-    let aggregatedData = {};
-    for (const hook of enabledHooks) {
-      try {
-        const result = await hook.fn(currentContext);
-        if (result.data) {
-          aggregatedData = { ...aggregatedData, ...result.data };
-        }
-        if (!result.continue) {
-          return {
-            continue: false,
-            data: aggregatedData,
-            error: result.error
-          };
-        }
-        currentContext = {
-          ...currentContext,
-          data: { ...currentContext.data, ...aggregatedData }
-        };
-      } catch (error) {
-        logger.error(`Hook "${hook.name}" failed:`, error);
-      }
-    }
-    return {
-      continue: true,
-      data: aggregatedData
-    };
-  }
-  /**
-   * Get all registered hooks for an event
-   */
-  getHooks(event) {
-    return this.hooks.get(event) || [];
-  }
-  /**
-   * Clear all hooks
-   */
-  clear() {
-    this.hooks.clear();
-  }
-}
-const hookRegistry = new HookRegistry();
-
 var cuid2 = {};
 
 var src = {};

package/dist/chunks/cli-hook.mjs

@@ -1,9 +1,19 @@
 import { EventEmitter } from 'node:events';
+import { contextLoader } from './context-loader.mjs';
+import { l as logger } from '../shared/ccjk.DG_o24cZ.mjs';
+import { h as hookRegistry } from '../shared/ccjk.CCcQfbni.mjs';
+import { Buffer } from 'node:buffer';
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { d as dirname, j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
 import { a as getGlobalStateManager, g as getGlobalConvoyManager, S as SessionIntelligence } from './convoy-manager.mjs';
 import { n as nanoid } from '../shared/ccjk.BoApaI4j.mjs';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
 import process__default from 'node:process';
+import 'tinyglobby';
+import '../shared/ccjk.CePkJq2S.mjs';
+import './index2.mjs';
+import '../shared/ccjk.BAGoDD49.mjs';
+import '../shared/ccjk.BxSmJ8B7.mjs';
 import 'node:child_process';
 import 'node:fs/promises';
 import 'node:os';
@@ -12,7 +22,918 @@ import './main.mjs';
 import 'module';
 import 'node:stream';
 import 'node:readline';
-import 'node:crypto';
+
+async function emitCommandHookEvent(event, data, sessionId) {
+  try {
+    const context = {
+      event,
+      sessionId,
+      data,
+      timestamp: Date.now(),
+      metadata: {
+        source: "brain-router"
+      }
+    };
+    await hookRegistry.execute(context);
+  } catch (error) {
+    logger.debug(`Command hook bridge skipped for "${event}": ${String(error)}`);
+  }
+}
+
+const DEFAULT_CONFIG = {
+  enablePersistence: false,
+  maxHistorySize: 1e3,
+  messageRetentionTime: 24 * 60 * 60 * 1e3,
+  // 24 hours
+  enableLogging: true,
+  logLevel: "info",
+  enableValidation: true,
+  maxMessageSize: 1024 * 1024,
+  // 1MB
+  enableDeadLetterQueue: true
+};
+class FileMessageStorage {
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.ensureDirectory();
+  }
+  ensureDirectory() {
+    const dir = dirname(this.filePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+  async save(message) {
+    try {
+      const messages = await this.load();
+      messages.push(message);
+      writeFileSync(this.filePath, JSON.stringify(messages, null, 2), "utf-8");
+    } catch (error) {
+      console.error("Failed to save message:", error);
+      throw error;
+    }
+  }
+  async load(filter) {
+    try {
+      if (!existsSync(this.filePath)) {
+        return [];
+      }
+      const content = readFileSync(this.filePath, "utf-8");
+      const messages = JSON.parse(content);
+      if (filter) {
+        return messages.filter(filter);
+      }
+      return messages;
+    } catch (error) {
+      console.error("Failed to load messages:", error);
+      return [];
+    }
+  }
+  async delete(messageId) {
+    try {
+      const messages = await this.load();
+      const filtered = messages.filter((msg) => msg.id !== messageId);
+      writeFileSync(this.filePath, JSON.stringify(filtered, null, 2), "utf-8");
+    } catch (error) {
+      console.error("Failed to delete message:", error);
+      throw error;
+    }
+  }
+  async clear() {
+    try {
+      writeFileSync(this.filePath, JSON.stringify([], null, 2), "utf-8");
+    } catch (error) {
+      console.error("Failed to clear messages:", error);
+      throw error;
+    }
+  }
+  async getStats() {
+    try {
+      if (!existsSync(this.filePath)) {
+        return { count: 0, size: 0 };
+      }
+      const messages = await this.load();
+      const content = readFileSync(this.filePath, "utf-8");
+      return {
+        count: messages.length,
+        size: Buffer.byteLength(content, "utf-8")
+      };
+    } catch (error) {
+      console.error("Failed to get storage stats:", error);
+      return { count: 0, size: 0 };
+    }
+  }
+}
+class MessageBus {
+  config;
+  subscriptions;
+  messageHistory;
+  deadLetterQueue;
+  storage;
+  stats;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.messageHistory = [];
+    this.deadLetterQueue = [];
+    if (this.config.enablePersistence && this.config.persistencePath) {
+      this.storage = new FileMessageStorage(this.config.persistencePath);
+      this.loadPersistedMessages();
+    }
+    this.stats = {
+      totalMessages: 0,
+      messagesByType: {},
+      messagesByStatus: {},
+      activeSubscriptions: 0,
+      historySize: 0,
+      deadLetterQueueSize: 0,
+      avgProcessingTime: 0
+    };
+    this.startCleanupInterval();
+  }
+  /**
+   * Publish a message to the bus
+   */
+  async publish(type, from, to, subject, payload, options = {}) {
+    const message = {
+      id: randomUUID(),
+      type,
+      from,
+      to,
+      subject,
+      payload,
+      priority: options.priority || "normal",
+      status: "pending",
+      timestamp: Date.now(),
+      correlationId: options.correlationId,
+      replyTo: options.replyTo,
+      metadata: options.metadata
+    };
+    if (this.config.enableValidation) {
+      this.validateMessage(message);
+    }
+    this.logMessage("publish", message);
+    this.updateStats(message);
+    this.addToHistory(message);
+    if (this.storage) {
+      await this.storage.save(message);
+    }
+    await this.routeMessage(message);
+    return message.id;
+  }
+  /**
+   * Subscribe to messages
+   */
+  subscribe(subscriber, handler, options = {}) {
+    const subscription = {
+      id: randomUUID(),
+      subscriber,
+      options,
+      handler,
+      createdAt: Date.now(),
+      unsubscribe: () => this.unsubscribe(subscription.id)
+    };
+    this.subscriptions.set(subscription.id, subscription);
+    this.stats.activeSubscriptions = this.subscriptions.size;
+    this.log("info", `Agent ${subscriber} subscribed with ID ${subscription.id}`);
+    return subscription;
+  }
+  /**
+   * Unsubscribe from messages
+   */
+  unsubscribe(subscriptionId) {
+    const subscription = this.subscriptions.get(subscriptionId);
+    if (subscription) {
+      this.subscriptions.delete(subscriptionId);
+      this.stats.activeSubscriptions = this.subscriptions.size;
+      this.log("info", `Subscription ${subscriptionId} removed`);
+    }
+  }
+  /**
+   * Get message by ID
+   */
+  getMessage(messageId) {
+    return this.messageHistory.find((msg) => msg.id === messageId);
+  }
+  /**
+   * Get messages by filter
+   */
+  getMessages(filter) {
+    return this.messageHistory.filter(filter);
+  }
+  /**
+   * Update message status
+   */
+  async updateMessageStatus(messageId, status, error) {
+    const message = this.getMessage(messageId);
+    if (message) {
+      message.status = status;
+      if (error) {
+        message.error = error;
+      }
+      if (status === "failed" && this.config.enableDeadLetterQueue) {
+        this.deadLetterQueue.push(message);
+        this.stats.deadLetterQueueSize = this.deadLetterQueue.length;
+      }
+      this.stats.messagesByStatus[status] = (this.stats.messagesByStatus[status] || 0) + 1;
+      if (this.storage) {
+        await this.storage.save(message);
+      }
+      this.log("debug", `Message ${messageId} status updated to ${status}`);
+    }
+  }
+  /**
+   * Get message bus statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Clear message history
+   */
+  async clearHistory() {
+    this.messageHistory = [];
+    this.stats.historySize = 0;
+    if (this.storage) {
+      await this.storage.clear();
+    }
+    this.log("info", "Message history cleared");
+  }
+  /**
+   * Clear dead letter queue
+   */
+  clearDeadLetterQueue() {
+    this.deadLetterQueue = [];
+    this.stats.deadLetterQueueSize = 0;
+    this.log("info", "Dead letter queue cleared");
+  }
+  /**
+   * Get dead letter queue messages
+   */
+  getDeadLetterQueue() {
+    return [...this.deadLetterQueue];
+  }
+  /**
+   * Shutdown message bus
+   */
+  async shutdown() {
+    this.log("info", "Shutting down message bus");
+    this.subscriptions.clear();
+    this.stats.activeSubscriptions = 0;
+    if (this.storage && this.messageHistory.length > 0) {
+      for (const message of this.messageHistory) {
+        await this.storage.save(message);
+      }
+    }
+    this.log("info", "Message bus shutdown complete");
+  }
+  /**
+   * Route message to subscribers
+   */
+  async routeMessage(message) {
+    const startTime = Date.now();
+    const matchingSubscriptions = this.findMatchingSubscriptions(message);
+    this.log("debug", `Routing message ${message.id} to ${matchingSubscriptions.length} subscribers`);
+    for (const subscription of matchingSubscriptions) {
+      try {
+        message.status = "processing";
+        if (subscription.options.async) {
+          await subscription.handler(message);
+        } else {
+          subscription.handler(message);
+        }
+        message.status = "completed";
+      } catch (error) {
+        this.log("error", `Error handling message ${message.id} in subscription ${subscription.id}:`, error);
+        await this.updateMessageStatus(message.id, "failed", {
+          code: "HANDLER_ERROR",
+          message: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        });
+      }
+    }
+    const processingTime = Date.now() - startTime;
+    this.stats.avgProcessingTime = (this.stats.avgProcessingTime + processingTime) / 2;
+  }
+  /**
+   * Find subscriptions matching the message
+   */
+  findMatchingSubscriptions(message) {
+    const matching = [];
+    const subscriptions = Array.from(this.subscriptions.values());
+    for (const subscription of subscriptions) {
+      const isAddressed = message.to === "all" || message.to === subscription.subscriber || Array.isArray(message.to) && message.to.includes(subscription.subscriber);
+      if (!isAddressed) {
+        continue;
+      }
+      if (!this.matchesSubscriptionFilters(message, subscription.options)) {
+        continue;
+      }
+      matching.push(subscription);
+    }
+    return matching;
+  }
+  /**
+   * Check if message matches subscription filters
+   */
+  matchesSubscriptionFilters(message, options) {
+    if (options.type) {
+      const types = Array.isArray(options.type) ? options.type : [options.type];
+      if (!types.includes(message.type)) {
+        return false;
+      }
+    }
+    if (options.from) {
+      const senders = Array.isArray(options.from) ? options.from : [options.from];
+      if (!senders.includes(message.from)) {
+        return false;
+      }
+    }
+    if (options.priority) {
+      const priorities = Array.isArray(options.priority) ? options.priority : [options.priority];
+      if (!priorities.includes(message.priority)) {
+        return false;
+      }
+    }
+    if (options.filter && !options.filter(message)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Validate message
+   */
+  validateMessage(message) {
+    if (!message.id) {
+      throw new Error("Message ID is required");
+    }
+    if (!message.type) {
+      throw new Error("Message type is required");
+    }
+    if (!message.from) {
+      throw new Error("Message sender is required");
+    }
+    if (!message.to) {
+      throw new Error("Message recipient is required");
+    }
+    if (!message.subject) {
+      throw new Error("Message subject is required");
+    }
+    if (this.config.maxMessageSize) {
+      const messageSize = Buffer.byteLength(JSON.stringify(message), "utf-8");
+      if (messageSize > this.config.maxMessageSize) {
+        throw new Error(`Message size ${messageSize} exceeds maximum ${this.config.maxMessageSize}`);
+      }
+    }
+  }
+  /**
+   * Add message to history
+   */
+  addToHistory(message) {
+    this.messageHistory.push(message);
+    this.stats.historySize = this.messageHistory.length;
+    const maxHistorySize = this.config.maxHistorySize ?? 1e3;
+    if (this.messageHistory.length > maxHistorySize) {
+      this.messageHistory.shift();
+      this.stats.historySize = this.messageHistory.length;
+    }
+  }
+  /**
+   * Update statistics
+   */
+  updateStats(message) {
+    this.stats.totalMessages++;
+    this.stats.messagesByType[message.type] = (this.stats.messagesByType[message.type] || 0) + 1;
+    this.stats.messagesByStatus[message.status] = (this.stats.messagesByStatus[message.status] || 0) + 1;
+  }
+  /**
+   * Load persisted messages
+   */
+  async loadPersistedMessages() {
+    if (!this.storage) {
+      return;
+    }
+    try {
+      const messages = await this.storage.load();
+      this.messageHistory = messages;
+      this.stats.historySize = messages.length;
+      this.log("info", `Loaded ${messages.length} persisted messages`);
+    } catch (error) {
+      this.log("error", "Failed to load persisted messages:", error);
+    }
+  }
+  /**
+   * Start cleanup interval for old messages
+   */
+  startCleanupInterval() {
+    setInterval(() => {
+      const now = Date.now();
+      const retentionTime = this.config.messageRetentionTime ?? 864e5;
+      this.messageHistory = this.messageHistory.filter(
+        (msg) => now - msg.timestamp < retentionTime
+      );
+      this.stats.historySize = this.messageHistory.length;
+      this.deadLetterQueue = this.deadLetterQueue.filter(
+        (msg) => now - msg.timestamp < retentionTime
+      );
+      this.stats.deadLetterQueueSize = this.deadLetterQueue.length;
+      this.log("debug", "Cleanup completed");
+    }, 60 * 60 * 1e3);
+  }
+  /**
+   * Log message
+   */
+  logMessage(action, message) {
+    if (!this.config.enableLogging) {
+      return;
+    }
+    const logLevel = this.config.logLevel;
+    const shouldLog = logLevel === "debug" || logLevel === "info" && ["publish", "subscribe"].includes(action) || logLevel === "warn" && message.priority === "high" || logLevel === "error" && message.status === "failed";
+    if (shouldLog) {
+      this.log("debug", `[${action}] ${message.type} from ${message.from} to ${message.to}: ${message.subject}`);
+    }
+  }
+  /**
+   * Internal logging
+   */
+  log(level, message, ...args) {
+    if (!this.config.enableLogging) {
+      return;
+    }
+    const levels = ["debug", "info", "warn", "error"];
+    const configLevel = levels.indexOf(this.config.logLevel ?? "info");
+    const messageLevel = levels.indexOf(level);
+    if (messageLevel >= configLevel) {
+      console[level](`[MessageBus] ${message}`, ...args);
+    }
+  }
+}
+let globalMessageBus = null;
+function getMessageBus(config) {
+  if (!globalMessageBus) {
+    globalMessageBus = new MessageBus(config);
+  }
+  return globalMessageBus;
+}
+
+class SkillRegistry extends EventEmitter {
+  skills;
+  filePathIndex;
+  triggerIndex;
+  messageBus = getMessageBus();
+  constructor() {
+    super();
+    this.skills = /* @__PURE__ */ new Map();
+    this.filePathIndex = /* @__PURE__ */ new Map();
+    this.triggerIndex = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a skill
+   *
+   * @param skill - Parsed skill file
+   * @param source - Skill source type
+   * @returns Registered entry
+   */
+  register(skill, source = "user") {
+    const id = skill.metadata.name;
+    const existing = this.skills.get(id);
+    const dependencies = this.extractDependencies(skill.metadata);
+    const entry = {
+      id,
+      metadata: skill.metadata,
+      content: skill.content,
+      filePath: skill.filePath,
+      enabled: existing?.enabled ?? true,
+      source,
+      registeredAt: existing?.registeredAt ?? Date.now(),
+      modifiedAt: skill.modifiedAt?.getTime() ?? Date.now(),
+      estimatedTokens: this.estimateTokens(skill),
+      dependencies,
+      dependents: existing?.dependents || /* @__PURE__ */ new Set()
+    };
+    this.skills.set(id, entry);
+    this.filePathIndex.set(skill.filePath, id);
+    this.updateTriggerIndex(id, entry.metadata.triggers);
+    this.updateDependencyGraph(id, dependencies);
+    if (existing) {
+      this.emit("skill:updated", existing, entry);
+      this.publishMessage("skill:updated", { oldSkill: existing, newSkill: entry });
+    } else {
+      this.emit("skill:registered", entry);
+      this.publishMessage("skill:registered", entry);
+    }
+    return entry;
+  }
+  /**
+   * Unregister a skill by ID
+   *
+   * @param id - Skill ID
+   * @returns True if skill was unregistered
+   */
+  unregister(id) {
+    const entry = this.skills.get(id);
+    if (!entry)
+      return false;
+    if (entry.dependents.size > 0) {
+      const dependentList = Array.from(entry.dependents).join(", ");
+      throw new Error(`Cannot unregister skill "${id}": depended upon by: ${dependentList}`);
+    }
+    this.skills.delete(id);
+    this.filePathIndex.delete(entry.filePath);
+    for (const trigger of entry.metadata.triggers) {
+      const skills = this.triggerIndex.get(trigger);
+      if (skills) {
+        skills.delete(id);
+        if (skills.size === 0)
+          this.triggerIndex.delete(trigger);
+      }
+    }
+    for (const dep of entry.dependencies) {
+      const depEntry = this.skills.get(dep);
+      if (depEntry)
+        depEntry.dependents.delete(id);
+    }
+    this.emit("skill:unregistered", entry);
+    this.publishMessage("skill:unregistered", entry);
+    return true;
+  }
+  /**
+   * Unregister a skill by file path
+   *
+   * @param filePath - File path
+   * @returns True if skill was unregistered
+   */
+  unregisterByPath(filePath) {
+    const id = this.filePathIndex.get(filePath);
+    return id ? this.unregister(id) : false;
+  }
+  /**
+   * Get a skill by ID
+   *
+   * @param id - Skill ID
+   * @returns Skill entry or undefined
+   */
+  getById(id) {
+    return this.skills.get(id);
+  }
+  /**
+   * Get a skill by file path
+   *
+   * @param filePath - File path
+   * @returns Skill entry or undefined
+   */
+  getByPath(filePath) {
+    const id = this.filePathIndex.get(filePath);
+    return id ? this.skills.get(id) : void 0;
+  }
+  /**
+   * Get skills by trigger
+   *
+   * @param trigger - Trigger string (e.g., '/commit')
+   * @returns Array of matching skills
+   */
+  getByTrigger(trigger) {
+    const ids = this.triggerIndex.get(trigger);
+    if (!ids)
+      return [];
+    return Array.from(ids).map((id) => this.skills.get(id)).filter((e) => e !== void 0 && e.enabled);
+  }
+  /**
+   * Lookup skills with filters
+   *
+   * @param options - Lookup options
+   * @returns Array of matching skills
+   */
+  lookup(options = {}) {
+    let results = Array.from(this.skills.values());
+    if (options.enabled !== void 0) {
+      results = results.filter((e) => e.enabled === options.enabled);
+    }
+    if (options.category) {
+      results = results.filter((e) => e.metadata.category === options.category);
+    }
+    if (options.source) {
+      results = results.filter((e) => e.source === options.source);
+    }
+    if (options.userInvocable !== void 0) {
+      results = results.filter(
+        (e) => (e.metadata.user_invocable ?? true) === options.userInvocable
+      );
+    }
+    if (options.autoActivate !== void 0) {
+      results = results.filter(
+        (e) => (e.metadata.auto_activate ?? false) === options.autoActivate
+      );
+    }
+    if (options.agent) {
+      results = results.filter(
+        (e) => e.metadata.agent === options.agent || e.metadata.agents?.includes(options.agent)
+      );
+    }
+    if (options.search) {
+      const query = options.search.toLowerCase();
+      results = results.filter(
+        (e) => e.id.toLowerCase().includes(query) || e.metadata.description.toLowerCase().includes(query) || e.metadata.tags?.some((t) => t.toLowerCase().includes(query))
+      );
+    }
+    if (options.sortBy) {
+      const dir = options.sortDir === "desc" ? -1 : 1;
+      results.sort((a, b) => {
+        switch (options.sortBy) {
+          case "name":
+            return a.id.localeCompare(b.id) * dir;
+          case "priority":
+            return ((a.metadata.priority ?? 5) - (b.metadata.priority ?? 5)) * dir;
+          case "registeredAt":
+            return (a.registeredAt - b.registeredAt) * dir;
+          case "modifiedAt":
+            return (a.modifiedAt - b.modifiedAt) * dir;
+          default:
+            return 0;
+        }
+      });
+    }
+    if (options.limit) {
+      results = results.slice(0, options.limit);
+    }
+    return results;
+  }
+  /**
+   * Enable a skill
+   *
+   * @param id - Skill ID
+   * @returns True if enabled
+   */
+  enable(id) {
+    const entry = this.skills.get(id);
+    if (!entry || entry.enabled)
+      return false;
+    entry.enabled = true;
+    this.emit("skill:enabled", entry);
+    this.publishMessage("skill:enabled", entry);
+    return true;
+  }
+  /**
+   * Disable a skill
+   *
+   * @param id - Skill ID
+   * @returns True if disabled
+   */
+  disable(id) {
+    const entry = this.skills.get(id);
+    if (!entry || !entry.enabled)
+      return false;
+    entry.enabled = false;
+    this.emit("skill:disabled", entry);
+    this.publishMessage("skill:disabled", entry);
+    return true;
+  }
+  /**
+   * Toggle skill enabled state
+   *
+   * @param id - Skill ID
+   * @returns New enabled state
+   */
+  toggle(id) {
+    const entry = this.skills.get(id);
+    if (!entry)
+      return false;
+    entry.enabled = !entry.enabled;
+    const event = entry.enabled ? "skill:enabled" : "skill:disabled";
+    this.emit(event, entry);
+    this.publishMessage(event, entry);
+    return entry.enabled;
+  }
+  /**
+   * Check if a skill exists
+   *
+   * @param id - Skill ID
+   * @returns True if skill exists
+   */
+  has(id) {
+    return this.skills.has(id);
+  }
+  /**
+   * Check if a skill is enabled
+   *
+   * @param id - Skill ID
+   * @returns True if enabled, false if disabled or not found
+   */
+  isEnabled(id) {
+    return this.skills.get(id)?.enabled ?? false;
+  }
+  /**
+   * Get all skill IDs
+   *
+   * @returns Array of skill IDs
+   */
+  getIds() {
+    return Array.from(this.skills.keys());
+  }
+  /**
+   * Get all entries
+   *
+   * @returns Array of all entries
+   */
+  getAll() {
+    return Array.from(this.skills.values());
+  }
+  /**
+   * Get enabled entries
+   *
+   * @returns Array of enabled entries
+   */
+  getEnabled() {
+    return this.lookup({ enabled: true });
+  }
+  /**
+   * Get registry statistics
+   *
+   * @returns Registry statistics
+   */
+  getStats() {
+    const all = this.getAll();
+    const enabled = this.getEnabled();
+    const byCategory = {
+      dev: 0,
+      git: 0,
+      review: 0,
+      testing: 0,
+      docs: 0,
+      devops: 0,
+      planning: 0,
+      debugging: 0,
+      custom: 0
+    };
+    const bySource = { builtin: 0, user: 0, marketplace: 0 };
+    let totalTokens = 0;
+    let lastRegistered = 0;
+    let lastModified = 0;
+    for (const entry of all) {
+      byCategory[entry.metadata.category]++;
+      bySource[entry.source]++;
+      totalTokens += entry.estimatedTokens;
+      if (entry.registeredAt > lastRegistered)
+        lastRegistered = entry.registeredAt;
+      if (entry.modifiedAt > lastModified)
+        lastModified = entry.modifiedAt;
+    }
+    return {
+      totalSkills: all.length,
+      enabledSkills: enabled.length,
+      disabledSkills: all.length - enabled.length,
+      byCategory,
+      bySource,
+      totalTokens,
+      lastRegistered: lastRegistered > 0 ? this.getById(this.getEntriesSortedBy("registeredAt")[0]?.id || "")?.id : void 0,
+      lastModified: lastModified > 0 ? this.getById(this.getEntriesSortedBy("modifiedAt")[0]?.id || "")?.id : void 0
+    };
+  }
+  /**
+   * Get dependent skills
+   *
+   * @param id - Skill ID
+   * @returns Array of dependent skill IDs
+   */
+  getDependents(id) {
+    return Array.from(this.skills.get(id)?.dependents || []);
+  }
+  /**
+   * Get skill dependencies
+   *
+   * @param id - Skill ID
+   * @returns Array of dependency IDs
+   */
+  getDependencies(id) {
+    return this.skills.get(id)?.dependencies || [];
+  }
+  /**
+   * Check for missing dependencies
+   *
+   * @param id - Skill ID
+   * @returns Array of missing dependency IDs
+   */
+  getMissingDependencies(id) {
+    const deps = this.getDependencies(id);
+    return deps.filter((dep) => !this.has(dep));
+  }
+  /**
+   * Validate all dependencies
+   *
+   * @returns Map of skill ID to missing dependencies
+   */
+  validateDependencies() {
+    const missing = /* @__PURE__ */ new Map();
+    Array.from(this.skills.entries()).forEach(([id, entry]) => {
+      const missingDeps = entry.dependencies.filter((dep) => !this.has(dep));
+      if (missingDeps.length > 0) {
+        missing.set(id, missingDeps);
+      }
+    });
+    return missing;
+  }
+  /**
+   * Clear all skills from registry
+   */
+  clear() {
+    this.skills.clear();
+    this.filePathIndex.clear();
+    this.triggerIndex.clear();
+    this.emit("registry:cleared");
+    this.publishMessage("registry:cleared", {});
+  }
+  /**
+   * Get the size of the registry
+   *
+   * @returns Number of registered skills
+   */
+  size() {
+    return this.skills.size;
+  }
+  // ==========================================================================
+  // Private Methods
+  // ==========================================================================
+  /**
+   * Extract dependencies from skill metadata
+   */
+  extractDependencies(metadata) {
+    const deps = [];
+    if (metadata.agents) {
+      deps.push(...metadata.agents);
+    }
+    if (metadata.related_skills) {
+      deps.push(...metadata.related_skills);
+    }
+    return deps;
+  }
+  /**
+   * Update trigger index
+   */
+  updateTriggerIndex(id, triggers) {
+    Array.from(this.triggerIndex.entries()).forEach(([trigger, skillIds]) => {
+      skillIds.delete(id);
+      if (skillIds.size === 0)
+        this.triggerIndex.delete(trigger);
+    });
+    for (const trigger of triggers) {
+      if (!this.triggerIndex.has(trigger)) {
+        this.triggerIndex.set(trigger, /* @__PURE__ */ new Set());
+      }
+      this.triggerIndex.get(trigger).add(id);
+    }
+  }
+  /**
+   * Update dependency graph
+   */
+  updateDependencyGraph(id, dependencies) {
+    Array.from(this.skills.entries()).forEach(([_depId, entry]) => {
+      if (entry.dependencies.includes(id)) {
+        entry.dependents.delete(id);
+      }
+    });
+    for (const dep of dependencies) {
+      const depEntry = this.skills.get(dep);
+      if (depEntry) {
+        depEntry.dependents.add(id);
+      }
+    }
+  }
+  /**
+   * Estimate token count for a skill
+   */
+  estimateTokens(skill) {
+    const contentTokens = Math.ceil(skill.content.length / 4);
+    const metadataTokens = Math.ceil(JSON.stringify(skill.metadata).length / 4);
+    return contentTokens + metadataTokens;
+  }
+  /**
+   * Get entries sorted by a field
+   */
+  getEntriesSortedBy(field) {
+    return Array.from(this.skills.values()).sort((a, b) => b[field] - a[field]);
+  }
+  /**
+   * Publish message to event bus
+   */
+  publishMessage(type, payload) {
+    this.messageBus.publish(
+      type,
+      "coordinator",
+      "all",
+      `Skill registry event: ${type}`,
+      payload,
+      { priority: "normal" }
+    ).catch(console.error);
+  }
+}
+let registryInstance = null;
+function getSkillRegistry() {
+  if (!registryInstance) {
+    registryInstance = new SkillRegistry();
+  }
+  return registryInstance;
+}
 
 class ProgressTracker extends EventEmitter {
   config;
@@ -1879,6 +2800,11 @@ class AutoExecutor extends EventEmitter {
     const executionId = `exec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const startedAt = Date.now();
     this.emit("execution:started", { input: userInput });
+    this.emitCommandHook("command-start", {
+      executionId,
+      inputLength: userInput.length,
+      source: "auto-executor"
+    });
     this.config.telemetry.record({
       executionId,
       phase: "execution",
@@ -1904,6 +2830,13 @@ class AutoExecutor extends EventEmitter {
           complexity: routeResult.intent.complexity
         }
       });
+      this.emitCommandHook("command-telemetry", {
+        executionId,
+        phase: "intent",
+        action: "route",
+        route: routeResult.route,
+        confidence: routeResult.intent.confidence
+      });
       const elicitationResult = await this.resolveRouteWithElicitation(
         routeResult.route,
         routeResult.intent,
@@ -2039,6 +2972,12 @@ class AutoExecutor extends EventEmitter {
           complexity: intent.complexity
         }
       });
+      this.emitCommandHook("command-telemetry", {
+        executionId,
+        phase: "route",
+        action: route,
+        durationMs: routeDuration
+      });
       const totalDuration = Date.now() - startedAt;
       this.metricsCollector.recordResponseTime("auto-executor", totalDuration);
       this.metricsCollector.recordTaskCompletion("auto-executor", true, totalDuration);
@@ -2055,6 +2994,13 @@ class AutoExecutor extends EventEmitter {
           mcpToolsUsed: mcpToolsUsed.length
         }
       });
+      this.emitCommandHook("command-complete", {
+        executionId,
+        success: true,
+        route,
+        durationMs: totalDuration,
+        mcpToolsUsed: mcpToolsUsed.length
+      });
       result.insights = this.buildExecutionInsights({
         initialRoute: routeResult.route,
         resolvedRoute: route,
@@ -2082,6 +3028,12 @@ class AutoExecutor extends EventEmitter {
           error: errorMessage
         }
       });
+      this.emitCommandHook("command-complete", {
+        executionId,
+        success: false,
+        durationMs: totalDuration,
+        error: errorMessage
+      });
       this.emit("execution:failed", { error, input: userInput });
       throw error;
     }
@@ -2552,6 +3504,9 @@ class AutoExecutor extends EventEmitter {
   getTelemetryEvents(limit = 50) {
     return this.config.telemetry.getRecent(limit);
   }
+  clearTelemetry() {
+    this.config.telemetry.clear();
+  }
   getErrorMessage(error) {
     if (error instanceof Error) {
       return error.message;
@@ -2566,6 +3521,9 @@ class AutoExecutor extends EventEmitter {
       console.log(`[AutoExecutor] ${message}`);
     }
   }
+  emitCommandHook(event, data) {
+    void emitCommandHookEvent(event, data);
+  }
 }
 let globalExecutor = null;
 function getGlobalAutoExecutor(config) {
@@ -2674,6 +3632,7 @@ class CliInterceptor extends EventEmitter {
       autoExecute: config.autoExecute !== void 0 ? config.autoExecute : true,
       showIntent: config.showIntent !== void 0 ? config.showIntent : true,
       bypassKeywords: config.bypassKeywords || [],
+      ccjkOwnedSlashPrefixes: config.ccjkOwnedSlashPrefixes || ["/ccjk", "/ccjk:", "/plugin", "/plugins", "/skill"],
       verbose: config.verbose !== void 0 ? config.verbose : false
     };
   }
@@ -2690,6 +3649,7 @@ class CliInterceptor extends EventEmitter {
     this.emit("intercept:started", { input: userInput });
     const bypassCheck = this.shouldBypass(userInput);
     if (bypassCheck.bypass) {
+      await this.handleBypassedCommand(userInput, bypassCheck.reason);
       this.emit("intercept:bypassed", { input: userInput, reason: bypassCheck.reason });
       return {
         intercepted: false,
@@ -2720,6 +3680,12 @@ class CliInterceptor extends EventEmitter {
    */
   shouldBypass(input) {
     const normalized = input.trim().toLowerCase();
+    if (normalized.startsWith("/")) {
+      const isCcjkOwned = this.config.ccjkOwnedSlashPrefixes.some((prefix) => normalized.startsWith(prefix));
+      if (!isCcjkOwned) {
+        return { bypass: true, reason: "Native slash command passthrough" };
+      }
+    }
     if (this.systemCommands.some((cmd) => normalized.startsWith(cmd))) {
       return { bypass: true, reason: "System command" };
     }
@@ -2742,6 +3708,31 @@ class CliInterceptor extends EventEmitter {
     console.log("   System will automatically handle: skills, agents, MCP tools\n");
     console.log("   Smart mode: ambiguity checks + capability-ranked tool selection + telemetry\n");
   }
+  async handleBypassedCommand(input, reason) {
+    const normalized = input.trim().toLowerCase();
+    const command = this.extractCommandName(normalized);
+    if (normalized.startsWith("/clear")) {
+      this.autoExecutor.clearTelemetry();
+      contextLoader.clearCache();
+      getSkillRegistry().clear();
+      await emitCommandHookEvent("command-clear", {
+        command,
+        cleared: ["telemetry", "context-cache", "skill-registry"]
+      });
+    }
+    if (normalized.startsWith("/")) {
+      await emitCommandHookEvent("command-bypass", {
+        command,
+        reason
+      });
+    }
+  }
+  extractCommandName(input) {
+    if (!input.startsWith("/")) {
+      return "";
+    }
+    return input.split(/\s+/)[0];
+  }
   /**
    * Enable interceptor
    */

package/dist/chunks/package.mjs

@@ -1,3 +1,3 @@
-const version = "12.2.1";
+const version = "12.2.2";
 
 export { version };

package/dist/shared/ccjk.CCcQfbni.mjs

@@ -0,0 +1,78 @@
+import { l as logger } from './ccjk.DG_o24cZ.mjs';
+
+class HookRegistry {
+  hooks = /* @__PURE__ */ new Map();
+  /**
+   * Register a hook for an event
+   */
+  register(event, hook) {
+    const hooks = this.hooks.get(event) || [];
+    hooks.push(hook);
+    hooks.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    this.hooks.set(event, hooks);
+    logger.debug(`Registered hook "${hook.name}" for event "${event}"`);
+  }
+  /**
+   * Unregister a hook
+   */
+  unregister(event, hookName) {
+    const hooks = this.hooks.get(event);
+    if (!hooks) return;
+    const filtered = hooks.filter((h) => h.name !== hookName);
+    this.hooks.set(event, filtered);
+    logger.debug(`Unregistered hook "${hookName}" for event "${event}"`);
+  }
+  /**
+   * Execute all hooks for an event
+   * Returns false if any hook returns continue: false
+   */
+  async execute(context) {
+    const hooks = this.hooks.get(context.event) || [];
+    const enabledHooks = hooks.filter((h) => h.enabled !== false);
+    if (enabledHooks.length === 0) {
+      return { continue: true };
+    }
+    let currentContext = context;
+    let aggregatedData = {};
+    for (const hook of enabledHooks) {
+      try {
+        const result = await hook.fn(currentContext);
+        if (result.data) {
+          aggregatedData = { ...aggregatedData, ...result.data };
+        }
+        if (!result.continue) {
+          return {
+            continue: false,
+            data: aggregatedData,
+            error: result.error
+          };
+        }
+        currentContext = {
+          ...currentContext,
+          data: { ...currentContext.data, ...aggregatedData }
+        };
+      } catch (error) {
+        logger.error(`Hook "${hook.name}" failed:`, error);
+      }
+    }
+    return {
+      continue: true,
+      data: aggregatedData
+    };
+  }
+  /**
+   * Get all registered hooks for an event
+   */
+  getHooks(event) {
+    return this.hooks.get(event) || [];
+  }
+  /**
+   * Clear all hooks
+   */
+  clear() {
+    this.hooks.clear();
+  }
+}
+const hookRegistry = new HookRegistry();
+
+export { hookRegistry as h };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ccjk",
   "type": "module",
-  "version": "12.2.1",
+  "version": "12.2.2",
   "packageManager": "pnpm@10.17.1",
   "description": "CLI toolkit for Claude Code and Codex setup. Simplifies MCP service installation, API configuration, workflow management, and multi-provider support with guided interactive setup.",
   "author": {