ccjk 14.2.2 → 15.0.0

package/dist/shared/ccjk.BnsY5WxD.mjs

@@ -1,171 +0,0 @@
-import { exec, spawn } from 'node:child_process';
-import { promisify } from 'node:util';
-
-const execAsync = promisify(exec);
-async function executeCommand(command, args = [], options = {}) {
-  try {
-    const fullCommand = buildCommand(command, args);
-    const execOptions = {
-      cwd: options.cwd,
-      env: { ...process.env, ...options.env },
-      timeout: options.timeout,
-      shell: typeof options.shell === "string" ? options.shell : options.shell ? "/bin/sh" : void 0,
-      encoding: options.encoding || "utf8",
-      maxBuffer: options.maxBuffer || 1024 * 1024 * 10
-      // 10MB default
-    };
-    const { stdout, stderr } = await execAsync(fullCommand, execOptions);
-    return {
-      success: true,
-      stdout: stdout.toString().trim(),
-      stderr: stderr.toString().trim(),
-      exitCode: 0
-    };
-  } catch (error) {
-    return {
-      success: false,
-      stdout: error.stdout?.toString().trim() || "",
-      stderr: error.stderr?.toString().trim() || "",
-      exitCode: error.code || 1,
-      error: error.message
-    };
-  }
-}
-function executeCommandStream(command, args = [], options = {}) {
-  return new Promise((resolve) => {
-    const spawnOptions = {
-      cwd: options.cwd,
-      env: { ...process.env, ...options.env },
-      shell: options.shell !== false
-    };
-    const child = spawn(command, args, spawnOptions);
-    let stdout = "";
-    let stderr = "";
-    child.stdout?.on("data", (data) => {
-      const text = data.toString();
-      stdout += text;
-      if (options.onStdout) {
-        options.onStdout(text);
-      }
-    });
-    child.stderr?.on("data", (data) => {
-      const text = data.toString();
-      stderr += text;
-      if (options.onStderr) {
-        options.onStderr(text);
-      }
-    });
-    child.on("close", (code) => {
-      resolve({
-        success: code === 0,
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        exitCode: code || 0,
-        error: code !== 0 ? `Command exited with code ${code}` : void 0
-      });
-    });
-    child.on("error", (error) => {
-      resolve({
-        success: false,
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        exitCode: 1,
-        error: error.message
-      });
-    });
-    if (options.timeout) {
-      setTimeout(() => {
-        child.kill();
-        resolve({
-          success: false,
-          stdout: stdout.trim(),
-          stderr: stderr.trim(),
-          exitCode: 1,
-          error: `Command timed out after ${options.timeout}ms`
-        });
-      }, options.timeout);
-    }
-  });
-}
-function buildCommand(command, args) {
-  const escapedArgs = args.map(escapeArgument);
-  return [command, ...escapedArgs].join(" ");
-}
-function escapeArgument(arg) {
-  if (/[\s"'`$&|;<>(){}[\]\\]/.test(arg)) {
-    const escaped = arg.replace(/"/g, '\\"');
-    return `"${escaped}"`;
-  }
-  return arg;
-}
-async function commandExists(command) {
-  const isWindows = process.platform === "win32";
-  const checkCommand = isWindows ? "where" : "which";
-  try {
-    const result = await executeCommand(checkCommand, [command]);
-    return result.success;
-  } catch {
-    return false;
-  }
-}
-async function getCommandPath(command) {
-  const isWindows = process.platform === "win32";
-  const checkCommand = isWindows ? "where" : "which";
-  try {
-    const result = await executeCommand(checkCommand, [command]);
-    if (result.success) {
-      return result.stdout.split("\n")[0].trim();
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function parseVersion(output) {
-  const patterns = [
-    /version\s+v?(\d+\.\d+\.\d+)/i,
-    /v?(\d+\.\d+\.\d+)/,
-    /(\d+\.\d+\.\d+)/
-  ];
-  for (const pattern of patterns) {
-    const match = output.match(pattern);
-    if (match) {
-      return match[1];
-    }
-  }
-  return null;
-}
-async function getCommandVersion(command, versionFlag = "--version") {
-  try {
-    const result = await executeCommand(command, [versionFlag]);
-    if (result.success) {
-      return parseVersion(result.stdout || result.stderr);
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function executeCommandSequence(commands) {
-  const results = [];
-  for (const cmd of commands) {
-    const result = await executeCommand(
-      cmd.command,
-      cmd.args || [],
-      cmd.options || {}
-    );
-    results.push(result);
-    if (!result.success) {
-      break;
-    }
-  }
-  return results;
-}
-async function executeCommandParallel(commands) {
-  const promises = commands.map(
-    (cmd) => executeCommand(cmd.command, cmd.args || [], cmd.options || {})
-  );
-  return Promise.all(promises);
-}
-
-export { escapeArgument as a, buildCommand as b, commandExists as c, executeCommandParallel as d, executeCommand as e, executeCommandSequence as f, executeCommandStream as g, getCommandPath as h, getCommandVersion as i, parseVersion as p };

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.Bq8TqZG_.mjs

@@ -1,189 +0,0 @@
-import { exec } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { promisify } from 'node:util';
-import { i18n } from '../chunks/index2.mjs';
-import { j as join } from './ccjk.bQ7Dh1g4.mjs';
-
-const execAsync = promisify(exec);
-function getClaudePluginDir() {
-  return join(homedir(), ".claude", "plugins");
-}
-function getSuperpowersPath() {
-  return join(getClaudePluginDir(), "superpowers");
-}
-async function checkSuperpowersInstalled() {
-  const superpowersPath = getSuperpowersPath();
-  if (!existsSync(superpowersPath)) {
-    return { installed: false };
-  }
-  try {
-    const packageJsonPath = join(superpowersPath, "package.json");
-    if (existsSync(packageJsonPath)) {
-      const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
-      const skillsDir = join(superpowersPath, "skills");
-      let skillCount = 0;
-      if (existsSync(skillsDir)) {
-        const { readdir } = await import('node:fs/promises');
-        const entries = await readdir(skillsDir, { withFileTypes: true });
-        skillCount = entries.filter((e) => e.isDirectory()).length;
-      }
-      return {
-        installed: true,
-        version: packageJson.version,
-        skillCount,
-        path: superpowersPath
-      };
-    }
-    return { installed: true, path: superpowersPath };
-  } catch {
-    return { installed: true, path: superpowersPath };
-  }
-}
-async function installSuperpowers(options) {
-  try {
-    const status = await checkSuperpowersInstalled();
-    if (status.installed) {
-      return {
-        success: true,
-        message: i18n.t("superpowers:alreadyInstalled")
-      };
-    }
-    const result = await installSuperpowersViaGit(options.skipPrompt);
-    if (result.success && options.enableCloudSync && options.cloudProvider && options.cloudCredentials) {
-      try {
-        const { configureCloudSync } = await import('../chunks/cloud-sync.mjs');
-        await configureCloudSync(options.cloudProvider, options.cloudCredentials);
-        if (!options.skipPrompt) {
-          console.log(i18n.t("superpowers:cloudSync.configured"));
-        }
-      } catch (error) {
-        if (!options.skipPrompt) {
-          console.warn(i18n.t("superpowers:cloudSync.configFailed"), error);
-        }
-      }
-    }
-    return result;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      message: i18n.t("superpowers:installFailed"),
-      error: errorMessage
-    };
-  }
-}
-async function installSuperpowersViaGit(silent = false) {
-  try {
-    const pluginDir = getClaudePluginDir();
-    const superpowersPath = getSuperpowersPath();
-    const { mkdir } = await import('node:fs/promises');
-    await mkdir(pluginDir, { recursive: true });
-    if (!silent) {
-      console.log(i18n.t("superpowers:cloning"));
-    }
-    await execAsync(
-      `git clone https://github.com/obra/superpowers.git "${superpowersPath}"`,
-      { timeout: 12e4 }
-    );
-    const status = await checkSuperpowersInstalled();
-    if (status.installed) {
-      return {
-        success: true,
-        message: i18n.t("superpowers:installSuccess")
-      };
-    }
-    return {
-      success: false,
-      message: i18n.t("superpowers:installFailed")
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      message: i18n.t("superpowers:installFailed"),
-      error: errorMessage
-    };
-  }
-}
-async function uninstallSuperpowers() {
-  try {
-    const status = await checkSuperpowersInstalled();
-    if (!status.installed) {
-      return {
-        success: true,
-        message: i18n.t("superpowers:notInstalled")
-      };
-    }
-    const superpowersPath = getSuperpowersPath();
-    if (existsSync(superpowersPath)) {
-      const { rm } = await import('node:fs/promises');
-      await rm(superpowersPath, { recursive: true, force: true });
-    }
-    const newStatus = await checkSuperpowersInstalled();
-    if (!newStatus.installed) {
-      return {
-        success: true,
-        message: i18n.t("superpowers:uninstallSuccess")
-      };
-    }
-    return {
-      success: false,
-      message: i18n.t("superpowers:uninstallFailed")
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      message: i18n.t("superpowers:uninstallFailed"),
-      error: errorMessage
-    };
-  }
-}
-async function updateSuperpowers() {
-  try {
-    const status = await checkSuperpowersInstalled();
-    if (!status.installed) {
-      return {
-        success: false,
-        message: i18n.t("superpowers:notInstalled")
-      };
-    }
-    const superpowersPath = getSuperpowersPath();
-    await execAsync("git pull", {
-      cwd: superpowersPath,
-      timeout: 6e4
-    });
-    return {
-      success: true,
-      message: i18n.t("superpowers:updateSuccess")
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      message: i18n.t("superpowers:updateFailed"),
-      error: errorMessage
-    };
-  }
-}
-async function getSuperpowersSkills() {
-  try {
-    const status = await checkSuperpowersInstalled();
-    if (!status.installed || !status.path) {
-      return [];
-    }
-    const skillsDir = join(status.path, "skills");
-    if (!existsSync(skillsDir)) {
-      return [];
-    }
-    const { readdir } = await import('node:fs/promises');
-    const entries = await readdir(skillsDir, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
-  } catch {
-    return [];
-  }
-}
-
-export { uninstallSuperpowers as a, installSuperpowersViaGit as b, checkSuperpowersInstalled as c, getSuperpowersSkills as g, installSuperpowers as i, updateSuperpowers as u };

package/dist/shared/ccjk.BtrioX1Z.mjs

@@ -1,25 +0,0 @@
-import process__default from 'node:process';
-import a from '../chunks/index5.mjs';
-import { ensureI18nInitialized, i18n } from '../chunks/index2.mjs';
-
-function handleExitPromptError(error) {
-  const isExitError = error instanceof Error && (error.name === "ExitPromptError" || error.message?.includes("ExitPromptError") || error.message?.includes("User force closed the prompt"));
-  if (isExitError) {
-    ensureI18nInitialized();
-    console.log(a.green(`
-${i18n.t("common:goodbye")}
-`));
-    process__default.exit(0);
-  }
-  return false;
-}
-function handleGeneralError(error) {
-  ensureI18nInitialized();
-  console.error(a.red(`${i18n.t("errors:generalError")}:`), error);
-  if (error instanceof Error) {
-    console.error(a.gray(`${i18n.t("errors:stackTrace")}: ${error.stack}`));
-  }
-  process__default.exit(1);
-}
-
-export { handleGeneralError as a, handleExitPromptError as h };

package/dist/shared/ccjk.Bx_rmYfN.mjs

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

package/dist/shared/ccjk.BzPbSEP2.mjs

@@ -1,115 +0,0 @@
-import { existsSync, readFileSync, readdirSync, rmSync } from 'node:fs';
-import { CCJK_CONFIG_DIR } from '../chunks/constants.mjs';
-import { writeFileAtomic, ensureDir } from '../chunks/fs-operations.mjs';
-import { j as join, b as basename } from './ccjk.bQ7Dh1g4.mjs';
-
-const SNAPSHOTS_DIR = join(CCJK_CONFIG_DIR, "snapshots");
-function getSnapshotsDir() {
-  return process.env.CCJK_SNAPSHOTS_DIR || SNAPSHOTS_DIR;
-}
-function safeTimestamp(date = /* @__PURE__ */ new Date()) {
-  return date.toISOString().replace(/[:.]/g, "-");
-}
-function safeFileName(path) {
-  return basename(path).replace(/[^\w.-]/g, "_") || "config";
-}
-function createConfigSnapshot(plan) {
-  const id = `${safeTimestamp()}-${plan.id.slice(0, 8)}`;
-  const snapshotDir = join(getSnapshotsDir(), id);
-  const filesDir = join(snapshotDir, "files");
-  ensureDir(filesDir);
-  const seen = /* @__PURE__ */ new Map();
-  const files = [];
-  for (const change of plan.changes) {
-    const beforeContent = change.beforeContent ?? "";
-    const count = seen.get(change.file) ?? 0;
-    seen.set(change.file, count + 1);
-    const backupName = `${String(count + 1).padStart(2, "0")}-${safeFileName(change.file)}`;
-    const backupPath = join("files", backupName);
-    writeFileAtomic(join(snapshotDir, backupPath), beforeContent);
-    files.push({
-      target: change.target,
-      sourcePath: change.file,
-      backupPath,
-      beforeHash: change.beforeHash,
-      afterHash: change.afterHash,
-      operation: change.operation,
-      reason: change.reason,
-      existed: change.beforeExists
-    });
-  }
-  const manifest = {
-    version: 1,
-    id,
-    planId: plan.id,
-    title: plan.title,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    risk: plan.risk,
-    files
-  };
-  writeFileAtomic(join(snapshotDir, "manifest.json"), JSON.stringify(manifest, null, 2));
-  return {
-    id,
-    path: snapshotDir,
-    manifest
-  };
-}
-function listConfigSnapshots() {
-  const snapshotsDir = getSnapshotsDir();
-  if (!existsSync(snapshotsDir)) {
-    return [];
-  }
-  return readdirSync(snapshotsDir).map((entry) => {
-    const manifestPath = join(snapshotsDir, entry, "manifest.json");
-    try {
-      return JSON.parse(readFileSync(manifestPath, "utf-8"));
-    } catch {
-      return null;
-    }
-  }).filter((item) => Boolean(item)).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-}
-function readConfigSnapshot(id) {
-  const snapshotDir = join(getSnapshotsDir(), id);
-  const manifestPath = join(snapshotDir, "manifest.json");
-  if (!existsSync(manifestPath)) {
-    return null;
-  }
-  try {
-    const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-    return {
-      id: manifest.id,
-      path: snapshotDir,
-      manifest
-    };
-  } catch {
-    return null;
-  }
-}
-function restoreConfigSnapshot(id) {
-  const snapshot = readConfigSnapshot(id);
-  if (!snapshot) {
-    throw new Error(`Snapshot not found: ${id}`);
-  }
-  const restored = [];
-  const skipped = [];
-  for (const file of snapshot.manifest.files) {
-    const backupPath = join(snapshot.path, file.backupPath);
-    if (!existsSync(backupPath)) {
-      skipped.push(file);
-      continue;
-    }
-    if (!file.existed) {
-      if (existsSync(file.sourcePath)) {
-        rmSync(file.sourcePath, { force: true });
-      }
-      restored.push(file);
-      continue;
-    }
-    const content = readFileSync(backupPath, "utf-8");
-    writeFileAtomic(file.sourcePath, content);
-    restored.push(file);
-  }
-  return { restored, skipped };
-}
-
-export { restoreConfigSnapshot as a, createConfigSnapshot as c, listConfigSnapshots as l, readConfigSnapshot as r };