@timmeck/brain 1.8.0 → 1.8.2

package/src/code/fingerprint.ts

@@ -1,87 +1,87 @@
-import { sha256 } from '../utils/hash.js';
-
-export function fingerprintCode(source: string, language: string): string {
-  let normalized = stripComments(source, language);
-  normalized = normalized.replace(/\s+/g, ' ').trim();
-  normalized = normalizeIdentifiers(normalized, language);
-  normalized = normalized.replace(/'[^']*'/g, "'<STR>'");
-  normalized = normalized.replace(/"[^"]*"/g, '"<STR>"');
-  normalized = normalized.replace(/`[^`]*`/g, '`<STR>`');
-  normalized = normalized.replace(/\b\d+\b/g, '<NUM>');
-  return sha256(normalized);
-}
-
-export function stripComments(source: string, language: string): string {
-  switch (language) {
-    case 'typescript':
-    case 'javascript':
-    case 'java':
-    case 'go':
-    case 'rust':
-    case 'c':
-    case 'cpp':
-      return source
-        .replace(/\/\/.*$/gm, '')
-        .replace(/\/\*[\s\S]*?\*\//g, '');
-    case 'python':
-      return source
-        .replace(/#.*$/gm, '')
-        .replace(/"""[\s\S]*?"""/g, '')
-        .replace(/'''[\s\S]*?'''/g, '');
-    default:
-      return source
-        .replace(/\/\/.*$/gm, '')
-        .replace(/#.*$/gm, '');
-  }
-}
-
-function normalizeIdentifiers(source: string, language: string): string {
-  const importNames = extractImportNames(source, language);
-  const keywords = getLanguageKeywords(language);
-  const preserve = new Set([...importNames, ...keywords]);
-
-  return source.replace(/\b[a-zA-Z_]\w*\b/g, (match) => {
-    if (preserve.has(match)) return match;
-    if (match[0] === match[0]!.toUpperCase() && match[0] !== match[0]!.toLowerCase()) return '<CLASS>';
-    return '<VAR>';
-  });
-}
-
-function extractImportNames(source: string, language: string): string[] {
-  const names: string[] = [];
-
-  if (language === 'typescript' || language === 'javascript') {
-    const re = /import\s+(?:\{([^}]+)\}|\*\s+as\s+(\w+)|(\w+))/g;
-    let m: RegExpExecArray | null;
-    while ((m = re.exec(source)) !== null) {
-      if (m[1]) names.push(...m[1].split(',').map(s => s.trim().split(/\s+as\s+/).pop()!));
-      if (m[2]) names.push(m[2]);
-      if (m[3]) names.push(m[3]);
-    }
-  } else if (language === 'python') {
-    const re = /(?:from\s+\S+\s+)?import\s+(.+)/g;
-    let m: RegExpExecArray | null;
-    while ((m = re.exec(source)) !== null) {
-      names.push(...m[1]!.split(',').map(s => {
-        const parts = s.trim().split(/\s+as\s+/);
-        return parts[parts.length - 1]!;
-      }));
-    }
-  }
-
-  return names.filter(Boolean);
-}
-
-function getLanguageKeywords(language: string): string[] {
-  const common = ['if', 'else', 'for', 'while', 'return', 'break', 'continue', 'switch', 'case', 'default', 'try', 'catch', 'throw', 'new', 'delete', 'true', 'false', 'null', 'undefined', 'void'];
-
-  const langKeywords: Record<string, string[]> = {
-    typescript: [...common, 'const', 'let', 'var', 'function', 'class', 'interface', 'type', 'enum', 'import', 'export', 'from', 'async', 'await', 'extends', 'implements', 'readonly', 'private', 'public', 'protected', 'static', 'abstract', 'as', 'is', 'in', 'of', 'typeof', 'keyof', 'infer', 'never', 'unknown', 'any', 'string', 'number', 'boolean', 'symbol', 'object'],
-    javascript: [...common, 'const', 'let', 'var', 'function', 'class', 'import', 'export', 'from', 'async', 'await', 'extends', 'typeof', 'instanceof', 'in', 'of', 'this', 'super', 'yield'],
-    python: ['def', 'class', 'import', 'from', 'if', 'elif', 'else', 'for', 'while', 'return', 'yield', 'break', 'continue', 'try', 'except', 'finally', 'raise', 'with', 'as', 'pass', 'lambda', 'True', 'False', 'None', 'and', 'or', 'not', 'in', 'is', 'global', 'nonlocal', 'assert', 'async', 'await', 'self'],
-    rust: [...common, 'fn', 'let', 'mut', 'pub', 'struct', 'enum', 'impl', 'trait', 'use', 'mod', 'crate', 'self', 'super', 'match', 'loop', 'move', 'ref', 'where', 'async', 'await', 'dyn', 'Box', 'Vec', 'String', 'Option', 'Result', 'Some', 'None', 'Ok', 'Err'],
-    go: [...common, 'func', 'package', 'import', 'type', 'struct', 'interface', 'map', 'chan', 'go', 'defer', 'select', 'range', 'var', 'const', 'nil', 'make', 'len', 'append', 'cap', 'copy', 'close'],
-  };
-
-  return langKeywords[language] ?? common;
-}
+import { sha256 } from '../utils/hash.js';
+
+export function fingerprintCode(source: string, language: string): string {
+  let normalized = stripComments(source, language);
+  normalized = normalized.replace(/\s+/g, ' ').trim();
+  normalized = normalizeIdentifiers(normalized, language);
+  normalized = normalized.replace(/'[^']*'/g, "'<STR>'");
+  normalized = normalized.replace(/"[^"]*"/g, '"<STR>"');
+  normalized = normalized.replace(/`[^`]*`/g, '`<STR>`');
+  normalized = normalized.replace(/\b\d+\b/g, '<NUM>');
+  return sha256(normalized);
+}
+
+export function stripComments(source: string, language: string): string {
+  switch (language) {
+    case 'typescript':
+    case 'javascript':
+    case 'java':
+    case 'go':
+    case 'rust':
+    case 'c':
+    case 'cpp':
+      return source
+        .replace(/\/\/.*$/gm, '')
+        .replace(/\/\*[\s\S]*?\*\//g, '');
+    case 'python':
+      return source
+        .replace(/#.*$/gm, '')
+        .replace(/"""[\s\S]*?"""/g, '')
+        .replace(/'''[\s\S]*?'''/g, '');
+    default:
+      return source
+        .replace(/\/\/.*$/gm, '')
+        .replace(/#.*$/gm, '');
+  }
+}
+
+function normalizeIdentifiers(source: string, language: string): string {
+  const importNames = extractImportNames(source, language);
+  const keywords = getLanguageKeywords(language);
+  const preserve = new Set([...importNames, ...keywords]);
+
+  return source.replace(/\b[a-zA-Z_]\w*\b/g, (match) => {
+    if (preserve.has(match)) return match;
+    if (match[0] === match[0]!.toUpperCase() && match[0] !== match[0]!.toLowerCase()) return '<CLASS>';
+    return '<VAR>';
+  });
+}
+
+function extractImportNames(source: string, language: string): string[] {
+  const names: string[] = [];
+
+  if (language === 'typescript' || language === 'javascript') {
+    const re = /import\s+(?:\{([^}]+)\}|\*\s+as\s+(\w+)|(\w+))/g;
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(source)) !== null) {
+      if (m[1]) names.push(...m[1].split(',').map(s => s.trim().split(/\s+as\s+/).pop()!));
+      if (m[2]) names.push(m[2]);
+      if (m[3]) names.push(m[3]);
+    }
+  } else if (language === 'python') {
+    const re = /(?:from\s+\S+\s+)?import\s+(.+)/g;
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(source)) !== null) {
+      names.push(...m[1]!.split(',').map(s => {
+        const parts = s.trim().split(/\s+as\s+/);
+        return parts[parts.length - 1]!;
+      }));
+    }
+  }
+
+  return names.filter(Boolean);
+}
+
+function getLanguageKeywords(language: string): string[] {
+  const common = ['if', 'else', 'for', 'while', 'return', 'break', 'continue', 'switch', 'case', 'default', 'try', 'catch', 'throw', 'new', 'delete', 'true', 'false', 'null', 'undefined', 'void'];
+
+  const langKeywords: Record<string, string[]> = {
+    typescript: [...common, 'const', 'let', 'var', 'function', 'class', 'interface', 'type', 'enum', 'import', 'export', 'from', 'async', 'await', 'extends', 'implements', 'readonly', 'private', 'public', 'protected', 'static', 'abstract', 'as', 'is', 'in', 'of', 'typeof', 'keyof', 'infer', 'never', 'unknown', 'any', 'string', 'number', 'boolean', 'symbol', 'object'],
+    javascript: [...common, 'const', 'let', 'var', 'function', 'class', 'import', 'export', 'from', 'async', 'await', 'extends', 'typeof', 'instanceof', 'in', 'of', 'this', 'super', 'yield'],
+    python: ['def', 'class', 'import', 'from', 'if', 'elif', 'else', 'for', 'while', 'return', 'yield', 'break', 'continue', 'try', 'except', 'finally', 'raise', 'with', 'as', 'pass', 'lambda', 'True', 'False', 'None', 'and', 'or', 'not', 'in', 'is', 'global', 'nonlocal', 'assert', 'async', 'await', 'self'],
+    rust: [...common, 'fn', 'let', 'mut', 'pub', 'struct', 'enum', 'impl', 'trait', 'use', 'mod', 'crate', 'self', 'super', 'match', 'loop', 'move', 'ref', 'where', 'async', 'await', 'dyn', 'Box', 'Vec', 'String', 'Option', 'Result', 'Some', 'None', 'Ok', 'Err'],
+    go: [...common, 'func', 'package', 'import', 'type', 'struct', 'interface', 'map', 'chan', 'go', 'defer', 'select', 'range', 'var', 'const', 'nil', 'make', 'len', 'append', 'cap', 'copy', 'close'],
+  };
+
+  return langKeywords[language] ?? common;
+}

package/src/code/parsers/generic.ts

@@ -1,29 +1,29 @@
-import type { ExportInfo } from '../../types/code.types.js';
-
-const FUNC_RE = /(?:function|func|fn|def|sub)\s+(\w+)/g;
-const CLASS_RE = /(?:class|struct|type)\s+(\w+)/g;
-
-export function extractExports(source: string): ExportInfo[] {
-  const exports: ExportInfo[] = [];
-  let match: RegExpExecArray | null;
-
-  const funcRe = new RegExp(FUNC_RE.source, 'g');
-  while ((match = funcRe.exec(source)) !== null) {
-    exports.push({ name: match[1]!, type: 'function' });
-  }
-
-  const classRe = new RegExp(CLASS_RE.source, 'g');
-  while ((match = classRe.exec(source)) !== null) {
-    exports.push({ name: match[1]!, type: 'class' });
-  }
-
-  return exports;
-}
-
-export function extractImports(_source: string): { external: string[]; internal: string[] } {
-  return { external: [], internal: [] };
-}
-
-export function hasTypeAnnotations(_source: string): boolean {
-  return false;
-}
+import type { ExportInfo } from '../../types/code.types.js';
+
+const FUNC_RE = /(?:function|func|fn|def|sub)\s+(\w+)/g;
+const CLASS_RE = /(?:class|struct|type)\s+(\w+)/g;
+
+export function extractExports(source: string): ExportInfo[] {
+  const exports: ExportInfo[] = [];
+  let match: RegExpExecArray | null;
+
+  const funcRe = new RegExp(FUNC_RE.source, 'g');
+  while ((match = funcRe.exec(source)) !== null) {
+    exports.push({ name: match[1]!, type: 'function' });
+  }
+
+  const classRe = new RegExp(CLASS_RE.source, 'g');
+  while ((match = classRe.exec(source)) !== null) {
+    exports.push({ name: match[1]!, type: 'class' });
+  }
+
+  return exports;
+}
+
+export function extractImports(_source: string): { external: string[]; internal: string[] } {
+  return { external: [], internal: [] };
+}
+
+export function hasTypeAnnotations(_source: string): boolean {
+  return false;
+}

package/src/code/parsers/python.ts

@@ -1,54 +1,54 @@
-import type { ExportInfo } from '../../types/code.types.js';
-
-const FUNC_DEF_RE = /^def\s+(\w+)\s*\(/gm;
-const CLASS_DEF_RE = /^class\s+(\w+)/gm;
-const IMPORT_RE = /^(?:from\s+(\S+)\s+)?import\s+(.+)/gm;
-const TOP_LEVEL_ASSIGN_RE = /^([A-Z_][A-Z_\d]*)\s*=/gm;
-
-export function extractExports(source: string): ExportInfo[] {
-  const exports: ExportInfo[] = [];
-  let match: RegExpExecArray | null;
-
-  const funcRe = new RegExp(FUNC_DEF_RE.source, 'gm');
-  while ((match = funcRe.exec(source)) !== null) {
-    if (!match[1]!.startsWith('_')) {
-      exports.push({ name: match[1]!, type: 'function' });
-    }
-  }
-
-  const classRe = new RegExp(CLASS_DEF_RE.source, 'gm');
-  while ((match = classRe.exec(source)) !== null) {
-    if (!match[1]!.startsWith('_')) {
-      exports.push({ name: match[1]!, type: 'class' });
-    }
-  }
-
-  const constRe = new RegExp(TOP_LEVEL_ASSIGN_RE.source, 'gm');
-  while ((match = constRe.exec(source)) !== null) {
-    exports.push({ name: match[1]!, type: 'constant' });
-  }
-
-  return exports;
-}
-
-export function extractImports(source: string): { external: string[]; internal: string[] } {
-  const external: string[] = [];
-  const internal: string[] = [];
-  let match: RegExpExecArray | null;
-
-  const importRe = new RegExp(IMPORT_RE.source, 'gm');
-  while ((match = importRe.exec(source)) !== null) {
-    const module = match[1] ?? match[2]!.trim().split(/\s*,\s*/)[0]!;
-    if (module.startsWith('.')) {
-      internal.push(module);
-    } else {
-      external.push(module);
-    }
-  }
-
-  return { external, internal };
-}
-
-export function hasTypeAnnotations(source: string): boolean {
-  return /:\s*\w+/.test(source) && /->/.test(source);
-}
+import type { ExportInfo } from '../../types/code.types.js';
+
+const FUNC_DEF_RE = /^def\s+(\w+)\s*\(/gm;
+const CLASS_DEF_RE = /^class\s+(\w+)/gm;
+const IMPORT_RE = /^(?:from\s+(\S+)\s+)?import\s+(.+)/gm;
+const TOP_LEVEL_ASSIGN_RE = /^([A-Z_][A-Z_\d]*)\s*=/gm;
+
+export function extractExports(source: string): ExportInfo[] {
+  const exports: ExportInfo[] = [];
+  let match: RegExpExecArray | null;
+
+  const funcRe = new RegExp(FUNC_DEF_RE.source, 'gm');
+  while ((match = funcRe.exec(source)) !== null) {
+    if (!match[1]!.startsWith('_')) {
+      exports.push({ name: match[1]!, type: 'function' });
+    }
+  }
+
+  const classRe = new RegExp(CLASS_DEF_RE.source, 'gm');
+  while ((match = classRe.exec(source)) !== null) {
+    if (!match[1]!.startsWith('_')) {
+      exports.push({ name: match[1]!, type: 'class' });
+    }
+  }
+
+  const constRe = new RegExp(TOP_LEVEL_ASSIGN_RE.source, 'gm');
+  while ((match = constRe.exec(source)) !== null) {
+    exports.push({ name: match[1]!, type: 'constant' });
+  }
+
+  return exports;
+}
+
+export function extractImports(source: string): { external: string[]; internal: string[] } {
+  const external: string[] = [];
+  const internal: string[] = [];
+  let match: RegExpExecArray | null;
+
+  const importRe = new RegExp(IMPORT_RE.source, 'gm');
+  while ((match = importRe.exec(source)) !== null) {
+    const module = match[1] ?? match[2]!.trim().split(/\s*,\s*/)[0]!;
+    if (module.startsWith('.')) {
+      internal.push(module);
+    } else {
+      external.push(module);
+    }
+  }
+
+  return { external, internal };
+}
+
+export function hasTypeAnnotations(source: string): boolean {
+  return /:\s*\w+/.test(source) && /->/.test(source);
+}

package/src/code/parsers/typescript.ts

@@ -1,65 +1,65 @@
-import type { ExportInfo } from '../../types/code.types.js';
-
-const NAMED_EXPORT_RE = /export\s+(?:async\s+)?(?:function|const|let|var|class|interface|type|enum)\s+(\w+)/g;
-const DEFAULT_EXPORT_RE = /export\s+default\s+(?:(?:async\s+)?(?:function|class)\s+)?(\w+)?/g;
-const IMPORT_RE = /import\s+(?:(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)(?:\s*,\s*(?:\{[^}]*\}|\*\s+as\s+\w+|\w+))*\s+from\s+)?['"]([^'"]+)['"]/g;
-
-export function extractExports(source: string): ExportInfo[] {
-  const exports: ExportInfo[] = [];
-  let match: RegExpExecArray | null;
-
-  const namedRe = new RegExp(NAMED_EXPORT_RE.source, 'g');
-  while ((match = namedRe.exec(source)) !== null) {
-    const line = source.substring(
-      source.lastIndexOf('\n', match.index) + 1,
-      source.indexOf('\n', match.index),
-    );
-    exports.push({
-      name: match[1]!,
-      type: detectExportType(line),
-    });
-  }
-
-  const defaultRe = new RegExp(DEFAULT_EXPORT_RE.source, 'g');
-  while ((match = defaultRe.exec(source)) !== null) {
-    exports.push({
-      name: match[1] ?? 'default',
-      type: 'function',
-    });
-  }
-
-  return exports;
-}
-
-export function extractImports(source: string): { external: string[]; internal: string[] } {
-  const external: string[] = [];
-  const internal: string[] = [];
-  let match: RegExpExecArray | null;
-
-  const importRe = new RegExp(IMPORT_RE.source, 'g');
-  while ((match = importRe.exec(source)) !== null) {
-    const specifier = match[1]!;
-    if (specifier.startsWith('.') || specifier.startsWith('/')) {
-      internal.push(specifier);
-    } else {
-      external.push(specifier);
-    }
-  }
-
-  return { external, internal };
-}
-
-export function hasTypeAnnotations(source: string): boolean {
-  return /:\s*\w+[\[\]<>|&]*\s*[=;,)\n{]/.test(source) ||
-    /interface\s+\w+/.test(source) ||
-    /type\s+\w+\s*=/.test(source);
-}
-
-function detectExportType(line: string): ExportInfo['type'] {
-  if (/\bfunction\b/.test(line)) return 'function';
-  if (/\bclass\b/.test(line)) return 'class';
-  if (/\binterface\b/.test(line)) return 'interface';
-  if (/\btype\b/.test(line)) return 'type';
-  if (/\bconst\b/.test(line)) return 'constant';
-  return 'variable';
-}
+import type { ExportInfo } from '../../types/code.types.js';
+
+const NAMED_EXPORT_RE = /export\s+(?:async\s+)?(?:function|const|let|var|class|interface|type|enum)\s+(\w+)/g;
+const DEFAULT_EXPORT_RE = /export\s+default\s+(?:(?:async\s+)?(?:function|class)\s+)?(\w+)?/g;
+const IMPORT_RE = /import\s+(?:(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)(?:\s*,\s*(?:\{[^}]*\}|\*\s+as\s+\w+|\w+))*\s+from\s+)?['"]([^'"]+)['"]/g;
+
+export function extractExports(source: string): ExportInfo[] {
+  const exports: ExportInfo[] = [];
+  let match: RegExpExecArray | null;
+
+  const namedRe = new RegExp(NAMED_EXPORT_RE.source, 'g');
+  while ((match = namedRe.exec(source)) !== null) {
+    const line = source.substring(
+      source.lastIndexOf('\n', match.index) + 1,
+      source.indexOf('\n', match.index),
+    );
+    exports.push({
+      name: match[1]!,
+      type: detectExportType(line),
+    });
+  }
+
+  const defaultRe = new RegExp(DEFAULT_EXPORT_RE.source, 'g');
+  while ((match = defaultRe.exec(source)) !== null) {
+    exports.push({
+      name: match[1] ?? 'default',
+      type: 'function',
+    });
+  }
+
+  return exports;
+}
+
+export function extractImports(source: string): { external: string[]; internal: string[] } {
+  const external: string[] = [];
+  const internal: string[] = [];
+  let match: RegExpExecArray | null;
+
+  const importRe = new RegExp(IMPORT_RE.source, 'g');
+  while ((match = importRe.exec(source)) !== null) {
+    const specifier = match[1]!;
+    if (specifier.startsWith('.') || specifier.startsWith('/')) {
+      internal.push(specifier);
+    } else {
+      external.push(specifier);
+    }
+  }
+
+  return { external, internal };
+}
+
+export function hasTypeAnnotations(source: string): boolean {
+  return /:\s*\w+[\[\]<>|&]*\s*[=;,)\n{]/.test(source) ||
+    /interface\s+\w+/.test(source) ||
+    /type\s+\w+\s*=/.test(source);
+}
+
+function detectExportType(line: string): ExportInfo['type'] {
+  if (/\bfunction\b/.test(line)) return 'function';
+  if (/\bclass\b/.test(line)) return 'class';
+  if (/\binterface\b/.test(line)) return 'interface';
+  if (/\btype\b/.test(line)) return 'type';
+  if (/\bconst\b/.test(line)) return 'constant';
+  return 'variable';
+}

package/src/code/registry.ts

@@ -1,60 +1,60 @@
-import type { ExportInfo } from '../types/code.types.js';
-import { analyzeCode, measureCohesion } from './analyzer.js';
-
-export type ModuleType = 'file' | 'class' | 'function';
-
-export function detectGranularity(
-  source: string,
-  language: string,
-): ModuleType {
-  const { exports } = analyzeCode(source, language);
-
-  const hasDefault = exports.some(e => e.name === 'default');
-  if (hasDefault && exports.length <= 3) return 'file';
-
-  const classes = exports.filter(e => e.type === 'class');
-  if (classes.length === 1 && exports.length <= 3) return 'class';
-
-  if (exports.length > 3) {
-    const cohesion = measureCohesion(exports);
-    if (cohesion < 0.5) return 'function';
-  }
-
-  return 'file';
-}
-
-export interface ModuleRegistration {
-  name: string;
-  filePath: string;
-  language: string;
-  source: string;
-  description?: string;
-  projectId: number;
-}
-
-export interface RegisteredModule {
-  name: string;
-  moduleType: ModuleType;
-  exports: ExportInfo[];
-  externalDeps: string[];
-  internalDeps: string[];
-  isPure: boolean;
-  hasTypeAnnotations: boolean;
-  linesOfCode: number;
-}
-
-export function prepareModule(reg: ModuleRegistration): RegisteredModule {
-  const analysis = analyzeCode(reg.source, reg.language);
-  const moduleType = detectGranularity(reg.source, reg.language);
-
-  return {
-    name: reg.name,
-    moduleType,
-    exports: analysis.exports,
-    externalDeps: analysis.externalDeps,
-    internalDeps: analysis.internalDeps,
-    isPure: analysis.isPure,
-    hasTypeAnnotations: analysis.hasTypeAnnotations,
-    linesOfCode: analysis.linesOfCode,
-  };
-}
+import type { ExportInfo } from '../types/code.types.js';
+import { analyzeCode, measureCohesion } from './analyzer.js';
+
+export type ModuleType = 'file' | 'class' | 'function';
+
+export function detectGranularity(
+  source: string,
+  language: string,
+): ModuleType {
+  const { exports } = analyzeCode(source, language);
+
+  const hasDefault = exports.some(e => e.name === 'default');
+  if (hasDefault && exports.length <= 3) return 'file';
+
+  const classes = exports.filter(e => e.type === 'class');
+  if (classes.length === 1 && exports.length <= 3) return 'class';
+
+  if (exports.length > 3) {
+    const cohesion = measureCohesion(exports);
+    if (cohesion < 0.5) return 'function';
+  }
+
+  return 'file';
+}
+
+export interface ModuleRegistration {
+  name: string;
+  filePath: string;
+  language: string;
+  source: string;
+  description?: string;
+  projectId: number;
+}
+
+export interface RegisteredModule {
+  name: string;
+  moduleType: ModuleType;
+  exports: ExportInfo[];
+  externalDeps: string[];
+  internalDeps: string[];
+  isPure: boolean;
+  hasTypeAnnotations: boolean;
+  linesOfCode: number;
+}
+
+export function prepareModule(reg: ModuleRegistration): RegisteredModule {
+  const analysis = analyzeCode(reg.source, reg.language);
+  const moduleType = detectGranularity(reg.source, reg.language);
+
+  return {
+    name: reg.name,
+    moduleType,
+    exports: analysis.exports,
+    externalDeps: analysis.externalDeps,
+    internalDeps: analysis.internalDeps,
+    isPure: analysis.isPure,
+    hasTypeAnnotations: analysis.hasTypeAnnotations,
+    linesOfCode: analysis.linesOfCode,
+  };
+}