@anatolykoptev/krolik-cli 0.5.0 → 0.7.0

package/dist/bin/cli.js

@@ -8,7 +8,7 @@ import { SyntaxKind, Project, Node, DiagnosticCategory } from 'ts-morph';
 import * as crypto from 'crypto';
 import { createHash } from 'crypto';
 import { parseSync } from '@swc/core';
-import { spawnSync, spawn, execSync } from 'child_process';
+import { spawnSync, spawn, execFileSync, execSync } from 'child_process';
 import { defaultOptions, minify } from 'minify-xml';
 import { homedir } from 'os';
 import Database from 'better-sqlite3';
@@ -56,7 +56,7 @@ var KROLIK_VERSION, TEMPLATE_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     init_esm_shims();
-    KROLIK_VERSION = "0.5.0";
+    KROLIK_VERSION = "0.7.0";
     TEMPLATE_VERSION = "6.0.0";
   }
 });
@@ -1394,6 +1394,279 @@ var init_signatures = __esm({
   }
 });
 
+// src/lib/@ast/fingerprint/normalize.ts
+function normalizeAst(node, options = {}, depth = 0) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (depth > opts.maxDepth) {
+    return { type: "$MAX_DEPTH" };
+  }
+  if (node === null || node === void 0) {
+    return null;
+  }
+  if (typeof node !== "object") {
+    return node;
+  }
+  if (Array.isArray(node)) {
+    return node.map((item) => normalizeAst(item, opts, depth + 1));
+  }
+  const obj = node;
+  const nodeType = obj.type;
+  if (nodeType) {
+    return normalizeNodeByType(obj, nodeType, opts, depth);
+  }
+  return normalizeGenericObject(obj, opts, depth);
+}
+function normalizeNodeByType(node, nodeType, opts, depth) {
+  if (nodeType === "Identifier" && opts.normalizeIdentifiers) {
+    return { type: "Identifier", name: PLACEHOLDERS.IDENTIFIER };
+  }
+  if (nodeType === "StringLiteral" && opts.normalizeStrings) {
+    return { type: "StringLiteral", value: PLACEHOLDERS.STRING };
+  }
+  if ((nodeType === "NumericLiteral" || nodeType === "NumberLiteral") && opts.normalizeNumbers) {
+    return { type: "NumericLiteral", value: PLACEHOLDERS.NUMBER };
+  }
+  if (nodeType === "BigIntLiteral" && opts.normalizeNumbers) {
+    return { type: "BigIntLiteral", value: PLACEHOLDERS.NUMBER };
+  }
+  if (nodeType === "RegExpLiteral") {
+    const flags = node.flags;
+    return { type: "RegExpLiteral", pattern: PLACEHOLDERS.REGEX, flags };
+  }
+  if (nodeType === "TemplateLiteral" && opts.normalizeStrings) {
+    const quasis = node.quasis;
+    const expressions = node.expressions;
+    return {
+      type: "TemplateLiteral",
+      quasis: quasis?.map(() => ({ type: "TemplateElement", value: PLACEHOLDERS.TEMPLATE })),
+      expressions: expressions?.map((e) => normalizeAst(e, opts, depth + 1))
+    };
+  }
+  if (nodeType === "JSXText" && opts.normalizeStrings) {
+    return { type: "JSXText", value: PLACEHOLDERS.STRING };
+  }
+  return normalizeGenericObject(node, opts, depth);
+}
+function normalizeGenericObject(obj, opts, depth) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    if (SKIP_KEYS.has(key)) continue;
+    const value = obj[key];
+    if (key === "type") {
+      if (opts.includeTypes) {
+        result[key] = value;
+      }
+      continue;
+    }
+    result[key] = normalizeAst(value, opts, depth + 1);
+  }
+  return result;
+}
+function astToTokens(node, options = {}, tokens = [], depth = 0) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (depth > opts.maxDepth) {
+    tokens.push("$MAX");
+    return tokens;
+  }
+  if (node === null || node === void 0) {
+    return tokens;
+  }
+  if (typeof node !== "object") {
+    if (typeof node === "string" && opts.normalizeStrings) {
+      tokens.push(PLACEHOLDERS.STRING);
+    } else if (typeof node === "number" && opts.normalizeNumbers) {
+      tokens.push(PLACEHOLDERS.NUMBER);
+    } else if (typeof node === "boolean") {
+      tokens.push(node ? "TRUE" : "FALSE");
+    }
+    return tokens;
+  }
+  if (Array.isArray(node)) {
+    tokens.push("[");
+    for (const item of node) {
+      astToTokens(item, opts, tokens, depth + 1);
+    }
+    tokens.push("]");
+    return tokens;
+  }
+  const obj = node;
+  const nodeType = obj.type;
+  if (nodeType) {
+    tokens.push(nodeType);
+    if (nodeType === "Identifier" && opts.normalizeIdentifiers) {
+      tokens.push(PLACEHOLDERS.IDENTIFIER);
+      return tokens;
+    }
+    if (nodeType === "StringLiteral" && opts.normalizeStrings) {
+      tokens.push(PLACEHOLDERS.STRING);
+      return tokens;
+    }
+    if ((nodeType === "NumericLiteral" || nodeType === "NumberLiteral") && opts.normalizeNumbers) {
+      tokens.push(PLACEHOLDERS.NUMBER);
+      return tokens;
+    }
+  }
+  tokens.push("{");
+  for (const key of Object.keys(obj)) {
+    if (SKIP_KEYS.has(key) || key === "type") continue;
+    const value = obj[key];
+    if (value !== null && value !== void 0) {
+      tokens.push(`${key}:`);
+      astToTokens(value, opts, tokens, depth + 1);
+    }
+  }
+  tokens.push("}");
+  return tokens;
+}
+var DEFAULT_OPTIONS, PLACEHOLDERS, SKIP_KEYS;
+var init_normalize = __esm({
+  "src/lib/@ast/fingerprint/normalize.ts"() {
+    init_esm_shims();
+    DEFAULT_OPTIONS = {
+      normalizeIdentifiers: true,
+      normalizeStrings: true,
+      normalizeNumbers: true,
+      includeTypes: true,
+      maxDepth: 50
+    };
+    PLACEHOLDERS = {
+      IDENTIFIER: "$ID",
+      STRING: "$STR",
+      NUMBER: "$NUM",
+      REGEX: "$RGX",
+      TEMPLATE: "$TPL"
+    };
+    SKIP_KEYS = /* @__PURE__ */ new Set([
+      "span",
+      "start",
+      "end",
+      "loc",
+      "range",
+      "comments",
+      "leadingComments",
+      "trailingComments",
+      "innerComments",
+      "extra",
+      "raw",
+      "rawValue"
+    ]);
+  }
+});
+function generateFingerprint(code, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  try {
+    const ast = parseSync(code, {
+      syntax: "typescript",
+      tsx: true
+    });
+    return generateFingerprintFromAst(ast, opts);
+  } catch {
+    return {
+      fingerprint: "",
+      tokenCount: 0,
+      complexity: 0,
+      tooSmall: true
+    };
+  }
+}
+function generateFingerprintFromAst(ast, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  if (opts.tokenBased) {
+    const tokens2 = astToTokens(ast, opts);
+    const tokenCount2 = tokens2.length;
+    if (tokenCount2 < (opts.minTokens ?? 10)) {
+      return {
+        fingerprint: "",
+        tokenCount: tokenCount2,
+        complexity: calculateComplexity(tokens2),
+        tooSmall: true
+      };
+    }
+    const tokenString = tokens2.join(" ");
+    const fingerprint2 = crypto.createHash("md5").update(tokenString).digest("hex");
+    return {
+      fingerprint: fingerprint2,
+      tokenCount: tokenCount2,
+      complexity: calculateComplexity(tokens2),
+      tooSmall: false
+    };
+  }
+  const normalized = normalizeAst(ast, opts);
+  const serialized = JSON.stringify(normalized, null, 0);
+  const tokens = astToTokens(ast, opts);
+  const tokenCount = tokens.length;
+  if (tokenCount < (opts.minTokens ?? 10)) {
+    return {
+      fingerprint: "",
+      tokenCount,
+      complexity: calculateComplexity(tokens),
+      tooSmall: true
+    };
+  }
+  const fingerprint = crypto.createHash("md5").update(serialized).digest("hex");
+  return {
+    fingerprint,
+    tokenCount,
+    complexity: calculateComplexity(tokens),
+    tooSmall: false
+  };
+}
+function calculateComplexity(tokens) {
+  let complexity = 0;
+  complexity += Math.log2(tokens.length + 1) * 10;
+  const controlFlow = [
+    "IfStatement",
+    "ForStatement",
+    "WhileStatement",
+    "SwitchStatement",
+    "TryStatement"
+  ];
+  for (const token of tokens) {
+    if (controlFlow.includes(token)) {
+      complexity += 5;
+    }
+  }
+  const callCount = tokens.filter((t) => t === "CallExpression").length;
+  complexity += callCount * 2;
+  let maxDepth = 0;
+  let currentDepth = 0;
+  for (const token of tokens) {
+    if (token === "{" || token === "[") {
+      currentDepth++;
+      maxDepth = Math.max(maxDepth, currentDepth);
+    } else if (token === "}" || token === "]") {
+      currentDepth--;
+    }
+  }
+  complexity += maxDepth * 3;
+  return Math.round(complexity);
+}
+var DEFAULT_OPTIONS2;
+var init_fingerprint = __esm({
+  "src/lib/@ast/fingerprint/fingerprint.ts"() {
+    init_esm_shims();
+    init_normalize();
+    DEFAULT_OPTIONS2 = {
+      normalizeIdentifiers: true,
+      normalizeStrings: true,
+      normalizeNumbers: true,
+      includeTypes: true,
+      maxDepth: 50,
+      tokenBased: false,
+      minTokens: 10
+    };
+  }
+});
+
+// src/lib/@ast/fingerprint/index.ts
+var init_fingerprint2 = __esm({
+  "src/lib/@ast/fingerprint/index.ts"() {
+    init_esm_shims();
+    init_fingerprint();
+    init_normalize();
+  }
+});
+
 // src/lib/@ast/index.ts
 var init_ast = __esm({
   "src/lib/@ast/index.ts"() {
@@ -1401,6 +1674,7 @@ var init_ast = __esm({
     init_ts_morph();
     init_analysis2();
     init_signatures();
+    init_fingerprint2();
   }
 });
 
@@ -1686,6 +1960,85 @@ var init_imports = __esm({
 });
 
 // src/lib/@ast/swc/string-context.ts
+function isInsideComment2(content, offset) {
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let inTemplate = false;
+  let templateBraceDepth = 0;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let escaped = false;
+  for (let i = 0; i < offset && i < content.length; i++) {
+    const char = content[i];
+    const nextChar = content[i + 1];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && (inSingleQuote || inDoubleQuote || inTemplate)) {
+      escaped = true;
+      continue;
+    }
+    if (inLineComment) {
+      if (char === "\n") {
+        inLineComment = false;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === "*" && nextChar === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (!inLineComment && !inBlockComment) {
+      if (inTemplate && templateBraceDepth === 0 && char === "$" && nextChar === "{") {
+        templateBraceDepth = 1;
+        i++;
+        continue;
+      }
+      if (inTemplate && templateBraceDepth > 0) {
+        if (char === "{") {
+          templateBraceDepth++;
+        } else if (char === "}") {
+          templateBraceDepth--;
+        }
+        if (templateBraceDepth > 0 && char === "/" && nextChar === "/") {
+          inLineComment = true;
+          i++;
+          continue;
+        }
+        if (templateBraceDepth > 0 && char === "/" && nextChar === "*") {
+          inBlockComment = true;
+          i++;
+          continue;
+        }
+        continue;
+      }
+      if (char === "'" && !inDoubleQuote && !inTemplate) {
+        inSingleQuote = !inSingleQuote;
+      } else if (char === '"' && !inSingleQuote && !inTemplate) {
+        inDoubleQuote = !inDoubleQuote;
+      } else if (char === "`" && !inSingleQuote && !inDoubleQuote) {
+        inTemplate = !inTemplate;
+        if (!inTemplate) templateBraceDepth = 0;
+      }
+      if (!inSingleQuote && !inDoubleQuote && !inTemplate) {
+        if (char === "/" && nextChar === "/") {
+          inLineComment = true;
+          i++;
+          continue;
+        }
+        if (char === "/" && nextChar === "*") {
+          inBlockComment = true;
+          i++;
+        }
+      }
+    }
+  }
+  return inLineComment || inBlockComment;
+}
 function isInsideStringOrComment(content, offset) {
   let inSingleQuote = false;
   let inDoubleQuote = false;
@@ -3107,92 +3460,103 @@ var init_browser_apis = __esm({
 });
 
 // src/lib/@detectors/lint/lint-detector.ts
-function detectLintIssue(node) {
-  const nodeType = node.type;
-  const span = node.span;
-  if (!span) {
+function detectDebuggerStatement(nodeType, offset) {
+  if (nodeType === "DebuggerStatement") {
+    return { type: "debugger", offset };
+  }
+  return null;
+}
+function detectEmptyCatchBlock(node, nodeType, offset) {
+  if (nodeType !== "CatchClause") {
     return null;
   }
-  if (nodeType === "DebuggerStatement") {
-    return {
-      type: "debugger",
-      offset: span.start
-    };
+  const catchClause = node;
+  const body = catchClause.body;
+  if (!body || body.type !== "BlockStatement") {
+    return null;
   }
-  if (nodeType === "CatchClause") {
-    const catchClause = node;
-    const body = catchClause.body;
-    if (body && body.type === "BlockStatement") {
-      const stmts = body.stmts ?? [];
-      if (stmts.length === 0) {
-        return {
-          type: "empty-catch",
-          offset: span.start
-        };
-      }
-      if (stmts.length === 1) {
-        const stmt = stmts[0];
-        if (stmt.type === "ReturnStatement") {
-          return {
-            type: "empty-catch",
-            offset: span.start
-          };
-        }
-      }
-    }
+  const stmts = body.stmts ?? [];
+  if (stmts.length === 0) {
+    return { type: "empty-catch", offset };
   }
-  if (nodeType === "CallExpression" || nodeType === "OptionalChainingExpression") {
-    const callExpr = node;
-    const callee = callExpr.callee ?? callExpr.base;
-    if (!callee) {
-      return null;
-    }
-    const calleeType = callee.type;
-    if (calleeType === "MemberExpression") {
-      const memberExpr = callee;
-      const object = memberExpr.object;
-      const property = memberExpr.property;
-      if (!object || !property) {
-        return null;
-      }
-      const objectType = object.type;
-      const propertyType = property.type;
-      if (objectType === "Identifier" && propertyType === "Identifier") {
-        const objectValue = object.value;
-        const propertyValue = property.value;
-        if (objectValue && propertyValue && isConsoleMember(propertyValue, objectValue)) {
-          return {
-            type: "console",
-            offset: span.start,
-            method: propertyValue
-          };
-        }
-      }
-    }
-    if (calleeType === "Identifier") {
-      const identifier = callee;
-      const identifierValue = identifier.value;
-      if (!identifierValue) {
-        return null;
-      }
-      if (isDialogFunction(identifierValue)) {
-        return {
-          type: "alert",
-          offset: span.start,
-          method: identifierValue
-        };
-      }
-      if (isEvalFunction(identifierValue)) {
-        return {
-          type: "eval",
-          offset: span.start,
-          method: identifierValue
-        };
-      }
+  if (stmts.length === 1) {
+    const stmt = stmts[0];
+    if (stmt.type === "ReturnStatement") {
+      return { type: "empty-catch", offset };
     }
   }
   return null;
 }
+function extractCallee(node, nodeType) {
+  if (nodeType !== "CallExpression" && nodeType !== "OptionalChainingExpression") {
+    return null;
+  }
+  const callExpr = node;
+  return callExpr.callee ?? callExpr.base ?? null;
+}
+function detectConsoleCall(callee, offset) {
+  const calleeType = callee.type;
+  if (calleeType !== "MemberExpression") {
+    return null;
+  }
+  const memberExpr = callee;
+  const object = memberExpr.object;
+  const property = memberExpr.property;
+  if (!object || !property) {
+    return null;
+  }
+  const objectNode = object;
+  const propertyNode = property;
+  if (objectNode.type !== "Identifier" || propertyNode.type !== "Identifier") {
+    return null;
+  }
+  const objectValue = objectNode.value;
+  const propertyValue = propertyNode.value;
+  if (!objectValue || !propertyValue) {
+    return null;
+  }
+  if (isConsoleMember(propertyValue, objectValue)) {
+    return { type: "console", offset, method: propertyValue };
+  }
+  return null;
+}
+function detectGlobalFunctionCall(callee, offset) {
+  const calleeType = callee.type;
+  if (calleeType !== "Identifier") {
+    return null;
+  }
+  const identifier = callee;
+  const name = identifier.value;
+  if (!name) {
+    return null;
+  }
+  if (isDialogFunction(name)) {
+    return { type: "alert", offset, method: name };
+  }
+  if (isEvalFunction(name)) {
+    return { type: "eval", offset, method: name };
+  }
+  return null;
+}
+function detectLintIssue(node) {
+  const nodeType = node.type;
+  const span = node.span;
+  if (!span || !nodeType) {
+    return null;
+  }
+  const offset = span.start;
+  const debuggerResult = detectDebuggerStatement(nodeType, offset);
+  if (debuggerResult) return debuggerResult;
+  const emptyCatchResult = detectEmptyCatchBlock(node, nodeType, offset);
+  if (emptyCatchResult) return emptyCatchResult;
+  const callee = extractCallee(node, nodeType);
+  if (!callee) return null;
+  const consoleResult = detectConsoleCall(callee, offset);
+  if (consoleResult) return consoleResult;
+  const globalResult = detectGlobalFunctionCall(callee, offset);
+  if (globalResult) return globalResult;
+  return null;
+}
 var init_lint_detector = __esm({
   "src/lib/@detectors/lint/lint-detector.ts"() {
     init_esm_shims();
@@ -3202,117 +3566,119 @@ var init_lint_detector = __esm({
 
 // src/lib/@detectors/lint/type-safety-detector.ts
 function isAnyType(node) {
-  const nodeType = node.type;
-  if (nodeType === "TsKeywordType") {
-    const kind = node.kind;
-    return kind === "any";
+  const typedNode = node;
+  return typedNode.type === "TsKeywordType" && typedNode.kind === "any";
+}
+function createDetection(type, offset) {
+  return { type, offset };
+}
+function detectTypeAnnotation(node, span) {
+  if (node.type !== "TsTypeAnnotation") return null;
+  const typeAnnotation = node.typeAnnotation;
+  if (!typeAnnotation || !isAnyType(typeAnnotation)) return null;
+  return createDetection("any-annotation", span.start);
+}
+function detectAsAnyAssertion(node, span) {
+  if (node.type !== "TsAsExpression") return null;
+  const typeAnnotation = node.typeAnnotation;
+  if (!typeAnnotation || !isAnyType(typeAnnotation)) return null;
+  return createDetection("any-assertion", span.start);
+}
+function detectDoubleAssertionPattern(node, span) {
+  if (node.type !== "TsAsExpression") return null;
+  const expression = node.expression;
+  if (!expression || expression.type !== "TsAsExpression") return null;
+  const innerTypeAnnotation = expression.typeAnnotation;
+  if (!innerTypeAnnotation) return null;
+  const isUnknownAssertion = innerTypeAnnotation.type === "TsKeywordType" && innerTypeAnnotation.kind === "unknown";
+  if (!isUnknownAssertion) return null;
+  return createDetection("double-assertion", span.start);
+}
+function detectNonNullAssertionHandler(node, span) {
+  if (node.type !== "TsNonNullExpression") return null;
+  return createDetection("non-null", span.start);
+}
+function detectAnyInTypeParams(node, span) {
+  if (node.type !== "TsTypeReference") return null;
+  const params = node.typeParams?.params;
+  if (!params) return null;
+  for (const param of params) {
+    if (isAnyType(param)) {
+      return createDetection("any-annotation", span.start);
+    }
   }
-  return false;
+  return null;
+}
+function detectAnyInReturnType(node, span) {
+  const functionTypes = ["TsFunctionType", "TsConstructorType", "TsMethodSignature"];
+  if (!functionTypes.includes(node.type ?? "")) return null;
+  const typeAnnotation = node.typeAnnotation;
+  if (!typeAnnotation) return null;
+  const returnType = typeAnnotation.typeAnnotation;
+  if (!returnType || !isAnyType(returnType)) return null;
+  return createDetection("any-annotation", span.start);
+}
+function detectAnyInParamType(node, span) {
+  if (node.type !== "Parameter") return null;
+  const typeAnnotation = node.typeAnnotation;
+  if (!typeAnnotation) return null;
+  const paramType = typeAnnotation.typeAnnotation;
+  if (!paramType || !isAnyType(paramType)) return null;
+  return createDetection("any-param", span.start);
+}
+function detectAnyInArrayType(node, span) {
+  if (node.type !== "TsArrayType") return null;
+  const elemType = node.elemType;
+  if (!elemType || !isAnyType(elemType)) return null;
+  return createDetection("any-array", span.start);
 }
 function detectTypeSafetyIssue(node) {
-  const nodeType = node.type;
-  const span = node.span;
-  if (!span) return null;
-  if (nodeType === "TsTypeAnnotation") {
-    const typeAnnotation = node.typeAnnotation;
-    if (typeAnnotation && isAnyType(typeAnnotation)) {
-      return {
-        type: "any-annotation",
-        offset: span.start
-      };
-    }
-  }
-  if (nodeType === "TsAsExpression") {
-    const typeAnnotation = node.typeAnnotation;
-    const expression = node.expression;
-    if (typeAnnotation && isAnyType(typeAnnotation)) {
-      return {
-        type: "any-assertion",
-        offset: span.start
-      };
-    }
-    if (expression && expression.type === "TsAsExpression") {
-      const innerTypeAnnotation = expression.typeAnnotation;
-      if (innerTypeAnnotation) {
-        const innerType = innerTypeAnnotation.type;
-        const innerKind = innerTypeAnnotation.kind;
-        if (innerType === "TsKeywordType" && innerKind === "unknown") {
-          return {
-            type: "double-assertion",
-            offset: span.start
-          };
-        }
-      }
-    }
-  }
-  if (nodeType === "TsNonNullExpression") {
-    return {
-      type: "non-null",
-      offset: span.start
-    };
-  }
-  if (nodeType === "TsTypeReference") {
-    const typeParams = node.typeParams;
-    if (typeParams?.params) {
-      for (const param of typeParams.params) {
-        if (isAnyType(param)) {
-          return {
-            type: "any-annotation",
-            offset: span.start
-          };
-        }
-      }
-    }
-  }
-  if (nodeType === "TsFunctionType" || nodeType === "TsConstructorType" || nodeType === "TsMethodSignature") {
-    const typeAnnotation = node.typeAnnotation;
-    if (typeAnnotation) {
-      const returnType = typeAnnotation.typeAnnotation;
-      if (returnType && isAnyType(returnType)) {
-        return {
-          type: "any-annotation",
-          offset: span.start
-        };
-      }
-    }
-  }
-  if (nodeType === "Parameter") {
-    const typeAnnotation = node.typeAnnotation;
-    if (typeAnnotation) {
-      const paramType = typeAnnotation.typeAnnotation;
-      if (paramType && isAnyType(paramType)) {
-        return {
-          type: "any-param",
-          offset: span.start
-        };
-      }
-    }
-  }
-  if (nodeType === "TsArrayType") {
-    const elemType = node.elemType;
-    if (elemType && isAnyType(elemType)) {
-      return {
-        type: "any-array",
-        offset: span.start
-      };
-    }
+  const typedNode = node;
+  const { type: nodeType, span } = typedNode;
+  if (!span || !nodeType) return null;
+  const handlers = detectionStrategies.get(nodeType);
+  if (!handlers) return null;
+  for (const handler of handlers) {
+    const result = handler(typedNode, span);
+    if (result) return result;
   }
   return null;
 }
+var detectionStrategies;
 var init_type_safety_detector = __esm({
   "src/lib/@detectors/lint/type-safety-detector.ts"() {
     init_esm_shims();
+    detectionStrategies = /* @__PURE__ */ new Map([
+      ["TsTypeAnnotation", [detectTypeAnnotation]],
+      ["TsAsExpression", [detectAsAnyAssertion, detectDoubleAssertionPattern]],
+      ["TsNonNullExpression", [detectNonNullAssertionHandler]],
+      ["TsTypeReference", [detectAnyInTypeParams]],
+      ["TsFunctionType", [detectAnyInReturnType]],
+      ["TsConstructorType", [detectAnyInReturnType]],
+      ["TsMethodSignature", [detectAnyInReturnType]],
+      ["Parameter", [detectAnyInParamType]],
+      ["TsArrayType", [detectAnyInArrayType]]
+    ]);
   }
 });
 
 // src/lib/@detectors/security/security-detector.ts
-function detectSecurityIssue(node) {
-  const nodeType = node.type;
-  const span = node.span;
-  if (!span) {
-    return null;
-  }
-  if (nodeType !== "CallExpression") {
+function getNodeType2(node) {
+  return node?.type;
+}
+function getNodeSpan2(node) {
+  return node.span;
+}
+function getIdentifierValue(node) {
+  return node.value;
+}
+function getArgumentExpression(arg) {
+  return arg.expression;
+}
+function parseCallExpression(node) {
+  const nodeType = getNodeType2(node);
+  const span = getNodeSpan2(node);
+  if (!span || nodeType !== "CallExpression") {
     return null;
   }
   const callExpr = node;
@@ -3320,82 +3686,132 @@ function detectSecurityIssue(node) {
   if (!callee) {
     return null;
   }
-  const calleeType = callee.type;
-  if (calleeType === "Identifier") {
-    const identifier = callee;
-    const identifierValue = identifier.value;
-    if (identifierValue && COMMAND_EXEC_METHODS.includes(identifierValue)) {
-      const args = callExpr.arguments ?? [];
-      const firstArg = args[0];
-      if (firstArg) {
-        const argExpr = firstArg.expression;
-        if (argExpr) {
-          const argType = argExpr.type;
-          if (argType === "TemplateLiteral") {
-            const templateLiteral = argExpr;
-            const expressions = templateLiteral.expressions ?? [];
-            if (expressions.length > 0) {
-              return {
-                type: "command-injection",
-                offset: span.start,
-                method: identifierValue
-              };
-            }
-          }
-        }
-      }
-    }
+  const calleeType = getNodeType2(callee);
+  if (!calleeType) {
+    return null;
   }
-  if (calleeType === "MemberExpression") {
-    const memberExpr = callee;
-    const object = memberExpr.object;
-    const property = memberExpr.property;
-    if (!object || !property) {
-      return null;
-    }
-    const objectType = object.type;
-    if (objectType === "Identifier") {
-      const objectValue = object.value;
-      if (objectValue === "path") {
-        const propertyType = property.type;
-        if (propertyType === "Identifier") {
-          const propertyValue = property.value;
-          if (propertyValue && PATH_METHODS.includes(propertyValue)) {
-            const args = callExpr.arguments ?? [];
-            const pathSegmentArgs = args.slice(1);
-            const hasUntrustedPathSegment = pathSegmentArgs.some((arg) => {
-              const argExpr = arg.expression;
-              if (!argExpr) return false;
-              const argType = argExpr.type;
-              if (argType === "Identifier") return true;
-              if (argType === "TemplateLiteral") {
-                const templateLiteral = argExpr;
-                return (templateLiteral.expressions?.length ?? 0) > 0;
-              }
-              if (argType === "MemberExpression") return true;
-              if (argType === "CallExpression") return true;
-              return false;
-            });
-            if (hasUntrustedPathSegment) {
-              return {
-                type: "path-traversal",
-                offset: span.start,
-                method: `path.${propertyValue}`
-              };
-            }
-          }
-        }
-      }
+  return {
+    callee,
+    calleeType,
+    args: callExpr.arguments ?? [],
+    span
+  };
+}
+function hasTemplateInterpolation(argExpr) {
+  const argType = getNodeType2(argExpr);
+  if (argType !== "TemplateLiteral") {
+    return false;
+  }
+  const templateLiteral = argExpr;
+  const expressions = templateLiteral.expressions ?? [];
+  return expressions.length > 0;
+}
+function detectCommandInjectionFromCall(parsed) {
+  if (parsed.calleeType !== "Identifier") {
+    return null;
+  }
+  const methodName = getIdentifierValue(parsed.callee);
+  if (!methodName || !COMMAND_EXEC_METHODS.has(methodName)) {
+    return null;
+  }
+  const firstArg = parsed.args[0];
+  if (!firstArg) {
+    return null;
+  }
+  const argExpr = getArgumentExpression(firstArg);
+  if (!argExpr) {
+    return null;
+  }
+  if (hasTemplateInterpolation(argExpr)) {
+    return {
+      type: "command-injection",
+      offset: parsed.span.start,
+      method: methodName
+    };
+  }
+  return null;
+}
+function isUntrustedArgument(arg) {
+  const argExpr = getArgumentExpression(arg);
+  if (!argExpr) {
+    return false;
+  }
+  const argType = getNodeType2(argExpr);
+  if (!argType) {
+    return false;
+  }
+  if (UNTRUSTED_ARG_TYPES.has(argType)) {
+    return true;
+  }
+  if (argType === "TemplateLiteral") {
+    return hasTemplateInterpolation(argExpr);
+  }
+  return false;
+}
+function extractPathMethod(callee) {
+  const memberExpr = callee;
+  const { object, property } = memberExpr;
+  if (!object || !property) {
+    return null;
+  }
+  if (getNodeType2(object) !== "Identifier") {
+    return null;
+  }
+  if (getIdentifierValue(object) !== "path") {
+    return null;
+  }
+  if (getNodeType2(property) !== "Identifier") {
+    return null;
+  }
+  const methodName = getIdentifierValue(property);
+  if (!methodName || !PATH_METHODS.has(methodName)) {
+    return null;
+  }
+  return methodName;
+}
+function detectPathTraversalFromCall(parsed) {
+  if (parsed.calleeType !== "MemberExpression") {
+    return null;
+  }
+  const methodName = extractPathMethod(parsed.callee);
+  if (!methodName) {
+    return null;
+  }
+  const pathSegmentArgs = parsed.args.slice(1);
+  const hasUntrustedSegment = pathSegmentArgs.some(isUntrustedArgument);
+  if (hasUntrustedSegment) {
+    return {
+      type: "path-traversal",
+      offset: parsed.span.start,
+      method: `path.${methodName}`
+    };
+  }
+  return null;
+}
+function detectSecurityIssue(node) {
+  const parsed = parseCallExpression(node);
+  if (!parsed) {
+    return null;
+  }
+  for (const detector of SECURITY_DETECTORS) {
+    const result = detector(parsed);
+    if (result) {
+      return result;
     }
   }
   return null;
 }
-var COMMAND_EXEC_METHODS, PATH_METHODS;
+var COMMAND_EXEC_METHODS, PATH_METHODS, UNTRUSTED_ARG_TYPES, SECURITY_DETECTORS;
 var init_security_detector = __esm({
   "src/lib/@detectors/security/security-detector.ts"() {
     init_esm_shims();
-    COMMAND_EXEC_METHODS = ["execSync", "exec", "spawn", "spawnSync"];
-    PATH_METHODS = ["join", "resolve"];
+    COMMAND_EXEC_METHODS = /* @__PURE__ */ new Set(["execSync", "exec", "spawn", "spawnSync"]);
+    PATH_METHODS = /* @__PURE__ */ new Set(["join", "resolve"]);
+    UNTRUSTED_ARG_TYPES = /* @__PURE__ */ new Set(["Identifier", "MemberExpression", "CallExpression"]);
+    SECURITY_DETECTORS = [
+      detectCommandInjectionFromCall,
+      detectPathTraversalFromCall
+    ];
   }
 });
 
@@ -5413,12 +5829,17 @@ var init_issue_factory = __esm({
 });
 
 // src/lib/@detectors/patterns/context.ts
-function isInsideStringLiteral(line, position) {
-  const beforeDirective = line.slice(0, position);
-  const singleQuotes = (beforeDirective.match(/'/g) || []).length;
-  const doubleQuotes = (beforeDirective.match(/"/g) || []).length;
-  const backticks = (beforeDirective.match(/`/g) || []).length;
-  return singleQuotes % 2 !== 0 || doubleQuotes % 2 !== 0 || backticks % 2 !== 0;
+function isRealTsDirective(line, matchIndex) {
+  const beforeMatch = line.slice(0, matchIndex);
+  const lineCommentMatch = beforeMatch.match(/\/\/\s*$/);
+  if (lineCommentMatch) {
+    return true;
+  }
+  const blockCommentMatch = beforeMatch.match(/\/\*+\s*$/);
+  if (blockCommentMatch) {
+    return true;
+  }
+  return false;
 }
 function createSnippet(line) {
   const trimmed = line.trim();
@@ -5427,24 +5848,27 @@ function createSnippet(line) {
 function checkTsDirectives(content, filepath) {
   const issues = [];
   const lines = content.split("\n");
+  let charOffset = 0;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i] ?? "";
-    const trimmed = line.trim();
-    if (!trimmed) {
-      continue;
-    }
+    const lineStartOffset = charOffset;
     for (const { pattern, type } of DIRECTIVE_PATTERNS) {
-      const match = pattern.exec(trimmed);
+      const match = pattern.exec(line);
       if (!match) {
         continue;
       }
-      if (isInsideStringLiteral(trimmed, match.index)) {
+      const absoluteOffset = lineStartOffset + match.index;
+      if (!isInsideComment2(content, absoluteOffset)) {
+        continue;
+      }
+      if (!isRealTsDirective(line, match.index)) {
         continue;
       }
-      const snippet = createSnippet(trimmed);
+      const snippet = createSnippet(line);
       const issue = createTsDirectiveIssue(type, i + 1, snippet, filepath);
       issues.push(issue);
     }
+    charOffset = lineStartOffset + line.length + 1;
   }
   return issues;
 }
@@ -5536,6 +5960,7 @@ var MAX_SNIPPET_LENGTH, DIRECTIVE_PATTERNS, VERB_ENDINGS, VERB_STEM_PATTERNS, VO
 var init_context = __esm({
   "src/lib/@detectors/patterns/context.ts"() {
     init_esm_shims();
+    init_swc();
     init_issue_factory();
     MAX_SNIPPET_LENGTH = 80;
     DIRECTIVE_PATTERNS = [
@@ -16111,6 +16536,132 @@ var init_registry5 = __esm({
   }
 });
 
+// src/lib/@core/text/morphology.ts
+function getVowelRatio2(str) {
+  const vowels = str.match(/[aeiou]/gi);
+  return vowels ? vowels.length / str.length : 0;
+}
+function isAbbreviation(name) {
+  if (name.length > 5) return false;
+  const vowelRatio = getVowelRatio2(name);
+  return vowelRatio < 0.2;
+}
+function estimateSyllables(word) {
+  const lowerWord = word.toLowerCase();
+  const vowelClusters = lowerWord.match(/[aeiouy]+/g);
+  if (!vowelClusters) return 1;
+  let count = vowelClusters.length;
+  if (lowerWord.endsWith("e") && count > 1) {
+    count--;
+  }
+  if (/le$/.test(lowerWord) && count > 1) {
+    const beforeLe = lowerWord.slice(-3, -2);
+    if (!/[aeiouy]/.test(beforeLe)) {
+      count++;
+    }
+  }
+  return Math.max(1, count);
+}
+function hasNounSuffix(word) {
+  const lowerWord = word.toLowerCase();
+  const nounPatterns = [
+    /er$/,
+    // handler, listener, helper, manager
+    /or$/,
+    // iterator, selector, constructor
+    /tion$/,
+    // function, action, collection
+    /sion$/,
+    // session, version
+    /ment$/,
+    // element, argument
+    /ness$/,
+    // readiness
+    /ity$/,
+    // utility, entity
+    /ure$/,
+    // structure, closure
+    /ance$/,
+    // instance
+    /ence$/,
+    // reference, sequence
+    /ing$/,
+    // string, thing (as nouns)
+    /ist$/,
+    // list (and -ist words)
+    /ata$/,
+    // data, metadata
+    /xt$/,
+    // context, text
+    /que$/,
+    // queue
+    /ay$/,
+    // array, display
+    /ch$/,
+    // cache, batch
+    /ck$/,
+    // callback, stack
+    /se$/,
+    // response, case
+    /te$/,
+    // state, template
+    /de$/,
+    // node, code
+    /ue$/,
+    // value, queue
+    /pe$/,
+    // type, pipe
+    /me$/,
+    // name, frame
+    /ms$/,
+    // params, items
+    /gs$/,
+    // args, flags
+    /ps$/,
+    // props
+    /ns$/,
+    // options, actions
+    /ts$/,
+    // results, events
+    /rd$/,
+    // record
+    /ry$/,
+    // factory, entry
+    /ol$/,
+    // control, protocol
+    /et$/,
+    // object, set
+    /ap$/,
+    // map
+    /lt$/,
+    // result
+    /ig$/,
+    // config
+    /fo$/
+    // info
+  ];
+  return nounPatterns.some((pattern) => pattern.test(lowerWord));
+}
+function splitIntoSegments(name) {
+  if (name.includes("_")) {
+    return name.split("_").filter((s) => s.length > 0);
+  }
+  return name.split(/(?=[A-Z])/).filter((s) => s.length > 0);
+}
+var init_morphology = __esm({
+  "src/lib/@core/text/morphology.ts"() {
+    init_esm_shims();
+  }
+});
+
+// src/lib/@core/text/index.ts
+var init_text3 = __esm({
+  "src/lib/@core/text/index.ts"() {
+    init_esm_shims();
+    init_morphology();
+  }
+});
+
 // src/lib/@core/utils/grouping.ts
 function groupBy(items, keyFn) {
   const grouped = /* @__PURE__ */ new Map();
@@ -16170,6 +16721,7 @@ var init_core2 = __esm({
     init_logger2();
     init_registry5();
     init_shell2();
+    init_text3();
     init_time();
     init_utils2();
   }
@@ -16527,7 +17079,8 @@ var init_alert = __esm({
     init_utils3();
     metadata = createFixerMetadata("alert", "Alert Statements", "lint", {
       description: "Remove alert() calls",
-      difficulty: "trivial",
+      difficulty: "risky",
+      // TODO: not production-ready
       cliFlag: "--fix-alert",
       tags: ["trivial", "safe-to-autofix", "debugging"]
     });
@@ -16613,7 +17166,8 @@ var init_any_type = __esm({
     init_utils3();
     metadata2 = createFixerMetadata("any-type", "Any Type Usage", "type-safety", {
       description: "Replace `any` with `unknown`",
-      difficulty: "safe",
+      difficulty: "risky",
+      // TODO: not production-ready
       cliFlag: "--fix-any",
       negateFlag: "--no-any",
       tags: ["safe", "type-safety"]
@@ -16900,7 +17454,8 @@ var init_backwards_compat2 = __esm({
       "backwards-compat",
       {
         description: "Delete deprecated shim files and update imports",
-        difficulty: "safe",
+        difficulty: "risky",
+        // TODO: not production-ready
         cliFlag: "--cleanup-deprecated",
         tags: ["safe", "refactoring", "cleanup"]
       }
@@ -16917,7 +17472,7 @@ var init_backwards_compat2 = __esm({
 });
 
 // src/commands/fix/fixers/complexity/index.ts
-function calculateComplexity(lines) {
+function calculateComplexity2(lines) {
   let complexity = 1;
   for (const line of lines) {
     for (const pattern of COMPLEXITY_PATTERNS) {
@@ -16941,7 +17496,7 @@ function findFunctionsWithComplexity(content, filePath) {
         name: f.name,
         startLine: f.startLine,
         endLine: f.endLine,
-        complexity: calculateComplexity(funcLines),
+        complexity: calculateComplexity2(funcLines),
         isAsync: f.isAsync
       };
     });
@@ -16978,7 +17533,7 @@ function findFunctionsRegex(content) {
     if (currentFunction && braceCount <= functionStartBrace && line.includes("}")) {
       currentFunction.endLine = i + 1;
       const funcLines = lines.slice(currentFunction.startLine - 1, currentFunction.endLine);
-      currentFunction.complexity = calculateComplexity(funcLines);
+      currentFunction.complexity = calculateComplexity2(funcLines);
       functions.push(currentFunction);
       currentFunction = null;
     }
@@ -17228,7 +17783,8 @@ var init_console = __esm({
     init_fixer();
     metadata5 = createFixerMetadata("console", "Console Statements", "lint", {
       description: "Remove console.log/warn/error statements",
-      difficulty: "trivial",
+      difficulty: "risky",
+      // TODO: not production-ready
       cliFlag: "--fix-console",
       negateFlag: "--no-console",
       tags: ["trivial", "safe-to-autofix", "debugging"]
@@ -17301,7 +17857,8 @@ var init_debugger = __esm({
     init_utils3();
     metadata6 = createFixerMetadata("debugger", "Debugger Statements", "lint", {
       description: "Remove debugger statements",
-      difficulty: "trivial",
+      difficulty: "risky",
+      // TODO: not production-ready
       cliFlag: "--fix-debugger",
       negateFlag: "--no-debugger",
       tags: ["trivial", "safe-to-autofix", "debugging"]
@@ -17375,7 +17932,8 @@ var init_duplicate = __esm({
     init_registry6();
     metadata7 = createFixerMetadata("duplicate", "Duplicate Functions", "lint", {
       description: "Merge duplicate functions from refactor analysis",
-      difficulty: "safe",
+      difficulty: "risky",
+      // TODO: not production-ready
       cliFlag: "--fix-duplicate",
       tags: ["safe", "refactoring", "deduplication"]
     });
@@ -17491,7 +18049,8 @@ var init_equality = __esm({
     init_fixer2();
     metadata8 = createFixerMetadata("equality", "Strict Equality", "type-safety", {
       description: "Replace == with === and != with !==",
-      difficulty: "safe",
+      difficulty: "risky",
+      // TODO: not production-ready
       cliFlag: "--fix-equality",
       negateFlag: "--no-equality",
       tags: ["safe", "type-safety", "eslint"]
@@ -17637,7 +18196,8 @@ var init_eval = __esm({
     init_fixer3();
     metadata9 = createFixerMetadata("eval", "Eval Security", "type-safety", {
       description: "Detect and fix eval() security risks",
-      difficulty: "safe",
+      difficulty: "risky",
+      // TODO: not production-ready
       cliFlag: "--fix-eval",
       negateFlag: "--no-eval",
       tags: ["security", "safe", "eval"]
@@ -17741,7 +18301,8 @@ var init_hardcoded_urls = __esm({
     init_registry6();
     metadata10 = createFixerMetadata("hardcoded-urls", "Hardcoded URLs", "hardcoded", {
       description: "Extract hardcoded URLs to constants",
-      difficulty: "safe",
+      difficulty: "risky",
+      // TODO: not production-ready
       cliFlag: "--fix-urls",
       tags: ["safe", "hardcoded", "refactoring"]
     });
@@ -20000,6 +20561,33 @@ var init_ast_transformer = __esm({
   "src/lib/@i18n/ast-transformer.ts"() {
     init_esm_shims();
     init_key_resolver();
+    /* @__PURE__ */ new Set([
+      SyntaxKind.ImportDeclaration,
+      SyntaxKind.ExportDeclaration,
+      SyntaxKind.ImportSpecifier,
+      SyntaxKind.ExportSpecifier
+    ]);
+    /* @__PURE__ */ new Set([
+      SyntaxKind.TypeLiteral,
+      SyntaxKind.TypeAliasDeclaration,
+      SyntaxKind.InterfaceDeclaration,
+      SyntaxKind.LiteralType
+    ]);
+    /* @__PURE__ */ new Set([
+      SyntaxKind.BinaryExpression,
+      SyntaxKind.ConditionalExpression
+    ]);
+    /* @__PURE__ */ new Map([
+      [SyntaxKind.JsxAttribute, "jsx-attribute"],
+      [SyntaxKind.JsxExpression, "jsx-expression"],
+      [SyntaxKind.PropertyAssignment, "object-property"],
+      [SyntaxKind.ShorthandPropertyAssignment, "object-property"],
+      [SyntaxKind.CallExpression, "function-argument"],
+      [SyntaxKind.ArrayLiteralExpression, "array-element"],
+      [SyntaxKind.VariableDeclaration, "variable"],
+      [SyntaxKind.TemplateSpan, "template-literal"],
+      [SyntaxKind.TemplateExpression, "template-literal"]
+    ]);
   }
 });
 
@@ -20390,7 +20978,8 @@ var init_i18n2 = __esm({
     init_replacer();
     metadata11 = createFixerMetadata("i18n", "I18n Hardcoded Strings", "i18n", {
       description: "Extract hardcoded Russian text to i18n translation keys",
-      difficulty: "safe",
+      difficulty: "risky",
+      // TODO: not production-ready
       cliFlag: "--fix-i18n",
       negateFlag: "--no-i18n",
       tags: ["i18n", "localization", "russian", "catalog-first"]
@@ -20739,7 +21328,8 @@ var init_magic_numbers = __esm({
     init_registry6();
     metadata13 = createFixerMetadata("magic-numbers", "Magic Numbers", "hardcoded", {
       description: "Extract magic numbers to named constants",
-      difficulty: "safe",
+      difficulty: "risky",
+      // TODO: not production-ready
       cliFlag: "--fix-magic-numbers",
       tags: ["safe", "hardcoded", "refactoring"]
     });
@@ -21098,7 +21688,8 @@ var init_ts_ignore = __esm({
     init_registry6();
     metadata16 = createFixerMetadata("ts-ignore", "TS-Ignore Comments", "type-safety", {
       description: "Remove @ts-ignore/@ts-nocheck comments",
-      difficulty: "safe",
+      difficulty: "risky",
+      // TODO: not production-ready
       cliFlag: "--fix-ts-ignore",
       tags: ["safe", "type-safety"]
     });
@@ -21336,7 +21927,8 @@ var init_unused_imports = __esm({
     init_fixer5();
     metadata17 = createFixerMetadata("unused-imports", "Unused Imports", "lint", {
       description: "Remove unused imports",
-      difficulty: "safe",
+      difficulty: "risky",
+      // TODO: not production-ready
       cliFlag: "--fix-imports",
       negateFlag: "--no-imports",
       tags: ["safe", "imports", "cleanup"]
@@ -26369,117 +26961,6 @@ var init_constants10 = __esm({
 });
 
 // src/commands/refactor/analyzers/core/duplicates/linguistic.ts
-function splitIntoSegments(name) {
-  if (name.includes("_")) {
-    return name.split("_").filter((s) => s.length > 0);
-  }
-  return name.split(/(?=[A-Z])/).filter((s) => s.length > 0);
-}
-function getVowelRatio2(str) {
-  const vowels = str.match(/[aeiou]/gi);
-  return vowels ? vowels.length / str.length : 0;
-}
-function isAbbreviation(name) {
-  if (name.length > 5) return false;
-  const vowelRatio = getVowelRatio2(name);
-  return vowelRatio < 0.2;
-}
-function estimateSyllables(word) {
-  const lowerWord = word.toLowerCase();
-  const vowelClusters = lowerWord.match(/[aeiouy]+/g);
-  if (!vowelClusters) return 1;
-  let count = vowelClusters.length;
-  if (lowerWord.endsWith("e") && count > 1) {
-    count--;
-  }
-  if (/le$/.test(lowerWord) && count > 1) {
-    const beforeLe = lowerWord.slice(-3, -2);
-    if (!/[aeiouy]/.test(beforeLe)) {
-      count++;
-    }
-  }
-  return Math.max(1, count);
-}
-function hasNounSuffix(word) {
-  const lowerWord = word.toLowerCase();
-  const nounPatterns = [
-    /er$/,
-    // handler, listener, helper, manager
-    /or$/,
-    // iterator, selector, constructor
-    /tion$/,
-    // function, action, collection
-    /sion$/,
-    // session, version
-    /ment$/,
-    // element, argument
-    /ness$/,
-    // readiness
-    /ity$/,
-    // utility, entity
-    /ure$/,
-    // structure, closure
-    /ance$/,
-    // instance
-    /ence$/,
-    // reference, sequence
-    /ing$/,
-    // string, thing (as nouns)
-    /ist$/,
-    // list (and -ist words)
-    /ata$/,
-    // data, metadata
-    /xt$/,
-    // context, text
-    /que$/,
-    // queue
-    /ay$/,
-    // array, display
-    /ch$/,
-    // cache, batch
-    /ck$/,
-    // callback, stack
-    /se$/,
-    // response, case
-    /te$/,
-    // state, template
-    /de$/,
-    // node, code
-    /ue$/,
-    // value, queue
-    /pe$/,
-    // type, pipe
-    /me$/,
-    // name, frame
-    /ms$/,
-    // params, items
-    /gs$/,
-    // args, flags
-    /ps$/,
-    // props
-    /ns$/,
-    // options, actions
-    /ts$/,
-    // results, events
-    /rd$/,
-    // record
-    /ry$/,
-    // factory, entry
-    /ol$/,
-    // control, protocol
-    /et$/,
-    // object, set
-    /ap$/,
-    // map
-    /lt$/,
-    // result
-    /ig$/,
-    // config
-    /fo$/
-    // info
-  ];
-  return nounPatterns.some((pattern) => pattern.test(lowerWord));
-}
 function hasVerbPrefix(word) {
   return extractVerbPrefix(word) !== null;
 }
@@ -26487,6 +26968,7 @@ var init_linguistic = __esm({
   "src/commands/refactor/analyzers/core/duplicates/linguistic.ts"() {
     init_esm_shims();
     init_detectors3();
+    init_text3();
   }
 });
 
@@ -26538,6 +27020,58 @@ function isSuffixOnlyName(name) {
   }
   return false;
 }
+function isCommonVariableName(name) {
+  const lowerName = name.toLowerCase();
+  const commonCollectionNames = [
+    // File system
+    /^(files|dirs|directories|folders|paths|sources)$/i,
+    // Array operations
+    /^(items|entries|elements|records|rows|lines|parts|chunks|segments|tokens)$/i,
+    // Results
+    /^(results|matches|hits|findings|issues|errors|warnings)$/i,
+    // Data
+    /^(keys|values|pairs|fields|props|attrs|args|params)$/i,
+    // Strings
+    /^(words|chars|names|labels|tags|ids)$/i
+  ];
+  for (const pattern of commonCollectionNames) {
+    if (pattern.test(lowerName)) {
+      return true;
+    }
+  }
+  const transformationPatterns = [
+    /^(sorted|filtered|mapped|reduced|grouped|merged|joined|split|parsed|formatted)$/i,
+    /^(processed|transformed|converted|normalized|validated|sanitized|cleaned)$/i,
+    /^(matched|found|selected|picked|extracted|collected|gathered)$/i,
+    /^(updated|modified|changed|fixed|patched|adjusted)$/i
+  ];
+  for (const pattern of transformationPatterns) {
+    if (pattern.test(lowerName)) {
+      return true;
+    }
+  }
+  const iterationPatterns = [
+    /^(line|path|file|dir|item|entry|key|value|name|index|offset)$/i,
+    /^(current|next|prev|first|last|head|tail)$/i,
+    /^(left|right|start|end|begin|stop)$/i
+  ];
+  for (const pattern of iterationPatterns) {
+    if (pattern.test(lowerName)) {
+      return true;
+    }
+  }
+  const tempPatterns = [
+    /^(temp|tmp|buf|buffer|acc|accumulator|memo|cache)$/i,
+    /^(output|input|source|target|dest|destination)$/i,
+    /^(raw|clean|final|base|root|parent|child)$/i
+  ];
+  for (const pattern of tempPatterns) {
+    if (pattern.test(lowerName)) {
+      return true;
+    }
+  }
+  return false;
+}
 function isPlaceholderName(name) {
   const lowerName = name.toLowerCase();
   if (/^(foo|bar|baz|qux|quux|corge|grault|garply|waldo|fred|plugh|xyzzy|thud)$/i.test(lowerName)) {
@@ -26662,6 +27196,7 @@ function isMeaningfulFunctionName(name) {
   if (isGenericFunctionName(name)) return false;
   if (name.length < 4) return false;
   if (isCommonCallbackPattern(name)) return false;
+  if (isCommonVariableName(name)) return false;
   const namedPattern = detectNamingPattern(name);
   if (namedPattern) {
     return true;
@@ -26700,13 +27235,16 @@ var init_name_detection = __esm({
 function extractFunctionsSwc(filePath, content) {
   const functions = [];
   try {
-    const ast = parseSync(content, {
-      syntax: "typescript",
-      tsx: filePath.endsWith(".tsx")
-    });
-    const lineOffsets = calculateLineOffsets2(content);
+    const { ast, lineOffsets, baseOffset } = parseFile(filePath, content);
     visitNode2(ast, (node, context) => {
-      const funcInfo = extractFunctionInfo(node, filePath, content, lineOffsets, context);
+      const funcInfo = extractFunctionInfo(
+        node,
+        filePath,
+        content,
+        lineOffsets,
+        context,
+        baseOffset
+      );
       if (funcInfo) {
         functions.push(funcInfo);
       }
@@ -26718,13 +27256,9 @@ function extractFunctionsSwc(filePath, content) {
 function extractTypesSwc(filePath, content) {
   const types = [];
   try {
-    const ast = parseSync(content, {
-      syntax: "typescript",
-      tsx: filePath.endsWith(".tsx")
-    });
-    const lineOffsets = calculateLineOffsets2(content);
+    const { ast, lineOffsets, baseOffset } = parseFile(filePath, content);
     visitNode2(ast, (node, context) => {
-      const typeInfo = extractTypeInfo(node, filePath, content, lineOffsets, context);
+      const typeInfo = extractTypeInfo(node, filePath, content, lineOffsets, context, baseOffset);
       if (typeInfo) {
         types.push(typeInfo);
       }
@@ -26733,23 +27267,37 @@ function extractTypesSwc(filePath, content) {
   }
   return types;
 }
-function extractTypeInfo(node, filePath, content, lineOffsets, context) {
+function extractTypeInfo(node, filePath, content, lineOffsets, context, baseOffset) {
   const nodeType = node.type;
   if (nodeType === "TsInterfaceDeclaration") {
-    return extractInterfaceInfo(node, filePath, content, lineOffsets, context.isExported);
+    return extractInterfaceInfo(
+      node,
+      filePath,
+      content,
+      lineOffsets,
+      context.isExported,
+      baseOffset
+    );
   }
   if (nodeType === "TsTypeAliasDeclaration") {
-    return extractTypeAliasInfo(node, filePath, content, lineOffsets, context.isExported);
+    return extractTypeAliasInfo(
+      node,
+      filePath,
+      content,
+      lineOffsets,
+      context.isExported,
+      baseOffset
+    );
   }
   return null;
 }
-function extractInterfaceInfo(node, filePath, content, lineOffsets, isExported) {
+function extractInterfaceInfo(node, filePath, content, lineOffsets, isExported, baseOffset) {
   const iface = node;
   const name = iface.id?.value;
   if (!name) return null;
   const span = iface.span;
-  const start = span?.start ?? 0;
-  const end = span?.end ?? content.length;
+  const start = Math.max(0, (span?.start ?? 1) - baseOffset - 1);
+  const end = Math.min(content.length, (span?.end ?? content.length + 1) - baseOffset - 1);
   const position = offsetToPosition2(start, lineOffsets);
   const fields = [];
   const fieldDefs = [];
@@ -26758,7 +27306,7 @@ function extractInterfaceInfo(node, filePath, content, lineOffsets, isExported)
       const propName = member.key.value;
       if (propName) {
         fields.push(propName);
-        const typeText = extractTypeText(member.typeAnnotation, content);
+        const typeText = extractTypeText(member.typeAnnotation, content, baseOffset);
         fieldDefs.push(`${propName}:${normalizeTypeText(typeText)}`);
       }
     } else if (member.type === "TsMethodSignature" && member.key) {
@@ -26783,15 +27331,15 @@ function extractInterfaceInfo(node, filePath, content, lineOffsets, isExported)
     definition
   };
 }
-function extractTypeAliasInfo(node, filePath, content, lineOffsets, isExported) {
+function extractTypeAliasInfo(node, filePath, content, lineOffsets, isExported, baseOffset) {
   const typeAlias = node;
   const name = typeAlias.id?.value;
   if (!name) return null;
   const span = typeAlias.span;
-  const start = span?.start ?? 0;
-  const end = span?.end ?? content.length;
+  const start = Math.max(0, (span?.start ?? 1) - baseOffset - 1);
+  const end = Math.min(content.length, (span?.end ?? content.length + 1) - baseOffset - 1);
   const position = offsetToPosition2(start, lineOffsets);
-  const typeText = extractTypeText(typeAlias.typeAnnotation, content);
+  const typeText = extractTypeText(typeAlias.typeAnnotation, content, baseOffset);
   const normalizedStructure = normalizeTypeText(typeText);
   const definition = content.slice(start, Math.min(end, start + 500));
   return {
@@ -26805,24 +27353,17 @@ function extractTypeAliasInfo(node, filePath, content, lineOffsets, isExported)
     definition
   };
 }
-function extractTypeText(typeAnnotation, content) {
+function extractTypeText(typeAnnotation, content, baseOffset) {
   if (!typeAnnotation || typeof typeAnnotation !== "object") return "unknown";
   const span = typeAnnotation.span;
   if (!span) return "unknown";
-  return content.slice(span.start, span.end);
+  const start = Math.max(0, span.start - baseOffset - 1);
+  const end = Math.min(content.length, span.end - baseOffset - 1);
+  return content.slice(start, end);
 }
 function normalizeTypeText(typeText) {
   return typeText.replace(/import\([^)]+\)\./g, "").replace(/\s+/g, "").split(/[|&]/).map((t) => t.trim()).sort().join("|");
 }
-function calculateLineOffsets2(content) {
-  const offsets = [0];
-  for (let i = 0; i < content.length; i++) {
-    if (content[i] === "\n") {
-      offsets.push(i + 1);
-    }
-  }
-  return offsets;
-}
 function offsetToPosition2(offset, lineOffsets) {
   let line = 0;
   for (let i = 0; i < lineOffsets.length; i++) {
@@ -26849,7 +27390,7 @@ function visitNode2(node, callback, context = { isExported: false }) {
       currentContext.variableName = decl.id.value;
     }
   }
-  if (nodeType === "ObjectExpression" || nodeType === "ArrayExpression") {
+  if (nodeType === "ObjectExpression" || nodeType === "ArrayExpression" || nodeType === "CallExpression") {
     currentContext.variableName = void 0;
   }
   callback(node, currentContext);
@@ -26866,17 +27407,33 @@ function visitNode2(node, callback, context = { isExported: false }) {
     }
   }
 }
-function extractFunctionInfo(node, filePath, content, lineOffsets, context) {
+function extractFunctionInfo(node, filePath, content, lineOffsets, context, baseOffset) {
   const nodeType = node.type;
   if (nodeType === "FunctionDeclaration") {
     const func = node;
     const name = func.identifier?.value ?? "anonymous";
-    return createFunctionInfo(func, name, filePath, content, lineOffsets, context.isExported);
+    return createFunctionInfo(
+      func,
+      name,
+      filePath,
+      content,
+      lineOffsets,
+      context.isExported,
+      baseOffset
+    );
   }
   if (nodeType === "FunctionExpression") {
     const func = node;
     const name = func.identifier?.value ?? "anonymous";
-    return createFunctionInfo(func, name, filePath, content, lineOffsets, context.isExported);
+    return createFunctionInfo(
+      func,
+      name,
+      filePath,
+      content,
+      lineOffsets,
+      context.isExported,
+      baseOffset
+    );
   }
   if (nodeType === "ArrowFunctionExpression") {
     const func = node;
@@ -26884,14 +27441,22 @@ function extractFunctionInfo(node, filePath, content, lineOffsets, context) {
     if (!name) {
       return null;
     }
-    return createFunctionInfo(func, name, filePath, content, lineOffsets, context.isExported);
+    return createFunctionInfo(
+      func,
+      name,
+      filePath,
+      content,
+      lineOffsets,
+      context.isExported,
+      baseOffset
+    );
   }
   return null;
 }
-function createFunctionInfo(func, name, filePath, content, lineOffsets, isExported) {
+function createFunctionInfo(func, name, filePath, content, lineOffsets, isExported, baseOffset) {
   const span = func.span;
-  const start = span?.start ?? 0;
-  const end = span?.end ?? content.length;
+  const start = Math.max(0, (span?.start ?? 1) - baseOffset - 1);
+  const end = Math.min(content.length, (span?.end ?? content.length + 1) - baseOffset - 1);
   const position = offsetToPosition2(start, lineOffsets);
   const bodyContent = content.slice(start, end);
   const bodyHash = crypto.createHash("md5").update(bodyContent).digest("hex");
@@ -26912,6 +27477,7 @@ function createFunctionInfo(func, name, filePath, content, lineOffsets, isExport
 var init_swc_parser = __esm({
   "src/commands/refactor/analyzers/core/swc-parser.ts"() {
     init_esm_shims();
+    init_parser();
   }
 });
 
@@ -27006,6 +27572,7 @@ function parseFileWithSwc(file, projectRoot, verbose) {
       const bodyText = content.slice(swcFunc.bodyStart, swcFunc.bodyEnd);
       const normalizedBodyText = normalizeBody(bodyText);
       const tokens = new Set(normalizedBodyText.split(/\s+/).filter((t) => t.length > 0));
+      const fpResult = generateFingerprint(bodyText);
       functions.push({
         name: swcFunc.name,
         file: relPath,
@@ -27016,7 +27583,10 @@ function parseFileWithSwc(file, projectRoot, verbose) {
         exported: swcFunc.isExported,
         bodyHash: swcFunc.bodyHash,
         normalizedBody: normalizedBodyText,
-        tokens
+        tokens,
+        // Fingerprint catches renamed clones (same structure, different identifiers)
+        ...fpResult.fingerprint && { fingerprint: fpResult.fingerprint },
+        ...fpResult.complexity > 0 && { complexity: fpResult.complexity }
       });
     }
   } catch (error) {
@@ -27198,6 +27768,7 @@ async function findDuplicates(targetPath, projectRoot, options = {}) {
     existing.push(func);
     byHash.set(func.bodyHash, existing);
   }
+  const reportedLocations = /* @__PURE__ */ new Set();
   for (const [, funcs] of byHash) {
     if (funcs.length < 2) continue;
     const { locations, uniqueFileCount } = deduplicateLocations(funcs);
@@ -27212,6 +27783,9 @@ async function findDuplicates(targetPath, projectRoot, options = {}) {
       if (!aExported && bExported) return 1;
       return a.localeCompare(b);
     });
+    for (const loc of locations) {
+      reportedLocations.add(`${loc.file}:${loc.line}`);
+    }
     duplicates.push({
       name: `[identical body] ${sortedNames.join(" / ")}`,
       locations,
@@ -27219,6 +27793,38 @@ async function findDuplicates(targetPath, projectRoot, options = {}) {
       recommendation: "merge"
     });
   }
+  const byFingerprint = /* @__PURE__ */ new Map();
+  for (const func of allFunctions) {
+    if (!isLargeEnoughForDuplication(func)) continue;
+    if (!func.fingerprint) continue;
+    const locKey = `${func.file}:${func.line}`;
+    if (reportedLocations.has(locKey)) continue;
+    const existing = byFingerprint.get(func.fingerprint) ?? [];
+    existing.push(func);
+    byFingerprint.set(func.fingerprint, existing);
+  }
+  for (const [, funcs] of byFingerprint) {
+    if (funcs.length < 2) continue;
+    const { locations, uniqueFileCount } = deduplicateLocations(funcs);
+    if (uniqueFileCount < 2) continue;
+    if (locations.length < 2) continue;
+    const uniqueNames = new Set(funcs.map((f) => f.name));
+    if (uniqueNames.size < 2) continue;
+    const sortedNames = [...uniqueNames].sort((a, b) => {
+      const aExported = funcs.some((f) => f.name === a && f.exported);
+      const bExported = funcs.some((f) => f.name === b && f.exported);
+      if (aExported && !bExported) return -1;
+      if (!aExported && bExported) return 1;
+      return a.localeCompare(b);
+    });
+    duplicates.push({
+      name: `[structural clone] ${sortedNames.join(" / ")}`,
+      locations,
+      similarity: 0.95,
+      // Slightly less than identical body to differentiate
+      recommendation: "merge"
+    });
+  }
   return duplicates;
 }
 async function quickScanDuplicates(targetPath) {
@@ -34648,7 +35254,7 @@ function formatMarkdown4(context) {
   return lines.join("\n");
 }
 var MAX_BODY_LENGTH;
-var init_text3 = __esm({
+var init_text4 = __esm({
   "src/commands/context/formatters/text.ts"() {
     init_esm_shims();
     init_format();
@@ -34661,7 +35267,7 @@ var init_formatters2 = __esm({
   "src/commands/context/formatters/index.ts"() {
     init_esm_shims();
     init_ai2();
-    init_text3();
+    init_text4();
   }
 });
 
@@ -39672,7 +40278,7 @@ function parseBiomeOutput(output) {
 function getBiomeVersion(projectRoot) {
   try {
     const biome = getBiomePath(projectRoot);
-    const result = execSync(`${biome} --version`, {
+    const result = execFileSync(biome, ["--version"], {
       cwd: projectRoot,
       encoding: "utf8",
       stdio: "pipe"
@@ -46515,11 +47121,11 @@ var init_duplicates_section = __esm({
           const sortedFunctions = [...data.functions].sort((a, b) => b.similarity - a.similarity);
           lines.push("    <!-- FUNCTION DUPLICATES - Consider merging or extracting -->");
           lines.push(`    <function-duplicates count="${data.functions.length}">`);
-          for (const dup of sortedFunctions.slice(0, 10)) {
+          for (const dup of sortedFunctions.slice(0, 100)) {
             formatFunctionDuplicate(lines, dup, "      ");
           }
-          if (sortedFunctions.length > 10) {
-            lines.push(`      <!-- +${sortedFunctions.length - 10} more function duplicates -->`);
+          if (sortedFunctions.length > 100) {
+            lines.push(`      <!-- +${sortedFunctions.length - 100} more function duplicates -->`);
           }
           lines.push("    </function-duplicates>");
         }
@@ -46527,11 +47133,11 @@ var init_duplicates_section = __esm({
           const sortedTypes = [...data.types].sort((a, b) => b.similarity - a.similarity);
           lines.push("    <!-- TYPE DUPLICATES - Consider consolidating -->");
           lines.push(`    <type-duplicates count="${data.types.length}">`);
-          for (const dup of sortedTypes.slice(0, 10)) {
+          for (const dup of sortedTypes.slice(0, 100)) {
             formatTypeDuplicate(lines, dup, "      ");
           }
-          if (sortedTypes.length > 10) {
-            lines.push(`      <!-- +${sortedTypes.length - 10} more type duplicates -->`);
+          if (sortedTypes.length > 100) {
+            lines.push(`      <!-- +${sortedTypes.length - 100} more type duplicates -->`);
           }
           lines.push("    </type-duplicates>");
         }
@@ -47730,7 +48336,7 @@ function formatMigrationPreview(plan) {
   lines.push("");
   return lines.join("\n");
 }
-var init_text4 = __esm({
+var init_text5 = __esm({
   "src/commands/refactor/output/text.ts"() {
     init_esm_shims();
   }
@@ -47814,7 +48420,7 @@ function formatRefactor(analysis, format2 = "text") {
       return formatRefactorJson2(analysis);
     }
     default: {
-      const { formatRefactorText: formatRefactorText2 } = (init_text4(), __toCommonJS(text_exports));
+      const { formatRefactorText: formatRefactorText2 } = (init_text5(), __toCommonJS(text_exports));
       return formatRefactorText2(analysis);
     }
   }
@@ -47824,7 +48430,7 @@ var init_output7 = __esm({
     init_esm_shims();
     init_ai_native();
     init_json2();
-    init_text4();
+    init_text5();
     init_xml3();
   }
 });
@@ -50026,86 +50632,117 @@ __export(setup_exports, {
   printDiagnostics: () => printDiagnostics,
   runSetup: () => runSetup
 });
-async function runSetup(ctx) {
-  const { logger: logger2, options, config } = ctx;
-  const projectRoot = config.projectRoot ?? process.cwd();
-  const { all, plugins, agents, mem, mcp, i18n, update: update2, check, dryRun, force } = options;
-  if (check) {
-    printDiagnostics();
-    return;
-  }
-  if (update2) {
-    await runUpdate({ dryRun: dryRun ?? false, logger: logger2 });
-    return;
-  }
-  if (i18n) {
-    logger2.info("\u{1F430} Krolik Setup\n");
-    if (dryRun) {
-      logger2.info("  [DRY RUN] No changes will be made\n");
-    }
-    await installI18nextCli(projectRoot, {
-      dryRun: dryRun ?? false,
-      force: force ?? false,
-      logger: logger2
+function handleCheck(ctx) {
+  if (!ctx.options.check) return false;
+  printDiagnostics();
+  return true;
+}
+async function handleUpdate2(ctx) {
+  if (!ctx.options.update) return false;
+  await runUpdate({ dryRun: ctx.options.dryRun ?? false, logger: ctx.logger });
+  return true;
+}
+async function handleI18n(ctx) {
+  if (!ctx.options.i18n) return false;
+  logHeader(ctx.logger, ctx.options.dryRun);
+  await installI18nextCli(ctx.projectRoot, {
+    dryRun: ctx.options.dryRun ?? false,
+    force: ctx.options.force ?? false,
+    logger: ctx.logger
+  });
+  return true;
+}
+async function handleMcp(ctx) {
+  if (!ctx.options.mcp) return false;
+  logHeader(ctx.logger, ctx.options.dryRun);
+  if (typeof ctx.options.mcp === "string") {
+    await installMcpServer(ctx.options.mcp, {
+      dryRun: ctx.options.dryRun ?? false,
+      logger: ctx.logger
+    });
+  } else {
+    await installAllMcpServers({
+      dryRun: ctx.options.dryRun ?? false,
+      logger: ctx.logger
     });
-    return;
-  }
-  if (mcp) {
-    logger2.info("\u{1F430} Krolik Setup\n");
-    if (dryRun) {
-      logger2.info("  [DRY RUN] No changes will be made\n");
-    }
-    if (typeof mcp === "string") {
-      await installMcpServer(mcp, { dryRun: dryRun ?? false, logger: logger2 });
-    } else {
-      await installAllMcpServers({ dryRun: dryRun ?? false, logger: logger2 });
-    }
-    return;
   }
+  return true;
+}
+function determineInstallTargets(options) {
+  const { all, plugins, agents, mem } = options;
   const noSelection = !all && !plugins && !agents && !mem;
-  const shouldInstallPlugins = all || plugins || mem || noSelection;
-  const shouldInstallAgents = all || agents || noSelection;
-  const shouldInstallMcp = all;
+  return {
+    shouldInstallPlugins: all || plugins || mem || noSelection,
+    shouldInstallAgents: all || agents || noSelection,
+    shouldInstallMcp: all ?? false
+  };
+}
+function logHeader(logger2, dryRun) {
   logger2.info("\u{1F430} Krolik Setup\n");
   if (dryRun) {
     logger2.info("  [DRY RUN] No changes will be made\n");
   }
-  if (!dryRun) {
-    ensureDirectories();
-  }
-  if (shouldInstallPlugins) {
-    logger2.info("\u{1F4E6} Installing Claude Code plugins...\n");
-    if (mem || all || noSelection) {
-      await installMcpPlugin("claude-mem", {
-        dryRun: dryRun ?? false,
-        force: force ?? false,
-        logger: logger2
-      });
-    }
-  }
-  if (shouldInstallAgents) {
-    logger2.info("\n\u{1F916} Installing AI agents...\n");
-    await installAgentsRepo({
-      dryRun: dryRun ?? false,
-      force: force ?? false,
-      logger: logger2
+}
+async function installPlugins(ctx, targets) {
+  if (!targets.shouldInstallPlugins) return;
+  const { all, mem } = ctx.options;
+  const noSelection = !all && !ctx.options.plugins && !ctx.options.agents && !mem;
+  ctx.logger.info("\u{1F4E6} Installing Claude Code plugins...\n");
+  if (mem || all || noSelection) {
+    await installMcpPlugin("claude-mem", {
+      dryRun: ctx.options.dryRun ?? false,
+      force: ctx.options.force ?? false,
+      logger: ctx.logger
     });
   }
-  if (shouldInstallMcp) {
-    logger2.info("\n");
-    await installAllMcpServers({ dryRun: dryRun ?? false, logger: logger2 });
-  }
+}
+async function installAgents(ctx, targets) {
+  if (!targets.shouldInstallAgents) return;
+  ctx.logger.info("\n\u{1F916} Installing AI agents...\n");
+  await installAgentsRepo({
+    dryRun: ctx.options.dryRun ?? false,
+    force: ctx.options.force ?? false,
+    logger: ctx.logger
+  });
+}
+async function installMcpServers(ctx, targets) {
+  if (!targets.shouldInstallMcp) return;
+  ctx.logger.info("\n");
+  await installAllMcpServers({
+    dryRun: ctx.options.dryRun ?? false,
+    logger: ctx.logger
+  });
+}
+function printSuccessMessage(logger2, targets) {
   logger2.info("\n\u2705 Setup complete!");
   logger2.info("\n\u{1F4DD} Next steps:");
   logger2.info("   1. Restart Claude Code to activate plugins");
-  if (shouldInstallPlugins) {
+  if (targets.shouldInstallPlugins) {
     logger2.info("   2. claude-mem Web UI: http://localhost:37777");
   }
-  if (shouldInstallAgents) {
+  if (targets.shouldInstallAgents) {
     logger2.info("   3. Run: krolik agent --list");
   }
   logger2.info("\n\u{1F4A1} Run: krolik setup --check  to see full status");
 }
+async function runSetup(ctx) {
+  const { logger: logger2, options, config } = ctx;
+  const projectRoot = config.projectRoot ?? process.cwd();
+  const setupCtx = { logger: logger2, projectRoot, options };
+  if (handleCheck(setupCtx)) return;
+  if (await handleUpdate2(setupCtx)) return;
+  if (await handleI18n(setupCtx)) return;
+  if (await handleMcp(setupCtx)) return;
+  const targets = determineInstallTargets(options);
+  logHeader(logger2, options.dryRun);
+  if (!options.dryRun) {
+    ensureDirectories();
+  }
+  await installPlugins(setupCtx, targets);
+  await installAgents(setupCtx, targets);
+  await installMcpServers(setupCtx, targets);
+  printSuccessMessage(logger2, targets);
+}
 async function runUpdate(opts) {
   const { dryRun, logger: logger2 } = opts;
   logger2.info("\u{1F504} Updating installed components...\n");