ccjk 2.3.2 → 2.4.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ccjk",
   "type": "module",
-  "version": "2.3.2",
+  "version": "2.4.2",
   "packageManager": "pnpm@10.17.1",
   "description": "Claude Code JinKu - Advanced AI-powered development assistant with skills, agents, and LLM-driven audit",
   "author": {
@@ -121,8 +121,10 @@
     "docs:preview": "pnpm -F @ccjk/docs preview"
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.52.0",
     "@iarna/toml": "^2.2.5",
     "@types/semver": "^7.7.1",
+    "@types/tar": "^6.1.13",
     "ansis": "^4.1.0",
     "cac": "^6.7.14",
     "chalk": "^5.6.2",
@@ -141,6 +143,7 @@
     "pathe": "^2.0.3",
     "semver": "^7.7.2",
     "smol-toml": "^1.4.2",
+    "tar": "^7.5.2",
     "tinyexec": "^1.0.1",
     "trash": "^10.0.0"
   },

package/dist/shared/ccjk.Bi-m3LKY.mjs

@@ -1,357 +0,0 @@
-import { existsSync } from 'node:fs';
-import { readFile, mkdir, rm } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'pathe';
-import { i18n } from '../chunks/index2.mjs';
-import { writeFileAtomicAsync } from '../chunks/fs-operations.mjs';
-
-const DEFAULT_REGISTRY_URL = "https://registry.ccjk.dev/v1";
-const DEFAULT_CACHE_CONFIG = {
-  cacheDir: join(homedir(), ".ccjk", "cache"),
-  ttl: 3600,
-  // 1 hour
-  enabled: true
-};
-const BUILTIN_PACKAGES = [
-  // Built-in packages will be added here in future versions
-];
-function getCacheFilePath(cacheDir) {
-  return join(cacheDir, "registry-cache.json");
-}
-async function isCacheValid(cacheDir, ttl) {
-  const cachePath = getCacheFilePath(cacheDir);
-  if (!existsSync(cachePath)) {
-    return false;
-  }
-  try {
-    const content = await readFile(cachePath, "utf-8");
-    const cache = JSON.parse(content);
-    const cacheTime = new Date(cache.lastUpdated).getTime();
-    const now = Date.now();
-    return now - cacheTime < ttl * 1e3;
-  } catch {
-    return false;
-  }
-}
-async function readCachedRegistry(cacheDir) {
-  const cachePath = getCacheFilePath(cacheDir);
-  if (!existsSync(cachePath)) {
-    return null;
-  }
-  try {
-    const content = await readFile(cachePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-async function writeCacheRegistry(cacheDir, registry) {
-  await mkdir(cacheDir, { recursive: true });
-  const cachePath = getCacheFilePath(cacheDir);
-  await writeFileAtomicAsync(cachePath, JSON.stringify(registry, null, 2));
-}
-async function fetchRemoteRegistry(registryUrl = DEFAULT_REGISTRY_URL, timeout = 3e4) {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeout);
-  try {
-    const response = await fetch(`${registryUrl}/registry.json`, {
-      signal: controller.signal,
-      headers: {
-        "Accept": "application/json",
-        "User-Agent": "ccjk-cli"
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-    return await response.json();
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-async function getRegistry(options = {}) {
-  const cacheConfig = { ...DEFAULT_CACHE_CONFIG, ...options.cache };
-  const registryUrl = options.registryUrl || DEFAULT_REGISTRY_URL;
-  if (cacheConfig.enabled && !options.forceRefresh) {
-    const cacheValid = await isCacheValid(cacheConfig.cacheDir, cacheConfig.ttl);
-    if (cacheValid) {
-      const cached = await readCachedRegistry(cacheConfig.cacheDir);
-      if (cached) {
-        return cached;
-      }
-    }
-  }
-  try {
-    const registry = await fetchRemoteRegistry(registryUrl);
-    if (cacheConfig.enabled) {
-      await writeCacheRegistry(cacheConfig.cacheDir, registry);
-    }
-    return registry;
-  } catch {
-    const cached = await readCachedRegistry(cacheConfig.cacheDir);
-    if (cached) {
-      return cached;
-    }
-    return {
-      version: "1.0.0",
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      url: registryUrl,
-      packages: BUILTIN_PACKAGES,
-      categories: {
-        "plugin": 0,
-        "skill": 0,
-        "workflow": 0,
-        "agent": 0,
-        "mcp-service": 0,
-        "output-style": 0,
-        "bundle": 0
-      }
-    };
-  }
-}
-async function searchPackages(options = {}) {
-  const registry = await getRegistry();
-  let packages = [...registry.packages];
-  if (options.query) {
-    const query = options.query.toLowerCase();
-    packages = packages.filter(
-      (pkg) => pkg.name.toLowerCase().includes(query) || pkg.id.toLowerCase().includes(query) || pkg.keywords.some((k) => k.toLowerCase().includes(query)) || Object.values(pkg.description).some((d) => d.toLowerCase().includes(query))
-    );
-  }
-  if (options.category) {
-    packages = packages.filter((pkg) => pkg.category === options.category);
-  }
-  if (options.author) {
-    packages = packages.filter(
-      (pkg) => pkg.author.toLowerCase().includes(options.author.toLowerCase())
-    );
-  }
-  if (options.verified) {
-    packages = packages.filter((pkg) => pkg.verified === options.verified);
-  }
-  if (options.keywords?.length) {
-    packages = packages.filter(
-      (pkg) => options.keywords.some((k) => pkg.keywords.includes(k))
-    );
-  }
-  if (options.minRating) {
-    packages = packages.filter((pkg) => pkg.rating >= options.minRating);
-  }
-  if (options.supportedTool) {
-    packages = packages.filter(
-      (pkg) => pkg.supportedTools?.includes(options.supportedTool)
-    );
-  }
-  const sortBy = options.sortBy || "downloads";
-  const sortDir = options.sortDir || "desc";
-  packages.sort((a, b) => {
-    let comparison = 0;
-    switch (sortBy) {
-      case "downloads":
-        comparison = a.downloads - b.downloads;
-        break;
-      case "rating":
-        comparison = a.rating - b.rating;
-        break;
-      case "updated":
-        comparison = new Date(a.updatedAt).getTime() - new Date(b.updatedAt).getTime();
-        break;
-      case "created":
-        comparison = new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
-        break;
-      case "name":
-        comparison = a.name.localeCompare(b.name);
-        break;
-    }
-    return sortDir === "desc" ? -comparison : comparison;
-  });
-  const total = packages.length;
-  const offset = options.offset || 0;
-  const limit = options.limit || 20;
-  packages = packages.slice(offset, offset + limit);
-  return {
-    packages,
-    total,
-    offset,
-    limit,
-    query: options.query,
-    filters: options
-  };
-}
-async function getPackage(packageId) {
-  const registry = await getRegistry();
-  return registry.packages.find((pkg) => pkg.id === packageId) || null;
-}
-
-const DEFAULT_INSTALL_DIR = join(homedir(), ".ccjk", "packages");
-const INSTALLED_MANIFEST = join(homedir(), ".ccjk", "installed-packages.json");
-async function getInstalledPackages() {
-  if (!existsSync(INSTALLED_MANIFEST)) {
-    return [];
-  }
-  try {
-    const content = await readFile(INSTALLED_MANIFEST, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return [];
-  }
-}
-async function saveInstalledPackages(packages) {
-  const dir = join(homedir(), ".ccjk");
-  await mkdir(dir, { recursive: true });
-  await writeFileAtomicAsync(INSTALLED_MANIFEST, JSON.stringify(packages, null, 2));
-}
-async function isPackageInstalled(packageId) {
-  const installed = await getInstalledPackages();
-  return installed.some((pkg) => pkg.package.id === packageId);
-}
-async function installPackage(packageId, options = {}) {
-  const startTime = Date.now();
-  try {
-    const alreadyInstalled = await isPackageInstalled(packageId);
-    if (alreadyInstalled && !options.force) {
-      const pkg2 = await getPackage(packageId);
-      if (!pkg2) {
-        return {
-          success: false,
-          package: {},
-          error: i18n.t("marketplace:packageNotFound", { name: packageId })
-        };
-      }
-      return {
-        success: true,
-        package: pkg2,
-        alreadyInstalled: true,
-        durationMs: Date.now() - startTime
-      };
-    }
-    const pkg = await getPackage(packageId);
-    if (!pkg) {
-      return {
-        success: false,
-        package: {},
-        error: i18n.t("marketplace:packageNotFound", { name: packageId })
-      };
-    }
-    const warnings = [];
-    if (options.codeToolType && pkg.supportedTools) {
-      if (!pkg.supportedTools.includes(options.codeToolType)) {
-        warnings.push(
-          i18n.t("marketplace:incompatibleTool", {
-            tool: options.codeToolType,
-            supported: pkg.supportedTools.join(", ")
-          })
-        );
-      }
-    }
-    const targetDir = options.targetDir || DEFAULT_INSTALL_DIR;
-    const installPath = join(targetDir, pkg.id);
-    await mkdir(installPath, { recursive: true });
-    const installed = await getInstalledPackages();
-    const installedPackage = {
-      package: pkg,
-      path: installPath,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      source: "marketplace",
-      enabled: true
-    };
-    const existingIndex = installed.findIndex((p) => p.package.id === pkg.id);
-    if (existingIndex >= 0) {
-      installed[existingIndex] = installedPackage;
-    } else {
-      installed.push(installedPackage);
-    }
-    await saveInstalledPackages(installed);
-    return {
-      success: true,
-      package: pkg,
-      installedPath: installPath,
-      warnings: warnings.length > 0 ? warnings : void 0,
-      durationMs: Date.now() - startTime
-    };
-  } catch (error) {
-    return {
-      success: false,
-      package: {},
-      error: error instanceof Error ? error.message : String(error),
-      durationMs: Date.now() - startTime
-    };
-  }
-}
-async function uninstallPackage(packageId, options = {}) {
-  try {
-    const installed = await getInstalledPackages();
-    const pkg = installed.find((p) => p.package.id === packageId);
-    if (!pkg) {
-      return {
-        success: false,
-        packageId,
-        error: i18n.t("marketplace:packageNotInstalled", { name: packageId })
-      };
-    }
-    if (!options.force) {
-      const dependents = installed.filter(
-        (p) => p.package.dependencies && Object.keys(p.package.dependencies).includes(packageId)
-      );
-      if (dependents.length > 0) {
-        return {
-          success: false,
-          packageId,
-          error: i18n.t("marketplace:packageHasDependents", {
-            name: packageId,
-            dependents: dependents.map((p) => p.package.name).join(", ")
-          })
-        };
-      }
-    }
-    if (existsSync(pkg.path)) {
-      await rm(pkg.path, { recursive: true, force: true });
-    }
-    const updated = installed.filter((p) => p.package.id !== packageId);
-    await saveInstalledPackages(updated);
-    return {
-      success: true,
-      packageId
-    };
-  } catch (error) {
-    return {
-      success: false,
-      packageId,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function updatePackage(packageId) {
-  const uninstallResult = await uninstallPackage(packageId, { keepConfig: true });
-  if (!uninstallResult.success) {
-    return {
-      success: false,
-      package: {},
-      error: uninstallResult.error
-    };
-  }
-  return await installPackage(packageId, { force: true });
-}
-async function checkForUpdates() {
-  const installed = await getInstalledPackages();
-  const updates = [];
-  for (const installedPkg of installed) {
-    const latestPkg = await getPackage(installedPkg.package.id);
-    if (!latestPkg)
-      continue;
-    if (latestPkg.version !== installedPkg.package.version) {
-      updates.push({
-        id: installedPkg.package.id,
-        currentVersion: installedPkg.package.version,
-        latestVersion: latestPkg.version,
-        breaking: false,
-        // TODO: Implement semver comparison
-        changelog: latestPkg.changelog,
-        releaseDate: latestPkg.updatedAt
-      });
-    }
-  }
-  return updates;
-}
-
-export { getPackage as a, uninstallPackage as b, checkForUpdates as c, installPackage as d, getInstalledPackages as g, isPackageInstalled as i, searchPackages as s, updatePackage as u };