@lexmanh/shed-cli 0.2.0-beta.3 → 0.2.0-beta.5

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import { Command } from "commander";
 
 // src/commands/clean.ts
@@ -395,6 +395,8 @@ async function doctorCommand() {
 }
 
 // src/commands/scan.ts
+import { createRequire } from "module";
+import { hostname } from "os";
 import { resolve as resolve2 } from "path";
 import * as p4 from "@clack/prompts";
 import {
@@ -419,6 +421,80 @@ import {
   XcodeDetector as XcodeDetector2
 } from "@lexmanh/shed-core";
 import pc4 from "picocolors";
+
+// src/commands/scan-aggregate.ts
+import { dirname } from "path";
+var AGGREGATE_THRESHOLD = 3;
+function aggregateForDisplay(items) {
+  const buckets = /* @__PURE__ */ new Map();
+  const singles = [];
+  for (const item of items) {
+    const kind = item.metadata?.kind ?? null;
+    if (!kind) {
+      singles.push(item);
+      continue;
+    }
+    const key = `${dirname(item.path)}::${item.detector}::${kind}`;
+    const arr = buckets.get(key) ?? [];
+    arr.push(item);
+    buckets.set(key, arr);
+  }
+  const result = [];
+  for (const arr of buckets.values()) {
+    if (arr.length >= AGGREGATE_THRESHOLD) {
+      const first = arr[0];
+      if (!first) continue;
+      const totalBytes = arr.reduce((s, i) => s + i.sizeBytes, 0);
+      const kind = first.metadata?.kind;
+      result.push({
+        type: "aggregate",
+        risk: first.risk,
+        displayPath: dirname(first.path),
+        description: `${arr.length} ${kind} files`,
+        totalBytes,
+        detector: first.detector,
+        itemCount: arr.length,
+        items: arr
+      });
+    } else {
+      for (const item of arr) result.push(toSingle(item));
+    }
+  }
+  for (const item of singles) result.push(toSingle(item));
+  return result;
+}
+function toSingle(item) {
+  return {
+    type: "single",
+    risk: item.risk,
+    displayPath: item.path,
+    description: item.description,
+    totalBytes: item.sizeBytes,
+    detector: item.detector,
+    itemCount: 1,
+    items: [item]
+  };
+}
+function selectTopGroups(groups, topN) {
+  const sorted = [...groups].sort((a, b) => b.totalBytes - a.totalBytes);
+  const shown = sorted.slice(0, topN);
+  const rest = sorted.slice(topN);
+  return {
+    shown,
+    hidden: {
+      groupCount: rest.length,
+      itemCount: rest.reduce((s, g) => s + g.itemCount, 0),
+      totalBytes: rest.reduce((s, g) => s + g.totalBytes, 0)
+    }
+  };
+}
+
+// src/commands/scan.ts
+var require2 = createRequire(import.meta.url);
+var { version: SHED_VERSION } = require2("../package.json");
+var JSON_SCHEMA_VERSION = 1;
+var COMPACT_TOP_N = 15;
+var DETECTOR_BREAKDOWN_TOP_N = 6;
 var RISK_LABEL = {
   [RiskTier2.Green]: pc4.green("\u25CF Green"),
   [RiskTier2.Yellow]: pc4.yellow("\u25CF Yellow"),
@@ -444,6 +520,7 @@ async function scanCommand(path = ".", options = {}) {
   const spinner3 = options.json ? null : p4.spinner();
   verbose(`scan root: ${rootDir}`);
   spinner3?.start(`Scanning ${rootDir} \u2026`);
+  const scanStartedAt = Date.now();
   const scanner = new Scanner2([
     new NodeDetector2(),
     new PythonDetector2(),
@@ -482,13 +559,41 @@ async function scanCommand(path = ".", options = {}) {
     `Found ${pc4.bold(String(allItems.length))} cleanable items across ${projects.length} project(s).`
   );
   if (options.json) {
+    const byRisk = { green: 0, yellow: 0, red: 0 };
+    let detectOnly = 0;
+    for (const item of allItems) {
+      byRisk[item.risk]++;
+      if (item.metadata?.detectOnly === true) detectOnly++;
+    }
+    const projectsOut = projects.map((proj) => ({
+      root: proj.root,
+      detectors: [...new Set(proj.items.map((i) => i.detector))],
+      itemCount: proj.items.length,
+      totalBytes: proj.items.reduce((s, i) => s + i.sizeBytes, 0)
+    }));
     console.log(
       JSON.stringify(
         {
-          root: rootDir,
-          projects: projects.length,
-          items: allItems,
-          totalBytes
+          schemaVersion: JSON_SCHEMA_VERSION,
+          shedVersion: SHED_VERSION,
+          timestamp: new Date(scanStartedAt).toISOString(),
+          host: {
+            hostname: hostname(),
+            platform: process.platform,
+            arch: process.arch
+          },
+          scan: {
+            root: rootDir,
+            durationMs: Date.now() - scanStartedAt
+          },
+          summary: {
+            totalBytes,
+            totalItems: allItems.length,
+            byRisk,
+            detectOnly
+          },
+          projects: projectsOut,
+          items: allItems
         },
         null,
         2
@@ -501,6 +606,52 @@ async function scanCommand(path = ".", options = {}) {
     p4.outro(pc4.dim("All clear!"));
     return;
   }
+  if (options.all) {
+    renderFull(allItems);
+  } else {
+    renderCompact(allItems);
+  }
+  console.log();
+  p4.outro(
+    `Total recoverable: ${pc4.bold(pc4.green(formatBytes2(totalBytes)))} \u2014 run ${pc4.cyan("shed clean")} to proceed.`
+  );
+}
+function renderCompact(allItems) {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  const byRisk = { green: 0, yellow: 0, red: 0 };
+  let detectOnly = 0;
+  const byDetector = /* @__PURE__ */ new Map();
+  for (const item of allItems) {
+    byRisk[item.risk]++;
+    if (item.metadata?.detectOnly === true) detectOnly++;
+    byDetector.set(item.detector, (byDetector.get(item.detector) ?? 0) + item.sizeBytes);
+  }
+  const riskLine = `${pc4.green(`\u25CF ${byRisk.green} Green`)}   ${pc4.yellow(`\u25CF ${byRisk.yellow} Yellow`)}   ${pc4.red(`\u25CF ${byRisk.red} Red`)}${detectOnly > 0 ? pc4.dim(` (${detectOnly} detect-only)`) : ""}`;
+  const detectorLine = [...byDetector.entries()].sort(([, a], [, b]) => b - a).slice(0, DETECTOR_BREAKDOWN_TOP_N).map(([d, b]) => `${d} ${formatBytes2(b)}`).join(" \xB7 ");
+  console.log();
+  console.log(`  By risk:    ${riskLine}`);
+  console.log(`  By detector: ${pc4.dim(detectorLine)}`);
+  const groups = aggregateForDisplay(allItems);
+  const { shown, hidden } = selectTopGroups(groups, COMPACT_TOP_N);
+  console.log();
+  console.log(`  ${pc4.bold(`Top ${shown.length} items:`)}`);
+  for (const g of shown) {
+    const path = home ? g.displayPath.replace(home, "~") : g.displayPath;
+    const tag = g.type === "aggregate" ? pc4.dim(` (${g.itemCount} ${g.detector} items)`) : "";
+    const size = g.totalBytes > 0 ? pc4.dim(` ${formatBytes2(g.totalBytes)}`) : "";
+    console.log(`    ${RISK_LABEL[g.risk]}  ${path}${tag}${size}`);
+  }
+  if (hidden.groupCount > 0) {
+    console.log();
+    console.log(
+      pc4.dim(
+        `  \u2026 ${hidden.groupCount} more groups (${hidden.itemCount} items, ${formatBytes2(hidden.totalBytes)}) \u2014 use --all to see everything`
+      )
+    );
+  }
+}
+function renderFull(allItems) {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
   const byProject = /* @__PURE__ */ new Map();
   for (const item of allItems) {
     const key = item.projectRoot ?? "(global)";
@@ -509,7 +660,6 @@ async function scanCommand(path = ".", options = {}) {
     byProject.set(key, group);
   }
   for (const [projectRoot, items] of byProject.entries()) {
-    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
     const projectLabel = projectRoot === "(global)" ? pc4.dim("global caches") : pc4.cyan(home ? projectRoot.replace(home, "~") : projectRoot);
     const groupTotal = items.reduce((s, i) => s + i.sizeBytes, 0);
     console.log(`
@@ -522,10 +672,6 @@ async function scanCommand(path = ".", options = {}) {
       console.log(`    ${pc4.dim(`       ${item.description}`)}`);
     }
   }
-  console.log();
-  p4.outro(
-    `Total recoverable: ${pc4.bold(pc4.green(formatBytes2(totalBytes)))} \u2014 run ${pc4.cyan("shed clean")} to proceed.`
-  );
 }
 
 // src/commands/undo.ts
@@ -589,11 +735,11 @@ function printLogo(version2) {
 }
 
 // src/cli.ts
-var require2 = createRequire(import.meta.url);
-var { version } = require2("../package.json");
+var require3 = createRequire2(import.meta.url);
+var { version } = require3("../package.json");
 var program = new Command();
 program.name("shed").description("Safe disk cleanup for dev machines and Linux servers").version(version).option("-v, --verbose", "Enable verbose logging");
-program.command("scan [path]").description("Scan for cleanable items without modifying anything").option("--json", "Output machine-readable JSON").option("--max-age <days>", "Only include items older than N days", "30").action(scanCommand);
+program.command("scan [path]").description("Scan for cleanable items without modifying anything").option("--json", "Output machine-readable JSON").option("--max-age <days>", "Only include items older than N days", "30").option("--all", "Show every item (default: compact summary with top 15)").action(scanCommand);
 program.command("clean [path]").description("Interactive cleanup of detected items").option("--dry-run", "Preview operations without executing", true).option("--execute", "Actually perform the cleanup (overrides --dry-run)").option("--hard-delete", "Skip Trash, delete permanently").option("--include-red", "Include Red-tier (high-risk) items").option("--yes", "Skip interactive confirmations (CI mode)").action(cleanCommand);
 program.command("undo").description("List and restore items from previous cleanups").action(undoCommand);
 program.command("doctor").description("Check environment and configuration").action(doctorCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexmanh/shed-cli",
-  "version": "0.2.0-beta.3",
+  "version": "0.2.0-beta.5",
   "description": "Safe disk cleanup CLI for dev machines and Linux servers — git-aware, cross-stack, trash-by-default",
   "type": "module",
   "bin": {
@@ -23,7 +23,7 @@
     "conf": "^13.1.0",
     "execa": "^9.5.0",
     "picocolors": "^1.1.1",
-    "@lexmanh/shed-core": "0.2.0-beta.3"
+    "@lexmanh/shed-core": "0.2.0-beta.5"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",