@snapback/cli 1.1.14 → 1.1.15

package/dist/{chunk-OJNDAPC2.js → chunk-5SQA44V7.js}

@@ -1,10 +1,900 @@
-#!/usr/bin/env node
-import { __name } from './chunk-BW7RALUZ.js';
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+import { __name } from './chunk-7ADPL4Q3.js';
+import { parseSync } from 'oxc-parser';
+import { dirname, resolve, relative, basename } from 'path';
 import * as eslintParser from '@typescript-eslint/parser';
 import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
-import { dirname, relative, basename } from 'path';
 
+process.env.SNAPBACK_CLI='true';
+var TS_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts"
+]);
+var JSX_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".tsx",
+  ".jsx"
+]);
+var ALL_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mts",
+  ".cts",
+  ".mjs",
+  ".cjs"
+]);
+function isSupportedFile(filePath) {
+  const ext = getExtension(filePath);
+  return ALL_EXTENSIONS.has(ext);
+}
+__name(isSupportedFile, "isSupportedFile");
+function parseSource(content, filePath) {
+  const ext = getExtension(filePath);
+  try {
+    const lang = JSX_EXTENSIONS.has(ext) ? TS_EXTENSIONS.has(ext) ? "tsx" : "jsx" : TS_EXTENSIONS.has(ext) ? "ts" : "js";
+    const result = parseSync(filePath, content, {
+      sourceType: "module",
+      lang
+    });
+    const errors = Array.isArray(result.errors) ? result.errors.map((e) => normalizeError(e)) : [];
+    return {
+      program: result.program,
+      errors,
+      success: errors.length === 0
+    };
+  } catch (error) {
+    return {
+      program: {
+        type: "Program",
+        body: [],
+        sourceType: "module"
+      },
+      errors: [
+        {
+          message: error instanceof Error ? error.message : String(error),
+          severity: "error"
+        }
+      ],
+      success: false
+    };
+  }
+}
+__name(parseSource, "parseSource");
+function walkAST(node, visitor, parent) {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  const n = node;
+  if (typeof n.type === "string") {
+    visitor(n, parent);
+  }
+  for (const key of Object.keys(n)) {
+    if (key === "type" || key === "start" || key === "end" || key === "loc") {
+      continue;
+    }
+    const value = n[key];
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item && typeof item === "object" && typeof item.type === "string") {
+          walkAST(item, visitor, n);
+        }
+      }
+    } else if (value && typeof value === "object" && typeof value.type === "string") {
+      walkAST(value, visitor, n);
+    }
+  }
+}
+__name(walkAST, "walkAST");
+function countASTNodes(program) {
+  let count = 0;
+  walkAST(program, () => {
+    count++;
+  });
+  return count;
+}
+__name(countASTNodes, "countASTNodes");
+function offsetToLine(source, offset) {
+  if (offset < 0 || offset > source.length) {
+    return 1;
+  }
+  let line = 1;
+  for (let i = 0; i < offset; i++) {
+    if (source[i] === "\n") {
+      line++;
+    }
+  }
+  return line;
+}
+__name(offsetToLine, "offsetToLine");
+function getExtension(filePath) {
+  const lastDot = filePath.lastIndexOf(".");
+  return lastDot >= 0 ? filePath.substring(lastDot).toLowerCase() : "";
+}
+__name(getExtension, "getExtension");
+function normalizeError(e) {
+  if (typeof e === "object" && e !== null) {
+    const err = e;
+    return {
+      message: String(err.message ?? err),
+      severity: String(err.severity ?? "error"),
+      labels: Array.isArray(err.labels) ? err.labels : void 0
+    };
+  }
+  return {
+    message: String(e),
+    severity: "error"
+  };
+}
+__name(normalizeError, "normalizeError");
+
+// ../../packages/core/dist/analysis/ast/ComplexityAnalyzer.js
+var THRESHOLDS = {
+  /** Cyclomatic complexity per function */
+  maxCyclomaticPerFunction: 15,
+  /** Maximum nesting depth per function */
+  maxNestingDepth: 5,
+  /** Maximum parameters per function */
+  maxParameters: 5,
+  /** Maximum functions per file */
+  maxFunctionsPerFile: 30,
+  /** File-level aggregate cyclomatic complexity */
+  maxCyclomaticPerFile: 50
+};
+var BRANCH_NODES = /* @__PURE__ */ new Set([
+  "IfStatement",
+  "ConditionalExpression",
+  "SwitchCase",
+  "ForStatement",
+  "ForInStatement",
+  "ForOfStatement",
+  "WhileStatement",
+  "DoWhileStatement",
+  "CatchClause"
+]);
+var LOGICAL_OPERATORS = /* @__PURE__ */ new Set([
+  "&&",
+  "||",
+  "??"
+]);
+var FUNCTION_NODES = /* @__PURE__ */ new Set([
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "ArrowFunctionExpression",
+  "MethodDefinition"
+]);
+var ComplexityAnalyzer = class {
+  static {
+    __name(this, "ComplexityAnalyzer");
+  }
+  id = "complexity";
+  name = "Complexity Analysis";
+  filePatterns = [
+    "*.ts",
+    "*.tsx",
+    "*.js",
+    "*.jsx"
+  ];
+  async analyze(context) {
+    const startTime = performance.now();
+    const issues = [];
+    let filesAnalyzed = 0;
+    let totalNodesVisited = 0;
+    const parseErrors = [];
+    for (const [file, content] of context.contents) {
+      if (!this.shouldAnalyzeFile(file)) {
+        continue;
+      }
+      filesAnalyzed++;
+      const fileComplexity = this.analyzeFile(content, file);
+      if (!fileComplexity) {
+        parseErrors.push(`${file}: Failed to parse`);
+        continue;
+      }
+      totalNodesVisited += fileComplexity.functions.length;
+      for (const fn of fileComplexity.functions) {
+        if (fn.cyclomatic > THRESHOLDS.maxCyclomaticPerFunction) {
+          issues.push({
+            id: `complexity/cyclomatic/${file}/${fn.line}`,
+            severity: fn.cyclomatic > THRESHOLDS.maxCyclomaticPerFunction * 2 ? "high" : "medium",
+            type: "HIGH_CYCLOMATIC_COMPLEXITY",
+            message: `Function "${fn.name}" has cyclomatic complexity ${fn.cyclomatic} (max: ${THRESHOLDS.maxCyclomaticPerFunction})`,
+            file,
+            line: fn.line,
+            fix: "Extract helper functions or simplify branching logic"
+          });
+        }
+        if (fn.maxNesting > THRESHOLDS.maxNestingDepth) {
+          issues.push({
+            id: `complexity/nesting/${file}/${fn.line}`,
+            severity: "medium",
+            type: "DEEP_NESTING",
+            message: `Function "${fn.name}" has nesting depth ${fn.maxNesting} (max: ${THRESHOLDS.maxNestingDepth})`,
+            file,
+            line: fn.line,
+            fix: "Use early returns or extract nested logic into helper functions"
+          });
+        }
+        if (fn.parameters > THRESHOLDS.maxParameters) {
+          issues.push({
+            id: `complexity/parameters/${file}/${fn.line}`,
+            severity: "low",
+            type: "TOO_MANY_PARAMETERS",
+            message: `Function "${fn.name}" has ${fn.parameters} parameters (max: ${THRESHOLDS.maxParameters})`,
+            file,
+            line: fn.line,
+            fix: "Use an options object pattern to reduce parameter count"
+          });
+        }
+      }
+      if (fileComplexity.functionCount > THRESHOLDS.maxFunctionsPerFile) {
+        issues.push({
+          id: `complexity/function-count/${file}`,
+          severity: "low",
+          type: "TOO_MANY_FUNCTIONS",
+          message: `${file} has ${fileComplexity.functionCount} functions (max: ${THRESHOLDS.maxFunctionsPerFile})`,
+          file,
+          fix: "Split into multiple focused modules"
+        });
+      }
+      if (fileComplexity.totalCyclomatic > THRESHOLDS.maxCyclomaticPerFile) {
+        issues.push({
+          id: `complexity/file-complexity/${file}`,
+          severity: "medium",
+          type: "HIGH_FILE_COMPLEXITY",
+          message: `${file} has total cyclomatic complexity ${fileComplexity.totalCyclomatic} (max: ${THRESHOLDS.maxCyclomaticPerFile})`,
+          file,
+          fix: "Consider splitting this file into smaller modules"
+        });
+      }
+    }
+    return {
+      analyzer: this.id,
+      success: true,
+      issues,
+      coverage: filesAnalyzed / Math.max(context.files.length, 1),
+      duration: performance.now() - startTime,
+      metadata: {
+        filesAnalyzed,
+        nodesVisited: totalNodesVisited,
+        patternsChecked: [
+          "HIGH_CYCLOMATIC_COMPLEXITY",
+          "DEEP_NESTING",
+          "TOO_MANY_PARAMETERS",
+          "TOO_MANY_FUNCTIONS",
+          "HIGH_FILE_COMPLEXITY"
+        ],
+        parseErrors
+      }
+    };
+  }
+  shouldRun(context) {
+    return context.files.some((f) => this.shouldAnalyzeFile(f));
+  }
+  /**
+   * Analyze a single file and return complexity metrics.
+   * Useful for external callers that just want metrics, not issues.
+   */
+  analyzeFile(content, filePath) {
+    if (!isSupportedFile(filePath)) {
+      return null;
+    }
+    const { program, success } = parseSource(content, filePath);
+    if (!success && program.body.length === 0) {
+      return null;
+    }
+    const functions = [];
+    let fileMaxNesting = 0;
+    walkAST(program, (node) => {
+      if (!FUNCTION_NODES.has(node.type)) {
+        return;
+      }
+      const fn = this.analyzeFunctionNode(node);
+      functions.push(fn);
+      if (fn.maxNesting > fileMaxNesting) {
+        fileMaxNesting = fn.maxNesting;
+      }
+    });
+    const totalCyclomatic = functions.reduce((sum, fn) => sum + fn.cyclomatic, 0);
+    return {
+      filePath,
+      functions,
+      totalCyclomatic,
+      maxNesting: fileMaxNesting,
+      functionCount: functions.length,
+      averageCyclomatic: functions.length > 0 ? totalCyclomatic / functions.length : 0
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Per-function analysis
+  // -----------------------------------------------------------------------
+  analyzeFunctionNode(node) {
+    const name = this.getFunctionName(node);
+    const line = node.start ?? 0;
+    const params = this.getParameterCount(node);
+    let cyclomatic = 1;
+    let maxNesting = 0;
+    const body = this.getFunctionBody(node);
+    if (body) {
+      this.walkForComplexity(body, (n, depth) => {
+        if (BRANCH_NODES.has(n.type)) {
+          cyclomatic++;
+        }
+        if (n.type === "LogicalExpression") {
+          const operator = n.operator;
+          if (LOGICAL_OPERATORS.has(operator)) {
+            cyclomatic++;
+          }
+        }
+        if (depth > maxNesting) {
+          maxNesting = depth;
+        }
+      });
+    }
+    return {
+      name,
+      line,
+      cyclomatic,
+      maxNesting,
+      parameters: params
+    };
+  }
+  /**
+   * Walk AST nodes counting nesting depth for complexity metrics
+   */
+  walkForComplexity(node, callback, depth = 0) {
+    if (!node || typeof node !== "object") {
+      return;
+    }
+    const n = node;
+    if (typeof n.type !== "string") {
+      return;
+    }
+    const nestingNodes = /* @__PURE__ */ new Set([
+      "IfStatement",
+      "ForStatement",
+      "ForInStatement",
+      "ForOfStatement",
+      "WhileStatement",
+      "DoWhileStatement",
+      "SwitchStatement",
+      "TryStatement"
+    ]);
+    const newDepth = nestingNodes.has(n.type) ? depth + 1 : depth;
+    callback(n, newDepth);
+    for (const key of Object.keys(n)) {
+      if (key === "type" || key === "start" || key === "end" || key === "loc") {
+        continue;
+      }
+      const value = n[key];
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          this.walkForComplexity(item, callback, newDepth);
+        }
+      } else if (value && typeof value === "object" && typeof value.type === "string") {
+        this.walkForComplexity(value, callback, newDepth);
+      }
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Helpers
+  // -----------------------------------------------------------------------
+  getFunctionName(node) {
+    if (node.id && typeof node.id === "object") {
+      const id = node.id;
+      if (typeof id.name === "string") {
+        return id.name;
+      }
+    }
+    if (node.key && typeof node.key === "object") {
+      const key = node.key;
+      if (typeof key.name === "string") {
+        return key.name;
+      }
+      if (typeof key.value === "string") {
+        return key.value;
+      }
+    }
+    return "<anonymous>";
+  }
+  getParameterCount(node) {
+    if (node.type === "MethodDefinition") {
+      const value = node.value;
+      if (value && Array.isArray(value.params)) {
+        return value.params.length;
+      }
+    }
+    if (Array.isArray(node.params)) {
+      return node.params.length;
+    }
+    return 0;
+  }
+  getFunctionBody(node) {
+    if (node.type === "MethodDefinition") {
+      const value = node.value;
+      if (value?.body) {
+        return value.body;
+      }
+    }
+    if (node.body) {
+      return node.body;
+    }
+    return null;
+  }
+  shouldAnalyzeFile(file) {
+    const ext = file.split(".").pop()?.toLowerCase();
+    return [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "mts",
+      "cts"
+    ].includes(ext ?? "");
+  }
+};
+
+// ../../packages/core/dist/analysis/ast/import-extractor.js
+function extractImports(content, filePath) {
+  if (!isSupportedFile(filePath)) {
+    return {
+      filePath,
+      imports: [],
+      parseSuccess: false,
+      parseErrors: [
+        `Unsupported file type: ${filePath}`
+      ]
+    };
+  }
+  const { program, errors, success } = parseSource(content, filePath);
+  const imports = [];
+  walkAST(program, (node) => {
+    switch (node.type) {
+      // import ... from 'source'
+      case "ImportDeclaration":
+        handleImportDeclaration(node, imports);
+        break;
+      // export { ... } from 'source'  OR  export * from 'source'
+      case "ExportNamedDeclaration":
+      case "ExportAllDeclaration":
+        handleExportDeclaration(node, imports);
+        break;
+      // import('source') — ESTree ImportExpression
+      case "ImportExpression":
+        handleImportExpression(node, imports);
+        break;
+      // require('source')  OR  legacy import('source') as CallExpression
+      case "CallExpression":
+        handleCallExpression(node, imports);
+        break;
+    }
+  });
+  return {
+    filePath,
+    imports,
+    parseSuccess: success,
+    parseErrors: errors.map((e) => e.message)
+  };
+}
+__name(extractImports, "extractImports");
+function extractImportSources(content, filePath) {
+  const result = extractImports(content, filePath);
+  const sources = /* @__PURE__ */ new Set();
+  for (const imp of result.imports) {
+    sources.add(imp.source);
+  }
+  return [
+    ...sources
+  ];
+}
+__name(extractImportSources, "extractImportSources");
+function extractImportsBatch(files) {
+  const results = /* @__PURE__ */ new Map();
+  for (const [filePath, content] of files) {
+    results.set(filePath, extractImports(content, filePath));
+  }
+  return results;
+}
+__name(extractImportsBatch, "extractImportsBatch");
+function handleImportDeclaration(node, imports) {
+  const source = getStringValue(node.source);
+  if (!source) {
+    return;
+  }
+  const specifiers = [];
+  if (Array.isArray(node.specifiers)) {
+    for (const spec of node.specifiers) {
+      const s = spec;
+      if (s.type === "ImportSpecifier") {
+        const imported = s.imported;
+        specifiers.push(getIdentifierName(imported) ?? "unknown");
+      } else if (s.type === "ImportDefaultSpecifier") {
+        specifiers.push("default");
+      } else if (s.type === "ImportNamespaceSpecifier") {
+        specifiers.push("*");
+      }
+    }
+  }
+  imports.push({
+    source,
+    kind: "static",
+    typeOnly: node.importKind === "type" || Boolean(node.isTypeOnly),
+    line: node.start != null ? node.start : void 0,
+    specifiers
+  });
+}
+__name(handleImportDeclaration, "handleImportDeclaration");
+function handleExportDeclaration(node, imports) {
+  const source = getStringValue(node.source);
+  if (!source) {
+    return;
+  }
+  const specifiers = [];
+  if (node.type === "ExportAllDeclaration") {
+    specifiers.push("*");
+  } else if (Array.isArray(node.specifiers)) {
+    for (const spec of node.specifiers) {
+      const s = spec;
+      const local = s.local;
+      specifiers.push(getIdentifierName(local) ?? "unknown");
+    }
+  }
+  imports.push({
+    source,
+    kind: "re-export",
+    typeOnly: node.exportKind === "type" || Boolean(node.isTypeOnly),
+    line: node.start != null ? node.start : void 0,
+    specifiers
+  });
+}
+__name(handleExportDeclaration, "handleExportDeclaration");
+function handleImportExpression(node, imports) {
+  const source = getStringValue(node.source);
+  if (source) {
+    imports.push({
+      source,
+      kind: "dynamic",
+      typeOnly: false,
+      line: node.start != null ? node.start : void 0,
+      specifiers: []
+    });
+  }
+}
+__name(handleImportExpression, "handleImportExpression");
+function handleCallExpression(node, imports) {
+  const callee = node.callee;
+  if (!callee) {
+    return;
+  }
+  if (node.type === "CallExpression" && callee.type === "Import") {
+    const args = node.arguments;
+    if (args && args.length > 0) {
+      const source = getStringValue(args[0]);
+      if (source) {
+        imports.push({
+          source,
+          kind: "dynamic",
+          typeOnly: false,
+          line: node.start != null ? node.start : void 0,
+          specifiers: []
+        });
+      }
+    }
+    return;
+  }
+  if (callee.type === "Identifier" && callee.name === "require") {
+    const args = node.arguments;
+    if (args && args.length > 0) {
+      const source = getStringValue(args[0]);
+      if (source) {
+        imports.push({
+          source,
+          kind: "require",
+          typeOnly: false,
+          line: node.start != null ? node.start : void 0,
+          specifiers: []
+        });
+      }
+    }
+  }
+}
+__name(handleCallExpression, "handleCallExpression");
+function getStringValue(node) {
+  if (!node || typeof node !== "object") {
+    return void 0;
+  }
+  const n = node;
+  if (n.type === "StringLiteral" || n.type === "Literal") {
+    return typeof n.value === "string" ? n.value : void 0;
+  }
+  return void 0;
+}
+__name(getStringValue, "getStringValue");
+function getIdentifierName(node) {
+  if (!node || typeof node !== "object") {
+    return void 0;
+  }
+  const n = node;
+  if (n.type === "Identifier" || n.type === "IdentifierName" || n.type === "IdentifierReference") {
+    return typeof n.name === "string" ? n.name : void 0;
+  }
+  return void 0;
+}
+__name(getIdentifierName, "getIdentifierName");
+
+// ../../packages/core/dist/analysis/ast/ImportGraphAnalyzer.js
+var THRESHOLDS2 = {
+  /** Max files that can import a single file before it's flagged as high fan-in */
+  highFanIn: 15,
+  /** Max imports a single file can have before it's flagged as high fan-out */
+  highFanOut: 20,
+  /** Minimum cycle length to report (avoids noise from self-imports) */
+  minCycleLength: 2
+};
+var ImportGraphAnalyzer = class {
+  static {
+    __name(this, "ImportGraphAnalyzer");
+  }
+  id = "import-graph";
+  name = "Import Graph Analysis";
+  filePatterns = [
+    "*.ts",
+    "*.tsx",
+    "*.js",
+    "*.jsx"
+  ];
+  async analyze(context) {
+    const startTime = performance.now();
+    const issues = [];
+    let filesAnalyzed = 0;
+    const parseErrors = [];
+    const extractions = /* @__PURE__ */ new Map();
+    for (const [file, content] of context.contents) {
+      if (!this.shouldAnalyzeFile(file)) {
+        continue;
+      }
+      filesAnalyzed++;
+      const result = extractImports(content, file);
+      extractions.set(file, result);
+      if (!result.parseSuccess) {
+        parseErrors.push(...result.parseErrors);
+      }
+    }
+    const graph = this.buildGraph(extractions, context.workspaceRoot);
+    const cycles = this.detectCycles(graph.edges);
+    graph.cycles = cycles;
+    for (const cycle of cycles) {
+      issues.push({
+        id: `import-graph/circular/${cycle.join("->")}`,
+        severity: "high",
+        type: "CIRCULAR_DEPENDENCY",
+        message: `Circular dependency: ${cycle.join(" \u2192 ")}`,
+        file: cycle[0],
+        fix: "Break the cycle by extracting shared code or using dependency injection"
+      });
+    }
+    for (const [file, node] of graph.nodes) {
+      if (node.importedBy.length > THRESHOLDS2.highFanIn) {
+        issues.push({
+          id: `import-graph/high-fan-in/${file}`,
+          severity: "medium",
+          type: "HIGH_FAN_IN",
+          message: `${file} is imported by ${node.importedBy.length} files \u2014 changes here have high blast radius`,
+          file,
+          fix: "Consider splitting into smaller, more focused modules"
+        });
+      }
+    }
+    for (const [file, node] of graph.nodes) {
+      const runtimeImports = node.imports.filter((imp) => !node.typeOnlyImports.includes(imp));
+      if (runtimeImports.length > THRESHOLDS2.highFanOut) {
+        issues.push({
+          id: `import-graph/high-fan-out/${file}`,
+          severity: "low",
+          type: "HIGH_FAN_OUT",
+          message: `${file} imports ${runtimeImports.length} modules \u2014 high coupling`,
+          file,
+          fix: "Consider using a facade or consolidating related imports"
+        });
+      }
+    }
+    for (const [file, node] of graph.nodes) {
+      if (node.importedBy.length === 0 && !this.isEntryPoint(file)) {
+        issues.push({
+          id: `import-graph/orphan/${file}`,
+          severity: "info",
+          type: "ORPHAN_FILE",
+          message: `${file} is not imported by any other analyzed file`,
+          file,
+          fix: "Verify this file is needed \u2014 it may be dead code"
+        });
+      }
+    }
+    return {
+      analyzer: this.id,
+      success: true,
+      issues,
+      coverage: filesAnalyzed / Math.max(context.files.length, 1),
+      duration: performance.now() - startTime,
+      metadata: {
+        filesAnalyzed,
+        nodesVisited: graph.nodes.size,
+        patternsChecked: [
+          "CIRCULAR_DEPENDENCY",
+          "HIGH_FAN_IN",
+          "HIGH_FAN_OUT",
+          "ORPHAN_FILE"
+        ],
+        parseErrors
+      }
+    };
+  }
+  shouldRun(context) {
+    return context.files.some((f) => this.shouldAnalyzeFile(f));
+  }
+  /**
+   * Build the import graph and return it for external consumption.
+   * Useful for other tools (momentum scoring, risk propagation, etc.).
+   */
+  buildGraphFromContext(context) {
+    const extractions = /* @__PURE__ */ new Map();
+    for (const [file, content] of context.contents) {
+      if (this.shouldAnalyzeFile(file)) {
+        extractions.set(file, extractImports(content, file));
+      }
+    }
+    const graph = this.buildGraph(extractions, context.workspaceRoot);
+    graph.cycles = this.detectCycles(graph.edges);
+    return graph;
+  }
+  // -----------------------------------------------------------------------
+  // Graph construction
+  // -----------------------------------------------------------------------
+  buildGraph(extractions, workspaceRoot) {
+    const nodes = /* @__PURE__ */ new Map();
+    const edges = /* @__PURE__ */ new Map();
+    const reverseEdges = /* @__PURE__ */ new Map();
+    for (const filePath of extractions.keys()) {
+      const normalized = this.normalizePath(filePath);
+      nodes.set(normalized, {
+        filePath: normalized,
+        imports: [],
+        importedBy: [],
+        typeOnlyImports: []
+      });
+      edges.set(normalized, /* @__PURE__ */ new Set());
+    }
+    for (const [filePath, extraction] of extractions) {
+      const normalized = this.normalizePath(filePath);
+      for (const imp of extraction.imports) {
+        const resolved = this.resolveImport(imp.source, filePath, workspaceRoot);
+        if (!resolved) {
+          continue;
+        }
+        const resolvedNorm = this.normalizePath(resolved);
+        edges.get(normalized)?.add(resolvedNorm);
+        const node = nodes.get(normalized);
+        if (node && !node.imports.includes(resolvedNorm)) {
+          node.imports.push(resolvedNorm);
+          if (imp.typeOnly) {
+            node.typeOnlyImports.push(resolvedNorm);
+          }
+        }
+        if (!reverseEdges.has(resolvedNorm)) {
+          reverseEdges.set(resolvedNorm, /* @__PURE__ */ new Set());
+        }
+        reverseEdges.get(resolvedNorm)?.add(normalized);
+        if (!nodes.has(resolvedNorm)) {
+          nodes.set(resolvedNorm, {
+            filePath: resolvedNorm,
+            imports: [],
+            importedBy: [],
+            typeOnlyImports: []
+          });
+        }
+      }
+    }
+    for (const [file, importers] of reverseEdges) {
+      const node = nodes.get(file);
+      if (node) {
+        node.importedBy = [
+          ...importers
+        ];
+      }
+    }
+    return {
+      nodes,
+      edges,
+      reverseEdges,
+      cycles: []
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Cycle detection (Tarjan's SCC adapted for cycles)
+  // -----------------------------------------------------------------------
+  detectCycles(edges) {
+    const cycles = [];
+    const visited = /* @__PURE__ */ new Set();
+    const inStack = /* @__PURE__ */ new Set();
+    const stack = [];
+    const dfs = /* @__PURE__ */ __name((node) => {
+      if (inStack.has(node)) {
+        const cycleStart = stack.indexOf(node);
+        if (cycleStart >= 0) {
+          const cycle = stack.slice(cycleStart);
+          if (cycle.length >= THRESHOLDS2.minCycleLength) {
+            cycles.push([
+              ...cycle,
+              node
+            ]);
+          }
+        }
+        return;
+      }
+      if (visited.has(node)) {
+        return;
+      }
+      visited.add(node);
+      inStack.add(node);
+      stack.push(node);
+      const neighbors = edges.get(node) ?? /* @__PURE__ */ new Set();
+      for (const neighbor of neighbors) {
+        dfs(neighbor);
+      }
+      stack.pop();
+      inStack.delete(node);
+    }, "dfs");
+    for (const node of edges.keys()) {
+      dfs(node);
+    }
+    return cycles;
+  }
+  // -----------------------------------------------------------------------
+  // Import resolution
+  // -----------------------------------------------------------------------
+  resolveImport(importSource, fromFile, _workspaceRoot) {
+    if (!importSource.startsWith(".") && !importSource.startsWith("/")) {
+      if (importSource.startsWith("@")) {
+        const parts = importSource.split("/");
+        if (parts.length >= 2) {
+          const pkg = parts[1];
+          return `packages/${pkg}/src/index.ts`;
+        }
+      }
+      return null;
+    }
+    const fromDir = dirname(fromFile);
+    let resolved = resolve(fromDir, importSource);
+    if (!resolved.match(/\.(ts|tsx|js|jsx|mts|cts|mjs|cjs)$/)) {
+      resolved += ".ts";
+    }
+    resolved = resolved.replace(/\.js$/, ".ts").replace(/\.jsx$/, ".tsx");
+    return resolved;
+  }
+  // -----------------------------------------------------------------------
+  // Helpers
+  // -----------------------------------------------------------------------
+  shouldAnalyzeFile(file) {
+    const ext = file.split(".").pop()?.toLowerCase();
+    return [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "mts",
+      "cts"
+    ].includes(ext ?? "");
+  }
+  isEntryPoint(file) {
+    return file.includes("index.") || file.includes("main.") || file.includes("entry.") || file.includes("server.") || file.includes("app.") || file.endsWith("/page.tsx") || file.endsWith("/layout.tsx") || file.endsWith("/route.ts") || file.includes("__tests__") || file.includes(".test.") || file.includes(".spec.");
+  }
+  normalizePath(filePath) {
+    return filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+  }
+};
 var SyntaxAnalyzer = class {
   static {
     __name(this, "SyntaxAnalyzer");
@@ -694,21 +1584,18 @@ var ChangeImpactAnalyzer = class {
     }
   }
   /**
-   * Extract import statements from file content
+   * Extract import statements from file content using AST analysis.
+   *
+   * UPGRADED (11b): Replaces regex-based import extraction with proper AST walking
+   * via packages/core/src/analysis/ast/import-extractor.ts (oxc-parser based).
+   * This eliminates false positives from imports in strings/comments and correctly
+   * handles dynamic imports, re-exports, and type-only imports.
    */
   extractImports(content, fromFile) {
+    const rawSources = extractImportSources(content, fromFile);
     const imports = [];
-    const importRegex = /import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/g;
-    const requireRegex = /require\s*\(['"]([^'"]+)['"]\)/g;
-    let match;
-    while ((match = importRegex.exec(content)) !== null) {
-      const importPath = this.resolveImportPath(match[1], fromFile);
-      if (importPath) {
-        imports.push(importPath);
-      }
-    }
-    while ((match = requireRegex.exec(content)) !== null) {
-      const importPath = this.resolveImportPath(match[1], fromFile);
+    for (const source of rawSources) {
+      const importPath = this.resolveImportPath(source, fromFile);
       if (importPath) {
         imports.push(importPath);
       }
@@ -1274,6 +2161,188 @@ var SecurityAnalyzer = class {
   }
 };
 
+// ../../packages/core/dist/analysis/pipeline.js
+var ANALYZER_COVERAGE_MAP = {
+  syntax: "astParsed",
+  security: "securityChecked",
+  completeness: "completenessChecked",
+  "change-impact": "architectureChecked",
+  "import-graph": "importGraphChecked",
+  complexity: "complexityChecked"
+};
+var CONFIDENCE_WEIGHTS = {
+  syntax: 0.2,
+  security: 0.25,
+  completeness: 0.15,
+  "change-impact": 0.1,
+  "import-graph": 0.15,
+  complexity: 0.15
+};
+async function runAnalysisPipeline(context, config) {
+  const start = Date.now();
+  const parallel = config?.parallel ?? true;
+  const timeout = config?.timeout ?? 3e4;
+  const allAnalyzers = createAnalyzers(context.workspaceRoot);
+  const selectedAnalyzers = filterAnalyzers(allAnalyzers, context, config?.analyzers);
+  const results = parallel ? await runParallel(selectedAnalyzers, context, timeout) : await runSequential(selectedAnalyzers, context, timeout);
+  const coverage = buildCoverageInfo(results, context);
+  const confidence = calculateConfidence(results, coverage);
+  const allIssues = results.flatMap((r) => r.issues);
+  const issuesBySeverity = groupBySeverity(allIssues);
+  return {
+    results,
+    totalIssues: allIssues.length,
+    issuesBySeverity,
+    coverage,
+    confidence,
+    duration: Date.now() - start
+  };
+}
+__name(runAnalysisPipeline, "runAnalysisPipeline");
+function createAnalyzers(workspaceRoot) {
+  return [
+    new SyntaxAnalyzer(),
+    new SecurityAnalyzer(),
+    new CompletenessAnalyzer(),
+    new ComplexityAnalyzer(),
+    new ImportGraphAnalyzer(),
+    new ChangeImpactAnalyzer(workspaceRoot)
+  ];
+}
+__name(createAnalyzers, "createAnalyzers");
+function filterAnalyzers(analyzers, context, selectedIds) {
+  let filtered = analyzers;
+  if (selectedIds && selectedIds.length > 0) {
+    const idSet = new Set(selectedIds);
+    filtered = filtered.filter((a) => idSet.has(a.id));
+  }
+  return filtered.filter((a) => a.shouldRun(context));
+}
+__name(filterAnalyzers, "filterAnalyzers");
+async function runParallel(analyzers, context, timeout) {
+  const promises = analyzers.map((analyzer) => runWithTimeout(analyzer, context, timeout));
+  return Promise.all(promises);
+}
+__name(runParallel, "runParallel");
+async function runSequential(analyzers, context, timeout) {
+  const results = [];
+  for (const analyzer of analyzers) {
+    const result = await runWithTimeout(analyzer, context, timeout);
+    results.push(result);
+  }
+  return results;
+}
+__name(runSequential, "runSequential");
+async function runWithTimeout(analyzer, context, timeout) {
+  const start = Date.now();
+  try {
+    const result = await Promise.race([
+      analyzer.analyze(context),
+      new Promise((_, reject) => {
+        setTimeout(() => reject(new Error(`Analyzer '${analyzer.id}' timed out after ${timeout}ms`)), timeout);
+      })
+    ]);
+    return result;
+  } catch (error) {
+    return {
+      analyzer: analyzer.id,
+      success: false,
+      issues: [
+        {
+          id: `pipeline/${analyzer.id}/error`,
+          severity: "high",
+          type: "ANALYZER_ERROR",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      ],
+      coverage: 0,
+      duration: Date.now() - start
+    };
+  }
+}
+__name(runWithTimeout, "runWithTimeout");
+function buildCoverageInfo(results, context) {
+  const coverage = {
+    astParsed: false,
+    securityChecked: false,
+    completenessChecked: false,
+    architectureChecked: false,
+    importGraphChecked: false,
+    complexityChecked: false,
+    filesCoverage: 0
+  };
+  for (const result of results) {
+    const field = ANALYZER_COVERAGE_MAP[result.analyzer];
+    if (field && field !== "filesCoverage" && result.success) {
+      coverage[field] = true;
+    }
+  }
+  const totalFiles = context.files.length;
+  if (totalFiles > 0) {
+    const successfulResults = results.filter((r) => r.success);
+    const avgCoverage = successfulResults.length > 0 ? successfulResults.reduce((sum, r) => sum + r.coverage, 0) / successfulResults.length : 0;
+    coverage.filesCoverage = avgCoverage;
+  }
+  return coverage;
+}
+__name(buildCoverageInfo, "buildCoverageInfo");
+function calculateConfidence(results, coverage) {
+  const breakdown = {};
+  let weightedSum = 0;
+  let totalWeight = 0;
+  let maxPossible = 0;
+  for (const [id, weight] of Object.entries(CONFIDENCE_WEIGHTS)) {
+    const result = results.find((r) => r.analyzer === id);
+    totalWeight += weight;
+    if (result) {
+      const analyzerConfidence = result.success ? result.coverage : 0;
+      breakdown[id] = analyzerConfidence;
+      weightedSum += weight * analyzerConfidence;
+      maxPossible += weight;
+    } else {
+      breakdown[id] = 0;
+    }
+  }
+  const confidence = totalWeight > 0 ? weightedSum / totalWeight : 0;
+  const maxPossibleConfidence = totalWeight > 0 ? maxPossible / totalWeight : 0;
+  const ranCount = results.filter((r) => r.success).length;
+  const totalAnalyzers = Object.keys(CONFIDENCE_WEIGHTS).length;
+  const explanationParts = [
+    `${ranCount}/${totalAnalyzers} analyzers ran successfully`,
+    `Files coverage: ${(coverage.filesCoverage * 100).toFixed(0)}%`
+  ];
+  const failedAnalyzers = results.filter((r) => !r.success);
+  if (failedAnalyzers.length > 0) {
+    explanationParts.push(`Failed: ${failedAnalyzers.map((r) => r.analyzer).join(", ")}`);
+  }
+  return {
+    confidence: Math.round(confidence * 100) / 100,
+    breakdown,
+    explanation: explanationParts.join(". "),
+    maxPossibleConfidence: Math.round(maxPossibleConfidence * 100) / 100
+  };
+}
+__name(calculateConfidence, "calculateConfidence");
+function groupBySeverity(issues) {
+  const grouped = {
+    critical: [],
+    high: [],
+    medium: [],
+    low: [],
+    info: []
+  };
+  for (const issue of issues) {
+    const severity = issue.severity || "info";
+    if (severity in grouped) {
+      grouped[severity].push(issue);
+    } else {
+      grouped.info.push(issue);
+    }
+  }
+  return grouped;
+}
+__name(groupBySeverity, "groupBySeverity");
+
 // ../../packages/core/dist/analysis/static/OrphanDetector.js
 var DEFAULT_OPTIONS = {
   fileExtensions: [
@@ -1376,7 +2445,7 @@ async function runStaticAnalysis(files, _workspaceRoot, options = {}) {
   };
   if (!options.skipTestDetection) {
     try {
-      const { analyzeSkippedTests: analyzeSkippedTests2 } = await import('./SkippedTestDetector-B3JZUE5G.js');
+      const { analyzeSkippedTests: analyzeSkippedTests2 } = await import('./SkippedTestDetector-AXTMWWHC.js');
       const testResults = analyzeSkippedTests2(files);
       for (const testResult of testResults) {
         if (!testResult.parsed && testResult.error) {
@@ -1402,6 +2471,4 @@ async function runStaticAnalysis(files, _workspaceRoot, options = {}) {
 }
 __name(runStaticAnalysis, "runStaticAnalysis");
 
-export { ChangeImpactAnalyzer, CompletenessAnalyzer, SecurityAnalyzer, SyntaxAnalyzer, checkFilesForOrphanStatus, createChangeImpactAnalyzer, detectOrphans, filterOrphansToFiles, runStaticAnalysis };
-//# sourceMappingURL=chunk-OJNDAPC2.js.map
-//# sourceMappingURL=chunk-OJNDAPC2.js.map
+export { ChangeImpactAnalyzer, CompletenessAnalyzer, ComplexityAnalyzer, ImportGraphAnalyzer, SecurityAnalyzer, SyntaxAnalyzer, checkFilesForOrphanStatus, countASTNodes, createChangeImpactAnalyzer, detectOrphans, extractImportSources, extractImports, extractImportsBatch, filterOrphansToFiles, isSupportedFile, offsetToLine, parseSource, runAnalysisPipeline, runStaticAnalysis, walkAST };