ccjk 12.0.0 → 12.0.2

package/dist/chunks/ccjk-all.mjs

@@ -1,39 +1,657 @@
-import ansis from 'ansis';
-import consola from 'consola';
-import nodeFs__default, { readFileSync, promises } from 'node:fs';
+import a from './index2.mjs';
+import { c as consola, o as ofetch, a as analyzeProject } from '../shared/ccjk.s7OCVzdd.mjs';
+import fs__default, { readFileSync, promises } from 'node:fs';
 import path__default, { dirname, join } from 'node:path';
-import { hash } from 'ohash';
 import { fileURLToPath } from 'node:url';
-import { ofetch } from 'ofetch';
 import { randomUUID, createHash } from 'node:crypto';
-import { i18n, ensureI18nInitialized } from './index3.mjs';
-import { a as analyzeProject } from '../shared/ccjk.BNwRnWYx.mjs';
+import { i18n, ensureI18nInitialized } from './index5.mjs';
 import { ccjkAgents } from './ccjk-agents.mjs';
 import { ccjkHooks } from './ccjk-hooks.mjs';
 import { ccjkMcp } from './ccjk-mcp.mjs';
 import { ccjkSkills } from './ccjk-skills.mjs';
 import { a as extractString } from '../shared/ccjk.AqnXPAzw.mjs';
-import 'node:process';
-import 'i18next';
-import 'i18next-fs-backend';
-import 'pathe';
+import '../shared/ccjk.BAGoDD49.mjs';
+import './index8.mjs';
+import '../shared/ccjk.bQ7Dh1g4.mjs';
 import 'tinyglobby';
-import 'smol-toml';
+import '../shared/ccjk.BBtCGd_g.mjs';
+import 'node:process';
 import './constants.mjs';
 import 'node:os';
-import '../shared/ccjk.Bvoex4TZ.mjs';
+import '../shared/ccjk.CfKKcvWy.mjs';
 import 'node:perf_hooks';
-import 'inquirer';
-import 'node:child_process';
+import './index3.mjs';
+import 'node:readline';
+import 'stream';
+import 'node:tty';
+import 'node:async_hooks';
+import '../shared/ccjk.Cjgrln_h.mjs';
 import 'node:util';
+import 'tty';
+import 'fs';
+import 'child_process';
+import 'buffer';
+import 'string_decoder';
+import 'node:child_process';
 import './claude-config.mjs';
 import './json-config.mjs';
-import 'dayjs';
+import '../shared/ccjk.RyizuzOI.mjs';
 import './fs-operations.mjs';
 import 'node:fs/promises';
 import './platform.mjs';
-import 'tinyexec';
-import '../shared/ccjk.Bdhyg3X-.mjs';
+import './main.mjs';
+import 'module';
+import 'node:stream';
+import '../shared/ccjk.DsYaCCx4.mjs';
+
+const defaults = Object.freeze({
+  ignoreUnknown: false,
+  respectType: false,
+  respectFunctionNames: false,
+  respectFunctionProperties: false,
+  unorderedObjects: true,
+  unorderedArrays: false,
+  unorderedSets: false,
+  excludeKeys: void 0,
+  excludeValues: void 0,
+  replacer: void 0
+});
+function objectHash(object, options) {
+  if (options) {
+    options = { ...defaults, ...options };
+  } else {
+    options = defaults;
+  }
+  const hasher = createHasher(options);
+  hasher.dispatch(object);
+  return hasher.toString();
+}
+const defaultPrototypesKeys = Object.freeze([
+  "prototype",
+  "__proto__",
+  "constructor"
+]);
+function createHasher(options) {
+  let buff = "";
+  let context = /* @__PURE__ */ new Map();
+  const write = (str) => {
+    buff += str;
+  };
+  return {
+    toString() {
+      return buff;
+    },
+    getContext() {
+      return context;
+    },
+    dispatch(value) {
+      if (options.replacer) {
+        value = options.replacer(value);
+      }
+      const type = value === null ? "null" : typeof value;
+      return this[type](value);
+    },
+    object(object) {
+      if (object && typeof object.toJSON === "function") {
+        return this.object(object.toJSON());
+      }
+      const objString = Object.prototype.toString.call(object);
+      let objType = "";
+      const objectLength = objString.length;
+      if (objectLength < 10) {
+        objType = "unknown:[" + objString + "]";
+      } else {
+        objType = objString.slice(8, objectLength - 1);
+      }
+      objType = objType.toLowerCase();
+      let objectNumber = null;
+      if ((objectNumber = context.get(object)) === void 0) {
+        context.set(object, context.size);
+      } else {
+        return this.dispatch("[CIRCULAR:" + objectNumber + "]");
+      }
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
+        write("buffer:");
+        return write(object.toString("utf8"));
+      }
+      if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
+        if (this[objType]) {
+          this[objType](object);
+        } else if (!options.ignoreUnknown) {
+          this.unkown(object, objType);
+        }
+      } else {
+        let keys = Object.keys(object);
+        if (options.unorderedObjects) {
+          keys = keys.sort();
+        }
+        let extraKeys = [];
+        if (options.respectType !== false && !isNativeFunction(object)) {
+          extraKeys = defaultPrototypesKeys;
+        }
+        if (options.excludeKeys) {
+          keys = keys.filter((key) => {
+            return !options.excludeKeys(key);
+          });
+          extraKeys = extraKeys.filter((key) => {
+            return !options.excludeKeys(key);
+          });
+        }
+        write("object:" + (keys.length + extraKeys.length) + ":");
+        const dispatchForKey = (key) => {
+          this.dispatch(key);
+          write(":");
+          if (!options.excludeValues) {
+            this.dispatch(object[key]);
+          }
+          write(",");
+        };
+        for (const key of keys) {
+          dispatchForKey(key);
+        }
+        for (const key of extraKeys) {
+          dispatchForKey(key);
+        }
+      }
+    },
+    array(arr, unordered) {
+      unordered = unordered === void 0 ? options.unorderedArrays !== false : unordered;
+      write("array:" + arr.length + ":");
+      if (!unordered || arr.length <= 1) {
+        for (const entry of arr) {
+          this.dispatch(entry);
+        }
+        return;
+      }
+      const contextAdditions = /* @__PURE__ */ new Map();
+      const entries = arr.map((entry) => {
+        const hasher = createHasher(options);
+        hasher.dispatch(entry);
+        for (const [key, value] of hasher.getContext()) {
+          contextAdditions.set(key, value);
+        }
+        return hasher.toString();
+      });
+      context = contextAdditions;
+      entries.sort();
+      return this.array(entries, false);
+    },
+    date(date) {
+      return write("date:" + date.toJSON());
+    },
+    symbol(sym) {
+      return write("symbol:" + sym.toString());
+    },
+    unkown(value, type) {
+      write(type);
+      if (!value) {
+        return;
+      }
+      write(":");
+      if (value && typeof value.entries === "function") {
+        return this.array(
+          Array.from(value.entries()),
+          true
+          /* ordered */
+        );
+      }
+    },
+    error(err) {
+      return write("error:" + err.toString());
+    },
+    boolean(bool) {
+      return write("bool:" + bool);
+    },
+    string(string) {
+      write("string:" + string.length + ":");
+      write(string);
+    },
+    function(fn) {
+      write("fn:");
+      if (isNativeFunction(fn)) {
+        this.dispatch("[native]");
+      } else {
+        this.dispatch(fn.toString());
+      }
+      if (options.respectFunctionNames !== false) {
+        this.dispatch("function-name:" + String(fn.name));
+      }
+      if (options.respectFunctionProperties) {
+        this.object(fn);
+      }
+    },
+    number(number) {
+      return write("number:" + number);
+    },
+    xml(xml) {
+      return write("xml:" + xml.toString());
+    },
+    null() {
+      return write("Null");
+    },
+    undefined() {
+      return write("Undefined");
+    },
+    regexp(regex) {
+      return write("regex:" + regex.toString());
+    },
+    uint8array(arr) {
+      write("uint8array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    uint8clampedarray(arr) {
+      write("uint8clampedarray:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    int8array(arr) {
+      write("int8array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    uint16array(arr) {
+      write("uint16array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    int16array(arr) {
+      write("int16array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    uint32array(arr) {
+      write("uint32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    int32array(arr) {
+      write("int32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    float32array(arr) {
+      write("float32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    float64array(arr) {
+      write("float64array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    arraybuffer(arr) {
+      write("arraybuffer:");
+      return this.dispatch(new Uint8Array(arr));
+    },
+    url(url) {
+      return write("url:" + url.toString());
+    },
+    map(map) {
+      write("map:");
+      const arr = [...map];
+      return this.array(arr, options.unorderedSets !== false);
+    },
+    set(set) {
+      write("set:");
+      const arr = [...set];
+      return this.array(arr, options.unorderedSets !== false);
+    },
+    file(file) {
+      write("file:");
+      return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
+    },
+    blob() {
+      if (options.ignoreUnknown) {
+        return write("[blob]");
+      }
+      throw new Error(
+        'Hashing Blob objects is currently not supported\nUse "options.replacer" or "options.ignoreUnknown"\n'
+      );
+    },
+    domwindow() {
+      return write("domwindow");
+    },
+    bigint(number) {
+      return write("bigint:" + number.toString());
+    },
+    /* Node.js standard native objects */
+    process() {
+      return write("process");
+    },
+    timer() {
+      return write("timer");
+    },
+    pipe() {
+      return write("pipe");
+    },
+    tcp() {
+      return write("tcp");
+    },
+    udp() {
+      return write("udp");
+    },
+    tty() {
+      return write("tty");
+    },
+    statwatcher() {
+      return write("statwatcher");
+    },
+    securecontext() {
+      return write("securecontext");
+    },
+    connection() {
+      return write("connection");
+    },
+    zlib() {
+      return write("zlib");
+    },
+    context() {
+      return write("context");
+    },
+    nodescript() {
+      return write("nodescript");
+    },
+    httpparser() {
+      return write("httpparser");
+    },
+    dataview() {
+      return write("dataview");
+    },
+    signal() {
+      return write("signal");
+    },
+    fsevent() {
+      return write("fsevent");
+    },
+    tlswrap() {
+      return write("tlswrap");
+    }
+  };
+}
+const nativeFunc = "[native code] }";
+const nativeFuncLength = nativeFunc.length;
+function isNativeFunction(f) {
+  if (typeof f !== "function") {
+    return false;
+  }
+  return Function.prototype.toString.call(f).slice(-nativeFuncLength) === nativeFunc;
+}
+
+class WordArray {
+  words;
+  sigBytes;
+  constructor(words, sigBytes) {
+    words = this.words = words || [];
+    this.sigBytes = sigBytes === void 0 ? words.length * 4 : sigBytes;
+  }
+  toString(encoder) {
+    return (encoder || Hex).stringify(this);
+  }
+  concat(wordArray) {
+    this.clamp();
+    if (this.sigBytes % 4) {
+      for (let i = 0; i < wordArray.sigBytes; i++) {
+        const thatByte = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+        this.words[this.sigBytes + i >>> 2] |= thatByte << 24 - (this.sigBytes + i) % 4 * 8;
+      }
+    } else {
+      for (let j = 0; j < wordArray.sigBytes; j += 4) {
+        this.words[this.sigBytes + j >>> 2] = wordArray.words[j >>> 2];
+      }
+    }
+    this.sigBytes += wordArray.sigBytes;
+    return this;
+  }
+  clamp() {
+    this.words[this.sigBytes >>> 2] &= 4294967295 << 32 - this.sigBytes % 4 * 8;
+    this.words.length = Math.ceil(this.sigBytes / 4);
+  }
+  clone() {
+    return new WordArray([...this.words]);
+  }
+}
+const Hex = {
+  stringify(wordArray) {
+    const hexChars = [];
+    for (let i = 0; i < wordArray.sigBytes; i++) {
+      const bite = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+      hexChars.push((bite >>> 4).toString(16), (bite & 15).toString(16));
+    }
+    return hexChars.join("");
+  }
+};
+const Base64 = {
+  stringify(wordArray) {
+    const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    const base64Chars = [];
+    for (let i = 0; i < wordArray.sigBytes; i += 3) {
+      const byte1 = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+      const byte2 = wordArray.words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;
+      const byte3 = wordArray.words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;
+      const triplet = byte1 << 16 | byte2 << 8 | byte3;
+      for (let j = 0; j < 4 && i * 8 + j * 6 < wordArray.sigBytes * 8; j++) {
+        base64Chars.push(keyStr.charAt(triplet >>> 6 * (3 - j) & 63));
+      }
+    }
+    return base64Chars.join("");
+  }
+};
+const Latin1 = {
+  parse(latin1Str) {
+    const latin1StrLength = latin1Str.length;
+    const words = [];
+    for (let i = 0; i < latin1StrLength; i++) {
+      words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;
+    }
+    return new WordArray(words, latin1StrLength);
+  }
+};
+const Utf8 = {
+  parse(utf8Str) {
+    return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+  }
+};
+class BufferedBlockAlgorithm {
+  _data = new WordArray();
+  _nDataBytes = 0;
+  _minBufferSize = 0;
+  blockSize = 512 / 32;
+  reset() {
+    this._data = new WordArray();
+    this._nDataBytes = 0;
+  }
+  _append(data) {
+    if (typeof data === "string") {
+      data = Utf8.parse(data);
+    }
+    this._data.concat(data);
+    this._nDataBytes += data.sigBytes;
+  }
+  _doProcessBlock(_dataWords, _offset) {
+  }
+  _process(doFlush) {
+    let processedWords;
+    let nBlocksReady = this._data.sigBytes / (this.blockSize * 4);
+    if (doFlush) {
+      nBlocksReady = Math.ceil(nBlocksReady);
+    } else {
+      nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
+    }
+    const nWordsReady = nBlocksReady * this.blockSize;
+    const nBytesReady = Math.min(nWordsReady * 4, this._data.sigBytes);
+    if (nWordsReady) {
+      for (let offset = 0; offset < nWordsReady; offset += this.blockSize) {
+        this._doProcessBlock(this._data.words, offset);
+      }
+      processedWords = this._data.words.splice(0, nWordsReady);
+      this._data.sigBytes -= nBytesReady;
+    }
+    return new WordArray(processedWords, nBytesReady);
+  }
+}
+class Hasher extends BufferedBlockAlgorithm {
+  update(messageUpdate) {
+    this._append(messageUpdate);
+    this._process();
+    return this;
+  }
+  finalize(messageUpdate) {
+    if (messageUpdate) {
+      this._append(messageUpdate);
+    }
+  }
+}
+
+const H = [
+  1779033703,
+  -1150833019,
+  1013904242,
+  -1521486534,
+  1359893119,
+  -1694144372,
+  528734635,
+  1541459225
+];
+const K = [
+  1116352408,
+  1899447441,
+  -1245643825,
+  -373957723,
+  961987163,
+  1508970993,
+  -1841331548,
+  -1424204075,
+  -670586216,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  -2132889090,
+  -1680079193,
+  -1046744716,
+  -459576895,
+  -272742522,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  -1740746414,
+  -1473132947,
+  -1341970488,
+  -1084653625,
+  -958395405,
+  -710438585,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  -2117940946,
+  -1838011259,
+  -1564481375,
+  -1474664885,
+  -1035236496,
+  -949202525,
+  -778901479,
+  -694614492,
+  -200395387,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  -2067236844,
+  -1933114872,
+  -1866530822,
+  -1538233109,
+  -1090935817,
+  -965641998
+];
+const W = [];
+class SHA256 extends Hasher {
+  _hash = new WordArray([...H]);
+  /**
+   * Resets the internal state of the hash object to initial values.
+   */
+  reset() {
+    super.reset();
+    this._hash = new WordArray([...H]);
+  }
+  _doProcessBlock(M, offset) {
+    const H2 = this._hash.words;
+    let a = H2[0];
+    let b = H2[1];
+    let c = H2[2];
+    let d = H2[3];
+    let e = H2[4];
+    let f = H2[5];
+    let g = H2[6];
+    let h = H2[7];
+    for (let i = 0; i < 64; i++) {
+      if (i < 16) {
+        W[i] = M[offset + i] | 0;
+      } else {
+        const gamma0x = W[i - 15];
+        const gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;
+        const gamma1x = W[i - 2];
+        const gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;
+        W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
+      }
+      const ch = e & f ^ ~e & g;
+      const maj = a & b ^ a & c ^ b & c;
+      const sigma0 = (a << 30 | a >>> 2) ^ (a << 19 | a >>> 13) ^ (a << 10 | a >>> 22);
+      const sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);
+      const t1 = h + sigma1 + ch + K[i] + W[i];
+      const t2 = sigma0 + maj;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    H2[0] = H2[0] + a | 0;
+    H2[1] = H2[1] + b | 0;
+    H2[2] = H2[2] + c | 0;
+    H2[3] = H2[3] + d | 0;
+    H2[4] = H2[4] + e | 0;
+    H2[5] = H2[5] + f | 0;
+    H2[6] = H2[6] + g | 0;
+    H2[7] = H2[7] + h | 0;
+  }
+  /**
+   * Finishes the hash calculation and returns the hash as a WordArray.
+   *
+   * @param {string} messageUpdate - Additional message content to include in the hash.
+   * @returns {WordArray} The finalised hash as a WordArray.
+   */
+  finalize(messageUpdate) {
+    super.finalize(messageUpdate);
+    const nBitsTotal = this._nDataBytes * 8;
+    const nBitsLeft = this._data.sigBytes * 8;
+    this._data.words[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(
+      nBitsTotal / 4294967296
+    );
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
+    this._data.sigBytes = this._data.words.length * 4;
+    this._process();
+    return this._hash;
+  }
+}
+function sha256base64(message) {
+  return new SHA256().finalize(message).toString(Base64);
+}
+
+function hash(object, options = {}) {
+  const hashed = typeof object === "string" ? object : objectHash(object, options);
+  return sha256base64(hashed).slice(0, 10);
+}
 
 class CloudCache {
   memoryCache;
@@ -53,8 +671,8 @@ class CloudCache {
    */
   ensureCacheDir() {
     try {
-      if (!nodeFs__default.existsSync(this.cacheDir)) {
-        nodeFs__default.mkdirSync(this.cacheDir, { recursive: true });
+      if (!fs__default.existsSync(this.cacheDir)) {
+        fs__default.mkdirSync(this.cacheDir, { recursive: true });
         consola.debug("Created cache directory:", this.cacheDir);
       }
     } catch (error) {
@@ -68,8 +686,8 @@ class CloudCache {
   loadCacheFromDisk() {
     try {
       const cacheFile = path__default.join(this.cacheDir, "cache.json");
-      if (nodeFs__default.existsSync(cacheFile)) {
-        const data = nodeFs__default.readFileSync(cacheFile, "utf-8");
+      if (fs__default.existsSync(cacheFile)) {
+        const data = fs__default.readFileSync(cacheFile, "utf-8");
         const entries = JSON.parse(data);
         const now = Date.now();
         for (const [key, entry] of Object.entries(entries)) {
@@ -90,7 +708,7 @@ class CloudCache {
     try {
       const cacheFile = path__default.join(this.cacheDir, "cache.json");
       const entries = Object.fromEntries(this.memoryCache);
-      nodeFs__default.writeFileSync(cacheFile, JSON.stringify(entries, null, 2));
+      fs__default.writeFileSync(cacheFile, JSON.stringify(entries, null, 2));
     } catch (error) {
       consola.warn("Failed to save cache to disk:", error);
     }
@@ -1177,7 +1795,7 @@ class CloudSetupOrchestrator {
    */
   async analyzeProject(options) {
     if (options.interactive !== false) {
-      console.log(ansis.bold(`
+      console.log(a.bold(`
   ${i18n.t("cloud-setup:analyzingProject")}`));
     }
     const analysis = await analyzeProject(options.targetDir || process.cwd(), {
@@ -1211,12 +1829,12 @@ class CloudSetupOrchestrator {
    * Display project information
    */
   displayProjectInfo(analysis) {
-    console.log(`    ${ansis.dim(i18n.t("cloud-setup:projectType"))}: ${analysis.projectType}`);
+    console.log(`    ${a.dim(i18n.t("cloud-setup:projectType"))}: ${analysis.projectType}`);
     if (analysis.frameworks.length > 0) {
-      console.log(`    ${ansis.dim(i18n.t("cloud-setup:frameworks"))}: ${analysis.frameworks.map((f) => f.name).join(", ")}`);
+      console.log(`    ${a.dim(i18n.t("cloud-setup:frameworks"))}: ${analysis.frameworks.map((f) => f.name).join(", ")}`);
     }
     if (analysis.languages.length > 0) {
-      console.log(`    ${ansis.dim(i18n.t("cloud-setup:languages"))}: ${analysis.languages.map((l) => l.language).join(", ")}`);
+      console.log(`    ${a.dim(i18n.t("cloud-setup:languages"))}: ${analysis.languages.map((l) => l.language).join(", ")}`);
     }
   }
   /**
@@ -1228,7 +1846,7 @@ class CloudSetupOrchestrator {
     }
     if (options.interactive !== false) {
       console.log(`
-  ${ansis.bold(i18n.t("cloud-setup:gettingRecommendations"))}`);
+  ${a.bold(i18n.t("cloud-setup:gettingRecommendations"))}`);
     }
     const request = {
       projectRoot: options.targetDir || process.cwd(),
@@ -1441,63 +2059,63 @@ class CloudSetupOrchestrator {
     if (options.interactive === false)
       return;
     console.log(`
-  ${ansis.bold(i18n.t("cloud-setup:cloudRecommendations"))} ${ansis.dim(`(${i18n.t("cloud-setup:confidence")} ${recommendations.confidence}%)`)}`);
+  ${a.bold(i18n.t("cloud-setup:cloudRecommendations"))} ${a.dim(`(${i18n.t("cloud-setup:confidence")} ${recommendations.confidence}%)`)}`);
     console.log("");
     if (recommendations.skills.length > 0) {
-      console.log(`  ${ansis.bold(i18n.t("cloud-setup:skills"))} (${recommendations.skills.length}):`);
+      console.log(`  ${a.bold(i18n.t("cloud-setup:skills"))} (${recommendations.skills.length}):`);
       for (const skill of recommendations.skills) {
         const confidence = options.showConfidence ? ` [${Math.round(skill.relevanceScore * 100)}%]` : "";
         const skillName = extractString(skill.name, skill.id, i18n.language);
         const skillDesc = extractString(skill.description, "", i18n.language);
         const reason = options.showRecommendationReason && skillDesc ? ` - ${skillDesc}` : "";
-        console.log(`    ${ansis.green("\u2713")} ${skillName}${ansis.dim(confidence)}${ansis.dim(reason)}`);
+        console.log(`    ${a.green("\u2713")} ${skillName}${a.dim(confidence)}${a.dim(reason)}`);
       }
     }
     if (recommendations.mcpServices.length > 0) {
       console.log(`
-  ${ansis.bold(i18n.t("cloud-setup:mcpServices"))} (${recommendations.mcpServices.length}):`);
+  ${a.bold(i18n.t("cloud-setup:mcpServices"))} (${recommendations.mcpServices.length}):`);
       for (const service of recommendations.mcpServices) {
         const confidence = options.showConfidence ? ` [${Math.round(service.relevanceScore * 100)}%]` : "";
         const serviceName = extractString(service.name, service.id, i18n.language);
         const serviceDesc = extractString(service.description, "", i18n.language);
         const reason = options.showRecommendationReason && serviceDesc ? ` - ${serviceDesc}` : "";
-        console.log(`    ${ansis.green("\u2713")} ${serviceName}${ansis.dim(confidence)}${ansis.dim(reason)}`);
+        console.log(`    ${a.green("\u2713")} ${serviceName}${a.dim(confidence)}${a.dim(reason)}`);
       }
     }
     if (recommendations.agents.length > 0) {
       console.log(`
-  ${ansis.bold(i18n.t("cloud-setup:agents"))} (${recommendations.agents.length}):`);
+  ${a.bold(i18n.t("cloud-setup:agents"))} (${recommendations.agents.length}):`);
       for (const agent of recommendations.agents) {
         const confidence = options.showConfidence ? ` [${Math.round(agent.relevanceScore * 100)}%]` : "";
         const agentName = extractString(agent.name, agent.id, i18n.language);
         const agentDesc = extractString(agent.description, "", i18n.language);
         const reason = options.showRecommendationReason && agentDesc ? ` - ${agentDesc}` : "";
-        console.log(`    ${ansis.green("\u2713")} ${agentName}${ansis.dim(confidence)}${ansis.dim(reason)}`);
+        console.log(`    ${a.green("\u2713")} ${agentName}${a.dim(confidence)}${a.dim(reason)}`);
       }
     }
     if (recommendations.hooks.length > 0) {
       console.log(`
-  ${ansis.bold(i18n.t("cloud-setup:hooks"))} (${recommendations.hooks.length}):`);
+  ${a.bold(i18n.t("cloud-setup:hooks"))} (${recommendations.hooks.length}):`);
       for (const hook of recommendations.hooks) {
         const confidence = options.showConfidence ? ` [${Math.round(hook.relevanceScore * 100)}%]` : "";
         const hookName = extractString(hook.name, hook.id, i18n.language);
         const hookDesc = extractString(hook.description, "", i18n.language);
         const reason = options.showRecommendationReason && hookDesc ? ` - ${hookDesc}` : "";
-        console.log(`    ${ansis.green("\u2713")} ${hookName}${ansis.dim(confidence)}${ansis.dim(reason)}`);
+        console.log(`    ${a.green("\u2713")} ${hookName}${a.dim(confidence)}${a.dim(reason)}`);
       }
     }
     if (recommendations.insights?.insights && recommendations.insights.insights.length > 0) {
       console.log(`
-  ${ansis.bold(i18n.t("cloud-setup:insights"))}:`);
+  ${a.bold(i18n.t("cloud-setup:insights"))}:`);
       for (const insight of recommendations.insights.insights) {
-        console.log(`    ${ansis.cyan("\u{1F4A1}")} ${insight}`);
+        console.log(`    ${a.cyan("\u{1F4A1}")} ${insight}`);
       }
     }
     if (recommendations.insights?.productivityImprovements && recommendations.insights.productivityImprovements.length > 0) {
       console.log(`
-  ${ansis.bold(i18n.t("cloud-setup:productivityImprovements"))}:`);
+  ${a.bold(i18n.t("cloud-setup:productivityImprovements"))}:`);
       for (const improvement of recommendations.insights.productivityImprovements) {
-        console.log(`    ${ansis.green("\u2191")} ${improvement.resource}: +${improvement.improvement}% ${improvement.reason}`);
+        console.log(`    ${a.green("\u2191")} ${improvement.resource}: +${improvement.improvement}% ${improvement.reason}`);
       }
     }
   }
@@ -1510,11 +2128,11 @@ class CloudSetupOrchestrator {
     const totalResources = recommendations.skills.length + recommendations.mcpServices.length + recommendations.agents.length + recommendations.hooks.length;
     if (totalResources === 0) {
       console.log(`
-  ${ansis.yellow(i18n.t("cloud-setup:noRecommendations"))}`);
+  ${a.yellow(i18n.t("cloud-setup:noRecommendations"))}`);
       return false;
     }
     try {
-      const inquirerModule = await import('inquirer');
+      const inquirerModule = await import('./index3.mjs').then(function (n) { return n.c; });
       const inquirer = inquirerModule.default || inquirerModule;
       const { confirm } = await inquirer.prompt([
         {
@@ -1536,7 +2154,7 @@ class CloudSetupOrchestrator {
   async downloadTemplates(recommendations, options) {
     if (options.interactive !== false) {
       console.log(`
-  ${ansis.bold(i18n.t("cloud-setup:downloadingTemplates"))}`);
+  ${a.bold(i18n.t("cloud-setup:downloadingTemplates"))}`);
     }
     const allRecommendations = [
       ...recommendations.skills,
@@ -1551,7 +2169,7 @@ class CloudSetupOrchestrator {
         language: options.lang
       });
       if (options.interactive !== false) {
-        console.log(`    ${ansis.green("\u2713")} ${i18n.t("cloud-setup:templatesDownloaded", { count: Object.keys(response.templates).length })}`);
+        console.log(`    ${a.green("\u2713")} ${i18n.t("cloud-setup:templatesDownloaded", { count: Object.keys(response.templates).length })}`);
       }
       return response;
     } catch (error) {
@@ -1565,7 +2183,7 @@ class CloudSetupOrchestrator {
   async executeInstallation(recommendations, templates, options) {
     if (options.interactive !== false) {
       console.log(`
-  ${ansis.bold(i18n.t("cloud-setup:installingResources"))}`);
+  ${a.bold(i18n.t("cloud-setup:installingResources"))}`);
     }
     const result = {
       success: true,
@@ -1616,7 +2234,7 @@ class CloudSetupOrchestrator {
       await ccjkSkills(skillsOptions);
       result.installed.skills = skillIds;
       if (options.interactive !== false) {
-        console.log(`    ${ansis.green("\u2713")} ${skills.length}/${skills.length} (${((Date.now() - this.startTime) / 1e3).toFixed(1)}s)`);
+        console.log(`    ${a.green("\u2713")} ${skills.length}/${skills.length} (${((Date.now() - this.startTime) / 1e3).toFixed(1)}s)`);
       }
     } catch (error) {
       this.logger.error("Skills installation failed:", error);
@@ -1642,7 +2260,7 @@ class CloudSetupOrchestrator {
       await ccjkMcp(mcpOptions);
       result.installed.mcpServices = services.map((s) => s.id);
       if (options.interactive !== false) {
-        console.log(`    ${ansis.green("\u2713")} ${services.length}/${services.length} (${((Date.now() - this.startTime) / 1e3).toFixed(1)}s)`);
+        console.log(`    ${a.green("\u2713")} ${services.length}/${services.length} (${((Date.now() - this.startTime) / 1e3).toFixed(1)}s)`);
       }
     } catch (error) {
       this.logger.error("MCP services installation failed:", error);
@@ -1667,7 +2285,7 @@ class CloudSetupOrchestrator {
       await ccjkAgents(agentOptions);
       result.installed.agents = agents.map((a) => a.id);
       if (options.interactive !== false) {
-        console.log(`    ${ansis.green("\u2713")} ${agents.length}/${agents.length} (${((Date.now() - this.startTime) / 1e3).toFixed(1)}s)`);
+        console.log(`    ${a.green("\u2713")} ${agents.length}/${agents.length} (${((Date.now() - this.startTime) / 1e3).toFixed(1)}s)`);
       }
     } catch (error) {
       this.logger.error("Agents installation failed:", error);
@@ -1691,7 +2309,7 @@ class CloudSetupOrchestrator {
       await ccjkHooks(hookOptions);
       result.installed.hooks = hooks.map((h) => h.id);
       if (options.interactive !== false) {
-        console.log(`    ${ansis.green("\u2713")} ${hooks.length}/${hooks.length} (${((Date.now() - this.startTime) / 1e3).toFixed(1)}s)`);
+        console.log(`    ${a.green("\u2713")} ${hooks.length}/${hooks.length} (${((Date.now() - this.startTime) / 1e3).toFixed(1)}s)`);
       }
     } catch (error) {
       this.logger.error("Hooks installation failed:", error);
@@ -1703,26 +2321,26 @@ class CloudSetupOrchestrator {
    */
   displaySummary(result, options) {
     console.log("");
-    console.log(ansis.green(`  ${i18n.t("cloud-setup:setupComplete")}`));
+    console.log(a.green(`  ${i18n.t("cloud-setup:setupComplete")}`));
     const totalInstalled = result.installed.skills.length + result.installed.mcpServices.length + result.installed.agents.length + result.installed.hooks.length;
     console.log(`  ${i18n.t("cloud-setup:installedResources", { count: totalInstalled, duration: (result.duration / 1e3).toFixed(1) })}`);
     if (result.insights) {
       console.log(`
-  ${ansis.bold(i18n.t("cloud-setup:cloudFeedback"))}`);
+  ${a.bold(i18n.t("cloud-setup:cloudFeedback"))}`);
       for (const insight of result.insights.insights) {
-        console.log(`    ${ansis.cyan("\u2022")} ${insight}`);
+        console.log(`    ${a.cyan("\u2022")} ${insight}`);
       }
     }
     console.log(`
-  ${ansis.bold(i18n.t("cloud-setup:nextSteps"))}`);
-    console.log(`    ${ansis.dim("\u2022")} ${i18n.t("cloud-setup:startCoding")}`);
+  ${a.bold(i18n.t("cloud-setup:nextSteps"))}`);
+    console.log(`    ${a.dim("\u2022")} ${i18n.t("cloud-setup:startCoding")}`);
     if (options.showRecommendationReason) {
-      console.log(`    ${ansis.dim("\u2022")} ${i18n.t("cloud-setup:viewRecommendations")}`);
+      console.log(`    ${a.dim("\u2022")} ${i18n.t("cloud-setup:viewRecommendations")}`);
     }
-    console.log(`    ${ansis.dim("\u2022")} ${i18n.t("cloud-setup:customizeSetup")}`);
+    console.log(`    ${a.dim("\u2022")} ${i18n.t("cloud-setup:customizeSetup")}`);
     if (result.reportPath) {
       console.log(`
-  ${ansis.dim(i18n.t("cloud-setup:reportGenerated", { path: result.reportPath }))}`);
+  ${a.dim(i18n.t("cloud-setup:reportGenerated", { path: result.reportPath }))}`);
     }
   }
   /**
@@ -1860,7 +2478,7 @@ class CloudSetupOrchestrator {
       return await this.executeCloudSetup(options);
     } catch (error) {
       if (error.code === "ENOTFOUND" || error.code === "ECONNREFUSED") {
-        console.warn(ansis.yellow(`
+        console.warn(a.yellow(`
   ${i18n.t("cloud-setup:cloudUnavailable")}`));
         console.warn(`  ${i18n.t("cloud-setup:fallingBackToLocal")}`);
         options.useCloud = false;
@@ -1929,11 +2547,11 @@ async function ccjkAll(options = {}) {
       }));
     } else if (!options.quiet) {
       console.error(`
-  ${ansis.red("\u2717")} ${isZh ? "\u8BBE\u7F6E\u5931\u8D25" : "Setup failed"}`);
-      console.error(`    ${ansis.red(error.message)}`);
+  ${a.red("\u2717")} ${isZh ? "\u8BBE\u7F6E\u5931\u8D25" : "Setup failed"}`);
+      console.error(`    ${a.red(error.message)}`);
       if (error.code === "ENOTFOUND") {
         console.error(`
-  ${ansis.yellow("\u2139")} ${isZh ? "\u4E91\u670D\u52A1\u548C\u672C\u5730\u670D\u52A1\u90FD\u4E0D\u53EF\u7528" : "Both cloud and local services are unavailable"}`);
+  ${a.yellow("\u2139")} ${isZh ? "\u4E91\u670D\u52A1\u548C\u672C\u5730\u670D\u52A1\u90FD\u4E0D\u53EF\u7528" : "Both cloud and local services are unavailable"}`);
         console.error(`    ${isZh ? "\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u6216\u7A0D\u540E\u518D\u8BD5" : "Please check your network connection or try again later"}`);
       }
     }
@@ -1942,15 +2560,15 @@ async function ccjkAll(options = {}) {
 }
 function displayHeader() {
   console.log("");
-  console.log(ansis.bold.cyan("\u2501".repeat(60)));
-  console.log(ansis.bold.cyan(`  ${i18n.t("ccjk-all:title")}`));
-  console.log(ansis.bold.cyan("\u2501".repeat(60)));
+  console.log(a.bold.cyan("\u2501".repeat(60)));
+  console.log(a.bold.cyan(`  ${i18n.t("ccjk-all:title")}`));
+  console.log(a.bold.cyan("\u2501".repeat(60)));
   console.log("");
 }
 async function checkCloudAvailability(options) {
   const logger = consola.withTag("cloud-check");
   i18n.language === "zh-CN";
-  console.log(`  ${ansis.bold(i18n.t("ccjk-all:connectingToCloud"))}`);
+  console.log(`  ${a.bold(i18n.t("ccjk-all:connectingToCloud"))}`);
   try {
     const client = createCompleteCloudClient({
       baseURL: options.cloudEndpoint || "https://api.ccjk.cloud"
@@ -1958,49 +2576,49 @@ async function checkCloudAvailability(options) {
     const startTime = Date.now();
     const health = await client.healthCheck();
     const latency = Date.now() - startTime;
-    console.log(`    ${ansis.green("\u2713")} ${i18n.t("ccjk-all:connected")} ${ansis.dim(`(${i18n.t("ccjk-all:latency")} ${latency}ms)`)}`);
-    console.log(`    ${ansis.green("\u2713")} ${i18n.t("ccjk-all:cloudVersion")} ${ansis.dim(health.version || "unknown")}`);
+    console.log(`    ${a.green("\u2713")} ${i18n.t("ccjk-all:connected")} ${a.dim(`(${i18n.t("ccjk-all:latency")} ${latency}ms)`)}`);
+    console.log(`    ${a.green("\u2713")} ${i18n.t("ccjk-all:cloudVersion")} ${a.dim(health.version || "unknown")}`);
   } catch (error) {
     logger.warn("Cloud service unavailable:", error);
-    console.log(`    ${ansis.yellow("\u26A0")} ${i18n.t("ccjk-all:cloudUnavailable")}`);
-    console.log(`    ${ansis.dim(i18n.t("ccjk-all:usingLocalMode"))}`);
+    console.log(`    ${a.yellow("\u26A0")} ${i18n.t("ccjk-all:cloudUnavailable")}`);
+    console.log(`    ${a.dim(i18n.t("ccjk-all:usingLocalMode"))}`);
     options.useCloud = false;
   }
 }
 function displayCompletion(result) {
   console.log("");
-  console.log(ansis.green(`  ${i18n.t("ccjk-all:setupComplete")}`));
+  console.log(a.green(`  ${i18n.t("ccjk-all:setupComplete")}`));
   const totalInstalled = result.installed.skills.length + result.installed.mcpServices.length + result.installed.agents.length + result.installed.hooks.length;
   console.log(`  ${i18n.t("ccjk-all:installedCount", { count: totalInstalled, duration: (result.duration / 1e3).toFixed(1) })}`);
   if (result.insights?.insights && result.insights.insights.length > 0) {
     console.log(`
-  ${ansis.bold(i18n.t("ccjk-all:cloudFeedback"))}`);
+  ${a.bold(i18n.t("ccjk-all:cloudFeedback"))}`);
     for (const insight of result.insights.insights) {
-      console.log(`    ${ansis.cyan("\u2022")} ${insight}`);
+      console.log(`    ${a.cyan("\u2022")} ${insight}`);
     }
   }
   console.log(`
-  ${ansis.bold(i18n.t("ccjk-all:nextSteps"))}`);
-  console.log(`    ${ansis.dim("\u2022")} ${i18n.t("ccjk-all:startCoding")}`);
-  console.log(`    ${ansis.dim("\u2022")} ${i18n.t("ccjk-all:viewRecommendations")}`);
-  console.log(`    ${ansis.dim("\u2022")} ${i18n.t("ccjk-all:customizeSetup")}`);
+  ${a.bold(i18n.t("ccjk-all:nextSteps"))}`);
+  console.log(`    ${a.dim("\u2022")} ${i18n.t("ccjk-all:startCoding")}`);
+  console.log(`    ${a.dim("\u2022")} ${i18n.t("ccjk-all:viewRecommendations")}`);
+  console.log(`    ${a.dim("\u2022")} ${i18n.t("ccjk-all:customizeSetup")}`);
   if (result.reportPath) {
     console.log(`
-  ${ansis.dim(i18n.t("ccjk-all:reportGenerated", { path: result.reportPath }))}`);
+  ${a.dim(i18n.t("ccjk-all:reportGenerated", { path: result.reportPath }))}`);
   }
   console.log("");
 }
 function displayHelp() {
   i18n.language === "zh-CN";
   console.log("");
-  console.log(ansis.bold.cyan("\u2501".repeat(60)));
-  console.log(ansis.bold.cyan(`  ${i18n.t("ccjk-all:helpTitle")}`));
-  console.log(ansis.bold.cyan("\u2501".repeat(60)));
+  console.log(a.bold.cyan("\u2501".repeat(60)));
+  console.log(a.bold.cyan(`  ${i18n.t("ccjk-all:helpTitle")}`));
+  console.log(a.bold.cyan("\u2501".repeat(60)));
   console.log("");
-  console.log(ansis.bold(i18n.t("ccjk-all:usage")));
+  console.log(a.bold(i18n.t("ccjk-all:usage")));
   console.log("  ccjk ccjk:all [options]");
   console.log("");
-  console.log(ansis.bold(i18n.t("ccjk-all:options")));
+  console.log(a.bold(i18n.t("ccjk-all:options")));
   console.log("  --strategy <type>          Cloud strategy (cloud-smart, cloud-conservative, local-fallback)");
   console.log("  --use-cloud <bool>        Use cloud recommendations (default: true)");
   console.log("  --cloud-endpoint <url>   Cloud API endpoint");
@@ -2023,7 +2641,7 @@ function displayHelp() {
   console.log("  --help                   Show help");
   console.log("  --version                Show version");
   console.log("");
-  console.log(ansis.bold(i18n.t("ccjk-all:examples")));
+  console.log(a.bold(i18n.t("ccjk-all:examples")));
   console.log("  ccjk ccjk:all                    # Interactive cloud-powered setup");
   console.log("  ccjk ccjk:all --strategy cloud-smart  # Use cloud-smart strategy");
   console.log("  ccjk ccjk:all --use-cloud false  # Local mode only");
@@ -2031,7 +2649,7 @@ function displayHelp() {
   console.log("  ccjk ccjk:all --generate-report  # Generate detailed report");
   console.log("  ccjk ccjk:all --dry-run          # Preview without installing");
   console.log("");
-  console.log(ansis.bold(i18n.t("ccjk-all:strategies")));
+  console.log(a.bold(i18n.t("ccjk-all:strategies")));
   console.log("  cloud-smart         Use cloud with intelligent fallback");
   console.log("  cloud-conservative  Prefer cloud but strict about errors");
   console.log("  local-fallback      Use local recommendations only");