ccjk 15.28.2 → 15.29.0

package/dist/chunks/fish.mjs

@@ -0,0 +1,181 @@
+function generateFishCompletion(commands) {
+  const lines = [
+    "# CCJK CLI Fish Completion",
+    "# Generated automatically - do not edit manually",
+    "# Install: place in ~/.config/fish/completions/ccjk.fish",
+    "",
+    "# Disable file completion by default",
+    "complete -c ccjk -f",
+    "",
+    "# Helper functions",
+    "",
+    "# Check if we need command completion",
+    "function __fish_ccjk_needs_command",
+    "    set -l cmd (commandline -opc)",
+    "    if test (count $cmd) -eq 1",
+    "        return 0",
+    "    end",
+    "    return 1",
+    "end",
+    "",
+    "# Check if current command matches",
+    "function __fish_ccjk_using_command",
+    "    set -l cmd (commandline -opc)",
+    "    if test (count $cmd) -gt 1",
+    "        if test $argv[1] = $cmd[2]",
+    "            return 0",
+    "        end",
+    "    end",
+    "    return 1",
+    "end",
+    "",
+    "# Check if current subcommand matches",
+    "function __fish_ccjk_using_subcommand",
+    "    set -l cmd (commandline -opc)",
+    "    if test (count $cmd) -gt 2",
+    "        if test $argv[1] = $cmd[2] -a $argv[2] = $cmd[3]",
+    "            return 0",
+    "        end",
+    "    end",
+    "    return 1",
+    "end",
+    "",
+    "# Dynamic completion functions",
+    "",
+    "# Get installed MCP services",
+    "function __fish_ccjk_mcp_services",
+    `    ccjk mcp list --json 2>/dev/null | string match -r '"name":\\s*"([^"]+)' | string replace -r '"name":\\s*"' ''`,
+    "end",
+    "",
+    "# Get available skills",
+    "function __fish_ccjk_skills",
+    "    ccjk skills list --format list 2>/dev/null | string match -v '^$'",
+    "end",
+    "",
+    "# Get available agents",
+    "function __fish_ccjk_agents",
+    `    ccjk agent list --json 2>/dev/null | string match -r '"id":\\s*"([^"]+)' | string replace -r '"id":\\s*"' ''`,
+    "end",
+    "",
+    "# Get available sessions",
+    "function __fish_ccjk_sessions",
+    `    ccjk session list --json 2>/dev/null | string match -r '"name":\\s*"([^"]+)' | string replace -r '"name":\\s*"' ''`,
+    "end",
+    "",
+    "# Global options",
+    'complete -c ccjk -s h -l help -d "Show help"',
+    'complete -c ccjk -s v -l version -d "Show version"',
+    'complete -c ccjk -s l -l lang -d "Display language" -xa "zh-CN en"',
+    "",
+    "# Commands"
+  ];
+  for (const cmd of commands) {
+    lines.push("");
+    lines.push(`# ${cmd.name} command`);
+    lines.push(`complete -c ccjk -n __fish_ccjk_needs_command -a ${cmd.name} -d "${escapeFishString(cmd.description)}"`);
+    if (cmd.aliases) {
+      for (const alias of cmd.aliases) {
+        lines.push(`complete -c ccjk -n __fish_ccjk_needs_command -a ${alias} -d "${escapeFishString(cmd.description)} (alias)"`);
+      }
+    }
+    if (cmd.options) {
+      for (const opt of cmd.options) {
+        const optLines = generateFishOption(cmd.name, opt, cmd.aliases);
+        lines.push(...optLines);
+      }
+    }
+    if (cmd.subcommands) {
+      lines.push("");
+      lines.push(`# ${cmd.name} subcommands`);
+      for (const sub of cmd.subcommands) {
+        const condition = `__fish_ccjk_using_command ${cmd.name}`;
+        lines.push(`complete -c ccjk -n "${condition}" -a ${sub.name} -d "${escapeFishString(sub.description)}"`);
+        if (cmd.aliases) {
+          for (const alias of cmd.aliases) {
+            const aliasCondition = `__fish_ccjk_using_command ${alias}`;
+            lines.push(`complete -c ccjk -n "${aliasCondition}" -a ${sub.name} -d "${escapeFishString(sub.description)}"`);
+          }
+        }
+        if (sub.options) {
+          for (const opt of sub.options) {
+            const subOptLines = generateFishSubcommandOption(cmd.name, sub.name, opt, cmd.aliases);
+            lines.push(...subOptLines);
+          }
+        }
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function generateFishOption(cmdName, opt, aliases) {
+  const lines = [];
+  const flags = parseOptionFlags(opt.flags);
+  const desc = escapeFishString(opt.description);
+  const condition = `__fish_ccjk_using_command ${cmdName}`;
+  let optSpec = `-n "${condition}"`;
+  const shortFlag = flags.find((f) => f.startsWith("-") && !f.startsWith("--"));
+  if (shortFlag) {
+    optSpec += ` -s ${shortFlag.replace("-", "")}`;
+  }
+  const longFlag = flags.find((f) => f.startsWith("--"));
+  if (longFlag) {
+    optSpec += ` -l ${longFlag.replace("--", "")}`;
+  }
+  optSpec += ` -d "${desc}"`;
+  if (opt.values) {
+    if (typeof opt.values === "function") {
+      optSpec += " -r";
+    } else {
+      optSpec += ` -xa "${opt.values.join(" ")}"`;
+    }
+  }
+  lines.push(`complete -c ccjk ${optSpec}`);
+  if (aliases) {
+    for (const alias of aliases) {
+      const aliasCondition = `__fish_ccjk_using_command ${alias}`;
+      const aliasOptSpec = optSpec.replace(condition, aliasCondition);
+      lines.push(`complete -c ccjk ${aliasOptSpec}`);
+    }
+  }
+  return lines;
+}
+function generateFishSubcommandOption(cmdName, subName, opt, aliases) {
+  const lines = [];
+  const flags = parseOptionFlags(opt.flags);
+  const desc = escapeFishString(opt.description);
+  const condition = `__fish_ccjk_using_subcommand ${cmdName} ${subName}`;
+  let optSpec = `-n "${condition}"`;
+  const shortFlag = flags.find((f) => f.startsWith("-") && !f.startsWith("--"));
+  if (shortFlag) {
+    optSpec += ` -s ${shortFlag.replace("-", "")}`;
+  }
+  const longFlag = flags.find((f) => f.startsWith("--"));
+  if (longFlag) {
+    optSpec += ` -l ${longFlag.replace("--", "")}`;
+  }
+  optSpec += ` -d "${desc}"`;
+  if (opt.values) {
+    if (typeof opt.values === "function") {
+      optSpec += " -r";
+    } else {
+      optSpec += ` -xa "${opt.values.join(" ")}"`;
+    }
+  }
+  lines.push(`complete -c ccjk ${optSpec}`);
+  if (aliases) {
+    for (const alias of aliases) {
+      const aliasCondition = `__fish_ccjk_using_subcommand ${alias} ${subName}`;
+      const aliasOptSpec = optSpec.replace(condition, aliasCondition);
+      lines.push(`complete -c ccjk ${aliasOptSpec}`);
+    }
+  }
+  return lines;
+}
+function parseOptionFlags(flags) {
+  return flags.split(",").map((f) => f.trim().split(/\s+/)[0]);
+}
+function escapeFishString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "\\$");
+}
+
+export { generateFishCompletion };

package/dist/chunks/fs-operations.mjs

@@ -0,0 +1,180 @@
+import { randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, writeFileSync, renameSync, unlinkSync, readdirSync, statSync, copyFileSync, readFileSync } from 'node:fs';
+import { mkdir, writeFile as writeFile$1, rename, unlink } from 'node:fs/promises';
+import { d as dirname, j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
+
+class FileSystemError extends Error {
+  constructor(message, path, cause) {
+    super(message);
+    this.path = path;
+    this.cause = cause;
+    this.name = "FileSystemError";
+  }
+}
+function exists(path) {
+  return existsSync(path);
+}
+function ensureDir(path) {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+function ensureFileDir(filePath) {
+  const dir = dirname(filePath);
+  ensureDir(dir);
+}
+function readFile(path, encoding = "utf-8") {
+  try {
+    return readFileSync(path, encoding);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to read file: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function writeFile(path, content, encoding = "utf-8") {
+  try {
+    ensureFileDir(path);
+    writeFileSync(path, content, encoding);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to write file: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function writeFileAtomic(path, content, options = "utf-8") {
+  const dir = dirname(path);
+  ensureDir(dir);
+  const opts = typeof options === "string" ? { encoding: options } : options;
+  const encoding = opts.encoding ?? "utf-8";
+  const tempFileName = `.tmp_${randomBytes(8).toString("hex")}_${Date.now()}`;
+  const tempPath = join(dir, tempFileName);
+  try {
+    writeFileSync(tempPath, content, { encoding, mode: opts.mode });
+    renameSync(tempPath, path);
+  } catch (error) {
+    try {
+      if (existsSync(tempPath)) {
+        unlinkSync(tempPath);
+      }
+    } catch {
+    }
+    throw new FileSystemError(
+      `Failed to write file atomically: ${path}`,
+      path,
+      error
+    );
+  }
+}
+async function writeFileAtomicAsync(path, content, options = "utf-8") {
+  const dir = dirname(path);
+  await mkdir(dir, { recursive: true });
+  const opts = typeof options === "string" ? { encoding: options } : options;
+  const encoding = opts.encoding ?? "utf-8";
+  const tempFileName = `.tmp_${randomBytes(8).toString("hex")}_${Date.now()}`;
+  const tempPath = join(dir, tempFileName);
+  try {
+    await writeFile$1(tempPath, content, { encoding, mode: opts.mode });
+    await rename(tempPath, path);
+  } catch (error) {
+    try {
+      if (existsSync(tempPath)) {
+        await unlink(tempPath);
+      }
+    } catch {
+    }
+    throw new FileSystemError(
+      `Failed to write file atomically: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function readJsonFile(path) {
+  try {
+    const content = readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to read JSON file: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function copyFile(src, dest) {
+  try {
+    ensureFileDir(dest);
+    copyFileSync(src, dest);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to copy file from ${src} to ${dest}`,
+      src,
+      error
+    );
+  }
+}
+function readDir(path) {
+  try {
+    return readdirSync(path);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to read directory: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function getStatsSafe(path) {
+  try {
+    return statSync(path);
+  } catch {
+    return null;
+  }
+}
+function removeFile(path) {
+  try {
+    if (exists(path)) {
+      unlinkSync(path);
+    }
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to remove file: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function copyDir(src, dest, options = {}) {
+  const { filter, overwrite = true } = options;
+  if (!exists(src)) {
+    throw new FileSystemError(`Source directory does not exist: ${src}`, src);
+  }
+  ensureDir(dest);
+  const entries = readDir(src);
+  for (const entry of entries) {
+    const srcPath = `${src}/${entry}`;
+    const destPath = `${dest}/${entry}`;
+    const stats = getStatsSafe(srcPath);
+    if (!stats) {
+      continue;
+    }
+    if (filter && !filter(srcPath, stats)) {
+      continue;
+    }
+    if (stats.isDirectory()) {
+      copyDir(srcPath, destPath, options);
+    } else {
+      if (!overwrite && exists(destPath)) {
+        continue;
+      }
+      copyFile(srcPath, destPath);
+    }
+  }
+}
+
+export { FileSystemError, copyDir, copyFile, ensureDir, ensureFileDir, exists, getStatsSafe, readDir, readFile, readJsonFile, removeFile, writeFile, writeFileAtomic, writeFileAtomicAsync };