ccjk 15.28.2 → 15.29.0

package/dist/shared/ccjk.CfKKcvWy.mjs

@@ -0,0 +1,126 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { CLAUDE_AGENTS_DIR, CCJK_CONFIG_DIR } from '../chunks/constants.mjs';
+import { j as join } from './ccjk.bQ7Dh1g4.mjs';
+
+const getProjectAgentsDir = (projectDir) => join(projectDir || process.cwd(), ".claude", "agents");
+const GLOBAL_AGENTS_DIR = CLAUDE_AGENTS_DIR;
+join(CCJK_CONFIG_DIR, "agents");
+const AGENT_COLORS = ["blue", "green", "orange", "purple", "red", "yellow", "cyan", "pink"];
+function agentToMarkdown(agent, options) {
+  const name = generateAgentId(agent);
+  const description = typeof agent.description === "string" ? agent.description : agent.description?.en || agent.description?.["zh-CN"] || "";
+  const tools = options?.tools || [];
+  if (agent.skills?.length) {
+    tools.push(...agent.skills.map((s) => s.skillId || s.pluginId));
+  }
+  if (agent.mcpServers?.length) {
+    tools.push(...agent.mcpServers.map((m) => `mcp__${m.serverName}`));
+  }
+  const color = options?.color || selectAgentColor(agent);
+  const frontmatter = [
+    "---",
+    `name: ${name}`,
+    `description: ${description}`
+  ];
+  if (tools.length > 0) {
+    frontmatter.push(`tools: ${tools.join(", ")}`);
+  }
+  frontmatter.push(`color: ${color}`);
+  frontmatter.push("---");
+  const body = [];
+  if (agent.persona) {
+    body.push("");
+    body.push(agent.persona);
+  }
+  if (agent.instructions) {
+    body.push("");
+    body.push("## Instructions");
+    body.push("");
+    body.push(agent.instructions);
+  }
+  if (agent.capabilities?.length) {
+    body.push("");
+    body.push("## Capabilities");
+    body.push("");
+    for (const cap of agent.capabilities) {
+      body.push(`- ${formatCapability(cap)}`);
+    }
+  }
+  if (agent.triggers?.length) {
+    body.push("");
+    body.push("## Triggers");
+    body.push("");
+    for (const trigger of agent.triggers) {
+      body.push(`- ${trigger}`);
+    }
+  }
+  return `${frontmatter.join("\n") + body.join("\n")}
+`;
+}
+function selectAgentColor(agent) {
+  const caps = agent.capabilities || [];
+  if (caps.includes("code-generation") || caps.includes("code-review"))
+    return "blue";
+  if (caps.includes("testing"))
+    return "green";
+  if (caps.includes("debugging"))
+    return "orange";
+  if (caps.includes("deployment"))
+    return "purple";
+  if (caps.includes("documentation"))
+    return "cyan";
+  if (caps.includes("git-operations"))
+    return "yellow";
+  if (caps.includes("web-search") || caps.includes("api-integration"))
+    return "pink";
+  const hash = agent.id?.split("").reduce((a, c) => a + c.charCodeAt(0), 0) || 0;
+  return AGENT_COLORS[hash % AGENT_COLORS.length];
+}
+function formatCapability(cap) {
+  const labels = {
+    "code-generation": "Code Generation",
+    "code-review": "Code Review",
+    "testing": "Testing",
+    "documentation": "Documentation",
+    "deployment": "Deployment",
+    "debugging": "Debugging",
+    "refactoring": "Refactoring",
+    "git-operations": "Git Operations",
+    "file-management": "File Management",
+    "web-search": "Web Search",
+    "api-integration": "API Integration"
+  };
+  return labels[cap] || cap;
+}
+async function writeAgentFile(agent, options) {
+  const format = options?.format || "markdown";
+  const agentId = generateAgentId(agent);
+  const isGlobal = options?.global || false;
+  const agentsDir = isGlobal ? GLOBAL_AGENTS_DIR : getProjectAgentsDir(options?.projectDir);
+  const ext = format === "markdown" ? "md" : "json";
+  const fileName = `${agentId}.${ext}`;
+  const filePath = join(agentsDir, fileName);
+  if (!existsSync(agentsDir)) {
+    mkdirSync(agentsDir, { recursive: true });
+  }
+  let content;
+  if (format === "markdown") {
+    content = agentToMarkdown(agent, options);
+  } else {
+    content = JSON.stringify(agent, null, options?.pretty ? 2 : 0);
+  }
+  writeFileSync(filePath, content, "utf-8");
+  return filePath;
+}
+function generateAgentId(agent) {
+  if (agent.id) {
+    return agent.id.toLowerCase().replace(/\s+/g, "-");
+  }
+  const name = typeof agent.name === "string" ? agent.name : agent.name?.en || agent.name?.["zh-CN"] || "unknown-agent";
+  return name.toLowerCase().replace(/\s+/g, "-");
+}
+function getAgentsDir(projectDir) {
+  return getProjectAgentsDir(projectDir);
+}
+
+export { getAgentsDir as g, writeAgentFile as w };

package/dist/shared/ccjk.Cjgrln_h.mjs

@@ -0,0 +1,297 @@
+/**
+ * This is not the set of all possible signals.
+ *
+ * It IS, however, the set of all signals that trigger
+ * an exit on either Linux or BSD systems.  Linux is a
+ * superset of the signal names supported on BSD, and
+ * the unknown signals just fail to register, so we can
+ * catch that easily enough.
+ *
+ * Windows signals are a different set, since there are
+ * signals that terminate Windows processes, but don't
+ * terminate (or don't even exist) on Posix systems.
+ *
+ * Don't bother with SIGKILL.  It's uncatchable, which
+ * means that we can't fire any callbacks anyway.
+ *
+ * If a user does happen to register a handler on a non-
+ * fatal signal like SIGWINCH or something, and then
+ * exit, it'll end up firing `process.emit('exit')`, so
+ * the handler will be fired anyway.
+ *
+ * SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+ * artificially, inherently leave the process in a
+ * state from which it is not safe to try and enter JS
+ * listeners.
+ */
+const signals = [];
+signals.push('SIGHUP', 'SIGINT', 'SIGTERM');
+if (process.platform !== 'win32') {
+    signals.push('SIGALRM', 'SIGABRT', 'SIGVTALRM', 'SIGXCPU', 'SIGXFSZ', 'SIGUSR2', 'SIGTRAP', 'SIGSYS', 'SIGQUIT', 'SIGIOT'
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+    );
+}
+if (process.platform === 'linux') {
+    signals.push('SIGIO', 'SIGPOLL', 'SIGPWR', 'SIGSTKFLT');
+}
+
+// Note: since nyc uses this module to output coverage, any lines
+// that are in the direct sync flow of nyc's outputCoverage are
+// ignored, since we can never get coverage for them.
+// grab a reference to node's real process object right away
+const processOk = (process) => !!process &&
+    typeof process === 'object' &&
+    typeof process.removeListener === 'function' &&
+    typeof process.emit === 'function' &&
+    typeof process.reallyExit === 'function' &&
+    typeof process.listeners === 'function' &&
+    typeof process.kill === 'function' &&
+    typeof process.pid === 'number' &&
+    typeof process.on === 'function';
+const kExitEmitter = Symbol.for('signal-exit emitter');
+const global = globalThis;
+const ObjectDefineProperty = Object.defineProperty.bind(Object);
+// teeny special purpose ee
+class Emitter {
+    emitted = {
+        afterExit: false,
+        exit: false,
+    };
+    listeners = {
+        afterExit: [],
+        exit: [],
+    };
+    count = 0;
+    id = Math.random();
+    constructor() {
+        if (global[kExitEmitter]) {
+            return global[kExitEmitter];
+        }
+        ObjectDefineProperty(global, kExitEmitter, {
+            value: this,
+            writable: false,
+            enumerable: false,
+            configurable: false,
+        });
+    }
+    on(ev, fn) {
+        this.listeners[ev].push(fn);
+    }
+    removeListener(ev, fn) {
+        const list = this.listeners[ev];
+        const i = list.indexOf(fn);
+        /* c8 ignore start */
+        if (i === -1) {
+            return;
+        }
+        /* c8 ignore stop */
+        if (i === 0 && list.length === 1) {
+            list.length = 0;
+        }
+        else {
+            list.splice(i, 1);
+        }
+    }
+    emit(ev, code, signal) {
+        if (this.emitted[ev]) {
+            return false;
+        }
+        this.emitted[ev] = true;
+        let ret = false;
+        for (const fn of this.listeners[ev]) {
+            ret = fn(code, signal) === true || ret;
+        }
+        if (ev === 'exit') {
+            ret = this.emit('afterExit', code, signal) || ret;
+        }
+        return ret;
+    }
+}
+class SignalExitBase {
+}
+const signalExitWrap = (handler) => {
+    return {
+        onExit(cb, opts) {
+            return handler.onExit(cb, opts);
+        },
+        load() {
+            return handler.load();
+        },
+        unload() {
+            return handler.unload();
+        },
+    };
+};
+class SignalExitFallback extends SignalExitBase {
+    onExit() {
+        return () => { };
+    }
+    load() { }
+    unload() { }
+}
+class SignalExit extends SignalExitBase {
+    // "SIGHUP" throws an `ENOSYS` error on Windows,
+    // so use a supported signal instead
+    /* c8 ignore start */
+    #hupSig = process$1.platform === 'win32' ? 'SIGINT' : 'SIGHUP';
+    /* c8 ignore stop */
+    #emitter = new Emitter();
+    #process;
+    #originalProcessEmit;
+    #originalProcessReallyExit;
+    #sigListeners = {};
+    #loaded = false;
+    constructor(process) {
+        super();
+        this.#process = process;
+        // { <signal>: <listener fn>, ... }
+        this.#sigListeners = {};
+        for (const sig of signals) {
+            this.#sigListeners[sig] = () => {
+                // If there are no other listeners, an exit is coming!
+                // Simplest way: remove us and then re-send the signal.
+                // We know that this will kill the process, so we can
+                // safely emit now.
+                const listeners = this.#process.listeners(sig);
+                let { count } = this.#emitter;
+                // This is a workaround for the fact that signal-exit v3 and signal
+                // exit v4 are not aware of each other, and each will attempt to let
+                // the other handle it, so neither of them do. To correct this, we
+                // detect if we're the only handler *except* for previous versions
+                // of signal-exit, and increment by the count of listeners it has
+                // created.
+                /* c8 ignore start */
+                const p = process;
+                if (typeof p.__signal_exit_emitter__ === 'object' &&
+                    typeof p.__signal_exit_emitter__.count === 'number') {
+                    count += p.__signal_exit_emitter__.count;
+                }
+                /* c8 ignore stop */
+                if (listeners.length === count) {
+                    this.unload();
+                    const ret = this.#emitter.emit('exit', null, sig);
+                    /* c8 ignore start */
+                    const s = sig === 'SIGHUP' ? this.#hupSig : sig;
+                    if (!ret)
+                        process.kill(process.pid, s);
+                    /* c8 ignore stop */
+                }
+            };
+        }
+        this.#originalProcessReallyExit = process.reallyExit;
+        this.#originalProcessEmit = process.emit;
+    }
+    onExit(cb, opts) {
+        /* c8 ignore start */
+        if (!processOk(this.#process)) {
+            return () => { };
+        }
+        /* c8 ignore stop */
+        if (this.#loaded === false) {
+            this.load();
+        }
+        const ev = opts?.alwaysLast ? 'afterExit' : 'exit';
+        this.#emitter.on(ev, cb);
+        return () => {
+            this.#emitter.removeListener(ev, cb);
+            if (this.#emitter.listeners['exit'].length === 0 &&
+                this.#emitter.listeners['afterExit'].length === 0) {
+                this.unload();
+            }
+        };
+    }
+    load() {
+        if (this.#loaded) {
+            return;
+        }
+        this.#loaded = true;
+        // This is the number of onSignalExit's that are in play.
+        // It's important so that we can count the correct number of
+        // listeners on signals, and don't wait for the other one to
+        // handle it instead of us.
+        this.#emitter.count += 1;
+        for (const sig of signals) {
+            try {
+                const fn = this.#sigListeners[sig];
+                if (fn)
+                    this.#process.on(sig, fn);
+            }
+            catch (_) { }
+        }
+        this.#process.emit = (ev, ...a) => {
+            return this.#processEmit(ev, ...a);
+        };
+        this.#process.reallyExit = (code) => {
+            return this.#processReallyExit(code);
+        };
+    }
+    unload() {
+        if (!this.#loaded) {
+            return;
+        }
+        this.#loaded = false;
+        signals.forEach(sig => {
+            const listener = this.#sigListeners[sig];
+            /* c8 ignore start */
+            if (!listener) {
+                throw new Error('Listener not defined for signal: ' + sig);
+            }
+            /* c8 ignore stop */
+            try {
+                this.#process.removeListener(sig, listener);
+                /* c8 ignore start */
+            }
+            catch (_) { }
+            /* c8 ignore stop */
+        });
+        this.#process.emit = this.#originalProcessEmit;
+        this.#process.reallyExit = this.#originalProcessReallyExit;
+        this.#emitter.count -= 1;
+    }
+    #processReallyExit(code) {
+        /* c8 ignore start */
+        if (!processOk(this.#process)) {
+            return 0;
+        }
+        this.#process.exitCode = code || 0;
+        /* c8 ignore stop */
+        this.#emitter.emit('exit', this.#process.exitCode, null);
+        return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+    }
+    #processEmit(ev, ...args) {
+        const og = this.#originalProcessEmit;
+        if (ev === 'exit' && processOk(this.#process)) {
+            if (typeof args[0] === 'number') {
+                this.#process.exitCode = args[0];
+                /* c8 ignore start */
+            }
+            /* c8 ignore start */
+            const ret = og.call(this.#process, ev, ...args);
+            /* c8 ignore start */
+            this.#emitter.emit('exit', this.#process.exitCode, null);
+            /* c8 ignore stop */
+            return ret;
+        }
+        else {
+            return og.call(this.#process, ev, ...args);
+        }
+    }
+}
+const process$1 = globalThis.process;
+// wrap so that we call the method on the actual handler, without
+// exporting it directly.
+const { 
+/**
+ * Called when the process is exiting, whether via signal, explicit
+ * exit, or running out of stuff to do.
+ *
+ * If the global process object is not suitable for instrumentation,
+ * then this will be a no-op.
+ *
+ * Returns a function that may be used to unload signal-exit.
+ */
+onExit} = signalExitWrap(processOk(process$1) ? new SignalExit(process$1) : new SignalExitFallback());
+
+export { onExit as o };