legacyver 2.1.0 → 2.1.2

package/src/renderer/markdown.js

@@ -1,149 +1,115 @@
-/**
- * Markdown renderer.
- * Takes DocFragment[] and PKG.
- * Mirrors source directory structure in output dir.
- * Writes one .md per file.
- * Generates index.md with project metadata + Mermaid dependency diagram + module index.
- * Generates SUMMARY.md in GitBook format.
- */
+'use strict';
 
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join, dirname, relative } from 'node:path';
+const { writeFileSync, mkdirSync, existsSync } = require('fs');
+const path = require('path');
 
 /**
- * Render documentation as Markdown files.
- * @param {import('../llm/queue.js').DocFragment[]} fragments
- * @param {import('../parser/pkg-builder.js').ProjectKnowledgeGraph} pkg
- * @param {string} outputDir - Output directory path
+ * Markdown renderer — produces one .md per source file + index.md + SUMMARY.md.
  */
-export async function renderMarkdown(fragments, pkg, outputDir) {
+async function render(fragments, pkg, outputDir, config) {
   mkdirSync(outputDir, { recursive: true });
 
-  // Write individual file docs
-  for (const fragment of fragments) {
-    const mdPath = join(outputDir, fragment.relativePath.replace(/\.\w+$/, '.md'));
-    mkdirSync(dirname(mdPath), { recursive: true });
-    writeFileSync(mdPath, fragment.content, 'utf-8');
+  const summaryLines = ['# Summary\n'];
+
+  for (const frag of fragments) {
+    const relOut = frag.relativePath.replace(/\.[^.]+$/, '.md');
+    const outPath = path.join(outputDir, relOut);
+    mkdirSync(path.dirname(outPath), { recursive: true });
+    writeFileSync(outPath, frag.content, 'utf8');
+    summaryLines.push(`* [${frag.relativePath}](${relOut})`);
   }
 
-  // Generate index.md
-  const indexContent = generateIndex(pkg, fragments);
-  writeFileSync(join(outputDir, 'index.md'), indexContent, 'utf-8');
+  // SUMMARY.md (GitBook / Docusaurus compatible)
+  writeFileSync(path.join(outputDir, 'SUMMARY.md'), summaryLines.join('\n'), 'utf8');
 
-  // Generate SUMMARY.md
-  const summaryContent = generateSummary(fragments);
-  writeFileSync(join(outputDir, 'SUMMARY.md'), summaryContent, 'utf-8');
+  // index.md
+  writeFileSync(path.join(outputDir, 'index.md'), buildIndexMd(pkg, fragments), 'utf8');
 }
 
-function generateIndex(pkg, fragments) {
+function buildIndexMd(pkg, fragments) {
+  const meta = pkg.meta || {};
   const lines = [];
-
-  lines.push(`# ${pkg.meta.name}`);
+  lines.push(`# ${meta.name || 'Project'} — Documentation`);
   lines.push('');
-  lines.push(`> Auto-generated documentation by Legacyver`);
+  lines.push(`**Primary language:** ${meta.primaryLanguage || 'unknown'}  `);
+  lines.push(`**Total files:** ${meta.totalFiles || fragments.length}  `);
+  lines.push(`**Analyzed at:** ${meta.analyzedAt || new Date().toISOString()}  `);
+  if (meta.framework) lines.push(`**Framework:** ${meta.framework}  `);
   lines.push('');
-  lines.push('## Project Overview');
+
+  // File tree
+  lines.push('## Files');
   lines.push('');
-  lines.push(`| Property | Value |`);
-  lines.push(`|---|---|`);
-  lines.push(`| Primary Language | ${pkg.meta.primaryLanguage} |`);
-  lines.push(`| Total Files | ${pkg.meta.totalFiles} |`);
-  lines.push(`| Analyzed At | ${pkg.meta.analyzedAt} |`);
+  for (const frag of fragments) {
+    const relOut = frag.relativePath.replace(/\.[^.]+$/, '.md');
+    lines.push(`- [${frag.relativePath}](${relOut})`);
+  }
   lines.push('');
 
-  // Entry points
-  if (pkg.entryPoints.length > 0) {
-    lines.push('## Entry Points');
-    lines.push('');
-    for (const ep of pkg.entryPoints) {
-      const mdLink = ep.replace(/\.\w+$/, '.md');
-      lines.push(`- [${ep}](${mdLink})`);
+  // Mermaid dependency graph
+  lines.push('## Dependency Graph');
+  lines.push('');
+  lines.push('```mermaid');
+  lines.push('graph TD');
+  const graph = pkg.graph || {};
+  for (const [from, targets] of Object.entries(graph)) {
+    for (const to of targets) {
+      const fromId = sanitizeMermaid(from);
+      const toId = sanitizeMermaid(to);
+      lines.push(`  ${fromId}["${from}"] --> ${toId}["${to}"]`);
     }
-    lines.push('');
   }
+  lines.push('```');
+  lines.push('');
 
-  // Dependency diagram (Mermaid)
-  if (Object.keys(pkg.graph).length > 0) {
-    lines.push('## Dependency Graph');
-    lines.push('');
-    lines.push('```mermaid');
-    lines.push('graph TD');
-
-    const nodeIds = new Map();
-    let nodeCounter = 0;
-
-    function getNodeId(path) {
-      if (!nodeIds.has(path)) {
-        nodeIds.set(path, `N${nodeCounter++}`);
+  // Laravel-specific sections
+  if (pkg.laravelMeta) {
+    const lm = pkg.laravelMeta;
+
+    if (lm.routeMap && lm.routeMap.length > 0) {
+      lines.push('## Route Map');
+      lines.push('');
+      lines.push('| Method | URI | Controller | Middleware | Route Name |');
+      lines.push('|--------|-----|------------|------------|------------|');
+      for (const r of lm.routeMap) {
+        lines.push(`| ${r.method || ''} | ${r.uri || ''} | ${r.controller || ''}${r.action ? '@' + r.action : ''} | ${r.middleware || ''} | ${r.name || ''} |`);
       }
-      return nodeIds.get(path);
+      lines.push('');
     }
 
-    for (const [source, targets] of Object.entries(pkg.graph)) {
-      const sourceId = getNodeId(source);
-      for (const target of targets) {
-        const targetId = getNodeId(target);
-        lines.push(`  ${sourceId}["${source}"] --> ${targetId}["${target}"]`);
+    if (lm.relationships && lm.relationships.length > 0) {
+      lines.push('## Model Relationships');
+      lines.push('');
+      lines.push('```mermaid');
+      lines.push('erDiagram');
+      for (const rel of lm.relationships) {
+        const from = rel.fromModel || 'Model';
+        const to = rel.relatedModel || 'Related';
+        const label = rel.type || 'relates';
+        lines.push(`  ${from} ||--o{ ${to} : "${label}"`);
       }
+      lines.push('```');
+      lines.push('');
     }
 
-    lines.push('```');
-    lines.push('');
-  }
-
-  // Module index
-  lines.push('## Module Index');
-  lines.push('');
-  lines.push('| File | Language | Lines | Functions | Classes |');
-  lines.push('|---|---|---|---|---|');
-
-  const sortedPaths = Object.keys(pkg.files).sort();
-  for (const filePath of sortedPaths) {
-    const facts = pkg.files[filePath];
-    const mdLink = filePath.replace(/\.\w+$/, '.md');
-    lines.push(
-      `| [${filePath}](${mdLink}) | ${facts.language} | ${facts.linesOfCode} | ${facts.functions.length} | ${facts.classes.length} |`
-    );
+    if (lm.providerBindings && lm.providerBindings.length > 0) {
+      lines.push('## Service Provider Bindings');
+      lines.push('');
+      for (const pb of lm.providerBindings) {
+        lines.push(`### ${pb.provider}`);
+        for (const b of pb.bindings) {
+          lines.push(`- \`${b}\``);
+        }
+      }
+      lines.push('');
+    }
   }
 
-  lines.push('');
-  lines.push('---');
-  lines.push('*Generated by [Legacyver](https://github.com/legacyver/legacyver)*');
-  lines.push('');
-
   return lines.join('\n');
 }
 
-function generateSummary(fragments) {
-  const lines = [];
-
-  lines.push('# Summary');
-  lines.push('');
-  lines.push('* [Index](index.md)');
-
-  // Group by directory
-  const dirs = new Map();
-  for (const fragment of fragments) {
-    const dir = dirname(fragment.relativePath);
-    if (!dirs.has(dir)) {
-      dirs.set(dir, []);
-    }
-    dirs.get(dir).push(fragment);
-  }
-
-  const sortedDirs = [...dirs.keys()].sort();
-  for (const dir of sortedDirs) {
-    if (dir !== '.') {
-      lines.push(`* ${dir}`);
-    }
-    const files = dirs.get(dir).sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-    for (const f of files) {
-      const mdPath = f.relativePath.replace(/\.\w+$/, '.md');
-      const indent = dir !== '.' ? '  ' : '';
-      lines.push(`${indent}* [${f.relativePath}](${mdPath})`);
-    }
-  }
-
-  lines.push('');
-  return lines.join('\n');
+function sanitizeMermaid(str) {
+  return str.replace(/[^a-zA-Z0-9_]/g, '_').replace(/^_+/, '').slice(0, 40) || 'node';
 }
+
+module.exports = { render };

package/src/utils/config.js

@@ -1,65 +1,64 @@
-/**
- * Configuration loader using cosmiconfig.
- * Loads .legacyverrc / legacyver.config.js / legacyver.config.yaml
- * Merges with CLI flags (CLI wins).
- */
-
-import { cosmiconfig } from 'cosmiconfig';
+'use strict';
 
-const DEFAULTS = {
-  provider: 'anthropic',
-  model: null,
-  concurrency: 5,
-  maxFileSizeKb: 500,
-  output: './legacyver-docs',
-  format: 'markdown',
-  incremental: false,
-  noConfirm: false,
-  verbose: false,
-  languages: ['javascript', 'typescript', 'python', 'java', 'go'],
-  ignore: [],
-};
+const { cosmiconfigSync } = require('cosmiconfig');
 
-let cachedConfig = null;
+const explorer = cosmiconfigSync('legacyver', {
+  searchPlaces: [
+    '.legacyverrc',
+    '.legacyverrc.json',
+    '.legacyverrc.yaml',
+    '.legacyverrc.yml',
+    '.legacyverrc.js',
+    'legacyver.config.js',
+    'legacyver.config.yaml',
+    'legacyver.config.yml',
+  ],
+});
 
 /**
- * Load configuration from rc files.
- * @param {string} [searchFrom] - Directory to search from (defaults to cwd)
- * @returns {Promise<object>} Merged config
+ * Load configuration from file and merge with CLI flags.
+ * CLI flags always win over file config.
+ * @param {Object} cliFlags
+ * @returns {Object}
  */
-export async function loadConfig(searchFrom) {
-  if (cachedConfig) return cachedConfig;
+function loadConfig(cliFlags = {}) {
+  let fileConfig = {};
+  try {
+    const result = explorer.search();
+    if (result && result.config) {
+      fileConfig = { ...result.config }; // shallow copy — never mutate the cached object
+    }
+  } catch (e) {
+    // no config file found — use defaults
+  }
 
-  const explorer = cosmiconfig('legacyver');
-  const result = await explorer.search(searchFrom || process.cwd());
+  const defaults = {
+    provider: 'openrouter',
+    model: undefined,
+    format: 'markdown',
+    out: './legacyver-docs',
+    concurrency: 3,
+    maxFileSizeKb: 500,
+    dryRun: false,
+    incremental: false,
+    confirm: true,
+    verbose: false,
+  };
 
-  const fileConfig = result ? result.config : {};
-  cachedConfig = { ...DEFAULTS, ...fileConfig };
-  return cachedConfig;
-}
+  // Merge: defaults < fileConfig < cliFlags (strip undefined cliFlags)
+  const cleanCli = Object.fromEntries(
+    Object.entries(cliFlags).filter(([, v]) => v !== undefined)
+  );
 
-/**
- * Merge loaded config with CLI flags. CLI flags take precedence.
- * Only non-undefined CLI values override config.
- * @param {object} config - Loaded config
- * @param {object} cliFlags - CLI flag values
- * @returns {object} Merged config
- */
-export function mergeWithFlags(config, cliFlags) {
-  const merged = { ...config };
-  for (const [key, value] of Object.entries(cliFlags)) {
-    if (value !== undefined && value !== null) {
-      merged[key] = value;
-    }
+  // If CLI specifies a different provider than what's in the config file,
+  // discard the file's model — it belongs to the old provider.
+  const effectiveProvider = cleanCli.provider || fileConfig.provider || defaults.provider;
+  const fileConfigProvider = fileConfig.provider || defaults.provider;
+  if (effectiveProvider !== fileConfigProvider && !cleanCli.model) {
+    delete fileConfig.model;
   }
-  return merged;
-}
 
-/**
- * Reset cached config (for testing).
- */
-export function resetConfig() {
-  cachedConfig = null;
+  return { ...defaults, ...fileConfig, ...cleanCli };
 }
 
-export { DEFAULTS };
+module.exports = { loadConfig };

package/src/utils/errors.js

@@ -1,70 +1,55 @@
+'use strict';
+
 /**
  * Custom error classes for Legacyver.
  */
 
-export class LegacyverError extends Error {
-  constructor(message, options = {}) {
+class LegacyverError extends Error {
+  constructor(message, code) {
     super(message);
     this.name = 'LegacyverError';
-    this.exitCode = options.exitCode || 1;
-    this.suggestion = options.suggestion || null;
+    this.code = code || 'LEGACYVER_ERROR';
   }
 }
 
-export class NoApiKeyError extends LegacyverError {
+class NoApiKeyError extends LegacyverError {
   constructor(provider) {
-    const envVarMap = {
-      anthropic: 'ANTHROPIC_API_KEY',
-      openai: 'OPENAI_API_KEY',
-      google: 'GOOGLE_API_KEY',
-      groq: 'GROQ_API_KEY',
-      ollama: null,
-    };
-    const envVar = envVarMap[provider] || `${provider.toUpperCase()}_API_KEY`;
-    const suggestion = provider === 'ollama'
-      ? 'Ensure Ollama is running locally at http://localhost:11434'
-      : `Set the ${envVar} environment variable or run "legacyver init" to configure`;
-
-    super(`No API key found for provider "${provider}"`, {
-      exitCode: 1,
-      suggestion,
-    });
+    super(
+      `No API key found for provider "${provider}". ` +
+        `Set the OPENROUTER_API_KEY environment variable or run \`legacyver init\`. ` +
+        `Get a key at https://openrouter.ai/keys`,
+      'NO_API_KEY'
+    );
     this.name = 'NoApiKeyError';
     this.provider = provider;
-    this.envVar = envVar;
   }
 }
 
-export class RateLimitError extends LegacyverError {
-  constructor(provider, retryAfterMs = null) {
-    super(`Rate limit exceeded for provider "${provider}"`, {
-      exitCode: 2,
-      suggestion: 'Reduce concurrency with --concurrency flag or wait and retry',
-    });
+class RateLimitError extends LegacyverError {
+  constructor(provider, retryAfter) {
+    super(`Rate limit exceeded for provider "${provider}". Retrying...`, 'RATE_LIMIT');
     this.name = 'RateLimitError';
     this.provider = provider;
-    this.retryAfterMs = retryAfterMs;
+    this.retryAfter = retryAfter || 1000;
   }
 }
 
-export class ParseError extends LegacyverError {
-  constructor(filePath, reason) {
-    super(`Failed to parse "${filePath}": ${reason}`, {
-      exitCode: 0, // recoverable — don't exit
-      suggestion: 'File will be processed with the generic fallback parser',
-    });
+class ParseError extends LegacyverError {
+  constructor(filePath, originalError) {
+    super(`Failed to parse file "${filePath}": ${originalError && originalError.message || originalError}`, 'PARSE_ERROR');
     this.name = 'ParseError';
     this.filePath = filePath;
+    this.originalError = originalError;
   }
 }
 
-export class RenderError extends LegacyverError {
-  constructor(format, reason) {
-    super(`Render failed for format "${format}": ${reason}`, {
-      exitCode: 3,
-      suggestion: 'Check write permissions on the output directory',
-    });
+class RenderError extends LegacyverError {
+  constructor(format, originalError) {
+    super(`Renderer failed for format "${format}": ${originalError && originalError.message || originalError}`, 'RENDER_ERROR');
     this.name = 'RenderError';
     this.format = format;
+    this.originalError = originalError;
   }
 }
+
+module.exports = { LegacyverError, NoApiKeyError, RateLimitError, ParseError, RenderError };

package/src/utils/logger.js

@@ -1,67 +1,46 @@
-/**
- * Structured logger with log levels and TTY detection for CI mode.
- */
+'use strict';
 
-import picocolors from 'picocolors';
+const pc = require('picocolors');
 
-let verbose = false;
-const isTTY = process.stdout.isTTY === true;
+const LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
 
-export function setVerbose(value) {
-  verbose = value;
-}
+let currentLevel = 'info';
+let isCI = !process.stdout.isTTY;
 
-export function isVerbose() {
-  return verbose;
+function setLevel(level) {
+  if (LOG_LEVELS[level] !== undefined) currentLevel = level;
 }
 
-export function isCIMode() {
-  return !isTTY;
+function setCI(val) {
+  isCI = val;
 }
 
-function timestamp() {
-  return new Date().toISOString();
+function shouldLog(level) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[currentLevel];
 }
 
-export const logger = {
-  info(message, ...args) {
-    if (isTTY) {
-      console.log(picocolors.blue('ℹ'), message, ...args);
-    } else {
-      console.log(`[${timestamp()}] INFO: ${message}`, ...args);
-    }
-  },
+function debug(...args) {
+  if (shouldLog('debug')) {
+    console.debug(pc.gray('[debug]'), ...args);
+  }
+}
 
-  warn(message, ...args) {
-    if (isTTY) {
-      console.warn(picocolors.yellow('⚠'), message, ...args);
-    } else {
-      console.warn(`[${timestamp()}] WARN: ${message}`, ...args);
-    }
-  },
+function info(...args) {
+  if (shouldLog('info')) {
+    console.log(pc.cyan('[info]'), ...args);
+  }
+}
 
-  error(message, ...args) {
-    if (isTTY) {
-      console.error(picocolors.red('✖'), message, ...args);
-    } else {
-      console.error(`[${timestamp()}] ERROR: ${message}`, ...args);
-    }
-  },
+function warn(...args) {
+  if (shouldLog('warn')) {
+    console.warn(pc.yellow('[warn]'), ...args);
+  }
+}
 
-  debug(message, ...args) {
-    if (!verbose) return;
-    if (isTTY) {
-      console.log(picocolors.gray('●'), picocolors.gray(message), ...args);
-    } else {
-      console.log(`[${timestamp()}] DEBUG: ${message}`, ...args);
-    }
-  },
+function error(...args) {
+  if (shouldLog('error')) {
+    console.error(pc.red('[error]'), ...args);
+  }
+}
 
-  success(message, ...args) {
-    if (isTTY) {
-      console.log(picocolors.green('✔'), message, ...args);
-    } else {
-      console.log(`[${timestamp()}] OK: ${message}`, ...args);
-    }
-  },
-};
+module.exports = { debug, info, warn, error, setLevel, setCI };

package/src/cli/flags.js

@@ -1,87 +0,0 @@
-/**
- * Shared CLI flag definitions with types, defaults, and descriptions.
- */
-
-export const FLAG_DEFINITIONS = {
-  provider: {
-    flags: '-p, --provider <name>',
-    description: 'LLM provider to use (anthropic, openai, google, groq, ollama)',
-    default: 'anthropic',
-  },
-  model: {
-    flags: '-m, --model <name>',
-    description: 'Model name to use (overrides provider default)',
-    default: undefined,
-  },
-  output: {
-    flags: '-o, --output <dir>',
-    description: 'Output directory for generated documentation',
-    default: './legacyver-docs',
-  },
-  format: {
-    flags: '-f, --format <type>',
-    description: 'Output format: markdown, html, json',
-    default: 'markdown',
-  },
-  concurrency: {
-    flags: '-c, --concurrency <number>',
-    description: 'Number of concurrent LLM requests',
-    default: '5',
-    parseArg: (val) => parseInt(val, 10),
-  },
-  maxFileSize: {
-    flags: '--max-file-size <kb>',
-    description: 'Skip files larger than this size in KB',
-    default: '500',
-    parseArg: (val) => parseInt(val, 10),
-  },
-  incremental: {
-    flags: '--incremental',
-    description: 'Only analyze files changed since last run',
-    default: false,
-  },
-  noConfirm: {
-    flags: '--no-confirm',
-    description: 'Skip cost confirmation prompt (required for CI)',
-    default: false,
-  },
-  dryRun: {
-    flags: '--dry-run',
-    description: 'Show cost estimate without running analysis',
-    default: false,
-  },
-  ignore: {
-    flags: '--ignore <patterns...>',
-    description: 'Additional glob patterns to ignore',
-    default: [],
-  },
-  jsonSummary: {
-    flags: '--json-summary',
-    description: 'Output machine-readable JSON summary to stdout',
-    default: false,
-  },
-  verbose: {
-    flags: '--verbose',
-    description: 'Enable verbose debug output',
-    default: false,
-  },
-};
-
-/**
- * Apply standard flags to a commander command.
- * @param {import('commander').Command} command
- * @param {string[]} flagNames - Which flags to apply
- * @returns {import('commander').Command}
- */
-export function applyFlags(command, flagNames) {
-  for (const name of flagNames) {
-    const def = FLAG_DEFINITIONS[name];
-    if (!def) continue;
-    if (def.parseArg) {
-      command.option(def.flags, def.description, def.parseArg, def.default);
-    } else {
-      command.option(def.flags, def.description, def.default);
-    }
-  }
-  return command;
-}