sweeply 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ángel Iván López Delgado (Fora)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,61 @@
+# sweeply
+
+[![CI](https://github.com/Foralitos/sweeply/actions/workflows/ci.yml/badge.svg)](https://github.com/Foralitos/sweeply/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/sweeply.svg)](https://www.npmjs.com/package/sweeply)
+[![license](https://img.shields.io/npm/l/sweeply.svg)](LICENSE)
+
+TUI para encontrar y borrar el peso muerto de tus proyectos — `node_modules`, `.next`, `dist`, `venv`, `target` y demás carpetas regenerables — con un **semáforo de seguridad git** que te dice de un vistazo qué tan tranquilo puedes estar:
+
+- 🟢 **pusheado** — todo commiteado y en el remoto. Borrar aquí es 100% recuperable.
+- 🟡 **cambios sin commitear / sin push / sin remoto** — revisa antes de tocar el proyecto.
+- 🔴 **sin git** — si borras el proyecto completo, no hay vuelta atrás.
+
+sweeply **solo borra carpetas regenerables** (las recuperas con `yarn install`, `pip install`, etc.), nunca tu código. Y siempre pide confirmación.
+
+## Uso
+
+Requiere **Node 22 o superior**.
+
+```bash
+npx sweeply                 # escanea tu home
+npx sweeply --dir ~/Sites   # escanea una carpeta específica
+npx sweeply -t .cache,tmp   # detecta carpetas extra
+```
+
+### Teclas
+
+| Tecla | Acción |
+|---|---|
+| `↑↓` / `j k` | navegar |
+| `espacio` | seleccionar/deseleccionar |
+| `a` | seleccionar todos los 🟢 |
+| `enter` | borrar seleccionados (pide confirmación) |
+| `g` | detalle git del proyecto |
+| `s` | ordenar por tamaño |
+| `q` | salir |
+
+## Qué detecta
+
+`node_modules`, `.next`, `.nuxt`, `.turbo`, `dist`, `build`, `out` (si hay `package.json` al lado), `venv`/`.venv` (si hay proyecto Python al lado), `target` (Rust), `Pods` (iOS). La condición de "manifest al lado" evita falsos positivos: una carpeta `dist` suelta sin `package.json` no se toca.
+
+## Desarrollo
+
+```bash
+yarn           # instalar deps
+yarn dev       # correr desde src con tsx
+yarn build     # compilar a dist/ con tsup
+yarn typecheck
+```
+
+## ¿Por qué no npkill?
+
+[npkill](https://npkill.js.org) está muy bien y fue la inspiración. sweeply agrega dos cosas: detección multi-ecosistema (Python, Rust, iOS, builds de Next) y el semáforo git — la respuesta a "¿será seguro borrar esto?" sin tener que abrir el proyecto.
+
+## Contribuir
+
+Los PRs son bienvenidos — lee [CONTRIBUTING.md](CONTRIBUTING.md) primero.
+Para vulnerabilidades, usa el [canal privado](SECURITY.md), no un issue público.
+
+## Licencia
+
+MIT — ver [LICENSE](LICENSE).

package/dist/cli.js

@@ -0,0 +1,463 @@
+#!/usr/bin/env node
+
+// src/cli.tsx
+import { render } from "ink";
+import os3 from "os";
+
+// src/ui/App.tsx
+import { useEffect, useMemo, useState } from "react";
+import { Box as Box3, Text as Text3, useApp, useInput, useStdout } from "ink";
+import path3 from "path";
+import os2 from "os";
+
+// src/core/scanner.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "Library",
+  "Applications",
+  "Movies",
+  "Music",
+  "Pictures",
+  "Photos",
+  "Public",
+  ".Trash"
+]);
+var MAX_DEPTH = 8;
+async function* scan(rootDir, targets) {
+  const byName = new Map(targets.map((t) => [t.name, t]));
+  const isHome = path.resolve(rootDir) === os.homedir();
+  const queue = [
+    { dir: path.resolve(rootDir), depth: 0 }
+  ];
+  while (queue.length > 0) {
+    const { dir: dir2, depth } = queue.shift();
+    let entries;
+    try {
+      entries = await fs.readdir(dir2, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    const fileNames = new Set(
+      entries.filter((e) => e.isFile()).map((e) => e.name)
+    );
+    const found = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+      const def = byName.get(entry.name);
+      if (def) {
+        const ok = !def.requiresSibling || def.requiresSibling.some((f) => fileNames.has(f));
+        if (ok) {
+          found.push({
+            path: path.join(dir2, entry.name),
+            name: entry.name,
+            label: def.label
+          });
+          continue;
+        }
+      }
+      if (entry.name === ".git" || entry.name.startsWith(".")) continue;
+      if (depth === 0 && isHome && SKIP_DIRS.has(entry.name)) continue;
+      if (depth < MAX_DEPTH) {
+        queue.push({ dir: path.join(dir2, entry.name), depth: depth + 1 });
+      }
+    }
+    if (found.length > 0) {
+      yield { path: dir2, name: path.basename(dir2), targets: found };
+    }
+  }
+}
+
+// src/core/size.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+async function dirSize(dir2) {
+  let total = 0;
+  const stack = [dir2];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = await fs2.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path2.join(current, entry.name);
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else if (entry.isFile()) {
+        try {
+          const st = await fs2.stat(full);
+          total += st.blocks > 0 ? st.blocks * 512 : st.size;
+        } catch {
+        }
+      }
+    }
+  }
+  return total;
+}
+function formatSize(bytes) {
+  if (bytes === void 0) return "\u2026";
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(0)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+
+// src/core/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import fs3 from "fs/promises";
+var run = promisify(execFile);
+async function git(cwd, args) {
+  const { stdout } = await run("git", args, { cwd, timeout: 1e4 });
+  return stdout.trim();
+}
+async function gitStatus(projectDir) {
+  let lastActivity = "";
+  try {
+    const st = await fs3.stat(projectDir);
+    lastActivity = st.mtime.toISOString().slice(0, 10);
+  } catch {
+  }
+  try {
+    await git(projectDir, ["rev-parse", "--is-inside-work-tree"]);
+  } catch {
+    return {
+      semaphore: "red",
+      summary: "sin git",
+      detail: "Este directorio no es un repositorio git.\nSi borras el proyecto completo no hay forma de recuperarlo.",
+      lastActivity
+    };
+  }
+  try {
+    lastActivity = await git(projectDir, ["log", "-1", "--format=%cs"]) || lastActivity;
+  } catch {
+  }
+  let branch = "";
+  try {
+    branch = await git(projectDir, ["branch", "--show-current"]);
+  } catch {
+  }
+  let dirtyLines = [];
+  try {
+    const porcelain = await git(projectDir, ["status", "--porcelain"]);
+    dirtyLines = porcelain ? porcelain.split("\n") : [];
+  } catch {
+    dirtyLines = ["(git status fall\xF3)"];
+  }
+  let ahead = null;
+  let hasUpstream = true;
+  try {
+    ahead = parseInt(await git(projectDir, ["rev-list", "@{u}..HEAD", "--count"]), 10);
+  } catch {
+    hasUpstream = false;
+  }
+  const detailParts = [`rama: ${branch || "(detached)"}`];
+  if (dirtyLines.length > 0) {
+    detailParts.push(
+      `${dirtyLines.length} archivo(s) sin commitear:`,
+      ...dirtyLines.slice(0, 8).map((l) => `  ${l}`)
+    );
+    if (dirtyLines.length > 8) detailParts.push(`  \u2026 y ${dirtyLines.length - 8} m\xE1s`);
+  }
+  if (!hasUpstream) detailParts.push("sin rama remota configurada (no hay respaldo en un servidor)");
+  else if (ahead && ahead > 0) detailParts.push(`${ahead} commit(s) sin pushear`);
+  if (dirtyLines.length > 0) {
+    return {
+      semaphore: "yellow",
+      summary: `${dirtyLines.length} sin commit`,
+      detail: detailParts.join("\n"),
+      lastActivity
+    };
+  }
+  if (!hasUpstream) {
+    return { semaphore: "yellow", summary: "sin remoto", detail: detailParts.join("\n"), lastActivity };
+  }
+  if (ahead && ahead > 0) {
+    return { semaphore: "yellow", summary: `${ahead} sin push`, detail: detailParts.join("\n"), lastActivity };
+  }
+  return {
+    semaphore: "green",
+    summary: "pusheado",
+    detail: detailParts.concat("Todo commiteado y pusheado. Borrar aqu\xED es 100% recuperable.").join("\n"),
+    lastActivity
+  };
+}
+
+// src/core/remove.ts
+import fs4 from "fs/promises";
+async function removeTargets(targets, onProgress) {
+  const removed = [];
+  const failed = [];
+  let done = 0;
+  for (const t of targets) {
+    onProgress(done, targets.length, t.path);
+    try {
+      await fs4.rm(t.path, { recursive: true, force: true });
+      removed.push(t.path);
+    } catch (err) {
+      failed.push({ path: t.path, error: err instanceof Error ? err.message : String(err) });
+    }
+    done += 1;
+    onProgress(done, targets.length, t.path);
+  }
+  return { removed, failed };
+}
+
+// src/ui/ProjectRow.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var SEM_COLOR = { green: "green", yellow: "yellow", red: "red" };
+function ProjectRow({ row, isCursor }) {
+  const targets = row.project.targets.map((t) => t.name).join(" + ");
+  const sem = row.git ? SEM_COLOR[row.git.semaphore] : "gray";
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(Text, { color: isCursor ? "cyan" : void 0, children: isCursor ? "\u276F " : "  " }),
+    /* @__PURE__ */ jsx(Text, { color: row.deleted ? "gray" : isCursor ? "cyan" : void 0, children: row.deleted ? "\u2714 " : row.selected ? "\u25A0 " : "\u25A1 " }),
+    /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { bold: isCursor, strikethrough: row.deleted, wrap: "truncate", children: row.project.name }) }),
+    /* @__PURE__ */ jsx(Box, { width: 9, justifyContent: "flex-end", marginRight: 2, children: /* @__PURE__ */ jsx(Text, { color: row.deleted ? "gray" : "magenta", children: row.deleted ? "liberado" : formatSize(row.size) }) }),
+    /* @__PURE__ */ jsx(Box, { width: 16, children: /* @__PURE__ */ jsxs(Text, { color: sem, children: [
+      "\u25CF ",
+      row.git ? row.git.summary : "\u2026"
+    ] }) }),
+    /* @__PURE__ */ jsx(Box, { width: 12, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: row.git?.lastActivity ?? "" }) }),
+    /* @__PURE__ */ jsx(Text, { color: "gray", wrap: "truncate", children: targets })
+  ] });
+}
+
+// src/ui/Footer.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsxs as jsxs2 } from "react/jsx-runtime";
+function Footer({
+  selectedCount,
+  selectedSize,
+  freedSize,
+  sortBySize
+}) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: 1, children: [
+    freedSize > 0 && /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+      "\u2714 liberado en esta sesi\xF3n: ",
+      formatSize(freedSize)
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+      "\u2191\u2193 navegar \xB7 espacio seleccionar \xB7 a seleccionar \u{1F7E2} \xB7 enter borrar",
+      selectedCount > 0 && /* @__PURE__ */ jsxs2(Text2, { color: "white", children: [
+        " (",
+        selectedCount,
+        " = ",
+        formatSize(selectedSize),
+        ")"
+      ] }),
+      " \xB7 g detalle git \xB7 s orden",
+      sortBySize ? " (tama\xF1o)" : "",
+      " \xB7 q salir"
+    ] })
+  ] });
+}
+
+// src/ui/App.tsx
+import { jsx as jsx2, jsxs as jsxs3 } from "react/jsx-runtime";
+function App({ rootDir, targets }) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const [rows, setRows] = useState([]);
+  const [scanning, setScanning] = useState(true);
+  const [cursor, setCursor] = useState(0);
+  const [mode, setMode] = useState("list");
+  const [showDetail, setShowDetail] = useState(false);
+  const [sortBySize, setSortBySize] = useState(false);
+  const [freedSize, setFreedSize] = useState(0);
+  const [deleteProgress, setDeleteProgress] = useState("");
+  const patchRow = (projectPath, patch) => {
+    setRows(
+      (prev) => prev.map((r) => r.project.path === projectPath ? { ...r, ...patch } : r)
+    );
+  };
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      for await (const project of scan(rootDir, targets)) {
+        if (cancelled) return;
+        setRows((prev) => [...prev, { project, selected: false, deleted: false }]);
+        void Promise.all(project.targets.map((t) => dirSize(t.path))).then((sizes) => {
+          if (!cancelled) patchRow(project.path, { size: sizes.reduce((a, b) => a + b, 0) });
+        });
+        void gitStatus(project.path).then((git2) => {
+          if (!cancelled) patchRow(project.path, { git: git2 });
+        });
+      }
+      if (!cancelled) setScanning(false);
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [rootDir, targets]);
+  const visible = useMemo(() => {
+    const list = [...rows];
+    if (sortBySize) list.sort((a, b) => (b.size ?? -1) - (a.size ?? -1));
+    return list;
+  }, [rows, sortBySize]);
+  const current = visible[cursor];
+  const selected = rows.filter((r) => r.selected && !r.deleted);
+  const selectedSize = selected.reduce((a, r) => a + (r.size ?? 0), 0);
+  const doDelete = async () => {
+    setMode("deleting");
+    const toDelete = rows.filter((r) => r.selected && !r.deleted);
+    for (const row of toDelete) {
+      const { failed } = await removeTargets(row.project.targets, (done, total) => {
+        setDeleteProgress(`${row.project.name}: ${done}/${total}`);
+      });
+      if (failed.length === 0) {
+        setFreedSize((f) => f + (row.size ?? 0));
+        patchRow(row.project.path, { deleted: true, selected: false });
+      } else {
+        setDeleteProgress(`error en ${row.project.name}: ${failed[0].error}`);
+      }
+    }
+    setDeleteProgress("");
+    setMode("list");
+  };
+  useInput((input, key) => {
+    if (mode === "deleting") return;
+    if (mode === "confirm") {
+      if (input === "y" || input === "s") void doDelete();
+      else if (input === "n" || key.escape) setMode("list");
+      return;
+    }
+    if (input === "q" || key.ctrl && input === "c") exit();
+    else if (key.downArrow || input === "j") setCursor((c) => Math.min(c + 1, visible.length - 1));
+    else if (key.upArrow || input === "k") setCursor((c) => Math.max(c - 1, 0));
+    else if (input === " " && current && !current.deleted) {
+      patchRow(current.project.path, { selected: !current.selected });
+    } else if (input === "a") {
+      setRows(
+        (prev) => prev.map(
+          (r) => r.git?.semaphore === "green" && !r.deleted ? { ...r, selected: true } : r
+        )
+      );
+    } else if (input === "g") setShowDetail((d) => !d);
+    else if (input === "s") setSortBySize((s) => !s);
+    else if (key.return && selected.length > 0) setMode("confirm");
+  });
+  const listHeight = Math.max(5, (stdout?.rows ?? 24) - 8);
+  const offset = Math.max(0, Math.min(cursor - Math.floor(listHeight / 2), visible.length - listHeight));
+  const windowRows = visible.slice(offset, offset + listHeight);
+  const totalFound = rows.reduce((a, r) => a + (r.size ?? 0), 0);
+  const displayDir = path3.resolve(rootDir).replace(os2.homedir(), "~");
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Box3, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx2(Text3, { bold: true, color: "cyan", children: "sweeply" }),
+      /* @__PURE__ */ jsxs3(Text3, { wrap: "truncate", children: [
+        /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
+          " \xB7 ",
+          displayDir
+        ] }),
+        /* @__PURE__ */ jsxs3(Text3, { children: [
+          " \xB7 ",
+          scanning ? "escaneando\u2026" : `${rows.length} proyectos`
+        ] }),
+        /* @__PURE__ */ jsxs3(Text3, { color: "magenta", children: [
+          " \xB7 ",
+          formatSize(totalFound),
+          " recuperables"
+        ] })
+      ] })
+    ] }),
+    rows.length === 0 && !scanning && /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
+      "No encontr\xE9 nada que limpiar en ",
+      rootDir,
+      "."
+    ] }),
+    windowRows.map((row, i) => /* @__PURE__ */ jsx2(ProjectRow, { row, isCursor: offset + i === cursor }, row.project.path)),
+    showDetail && current?.git && /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, marginTop: 1, children: [
+      /* @__PURE__ */ jsx2(Text3, { bold: true, children: current.project.path }),
+      current.git.detail.split("\n").map((line, i) => /* @__PURE__ */ jsx2(Text3, { color: "gray", children: line }, i))
+    ] }),
+    mode === "confirm" && /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", borderStyle: "double", borderColor: "red", paddingX: 1, marginTop: 1, children: [
+      /* @__PURE__ */ jsxs3(Text3, { bold: true, color: "red", children: [
+        "\xBFBorrar ",
+        selected.length,
+        " proyecto(s) \u2014 ",
+        formatSize(selectedSize),
+        "?"
+      ] }),
+      selected.slice(0, 6).map((r) => /* @__PURE__ */ jsxs3(Text3, { children: [
+        "  ",
+        r.project.name,
+        ": ",
+        r.project.targets.map((t) => t.name).join(", ")
+      ] }, r.project.path)),
+      selected.length > 6 && /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
+        "  \u2026 y ",
+        selected.length - 6,
+        " m\xE1s"
+      ] }),
+      /* @__PURE__ */ jsx2(Text3, { color: "gray", children: "Solo se borran las carpetas regenerables, nunca tu c\xF3digo." }),
+      /* @__PURE__ */ jsx2(Text3, { bold: true, children: "y = s\xED, borrar \xB7 n = cancelar" })
+    ] }),
+    mode === "deleting" && /* @__PURE__ */ jsx2(Box3, { marginTop: 1, children: /* @__PURE__ */ jsxs3(Text3, { color: "yellow", children: [
+      "borrando\u2026 ",
+      deleteProgress
+    ] }) }),
+    /* @__PURE__ */ jsx2(
+      Footer,
+      {
+        selectedCount: selected.length,
+        selectedSize,
+        freedSize,
+        sortBySize
+      }
+    )
+  ] });
+}
+
+// src/core/targets.ts
+var DEFAULT_TARGETS = [
+  { name: "node_modules", requiresSibling: ["package.json"], label: "node" },
+  { name: ".next", requiresSibling: ["package.json"], label: "next" },
+  { name: ".nuxt", requiresSibling: ["package.json"], label: "nuxt" },
+  { name: ".turbo", requiresSibling: ["package.json"], label: "turbo" },
+  { name: "dist", requiresSibling: ["package.json"], label: "build" },
+  { name: "build", requiresSibling: ["package.json"], label: "build" },
+  { name: "out", requiresSibling: ["package.json"], label: "build" },
+  { name: "venv", requiresSibling: ["pyproject.toml", "requirements.txt", "setup.py"], label: "python" },
+  { name: ".venv", requiresSibling: ["pyproject.toml", "requirements.txt", "setup.py"], label: "python" },
+  { name: "target", requiresSibling: ["Cargo.toml"], label: "rust" },
+  { name: "Pods", requiresSibling: ["Podfile"], label: "ios" }
+];
+function buildTargets(extra) {
+  const custom = extra.filter((n) => n.trim().length > 0).map((n) => ({ name: n.trim(), label: "custom" }));
+  return [...DEFAULT_TARGETS, ...custom];
+}
+
+// src/cli.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function parseArgs(argv) {
+  let dir2 = os3.homedir();
+  let extraTargets2 = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--dir" || arg === "-d") dir2 = argv[++i] ?? dir2;
+    else if (arg === "--targets" || arg === "-t") extraTargets2 = (argv[++i] ?? "").split(",");
+    else if (arg === "--help" || arg === "-h") {
+      console.log(`sweeply \u2014 limpia el peso muerto de tus proyectos
+
+Uso: sweeply [opciones]
+
+  -d, --dir <ruta>       d\xF3nde buscar (default: tu home)
+  -t, --targets <a,b>    carpetas extra a detectar, separadas por coma
+  -h, --help             esta ayuda
+
+Dentro de la interfaz: \u2191\u2193 navegar \xB7 espacio seleccionar \xB7 a seleccionar
+todo lo \u{1F7E2} \xB7 enter borrar (pide confirmaci\xF3n) \xB7 g detalle git \xB7 s ordenar
+por tama\xF1o \xB7 q salir`);
+      process.exit(0);
+    }
+  }
+  return { dir: dir2, extraTargets: extraTargets2 };
+}
+var { dir, extraTargets } = parseArgs(process.argv.slice(2));
+render(/* @__PURE__ */ jsx3(App, { rootDir: dir, targets: buildTargets(extraTargets) }));

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "sweeply",
+  "version": "0.1.0",
+  "description": "TUI para encontrar y borrar peso muerto de tus proyectos (node_modules, .next, venv...) con semáforo de seguridad git",
+  "license": "MIT",
+  "author": "Fora (Ángel Iván López Delgado)",
+  "homepage": "https://github.com/Foralitos/sweeply#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Foralitos/sweeply.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Foralitos/sweeply/issues"
+  },
+  "type": "module",
+  "bin": {
+    "sweeply": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.tsx",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "yarn typecheck && yarn build"
+  },
+  "keywords": [
+    "cli",
+    "tui",
+    "node_modules",
+    "cleanup",
+    "disk-space",
+    "npkill",
+    "monorepo",
+    "ink"
+  ],
+  "dependencies": {
+    "ink": "^7.1.1",
+    "react": "^19.2.8"
+  },
+  "devDependencies": {
+    "@types/node": "^26.3.0",
+    "@types/react": "^19.2.18",
+    "tsup": "^8.5.1",
+    "tsx": "^4.23.12",
+    "typescript": "^7.0.2"
+  },
+  "resolutions": {
+    "esbuild": "^0.28.1"
+  }
+}