@justmpm/ai-tool 3.22.2 → 3.23.0

package/dist/{chunk-4AFO5NLB.js → chunk-4Z6PUAFR.js}

@@ -20,7 +20,7 @@ import {
   readConfig,
   recoveryHint,
   simplifyType
-} from "./chunk-WESIQAV2.js";
+} from "./chunk-WTRV35AO.js";
 
 // src/commands/describe.ts
 var STOPWORDS = /* @__PURE__ */ new Set([

package/dist/{chunk-WESIQAV2.js → chunk-WTRV35AO.js}

@@ -2002,6 +2002,24 @@ Use: ${hint("changes", ctx)} --file=<arquivo>
 `;
       }
     }
+    if (file.astDiff && file.astDiff.astApplied) {
+      out += `
+  AST ANALYSIS (${file.astDiff.changeType})
+`;
+      for (const category of file.astDiff.categories) {
+        if (category.entries.length === 0) continue;
+        const catIcon = formatAstCategoryIcon(category.name);
+        out += `    ${catIcon} ${category.name} (${category.entries.length})
+`;
+        for (const entry of category.entries) {
+          const prefix = entry.type === "added" ? "+" : entry.type === "removed" ? "-" : "~";
+          const detail = entry.detail ? ` - ${entry.detail}` : "";
+          const count = entry.count && entry.count > 1 ? ` (x${entry.count})` : "";
+          out += `      ${prefix} ${entry.name}${detail}${count}
+`;
+        }
+      }
+    }
   }
   if (newFiles.length > 0) {
     out += `
@@ -2077,6 +2095,24 @@ function formatKindIcon(kind) {
       return "+";
   }
 }
+function formatAstCategoryIcon(name) {
+  switch (name) {
+    case "JSX COMPONENTS":
+      return "<>";
+    case "PROPS":
+      return "{}";
+    case "DECLARATIONS":
+      return "fn";
+    case "IMPORTS":
+      return "->";
+    case "STRINGS":
+      return '""';
+    case "STRUCTURAL":
+      return "##";
+    default:
+      return "..";
+  }
+}
 var MAX_EXAMPLES_PER_SYMBOL = 3;
 function formatUsageExamples(examples, indent = 2) {
   const prefix = "   ".repeat(indent);
@@ -5286,7 +5322,7 @@ function enrichSuggestionsWithUsages(suggestions, index, cwd) {
 }
 
 // src/integrations/git.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
 import { execSync as execSync2 } from "child_process";
 function hasGitRepo(cwd) {
   return existsSync8(cwd + "/.git");
@@ -5349,14 +5385,37 @@ function getUntrackedFiles(cwd) {
 }
 function getFullDiffText(target, cwd, filePath) {
   if (!hasGitRepo(cwd)) return "";
+  const fileArg = filePath ? ` -- "${filePath}"` : "";
   try {
+    if (target === "all") {
+      let output2 = "";
+      try {
+        output2 += execSync2(`git diff --unified=10${fileArg} --cached`, {
+          cwd,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"],
+          maxBuffer: 10 * 1024 * 1024
+        });
+      } catch {
+      }
+      try {
+        output2 += execSync2(`git diff --unified=10${fileArg}`, {
+          cwd,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"],
+          maxBuffer: 10 * 1024 * 1024
+        });
+      } catch {
+      }
+      return output2;
+    }
     const diffArgs = getDiffArgs(target);
-    const fileArg = filePath ? ` -- "${filePath}"` : "";
     const cmd = `git diff --unified=10${fileArg} ${diffArgs.join(" ")}`;
     const output = execSync2(cmd, {
       cwd,
       encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      maxBuffer: 10 * 1024 * 1024
     });
     return output;
   } catch {
@@ -5638,7 +5697,7 @@ async function suggest(target, options = {}) {
 }
 
 // src/commands/context.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
 import { resolve as resolve3, join as join9 } from "path";
 import { SyntaxKind as SyntaxKind3 } from "ts-morph";
 
@@ -6102,7 +6161,7 @@ function findUsageInFile2(symbolName, filePath, maxExamples, cwd) {
     return examples;
   }
   try {
-    const content = readFileSync6(absolutePath, "utf-8");
+    const content = readFileSync7(absolutePath, "utf-8");
     const lines = content.split("\n");
     const usageRegex = new RegExp(`\\b${escapeRegex2(symbolName)}\\b`);
     for (let i = 0; i < lines.length; i++) {
@@ -7275,9 +7334,423 @@ function getTriggerIcon(trigger) {
 
 // src/commands/changes.ts
 import * as path from "path";
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import parseGitDiff from "parse-git-diff";
+
+// src/commands/ast-diff.ts
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { join as join11, extname as extname3 } from "path";
+import {
+  Project as Project3,
+  SyntaxKind as SyntaxKind4
+} from "ts-morph";
+var MAX_ENTRIES_PER_CATEGORY = 100;
+var TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx"]);
+var EMPTY_RESULT = (filePath) => ({
+  filePath,
+  changeType: "mixed",
+  stats: { added: 0, removed: 0 },
+  categories: []
+});
+function compareByName(oldItems, newItems, getName, getValue) {
+  const entries = [];
+  const oldMap = new Map(oldItems.map((item) => [getName(item), item]));
+  const newMap = new Map(newItems.map((item) => [getName(item), item]));
+  for (const [name] of oldMap) {
+    if (!newMap.has(name)) {
+      entries.push({ type: "removed", name });
+    }
+  }
+  for (const [name] of newMap) {
+    if (!oldMap.has(name)) {
+      entries.push({ type: "added", name });
+    }
+  }
+  if (getValue) {
+    for (const [name, oldItem] of oldMap) {
+      const newItem = newMap.get(name);
+      if (newItem && getValue(oldItem) !== getValue(newItem)) {
+        entries.push({ type: "modified", name });
+      }
+    }
+  }
+  return entries;
+}
+function classifyChangeType(stats, categories) {
+  const totalLines = stats.added + stats.removed;
+  const totalEntries = categories.reduce((sum, cat) => sum + cat.entries.length, 0);
+  const jsxCount = categories.find((c) => c.name === "JSX COMPONENTS")?.entries.length ?? 0;
+  const propsCount = categories.find((c) => c.name === "PROPS")?.entries.length ?? 0;
+  const declCount = categories.find((c) => c.name === "DECLARATIONS")?.entries.length ?? 0;
+  const addedEntries = categories.reduce(
+    (sum, cat) => sum + cat.entries.filter((e) => e.type === "added").length,
+    0
+  );
+  const modifiedEntries = categories.reduce(
+    (sum, cat) => sum + cat.entries.filter((e) => e.type === "modified").length,
+    0
+  );
+  if (totalLines > 100 && addedEntries < 3 && jsxCount + propsCount > 5) {
+    return "structural";
+  }
+  if (addedEntries > 3 || declCount > 2 && addedEntries > 1) {
+    return "new-feature";
+  }
+  if (totalLines < 50 && modifiedEntries > addedEntries && totalEntries < 20) {
+    return "correction";
+  }
+  return "mixed";
+}
+function extractAttributesFromElement(el) {
+  const props = /* @__PURE__ */ new Map();
+  const attrs = el.getDescendantsOfKind(SyntaxKind4.JsxAttribute);
+  for (const attr of attrs) {
+    const name = attr.getNameNode().getText();
+    const value = attr.getInitializer()?.getText() ?? "";
+    props.set(name, value);
+  }
+  return props;
+}
+function extractImportsFromFile(sourceFile) {
+  const imports = [];
+  for (const decl of sourceFile.getImportDeclarations()) {
+    const specifiers = [];
+    const defaultImport = decl.getDefaultImport();
+    if (defaultImport) {
+      specifiers.push(defaultImport.getText());
+    }
+    for (const named of decl.getNamedImports()) {
+      const alias = named.getAliasNode();
+      if (alias) {
+        specifiers.push(`${named.getName()} as ${alias.getText()}`);
+      } else {
+        specifiers.push(named.getName());
+      }
+    }
+    const namespace = decl.getNamespaceImport();
+    if (namespace) {
+      specifiers.push(`* as ${namespace.getText()}`);
+    }
+    imports.push({
+      module: decl.getModuleSpecifierValue(),
+      specifiers: specifiers.join(", ")
+    });
+  }
+  return imports;
+}
+function getOldContent(filePath, cwd, target) {
+  try {
+    const gitRef = target === "staged" ? `:${filePath}` : `HEAD:${filePath}`;
+    return execSync3(`git show ${gitRef}`, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+  } catch {
+    return null;
+  }
+}
+function countLineChanges(oldContent, newContent) {
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  const oldSet = new Set(oldLines);
+  const newSet = new Set(newLines);
+  const added = newLines.filter((line) => !oldSet.has(line)).length;
+  const removed = oldLines.filter((line) => !newSet.has(line)).length;
+  return { added, removed };
+}
+function compareComponentProps(oldProps, newProps, componentName) {
+  const entries = [];
+  for (const [name] of oldProps) {
+    if (!newProps.has(name)) {
+      entries.push({
+        type: "removed",
+        name: `${componentName}.${name}`,
+        detail: `${name}=${oldProps.get(name)}`
+      });
+    }
+  }
+  for (const [name, value] of newProps) {
+    if (!oldProps.has(name)) {
+      entries.push({
+        type: "added",
+        name: `${componentName}.${name}`,
+        detail: `${name}=${value}`
+      });
+    }
+  }
+  for (const [name, oldValue] of oldProps) {
+    const newValue = newProps.get(name);
+    if (newValue !== void 0 && oldValue !== newValue) {
+      entries.push({
+        type: "modified",
+        name: `${componentName}.${name}`,
+        detail: `${oldValue} -> ${newValue}`
+      });
+    }
+  }
+  return entries;
+}
+function detectStructuralChanges(oldContent, newContent, detectedChanges) {
+  const entries = [];
+  const lineStats = countLineChanges(oldContent, newContent);
+  const unexplainedLines = lineStats.added + lineStats.removed - detectedChanges * 2;
+  if (unexplainedLines > 20) {
+    entries.push({
+      type: "modified",
+      name: "layout/structure",
+      detail: `~${unexplainedLines} linhas nao explicadas por declaracoes individuais`
+    });
+  }
+  const stylePatterns = [/\bsx=\{/, /\bclassName=/, /\bstyle=\{/];
+  const newStyleMatches = stylePatterns.reduce(
+    (count, pattern) => count + (newContent.match(pattern)?.length ?? 0),
+    0
+  );
+  const oldStyleMatches = stylePatterns.reduce(
+    (count, pattern) => count + (oldContent.match(pattern)?.length ?? 0),
+    0
+  );
+  if (newStyleMatches !== oldStyleMatches) {
+    const diff = newStyleMatches - oldStyleMatches;
+    if (diff > 0) {
+      entries.push({
+        type: "added",
+        name: "inline-styles",
+        detail: `${diff} atributo(s) de estilo adicionado(s)`
+      });
+    } else {
+      entries.push({
+        type: "removed",
+        name: "inline-styles",
+        detail: `${Math.abs(diff)} atributo(s) de estilo removido(s)`
+      });
+    }
+  }
+  return entries;
+}
+async function astDiff(options) {
+  const { filePath, cwd, target } = options;
+  const fullPath = join11(cwd, filePath);
+  const ext = extname3(filePath).toLowerCase();
+  if (!TS_EXTENSIONS.has(ext)) {
+    return EMPTY_RESULT(filePath);
+  }
+  if (!existsSync10(fullPath)) {
+    return EMPTY_RESULT(filePath);
+  }
+  let newContent;
+  try {
+    newContent = readFileSync8(fullPath, "utf-8");
+  } catch {
+    return EMPTY_RESULT(filePath);
+  }
+  const oldContent = getOldContent(filePath, cwd, target);
+  if (oldContent === null) {
+    return {
+      filePath,
+      changeType: "new-feature",
+      stats: { added: newContent.split("\n").length, removed: 0 },
+      categories: []
+    };
+  }
+  if (oldContent === newContent) {
+    return EMPTY_RESULT(filePath);
+  }
+  try {
+    const project = new Project3({ useInMemoryFileSystem: true });
+    const oldFile = project.createSourceFile("old.tsx", oldContent);
+    const newFile = project.createSourceFile("new.tsx", newContent);
+    const categories = [];
+    categories.push(compareJsxComponents(oldFile, newFile));
+    categories.push(compareJsxProps(oldFile, newFile));
+    categories.push(compareDeclarations(oldFile, newFile));
+    categories.push(compareImports(oldFile, newFile));
+    categories.push(compareStringLiterals(oldFile, newFile));
+    const detectedChanges = categories.reduce((sum, cat) => sum + cat.entries.length, 0);
+    const structuralEntries = detectStructuralChanges(oldContent, newContent, detectedChanges);
+    if (structuralEntries.length > 0) {
+      categories.push({ name: "STRUCTURAL", entries: structuralEntries });
+    }
+    for (const cat of categories) {
+      if (cat.entries.length > MAX_ENTRIES_PER_CATEGORY) {
+        cat.entries = cat.entries.slice(0, MAX_ENTRIES_PER_CATEGORY);
+      }
+    }
+    const stats = countLineChanges(oldContent, newContent);
+    const changeType = classifyChangeType(stats, categories);
+    return { filePath, changeType, stats, categories };
+  } catch {
+    const stats = countLineChanges(oldContent, newContent);
+    return {
+      filePath,
+      changeType: "mixed",
+      stats,
+      categories: []
+    };
+  }
+}
+function compareJsxComponents(oldFile, newFile) {
+  const oldComponents = extractJsxComponentsFromSource(oldFile);
+  const newComponents = extractJsxComponentsFromSource(newFile);
+  const entries = [];
+  for (const [name] of oldComponents) {
+    if (!newComponents.has(name)) {
+      entries.push({ type: "removed", name });
+    }
+  }
+  for (const [name] of newComponents) {
+    if (!oldComponents.has(name)) {
+      entries.push({ type: "added", name });
+    }
+  }
+  for (const [name, oldInfo] of oldComponents) {
+    const newInfo = newComponents.get(name);
+    if (newInfo) {
+      const propChanges = compareComponentProps(oldInfo.props, newInfo.props, name);
+      const modifiedProps = propChanges.filter((p) => p.type === "modified");
+      if (modifiedProps.length > 0) {
+        entries.push({
+          type: "modified",
+          name,
+          detail: modifiedProps.map((p) => p.detail).join(", ")
+        });
+      }
+    }
+  }
+  return { name: "JSX COMPONENTS", entries };
+}
+function compareJsxProps(oldFile, newFile) {
+  const oldComponents = extractJsxComponentsFromSource(oldFile);
+  const newComponents = extractJsxComponentsFromSource(newFile);
+  const entries = [];
+  for (const [name, newInfo] of newComponents) {
+    const oldInfo = oldComponents.get(name);
+    if (oldInfo) {
+      const propChanges = compareComponentProps(oldInfo.props, newInfo.props, name);
+      const addedRemoved = propChanges.filter((p) => p.type !== "modified");
+      entries.push(...addedRemoved);
+    }
+  }
+  return { name: "PROPS", entries };
+}
+function compareDeclarations(oldFile, newFile) {
+  const oldDecls = extractDeclarationsFromSource(oldFile);
+  const newDecls = extractDeclarationsFromSource(newFile);
+  const entries = compareByName(
+    oldDecls,
+    newDecls,
+    (d) => d.name,
+    (d) => `${d.kind}:${d.name}`
+  );
+  for (const entry of entries) {
+    const isNew = entry.type === "added";
+    const source = isNew ? newDecls : oldDecls;
+    const decl = source.find((d) => d.name === entry.name);
+    if (decl) {
+      entry.detail = `(${decl.kind})`;
+    }
+  }
+  return { name: "DECLARATIONS", entries };
+}
+function compareImports(oldFile, newFile) {
+  const oldImports = extractImportsFromFile(oldFile);
+  const newImports = extractImportsFromFile(newFile);
+  const entries = compareByName(
+    oldImports,
+    newImports,
+    (i) => i.module,
+    (i) => i.specifiers
+  );
+  return { name: "IMPORTS", entries };
+}
+function compareStringLiterals(oldFile, newFile) {
+  const oldStrings = extractStringsFromSource(oldFile);
+  const newStrings = extractStringsFromSource(newFile);
+  const oldMap = /* @__PURE__ */ new Map();
+  for (const s of oldStrings) {
+    oldMap.set(s, (oldMap.get(s) ?? 0) + 1);
+  }
+  const newMap = /* @__PURE__ */ new Map();
+  for (const s of newStrings) {
+    newMap.set(s, (newMap.get(s) ?? 0) + 1);
+  }
+  const entries = [];
+  for (const [str, oldCount] of oldMap) {
+    const newCount = newMap.get(str) ?? 0;
+    if (newCount < oldCount) {
+      entries.push({
+        type: "removed",
+        name: `"${str}"`,
+        count: oldCount - newCount
+      });
+    }
+  }
+  for (const [str, newCount] of newMap) {
+    const oldCount = oldMap.get(str) ?? 0;
+    if (newCount > oldCount) {
+      entries.push({
+        type: "added",
+        name: `"${str}"`,
+        count: newCount - oldCount
+      });
+    }
+  }
+  return { name: "STRINGS", entries };
+}
+function extractJsxComponentsFromSource(sourceFile) {
+  const components = /* @__PURE__ */ new Map();
+  const selfClosing = sourceFile.getDescendantsOfKind(SyntaxKind4.JsxSelfClosingElement);
+  const opening = sourceFile.getDescendantsOfKind(SyntaxKind4.JsxOpeningElement);
+  for (const el of [...selfClosing, ...opening]) {
+    const name = el.getTagNameNode().getText();
+    const props = extractAttributesFromElement(el);
+    components.set(name, { name, props });
+  }
+  return components;
+}
+function extractDeclarationsFromSource(sourceFile) {
+  const declarations = [];
+  for (const fn of sourceFile.getFunctions()) {
+    const name = fn.getName();
+    if (name) {
+      declarations.push({ name, kind: "function" });
+    }
+  }
+  for (const v of sourceFile.getVariableDeclarations()) {
+    const name = v.getName();
+    if (name) {
+      declarations.push({ name, kind: "const" });
+    }
+  }
+  for (const iface of sourceFile.getInterfaces()) {
+    declarations.push({ name: iface.getName(), kind: "interface" });
+  }
+  for (const t of sourceFile.getTypeAliases()) {
+    declarations.push({ name: t.getName(), kind: "type" });
+  }
+  for (const e of sourceFile.getEnums()) {
+    declarations.push({ name: e.getName(), kind: "enum" });
+  }
+  return declarations;
+}
+function extractStringsFromSource(sourceFile) {
+  const literals = [];
+  const strings = sourceFile.getDescendantsOfKind(SyntaxKind4.StringLiteral);
+  for (const str of strings) {
+    const parent = str.getParent();
+    if (parent && (parent.getKind() === SyntaxKind4.ImportDeclaration || parent.getKind() === SyntaxKind4.ExportDeclaration)) {
+      continue;
+    }
+    literals.push(str.getLiteralValue());
+  }
+  return literals;
+}
+
+// src/commands/changes.ts
 var UNTRACKED_PREVIEW_LINES = 20;
+var AST_DIFF_THRESHOLD = 50;
+function extIsTsOrTsx(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  return ext === "ts" || ext === "tsx";
+}
 async function changes(options = {}) {
   const { cwd, format } = parseCommandOptions(options);
   const ctx = options.ctx || "cli";
@@ -7327,6 +7800,19 @@ async function changes(options = {}) {
         if (file.type === "DeletedFile") totalDeletedFiles++;
         totalAdded += added;
         totalRemoved += removed;
+        if (options.file && extIsTsOrTsx(filePath) && added + removed > AST_DIFF_THRESHOLD) {
+          try {
+            const astResult = await astDiff({
+              filePath,
+              cwd,
+              target
+            });
+            if (astResult.categories.length > 0) {
+              change.astDiff = { ...astResult, astApplied: true };
+            }
+          } catch {
+          }
+        }
         fileChanges.push(change);
       }
     }
@@ -7339,7 +7825,7 @@ async function changes(options = {}) {
       const fullFilePath = path.resolve(cwd, filePath);
       let lineCount = 0;
       try {
-        const content = readFileSync7(fullFilePath, "utf-8");
+        const content = readFileSync9(fullFilePath, "utf-8");
         const lines = content.split("\n");
         lineCount = lines.length;
         const syntheticDiff = lines.slice(0, UNTRACKED_PREVIEW_LINES).map((line) => `+${line}`).join("\n");
@@ -7941,8 +8427,8 @@ function extractGenericDiffPreview(diffText, filePath) {
 }
 
 // src/commands/find.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+import { join as join12 } from "path";
 
 // src/cache/gitHistory.ts
 var memoryCache = /* @__PURE__ */ new Map();
@@ -8137,11 +8623,11 @@ function searchInIndex(index, query, filterType, allowedFiles, cwd) {
     const baseCwd = cwd || "";
     for (const filePath of importFiles) {
       try {
-        const fullPath = baseCwd ? join11(baseCwd, filePath) : filePath;
-        if (!existsSync10(fullPath)) {
+        const fullPath = baseCwd ? join12(baseCwd, filePath) : filePath;
+        if (!existsSync11(fullPath)) {
           continue;
         }
-        const content = readFileSync8(fullPath, "utf-8");
+        const content = readFileSync10(fullPath, "utf-8");
         const lines = content.split("\n");
         usageFilesScanned++;
         const usageRegex = new RegExp(`\\b${escapeRegex3(query)}\\b`);

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
   depsInfo,
   depsSearch,
   describe
-} from "./chunk-4AFO5NLB.js";
+} from "./chunk-4Z6PUAFR.js";
 import {
   VERSION,
   area,
@@ -20,7 +20,7 @@ import {
   impact,
   map,
   suggest
-} from "./chunk-WESIQAV2.js";
+} from "./chunk-WTRV35AO.js";
 
 // src/cli.ts
 import { resolve } from "path";
@@ -131,7 +131,7 @@ async function main() {
     }
   }
   if (flags.mcp) {
-    const { startMcpServer } = await import("./server-XCWCN2RZ.js");
+    const { startMcpServer } = await import("./server-3HLEATUD.js");
     await startMcpServer();
     return;
   }

package/dist/index.d.ts

@@ -406,6 +406,8 @@ interface FileChange {
     renamedFrom?: string;
     /** Tipo de mudança do arquivo no git */
     fileType?: "added" | "deleted" | "changed" | "renamed";
+    /** Resultado AST diff quando disponível (só para --file com diff grande) */
+    astDiff?: AstDiffResult;
 }
 interface ChangesOptions extends CommandOptions {
     target?: "staged" | "unstaged" | "all";
@@ -452,6 +454,39 @@ interface StabilityInfo {
     /** Resumo de cambios recientes (máx 3) */
     lastChanges: string[];
 }
+/** Tipo de mudança predominante detectada pelo AST diff */
+type AstChangeType = "structural" | "new-feature" | "correction" | "mixed";
+/** Categoria de mudança AST */
+type AstDiffCategoryName = "JSX COMPONENTS" | "PROPS" | "DECLARATIONS" | "IMPORTS" | "STRINGS" | "STRUCTURAL";
+/** Entry individual do diff AST */
+interface AstDiffEntry {
+    type: "added" | "modified" | "removed";
+    name: string;
+    detail?: string;
+    line?: number;
+    /** Quantas ocorrências da mudança */
+    count?: number;
+}
+/** Categoria com entries agrupadas */
+interface AstDiffCategory {
+    name: AstDiffCategoryName;
+    entries: AstDiffEntry[];
+}
+/** Resultado do AST diff */
+interface AstDiffResult {
+    filePath: string;
+    /** Classificação do tipo de mudança predominante */
+    changeType: AstChangeType;
+    /** Total de linhas mudadas */
+    stats: {
+        added: number;
+        removed: number;
+    };
+    /** Entradas agrupadas por categoria */
+    categories: AstDiffCategory[];
+    /** Indica se AST diff foi aplicado (false = fallback para regex) */
+    astApplied: boolean;
+}
 
 /**
  * Comando MAP - Mapa do projeto usando Skott

package/dist/index.js

@@ -47,7 +47,7 @@ import {
   setFileDescription,
   suggest,
   writeConfig
-} from "./chunk-WESIQAV2.js";
+} from "./chunk-WTRV35AO.js";
 export {
   VERSION,
   area,

package/dist/{server-XCWCN2RZ.js → server-3HLEATUD.js}

@@ -3,7 +3,7 @@ import {
   depsInfo,
   depsSearch,
   describe
-} from "./chunk-4AFO5NLB.js";
+} from "./chunk-4Z6PUAFR.js";
 import {
   VERSION,
   area,
@@ -19,7 +19,7 @@ import {
   map,
   recoveryHint,
   suggest
-} from "./chunk-WESIQAV2.js";
+} from "./chunk-WTRV35AO.js";
 
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justmpm/ai-tool",
-  "version": "3.22.2",
+  "version": "3.23.0",
   "description": "Ferramenta de análise de dependências e impacto para projetos TypeScript/JavaScript. Usa Skott + Knip internamente. Inclui busca por descrição, integração Git e testes inteligentes.",
   "keywords": [
     "dependency-analysis",