ccjk 12.2.2 → 12.3.1

package/dist/chunks/convoy-manager.mjs

@@ -1,12 +1,364 @@
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { glob } from 'tinyglobby';
+import { e as executionTracer } from '../shared/ccjk.BfIpomdz.mjs';
+import { f as fsParadigm } from '../shared/ccjk.BxSmJ8B7.mjs';
+import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
 import 'node:child_process';
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
 import 'node:fs/promises';
 import { homedir } from 'node:os';
 import 'node:path';
 import { EventEmitter } from 'node:events';
 import { n as nanoid } from '../shared/ccjk.BoApaI4j.mjs';
 import { x as K } from './main.mjs';
-import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
+
+const DEPTH_TOKEN_BUDGETS = {
+  L0: 100,
+  // Abstract summary only
+  L1: 2e3,
+  // Overview
+  L2: Number.POSITIVE_INFINITY
+  // Full content
+};
+const PHASE_BUDGET_MULTIPLIERS = {
+  exploring: 2,
+  executing: 0.6,
+  generating: 0.4,
+  reviewing: 1.2,
+  idle: 1
+};
+const CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function truncateToDepth(content, depth) {
+  if (depth === "L2") return content;
+  const maxChars = DEPTH_TOKEN_BUDGETS[depth] * CHARS_PER_TOKEN;
+  if (content.length <= maxChars) return content;
+  if (depth === "L0") {
+    const firstPara = content.split(/\n\n/)[0];
+    return firstPara.length <= maxChars ? firstPara : content.slice(0, maxChars);
+  }
+  return `${content.slice(0, maxChars)}
+... (truncated, use L2 for full content)`;
+}
+class ContextLoader {
+  cache = /* @__PURE__ */ new Map();
+  defaultMaxSize = 1e5;
+  // 100KB default
+  defaultTokenBudget = 8e3;
+  // ~32KB at 4 chars/token
+  /**
+   * Resolve effective depth from options.
+   * If depth is explicit, use it. Otherwise derive from tokenBudget.
+   */
+  resolveDepth(tokenBudget, explicitDepth) {
+    if (explicitDepth) return explicitDepth;
+    if (tokenBudget <= DEPTH_TOKEN_BUDGETS.L0) return "L0";
+    if (tokenBudget <= DEPTH_TOKEN_BUDGETS.L1) return "L1";
+    return "L2";
+  }
+  /**
+   * Load context hierarchically with OpenViking-style tiered depth control.
+   * Pass tokenBudget to automatically select L0/L1/L2 depth.
+   */
+  async load(options = {}) {
+    const {
+      projectRoot = process.cwd(),
+      maxSize = this.defaultMaxSize,
+      tokenBudget,
+      depth: explicitDepth,
+      layers = ["project", "domain", "task", "execution"],
+      task
+    } = options;
+    const phaseMultiplier = options.taskPhase ? PHASE_BUDGET_MULTIPLIERS[options.taskPhase] ?? 1 : 1;
+    const effectiveBudget = Math.round((tokenBudget ?? this.defaultTokenBudget) * phaseMultiplier);
+    const depth = this.resolveDepth(effectiveBudget, explicitDepth);
+    const cacheKey = this.getCacheKey(projectRoot, layers, task?.id, depth);
+    const cached = this.cache.get(cacheKey);
+    if (cached && Date.now() - cached.loadedAt < 6e4) {
+      executionTracer.logEvent("context-load", {
+        source: "cache",
+        layers: layers.length,
+        size: cached.totalSize,
+        tokens: cached.totalTokens,
+        depth
+      });
+      return cached;
+    }
+    const context = {
+      layers: /* @__PURE__ */ new Map(),
+      totalSize: 0,
+      totalTokens: 0,
+      loadedAt: Date.now(),
+      depth
+    };
+    for (const layer of layers) {
+      const entries = await this.loadLayer(layer, projectRoot, task, depth);
+      if (entries.length > 0) {
+        context.layers.set(layer, entries);
+        context.totalSize += entries.reduce((sum, e) => sum + e.content.length, 0);
+        context.totalTokens += entries.reduce((sum, e) => sum + e.tokenEstimate, 0);
+      }
+      if (context.totalSize > maxSize || context.totalTokens > effectiveBudget) {
+        break;
+      }
+    }
+    this.cache.set(cacheKey, context);
+    executionTracer.logEvent("context-load", {
+      source: "fresh",
+      layers: context.layers.size,
+      size: context.totalSize,
+      tokens: context.totalTokens,
+      depth
+    });
+    return context;
+  }
+  /**
+   * Load a specific context layer
+   */
+  async loadLayer(layer, projectRoot, task, depth = "L2") {
+    switch (layer) {
+      case "project":
+        return this.loadProjectContext(projectRoot, depth);
+      case "domain":
+        return this.loadDomainContext(projectRoot, task, depth);
+      case "task":
+        return this.loadTaskContext(task, depth);
+      case "execution":
+        return this.loadExecutionContext(task, depth);
+      default:
+        return [];
+    }
+  }
+  /**
+   * Load project-level context
+   * - README.md
+   * - CLAUDE.md
+   * - package.json
+   * - tsconfig.json
+   */
+  async loadProjectContext(projectRoot, depth = "L2") {
+    const entries = [];
+    const files = ["README.md", "CLAUDE.md", "package.json", "tsconfig.json"];
+    for (const file of files) {
+      const path = join(projectRoot, file);
+      if (existsSync(path)) {
+        const raw = readFileSync(path, "utf-8");
+        const content = truncateToDepth(raw, depth);
+        entries.push({
+          layer: "project",
+          source: file,
+          content,
+          priority: 100,
+          depth,
+          tokenEstimate: estimateTokens(content),
+          metadata: { path }
+        });
+      }
+    }
+    return entries;
+  }
+  /**
+   * Load domain-specific context
+   * Based on task type/domain, load relevant files
+   */
+  async loadDomainContext(projectRoot, task, depth = "L2") {
+    if (!task) return [];
+    const entries = [];
+    const structure = await fsParadigm.detect(projectRoot);
+    const domain = this.inferDomain(task);
+    if (!domain) {
+      const sourceFiles = fsParadigm.getFilesByRole(structure, "source");
+      for (const file of sourceFiles.slice(0, 3)) {
+        try {
+          const raw = readFileSync(file, "utf-8");
+          const content = truncateToDepth(raw, depth);
+          entries.push({
+            layer: "domain",
+            source: file.replace(projectRoot, ""),
+            content,
+            priority: 75,
+            depth,
+            tokenEstimate: estimateTokens(content),
+            metadata: { paradigm: structure.paradigm, path: file }
+          });
+        } catch {
+        }
+      }
+      return entries;
+    }
+    const patterns = this.getDomainPatterns(domain, structure.paradigm);
+    for (const pattern of patterns) {
+      const files = await glob([pattern], {
+        cwd: projectRoot,
+        absolute: true,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+      });
+      for (const file of files.slice(0, 5)) {
+        try {
+          const raw = readFileSync(file, "utf-8");
+          const content = truncateToDepth(raw, depth);
+          entries.push({
+            layer: "domain",
+            source: file.replace(projectRoot, ""),
+            content,
+            priority: 80,
+            depth,
+            tokenEstimate: estimateTokens(content),
+            metadata: { domain, paradigm: structure.paradigm, path: file }
+          });
+        } catch {
+        }
+      }
+    }
+    return entries;
+  }
+  /**
+   * Load task-specific context
+   */
+  async loadTaskContext(task, depth = "L2") {
+    if (!task) return [];
+    const entries = [];
+    if (task.description) {
+      const content = truncateToDepth(task.description, depth);
+      entries.push({
+        layer: "task",
+        source: "task-description",
+        content,
+        priority: 90,
+        depth,
+        tokenEstimate: estimateTokens(content),
+        metadata: { taskId: task.id }
+      });
+    }
+    if (task.input && depth !== "L0") {
+      const content = truncateToDepth(JSON.stringify(task.input, null, 2), depth);
+      entries.push({
+        layer: "task",
+        source: "task-input",
+        content,
+        priority: 85,
+        depth,
+        tokenEstimate: estimateTokens(content),
+        metadata: { taskId: task.id }
+      });
+    }
+    return entries;
+  }
+  /**
+   * Load execution-specific context
+   * - Recent errors
+   * - Previous attempts
+   * - Related task outputs
+   */
+  async loadExecutionContext(task, depth = "L2") {
+    if (!task) return [];
+    const entries = [];
+    if (task.output && depth !== "L0") {
+      const content = truncateToDepth(JSON.stringify(task.output, null, 2), depth);
+      entries.push({
+        layer: "execution",
+        source: "previous-output",
+        content,
+        priority: 70,
+        depth,
+        tokenEstimate: estimateTokens(content),
+        metadata: { taskId: task.id }
+      });
+    }
+    return entries;
+  }
+  /**
+   * Infer domain from task
+   */
+  inferDomain(task) {
+    const text = `${task.name} ${task.description || ""}`.toLowerCase();
+    const domains = {
+      api: ["api", "endpoint", "route", "controller"],
+      ui: ["ui", "component", "view", "page", "frontend"],
+      database: ["database", "db", "schema", "migration", "model"],
+      auth: ["auth", "login", "user", "permission", "session"],
+      test: ["test", "spec", "e2e", "unit", "integration"],
+      config: ["config", "settings", "env", "setup"]
+    };
+    for (const [domain, keywords] of Object.entries(domains)) {
+      if (keywords.some((kw) => text.includes(kw))) {
+        return domain;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get file patterns for a domain (paradigm-aware)
+   */
+  getDomainPatterns(domain, paradigm) {
+    const basePatterns = {
+      api: ["**/api/**/*.ts", "**/routes/**/*.ts", "**/controllers/**/*.ts"],
+      ui: ["**/components/**/*.{tsx,vue}", "**/pages/**/*.{tsx,vue}", "**/views/**/*.{tsx,vue}"],
+      database: ["**/models/**/*.ts", "**/schema/**/*.ts", "**/migrations/**/*.ts"],
+      auth: ["**/auth/**/*.ts", "**/middleware/auth*.ts"],
+      test: ["**/*.test.ts", "**/*.spec.ts"],
+      config: ["**/config/**/*.ts", "**/*.config.ts"]
+    };
+    let patterns = basePatterns[domain] || [];
+    if (paradigm === "monorepo") {
+      patterns = patterns.map((p) => `packages/*/${p}`);
+    } else if (paradigm === "fullstack") {
+      if (domain === "ui") {
+        patterns = patterns.map((p) => `client/${p}`);
+      } else if (domain === "api") {
+        patterns = patterns.map((p) => `server/${p}`);
+      }
+    }
+    return patterns;
+  }
+  /**
+   * Get cache key
+   */
+  getCacheKey(projectRoot, layers, taskId, depth = "L2") {
+    return `${projectRoot}:${layers.join(",")}:${taskId || "none"}:${depth}`;
+  }
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Format context for LLM consumption
+   */
+  formatForLLM(context) {
+    const sections = [];
+    sections.push(`<!-- context depth=${context.depth} tokens\u2248${context.totalTokens} -->
+`);
+    const layerOrder = ["project", "domain", "task", "execution"];
+    for (const layer of layerOrder) {
+      const entries = context.layers.get(layer);
+      if (!entries || entries.length === 0) continue;
+      sections.push(`# ${layer.toUpperCase()} CONTEXT
+`);
+      const sorted = entries.sort((a, b) => b.priority - a.priority);
+      for (const entry of sorted) {
+        sections.push(`## ${entry.source} [${entry.depth}]
+`);
+        sections.push(entry.content);
+        sections.push("\n");
+      }
+    }
+    return sections.join("\n");
+  }
+}
+const contextLoader = new ContextLoader();
+async function loadContextAtDepth(depth, options = {}) {
+  return contextLoader.load({ ...options, depth });
+}
+
+const contextLoader$1 = {
+  __proto__: null,
+  ContextLoader: ContextLoader,
+  contextLoader: contextLoader,
+  loadContextAtDepth: loadContextAtDepth
+};
 
 function detectTaskPhase(history) {
   if (history.length === 0) return "idle";
@@ -982,4 +1334,4 @@ const convoyManager = {
   getGlobalConvoyManager: getGlobalConvoyManager
 };
 
-export { SessionIntelligence as S, getGlobalStateManager as a, gitBackedState as b, convoyManager as c, getGlobalConvoyManager as g };
+export { SessionIntelligence as S, getGlobalStateManager as a, contextLoader$1 as b, contextLoader as c, gitBackedState as d, convoyManager as e, getGlobalConvoyManager as g };

package/dist/chunks/dashboard.mjs

@@ -1,8 +1,8 @@
-import a from './index2.mjs';
+import a from './index3.mjs';
 import { existsSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import process__default from 'node:process';
-import { i18n } from './index5.mjs';
+import { i18n } from './index6.mjs';
 import { createHash } from 'node:crypto';
 import { exec as q } from './main.mjs';
 import { n as normalize, j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';

package/dist/chunks/doctor.mjs

@@ -1,15 +1,15 @@
 import { existsSync, mkdirSync, statSync, writeFileSync, readFileSync, copyFileSync, readdirSync } from 'node:fs';
 import process__default from 'node:process';
-import a from './index2.mjs';
-import { i as inquirer } from './index3.mjs';
+import a from './index3.mjs';
+import { i as inquirer } from './index4.mjs';
 import { getApiProviderPresets } from './api-providers.mjs';
 import { SETTINGS_FILE, CLAUDE_DIR } from './constants.mjs';
-import { i18n } from './index5.mjs';
+import { i18n } from './index6.mjs';
 import { g as getPermissionManager } from '../shared/ccjk.SPoXMvZD.mjs';
 import { e as commandExists } from './platform.mjs';
 import { P as ProviderHealthMonitor } from '../shared/ccjk.J8YiPsOw.mjs';
 import { platform, userInfo, homedir } from 'node:os';
-import ora from './index7.mjs';
+import ora from './index8.mjs';
 import { exec as q } from './main.mjs';
 import { STATUS } from './banner.mjs';
 import { writeFileAtomic } from './fs-operations.mjs';

package/dist/chunks/evolution.mjs

@@ -1,6 +1,6 @@
-import a from './index2.mjs';
+import a from './index3.mjs';
 import { getCloudBaseUrl } from './constants.mjs';
-import { i18n } from './index5.mjs';
+import { i18n } from './index6.mjs';
 import '../shared/ccjk.BAGoDD49.mjs';
 import 'node:os';
 import '../shared/ccjk.bQ7Dh1g4.mjs';