ccjk 10.3.0 → 11.1.0

package/dist/chunks/evolution.mjs

@@ -0,0 +1,383 @@
+import ansis from 'ansis';
+import { i18n } from './index2.mjs';
+import 'node:fs';
+import 'node:process';
+import 'node:url';
+import 'i18next';
+import 'i18next-fs-backend';
+import 'pathe';
+
+class A2AClient {
+  baseUrl;
+  token = null;
+  agentId = null;
+  constructor(baseUrl = "http://localhost:3005") {
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * Register agent (hello)
+   */
+  async hello(agent) {
+    const response = await this.request("/a2a/hello", {
+      method: "POST",
+      body: { type: "hello", agent }
+    });
+    this.token = response.token;
+    this.agentId = response.agentId;
+    return response;
+  }
+  /**
+   * Publish a gene
+   */
+  async publish(gene, proof) {
+    this.ensureAuthenticated();
+    return this.request("/a2a/publish", {
+      method: "POST",
+      body: { type: "publish", gene, proof },
+      auth: true
+    });
+  }
+  /**
+   * Fetch genes
+   */
+  async fetch(query, limit) {
+    this.ensureAuthenticated();
+    const response = await this.request("/a2a/fetch", {
+      method: "POST",
+      body: { type: "fetch", query, limit },
+      auth: true
+    });
+    return response.genes;
+  }
+  /**
+   * Report usage result
+   */
+  async report(geneId, result) {
+    this.ensureAuthenticated();
+    return this.request("/a2a/report", {
+      method: "POST",
+      body: { type: "report", geneId, result },
+      auth: true
+    });
+  }
+  /**
+   * Request decision
+   */
+  async decision(problem, options, context) {
+    this.ensureAuthenticated();
+    return this.request("/a2a/decision", {
+      method: "POST",
+      body: { type: "decision", problem, options, context },
+      auth: true
+    });
+  }
+  /**
+   * Revoke a gene
+   */
+  async revoke(geneId, reason) {
+    this.ensureAuthenticated();
+    await this.request(`/a2a/genes/${geneId}`, {
+      method: "DELETE",
+      body: { reason },
+      auth: true
+    });
+  }
+  /**
+   * Get agent ID
+   */
+  getAgentId() {
+    return this.agentId;
+  }
+  /**
+   * Check if authenticated
+   */
+  isAuthenticated() {
+    return this.token !== null;
+  }
+  /**
+   * Internal request wrapper
+   */
+  async request(path, options) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (options.auth && this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    const response = await globalThis.fetch(url, {
+      method: options.method,
+      headers,
+      body: options.body ? JSON.stringify(options.body) : void 0
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: response.statusText }));
+      throw new Error(error.error || `Request failed: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  ensureAuthenticated() {
+    if (!this.token) {
+      throw new Error("Not authenticated. Call hello() first.");
+    }
+  }
+}
+
+const PROTOCOL_CACHE_TTL_MS = 10 * 60 * 1e3;
+const HEALTH_PATH = "/health";
+const API_CANDIDATES = [
+  "https://remote-api.claudehome.cn",
+  "http://remote-api.claudehome.cn"
+];
+let protocolCache = null;
+async function resolveRemoteApiBaseUrl(timeoutMs = 5e3) {
+  const now = Date.now();
+  if (protocolCache && protocolCache.expiresAt > now) {
+    return protocolCache.baseUrl;
+  }
+  for (const baseUrl of API_CANDIDATES) {
+    const ok = await probeHealth(baseUrl, timeoutMs);
+    if (ok) {
+      protocolCache = {
+        baseUrl,
+        expiresAt: now + PROTOCOL_CACHE_TTL_MS
+      };
+      return baseUrl;
+    }
+  }
+  throw new Error("Remote API unavailable");
+}
+async function probeHealth(baseUrl, timeoutMs) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${baseUrl}${HEALTH_PATH}`, {
+      method: "GET",
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return false;
+    }
+    const data = await response.json().catch(() => null);
+    return data?.status === "ok";
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+async function handleEvolutionCommand(action, args, options) {
+  try {
+    const resolvedBaseUrl = await resolveRemoteApiBaseUrl();
+    const client = new A2AClient(resolvedBaseUrl);
+    switch (action) {
+      case "top":
+        await showTopCapabilities(client, options);
+        break;
+      case "search":
+        await searchSolutions(client, args[0], options);
+        break;
+      case "show":
+        await showGeneDetails(client, args[0]);
+        break;
+      case "stats":
+        await showStats(client);
+        break;
+      default:
+        await showTopCapabilities(client, { limit: "30", minGdi: "70" });
+    }
+  } catch (error) {
+    const failedMsg = i18n.t("evolution:failed", "Failed");
+    console.error(ansis.red("\u274C " + failedMsg + ":"), error.message);
+    process.exit(1);
+  }
+}
+async function showTopCapabilities(client, options) {
+  const connectingMsg = i18n.t("evolution:connecting", "Connecting to Evolution Layer...");
+  console.log(ansis.blue("\u{1F517} " + connectingMsg));
+  await client.hello({
+    id: "claude-code-cli",
+    name: "claude-code",
+    version: "1.0.0",
+    capabilities: ["fetch", "report"]
+  });
+  const fetchingMsg = i18n.t("evolution:fetching", "Fetching top capabilities...");
+  console.log(ansis.blue("\u{1F4CA} " + fetchingMsg));
+  const genes = await client.fetch(
+    {
+      signature: "*",
+      context: [],
+      minGDI: Number.parseInt(options.minGdi || "70")
+    },
+    Number.parseInt(options.limit || "30")
+  );
+  const foundMsg = i18n.t("evolution:found", "Found {{count}} capabilities", { count: genes.length });
+  console.log(ansis.green("\n\u2705 " + foundMsg + "\n"));
+  if (genes.length === 0) {
+    const noResultsMsg = i18n.t("evolution:noResults", "No capabilities found");
+    console.log(ansis.yellow(noResultsMsg));
+    return;
+  }
+  genes.forEach((gene, index) => {
+    console.log(ansis.bold(`${index + 1}. ${gene.id.substring(0, 8)}`));
+    const problemLabel = ansis.cyan(i18n.t("evolution:problem", "Problem"));
+    console.log("   " + problemLabel + ": " + gene.problem.signature);
+    const solutionLabel = ansis.yellow(i18n.t("evolution:solution", "Solution"));
+    console.log("   " + solutionLabel + ": " + gene.solution.strategy);
+    console.log("   " + ansis.green("GDI") + ": " + gene.quality.gdi.toFixed(1));
+    const usedLabel = ansis.gray(i18n.t("evolution:used", "Used"));
+    const timesLabel = i18n.t("evolution:times", "times");
+    console.log("   " + usedLabel + ": " + gene.quality.usageCount + " " + timesLabel);
+    const successLabel = ansis.gray(i18n.t("evolution:success", "Success"));
+    const successRate = (gene.quality.successRate * 100).toFixed(1);
+    console.log("   " + successLabel + ": " + successRate + "%");
+    console.log();
+  });
+}
+async function searchSolutions(client, query, options) {
+  const searchingMsg = i18n.t("evolution:searching", "Searching for: {{query}}", { query });
+  console.log(ansis.blue("\u{1F50D} " + searchingMsg));
+  await client.hello({
+    id: "claude-code-cli",
+    name: "claude-code",
+    version: "1.0.0",
+    capabilities: ["fetch", "report"]
+  });
+  const genes = await client.fetch(
+    {
+      signature: query,
+      context: [],
+      minGDI: Number.parseInt(options.minGdi || "60")
+    },
+    Number.parseInt(options.limit || "10")
+  );
+  if (genes.length === 0) {
+    const noSolutionsMsg = i18n.t("evolution:noSolutions", "No solutions found");
+    console.log(ansis.yellow("\n" + noSolutionsMsg));
+    return;
+  }
+  const foundMsg = i18n.t("evolution:foundSolutions", "Found {{count}} solutions", { count: genes.length });
+  console.log(ansis.green("\n\u2705 " + foundMsg + "\n"));
+  genes.forEach((gene, index) => {
+    console.log(ansis.bold(`${index + 1}. ${gene.problem.signature}`));
+    console.log("   " + gene.solution.strategy);
+    const usedLabel = i18n.t("evolution:used", "Used");
+    console.log("   GDI: " + gene.quality.gdi.toFixed(1) + " | " + usedLabel + ": " + gene.quality.usageCount + "x");
+    if (gene.problem.context.length > 0) {
+      const contextLabel = ansis.gray(i18n.t("evolution:context", "Context"));
+      console.log("   " + contextLabel + ": " + gene.problem.context.join(", "));
+    }
+    console.log();
+  });
+}
+async function showGeneDetails(client, geneId) {
+  await client.hello({
+    id: "claude-code-cli",
+    name: "claude-code",
+    version: "1.0.0",
+    capabilities: ["fetch", "report"]
+  });
+  const genes = await client.fetch({ signature: "*", context: [] });
+  const gene = genes.find((g) => g.id.startsWith(geneId));
+  if (!gene) {
+    const notFoundMsg = i18n.t("evolution:geneNotFound", "Gene not found");
+    console.log(ansis.red(notFoundMsg));
+    return;
+  }
+  displayGene(gene);
+}
+async function showStats(client) {
+  const fetchingMsg = i18n.t("evolution:fetchingStats", "Fetching statistics...");
+  console.log(ansis.blue("\u{1F4CA} " + fetchingMsg));
+  await client.hello({
+    id: "claude-code-cli",
+    name: "claude-code",
+    version: "1.0.0",
+    capabilities: ["fetch", "report"]
+  });
+  const allGenes = await client.fetch({ signature: "*", context: [] }, 1e3);
+  const totalGenes = allGenes.length;
+  const avgGDI = allGenes.reduce((sum, g) => sum + g.quality.gdi, 0) / totalGenes;
+  const totalUsage = allGenes.reduce((sum, g) => sum + g.quality.usageCount, 0);
+  const avgSuccessRate = allGenes.reduce((sum, g) => sum + g.quality.successRate, 0) / totalGenes;
+  const typeCount = allGenes.reduce((acc, g) => {
+    acc[g.type] = (acc[g.type] || 0) + 1;
+    return acc;
+  }, {});
+  console.log(ansis.bold("\n\u{1F4C8} Evolution Layer Statistics\n"));
+  const totalLabel = ansis.cyan(i18n.t("evolution:totalGenes", "Total Genes"));
+  console.log(totalLabel + ": " + totalGenes);
+  const avgGdiLabel = ansis.cyan(i18n.t("evolution:avgGDI", "Average GDI"));
+  console.log(avgGdiLabel + ": " + avgGDI.toFixed(1));
+  const totalUsageLabel = ansis.cyan(i18n.t("evolution:totalUsage", "Total Usage"));
+  console.log(totalUsageLabel + ": " + totalUsage);
+  const avgSuccessLabel = ansis.cyan(i18n.t("evolution:avgSuccess", "Average Success Rate"));
+  console.log(avgSuccessLabel + ": " + (avgSuccessRate * 100).toFixed(1) + "%");
+  console.log();
+  const byTypeLabel = i18n.t("evolution:byType", "By Type");
+  console.log(ansis.bold(byTypeLabel + ":"));
+  Object.entries(typeCount).forEach(([type, count]) => {
+    console.log("  " + type + ": " + count);
+  });
+}
+function displayGene(gene) {
+  const detailsLabel = i18n.t("evolution:geneDetails", "Gene Details");
+  console.log(ansis.bold("\n\u{1F4E6} " + detailsLabel + "\n"));
+  console.log(ansis.cyan("ID") + ": " + gene.id);
+  const typeLabel = i18n.t("evolution:type", "Type");
+  console.log(ansis.cyan(typeLabel) + ": " + gene.type);
+  console.log(ansis.cyan("SHA256") + ": " + gene.sha256);
+  console.log();
+  const problemLabel = i18n.t("evolution:problem", "Problem");
+  console.log(ansis.bold(problemLabel + ":"));
+  const sigLabel = i18n.t("evolution:signature", "Signature");
+  console.log("  " + sigLabel + ": " + gene.problem.signature);
+  if (gene.problem.context.length > 0) {
+    const contextLabel = i18n.t("evolution:context", "Context");
+    console.log("  " + contextLabel + ": " + gene.problem.context.join(", "));
+  }
+  console.log();
+  const solutionLabel = i18n.t("evolution:solution", "Solution");
+  console.log(ansis.bold(solutionLabel + ":"));
+  const strategyLabel = i18n.t("evolution:strategy", "Strategy");
+  console.log("  " + strategyLabel + ": " + gene.solution.strategy);
+  if (gene.solution.code) {
+    const codeLabel = i18n.t("evolution:code", "Code");
+    console.log("  " + codeLabel + ":");
+    const codeLines = gene.solution.code.split("\n").map((line) => "    " + line).join("\n");
+    console.log(ansis.gray(codeLines));
+  }
+  if (gene.solution.steps.length > 0) {
+    const stepsLabel = i18n.t("evolution:steps", "Steps");
+    console.log("  " + stepsLabel + ":");
+    gene.solution.steps.forEach((step, i) => {
+      console.log("    " + (i + 1) + ". " + step);
+    });
+  }
+  console.log();
+  const qualityLabel = i18n.t("evolution:quality", "Quality");
+  console.log(ansis.bold(qualityLabel + ":"));
+  console.log("  GDI: " + gene.quality.gdi.toFixed(1));
+  const successRateLabel = i18n.t("evolution:successRate", "Success Rate");
+  console.log("  " + successRateLabel + ": " + (gene.quality.successRate * 100).toFixed(1) + "%");
+  const usageCountLabel = i18n.t("evolution:usageCount", "Usage Count");
+  console.log("  " + usageCountLabel + ": " + gene.quality.usageCount);
+  const avgTimeLabel = i18n.t("evolution:avgTime", "Average Time");
+  console.log("  " + avgTimeLabel + ": " + gene.quality.avgTime + "s");
+  if (gene.metadata) {
+    console.log();
+    const metadataLabel = i18n.t("evolution:metadata", "Metadata");
+    console.log(ansis.bold(metadataLabel + ":"));
+    const authorLabel = i18n.t("evolution:author", "Author");
+    console.log("  " + authorLabel + ": " + (gene.metadata.author || "-"));
+    const createdLabel = i18n.t("evolution:createdAt", "Created At");
+    console.log("  " + createdLabel + ": " + (gene.metadata.createdAt || "-"));
+    if (gene.metadata.tags && gene.metadata.tags.length > 0) {
+      const tagsLabel = i18n.t("evolution:tags", "Tags");
+      console.log("  " + tagsLabel + ": " + gene.metadata.tags.join(", "));
+    }
+  }
+}
+
+export { handleEvolutionCommand };

package/dist/chunks/package.mjs

@@ -1,4 +1,4 @@
-const version = "10.3.0";
+const version = "11.1.0";
 const homepage = "https://github.com/miounet11/ccjk";
 
 export { homepage, version };

package/dist/chunks/quick-provider.mjs

@@ -602,6 +602,7 @@ const KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "status",
   "st",
   "boost",
+  "evolution",
   // CCJK v8 commands
   "ccjk:mcp",
   "ccjk-mcp",

package/dist/chunks/remote.mjs

@@ -0,0 +1,166 @@
+import { l as logger } from '../shared/ccjk.Cu_R2MbQ.mjs';
+import { i18n } from './index2.mjs';
+import inquirer from 'inquirer';
+import { spawn } from 'child_process';
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import ora from 'ora';
+import 'ansis';
+import 'node:fs';
+import 'node:process';
+import 'node:url';
+import 'i18next';
+import 'i18next-fs-backend';
+import 'pathe';
+
+const DAEMON_CONFIG_PATH = join(homedir(), ".ccjk", "daemon.json");
+async function enableRemote() {
+  console.log(i18n.t("remote:enable.title"));
+  const config = loadDaemonConfig();
+  if (config.enabled) {
+    console.log(i18n.t("remote:enable.already_enabled"));
+    return;
+  }
+  const { serverUrl } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "serverUrl",
+      message: i18n.t("remote:enable.server_url"),
+      default: "https://ccjk-server.example.com"
+    }
+  ]);
+  const machineId = `machine-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  const newConfig = {
+    enabled: true,
+    serverUrl,
+    machineId
+  };
+  saveDaemonConfig(newConfig);
+  console.log(i18n.t("remote:enable.success"));
+  console.log(i18n.t("remote:enable.next_steps"));
+}
+async function disableRemote() {
+  console.log(i18n.t("remote:disable.title"));
+  const config = loadDaemonConfig();
+  if (!config.enabled) {
+    console.log(i18n.t("remote:disable.already_disabled"));
+    return;
+  }
+  await stopDaemon();
+  config.enabled = false;
+  saveDaemonConfig(config);
+  console.log(i18n.t("remote:disable.success"));
+}
+async function remoteStatus() {
+  const config = loadDaemonConfig();
+  console.log(i18n.t("remote:status.title"));
+  console.log(`  ${i18n.t("remote:status.enabled")}: ${config.enabled ? "\u2705" : "\u274C"}`);
+  if (config.enabled) {
+    console.log(`  ${i18n.t("remote:status.server")}: ${config.serverUrl}`);
+    console.log(`  ${i18n.t("remote:status.machine_id")}: ${config.machineId}`);
+    const daemonRunning = await isDaemonRunning();
+    console.log(`  ${i18n.t("remote:status.daemon")}: ${daemonRunning ? "\u{1F7E2} Running" : "\u{1F534} Stopped"}`);
+  }
+}
+async function showQRCode() {
+  const config = loadDaemonConfig();
+  if (!config.enabled) {
+    console.log(i18n.t("remote:qr.not_enabled"));
+    return;
+  }
+  const pairingData = {
+    serverUrl: config.serverUrl,
+    machineId: config.machineId,
+    timestamp: Date.now()
+  };
+  const pairingUrl = `ccjk://pair?data=${encodeURIComponent(JSON.stringify(pairingData))}`;
+  console.log(i18n.t("remote:qr.title"));
+  console.log(i18n.t("remote:qr.instructions"));
+  console.log();
+  console.log(`  ${pairingUrl}`);
+  console.log();
+  console.log(i18n.t("remote:qr.manual_entry"));
+  console.log(`  Server: ${config.serverUrl}`);
+  console.log(`  Machine ID: ${config.machineId}`);
+}
+async function startDaemon() {
+  const spinner = ora(i18n.t("remote:daemon.starting")).start();
+  try {
+    if (await isDaemonRunning()) {
+      spinner.warn(i18n.t("remote:daemon.already_running"));
+      return;
+    }
+    const daemon = spawn("ccjk-daemon", ["start"], {
+      detached: true,
+      stdio: "ignore"
+    });
+    daemon.unref();
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+    if (await isDaemonRunning()) {
+      spinner.succeed(i18n.t("remote:daemon.started"));
+    } else {
+      spinner.fail(i18n.t("remote:daemon.start_failed"));
+    }
+  } catch (error) {
+    spinner.fail(i18n.t("remote:daemon.start_error"));
+    logger.error("Failed to start daemon:", error);
+  }
+}
+async function stopDaemon() {
+  const spinner = ora(i18n.t("remote:daemon.stopping")).start();
+  try {
+    if (!await isDaemonRunning()) {
+      spinner.warn(i18n.t("remote:daemon.not_running"));
+      return;
+    }
+    const response = await fetch("http://127.0.0.1:37821/stop", {
+      method: "POST"
+    });
+    if (response.ok) {
+      spinner.succeed(i18n.t("remote:daemon.stopped"));
+    } else {
+      spinner.fail(i18n.t("remote:daemon.stop_failed"));
+    }
+  } catch (error) {
+    spinner.fail(i18n.t("remote:daemon.stop_error"));
+    logger.error("Failed to stop daemon:", error);
+  }
+}
+async function isDaemonRunning() {
+  try {
+    const response = await fetch("http://127.0.0.1:37821/health", {
+      signal: AbortSignal.timeout(1e3)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function loadDaemonConfig() {
+  try {
+    if (existsSync(DAEMON_CONFIG_PATH)) {
+      return JSON.parse(readFileSync(DAEMON_CONFIG_PATH, "utf-8"));
+    }
+  } catch (error) {
+    logger.error("Failed to load daemon config:", error);
+  }
+  return {
+    enabled: false,
+    serverUrl: ""
+  };
+}
+function saveDaemonConfig(config) {
+  try {
+    const dir = join(homedir(), ".ccjk");
+    if (!existsSync(dir)) {
+      require("fs").mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(DAEMON_CONFIG_PATH, JSON.stringify(config, null, 2));
+  } catch (error) {
+    logger.error("Failed to save daemon config:", error);
+    throw error;
+  }
+}
+
+export { disableRemote, enableRemote, remoteStatus, showQRCode, startDaemon, stopDaemon };

package/dist/cli.mjs

@@ -1456,6 +1456,87 @@ ${ansis.yellow("By Status:")}`);
       };
     }
   },
+  {
+    name: "remote",
+    description: "Remote control management",
+    tier: "core",
+    options: [
+      { flags: "enable", description: "Enable remote control" },
+      { flags: "disable", description: "Disable remote control" },
+      { flags: "status", description: "Show remote status" },
+      { flags: "qr", description: "Show pairing QR code" }
+    ],
+    loader: async () => {
+      const { enableRemote, disableRemote, remoteStatus, showQRCode } = await import('./chunks/remote.mjs');
+      return async (options, ...args) => {
+        const action = args[0];
+        switch (action) {
+          case "enable":
+            await enableRemote();
+            break;
+          case "disable":
+            await disableRemote();
+            break;
+          case "status":
+            await remoteStatus();
+            break;
+          case "qr":
+            await showQRCode();
+            break;
+          default:
+            await remoteStatus();
+        }
+      };
+    }
+  },
+  {
+    name: "evolution",
+    description: "Evolution Layer - AI knowledge sharing",
+    tier: "core",
+    options: [
+      { flags: "top", description: "Show top capabilities" },
+      { flags: "search <query>", description: "Search for solutions" },
+      { flags: "show <geneId>", description: "Show gene details" },
+      { flags: "stats", description: "Show statistics" }
+    ],
+    loader: async () => {
+      const { handleEvolutionCommand } = await import('./chunks/evolution.mjs');
+      return async (options, ...args) => {
+        const action = args[0];
+        const restArgs = args.slice(1);
+        await handleEvolutionCommand(action, restArgs, options);
+      };
+    }
+  },
+  {
+    name: "daemon",
+    description: "Daemon management",
+    tier: "core",
+    options: [
+      { flags: "start", description: "Start daemon" },
+      { flags: "stop", description: "Stop daemon" },
+      { flags: "status", description: "Daemon status" }
+    ],
+    loader: async () => {
+      const { startDaemon, stopDaemon, remoteStatus } = await import('./chunks/remote.mjs');
+      return async (options, ...args) => {
+        const action = args[0];
+        switch (action) {
+          case "start":
+            await startDaemon();
+            break;
+          case "stop":
+            await stopDaemon();
+            break;
+          case "status":
+            await remoteStatus();
+            break;
+          default:
+            await remoteStatus();
+        }
+      };
+    }
+  },
   {
     name: "morning",
     description: "Morning health check + stats summary",
@@ -1918,6 +1999,11 @@ async function runLazyCli() {
     } catch {
     }
     bootstrapCloudServices();
+    try {
+      const { autoInitBrainHooks } = await import('./chunks/auto-init.mjs');
+      await autoInitBrainHooks();
+    } catch {
+    }
     const handled = await tryQuickProviderLaunch();
     if (handled) {
       spinner?.stop();