@bfra.me/workspace-analyzer 0.1.0

package/lib/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/lib/cli.js

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+import {
+  BUILTIN_ANALYZER_IDS,
+  analyzeWorkspace,
+  createConsoleReporter,
+  createJsonReporter,
+  createMarkdownReporter
+} from "./chunk-WOJ4C7N7.js";
+import "./chunk-JDF7DQ4V.js";
+
+// src/cli/index.ts
+import process2 from "process";
+import { cac } from "cac";
+import { consola as consola2 } from "consola";
+
+// src/cli/commands/analyze.ts
+import path from "path";
+import process from "process";
+
+// src/cli/ui.ts
+import * as p from "@clack/prompts";
+import { consola } from "consola";
+function createLogger(options) {
+  const { verbose = false, quiet = false } = options;
+  return {
+    info(message) {
+      if (!quiet) {
+        p.log.info(message);
+      }
+    },
+    success(message) {
+      if (!quiet) {
+        p.log.success(message);
+      }
+    },
+    warn(message) {
+      p.log.warn(message);
+    },
+    error(message) {
+      p.log.error(message);
+    },
+    debug(message) {
+      if (verbose) {
+        consola.debug(message);
+      }
+    }
+  };
+}
+function showIntro(title) {
+  p.intro(title);
+}
+function showOutro(message) {
+  p.outro(message);
+}
+function createSpinner() {
+  return p.spinner();
+}
+function showCancel(message = "Operation cancelled.") {
+  p.cancel(message);
+}
+function handleCancel(value) {
+  return p.isCancel(value);
+}
+async function selectAnalyzers(availableAnalyzers) {
+  if (availableAnalyzers.length === 0) {
+    return [];
+  }
+  const options = availableAnalyzers.map((analyzer) => ({
+    value: analyzer.value,
+    label: analyzer.label,
+    hint: analyzer.hint
+  }));
+  const selected = await p.multiselect({
+    message: "Select analyzers to run",
+    options,
+    required: false,
+    initialValues: options.map((o) => o.value)
+  });
+  return selected;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.round(ms % 6e4 / 1e3);
+  return `${minutes}m ${seconds}s`;
+}
+function formatIssueCount(count, severity) {
+  const severityIndicators = {
+    info: "\u2139\uFE0F",
+    warning: "\u26A0\uFE0F",
+    error: "\u274C",
+    critical: "\u{1F6A8}"
+  };
+  return `${severityIndicators[severity]} ${count} ${severity}${count === 1 ? "" : "s"}`;
+}
+function formatSeveritySummary(bySeverity) {
+  const parts = [];
+  const critical = bySeverity.critical ?? 0;
+  const error = bySeverity.error ?? 0;
+  const warning = bySeverity.warning ?? 0;
+  const info = bySeverity.info ?? 0;
+  if (critical > 0) {
+    parts.push(formatIssueCount(critical, "critical"));
+  }
+  if (error > 0) {
+    parts.push(formatIssueCount(error, "error"));
+  }
+  if (warning > 0) {
+    parts.push(formatIssueCount(warning, "warning"));
+  }
+  if (info > 0) {
+    parts.push(formatIssueCount(info, "info"));
+  }
+  return parts.length > 0 ? parts.join(", ") : "\u2705 No issues";
+}
+
+// src/cli/commands/analyze.ts
+var ANALYZER_METADATA = {
+  [BUILTIN_ANALYZER_IDS.PACKAGE_JSON]: {
+    label: "Package.json Analyzer",
+    hint: "Validates package.json structure and required fields"
+  },
+  [BUILTIN_ANALYZER_IDS.TSCONFIG]: {
+    label: "TSConfig Analyzer",
+    hint: "Checks TypeScript configuration consistency"
+  },
+  [BUILTIN_ANALYZER_IDS.ESLINT_CONFIG]: {
+    label: "ESLint Config Analyzer",
+    hint: "Validates ESLint configuration patterns"
+  },
+  [BUILTIN_ANALYZER_IDS.BUILD_CONFIG]: {
+    label: "Build Config Analyzer",
+    hint: "Analyzes tsup and build configuration"
+  },
+  [BUILTIN_ANALYZER_IDS.CONFIG_CONSISTENCY]: {
+    label: "Config Consistency",
+    hint: "Cross-validates multiple configuration files"
+  },
+  [BUILTIN_ANALYZER_IDS.VERSION_ALIGNMENT]: {
+    label: "Version Alignment",
+    hint: "Checks dependency version consistency"
+  },
+  [BUILTIN_ANALYZER_IDS.EXPORTS_FIELD]: {
+    label: "Exports Field Analyzer",
+    hint: "Validates package.json exports against source files"
+  },
+  [BUILTIN_ANALYZER_IDS.UNUSED_DEPENDENCY]: {
+    label: "Unused Dependencies",
+    hint: "Detects dependencies not used in source code"
+  },
+  [BUILTIN_ANALYZER_IDS.CIRCULAR_IMPORT]: {
+    label: "Circular Imports",
+    hint: "Finds circular import dependencies"
+  },
+  [BUILTIN_ANALYZER_IDS.PEER_DEPENDENCY]: {
+    label: "Peer Dependencies",
+    hint: "Validates peer dependency requirements"
+  },
+  [BUILTIN_ANALYZER_IDS.DUPLICATE_DEPENDENCY]: {
+    label: "Duplicate Dependencies",
+    hint: "Finds duplicate packages across workspace"
+  },
+  [BUILTIN_ANALYZER_IDS.ARCHITECTURAL]: {
+    label: "Architecture",
+    hint: "Validates architectural patterns and layers"
+  },
+  [BUILTIN_ANALYZER_IDS.DEAD_CODE]: {
+    label: "Dead Code",
+    hint: "Detects unreachable or unused exports"
+  },
+  [BUILTIN_ANALYZER_IDS.DUPLICATE_CODE]: {
+    label: "Duplicate Code",
+    hint: "Finds similar code patterns via AST fingerprinting"
+  },
+  [BUILTIN_ANALYZER_IDS.LARGE_DEPENDENCY]: {
+    label: "Large Dependencies",
+    hint: "Identifies oversized dependencies"
+  },
+  [BUILTIN_ANALYZER_IDS.TREE_SHAKING_BLOCKER]: {
+    label: "Tree Shaking Blockers",
+    hint: "Finds patterns that prevent tree shaking"
+  }
+};
+function getAnalyzerOptions() {
+  return Object.entries(BUILTIN_ANALYZER_IDS).map(([_key, id]) => {
+    const metadata = ANALYZER_METADATA[id] ?? {
+      label: id,
+      hint: "Analyzer"
+    };
+    return {
+      value: id,
+      label: metadata.label,
+      hint: metadata.hint
+    };
+  });
+}
+function reportResults(result, options) {
+  if (options.json === true) {
+    const jsonReporter = createJsonReporter();
+    const report = jsonReporter.generate(result);
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  if (options.markdown === true) {
+    const mdReporter = createMarkdownReporter();
+    const report = mdReporter.generate(result);
+    console.log(report);
+    return;
+  }
+  const consoleReporter = createConsoleReporter({ verbose: options.verbose });
+  consoleReporter.generate(result);
+}
+async function runAnalyze(inputPath, options) {
+  const logger = createLogger(options);
+  const rootDir = path.resolve(options.root ?? inputPath);
+  if (options.quiet !== true) {
+    showIntro("\u{1F50D} Workspace Analyzer");
+  }
+  let selectedAnalyzers;
+  if (options.interactive === true) {
+    const availableAnalyzers = getAnalyzerOptions();
+    const selection = await selectAnalyzers(availableAnalyzers);
+    if (handleCancel(selection)) {
+      showCancel();
+      process.exit(0);
+    }
+    selectedAnalyzers = selection;
+    logger.debug(`Selected ${selectedAnalyzers.length} analyzers: ${selectedAnalyzers.join(", ")}`);
+  }
+  if (options.dryRun === true) {
+    logger.info(`[DRY RUN] Would analyze workspace at: ${rootDir}`);
+    if (selectedAnalyzers != null && selectedAnalyzers.length > 0) {
+      logger.info(`[DRY RUN] Using analyzers: ${selectedAnalyzers.join(", ")}`);
+    } else {
+      logger.info("[DRY RUN] Using all analyzers");
+    }
+    if (options.config != null) {
+      logger.info(`[DRY RUN] Using config: ${options.config}`);
+    }
+    if (options.quiet !== true) {
+      showOutro("Dry run complete - no analysis performed");
+    }
+    return;
+  }
+  if (options.fix === true) {
+    logger.warn("Auto-fix mode is not yet implemented. Running analysis only.");
+  }
+  const spinner2 = options.quiet === true ? void 0 : createSpinner();
+  spinner2?.start("Analyzing workspace...");
+  const startTime = Date.now();
+  const result = await analyzeWorkspace(rootDir, {
+    configPath: options.config,
+    verbose: options.verbose,
+    minSeverity: options.minSeverity,
+    analyzers: selectedAnalyzers != null && selectedAnalyzers.length > 0 ? Object.fromEntries(
+      Object.values(BUILTIN_ANALYZER_IDS).map((id) => [
+        id,
+        { enabled: selectedAnalyzers.includes(id) }
+      ])
+    ) : void 0,
+    onProgress: (progress) => {
+      const totalSuffix = progress.total == null ? "" : `/${progress.total}`;
+      const currentItem = progress.current ?? "";
+      const message = `${progress.phase}: ${currentItem} (${progress.processed}${totalSuffix})`;
+      spinner2?.message(message);
+      logger.debug(message);
+    }
+  });
+  const duration = Date.now() - startTime;
+  spinner2?.stop(`Analysis complete in ${formatDuration(duration)}`);
+  if (result.success) {
+    const analysisResult = result.data;
+    reportResults(analysisResult, options);
+    if (options.quiet !== true) {
+      const summary = formatSeveritySummary(analysisResult.summary.bySeverity);
+      showOutro(`${summary} (${analysisResult.summary.totalIssues} total issues)`);
+    }
+    const hasErrors = (analysisResult.summary.bySeverity.error ?? 0) > 0 || (analysisResult.summary.bySeverity.critical ?? 0) > 0;
+    if (hasErrors) {
+      process.exit(1);
+    }
+  } else {
+    logger.error(`Analysis failed: ${result.error.message}`);
+    if (options.verbose === true && result.error.cause != null) {
+      logger.debug(`Cause: ${String(result.error.cause)}`);
+    }
+    process.exit(1);
+  }
+}
+
+// src/cli/index.ts
+var cli = cac("workspace-analyzer");
+function registerAnalyzeCommand(command) {
+  return command.option("-c, --config <path>", "Path to workspace-analyzer.config.ts file").option("-r, --root <dir>", "Root directory of the workspace", { default: process2.cwd() }).option("--json", "Output results as JSON").option("--markdown", "Output results as Markdown").option("-i, --interactive", "Use interactive analyzer selection").option("--fix", "Attempt to auto-fix issues (placeholder for future)").option("-d, --dry-run", "Preview what would be analyzed without running").option("-v, --verbose", "Enable verbose logging").option("-q, --quiet", "Suppress non-essential output").option(
+    "--min-severity <level>",
+    "Minimum severity level to report (info, warning, error, critical)"
+  ).action(async (inputPath = ".", options) => {
+    const workspacePath = String(inputPath);
+    if (options.verbose === true) {
+      consola2.level = 4;
+    }
+    await runAnalyze(workspacePath, options);
+  });
+}
+registerAnalyzeCommand(cli.command("[path]", "Analyze a workspace for issues"));
+registerAnalyzeCommand(cli.command("analyze [path]", "Analyze a workspace for issues"));
+cli.command("version", "Show version information").action(() => {
+  consola2.info("@bfra.me/workspace-analyzer v0.0.0");
+});
+cli.help();
+cli.version("0.0.0");
+cli.parse();
+//# sourceMappingURL=cli.js.map