ccjk 12.0.7 → 12.0.8

package/dist/shared/ccjk.BRZ9ww8S.mjs

@@ -1,142 +0,0 @@
-import fs__default, { promises } from 'node:fs';
-import path__default from 'node:path';
-import process__default from 'node:process';
-import { globby } from 'globby';
-
-function isPathInside(childPath, parentPath) {
-	const relation = path__default.relative(parentPath, childPath);
-
-	return Boolean(
-		relation &&
-		relation !== '..' &&
-		!relation.startsWith(`..${path__default.sep}`) &&
-		relation !== path__default.resolve(childPath)
-	);
-}
-
-async function trash(paths, options = {}) {
-	paths = [paths].flat().map(String);
-
-	const {glob = true} = options;
-
-	if (glob) {
-		// Normalize '/**' patterns to their base directory
-		const patterns = paths.map(pattern => {
-			const isNegated = pattern.startsWith('!');
-			const body = isNegated ? pattern.slice(1) : pattern;
-			const normalized = body.endsWith('/**') ? path__default.dirname(body) : body;
-			return isNegated ? '!' + normalized : normalized;
-		});
-
-		const matches = await globby(patterns, {
-			expandDirectories: false,
-			onlyFiles: false,
-			followSymbolicLinks: false,
-		});
-
-		// Include literal paths that exist
-		const literals = await Promise.all(paths.map(async p => {
-			try {
-				await fs__default.promises.lstat(p);
-				return p;
-			} catch {
-				return null;
-			}
-		}));
-
-		paths = [...new Set([...matches, ...literals.filter(Boolean)])];
-	}
-
-	// Filter out nested paths and resolve
-	const pathChecks = await Promise.all(paths.map(async filePath => {
-		// Skip if nested in another path
-		if (paths.some(p => p !== filePath && isPathInside(filePath, p))) {
-			return;
-		}
-
-		try {
-			await fs__default.promises.lstat(filePath);
-			return path__default.resolve(filePath);
-		} catch (error) {
-			// Ignore non-existent paths
-			if (error.code !== 'ENOENT') {
-				throw error;
-			}
-		}
-	}));
-
-	const resolvedPaths = pathChecks.filter(Boolean);
-
-	if (resolvedPaths.length === 0) {
-		return;
-	}
-
-	const {default: trashFunction} = await platformSpecificImplementation();
-	return trashFunction(resolvedPaths);
-}
-
-// We use static imports so it can be statically analyzed.
-async function platformSpecificImplementation() {
-	switch (process__default.platform) {
-		case 'darwin': {
-			return import('../chunks/macos.mjs');
-		}
-
-		case 'win32': {
-			return import('../chunks/windows.mjs');
-		}
-
-		case 'linux': {
-			const {isWsl} = await import('../chunks/index13.mjs');
-			if (isWsl) {
-				return import('../chunks/wsl.mjs');
-			}
-
-			return import('../chunks/linux.mjs');
-		}
-
-		default: {
-			return import('../chunks/linux.mjs');
-		}
-	}
-}
-
-async function pathExists(p) {
-  try {
-    await promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function moveToTrash(paths) {
-  const pathArray = Array.isArray(paths) ? paths : [paths];
-  const results = [];
-  for (const path of pathArray) {
-    try {
-      const exists = await pathExists(path);
-      if (!exists) {
-        results.push({
-          success: false,
-          path,
-          error: "Path does not exist"
-        });
-        continue;
-      }
-      await trash(path);
-      results.push({
-        success: true,
-        path
-      });
-    } catch (error) {
-      results.push({
-        success: false,
-        path,
-        error: error.message || "Unknown error occurred"
-      });
-    }
-  }
-  return results;
-}
-
-export { moveToTrash as m };

package/dist/shared/ccjk.BoApaI4j.mjs

@@ -1,28 +0,0 @@
-import { webcrypto } from 'node:crypto';
-
-const urlAlphabet =
-  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
-
-const POOL_SIZE_MULTIPLIER = 128;
-let pool, poolOffset;
-function fillPool(bytes) {
-  if (!pool || pool.length < bytes) {
-    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
-    webcrypto.getRandomValues(pool);
-    poolOffset = 0;
-  } else if (poolOffset + bytes > pool.length) {
-    webcrypto.getRandomValues(pool);
-    poolOffset = 0;
-  }
-  poolOffset += bytes;
-}
-function nanoid(size = 21) {
-  fillPool((size |= 0));
-  let id = '';
-  for (let i = poolOffset - size; i < poolOffset; i++) {
-    id += urlAlphabet[pool[i] & 63];
-  }
-  return id
-}
-
-export { nanoid as n };

package/dist/shared/ccjk.BrPUmTqm.mjs

@@ -1,266 +0,0 @@
-import { execSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import process__default from 'node:process';
-import { j as join } from './ccjk.bQ7Dh1g4.mjs';
-
-function scanProject(cwd) {
-  const root = cwd || process__default.cwd();
-  const pkg = readPackageJson(root);
-  const language = detectLanguage(root, pkg);
-  const secondaryLanguages = detectSecondaryLanguages(root, pkg, language);
-  return {
-    language,
-    secondaryLanguages,
-    framework: detectFramework(root, pkg),
-    testRunner: detectTestRunner(root, pkg),
-    packageManager: detectPackageManager(root),
-    linter: detectLinter(root, pkg),
-    formatter: detectFormatter(root, pkg),
-    database: detectDatabase(root),
-    runtime: detectRuntime(),
-    isMonorepo: detectMonorepo(root, pkg),
-    usesConventionalCommits: detectConventionalCommits(root, pkg),
-    hasGitHooks: detectGitHooks(root, pkg),
-    hasDocker: existsSync(join(root, "Dockerfile")) || existsSync(join(root, "docker-compose.yml")) || existsSync(join(root, "docker-compose.yaml")),
-    hasCI: detectCI(root),
-    root
-  };
-}
-function readPackageJson(root) {
-  const p = join(root, "package.json");
-  if (!existsSync(p)) return null;
-  try {
-    return JSON.parse(readFileSync(p, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function hasDep(pkg, name) {
-  if (!pkg) return false;
-  return !!(pkg.dependencies?.[name] || pkg.devDependencies?.[name] || pkg.peerDependencies?.[name]);
-}
-function detectLanguage(root, pkg) {
-  if (existsSync(join(root, "tsconfig.json")) || hasDep(pkg, "typescript")) {
-    return "typescript";
-  }
-  if (existsSync(join(root, "pyproject.toml")) || existsSync(join(root, "setup.py")) || existsSync(join(root, "requirements.txt")) || existsSync(join(root, "Pipfile"))) {
-    return "python";
-  }
-  if (existsSync(join(root, "go.mod"))) {
-    return "go";
-  }
-  if (existsSync(join(root, "Cargo.toml"))) {
-    return "rust";
-  }
-  if (existsSync(join(root, "pom.xml")) || existsSync(join(root, "build.gradle")) || existsSync(join(root, "build.gradle.kts"))) {
-    return "java";
-  }
-  if (existsSync(join(root, "Gemfile"))) {
-    return "ruby";
-  }
-  if (existsSync(join(root, "composer.json"))) {
-    return "php";
-  }
-  if (existsSync(join(root, "Package.swift"))) {
-    return "swift";
-  }
-  if (existsSync(join(root, "*.csproj")) || existsSync(join(root, "*.sln"))) {
-    return "csharp";
-  }
-  if (pkg) {
-    return "javascript";
-  }
-  return "unknown";
-}
-function detectSecondaryLanguages(root, pkg, primary) {
-  const langs = [];
-  const checks = [
-    ["typescript", () => existsSync(join(root, "tsconfig.json")) || hasDep(pkg, "typescript")],
-    ["javascript", () => !!pkg],
-    ["python", () => existsSync(join(root, "pyproject.toml")) || existsSync(join(root, "requirements.txt"))],
-    ["go", () => existsSync(join(root, "go.mod"))],
-    ["rust", () => existsSync(join(root, "Cargo.toml"))]
-  ];
-  for (const [lang, check] of checks) {
-    if (lang !== primary && check()) langs.push(lang);
-  }
-  return langs;
-}
-function detectFramework(root, pkg) {
-  if (!pkg) {
-    if (existsSync(join(root, "pyproject.toml"))) {
-      const content = safeRead(join(root, "pyproject.toml"));
-      if (content.includes("fastapi")) return "fastapi";
-      if (content.includes("django")) return "django";
-      if (content.includes("flask")) return "flask";
-    }
-    if (existsSync(join(root, "requirements.txt"))) {
-      const content = safeRead(join(root, "requirements.txt"));
-      if (content.includes("fastapi")) return "fastapi";
-      if (content.includes("django")) return "django";
-      if (content.includes("flask")) return "flask";
-    }
-    return "none";
-  }
-  if (hasDep(pkg, "next")) return "next";
-  if (hasDep(pkg, "nuxt")) return "nuxt";
-  if (hasDep(pkg, "@angular/core")) return "angular";
-  if (hasDep(pkg, "svelte") || hasDep(pkg, "@sveltejs/kit")) return "svelte";
-  if (hasDep(pkg, "@nestjs/core")) return "nest";
-  if (hasDep(pkg, "@tauri-apps/api") || hasDep(pkg, "@tauri-apps/cli")) return "tauri";
-  if (hasDep(pkg, "electron")) return "electron";
-  if (hasDep(pkg, "vue")) return "vue";
-  if (hasDep(pkg, "react")) return "react";
-  if (hasDep(pkg, "fastify")) return "fastify";
-  if (hasDep(pkg, "express")) return "express";
-  return "none";
-}
-function detectTestRunner(root, pkg) {
-  if (hasDep(pkg, "vitest")) return "vitest";
-  if (hasDep(pkg, "jest") || hasDep(pkg, "@jest/core")) return "jest";
-  if (hasDep(pkg, "mocha")) return "mocha";
-  if (existsSync(join(root, "pytest.ini")) || existsSync(join(root, "conftest.py"))) return "pytest";
-  if (existsSync(join(root, "pyproject.toml"))) {
-    const content = safeRead(join(root, "pyproject.toml"));
-    if (content.includes("[tool.pytest") || content.includes("pytest")) return "pytest";
-  }
-  if (existsSync(join(root, "go.mod"))) return "go-test";
-  if (existsSync(join(root, "Cargo.toml"))) return "cargo-test";
-  if (existsSync(join(root, "pom.xml")) || existsSync(join(root, "build.gradle"))) return "junit";
-  if (existsSync(join(root, "Gemfile"))) {
-    const content = safeRead(join(root, "Gemfile"));
-    if (content.includes("rspec")) return "rspec";
-  }
-  if (hasDep(pkg, "phpunit") || existsSync(join(root, "phpunit.xml"))) return "phpunit";
-  return "none";
-}
-function detectPackageManager(root) {
-  if (existsSync(join(root, "pnpm-lock.yaml")) || existsSync(join(root, "pnpm-workspace.yaml"))) return "pnpm";
-  if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock"))) return "bun";
-  if (existsSync(join(root, "yarn.lock"))) return "yarn";
-  if (existsSync(join(root, "package-lock.json"))) return "npm";
-  if (existsSync(join(root, "poetry.lock"))) return "poetry";
-  if (existsSync(join(root, "Pipfile.lock")) || existsSync(join(root, "requirements.txt"))) return "pip";
-  if (existsSync(join(root, "Cargo.lock"))) return "cargo";
-  if (existsSync(join(root, "go.sum"))) return "go";
-  if (existsSync(join(root, "pom.xml"))) return "maven";
-  if (existsSync(join(root, "build.gradle")) || existsSync(join(root, "build.gradle.kts"))) return "gradle";
-  return "none";
-}
-function detectLinter(root, pkg) {
-  if (hasDep(pkg, "@biomejs/biome") || existsSync(join(root, "biome.json")) || existsSync(join(root, "biome.jsonc"))) return "biome";
-  if (hasDep(pkg, "oxlint") || hasDep(pkg, "oxc")) return "oxlint";
-  if (hasDep(pkg, "eslint") || existsSync(join(root, ".eslintrc.json")) || existsSync(join(root, ".eslintrc.js")) || existsSync(join(root, "eslint.config.js")) || existsSync(join(root, "eslint.config.mjs"))) return "eslint";
-  if (existsSync(join(root, "ruff.toml")) || existsSync(join(root, ".ruff.toml"))) return "ruff";
-  if (existsSync(join(root, "pyproject.toml"))) {
-    const content = safeRead(join(root, "pyproject.toml"));
-    if (content.includes("[tool.ruff")) return "ruff";
-    if (content.includes("[tool.pylint") || content.includes("pylint")) return "pylint";
-    if (content.includes("flake8")) return "flake8";
-  }
-  if (existsSync(join(root, ".golangci.yml")) || existsSync(join(root, ".golangci.yaml"))) return "golangci-lint";
-  if (existsSync(join(root, "Cargo.toml"))) return "clippy";
-  if (existsSync(join(root, ".rubocop.yml"))) return "rubocop";
-  return "none";
-}
-function detectFormatter(root, pkg) {
-  if (hasDep(pkg, "@biomejs/biome") || existsSync(join(root, "biome.json"))) return "biome";
-  if (hasDep(pkg, "prettier") || existsSync(join(root, ".prettierrc")) || existsSync(join(root, ".prettierrc.json")) || existsSync(join(root, "prettier.config.js")) || existsSync(join(root, "prettier.config.mjs"))) return "prettier";
-  if (existsSync(join(root, "pyproject.toml"))) {
-    const content = safeRead(join(root, "pyproject.toml"));
-    if (content.includes("[tool.ruff") && content.includes("format")) return "ruff";
-    if (content.includes("[tool.black") || content.includes("black")) return "black";
-  }
-  if (existsSync(join(root, "go.mod"))) return "gofmt";
-  if (existsSync(join(root, "Cargo.toml"))) return "rustfmt";
-  return "none";
-}
-function detectDatabase(root) {
-  for (const f of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
-    const content = safeRead(join(root, f));
-    if (!content) continue;
-    if (content.includes("postgres")) return "postgresql";
-    if (content.includes("mysql") || content.includes("mariadb")) return "mysql";
-    if (content.includes("mongo")) return "mongodb";
-    if (content.includes("redis")) return "redis";
-  }
-  for (const f of [".env", ".env.local", ".env.development"]) {
-    const content = safeRead(join(root, f));
-    if (!content) continue;
-    if (content.includes("postgres")) return "postgresql";
-    if (content.includes("mysql")) return "mysql";
-    if (content.includes("mongodb") || content.includes("mongo+srv")) return "mongodb";
-    if (content.includes("redis://")) return "redis";
-  }
-  if (existsSync(join(root, "prisma", "schema.prisma"))) {
-    const content = safeRead(join(root, "prisma", "schema.prisma"));
-    if (content.includes("postgresql")) return "postgresql";
-    if (content.includes("mysql")) return "mysql";
-    if (content.includes("sqlite")) return "sqlite";
-    if (content.includes("mongodb")) return "mongodb";
-  }
-  for (const f of ["*.db", "*.sqlite", "*.sqlite3"]) {
-    if (existsSync(join(root, "db.sqlite")) || existsSync(join(root, "database.sqlite")) || existsSync(join(root, "dev.db"))) {
-      return "sqlite";
-    }
-  }
-  return "none";
-}
-function detectRuntime() {
-  const isContainer = existsSync("/.dockerenv") || existsSync("/run/.containerenv") || safeRead("/proc/1/cgroup").includes("docker");
-  const isSSH = !!process__default.env.SSH_CLIENT || !!process__default.env.SSH_TTY || !!process__default.env.SSH_CONNECTION;
-  const isCI = !!(process__default.env.CI || process__default.env.GITHUB_ACTIONS || process__default.env.GITLAB_CI || process__default.env.JENKINS_URL || process__default.env.CIRCLECI || process__default.env.TRAVIS || process__default.env.BUILDKITE);
-  const isWSL = safeRead("/proc/version").toLowerCase().includes("microsoft");
-  const isMac = process__default.platform === "darwin";
-  const hasDisplay = !!(process__default.env.DISPLAY || process__default.env.WAYLAND_DISPLAY || process__default.env.TERM_PROGRAM);
-  const isHeadless = !isMac && !hasDisplay && !isWSL;
-  const hasBrowser = isMac || hasDisplay || isWSL;
-  return {
-    isContainer,
-    isHeadless,
-    isSSH,
-    isCI,
-    isWSL,
-    hasBrowser
-  };
-}
-function detectMonorepo(root, pkg) {
-  if (pkg?.workspaces) return true;
-  if (existsSync(join(root, "pnpm-workspace.yaml"))) return true;
-  if (existsSync(join(root, "lerna.json"))) return true;
-  if (existsSync(join(root, "nx.json"))) return true;
-  if (existsSync(join(root, "turbo.json"))) return true;
-  return false;
-}
-function detectConventionalCommits(root, pkg) {
-  if (existsSync(join(root, ".commitlintrc.json")) || existsSync(join(root, ".commitlintrc.js")) || existsSync(join(root, "commitlint.config.js")) || existsSync(join(root, "commitlint.config.mjs"))) return true;
-  if (hasDep(pkg, "@commitlint/cli") || hasDep(pkg, "@commitlint/config-conventional")) return true;
-  try {
-    const log = execSync("git log --oneline -10 2>/dev/null", { cwd: root, encoding: "utf-8", timeout: 3e3 });
-    const conventionalPattern = /^[a-f0-9]+ (feat|fix|chore|docs|style|refactor|perf|test|build|ci|revert)(\(.+\))?[!]?:/m;
-    const lines = log.trim().split("\n").filter(Boolean);
-    const matches = lines.filter((l) => conventionalPattern.test(l));
-    return lines.length > 0 && matches.length / lines.length > 0.5;
-  } catch {
-    return false;
-  }
-}
-function detectGitHooks(root, pkg) {
-  if (existsSync(join(root, ".husky"))) return true;
-  if (hasDep(pkg, "husky") || hasDep(pkg, "simple-git-hooks") || hasDep(pkg, "lefthook")) return true;
-  if (existsSync(join(root, ".lefthook.yml"))) return true;
-  return false;
-}
-function detectCI(root) {
-  return existsSync(join(root, ".github", "workflows")) || existsSync(join(root, ".gitlab-ci.yml")) || existsSync(join(root, ".circleci")) || existsSync(join(root, "Jenkinsfile")) || existsSync(join(root, ".travis.yml")) || existsSync(join(root, "bitbucket-pipelines.yml"));
-}
-function safeRead(path) {
-  try {
-    if (!existsSync(path)) return "";
-    return readFileSync(path, "utf-8");
-  } catch {
-    return "";
-  }
-}
-
-export { scanProject as s };

package/dist/shared/ccjk.BtB1e5jm.mjs

@@ -1,171 +0,0 @@
-import { CLOUD_ENDPOINTS } from '../chunks/constants.mjs';
-import { C as CloudApiClient } from './ccjk.D6ycHbak.mjs';
-
-const ROUTE_MAP = {
-  // Analysis endpoints
-  "analysis.projects": {
-    v1: "/api/v1/analysis/projects",
-    v8: "/api/v8/analyze"
-    // Legacy v8 path
-  },
-  // Template endpoints
-  "templates.get": {
-    v1: "/api/v1/templates/:id"
-  },
-  "templates.batch": {
-    v1: "/api/v1/templates/batch",
-    v8: "/api/v8/templates"
-    // Legacy v8 batch endpoint
-  },
-  // Telemetry endpoints
-  "telemetry.installation": {
-    v1: "/api/v1/telemetry/installation"
-  },
-  // Health check
-  "health": {
-    v1: "/api/v1/health"
-  },
-  // Plugin endpoints
-  "plugins.list": {
-    v1: "/v1/plugins/list"
-  },
-  "plugins.recommend": {
-    v1: "/v1/plugins/recommend"
-  },
-  // Skills endpoints
-  "skills.list": {
-    v1: "/v1/skills/list"
-  },
-  "skills.upload": {
-    v1: "/v1/skills/upload"
-  },
-  "skills.download": {
-    v1: "/v1/skills/download"
-  },
-  // Notification endpoints (remote API)
-  "notifications.bind": {
-    v1: "/bind/use"
-  },
-  "notifications.send": {
-    v1: "/notify"
-  },
-  "notifications.poll": {
-    v1: "/reply/poll"
-  }
-};
-class CloudApiGateway {
-  mainClient;
-  pluginsClient;
-  remoteClient;
-  config;
-  constructor(config = {}) {
-    this.config = {
-      timeout: config.timeout || 3e4,
-      authToken: config.authToken || "",
-      enableVersionFallback: config.enableVersionFallback ?? true
-    };
-    this.mainClient = new CloudApiClient({
-      baseUrl: CLOUD_ENDPOINTS.MAIN.BASE_URL,
-      timeout: this.config.timeout,
-      authToken: this.config.authToken
-    });
-    this.pluginsClient = new CloudApiClient({
-      baseUrl: CLOUD_ENDPOINTS.PLUGINS.BASE_URL,
-      timeout: this.config.timeout,
-      authToken: this.config.authToken
-    });
-    this.remoteClient = new CloudApiClient({
-      baseUrl: CLOUD_ENDPOINTS.REMOTE.BASE_URL,
-      timeout: this.config.timeout,
-      authToken: this.config.authToken
-    });
-  }
-  /**
-   * Make a request through the gateway
-   *
-   * @param route - Semantic route identifier
-   * @param options - Request options
-   * @returns API response
-   */
-  async request(route, options) {
-    const routeConfig = ROUTE_MAP[route];
-    if (!routeConfig) {
-      return {
-        success: false,
-        error: `Unknown route: ${route}`,
-        code: "INVALID_ROUTE"
-      };
-    }
-    const client = this.getClientForRoute(route);
-    const version = options.preferVersion || "v1";
-    const path = this.resolvePath(routeConfig, version);
-    const response = await client.request(path, {
-      method: options.method,
-      body: options.body,
-      query: options.query,
-      authToken: options.authToken || this.config.authToken,
-      timeout: options.timeout || this.config.timeout
-    });
-    if (!response.success && version === "v1" && routeConfig.v8 && this.config.enableVersionFallback) {
-      const v8Path = routeConfig.v8;
-      return client.request(v8Path, {
-        method: options.method,
-        body: options.body,
-        query: options.query,
-        authToken: options.authToken || this.config.authToken,
-        timeout: options.timeout || this.config.timeout
-      });
-    }
-    return response;
-  }
-  /**
-   * Set authentication token for all clients
-   */
-  setAuthToken(token) {
-    this.config.authToken = token;
-    this.mainClient.setAuthToken(token);
-    this.pluginsClient.setAuthToken(token);
-    this.remoteClient.setAuthToken(token);
-  }
-  /**
-   * Get current configuration
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  // ==========================================================================
-  // Private Methods
-  // ==========================================================================
-  /**
-   * Get appropriate client for a route
-   */
-  getClientForRoute(route) {
-    if (route.startsWith("plugins.")) {
-      return this.pluginsClient;
-    }
-    if (route.startsWith("notifications.")) {
-      return this.remoteClient;
-    }
-    if (route.startsWith("skills.")) {
-      return this.pluginsClient;
-    }
-    return this.mainClient;
-  }
-  /**
-   * Resolve path for specific version
-   */
-  resolvePath(routeConfig, version) {
-    return version === "v8" && routeConfig.v8 ? routeConfig.v8 : routeConfig.v1;
-  }
-}
-function createGateway(config) {
-  return new CloudApiGateway(config);
-}
-function createDefaultGateway() {
-  return new CloudApiGateway({
-    timeout: 3e4,
-    enableVersionFallback: true
-  });
-}
-
-export { createGateway as a, createDefaultGateway as c };