ccjk 14.2.2 → 15.1.0

package/dist/shared/ccjk.CfKKcvWy.mjs

@@ -1,126 +0,0 @@
-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

@@ -1,297 +0,0 @@
-/**
- * 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 };