ccjk 12.2.2 → 12.3.2

package/dist/chunks/context-loader.mjs

@@ -1,351 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { glob } from 'tinyglobby';
-import { e as executionTracer } from '../shared/ccjk.CePkJq2S.mjs';
-import { f as fsParadigm } from '../shared/ccjk.BxSmJ8B7.mjs';
-import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
-import './index2.mjs';
-import '../shared/ccjk.BAGoDD49.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 });
-}
-
-export { ContextLoader, contextLoader, loadContextAtDepth };