ccjk 12.0.0 → 12.0.2

package/dist/shared/{ccjk.C10pepYx.mjs → ccjk.BxSmJ8B7.mjs}

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
-import { join } from 'pathe';
 import { glob } from 'tinyglobby';
+import { j as join } from './ccjk.bQ7Dh1g4.mjs';
 
 const PARADIGMS = [
   {

package/dist/shared/ccjk.Bx_rmYfN.mjs

@@ -0,0 +1,69 @@
+import process__default from 'node:process';
+import path__default from 'node:path';
+import fs__default, { promises } from 'node:fs';
+
+const resolvePath = (cwd, sourcePath, destinationPath) => {
+	sourcePath = path__default.resolve(cwd, sourcePath);
+	destinationPath = path__default.resolve(cwd, destinationPath);
+
+	return {
+		sourcePath,
+		destinationPath,
+	};
+};
+
+const validatePathsExist = (sourcePath, destinationPath, suffix = 'Path') => {
+	if (!sourcePath || !destinationPath) {
+		throw new TypeError(`\`source${suffix}\` and \`destination${suffix}\` required`);
+	}
+};
+
+const validateSameDirectory = (source, destination) => {
+	if (path__default.dirname(source) !== path__default.dirname(destination)) {
+		throw new Error('`source` and `destination` must be in the same directory');
+	}
+};
+
+const _moveFile = async (sourcePath, destinationPath, {overwrite = true, cwd = process__default.cwd(), directoryMode, validateDirectory = false} = {}) => {
+	if (cwd) {
+		({sourcePath, destinationPath} = resolvePath(cwd, sourcePath, destinationPath));
+	}
+
+	if (validateDirectory) {
+		validateSameDirectory(sourcePath, destinationPath);
+	}
+
+	if (!overwrite && fs__default.existsSync(destinationPath)) {
+		throw new Error(`The destination file exists: ${destinationPath}`);
+	}
+
+	await promises.mkdir(path__default.dirname(destinationPath), {
+		recursive: true,
+		mode: directoryMode,
+	});
+
+	try {
+		await promises.rename(sourcePath, destinationPath);
+	} catch (error) {
+		if (error.code === 'EXDEV') {
+			const stats = await promises.lstat(sourcePath);
+			if (stats.isSymbolicLink()) {
+				const target = await promises.readlink(sourcePath);
+				await promises.symlink(target, destinationPath);
+				await promises.unlink(sourcePath);
+			} else {
+				await promises.cp(sourcePath, destinationPath, {recursive: true, preserveTimestamps: true});
+				await promises.rm(sourcePath, {recursive: true});
+			}
+		} else {
+			throw error;
+		}
+	}
+};
+
+async function moveFile(sourcePath, destinationPath, options) {
+	validatePathsExist(sourcePath, destinationPath);
+	return _moveFile(sourcePath, destinationPath, options);
+}
+
+export { moveFile as m };

package/dist/shared/ccjk.COweQ1RR.mjs

@@ -0,0 +1,5 @@
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
+export { commonjsRequire as c };

package/dist/shared/{ccjk.BN90X6oc.mjs → ccjk.CePkJq2S.mjs}

@@ -1,4 +1,4 @@
-import ansis from 'ansis';
+import a from '../chunks/index2.mjs';
 
 class ExecutionTracer {
   traces = /* @__PURE__ */ new Map();
@@ -139,16 +139,16 @@ class ExecutionTracer {
   visualizeTrace(sessionId) {
     const trace = this.traces.get(sessionId);
     if (!trace) {
-      return ansis.red(`Trace not found: ${sessionId}`);
+      return a.red(`Trace not found: ${sessionId}`);
     }
     const lines = [];
-    lines.push(ansis.cyan.bold(`
+    lines.push(a.cyan.bold(`
 \u{1F4CA} Execution Trace: ${sessionId}`));
-    lines.push(ansis.gray(`Started: ${new Date(trace.startTime).toISOString()}`));
+    lines.push(a.gray(`Started: ${new Date(trace.startTime).toISOString()}`));
     if (trace.endTime) {
-      lines.push(ansis.gray(`Duration: ${trace.endTime - trace.startTime}ms`));
+      lines.push(a.gray(`Duration: ${trace.endTime - trace.startTime}ms`));
     }
-    lines.push(ansis.gray(`Events: ${trace.metadata.totalEvents}`));
+    lines.push(a.gray(`Events: ${trace.metadata.totalEvents}`));
     lines.push("");
     const agentEvents = /* @__PURE__ */ new Map();
     for (const event of trace.events) {
@@ -159,7 +159,7 @@ class ExecutionTracer {
       agentEvents.get(agentId).push(event);
     }
     for (const [agentId, events] of agentEvents) {
-      lines.push(ansis.yellow(`\u{1F916} ${agentId}`));
+      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);
@@ -178,7 +178,7 @@ class ExecutionTracer {
       }
       lines.push("");
     }
-    lines.push(ansis.cyan("\u{1F4C8} Summary"));
+    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}`);
@@ -206,16 +206,16 @@ class ExecutionTracer {
    */
   getEventColor(type) {
     const colors = {
-      "agent-start": ansis.green,
-      "agent-end": ansis.gray,
-      "decision": ansis.cyan,
-      "tool-call": ansis.blue,
-      "tool-result": ansis.green,
-      "error": ansis.red,
-      "context-load": ansis.yellow,
-      "context-save": ansis.yellow
+      "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] || ansis.white;
+    return colors[type] || a.white;
   }
 }
 const executionTracer = new ExecutionTracer();

package/dist/shared/{ccjk.Bvoex4TZ.mjs → ccjk.CfKKcvWy.mjs}

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'pathe';
 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;

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