@justmpm/ai-tool 1.0.5 → 1.1.0

package/dist/{chunk-VG3ZBPEH.js → chunk-XFXRWLQA.js}

@@ -196,6 +196,14 @@ var COMMAND_MAP = {
   functions: {
     cli: "ai-tool functions",
     mcp: "analyze__aitool_list_functions"
+  },
+  changes: {
+    cli: "ai-tool changes",
+    mcp: "analyze__aitool_changes"
+  },
+  changes_staged: {
+    cli: "ai-tool changes --staged",
+    mcp: "analyze__aitool_changes { target: 'staged' }"
   }
 };
 function hint(command, ctx, params) {
@@ -260,6 +268,11 @@ var NEXT_STEPS = {
     { command: "find", description: "buscar uma Cloud Function especifica" },
     { command: "impact", description: "ver impacto de modificar uma function" },
     { command: "context", description: "ver assinaturas de uma function" }
+  ],
+  changes: [
+    { command: "context", description: "ver assinaturas atuais de um arquivo modificado" },
+    { command: "impact", description: "ver impacto das mudancas em outros arquivos" },
+    { command: "suggest", description: "o que ler antes de editar um arquivo modificado" }
   ]
 };
 function nextSteps(command, ctx) {
@@ -1534,6 +1547,150 @@ function formatAreaContextText(result, ctx = "cli") {
   out += nextSteps("area_context", ctx);
   return out;
 }
+function formatChangesText(result, ctx = "cli") {
+  let out = "";
+  out += `CHANGES SUMMARY
+`;
+  if (result.files.length === 0) {
+    out += `No changes detected.
+`;
+    out += nextSteps("changes", ctx);
+    return out;
+  }
+  const targetLabel = result.target === "staged" ? "staged" : result.target === "unstaged" ? "unstaged" : "unstaged + staged";
+  out += `Files: ${result.summary.totalFiles} modified (${targetLabel}) | +${result.summary.totalAdded} -${result.summary.totalRemoved}
+`;
+  const kindCounts = {};
+  for (const file of result.files) {
+    for (const entry of file.changes) {
+      if (!kindCounts[entry.kind]) kindCounts[entry.kind] = { added: 0, modified: 0, removed: 0 };
+      kindCounts[entry.kind][entry.type]++;
+    }
+  }
+  const kindLabels = {
+    function: "Functions",
+    type: "Types",
+    import: "Imports",
+    const: "Consts",
+    component: "Components",
+    hook: "Hooks",
+    enum: "Enums",
+    class: "Classes",
+    config: "Config",
+    other: "Other"
+  };
+  const kindParts = [];
+  for (const [kind, counts] of Object.entries(kindCounts)) {
+    const parts = [];
+    if (counts.added > 0) parts.push(`+${counts.added}`);
+    if (counts.modified > 0) parts.push(`~${counts.modified}`);
+    if (counts.removed > 0) parts.push(`-${counts.removed}`);
+    if (parts.length > 0) kindParts.push(`${kindLabels[kind]}: ${parts.join(" ")}`);
+  }
+  if (kindParts.length > 0) {
+    out += `${kindParts.join(" | ")}
+`;
+  }
+  if (result.affectedAreas && result.affectedAreas.length > 0) {
+    out += `
+AFFECTED AREAS:
+`;
+    for (const area2 of result.affectedAreas) {
+      const desc = area2.description ? ` - ${area2.description}` : "";
+      out += `  ${area2.name} (${area2.fileCount} file${area2.fileCount === 1 ? "" : "s"})${desc}
+`;
+    }
+    out += "\n";
+  }
+  const semanticFiles = result.files.filter((f) => f.changes.length > 0);
+  const otherFiles = result.files.filter((f) => f.changes.length === 0);
+  const COMPACT_THRESHOLD = 10;
+  if (result.files.length > COMPACT_THRESHOLD) {
+    out += `
+COMPACT MODE: Too many files. Use --file=<path> for details.
+
+`;
+    out += `Modified files:
+`;
+    for (const file of result.files) {
+      const changeCount = file.changes.length;
+      out += `  ${file.path} (+${file.stats.added} -${file.stats.removed})`;
+      if (changeCount > 0) {
+        out += ` - ${changeCount} changes`;
+      } else {
+        out += ` - (no semantic changes)`;
+      }
+      out += `
+`;
+    }
+    out += `
+Use: ${hint("changes", ctx)} --file=<arquivo>
+`;
+    out += nextSteps("changes", ctx);
+    return out;
+  }
+  for (const file of semanticFiles) {
+    out += `
+--- ${file.path} (+${file.stats.added} -${file.stats.removed}) ---
+`;
+    const added = file.changes.filter((c) => c.type === "added");
+    const modified = file.changes.filter((c) => c.type === "modified");
+    const removed = file.changes.filter((c) => c.type === "removed");
+    if (added.length > 0) {
+      out += `  ADDED
+`;
+      for (const entry of added) {
+        const prefix = formatKindIcon(entry.kind);
+        const detail = entry.detail ? ` - ${entry.detail}` : "";
+        out += `    ${prefix} ${entry.name}${detail}
+`;
+      }
+    }
+    if (modified.length > 0) {
+      out += `  MODIFIED
+`;
+      for (const entry of modified) {
+        const detail = entry.detail ? ` - ${entry.detail}` : "";
+        out += `    ~ ${entry.name}${detail}
+`;
+      }
+    }
+    if (removed.length > 0) {
+      out += `  REMOVED
+`;
+      for (const entry of removed) {
+        out += `    - ${entry.name}
+`;
+      }
+    }
+  }
+  if (otherFiles.length > 0) {
+    out += `
+OTHER FILES (${otherFiles.length}): `;
+    out += otherFiles.map((f) => f.path.split("/").pop()).join(", ");
+    out += "\n";
+  }
+  out += nextSteps("changes", ctx);
+  return out;
+}
+function formatKindIcon(kind) {
+  switch (kind) {
+    case "function":
+    case "hook":
+    case "component":
+      return "+";
+    case "type":
+    case "enum":
+      return "+";
+    case "import":
+      return "+";
+    case "const":
+    case "class":
+      return "+";
+    default:
+      return "+";
+  }
+}
 
 // src/cache/index.ts
 import {
@@ -2669,6 +2826,68 @@ async function getCommitsForFile(filePath, cwd, limit = 10) {
     return [];
   }
 }
+function getDiffArgs(target) {
+  switch (target) {
+    case "staged":
+      return ["--cached"];
+    case "unstaged":
+      return [];
+    case "all":
+      return ["HEAD"];
+  }
+}
+function getChangedFiles(target, cwd) {
+  if (!hasGitRepo(cwd)) return [];
+  try {
+    const diffArgs = getDiffArgs(target);
+    const cmd = `git diff --name-only ${diffArgs.join(" ")}`;
+    const output = execSync2(cmd, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output.trim().split("\n").filter((line) => line.trim() !== "").map((line) => line.trim());
+  } catch {
+    return [];
+  }
+}
+function getDiffForFile(filePath, target, cwd) {
+  if (!hasGitRepo(cwd)) return "";
+  try {
+    const diffArgs = getDiffArgs(target);
+    const cmd = `git diff -U0 ${diffArgs.join(" ")} -- "${filePath}"`;
+    const output = execSync2(cmd, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output;
+  } catch {
+    return "";
+  }
+}
+function getDiffStats(filePath, target, cwd) {
+  if (!hasGitRepo(cwd)) return null;
+  try {
+    const diffArgs = getDiffArgs(target);
+    const cmd = `git diff --numstat ${diffArgs.join(" ")} -- "${filePath}"`;
+    const output = execSync2(cmd, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const line = output.trim().split("\n")[0];
+    if (!line) return null;
+    const parts = line.split("	");
+    if (parts.length < 2) return null;
+    const added = parts[0] === "-" ? 0 : parseInt(parts[0], 10);
+    const removed = parts[1] === "-" ? 0 : parseInt(parts[1], 10);
+    if (Number.isNaN(added) || Number.isNaN(removed)) return null;
+    return { added, removed };
+  } catch {
+    return null;
+  }
+}
 
 // src/commands/impact.ts
 async function impact(target, options = {}) {
@@ -3733,6 +3952,14 @@ function extractTriggerInfo(init, triggerName) {
 }
 
 // src/ts/cache.ts
+function extractJsDocDescription(node) {
+  const descriptions = node.getJsDocs().map((d) => d.getDescription().trim()).filter(Boolean);
+  return descriptions.length > 0 ? descriptions.join(" ") : void 0;
+}
+function extractVarStatementJsDoc(varStatement) {
+  const descriptions = varStatement.getJsDocs().map((d) => d.getDescription().trim()).filter(Boolean);
+  return descriptions.length > 0 ? descriptions.join(" ") : void 0;
+}
 function indexProject(cwd) {
   const resolvedCwd = cwd || process.cwd();
   const allFiles = getAllCodeFiles(resolvedCwd);
@@ -3810,6 +4037,7 @@ function indexProject(cwd) {
       const params = func.getParameters().map((p) => p.getName());
       const returnType = simplifyType(safeGetReturnType(func));
       const kind = inferSymbolKind(name, "function");
+      const description = extractJsDocDescription(func);
       const symbol = {
         name,
         file: filePath,
@@ -3818,7 +4046,8 @@ function indexProject(cwd) {
         signature: `${isExported ? "export " : ""}${func.isAsync() ? "async " : ""}function ${name}(${params.join(", ")})`,
         isExported,
         params,
-        returnType
+        returnType,
+        description
       };
       symbols.push(symbol);
       if (!symbolsByName[name]) {
@@ -3846,6 +4075,7 @@ function indexProject(cwd) {
           const params = funcLike.getParameters().map((p) => p.getName());
           const returnType = simplifyType(safeGetReturnType(funcLike));
           const kind = inferSymbolKind(name, "function");
+          const description = extractVarStatementJsDoc(varStatement);
           const symbol = {
             name,
             file: filePath,
@@ -3854,7 +4084,8 @@ function indexProject(cwd) {
             signature: `${isExported ? "export " : ""}const ${name} = (${params.join(", ")}) => ...`,
             isExported,
             params,
-            returnType
+            returnType,
+            description
           };
           symbols.push(symbol);
           if (!symbolsByName[name]) {
@@ -3887,6 +4118,7 @@ function indexProject(cwd) {
           }
           if (triggerName && FIREBASE_V2_TRIGGERS.has(triggerName)) {
             const triggerInfo = extractTriggerInfo(init, triggerName);
+            const description = extractVarStatementJsDoc(varStatement);
             const symbol = {
               name,
               file: filePath,
@@ -3894,7 +4126,8 @@ function indexProject(cwd) {
               kind: "trigger",
               signature: `${isExported ? "export " : ""}const ${name} = ${triggerName}(...)`,
               isExported,
-              triggerInfo
+              triggerInfo,
+              description
             };
             symbols.push(symbol);
             if (!symbolsByName[name]) {
@@ -3907,13 +4140,15 @@ function indexProject(cwd) {
           } else {
             const declKind = varStatement.getDeclarationKind();
             if (declKind.toString() === "const") {
+              const description = extractVarStatementJsDoc(varStatement);
               const symbol = {
                 name,
                 file: filePath,
                 line: varDecl.getStartLineNumber(),
                 kind: "const",
                 signature: `${isExported ? "export " : ""}const ${name} = ${truncateCode(init.getText(), 40)}`,
-                isExported
+                isExported,
+                description
               };
               symbols.push(symbol);
               if (!symbolsByName[name]) {
@@ -3928,13 +4163,15 @@ function indexProject(cwd) {
         } else {
           const declKind = varStatement.getDeclarationKind();
           if (declKind.toString() !== "const") continue;
+          const description = extractVarStatementJsDoc(varStatement);
           const symbol = {
             name,
             file: filePath,
             line: varDecl.getStartLineNumber(),
             kind: "const",
             signature: `${isExported ? "export " : ""}const ${name} = ${truncateCode(init.getText(), 40)}`,
-            isExported
+            isExported,
+            description
           };
           symbols.push(symbol);
           if (!symbolsByName[name]) {
@@ -3950,6 +4187,7 @@ function indexProject(cwd) {
     for (const iface of sourceFile.getInterfaces()) {
       const name = iface.getName();
       const isExported = iface.isExported();
+      const description = extractJsDocDescription(iface);
       const symbol = {
         name,
         file: filePath,
@@ -3957,7 +4195,8 @@ function indexProject(cwd) {
         kind: "interface",
         signature: `${isExported ? "export " : ""}interface ${name}`,
         isExported,
-        definition: formatInterfaceDefinition(iface)
+        definition: formatInterfaceDefinition(iface),
+        description
       };
       symbols.push(symbol);
       if (!symbolsByName[name]) {
@@ -3971,6 +4210,7 @@ function indexProject(cwd) {
     for (const typeAlias of sourceFile.getTypeAliases()) {
       const name = typeAlias.getName();
       const isExported = typeAlias.isExported();
+      const description = extractJsDocDescription(typeAlias);
       const symbol = {
         name,
         file: filePath,
@@ -3978,7 +4218,8 @@ function indexProject(cwd) {
         kind: "type",
         signature: `${isExported ? "export " : ""}type ${name}`,
         isExported,
-        definition: simplifyType(safeGetTypeText(() => typeAlias.getType()))
+        definition: simplifyType(safeGetTypeText(() => typeAlias.getType())),
+        description
       };
       symbols.push(symbol);
       if (!symbolsByName[name]) {
@@ -3992,6 +4233,7 @@ function indexProject(cwd) {
     for (const enumDecl of sourceFile.getEnums()) {
       const name = enumDecl.getName();
       const isExported = enumDecl.isExported();
+      const description = extractJsDocDescription(enumDecl);
       const symbol = {
         name,
         file: filePath,
@@ -3999,7 +4241,8 @@ function indexProject(cwd) {
         kind: "enum",
         signature: `${isExported ? "export " : ""}enum ${name}`,
         isExported,
-        definition: enumDecl.getMembers().map((m) => m.getName()).join(" | ")
+        definition: enumDecl.getMembers().map((m) => m.getName()).join(" | "),
+        description
       };
       symbols.push(symbol);
       if (!symbolsByName[name]) {
@@ -5270,6 +5513,478 @@ function getTriggerIcon(trigger) {
   return "\u26A1";
 }
 
+// src/commands/changes.ts
+async function changes(options = {}) {
+  const { cwd, format } = parseCommandOptions(options);
+  const ctx = options.ctx || "cli";
+  const target = options.target || "all";
+  if (!hasGitRepo(cwd)) {
+    throw new Error("Nao e um repositorio Git. Execute este comando em um projeto com Git.");
+  }
+  try {
+    const changedFiles = getChangedFiles(target, cwd);
+    if (changedFiles.length === 0) {
+      const result2 = {
+        version: "1.0.0",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        target,
+        summary: {
+          totalFiles: 0,
+          totalAdded: 0,
+          totalRemoved: 0
+        },
+        files: []
+      };
+      return formatOutput(result2, format, (r) => formatChangesText(r, ctx));
+    }
+    const DEFAULT_IGNORE = [".analyze/"];
+    const filesFiltered = changedFiles.filter(
+      (f) => !DEFAULT_IGNORE.some((pattern) => f.includes(pattern))
+    );
+    const filesToProcess = options.file ? filesFiltered.filter(
+      (f) => f.toLowerCase().includes(options.file.toLowerCase())
+    ) : filesFiltered;
+    const fileChanges = [];
+    let totalAdded = 0;
+    let totalRemoved = 0;
+    let symbolsIndex = null;
+    for (const filePath of filesToProcess) {
+      const stats = getDiffStats(filePath, target, cwd);
+      const diffText = getDiffForFile(filePath, target, cwd);
+      const entries = classifyChanges(diffText);
+      if (stats) {
+        totalAdded += stats.added;
+        totalRemoved += stats.removed;
+      }
+      const enrichedEntries = enrichWithJsDoc(entries, filePath, cwd, symbolsIndex);
+      fileChanges.push({
+        path: filePath,
+        category: detectCategory(filePath),
+        stats: stats || { added: 0, removed: 0 },
+        changes: enrichedEntries
+      });
+    }
+    const affectedAreas = buildAffectedAreas(fileChanges, cwd);
+    const totalForSummary = options.file ? fileChanges.length : changedFiles.length;
+    const result = {
+      version: "1.0.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      target,
+      summary: {
+        totalFiles: totalForSummary,
+        totalAdded,
+        totalRemoved
+      },
+      files: fileChanges,
+      affectedAreas: affectedAreas.length > 0 ? affectedAreas : void 0
+    };
+    return formatOutput(result, format, (r) => formatChangesText(r, ctx));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Erro ao executar changes: ${message}`);
+  }
+}
+function enrichWithJsDoc(entries, filePath, cwd, cachedIndex) {
+  const needsEnrichment = (e) => e.kind !== "import" && e.kind !== "config" && !e.detail;
+  if (!entries.some(needsEnrichment)) {
+    return entries;
+  }
+  let index = cachedIndex;
+  if (!index) {
+    try {
+      if (isCacheValid(cwd)) {
+        index = getCachedSymbolsIndex(cwd);
+      }
+      if (!index) {
+        index = indexProject(cwd);
+      }
+    } catch {
+      return entries;
+    }
+  }
+  return entries.map((entry) => {
+    if (!needsEnrichment(entry)) return entry;
+    const cached = index.symbolsByName[entry.name];
+    if (cached) {
+      const match = cached.find((s) => s.file === filePath);
+      if (match?.description) {
+        return { ...entry, detail: match.description };
+      }
+    }
+    return entry;
+  });
+}
+function buildAffectedAreas(fileChanges, cwd) {
+  if (!configExists(cwd)) return [];
+  try {
+    const areaConfig = readConfig(cwd);
+    const areaMap = /* @__PURE__ */ new Map();
+    const ungroupedFiles = [];
+    for (const file of fileChanges) {
+      const areas2 = detectFileAreas(file.path, areaConfig);
+      if (areas2.length > 0) {
+        const areaId = areas2[0];
+        if (!areaMap.has(areaId)) {
+          areaMap.set(areaId, {
+            name: getAreaName(areaId, areaConfig),
+            description: getAreaDescription(areaId, areaConfig),
+            files: []
+          });
+        }
+        areaMap.get(areaId).files.push(file.path);
+      } else {
+        ungroupedFiles.push(file.path);
+      }
+    }
+    const affectedAreas = [];
+    for (const [id, info] of areaMap) {
+      affectedAreas.push({
+        id,
+        name: info.name,
+        description: info.description,
+        fileCount: info.files.length,
+        files: info.files
+      });
+    }
+    if (ungroupedFiles.length > 0) {
+      affectedAreas.push({
+        id: "ungrouped",
+        name: "ungrouped",
+        fileCount: ungroupedFiles.length,
+        files: ungroupedFiles
+      });
+    }
+    return affectedAreas;
+  } catch {
+    return [];
+  }
+}
+function classifyChanges(diffText) {
+  if (!diffText.trim()) return [];
+  const lines = diffText.split("\n");
+  const entries = [];
+  const relevantLines = [];
+  let lineNumber = 0;
+  for (const rawLine of lines) {
+    lineNumber++;
+    if (rawLine.startsWith("@@") || rawLine.startsWith("diff ") || rawLine.startsWith("index ") || rawLine.startsWith("---") || rawLine.startsWith("+++")) {
+      continue;
+    }
+    if (rawLine.trim() === "") continue;
+    if (rawLine.startsWith("+") || rawLine.startsWith("-")) {
+      const content = rawLine.slice(1).trim();
+      if (content.startsWith("//") || content.startsWith("*") || content.startsWith("/*")) {
+        continue;
+      }
+    }
+    if (rawLine.startsWith("+") || rawLine.startsWith("-")) {
+      const content = rawLine.slice(1).trim();
+      if (/^[})\];,]$/.test(content)) {
+        continue;
+      }
+    }
+    if (rawLine.startsWith("+")) {
+      relevantLines.push({ prefix: "add", content: rawLine.slice(1), line: lineNumber });
+    } else if (rawLine.startsWith("-")) {
+      relevantLines.push({ prefix: "remove", content: rawLine.slice(1), line: lineNumber });
+    }
+  }
+  const processed = /* @__PURE__ */ new Set();
+  const removedSymbols = /* @__PURE__ */ new Map();
+  const addedSymbols = /* @__PURE__ */ new Map();
+  for (let i = 0; i < relevantLines.length; i++) {
+    const line = relevantLines[i];
+    const multiReexport = extractMultipleReexports(line.content);
+    if (multiReexport) {
+      for (const name of multiReexport.names) {
+        if (line.prefix === "remove") {
+          if (!removedSymbols.has(name)) {
+            removedSymbols.set(name, line);
+          }
+        } else {
+          if (!addedSymbols.has(name)) {
+            addedSymbols.set(name, line);
+          }
+        }
+      }
+      continue;
+    }
+    const info = extractSymbolInfo(line.content);
+    if (info && info.name && isRelevantSymbol(info)) {
+      if (line.prefix === "remove") {
+        if (!removedSymbols.has(info.name)) {
+          removedSymbols.set(info.name, line);
+        }
+      } else {
+        if (!addedSymbols.has(info.name)) {
+          addedSymbols.set(info.name, line);
+        }
+      }
+    }
+  }
+  const modifiedNames = /* @__PURE__ */ new Set();
+  for (const name of removedSymbols.keys()) {
+    if (addedSymbols.has(name)) {
+      modifiedNames.add(name);
+    }
+  }
+  for (const [name, line] of removedSymbols) {
+    if (!modifiedNames.has(name)) {
+      const info = extractSymbolInfo(line.content);
+      if (info) {
+        processed.add(line.line);
+        entries.push({
+          kind: info.kind,
+          type: "removed",
+          name
+        });
+      }
+    }
+  }
+  for (const name of modifiedNames) {
+    const removedLine = removedSymbols.get(name);
+    const addedLine = addedSymbols.get(name);
+    const removedInfo = extractSymbolInfo(removedLine.content);
+    const addedInfo = extractSymbolInfo(addedLine.content);
+    if (removedInfo && addedInfo) {
+      processed.add(removedLine.line);
+      processed.add(addedLine.line);
+      const detail = generateModifiedDetail(removedLine.content, addedLine.content, addedInfo.kind);
+      entries.push({
+        kind: addedInfo.kind,
+        type: "modified",
+        name,
+        detail
+      });
+    }
+  }
+  for (const [name, line] of addedSymbols) {
+    if (!modifiedNames.has(name) && !processed.has(line.line)) {
+      const info = extractSymbolInfo(line.content);
+      if (info) {
+        processed.add(line.line);
+        entries.push({
+          kind: info.kind,
+          type: "added",
+          name
+        });
+      }
+    }
+  }
+  return entries;
+}
+var COMMON_PROPERTIES = /* @__PURE__ */ new Set([
+  "inputSchema",
+  "outputSchema",
+  "annotations",
+  "content",
+  "isError",
+  "description",
+  "title",
+  "name",
+  "version",
+  "type",
+  "properties",
+  "required",
+  "stats",
+  "summary",
+  "totalFiles",
+  "totalAdded",
+  "totalRemoved",
+  "options",
+  "params",
+  "args",
+  "config",
+  "data",
+  "result",
+  "error",
+  "format",
+  "cwd",
+  "target",
+  "file",
+  "cache",
+  "ctx",
+  "value",
+  "label",
+  "default",
+  "enum",
+  "items",
+  "stdio",
+  "encoding",
+  "actions",
+  "reducer",
+  "payload",
+  "state",
+  "children",
+  "className",
+  "sx",
+  "theme"
+]);
+function extractMultipleReexports(content) {
+  const trimmed = content.trim();
+  const typeMatch = trimmed.match(
+    /export\s+type\s+\{([^}]+)\}\s*from\s+['"][^'"]+['"]/
+  );
+  if (typeMatch) {
+    const names = typeMatch[1].split(",").map((n) => n.trim()).filter(Boolean);
+    return names.length > 1 ? { names, kind: "type" } : null;
+  }
+  const valueMatch = trimmed.match(
+    /export\s+\{([^}]+)\}\s*from\s+['"][^'"]+['"]/
+  );
+  if (valueMatch) {
+    const names = valueMatch[1].split(",").map((n) => n.trim()).filter(Boolean);
+    return names.length > 1 ? { names, kind: "import" } : null;
+  }
+  const localTypeMatch = trimmed.match(/export\s+type\s+\{([^}]+)\}/);
+  if (localTypeMatch) {
+    const names = localTypeMatch[1].split(",").map((n) => n.trim()).filter(Boolean);
+    return names.length > 1 ? { names, kind: "type" } : null;
+  }
+  return null;
+}
+function isRelevantSymbol(info) {
+  if (info.kind === "import" || info.kind === "type" || info.kind === "enum" || info.kind === "class" || info.kind === "config") {
+    return true;
+  }
+  if (info.kind === "function" || info.kind === "hook" || info.kind === "component") {
+    return true;
+  }
+  if (info.isExported) {
+    return true;
+  }
+  if (info.kind === "const") {
+    if (/^[A-Z_]+$/.test(info.name) && info.name.length > 2) {
+      return true;
+    }
+    if (/^[A-Z]/.test(info.name)) {
+      return true;
+    }
+    if (info.name.startsWith("use") && info.name.length > 3) {
+      return true;
+    }
+    return false;
+  }
+  return true;
+}
+function extractSymbolInfo(content) {
+  const trimmed = content.trim();
+  const importMatch = trimmed.match(/import\s+.*from\s+['"](.+)['"]/);
+  if (importMatch) {
+    return { name: importMatch[1], kind: "import", isExported: false };
+  }
+  const reExportTypeMatch = trimmed.match(/export\s+type\s+\{([^}]+)\}\s*from\s+['"]([^'"]+)['"]/);
+  if (reExportTypeMatch) {
+    const names = reExportTypeMatch[1].split(",").map((n) => n.trim()).filter(Boolean);
+    const firstName = names[0] ?? reExportTypeMatch[2];
+    const fromPath = reExportTypeMatch[2];
+    return { name: `${firstName} (from ${fromPath})`, kind: "type", isExported: true };
+  }
+  const reExportMatch = trimmed.match(/export\s+\{([^}]+)\}\s*from\s+['"]([^'"]+)['"]/);
+  if (reExportMatch) {
+    const names = reExportMatch[1].split(",").map((n) => n.trim()).filter(Boolean);
+    const firstName = names[0] ?? reExportMatch[2];
+    const fromPath = reExportMatch[2];
+    return { name: `${firstName} (from ${fromPath})`, kind: "import", isExported: true };
+  }
+  const funcMatch = trimmed.match(/(?:export\s+)?function\s+(\w+)/);
+  if (funcMatch) {
+    const isExported = /^export\s+/.test(trimmed);
+    const kind = detectFunctionKind(funcMatch[1], trimmed);
+    return { name: funcMatch[1], kind, isExported };
+  }
+  const constMatch = trimmed.match(/(?:export\s+)?const\s+(\w+)\s*[=:(]/);
+  if (constMatch) {
+    const isExported = /^export\s+/.test(trimmed);
+    const kind = detectConstKind(constMatch[1]);
+    return { name: constMatch[1], kind, isExported };
+  }
+  const typeMatch = trimmed.match(/(?:export\s+)?(interface|type|enum)\s+(\w+)/);
+  if (typeMatch) {
+    const isExported = /^export\s+/.test(trimmed);
+    const kindMap = {
+      interface: "type",
+      type: "type",
+      enum: "enum"
+    };
+    return { name: typeMatch[2], kind: kindMap[typeMatch[1]], isExported };
+  }
+  const classMatch = trimmed.match(/(?:export\s+)?class\s+(\w+)/);
+  if (classMatch) {
+    const isExported = /^export\s+/.test(trimmed);
+    return { name: classMatch[1], kind: "class", isExported };
+  }
+  const entryMatchFull = content.match(/^(\s{2,})(\w[\w-]*)\s*:\s*[{[]/);
+  if (entryMatchFull && !COMMON_PROPERTIES.has(entryMatchFull[2])) {
+    return { name: entryMatchFull[2], kind: "config", isExported: false };
+  }
+  return null;
+}
+function detectFunctionKind(name, content) {
+  if (name.startsWith("use") && name.length > 3) {
+    return "hook";
+  }
+  if (/^[A-Z]/.test(name) && content.includes("(")) {
+    return "component";
+  }
+  return "function";
+}
+function detectConstKind(name) {
+  if (name.startsWith("use") && name.length > 3) {
+    return "hook";
+  }
+  if (/^[A-Z][A-Z_]+$/.test(name) && name.length > 1) {
+    return "const";
+  }
+  if (/^[A-Z]/.test(name)) {
+    return "component";
+  }
+  return "const";
+}
+function generateModifiedDetail(oldLine, newLine, kind) {
+  const details = [];
+  const oldReturnMatch = oldLine.match(/:\s*(Promise<)?([A-Z]\w+)(\)?>?)\s*$/);
+  const newReturnMatch = newLine.match(/:\s*(Promise<)?([A-Z]\w+)(\)?>?)\s*$/);
+  if (oldReturnMatch && newReturnMatch && oldReturnMatch[0] !== newReturnMatch[0]) {
+    const oldType = oldReturnMatch[0].trim();
+    const newType = newReturnMatch[0].trim();
+    details.push(`return type: ${oldType} -> ${newType}`);
+  }
+  const oldParams = extractParams2(oldLine);
+  const newParams = extractParams2(newLine);
+  if (oldParams !== newParams && oldParams && newParams) {
+    if (oldParams.split(",").length !== newParams.split(",").length) {
+      details.push("params changed");
+    }
+  }
+  const wasAsync = /^\s*async\s+/.test(oldLine) || /export\s+async\s+/.test(oldLine);
+  const isAsync = /^\s*async\s+/.test(newLine) || /export\s+async\s+/.test(newLine);
+  if (!wasAsync && isAsync) {
+    details.push("now async");
+  } else if (wasAsync && !isAsync) {
+    details.push("no longer async");
+  }
+  if (kind === "type") {
+    const oldBody = extractTypeBody(oldLine);
+    const newBody = extractTypeBody(newLine);
+    if (oldBody !== newBody) {
+      details.push("definition changed");
+    }
+  }
+  if (details.length === 0) {
+    details.push("implementation changed");
+  }
+  return details.join(", ");
+}
+function extractParams2(line) {
+  const match = line.match(/\(([^)]*)\)/);
+  return match ? match[1].trim() : null;
+}
+function extractTypeBody(line) {
+  const eqIndex = line.indexOf("=");
+  return eqIndex >= 0 ? line.slice(eqIndex + 1).trim() : line.trim();
+}
+
 // src/commands/find.ts
 import { readFileSync as readFileSync4 } from "fs";
 import { join as join11 } from "path";
@@ -5598,5 +6313,6 @@ export {
   areasInit,
   find,
   functions,
+  changes,
   VERSION
 };

package/dist/{chunk-PJDTFEHK.js → chunk-XVOQNZHC.js}

@@ -13,7 +13,7 @@ import {
   parseCommandOptions,
   readConfig,
   updateCacheMeta
-} from "./chunk-VG3ZBPEH.js";
+} from "./chunk-XFXRWLQA.js";
 
 // src/commands/describe.ts
 var STOPWORDS = /* @__PURE__ */ new Set([

package/dist/cli.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import {
   describe
-} from "./chunk-PJDTFEHK.js";
+} from "./chunk-XVOQNZHC.js";
 import {
   VERSION,
   area,
   areaContext,
   areas,
   areasInit,
+  changes,
   context,
   dead,
   deadFix,
@@ -16,7 +17,7 @@ import {
   impact,
   map,
   suggest
-} from "./chunk-VG3ZBPEH.js";
+} from "./chunk-XFXRWLQA.js";
 
 // src/cli.ts
 import { resolve } from "path";
@@ -55,6 +56,12 @@ FIREBASE:
   functions              Lista todas as Cloud Functions do projeto
   functions --trigger=onCall   Filtra por tipo de trigger
 
+CHANGES:
+  changes                Resumo semantico de mudancas git
+  changes --staged       Mudancas no staging area (git add)
+  changes --unstaged     Mudancas no working directory
+  changes --file=src/types/auth.ts  Detalhar um arquivo especifico
+
 MODOS:
   --mcp                  Inicia servidor MCP para integracao com Claude Desktop
 
@@ -115,7 +122,7 @@ async function main() {
     }
   }
   if (flags.mcp) {
-    const { startMcpServer } = await import("./server-T4MWFGJ5.js");
+    const { startMcpServer } = await import("./server-M2RWCDVQ.js");
     await startMcpServer();
     return;
   }
@@ -238,6 +245,14 @@ async function main() {
         }
         result = await describe(target, { format, cwd });
         break;
+      case "changes":
+        result = await changes({
+          format,
+          cwd,
+          target: flags.staged ? "staged" : flags.unstaged ? "unstaged" : "all",
+          file: flags.file
+        });
+        break;
       default:
         console.error(`\u274C Comando desconhecido: ${command}`);
         console.error("   Use 'ai-tool --help' para ver comandos dispon\xEDveis.");

package/dist/index.d.ts

@@ -288,6 +288,47 @@ interface AreaContextResult {
     stores: AreaContextStoreInfo[];
     triggers: AreaContextTriggerInfo[];
 }
+type ChangeType = "added" | "modified" | "removed";
+type ChangeKind = "function" | "type" | "import" | "const" | "component" | "hook" | "enum" | "class" | "config" | "other";
+interface ChangeEntry {
+    kind: ChangeKind;
+    type: ChangeType;
+    name: string;
+    detail?: string;
+    line?: number;
+}
+interface FileChange {
+    path: string;
+    category: FileCategory;
+    stats: {
+        added: number;
+        removed: number;
+    };
+    changes: ChangeEntry[];
+}
+interface ChangesOptions extends CommandOptions {
+    target?: "staged" | "unstaged" | "all";
+    file?: string;
+}
+interface AffectedArea {
+    id: string;
+    name: string;
+    description?: string;
+    fileCount: number;
+    files: string[];
+}
+interface ChangesResult {
+    version: string;
+    timestamp: string;
+    target: "staged" | "unstaged" | "all";
+    summary: {
+        totalFiles: number;
+        totalAdded: number;
+        totalRemoved: number;
+    };
+    files: FileChange[];
+    affectedAreas?: AffectedArea[];
+}
 
 /**
  * Comando MAP - Mapa do projeto usando Skott
@@ -469,6 +510,22 @@ interface FunctionsOptions {
  */
 declare function functions(options?: FunctionsOptions): Promise<string>;
 
+/**
+ * Comando CHANGES - Resumo semantico de mudancas git
+ *
+ * Analisa arquivos modificados via git diff, classifica mudancas por tipo
+ * (added/modified/removed) e categoria (function/type/import/const/component/hook)
+ * usando pattern matching deterministico, e retorna um resumo estruturado.
+ */
+
+/**
+ * Executa o comando CHANGES
+ *
+ * Retorna um resumo semantico de mudancas git otimizado para consumo de IA.
+ * Ao inves de mostrar diff bruto, classifica mudancas por tipo e categoria.
+ */
+declare function changes(options?: ChangesOptions): Promise<string>;
+
 /**
  * Comando FIND - Busca símbolos no código usando índice cacheado
  *
@@ -587,6 +644,8 @@ interface SymbolInfo {
     definition?: string;
     /** Metadados específicos para triggers Firebase */
     triggerInfo?: TriggerInfo;
+    /** Descrição extraída do JSDoc */
+    description?: string;
 }
 /**
  * Informação de import
@@ -936,4 +995,4 @@ declare function inferFileDescription(filePath: string, category: string): strin
 
 declare const VERSION: string;
 
-export { type AreaConfig, type AreaContextComponentInfo, type AreaContextFunctionInfo, type AreaContextResult, type AreaContextStoreInfo, type AreaContextTriggerInfo, type AreaContextTypeInfo, type AreaDetailResult, type AreaFile, type AreaInfo, type AreaOptions, type AreasConfigFile, type AreasOptions, type AreasResult, type CloudFunctionInfo, type CommandOptions, type ContextOptions, type ContextResult, type DeadFile, type DeadOptions, type DeadResult, type DetectedArea, type FileCategory, type FileInfo, type FindMatch, type FindOptions, type FindResult, type FindSimilarOptions, type FolderStats, type FormatAreaNotFoundOptions, type FormatFileNotFoundOptions, type FunctionInfo, type FunctionsOptions, type FunctionsResult, type HintContext, type ImpactFile, type ImpactOptions, type ImpactResult, type ImportInfo$1 as ImportInfo, type MapOptions, type MapResult, type OutputFormat, type ParamInfo, type ProjectIndex, type RecoveryErrorType, type RiskInfo, type SuggestOptions, type SuggestResult, type Suggestion, type SuggestionPriority, type SymbolInfo, type SymbolType, type TriggerInfo, type TypeInfo, type TypeKind, VERSION, area, areas, areasInit, categoryIcons, clearFirebaseCache, configExists, context, dead, deadFix, detectCategory, detectFileAreas, extractFileName, filterCloudFunctionsFalsePositives, find, findBestMatch, findSimilar, formatAreaNotFound, formatFileNotFound, formatInvalidCommand, formatMissingTarget, functions, getAreaDescription, getAreaName, getCacheDir, getFileDescription, hasFirebaseFunctions, hint, impact, inferFileDescription, invalidateCache, isCacheValid, isCodeFile, isEntryPoint, isExportedCloudFunction, isFileIgnored, isFirebaseProject, levenshteinDistance, map, nextSteps, readConfig, recoveryHint, removeArea, setArea, setFileDescription, suggest, writeConfig };
+export { type AffectedArea, type AreaConfig, type AreaContextComponentInfo, type AreaContextFunctionInfo, type AreaContextResult, type AreaContextStoreInfo, type AreaContextTriggerInfo, type AreaContextTypeInfo, type AreaDetailResult, type AreaFile, type AreaInfo, type AreaOptions, type AreasConfigFile, type AreasOptions, type AreasResult, type ChangeEntry, type ChangeKind, type ChangeType, type ChangesOptions, type ChangesResult, type CloudFunctionInfo, type CommandOptions, type ContextOptions, type ContextResult, type DeadFile, type DeadOptions, type DeadResult, type DetectedArea, type FileCategory, type FileChange, type FileInfo, type FindMatch, type FindOptions, type FindResult, type FindSimilarOptions, type FolderStats, type FormatAreaNotFoundOptions, type FormatFileNotFoundOptions, type FunctionInfo, type FunctionsOptions, type FunctionsResult, type HintContext, type ImpactFile, type ImpactOptions, type ImpactResult, type ImportInfo$1 as ImportInfo, type MapOptions, type MapResult, type OutputFormat, type ParamInfo, type ProjectIndex, type RecoveryErrorType, type RiskInfo, type SuggestOptions, type SuggestResult, type Suggestion, type SuggestionPriority, type SymbolInfo, type SymbolType, type TriggerInfo, type TypeInfo, type TypeKind, VERSION, area, areas, areasInit, categoryIcons, changes, clearFirebaseCache, configExists, context, dead, deadFix, detectCategory, detectFileAreas, extractFileName, filterCloudFunctionsFalsePositives, find, findBestMatch, findSimilar, formatAreaNotFound, formatFileNotFound, formatInvalidCommand, formatMissingTarget, functions, getAreaDescription, getAreaName, getCacheDir, getFileDescription, hasFirebaseFunctions, hint, impact, inferFileDescription, invalidateCache, isCacheValid, isCodeFile, isEntryPoint, isExportedCloudFunction, isFileIgnored, isFirebaseProject, levenshteinDistance, map, nextSteps, readConfig, recoveryHint, removeArea, setArea, setFileDescription, suggest, writeConfig };

package/dist/index.js

@@ -4,6 +4,7 @@ import {
   areas,
   areasInit,
   categoryIcons,
+  changes,
   clearFirebaseCache,
   configExists,
   context,
@@ -46,13 +47,14 @@ import {
   setFileDescription,
   suggest,
   writeConfig
-} from "./chunk-VG3ZBPEH.js";
+} from "./chunk-XFXRWLQA.js";
 export {
   VERSION,
   area,
   areas,
   areasInit,
   categoryIcons,
+  changes,
   clearFirebaseCache,
   configExists,
   context,

package/dist/{server-T4MWFGJ5.js → server-M2RWCDVQ.js}

@@ -1,12 +1,13 @@
 import {
   describe
-} from "./chunk-PJDTFEHK.js";
+} from "./chunk-XVOQNZHC.js";
 import {
   VERSION,
   area,
   areaContext,
   areas,
   areasInit,
+  changes,
   context,
   dead,
   find,
@@ -15,7 +16,7 @@ import {
   map,
   recoveryHint,
   suggest
-} from "./chunk-VG3ZBPEH.js";
+} from "./chunk-XFXRWLQA.js";
 
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -543,6 +544,56 @@ Se nao encontrar: tente termos diferentes, use list_areas para ver areas disponi
         const hint = recoveryHint("generic", "mcp");
         return {
           content: [{ type: "text", text: `Erro ao executar describe: ${msg}
+${hint}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "aitool_changes",
+    {
+      title: "Changes Summary",
+      description: `Resumo semantico de mudancas git - alternativa inteligente ao git diff.
+Classifica mudancas por tipo (funcoes adicionadas, tipos modificados, imports removidos) usando
+pattern matching deterministico + JSDoc dos simbolos. Inclui agrupamento por area quando configurado.
+
+Quando usar: ANTES de implementar algo apos mudancas, entender o que mudou no projeto, revisar PRs,
+contextualizar-se rapidamente sem gastar tokens com diff bruto. Ideal apos git add/commit.
+NAO use para: ver diff detalhado com contexto de linhas (use git diff direto), entender dependencias
+entre arquivos (use impact_analysis), ou listar todos os arquivos do projeto (use project_map).
+
+Workflow: changes \u2192 context (entender tipos atuais de um arquivo) \u2192 implementar
+Dica: use --file=<path> para focar em um arquivo especifico quando houver muitas mudancas.`,
+      inputSchema: {
+        target: z.enum(["staged", "unstaged", "all"]).default("all").describe("O que comparar: staged (git add), unstaged (working dir) ou all"),
+        file: z.string().optional().describe("Detalhar apenas um arquivo especifico (caminho parcial ou completo)"),
+        format: z.enum(["text", "json"]).default("text").describe("Formato de saida: text ou json"),
+        cwd: z.string().optional().describe("Diretorio do projeto a analisar")
+      },
+      annotations: {
+        title: "Changes Summary",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await changes({
+          format: params.format,
+          cwd: params.cwd,
+          target: params.target,
+          file: params.file,
+          ctx: "mcp"
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        const hint = recoveryHint("generic", "mcp");
+        return {
+          content: [{ type: "text", text: `Erro ao executar changes: ${msg}
 ${hint}` }],
           isError: true
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justmpm/ai-tool",
-  "version": "1.0.5",
+  "version": "1.1.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",