ruvector 0.2.21 → 0.2.23

package/src/decompiler/model-decompiler.js

@@ -0,0 +1,423 @@
+'use strict';
+
+/**
+ * LLM model weight decompiler for Node.js.
+ * Parses GGUF and Safetensors files to reconstruct architecture info.
+ * See ADR-138.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// ── GGUF constants ───────────────────────────────────────────────────────
+
+const GGUF_MAGIC = 0x46554747;
+
+const QUANT_TYPES = {
+  0: { name: 'F32', bpw: 32 }, 1: { name: 'F16', bpw: 16 },
+  2: { name: 'Q4_0', bpw: 4.5 }, 3: { name: 'Q4_1', bpw: 5 },
+  6: { name: 'Q5_0', bpw: 5.5 }, 7: { name: 'Q5_1', bpw: 6 },
+  8: { name: 'Q8_0', bpw: 8.5 }, 9: { name: 'Q8_1', bpw: 9 },
+  10: { name: 'Q2_K', bpw: 2.56 }, 11: { name: 'Q3_K', bpw: 3.44 },
+  12: { name: 'Q4_K', bpw: 4.5 }, 13: { name: 'Q5_K', bpw: 5.5 },
+  14: { name: 'Q6_K', bpw: 6.56 }, 15: { name: 'Q8_K', bpw: 8.5 },
+  29: { name: 'BF16', bpw: 16 },
+};
+
+// ── Main entry ───────────────────────────────────────────────────────────
+
+async function decompileModelFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === '.gguf') return decompileGguf(filePath);
+  if (ext === '.safetensors') return decompileSafetensors(filePath);
+  throw new Error(`Unsupported model format: ${ext} (expected .gguf or .safetensors)`);
+}
+
+// ── GGUF decompiler ──────────────────────────────────────────────────────
+
+function decompileGguf(filePath) {
+  const fd = fs.openSync(filePath, 'r');
+  const stat = fs.fstatSync(fd);
+  let pos = 0;
+
+  function readBuf(n) {
+    const buf = Buffer.alloc(n);
+    fs.readSync(fd, buf, 0, n, pos);
+    pos += n;
+    return buf;
+  }
+  function readU32() { return readBuf(4).readUInt32LE(0); }
+  function readU64() { return Number(readBuf(8).readBigUInt64LE(0)); }
+  function readF32() { return readBuf(4).readFloatLE(0); }
+  function readF64() { return readBuf(8).readDoubleLE(0); }
+  function readStr() {
+    const len = readU64();
+    if (len > 65536) throw new Error(`String too long: ${len}`);
+    return readBuf(len).toString('utf8');
+  }
+
+  function readValue() {
+    const type = readU32();
+    switch (type) {
+      case 0: return readBuf(1).readUInt8(0);
+      case 1: return readBuf(1).readInt8(0);
+      case 2: return readBuf(2).readUInt16LE(0);
+      case 3: return readBuf(2).readInt16LE(0);
+      case 4: return readU32();
+      case 5: return readBuf(4).readInt32LE(0);
+      case 6: return readF32();
+      case 7: return readBuf(1).readUInt8(0) !== 0;
+      case 8: return readStr();
+      case 9: { // Array
+        const elemType = readU32();
+        const count = readU64();
+        const arr = [];
+        for (let i = 0; i < Math.min(count, 10000); i++) {
+          if (elemType === 8) arr.push(readStr());
+          else if (elemType === 4) arr.push(readU32());
+          else if (elemType === 0) arr.push(readBuf(1).readUInt8(0));
+          else if (elemType === 5) arr.push(readBuf(4).readInt32LE(0));
+          else if (elemType === 6) arr.push(readF32());
+          else if (elemType === 10) arr.push(readU64());
+          else readBuf(elemType <= 1 ? 1 : elemType <= 3 ? 2 : elemType <= 6 ? 4 : 8);
+        }
+        // Skip remaining if array was truncated
+        if (count > 10000) {
+          // Cannot reliably skip variable-size elements, just return what we have
+        }
+        return arr;
+      }
+      case 10: return readU64();
+      case 11: return Number(readBuf(8).readBigInt64LE(0));
+      case 12: return readF64();
+      default: throw new Error(`Unknown value type: ${type}`);
+    }
+  }
+
+  // Parse header
+  const magic = readU32();
+  if (magic !== GGUF_MAGIC) throw new Error(`Not a GGUF file (magic: 0x${magic.toString(16)})`);
+  const version = readU32();
+  const tensorCount = readU64();
+  const metadataCount = readU64();
+
+  // Parse metadata
+  const metadata = {};
+  for (let i = 0; i < metadataCount; i++) {
+    const key = readStr();
+    metadata[key] = readValue();
+  }
+
+  // Parse tensor infos
+  const tensors = [];
+  for (let i = 0; i < tensorCount; i++) {
+    const name = readStr();
+    const nDims = readU32();
+    const shape = [];
+    for (let d = 0; d < nDims; d++) shape.push(readU64());
+    const quantType = readU32();
+    const offset = readU64();
+    const qt = QUANT_TYPES[quantType] || { name: `Unknown(${quantType})`, bpw: 0 };
+    tensors.push({ name, shape, quantType, quantName: qt.name, bpw: qt.bpw, offset });
+  }
+
+  fs.closeSync(fd);
+
+  return buildResult({
+    format: `GGUF v${version}`,
+    metadata,
+    tensors,
+    fileSize: stat.size,
+    filePath,
+  });
+}
+
+// ── Safetensors decompiler ───────────────────────────────────────────────
+
+function decompileSafetensors(filePath) {
+  const fd = fs.openSync(filePath, 'r');
+  const stat = fs.fstatSync(fd);
+  const lenBuf = Buffer.alloc(8);
+  fs.readSync(fd, lenBuf, 0, 8, 0);
+  const headerLen = Number(lenBuf.readBigUInt64LE(0));
+  if (headerLen > 100 * 1024 * 1024) throw new Error(`Header too large: ${headerLen}`);
+
+  const headerBuf = Buffer.alloc(headerLen);
+  fs.readSync(fd, headerBuf, 0, headerLen, 8);
+  fs.closeSync(fd);
+
+  const header = JSON.parse(headerBuf.toString('utf8'));
+  const metadata = {};
+  const tensors = [];
+
+  for (const [name, info] of Object.entries(header)) {
+    if (name === '__metadata__') {
+      Object.assign(metadata, info);
+      continue;
+    }
+    if (!info || !info.dtype) continue;
+    const dtypeMap = { F32: 32, F16: 16, BF16: 16, F64: 64, I8: 8, I16: 16, I32: 32, I64: 64 };
+    tensors.push({
+      name,
+      shape: info.shape || [],
+      quantName: info.dtype,
+      bpw: dtypeMap[info.dtype] || 32,
+      offset: info.data_offsets ? info.data_offsets[0] : 0,
+    });
+  }
+
+  tensors.sort((a, b) => a.offset - b.offset);
+
+  return buildResult({
+    format: 'Safetensors',
+    metadata,
+    tensors,
+    fileSize: stat.size,
+    filePath,
+  });
+}
+
+// ── Architecture inference ───────────────────────────────────────────────
+
+function buildResult({ format, metadata, tensors, fileSize, filePath }) {
+  const arch = inferArchitecture(metadata, tensors);
+  const quant = detectQuantization(tensors, arch);
+  const layers = extractLayers(tensors, arch);
+
+  // Witness: SHA3 not available in Node crypto, use SHA256
+  const hash = crypto.createHash('sha256').update(filePath).digest('hex');
+
+  return {
+    format,
+    architecture: arch,
+    layers: layers.slice(0, 50), // Limit output
+    tokenizer: extractTokenizer(metadata),
+    quantization: quant,
+    witness: { source_hash: hash, chain_root: hash.slice(0, 32) },
+    metadata: flattenMetadata(metadata),
+    fileSize,
+  };
+}
+
+function inferArchitecture(metadata, tensors) {
+  const archKey = metadata['general.architecture'] || '';
+  const prefix = archKey ? `${archKey}.` : '';
+  const hiddenSize = Number(metadata[`${prefix}embedding_length`]) || inferHiddenSize(tensors);
+  const numLayers = Number(metadata[`${prefix}block_count`]) || inferNumLayers(tensors);
+  const numHeads = Number(metadata[`${prefix}attention.head_count`]) || inferNumHeads(hiddenSize);
+  const numKvHeads = Number(metadata[`${prefix}attention.head_count_kv`]) || inferKvHeads(tensors, hiddenSize, numHeads);
+  const ffnSize = Number(metadata[`${prefix}feed_forward_length`]) || inferFfnSize(tensors);
+  const vocabSize = inferVocabSize(tensors);
+  const maxSeqLen = Number(metadata[`${prefix}context_length`]) || 0;
+  const totalParams = tensors.reduce((sum, t) => sum + t.shape.reduce((a, b) => a * b, 1), 0);
+
+  return {
+    name: archKey || 'unknown',
+    hidden_size: hiddenSize,
+    num_layers: numLayers,
+    num_heads: numHeads,
+    num_kv_heads: numKvHeads,
+    intermediate_size: ffnSize,
+    vocab_size: vocabSize,
+    max_sequence_length: maxSeqLen,
+    total_params: totalParams,
+    estimated_size_mb: (totalParams * 2) / (1024 * 1024),
+  };
+}
+
+function inferHiddenSize(tensors) {
+  for (const t of tensors) {
+    if ((t.name.includes('embed') || t.name.includes('token_embd')) && t.shape.length === 2) {
+      return t.shape[1];
+    }
+  }
+  return 0;
+}
+
+function inferNumLayers(tensors) {
+  let max = -1;
+  for (const t of tensors) {
+    const m = t.name.match(/(?:blk|layers|h)\.\s*(\d+)\./);
+    if (m) max = Math.max(max, parseInt(m[1], 10));
+  }
+  return max >= 0 ? max + 1 : 0;
+}
+
+function inferNumHeads(hiddenSize) {
+  if (!hiddenSize) return 0;
+  for (const hd of [128, 64, 96, 256]) {
+    if (hiddenSize % hd === 0) return hiddenSize / hd;
+  }
+  return 0;
+}
+
+function inferKvHeads(tensors, hiddenSize, numHeads) {
+  if (!hiddenSize || !numHeads) return numHeads;
+  const headDim = hiddenSize / numHeads;
+  for (const t of tensors) {
+    if ((t.name.includes('attn_k') || t.name.includes('k_proj')) && t.shape.length === 2) {
+      if (headDim > 0 && t.shape[0] % headDim === 0) return t.shape[0] / headDim;
+    }
+  }
+  return numHeads;
+}
+
+function inferFfnSize(tensors) {
+  for (const t of tensors) {
+    if ((t.name.includes('ffn_up') || t.name.includes('up_proj') ||
+         t.name.includes('ffn_gate') || t.name.includes('gate_proj')) && t.shape.length === 2) {
+      return t.shape[0];
+    }
+  }
+  return 0;
+}
+
+function inferVocabSize(tensors) {
+  for (const t of tensors) {
+    if ((t.name.includes('embed') || t.name.includes('token_embd')) && t.shape.length === 2) {
+      return t.shape[0];
+    }
+  }
+  return 0;
+}
+
+function detectQuantization(tensors, arch) {
+  const counts = {};
+  for (const t of tensors) {
+    if (t.name.includes('norm') || t.name.includes('embed') || t.name.includes('embd')) continue;
+    counts[t.quantName] = (counts[t.quantName] || 0) + 1;
+  }
+  let method = 'Unknown';
+  let maxCount = 0;
+  for (const [name, count] of Object.entries(counts)) {
+    if (count > maxCount) { method = name; maxCount = count; }
+  }
+  const bpw = (QUANT_TYPES[Object.keys(QUANT_TYPES).find(k => QUANT_TYPES[k].name === method)] || {}).bpw || 0;
+  const totalBits = tensors.reduce((s, t) => s + t.shape.reduce((a, b) => a * b, 1) * t.bpw, 0);
+  const quantizedMb = totalBits / 8 / (1024 * 1024);
+
+  return {
+    method,
+    bits_per_weight: bpw,
+    original_size_mb: arch.estimated_size_mb,
+    quantized_size_mb: quantizedMb,
+    compression_ratio: quantizedMb > 0 ? arch.estimated_size_mb / quantizedMb : 1,
+  };
+}
+
+function extractLayers(tensors, arch) {
+  const layers = [];
+  // Just collect unique layer indices
+  const seen = new Set();
+  for (const t of tensors) {
+    const m = t.name.match(/(?:blk|layers|h)\.\s*(\d+)\./);
+    if (m && !seen.has(m[1])) {
+      seen.add(m[1]);
+      const idx = parseInt(m[1], 10);
+      const blockTensors = tensors.filter(tt => {
+        const mm = tt.name.match(/(?:blk|layers|h)\.\s*(\d+)\./);
+        return mm && parseInt(mm[1], 10) === idx;
+      });
+      layers.push({
+        index: idx,
+        tensor_count: blockTensors.length,
+        param_count: blockTensors.reduce((s, tt) => s + tt.shape.reduce((a, b) => a * b, 1), 0),
+        quantization: blockTensors[0]?.quantName,
+      });
+    }
+  }
+  return layers;
+}
+
+function extractTokenizer(metadata) {
+  const tokens = metadata['tokenizer.ggml.tokens'];
+  if (!Array.isArray(tokens)) return null;
+  const special = [];
+  for (const key of ['tokenizer.ggml.bos_token_id', 'tokenizer.ggml.eos_token_id',
+                      'tokenizer.ggml.padding_token_id', 'tokenizer.ggml.unknown_token_id']) {
+    if (metadata[key] != null) {
+      special.push({ name: key.replace('tokenizer.ggml.', ''), id: metadata[key] });
+    }
+  }
+  return {
+    vocab_size: tokens.length,
+    special_tokens: special,
+    sample_tokens: tokens.slice(0, 20).map((t, i) => ({ id: i, text: String(t) })),
+  };
+}
+
+function flattenMetadata(metadata) {
+  const flat = {};
+  for (const [k, v] of Object.entries(metadata)) {
+    if (Array.isArray(v)) flat[k] = `[${v.length} elements]`;
+    else if (typeof v === 'object' && v !== null) flat[k] = JSON.stringify(v);
+    else flat[k] = String(v);
+  }
+  return flat;
+}
+
+// ── Pretty printer ───────────────────────────────────────────────────────
+
+function printModelResult(result) {
+  const _chalk = require('chalk');
+  const chalk = _chalk.default || _chalk;
+  const a = result.architecture;
+
+  console.log(chalk.bold.cyan('\n  LLM Model Decompilation'));
+  console.log(chalk.white(`  Format:       ${result.format}`));
+  console.log(chalk.white(`  Architecture: ${a.name}`));
+  console.log(chalk.white(`  Parameters:   ${formatNumber(a.total_params)} (${formatSize(a.total_params)})`));
+  console.log('');
+  console.log(chalk.white(`  Hidden size:     ${a.hidden_size}`));
+  console.log(chalk.white(`  Layers:          ${a.num_layers}`));
+  console.log(chalk.white(`  Attention heads: ${a.num_heads}`));
+  if (a.num_kv_heads !== a.num_heads) {
+    const ratio = a.num_heads / a.num_kv_heads;
+    console.log(chalk.white(`  KV heads:        ${a.num_kv_heads} (GQA ${ratio}:1)`));
+  }
+  console.log(chalk.white(`  FFN size:        ${a.intermediate_size}`));
+  console.log(chalk.white(`  Vocab size:      ${a.vocab_size}`));
+  if (a.max_sequence_length > 0) {
+    console.log(chalk.white(`  Max seq length:  ${a.max_sequence_length}`));
+  }
+
+  if (result.quantization) {
+    const q = result.quantization;
+    console.log('');
+    console.log(chalk.white(`  Quantization:  ${q.method}`));
+    console.log(chalk.white(`  Original size: ${q.original_size_mb.toFixed(0)} MB (FP16)`));
+    console.log(chalk.white(`  Quantized:     ${q.quantized_size_mb.toFixed(0)} MB`));
+    console.log(chalk.white(`  Compression:   ${q.compression_ratio.toFixed(1)}x`));
+  }
+
+  if (result.tokenizer) {
+    console.log('');
+    console.log(chalk.white(`  Tokenizer:`));
+    console.log(chalk.white(`    Vocab: ${formatNumber(result.tokenizer.vocab_size)} tokens`));
+    if (result.tokenizer.special_tokens.length > 0) {
+      const specials = result.tokenizer.special_tokens.map(s => `${s.name}(${s.id})`).join(', ');
+      console.log(chalk.white(`    Special: ${specials}`));
+    }
+  }
+
+  console.log('');
+  console.log(chalk.dim(`  Witness: ${result.witness.source_hash.slice(0, 16)}...`));
+  console.log('');
+}
+
+function formatNumber(n) {
+  if (n >= 1e12) return `${(n / 1e12).toFixed(1)}T`;
+  if (n >= 1e9) return `${(n / 1e9).toFixed(1)}B`;
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return String(n);
+}
+
+function formatSize(params) {
+  const mb = (params * 2) / (1024 * 1024);
+  if (mb >= 1024) return `${(mb / 1024).toFixed(1)} GB FP16`;
+  return `${mb.toFixed(0)} MB FP16`;
+}
+
+module.exports = { decompileModelFile, decompileGguf, decompileSafetensors, printModelResult };

package/dist/analysis/complexity.d.ts

@@ -1,52 +0,0 @@
-/**
- * Complexity Analysis Module - Consolidated code complexity metrics
- *
- * Single source of truth for cyclomatic complexity and code metrics.
- * Used by native-worker.ts and parallel-workers.ts
- */
-export interface ComplexityResult {
-    file: string;
-    lines: number;
-    nonEmptyLines: number;
-    cyclomaticComplexity: number;
-    functions: number;
-    avgFunctionSize: number;
-    maxFunctionComplexity?: number;
-}
-export interface ComplexityThresholds {
-    complexity: number;
-    functions: number;
-    lines: number;
-    avgSize: number;
-}
-export declare const DEFAULT_THRESHOLDS: ComplexityThresholds;
-/**
- * Analyze complexity of a single file
- */
-export declare function analyzeFile(filePath: string, content?: string): ComplexityResult;
-/**
- * Analyze complexity of multiple files
- */
-export declare function analyzeFiles(files: string[], maxFiles?: number): ComplexityResult[];
-/**
- * Check if complexity exceeds thresholds
- */
-export declare function exceedsThresholds(result: ComplexityResult, thresholds?: ComplexityThresholds): boolean;
-/**
- * Get complexity rating
- */
-export declare function getComplexityRating(complexity: number): 'low' | 'medium' | 'high' | 'critical';
-/**
- * Filter files exceeding thresholds
- */
-export declare function filterComplex(results: ComplexityResult[], thresholds?: ComplexityThresholds): ComplexityResult[];
-declare const _default: {
-    DEFAULT_THRESHOLDS: ComplexityThresholds;
-    analyzeFile: typeof analyzeFile;
-    analyzeFiles: typeof analyzeFiles;
-    exceedsThresholds: typeof exceedsThresholds;
-    getComplexityRating: typeof getComplexityRating;
-    filterComplex: typeof filterComplex;
-};
-export default _default;
-//# sourceMappingURL=complexity.d.ts.map

package/dist/analysis/complexity.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"complexity.d.ts","sourceRoot":"","sources":["../../src/analysis/complexity.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,kBAAkB,EAAE,oBAKhC,CAAC;AAEF;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAsDhF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,QAAQ,GAAE,MAAY,GAAG,gBAAgB,EAAE,CAExF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,gBAAgB,EACxB,UAAU,GAAE,oBAAyC,GACpD,OAAO,CAOT;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAK9F;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,gBAAgB,EAAE,EAC3B,UAAU,GAAE,oBAAyC,GACpD,gBAAgB,EAAE,CAEpB;;;;;;;;;AAED,wBAOE"}

package/dist/analysis/complexity.js

@@ -1,146 +0,0 @@
-"use strict";
-/**
- * Complexity Analysis Module - Consolidated code complexity metrics
- *
- * Single source of truth for cyclomatic complexity and code metrics.
- * Used by native-worker.ts and parallel-workers.ts
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_THRESHOLDS = void 0;
-exports.analyzeFile = analyzeFile;
-exports.analyzeFiles = analyzeFiles;
-exports.exceedsThresholds = exceedsThresholds;
-exports.getComplexityRating = getComplexityRating;
-exports.filterComplex = filterComplex;
-const fs = __importStar(require("fs"));
-exports.DEFAULT_THRESHOLDS = {
-    complexity: 10,
-    functions: 30,
-    lines: 500,
-    avgSize: 50,
-};
-/**
- * Analyze complexity of a single file
- */
-function analyzeFile(filePath, content) {
-    try {
-        const fileContent = content ?? (fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '');
-        if (!fileContent) {
-            return { file: filePath, lines: 0, nonEmptyLines: 0, cyclomaticComplexity: 1, functions: 0, avgFunctionSize: 0 };
-        }
-        const lines = fileContent.split('\n');
-        const nonEmptyLines = lines.filter(l => l.trim().length > 0).length;
-        // Count branching statements for cyclomatic complexity
-        const branches = (fileContent.match(/\bif\b/g)?.length || 0) +
-            (fileContent.match(/\belse\b/g)?.length || 0) +
-            (fileContent.match(/\bfor\b/g)?.length || 0) +
-            (fileContent.match(/\bwhile\b/g)?.length || 0) +
-            (fileContent.match(/\bswitch\b/g)?.length || 0) +
-            (fileContent.match(/\bcase\b/g)?.length || 0) +
-            (fileContent.match(/\bcatch\b/g)?.length || 0) +
-            (fileContent.match(/\?\?/g)?.length || 0) +
-            (fileContent.match(/&&/g)?.length || 0) +
-            (fileContent.match(/\|\|/g)?.length || 0) +
-            (fileContent.match(/\?[^:]/g)?.length || 0); // Ternary
-        const cyclomaticComplexity = branches + 1;
-        // Count functions
-        const functionPatterns = [
-            /function\s+\w+/g,
-            /\w+\s*=\s*(?:async\s*)?\(/g,
-            /\w+\s*:\s*(?:async\s*)?\(/g,
-            /(?:async\s+)?(?:public|private|protected)?\s+\w+\s*\([^)]*\)\s*[:{]/g,
-        ];
-        let functions = 0;
-        for (const pattern of functionPatterns) {
-            functions += (fileContent.match(pattern) || []).length;
-        }
-        // Deduplicate by rough estimate
-        functions = Math.ceil(functions / 2);
-        const avgFunctionSize = functions > 0 ? Math.round(nonEmptyLines / functions) : nonEmptyLines;
-        return {
-            file: filePath,
-            lines: lines.length,
-            nonEmptyLines,
-            cyclomaticComplexity,
-            functions,
-            avgFunctionSize,
-        };
-    }
-    catch {
-        return { file: filePath, lines: 0, nonEmptyLines: 0, cyclomaticComplexity: 1, functions: 0, avgFunctionSize: 0 };
-    }
-}
-/**
- * Analyze complexity of multiple files
- */
-function analyzeFiles(files, maxFiles = 100) {
-    return files.slice(0, maxFiles).map(f => analyzeFile(f));
-}
-/**
- * Check if complexity exceeds thresholds
- */
-function exceedsThresholds(result, thresholds = exports.DEFAULT_THRESHOLDS) {
-    return (result.cyclomaticComplexity > thresholds.complexity ||
-        result.functions > thresholds.functions ||
-        result.lines > thresholds.lines ||
-        result.avgFunctionSize > thresholds.avgSize);
-}
-/**
- * Get complexity rating
- */
-function getComplexityRating(complexity) {
-    if (complexity <= 5)
-        return 'low';
-    if (complexity <= 10)
-        return 'medium';
-    if (complexity <= 20)
-        return 'high';
-    return 'critical';
-}
-/**
- * Filter files exceeding thresholds
- */
-function filterComplex(results, thresholds = exports.DEFAULT_THRESHOLDS) {
-    return results.filter(r => exceedsThresholds(r, thresholds));
-}
-exports.default = {
-    DEFAULT_THRESHOLDS: exports.DEFAULT_THRESHOLDS,
-    analyzeFile,
-    analyzeFiles,
-    exceedsThresholds,
-    getComplexityRating,
-    filterComplex,
-};

package/dist/analysis/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * Analysis Module - Consolidated code analysis utilities
- *
- * Single source of truth for:
- * - Security scanning
- * - Complexity analysis
- * - Pattern extraction
- */
-export * from './security';
-export * from './complexity';
-export * from './patterns';
-export { default as security } from './security';
-export { default as complexity } from './complexity';
-export { default as patterns } from './patterns';
-//# sourceMappingURL=index.d.ts.map

package/dist/analysis/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/analysis/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/analysis/index.js

@@ -1,38 +0,0 @@
-"use strict";
-/**
- * Analysis Module - Consolidated code analysis utilities
- *
- * Single source of truth for:
- * - Security scanning
- * - Complexity analysis
- * - Pattern extraction
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.patterns = exports.complexity = exports.security = void 0;
-__exportStar(require("./security"), exports);
-__exportStar(require("./complexity"), exports);
-__exportStar(require("./patterns"), exports);
-// Re-export defaults for convenience
-var security_1 = require("./security");
-Object.defineProperty(exports, "security", { enumerable: true, get: function () { return __importDefault(security_1).default; } });
-var complexity_1 = require("./complexity");
-Object.defineProperty(exports, "complexity", { enumerable: true, get: function () { return __importDefault(complexity_1).default; } });
-var patterns_1 = require("./patterns");
-Object.defineProperty(exports, "patterns", { enumerable: true, get: function () { return __importDefault(patterns_1).default; } });