@holoscript/core 7.0.0 → 8.0.0

package/dist/codebase/index.cjs

@@ -0,0 +1,336 @@
+'use strict';
+
+require('../chunk-HCCQLAA4.cjs');
+var crypto = require('crypto');
+
+var DEFAULT_CONFIG = {
+  semanticThreshold: 0.92,
+  numHashFunctions: 128,
+  numBands: 16,
+  shingleSize: 3,
+  qualityWeighted: true
+};
+var DedupFilter = class {
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Run full dedup pipeline on a set of items
+   */
+  dedup(items) {
+    const startTime = Date.now();
+    const removals = [];
+    const { unique: exactUnique, removals: exactRemovals } = this.exactDedup(items);
+    removals.push(...exactRemovals);
+    const { unique: semanticUnique, removals: semanticRemovals } = this.semanticDedup(exactUnique);
+    removals.push(...semanticRemovals);
+    const report = {
+      totalInput: items.length,
+      exactDuplicates: exactRemovals.length,
+      semanticDuplicates: semanticRemovals.length,
+      retained: semanticUnique.length,
+      removedDetails: removals,
+      processingTimeMs: Date.now() - startTime
+    };
+    return { retained: semanticUnique, report };
+  }
+  /**
+   * Layer 1: Exact dedup via SHA-256 hash
+   */
+  exactDedup(items) {
+    const hashMap = /* @__PURE__ */ new Map();
+    const removals = [];
+    for (const item of items) {
+      const hash = this.sha256(item.content);
+      const existing = hashMap.get(hash);
+      if (existing) {
+        if (this.config.qualityWeighted && (item.quality ?? 0) > (existing.quality ?? 0)) {
+          removals.push({ removedId: existing.id, keptId: item.id, reason: "exact" });
+          hashMap.set(hash, item);
+        } else {
+          removals.push({ removedId: item.id, keptId: existing.id, reason: "exact" });
+        }
+      } else {
+        hashMap.set(hash, item);
+      }
+    }
+    return { unique: Array.from(hashMap.values()), removals };
+  }
+  /**
+   * Layer 2: Semantic near-dedup via MinHash LSH (Jaccard similarity)
+   */
+  semanticDedup(items) {
+    if (items.length <= 1) return { unique: items, removals: [] };
+    const removals = [];
+    const removed = /* @__PURE__ */ new Set();
+    const signatures = items.map((item) => ({
+      item,
+      shingles: this.shingle(item.content),
+      minhash: this.minhash(this.shingle(item.content))
+    }));
+    const bandSize = Math.floor(this.config.numHashFunctions / this.config.numBands);
+    const candidatePairs = /* @__PURE__ */ new Set();
+    for (let band = 0; band < this.config.numBands; band++) {
+      const buckets = /* @__PURE__ */ new Map();
+      const start = band * bandSize;
+      const end = start + bandSize;
+      for (let i = 0; i < signatures.length; i++) {
+        const bandHash = signatures[i].minhash.slice(start, end).join(",");
+        const bucket = buckets.get(bandHash) ?? [];
+        bucket.push(i);
+        buckets.set(bandHash, bucket);
+      }
+      for (const bucket of buckets.values()) {
+        for (let i = 0; i < bucket.length; i++) {
+          for (let j = i + 1; j < bucket.length; j++) {
+            const key = `${Math.min(bucket[i], bucket[j])},${Math.max(bucket[i], bucket[j])}`;
+            candidatePairs.add(key);
+          }
+        }
+      }
+    }
+    for (const pair of candidatePairs) {
+      const [iStr, jStr] = pair.split(",");
+      const i = parseInt(iStr, 10);
+      const j = parseInt(jStr, 10);
+      if (removed.has(signatures[i].item.id) || removed.has(signatures[j].item.id)) continue;
+      const similarity = this.jaccardSimilarity(signatures[i].shingles, signatures[j].shingles);
+      if (similarity >= this.config.semanticThreshold) {
+        const itemA = signatures[i].item;
+        const itemB = signatures[j].item;
+        if (this.config.qualityWeighted && (itemA.quality ?? 0) >= (itemB.quality ?? 0)) {
+          removed.add(itemB.id);
+          removals.push({ removedId: itemB.id, keptId: itemA.id, reason: "semantic", similarity });
+        } else {
+          removed.add(itemA.id);
+          removals.push({ removedId: itemA.id, keptId: itemB.id, reason: "semantic", similarity });
+        }
+      }
+    }
+    const unique = items.filter((item) => !removed.has(item.id));
+    return { unique, removals };
+  }
+  // ---- Private helpers ----
+  sha256(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+  }
+  shingle(text) {
+    const shingles = /* @__PURE__ */ new Set();
+    const words = text.toLowerCase().split(/\s+/);
+    for (let i = 0; i <= words.length - this.config.shingleSize; i++) {
+      shingles.add(words.slice(i, i + this.config.shingleSize).join(" "));
+    }
+    return shingles;
+  }
+  minhash(shingles) {
+    const signature = new Array(this.config.numHashFunctions).fill(Infinity);
+    for (const shingle of shingles) {
+      for (let i = 0; i < this.config.numHashFunctions; i++) {
+        const hash = this.hashWithSeed(shingle, i);
+        if (hash < signature[i]) {
+          signature[i] = hash;
+        }
+      }
+    }
+    return signature;
+  }
+  hashWithSeed(value, seed) {
+    let hash = 2166136261 ^ seed;
+    for (let i = 0; i < value.length; i++) {
+      hash ^= value.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return hash >>> 0;
+  }
+  jaccardSimilarity(a, b) {
+    let intersection = 0;
+    for (const item of a) {
+      if (b.has(item)) intersection++;
+    }
+    const union = a.size + b.size - intersection;
+    return union === 0 ? 0 : intersection / union;
+  }
+};
+function createDedupFilter(config) {
+  return new DedupFilter(config);
+}
+
+// src/codebase/GodFileDetector.ts
+var DEFAULT_THRESHOLDS = {
+  loc_warning: 500,
+  loc_god: 1e3,
+  functions_warning: 20,
+  functions_god: 40,
+  complexity_god: 50,
+  imports_god: 30
+};
+var GodFileDetector = class {
+  constructor(thresholds) {
+    this.thresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
+  }
+  /**
+   * Analyze a file's content and produce metrics + classification
+   */
+  analyze(filePath, content) {
+    const metrics = this.computeMetrics(filePath, content);
+    const reasons = [];
+    let classification = "normal";
+    if (metrics.loc >= this.thresholds.loc_god) {
+      reasons.push(`LOC ${metrics.loc} >= ${this.thresholds.loc_god} (god file threshold)`);
+      classification = "god_file";
+    } else if (metrics.loc >= this.thresholds.loc_warning) {
+      reasons.push(`LOC ${metrics.loc} >= ${this.thresholds.loc_warning} (warning threshold)`);
+      classification = "warning";
+    }
+    if (metrics.functionCount >= this.thresholds.functions_god) {
+      reasons.push(
+        `Functions ${metrics.functionCount} >= ${this.thresholds.functions_god} (god file threshold)`
+      );
+      classification = "god_file";
+    } else if (metrics.functionCount >= this.thresholds.functions_warning) {
+      reasons.push(
+        `Functions ${metrics.functionCount} >= ${this.thresholds.functions_warning} (warning threshold)`
+      );
+      if (classification !== "god_file") classification = "warning";
+    }
+    if (metrics.cyclomaticComplexity >= this.thresholds.complexity_god) {
+      reasons.push(
+        `Cyclomatic complexity ${metrics.cyclomaticComplexity} >= ${this.thresholds.complexity_god}`
+      );
+      classification = "god_file";
+    }
+    if (metrics.importCount >= this.thresholds.imports_god) {
+      reasons.push(`Imports ${metrics.importCount} >= ${this.thresholds.imports_god}`);
+      if (classification !== "god_file") classification = "warning";
+    }
+    const report = {
+      filePath,
+      classification,
+      metrics,
+      reasons
+    };
+    if (classification === "god_file") {
+      report.splitPlan = this.suggestSplit(filePath, content, metrics);
+    }
+    return report;
+  }
+  /**
+   * Compute metrics for a file
+   */
+  computeMetrics(filePath, content) {
+    const lines = content.split("\n");
+    const loc = lines.filter((l) => l.trim().length > 0 && !l.trim().startsWith("//")).length;
+    const functionPattern = /\b(function\s+\w+|(?:async\s+)?(?:get|set)?\s*\w+\s*\(.*\)\s*(?::\s*\w[\w<>,\s|]*\s*)?{|\w+\s*=\s*(?:async\s+)?(?:\(.*\)|[\w]+)\s*=>)/g;
+    const functionCount = (content.match(functionPattern) || []).length;
+    const importPattern = /\bimport\s+(?:type\s+)?(?:{[^}]*}|\*\s+as\s+\w+|\w+)\s+from/g;
+    const importCount = (content.match(importPattern) || []).length;
+    const exportPattern = /\bexport\s+(?:default\s+)?(?:class|function|const|let|var|interface|type|enum)/g;
+    const exportCount = (content.match(exportPattern) || []).length;
+    const classPattern = /\bclass\s+\w+/g;
+    const classCount = (content.match(classPattern) || []).length;
+    const complexityPatterns = /\b(if|else if|for|while|do|switch|case|catch|\?\?|&&|\|\||ternary)\b|\?(?!=)/g;
+    const cyclomaticComplexity = (content.match(complexityPatterns) || []).length + 1;
+    return {
+      filePath,
+      loc,
+      functionCount,
+      importCount,
+      exportCount,
+      classCount,
+      cyclomaticComplexity
+    };
+  }
+  /**
+   * Suggest a virtual split plan for a god file.
+   * Only splits at top-level declaration boundaries (G.GAP.05 prevention).
+   */
+  suggestSplit(filePath, content, metrics) {
+    const lines = content.split("\n");
+    const segments = [];
+    const baseName = filePath.replace(/\.[^.]+$/, "").split(/[/\\]/).pop() || "module";
+    let currentStart = 0;
+    let currentType = "module";
+    let currentName = "";
+    let symbolCount = 0;
+    let braceDepth = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      for (const ch of line) {
+        if (ch === "{") braceDepth++;
+        if (ch === "}") braceDepth--;
+      }
+      const classMatch = trimmed.match(/^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/);
+      if (classMatch && braceDepth <= 1) {
+        if (i > currentStart + 5) {
+          segments.push({
+            suggestedName: currentName || `${baseName}-segment-${segments.length}`,
+            startLine: currentStart + 1,
+            endLine: i,
+            type: currentType,
+            symbolCount,
+            description: `Lines ${currentStart + 1}-${i}`
+          });
+        }
+        currentStart = i;
+        currentType = "class";
+        currentName = classMatch[1];
+        symbolCount = 0;
+      }
+      if (trimmed.match(/^(?:export\s+)?(?:const|let|var|function|class|interface|type|enum)\s/)) {
+        symbolCount++;
+      }
+    }
+    if (currentStart < lines.length - 1) {
+      segments.push({
+        suggestedName: currentName || `${baseName}-segment-${segments.length}`,
+        startLine: currentStart + 1,
+        endLine: lines.length,
+        type: currentType,
+        symbolCount,
+        description: `Lines ${currentStart + 1}-${lines.length}`
+      });
+    }
+    if (segments.length <= 1) {
+      return this.splitByFunctionGroups(filePath, content, metrics, baseName);
+    }
+    return {
+      originalPath: filePath,
+      segments,
+      totalSegments: segments.length
+    };
+  }
+  splitByFunctionGroups(filePath, content, _metrics, baseName) {
+    const lines = content.split("\n");
+    const segmentSize = Math.ceil(lines.length / 3);
+    const segments = [];
+    for (let i = 0; i < 3; i++) {
+      const start = i * segmentSize;
+      const end = Math.min((i + 1) * segmentSize, lines.length);
+      if (start >= lines.length) break;
+      segments.push({
+        suggestedName: `${baseName}-part-${i + 1}`,
+        startLine: start + 1,
+        endLine: end,
+        type: "function-group",
+        symbolCount: 0,
+        description: `Lines ${start + 1}-${end}`
+      });
+    }
+    return {
+      originalPath: filePath,
+      segments,
+      totalSegments: segments.length
+    };
+  }
+};
+function createGodFileDetector(thresholds) {
+  return new GodFileDetector(thresholds);
+}
+
+exports.DedupFilter = DedupFilter;
+exports.GodFileDetector = GodFileDetector;
+exports.createDedupFilter = createDedupFilter;
+exports.createGodFileDetector = createGodFileDetector;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/codebase/index.js

@@ -0,0 +1,331 @@
+import '../chunk-OL46QLBJ.js';
+import { createHash } from 'crypto';
+
+var DEFAULT_CONFIG = {
+  semanticThreshold: 0.92,
+  numHashFunctions: 128,
+  numBands: 16,
+  shingleSize: 3,
+  qualityWeighted: true
+};
+var DedupFilter = class {
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Run full dedup pipeline on a set of items
+   */
+  dedup(items) {
+    const startTime = Date.now();
+    const removals = [];
+    const { unique: exactUnique, removals: exactRemovals } = this.exactDedup(items);
+    removals.push(...exactRemovals);
+    const { unique: semanticUnique, removals: semanticRemovals } = this.semanticDedup(exactUnique);
+    removals.push(...semanticRemovals);
+    const report = {
+      totalInput: items.length,
+      exactDuplicates: exactRemovals.length,
+      semanticDuplicates: semanticRemovals.length,
+      retained: semanticUnique.length,
+      removedDetails: removals,
+      processingTimeMs: Date.now() - startTime
+    };
+    return { retained: semanticUnique, report };
+  }
+  /**
+   * Layer 1: Exact dedup via SHA-256 hash
+   */
+  exactDedup(items) {
+    const hashMap = /* @__PURE__ */ new Map();
+    const removals = [];
+    for (const item of items) {
+      const hash = this.sha256(item.content);
+      const existing = hashMap.get(hash);
+      if (existing) {
+        if (this.config.qualityWeighted && (item.quality ?? 0) > (existing.quality ?? 0)) {
+          removals.push({ removedId: existing.id, keptId: item.id, reason: "exact" });
+          hashMap.set(hash, item);
+        } else {
+          removals.push({ removedId: item.id, keptId: existing.id, reason: "exact" });
+        }
+      } else {
+        hashMap.set(hash, item);
+      }
+    }
+    return { unique: Array.from(hashMap.values()), removals };
+  }
+  /**
+   * Layer 2: Semantic near-dedup via MinHash LSH (Jaccard similarity)
+   */
+  semanticDedup(items) {
+    if (items.length <= 1) return { unique: items, removals: [] };
+    const removals = [];
+    const removed = /* @__PURE__ */ new Set();
+    const signatures = items.map((item) => ({
+      item,
+      shingles: this.shingle(item.content),
+      minhash: this.minhash(this.shingle(item.content))
+    }));
+    const bandSize = Math.floor(this.config.numHashFunctions / this.config.numBands);
+    const candidatePairs = /* @__PURE__ */ new Set();
+    for (let band = 0; band < this.config.numBands; band++) {
+      const buckets = /* @__PURE__ */ new Map();
+      const start = band * bandSize;
+      const end = start + bandSize;
+      for (let i = 0; i < signatures.length; i++) {
+        const bandHash = signatures[i].minhash.slice(start, end).join(",");
+        const bucket = buckets.get(bandHash) ?? [];
+        bucket.push(i);
+        buckets.set(bandHash, bucket);
+      }
+      for (const bucket of buckets.values()) {
+        for (let i = 0; i < bucket.length; i++) {
+          for (let j = i + 1; j < bucket.length; j++) {
+            const key = `${Math.min(bucket[i], bucket[j])},${Math.max(bucket[i], bucket[j])}`;
+            candidatePairs.add(key);
+          }
+        }
+      }
+    }
+    for (const pair of candidatePairs) {
+      const [iStr, jStr] = pair.split(",");
+      const i = parseInt(iStr, 10);
+      const j = parseInt(jStr, 10);
+      if (removed.has(signatures[i].item.id) || removed.has(signatures[j].item.id)) continue;
+      const similarity = this.jaccardSimilarity(signatures[i].shingles, signatures[j].shingles);
+      if (similarity >= this.config.semanticThreshold) {
+        const itemA = signatures[i].item;
+        const itemB = signatures[j].item;
+        if (this.config.qualityWeighted && (itemA.quality ?? 0) >= (itemB.quality ?? 0)) {
+          removed.add(itemB.id);
+          removals.push({ removedId: itemB.id, keptId: itemA.id, reason: "semantic", similarity });
+        } else {
+          removed.add(itemA.id);
+          removals.push({ removedId: itemA.id, keptId: itemB.id, reason: "semantic", similarity });
+        }
+      }
+    }
+    const unique = items.filter((item) => !removed.has(item.id));
+    return { unique, removals };
+  }
+  // ---- Private helpers ----
+  sha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+  }
+  shingle(text) {
+    const shingles = /* @__PURE__ */ new Set();
+    const words = text.toLowerCase().split(/\s+/);
+    for (let i = 0; i <= words.length - this.config.shingleSize; i++) {
+      shingles.add(words.slice(i, i + this.config.shingleSize).join(" "));
+    }
+    return shingles;
+  }
+  minhash(shingles) {
+    const signature = new Array(this.config.numHashFunctions).fill(Infinity);
+    for (const shingle of shingles) {
+      for (let i = 0; i < this.config.numHashFunctions; i++) {
+        const hash = this.hashWithSeed(shingle, i);
+        if (hash < signature[i]) {
+          signature[i] = hash;
+        }
+      }
+    }
+    return signature;
+  }
+  hashWithSeed(value, seed) {
+    let hash = 2166136261 ^ seed;
+    for (let i = 0; i < value.length; i++) {
+      hash ^= value.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return hash >>> 0;
+  }
+  jaccardSimilarity(a, b) {
+    let intersection = 0;
+    for (const item of a) {
+      if (b.has(item)) intersection++;
+    }
+    const union = a.size + b.size - intersection;
+    return union === 0 ? 0 : intersection / union;
+  }
+};
+function createDedupFilter(config) {
+  return new DedupFilter(config);
+}
+
+// src/codebase/GodFileDetector.ts
+var DEFAULT_THRESHOLDS = {
+  loc_warning: 500,
+  loc_god: 1e3,
+  functions_warning: 20,
+  functions_god: 40,
+  complexity_god: 50,
+  imports_god: 30
+};
+var GodFileDetector = class {
+  constructor(thresholds) {
+    this.thresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
+  }
+  /**
+   * Analyze a file's content and produce metrics + classification
+   */
+  analyze(filePath, content) {
+    const metrics = this.computeMetrics(filePath, content);
+    const reasons = [];
+    let classification = "normal";
+    if (metrics.loc >= this.thresholds.loc_god) {
+      reasons.push(`LOC ${metrics.loc} >= ${this.thresholds.loc_god} (god file threshold)`);
+      classification = "god_file";
+    } else if (metrics.loc >= this.thresholds.loc_warning) {
+      reasons.push(`LOC ${metrics.loc} >= ${this.thresholds.loc_warning} (warning threshold)`);
+      classification = "warning";
+    }
+    if (metrics.functionCount >= this.thresholds.functions_god) {
+      reasons.push(
+        `Functions ${metrics.functionCount} >= ${this.thresholds.functions_god} (god file threshold)`
+      );
+      classification = "god_file";
+    } else if (metrics.functionCount >= this.thresholds.functions_warning) {
+      reasons.push(
+        `Functions ${metrics.functionCount} >= ${this.thresholds.functions_warning} (warning threshold)`
+      );
+      if (classification !== "god_file") classification = "warning";
+    }
+    if (metrics.cyclomaticComplexity >= this.thresholds.complexity_god) {
+      reasons.push(
+        `Cyclomatic complexity ${metrics.cyclomaticComplexity} >= ${this.thresholds.complexity_god}`
+      );
+      classification = "god_file";
+    }
+    if (metrics.importCount >= this.thresholds.imports_god) {
+      reasons.push(`Imports ${metrics.importCount} >= ${this.thresholds.imports_god}`);
+      if (classification !== "god_file") classification = "warning";
+    }
+    const report = {
+      filePath,
+      classification,
+      metrics,
+      reasons
+    };
+    if (classification === "god_file") {
+      report.splitPlan = this.suggestSplit(filePath, content, metrics);
+    }
+    return report;
+  }
+  /**
+   * Compute metrics for a file
+   */
+  computeMetrics(filePath, content) {
+    const lines = content.split("\n");
+    const loc = lines.filter((l) => l.trim().length > 0 && !l.trim().startsWith("//")).length;
+    const functionPattern = /\b(function\s+\w+|(?:async\s+)?(?:get|set)?\s*\w+\s*\(.*\)\s*(?::\s*\w[\w<>,\s|]*\s*)?{|\w+\s*=\s*(?:async\s+)?(?:\(.*\)|[\w]+)\s*=>)/g;
+    const functionCount = (content.match(functionPattern) || []).length;
+    const importPattern = /\bimport\s+(?:type\s+)?(?:{[^}]*}|\*\s+as\s+\w+|\w+)\s+from/g;
+    const importCount = (content.match(importPattern) || []).length;
+    const exportPattern = /\bexport\s+(?:default\s+)?(?:class|function|const|let|var|interface|type|enum)/g;
+    const exportCount = (content.match(exportPattern) || []).length;
+    const classPattern = /\bclass\s+\w+/g;
+    const classCount = (content.match(classPattern) || []).length;
+    const complexityPatterns = /\b(if|else if|for|while|do|switch|case|catch|\?\?|&&|\|\||ternary)\b|\?(?!=)/g;
+    const cyclomaticComplexity = (content.match(complexityPatterns) || []).length + 1;
+    return {
+      filePath,
+      loc,
+      functionCount,
+      importCount,
+      exportCount,
+      classCount,
+      cyclomaticComplexity
+    };
+  }
+  /**
+   * Suggest a virtual split plan for a god file.
+   * Only splits at top-level declaration boundaries (G.GAP.05 prevention).
+   */
+  suggestSplit(filePath, content, metrics) {
+    const lines = content.split("\n");
+    const segments = [];
+    const baseName = filePath.replace(/\.[^.]+$/, "").split(/[/\\]/).pop() || "module";
+    let currentStart = 0;
+    let currentType = "module";
+    let currentName = "";
+    let symbolCount = 0;
+    let braceDepth = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      for (const ch of line) {
+        if (ch === "{") braceDepth++;
+        if (ch === "}") braceDepth--;
+      }
+      const classMatch = trimmed.match(/^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/);
+      if (classMatch && braceDepth <= 1) {
+        if (i > currentStart + 5) {
+          segments.push({
+            suggestedName: currentName || `${baseName}-segment-${segments.length}`,
+            startLine: currentStart + 1,
+            endLine: i,
+            type: currentType,
+            symbolCount,
+            description: `Lines ${currentStart + 1}-${i}`
+          });
+        }
+        currentStart = i;
+        currentType = "class";
+        currentName = classMatch[1];
+        symbolCount = 0;
+      }
+      if (trimmed.match(/^(?:export\s+)?(?:const|let|var|function|class|interface|type|enum)\s/)) {
+        symbolCount++;
+      }
+    }
+    if (currentStart < lines.length - 1) {
+      segments.push({
+        suggestedName: currentName || `${baseName}-segment-${segments.length}`,
+        startLine: currentStart + 1,
+        endLine: lines.length,
+        type: currentType,
+        symbolCount,
+        description: `Lines ${currentStart + 1}-${lines.length}`
+      });
+    }
+    if (segments.length <= 1) {
+      return this.splitByFunctionGroups(filePath, content, metrics, baseName);
+    }
+    return {
+      originalPath: filePath,
+      segments,
+      totalSegments: segments.length
+    };
+  }
+  splitByFunctionGroups(filePath, content, _metrics, baseName) {
+    const lines = content.split("\n");
+    const segmentSize = Math.ceil(lines.length / 3);
+    const segments = [];
+    for (let i = 0; i < 3; i++) {
+      const start = i * segmentSize;
+      const end = Math.min((i + 1) * segmentSize, lines.length);
+      if (start >= lines.length) break;
+      segments.push({
+        suggestedName: `${baseName}-part-${i + 1}`,
+        startLine: start + 1,
+        endLine: end,
+        type: "function-group",
+        symbolCount: 0,
+        description: `Lines ${start + 1}-${end}`
+      });
+    }
+    return {
+      originalPath: filePath,
+      segments,
+      totalSegments: segments.length
+    };
+  }
+};
+function createGodFileDetector(thresholds) {
+  return new GodFileDetector(thresholds);
+}
+
+export { DedupFilter, GodFileDetector, createDedupFilter, createGodFileDetector };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/compiler/agent-inference.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var chunkJC5YBPSF_cjs = require('../chunk-JC5YBPSF.cjs');
+require('../chunk-KKP7JKN4.cjs');
+require('../chunk-5FSKKMR7.cjs');
+require('../chunk-GTU2Z2WW.cjs');
+require('../chunk-E7JP3BS3.cjs');
+require('../chunk-HCCQLAA4.cjs');
+
+
+
+Object.defineProperty(exports, "AgentInferenceCompiler", {
+  enumerable: true,
+  get: function () { return chunkJC5YBPSF_cjs.AgentInferenceCompiler; }
+});
+Object.defineProperty(exports, "createAgentInferenceCompiler", {
+  enumerable: true,
+  get: function () { return chunkJC5YBPSF_cjs.createAgentInferenceCompiler; }
+});
+Object.defineProperty(exports, "createPythonAgentInferenceCompiler", {
+  enumerable: true,
+  get: function () { return chunkJC5YBPSF_cjs.createPythonAgentInferenceCompiler; }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () { return chunkJC5YBPSF_cjs.AgentInferenceExportTarget_default; }
+});
+//# sourceMappingURL=agent-inference.cjs.map
+//# sourceMappingURL=agent-inference.cjs.map