codesummary 1.2.1 → 1.2.2

package/src/configManager.js

@@ -175,6 +175,17 @@ export class ConfigManager {
         documentTitle: "Project Code Summary",
         maxFilesBeforePrompt: 500,
       },
+      ai: {
+        enabled: false,
+        provider: "openai-compatible",
+        baseUrl: "http://localhost:11434/v1",
+        apiKey: "",
+        model: "llama3.1",
+        timeoutMs: 30000,
+        maxRetries: 2,
+        retryBackoffMs: 500,
+        maxBackoffMs: 5000,
+      },
     };
   }
 
@@ -874,6 +885,16 @@ export class ConfigManager {
     console.log(chalk.gray(`  • File warning threshold: ${config.settings?.maxFilesBeforePrompt || 500} files`));
     console.log(chalk.gray(`  • Configuration version: ${config.configVersion || 'legacy'}`));
     console.log();
+
+    // AI Settings
+    if (config.ai) {
+      console.log(chalk.green("🤖 AI Settings:"));
+      console.log(chalk.gray(`  • Provider: ${config.ai.provider || 'openai-compatible'}`));
+      console.log(chalk.gray(`  • Model: ${config.ai.model || 'not set'}`));
+      console.log(chalk.gray(`  • Base URL: ${config.ai.baseUrl || 'http://localhost:11434/v1'}`));
+      console.log(chalk.gray(`  • API Key: ${config.ai.apiKey ? '********' : 'not set'}`));
+      console.log();
+    }
   }
 }
 

package/src/graph/adapters/baseAdapter.js

@@ -0,0 +1,24 @@
+/**
+ * Base adapter contract for language-aware extraction.
+ */
+export default class BaseAdapter {
+  supports(fileInfo) {
+    return false;
+  }
+
+  mode() {
+    return 'generic';
+  }
+
+  extractDependencies(content, fileInfo) {
+    return [];
+  }
+
+  extractSymbols(content, fileInfo) {
+    return {
+      entrypoints: [],
+      symbols: []
+    };
+  }
+}
+

package/src/graph/adapters/javascriptAdapter.js

@@ -0,0 +1,53 @@
+import BaseAdapter from './baseAdapter.js';
+
+export default class JavaScriptAdapter extends BaseAdapter {
+  supports(fileInfo) {
+    return ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'].includes(fileInfo.ext);
+  }
+
+  mode() {
+    return 'deep';
+  }
+
+  extractDependencies(content) {
+    const deps = [];
+    const importRegex = /import\s+.*?from\s+['"]([^'"]+)['"]/g;
+    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    let match;
+
+    while ((match = importRegex.exec(content)) !== null) deps.push(match[1]);
+    while ((match = requireRegex.exec(content)) !== null) deps.push(match[1]);
+    while ((match = dynamicImportRegex.exec(content)) !== null) deps.push(match[1]);
+
+    return [...new Set(deps)];
+  }
+
+  extractSymbols(content, fileInfo) {
+    const entrypoints = [];
+    const symbols = [];
+
+    if (/^\s*if\s*\(\s*require\.main\s*===\s*module\s*\)/m.test(content)) {
+      entrypoints.push(fileInfo.relativePath);
+    }
+
+    if (/^\s*#!/.test(content)) {
+      entrypoints.push(fileInfo.relativePath);
+    }
+
+    const classRegex = /^\s*(?:export\s+)?class\s+([A-Za-z_$][A-Za-z0-9_$]*)/gm;
+    const fnRegex = /^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)/gm;
+    const arrowRegex = /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>/gm;
+    let match;
+
+    while ((match = classRegex.exec(content)) !== null) symbols.push({ name: match[1], kind: 'class' });
+    while ((match = fnRegex.exec(content)) !== null) symbols.push({ name: match[1], kind: 'function' });
+    while ((match = arrowRegex.exec(content)) !== null) symbols.push({ name: match[1], kind: 'function' });
+
+    return {
+      entrypoints: [...new Set(entrypoints)],
+      symbols
+    };
+  }
+}
+

package/src/graph/adapters/pythonAdapter.js

@@ -0,0 +1,77 @@
+import BaseAdapter from './baseAdapter.js';
+
+export default class PythonAdapter extends BaseAdapter {
+  supports(fileInfo) {
+    return fileInfo.ext === '.py';
+  }
+
+  mode() {
+    return 'deep';
+  }
+
+  extractDependencies(content, fileInfo) {
+    const deps = [];
+    const fromImportRegex = /^\s*from\s+([A-Za-z0-9_\.]+)\s+import\s+/gm;
+    const importRegex = /^\s*import\s+([A-Za-z0-9_\.,\s]+)/gm;
+    let match;
+
+    while ((match = fromImportRegex.exec(content)) !== null) {
+      deps.push(match[1]);
+    }
+
+    while ((match = importRegex.exec(content)) !== null) {
+      const modules = match[1]
+        .split(',')
+        .map(part => part.trim().split(/\s+as\s+/i)[0])
+        .filter(Boolean);
+      deps.push(...modules);
+    }
+
+    const relativePrefix = this.getPackagePrefix(fileInfo.relativePath);
+    const resolved = deps.map(dep => this.normalizeDependency(dep, relativePrefix));
+    return [...new Set(resolved.filter(Boolean))];
+  }
+
+  extractSymbols(content, fileInfo) {
+    const symbols = [];
+    const entrypoints = [];
+
+    if (/if\s+__name__\s*==\s*['"]__main__['"]\s*:/m.test(content)) {
+      entrypoints.push(fileInfo.relativePath);
+    }
+
+    if (fileInfo.relativePath.endsWith('__init__.py')) {
+      entrypoints.push(fileInfo.relativePath);
+    }
+
+    const classRegex = /^\s*class\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?:\(|:)/gm;
+    const fnRegex = /^\s*def\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/gm;
+    let match;
+
+    while ((match = classRegex.exec(content)) !== null) symbols.push({ name: match[1], kind: 'class' });
+    while ((match = fnRegex.exec(content)) !== null) symbols.push({ name: match[1], kind: 'function' });
+
+    return {
+      entrypoints: [...new Set(entrypoints)],
+      symbols
+    };
+  }
+
+  getPackagePrefix(relativePath) {
+    const clean = relativePath.replace(/\\/g, '/');
+    const parts = clean.split('/');
+    parts.pop();
+    return parts.join('.');
+  }
+
+  normalizeDependency(dep, packagePrefix) {
+    if (!dep) return null;
+    if (dep.startsWith('.')) {
+      const trimmed = dep.replace(/^\.+/, '');
+      const base = packagePrefix ? `${packagePrefix}.${trimmed}` : trimmed;
+      return base.replace(/\.+/g, '.').replace(/^\./, '').replace(/\.$/, '');
+    }
+    return dep;
+  }
+}
+

package/src/graph/graphEngine.js

@@ -0,0 +1,151 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { createGraph, createNode, createEdge } from './graphSchema.js';
+import UniversalExtractor from './universalExtractor.js';
+import GraphMetrics from './graphMetrics.js';
+import JavaScriptAdapter from './adapters/javascriptAdapter.js';
+import PythonAdapter from './adapters/pythonAdapter.js';
+
+export default class GraphEngine {
+  constructor() {
+    this.universalExtractor = new UniversalExtractor();
+    this.metrics = new GraphMetrics();
+    this.adapters = [
+      new PythonAdapter(),
+      new JavaScriptAdapter()
+    ];
+  }
+
+  async analyze(allFiles, fileContentsByPath = null) {
+    const graph = createGraph();
+    const fileMap = new Map();
+    const fileMapNoExt = new Map();
+    const packageMap = new Map();
+    const localContents = fileContentsByPath || new Map();
+
+    for (const file of allFiles) {
+      const rel = file.relativePath;
+      const ext = path.extname(rel).toLowerCase();
+      const noExt = rel.slice(0, Math.max(0, rel.length - ext.length));
+      const pkg = noExt.replace(/\//g, '.');
+      fileMap.set(rel, file);
+      fileMapNoExt.set(noExt, rel);
+      packageMap.set(pkg, rel);
+      graph.nodes.push(createNode(rel, this.languageFromExtension(ext)));
+    }
+
+    const entrypoints = new Set();
+    const symbolsByFile = new Map();
+    const adapterModes = {};
+
+    for (const file of allFiles) {
+      const rel = file.relativePath;
+      const ext = path.extname(rel).toLowerCase();
+      const fileInfo = { ...file, ext };
+      const adapter = this.getAdapter(fileInfo);
+
+      if (!localContents.has(rel)) {
+        try {
+          localContents.set(rel, await fs.readFile(file.absolutePath, 'utf8'));
+        } catch {
+          continue;
+        }
+      }
+
+      const content = localContents.get(rel);
+      const deps = adapter
+        ? adapter.extractDependencies(content, fileInfo)
+        : this.universalExtractor.extractDependencies(content, fileInfo);
+      const resolvedDeps = deps
+        .map(dep => this.resolveDependency(dep, rel, fileMap, fileMapNoExt, packageMap))
+        .filter(Boolean);
+
+      for (const dep of [...new Set(resolvedDeps)]) {
+        graph.edges.push(createEdge(rel, dep, 'imports'));
+      }
+
+      const symbols = adapter
+        ? adapter.extractSymbols(content, fileInfo)
+        : { entrypoints: [], symbols: [] };
+      for (const ep of (symbols.entrypoints || [])) entrypoints.add(ep);
+      symbolsByFile.set(rel, symbols.symbols || []);
+
+      if (adapter) {
+        adapterModes[ext] = adapter.mode();
+      } else if (!adapterModes[ext]) {
+        adapterModes[ext] = 'generic';
+      }
+    }
+
+    graph.metadata.adapterModes = adapterModes;
+
+    const metrics = this.metrics.compute(graph);
+    const connectedSubmodules = this.metrics.connectedSubmodules(graph);
+
+    return {
+      graph,
+      metrics,
+      connectedSubmodules,
+      entrypoints: [...entrypoints],
+      symbolsByFile,
+      fileContentsByPath: localContents
+    };
+  }
+
+  getAdapter(fileInfo) {
+    return this.adapters.find(adapter => adapter.supports(fileInfo)) || null;
+  }
+
+  resolveDependency(specifier, sourcePath, fileMap, fileMapNoExt, packageMap) {
+    if (!specifier || typeof specifier !== 'string') return null;
+    const sourceDir = path.posix.dirname(sourcePath);
+    const spec = specifier.replace(/\\/g, '/');
+    const candidates = [];
+
+    if (spec.startsWith('./') || spec.startsWith('../')) {
+      const resolved = path.posix.normalize(path.posix.join(sourceDir, spec));
+      candidates.push(resolved);
+      candidates.push(`${resolved}.js`, `${resolved}.ts`, `${resolved}.jsx`, `${resolved}.tsx`, `${resolved}.py`);
+      candidates.push(path.posix.join(resolved, 'index.js'));
+      candidates.push(path.posix.join(resolved, 'index.ts'));
+      candidates.push(path.posix.join(resolved, '__init__.py'));
+    } else if (spec.startsWith('/')) {
+      candidates.push(spec.slice(1));
+    } else {
+      const dotted = spec.replace(/\//g, '.');
+      if (packageMap.has(dotted)) {
+        return packageMap.get(dotted);
+      }
+      candidates.push(spec);
+      candidates.push(`src/${spec}`);
+      candidates.push(`src/${spec}.js`, `src/${spec}.ts`, `src/${spec}.py`);
+      candidates.push(`${spec}.js`, `${spec}.ts`, `${spec}.py`);
+    }
+
+    for (const candidate of candidates) {
+      if (fileMap.has(candidate)) return candidate;
+      if (fileMapNoExt.has(candidate)) return fileMapNoExt.get(candidate);
+    }
+
+    return null;
+  }
+
+  languageFromExtension(ext) {
+    const map = {
+      '.js': 'JavaScript', '.jsx': 'JavaScript', '.mjs': 'JavaScript', '.cjs': 'JavaScript',
+      '.ts': 'TypeScript', '.tsx': 'TypeScript',
+      '.py': 'Python',
+      '.java': 'Java',
+      '.cs': 'C#',
+      '.cpp': 'C++', '.c': 'C', '.h': 'C/C++',
+      '.php': 'PHP',
+      '.rb': 'Ruby',
+      '.go': 'Go',
+      '.rs': 'Rust',
+      '.sh': 'Shell',
+      '.bat': 'Batch'
+    };
+    return map[ext] || 'Unknown';
+  }
+}
+

package/src/graph/graphMetrics.js

@@ -0,0 +1,79 @@
+/**
+ * Basic graph metrics for repository navigation.
+ */
+export default class GraphMetrics {
+  compute(graph) {
+    const inDegree = new Map();
+    const outDegree = new Map();
+
+    for (const node of graph.nodes) {
+      inDegree.set(node.id, 0);
+      outDegree.set(node.id, 0);
+    }
+
+    for (const edge of graph.edges) {
+      outDegree.set(edge.from, (outDegree.get(edge.from) || 0) + 1);
+      inDegree.set(edge.to, (inDegree.get(edge.to) || 0) + 1);
+    }
+
+    const hubs = [...outDegree.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 8)
+      .map(([id, degree]) => ({ id, degree }));
+
+    const centralNodes = [...inDegree.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 8)
+      .map(([id, degree]) => ({ id, degree }));
+
+    const isolated = graph.nodes
+      .filter(node => (inDegree.get(node.id) || 0) === 0 && (outDegree.get(node.id) || 0) === 0)
+      .map(node => node.id);
+
+    return {
+      inDegree,
+      outDegree,
+      hubs,
+      centralNodes,
+      isolated
+    };
+  }
+
+  connectedSubmodules(graph) {
+    const adjacency = new Map();
+    for (const node of graph.nodes) adjacency.set(node.id, new Set());
+    for (const edge of graph.edges) {
+      adjacency.get(edge.from)?.add(edge.to);
+      adjacency.get(edge.to)?.add(edge.from);
+    }
+
+    const visited = new Set();
+    const components = [];
+
+    for (const node of graph.nodes) {
+      if (visited.has(node.id)) continue;
+
+      const stack = [node.id];
+      const component = [];
+      visited.add(node.id);
+
+      while (stack.length > 0) {
+        const current = stack.pop();
+        component.push(current);
+        for (const next of (adjacency.get(current) || [])) {
+          if (!visited.has(next)) {
+            visited.add(next);
+            stack.push(next);
+          }
+        }
+      }
+
+      components.push(component.sort((a, b) => a.localeCompare(b)));
+    }
+
+    return components
+      .sort((a, b) => b.length - a.length)
+      .slice(0, 8);
+  }
+}
+

package/src/graph/graphSchema.js

@@ -0,0 +1,30 @@
+/**
+ * Lightweight schema helpers for dependency graph structures.
+ */
+export function createGraph() {
+  return {
+    nodes: [],
+    edges: [],
+    metadata: {
+      adapterModes: {},
+      generatedAt: new Date().toISOString()
+    }
+  };
+}
+
+export function createNode(path, language = 'Unknown') {
+  return {
+    id: path,
+    path,
+    language
+  };
+}
+
+export function createEdge(from, to, type = 'imports') {
+  return {
+    from,
+    to,
+    type
+  };
+}
+

package/src/graph/universalExtractor.js

@@ -0,0 +1,29 @@
+/**
+ * Generic dependency extraction fallback for unsupported languages.
+ */
+export default class UniversalExtractor {
+  extractDependencies(content, fileInfo) {
+    const ext = fileInfo.ext;
+    const deps = [];
+    let match;
+
+    if (['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'].includes(ext)) {
+      const importRegex = /import\s+.*?from\s+['"]([^'"]+)['"]/g;
+      const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+      while ((match = importRegex.exec(content)) !== null) deps.push(match[1]);
+      while ((match = requireRegex.exec(content)) !== null) deps.push(match[1]);
+    } else if (ext === '.py') {
+      const pyRegex = /(?:from\s+([A-Za-z0-9_\.]+)\s+import|import\s+([A-Za-z0-9_\.]+))/g;
+      while ((match = pyRegex.exec(content)) !== null) deps.push(match[1] || match[2]);
+    } else if (['.c', '.cpp', '.h', '.hpp', '.cc'].includes(ext)) {
+      const includeRegex = /#include\s*[<"]([^>"]+)[>"]/g;
+      while ((match = includeRegex.exec(content)) !== null) deps.push(match[1]);
+    } else if (['.php'].includes(ext)) {
+      const useRegex = /^\s*use\s+([A-Za-z0-9_\\]+)\s*;/gm;
+      while ((match = useRegex.exec(content)) !== null) deps.push(match[1]);
+    }
+
+    return [...new Set(deps.filter(Boolean))];
+  }
+}
+