@aladac/hu 0.1.0-a1

package/src/commands/bump.ts

@@ -0,0 +1,130 @@
+#!/usr/bin/env npx tsx
+/**
+ * Version bumping script
+ * Usage: npx tsx src/commands/bump.ts [patch|minor|major]
+ * - No args: bump pre-release number (1.0.0-pre1 -> 1.0.0-pre2)
+ * - patch: bump patch version (1.0.0-pre1 -> 1.0.1-pre1, or 1.0.0 -> 1.0.1)
+ * - minor: bump minor version (1.0.0 -> 1.1.0, or 1.0.0-pre1 -> 1.1.0-pre1)
+ * - major: bump major version (1.0.0 -> 2.0.0)
+ */
+
+import { execSync } from 'node:child_process';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const ROOT_DIR = join(import.meta.dirname, '../..');
+
+interface VersionParts {
+  major: number;
+  minor: number;
+  patch: number;
+  pre: number | null;
+}
+
+function parseVersion(version: string): VersionParts {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)(-pre(\d+))?$/);
+  if (!match) {
+    throw new Error(`Cannot parse version '${version}'`);
+  }
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10),
+    pre: match[5] ? Number.parseInt(match[5], 10) : null,
+  };
+}
+
+function formatVersion(parts: VersionParts): string {
+  const base = `${parts.major}.${parts.minor}.${parts.patch}`;
+  return parts.pre !== null ? `${base}-pre${parts.pre}` : base;
+}
+
+function bumpVersion(current: string, type?: string): string {
+  const parts = parseVersion(current);
+
+  switch (type) {
+    case 'major':
+    case '--major':
+      parts.major++;
+      parts.minor = 0;
+      parts.patch = 0;
+      if (parts.pre !== null) parts.pre = 1;
+      break;
+
+    case 'minor':
+    case '--minor':
+      parts.minor++;
+      parts.patch = 0;
+      if (parts.pre !== null) parts.pre = 1;
+      break;
+
+    case 'patch':
+    case '--patch':
+      parts.patch++;
+      if (parts.pre !== null) parts.pre = 1;
+      break;
+
+    default:
+      // Bump pre-release number
+      if (parts.pre !== null) {
+        parts.pre++;
+      } else {
+        parts.pre = 1;
+      }
+      break;
+  }
+
+  return formatVersion(parts);
+}
+
+function exec(cmd: string): string {
+  return execSync(cmd, { cwd: ROOT_DIR, encoding: 'utf-8' }).trim();
+}
+
+function run(cmd: string): void {
+  execSync(cmd, { cwd: ROOT_DIR, stdio: 'inherit' });
+}
+
+async function main() {
+  const arg = process.argv[2];
+
+  // Read current version from package.json
+  const pkgPath = join(ROOT_DIR, 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  const currentVersion = pkg.version;
+
+  console.log(`Current version: ${currentVersion}`);
+
+  // Calculate new version
+  const newVersion = bumpVersion(currentVersion, arg);
+  console.log(`New version: ${newVersion}`);
+
+  // Update package.json
+  pkg.version = newVersion;
+  writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+
+  // Update version in index.ts
+  const indexPath = join(ROOT_DIR, 'src/index.ts');
+  let indexContent = readFileSync(indexPath, 'utf-8');
+  indexContent = indexContent.replace(/version: '[^']+'/, `version: '${newVersion}'`);
+  writeFileSync(indexPath, indexContent);
+
+  console.log('Updated package.json and src/index.ts');
+
+  // Reinstall
+  console.log('Reinstalling...');
+  run('npm install && npm link');
+
+  // Git commit, tag, and push
+  run('git add package.json package-lock.json src/index.ts');
+  run(`git commit -m "chore: Bump version to ${newVersion}"`);
+  run(`git tag "v${newVersion}"`);
+  run('git push origin HEAD --tags');
+
+  console.log(`\nDone! Version ${newVersion} installed and pushed.`);
+}
+
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/src/commands/disk.ts

@@ -0,0 +1,419 @@
+/**
+ * Disk space analysis commands
+ */
+
+import { defineCommand } from 'citty';
+import {
+  c,
+  colorizeSize,
+  formatSize,
+  parseSize,
+  printHeader,
+  printSubHeader,
+  progressBar,
+} from '../lib/colors.ts';
+import { exec } from '../lib/exec.ts';
+import { startSpinner, stopSpinner } from '../lib/spinner.ts';
+import type { CleanupSuggestion, SpaceHogCheck } from '../types/index.ts';
+
+// ─────────────────────────────────────────────────────────────
+// Analysis Functions
+// ─────────────────────────────────────────────────────────────
+
+async function getDiskOverview(): Promise<void> {
+  startSpinner('Analyzing APFS volumes...');
+
+  const dfOutput = exec('df -h /System/Volumes/Data');
+  const lines = dfOutput.split('\n');
+
+  let used = '0G';
+  let avail = '0G';
+  let capacity = '0%';
+  let total = '0G';
+  if (lines[1]) {
+    const parts = lines[1].split(/\s+/);
+    total = parts[1];
+    used = parts[2];
+    avail = parts[3];
+    capacity = parts[4];
+  }
+
+  stopSpinner(true, 'APFS volumes analyzed');
+
+  printHeader('💾 DISK OVERVIEW');
+
+  const pct = Number.parseInt(capacity) || 0;
+  console.log(`  ${c.bold}Data Volume${c.reset} (/System/Volumes/Data)`);
+  console.log();
+  console.log(`  ${progressBar(pct, 40)} ${c.bold}${capacity}${c.reset}`);
+  console.log();
+  console.log(
+    `  ${c.green}●${c.reset} Used: ${c.bold}${used}${c.reset}    ${c.blue}●${c.reset} Free: ${c.bold}${avail}${c.reset}    ${c.dim}Total: ${total}${c.reset}`,
+  );
+}
+
+async function getHomeBreakdown(): Promise<void> {
+  startSpinner('Scanning home directory...');
+
+  const output = exec('sudo du -sh ~/* ~/.* 2>/dev/null | sort -hr | head -20');
+  const lines = output.split('\n').filter((l) => l.trim());
+
+  stopSpinner(true, 'Home directory scanned');
+
+  printHeader('🏠 HOME DIRECTORY BREAKDOWN');
+
+  const rows = lines
+    .map((line) => {
+      const match = line.match(/^([\d.]+[KMGTP]?)\s+(.+)$/i);
+      if (!match) return null;
+      const [, size, path] = match;
+      const shortPath = path.replace(process.env.HOME || '', '~');
+      return `${colorizeSize(size.padStart(8))}  ${shortPath}`;
+    })
+    .filter((row): row is string => row !== null);
+
+  for (const row of rows) {
+    console.log(`  ${row}`);
+  }
+}
+
+async function getLibraryBreakdown(): Promise<void> {
+  startSpinner('Analyzing ~/Library...');
+
+  const output = exec('sudo du -sh ~/Library/*/ 2>/dev/null | sort -hr | head -20');
+  const lines = output.split('\n').filter((l) => l.trim());
+
+  stopSpinner(true, 'Library analyzed');
+
+  printHeader('📚 LIBRARY BREAKDOWN');
+
+  const rows = lines
+    .map((line) => {
+      const match = line.match(/^([\d.]+[KMGTP]?)\s+(.+)$/i);
+      if (!match) return null;
+      const [, size, path] = match;
+      const shortPath = path.replace(`${process.env.HOME || ''}/Library/`, '').replace(/\/$/, '');
+      return `${colorizeSize(size.padStart(8))}  ${shortPath}`;
+    })
+    .filter((row): row is string => row !== null);
+
+  for (const row of rows) {
+    console.log(`  ${row}`);
+  }
+}
+
+async function getCommonHogs(): Promise<void> {
+  printHeader('🐷 COMMON SPACE HOGS');
+
+  const checks: SpaceHogCheck[] = [
+    { name: 'Ollama models', cmd: 'sudo du -sh ~/.ollama/models/ 2>/dev/null' },
+    { name: 'LM Studio models', cmd: 'sudo du -sh ~/.lmstudio/models 2>/dev/null' },
+    { name: 'asdf versions', cmd: 'sudo du -sh ~/.asdf/installs 2>/dev/null' },
+    {
+      name: 'Homebrew',
+      cmd: 'sudo du -sh /opt/homebrew/Cellar 2>/dev/null || sudo du -sh /usr/local/Cellar 2>/dev/null',
+    },
+    {
+      name: 'Docker VM',
+      cmd: 'sudo du -sh ~/Library/Containers/com.docker.docker/Data/vms/ 2>/dev/null',
+    },
+    { name: 'Trash', cmd: 'sudo du -sh ~/.Trash/ 2>/dev/null' },
+    {
+      name: 'StabilityMatrix',
+      cmd: 'sudo du -sh ~/Library/Application\\ Support/StabilityMatrix/Models 2>/dev/null',
+    },
+    { name: 'Downloads', cmd: 'sudo du -sh ~/Downloads 2>/dev/null' },
+  ];
+
+  for (const check of checks) {
+    startSpinner(`Checking ${check.name}...`);
+    const output = exec(check.cmd);
+    const match = output.match(/^([\d.]+[KMGTP]?)/i);
+    const size = match ? match[1] : 'N/A';
+    stopSpinner(size !== 'N/A', `${check.name}: ${colorizeSize(size)}`);
+  }
+}
+
+interface ModelInfo {
+  name: string;
+  size: string;
+  sizeBytes: number;
+}
+
+async function getModelsBreakdown(): Promise<void> {
+  printHeader('🤖 AI MODELS');
+
+  // StabilityMatrix models
+  printSubHeader('StabilityMatrix');
+  startSpinner('Scanning StabilityMatrix models...');
+
+  const smPath = '~/Library/Application\\ Support/StabilityMatrix/Models';
+  const smOutput = exec(
+    `find ${smPath} -type f \\( -name "*.safetensors" -o -name "*.ckpt" -o -name "*.pt" \\) -exec du -sh {} \\; 2>/dev/null | sort -hr`,
+  );
+
+  const smModels: ModelInfo[] = smOutput
+    .split('\n')
+    .filter((l) => l.trim())
+    .map((line) => {
+      const match = line.match(/^([\d.]+[KMGTP]?)\s+(.+)$/i);
+      if (!match) return null;
+      const [, size, path] = match;
+      const name =
+        path
+          .split('/')
+          .pop()
+          ?.replace(/\.(safetensors|ckpt|pt)$/, '') || path;
+      return { name, size, sizeBytes: parseSize(size) };
+    })
+    .filter((m): m is ModelInfo => m !== null);
+
+  const smTotal = smModels.reduce((acc, m) => acc + m.sizeBytes, 0);
+  const smTotalStr = formatSize(smTotal);
+
+  stopSpinner(true, `Found ${smModels.length} models (${smTotalStr})`);
+
+  for (const model of smModels) {
+    console.log(
+      `  ${c.dim}•${c.reset} ${model.name} ${c.dim}—${c.reset} ${colorizeSize(model.size)}`,
+    );
+  }
+
+  console.log();
+
+  // LM Studio models
+  printSubHeader('LM Studio');
+  startSpinner('Scanning LM Studio models...');
+
+  const lmOutput = exec(
+    'find ~/.lmstudio/models -type f -name "*.safetensors" -exec du -sh {} \\; 2>/dev/null | sort -hr',
+  );
+
+  // Group by model directory
+  const lmFiles = lmOutput
+    .split('\n')
+    .filter((l) => l.trim())
+    .map((line) => {
+      const match = line.match(/^([\d.]+[KMGTP]?)\s+(.+)$/i);
+      if (!match) return null;
+      const [, size, path] = match;
+      // Extract model name from path (parent directory)
+      const parts = path.split('/');
+      const modelName = parts[parts.length - 2] || 'unknown';
+      return { modelName, size, sizeBytes: parseSize(size) };
+    })
+    .filter((m): m is { modelName: string; size: string; sizeBytes: number } => m !== null);
+
+  // Aggregate by model name
+  const lmModels = new Map<string, number>();
+  for (const file of lmFiles) {
+    const existing = lmModels.get(file.modelName) || 0;
+    lmModels.set(file.modelName, existing + file.sizeBytes);
+  }
+
+  const lmModelList: ModelInfo[] = Array.from(lmModels.entries())
+    .map(([name, sizeBytes]) => ({ name, size: formatSize(sizeBytes), sizeBytes }))
+    .sort((a, b) => b.sizeBytes - a.sizeBytes);
+
+  const lmTotal = lmModelList.reduce((acc, m) => acc + m.sizeBytes, 0);
+  const lmTotalStr = formatSize(lmTotal);
+
+  stopSpinner(true, `Found ${lmModelList.length} models (${lmTotalStr})`);
+
+  for (const model of lmModelList) {
+    console.log(
+      `  ${c.dim}•${c.reset} ${model.name} ${c.dim}—${c.reset} ${colorizeSize(model.size)}`,
+    );
+  }
+}
+
+async function getCleanupSuggestions(): Promise<void> {
+  printHeader('🧹 CLEANUP SUGGESTIONS');
+
+  const suggestions: CleanupSuggestion[] = [];
+
+  // Check Trash
+  const trashSize = exec('sudo du -sh ~/.Trash/ 2>/dev/null').match(/^([\d.]+[KMGTP]?)/i);
+  if (trashSize && parseSize(trashSize[1]) > 100 * 1024 * 1024) {
+    suggestions.push({
+      item: 'Trash',
+      size: trashSize[1],
+      cmd: 'rm -rf ~/.Trash/*',
+    });
+  }
+
+  // Check Homebrew
+  const brewCleanable = exec('brew cleanup -n 2>/dev/null | tail -1');
+  if (brewCleanable.includes('would be removed')) {
+    suggestions.push({
+      item: 'Homebrew cache',
+      size: 'varies',
+      cmd: 'brew cleanup && brew autoremove',
+    });
+  }
+
+  // Check npm cache
+  const npmCache = exec('npm cache ls 2>/dev/null | wc -l').trim();
+  if (Number.parseInt(npmCache) > 100) {
+    suggestions.push({
+      item: 'npm cache',
+      size: 'varies',
+      cmd: 'npm cache clean --force',
+    });
+  }
+
+  // Check pip cache
+  const pipCache = exec('pip cache info 2>/dev/null | grep "Package index"');
+  if (pipCache) {
+    suggestions.push({
+      item: 'pip cache',
+      size: 'varies',
+      cmd: 'pip cache purge',
+    });
+  }
+
+  if (suggestions.length === 0) {
+    console.log(`  ${c.green}✓${c.reset} ${c.dim}No obvious cleanup targets found${c.reset}`);
+  } else {
+    for (const s of suggestions) {
+      console.log(
+        `  ${c.yellow}●${c.reset} ${c.bold}${s.item}${c.reset} (${colorizeSize(s.size)})`,
+      );
+      console.log(`    ${c.dim}$ ${s.cmd}${c.reset}`);
+    }
+  }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Subcommands
+// ─────────────────────────────────────────────────────────────
+
+const overviewCommand = defineCommand({
+  meta: {
+    name: 'overview',
+    description: 'Show APFS volume disk usage overview',
+  },
+  run: async () => {
+    printBanner();
+    await getDiskOverview();
+    printFooter();
+  },
+});
+
+const homeCommand = defineCommand({
+  meta: {
+    name: 'home',
+    description: 'Show home directory breakdown',
+  },
+  run: async () => {
+    printBanner();
+    await getHomeBreakdown();
+    printFooter();
+  },
+});
+
+const libraryCommand = defineCommand({
+  meta: {
+    name: 'library',
+    description: 'Show ~/Library breakdown',
+  },
+  run: async () => {
+    printBanner();
+    await getLibraryBreakdown();
+    printFooter();
+  },
+});
+
+const hogsCommand = defineCommand({
+  meta: {
+    name: 'hogs',
+    description: 'Check common space hogs',
+  },
+  run: async () => {
+    printBanner();
+    await getCommonHogs();
+    printFooter();
+  },
+});
+
+const cleanupCommand = defineCommand({
+  meta: {
+    name: 'cleanup',
+    description: 'Show cleanup suggestions',
+  },
+  run: async () => {
+    printBanner();
+    await getCleanupSuggestions();
+    printFooter();
+  },
+});
+
+const modelsCommand = defineCommand({
+  meta: {
+    name: 'models',
+    description: 'List AI models (StabilityMatrix, LM Studio)',
+  },
+  run: async () => {
+    printBanner();
+    await getModelsBreakdown();
+    printFooter();
+  },
+});
+
+const inventoryCommand = defineCommand({
+  meta: {
+    name: 'inventory',
+    description: 'Full disk space analysis (default)',
+  },
+  run: async () => {
+    printBanner();
+    await getDiskOverview();
+    await getHomeBreakdown();
+    await getLibraryBreakdown();
+    await getCommonHogs();
+    await getCleanupSuggestions();
+    printFooter();
+  },
+});
+
+// ─────────────────────────────────────────────────────────────
+// UI Helpers
+// ─────────────────────────────────────────────────────────────
+
+function printBanner(): void {
+  console.log();
+  console.log(`${c.bold}${c.magenta}╔════════════════════════════════════════╗${c.reset}`);
+  console.log(
+    `${c.bold}${c.magenta}║${c.reset}  ${c.bold}💾 Disk Space Inventory${c.reset}               ${c.bold}${c.magenta}║${c.reset}`,
+  );
+  console.log(`${c.bold}${c.magenta}╚════════════════════════════════════════╝${c.reset}`);
+}
+
+function printFooter(): void {
+  console.log();
+  console.log(`${c.dim}─────────────────────────────────────────${c.reset}`);
+  console.log(
+    `${c.dim}Run: hu disk [overview|home|library|hogs|models|cleanup|inventory]${c.reset}`,
+  );
+  console.log();
+}
+
+// ─────────────────────────────────────────────────────────────
+// Main Command
+// ─────────────────────────────────────────────────────────────
+
+export const diskCommand = defineCommand({
+  meta: {
+    name: 'disk',
+    description: 'Disk space analysis tools',
+  },
+  subCommands: {
+    inventory: inventoryCommand,
+    overview: overviewCommand,
+    home: homeCommand,
+    library: libraryCommand,
+    hogs: hogsCommand,
+    models: modelsCommand,
+    cleanup: cleanupCommand,
+  },
+});