ccjk 10.1.0 → 10.2.0

package/dist/chunks/persistence.mjs

@@ -0,0 +1,667 @@
+import Database from 'better-sqlite3';
+import { existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'pathe';
+
+class ContextPersistence {
+  db;
+  dbPath;
+  constructor(dbPath) {
+    this.dbPath = dbPath || join(
+      process.env.HOME || process.env.USERPROFILE || ".",
+      ".ccjk",
+      "context",
+      "contexts.db"
+    );
+    const dir = dirname(this.dbPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(this.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.initSchema();
+  }
+  /**
+   * Initialize database schema
+   */
+  initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS contexts (
+        id TEXT PRIMARY KEY,
+        project_hash TEXT NOT NULL,
+        content TEXT NOT NULL,
+        compressed TEXT NOT NULL,
+        algorithm TEXT NOT NULL,
+        strategy TEXT NOT NULL,
+        original_tokens INTEGER NOT NULL,
+        compressed_tokens INTEGER NOT NULL,
+        compression_ratio REAL NOT NULL,
+        metadata TEXT NOT NULL DEFAULT '{}',
+        timestamp INTEGER NOT NULL,
+        last_accessed INTEGER NOT NULL,
+        access_count INTEGER NOT NULL DEFAULT 1
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_contexts_project ON contexts(project_hash);
+      CREATE INDEX IF NOT EXISTS idx_contexts_timestamp ON contexts(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_contexts_last_accessed ON contexts(last_accessed);
+      CREATE INDEX IF NOT EXISTS idx_contexts_access_count ON contexts(access_count);
+
+      -- FTS5 virtual table for full-text search
+      CREATE VIRTUAL TABLE IF NOT EXISTS contexts_fts USING fts5(
+        id UNINDEXED,
+        content,
+        compressed,
+        metadata,
+        tokenize = 'porter unicode61'
+      );
+
+      -- Triggers to keep FTS5 in sync with main table
+      CREATE TRIGGER IF NOT EXISTS contexts_ai AFTER INSERT ON contexts BEGIN
+        INSERT INTO contexts_fts(id, content, compressed, metadata)
+        VALUES (new.id, new.content, new.compressed, new.metadata);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS contexts_ad AFTER DELETE ON contexts BEGIN
+        DELETE FROM contexts_fts WHERE id = old.id;
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS contexts_au AFTER UPDATE ON contexts BEGIN
+        UPDATE contexts_fts
+        SET content = new.content,
+            compressed = new.compressed,
+            metadata = new.metadata
+        WHERE id = old.id;
+      END;
+
+      CREATE TABLE IF NOT EXISTS projects (
+        hash TEXT PRIMARY KEY,
+        path TEXT NOT NULL,
+        name TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        context_count INTEGER NOT NULL DEFAULT 0,
+        total_tokens INTEGER NOT NULL DEFAULT 0,
+        metadata TEXT NOT NULL DEFAULT '{}'
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_projects_created ON projects(created_at);
+      CREATE INDEX IF NOT EXISTS idx_projects_updated ON projects(updated_at);
+
+      -- Compression metrics table
+      CREATE TABLE IF NOT EXISTS compression_metrics (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        project_hash TEXT NOT NULL,
+        context_id TEXT NOT NULL,
+        original_tokens INTEGER NOT NULL,
+        compressed_tokens INTEGER NOT NULL,
+        compression_ratio REAL NOT NULL,
+        time_taken_ms INTEGER NOT NULL,
+        algorithm TEXT NOT NULL,
+        strategy TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        FOREIGN KEY (project_hash) REFERENCES projects(hash) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_metrics_project ON compression_metrics(project_hash);
+      CREATE INDEX IF NOT EXISTS idx_metrics_timestamp ON compression_metrics(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_metrics_context ON compression_metrics(context_id);
+
+      -- Composite indexes for hot/warm/cold queries
+      CREATE INDEX IF NOT EXISTS idx_contexts_hot ON contexts(project_hash, last_accessed DESC, access_count DESC);
+      CREATE INDEX IF NOT EXISTS idx_contexts_warm ON contexts(project_hash, timestamp DESC) WHERE access_count > 1;
+      CREATE INDEX IF NOT EXISTS idx_contexts_cold ON contexts(project_hash, timestamp ASC) WHERE access_count = 1;
+    `);
+  }
+  /**
+   * Save a compressed context
+   */
+  saveContext(context, projectHash, originalContent, timeTakenMs) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO contexts (
+        id, project_hash, content, compressed, algorithm, strategy,
+        original_tokens, compressed_tokens, compression_ratio,
+        metadata, timestamp, last_accessed, access_count
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const now = Date.now();
+    const existingContext = this.getContext(context.id);
+    const accessCount = existingContext ? existingContext.accessCount + 1 : 1;
+    stmt.run(
+      context.id,
+      projectHash,
+      originalContent || "",
+      // Store original content if provided
+      context.compressed,
+      context.algorithm,
+      context.strategy,
+      context.originalTokens,
+      context.compressedTokens,
+      context.compressionRatio,
+      JSON.stringify(context.metadata || {}),
+      context.compressedAt || now,
+      now,
+      accessCount
+    );
+    if (timeTakenMs !== void 0) {
+      this.saveCompressionMetric({
+        projectHash,
+        contextId: context.id,
+        originalTokens: context.originalTokens,
+        compressedTokens: context.compressedTokens,
+        compressionRatio: context.compressionRatio,
+        timeTakenMs,
+        algorithm: context.algorithm,
+        strategy: context.strategy,
+        timestamp: now
+      });
+    }
+    this.updateProjectStats(projectHash);
+  }
+  /**
+   * Get context by ID
+   */
+  getContext(contextId) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM contexts WHERE id = ?
+    `);
+    const row = stmt.get(contextId);
+    if (!row) return null;
+    this.updateLastAccessed(contextId);
+    return this.rowToContext(row);
+  }
+  /**
+   * Get contexts for a project
+   */
+  getProjectContexts(projectHash, options) {
+    let query = "SELECT * FROM contexts WHERE project_hash = ?";
+    const params = [projectHash];
+    if (options?.startTime) {
+      query += " AND timestamp >= ?";
+      params.push(options.startTime);
+    }
+    if (options?.endTime) {
+      query += " AND timestamp <= ?";
+      params.push(options.endTime);
+    }
+    const sortBy = options?.sortBy || "timestamp";
+    const sortOrder = options?.sortOrder || "desc";
+    query += ` ORDER BY ${sortBy} ${sortOrder.toUpperCase()}`;
+    if (options?.limit) {
+      query += " LIMIT ?";
+      params.push(options.limit);
+    }
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map((row) => this.rowToContext(row));
+  }
+  /**
+   * Query contexts with filters
+   */
+  queryContexts(options) {
+    let query = "SELECT * FROM contexts WHERE 1=1";
+    const params = [];
+    if (options?.projectHash) {
+      query += " AND project_hash = ?";
+      params.push(options.projectHash);
+    }
+    if (options?.startTime) {
+      query += " AND timestamp >= ?";
+      params.push(options.startTime);
+    }
+    if (options?.endTime) {
+      query += " AND timestamp <= ?";
+      params.push(options.endTime);
+    }
+    const sortBy = options?.sortBy || "timestamp";
+    const sortOrder = options?.sortOrder || "desc";
+    query += ` ORDER BY ${sortBy} ${sortOrder.toUpperCase()}`;
+    if (options?.limit) {
+      query += " LIMIT ?";
+      params.push(options.limit);
+    }
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map((row) => this.rowToContext(row));
+  }
+  /**
+   * Search contexts using FTS5 full-text search
+   * @param searchQuery - Search query (supports FTS5 syntax: AND, OR, NOT, NEAR, "phrases")
+   * @param options - Query options
+   * @returns Search results with ranking
+   */
+  searchContexts(searchQuery, options) {
+    if (!searchQuery || searchQuery.trim().length === 0) {
+      return [];
+    }
+    let query = `
+      SELECT
+        c.*,
+        bm25(contexts_fts) as rank,
+        snippet(contexts_fts, 1, '<mark>', '</mark>', '...', 32) as snippet
+      FROM contexts c
+      INNER JOIN contexts_fts ON contexts_fts.id = c.id
+      WHERE contexts_fts MATCH ?
+    `;
+    const params = [searchQuery];
+    if (options?.projectHash) {
+      query += " AND c.project_hash = ?";
+      params.push(options.projectHash);
+    }
+    if (options?.startTime) {
+      query += " AND c.timestamp >= ?";
+      params.push(options.startTime);
+    }
+    if (options?.endTime) {
+      query += " AND c.timestamp <= ?";
+      params.push(options.endTime);
+    }
+    const sortBy = options?.sortBy || "relevance";
+    const sortOrder = options?.sortOrder || "desc";
+    if (sortBy === "relevance") {
+      query += ` ORDER BY rank ${sortOrder === "asc" ? "DESC" : "ASC"}`;
+    } else {
+      query += ` ORDER BY c.${sortBy} ${sortOrder.toUpperCase()}`;
+    }
+    if (options?.limit) {
+      query += " LIMIT ?";
+      params.push(options.limit);
+    }
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map((row) => ({
+      ...this.rowToContext(row),
+      rank: row.rank,
+      snippet: row.snippet
+    }));
+  }
+  /**
+   * Get hot contexts (frequently accessed, recently used)
+   * @param projectHash - Project hash
+   * @param limit - Maximum number of results
+   */
+  getHotContexts(projectHash, limit = 10) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM contexts
+      WHERE project_hash = ?
+      ORDER BY last_accessed DESC, access_count DESC
+      LIMIT ?
+    `);
+    const rows = stmt.all(projectHash, limit);
+    return rows.map((row) => this.rowToContext(row));
+  }
+  /**
+   * Get warm contexts (accessed multiple times but not recently)
+   * @param projectHash - Project hash
+   * @param limit - Maximum number of results
+   */
+  getWarmContexts(projectHash, limit = 10) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM contexts
+      WHERE project_hash = ? AND access_count > 1
+      ORDER BY timestamp DESC
+      LIMIT ?
+    `);
+    const rows = stmt.all(projectHash, limit);
+    return rows.map((row) => this.rowToContext(row));
+  }
+  /**
+   * Get cold contexts (rarely accessed, older)
+   * @param projectHash - Project hash
+   * @param limit - Maximum number of results
+   */
+  getColdContexts(projectHash, limit = 10) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM contexts
+      WHERE project_hash = ? AND access_count = 1
+      ORDER BY timestamp ASC
+      LIMIT ?
+    `);
+    const rows = stmt.all(projectHash, limit);
+    return rows.map((row) => this.rowToContext(row));
+  }
+  /**
+   * Delete context by ID
+   */
+  deleteContext(contextId) {
+    const context = this.getContext(contextId);
+    if (!context) return false;
+    const stmt = this.db.prepare("DELETE FROM contexts WHERE id = ?");
+    const result = stmt.run(contextId);
+    if (context.projectHash) {
+      this.updateProjectStats(context.projectHash);
+    }
+    return result.changes > 0;
+  }
+  /**
+   * Delete all contexts for a project
+   */
+  deleteProjectContexts(projectHash) {
+    const stmt = this.db.prepare("DELETE FROM contexts WHERE project_hash = ?");
+    const result = stmt.run(projectHash);
+    this.updateProjectStats(projectHash);
+    return result.changes;
+  }
+  /**
+   * Register or update project
+   */
+  registerProject(projectHash, projectPath, projectName) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO projects (hash, path, name, created_at, updated_at, context_count, total_tokens, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const now = Date.now();
+    const existing = this.getProject(projectHash);
+    const createdAt = existing?.created_at || now;
+    stmt.run(
+      projectHash,
+      projectPath,
+      projectName || null,
+      createdAt,
+      now,
+      existing?.context_count || 0,
+      existing?.total_tokens || 0,
+      JSON.stringify(existing?.metadata || {})
+    );
+  }
+  /**
+   * Get project info
+   */
+  getProject(projectHash) {
+    const stmt = this.db.prepare("SELECT * FROM projects WHERE hash = ?");
+    return stmt.get(projectHash);
+  }
+  /**
+   * List all projects
+   */
+  listProjects() {
+    const stmt = this.db.prepare("SELECT * FROM projects ORDER BY updated_at DESC");
+    return stmt.all();
+  }
+  /**
+   * Get context statistics
+   */
+  getStats(projectHash) {
+    let query = "SELECT COUNT(*) as count, SUM(original_tokens) as orig, SUM(compressed_tokens) as comp, MIN(timestamp) as oldest, MAX(timestamp) as newest FROM contexts";
+    const params = [];
+    if (projectHash) {
+      query += " WHERE project_hash = ?";
+      params.push(projectHash);
+    }
+    const stmt = this.db.prepare(query);
+    const row = stmt.get(...params);
+    const totalProjects = projectHash ? 1 : this.db.prepare("SELECT COUNT(*) as count FROM projects").get().count;
+    const avgRatio = row.orig > 0 ? (row.orig - row.comp) / row.orig : 0;
+    return {
+      totalContexts: row.count || 0,
+      totalProjects,
+      totalOriginalTokens: row.orig || 0,
+      totalCompressedTokens: row.comp || 0,
+      averageCompressionRatio: avgRatio,
+      totalSize: this.getDatabaseSize(),
+      oldestContext: row.oldest || void 0,
+      newestContext: row.newest || void 0
+    };
+  }
+  /**
+   * Clean up old contexts
+   */
+  cleanup(maxAge) {
+    const cutoff = Date.now() - maxAge;
+    const stmt = this.db.prepare("DELETE FROM contexts WHERE timestamp < ?");
+    const result = stmt.run(cutoff);
+    const projects = this.listProjects();
+    for (const project of projects) {
+      this.updateProjectStats(project.hash);
+    }
+    return result.changes;
+  }
+  /**
+   * Vacuum database to reclaim space
+   */
+  vacuum() {
+    this.db.exec("VACUUM");
+  }
+  /**
+   * Close database
+   */
+  close() {
+    this.db.close();
+  }
+  /**
+   * Get database size in bytes
+   */
+  getDatabaseSize() {
+    try {
+      const fs = require("node:fs");
+      const stats = fs.statSync(this.dbPath);
+      return stats.size;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Export contexts to JSON
+   */
+  exportContexts(projectHash) {
+    return this.queryContexts({ projectHash });
+  }
+  /**
+   * Import contexts from JSON
+   */
+  importContexts(contexts) {
+    let imported = 0;
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO contexts (
+        id, project_hash, content, compressed, algorithm, strategy,
+        original_tokens, compressed_tokens, compression_ratio,
+        metadata, timestamp, last_accessed, access_count
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    for (const context of contexts) {
+      try {
+        stmt.run(
+          context.id,
+          context.projectHash,
+          context.content,
+          context.compressed,
+          context.algorithm,
+          context.strategy,
+          context.originalTokens,
+          context.compressedTokens,
+          context.compressionRatio,
+          context.metadata,
+          context.timestamp,
+          context.lastAccessed,
+          context.accessCount
+        );
+        imported++;
+      } catch {
+      }
+    }
+    return imported;
+  }
+  /**
+   * Update last accessed time
+   */
+  updateLastAccessed(contextId) {
+    const stmt = this.db.prepare(`
+      UPDATE contexts
+      SET last_accessed = ?, access_count = access_count + 1
+      WHERE id = ?
+    `);
+    stmt.run(Date.now(), contextId);
+  }
+  /**
+   * Update project statistics
+   */
+  updateProjectStats(projectHash) {
+    const stmt = this.db.prepare(`
+      UPDATE projects
+      SET
+        context_count = (SELECT COUNT(*) FROM contexts WHERE project_hash = ?),
+        total_tokens = (SELECT COALESCE(SUM(original_tokens), 0) FROM contexts WHERE project_hash = ?),
+        updated_at = ?
+      WHERE hash = ?
+    `);
+    stmt.run(projectHash, projectHash, Date.now(), projectHash);
+  }
+  /**
+   * Convert database row to PersistedContext
+   */
+  rowToContext(row) {
+    return {
+      id: row.id,
+      projectHash: row.project_hash,
+      content: row.content,
+      compressed: row.compressed,
+      algorithm: row.algorithm,
+      strategy: row.strategy,
+      originalTokens: row.original_tokens,
+      compressedTokens: row.compressed_tokens,
+      compressionRatio: row.compression_ratio,
+      metadata: row.metadata,
+      timestamp: row.timestamp,
+      lastAccessed: row.last_accessed,
+      accessCount: row.access_count
+    };
+  }
+  /**
+   * Save compression metric
+   */
+  saveCompressionMetric(metric) {
+    const stmt = this.db.prepare(`
+      INSERT INTO compression_metrics (
+        project_hash, context_id, original_tokens, compressed_tokens,
+        compression_ratio, time_taken_ms, algorithm, strategy, timestamp
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      metric.projectHash,
+      metric.contextId,
+      metric.originalTokens,
+      metric.compressedTokens,
+      metric.compressionRatio,
+      metric.timeTakenMs,
+      metric.algorithm,
+      metric.strategy,
+      metric.timestamp
+    );
+  }
+  /**
+   * Get compression metrics statistics
+   */
+  getCompressionMetricsStats(projectHash, options) {
+    const now = Date.now();
+    const sessionStart = now - 24 * 60 * 60 * 1e3;
+    const weekStart = now - 7 * 24 * 60 * 60 * 1e3;
+    const monthStart = now - 30 * 24 * 60 * 60 * 1e3;
+    let baseQuery = "SELECT * FROM compression_metrics WHERE 1=1";
+    const params = [];
+    if (projectHash) {
+      baseQuery += " AND project_hash = ?";
+      params.push(projectHash);
+    }
+    if (options?.startTime) {
+      baseQuery += " AND timestamp >= ?";
+      params.push(options.startTime);
+    }
+    if (options?.endTime) {
+      baseQuery += " AND timestamp <= ?";
+      params.push(options.endTime);
+    }
+    const stmt = this.db.prepare(baseQuery);
+    const metrics = stmt.all(...params);
+    const totalCompressions = metrics.length;
+    const totalOriginalTokens = metrics.reduce((sum, m) => sum + m.original_tokens, 0);
+    const totalCompressedTokens = metrics.reduce((sum, m) => sum + m.compressed_tokens, 0);
+    const totalTokensSaved = totalOriginalTokens - totalCompressedTokens;
+    const averageCompressionRatio = totalCompressions > 0 ? metrics.reduce((sum, m) => sum + m.compression_ratio, 0) / totalCompressions : 0;
+    const averageTimeTakenMs = totalCompressions > 0 ? metrics.reduce((sum, m) => sum + m.time_taken_ms, 0) / totalCompressions : 0;
+    const COST_PER_1K_TOKENS = 0.015;
+    const estimatedCostSavings = totalTokensSaved / 1e3 * COST_PER_1K_TOKENS;
+    const sessionMetrics = metrics.filter((m) => m.timestamp >= sessionStart);
+    const sessionTokensSaved = sessionMetrics.reduce(
+      (sum, m) => sum + (m.original_tokens - m.compressed_tokens),
+      0
+    );
+    const weeklyMetrics = metrics.filter((m) => m.timestamp >= weekStart);
+    const weeklyTokensSaved = weeklyMetrics.reduce(
+      (sum, m) => sum + (m.original_tokens - m.compressed_tokens),
+      0
+    );
+    const monthlyMetrics = metrics.filter((m) => m.timestamp >= monthStart);
+    const monthlyTokensSaved = monthlyMetrics.reduce(
+      (sum, m) => sum + (m.original_tokens - m.compressed_tokens),
+      0
+    );
+    return {
+      totalCompressions,
+      totalOriginalTokens,
+      totalCompressedTokens,
+      totalTokensSaved,
+      averageCompressionRatio,
+      averageTimeTakenMs,
+      estimatedCostSavings,
+      sessionStats: {
+        compressions: sessionMetrics.length,
+        tokensSaved: sessionTokensSaved,
+        costSavings: sessionTokensSaved / 1e3 * COST_PER_1K_TOKENS
+      },
+      weeklyStats: {
+        compressions: weeklyMetrics.length,
+        tokensSaved: weeklyTokensSaved,
+        costSavings: weeklyTokensSaved / 1e3 * COST_PER_1K_TOKENS
+      },
+      monthlyStats: {
+        compressions: monthlyMetrics.length,
+        tokensSaved: monthlyTokensSaved,
+        costSavings: monthlyTokensSaved / 1e3 * COST_PER_1K_TOKENS
+      }
+    };
+  }
+  /**
+   * Get recent compression metrics
+   */
+  getRecentCompressionMetrics(projectHash, limit = 10) {
+    let query = "SELECT * FROM compression_metrics";
+    const params = [];
+    if (projectHash) {
+      query += " WHERE project_hash = ?";
+      params.push(projectHash);
+    }
+    query += " ORDER BY timestamp DESC LIMIT ?";
+    params.push(limit);
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map((row) => ({
+      id: row.id,
+      projectHash: row.project_hash,
+      contextId: row.context_id,
+      originalTokens: row.original_tokens,
+      compressedTokens: row.compressed_tokens,
+      compressionRatio: row.compression_ratio,
+      timeTakenMs: row.time_taken_ms,
+      algorithm: row.algorithm,
+      strategy: row.strategy,
+      timestamp: row.timestamp
+    }));
+  }
+  /**
+   * Clean up old compression metrics
+   */
+  cleanupCompressionMetrics(maxAge) {
+    const cutoff = Date.now() - maxAge;
+    const stmt = this.db.prepare("DELETE FROM compression_metrics WHERE timestamp < ?");
+    const result = stmt.run(cutoff);
+    return result.changes;
+  }
+}
+let globalContextPersistence = null;
+function getContextPersistence(dbPath) {
+  if (!globalContextPersistence) {
+    globalContextPersistence = new ContextPersistence(dbPath);
+  }
+  return globalContextPersistence;
+}
+
+export { ContextPersistence, getContextPersistence };

package/dist/chunks/platform.mjs

@@ -388,4 +388,4 @@ const platform = {
   wrapCommandWithSudo: wrapCommandWithSudo
 };
 
-export { isTermux as a, getMcpCommand as b, commandExists as c, getPlatform as d, getHomebrewCommandPaths as e, findCommandPath as f, getSystemRoot as g, getTermuxPrefix as h, isWindows as i, isWSL as j, getWSLInfo as k, getRecommendedInstallMethods as l, findRealCommandPath as m, normalizeTomlPath as n, platform as p, shouldUseSudoForGlobalInstall as s, wrapCommandWithSudo as w };
+export { getHomebrewCommandPaths as a, isTermux as b, getTermuxPrefix as c, isWSL as d, getWSLInfo as e, findCommandPath as f, getPlatform as g, commandExists as h, isWindows as i, getRecommendedInstallMethods as j, findRealCommandPath as k, getSystemRoot as l, getMcpCommand as m, normalizeTomlPath as n, platform as p, shouldUseSudoForGlobalInstall as s, wrapCommandWithSudo as w };

package/dist/chunks/plugin.mjs

@@ -4,7 +4,7 @@ import { Buffer } from 'node:buffer';
 import { existsSync, mkdirSync, readFileSync, unlinkSync, readdirSync, statSync, rmSync } from 'node:fs';
 import { join } from 'pathe';
 import { CCJK_CLOUD_PLUGINS_DIR, CCJK_CLOUD_PLUGINS_CACHE_DIR, CCJK_CLOUD_PLUGINS_INSTALLED_DIR } from './constants.mjs';
-import { i18n } from './index.mjs';
+import { i18n } from './index2.mjs';
 import { writeFileAtomic } from './fs-operations.mjs';
 import { homedir } from 'node:os';
 import { d as detectProject } from '../shared/ccjk.CBhIZiPz.mjs';

package/dist/chunks/prompts.mjs

@@ -3,7 +3,7 @@ import ansis from 'ansis';
 import inquirer from 'inquirer';
 import { version } from './package.mjs';
 import { LANG_LABELS, getAiOutputLanguageLabel, SUPPORTED_LANGS, AI_OUTPUT_LANGUAGES } from './constants.mjs';
-import { ensureI18nInitialized, i18n } from './index.mjs';
+import { ensureI18nInitialized, i18n } from './index2.mjs';
 import { readZcfConfig, updateZcfConfig } from './ccjk-config.mjs';
 import { a as addNumbersToChoices } from '../shared/ccjk.BFQ7yr5S.mjs';
 import { p as promptBoolean } from '../shared/ccjk.DHbrGcgg.mjs';

package/dist/chunks/providers.mjs

@@ -1,6 +1,6 @@
 import ansis from 'ansis';
 import { getApiProviderPresets } from './api-providers.mjs';
-import { i18n } from './index.mjs';
+import { i18n } from './index2.mjs';
 import { P as ProviderHealthMonitor } from '../shared/ccjk.J8YiPsOw.mjs';
 import './constants.mjs';
 import 'node:os';