@justmpm/ai-tool 0.1.0 → 0.2.0

package/dist/{chunk-EGBEXF4G.js → chunk-HOVHD2N4.js}

@@ -374,10 +374,143 @@ function formatImpactText(result) {
   return out;
 }
 
+// src/cache/index.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync, readdirSync } from "fs";
+import { join, extname } from "path";
+var CACHE_DIR = ".analyze";
+var META_FILE = "meta.json";
+var GRAPH_FILE = "graph.json";
+var MAP_FILE = "map.json";
+var DEAD_FILE = "dead.json";
+function calculateFilesHash(cwd) {
+  const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+  const timestamps = [];
+  function scanDir(dir) {
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".next" || entry.name === "dist" || entry.name === ".analyze") {
+            continue;
+          }
+          scanDir(fullPath);
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name).toLowerCase();
+          if (extensions.includes(ext)) {
+            try {
+              const stat = statSync(fullPath);
+              timestamps.push(stat.mtimeMs);
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  scanDir(cwd);
+  const sum = timestamps.reduce((a, b) => a + b, 0);
+  return `${timestamps.length}-${Math.floor(sum)}`;
+}
+function getCacheDir(cwd) {
+  return join(cwd, CACHE_DIR);
+}
+function isCacheValid(cwd) {
+  const cacheDir = getCacheDir(cwd);
+  const metaPath = join(cacheDir, META_FILE);
+  if (!existsSync(metaPath)) {
+    return false;
+  }
+  try {
+    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+    const currentHash = calculateFilesHash(cwd);
+    return meta.filesHash === currentHash;
+  } catch {
+    return false;
+  }
+}
+function readCache(cwd, file) {
+  const cachePath = join(getCacheDir(cwd), file);
+  if (!existsSync(cachePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync(cachePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeCache(cwd, file, data) {
+  const cacheDir = getCacheDir(cwd);
+  if (!existsSync(cacheDir)) {
+    mkdirSync(cacheDir, { recursive: true });
+  }
+  const cachePath = join(cacheDir, file);
+  writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+}
+function updateCacheMeta(cwd) {
+  const meta = {
+    version: "1.0.0",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
+    filesHash: calculateFilesHash(cwd)
+  };
+  writeCache(cwd, META_FILE, meta);
+}
+function cacheGraph(cwd, graph) {
+  writeCache(cwd, GRAPH_FILE, graph);
+  updateCacheMeta(cwd);
+}
+function getCachedGraph(cwd) {
+  if (!isCacheValid(cwd)) {
+    return null;
+  }
+  return readCache(cwd, GRAPH_FILE);
+}
+function cacheMapResult(cwd, result) {
+  writeCache(cwd, MAP_FILE, result);
+}
+function getCachedMapResult(cwd) {
+  if (!isCacheValid(cwd)) {
+    return null;
+  }
+  return readCache(cwd, MAP_FILE);
+}
+function cacheDeadResult(cwd, result) {
+  writeCache(cwd, DEAD_FILE, result);
+}
+function getCachedDeadResult(cwd) {
+  if (!isCacheValid(cwd)) {
+    return null;
+  }
+  return readCache(cwd, DEAD_FILE);
+}
+function invalidateCache(cwd) {
+  const metaPath = join(getCacheDir(cwd), META_FILE);
+  if (existsSync(metaPath)) {
+    try {
+      writeFileSync(metaPath, "{}", "utf-8");
+    } catch {
+    }
+  }
+}
+
 // src/commands/map.ts
 async function map(options = {}) {
   const cwd = options.cwd || process.cwd();
   const format = options.format || "text";
+  const useCache = options.cache !== false;
+  if (useCache && isCacheValid(cwd)) {
+    const cached = getCachedMapResult(cwd);
+    if (cached) {
+      const result = { ...cached, timestamp: (/* @__PURE__ */ new Date()).toISOString(), fromCache: true };
+      if (format === "json") {
+        return JSON.stringify(result, null, 2);
+      }
+      return formatMapText(result) + "\n\n\u{1F4E6} (resultado do cache)";
+    }
+  }
   try {
     const { getStructure, useGraph } = await skott({
       cwd,
@@ -391,7 +524,16 @@ async function map(options = {}) {
       tsConfigPath: "tsconfig.json"
     });
     const structure = getStructure();
-    const { findCircularDependencies } = useGraph();
+    const graphApi = useGraph();
+    const { findCircularDependencies } = graphApi;
+    if (useCache) {
+      const graphData = {
+        graph: structure.graph,
+        files: Object.keys(structure.graph),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      cacheGraph(cwd, graphData);
+    }
     const files = Object.entries(structure.graph).map(([path]) => ({
       path,
       category: detectCategory(path),
@@ -433,6 +575,10 @@ async function map(options = {}) {
       files,
       circularDependencies: circular
     };
+    if (useCache) {
+      cacheMapResult(cwd, result);
+      updateCacheMeta(cwd);
+    }
     if (format === "json") {
       return JSON.stringify(result, null, 2);
     }
@@ -448,6 +594,17 @@ import { execSync } from "child_process";
 async function dead(options = {}) {
   const cwd = options.cwd || process.cwd();
   const format = options.format || "text";
+  const useCache = options.cache !== false;
+  if (useCache && isCacheValid(cwd)) {
+    const cached = getCachedDeadResult(cwd);
+    if (cached) {
+      const result = { ...cached, timestamp: (/* @__PURE__ */ new Date()).toISOString(), fromCache: true };
+      if (format === "json") {
+        return JSON.stringify(result, null, 2);
+      }
+      return formatDeadText(result) + "\n\n\u{1F4E6} (resultado do cache)";
+    }
+  }
   try {
     let knipOutput;
     try {
@@ -506,6 +663,10 @@ async function dead(options = {}) {
       exports: deadExports,
       dependencies: deadDependencies
     };
+    if (useCache) {
+      cacheDeadResult(cwd, result);
+      updateCacheMeta(cwd);
+    }
     if (format === "json") {
       return JSON.stringify(result, null, 2);
     }
@@ -537,39 +698,57 @@ import skott2 from "skott";
 async function impact(target, options = {}) {
   const cwd = options.cwd || process.cwd();
   const format = options.format || "text";
+  const useCache = options.cache !== false;
   if (!target) {
     throw new Error("Target \xE9 obrigat\xF3rio. Exemplo: ai-tool impact src/components/Button.tsx");
   }
   try {
-    const { getStructure, useGraph } = await skott2({
-      cwd,
-      includeBaseDir: false,
-      dependencyTracking: {
-        thirdParty: false,
-        builtin: false,
-        typeOnly: false
-      },
-      fileExtensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
-      tsConfigPath: "tsconfig.json"
-    });
-    const structure = getStructure();
-    const graphApi = useGraph();
-    const allFiles = Object.keys(structure.graph);
+    let graph;
+    let allFiles = [];
+    let findCircular = () => [];
+    let fromCache = false;
+    if (useCache && isCacheValid(cwd)) {
+      const cached = getCachedGraph(cwd);
+      if (cached) {
+        graph = cached.graph;
+        allFiles = cached.files;
+        findCircular = () => findCircularFromGraph(graph);
+        fromCache = true;
+      }
+    }
+    if (!graph) {
+      const { getStructure, useGraph } = await skott2({
+        cwd,
+        includeBaseDir: false,
+        dependencyTracking: {
+          thirdParty: false,
+          builtin: false,
+          typeOnly: false
+        },
+        fileExtensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+        tsConfigPath: "tsconfig.json"
+      });
+      const structure = getStructure();
+      const graphApi = useGraph();
+      graph = structure.graph;
+      allFiles = Object.keys(graph);
+      findCircular = () => graphApi.findCircularDependencies();
+      if (useCache) {
+        cacheGraph(cwd, {
+          graph,
+          files: allFiles,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        updateCacheMeta(cwd);
+      }
+    }
     const targetPath = findTargetFile(target, allFiles);
     if (!targetPath) {
       return formatNotFound(target, allFiles);
     }
-    const dependingOnNodes = graphApi.collectFilesDependingOn(targetPath, "deep");
-    const dependingOnShallow = graphApi.collectFilesDependingOn(targetPath, "shallow");
-    const dependenciesNodes = graphApi.collectFilesDependencies(targetPath, "deep");
-    const dependenciesShallow = graphApi.collectFilesDependencies(targetPath, "shallow");
-    const dependingOn = dependingOnNodes.map((n) => n.id);
-    const dependencies = dependenciesNodes.map((n) => n.id);
-    const directUpstream = dependingOnShallow.map((n) => n.id);
-    const directDownstream = dependenciesShallow.map((n) => n.id);
-    const indirectUpstream = dependingOn.filter((f) => !directUpstream.includes(f));
-    const indirectDownstream = dependencies.filter((f) => !directDownstream.includes(f));
-    const findCircular = () => graphApi.findCircularDependencies();
+    const { directUpstream, indirectUpstream, directDownstream, indirectDownstream } = calculateDependencies(targetPath, graph);
+    const dependingOn = [...directUpstream, ...indirectUpstream];
+    const dependencies = [...directDownstream, ...indirectDownstream];
     const risks = detectRisks(targetPath, dependingOn, dependencies, findCircular);
     const suggestions = generateSuggestions(dependingOn, dependencies, risks);
     const result = {
@@ -593,12 +772,95 @@ async function impact(target, options = {}) {
     if (format === "json") {
       return JSON.stringify(result, null, 2);
     }
-    return formatImpactText(result);
+    const output = formatImpactText(result);
+    return fromCache ? output + "\n\n\u{1F4E6} (grafo do cache)" : output;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Erro ao executar impact: ${message}`);
   }
 }
+function calculateDependencies(targetPath, graph) {
+  const targetNode = graph[targetPath];
+  const directDownstream = targetNode ? targetNode.adjacentTo : [];
+  const allDownstream = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  function collectDownstream(file) {
+    if (visited.has(file)) return;
+    visited.add(file);
+    const node = graph[file];
+    if (node) {
+      for (const dep of node.adjacentTo) {
+        allDownstream.add(dep);
+        collectDownstream(dep);
+      }
+    }
+  }
+  collectDownstream(targetPath);
+  const indirectDownstream = Array.from(allDownstream).filter(
+    (f) => !directDownstream.includes(f)
+  );
+  const directUpstream = [];
+  const allUpstream = /* @__PURE__ */ new Set();
+  for (const [file, node] of Object.entries(graph)) {
+    if (node.adjacentTo.includes(targetPath)) {
+      directUpstream.push(file);
+    }
+  }
+  visited.clear();
+  function collectUpstream(file) {
+    if (visited.has(file)) return;
+    visited.add(file);
+    for (const [f, node] of Object.entries(graph)) {
+      if (node.adjacentTo.includes(file) && !visited.has(f)) {
+        allUpstream.add(f);
+        collectUpstream(f);
+      }
+    }
+  }
+  for (const file of directUpstream) {
+    collectUpstream(file);
+  }
+  const indirectUpstream = Array.from(allUpstream).filter(
+    (f) => !directUpstream.includes(f)
+  );
+  return {
+    directUpstream,
+    indirectUpstream,
+    directDownstream,
+    indirectDownstream
+  };
+}
+function findCircularFromGraph(graph) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const path = [];
+  function dfs(node) {
+    if (stack.has(node)) {
+      const cycleStart = path.indexOf(node);
+      if (cycleStart !== -1) {
+        cycles.push(path.slice(cycleStart));
+      }
+      return;
+    }
+    if (visited.has(node)) return;
+    visited.add(node);
+    stack.add(node);
+    path.push(node);
+    const nodeData = graph[node];
+    if (nodeData) {
+      for (const dep of nodeData.adjacentTo) {
+        dfs(dep);
+      }
+    }
+    path.pop();
+    stack.delete(node);
+  }
+  for (const node of Object.keys(graph)) {
+    dfs(node);
+  }
+  return cycles;
+}
 function findTargetFile(target, allFiles) {
   const normalizedTarget = target.replace(/\\/g, "/");
   if (allFiles.includes(normalizedTarget)) {
@@ -749,13 +1011,16 @@ function levenshteinDistance(a, b) {
 }
 
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 
 export {
   detectCategory,
   categoryIcons,
   isEntryPoint,
   isCodeFile,
+  getCacheDir,
+  isCacheValid,
+  invalidateCache,
   map,
   dead,
   deadFix,

package/dist/cli.js

@@ -5,7 +5,7 @@ import {
   deadFix,
   impact,
   map
-} from "./chunk-EGBEXF4G.js";
+} from "./chunk-HOVHD2N4.js";
 
 // src/cli.ts
 var HELP = `
@@ -20,12 +20,19 @@ COMANDOS:
 OP\xC7\xD5ES:
   --format=text|json     Formato de sa\xEDda (default: text)
   --cwd=<path>           Diret\xF3rio do projeto (default: cwd)
+  --no-cache             Ignora cache e for\xE7a regenera\xE7\xE3o
   --help, -h             Mostra esta ajuda
   --version, -v          Mostra vers\xE3o
 
+CACHE:
+  Resultados s\xE3o salvos em .analyze/ para acelerar execu\xE7\xF5es futuras.
+  O cache \xE9 invalidado automaticamente quando arquivos mudam.
+  Use --no-cache para for\xE7ar regenera\xE7\xE3o.
+
 EXEMPLOS:
   ai-tool map
   ai-tool map --format=json
+  ai-tool map --no-cache
   ai-tool dead
   ai-tool dead --fix
   ai-tool impact Button
@@ -63,17 +70,18 @@ async function main() {
   const target = positional[1];
   const format = flags.format || "text";
   const cwd = flags.cwd || process.cwd();
+  const cache = !flags["no-cache"];
   try {
     let result;
     switch (command) {
       case "map":
-        result = await map({ format, cwd });
+        result = await map({ format, cwd, cache });
         break;
       case "dead":
         if (flags.fix) {
           result = await deadFix({ cwd });
         } else {
-          result = await dead({ format, cwd });
+          result = await dead({ format, cwd, cache });
         }
         break;
       case "impact":
@@ -83,7 +91,7 @@ async function main() {
           console.error("   Exemplo: ai-tool impact Button");
           process.exit(1);
         }
-        result = await impact(target, { format, cwd });
+        result = await impact(target, { format, cwd, cache });
         break;
       default:
         console.error(`\u274C Comando desconhecido: ${command}`);

package/dist/index.d.ts

@@ -7,6 +7,7 @@ interface CommandOptions {
     format?: OutputFormat;
     cwd?: string;
     save?: boolean;
+    cache?: boolean;
 }
 interface MapOptions extends CommandOptions {
     trackDependencies?: boolean;
@@ -147,6 +148,19 @@ declare function isEntryPoint(filePath: string): boolean;
  */
 declare function isCodeFile(filePath: string): boolean;
 
+/**
+ * Obtém o caminho da pasta de cache
+ */
+declare function getCacheDir(cwd: string): string;
+/**
+ * Verifica se o cache existe e é válido
+ */
+declare function isCacheValid(cwd: string): boolean;
+/**
+ * Invalida o cache (força regeneração)
+ */
+declare function invalidateCache(cwd: string): void;
+
 /**
  * ai-tool - Ferramenta de análise de dependências e impacto
  *
@@ -167,6 +181,6 @@ declare function isCodeFile(filePath: string): boolean;
  * ```
  */
 
-declare const VERSION = "0.1.0";
+declare const VERSION = "0.2.0";
 
-export { type CommandOptions, type DeadFile, type DeadOptions, type DeadResult, type FileCategory, type FileInfo, type FolderStats, type ImpactFile, type ImpactOptions, type ImpactResult, type MapOptions, type MapResult, type OutputFormat, type RiskInfo, VERSION, categoryIcons, dead, deadFix, detectCategory, impact, isCodeFile, isEntryPoint, map };
+export { type CommandOptions, type DeadFile, type DeadOptions, type DeadResult, type FileCategory, type FileInfo, type FolderStats, type ImpactFile, type ImpactOptions, type ImpactResult, type MapOptions, type MapResult, type OutputFormat, type RiskInfo, VERSION, categoryIcons, dead, deadFix, detectCategory, getCacheDir, impact, invalidateCache, isCacheValid, isCodeFile, isEntryPoint, map };

package/dist/index.js

@@ -4,18 +4,24 @@ import {
   dead,
   deadFix,
   detectCategory,
+  getCacheDir,
   impact,
+  invalidateCache,
+  isCacheValid,
   isCodeFile,
   isEntryPoint,
   map
-} from "./chunk-EGBEXF4G.js";
+} from "./chunk-HOVHD2N4.js";
 export {
   VERSION,
   categoryIcons,
   dead,
   deadFix,
   detectCategory,
+  getCacheDir,
   impact,
+  invalidateCache,
+  isCacheValid,
   isCodeFile,
   isEntryPoint,
   map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justmpm/ai-tool",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Ferramenta de análise de dependências e impacto para projetos TypeScript/JavaScript. Usa Skott + Knip internamente.",
   "keywords": [
     "dependency-analysis",
@@ -18,13 +18,13 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/anthropic-studio/ai-tool"
+    "url": "git+https://github.com/anthropic-studio/ai-tool.git"
   },
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "ai-tool": "./dist/cli.js"
+    "ai-tool": "dist/cli.js"
   },
   "exports": {
     ".": {