ccjk 12.0.7 → 12.0.8

package/dist/shared/ccjk.CePkJq2S.mjs

@@ -1,223 +0,0 @@
-import a from '../chunks/index2.mjs';
-
-class ExecutionTracer {
-  traces = /* @__PURE__ */ new Map();
-  currentSessionId = null;
-  /**
-   * Start a new trace session
-   */
-  startSession(sessionId) {
-    this.currentSessionId = sessionId;
-    this.traces.set(sessionId, {
-      sessionId,
-      startTime: Date.now(),
-      events: [],
-      metadata: {
-        totalEvents: 0,
-        totalDuration: 0,
-        agentCount: 0,
-        toolCallCount: 0,
-        errorCount: 0
-      }
-    });
-  }
-  /**
-   * End current trace session
-   */
-  endSession(sessionId) {
-    const sid = sessionId || this.currentSessionId;
-    if (!sid) return;
-    const trace = this.traces.get(sid);
-    if (trace) {
-      trace.endTime = Date.now();
-      trace.metadata.totalDuration = trace.endTime - trace.startTime;
-    }
-    if (sid === this.currentSessionId) {
-      this.currentSessionId = null;
-    }
-  }
-  /**
-   * Log an event
-   */
-  logEvent(type, data, options) {
-    const sessionId = options?.sessionId || this.currentSessionId;
-    if (!sessionId) {
-      throw new Error("No active trace session");
-    }
-    const trace = this.traces.get(sessionId);
-    if (!trace) {
-      throw new Error(`Trace session not found: ${sessionId}`);
-    }
-    const eventId = `${sessionId}-${trace.events.length}`;
-    const event = {
-      id: eventId,
-      sessionId,
-      timestamp: Date.now(),
-      type,
-      agentId: options?.agentId,
-      data,
-      duration: options?.duration,
-      parentId: options?.parentId
-    };
-    trace.events.push(event);
-    trace.metadata.totalEvents++;
-    if (type === "agent-start") {
-      trace.metadata.agentCount++;
-    } else if (type === "tool-call") {
-      trace.metadata.toolCallCount++;
-    } else if (type === "error") {
-      trace.metadata.errorCount++;
-    }
-    return eventId;
-  }
-  /**
-   * Log agent start
-   */
-  logAgentStart(agentId, data = {}) {
-    return this.logEvent("agent-start", { agentId, ...data }, { agentId });
-  }
-  /**
-   * Log agent end
-   */
-  logAgentEnd(agentId, data = {}, duration) {
-    return this.logEvent("agent-end", { agentId, ...data }, { agentId, duration });
-  }
-  /**
-   * Log decision
-   */
-  logDecision(agentId, decision, reasoning) {
-    return this.logEvent("decision", { decision, reasoning }, { agentId });
-  }
-  /**
-   * Log tool call
-   */
-  logToolCall(tool, args, agentId) {
-    return this.logEvent("tool-call", { tool, args }, { agentId });
-  }
-  /**
-   * Log tool result
-   */
-  logToolResult(tool, result, duration, parentId) {
-    return this.logEvent("tool-result", { tool, result }, { duration, parentId });
-  }
-  /**
-   * Log error
-   */
-  logError(error, agentId) {
-    return this.logEvent("error", {
-      message: error.message,
-      stack: error.stack
-    }, { agentId });
-  }
-  /**
-   * Get trace for session
-   */
-  getTrace(sessionId) {
-    return this.traces.get(sessionId);
-  }
-  /**
-   * List all traces
-   */
-  listTraces() {
-    return Array.from(this.traces.values());
-  }
-  /**
-   * Clear old traces (keep last N)
-   */
-  cleanup(keepLast = 10) {
-    const traces = this.listTraces().sort((a, b) => b.startTime - a.startTime);
-    const toKeep = new Set(traces.slice(0, keepLast).map((t) => t.sessionId));
-    for (const [sessionId] of this.traces) {
-      if (!toKeep.has(sessionId)) {
-        this.traces.delete(sessionId);
-      }
-    }
-  }
-  /**
-   * Visualize trace as ASCII tree
-   */
-  visualizeTrace(sessionId) {
-    const trace = this.traces.get(sessionId);
-    if (!trace) {
-      return a.red(`Trace not found: ${sessionId}`);
-    }
-    const lines = [];
-    lines.push(a.cyan.bold(`
-\u{1F4CA} Execution Trace: ${sessionId}`));
-    lines.push(a.gray(`Started: ${new Date(trace.startTime).toISOString()}`));
-    if (trace.endTime) {
-      lines.push(a.gray(`Duration: ${trace.endTime - trace.startTime}ms`));
-    }
-    lines.push(a.gray(`Events: ${trace.metadata.totalEvents}`));
-    lines.push("");
-    const agentEvents = /* @__PURE__ */ new Map();
-    for (const event of trace.events) {
-      const agentId = event.agentId || "system";
-      if (!agentEvents.has(agentId)) {
-        agentEvents.set(agentId, []);
-      }
-      agentEvents.get(agentId).push(event);
-    }
-    for (const [agentId, events] of agentEvents) {
-      lines.push(a.yellow(`\u{1F916} ${agentId}`));
-      for (const event of events) {
-        const time = new Date(event.timestamp).toLocaleTimeString();
-        const icon = this.getEventIcon(event.type);
-        const color = this.getEventColor(event.type);
-        let line = `  ${icon} ${time} ${color(event.type)}`;
-        if (event.type === "decision") {
-          line += `: ${event.data.decision}`;
-        } else if (event.type === "tool-call") {
-          line += `: ${event.data.tool}(${JSON.stringify(event.data.args).slice(0, 50)}...)`;
-        } else if (event.type === "tool-result" && event.duration) {
-          line += `: ${event.data.tool} (${event.duration}ms)`;
-        } else if (event.type === "error") {
-          line += `: ${event.data.message}`;
-        }
-        lines.push(line);
-      }
-      lines.push("");
-    }
-    lines.push(a.cyan("\u{1F4C8} Summary"));
-    lines.push(`  Agents: ${trace.metadata.agentCount}`);
-    lines.push(`  Tool Calls: ${trace.metadata.toolCallCount}`);
-    lines.push(`  Errors: ${trace.metadata.errorCount}`);
-    lines.push("");
-    return lines.join("\n");
-  }
-  /**
-   * Get icon for event type
-   */
-  getEventIcon(type) {
-    const icons = {
-      "agent-start": "\u25B6\uFE0F",
-      "agent-end": "\u23F9\uFE0F",
-      "decision": "\u{1F9E0}",
-      "tool-call": "\u{1F527}",
-      "tool-result": "\u2705",
-      "error": "\u274C",
-      "context-load": "\u{1F4E5}",
-      "context-save": "\u{1F4E4}"
-    };
-    return icons[type] || "\u2022";
-  }
-  /**
-   * Get color function for event type
-   */
-  getEventColor(type) {
-    const colors = {
-      "agent-start": a.green,
-      "agent-end": a.gray,
-      "decision": a.cyan,
-      "tool-call": a.blue,
-      "tool-result": a.green,
-      "error": a.red,
-      "context-load": a.yellow,
-      "context-save": a.yellow
-    };
-    return colors[type] || a.white;
-  }
-}
-const executionTracer = new ExecutionTracer();
-
-export { executionTracer as e };

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 };

package/dist/shared/ccjk.Cjj8SVrn.mjs

@@ -1,54 +0,0 @@
-import { a as detectCodeToolType } from '../chunks/smart-defaults.mjs';
-import { DEFAULT_CODE_TOOL_TYPE } from '../chunks/constants.mjs';
-import { i18n } from '../chunks/index5.mjs';
-import { readZcfConfigAsync } from '../chunks/ccjk-config.mjs';
-
-const CODE_TYPE_ABBREVIATIONS = {
-  cc: "claude-code",
-  cx: "codex"
-};
-async function resolveCodeType(codeTypeParam) {
-  if (codeTypeParam) {
-    const normalizedParam = codeTypeParam.toLowerCase().trim();
-    if (normalizedParam in CODE_TYPE_ABBREVIATIONS) {
-      return CODE_TYPE_ABBREVIATIONS[normalizedParam];
-    }
-    if (isValidCodeType(normalizedParam)) {
-      return normalizedParam;
-    }
-    const validAbbreviations = Object.keys(CODE_TYPE_ABBREVIATIONS);
-    const validFullTypes = Object.values(CODE_TYPE_ABBREVIATIONS);
-    const validOptions = [...validAbbreviations, ...validFullTypes].join(", ");
-    let defaultValue = DEFAULT_CODE_TOOL_TYPE;
-    try {
-      const config = await readZcfConfigAsync();
-      if (config?.codeToolType && isValidCodeType(config.codeToolType)) {
-        defaultValue = config.codeToolType;
-      }
-    } catch {
-    }
-    throw new Error(
-      i18n.t("errors:invalidCodeType", { value: codeTypeParam, validOptions, defaultValue })
-    );
-  }
-  try {
-    const config = await readZcfConfigAsync();
-    if (config?.codeToolType && isValidCodeType(config.codeToolType)) {
-      return config.codeToolType;
-    }
-  } catch {
-  }
-  try {
-    const freshDetected = detectCodeToolType();
-    if (isValidCodeType(freshDetected)) {
-      return freshDetected;
-    }
-  } catch {
-  }
-  return DEFAULT_CODE_TOOL_TYPE;
-}
-function isValidCodeType(value) {
-  return ["claude-code", "codex"].includes(value);
-}
-
-export { resolveCodeType as r };