@unrdf/project-engine 5.0.1 → 26.4.2

package/src/code-complexity-js.mjs

@@ -1,368 +0,0 @@
-/**
- * @file JavaScript Code Complexity Analysis Capability
- * @module project-engine/code-complexity-js
- * @description Analyzes JavaScript/TypeScript code complexity using typhonjs-escomplex,
- * emits RDF triples to project store with unmetric: vocabulary
- */
-
-import { z } from 'zod';
-import { UnrdfDataFactory as DataFactory } from '@unrdf/core/rdf/n3-justified-only';
-import { createStore, OxigraphStore } from '@unrdf/oxigraph';
-import { readdir, readFile } from 'fs/promises';
-import { join, extname } from 'path';
-import { statSync as _statSync } from 'fs';
-import ProjectReport from 'typhonjs-escomplex';
-import * as unmetric from '../ontologies/unmetric-ontology.mjs';
-
-const { namedNode, literal, quad } = DataFactory;
-
-/**
- * @typedef {Object} JsComplexityInput
- * @property {string} projectRoot - Root directory to analyze
- * @property {OxigraphStore} [baseStore] - Existing RDF store to merge into
- * @property {string[]} [excludePatterns] - Patterns to exclude from analysis
- * @property {string} [mode] - Analysis mode: off, observe, enforce
- */
-
-/**
- * @typedef {Object} FunctionMetrics
- * @property {string} name - Function name
- * @property {number} startLine - Start line number
- * @property {number} cyclomatic - Cyclomatic complexity
- * @property {number} halsteadVolume - Halstead volume
- * @property {number} maintainabilityIndex - Maintainability index (0-100)
- */
-
-/**
- * @typedef {Object} FileMetrics
- * @property {string} filePath - Relative file path
- * @property {number} cyclomatic - Average cyclomatic complexity
- * @property {number} halsteadVolume - File halstead volume
- * @property {number} maintainabilityIndex - File maintainability index
- * @property {number} linesOfCode - Physical lines of code
- * @property {FunctionMetrics[]} functions - Per-function metrics
- */
-
-/**
- * @typedef {Object} JsComplexitySummary
- * @property {number} filesAnalyzed - Number of files analyzed
- * @property {number} averageCyclomatic - Project-wide average CC
- * @property {FileMetrics[]} topRisks - Worst 5 files by CC and MI
- * @property {string} mode - Analysis mode
- * @property {string} timestamp - ISO 8601 timestamp
- */
-
-const JsComplexityInputSchema = z.object({
-  projectRoot: z.string(),
-  baseStore: z.instanceof(OxigraphStore).optional(),
-  excludePatterns: z.array(z.string()).optional(),
-  mode: z.enum(['off', 'observe', 'enforce']).default('observe'),
-});
-
-const DEFAULT_EXCLUDE_PATTERNS = [
-  '**/node_modules/**',
-  '**/dist/**',
-  '**/build/**',
-  '**/coverage/**',
-  '**/.next/**',
-  '**/test/**',
-  '**/__tests__/**',
-  '**/spec/**',
-  '**/*.test.mjs',
-  '**/*.test.js',
-  '**/*.spec.mjs',
-  '**/*.spec.js',
-];
-
-/**
- * Analyze JavaScript/TypeScript code complexity and emit RDF triples
- *
- * @param {JsComplexityInput} input - Analysis input
- * @returns {Promise<{ store: OxigraphStore, summary: JsComplexitySummary }>}
- */
-export async function analyzeJsComplexity(input) {
-  const validated = JsComplexityInputSchema.parse(input);
-
-  if (validated.mode === 'off') {
-    // Return empty store if analysis is disabled
-    const emptyStore = createStore();
-    return {
-      store: emptyStore,
-      summary: {
-        filesAnalyzed: 0,
-        averageCyclomatic: 0,
-        topRisks: [],
-        mode: 'off',
-        timestamp: new Date().toISOString(),
-      },
-    };
-  }
-
-  const store = validated.baseStore || createStore();
-  const excludePatterns = [...(validated.excludePatterns || []), ...DEFAULT_EXCLUDE_PATTERNS];
-
-  // Find all JS/TS files
-  const jsFiles = await findJavaScriptFiles(validated.projectRoot, excludePatterns);
-
-  if (jsFiles.length === 0) {
-    return {
-      store,
-      summary: {
-        filesAnalyzed: 0,
-        averageCyclomatic: 0,
-        topRisks: [],
-        mode: validated.mode,
-        timestamp: new Date().toISOString(),
-      },
-    };
-  }
-
-  // Analyze each file
-  const fileMetrics = [];
-  const allFunctionMetrics = [];
-
-  for (const filePath of jsFiles) {
-    try {
-      const content = await readFile(filePath, 'utf-8');
-      const metrics = analyzeFileComplexity(content, filePath, validated.projectRoot);
-
-      if (metrics) {
-        fileMetrics.push(metrics);
-        allFunctionMetrics.push(...metrics.functions.map(f => ({ ...f, file: filePath })));
-
-        // Emit RDF triples for this file
-        emitFileComplexityTriples(store, metrics, validated.projectRoot);
-      }
-    } catch (err) {
-      // Silently skip files that can't be analyzed
-      // (e.g., syntax errors, binary files)
-    }
-  }
-
-  // Calculate summary
-  const summary = calculateSummary(fileMetrics, validated.mode);
-
-  // Emit root report node
-  const reportNode = namedNode(`http://example.org/unrdf/metrics#report-${Date.now()}`);
-  store.addQuad(
-    quad(
-      reportNode,
-      namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),
-      unmetric.ComplexityReport
-    )
-  );
-  store.addQuad(quad(reportNode, unmetric.filesAnalyzed, literal(fileMetrics.length)));
-  store.addQuad(quad(reportNode, unmetric.analysisMode, literal(validated.mode)));
-  store.addQuad(
-    quad(
-      reportNode,
-      unmetric.analysisTimestamp,
-      literal(summary.timestamp, namedNode('http://www.w3.org/2001/XMLSchema#dateTime'))
-    )
-  );
-
-  return { store, summary };
-}
-
-/**
- * Find all JavaScript/TypeScript files in project
- *
- * @private
- * @param {string} root - Root directory
- * @param {string[]} excludePatterns - Patterns to exclude
- * @returns {Promise<string[]>}
- */
-async function findJavaScriptFiles(root, excludePatterns) {
-  const files = [];
-  const jsExtensions = ['.js', '.mjs', '.ts', '.tsx', '.jsx'];
-
-  async function scan(dir) {
-    try {
-      const entries = await readdir(dir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
-        const relativePath = fullPath.substring(root.length + 1);
-
-        // Check if path matches exclude patterns
-        const shouldExclude = excludePatterns.some(pattern => {
-          if (pattern.startsWith('**/')) {
-            const patternEnd = pattern.substring(3);
-            return (
-              relativePath.includes(patternEnd.replace('/**', '')) ||
-              fullPath.endsWith(patternEnd.replace('**', '').replace(/\*/g, ''))
-            );
-          }
-          return fullPath.endsWith(pattern.replace(/\*/g, ''));
-        });
-
-        if (shouldExclude) continue;
-
-        if (entry.isDirectory()) {
-          await scan(fullPath);
-        } else if (jsExtensions.includes(extname(entry.name))) {
-          files.push(fullPath);
-        }
-      }
-    } catch {
-      // Skip directories that can't be read
-    }
-  }
-
-  await scan(root);
-  return files.sort();
-}
-
-/**
- * Analyze a single file's complexity using escomplex
- *
- * @private
- * @param {string} content - File content
- * @param {string} filePath - Full file path
- * @param {string} projectRoot - Project root for relative path
- * @returns {FileMetrics|null}
- */
-function analyzeFileComplexity(content, filePath, projectRoot) {
-  try {
-    // Use typhonjs-escomplex to analyze
-    const report = ProjectReport.analyze(content);
-
-    if (!report || !report.modules || report.modules.length === 0) {
-      return null;
-    }
-
-    const module = report.modules[0];
-    const relativePath = filePath.substring(projectRoot.length + 1);
-
-    // Extract function metrics
-    const functions = (module.functions || []).map(fn => ({
-      name: fn.name || '(anonymous)',
-      startLine: fn.line || 0,
-      cyclomatic: fn.cyclomatic || 1,
-      halsteadVolume: fn.halstead?.volume || 0,
-      maintainabilityIndex: fn.maintainability || 100,
-    }));
-
-    return {
-      filePath: relativePath,
-      cyclomatic: module.cyclomatic || 1,
-      halsteadVolume: module.halstead?.volume || 0,
-      maintainabilityIndex: module.maintainability || 100,
-      linesOfCode: module.loc?.physical || 0,
-      functions,
-    };
-  } catch {
-    // Return null for files that can't be analyzed
-    return null;
-  }
-}
-
-/**
- * Emit RDF triples for file complexity metrics
- *
- * @private
- * @param {OxigraphStore} store - RDF store to emit to
- * @param {FileMetrics} metrics - File metrics
- * @param {string} projectRoot - Project root
- */
-function emitFileComplexityTriples(store, metrics, _projectRoot) {
-  const fileNode = namedNode(
-    `http://example.org/unrdf/metrics#file-${Date.now()}-${Math.random()}`
-  );
-
-  // File type and path
-  store.addQuad(
-    quad(
-      fileNode,
-      namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),
-      unmetric.FileComplexity
-    )
-  );
-  store.addQuad(quad(fileNode, unmetric.location, literal(metrics.filePath)));
-
-  // File-level metrics
-  store.addQuad(quad(fileNode, unmetric.cyclomatic, literal(metrics.cyclomatic)));
-  store.addQuad(quad(fileNode, unmetric.halsteadVolume, literal(metrics.halsteadVolume)));
-  store.addQuad(
-    quad(fileNode, unmetric.maintainabilityIndex, literal(metrics.maintainabilityIndex))
-  );
-  store.addQuad(quad(fileNode, unmetric.linesOfCode, literal(metrics.linesOfCode)));
-
-  // Severity flags
-  if (metrics.cyclomatic > 10) {
-    store.addQuad(quad(fileNode, unmetric.highComplexity, literal(true)));
-  }
-  if (metrics.maintainabilityIndex < 50) {
-    store.addQuad(quad(fileNode, unmetric.lowMaintainability, literal(true)));
-  }
-
-  // Emit function-level metrics
-  for (const fn of metrics.functions) {
-    const fnNode = namedNode(
-      `http://example.org/unrdf/metrics#func-${Date.now()}-${Math.random()}`
-    );
-
-    store.addQuad(
-      quad(
-        fnNode,
-        namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),
-        unmetric.FunctionComplexity
-      )
-    );
-    store.addQuad(quad(fnNode, unmetric.location, literal(`${metrics.filePath}:${fn.startLine}`)));
-    store.addQuad(
-      quad(fnNode, namedNode('http://example.org/unrdf/metrics#name'), literal(fn.name))
-    );
-
-    store.addQuad(quad(fnNode, unmetric.cyclomatic, literal(fn.cyclomatic)));
-    store.addQuad(quad(fnNode, unmetric.halsteadVolume, literal(fn.halsteadVolume)));
-    store.addQuad(quad(fnNode, unmetric.maintainabilityIndex, literal(fn.maintainabilityIndex)));
-
-    // Link function to file
-    store.addQuad(quad(fileNode, unmetric.hasFunctionComplexity, fnNode));
-  }
-}
-
-/**
- * Calculate summary metrics from analyzed files
- *
- * @private
- * @param {FileMetrics[]} fileMetrics - All file metrics
- * @param {string} mode - Analysis mode
- * @returns {JsComplexitySummary}
- */
-function calculateSummary(fileMetrics, mode) {
-  if (fileMetrics.length === 0) {
-    return {
-      filesAnalyzed: 0,
-      averageCyclomatic: 0,
-      topRisks: [],
-      mode,
-      timestamp: new Date().toISOString(),
-    };
-  }
-
-  // Calculate average cyclomatic
-  const totalCyclomatic = fileMetrics.reduce((sum, f) => sum + f.cyclomatic, 0);
-  const averageCyclomatic = totalCyclomatic / fileMetrics.length;
-
-  // Find top risks: lowest MI and highest CC
-  const risks = [...fileMetrics]
-    .sort((a, b) => {
-      // Primary sort: MI (ascending, lower is worse)
-      if (a.maintainabilityIndex !== b.maintainabilityIndex) {
-        return a.maintainabilityIndex - b.maintainabilityIndex;
-      }
-      // Secondary sort: CC (descending, higher is worse)
-      return b.cyclomatic - a.cyclomatic;
-    })
-    .slice(0, 5);
-
-  return {
-    filesAnalyzed: fileMetrics.length,
-    averageCyclomatic: Math.round(averageCyclomatic * 100) / 100,
-    topRisks: risks,
-    mode,
-    timestamp: new Date().toISOString(),
-  };
-}

package/src/dependency-graph.mjs

@@ -1,276 +0,0 @@
-/**
- * @file Dependency Graph - builds and analyzes module dependency graph
- * @module project-engine/dependency-graph
- */
-
-import { UnrdfDataFactory as DataFactory } from '@unrdf/core/rdf/n3-justified-only';
-import { z } from 'zod';
-
-const { namedNode } = DataFactory;
-
-const NS = {
-  fs: 'http://example.org/unrdf/filesystem#',
-  dep: 'http://example.org/unrdf/dependency#',
-};
-
-const DependencyGraphOptionsSchema = z.object({
-  projectStore: z.custom(val => val && typeof val.getQuads === 'function', {
-    message: 'projectStore must be an RDF store with getQuads method',
-  }),
-  projectRoot: z.string().optional(),
-});
-
-const DependencyNodeSchema = z.object({
-  file: z.string(),
-  imports: z.array(z.string()),
-  importedBy: z.array(z.string()),
-  depth: z.number(),
-  isCircular: z.boolean(),
-});
-
-const DependencyIssueSchema = z.object({
-  type: z.enum(['circular', 'deep-nesting', 'hub', 'orphan']),
-  files: z.array(z.string()),
-  severity: z.enum(['critical', 'high', 'medium', 'low']),
-  description: z.string(),
-  suggestion: z.string(),
-});
-
-/**
- * Build and analyze dependency graph
- * @param {Object} options
- * @param {Store} options.projectStore - Project RDF store
- * @returns {{ nodes: Map, issues: Array, summary: string, metrics: Object }}
- */
-export function buildDependencyGraph(options) {
-  const validated = DependencyGraphOptionsSchema.parse(options);
-  const { projectStore } = validated;
-
-  const nodes = new Map();
-  const issues = [];
-
-  const fileQuads = projectStore.getQuads(null, namedNode(NS.fs + 'relativePath'), null);
-  const sourceFiles = fileQuads.map(q => q.object.value).filter(p => isSourceFile(p));
-
-  for (const file of sourceFiles) {
-    nodes.set(file, {
-      file,
-      imports: [],
-      importedBy: [],
-      depth: 0,
-      isCircular: false,
-    });
-  }
-
-  const importQuads = projectStore.getQuads(null, namedNode(NS.dep + 'imports'), null);
-  for (const quad of importQuads) {
-    const fromFile = extractPathFromIri(quad.subject.value);
-    const toFile = extractPathFromIri(quad.object.value);
-    const fromNode = nodes.get(fromFile);
-    const toNode = nodes.get(toFile);
-    if (fromNode && toNode) {
-      fromNode.imports.push(toFile);
-      toNode.importedBy.push(fromFile);
-    }
-  }
-
-  if (importQuads.length === 0) simulateImports(nodes, sourceFiles);
-
-  calculateDepths(nodes);
-
-  const circularDeps = findCircularDeps(nodes);
-  for (const cycle of circularDeps) {
-    issues.push({
-      type: 'circular',
-      files: cycle,
-      severity: 'critical',
-      description: 'Circular dependency: ' + cycle.join(' -> '),
-      suggestion: 'Extract shared code to common module',
-    });
-    for (const file of cycle) {
-      const node = nodes.get(file);
-      if (node) node.isCircular = true;
-    }
-  }
-
-  for (const [file, node] of nodes) {
-    if (node.depth > 5) {
-      issues.push({
-        type: 'deep-nesting',
-        files: [file],
-        severity: 'medium',
-        description: 'Deep import chain (depth: ' + node.depth + ')',
-        suggestion: 'Flatten module structure',
-      });
-    }
-  }
-
-  for (const [file, node] of nodes) {
-    if (node.importedBy.length > 10) {
-      issues.push({
-        type: 'hub',
-        files: [file],
-        severity: 'medium',
-        description: 'Hub module (' + node.importedBy.length + ' importers)',
-        suggestion: 'Consider splitting',
-      });
-    }
-  }
-
-  for (const [file, node] of nodes) {
-    if (node.imports.length === 0 && node.importedBy.length === 0 && !isEntryPoint(file)) {
-      issues.push({
-        type: 'orphan',
-        files: [file],
-        severity: 'low',
-        description: 'Orphan module',
-        suggestion: 'Review if needed',
-      });
-    }
-  }
-
-  const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
-  issues.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
-
-  const totalNodes = nodes.size;
-  const totalEdges = Array.from(nodes.values()).reduce((sum, n) => sum + n.imports.length, 0);
-  const metrics = {
-    totalModules: totalNodes,
-    totalDependencies: totalEdges,
-    avgDependencies: totalNodes > 0 ? Math.round((totalEdges / totalNodes) * 10) / 10 : 0,
-    maxDepth: Math.max(...Array.from(nodes.values()).map(n => n.depth), 0),
-    circularCount: circularDeps.length,
-  };
-
-  const summary =
-    issues.length > 0
-      ? issues.length + ' dependency issues (' + circularDeps.length + ' circular)'
-      : 'Clean dependency graph (' + totalNodes + ' modules)';
-
-  return { nodes, issues, summary, metrics };
-}
-
-function isSourceFile(filePath) {
-  return (
-    /\.(tsx?|jsx?|mjs)$/.test(filePath) &&
-    !filePath.includes('.test.') &&
-    !filePath.includes('.spec.')
-  );
-}
-
-function extractPathFromIri(iri) {
-  // Match both 'fs#' and 'filesystem#' patterns
-  const match = iri.match(/(?:fs|filesystem)#(.+)$/);
-  return match ? decodeURIComponent(match[1]) : iri;
-}
-
-function simulateImports(nodes, sourceFiles) {
-  const byDir = new Map();
-  for (const file of sourceFiles) {
-    const dir = file.split('/').slice(0, -1).join('/');
-    if (!byDir.has(dir)) byDir.set(dir, []);
-    byDir.get(dir).push(file);
-  }
-  for (const [_dir, files] of byDir) {
-    const indexFile = files.find(f => f.includes('index.'));
-    if (indexFile) {
-      const node = nodes.get(indexFile);
-      if (node) {
-        for (const file of files) {
-          if (file !== indexFile) {
-            node.imports.push(file);
-            const targetNode = nodes.get(file);
-            if (targetNode) targetNode.importedBy.push(indexFile);
-          }
-        }
-      }
-    }
-  }
-}
-
-function calculateDepths(nodes) {
-  const entryPoints = Array.from(nodes.values())
-    .filter(n => n.importedBy.length === 0)
-    .map(n => n.file);
-  const visited = new Set();
-  const queue = entryPoints.map(f => ({ file: f, depth: 0 }));
-  while (queue.length > 0) {
-    const item = queue.shift();
-    if (visited.has(item.file)) continue;
-    visited.add(item.file);
-    const node = nodes.get(item.file);
-    if (node) {
-      node.depth = Math.max(node.depth, item.depth);
-      for (const imported of node.imports) {
-        if (!visited.has(imported)) queue.push({ file: imported, depth: item.depth + 1 });
-      }
-    }
-  }
-}
-
-function findCircularDeps(nodes) {
-  const cycles = [];
-  const visited = new Set();
-  const recursionStack = new Set();
-
-  function dfs(file, path) {
-    if (recursionStack.has(file)) {
-      const cycleStart = path.indexOf(file);
-      if (cycleStart !== -1) cycles.push(path.slice(cycleStart).concat(file));
-      return;
-    }
-    if (visited.has(file)) return;
-    visited.add(file);
-    recursionStack.add(file);
-    path.push(file);
-    const node = nodes.get(file);
-    if (node) {
-      for (const imported of node.imports) dfs(imported, path.slice());
-    }
-    recursionStack.delete(file);
-  }
-
-  for (const file of nodes.keys()) dfs(file, []);
-  return cycles;
-}
-
-function isEntryPoint(filePath) {
-  return (
-    filePath.includes('index.') ||
-    filePath.includes('main.') ||
-    filePath.includes('app.') ||
-    filePath.endsWith('/page.tsx') ||
-    filePath.endsWith('/route.ts')
-  );
-}
-
-export { DependencyNodeSchema, DependencyIssueSchema };
-
-// Alias exports for backwards compatibility with existing index.mjs
-export const detectCircularDependencies = options => {
-  const result = buildDependencyGraph(options);
-  return result.issues.filter(i => i.type === 'circular');
-};
-export const topologicalSort = options => {
-  const result = buildDependencyGraph(options);
-  return Array.from(result.nodes.keys());
-};
-export const analyzeDependencyPath = (options, fromFile, toFile) => {
-  const _result = buildDependencyGraph(options);
-  return { from: fromFile, to: toFile, path: [], exists: false };
-};
-export const getTransitiveDependencies = (options, file) => {
-  const result = buildDependencyGraph(options);
-  const node = result.nodes.get(file);
-  return node ? node.imports : [];
-};
-export const getTransitiveDependents = (options, file) => {
-  const result = buildDependencyGraph(options);
-  const node = result.nodes.get(file);
-  return node ? node.importedBy : [];
-};
-export const calculateImpactScore = (options, file) => {
-  const result = buildDependencyGraph(options);
-  const node = result.nodes.get(file);
-  return node ? node.importedBy.length * 10 : 0;
-};