ccjk 14.2.2 → 15.0.0

package/dist/shared/ccjk.CoCHVXl3.mjs

@@ -1,3951 +0,0 @@
-import { promises, existsSync } from 'node:fs';
-import posix from '../chunks/index10.mjs';
-import { glob } from 'tinyglobby';
-import { p as parse } from './ccjk.BBtCGd_g.mjs';
-import { CLOUD_ENDPOINTS } from '../chunks/constants.mjs';
-
-const LogLevels = {
-  fatal: 0,
-  error: 0,
-  warn: 1,
-  log: 2,
-  info: 3,
-  success: 3,
-  fail: 3,
-  debug: 4,
-  trace: 5,
-  verbose: Number.POSITIVE_INFINITY
-};
-const LogTypes = {
-  // Silent
-  silent: {
-    level: -1
-  },
-  // Level 0
-  fatal: {
-    level: LogLevels.fatal
-  },
-  error: {
-    level: LogLevels.error
-  },
-  // Level 1
-  warn: {
-    level: LogLevels.warn
-  },
-  // Level 2
-  log: {
-    level: LogLevels.log
-  },
-  // Level 3
-  info: {
-    level: LogLevels.info
-  },
-  success: {
-    level: LogLevels.success
-  },
-  fail: {
-    level: LogLevels.fail
-  },
-  ready: {
-    level: LogLevels.info
-  },
-  start: {
-    level: LogLevels.info
-  },
-  box: {
-    level: LogLevels.info
-  },
-  // Level 4
-  debug: {
-    level: LogLevels.debug
-  },
-  // Level 5
-  trace: {
-    level: LogLevels.trace
-  },
-  // Verbose
-  verbose: {
-    level: LogLevels.verbose
-  }
-};
-
-function isPlainObject$1(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
-    return false;
-  }
-  if (Symbol.iterator in value) {
-    return false;
-  }
-  if (Symbol.toStringTag in value) {
-    return Object.prototype.toString.call(value) === "[object Module]";
-  }
-  return true;
-}
-
-function _defu(baseObject, defaults, namespace = ".", merger) {
-  if (!isPlainObject$1(defaults)) {
-    return _defu(baseObject, {}, namespace);
-  }
-  const object = Object.assign({}, defaults);
-  for (const key in baseObject) {
-    if (key === "__proto__" || key === "constructor") {
-      continue;
-    }
-    const value = baseObject[key];
-    if (value === null || value === void 0) {
-      continue;
-    }
-    if (Array.isArray(value) && Array.isArray(object[key])) {
-      object[key] = [...value, ...object[key]];
-    } else if (isPlainObject$1(value) && isPlainObject$1(object[key])) {
-      object[key] = _defu(
-        value,
-        object[key],
-        (namespace ? `${namespace}.` : "") + key.toString());
-    } else {
-      object[key] = value;
-    }
-  }
-  return object;
-}
-function createDefu(merger) {
-  return (...arguments_) => (
-    // eslint-disable-next-line unicorn/no-array-reduce
-    arguments_.reduce((p, c) => _defu(p, c, ""), {})
-  );
-}
-const defu = createDefu();
-
-function isPlainObject(obj) {
-  return Object.prototype.toString.call(obj) === "[object Object]";
-}
-function isLogObj(arg) {
-  if (!isPlainObject(arg)) {
-    return false;
-  }
-  if (!arg.message && !arg.args) {
-    return false;
-  }
-  if (arg.stack) {
-    return false;
-  }
-  return true;
-}
-
-let paused = false;
-const queue = [];
-class Consola {
-  options;
-  _lastLog;
-  _mockFn;
-  /**
-   * Creates an instance of Consola with specified options or defaults.
-   *
-   * @param {Partial<ConsolaOptions>} [options={}] - Configuration options for the Consola instance.
-   */
-  constructor(options = {}) {
-    const types = options.types || LogTypes;
-    this.options = defu(
-      {
-        ...options,
-        defaults: { ...options.defaults },
-        level: _normalizeLogLevel(options.level, types),
-        reporters: [...options.reporters || []]
-      },
-      {
-        types: LogTypes,
-        throttle: 1e3,
-        throttleMin: 5,
-        formatOptions: {
-          date: true,
-          colors: false,
-          compact: true
-        }
-      }
-    );
-    for (const type in types) {
-      const defaults = {
-        type,
-        ...this.options.defaults,
-        ...types[type]
-      };
-      this[type] = this._wrapLogFn(defaults);
-      this[type].raw = this._wrapLogFn(
-        defaults,
-        true
-      );
-    }
-    if (this.options.mockFn) {
-      this.mockTypes();
-    }
-    this._lastLog = {};
-  }
-  /**
-   * Gets the current log level of the Consola instance.
-   *
-   * @returns {number} The current log level.
-   */
-  get level() {
-    return this.options.level;
-  }
-  /**
-   * Sets the minimum log level that will be output by the instance.
-   *
-   * @param {number} level - The new log level to set.
-   */
-  set level(level) {
-    this.options.level = _normalizeLogLevel(
-      level,
-      this.options.types,
-      this.options.level
-    );
-  }
-  /**
-   * Displays a prompt to the user and returns the response.
-   * Throw an error if `prompt` is not supported by the current configuration.
-   *
-   * @template T
-   * @param {string} message - The message to display in the prompt.
-   * @param {T} [opts] - Optional options for the prompt. See {@link PromptOptions}.
-   * @returns {promise<T>} A promise that infer with the prompt options. See {@link PromptOptions}.
-   */
-  prompt(message, opts) {
-    if (!this.options.prompt) {
-      throw new Error("prompt is not supported!");
-    }
-    return this.options.prompt(message, opts);
-  }
-  /**
-   * Creates a new instance of Consola, inheriting options from the current instance, with possible overrides.
-   *
-   * @param {Partial<ConsolaOptions>} options - Optional overrides for the new instance. See {@link ConsolaOptions}.
-   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
-   */
-  create(options) {
-    const instance = new Consola({
-      ...this.options,
-      ...options
-    });
-    if (this._mockFn) {
-      instance.mockTypes(this._mockFn);
-    }
-    return instance;
-  }
-  /**
-   * Creates a new Consola instance with the specified default log object properties.
-   *
-   * @param {InputLogObject} defaults - Default properties to include in any log from the new instance. See {@link InputLogObject}.
-   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
-   */
-  withDefaults(defaults) {
-    return this.create({
-      ...this.options,
-      defaults: {
-        ...this.options.defaults,
-        ...defaults
-      }
-    });
-  }
-  /**
-   * Creates a new Consola instance with a specified tag, which will be included in every log.
-   *
-   * @param {string} tag - The tag to include in each log of the new instance.
-   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
-   */
-  withTag(tag) {
-    return this.withDefaults({
-      tag: this.options.defaults.tag ? this.options.defaults.tag + ":" + tag : tag
-    });
-  }
-  /**
-   * Adds a custom reporter to the Consola instance.
-   * Reporters will be called for each log message, depending on their implementation and log level.
-   *
-   * @param {ConsolaReporter} reporter - The reporter to add. See {@link ConsolaReporter}.
-   * @returns {Consola} The current Consola instance.
-   */
-  addReporter(reporter) {
-    this.options.reporters.push(reporter);
-    return this;
-  }
-  /**
-   * Removes a custom reporter from the Consola instance.
-   * If no reporter is specified, all reporters will be removed.
-   *
-   * @param {ConsolaReporter} reporter - The reporter to remove. See {@link ConsolaReporter}.
-   * @returns {Consola} The current Consola instance.
-   */
-  removeReporter(reporter) {
-    if (reporter) {
-      const i = this.options.reporters.indexOf(reporter);
-      if (i !== -1) {
-        return this.options.reporters.splice(i, 1);
-      }
-    } else {
-      this.options.reporters.splice(0);
-    }
-    return this;
-  }
-  /**
-   * Replaces all reporters of the Consola instance with the specified array of reporters.
-   *
-   * @param {ConsolaReporter[]} reporters - The new reporters to set. See {@link ConsolaReporter}.
-   * @returns {Consola} The current Consola instance.
-   */
-  setReporters(reporters) {
-    this.options.reporters = Array.isArray(reporters) ? reporters : [reporters];
-    return this;
-  }
-  wrapAll() {
-    this.wrapConsole();
-    this.wrapStd();
-  }
-  restoreAll() {
-    this.restoreConsole();
-    this.restoreStd();
-  }
-  /**
-   * Overrides console methods with Consola logging methods for consistent logging.
-   */
-  wrapConsole() {
-    for (const type in this.options.types) {
-      if (!console["__" + type]) {
-        console["__" + type] = console[type];
-      }
-      console[type] = this[type].raw;
-    }
-  }
-  /**
-   * Restores the original console methods, removing Consola overrides.
-   */
-  restoreConsole() {
-    for (const type in this.options.types) {
-      if (console["__" + type]) {
-        console[type] = console["__" + type];
-        delete console["__" + type];
-      }
-    }
-  }
-  /**
-   * Overrides standard output and error streams to redirect them through Consola.
-   */
-  wrapStd() {
-    this._wrapStream(this.options.stdout, "log");
-    this._wrapStream(this.options.stderr, "log");
-  }
-  _wrapStream(stream, type) {
-    if (!stream) {
-      return;
-    }
-    if (!stream.__write) {
-      stream.__write = stream.write;
-    }
-    stream.write = (data) => {
-      this[type].raw(String(data).trim());
-    };
-  }
-  /**
-   * Restores the original standard output and error streams, removing the Consola redirection.
-   */
-  restoreStd() {
-    this._restoreStream(this.options.stdout);
-    this._restoreStream(this.options.stderr);
-  }
-  _restoreStream(stream) {
-    if (!stream) {
-      return;
-    }
-    if (stream.__write) {
-      stream.write = stream.__write;
-      delete stream.__write;
-    }
-  }
-  /**
-   * Pauses logging, queues incoming logs until resumed.
-   */
-  pauseLogs() {
-    paused = true;
-  }
-  /**
-   * Resumes logging, processing any queued logs.
-   */
-  resumeLogs() {
-    paused = false;
-    const _queue = queue.splice(0);
-    for (const item of _queue) {
-      item[0]._logFn(item[1], item[2]);
-    }
-  }
-  /**
-   * Replaces logging methods with mocks if a mock function is provided.
-   *
-   * @param {ConsolaOptions["mockFn"]} mockFn - The function to use for mocking logging methods. See {@link ConsolaOptions["mockFn"]}.
-   */
-  mockTypes(mockFn) {
-    const _mockFn = mockFn || this.options.mockFn;
-    this._mockFn = _mockFn;
-    if (typeof _mockFn !== "function") {
-      return;
-    }
-    for (const type in this.options.types) {
-      this[type] = _mockFn(type, this.options.types[type]) || this[type];
-      this[type].raw = this[type];
-    }
-  }
-  _wrapLogFn(defaults, isRaw) {
-    return (...args) => {
-      if (paused) {
-        queue.push([this, defaults, args, isRaw]);
-        return;
-      }
-      return this._logFn(defaults, args, isRaw);
-    };
-  }
-  _logFn(defaults, args, isRaw) {
-    if ((defaults.level || 0) > this.level) {
-      return false;
-    }
-    const logObj = {
-      date: /* @__PURE__ */ new Date(),
-      args: [],
-      ...defaults,
-      level: _normalizeLogLevel(defaults.level, this.options.types)
-    };
-    if (!isRaw && args.length === 1 && isLogObj(args[0])) {
-      Object.assign(logObj, args[0]);
-    } else {
-      logObj.args = [...args];
-    }
-    if (logObj.message) {
-      logObj.args.unshift(logObj.message);
-      delete logObj.message;
-    }
-    if (logObj.additional) {
-      if (!Array.isArray(logObj.additional)) {
-        logObj.additional = logObj.additional.split("\n");
-      }
-      logObj.args.push("\n" + logObj.additional.join("\n"));
-      delete logObj.additional;
-    }
-    logObj.type = typeof logObj.type === "string" ? logObj.type.toLowerCase() : "log";
-    logObj.tag = typeof logObj.tag === "string" ? logObj.tag : "";
-    const resolveLog = (newLog = false) => {
-      const repeated = (this._lastLog.count || 0) - this.options.throttleMin;
-      if (this._lastLog.object && repeated > 0) {
-        const args2 = [...this._lastLog.object.args];
-        if (repeated > 1) {
-          args2.push(`(repeated ${repeated} times)`);
-        }
-        this._log({ ...this._lastLog.object, args: args2 });
-        this._lastLog.count = 1;
-      }
-      if (newLog) {
-        this._lastLog.object = logObj;
-        this._log(logObj);
-      }
-    };
-    clearTimeout(this._lastLog.timeout);
-    const diffTime = this._lastLog.time && logObj.date ? logObj.date.getTime() - this._lastLog.time.getTime() : 0;
-    this._lastLog.time = logObj.date;
-    if (diffTime < this.options.throttle) {
-      try {
-        const serializedLog = JSON.stringify([
-          logObj.type,
-          logObj.tag,
-          logObj.args
-        ]);
-        const isSameLog = this._lastLog.serialized === serializedLog;
-        this._lastLog.serialized = serializedLog;
-        if (isSameLog) {
-          this._lastLog.count = (this._lastLog.count || 0) + 1;
-          if (this._lastLog.count > this.options.throttleMin) {
-            this._lastLog.timeout = setTimeout(
-              resolveLog,
-              this.options.throttle
-            );
-            return;
-          }
-        }
-      } catch {
-      }
-    }
-    resolveLog(true);
-  }
-  _log(logObj) {
-    for (const reporter of this.options.reporters) {
-      reporter.log(logObj, {
-        options: this.options
-      });
-    }
-  }
-}
-function _normalizeLogLevel(input, types = {}, defaultLevel = 3) {
-  if (input === void 0) {
-    return defaultLevel;
-  }
-  if (typeof input === "number") {
-    return input;
-  }
-  if (types[input] && types[input].level !== void 0) {
-    return types[input].level;
-  }
-  return defaultLevel;
-}
-Consola.prototype.add = Consola.prototype.addReporter;
-Consola.prototype.remove = Consola.prototype.removeReporter;
-Consola.prototype.clear = Consola.prototype.removeReporter;
-Consola.prototype.withScope = Consola.prototype.withTag;
-Consola.prototype.mock = Consola.prototype.mockTypes;
-Consola.prototype.pause = Consola.prototype.pauseLogs;
-Consola.prototype.resume = Consola.prototype.resumeLogs;
-function createConsola$1(options = {}) {
-  return new Consola(options);
-}
-
-class BrowserReporter {
-  options;
-  defaultColor;
-  levelColorMap;
-  typeColorMap;
-  constructor(options) {
-    this.options = { ...options };
-    this.defaultColor = "#7f8c8d";
-    this.levelColorMap = {
-      0: "#c0392b",
-      // Red
-      1: "#f39c12",
-      // Yellow
-      3: "#00BCD4"
-      // Cyan
-    };
-    this.typeColorMap = {
-      success: "#2ecc71"
-      // Green
-    };
-  }
-  _getLogFn(level) {
-    if (level < 1) {
-      return console.__error || console.error;
-    }
-    if (level === 1) {
-      return console.__warn || console.warn;
-    }
-    return console.__log || console.log;
-  }
-  log(logObj) {
-    const consoleLogFn = this._getLogFn(logObj.level);
-    const type = logObj.type === "log" ? "" : logObj.type;
-    const tag = logObj.tag || "";
-    const color = this.typeColorMap[logObj.type] || this.levelColorMap[logObj.level] || this.defaultColor;
-    const style = `
-      background: ${color};
-      border-radius: 0.5em;
-      color: white;
-      font-weight: bold;
-      padding: 2px 0.5em;
-    `;
-    const badge = `%c${[tag, type].filter(Boolean).join(":")}`;
-    if (typeof logObj.args[0] === "string") {
-      consoleLogFn(
-        `${badge}%c ${logObj.args[0]}`,
-        style,
-        // Empty string as style resets to default console style
-        "",
-        ...logObj.args.slice(1)
-      );
-    } else {
-      consoleLogFn(badge, style, ...logObj.args);
-    }
-  }
-}
-
-function createConsola(options = {}) {
-  const consola2 = createConsola$1({
-    reporters: options.reporters || [new BrowserReporter({})],
-    prompt(message, options2 = {}) {
-      if (options2.type === "confirm") {
-        return Promise.resolve(confirm(message));
-      }
-      return Promise.resolve(prompt(message));
-    },
-    ...options
-  });
-  return consola2;
-}
-const consola = createConsola();
-
-async function pathExists$5(p) {
-  try {
-    await promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readJson$1(p) {
-  const content = await promises.readFile(p, "utf-8");
-  return JSON.parse(content);
-}
-const logger$6 = consola.withTag("dependency-resolver");
-async function analyzeDependencies$1(analysis, config) {
-  logger$6.info("Analyzing project dependencies");
-  if (config.analyzeTransitiveDeps) {
-    logger$6.warn(
-      'Transitive dependency analysis requested but not fully implemented. The "all" field will only contain direct dependencies. See dependency-resolver.ts for details.'
-    );
-  }
-  const projectPath = analysis.rootPath;
-  const packageManager = analysis.packageManager;
-  analysis.languages;
-  let direct = [];
-  let all = [];
-  if (packageManager === "npm" || packageManager === "yarn" || packageManager === "pnpm" || packageManager === "bun") {
-    const npmDeps = await analyzeNpmDependencies(projectPath);
-    direct = npmDeps.direct;
-    all = npmDeps.all;
-  } else if (packageManager === "pip" || packageManager === "poetry" || packageManager === "pipenv") {
-    const pythonDeps = await analyzePythonDependencies(projectPath, packageManager);
-    direct = pythonDeps.direct;
-    all = pythonDeps.all;
-  } else if (packageManager === "go") {
-    const goDeps = await analyzeGoDependencies(projectPath);
-    direct = goDeps.direct;
-    all = goDeps.all;
-  } else if (packageManager === "cargo") {
-    const rustDeps = await analyzeRustDependencies(projectPath);
-    direct = rustDeps.direct;
-    all = rustDeps.all;
-  }
-  const graph = buildDependencyGraph(all);
-  const installationPlan = generateInstallationPlan(all, packageManager);
-  const conflicts = detectConflicts(all);
-  const circularDeps = detectCircularDependencies(graph);
-  logger$6.info(`Found ${direct.length} direct dependencies, ${all.length} total`);
-  if (conflicts.length > 0) {
-    logger$6.warn(`Found ${conflicts.length} dependency conflicts`);
-  }
-  if (circularDeps.length > 0) {
-    logger$6.warn(`Found ${circularDeps.length} circular dependencies`);
-  }
-  return {
-    direct,
-    all,
-    graph,
-    installationPlan,
-    conflicts,
-    circularDeps
-  };
-}
-async function analyzeNpmDependencies(projectPath) {
-  const packageJsonPath = posix.join(projectPath, "package.json");
-  if (!await pathExists$5(packageJsonPath)) {
-    return { direct: [], all: [] };
-  }
-  try {
-    const packageJson = await readJson$1(packageJsonPath);
-    const direct = [];
-    const processDeps = (deps2, isDev, isPeer) => {
-      if (!deps2)
-        return [];
-      return Object.entries(deps2).map(([name, version]) => ({
-        name,
-        version,
-        type: isDev ? "dev" : isPeer ? "peer" : "runtime",
-        isDev,
-        isPeer,
-        isOptional: false
-      }));
-    };
-    const deps = processDeps(packageJson.dependencies, false, false);
-    const devDeps = processDeps(packageJson.devDependencies, true, false);
-    const peerDeps = processDeps(packageJson.peerDependencies, false, true);
-    const optionalDeps = processDeps(packageJson.optionalDependencies, false, false).map((d) => ({
-      ...d,
-      isOptional: true,
-      type: "optional"
-    }));
-    direct.push(...deps, ...devDeps, ...peerDeps, ...optionalDeps);
-    const all = [...direct];
-    return { direct, all };
-  } catch (error) {
-    logger$6.warn("Failed to analyze npm dependencies:", error);
-    return { direct: [], all: [] };
-  }
-}
-async function analyzePythonDependencies(projectPath, packageManager) {
-  const direct = [];
-  const all = [];
-  if (packageManager === "poetry") {
-    const pyprojectPath = posix.join(projectPath, "pyproject.toml");
-    if (await pathExists$5(pyprojectPath)) {
-      try {
-        const { parse } = await import('../chunks/index3.mjs');
-        const content = await promises.readFile(pyprojectPath, "utf-8");
-        const pyproject = parse(content);
-        const deps = pyproject.tool?.poetry?.dependencies || {};
-        const devDeps = pyproject.tool?.poetry?.["dev-dependencies"] || {};
-        for (const [name, version] of Object.entries(deps)) {
-          direct.push({
-            name,
-            version: typeof version === "string" ? version : "latest",
-            type: "runtime",
-            isDev: false,
-            isPeer: false,
-            isOptional: false
-          });
-        }
-        for (const [name, version] of Object.entries(devDeps)) {
-          direct.push({
-            name,
-            version: typeof version === "string" ? version : "latest",
-            type: "dev",
-            isDev: true,
-            isPeer: false,
-            isOptional: false
-          });
-        }
-      } catch (error) {
-        logger$6.warn("Failed to parse pyproject.toml:", error);
-      }
-    }
-  } else if (packageManager === "pipenv") {
-    const pipfilePath = posix.join(projectPath, "Pipfile");
-    if (await pathExists$5(pipfilePath)) {
-      try {
-        const { parse } = await import('../chunks/index3.mjs');
-        const content = await promises.readFile(pipfilePath, "utf-8");
-        const pipfile = parse(content);
-        const deps = pipfile.packages || {};
-        const devDeps = pipfile["dev-packages"] || {};
-        for (const [name, version] of Object.entries(deps)) {
-          direct.push({
-            name,
-            version: typeof version === "string" ? version : "latest",
-            type: "runtime",
-            isDev: false,
-            isPeer: false,
-            isOptional: false
-          });
-        }
-        for (const [name, version] of Object.entries(devDeps)) {
-          direct.push({
-            name,
-            version: typeof version === "string" ? version : "latest",
-            type: "dev",
-            isDev: true,
-            isPeer: false,
-            isOptional: false
-          });
-        }
-      } catch (error) {
-        logger$6.warn("Failed to parse Pipfile:", error);
-      }
-    }
-  } else {
-    const requirementsPath = posix.join(projectPath, "requirements.txt");
-    if (await pathExists$5(requirementsPath)) {
-      try {
-        const content = await promises.readFile(requirementsPath, "utf-8");
-        const lines = content.split("\n");
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (trimmed && !trimmed.startsWith("#")) {
-            const match = trimmed.match(/^([\w-]+)([[~=><].*)?$/);
-            if (match) {
-              direct.push({
-                name: match[1],
-                version: match[2] || "latest",
-                type: "runtime",
-                isDev: false,
-                isPeer: false,
-                isOptional: false
-              });
-            }
-          }
-        }
-      } catch (error) {
-        logger$6.warn("Failed to parse requirements.txt:", error);
-      }
-    }
-  }
-  all.push(...direct);
-  return { direct, all };
-}
-async function analyzeGoDependencies(projectPath) {
-  const goModPath = posix.join(projectPath, "go.mod");
-  if (!await pathExists$5(goModPath)) {
-    return { direct: [], all: [] };
-  }
-  try {
-    const content = await promises.readFile(goModPath, "utf-8");
-    const lines = content.split("\n");
-    const direct = [];
-    let inRequireBlock = false;
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith("require (")) {
-        inRequireBlock = true;
-        continue;
-      }
-      if (inRequireBlock && trimmed === ")") {
-        inRequireBlock = false;
-        continue;
-      }
-      if (trimmed.startsWith("require ") || inRequireBlock) {
-        const parts = trimmed.split(/\s+/);
-        if (parts.length >= 2) {
-          const name = parts[0].replace("require ", "");
-          const version = parts[1];
-          direct.push({
-            name,
-            version,
-            type: "runtime",
-            isDev: false,
-            isPeer: false,
-            isOptional: false
-          });
-        }
-      }
-    }
-    const all = [...direct];
-    return { direct, all };
-  } catch (error) {
-    logger$6.warn("Failed to analyze Go dependencies:", error);
-    return { direct: [], all: [] };
-  }
-}
-async function analyzeRustDependencies(projectPath) {
-  const cargoTomlPath = posix.join(projectPath, "Cargo.toml");
-  if (!await pathExists$5(cargoTomlPath)) {
-    return { direct: [], all: [] };
-  }
-  try {
-    const { parse } = await import('../chunks/index3.mjs');
-    const content = await promises.readFile(cargoTomlPath, "utf-8");
-    const cargoToml = parse(content);
-    const direct = [];
-    const processDeps = (deps2, isDev) => {
-      if (!deps2)
-        return [];
-      return Object.entries(deps2).map(([name, version]) => ({
-        name,
-        version: typeof version === "string" ? version : version?.version || "latest",
-        type: isDev ? "dev" : "runtime",
-        isDev,
-        isPeer: false,
-        isOptional: false
-      }));
-    };
-    const deps = processDeps(cargoToml.dependencies, false);
-    const devDeps = processDeps(cargoToml["dev-dependencies"], true);
-    const buildDeps = processDeps(cargoToml["build-dependencies"], false);
-    direct.push(...deps, ...devDeps, ...buildDeps);
-    const all = [...direct];
-    return { direct, all };
-  } catch (error) {
-    logger$6.warn("Failed to analyze Rust dependencies:", error);
-    return { direct: [], all: [] };
-  }
-}
-function buildDependencyGraph(dependencies) {
-  const graph = /* @__PURE__ */ new Map();
-  for (const dep of dependencies) {
-    graph.set(dep.name, []);
-  }
-  return graph;
-}
-function generateInstallationPlan(dependencies, packageManager) {
-  const order = [...dependencies];
-  const runtime = order.filter((d) => d.type === "runtime");
-  order.filter((d) => d.type === "dev");
-  order.filter((d) => d.type === "peer");
-  order.filter((d) => d.type === "optional");
-  const parallelizable = runtime.length;
-  const commands = generateInstallationCommands(packageManager);
-  return {
-    order,
-    total: dependencies.length,
-    parallelizable,
-    commands
-  };
-}
-function generateInstallationCommands(packageManager) {
-  if (!packageManager) {
-    return {
-      installAll: 'echo "Unknown package manager"',
-      installPackage: () => 'echo "Unknown package manager"',
-      installDev: 'echo "Unknown package manager"',
-      add: () => 'echo "Unknown package manager"'
-    };
-  }
-  const commands = {
-    npm: {
-      installAll: "npm install",
-      installPackage: (name, version) => `npm install ${name}${version ? `@${version}` : ""}`,
-      installDev: "npm install --only=dev",
-      add: (name, isDev) => isDev ? `npm install -D ${name}` : `npm install ${name}`
-    },
-    yarn: {
-      installAll: "yarn install",
-      installPackage: (name, version) => `yarn add ${name}${version ? `@${version}` : ""}`,
-      installDev: "yarn install --dev",
-      add: (name, isDev) => isDev ? `yarn add -D ${name}` : `yarn add ${name}`
-    },
-    pnpm: {
-      installAll: "pnpm install",
-      installPackage: (name, version) => `pnpm add ${name}${version ? `@${version}` : ""}`,
-      installDev: "pnpm install --dev",
-      add: (name, isDev) => isDev ? `pnpm add -D ${name}` : `pnpm add ${name}`
-    },
-    bun: {
-      installAll: "bun install",
-      installPackage: (name, version) => `bun add ${name}${version ? `@${version}` : ""}`,
-      installDev: "bun install --dev",
-      add: (name, isDev) => isDev ? `bun add -d ${name}` : `bun add ${name}`
-    },
-    pip: {
-      installAll: "pip install -r requirements.txt",
-      installPackage: (name, version) => `pip install ${name}${version ? version.replace(/[*=]/, "==") : ""}`,
-      installDev: "pip install -r requirements-dev.txt",
-      add: (name) => `pip install ${name}`
-    },
-    poetry: {
-      installAll: "poetry install",
-      installPackage: (name, version) => `poetry add ${name}${version ? `=${version}` : ""}`,
-      installDev: "poetry install --with dev",
-      add: (name, isDev) => isDev ? `poetry add --group dev ${name}` : `poetry add ${name}`
-    },
-    pipenv: {
-      installAll: "pipenv install",
-      installPackage: (name, version) => `pipenv install ${name}${version ? `==${version}` : ""}`,
-      installDev: "pipenv install --dev",
-      add: (name, isDev) => isDev ? `pipenv install --dev ${name}` : `pipenv install ${name}`
-    },
-    go: {
-      installAll: "go mod download",
-      installPackage: (name) => `go get ${name}`,
-      installDev: "go mod download",
-      add: (name) => `go get ${name}`
-    },
-    cargo: {
-      installAll: "cargo build",
-      installPackage: (name, version) => `cargo add ${name}${version ? ` --vers ${version}` : ""}`,
-      installDev: "cargo build",
-      add: (name) => `cargo add ${name}`
-    }
-  };
-  return commands[packageManager] || commands.npm;
-}
-function detectConflicts(dependencies, _graph) {
-  const conflicts = [];
-  const versionMap = /* @__PURE__ */ new Map();
-  for (const dep of dependencies) {
-    if (!versionMap.has(dep.name)) {
-      versionMap.set(dep.name, /* @__PURE__ */ new Set());
-    }
-    versionMap.get(dep.name).add(dep.version);
-  }
-  for (const [name, versions] of versionMap) {
-    if (versions.size > 1) {
-      conflicts.push({
-        package: name,
-        versions: Array.from(versions),
-        requiredBy: [name],
-        severity: "warning"
-      });
-    }
-  }
-  return conflicts;
-}
-function detectCircularDependencies(graph) {
-  const circular = [];
-  const visited = /* @__PURE__ */ new Set();
-  const recStack = /* @__PURE__ */ new Set();
-  const path2 = [];
-  const dfs = (node) => {
-    visited.add(node);
-    recStack.add(node);
-    path2.push(node);
-    const neighbors = graph.get(node) || [];
-    for (const neighbor of neighbors) {
-      if (!visited.has(neighbor.name)) {
-        if (dfs(neighbor.name)) {
-          return true;
-        }
-      } else if (recStack.has(neighbor.name)) {
-        const cycleStart = path2.indexOf(neighbor.name);
-        const cycle = path2.slice(cycleStart).concat(neighbor.name);
-        circular.push(cycle);
-        return true;
-      }
-    }
-    path2.pop();
-    recStack.delete(node);
-    return false;
-  };
-  for (const node of graph.keys()) {
-    if (!visited.has(node)) {
-      dfs(node);
-    }
-  }
-  return circular;
-}
-
-async function pathExists$4(p) {
-  try {
-    await promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-const logger$5 = consola.withTag("go-analyzer");
-const FRAMEWORK_PATTERNS$3 = {
-  gin: {
-    imports: ["github.com/gin-gonic/gin"],
-    indicators: ["gin.Default()", "gin.Context"]
-  },
-  echo: {
-    imports: ["github.com/labstack/echo/v4"],
-    indicators: ["echo.New()", "echo.Context"]
-  },
-  fiber: {
-    imports: ["github.com/gofiber/fiber/v2"],
-    indicators: ["fiber.New()", "fiber.Ctx"]
-  },
-  chi: {
-    imports: ["github.com/go-chi/chi/v5"],
-    indicators: ["chi.NewRouter()", "chi.Router"]
-  },
-  mux: {
-    imports: ["github.com/gorilla/mux"],
-    indicators: ["mux.NewRouter()", "mux.Router"]
-  },
-  httprouter: {
-    imports: ["github.com/julienschmidt/httprouter"],
-    indicators: ["httprouter.New()", "httprouter.Params"]
-  },
-  fasthttp: {
-    imports: ["github.com/valyala/fasthttp"],
-    indicators: ["fasthttp.Server", "fasthttp.RequestHandler"]
-  },
-  grpc: {
-    imports: ["google.golang.org/grpc"],
-    indicators: ["grpc.NewServer()", "grpc.Dial"]
-  },
-  protobuf: {
-    imports: ["google.golang.org/protobuf"],
-    indicators: [".proto", "proto.Marshal"]
-  },
-  gorm: {
-    imports: ["gorm.io/gorm"],
-    indicators: ["gorm.Open", "gorm.DB"]
-  },
-  sql: {
-    imports: ["database/sql"],
-    indicators: ["sql.Open", "sql.DB"]
-  },
-  ent: {
-    imports: ["entgo.io/ent"],
-    indicators: ["ent.Client", "ent.Schema"]
-  },
-  cobra: {
-    imports: ["github.com/spf13/cobra"],
-    indicators: ["cobra.Command", "cobra.Execute"]
-  },
-  viper: {
-    imports: ["github.com/spf13/viper"],
-    indicators: ["viper.New", "viper.Get"]
-  },
-  testify: {
-    imports: ["github.com/stretchr/testify"],
-    indicators: ["assert.Equal", "require.NoError"]
-  },
-  mock: {
-    imports: ["github.com/golang/mock"],
-    indicators: ["gomock.Controller", "mockgen"]
-  },
-  redis: {
-    imports: ["github.com/redis/go-redis/v9"],
-    indicators: ["redis.NewClient", "redis.Client"]
-  },
-  mongo: {
-    imports: ["go.mongodb.org/mongo-driver"],
-    indicators: ["mongo.Connect", "mongo.Database"]
-  },
-  prometheus: {
-    imports: ["github.com/prometheus/client_golang"],
-    indicators: ["prometheus.Counter", "promhttp.Handler"]
-  },
-  jaeger: {
-    imports: ["github.com/uber/jaeger-client-go"],
-    indicators: ["jaeger.NewTracer", "jaeger.Config"]
-  },
-  kubernetes: {
-    imports: ["k8s.io/client-go"],
-    indicators: ["kubernetes.Clientset", "k8s.io"]
-  }
-};
-async function analyzeGoProject(projectPath, files, _languages) {
-  logger$5.info("Analyzing Go project");
-  const frameworks = [];
-  const goModPath = posix.join(projectPath, "go.mod");
-  let _goMod = null;
-  try {
-    if (await pathExists$4(goModPath)) {
-      const content = await promises.readFile(goModPath, "utf-8");
-      _goMod = parseGoMod(content);
-    }
-  } catch (error) {
-    logger$5.warn("Failed to read go.mod:", error);
-  }
-  const imports = await scanGoImports(projectPath, files);
-  for (const [frameworkName, patterns] of Object.entries(FRAMEWORK_PATTERNS$3)) {
-    const evidence = [];
-    let confidence = 0;
-    for (const importPath of patterns.imports) {
-      if (imports[importPath]) {
-        evidence.push(`Found import: ${importPath}`);
-        confidence += 0.5;
-      }
-    }
-    for (const indicator of patterns.indicators) {
-      const filesWithIndicator = Object.values(imports).flat();
-      if (filesWithIndicator.some((f) => f.includes(indicator))) {
-        evidence.push(`Found pattern: ${indicator}`);
-        confidence += 0.3;
-      }
-    }
-    if (confidence > 0) {
-      frameworks.push({
-        name: frameworkName,
-        category: getFrameworkCategory$3(frameworkName),
-        confidence: Math.min(confidence, 1),
-        evidence
-      });
-    }
-  }
-  await detectAdditionalPatterns$3(projectPath, files, frameworks, imports);
-  frameworks.sort((a, b) => b.confidence - a.confidence);
-  logger$5.debug(`Detected frameworks: ${frameworks.map((f) => `${f.name} (${Math.round(f.confidence * 100)}%)`).join(", ")}`);
-  return frameworks;
-}
-function parseGoMod(content) {
-  const result = {
-    requires: {}
-  };
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("module")) {
-      result.module = trimmed.split(" ")[1];
-    } else if (trimmed.startsWith("go")) {
-      result.go = trimmed.split(" ")[1];
-    } else if (trimmed.startsWith("require")) {
-      const parts = trimmed.split(" ");
-      if (parts.length >= 3) {
-        result.requires[parts[1]] = parts[2];
-      }
-    } else if (trimmed.includes(" ")) {
-      const parts = trimmed.split(" ");
-      if (parts.length >= 2 && !trimmed.startsWith("//")) {
-        result.requires[parts[0]] = parts[1];
-      }
-    }
-  }
-  return result;
-}
-async function scanGoImports(projectPath, files) {
-  const imports = {};
-  const goFiles = files.filter((f) => f.endsWith(".go"));
-  for (const file of goFiles) {
-    try {
-      const content = await promises.readFile(posix.join(projectPath, file), "utf-8");
-      const fileImports = extractGoImports(content);
-      for (const importPath of fileImports) {
-        if (!imports[importPath]) {
-          imports[importPath] = [];
-        }
-        imports[importPath].push(file);
-      }
-    } catch (error) {
-      logger$5.warn(`Failed to read ${file}:`, error);
-    }
-  }
-  return imports;
-}
-function extractGoImports(content) {
-  const imports = [];
-  const importRegex = /import\s+(?:\(\s*([\s\S]*?)\s*\)|(["`][^"`]+["`]))/g;
-  let match;
-  while ((match = importRegex.exec(content)) !== null) {
-    const importBlock = match[1] || match[2];
-    if (importBlock) {
-      const singleImportRegex = /["`]([^"`]+)["`]/g;
-      let importMatch;
-      while ((importMatch = singleImportRegex.exec(importBlock)) !== null) {
-        imports.push(importMatch[1]);
-      }
-    }
-  }
-  return imports;
-}
-function getFrameworkCategory$3(framework) {
-  const categories = {
-    web: [
-      "gin",
-      "echo",
-      "fiber",
-      "chi",
-      "mux",
-      "httprouter",
-      "fasthttp"
-    ],
-    rpc: ["grpc", "protobuf"],
-    database: ["gorm", "sql", "ent"],
-    cli: ["cobra", "viper"],
-    testing: ["testify", "mock"],
-    cache: ["redis"],
-    database2: ["mongo"],
-    monitoring: ["prometheus", "jaeger"],
-    infrastructure: ["kubernetes"]
-  };
-  for (const [category, frameworks] of Object.entries(categories)) {
-    if (frameworks.includes(framework)) {
-      return category;
-    }
-  }
-  return "other";
-}
-async function detectAdditionalPatterns$3(projectPath, files, frameworks, imports) {
-  const goModPath = posix.join(projectPath, "go.mod");
-  if (files.includes("go.mod") && await pathExists$4(goModPath)) {
-    try {
-      const content = await promises.readFile(goModPath, "utf-8");
-      const goVersionMatch = content.match(/^go\s+(\d+\.\d+)/m);
-      if (goVersionMatch) {
-        frameworks.push({
-          name: "go",
-          category: "language",
-          version: goVersionMatch[1],
-          confidence: 0.9,
-          evidence: ["Found go.mod"]
-        });
-      }
-    } catch (error) {
-      logger$5.warn("Failed to read go.mod:", error);
-    }
-  }
-  const dockerFiles = ["Dockerfile", "docker-compose.yml", "docker-compose.yaml"];
-  for (const file of dockerFiles) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: "docker",
-        category: "deployment",
-        confidence: 0.9,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  if (files.some((f) => f.endsWith("_test.go"))) {
-    frameworks.push({
-      name: "testing",
-      category: "testing",
-      confidence: 0.7,
-      evidence: ["Found test files"]
-    });
-  }
-  const buildFiles = {
-    "Makefile": "make",
-    "Dockerfile": "docker",
-    ".goreleaser.yml": "goreleaser",
-    ".goreleaser.yaml": "goreleaser"
-  };
-  for (const [file, tool] of Object.entries(buildFiles)) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: tool,
-        category: "build",
-        confidence: 0.8,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  const lintingTools = [
-    "github.com/golangci/golangci-lint",
-    "golang.org/x/lint",
-    "honnef.co/go/tools"
-  ];
-  for (const tool of lintingTools) {
-    if (imports[tool]) {
-      frameworks.push({
-        name: "golangci-lint",
-        category: "linting",
-        confidence: 0.8,
-        evidence: [`Found ${tool} import`]
-      });
-    }
-  }
-  const ciFiles = {
-    ".github/workflows": "github-actions",
-    ".gitlab-ci.yml": "gitlab-ci",
-    "Jenkinsfile": "jenkins",
-    ".travis.yml": "travis-ci"
-  };
-  for (const [file, tool] of Object.entries(ciFiles)) {
-    if (files.includes(file) || files.some((f) => f.startsWith(file))) {
-      frameworks.push({
-        name: tool,
-        category: "ci-cd",
-        confidence: 0.8,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  if (files.some((f) => f.endsWith(".proto"))) {
-    frameworks.push({
-      name: "protobuf",
-      category: "rpc",
-      confidence: 0.9,
-      evidence: ["Found .proto files"]
-    });
-  }
-  const goWorkPath = posix.join(projectPath, "go.work");
-  if (files.includes("go.work") && await pathExists$4(goWorkPath)) {
-    frameworks.push({
-      name: "workspace",
-      category: "workspace",
-      confidence: 0.9,
-      evidence: ["Found go.work"]
-    });
-  }
-  if (files.includes("vendor/") || files.some((f) => f.startsWith("vendor/"))) {
-    frameworks.push({
-      name: "vendor",
-      category: "dependency",
-      confidence: 0.8,
-      evidence: ["Found vendor directory"]
-    });
-  }
-}
-
-async function pathExists$3(p) {
-  try {
-    await promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-const logger$4 = consola.withTag("python-analyzer");
-const FRAMEWORK_PATTERNS$2 = {
-  "django": {
-    files: ["manage.py", "settings.py"],
-    dependencies: ["django"],
-    indicators: ["manage.py", "wsgi.py", "asgi.py", "settings/", "templates/", "static/"]
-  },
-  "fastapi": {
-    files: ["main.py"],
-    dependencies: ["fastapi"],
-    indicators: ["main.py", "app/", "api/", "routers/"]
-  },
-  "flask": {
-    files: ["app.py", "wsgi.py"],
-    dependencies: ["flask"],
-    indicators: ["app.py", "app/", "templates/", "static/"]
-  },
-  "tornado": {
-    files: [],
-    dependencies: ["tornado"],
-    indicators: ["tornado", "handlers/"]
-  },
-  "sanic": {
-    files: [],
-    dependencies: ["sanic"],
-    indicators: ["sanic"]
-  },
-  "quart": {
-    files: [],
-    dependencies: ["quart"],
-    indicators: ["quart"]
-  },
-  "falcon": {
-    files: [],
-    dependencies: ["falcon"],
-    indicators: ["falcon"]
-  },
-  "bottle": {
-    files: [],
-    dependencies: ["bottle"],
-    indicators: ["bottle"]
-  },
-  "pyramid": {
-    files: ["development.ini", "production.ini"],
-    dependencies: ["pyramid"],
-    indicators: ["development.ini", "production.ini"]
-  },
-  "starlette": {
-    files: [],
-    dependencies: ["starlette"],
-    indicators: ["starlette"]
-  },
-  "celery": {
-    files: ["celery.py"],
-    dependencies: ["celery"],
-    indicators: ["celery.py", "tasks.py", "celeryconfig.py"]
-  },
-  "pandas": {
-    files: [],
-    dependencies: ["pandas"],
-    indicators: ["pandas"]
-  },
-  "numpy": {
-    files: [],
-    dependencies: ["numpy"],
-    indicators: ["numpy"]
-  },
-  "scikit-learn": {
-    files: [],
-    dependencies: ["scikit-learn"],
-    indicators: ["sklearn"]
-  },
-  "tensorflow": {
-    files: [],
-    dependencies: ["tensorflow"],
-    indicators: ["tensorflow"]
-  },
-  "pytorch": {
-    files: [],
-    dependencies: ["torch"],
-    indicators: ["torch"]
-  },
-  "jupyter": {
-    files: [],
-    dependencies: ["jupyter"],
-    indicators: [".ipynb", "jupyter"]
-  },
-  "streamlit": {
-    files: [],
-    dependencies: ["streamlit"],
-    indicators: ["streamlit"]
-  },
-  "dash": {
-    files: [],
-    dependencies: ["dash"],
-    indicators: ["dash"]
-  },
-  "gradio": {
-    files: [],
-    dependencies: ["gradio"],
-    indicators: ["gradio"]
-  },
-  "pytest": {
-    files: [],
-    dependencies: ["pytest"],
-    indicators: ["pytest", "conftest.py", "test_"]
-  },
-  "unittest": {
-    files: [],
-    dependencies: [],
-    indicators: ["test_", "_test.py"]
-  },
-  "poetry": {
-    files: ["pyproject.toml"],
-    dependencies: [],
-    indicators: ["pyproject.toml", "poetry.lock"]
-  },
-  "pipenv": {
-    files: ["Pipfile"],
-    dependencies: [],
-    indicators: ["Pipfile", "Pipfile.lock"]
-  },
-  "conda": {
-    files: ["environment.yml", "environment.yaml"],
-    dependencies: [],
-    indicators: ["environment.yml", "environment.yaml"]
-  }
-};
-async function analyzePythonProject(projectPath, files, _languages) {
-  logger$4.info("Analyzing Python project");
-  const frameworks = [];
-  const dependencies = await analyzeDependencies(projectPath, files);
-  for (const [frameworkName, patterns] of Object.entries(FRAMEWORK_PATTERNS$2)) {
-    const evidence = [];
-    let confidence = 0;
-    for (const file of patterns.files) {
-      if (files.includes(file) || files.some((f) => f.includes(file))) {
-        evidence.push(`Found ${file}`);
-        confidence += 0.3;
-      }
-    }
-    for (const indicator of patterns.indicators) {
-      if (files.some((f) => f.includes(indicator))) {
-        evidence.push(`Found ${indicator} pattern`);
-        confidence += 0.2;
-      }
-    }
-    for (const dep of patterns.dependencies) {
-      if (dependencies[dep]) {
-        evidence.push(`Found ${dep} in dependencies`);
-        confidence += 0.4;
-      }
-    }
-    if (confidence > 0) {
-      frameworks.push({
-        name: frameworkName,
-        category: getFrameworkCategory$2(frameworkName),
-        version: dependencies[frameworkName],
-        confidence: Math.min(confidence, 1),
-        evidence
-      });
-    }
-  }
-  await detectAdditionalPatterns$2(projectPath, files, frameworks, dependencies);
-  frameworks.sort((a, b) => b.confidence - a.confidence);
-  logger$4.debug(`Detected frameworks: ${frameworks.map((f) => `${f.name} (${Math.round(f.confidence * 100)}%)`).join(", ")}`);
-  return frameworks;
-}
-async function analyzeDependencies(projectPath, files) {
-  const dependencies = {};
-  const requirementsPath = posix.join(projectPath, "requirements.txt");
-  if (files.includes("requirements.txt") && await pathExists$3(requirementsPath)) {
-    try {
-      const content = await promises.readFile(requirementsPath, "utf-8");
-      const lines = content.split("\n");
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed && !trimmed.startsWith("#")) {
-          const match = trimmed.match(/^([\w-]+)([[~=><].*)?$/);
-          if (match) {
-            dependencies[match[1]] = match[2] || "latest";
-          }
-        }
-      }
-    } catch (error) {
-      logger$4.warn("Failed to parse requirements.txt:", error);
-    }
-  }
-  const pyprojectPath = posix.join(projectPath, "pyproject.toml");
-  if (files.includes("pyproject.toml") && await pathExists$3(pyprojectPath)) {
-    try {
-      const content = await promises.readFile(pyprojectPath, "utf-8");
-      const parsed = parse(content);
-      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && "tool" in parsed) {
-        const tool = parsed.tool;
-        if (typeof tool === "object" && tool !== null && !Array.isArray(tool) && "poetry" in tool) {
-          const poetry = tool.poetry;
-          if (typeof poetry === "object" && poetry !== null && !Array.isArray(poetry) && "dependencies" in poetry) {
-            const poetryDeps = poetry.dependencies;
-            if (typeof poetryDeps === "object" && poetryDeps !== null && !Array.isArray(poetryDeps)) {
-              Object.assign(dependencies, poetryDeps);
-            }
-          }
-        }
-      }
-      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && "project" in parsed) {
-        const project = parsed.project;
-        if (typeof project === "object" && project !== null && !Array.isArray(project) && "dependencies" in project) {
-          const projectDeps = project.dependencies;
-          if (Array.isArray(projectDeps)) {
-            for (const dep of projectDeps) {
-              if (typeof dep === "string") {
-                const match = dep.match(/^([\w-]+)([[~=><].*)?$/);
-                if (match) {
-                  dependencies[match[1]] = match[2] || "latest";
-                }
-              }
-            }
-          }
-        }
-      }
-    } catch (error) {
-      logger$4.warn("Failed to parse pyproject.toml:", error);
-    }
-  }
-  const pipfilePath = posix.join(projectPath, "Pipfile");
-  if (files.includes("Pipfile") && await pathExists$3(pipfilePath)) {
-    try {
-      const content = await promises.readFile(pipfilePath, "utf-8");
-      const lines = content.split("\n");
-      let inPackages = false;
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed === "[packages]") {
-          inPackages = true;
-          continue;
-        }
-        if (trimmed.startsWith("[") && trimmed !== "[packages]") {
-          inPackages = false;
-          continue;
-        }
-        if (inPackages && trimmed && !trimmed.startsWith("#")) {
-          const match = trimmed.match(/^([\w-]+)\s*=\s*"?([^"]*)"?/);
-          if (match) {
-            dependencies[match[1]] = match[2] || "latest";
-          }
-        }
-      }
-    } catch (error) {
-      logger$4.warn("Failed to parse Pipfile:", error);
-    }
-  }
-  const setupPath = posix.join(projectPath, "setup.py");
-  if (files.includes("setup.py") && await pathExists$3(setupPath)) {
-    try {
-      const content = await promises.readFile(setupPath, "utf-8");
-      const installRequiresMatch = content.match(/install_requires\s*=\s*\[([\s\S]*?)\]/);
-      if (installRequiresMatch) {
-        const requiresList = installRequiresMatch[1];
-        const requires = requiresList.match(/['"`]([\w-]+)/g);
-        if (requires) {
-          for (const req of requires) {
-            const name = req.replace(/['"`]/g, "");
-            dependencies[name] = "latest";
-          }
-        }
-      }
-    } catch (error) {
-      logger$4.warn("Failed to parse setup.py:", error);
-    }
-  }
-  const envPath = posix.join(projectPath, "environment.yml");
-  if (files.includes("environment.yml") && await pathExists$3(envPath)) {
-    try {
-      const content = await promises.readFile(envPath, "utf-8");
-      const parsed = parse(content);
-      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && "dependencies" in parsed) {
-        const deps = parsed.dependencies;
-        if (Array.isArray(deps)) {
-          for (const dep of deps) {
-            if (typeof dep === "string") {
-              const match = dep.match(/^([\w-]+)([[~=><].*)?$/);
-              if (match) {
-                dependencies[match[1]] = match[2] || "latest";
-              }
-            }
-          }
-        }
-      }
-    } catch (error) {
-      logger$4.warn("Failed to parse environment.yml:", error);
-    }
-  }
-  return dependencies;
-}
-function getFrameworkCategory$2(framework) {
-  const categories = {
-    web: [
-      "django",
-      "fastapi",
-      "flask",
-      "tornado",
-      "sanic",
-      "quart",
-      "falcon",
-      "bottle",
-      "pyramid",
-      "starlette"
-    ],
-    async: ["celery"],
-    data: ["pandas", "numpy", "scikit-learn", "tensorflow", "pytorch"],
-    notebook: ["jupyter"],
-    ui: ["streamlit", "dash", "gradio"],
-    testing: ["pytest", "unittest"],
-    package: ["poetry", "pipenv", "conda"]
-  };
-  for (const [category, frameworks] of Object.entries(categories)) {
-    if (frameworks.includes(framework)) {
-      return category;
-    }
-  }
-  return "other";
-}
-async function detectAdditionalPatterns$2(projectPath, files, frameworks, dependencies) {
-  const pythonVersionPath = posix.join(projectPath, ".python-version");
-  if (files.includes(".python-version") && await pathExists$3(pythonVersionPath)) {
-    try {
-      const version = await promises.readFile(pythonVersionPath, "utf-8");
-      frameworks.push({
-        name: "python",
-        category: "language",
-        version: version.trim(),
-        confidence: 0.9,
-        evidence: ["Found .python-version"]
-      });
-    } catch (error) {
-      logger$4.warn("Failed to read .python-version:", error);
-    }
-  }
-  const dockerFiles = ["Dockerfile", "docker-compose.yml", "docker-compose.yaml"];
-  for (const file of dockerFiles) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: "docker",
-        category: "deployment",
-        confidence: 0.9,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  if (files.some((f) => f.startsWith("test_") || f.includes("_test.py"))) {
-    frameworks.push({
-      name: "unittest",
-      category: "testing",
-      confidence: 0.6,
-      evidence: ["Found test files"]
-    });
-  }
-  const lintingTools = ["flake8", "pylint", "black", "isort", "mypy"];
-  for (const tool of lintingTools) {
-    if (dependencies[tool]) {
-      frameworks.push({
-        name: tool,
-        category: "linting",
-        version: dependencies[tool],
-        confidence: 0.8,
-        evidence: [`Found ${tool} in dependencies`]
-      });
-    }
-  }
-  const configFiles = {
-    "setup.cfg": "setuptools",
-    "tox.ini": "tox",
-    "mypy.ini": "mypy",
-    ".flake8": "flake8",
-    ".pylintrc": "pylint",
-    "pytest.ini": "pytest",
-    "pyproject.toml": "modern-python"
-  };
-  for (const [file, tool] of Object.entries(configFiles)) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: tool,
-        category: "config",
-        confidence: 0.8,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-}
-
-async function pathExists$2(p) {
-  try {
-    await promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-const logger$3 = consola.withTag("rust-analyzer");
-const FRAMEWORK_PATTERNS$1 = {
-  "actix-web": {
-    dependencies: ["actix-web"],
-    indicators: ["HttpServer", "web::"]
-  },
-  "rocket": {
-    dependencies: ["rocket"],
-    indicators: ["rocket::", "#[get]", "#[post]"]
-  },
-  "tokio": {
-    dependencies: ["tokio"],
-    indicators: ["tokio::", "#[tokio::main]"]
-  },
-  "async-std": {
-    dependencies: ["async-std"],
-    indicators: ["async_std::"]
-  },
-  "serde": {
-    dependencies: ["serde"],
-    indicators: ["serde::", "Serialize", "Deserialize"]
-  },
-  "clap": {
-    dependencies: ["clap"],
-    indicators: ["clap::", "Command", "Parser"]
-  },
-  "axum": {
-    dependencies: ["axum"],
-    indicators: ["axum::", "Router"]
-  },
-  "warp": {
-    dependencies: ["warp"],
-    indicators: ["warp::", "Filter"]
-  },
-  "hyper": {
-    dependencies: ["hyper"],
-    indicators: ["hyper::", "Request", "Response"]
-  },
-  "tide": {
-    dependencies: ["tide"],
-    indicators: ["tide::", "Server"]
-  },
-  "tracing": {
-    dependencies: ["tracing"],
-    indicators: ["tracing::", "#[instrument]"]
-  },
-  "log": {
-    dependencies: ["log"],
-    indicators: ["log::", "info!", "debug!"]
-  },
-  "anyhow": {
-    dependencies: ["anyhow"],
-    indicators: ["anyhow::", "anyhow!"]
-  },
-  "thiserror": {
-    dependencies: ["thiserror"],
-    indicators: ["thiserror::", "#[error]"]
-  },
-  "sqlx": {
-    dependencies: ["sqlx"],
-    indicators: ["sqlx::", "PgPool"]
-  },
-  "diesel": {
-    dependencies: ["diesel"],
-    indicators: ["diesel::", "prelude::*"]
-  },
-  "sea-orm": {
-    dependencies: ["sea-orm"],
-    indicators: ["sea_orm::", "Database"]
-  },
-  "redis": {
-    dependencies: ["redis"],
-    indicators: ["redis::", "Connection"]
-  },
-  "tokio-postgres": {
-    dependencies: ["tokio-postgres"],
-    indicators: ["tokio_postgres::", "Client"]
-  },
-  "prometheus": {
-    dependencies: ["prometheus"],
-    indicators: ["prometheus::", "Counter"]
-  },
-  "sentry": {
-    dependencies: ["sentry"],
-    indicators: ["sentry::", "capture_event"]
-  },
-  "uuid": {
-    dependencies: ["uuid"],
-    indicators: ["uuid::", "Uuid"]
-  },
-  "chrono": {
-    dependencies: ["chrono"],
-    indicators: ["chrono::", "DateTime"]
-  },
-  "regex": {
-    dependencies: ["regex"],
-    indicators: ["regex::", "Regex"]
-  },
-  "rand": {
-    dependencies: ["rand"],
-    indicators: ["rand::", "Rng"]
-  },
-  "serde_json": {
-    dependencies: ["serde_json"],
-    indicators: ["serde_json::", "json!"]
-  },
-  "tower": {
-    dependencies: ["tower"],
-    indicators: ["tower::", "Service"]
-  },
-  "prost": {
-    dependencies: ["prost"],
-    indicators: ["prost::", "Message"]
-  },
-  "tonic": {
-    dependencies: ["tonic"],
-    indicators: ["tonic::", "#[tonic::async_trait]"]
-  },
-  "yew": {
-    dependencies: ["yew"],
-    indicators: ["yew::", "html!"]
-  },
-  "leptos": {
-    dependencies: ["leptos"],
-    indicators: ["leptos::", "view!"]
-  },
-  "tauri": {
-    dependencies: ["tauri"],
-    indicators: ["tauri::", "#[tauri::command]"]
-  },
-  "bevy": {
-    dependencies: ["bevy"],
-    indicators: ["bevy::", "App"]
-  },
-  "egui": {
-    dependencies: ["egui"],
-    indicators: ["egui::", "CentralPanel"]
-  }
-};
-async function analyzeRustProject(projectPath, files, _languages) {
-  logger$3.info("Analyzing Rust project");
-  const frameworks = [];
-  const cargoTomlPath = posix.join(projectPath, "Cargo.toml");
-  let cargoToml = null;
-  try {
-    if (await pathExists$2(cargoTomlPath)) {
-      const content = await promises.readFile(cargoTomlPath, "utf-8");
-      cargoToml = parse(content);
-    }
-  } catch (error) {
-    logger$3.warn("Failed to read Cargo.toml:", error);
-  }
-  const dependencies = extractCargoDependencies(cargoToml);
-  const patterns = await scanRustPatterns(projectPath, files);
-  for (const [frameworkName, frameworkPatterns] of Object.entries(FRAMEWORK_PATTERNS$1)) {
-    const evidence = [];
-    let confidence = 0;
-    for (const dep of frameworkPatterns.dependencies) {
-      if (dependencies[dep]) {
-        evidence.push(`Found ${dep} in dependencies`);
-        confidence += 0.5;
-      }
-    }
-    for (const indicator of frameworkPatterns.indicators) {
-      if (patterns[indicator]) {
-        evidence.push(`Found pattern: ${indicator}`);
-        confidence += 0.3;
-      }
-    }
-    if (confidence > 0) {
-      frameworks.push({
-        name: frameworkName,
-        category: getFrameworkCategory$1(frameworkName),
-        version: dependencies[frameworkName],
-        confidence: Math.min(confidence, 1),
-        evidence
-      });
-    }
-  }
-  await detectAdditionalPatterns$1(projectPath, files, frameworks, dependencies, patterns, cargoToml);
-  frameworks.sort((a, b) => b.confidence - a.confidence);
-  logger$3.debug(`Detected frameworks: ${frameworks.map((f) => `${f.name} (${Math.round(f.confidence * 100)}%)`).join(", ")}`);
-  return frameworks;
-}
-function extractCargoDependencies(cargoToml) {
-  const dependencies = {};
-  if (!cargoToml) {
-    return dependencies;
-  }
-  const depsSections = [
-    cargoToml.dependencies,
-    cargoToml["dev-dependencies"],
-    cargoToml["build-dependencies"]
-  ];
-  for (const section of depsSections) {
-    if (typeof section === "object") {
-      for (const [name, version] of Object.entries(section)) {
-        if (typeof version === "string") {
-          dependencies[name] = version;
-        } else if (typeof version === "object" && version !== null && "version" in version) {
-          dependencies[name] = version.version;
-        }
-      }
-    }
-  }
-  if (cargoToml.workspace?.dependencies) {
-    for (const [name, version] of Object.entries(cargoToml.workspace.dependencies)) {
-      if (!dependencies[name]) {
-        if (typeof version === "string") {
-          dependencies[name] = version;
-        } else if (typeof version === "object" && version !== null && "version" in version) {
-          dependencies[name] = version.version;
-        }
-      }
-    }
-  }
-  return dependencies;
-}
-async function scanRustPatterns(projectPath, files) {
-  const patterns = {};
-  const rustFiles = files.filter((f) => f.endsWith(".rs"));
-  for (const file of rustFiles) {
-    try {
-      const content = await promises.readFile(posix.join(projectPath, file), "utf-8");
-      const patternRegex = /(\w+::|@\[|!\w+\()/g;
-      let match;
-      while ((match = patternRegex.exec(content)) !== null) {
-        const pattern = match[1];
-        patterns[pattern] = (patterns[pattern] || 0) + 1;
-      }
-      const macroRegex = /(\w+!)/g;
-      while ((match = macroRegex.exec(content)) !== null) {
-        const macroName = match[1];
-        patterns[macroName] = (patterns[macroName] || 0) + 1;
-      }
-      const traitRegex = /:\s*([\w\s,]+)(?:\s*\{|<)/g;
-      while ((match = traitRegex.exec(content)) !== null) {
-        const traits = match[1].split(",").map((t) => t.trim());
-        for (const trait of traits) {
-          patterns[trait] = (patterns[trait] || 0) + 1;
-        }
-      }
-    } catch (error) {
-      logger$3.warn(`Failed to read ${file}:`, error);
-    }
-  }
-  return patterns;
-}
-function getFrameworkCategory$1(framework) {
-  const categories = {
-    web: [
-      "actix-web",
-      "rocket",
-      "axum",
-      "warp",
-      "hyper",
-      "tide"
-    ],
-    async: ["tokio", "async-std"],
-    serialization: ["serde", "serde_json"],
-    cli: ["clap"],
-    error: ["anyhow", "thiserror"],
-    logging: ["tracing", "log"],
-    database: ["sqlx", "diesel", "sea-orm", "tokio-postgres"],
-    cache: ["redis"],
-    monitoring: ["prometheus", "sentry"],
-    utility: ["uuid", "chrono", "regex", "rand"],
-    middleware: ["tower"],
-    rpc: ["prost", "tonic"],
-    frontend: ["yew", "leptos"],
-    desktop: ["tauri"],
-    game: ["bevy"],
-    gui: ["egui"]
-  };
-  for (const [category, frameworks] of Object.entries(categories)) {
-    if (frameworks.includes(framework)) {
-      return category;
-    }
-  }
-  return "other";
-}
-async function detectAdditionalPatterns$1(projectPath, files, frameworks, dependencies, patterns, cargoToml) {
-  if (cargoToml?.package?.edition) {
-    frameworks.push({
-      name: "rust",
-      category: "language",
-      version: cargoToml.package.edition,
-      confidence: 0.9,
-      evidence: ["Found Cargo.toml"]
-    });
-  }
-  if (cargoToml?.workspace) {
-    frameworks.push({
-      name: "workspace",
-      category: "workspace",
-      confidence: 0.9,
-      evidence: ["Found workspace in Cargo.toml"]
-    });
-  }
-  if (cargoToml?.bin) {
-    frameworks.push({
-      name: "binary",
-      category: "build",
-      confidence: 0.8,
-      evidence: ["Found binary targets"]
-    });
-  }
-  if (cargoToml?.lib) {
-    frameworks.push({
-      name: "library",
-      category: "build",
-      confidence: 0.8,
-      evidence: ["Found library configuration"]
-    });
-  }
-  const dockerFiles = ["Dockerfile", "docker-compose.yml", "docker-compose.yaml"];
-  for (const file of dockerFiles) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: "docker",
-        category: "deployment",
-        confidence: 0.9,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  if (files.some((f) => f.endsWith("_test.rs")) || patterns["#["] && patterns["#["] > 0) {
-    frameworks.push({
-      name: "testing",
-      category: "testing",
-      confidence: 0.7,
-      evidence: ["Found test files"]
-    });
-  }
-  if (files.some((f) => f.endsWith("_bench.rs"))) {
-    frameworks.push({
-      name: "benchmark",
-      category: "testing",
-      confidence: 0.8,
-      evidence: ["Found benchmark files"]
-    });
-  }
-  if (files.some((f) => f.startsWith("examples/"))) {
-    frameworks.push({
-      name: "examples",
-      category: "documentation",
-      confidence: 0.7,
-      evidence: ["Found examples directory"]
-    });
-  }
-  const ciFiles = {
-    ".github/workflows": "github-actions",
-    ".gitlab-ci.yml": "gitlab-ci",
-    "Jenkinsfile": "jenkins",
-    ".travis.yml": "travis-ci"
-  };
-  for (const [file, tool] of Object.entries(ciFiles)) {
-    if (files.includes(file) || files.some((f) => f.startsWith(file))) {
-      frameworks.push({
-        name: tool,
-        category: "ci-cd",
-        confidence: 0.8,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  const buildFiles = {
-    "Makefile": "make",
-    "justfile": "just",
-    "build.rs": "build-script"
-  };
-  for (const [file, tool] of Object.entries(buildFiles)) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: tool,
-        category: "build",
-        confidence: 0.8,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  if (files.some((f) => f.endsWith(".proto"))) {
-    frameworks.push({
-      name: "protobuf",
-      category: "rpc",
-      confidence: 0.9,
-      evidence: ["Found .proto files"]
-    });
-  }
-  if (dependencies["wasm-bindgen"] || dependencies["wasm-pack"]) {
-    frameworks.push({
-      name: "wasm",
-      category: "webassembly",
-      confidence: 0.8,
-      evidence: ["Found WASM dependencies"]
-    });
-  }
-  if (patterns["#![no_std]"]) {
-    frameworks.push({
-      name: "no_std",
-      category: "embedded",
-      confidence: 0.9,
-      evidence: ["Found #![no_std]"]
-    });
-  }
-  if (cargoToml?.lib?.proc_macro) {
-    frameworks.push({
-      name: "proc-macro",
-      category: "meta",
-      confidence: 0.9,
-      evidence: ["Found proc-macro configuration"]
-    });
-  }
-  if (dependencies.clippy) {
-    frameworks.push({
-      name: "clippy",
-      category: "linting",
-      confidence: 0.8,
-      evidence: ["Found clippy dependency"]
-    });
-  }
-  if (dependencies.rustfmt) {
-    frameworks.push({
-      name: "rustfmt",
-      category: "formatting",
-      confidence: 0.8,
-      evidence: ["Found rustfmt dependency"]
-    });
-  }
-  if (dependencies.rustdoc) {
-    frameworks.push({
-      name: "rustdoc",
-      category: "documentation",
-      confidence: 0.8,
-      evidence: ["Found rustdoc dependency"]
-    });
-  }
-  if (cargoToml?.package?.publish) {
-    frameworks.push({
-      name: "crates.io",
-      category: "registry",
-      confidence: 0.7,
-      evidence: ["Found publish configuration"]
-    });
-  }
-  if (cargoToml?.package?.license) {
-    frameworks.push({
-      name: cargoToml.package.license,
-      category: "legal",
-      confidence: 0.6,
-      evidence: ["Found license in Cargo.toml"]
-    });
-  }
-  if (cargoToml?.package) {
-    const type = cargoToml.bin ? "binary" : cargoToml.lib ? "library" : "unknown";
-    frameworks.push({
-      name: type,
-      category: "package",
-      confidence: 0.9,
-      evidence: [`Detected as ${type}`]
-    });
-  }
-  if (files.includes("target/") || files.some((f) => f.startsWith("target/"))) {
-    logger$3.debug("Found target/ directory (build artifacts)");
-  }
-  if (files.includes("Cargo.lock")) {
-    frameworks.push({
-      name: "cargo-lock",
-      category: "dependency",
-      confidence: 0.9,
-      evidence: ["Found Cargo.lock"]
-    });
-  }
-}
-
-async function pathExists$1(p) {
-  try {
-    await promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readJson(p) {
-  const content = await promises.readFile(p, "utf-8");
-  return JSON.parse(content);
-}
-const logger$2 = consola.withTag("typescript-analyzer");
-const FRAMEWORK_PATTERNS = {
-  "next.js": {
-    files: ["next.config.js", "next.config.ts", "next.config.mjs"],
-    dependencies: ["next"],
-    indicators: ["pages/", "app/", "src/app/", "src/pages/"]
-  },
-  "nuxt": {
-    files: ["nuxt.config.js", "nuxt.config.ts"],
-    dependencies: ["nuxt"],
-    indicators: ["pages/", "layouts/", "components/", "store/"]
-  },
-  "sveltekit": {
-    files: ["svelte.config.js", "svelte.config.ts"],
-    dependencies: ["@sveltejs/kit"],
-    indicators: ["src/routes/", "src/lib/", ".svelte-kit/"]
-  },
-  "astro": {
-    files: ["astro.config.js", "astro.config.mjs", "astro.config.ts"],
-    dependencies: ["astro"],
-    indicators: ["src/pages/", "src/content/", "src/components/"]
-  },
-  "solidstart": {
-    files: ["vite.config.ts", "vite.config.js"],
-    dependencies: ["solid-start"],
-    indicators: ["src/routes/", "src/components/"]
-  },
-  "qwik": {
-    files: ["vite.config.ts"],
-    dependencies: ["@builder.io/qwik"],
-    indicators: ["src/routes/", "src/components/"]
-  },
-  "remix": {
-    files: ["remix.config.js", "vite.config.ts"],
-    dependencies: ["@remix-run/node"],
-    indicators: ["app/", "app/routes/", "app/components/"]
-  },
-  "gatsby": {
-    files: ["gatsby-config.js", "gatsby-config.ts"],
-    dependencies: ["gatsby"],
-    indicators: ["src/pages/", "src/templates/", "gatsby-node.js"]
-  },
-  "vue": {
-    files: ["vue.config.js"],
-    dependencies: ["vue"],
-    indicators: ["src/components/", "src/views/", "src/router/"]
-  },
-  "angular": {
-    files: ["angular.json"],
-    dependencies: ["@angular/core"],
-    indicators: ["src/app/", "e2e/", ".angular/"]
-  },
-  "react": {
-    files: [],
-    dependencies: ["react", "react-dom"],
-    indicators: ["src/", "components/", "src/components/"]
-  },
-  "preact": {
-    files: [],
-    dependencies: ["preact"],
-    indicators: ["src/", "components/"]
-  },
-  "solidjs": {
-    files: [],
-    dependencies: ["solid-js"],
-    indicators: ["src/", "components/"]
-  },
-  "svelte": {
-    files: [],
-    dependencies: ["svelte"],
-    indicators: ["src/", "components/", "src/components/"]
-  },
-  "nest.js": {
-    files: ["nest-cli.json"],
-    dependencies: ["@nestjs/core"],
-    indicators: ["src/", "src/modules/", "src/controllers/"]
-  },
-  "express": {
-    files: [],
-    dependencies: ["express"],
-    indicators: ["app.js", "server.js", "routes/", "middleware/"]
-  },
-  "fastify": {
-    files: [],
-    dependencies: ["fastify"],
-    indicators: ["app.js", "server.js", "routes/", "plugins/"]
-  },
-  "koa": {
-    files: [],
-    dependencies: ["koa"],
-    indicators: ["app.js", "server.js", "middleware/"]
-  },
-  "adonisjs": {
-    files: [".adonisrc.json"],
-    dependencies: ["@adonisjs/core"],
-    indicators: ["app/", "config/", "start/", "providers/"]
-  },
-  "feathers": {
-    files: [],
-    dependencies: ["@feathersjs/feathers"],
-    indicators: ["src/", "services/"]
-  },
-  "meteor": {
-    files: [".meteor/"],
-    dependencies: ["meteor-node-stubs"],
-    indicators: ["client/", "server/", "imports/"]
-  },
-  "ionic": {
-    files: ["ionic.config.json"],
-    dependencies: ["@ionic/core"],
-    indicators: ["src/", "www/"]
-  },
-  "electron": {
-    files: [],
-    dependencies: ["electron"],
-    indicators: ["main.js", "src/main/", "electron/"]
-  },
-  "turborepo": {
-    files: ["turbo.json"],
-    dependencies: ["turbo"],
-    indicators: ["apps/", "packages/"]
-  },
-  "nx": {
-    files: ["nx.json"],
-    dependencies: ["nx"],
-    indicators: ["apps/", "libs/"]
-  },
-  "lerna": {
-    files: ["lerna.json"],
-    dependencies: ["lerna"],
-    indicators: ["packages/"]
-  }
-};
-async function analyzeTypeScriptProject(projectPath, files, _languages) {
-  logger$2.info("Analyzing TypeScript/JavaScript project");
-  const frameworks = [];
-  const packageJsonPath = posix.join(projectPath, "package.json");
-  let packageJson = null;
-  try {
-    if (await pathExists$1(packageJsonPath)) {
-      packageJson = await readJson(packageJsonPath);
-    }
-  } catch (error) {
-    logger$2.warn("Failed to read package.json:", error);
-  }
-  for (const [frameworkName, patterns] of Object.entries(FRAMEWORK_PATTERNS)) {
-    const evidence = [];
-    let confidence = 0;
-    for (const file of patterns.files) {
-      if (files.includes(file)) {
-        evidence.push(`Found ${file}`);
-        confidence += 0.3;
-      }
-    }
-    for (const indicator of patterns.indicators) {
-      const indicatorPath = posix.join(projectPath, indicator);
-      if (files.some((f) => f.startsWith(indicator)) || await pathExists$1(indicatorPath)) {
-        evidence.push(`Found ${indicator} directory`);
-        confidence += 0.2;
-      }
-    }
-    if (packageJson) {
-      const allDeps = {
-        ...packageJson.dependencies,
-        ...packageJson.devDependencies
-      };
-      for (const dep of patterns.dependencies) {
-        if (allDeps[dep]) {
-          evidence.push(`Found ${dep} in dependencies`);
-          confidence += 0.4;
-        }
-      }
-    }
-    if (confidence > 0) {
-      let version;
-      if (packageJson) {
-        for (const dep of patterns.dependencies) {
-          const depVersion = packageJson.dependencies?.[dep] || packageJson.devDependencies?.[dep];
-          if (depVersion) {
-            version = depVersion;
-            break;
-          }
-        }
-      }
-      frameworks.push({
-        name: frameworkName,
-        category: getFrameworkCategory(frameworkName),
-        version,
-        confidence: Math.min(confidence, 1),
-        evidence
-      });
-    }
-  }
-  await detectAdditionalPatterns(projectPath, files, frameworks, packageJson);
-  frameworks.sort((a, b) => b.confidence - a.confidence);
-  logger$2.debug(`Detected frameworks: ${frameworks.map((f) => `${f.name} (${Math.round(f.confidence * 100)}%)`).join(", ")}`);
-  return frameworks;
-}
-function getFrameworkCategory(framework) {
-  const categories = {
-    frontend: [
-      "next.js",
-      "nuxt",
-      "sveltekit",
-      "astro",
-      "solidstart",
-      "qwik",
-      "remix",
-      "gatsby",
-      "vue",
-      "angular",
-      "react",
-      "preact",
-      "solidjs",
-      "svelte",
-      "ionic"
-    ],
-    backend: [
-      "nest.js",
-      "express",
-      "fastify",
-      "koa",
-      "adonisjs",
-      "feathers",
-      "meteor"
-    ],
-    desktop: ["electron"],
-    monorepo: ["turborepo", "nx", "lerna"]
-  };
-  for (const [category, frameworks] of Object.entries(categories)) {
-    if (frameworks.includes(framework)) {
-      return category;
-    }
-  }
-  return "other";
-}
-async function detectAdditionalPatterns(projectPath, files, frameworks, packageJson) {
-  if (files.includes("tsconfig.json")) {
-    const tsFramework = frameworks.find((f) => f.name === "typescript");
-    if (!tsFramework) {
-      frameworks.push({
-        name: "typescript",
-        category: "language",
-        confidence: 0.9,
-        evidence: ["Found tsconfig.json"]
-      });
-    }
-  }
-  const testDependencies = ["jest", "vitest", "cypress", "playwright", "mocha", "jasmine"];
-  if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    for (const testDep of testDependencies) {
-      if (allDeps[testDep]) {
-        frameworks.push({
-          name: testDep,
-          category: "testing",
-          version: allDeps[testDep],
-          confidence: 0.8,
-          evidence: [`Found ${testDep} in dependencies`]
-        });
-      }
-    }
-  }
-  const cssFrameworks = ["tailwindcss", "bootstrap", "bulma", "material-ui", "chakra-ui"];
-  if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    for (const cssFw of cssFrameworks) {
-      if (allDeps[cssFw]) {
-        frameworks.push({
-          name: cssFw,
-          category: "css",
-          version: allDeps[cssFw],
-          confidence: 0.8,
-          evidence: [`Found ${cssFw} in dependencies`]
-        });
-      }
-    }
-  }
-  const stateLibs = ["redux", "zustand", "recoil", "jotai", "valtio"];
-  if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    for (const lib of stateLibs) {
-      if (allDeps[lib]) {
-        frameworks.push({
-          name: lib,
-          category: "state-management",
-          version: allDeps[lib],
-          confidence: 0.8,
-          evidence: [`Found ${lib} in dependencies`]
-        });
-      }
-    }
-  }
-  const lintingTools = ["eslint", "prettier", "biome", "rome"];
-  if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    for (const tool of lintingTools) {
-      if (allDeps[tool]) {
-        frameworks.push({
-          name: tool,
-          category: "linting",
-          version: allDeps[tool],
-          confidence: 0.8,
-          evidence: [`Found ${tool} in dependencies`]
-        });
-      }
-    }
-  }
-  const deploymentFiles = {
-    "vercel.json": "vercel",
-    "netlify.toml": "netlify",
-    "app.yaml": "app-engine",
-    "now.json": "now"
-  };
-  for (const [file, platform] of Object.entries(deploymentFiles)) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: platform,
-        category: "deployment",
-        confidence: 0.9,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-}
-
-async function pathExists(p) {
-  try {
-    await promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-const logger$1 = consola.withTag("project-detector");
-const LANGUAGE_PATTERNS = {
-  typescript: {
-    files: ["package.json", "tsconfig.json", "tsconfig.build.json"],
-    extensions: [".ts", ".tsx", ".mts", ".cts"],
-    indicators: ["node_modules", "yarn.lock", "package-lock.json", "pnpm-lock.yaml"]
-  },
-  javascript: {
-    files: ["package.json"],
-    extensions: [".js", ".jsx", ".mjs", ".cjs"],
-    indicators: ["node_modules", "yarn.lock", "package-lock.json", "pnpm-lock.yaml"]
-  },
-  python: {
-    files: ["requirements.txt", "pyproject.toml", "setup.py", "Pipfile"],
-    extensions: [".py", ".pyx", ".pyi"],
-    indicators: [".venv", "venv", "__pycache__", ".python-version"]
-  },
-  go: {
-    files: ["go.mod", "go.sum"],
-    extensions: [".go"],
-    indicators: ["vendor", "Gopkg.lock"]
-  },
-  rust: {
-    files: ["Cargo.toml", "Cargo.lock"],
-    extensions: [".rs"],
-    indicators: ["target"]
-  },
-  java: {
-    files: ["pom.xml", "build.gradle", "build.gradle.kts"],
-    extensions: [".java", ".kt"],
-    indicators: ["gradlew", "mvnw"]
-  },
-  dotnet: {
-    files: ["*.csproj", "*.sln", "*.fsproj", "*.vbproj"],
-    extensions: [".cs", ".fs", ".vb"],
-    indicators: ["bin", "obj"]
-  },
-  ruby: {
-    files: ["Gemfile", "Gemfile.lock"],
-    extensions: [".rb"],
-    indicators: ["vendor/bundle"]
-  },
-  php: {
-    files: ["composer.json", "composer.lock"],
-    extensions: [".php"],
-    indicators: ["vendor"]
-  },
-  swift: {
-    files: ["Package.swift"],
-    extensions: [".swift"],
-    indicators: [".build"]
-  },
-  kotlin: {
-    files: ["build.gradle.kts"],
-    extensions: [".kt", ".kts"],
-    indicators: ["gradlew"]
-  },
-  dart: {
-    files: ["pubspec.yaml"],
-    extensions: [".dart"],
-    indicators: [".dart_tool"]
-  }
-};
-const FRAMEWORK_PRIORITY = {
-  "next.js": 10,
-  "nuxt": 9,
-  "sveltekit": 8,
-  "astro": 7,
-  "solidstart": 6,
-  "qwik": 5,
-  "remix": 4,
-  "gatsby": 3,
-  "create-react-app": 2,
-  "vue": 1,
-  "angular": 1,
-  "react": 0
-};
-async function detectProject(projectPath, config) {
-  const startTime = Date.now();
-  logger$1.info(`Detecting project at: ${projectPath}`);
-  const absolutePath = posix.resolve(projectPath);
-  if (!await pathExists(absolutePath)) {
-    throw new Error(`Project path does not exist: ${absolutePath}`);
-  }
-  const files = await scanProjectFiles(absolutePath, config);
-  logger$1.debug(`Scanned ${files.length} files`);
-  const languages = await detectLanguages(absolutePath, files, config);
-  logger$1.debug(`Detected languages: ${languages.map((l) => l.language).join(", ")}`);
-  languages.sort((a, b) => b.confidence - a.confidence);
-  const primaryLanguage = languages[0];
-  let frameworks = [];
-  if (primaryLanguage) {
-    switch (primaryLanguage.language) {
-      case "typescript":
-      case "javascript":
-        frameworks = await analyzeTypeScriptProject(absolutePath, files);
-        break;
-      case "python":
-        frameworks = await analyzePythonProject(absolutePath, files);
-        break;
-      case "go":
-        frameworks = await analyzeGoProject(absolutePath, files);
-        break;
-      case "rust":
-        frameworks = await analyzeRustProject(absolutePath, files);
-        break;
-    }
-  }
-  const packageManager = detectPackageManager(files);
-  const buildSystem = detectBuildSystem(files, frameworks);
-  const configFiles = detectConfigFiles(files);
-  const importantDirs = detectImportantDirs(absolutePath);
-  const analysis = {
-    rootPath: absolutePath,
-    projectType: determineProjectType(languages, frameworks),
-    languages,
-    frameworks,
-    packageManager,
-    buildSystem,
-    configFiles,
-    importantDirs,
-    metadata: {
-      timestamp: /* @__PURE__ */ new Date(),
-      duration: Date.now() - startTime,
-      filesScanned: files.length,
-      confidence: calculateOverallConfidence(languages, frameworks),
-      version: "1.0.0"
-    }
-  };
-  logger$1.info(`Detected project type: ${analysis.projectType}`);
-  return analysis;
-}
-const ROOT_CONFIG_FILES = [
-  "package.json",
-  "tsconfig.json",
-  "jsconfig.json",
-  "go.mod",
-  "Cargo.toml",
-  "pyproject.toml",
-  "requirements.txt",
-  "setup.py",
-  "Gemfile",
-  "composer.json",
-  "pom.xml",
-  "build.gradle",
-  "build.gradle.kts",
-  "pubspec.yaml",
-  "Package.swift",
-  "pom.xml"
-];
-async function scanProjectFiles(projectPath, config) {
-  const rootConfigFiles = [];
-  for (const configFile of ROOT_CONFIG_FILES) {
-    const configPath = posix.join(projectPath, configFile);
-    if (await pathExists(configPath)) {
-      rootConfigFiles.push(configFile);
-      logger$1.debug(`Found root config: ${configFile}`);
-    }
-  }
-  const patterns = ["**/*"];
-  const ignore = config.excludePatterns;
-  if (!config.includeNodeModules) {
-    ignore.push("node_modules/**");
-  }
-  const allFiles = await glob(patterns, {
-    cwd: projectPath,
-    ignore,
-    absolute: false
-  });
-  const fileSet = /* @__PURE__ */ new Set([...rootConfigFiles, ...allFiles]);
-  const files = Array.from(fileSet);
-  if (files.length > config.maxFilesToScan) {
-    logger$1.warn(`Too many files (${files.length}), limiting to ${config.maxFilesToScan}`);
-    const rootConfigs = files.filter((f) => ROOT_CONFIG_FILES.includes(f));
-    const otherFiles = files.filter((f) => !ROOT_CONFIG_FILES.includes(f));
-    const limitedOthers = otherFiles.slice(0, config.maxFilesToScan - rootConfigs.length);
-    return [...rootConfigs, ...limitedOthers];
-  }
-  return files;
-}
-async function detectLanguages(projectPath, files, config) {
-  const languageCounts = /* @__PURE__ */ new Map();
-  const languageIndicators = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const ext = posix.extname(file).toLowerCase();
-    for (const [language, patterns] of Object.entries(LANGUAGE_PATTERNS)) {
-      const extensions = patterns.extensions;
-      if (extensions.includes(ext)) {
-        languageCounts.set(language, (languageCounts.get(language) || 0) + 1);
-      }
-    }
-  }
-  const fileSet = new Set(files);
-  for (const [language, patterns] of Object.entries(LANGUAGE_PATTERNS)) {
-    const indicators = [];
-    for (const file of patterns.files) {
-      if (fileSet.has(file) || fileSet.has(file.toLowerCase())) {
-        indicators.push(`Found ${file}`);
-        languageCounts.set(language, (languageCounts.get(language) || 0) + 10);
-      }
-    }
-    for (const indicator of patterns.indicators) {
-      if (fileSet.has(indicator) || await pathExists(posix.join(projectPath, indicator))) {
-        indicators.push(`Found ${indicator}`);
-        languageCounts.set(language, (languageCounts.get(language) || 0) + 5);
-      }
-    }
-    if (indicators.length > 0) {
-      languageIndicators.set(language, new Set(indicators));
-    }
-  }
-  const totalFiles = files.length;
-  const languages = [];
-  for (const [language, count] of Array.from(languageCounts.entries())) {
-    const confidence = Math.min(count / totalFiles, 1);
-    if (confidence >= config.minConfidence) {
-      languages.push({
-        language,
-        confidence,
-        fileCount: count,
-        indicators: Array.from(languageIndicators.get(language) || [])
-      });
-    }
-  }
-  return languages;
-}
-function detectPackageManager(files) {
-  const managers = {
-    "pnpm-lock.yaml": "pnpm",
-    "yarn.lock": "yarn",
-    "package-lock.json": "npm",
-    "bun.lockb": "bun",
-    "requirements.txt": "pip",
-    "Pipfile": "pipenv",
-    "pyproject.toml": "poetry",
-    "go.mod": "go",
-    "Cargo.toml": "cargo",
-    "pom.xml": "maven",
-    "build.gradle": "gradle"
-  };
-  for (const [file, manager] of Object.entries(managers)) {
-    if (files.includes(file)) {
-      return manager;
-    }
-  }
-  return void 0;
-}
-function detectBuildSystem(files, frameworks) {
-  for (const framework of frameworks) {
-    if (framework.name.includes("next"))
-      return "next";
-    if (framework.name.includes("nuxt"))
-      return "nuxt";
-    if (framework.name.includes("sveltekit"))
-      return "svelte";
-    if (framework.name.includes("astro"))
-      return "unknown";
-  }
-  const buildFiles = {
-    "webpack.config.js": "webpack",
-    "webpack.config.ts": "webpack",
-    "vite.config.ts": "vite",
-    "vite.config.js": "vite",
-    "rollup.config.js": "rollup",
-    "rollup.config.ts": "rollup",
-    "esbuild.config.js": "esbuild",
-    "tsconfig.json": "tsc",
-    ".babelrc": "babel",
-    "babel.config.js": "babel",
-    ".swcrc": "swc",
-    "Makefile": "make",
-    "CMakeLists.txt": "cmake",
-    "BUILD": "bazel"
-  };
-  for (const [file, system] of Object.entries(buildFiles)) {
-    if (files.includes(file)) {
-      return system;
-    }
-  }
-  return void 0;
-}
-function detectConfigFiles(files) {
-  const configPatterns = [
-    "package.json",
-    "tsconfig.json",
-    "jsconfig.json",
-    "pyproject.toml",
-    "requirements.txt",
-    "setup.py",
-    "go.mod",
-    "Cargo.toml",
-    "pom.xml",
-    "build.gradle",
-    "build.gradle.kts",
-    "composer.json",
-    "Gemfile",
-    "pubspec.yaml",
-    "docker-compose.yml",
-    "docker-compose.yaml",
-    "Dockerfile",
-    ".env",
-    ".env.example",
-    ".gitignore",
-    ".dockerignore",
-    "README.md",
-    "readme.md",
-    "README.rst",
-    "readme.rst"
-  ];
-  return files.filter((file) => configPatterns.includes(file));
-}
-function detectImportantDirs(projectPath) {
-  const importantDirs = [
-    "src",
-    "lib",
-    "app",
-    "public",
-    "static",
-    "assets",
-    "components",
-    "pages",
-    "views",
-    "templates",
-    "styles",
-    "css",
-    "scss",
-    "sass",
-    "less",
-    "tests",
-    "test",
-    "spec",
-    "__tests__",
-    "docs",
-    "doc",
-    "examples",
-    "samples",
-    "scripts",
-    "bin",
-    "tools",
-    "config",
-    "configs",
-    "build",
-    "dist",
-    "out",
-    "target",
-    ".github",
-    ".vscode",
-    ".idea"
-  ];
-  const foundDirs = [];
-  for (const dir of importantDirs) {
-    if (existsSync(posix.join(projectPath, dir))) {
-      foundDirs.push(dir);
-    }
-  }
-  return foundDirs;
-}
-function determineProjectType(languages, frameworks) {
-  if (languages.length === 0) {
-    return "unknown";
-  }
-  const sortedFrameworks = [...frameworks].sort((a, b) => {
-    const priorityA = FRAMEWORK_PRIORITY[a.name.toLowerCase()] || 0;
-    const priorityB = FRAMEWORK_PRIORITY[b.name.toLowerCase()] || 0;
-    return priorityB - priorityA;
-  });
-  if (sortedFrameworks.length > 0 && sortedFrameworks[0].confidence > 0.7) {
-    return sortedFrameworks[0].name;
-  }
-  return languages[0].language;
-}
-function calculateOverallConfidence(languages, frameworks) {
-  if (languages.length === 0)
-    return 0;
-  const langConfidence = languages.reduce((sum, lang) => sum + lang.confidence, 0) / languages.length;
-  let frameworkConfidence = 0;
-  if (frameworks.length > 0) {
-    frameworkConfidence = frameworks.reduce((sum, fw) => sum + fw.confidence, 0) / frameworks.length;
-  }
-  return frameworkConfidence > 0 ? langConfidence * 0.7 + frameworkConfidence * 0.3 : langConfidence;
-}
-
-class ProjectAnalyzer {
-  config = {};
-  constructor(config = {}) {
-    this.config = config;
-  }
-  /**
-   * Analyze a project directory
-   */
-  async analyze(projectPath) {
-    return analyzeProject(projectPath, this.config);
-  }
-  /**
-   * Get project type only
-   */
-  async getProjectType(projectPath) {
-    return detectProjectType(projectPath);
-  }
-}
-const logger = consola.withTag("analyzer");
-const DEFAULT_CONFIG = {
-  minConfidence: 0.05,
-  // Lower threshold for large projects with many file types
-  includeNodeModules: false,
-  analyzeTransitiveDeps: true,
-  maxFilesToScan: 1e4,
-  includePatterns: [],
-  excludePatterns: [
-    "node_modules",
-    ".git",
-    "dist",
-    "build",
-    "coverage",
-    ".vscode",
-    ".idea",
-    "*.log",
-    "*.tmp",
-    ".DS_Store",
-    "Thumbs.db"
-  ]
-};
-async function analyzeProject(projectPath, config = {}) {
-  const startTime = Date.now();
-  logger.info(`Analyzing project at: ${projectPath}`);
-  const mergedConfig = {
-    ...DEFAULT_CONFIG,
-    ...config
-  };
-  try {
-    const analysis = await detectProject(projectPath, mergedConfig);
-    if (mergedConfig.analyzeTransitiveDeps && analysis.dependencies) {
-      analysis.dependencies = await analyzeDependencies$1(analysis, mergedConfig);
-    }
-    analysis.metadata.duration = Date.now() - startTime;
-    logger.success(`Project analysis completed in ${analysis.metadata.duration}ms`);
-    logger.info(`Detected: ${analysis.projectType} (${analysis.metadata.confidence * 100}% confidence)`);
-    return analysis;
-  } catch (error) {
-    logger.error("Project analysis failed:", error);
-    throw new Error(`Failed to analyze project at ${projectPath}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-async function detectProjectType(projectPath) {
-  const analysis = await analyzeProject(projectPath, {
-    analyzeTransitiveDeps: false
-  });
-  return analysis.projectType;
-}
-async function batchAnalyze(projectPaths, config = {}) {
-  logger.info(`Batch analyzing ${projectPaths.length} projects`);
-  const results = [];
-  for (const path of projectPaths) {
-    try {
-      const analysis = await analyzeProject(path, config);
-      results.push(analysis);
-    } catch (error) {
-      logger.error(`Failed to analyze ${path}:`, error);
-    }
-  }
-  logger.success(`Batch analysis completed: ${results.length}/${projectPaths.length} successful`);
-  return results;
-}
-
-const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
-const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
-const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
-function jsonParseTransform(key, value) {
-  if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
-    warnKeyDropped(key);
-    return;
-  }
-  return value;
-}
-function warnKeyDropped(key) {
-  console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
-}
-function destr(value, options = {}) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  if (value[0] === '"' && value[value.length - 1] === '"' && value.indexOf("\\") === -1) {
-    return value.slice(1, -1);
-  }
-  const _value = value.trim();
-  if (_value.length <= 9) {
-    switch (_value.toLowerCase()) {
-      case "true": {
-        return true;
-      }
-      case "false": {
-        return false;
-      }
-      case "undefined": {
-        return void 0;
-      }
-      case "null": {
-        return null;
-      }
-      case "nan": {
-        return Number.NaN;
-      }
-      case "infinity": {
-        return Number.POSITIVE_INFINITY;
-      }
-      case "-infinity": {
-        return Number.NEGATIVE_INFINITY;
-      }
-    }
-  }
-  if (!JsonSigRx.test(value)) {
-    if (options.strict) {
-      throw new SyntaxError("[destr] Invalid JSON");
-    }
-    return value;
-  }
-  try {
-    if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
-      if (options.strict) {
-        throw new Error("[destr] Possible prototype pollution");
-      }
-      return JSON.parse(value, jsonParseTransform);
-    }
-    return JSON.parse(value);
-  } catch (error) {
-    if (options.strict) {
-      throw error;
-    }
-    return value;
-  }
-}
-
-const HASH_RE = /#/g;
-const AMPERSAND_RE = /&/g;
-const SLASH_RE = /\//g;
-const EQUAL_RE = /=/g;
-const PLUS_RE = /\+/g;
-const ENC_CARET_RE = /%5e/gi;
-const ENC_BACKTICK_RE = /%60/gi;
-const ENC_PIPE_RE = /%7c/gi;
-const ENC_SPACE_RE = /%20/gi;
-function encode(text) {
-  return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
-}
-function encodeQueryValue(input) {
-  return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^").replace(SLASH_RE, "%2F");
-}
-function encodeQueryKey(text) {
-  return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
-}
-function decode(text = "") {
-  try {
-    return decodeURIComponent("" + text);
-  } catch {
-    return "" + text;
-  }
-}
-function decodeQueryKey(text) {
-  return decode(text.replace(PLUS_RE, " "));
-}
-function decodeQueryValue(text) {
-  return decode(text.replace(PLUS_RE, " "));
-}
-
-function parseQuery(parametersString = "") {
-  const object = /* @__PURE__ */ Object.create(null);
-  if (parametersString[0] === "?") {
-    parametersString = parametersString.slice(1);
-  }
-  for (const parameter of parametersString.split("&")) {
-    const s = parameter.match(/([^=]+)=?(.*)/) || [];
-    if (s.length < 2) {
-      continue;
-    }
-    const key = decodeQueryKey(s[1]);
-    if (key === "__proto__" || key === "constructor") {
-      continue;
-    }
-    const value = decodeQueryValue(s[2] || "");
-    if (object[key] === void 0) {
-      object[key] = value;
-    } else if (Array.isArray(object[key])) {
-      object[key].push(value);
-    } else {
-      object[key] = [object[key], value];
-    }
-  }
-  return object;
-}
-function encodeQueryItem(key, value) {
-  if (typeof value === "number" || typeof value === "boolean") {
-    value = String(value);
-  }
-  if (!value) {
-    return encodeQueryKey(key);
-  }
-  if (Array.isArray(value)) {
-    return value.map(
-      (_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`
-    ).join("&");
-  }
-  return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
-}
-function stringifyQuery(query) {
-  return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join("&");
-}
-
-const PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
-const PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
-const PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
-const JOIN_LEADING_SLASH_RE = /^\.?\//;
-function hasProtocol(inputString, opts = {}) {
-  if (typeof opts === "boolean") {
-    opts = { acceptRelative: opts };
-  }
-  if (opts.strict) {
-    return PROTOCOL_STRICT_REGEX.test(inputString);
-  }
-  return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
-}
-function hasTrailingSlash(input = "", respectQueryAndFragment) {
-  {
-    return input.endsWith("/");
-  }
-}
-function withoutTrailingSlash(input = "", respectQueryAndFragment) {
-  {
-    return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
-  }
-}
-function withTrailingSlash(input = "", respectQueryAndFragment) {
-  {
-    return input.endsWith("/") ? input : input + "/";
-  }
-}
-function withBase(input, base) {
-  if (isEmptyURL(base) || hasProtocol(input)) {
-    return input;
-  }
-  const _base = withoutTrailingSlash(base);
-  if (input.startsWith(_base)) {
-    return input;
-  }
-  return joinURL(_base, input);
-}
-function withQuery(input, query) {
-  const parsed = parseURL(input);
-  const mergedQuery = { ...parseQuery(parsed.search), ...query };
-  parsed.search = stringifyQuery(mergedQuery);
-  return stringifyParsedURL(parsed);
-}
-function isEmptyURL(url) {
-  return !url || url === "/";
-}
-function isNonEmptyURL(url) {
-  return url && url !== "/";
-}
-function joinURL(base, ...input) {
-  let url = base || "";
-  for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {
-    if (url) {
-      const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
-      url = withTrailingSlash(url) + _segment;
-    } else {
-      url = segment;
-    }
-  }
-  return url;
-}
-
-const protocolRelative = Symbol.for("ufo:protocolRelative");
-function parseURL(input = "", defaultProto) {
-  const _specialProtoMatch = input.match(
-    /^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i
-  );
-  if (_specialProtoMatch) {
-    const [, _proto, _pathname = ""] = _specialProtoMatch;
-    return {
-      protocol: _proto.toLowerCase(),
-      pathname: _pathname,
-      href: _proto + _pathname,
-      auth: "",
-      host: "",
-      search: "",
-      hash: ""
-    };
-  }
-  if (!hasProtocol(input, { acceptRelative: true })) {
-    return parsePath(input);
-  }
-  const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
-  let [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
-  if (protocol === "file:") {
-    path = path.replace(/\/(?=[A-Za-z]:)/, "");
-  }
-  const { pathname, search, hash } = parsePath(path);
-  return {
-    protocol: protocol.toLowerCase(),
-    auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
-    host,
-    pathname,
-    search,
-    hash,
-    [protocolRelative]: !protocol
-  };
-}
-function parsePath(input = "") {
-  const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
-  return {
-    pathname,
-    search,
-    hash
-  };
-}
-function stringifyParsedURL(parsed) {
-  const pathname = parsed.pathname || "";
-  const search = parsed.search ? (parsed.search.startsWith("?") ? "" : "?") + parsed.search : "";
-  const hash = parsed.hash || "";
-  const auth = parsed.auth ? parsed.auth + "@" : "";
-  const host = parsed.host || "";
-  const proto = parsed.protocol || parsed[protocolRelative] ? (parsed.protocol || "") + "//" : "";
-  return proto + auth + host + pathname + search + hash;
-}
-
-class FetchError extends Error {
-  constructor(message, opts) {
-    super(message, opts);
-    this.name = "FetchError";
-    if (opts?.cause && !this.cause) {
-      this.cause = opts.cause;
-    }
-  }
-}
-function createFetchError(ctx) {
-  const errorMessage = ctx.error?.message || ctx.error?.toString() || "";
-  const method = ctx.request?.method || ctx.options?.method || "GET";
-  const url = ctx.request?.url || String(ctx.request) || "/";
-  const requestStr = `[${method}] ${JSON.stringify(url)}`;
-  const statusStr = ctx.response ? `${ctx.response.status} ${ctx.response.statusText}` : "<no response>";
-  const message = `${requestStr}: ${statusStr}${errorMessage ? ` ${errorMessage}` : ""}`;
-  const fetchError = new FetchError(
-    message,
-    ctx.error ? { cause: ctx.error } : void 0
-  );
-  for (const key of ["request", "options", "response"]) {
-    Object.defineProperty(fetchError, key, {
-      get() {
-        return ctx[key];
-      }
-    });
-  }
-  for (const [key, refKey] of [
-    ["data", "_data"],
-    ["status", "status"],
-    ["statusCode", "status"],
-    ["statusText", "statusText"],
-    ["statusMessage", "statusText"]
-  ]) {
-    Object.defineProperty(fetchError, key, {
-      get() {
-        return ctx.response && ctx.response[refKey];
-      }
-    });
-  }
-  return fetchError;
-}
-
-const payloadMethods = new Set(
-  Object.freeze(["PATCH", "POST", "PUT", "DELETE"])
-);
-function isPayloadMethod(method = "GET") {
-  return payloadMethods.has(method.toUpperCase());
-}
-function isJSONSerializable(value) {
-  if (value === void 0) {
-    return false;
-  }
-  const t = typeof value;
-  if (t === "string" || t === "number" || t === "boolean" || t === null) {
-    return true;
-  }
-  if (t !== "object") {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    return true;
-  }
-  if (value.buffer) {
-    return false;
-  }
-  if (value instanceof FormData || value instanceof URLSearchParams) {
-    return false;
-  }
-  return value.constructor && value.constructor.name === "Object" || typeof value.toJSON === "function";
-}
-const textTypes = /* @__PURE__ */ new Set([
-  "image/svg",
-  "application/xml",
-  "application/xhtml",
-  "application/html"
-]);
-const JSON_RE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
-function detectResponseType(_contentType = "") {
-  if (!_contentType) {
-    return "json";
-  }
-  const contentType = _contentType.split(";").shift() || "";
-  if (JSON_RE.test(contentType)) {
-    return "json";
-  }
-  if (contentType === "text/event-stream") {
-    return "stream";
-  }
-  if (textTypes.has(contentType) || contentType.startsWith("text/")) {
-    return "text";
-  }
-  return "blob";
-}
-function resolveFetchOptions(request, input, defaults, Headers) {
-  const headers = mergeHeaders(
-    input?.headers ?? request?.headers,
-    defaults?.headers,
-    Headers
-  );
-  let query;
-  if (defaults?.query || defaults?.params || input?.params || input?.query) {
-    query = {
-      ...defaults?.params,
-      ...defaults?.query,
-      ...input?.params,
-      ...input?.query
-    };
-  }
-  return {
-    ...defaults,
-    ...input,
-    query,
-    params: query,
-    headers
-  };
-}
-function mergeHeaders(input, defaults, Headers) {
-  if (!defaults) {
-    return new Headers(input);
-  }
-  const headers = new Headers(defaults);
-  if (input) {
-    for (const [key, value] of Symbol.iterator in input || Array.isArray(input) ? input : new Headers(input)) {
-      headers.set(key, value);
-    }
-  }
-  return headers;
-}
-async function callHooks(context, hooks) {
-  if (hooks) {
-    if (Array.isArray(hooks)) {
-      for (const hook of hooks) {
-        await hook(context);
-      }
-    } else {
-      await hooks(context);
-    }
-  }
-}
-
-const retryStatusCodes = /* @__PURE__ */ new Set([
-  408,
-  // Request Timeout
-  409,
-  // Conflict
-  425,
-  // Too Early (Experimental)
-  429,
-  // Too Many Requests
-  500,
-  // Internal Server Error
-  502,
-  // Bad Gateway
-  503,
-  // Service Unavailable
-  504
-  // Gateway Timeout
-]);
-const nullBodyResponses = /* @__PURE__ */ new Set([101, 204, 205, 304]);
-function createFetch(globalOptions = {}) {
-  const {
-    fetch = globalThis.fetch,
-    Headers = globalThis.Headers,
-    AbortController = globalThis.AbortController
-  } = globalOptions;
-  async function onError(context) {
-    const isAbort = context.error && context.error.name === "AbortError" && !context.options.timeout || false;
-    if (context.options.retry !== false && !isAbort) {
-      let retries;
-      if (typeof context.options.retry === "number") {
-        retries = context.options.retry;
-      } else {
-        retries = isPayloadMethod(context.options.method) ? 0 : 1;
-      }
-      const responseCode = context.response && context.response.status || 500;
-      if (retries > 0 && (Array.isArray(context.options.retryStatusCodes) ? context.options.retryStatusCodes.includes(responseCode) : retryStatusCodes.has(responseCode))) {
-        const retryDelay = typeof context.options.retryDelay === "function" ? context.options.retryDelay(context) : context.options.retryDelay || 0;
-        if (retryDelay > 0) {
-          await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        }
-        return $fetchRaw(context.request, {
-          ...context.options,
-          retry: retries - 1
-        });
-      }
-    }
-    const error = createFetchError(context);
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(error, $fetchRaw);
-    }
-    throw error;
-  }
-  const $fetchRaw = async function $fetchRaw2(_request, _options = {}) {
-    const context = {
-      request: _request,
-      options: resolveFetchOptions(
-        _request,
-        _options,
-        globalOptions.defaults,
-        Headers
-      ),
-      response: void 0,
-      error: void 0
-    };
-    if (context.options.method) {
-      context.options.method = context.options.method.toUpperCase();
-    }
-    if (context.options.onRequest) {
-      await callHooks(context, context.options.onRequest);
-      if (!(context.options.headers instanceof Headers)) {
-        context.options.headers = new Headers(
-          context.options.headers || {}
-          /* compat */
-        );
-      }
-    }
-    if (typeof context.request === "string") {
-      if (context.options.baseURL) {
-        context.request = withBase(context.request, context.options.baseURL);
-      }
-      if (context.options.query) {
-        context.request = withQuery(context.request, context.options.query);
-        delete context.options.query;
-      }
-      if ("query" in context.options) {
-        delete context.options.query;
-      }
-      if ("params" in context.options) {
-        delete context.options.params;
-      }
-    }
-    if (context.options.body && isPayloadMethod(context.options.method)) {
-      if (isJSONSerializable(context.options.body)) {
-        const contentType = context.options.headers.get("content-type");
-        if (typeof context.options.body !== "string") {
-          context.options.body = contentType === "application/x-www-form-urlencoded" ? new URLSearchParams(
-            context.options.body
-          ).toString() : JSON.stringify(context.options.body);
-        }
-        if (!contentType) {
-          context.options.headers.set("content-type", "application/json");
-        }
-        if (!context.options.headers.has("accept")) {
-          context.options.headers.set("accept", "application/json");
-        }
-      } else if (
-        // ReadableStream Body
-        "pipeTo" in context.options.body && typeof context.options.body.pipeTo === "function" || // Node.js Stream Body
-        typeof context.options.body.pipe === "function"
-      ) {
-        if (!("duplex" in context.options)) {
-          context.options.duplex = "half";
-        }
-      }
-    }
-    let abortTimeout;
-    if (!context.options.signal && context.options.timeout) {
-      const controller = new AbortController();
-      abortTimeout = setTimeout(() => {
-        const error = new Error(
-          "[TimeoutError]: The operation was aborted due to timeout"
-        );
-        error.name = "TimeoutError";
-        error.code = 23;
-        controller.abort(error);
-      }, context.options.timeout);
-      context.options.signal = controller.signal;
-    }
-    try {
-      context.response = await fetch(
-        context.request,
-        context.options
-      );
-    } catch (error) {
-      context.error = error;
-      if (context.options.onRequestError) {
-        await callHooks(
-          context,
-          context.options.onRequestError
-        );
-      }
-      return await onError(context);
-    } finally {
-      if (abortTimeout) {
-        clearTimeout(abortTimeout);
-      }
-    }
-    const hasBody = (context.response.body || // https://github.com/unjs/ofetch/issues/324
-    // https://github.com/unjs/ofetch/issues/294
-    // https://github.com/JakeChampion/fetch/issues/1454
-    context.response._bodyInit) && !nullBodyResponses.has(context.response.status) && context.options.method !== "HEAD";
-    if (hasBody) {
-      const responseType = (context.options.parseResponse ? "json" : context.options.responseType) || detectResponseType(context.response.headers.get("content-type") || "");
-      switch (responseType) {
-        case "json": {
-          const data = await context.response.text();
-          const parseFunction = context.options.parseResponse || destr;
-          context.response._data = parseFunction(data);
-          break;
-        }
-        case "stream": {
-          context.response._data = context.response.body || context.response._bodyInit;
-          break;
-        }
-        default: {
-          context.response._data = await context.response[responseType]();
-        }
-      }
-    }
-    if (context.options.onResponse) {
-      await callHooks(
-        context,
-        context.options.onResponse
-      );
-    }
-    if (!context.options.ignoreResponseError && context.response.status >= 400 && context.response.status < 600) {
-      if (context.options.onResponseError) {
-        await callHooks(
-          context,
-          context.options.onResponseError
-        );
-      }
-      return await onError(context);
-    }
-    return context.response;
-  };
-  const $fetch = async function $fetch2(request, options) {
-    const r = await $fetchRaw(request, options);
-    return r._data;
-  };
-  $fetch.raw = $fetchRaw;
-  $fetch.native = (...args) => fetch(...args);
-  $fetch.create = (defaultOptions = {}, customGlobalOptions = {}) => createFetch({
-    ...globalOptions,
-    ...customGlobalOptions,
-    defaults: {
-      ...globalOptions.defaults,
-      ...customGlobalOptions.defaults,
-      ...defaultOptions
-    }
-  });
-  return $fetch;
-}
-
-const _globalThis = (function() {
-  if (typeof globalThis !== "undefined") {
-    return globalThis;
-  }
-  if (typeof self !== "undefined") {
-    return self;
-  }
-  if (typeof window !== "undefined") {
-    return window;
-  }
-  if (typeof global !== "undefined") {
-    return global;
-  }
-  throw new Error("unable to locate global object");
-})();
-const fetch = _globalThis.fetch ? (...args) => _globalThis.fetch(...args) : () => Promise.reject(new Error("[ofetch] global.fetch is not supported!"));
-const Headers = _globalThis.Headers;
-const AbortController = _globalThis.AbortController;
-const ofetch = createFetch({ fetch, Headers, AbortController });
-
-class TemplatesClient {
-  fetch;
-  baseURL;
-  language;
-  logger = consola.withTag("templates-client");
-  constructor(config = {}) {
-    this.baseURL = config.baseURL || CLOUD_ENDPOINTS.MAIN.BASE_URL;
-    this.language = config.language || "en";
-    this.fetch = ofetch.create({
-      baseURL: this.baseURL,
-      timeout: config.timeout || 1e4,
-      headers: {
-        "User-Agent": "CCJK/8.2.0"
-      },
-      retry: 2
-    });
-  }
-  // ==========================================================================
-  // Single Template
-  // ==========================================================================
-  /**
-   * Get a single template by ID
-   */
-  async getTemplate(templateId) {
-    try {
-      this.logger.debug(`Fetching template: ${templateId}`);
-      const response = await this.fetch(
-        `/api/v8/templates/${encodeURIComponent(templateId)}`
-      );
-      if (response.code === 200 && response.data) {
-        return response.data;
-      }
-      return null;
-    } catch (error) {
-      this.logger.warn(`Failed to fetch template ${templateId}:`, error);
-      return null;
-    }
-  }
-  // ==========================================================================
-  // Batch Templates
-  // ==========================================================================
-  /**
-   * Batch get templates by IDs
-   */
-  async getTemplates(ids, language) {
-    try {
-      this.logger.debug(`Batch fetching ${ids.length} templates`);
-      const response = await this.fetch(
-        "/api/v8/templates/batch",
-        {
-          method: "POST",
-          body: {
-            ids,
-            language: language || this.language,
-            includeStats: true
-          }
-        }
-      );
-      return {
-        requestId: response.requestId || "",
-        templates: response.templates || {},
-        notFound: response.notFound || [],
-        stats: response.stats
-      };
-    } catch (error) {
-      this.logger.warn("Failed to batch fetch templates:", error);
-      return {
-        requestId: "",
-        templates: {},
-        notFound: ids
-      };
-    }
-  }
-  // ==========================================================================
-  // Search & List
-  // ==========================================================================
-  /**
-   * Search templates
-   */
-  async searchTemplates(query, params = {}) {
-    try {
-      this.logger.debug(`Searching templates: ${query}`);
-      const searchParams = this.buildSearchParams({ ...params, query });
-      const response = await this.fetch(
-        `/api/v8/templates/search?${searchParams}`
-      );
-      if (response.code === 200 && response.data) {
-        return response.data;
-      }
-      return { items: [], total: 0, limit: 20, offset: 0 };
-    } catch (error) {
-      this.logger.warn("Failed to search templates:", error);
-      return { items: [], total: 0, limit: 20, offset: 0 };
-    }
-  }
-  /**
-   * List templates with filters
-   */
-  async listTemplates(params = {}) {
-    try {
-      this.logger.debug("Listing templates with params:", params);
-      const searchParams = this.buildSearchParams(params);
-      const response = await this.fetch(
-        `/api/v8/templates?${searchParams}`
-      );
-      if (response.code === 200 && response.data) {
-        return response.data;
-      }
-      return { items: [], total: 0, limit: 20, offset: 0 };
-    } catch (error) {
-      this.logger.warn("Failed to list templates:", error);
-      return { items: [], total: 0, limit: 20, offset: 0 };
-    }
-  }
-  // ==========================================================================
-  // Type-specific Methods
-  // ==========================================================================
-  /**
-   * Get templates by type
-   */
-  async getTemplatesByType(type, options = {}) {
-    const { items } = await this.listTemplates({
-      type,
-      category: options.category,
-      limit: options.limit || 50,
-      is_official: options.is_official
-    });
-    return items;
-  }
-  /**
-   * Get specialist agents
-   */
-  async getSpecialistAgents(category) {
-    return this.getTemplatesByType("agent", { category, limit: 50 });
-  }
-  /**
-   * Get official MCP servers
-   */
-  async getOfficialMcpServers() {
-    return this.getTemplatesByType("mcp", { is_official: true, limit: 50 });
-  }
-  /**
-   * Get skills by category
-   */
-  async getSkills(category) {
-    return this.getTemplatesByType("skill", { category, limit: 50 });
-  }
-  /**
-   * Get hooks by category
-   */
-  async getHooks(category) {
-    return this.getTemplatesByType("hook", { category, limit: 50 });
-  }
-  // ==========================================================================
-  // Featured & Popular
-  // ==========================================================================
-  /**
-   * Get featured templates
-   */
-  async getFeaturedTemplates(limit = 10) {
-    try {
-      const response = await this.fetch(
-        `/api/v8/templates/featured?limit=${limit}`
-      );
-      if (response.code === 200 && response.data) {
-        return response.data;
-      }
-      return [];
-    } catch (error) {
-      this.logger.warn("Failed to fetch featured templates:", error);
-      return [];
-    }
-  }
-  /**
-   * Get popular templates
-   */
-  async getPopularTemplates(limit = 20) {
-    try {
-      const response = await this.fetch(
-        `/api/v8/templates/popular?limit=${limit}`
-      );
-      if (response.code === 200 && response.data) {
-        return response.data;
-      }
-      return [];
-    } catch (error) {
-      this.logger.warn("Failed to fetch popular templates:", error);
-      return [];
-    }
-  }
-  // ==========================================================================
-  // Categories
-  // ==========================================================================
-  /**
-   * Get all categories
-   */
-  async getCategories() {
-    try {
-      const response = await this.fetch(
-        "/api/v8/templates/categories"
-      );
-      if (response.code === 200 && response.data) {
-        return response.data;
-      }
-      return [];
-    } catch (error) {
-      this.logger.warn("Failed to fetch categories:", error);
-      return [];
-    }
-  }
-  // ==========================================================================
-  // Download Tracking
-  // ==========================================================================
-  /**
-   * Track template download
-   */
-  async trackDownload(templateId) {
-    try {
-      const response = await this.fetch(
-        `/api/v8/templates/${encodeURIComponent(templateId)}/download`,
-        { method: "POST" }
-      );
-      return response.code === 200;
-    } catch (error) {
-      this.logger.warn(`Failed to track download for ${templateId}:`, error);
-      return false;
-    }
-  }
-  // ==========================================================================
-  // Helpers
-  // ==========================================================================
-  /**
-   * Build search params string
-   */
-  buildSearchParams(params) {
-    const searchParams = new URLSearchParams();
-    if (params.query)
-      searchParams.set("query", params.query);
-    if (params.type)
-      searchParams.set("type", params.type);
-    if (params.category)
-      searchParams.set("category", params.category);
-    if (params.tags?.length)
-      searchParams.set("tags", params.tags.join(","));
-    if (params.is_official !== void 0)
-      searchParams.set("is_official", String(params.is_official));
-    if (params.is_featured !== void 0)
-      searchParams.set("is_featured", String(params.is_featured));
-    if (params.is_verified !== void 0)
-      searchParams.set("is_verified", String(params.is_verified));
-    if (params.sortBy)
-      searchParams.set("sortBy", params.sortBy);
-    if (params.order)
-      searchParams.set("order", params.order);
-    if (params.limit)
-      searchParams.set("limit", String(params.limit));
-    if (params.offset)
-      searchParams.set("offset", String(params.offset));
-    return searchParams.toString();
-  }
-  /**
-   * Extract localized name from template
-   */
-  getLocalizedName(template, lang) {
-    const language = lang || this.language;
-    return language === "zh-CN" && template.name_zh_cn ? template.name_zh_cn : template.name_en;
-  }
-  /**
-   * Extract localized description from template
-   */
-  getLocalizedDescription(template, lang) {
-    const language = lang || this.language;
-    return language === "zh-CN" && template.description_zh_cn ? template.description_zh_cn : template.description_en || "";
-  }
-}
-let templatesClientInstance = null;
-function getTemplatesClient(config) {
-  if (!templatesClientInstance) {
-    templatesClientInstance = new TemplatesClient(config);
-  }
-  return templatesClientInstance;
-}
-function createTemplatesClient(config) {
-  return new TemplatesClient(config);
-}
-
-export { ProjectAnalyzer as P, TemplatesClient as T, analyzeProject as a, createTemplatesClient as b, consola as c, analyzeDependencies$1 as d, detectProject as e, detectProjectType as f, getTemplatesClient as g, batchAnalyze as h, ofetch as o };