@justmpm/ai-tool 0.1.0

package/README.md

@@ -0,0 +1,161 @@
+# ai-tool
+
+Ferramenta de análise de dependências e impacto para projetos TypeScript/JavaScript.
+
+Usa [Skott](https://github.com/antoine-coulon/skott) + [Knip](https://knip.dev) internamente para análise precisa.
+
+## Instalação
+
+```bash
+# Via npx (sem instalar)
+npx ai-tool map
+npx ai-tool dead
+npx ai-tool impact Button
+
+# Ou instalar globalmente
+npm install -g ai-tool
+
+# Ou como devDependency
+npm install -D ai-tool
+```
+
+## Comandos
+
+### `map` - Mapa do Projeto
+
+Gera um mapa completo do projeto com categorização de arquivos.
+
+```bash
+ai-tool map
+ai-tool map --format=json
+```
+
+**Output:**
+- Total de arquivos e pastas
+- Categorização automática (component, hook, service, util, etc.)
+- Estrutura de pastas
+- Dependências circulares detectadas
+
+### `dead` - Código Morto
+
+Detecta arquivos, exports e dependências não utilizados.
+
+```bash
+ai-tool dead
+ai-tool dead --format=json
+ai-tool dead --fix  # Remove automaticamente
+```
+
+**Detecta:**
+- Arquivos órfãos (ninguém importa)
+- Exports não utilizados
+- Dependências npm não usadas
+
+### `impact` - Análise de Impacto
+
+Analisa o impacto de modificar um arquivo específico.
+
+```bash
+ai-tool impact Button
+ai-tool impact src/components/Button.tsx
+ai-tool impact useAuth --format=json
+```
+
+**Output:**
+- **Upstream**: Quem importa este arquivo (afetados por mudanças)
+- **Downstream**: O que este arquivo importa (dependências)
+- **Riscos**: Arquivo crítico, dependências circulares, etc.
+- **Sugestões**: Recomendações para modificação segura
+
+## Uso Programático
+
+```typescript
+import { map, dead, impact } from "ai-tool";
+
+// Mapa do projeto
+const projectMap = await map({ format: "json" });
+
+// Código morto
+const deadCode = await dead({ format: "json" });
+
+// Análise de impacto
+const analysis = await impact("src/components/Button.tsx", {
+  format: "json"
+});
+```
+
+## Opções
+
+| Opção | Descrição | Default |
+|-------|-----------|---------|
+| `--format=text\|json` | Formato de saída | `text` |
+| `--cwd=<path>` | Diretório do projeto | `process.cwd()` |
+| `--fix` | Remove código morto (só para `dead`) | `false` |
+
+## Categorias de Arquivos
+
+O ai-tool categoriza automaticamente os arquivos:
+
+| Categoria | Descrição |
+|-----------|-----------|
+| `page` | Páginas (Next.js, etc.) |
+| `layout` | Layouts |
+| `route` | Rotas de API |
+| `component` | Componentes React/Vue |
+| `hook` | React Hooks |
+| `service` | Serviços/API |
+| `store` | Estado global (Redux, Zustand, Context) |
+| `util` | Utilitários |
+| `type` | Tipos TypeScript |
+| `config` | Configurações |
+| `test` | Testes |
+| `other` | Outros |
+
+## Integração com IA
+
+Este pacote foi criado para ser usado com ferramentas de IA como Claude Code, OpenCode, etc.
+
+Exemplo de tool para OpenCode:
+
+```typescript
+import { tool } from "@opencode-ai/plugin";
+import { execSync } from "child_process";
+
+export default tool({
+  description: `Analisa dependências e impacto do projeto.
+
+  COMANDOS:
+  - map: Mapa do projeto
+  - dead: Código morto
+  - impact <arquivo>: Análise de impacto`,
+
+  args: {
+    command: tool.schema.enum(["map", "dead", "impact"]),
+    target: tool.schema.string().optional(),
+    format: tool.schema.enum(["text", "json"]).optional()
+  },
+
+  async execute({ command, target, format }) {
+    const fmt = format || "text";
+    const cmd = target
+      ? `npx ai-tool ${command} "${target}" --format=${fmt}`
+      : `npx ai-tool ${command} --format=${fmt}`;
+
+    return execSync(cmd, { encoding: "utf-8" });
+  }
+});
+```
+
+## Requisitos
+
+- Node.js >= 18.0.0
+- TypeScript/JavaScript project
+
+## Créditos
+
+- [Skott](https://github.com/antoine-coulon/skott) - Análise de dependências
+- [Knip](https://knip.dev) - Detecção de código morto
+
+## Licença
+
+MIT - [Koda AI Studio](https://kodaai.app)

package/dist/chunk-EGBEXF4G.js

@@ -0,0 +1,764 @@
+// src/commands/map.ts
+import skott from "skott";
+
+// src/utils/detect.ts
+function detectCategory(filePath) {
+  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+  const fileName = normalized.split("/").pop() || "";
+  const fileNameNoExt = fileName.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
+  if (fileName.includes(".test.") || fileName.includes(".spec.") || normalized.includes("/__tests__/") || normalized.includes("/test/")) {
+    return "test";
+  }
+  if (isConfigFile(fileName)) {
+    return "config";
+  }
+  if (fileNameNoExt === "page") return "page";
+  if (fileNameNoExt === "layout") return "layout";
+  if (fileNameNoExt === "route") return "route";
+  if (["error", "global-error", "not-found", "loading", "template", "middleware", "default"].includes(
+    fileNameNoExt
+  )) {
+    return "page";
+  }
+  if (normalized.includes("/api/")) return "route";
+  if (normalized.includes("/pages/")) return "page";
+  if (fileNameNoExt.startsWith("use") && fileNameNoExt.length > 3) return "hook";
+  if (normalized.includes("/hooks/")) return "hook";
+  if (normalized.includes("/types/") || fileName.endsWith(".d.ts") || fileNameNoExt === "types" || fileNameNoExt === "interfaces") {
+    return "type";
+  }
+  if (normalized.includes("/services/") || fileNameNoExt.endsWith("service")) {
+    return "service";
+  }
+  if (normalized.includes("/store/") || normalized.includes("/stores/") || normalized.includes("/context/") || normalized.includes("/contexts/") || normalized.includes("/providers/")) {
+    return "store";
+  }
+  if (normalized.includes("/utils/") || normalized.includes("/lib/") || normalized.includes("/helpers/") || normalized.includes("/common/")) {
+    return "util";
+  }
+  if (normalized.includes("/components/") || normalized.includes("/ui/") || normalized.includes("/features/")) {
+    return "component";
+  }
+  return "other";
+}
+function isConfigFile(fileName) {
+  const patterns = [
+    /eslint\.config\./,
+    /prettier\.config\./,
+    /tailwind\.config\./,
+    /next\.config\./,
+    /vite\.config\./,
+    /tsconfig/,
+    /jest\.config/,
+    /vitest\.config/,
+    /postcss\.config/,
+    /babel\.config/,
+    /webpack\.config/,
+    /firebase-messaging-sw/,
+    /sw\./,
+    /service-worker/,
+    /knip\.config/,
+    /\.env/
+  ];
+  return patterns.some((p) => p.test(fileName));
+}
+var categoryIcons = {
+  page: "\u{1F4C4}",
+  layout: "\u{1F532}",
+  route: "\u{1F6E3}\uFE0F",
+  component: "\u{1F9E9}",
+  hook: "\u{1FA9D}",
+  store: "\u{1F5C4}\uFE0F",
+  service: "\u2699\uFE0F",
+  util: "\u{1F527}",
+  type: "\u{1F4DD}",
+  config: "\u2699\uFE0F",
+  test: "\u{1F9EA}",
+  other: "\u{1F4C1}"
+};
+function isEntryPoint(filePath) {
+  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+  const fileName = normalized.split("/").pop() || "";
+  const entryPoints = [
+    "main.tsx",
+    "main.ts",
+    "main.jsx",
+    "main.js",
+    "index.tsx",
+    "index.ts",
+    "app.tsx",
+    "app.ts"
+  ];
+  if (entryPoints.includes(fileName)) {
+    const depth = normalized.split("/").length;
+    if (depth <= 2) return true;
+  }
+  return false;
+}
+var CODE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+function isCodeFile(filePath) {
+  return CODE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
+}
+
+// src/formatters/text.ts
+function formatMapText(result) {
+  let out = "";
+  out += `
+`;
+  out += `\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+`;
+  out += `\u2551                    \u{1F4C1} PROJECT MAP                           \u2551
+`;
+  out += `\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+
+`;
+  out += `\u{1F4CA} RESUMO
+`;
+  out += `   Arquivos: ${result.summary.totalFiles}
+`;
+  out += `   Pastas: ${result.summary.totalFolders}
+`;
+  out += `   Diret\xF3rio: ${result.cwd}
+
+`;
+  out += `\u{1F4C2} CATEGORIAS
+`;
+  const catOrder = [
+    "page",
+    "layout",
+    "route",
+    "component",
+    "hook",
+    "service",
+    "store",
+    "util",
+    "type",
+    "config",
+    "test",
+    "other"
+  ];
+  for (const cat of catOrder) {
+    const count = result.summary.categories[cat];
+    if (count) {
+      const icon = categoryIcons[cat];
+      out += `   ${icon} ${cat.padEnd(12)} ${count}
+`;
+    }
+  }
+  out += `
+\u{1F4C1} ESTRUTURA (Top 15 pastas)
+`;
+  const topFolders = result.folders.sort((a, b) => b.fileCount - a.fileCount).slice(0, 15);
+  for (const folder of topFolders) {
+    out += `   ${folder.path}/ (${folder.fileCount} arquivos)
+`;
+  }
+  if (result.folders.length > 15) {
+    out += `   ... e mais ${result.folders.length - 15} pastas
+`;
+  }
+  if (result.circularDependencies.length > 0) {
+    out += `
+\u26A0\uFE0F DEPEND\xCANCIAS CIRCULARES (${result.circularDependencies.length})
+`;
+    for (const cycle of result.circularDependencies.slice(0, 5)) {
+      out += `   ${cycle.join(" \u2192 ")}
+`;
+    }
+    if (result.circularDependencies.length > 5) {
+      out += `   ... e mais ${result.circularDependencies.length - 5}
+`;
+    }
+  }
+  return out;
+}
+function formatDeadText(result) {
+  let out = "";
+  out += `
+`;
+  out += `\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+`;
+  out += `\u2551                    \u{1F480} DEAD CODE                              \u2551
+`;
+  out += `\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+
+`;
+  if (result.summary.totalDead === 0) {
+    out += `\u2705 Nenhum c\xF3digo morto encontrado!
+`;
+    out += `   Todos os arquivos e exports est\xE3o sendo utilizados.
+`;
+    return out;
+  }
+  out += `\u{1F4CA} RESUMO
+`;
+  out += `   Total: ${result.summary.totalDead} itens n\xE3o utilizados
+`;
+  out += `   Arquivos \xF3rf\xE3os: ${result.summary.byType.files}
+`;
+  out += `   Exports n\xE3o usados: ${result.summary.byType.exports}
+`;
+  out += `   Depend\xEAncias n\xE3o usadas: ${result.summary.byType.dependencies}
+
+`;
+  if (result.files.length > 0) {
+    out += `\u{1F5D1}\uFE0F ARQUIVOS \xD3RF\xC3OS (${result.files.length})
+`;
+    out += `   Arquivos que ningu\xE9m importa:
+
+`;
+    const byCategory = /* @__PURE__ */ new Map();
+    for (const file of result.files) {
+      if (!byCategory.has(file.category)) {
+        byCategory.set(file.category, []);
+      }
+      byCategory.get(file.category).push(file);
+    }
+    for (const [category, files] of byCategory) {
+      const icon = categoryIcons[category];
+      out += `   ${icon} ${category}/ (${files.length})
+`;
+      for (const file of files.slice(0, 5)) {
+        out += `      ${file.path}
+`;
+      }
+      if (files.length > 5) {
+        out += `      ... e mais ${files.length - 5}
+`;
+      }
+      out += `
+`;
+    }
+  }
+  if (result.exports.length > 0) {
+    out += `\u{1F4E4} EXPORTS N\xC3O USADOS (${result.exports.length})
+`;
+    for (const exp of result.exports.slice(0, 10)) {
+      out += `   ${exp.file}: ${exp.export}
+`;
+    }
+    if (result.exports.length > 10) {
+      out += `   ... e mais ${result.exports.length - 10}
+`;
+    }
+    out += `
+`;
+  }
+  if (result.dependencies.length > 0) {
+    out += `\u{1F4E6} DEPEND\xCANCIAS N\xC3O USADAS (${result.dependencies.length})
+`;
+    for (const dep of result.dependencies) {
+      out += `   ${dep}
+`;
+    }
+    out += `
+`;
+  }
+  out += `\u{1F4A1} SUGEST\xC3O
+`;
+  out += `   Execute 'npx knip --fix' para remover automaticamente.
+`;
+  return out;
+}
+function formatImpactText(result) {
+  let out = "";
+  out += `
+`;
+  out += `\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+`;
+  out += `\u2551                    \u{1F3AF} IMPACT ANALYSIS                        \u2551
+`;
+  out += `\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+
+`;
+  const icon = categoryIcons[result.category];
+  out += `\u{1F4CD} ARQUIVO: ${result.target}
+`;
+  out += `   ${icon} ${result.category}
+
+`;
+  out += `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+`;
+  out += `\u2B06\uFE0F USADO POR (${result.upstream.total} arquivo${result.upstream.total !== 1 ? "s" : ""} \xFAnico${result.upstream.total !== 1 ? "s" : ""})
+`;
+  if (result.upstream.direct.length > 0 || result.upstream.indirect.length > 0) {
+    out += `   \u{1F4CD} ${result.upstream.direct.length} direto${result.upstream.direct.length !== 1 ? "s" : ""} + ${result.upstream.indirect.length} indireto${result.upstream.indirect.length !== 1 ? "s" : ""}
+`;
+  }
+  out += `   Quem importa este arquivo:
+
+`;
+  if (result.upstream.total === 0) {
+    out += `   Ningu\xE9m importa este arquivo diretamente.
+`;
+  } else {
+    for (const file of result.upstream.direct.slice(0, 10)) {
+      const fileIcon = categoryIcons[file.category];
+      out += `   ${fileIcon} ${file.path}
+`;
+    }
+    if (result.upstream.direct.length > 10) {
+      out += `   ... e mais ${result.upstream.direct.length - 10} diretos
+`;
+    }
+    if (result.upstream.indirect.length > 0) {
+      out += `
+   Indiretos: ${result.upstream.indirect.slice(0, 5).map((f) => f.path.split("/").pop()).join(", ")}`;
+      if (result.upstream.indirect.length > 5) {
+        out += ` (+${result.upstream.indirect.length - 5})`;
+      }
+      out += `
+`;
+    }
+  }
+  out += `
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+`;
+  out += `\u2B07\uFE0F DEPEND\xCANCIAS (${result.downstream.total} arquivo${result.downstream.total !== 1 ? "s" : ""} \xFAnico${result.downstream.total !== 1 ? "s" : ""})
+`;
+  if (result.downstream.direct.length > 0 || result.downstream.indirect.length > 0) {
+    out += `   \u{1F4CD} ${result.downstream.direct.length} direto${result.downstream.direct.length !== 1 ? "s" : ""} + ${result.downstream.indirect.length} indireto${result.downstream.indirect.length !== 1 ? "s" : ""}
+`;
+  }
+  out += `   O que este arquivo importa:
+
+`;
+  if (result.downstream.total === 0) {
+    out += `   Este arquivo n\xE3o importa nenhum arquivo local.
+`;
+  } else {
+    for (const file of result.downstream.direct.slice(0, 10)) {
+      const fileIcon = categoryIcons[file.category];
+      out += `   ${fileIcon} ${file.path}
+`;
+    }
+    if (result.downstream.direct.length > 10) {
+      out += `   ... e mais ${result.downstream.direct.length - 10}
+`;
+    }
+  }
+  out += `
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+`;
+  out += `\u{1F4CA} M\xC9TRICAS DE IMPACTO
+
+`;
+  out += `   Arquivos que importam este (upstream):  ${result.upstream.total} \xFAnico${result.upstream.total !== 1 ? "s" : ""}
+`;
+  out += `   Arquivos que este importa (downstream): ${result.downstream.total} \xFAnico${result.downstream.total !== 1 ? "s" : ""}
+`;
+  if (result.risks.length > 0) {
+    out += `
+\u26A0\uFE0F RISCOS IDENTIFICADOS (${result.risks.length})
+
+`;
+    for (const risk of result.risks) {
+      const severity = risk.severity === "high" ? "\u{1F534}" : risk.severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+      out += `   ${severity} ${risk.severity.toUpperCase()}: ${risk.message}
+`;
+    }
+  }
+  if (result.suggestions.length > 0) {
+    out += `
+\u{1F4A1} SUGEST\xD5ES
+
+`;
+    for (const suggestion of result.suggestions) {
+      out += `   \u2022 ${suggestion}
+`;
+    }
+  }
+  return out;
+}
+
+// src/commands/map.ts
+async function map(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const format = options.format || "text";
+  try {
+    const { getStructure, useGraph } = await skott({
+      cwd,
+      includeBaseDir: false,
+      dependencyTracking: {
+        thirdParty: options.trackDependencies ?? false,
+        builtin: false,
+        typeOnly: false
+      },
+      fileExtensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+      tsConfigPath: "tsconfig.json"
+    });
+    const structure = getStructure();
+    const { findCircularDependencies } = useGraph();
+    const files = Object.entries(structure.graph).map(([path]) => ({
+      path,
+      category: detectCategory(path),
+      size: 0
+      // Skott não fornece tamanho
+    }));
+    const folderMap = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const parts = file.path.split("/");
+      if (parts.length > 1) {
+        const folder = parts.slice(0, -1).join("/");
+        if (!folderMap.has(folder)) {
+          folderMap.set(folder, {
+            path: folder,
+            fileCount: 0,
+            categories: {}
+          });
+        }
+        const stats = folderMap.get(folder);
+        stats.fileCount++;
+        stats.categories[file.category] = (stats.categories[file.category] || 0) + 1;
+      }
+    }
+    const categories = {};
+    for (const file of files) {
+      categories[file.category] = (categories[file.category] || 0) + 1;
+    }
+    const circular = findCircularDependencies();
+    const result = {
+      version: "1.0.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      cwd,
+      summary: {
+        totalFiles: files.length,
+        totalFolders: folderMap.size,
+        categories
+      },
+      folders: Array.from(folderMap.values()),
+      files,
+      circularDependencies: circular
+    };
+    if (format === "json") {
+      return JSON.stringify(result, null, 2);
+    }
+    return formatMapText(result);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Erro ao executar map: ${message}`);
+  }
+}
+
+// src/commands/dead.ts
+import { execSync } from "child_process";
+async function dead(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const format = options.format || "text";
+  try {
+    let knipOutput;
+    try {
+      const output = execSync("npx knip --reporter=json", {
+        cwd,
+        encoding: "utf-8",
+        maxBuffer: 50 * 1024 * 1024,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      knipOutput = JSON.parse(output || "{}");
+    } catch (execError) {
+      const error = execError;
+      if (error.stdout) {
+        try {
+          knipOutput = JSON.parse(error.stdout);
+        } catch {
+          knipOutput = {};
+        }
+      } else {
+        knipOutput = {};
+      }
+    }
+    const deadFiles = (knipOutput.files || []).map((file) => ({
+      path: file,
+      category: detectCategory(file),
+      type: "file"
+    }));
+    const deadExports = [];
+    if (knipOutput.issues) {
+      for (const issue of knipOutput.issues) {
+        if (issue.symbol && issue.symbolType === "export") {
+          deadExports.push({
+            file: issue.file,
+            export: issue.symbol
+          });
+        }
+      }
+    }
+    const deadDependencies = [
+      ...knipOutput.dependencies || [],
+      ...knipOutput.devDependencies || []
+    ];
+    const result = {
+      version: "1.0.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      cwd,
+      summary: {
+        totalDead: deadFiles.length + deadExports.length + deadDependencies.length,
+        byType: {
+          files: deadFiles.length,
+          exports: deadExports.length,
+          dependencies: deadDependencies.length
+        }
+      },
+      files: deadFiles,
+      exports: deadExports,
+      dependencies: deadDependencies
+    };
+    if (format === "json") {
+      return JSON.stringify(result, null, 2);
+    }
+    return formatDeadText(result);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Erro ao executar dead: ${message}`);
+  }
+}
+async function deadFix(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  try {
+    const output = execSync("npx knip --fix", {
+      cwd,
+      encoding: "utf-8",
+      maxBuffer: 50 * 1024 * 1024
+    });
+    return `\u2705 Fix executado com sucesso!
+
+${output}`;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Erro ao executar fix: ${message}`);
+  }
+}
+
+// src/commands/impact.ts
+import skott2 from "skott";
+async function impact(target, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const format = options.format || "text";
+  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);
+    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 risks = detectRisks(targetPath, dependingOn, dependencies, findCircular);
+    const suggestions = generateSuggestions(dependingOn, dependencies, risks);
+    const result = {
+      version: "1.0.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      target: targetPath,
+      category: detectCategory(targetPath),
+      upstream: {
+        direct: directUpstream.map(toImpactFile(true)),
+        indirect: indirectUpstream.map(toImpactFile(false)),
+        total: dependingOn.length
+      },
+      downstream: {
+        direct: directDownstream.map(toImpactFile(true)),
+        indirect: indirectDownstream.map(toImpactFile(false)),
+        total: dependencies.length
+      },
+      risks,
+      suggestions
+    };
+    if (format === "json") {
+      return JSON.stringify(result, null, 2);
+    }
+    return formatImpactText(result);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Erro ao executar impact: ${message}`);
+  }
+}
+function findTargetFile(target, allFiles) {
+  const normalizedTarget = target.replace(/\\/g, "/");
+  if (allFiles.includes(normalizedTarget)) {
+    return normalizedTarget;
+  }
+  const targetName = normalizedTarget.split("/").pop()?.toLowerCase() || "";
+  const targetNameNoExt = targetName.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
+  const matches = [];
+  for (const file of allFiles) {
+    const fileName = file.split("/").pop()?.toLowerCase() || "";
+    const fileNameNoExt = fileName.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
+    if (fileNameNoExt === targetNameNoExt) {
+      matches.unshift(file);
+    } else if (file.toLowerCase().includes(normalizedTarget.toLowerCase())) {
+      matches.push(file);
+    }
+  }
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  if (matches.length > 1) {
+    return matches[0];
+  }
+  return null;
+}
+function formatNotFound(target, allFiles) {
+  const normalizedTarget = target.toLowerCase();
+  const similar = allFiles.filter((f) => {
+    const fileName = f.split("/").pop()?.toLowerCase() || "";
+    const fileNameNoExt = fileName.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
+    return fileName.includes(normalizedTarget) || fileNameNoExt.includes(normalizedTarget) || levenshteinDistance(fileNameNoExt, normalizedTarget) <= 3;
+  }).slice(0, 5);
+  let out = `\u274C Arquivo n\xE3o encontrado no \xEDndice: "${target}"
+
+`;
+  out += `\u{1F4CA} Total de arquivos indexados: ${allFiles.length}
+
+`;
+  if (similar.length > 0) {
+    out += `\u{1F4DD} Arquivos com nome similar:
+`;
+    for (const s of similar) {
+      out += `   \u2022 ${s}
+`;
+    }
+    out += `
+`;
+  }
+  out += `\u{1F4A1} Dicas:
+`;
+  out += `   \u2022 Use o caminho relativo: src/components/Header.tsx
+`;
+  out += `   \u2022 Ou apenas o nome do arquivo: Header
+`;
+  out += `   \u2022 Verifique se o arquivo est\xE1 em uma pasta inclu\xEDda no scan
+`;
+  return out;
+}
+function toImpactFile(isDirect) {
+  return (path) => ({
+    path,
+    category: detectCategory(path),
+    isDirect
+  });
+}
+function detectRisks(targetPath, upstream, downstream, findCircular) {
+  const risks = [];
+  if (upstream.length >= 15) {
+    risks.push({
+      type: "widely-used",
+      severity: "high",
+      message: `Arquivo CR\xCDTICO: usado por ${upstream.length} arquivos \xFAnicos`
+    });
+  } else if (upstream.length >= 5) {
+    risks.push({
+      type: "widely-used",
+      severity: "medium",
+      message: `Arquivo compartilhado: usado por ${upstream.length} arquivos \xFAnicos`
+    });
+  }
+  if (downstream.length >= 20) {
+    risks.push({
+      type: "deep-chain",
+      severity: "medium",
+      message: `Arquivo importa ${downstream.length} depend\xEAncias (considere dividir)`
+    });
+  } else if (downstream.length >= 10) {
+    risks.push({
+      type: "deep-chain",
+      severity: "low",
+      message: `Arquivo importa ${downstream.length} depend\xEAncias`
+    });
+  }
+  const circular = findCircular();
+  const targetCircular = circular.filter((cycle) => cycle.includes(targetPath));
+  if (targetCircular.length > 0) {
+    risks.push({
+      type: "circular",
+      severity: "medium",
+      message: `Envolvido em ${targetCircular.length} depend\xEAncia${targetCircular.length > 1 ? "s" : ""} circular${targetCircular.length > 1 ? "es" : ""}`
+    });
+  }
+  return risks;
+}
+function generateSuggestions(upstream, downstream, risks) {
+  const suggestions = [];
+  if (upstream.length > 0) {
+    suggestions.push(
+      `Verifique os ${upstream.length} arquivo(s) que importam este antes de modificar`
+    );
+  }
+  if (upstream.length >= 10) {
+    suggestions.push(`Considere criar testes para garantir que mudan\xE7as n\xE3o quebrem dependentes`);
+  }
+  if (downstream.length > 0) {
+    suggestions.push(`Teste as ${downstream.length} depend\xEAncia(s) ap\xF3s mudan\xE7as`);
+  }
+  if (risks.some((r) => r.type === "circular")) {
+    suggestions.push(`Considere resolver as depend\xEAncias circulares antes de refatorar`);
+  }
+  if (risks.some((r) => r.type === "widely-used" && r.severity === "high")) {
+    suggestions.push(`Este arquivo \xE9 cr\xEDtico - planeje mudan\xE7as com cuidado`);
+  }
+  return suggestions;
+}
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j] + 1
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+export {
+  detectCategory,
+  categoryIcons,
+  isEntryPoint,
+  isCodeFile,
+  map,
+  dead,
+  deadFix,
+  impact,
+  VERSION
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import {
+  VERSION,
+  dead,
+  deadFix,
+  impact,
+  map
+} from "./chunk-EGBEXF4G.js";
+
+// src/cli.ts
+var HELP = `
+ai-tool v${VERSION} - An\xE1lise de depend\xEAncias e impacto
+
+COMANDOS:
+  map                    Mapa completo do projeto (usa Skott)
+  dead                   Detecta c\xF3digo morto (usa Knip)
+  dead --fix             Remove c\xF3digo morto automaticamente
+  impact <arquivo>       An\xE1lise de impacto antes de modificar
+
+OP\xC7\xD5ES:
+  --format=text|json     Formato de sa\xEDda (default: text)
+  --cwd=<path>           Diret\xF3rio do projeto (default: cwd)
+  --help, -h             Mostra esta ajuda
+  --version, -v          Mostra vers\xE3o
+
+EXEMPLOS:
+  ai-tool map
+  ai-tool map --format=json
+  ai-tool dead
+  ai-tool dead --fix
+  ai-tool impact Button
+  ai-tool impact src/hooks/useAuth.ts
+  ai-tool impact src/components/Header.tsx --format=json
+
+SOBRE:
+  Criado por Koda AI Studio (kodaai.app)
+  Usa Skott para an\xE1lise de depend\xEAncias e Knip para dead code detection.
+`;
+async function main() {
+  const args = process.argv.slice(2);
+  const flags = {};
+  const positional = [];
+  for (const arg of args) {
+    if (arg.startsWith("--")) {
+      const [key, value] = arg.slice(2).split("=");
+      flags[key] = value ?? true;
+    } else if (arg.startsWith("-")) {
+      const key = arg.slice(1);
+      flags[key] = true;
+    } else {
+      positional.push(arg);
+    }
+  }
+  if (flags.help || flags.h || positional.length === 0) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (flags.version || flags.v) {
+    console.log(`ai-tool v${VERSION}`);
+    process.exit(0);
+  }
+  const command = positional[0];
+  const target = positional[1];
+  const format = flags.format || "text";
+  const cwd = flags.cwd || process.cwd();
+  try {
+    let result;
+    switch (command) {
+      case "map":
+        result = await map({ format, cwd });
+        break;
+      case "dead":
+        if (flags.fix) {
+          result = await deadFix({ cwd });
+        } else {
+          result = await dead({ format, cwd });
+        }
+        break;
+      case "impact":
+        if (!target) {
+          console.error("\u274C Erro: arquivo alvo \xE9 obrigat\xF3rio para o comando impact");
+          console.error("   Exemplo: ai-tool impact src/components/Button.tsx");
+          console.error("   Exemplo: ai-tool impact Button");
+          process.exit(1);
+        }
+        result = await impact(target, { format, cwd });
+        break;
+      default:
+        console.error(`\u274C Comando desconhecido: ${command}`);
+        console.error("   Use 'ai-tool --help' para ver comandos dispon\xEDveis.");
+        process.exit(1);
+    }
+    console.log(result);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`\u274C Erro: ${message}`);
+    process.exit(1);
+  }
+}
+main();

package/dist/index.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Tipos para o ai-tool
+ */
+type OutputFormat = "text" | "json";
+type FileCategory = "page" | "layout" | "route" | "component" | "hook" | "service" | "store" | "util" | "type" | "config" | "test" | "other";
+interface CommandOptions {
+    format?: OutputFormat;
+    cwd?: string;
+    save?: boolean;
+}
+interface MapOptions extends CommandOptions {
+    trackDependencies?: boolean;
+}
+interface DeadOptions extends CommandOptions {
+    include?: string[];
+    exclude?: string[];
+    fix?: boolean;
+}
+interface ImpactOptions extends CommandOptions {
+    depth?: number;
+}
+interface FileInfo {
+    path: string;
+    category: FileCategory;
+    size: number;
+}
+interface FolderStats {
+    path: string;
+    fileCount: number;
+    categories: Partial<Record<FileCategory, number>>;
+}
+interface MapResult {
+    version: string;
+    timestamp: string;
+    cwd: string;
+    summary: {
+        totalFiles: number;
+        totalFolders: number;
+        categories: Partial<Record<FileCategory, number>>;
+    };
+    folders: FolderStats[];
+    files: FileInfo[];
+    circularDependencies: string[][];
+}
+interface DeadFile {
+    path: string;
+    category: FileCategory;
+    type: "file" | "export" | "dependency";
+}
+interface DeadResult {
+    version: string;
+    timestamp: string;
+    cwd: string;
+    summary: {
+        totalDead: number;
+        byType: {
+            files: number;
+            exports: number;
+            dependencies: number;
+        };
+    };
+    files: DeadFile[];
+    exports: Array<{
+        file: string;
+        export: string;
+    }>;
+    dependencies: string[];
+}
+interface ImpactFile {
+    path: string;
+    category: FileCategory;
+    isDirect: boolean;
+}
+interface RiskInfo {
+    type: "widely-used" | "circular" | "deep-chain";
+    severity: "low" | "medium" | "high";
+    message: string;
+}
+interface ImpactResult {
+    version: string;
+    timestamp: string;
+    target: string;
+    category: FileCategory;
+    upstream: {
+        direct: ImpactFile[];
+        indirect: ImpactFile[];
+        total: number;
+    };
+    downstream: {
+        direct: ImpactFile[];
+        indirect: ImpactFile[];
+        total: number;
+    };
+    risks: RiskInfo[];
+    suggestions: string[];
+}
+
+/**
+ * Comando MAP - Mapa do projeto usando Skott
+ */
+
+/**
+ * Executa o comando MAP
+ */
+declare function map(options?: MapOptions): Promise<string>;
+
+/**
+ * Comando DEAD - Detecção de código morto usando Knip
+ */
+
+/**
+ * Executa o comando DEAD
+ */
+declare function dead(options?: DeadOptions): Promise<string>;
+/**
+ * Executa fix automático do Knip
+ */
+declare function deadFix(options?: DeadOptions): Promise<string>;
+
+/**
+ * Comando IMPACT - Análise de impacto usando Skott API
+ */
+
+/**
+ * Executa o comando IMPACT
+ */
+declare function impact(target: string, options?: ImpactOptions): Promise<string>;
+
+/**
+ * Utilitários para detecção e classificação de arquivos
+ */
+
+/**
+ * Detecta a categoria de um arquivo baseado no path
+ */
+declare function detectCategory(filePath: string): FileCategory;
+/**
+ * Ícones para cada categoria (para output text)
+ */
+declare const categoryIcons: Record<FileCategory, string>;
+/**
+ * Verifica se um arquivo é entry point
+ */
+declare function isEntryPoint(filePath: string): boolean;
+/**
+ * Verifica se é um arquivo de código
+ */
+declare function isCodeFile(filePath: string): boolean;
+
+/**
+ * ai-tool - Ferramenta de análise de dependências e impacto
+ *
+ * Usa Skott + Knip internamente para análise precisa.
+ *
+ * @example
+ * ```typescript
+ * import { map, dead, impact } from "ai-tool";
+ *
+ * // Mapa do projeto
+ * const projectMap = await map({ format: "json" });
+ *
+ * // Código morto
+ * const deadCode = await dead({ format: "json" });
+ *
+ * // Análise de impacto
+ * const analysis = await impact("src/components/Button.tsx", { format: "json" });
+ * ```
+ */
+
+declare const VERSION = "0.1.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 };

package/dist/index.js

@@ -0,0 +1,22 @@
+import {
+  VERSION,
+  categoryIcons,
+  dead,
+  deadFix,
+  detectCategory,
+  impact,
+  isCodeFile,
+  isEntryPoint,
+  map
+} from "./chunk-EGBEXF4G.js";
+export {
+  VERSION,
+  categoryIcons,
+  dead,
+  deadFix,
+  detectCategory,
+  impact,
+  isCodeFile,
+  isEntryPoint,
+  map
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@justmpm/ai-tool",
+  "version": "0.1.0",
+  "description": "Ferramenta de análise de dependências e impacto para projetos TypeScript/JavaScript. Usa Skott + Knip internamente.",
+  "keywords": [
+    "dependency-analysis",
+    "impact-analysis",
+    "dead-code",
+    "typescript",
+    "javascript",
+    "skott",
+    "knip",
+    "ai",
+    "claude",
+    "opencode"
+  ],
+  "author": "Koda AI Studio <studio.kodaai@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anthropic-studio/ai-tool"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "ai-tool": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/cli.ts --format esm --dts --watch",
+    "prepublishOnly": "npm run build",
+    "test": "node --test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "knip": "^5.44.0",
+    "skott": "^0.35.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.21",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}